equipped 5.0.0-beta.9 → 5.0.0-rc.2

package/lib/listeners/emitter.js

@@ -1,16 +1,4 @@
 "use strict";
-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 __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 _Listener_instances, _Listener_socket, _Listener_callers, _Listener_routes, _Listener_subscriber, _Listener_publisher, _Listener_getJoinCb, _Listener_emit, _Listener_setupSocketConnection;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Listener = void 0;
 const path_to_regexp_1 = require("path-to-regexp");
@@ -25,118 +13,118 @@ var EmitTypes;
 })(EmitTypes || (EmitTypes = {}));
 const EmitterEvent = '__listener_emitter';
 class Listener {
+    #socket;
+    #callers;
+    #routes = {};
+    #subscriber = instance_1.Instance.get().eventBus.createSubscriber(EmitterEvent, async (data) => {
+        this.#socket.to(data.channel).emit(data.channel, data);
+    }, { fanout: true });
+    #publisher = instance_1.Instance.get().eventBus.createPublisher(EmitterEvent);
     constructor(socket, callers) {
-        _Listener_instances.add(this);
-        _Listener_socket.set(this, void 0);
-        _Listener_callers.set(this, void 0);
-        _Listener_routes.set(this, {});
-        _Listener_subscriber.set(this, instance_1.Instance.get().eventBus.createSubscriber(EmitterEvent, async (data) => {
-            __classPrivateFieldGet(this, _Listener_socket, "f").to(data.channel).emit(data.channel, data);
-        }, { fanout: true }));
-        _Listener_publisher.set(this, instance_1.Instance.get().eventBus.createPublisher(EmitterEvent));
-        _Listener_setupSocketConnection.set(this, () => {
-            const event = 'connection';
-            __classPrivateFieldGet(this, _Listener_socket, "f").removeAllListeners(event);
-            __classPrivateFieldGet(this, _Listener_socket, "f").on(event, async (socket) => {
-                const socketId = socket.id;
-                let user = null;
-                if (socket.handshake.auth.token)
-                    user = await (0, tokens_1.verifyAccessToken)(socket.handshake.auth.token ?? '').catch(() => null);
-                socket.on('leave', async (data, callback) => {
-                    if (!data.channel)
-                        return typeof (callback) === 'function' && callback({
-                            code: server_1.StatusCodes.ValidationError,
-                            message: 'channel is required',
-                            channel: ''
-                        });
-                    socket.leave(data.channel);
-                    return typeof (callback) === 'function' && callback({
-                        code: server_1.StatusCodes.Ok,
-                        message: '',
-                        channel: data.channel
-                    });
-                });
-                socket.on('join', async (data, callback) => {
-                    if (!data.channel)
-                        return typeof (callback) === 'function' && callback({
-                            code: server_1.StatusCodes.ValidationError,
-                            message: 'channel is required',
-                            channel: ''
-                        });
-                    const channel = data.channel;
-                    const route = __classPrivateFieldGet(this, _Listener_instances, "m", _Listener_getJoinCb).call(this, channel) ?? null;
-                    if (!route)
-                        return typeof (callback) === 'function' && callback({
-                            code: server_1.StatusCodes.BadRequest,
-                            message: 'unknown channel',
-                            channel
-                        });
-                    const newChannel = await route.onJoin({ channel, user }, route.params, data.query ?? {});
-                    if (!newChannel)
-                        return typeof (callback) === 'function' && callback({
-                            code: server_1.StatusCodes.NotAuthorized,
-                            message: 'restricted access',
-                            channel
-                        });
-                    socket.join(newChannel);
-                    return typeof (callback) === 'function' && callback({
-                        code: server_1.StatusCodes.Ok,
-                        message: '',
-                        channel: newChannel
-                    });
-                });
-                if (user)
-                    await __classPrivateFieldGet(this, _Listener_callers, "f").onConnect(user.id, socketId);
-                socket.on('disconnect', async () => {
-                    if (user)
-                        await __classPrivateFieldGet(this, _Listener_callers, "f").onDisconnect(user.id, socketId);
-                });
-            });
-        });
-        __classPrivateFieldSet(this, _Listener_socket, socket, "f");
-        __classPrivateFieldSet(this, _Listener_callers, callers, "f");
-        __classPrivateFieldGet(this, _Listener_setupSocketConnection, "f").call(this);
+        this.#socket = socket;
+        this.#callers = callers;
+        this.#setupSocketConnection();
     }
     async start() {
-        await __classPrivateFieldGet(this, _Listener_subscriber, "f").subscribe();
+        await this.#subscriber.subscribe();
     }
     async created(channels, data) {
-        await __classPrivateFieldGet(this, _Listener_instances, "m", _Listener_emit).call(this, channels, EmitTypes.created, data.toJSON());
+        await this.#emit(channels, EmitTypes.created, { after: data.toJSON(), before: null });
     }
