apeframework 0.0.0-dev.17 → 0.0.0-dev.19

package/config/Config.d.ts

@@ -1,2 +1,2 @@
-type Config = Record<string, boolean | number | string>;
+type Config = Record<string, any>;
 export { type Config, };

package/config/Config.ts

@@ -1,4 +1,4 @@
-type Config = Record<string, boolean | number | string>
+type Config = Record<string, any>
 
 export {
   type Config,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apeframework",
-  "version": "0.0.0-dev.17",
+  "version": "0.0.0-dev.19",
   "license": "MIT",
   "author": "Matthieu Symoens",
   "description": "Node.js app framework",
@@ -22,32 +22,34 @@
     "node": "^22"
   },
   "dependencies": {
+    "@fastify/compress": "^8.0",
     "@fastify/cors": "^10.0",
+    "@fastify/helmet": "^13.0",
     "@fastify/response-validation": "^3.0",
-    "@fastify/swagger": "^9.2",
+    "@fastify/swagger": "^9.4",
     "@types/bcryptjs": "^2.4",
     "@types/fs-extra": "^11.0",
     "@types/nodemailer": "^6.4",
     "@types/yargs-parser": "^21.0",
     "ajv": "^8.17",
     "bcryptjs": "^2.4",
-    "bullmq": "^5.19",
+    "bullmq": "^5.34",
     "dotenv": "^16.4",
     "fast-uri": "^3.0",
-    "fastify": "^5.0",
+    "fastify": "^5.2",
     "fs-extra": "^11.2",
     "ical-generator": "^8.0",
     "ioredis": "^5.4",
     "jose": "^5.9",
     "nodemailer": "^6.9",
     "openapi-types": "^12.1",
-    "pino": "^9.4",
-    "pino-pretty": "^11.2",
+    "pino": "^9.5",
+    "pino-pretty": "^13.0",
     "yargs-parser": "^21.1"
   },
   "peerDependencies": {
-    "@types/node": "^22.7",
+    "@types/node": "^22.10",
     "ts-node": "^10.9",
-    "typescript": "^5.6"
+    "typescript": "^5.7"
   }
 }

package/parser/factories/enum/createEnumParser.d.ts

@@ -0,0 +1,6 @@
+import type { Parser } from '../../Parser';
+declare const createEnumParser: <Type extends Record<string, string | number>>(params: {
+    type: string;
+    enum: Type;
+}) => Parser<Type[keyof Type]>;
+export { createEnumParser, };

package/parser/factories/enum/createEnumParser.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnumParser = void 0;
+const ParseError_1 = require("../../errors/ParseError");
+const createEnumParser = (params) => {
+    return (input) => {
+        if (!Object.values(params.enum).includes(input)) {
+            throw new ParseError_1.ParseError(params.type);
+        }
+        return input;
+    };
+};
+exports.createEnumParser = createEnumParser;

package/parser/factories/enum/createEnumParser.ts

@@ -0,0 +1,21 @@
+import { ParseError } from '../../errors/ParseError'
+import type { Parser } from '../../Parser'
+
+const createEnumParser = <Type extends Record<string, string | number>>(
+  params: {
+    type: string,
+    enum: Type,
+  },
+): Parser<Type[keyof Type]> => {
+  return (input) => {
+    if (!Object.values(params.enum).includes(input)) {
+      throw new ParseError(params.type)
+    }
+
+    return input
+  }
+}
+
+export {
+  createEnumParser,
+}

package/{api/Endpoint.d.ts → server/Route.d.ts}

@@ -1,7 +1,7 @@
 import type { Handler } from './Handler';
 import type { Method } from './Method';
 import type { Schema } from './Schema';
