vovk 3.4.1 → 3.5.0

package/dist/createVovkApp.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVovkApp = createVovkApp;
+const VovkApp_1 = require("./VovkApp");
+const types_1 = require("./types");
+const getSchema_1 = __importDefault(require("./utils/getSchema"));
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const isClass = (func) => typeof func === 'function' && /class/.test(func.toString());
+const toKebabCase = (str) => str
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2') // Add hyphen between lowercase/digit and uppercase
+    .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1-$2') // Add hyphen between uppercase letters if the second one is followed by a lowercase
+    .toLowerCase()
+    .replace(/^-/, ''); // Remove leading hyphen
+const assignSchema = ({ controller, propertyKey, path, options, httpMethod, vovkApp, }) => {
+    if (typeof window !== 'undefined') {
+        throw new Error('Decorators are intended for server-side use only. You have probably imported a controller on the client-side.');
+    }
+    if (!isClass(controller)) {
+        let decoratorName = httpMethod.toLowerCase();
+        if (decoratorName === 'delete')
+            decoratorName = 'del';
+        throw new Error(`Decorator must be used on a static class method. Check the controller method named "${propertyKey}" used with @${decoratorName}().`);
+    }
+    const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+    vovkApp.routes[httpMethod].set(controller, methods);
+    const originalMethod = controller[propertyKey];
+    originalMethod._controller = controller;
+    originalMethod._sourceMethod = originalMethod._sourceMethod ?? originalMethod;
+    const schema = originalMethod._sourceMethod._getSchema?.(controller);
+    controller._handlers = {
+        ...controller._handlers,
+        [propertyKey]: {
+            ...schema,
+            ...(controller._handlers ?? {})[propertyKey],
+            path,
+            httpMethod,
+        },
+    };
+    methods[path] = controller[propertyKey];
+    methods[path]._options = options;
+    controller._handlersMetadata = {
+        ...controller._handlersMetadata,
+        [propertyKey]: {
+            ...(controller._handlersMetadata ?? {})[propertyKey],
+            staticParams: options?.staticParams,
+        },
+    };
+};
+function createVovkApp() {
+    const vovkApp = new VovkApp_1.VovkApp();
+    const createHTTPDecorator = (httpMethod) => {
+        function decoratorCreator(givenPath = '', options) {
+            const path = trimPath(givenPath);
+            function decorator(givenTarget, propertyKey) {
+                const controller = givenTarget;
+                assignSchema({ controller, propertyKey, path, options, httpMethod, vovkApp });
+            }
+            return decorator;
+        }
+        const auto = (options) => {
+            function decorator(givenTarget, propertyKey) {
+                const controller = givenTarget;
+                const methods = vovkApp.routes[httpMethod].get(controller) ?? {};
+                vovkApp.routes[httpMethod].set(controller, methods);
+                controller._handlers = {
+                    ...controller._handlers,
+                    [propertyKey]: {
+                        ...(controller._handlers ?? {})[propertyKey],
+                        httpMethod,
+                    },
+                };
+                const properties = Object.keys(controller._handlers[propertyKey]?.validation?.params?.properties ?? {});
+                const kebab = toKebabCase(propertyKey); // 🥙
+                const path = properties.length ? `${kebab}/${properties.map((prop) => `:${prop}`).join('/')}` : kebab;
+                assignSchema({ controller, propertyKey, path, options, httpMethod, vovkApp });
+            }
+            return decorator;
+        };
+        const enhancedDecoratorCreator = decoratorCreator;
+        enhancedDecoratorCreator.auto = auto;
+        return enhancedDecoratorCreator;
+    };
+    const prefix = (givenPath = '') => {
+        const path = trimPath(givenPath);
+        return (givenTarget) => {
+            const controller = givenTarget;
+            controller._prefix = path;
+            return givenTarget;
+        };
+    };
+    const initVovk = (options) => {
+        for (const [rpcModuleName, controller] of Object.entries(options.controllers)) {
+            controller._rpcModuleName = rpcModuleName;
+            controller._activated = true;
+            controller._onError = options?.onError;
+        }
+        async function GET_DEV(req, data) {
+            const params = await data.params;
+            if (params[Object.keys(params)[0]]?.[0] === '_schema_') {
+                const schema = (0, getSchema_1.default)(options);
+                return vovkApp.respond(200, { schema });
+            }
+            return vovkApp.GET(req, data);
+        }
+        return {
+            GET: process.env.NODE_ENV === 'development' ? GET_DEV : vovkApp.GET,
+            POST: vovkApp.POST,
+            PUT: vovkApp.PUT,
+            PATCH: vovkApp.PATCH,
+            DELETE: vovkApp.DELETE,
+            HEAD: vovkApp.HEAD,
+            OPTIONS: vovkApp.OPTIONS,
+        };
+    };
+    return {
+        get: createHTTPDecorator(types_1.HttpMethod.GET),
+        post: createHTTPDecorator(types_1.HttpMethod.POST),
+        put: createHTTPDecorator(types_1.HttpMethod.PUT),
+        patch: createHTTPDecorator(types_1.HttpMethod.PATCH),
+        del: createHTTPDecorator(types_1.HttpMethod.DELETE),
+        head: createHTTPDecorator(types_1.HttpMethod.HEAD),
+        options: createHTTPDecorator(types_1.HttpMethod.OPTIONS),
+        prefix,
+        initVovk,
+    };
+}

