WIP

index.d.ts

@@ -1,6 +1,7 @@
 export * from './src/interfaces/server/app.ts';
 export * from './src/interfaces/server/context.ts';
 export * from './src/interfaces/migration/context.js';
+export * from './src/interfaces/server/cache.ts';
 export * from './src/interfaces/security/WebAuthn.js';
 export * from './src/interfaces/security/Challenge.ts';
 export * from './src/interfaces/security/decorators.ts';

src/compiler/entities/api/constants.js

@@ -1,5 +1,6 @@
 export const methods = new Map()
   .set('get', 'get')
+  .set('head', 'head')
   .set('put', 'put')
   .set('post', 'post')
   .set('patch', 'patch')

src/compiler/entities/api/handler.js

@@ -28,9 +28,9 @@ import {
   isNotThisParameter,
   isStringType,
   isBigIntType,
-  typeToString,
   hasUndefinedType,
   getNonUndefinedType,
+  hasAsyncModifier,
 } from '../../helpers/checker.js';
 import { methods } from './constants.js';
 import { makePayloadValidator } from '../../helpers/validator.js';
@@ -39,6 +39,7 @@ import { lookup } from '../../makers/declaration.js';
 
 import { File } from '../../makers/types/validators/File.js';
 import { BinaryData } from '../../makers/types/validators/BinaryData.js';