-interface Endpoint {
+interface Route {
     path: string;
     method: Method;
     name?: string;
@@ -9,4 +9,4 @@ interface Endpoint {
     schema: Schema;
     handler: Handler;
 }
-export { type Endpoint, };
+export { type Route, };

package/{api/Endpoint.ts → server/Route.ts}

@@ -2,7 +2,7 @@ import type { Handler } from './Handler'
 import type { Method } from './Method'
 import type { Schema } from './Schema'
 
-interface Endpoint {
+interface Route {
   path: string,
   method: Method,
   name?: string,
@@ -12,5 +12,5 @@ interface Endpoint {
 }
 
 export {
-  type Endpoint,
+  type Route,
 }

package/{api/Api.d.ts → server/Server.d.ts}

@@ -1,27 +1,31 @@
 import { OpenApiFormat } from './OpenApiFormat';
-import type { Endpoint } from './Endpoint';
 import type { ErrorHandler } from './ErrorHandler';
 import type { Format } from './Format';
 import type { Handler } from './Handler';
+import type { Route } from './Route';
 import type { OpenAPIV3 } from 'openapi-types';
-declare class Api {
+declare class Server {
+    private readonly server;
     private readonly host;
     private readonly port;
-    private readonly server;
     constructor(params: {
         host: string;
         port?: number;
-        endpoints: Endpoint[];
+        routes: Route[];
         formats?: Format[];
         openapi?: {
             name?: string;
             version?: string;
         };
+        responseValidation?: boolean;
+        compression?: {
+            enabled?: boolean;
+            threshold?: number;
+        };
         cors?: {
-            enable?: boolean;
+            enabled?: boolean;
             origins?: string[];
         };
-        responseValidation?: boolean;
         onRequest?: Handler;
         onResponse?: Handler;
         onNotFound?: Handler;
@@ -30,4 +34,4 @@ declare class Api {
     start(): Promise<string>;
     openapi(format: OpenApiFormat): OpenAPIV3.Document;
 }
-export { Api, };
+export { Server, };

package/{api/Api.js → server/Server.js}

@@ -3,37 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Api = void 0;
+exports.Server = void 0;
+const compress_1 = __importDefault(require("@fastify/compress"));
 const cors_1 = __importDefault(require("@fastify/cors"));
+const helmet_1 = __importDefault(require("@fastify/helmet"));
 const response_validation_1 = __importDefault(require("@fastify/response-validation"));
 const swagger_1 = __importDefault(require("@fastify/swagger"));
 const fastify_1 = __importDefault(require("fastify"));
 const OpenApiFormat_1 = require("./OpenApiFormat");
 const getAjv_1 = require("./getAjv");
-class Api {
+class Server {
+    server;
     host;
     port;
-    server;
     constructor(params) {
         this.host = params.host;
         this.port = params.port;
         this.server = (0, fastify_1.default)();
-        const ajv = (0, getAjv_1.getAjv)(params.formats);
         this.server.setValidatorCompiler(({ schema }) => {
-            return ajv.compile(schema);
+            return (0, getAjv_1.getAjv)(params.formats).compile(schema);
         });
-        if (params.onRequest) {
-            this.server.addHook('onRequest', params.onRequest);
-        }
-        if (params.onResponse) {
-            this.server.addHook('onResponse', params.onResponse);
-        }
-        if (params.onNotFound) {
-            this.server.setNotFoundHandler(params.onNotFound);
-        }
-        if (params.onError) {
-            this.server.setErrorHandler(params.onError);
-        }
         this.server.register(swagger_1.default, {
             openapi: {
                 openapi: '3.1.0',
@@ -43,33 +32,54 @@ class Api {
                 },
             },
         });
-        if (params.cors?.enable) {
+        if (params.responseValidation) {
+            this.server.register(response_validation_1.default);
+        }
+        if (params.compression?.enabled) {
+            this.server.register(compress_1.default, {
+                global: true,
+                threshold: params.compression.threshold ?? 1024,
+            });
+        }
+        if (params.cors?.enabled) {
             this.server.register(cors_1.default, {
                 origin: params.cors.origins,
             });
         }
-        if (params.responseValidation) {
-            this.server.register(response_validation_1.default);
-        }
+        this.server.register(helmet_1.default, {
+            global: false,
+        });
         this.server.register((server, options, done) => {
-            params.endpoints.forEach((e) => {
+            params.routes.forEach((route) => {
                 server.route({
-                    url: e.path,
-                    method: e.method,
+                    url: route.path,
+                    method: route.method,
                     schema: {
-                        summary: e.name ?? e.path,
-                        description: e.description,
-                        ...e.schema.params ? { params: e.schema.params } : {},
-                        ...e.schema.query ? { query: e.schema.query } : {},
-                        ...e.schema.headers ? { headers: e.schema.headers } : {},
-                        ...e.schema.body ? { body: e.schema.body } : {},
-                        ...e.schema.response ? { response: e.schema.response } : {},
+                        summary: route.name ?? route.path,
+                        description: route.description,
+                        ...route.schema.params ? { params: route.schema.params } : {},
+                        ...route.schema.query ? { query: route.schema.query } : {},
+                        ...route.schema.headers ? { headers: route.schema.headers } : {},
+                        ...route.schema.body ? { body: route.schema.body } : {},
+                        ...route.schema.response ? { response: route.schema.response } : {},
                     },
-                    handler: e.handler,
+                    handler: route.handler,
                 });
             });
             done();
         });
+        if (params.onRequest) {
+            this.server.addHook('onRequest', params.onRequest);
+        }
+        if (params.onResponse) {
+            this.server.addHook('onResponse', params.onResponse);
+        }
+        if (params.onNotFound) {
+            this.server.setNotFoundHandler(params.onNotFound);
+        }
+        if (params.onError) {
+            this.server.setErrorHandler(params.onError);
+        }
     }
     async start() {
         return this.server.listen({
@@ -83,4 +93,4 @@ class Api {
         });
     }
 }
-exports.Api = Api;
+exports.Server = Server;

package/{api/Api.ts → server/Server.ts}

@@ -1,37 +1,43 @@
+import compress from '@fastify/compress'
 import cors from '@fastify/cors'
+import helmet from '@fastify/helmet'
 import responseValidation from '@fastify/response-validation'
 import swagger from '@fastify/swagger'
 import fastify from 'fastify'
 import { OpenApiFormat } from './OpenApiFormat'
 import { getAjv } from './getAjv'
-import type { Endpoint } from './Endpoint'
 import type { ErrorHandler } from './ErrorHandler'
 import type { Format } from './Format'
 import type { Handler } from './Handler'
+import type { Route } from './Route'
 import type { FastifyInstance } from 'fastify'
 import type { OpenAPIV3 } from 'openapi-types'
 
-class Api {
+class Server {
+  private readonly server: FastifyInstance
+
   private readonly host: string
 
   private readonly port: number | undefined
 
-  private readonly server: FastifyInstance
-
   public constructor(params: {
     host: string,
     port?: number,
-    endpoints: Endpoint[],
+    routes: Route[],
     formats?: Format[],
     openapi?: {
       name?: string,
       version?: string,
     },
+    responseValidation?: boolean,
+    compression?: {
+      enabled?: boolean,
+      threshold?: number,
+    },
     cors?: {
-      enable?: boolean,
+      enabled?: boolean,
       origins?: string[],
     },
-    responseValidation?: boolean,
     onRequest?: Handler,
     onResponse?: Handler,
     onNotFound?: Handler,
@@ -42,28 +48,10 @@ class Api {
 
     this.server = fastify()
 
-    const ajv = getAjv(params.formats)
-
     this.server.setValidatorCompiler(({ schema }) => {
-      return ajv.compile(schema)
+      return getAjv(params.formats).compile(schema)
     })
 
-    if (params.onRequest) {
-      this.server.addHook('onRequest', params.onRequest)
-    }
-
-    if (params.onResponse) {
-      this.server.addHook('onResponse', params.onResponse)
-    }
-
-    if (params.onNotFound) {
-      this.server.setNotFoundHandler(params.onNotFound)
-    }
-
-    if (params.onError) {
-      this.server.setErrorHandler(params.onError)
-    }
-
     this.server.register(swagger, {
       openapi: {
         openapi: '3.1.0',
@@ -74,35 +62,62 @@ class Api {
       },
     })
 
-    if (params.cors?.enable) {
+    if (params.responseValidation) {
+      this.server.register(responseValidation)
+    }
+
+    if (params.compression?.enabled) {
+      this.server.register(compress, {
+        global: true,
+        threshold: params.compression.threshold ?? 1024,
+      })
+    }
+
+    if (params.cors?.enabled) {
       this.server.register(cors, {
         origin: params.cors.origins,
       })
     }
 
-    if (params.responseValidation) {
-      this.server.register(responseValidation)
-    }
+    this.server.register(helmet, {
+      global: false,
+    })
 
     this.server.register((server, options, done) => {
-      params.endpoints.forEach((e) => {
+      params.routes.forEach((route) => {
         server.route({
-          url: e.path,
-          method: e.method,
+          url: route.path,
+          method: route.method,
           schema: {
-            summary: e.name ?? e.path,
-            description: e.description,
-            ...e.schema.params ? { params: e.schema.params } : {},
-            ...e.schema.query ? { query: e.schema.query } : {},
-            ...e.schema.headers ? { headers: e.schema.headers } : {},
-            ...e.schema.body ? { body: e.schema.body } : {},
-            ...e.schema.response ? { response: e.schema.response } : {},
+            summary: route.name ?? route.path,
+            description: route.description,
+            ...route.schema.params ? { params: route.schema.params } : {},
+            ...route.schema.query ? { query: route.schema.query } : {},
+            ...route.schema.headers ? { headers: route.schema.headers } : {},
+            ...route.schema.body ? { body: route.schema.body } : {},
+            ...route.schema.response ? { response: route.schema.response } : {},
           },
-          handler: e.handler,
+          handler: route.handler,
         })
       })
       done()
     })
+
+    if (params.onRequest) {
+      this.server.addHook('onRequest', params.onRequest)
+    }
+
+    if (params.onResponse) {
+      this.server.addHook('onResponse', params.onResponse)
+    }
+
+    if (params.onNotFound) {
+      this.server.setNotFoundHandler(params.onNotFound)
+    }
+
+    if (params.onError) {
+      this.server.setErrorHandler(params.onError)
+    }
   }
 
   public async start(): Promise<string> {
@@ -120,5 +135,5 @@ class Api {
 }
 
 export {
-  Api,
+  Server,
 }