package/dist/openapi/openAPIToVovkSchema/index.d.ts

@@ -1,5 +1,5 @@
 import type { VovkSchema } from '../../types/core.js';
 import type { VovkOpenAPIMixinNormalized } from '../../types/config.js';
-export declare function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }, getModuleName, getMethodName, errorMessageKey, segmentName, }: VovkOpenAPIMixinNormalized & {
+export declare function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }, getModuleName, getMethodName, filterOperations, pruneComponents, errorMessageKey, segmentName, }: VovkOpenAPIMixinNormalized & {
     segmentName?: string;
 }): VovkSchema;

package/dist/openapi/openAPIToVovkSchema/index.js

@@ -1,5 +1,6 @@
 import { applyComponentsSchemas } from './applyComponentsSchemas.js';
 import { inlineRefs } from './inlineRefs.js';
+import { pruneComponentsSchemas } from './pruneComponentsSchemas.js';
 import { VovkSchemaIdEnum } from '../../types/enums.js';
 import { schemaToTsType } from '../../samples/schemaToTsType.js';
 function getTsTypeString(contentType, schema) {
@@ -19,7 +20,7 @@ function getTsTypeString(contentType, schema) {
     }));
     return [...tsTypes].join(' | ') || schemaToTsType(schema);
 }
-export function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }, getModuleName, getMethodName, errorMessageKey, segmentName, }) {
+export function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }, getModuleName, getMethodName, filterOperations, pruneComponents, errorMessageKey, segmentName, }) {
     segmentName = segmentName ?? '';
     const forceApiRoot = apiRoot ||
         (openAPIObject.servers?.[0]?.url ??
@@ -47,10 +48,19 @@ export function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }
         },
     };
     const segment = schema.segments[segmentName];
-    return Object.entries(paths ?? {}).reduce((acc, [path, operations]) => {
+    Object.entries(paths ?? {}).forEach(([path, operations]) => {
         Object.entries(operations ?? {})
             .filter(([, operation]) => operation && typeof operation === 'object')
             .forEach(([method, operation]) => {
+            if (filterOperations &&
+                !filterOperations({
+                    method: method.toUpperCase(),
+                    path,
+                    openAPIObject,
+                    operationObject: operation,
+                })) {
+                return;
+            }
             const rpcModuleName = getModuleName({
                 method: method.toUpperCase(),
                 path,
@@ -149,6 +159,21 @@ export function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }
                 },
             };
         });
-        return acc;
-    }, schema);
+    });
+    if (pruneComponents && noPathsOpenAPIObject.components?.schemas) {
+        // Reassign with fresh objects only — `noPathsOpenAPIObject` shares references with the
+        // caller's spec, so the original `components.schemas` must stay untouched. Walking the
+        // whole controllers tree (validation slots + raw operation objects) keeps every `$ref`
+        // a kept handler carries resolvable against the pruned meta.
+        segment.meta = {
+            openAPIObject: {
+                ...noPathsOpenAPIObject,
+                components: {
+                    ...noPathsOpenAPIObject.components,
+                    schemas: pruneComponentsSchemas(segment.controllers, noPathsOpenAPIObject.components.schemas),
+                },
+            },
+        };
+    }
+    return schema;
 }

package/dist/openapi/openAPIToVovkSchema/pruneComponentsSchemas.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentsObject } from 'openapi3-ts/oas31';
+/**
+ * Shrinks a `components.schemas` dict to the transitive `$ref` closure of `roots`
+ * (BFS with a visited set — component graphs of large specs like Stripe are cyclic).
+ * Preserves the original key order for deterministic output.
+ */
+export declare function pruneComponentsSchemas(roots: unknown, componentsSchemas: NonNullable<ComponentsObject['schemas']>): NonNullable<ComponentsObject['schemas']>;

package/dist/openapi/openAPIToVovkSchema/pruneComponentsSchemas.js

@@ -0,0 +1,51 @@
+// Collect the trailing name of every `$ref` in the tree. Covers both pointer styles
+// the transform emits: `#/components/schemas/X` (response slots, raw operation objects)
+// and `#/$defs/X` (request slots embed components under their original names).
+function collectRefNames(node, into) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            collectRefNames(item, into);
+        }
+        return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (key === '$ref' && typeof value === 'string') {
+            const name = value.split('/').pop();
+            if (name)
+                into.add(name);
+        }
+        else {
+            collectRefNames(value, into);
+        }
+    }
+}
+/**
+ * Shrinks a `components.schemas` dict to the transitive `$ref` closure of `roots`
+ * (BFS with a visited set — component graphs of large specs like Stripe are cyclic).
+ * Preserves the original key order for deterministic output.
+ */
+export function pruneComponentsSchemas(roots, componentsSchemas) {
+    const required = new Set();
+    collectRefNames(roots, required);
+    const queue = [...required];
+    const visited = new Set();
+    while (queue.length) {
+        const name = queue.pop();
+        if (!name || visited.has(name))
+            continue;
+        visited.add(name);
+        const component = componentsSchemas[name];
+        if (!component)
+            continue;
+        const refs = new Set();
+        collectRefNames(component, refs);
+        for (const ref of refs) {
+            required.add(ref);
+            if (!visited.has(ref))
+                queue.push(ref);
+        }
+    }
+    return Object.fromEntries(Object.entries(componentsSchemas).filter(([name]) => required.has(name)));
+}