-    async updated(channels, data) {
-        await __classPrivateFieldGet(this, _Listener_instances, "m", _Listener_emit).call(this, channels, EmitTypes.updated, data.toJSON());
+    async updated(channels, { after, before }) {
+        await this.#emit(channels, EmitTypes.updated, { after: after.toJSON(), before: before.toJSON() });
     }
     async deleted(channels, data) {
-        await __classPrivateFieldGet(this, _Listener_instances, "m", _Listener_emit).call(this, channels, EmitTypes.deleted, data.toJSON());
+        await this.#emit(channels, EmitTypes.deleted, { before: data.toJSON(), after: null });
     }
     set callers(callers) {
-        __classPrivateFieldSet(this, _Listener_callers, callers, "f");
-        __classPrivateFieldGet(this, _Listener_setupSocketConnection, "f").call(this);
+        this.#callers = callers;
+        this.#setupSocketConnection();
     }
     register(channel, onJoin) {
         if (!onJoin)
             onJoin = async ({ channel }) => channel;
-        __classPrivateFieldGet(this, _Listener_routes, "f")[channel] = onJoin;
-        __classPrivateFieldGet(this, _Listener_routes, "f")[channel + '/:id'] = onJoin;
+        this.#routes[channel] = onJoin;
+        this.#routes[channel + '/:id'] = onJoin;
         return this;
     }
+    #getJoinCb(channel) {
+        const matcher = (key) => (0, path_to_regexp_1.match)(key)(channel);
+        const matchedChannel = Object.keys(this.#routes).find(matcher) ?? null;
+        if (!matchedChannel)
+            return null;
+        const match = matcher(matchedChannel);
+        if (!match)
+            return null;
+        return {
+            onJoin: this.#routes[matchedChannel],
+            params: JSON.parse(JSON.stringify(match.params))
+        };
+    }
+    async #emit(channels, type, { before, after }) {
+        await Promise.all(channels.map(async (channel) => {
+            const emitData = { channel, type, before, after };
+            await this.#publisher.publish(emitData);
+        }));
+    }
+    #setupSocketConnection = () => {
+        const event = 'connection';
+        this.#socket.removeAllListeners(event);
+        this.#socket.on(event, async (socket) => {
+            const socketId = socket.id;
+            let user = null;
+            if (socket.handshake.auth.token)
+                user = await (0, tokens_1.verifyAccessToken)(socket.handshake.auth.token ?? '').catch(() => null);
+            socket.on('leave', async (data, callback) => {
+                if (!data.channel)
+                    return typeof (callback) === 'function' && callback({
+                        code: server_1.StatusCodes.ValidationError,
+                        message: 'channel is required',
+                        channel: ''
+                    });
+                socket.leave(data.channel);
+                return typeof (callback) === 'function' && callback({
+                    code: server_1.StatusCodes.Ok,
+                    message: '',
+                    channel: data.channel
+                });
+            });
+            socket.on('join', async (data, callback) => {
+                if (!data.channel)
+                    return typeof (callback) === 'function' && callback({
+                        code: server_1.StatusCodes.ValidationError,
+                        message: 'channel is required',
+                        channel: ''
+                    });
+                const channel = data.channel;
+                const route = this.#getJoinCb(channel) ?? null;
+                if (!route)
+                    return typeof (callback) === 'function' && callback({
+                        code: server_1.StatusCodes.BadRequest,
+                        message: 'unknown channel',
+                        channel
+                    });
+                const newChannel = await route.onJoin({ channel, user }, route.params, data.query ?? {});
+                if (!newChannel)
+                    return typeof (callback) === 'function' && callback({
+                        code: server_1.StatusCodes.NotAuthorized,
+                        message: 'restricted access',
+                        channel
+                    });
+                socket.join(newChannel);
+                return typeof (callback) === 'function' && callback({
+                    code: server_1.StatusCodes.Ok,
+                    message: '',
+                    channel: newChannel
+                });
+            });
+            if (user)
+                await this.#callers.onConnect(user.id, socketId);
+            socket.on('disconnect', async () => {
+                if (user)
+                    await this.#callers.onDisconnect(user.id, socketId);
+            });
+        });
+    };
 }
 exports.Listener = Listener;