+import { makeCache } from '#compiler/makers/decorators/cache.js';
 
 export function makeRouteMethod(name, node) {
   const statements = [];
@@ -51,6 +52,22 @@ export function makeRouteMethod(name, node) {
   let payloadNode = node.parameters.find(isNotThisParameter);
   let payloadType = payloadNode && getTypeOfNode(payloadNode);
 
+  let isAsyncAction = hasAsyncModifier(node);
+  let isAsyncHandler = isAsyncAction;
+
+  const isPrivate = node.modifiers?.some(
+    hasDecorator,
+    lookup.decorators.Permission
+  );
+
+  const cache = makeCache(
+    node.modifiers?.find(hasDecorator, lookup.decorators.Cache),
+    req,
+    res,
+    ctx,
+    isPrivate
+  );
+
   const hasUndefinedReturnType = hasUndefinedType(returnType);
 
   if (hasUndefinedReturnType) {
@@ -61,62 +78,74 @@ export function makeRouteMethod(name, node) {
   let payload;
   let pathParameters = '';
 
+  if (cache?.check) {
+    statements.push(cache.check);
+  }
+
   statements.push(
     factoryConstant(ctx, factoryCallThisMethod('create', [req, res]))
   );
 
   if (payloadType) {
     const metaType = makePayloadValidator(node, payloadType);
 
-    if (name === 'get') {
+    if (name === 'get' || name === 'head') {
       payload = factoryIdentifier('data');
       const query = makePayloadFromQuery(payloadType);
 
       pathParameters = query.path;
       statements.push(factoryConstant(payload, query.data));
     } else {
       const body = makePayloadFromBody(metaType);
-
       payload = body.data;
       statements.push(factoryConstant(factoryIdentifier('data'), body.init));
     }
   }
 
-  if (node.modifiers?.some(hasDecorator, lookup.decorators.Permission)) {
+  if (isPrivate) {
+    isAsyncHandler = true;
     statements.push(factoryAwaitStatement(factoryCallMethod(ctx, 'auth')));
   }
 
-  ast = factoryAwait(factoryCallMethod(ast, name, payload && [payload]));
+  ast = factoryCallMethod(ast, name, payload && [payload]);
+
+  if (cache?.preset) {
+    statements.push(cache.preset);
+  }
+
+  if (isAsyncAction) {
+    ast = factoryAwait(ast);
+  }
 
   if (isVoidLikeType(returnType)) {
-    statements.push(factoryStatement(ast), internals.respondNoContent(res));
+    (ast = factoryStatement(ast)), internals.respondNoContent(res);
   } else if (File.isAssignable(returnType)) {
-    statements.push(internals.respondFile(res, ast));
+    ast = internals.respondFile(res, ast);
   } else if (BinaryData.isAssignable(returnType) || isStringType(returnType)) {
-    statements.push(internals.respondBinary(res, ast));
+    ast = internals.respondBinary(res, ast);
   } else if (isBigIntType(returnType)) {
-    statements.push(
-      internals.respondBinary(
-        res,
-        factoryPropertyParenthesized(
-          ast,
-          factoryCall(factoryIdentifier('toString')),
-          hasUndefinedReturnType
-        )
+    ast = internals.respondBinary(
+      res,
+      factoryPropertyParenthesized(
+        ast,
+        factoryCall(factoryIdentifier('toString')),
+        hasUndefinedReturnType
       )
     );
   } else {
-    statements.push(internals.respondJson(res, ast));
+    ast = internals.respondJson(res, ast);
   }
 
+  statements.push(ast);
+
   host.entity.route.methods.push({
     name: methods.get(name),
     params: pathParameters,
   });
 
   return factoryStaticProperty(
     factoryIdentifier(methods.get(name)),
-    factoryRouteFunction([
+    factoryRouteFunction(isAsyncHandler, [
       factoryTryStatement(statements, factoryIdentifier('e'), [
         internals.respondError(res, factoryIdentifier('e')),
       ]),

src/compiler/entities/api/maker.js

@@ -52,7 +52,7 @@ export function ServerContext(node) {
     if (
       member.kind === MethodDeclaration &&
       methods.has(member.name.escapedText) &&
-      !member.modifiers.some(isStaticKeyword)
+      !member.modifiers?.some(isStaticKeyword)
     )
       members.push(makeRouteMethod(member.name.escapedText, member));
   }

src/compiler/helpers/checker.js

@@ -34,6 +34,7 @@ const {
 export const {
   Decorator,
   TrueKeyword,
+  AsyncKeyword,
   FalseKeyword,
   StaticKeyword,
   ExportKeyword,
@@ -58,6 +59,7 @@ export const isTrueKeyword = ({ kind }) => kind === TrueKeyword;
 export const isFalseKeyword = ({ kind }) => kind === FalseKeyword;
 export const isStaticKeyword = ({ kind }) => kind === StaticKeyword;
 export const isDeclareKeyword = ({ kind }) => kind === DeclareKeyword;
+export const isAsyncKeyword = ({ kind }) => kind === AsyncKeyword;
 
 export const isAnyType = ({ flags }) => (flags & flagAny) !== 0;
 export const isNullType = ({ flags }) => (flags & flagNull) !== 0;
@@ -154,6 +156,7 @@ export const isExtendsToken = ({ token }) => token === ExtendsKeyword;
 export const isNotThisIdentifier = node => node.escapedText !== 'this';
 export const isNotThisParameter = node => isNotThisIdentifier(node.name);
 
+export const hasAsyncModifier = node => some(node.modifiers, isAsyncKeyword);
 export const hasDeclareModifier = node =>
   some(node.modifiers, isDeclareKeyword);
 

src/compiler/helpers/function.js

@@ -43,9 +43,9 @@ export const factoryBodyFunction = statements =>
     host.factory.createBlock(statements, false)
   );
 
-export const factoryRouteFunction = statements =>
+export const factoryRouteFunction = (isAsync, statements) =>
   host.factory.createArrowFunction(
-    [factoryToken(AsyncKeyword)],
+    isAsync ? [factoryToken(AsyncKeyword)] : undefined,
     undefined,
     [
       factoryParameter(factoryIdentifier('res')),

src/compiler/makers/declaration.js

@@ -33,6 +33,7 @@ import { TypedArray } from './types/validators/TypedArray.js';
 import { BinaryData } from './types/validators/BinaryData.js';
 import { BigIntSerial } from './types/validators/BigIntSerial.js';
 
+import { Cache } from './decorators/cache.js';
 import { Table } from './decorators/table.js';
 import { Postgres } from './decorators/postgres.js';
 import { Permission } from './decorators/permission.js';
@@ -66,6 +67,7 @@ export const lookup = {
   },
 
   decorators: {
+    Cache,
     Table,
     Postgres,
     Permission,

src/compiler/makers/decorators/cache.js

@@ -0,0 +1,38 @@
+import { factoryCallMethod } from '#compiler/helpers/call.js';
+import {
+  getTypeOfNode,
+  isFalseKeyword,
+  isNumberType,
+  isTrueKeyword,
+} from '#compiler/helpers/checker.js';
+import { factoryIfReturn } from '#compiler/helpers/statement.js';
+
+export function makeCache(decor, req, res, ctx) {
+  if (!decor?.expression) return;
+
+  const arg = decor.expression.arguments[0];
+  const name = decor.expression.expression;
+  const type = getTypeOfNode(arg);
+
+  if (isTrueKeyword(arg)) {
+    return {
+      check: factoryIfReturn(
+        factoryCallMethod(name, 'checkImmutable', [req, res])
+      ),
+      preset: factoryCallMethod(name, 'setImmutable', [ctx]),
+    };
+  } else if (isFalseKeyword(arg)) {
+    return {
+      preset: factoryCallMethod(name, 'setNoStore', [ctx]),
+    };
+  } else if (isNumberType(type)) {
+    return {
+      check: factoryIfReturn(factoryCallMethod(name, 'checkAge', [req, res])),
+      preset: factoryCallMethod(name, 'setAge', [ctx, arg]),
+    };
+  }
+}
+
+export function Cache(node) {
+  return node;
+}

src/interfaces/server/cache.ts

@@ -0,0 +1,12 @@
+interface CacheOptions {
+  maxAge?: number;
+  immutable?: boolean;
+  revalidate?: () => Promise<boolean>;
+}
+
+export declare function Cache(
+  options: boolean | number | CacheOptions
+): (
+  target: (payload?: any) => any,
+  context: ClassMethodDecoratorContext
+) => void;

src/interfaces/types/File.ts

@@ -1,5 +1,7 @@
 import type { BlobOptions } from './Blob.ts';
 
+
+
 export declare class File<
   T extends BlobOptions = undefined,
 > extends globalThis.Blob {

src/runtime/server/cache.js

@@ -0,0 +1,41 @@
+import { respondNotModified } from './response/respondCache.js';
+
+export class Cache {
+  static checkImmutable(req, res) {
+    if (req.getHeader('if-none-match')) {
+      respondNotModified(res);
+      return true;
+    } else return false;
+  }
+
+  static setImmutable(context) {
+    context.response.headers.push(
+      'cache-control',
+      'max-age=31536000, immutable',
+      'etag',
+      '1'
+    );
+  }
+
+  static setNoStore(context) {
+    context.response.headers.push('cache-control', 'no-store');
+  }
+
+  static checkAge(req, res) {
+    const eTag = req.getHeader('if-none-match');
+
+    if (eTag && +eTag > Date.now()) {
+      respondNotModified(res);
+      return true;
+    } else return false;
+  }
+
+  static setAge(context, age) {
+    context.response.headers.push(
+      'cache-control',
+      'max-age=' + age,
+      'etag',
+      (Date.now() + age * 1000).toString()
+    );
+  }
+}

src/runtime/server/context.js

@@ -8,7 +8,6 @@ export class ServerContext extends Context {
   request = {
     cookies: new Map(),
     headers: {
-      etag: '',
       range: '',
     },
   };
@@ -33,7 +32,6 @@ export class ServerContext extends Context {
 
     parseCookies(context.request.cookies, req.getHeader('cookie'));
 
-    context.request.headers.etag = req.getHeader('etag') ?? '';
     context.request.headers.range = req.getHeader('range') ?? '';
 
     return context;

src/runtime/server/response/respondCache.js

@@ -0,0 +1,5 @@
+export function respondNotModified(res) {
+  res.cork(() => {
+    res.writeStatus('304').end();
+  });
+}

src/runtime/server/response/respondError.js

@@ -3,7 +3,7 @@ export function respondError(res, error) {
 
   let status = error.status || 500;
 
-  if (res.context.connected) {
+  if (res.context?.connected) {
     const type = error.constructor?.name || 'Error';
 
     res.cork(() => {

src/runtime/server/response/respondFile.js

@@ -79,10 +79,6 @@ class FileSender {
       response.writeHeader('content-type', file.type);
     }
 
-    if (file.hash) {
-      response.writeHeader('etag', file.hash);
-    }
-
     if (file.lastModified) {
       response.writeHeader(
         'last-modified',