equipped 4.4.6 → 5.0.0-beta-1

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [5.0.0-beta-1](https://github.com/kevinand11/equipped/compare/v4.4.6...v5.0.0-beta-1) (2024-05-29)
+
+
+### Features
+
+* add request type details on Request class ([d6c3752](https://github.com/kevinand11/equipped/commit/d6c37529e7eeac5a3c2ac20e0a205de49cb0465e))
+* error handler per route ([0eccc21](https://github.com/kevinand11/equipped/commit/0eccc2129c559353efc65ae7ddf6bd0368e4031e))
+* express server swagger ([95c811b](https://github.com/kevinand11/equipped/commit/95c811ba7a1086116c4327c37e1723b08b85059d))
+* fastify swagger and custom schema validation error ([17b8710](https://github.com/kevinand11/equipped/commit/17b8710324c5c515daa8928d7028ef0150a6c30d))
+* hide routes from schema ([304df23](https://github.com/kevinand11/equipped/commit/304df23a413f13cbd77f2eeeae00032d57dcea2c))
+* new JsonValue and Ignored types ([ba73af4](https://github.com/kevinand11/equipped/commit/ba73af440f54549d10a974fd530c35ac912ec4dd))
+* regustere schemas in server and reference by key ([7298bb0](https://github.com/kevinand11/equipped/commit/7298bb0ae6a908325bbef3cd308e2a7787147387))
+* route securities ([a7b91a1](https://github.com/kevinand11/equipped/commit/a7b91a17acf15cc9013fe971b0adf2b96cd129da))
+* schema for fastify ([990529c](https://github.com/kevinand11/equipped/commit/990529ce777d5fcfb6f4c11d634ecdc31aa2ea81))
+* script to generate schemas ([2736ffa](https://github.com/kevinand11/equipped/commit/2736ffa68da13fb0b3ef96809a06be74754257ba))
+* settings to toggle whether to schema validate ([6f64313](https://github.com/kevinand11/equipped/commit/6f643133632963cc5418259d3f97a9cf172bcdaf))
+* throw ValidationError for failed schema validation in express app ([be30a5e](https://github.com/kevinand11/equipped/commit/be30a5e1ff7fe7016bf6effa9566a3a48acafd0e))
+
+
+### Bug Fixes
+
+* catch errors in json schema ([02f4b0b](https://github.com/kevinand11/equipped/commit/02f4b0bb4c8eaa3fc0e1a25b14e2f531101d3d08))
+* fix mongo createCollection command ([f0bfbfa](https://github.com/kevinand11/equipped/commit/f0bfbfa945d48741fbc56b6766483f12b35e0f7c))
+* remove recursive type for QueryWhereBlock to prevent recursive errors in schema gen ([31e3af6](https://github.com/kevinand11/equipped/commit/31e3af64e6ead4b67e5a787df3c0b39671f8e39b))
+
 ### [4.4.6](https://github.com/kevinand11/equipped/compare/v4.4.5...v4.4.6) (2024-04-07)
 
 ### [4.4.5](https://github.com/kevinand11/equipped/compare/v4.4.4...v4.4.5) (2024-04-06)

package/lib/db/_instance.d.ts

@@ -1,16 +1,17 @@
 import { BaseEntity } from '../structure';
+import { DeepPartial } from '../types';
 import { DebeziumSetup } from './debezium';
 import { QueryParams, QueryResults } from './query';
 export declare abstract class Db {
     #private;
-    abstract change<Model, Entity extends BaseEntity<any>>(collection: any, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): DbChange<Model, Entity>;
+    abstract change<Model, Entity extends BaseEntity>(collection: any, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): DbChange<Model, Entity>;
     abstract query<Model>(collection: any, params: QueryParams): Promise<QueryResults<Model>>;
     protected _addToDbChanges(dbChange: DbChange<any, any>): this;
     startAllDbChanges(): Promise<void>;
     abstract start(): Promise<void>;
     abstract close(): Promise<void>;
 }
-export declare abstract class DbChange<Model, Entity extends BaseEntity<any>> {
+export declare abstract class DbChange<Model, Entity extends BaseEntity> {
     #private;
     constructor(callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null);
     abstract start(): Promise<void>;
@@ -18,9 +19,6 @@ export declare abstract class DbChange<Model, Entity extends BaseEntity<any>> {
     get mapper(): (model: Model | null) => Entity | null;
     protected _setup(key: string, data: DebeziumSetup): Promise<boolean>;
 }
-type DeepPartial<T> = {
-    [P in keyof T]?: DeepPartial<T[P]>;
-};
 export type DbChangeCallbacks<Model, Entity> = {
     created?: (data: {
         before: null;
@@ -36,4 +34,3 @@ export type DbChangeCallbacks<Model, Entity> = {
         after: null;
     }) => Promise<void>;
 };
-export {};

package/lib/db/mongoose/changes.d.ts

@@ -22,10 +22,11 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
 import mongoose from 'mongoose';
 import { BaseEntity } from '../../structure';
 import { DbChange, DbChangeCallbacks } from '../_instance';
-export declare class MongoDbChange<Model, Entity extends BaseEntity<any>> extends DbChange<Model, Entity> {
+export declare class MongoDbChange<Model, Entity extends BaseEntity> extends DbChange<Model, Entity> {
     #private;
     constructor(model: mongoose.Model<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null);
     start(): Promise<void>;

package/lib/db/mongoose/index.d.ts

@@ -22,6 +22,7 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
 import mongoose from 'mongoose';
 import { BaseEntity } from '../../structure';
 import { QueryParams, QueryResults } from '../query';
@@ -32,7 +33,7 @@ export declare class MongoDb extends Db {
     get Schema(): typeof mongoose.Schema;
     get Id(): mongoose.Types.ObjectId;
     use(dbName?: string): mongoose.Connection;
-    change<Model, Entity extends BaseEntity<any>>(model: mongoose.Model<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): MongoDbChange<Model, Entity>;
+    change<Model, Entity extends BaseEntity>(model: mongoose.Model<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): MongoDbChange<Model, Entity>;
     query<Model>(model: mongoose.Model<Model>, params: QueryParams): Promise<QueryResults<Model>>;
     start(): Promise<void>;
     close(): Promise<void>;

package/lib/db/mongoose/index.js

@@ -58,7 +58,9 @@ class MongoDb extends _instance_1.Db {
         await Promise.all([mongoose_1.default.connection, ...__classPrivateFieldGet(this, _MongoDb_instances, "a", _MongoDb_connections_get)].map((conn) => {
             return Object.values(conn.models)
                 .map(async (model) => {
-                await conn.db.command({ collMod: model.collection.name, changeStreamPreAndPostImages: { enabled: true } });
+                await conn.db.createCollection(model.collection.name, {
+                    changeStreamPreAndPostImages: { enabled: true }
+                });
             });
         }).flat());
     }

package/lib/db/mongoose/query.d.ts

@@ -22,6 +22,7 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
 import mongoose from 'mongoose';
 import { QueryParams, QueryResults } from '../query';
 export declare const parseMongodbQueryParams: <Model>(model: mongoose.Model<Model>, params: QueryParams) => Promise<QueryResults<Model>>;

package/lib/db/query.d.ts

@@ -1,3 +1,4 @@
+import { Paths } from '../types';
 export type QueryResults<Model> = {
     pages: {
         start: number;
@@ -28,23 +29,23 @@ export declare enum Conditions {
     nin = "nin",
     exists = "exists"
 }
-export type QueryWhere = {
-    field: string;
-    value: any;
+export type QueryWhere<T> = {
+    field: Paths<T, string>;
+    value: unknown;
     condition?: Conditions;
 };
-export type QueryWhereBlock = {
+export type QueryWhereBlock<T> = {
     condition: QueryKeys;
-    value: (QueryWhere | QueryWhereBlock)[];
+    value: QueryWhere<T>[];
 };
-export type QueryWhereClause = QueryWhere | QueryWhereBlock;
-export type QueryParams = {
-    where?: QueryWhereClause[];
-    auth?: QueryWhereClause[];
+export type QueryWhereClause<T> = QueryWhere<T> | QueryWhereBlock<T>;
+export type QueryParams<T = unknown> = {
+    where?: QueryWhereClause<T>[];
+    auth?: QueryWhereClause<T>[];
     whereType?: QueryKeys;
     authType?: QueryKeys;
     sort?: {
-        field: string;
+        field: Paths<T, string>;
         desc?: boolean;
     }[];
     limit?: number;
@@ -52,6 +53,6 @@ export type QueryParams = {
     page?: number;
     search?: {
         value: string;
-        fields: string[];
+        fields: Paths<T, string>[];
     };
 };

package/lib/errors/customError.d.ts

@@ -6,7 +6,6 @@ export declare abstract class CustomError extends Error {
         message: string;
         field?: string;
     }[];
-    isCustomError: boolean;
     protected constructor(message: string, serializedErrors: {
         message: string;
         field?: string;

package/lib/errors/customError.js

@@ -4,7 +4,6 @@ exports.CustomError = void 0;
 class CustomError extends Error {
     constructor(message, serializedErrors) {
         super(message);
-        this.isCustomError = true;
         this.message = message;
         this.serializedErrors = serializedErrors;
     }

package/lib/errors/index.d.ts

@@ -1,8 +1,6 @@
 export * from './customError';
 export * from './types/accessTokenExpired';
-export * from './types/accountNotVerifiedError';
 export * from './types/badRequestError';
-export * from './types/invalidToken';
 export * from './types/notAuthenticatedError';
 export * from './types/notAuthorizedError';
 export * from './types/notFoundError';

package/lib/errors/index.js

@@ -16,9 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./customError"), exports);
 __exportStar(require("./types/accessTokenExpired"), exports);
-__exportStar(require("./types/accountNotVerifiedError"), exports);
 __exportStar(require("./types/badRequestError"), exports);
-__exportStar(require("./types/invalidToken"), exports);
 __exportStar(require("./types/notAuthenticatedError"), exports);
 __exportStar(require("./types/notAuthorizedError"), exports);
 __exportStar(require("./types/notFoundError"), exports);

package/lib/errors/types/refreshTokenMisusedError.d.ts

@@ -1,5 +1,5 @@
 import { CustomError } from '../customError';
 export declare class RefreshTokenMisusedError extends CustomError {
-    statusCode: 462;
+    statusCode: 401;
     constructor(message?: string);
 }

package/lib/errors/types/refreshTokenMisusedError.js

@@ -6,7 +6,7 @@ const customError_1 = require("../customError");
 class RefreshTokenMisusedError extends customError_1.CustomError {
     constructor(message = 'Refresh token misused') {
         super(message, [{ message }]);
-        this.statusCode = server_1.StatusCodes.RefreshTokenMisused;
+        this.statusCode = server_1.StatusCodes.NotAuthenticated;
     }
 }
 exports.RefreshTokenMisusedError = RefreshTokenMisusedError;

package/lib/index.d.ts

@@ -7,9 +7,11 @@ export { Events } from './events/';
 export * from './exit';
 export * from './instance';
 export * from './listeners';
+export * from './scripts';
 export * from './server';
 export * from './storage';
 export * from './structure';
+export * from './types';
 export * from './utils/auth';
 export * from './utils/authUser';
 export * from './utils/retry';

package/lib/index.js

@@ -28,9 +28,11 @@ __exportStar(require("./errors"), exports);
 __exportStar(require("./exit"), exports);
 __exportStar(require("./instance"), exports);
 __exportStar(require("./listeners"), exports);
+__exportStar(require("./scripts"), exports);
 __exportStar(require("./server"), exports);
 __exportStar(require("./storage"), exports);
 __exportStar(require("./structure"), exports);
+__exportStar(require("./types"), exports);
 __exportStar(require("./utils/auth"), exports);
 __exportStar(require("./utils/authUser"), exports);
 __exportStar(require("./utils/retry"), exports);

package/lib/instance/index.d.ts

@@ -1,23 +1,24 @@
+import pino from 'pino';
 import { BullJob } from '../bull';
 import { Cache } from '../cache/cache';
 import { MongoDb } from '../db/mongoose';
 import { EventBus } from '../events/';
-import { Logger } from '../logger';
-import { Server } from '../server/app';
+import { Server } from '../server';
 import { Settings } from './settings';
 export declare class Instance {
     #private;
     private constructor();
-    get logger(): Logger;
+    get logger(): pino.Logger<any>;
     get job(): BullJob;
     get cache(): Cache;
     get eventBus(): EventBus;
-    get server(): Server;
+    get server(): Server<any, any>;
     get dbs(): {
         mongo: MongoDb;
     };
     get listener(): import("..").Listener;
     get settings(): Settings;
+    static createLogger(): import("pino").Logger<any>;
     static initialize(settings: Partial<Settings>): void;
     static get(): Instance;
     startConnections(): Promise<void>;

package/lib/instance/index.js

@@ -10,16 +10,19 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _a, _Instance_initialized, _Instance_instance, _Instance_settings, _Instance_logger, _Instance_job, _Instance_cache, _Instance_eventBus, _Instance_server, _Instance_dbs;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Instance = void 0;
+const pino_1 = __importDefault(require("pino"));
 const bull_1 = require("../bull");
 const redis_cache_1 = require("../cache/types/redis-cache");
 const mongoose_1 = require("../db/mongoose");
 const kafka_1 = require("../events/kafka");
 const exit_1 = require("../exit");
-const logger_1 = require("../logger");
-const app_1 = require("../server/app");
+const server_1 = require("../server");
 const settings_1 = require("./settings");
 class Instance {
     constructor() {
@@ -32,7 +35,7 @@ class Instance {
         _Instance_dbs.set(this, null);
     }
     get logger() {
-        return __classPrivateFieldSet(this, _Instance_logger, __classPrivateFieldGet(this, _Instance_logger, "f") || new logger_1.ConsoleLogger(), "f");
+        return __classPrivateFieldSet(this, _Instance_logger, __classPrivateFieldGet(this, _Instance_logger, "f") || _a.createLogger(), "f");
     }
     get job() {
         return __classPrivateFieldSet(this, _Instance_job, __classPrivateFieldGet(this, _Instance_job, "f") || new bull_1.BullJob(), "f");
@@ -44,7 +47,7 @@ class Instance {
         return __classPrivateFieldSet(this, _Instance_eventBus, __classPrivateFieldGet(this, _Instance_eventBus, "f") || new kafka_1.KafkaEventBus(), "f");
     }
     get server() {
-        return __classPrivateFieldSet(this, _Instance_server, __classPrivateFieldGet(this, _Instance_server, "f") || new app_1.Server(), "f");
+        return __classPrivateFieldSet(this, _Instance_server, __classPrivateFieldGet(this, _Instance_server, "f") || server_1.serverTypes[this.settings.server](), "f");
     }
     get dbs() {
         return __classPrivateFieldSet(this, _Instance_dbs, __classPrivateFieldGet(this, _Instance_dbs, "f") || { mongo: new mongoose_1.MongoDb() }, "f");
@@ -55,6 +58,16 @@ class Instance {
     get settings() {
         return __classPrivateFieldGet(this, _Instance_settings, "f");
     }
+    static createLogger() {
+        return (0, pino_1.default)({
+            level: _a.get()?.settings?.logLevel ?? 'info',
+            serializers: {
+                err: pino_1.default.stdSerializers.err,
+                req: pino_1.default.stdSerializers.req,
+                res: pino_1.default.stdSerializers.res,
+            },
+        });
+    }
     static initialize(settings) {
         __classPrivateFieldSet(_a, _a, true, "f", _Instance_initialized);
         const instanceSettings = _a.get().settings;

package/lib/instance/settings.d.ts

@@ -1,3 +1,5 @@
+import { Level } from 'pino';
+import type { ServerTypes } from '../server';
 export type Settings = {
     isDev: boolean;
     accessTokenKey: string;
@@ -22,5 +24,11 @@ export type Settings = {
     slowDownDelayInMs: number;
     hashSaltRounds: number;
     paginationDefaultLimit: number;
+    server: ServerTypes;
+    openapiDocsVersion: string;
+    openapiDocsUrl: string;
+    logLevel: Level;
+    logRequests: boolean;
+    requestSchemaValidation: boolean;
 };
 export declare const defaulInstanceSetting: Settings;

package/lib/instance/settings.js

@@ -24,5 +24,11 @@ exports.defaulInstanceSetting = {
     slowDownAfter: 1000,
     slowDownDelayInMs: 500,
     hashSaltRounds: 10,
-    paginationDefaultLimit: 100
+    paginationDefaultLimit: 100,
+    server: 'express',
+    openapiDocsVersion: '1.0.0',
+    openapiDocsUrl: '/__docs',
+    logLevel: 'info',
+    logRequests: true,
+    requestSchemaValidation: false,
 };

package/lib/listeners/emitter.d.ts

@@ -13,9 +13,9 @@ export declare class Listener {
     #private;
     constructor(socket: io.Server, callers: SocketCallers);
     start(): Promise<void>;
-    created(channels: string[], data: BaseEntity<any>): Promise<void>;
-    updated(channels: string[], data: BaseEntity<any>): Promise<void>;
-    deleted(channels: string[], data: BaseEntity<any>): Promise<void>;
+    created(channels: string[], data: BaseEntity): Promise<void>;
+    updated(channels: string[], data: BaseEntity): Promise<void>;
+    deleted(channels: string[], data: BaseEntity): Promise<void>;
     set callers(callers: SocketCallers);
     register(channel: string, onJoin?: OnJoinFn): this;
 }

package/lib/scripts/index.d.ts

@@ -0,0 +1 @@
+export * from './json-schema';

package/lib/scripts/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./json-schema"), exports);

package/lib/scripts/json-schema.d.ts

@@ -0,0 +1,2 @@
+import { RouteSchema } from '../server';
+export declare function generateJSONSchema(patterns: (string | RegExp)[], paths: string[]): Record<string, RouteSchema>;

package/lib/scripts/json-schema.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJSONSchema = void 0;
+const ts_oas_1 = __importStar(require("ts-oas"));
+const instance_1 = require("../instance");
+function generateJSONSchema(patterns, paths) {
+    const tsProgram = (0, ts_oas_1.createProgram)(paths, { strictNullChecks: true });
+    const tsoas = new ts_oas_1.default(tsProgram, { ref: false, ignoreErrors: true });
+    const jsonSchema = tsoas.getSchemas(patterns);
+    return Object.entries(jsonSchema)
+        .map(([name, { properties: def }]) => {
+        try {
+            const key = def?.key?.enum?.at(0) ?? name;
+            if (!def || !key || !def.method)
+                throw new Error();
+            const response = def.responses.properties ?? def.responses.anyOf?.reduce((acc, cur) => {
+                if (cur.properties)
+                    return { ...acc, ...cur.properties };
+                return acc;
+            }, {}) ?? undefined;
+            const schema = def
+                ? {
+                    body: def.body,
+                    params: def.params,
+                    querystring: def.query,
+                    headers: def.headers,
+                    response,
+                    operationId: key,
+                    summary: name,
+                }
+                : undefined;
+            return [key, schema];
+        }
+        catch (err) {
+            instance_1.Instance.createLogger().warn(`Error parsing ${name}: ${err.message}. Skipping route`);
+            return [undefined, undefined];
+        }
+    })
+        .reduce((acc, [path, schema]) => {
+        if (path && schema)
+            acc[path] = stripEmptyObjects(schema);
+        return acc;
+    }, {});
+}
+exports.generateJSONSchema = generateJSONSchema;
+function stripEmptyObjects(obj) {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        if (!value || typeof value === 'object' && Object.keys(value).length === 0)
+            return acc;
+        return { ...acc, [key]: value };
+    }, {});
+}

package/lib/server/impls/base.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node/http" />
+/// <reference types="pino-http" />
+import http from 'http';
+import { OpenAPIV3_1 } from 'openapi-types';
+import supertest from 'supertest';
+import { FastifySchema } from 'fastify';
+import { Listener } from '../../listeners';
+import { Defined } from '../../types';
+import { Request } from '../requests';
+import { Router } from '../routes';
+import { Route } from '../types';
+export type FullRoute = Required<Omit<Route, 'schema' | 'tags' | 'security' | 'hideSchema' | 'onError' | 'onSetupHandler' | '__def'>> & {
+    schema: FastifySchema;
+    onError?: Route['onError'];
+};
+type Schemas = Record<string, Defined<Route['schema']>>;
+export declare abstract class Server<Req = any, Res = any> {
+    #private;
+    protected server: http.Server;
+    protected staticPath: string;
+    protected settings: import("../../instance/settings").Settings;
+    protected baseOpenapiDoc: OpenAPIV3_1.Document;
+    protected abstract onLoad(): Promise<void>;
+    protected abstract startServer(port: number): Promise<boolean>;
+    protected abstract parse(req: Req, res: Res): Promise<Request>;
+    protected abstract registerRoute(route: FullRoute): void;
+    constructor(server: http.Server);
+    get listener(): Listener;
+    addRoutes(routes: Route[]): void;
+    addSchema(schemas: Schemas): void;
+    load(): Promise<void>;
+    register(router: Router | Router[]): void;
+    test(): import("supertest/lib/agent")<supertest.SuperTestStatic.Test>;
+    start(port: number): Promise<boolean>;
+}
+export {};

package/lib/server/impls/base.js

@@ -0,0 +1,120 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Server_instances, _Server_schemas, _Server_listener, _Server_regRoute;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const socket_io_1 = __importDefault(require("socket.io"));
+const supertest_1 = __importDefault(require("supertest"));
+const path_1 = __importDefault(require("path"));
+const instance_1 = require("../../instance");
+const listeners_1 = require("../../listeners");
+const middlewares_1 = require("../middlewares");
+const routes_1 = require("../routes");
+class Server {
+    constructor(server) {
+        _Server_instances.add(this);
+        _Server_schemas.set(this, {});
+        _Server_listener.set(this, null);
+        this.staticPath = path_1.default.join(process.cwd(), 'public');
+        this.settings = instance_1.Instance.get().settings;
+        this.baseOpenapiDoc = {
+            openapi: '3.0.0',
+            info: { title: this.settings.appId, version: this.settings.openapiDocsVersion },
+            paths: {},
+            components: {
+                schemas: {},
+                securitySchemes: {
+                    AccessToken: {
+                        type: 'apiKey',
+                        name: 'Access-Token',
+                        in: 'header',
+                    },
+                    RefreshToken: {
+                        type: 'apiKey',
+                        name: 'Refresh-Token',
+                        in: 'header',
+                    }
+                },
+            }
+        };
+        this.server = server;
+    }
+    get listener() {
+        if (!__classPrivateFieldGet(this, _Server_listener, "f")) {
+            const socket = new socket_io_1.default.Server(this.server, { cors: { origin: '*' } });
+            __classPrivateFieldSet(this, _Server_listener, new listeners_1.Listener(socket, {
+                onConnect: async () => { },
+                onDisconnect: async () => { }
+            }), "f");
+        }
+        return __classPrivateFieldGet(this, _Server_listener, "f");
+    }
+    addRoutes(routes) {
+        routes.forEach((route) => __classPrivateFieldGet(this, _Server_instances, "m", _Server_regRoute).call(this, route));
+    }
+    addSchema(schemas) {
+        Object.assign(__classPrivateFieldGet(this, _Server_schemas, "f"), schemas);
+    }
+    async load() {
+        await this.onLoad();
+    }
+    register(router) {
+        const routers = Array.isArray(router) ? router : [router];
+        routers.map((router) => router.routes).forEach((routes) => this.addRoutes(routes));
+    }
+    test() {
+        return (0, supertest_1.default)(this.server);
+    }
+    async start(port) {
+        const postRoutesRouter = new routes_1.Router();
+        postRoutesRouter.get({
+            path: '__health',
+            schema: {
+                response: {
+                    200: { type: 'string' },
+                }
+            }
+        })(async () => `${this.settings.appId} service running`);
+        this.register(postRoutesRouter);
+        const started = await this.startServer(port);
+        if (started)
+            await instance_1.Instance.get().logger.info(`${this.settings.appId} service listening on port`, port);
+        return started;
+    }
+}
+exports.Server = Server;
+_Server_schemas = new WeakMap(), _Server_listener = new WeakMap(), _Server_instances = new WeakSet(), _Server_regRoute = function _Server_regRoute(route) {
+    const { method, path, middlewares = [], handler, schema, tags = [], security = [], onError, hideSchema = false } = route;
+    const { key = `${method.toLowerCase()} ${path}` } = route;
+    const allMiddlewares = [middlewares_1.parseAuthUser, ...middlewares];
+    allMiddlewares.forEach((m) => m.onSetup?.(route));
+    route.onSetupHandler?.(route);
+    onError?.onSetup?.(route);
+    const scheme = schema ?? __classPrivateFieldGet(this, _Server_schemas, "f")[key] ?? {};
+    const fullRoute = {
+        method, middlewares, handler, key,
+        path: path.replace(/(\/\s*)+/g, '/'),
+        onError,
+        schema: {
+            ...scheme,
+            hide: hideSchema,
+            operationId: scheme.operationId ?? handler.name,
+            tags: [tags.join(' > ') || 'default'],
+            security,
+        }
+    };
+    this.registerRoute(fullRoute);
+};