-_Listener_socket = new WeakMap(), _Listener_callers = new WeakMap(), _Listener_routes = new WeakMap(), _Listener_subscriber = new WeakMap(), _Listener_publisher = new WeakMap(), _Listener_setupSocketConnection = new WeakMap(), _Listener_instances = new WeakSet(), _Listener_getJoinCb = function _Listener_getJoinCb(channel) {
-    const matcher = (key) => (0, path_to_regexp_1.match)(key, { encode: encodeURI, decode: decodeURIComponent })(channel);
-    const matchedChannel = Object.keys(__classPrivateFieldGet(this, _Listener_routes, "f")).find(matcher) ?? null;
-    if (!matchedChannel)
-        return null;
-    const match = matcher(matchedChannel);
-    if (!match)
-        return null;
-    return {
-        onJoin: __classPrivateFieldGet(this, _Listener_routes, "f")[matchedChannel],
-        params: JSON.parse(JSON.stringify(match.params))
-    };
-}, _Listener_emit = async function _Listener_emit(channels, type, data) {
-    await Promise.all(channels.map(async (channel) => {
-        const emitData = { channel, type, data };
-        await __classPrivateFieldGet(this, _Listener_publisher, "f").publish(emitData);
-    }));
-};

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

@@ -1,6 +1,7 @@
 import { Options } from 'ts-oas';
+import type { CompilerOptions } from 'typescript';
 import { RouteSchema } from '../server';
 export declare function generateJSONSchema(patterns: (string | RegExp)[], paths: string[], options?: {
-    tsConfigPath?: string | Record<string, unknown>;
+    tsConfig?: string | CompilerOptions;
     options?: Options;
 }): Record<string, RouteSchema>;

package/lib/scripts/json-schema.js

@@ -23,16 +23,30 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateJSONSchema = void 0;
+exports.generateJSONSchema = generateJSONSchema;
 const ts_oas_1 = __importStar(require("ts-oas"));
 const instance_1 = require("../instance");
-const fileSchema = { type: 'string', format: 'binary' };
+const server_1 = require("../server");
+const statusCodes = Object.entries(server_1.StatusCodes);
+const fileSchema = { type: 'string', format: 'binary', example: 'uploaded binary file' };
+function isFile(schema) {
+    return schema.type === 'string' && schema.enum?.at(0) === 'equipped-file-schema';
+}
 function generateJSONSchema(patterns, paths, options) {
-    const tsProgram = (0, ts_oas_1.createProgram)(paths, options?.tsConfigPath);
+    const tsProgram = (0, ts_oas_1.createProgram)(paths, options?.tsConfig);
     const logger = instance_1.Instance.createLogger();
     const tsoas = new ts_oas_1.default(tsProgram, {
         ref: false,
         nullableKeyword: false,
+        schemaProcessor: (schema) => {
+            if (isFile(schema))
+                return fileSchema;
+            if (schema.anyOf)
+                schema.anyOf = schema.anyOf.map((s) => isFile(s) ? fileSchema : s);
+            if (schema.allOf)
+                schema.allOf = schema.allOf.map((s) => isFile(s) ? fileSchema : s);
+            return schema;
+        },
         ...(options?.options ?? {})
     });
     const jsonSchema = tsoas.getSchemas(patterns);
@@ -40,34 +54,28 @@ function generateJSONSchema(patterns, paths, options) {
         .map(([name, { properties: def }]) => {
         try {
             const key = def?.key?.enum?.at(0) ?? name;
-            if (!def || !key || !def.method)
+            const isApiDef = def?.__apiDef?.type === 'boolean' && def?.__apiDef?.enum?.[0] === true;
+            const method = def?.method?.enum?.at?.(0)?.toLowerCase?.();
+            if (!def || !isApiDef || !key || !method)
                 return [undefined, undefined];
             const response = def.responses.properties ?? def.responses.anyOf?.reduce((acc, cur) => {
                 if (cur.properties)
                     return { ...acc, ...cur.properties };
                 return acc;
             }, {}) ?? undefined;
-            const body = def.body ?? {};
-            if (def.files?.properties) {
-                const files = def.files ?? {};
-                if (!body.type)
-                    body.type = 'object';
-                if (!body.properties)
-                    body.properties = {};
-                if (!body.required)
-                    body.required = [];
-                Object.entries(files.properties ?? {}).forEach(([key, value]) => {
-                    const isMultiple = !!value.enum?.at(0);
-                    body.properties[key] = isMultiple ? { type: 'array', items: fileSchema } : fileSchema;
-                    if (files.required?.includes(key))
-                        body.required.push(key);
-                });
+            if (response) {
+                for (const [key, value] of Object.entries(response)) {
+                    const status = statusCodes.find(([_, code]) => code.toString() === key);
+                    if (status)
+                        value['description'] = `${status[0]} Response`;
+                }
             }
+            const supportsBody = ['post', 'put', 'patch'].includes(method);
             const schema = {
-                body,
+                body: supportsBody ? def.body : undefined,
                 params: def.params,
                 querystring: def.query,
-                headers: def.headers,
+                headers: def.requestHeaders,
                 response,
                 operationId: key,
                 summary: name,
@@ -88,7 +96,6 @@ function generateJSONSchema(patterns, paths, options) {
         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)

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

@@ -1,6 +1,3 @@
-/// <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';
@@ -10,16 +7,30 @@ 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' | 'descriptions' | 'hideSchema' | 'onError' | 'onSetupHandler' | '__def'>> & {
+export type FullRoute = Required<Omit<Route, 'schema' | 'groups' | 'security' | 'descriptions' | 'hideSchema' | 'onError' | 'onSetupHandler' | '__def'>> & {
     schema: FastifySchema;
     onError?: Route['onError'];
 };
 type Schemas = Record<string, Defined<Route['schema']>>;
+declare module 'openapi-types' {
+    namespace OpenAPIV3 {
+        interface Document {
+            'x-tagGroups': {
+                name: string;
+                tags: string[];
+            }[];
+        }
+        interface TagObject {
+            'x-displayName': string;
+        }
+    }
+}
 export declare abstract class Server<Req = any, Res = any> {
     #private;
     protected server: http.Server;
     protected staticPath: string;
     protected settings: import("../../instance/settings").Settings;
+    protected openapiJsonUrl: string;
     protected baseOpenapiDoc: OpenAPIV3_1.Document;
     protected abstract onLoad(): Promise<void>;
     protected abstract startServer(port: number): Promise<boolean>;
@@ -27,10 +38,10 @@ export declare abstract class Server<Req = any, Res = any> {
     protected abstract registerRoute(route: FullRoute): void;
     constructor(server: http.Server);
     get listener(): Listener;
-    addRoutes(routes: Route[]): void;
-    addSchema(schemas: Schemas): void;
+    addRouter(...routers: Router[]): void;
+    addRoute(...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>;
 }