vovk 3.0.0-draft.46 → 3.0.0-draft.460

package/cjs/utils/getJSONSchemaSample.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSONSchemaSample = getJSONSchemaSample;
+function getJSONSchemaSample(schema, rootSchema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    // Use the input schema as the root if not provided
+    rootSchema = rootSchema || schema;
+    // If there's an example, use it
+    if (schema.example !== undefined) {
+        return schema.example;
+    }
+    // If there are examples, use one of them
+    if (schema.examples && schema.examples.length > 0) {
+        return schema.examples[0];
+    }
+    // Handle const if present
+    if (schema.const !== undefined) {
+        return schema.const;
+    }
+    // Handle $ref if present
+    if (schema.$ref) {
+        return handleRef(schema.$ref, rootSchema);
+    }
+    // Handle enum if present
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum[0];
+    }
+    // Handle oneOf, anyOf, allOf
+    if (schema.oneOf && schema.oneOf.length > 0) {
+        return getJSONSchemaSample(schema.oneOf[0], rootSchema);
+    }
+    if (schema.anyOf && schema.anyOf.length > 0) {
+        return getJSONSchemaSample(schema.anyOf[0], rootSchema);
+    }
+    if (schema.allOf && schema.allOf.length > 0) {
+        // Merge all schemas in allOf
+        const mergedSchema = schema.allOf.reduce((acc, s) => ({ ...acc, ...s }), {});
+        return getJSONSchemaSample(mergedSchema, rootSchema);
+    }
+    // Handle different types
+    if (schema.type) {
+        switch (schema.type) {
+            case 'string':
+                return handleString(schema);
+            case 'number':
+            case 'integer':
+                return handleNumber(schema);
+            case 'boolean':
+                return handleBoolean();
+            case 'object':
+                return handleObject(schema, rootSchema);
+            case 'array':
+                return handleArray(schema, rootSchema);
+            case 'null':
+                return null;
+            default:
+                return null;
+        }
+    }
+    // If type is not specified but properties are, treat it as an object
+    if (schema.properties) {
+        return handleObject(schema, rootSchema);
+    }
+    // Default fallback
+    return null;
+}
+function handleRef(ref, rootSchema) {
+    // Parse the reference path
+    const path = ref.split('/').slice(1); // Remove the initial '#'
+    // Navigate through the schema to find the referenced definition
+    let current = rootSchema;
+    for (const segment of path) {
+        current = current[segment];
+        if (current === undefined) {
+            return null; // Reference not found
+        }
+    }
+    // Process the referenced schema
+    return getJSONSchemaSample(current, rootSchema);
+}
+function handleString(schema) {
+    if (schema.format) {
+        switch (schema.format) {
+            case 'email':
+            case 'idn-email':
+                return 'user@example.com';
+            case 'uri':
+            case 'url':
+            case 'iri':
+                return 'https://example.com';
+            case 'date':
+                return '2023-01-01';
+            case 'date-time':
+                return '2023-01-01T00:00:00Z';
+            case 'time':
+                return '12:00:00Z';
+            case 'duration':
+                return 'PT1H';
+            case 'uuid':
+                return '00000000-0000-0000-0000-000000000000';
+            case 'regex':
+                return '^[a-zA-Z0-9]+$';
+            case 'relative-json-pointer':
+                return '/some/relative/path';
+            case 'color':
+                return '#000000';
+            case 'hostname':
+                return 'example.com';
+            case 'zipcode':
+                return '12345';
+            case 'phone':
+                return '+123-456-7890';
+            case 'password':
+                return '******';
+            default:
+                return 'string';
+        }
+    }
+    if (schema.pattern) {
+        // For simplicity, return a basic string for patterns
+        return 'pattern-string';
+    }
+    return 'string';
+}
+function handleNumber(schema) {
+    if (schema.minimum !== undefined && schema.maximum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.minimum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.maximum !== undefined) {
+        return schema.maximum;
+    }
+    return 0;
+}
+function handleBoolean() {
+    return true;
+}
+function handleObject(schema, rootSchema) {
+    const result = {};
+    if (schema.properties) {
+        const required = schema.required || [];
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+            // Only include required properties or as a basic example
+            if (required.includes(key) || required.length === 0) {
+                result[key] = getJSONSchemaSample(propSchema, rootSchema);
+            }
+        }
+    }
+    // Handle additionalProperties
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        result['additionalProp'] = getJSONSchemaSample(schema.additionalProperties, rootSchema);
+    }
+    return result;
+}
+function handleArray(schema, rootSchema) {
+    if (schema.items) {
+        const itemSchema = schema.items;
+        const minItems = schema.minItems || 1;
+        // Create minimum number of items (capped at a reasonable max for examples)
+        const numItems = Math.min(minItems, 3);
+        return Array.from({ length: numItems }, () => getJSONSchemaSample(itemSchema, rootSchema));
+    }
+    return [];
+}

package/cjs/utils/getSampleFromObject.d.ts

@@ -0,0 +1,9 @@
+import { KnownAny } from '../types';
+interface SamplerOptions {
+    stripQuotes?: boolean;
+    indent?: number;
+    nestingIndent?: number;
+    quote?: '"' | "'";
+}
+export declare function getSampleFromObject(obj: KnownAny, options?: SamplerOptions): string;
+export {};

package/cjs/utils/getSampleFromObject.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSampleFromObject = getSampleFromObject;
+function getSampleFromObject(obj, options) {
+    const { stripQuotes = false, indent = 0, nestingIndent = 2, quote = '"' } = options || {};
+    // Use JSON.stringify with the nesting indent
+    let result = JSON.stringify(obj, null, nestingIndent);
+    // Replace double quotes with single quotes for string values if requested
+    if (quote === "'") {
+        // First, escape any existing single quotes in string values
+        result = result.replace(/"([^"]*)"/g, (match, content) => {
+            // Check if this is a key (followed by colon) or a value
+            const matchIndex = result.indexOf(match);
+            const afterMatch = result.substring(matchIndex + match.length);
+            if (afterMatch.startsWith(':')) {
+                // This is a key, keep it for now
+                return match;
+            }
+            // This is a value, replace quotes and escape single quotes
+            const escaped = content.replace(/'/g, "\\'");
+            return `'${escaped}'`;
+        });
+    }
+    // Strip quotes from keys if requested
+    if (stripQuotes) {
+        // Remove quotes from keys that are valid JavaScript identifiers
+        // Keep quotes for keys with special characters (like 'x-foo', spaces, etc.)
+        const keyQuote = quote === "'" ? "'" : '"';
+        const pattern = new RegExp(`${keyQuote}([a-zA-Z_$][a-zA-Z0-9_$]*)${keyQuote}:`, 'g');
+        result = result.replace(pattern, '$1:');
+    }
+    // Apply base indentation if specified
+    if (indent > 0) {
+        const indentStr = ' '.repeat(indent);
+        result = result
+            .split('\n')
+            .map((line, i) => (i === 0 ? line : indentStr + line))
+            .join('\n');
+    }
+    return result;
+}

package/cjs/utils/getSchema.d.ts

@@ -0,0 +1,21 @@
+import { type VovkSegmentSchema, type VovkController, type StaticClass } from '../types';
+export declare function getControllerSchema(controller: VovkController, rpcModuleName: string, exposeValidation: boolean): Promise<{
+    rpcModuleName: string;
+    originalControllerName: string;
+    prefix: string;
+    handlers: {
+        [k: string]: {
+            path: string;
+            httpMethod: string;
+            operationObject?: import("../types").VovkOperationObject;
+            misc?: Record<string, import("../types").KnownAny>;
+        };
+    };
+}>;
+export default function getSchema(options: {
+    emitSchema?: boolean;
+    segmentName?: string;
+    controllers: Record<string, StaticClass>;
+    exposeValidation?: boolean;
+    forceApiRoot?: string;
+}): Promise<VovkSegmentSchema>;

package/cjs/utils/getSchema.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getControllerSchema = getControllerSchema;
+exports.default = getSchema;
+const types_1 = require("../types");
+async function getControllerSchema(controller, rpcModuleName, exposeValidation) {
+    const handlers = exposeValidation
+        ? (controller._handlers ?? {})
+        : Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Object.entries(controller._handlers ?? {}).map(([key, { validation: _v, ...value }]) => [key, value]));
+    return {
+        rpcModuleName,
+        originalControllerName: controller.name,
+        prefix: controller._prefix ?? '',
+        handlers,
+    };
+}
+async function getSchema(options) {
+    const exposeValidation = options?.exposeValidation ?? true;
+    const emitSchema = options.emitSchema ?? true;
+    const schema = {
+        $schema: types_1.VovkSchemaIdEnum.SEGMENT,
+        emitSchema,
+        segmentName: options.segmentName ?? '',
+        segmentType: 'segment',
+        controllers: {},
+    };
+    if (options.forceApiRoot) {
+        schema.forceApiRoot = options.forceApiRoot;
+    }
+    if (!emitSchema)
+        return schema;
+    for (const [rpcModuleName, controller] of Object.entries(options.controllers ?? {})) {
+        schema.controllers[rpcModuleName] = await getControllerSchema(controller, rpcModuleName, exposeValidation);
+    }
+    return schema;
+}

package/cjs/utils/multitenant.d.ts

@@ -0,0 +1,24 @@
+type Override = {
+    from: string;
+    to: string;
+};
+type Config = {
+    requestUrl: string;
+    requestHost: string;
+    targetHost: string;
+    overrides: {
+        [key: string]: Override[];
+    };
+};
+export declare function multitenant(config: Config): {
+    action: null;
+    destination: null;
+    message: string;
+    subdomains: null;
+} | {
+    action: string;
+    destination: string;
+    message: string;
+    subdomains: Record<string, string> | null;
+};
+export {};

package/cjs/utils/multitenant.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multitenant = multitenant;
+// Get the reserved paths from the overrides configuration
+const getReservedPaths = (overrides) => {
+    return Object.keys(overrides).filter((key) => !key.includes('[') && !key.includes(']')); // Filter out dynamic paths
+};
+/**
+ * Convert a pattern with [placeholders] to a regex pattern and extract placeholder names
+ */
+const patternToRegex = (pattern) => {
+    const paramNames = [];
+    const regexPattern = pattern
+        .replace(/\[([^\]]+)\]/g, (_, name) => {
+        paramNames.push(name);
+        return '([^.]+)';
+    })
+        .replace(/\./g, '\\.'); // Escape dots in the pattern
+    return {
+        regex: new RegExp(`^${regexPattern}$`),
+        paramNames,
+    };
+};
+function multitenant(config) {
+    const { requestUrl, requestHost, targetHost, overrides } = config;
+    // Parse the URL
+    const urlObj = new URL(requestUrl);
+    const pathname = urlObj.pathname.slice(1); // Remove leading slash
+    // Skip processing for paths ending with "_schema_"
+    if (pathname.endsWith('_schema_')) {
+        return {
+            action: null,
+            destination: null,
+            message: 'Schema endpoint, bypassing overrides',
+            subdomains: null,
+        };
+    }
+    const pathSegments = pathname.split('/').filter(Boolean);
+    // Get reserved paths
+    const reservedPaths = getReservedPaths(overrides);
+    // Check if any path segment matches a reserved path (e.g., "admin")
+    for (let i = 0; i < pathSegments.length; i++) {
+        const segment = pathSegments[i];
+        if (reservedPaths.includes(segment)) {
+            // Create the destination URL with the reserved path as subdomain
+            const destinationHost = `${segment}.${targetHost}`;
+            // Keep path segments before the reserved path
+            const beforeSegments = pathSegments.slice(0, i);
+            // Keep path segments after the reserved path
+            const afterSegments = pathSegments.slice(i + 1);
+            // Construct the new path
+            const newPath = [...beforeSegments, ...afterSegments].join('/');
+            const destinationUrl = new URL(`${urlObj.protocol}//${destinationHost}`);
+            if (newPath) {
+                destinationUrl.pathname = `/${newPath}`;
+            }
+            // Keep any query parameters
+            destinationUrl.search = urlObj.search;
+            return {
+                action: 'redirect',
+                destination: destinationUrl.toString(),
+                message: `Redirecting to ${segment} subdomain`,
+                subdomains: null, // No wildcards used
+            };
+        }
+    }
+    // Process based on host and subdomains
+    for (const pattern in overrides) {
+        const fullPattern = `${pattern}.${targetHost}`;
+        const { regex, paramNames } = patternToRegex(fullPattern);
+        const match = requestHost.match(regex);
+        if (match) {
+            const overrideRules = overrides[pattern];
+            // Extract parameters from the match
+            const params = {};
+            if (match.length > 1) {
+                for (let i = 0; i < paramNames.length; i++) {
+                    params[paramNames[i]] = match[i + 1];
+                }
+            }
+            // Find the appropriate rule based on the path
+            for (const rule of overrideRules) {
+                if (pathname === rule.from || pathname.startsWith(`${rule.from}/`)) {
+                    // Replace path with the destination
+                    let destination = pathname.replace(rule.from, rule.to);
+                    // Replace any dynamic parameters in destination
+                    if (Object.keys(params).length > 0) {
+                        Object.entries(params).forEach(([key, value]) => {
+                            destination = destination.replace(`[${key}]`, value);
+                        });
+                    }
+                    // Only return non-null subdomains if we have wildcard parameters
+                    const wildcardSubdomains = paramNames.length > 0 ? params : null;
+                    return {
+                        action: 'rewrite',
+                        destination: `${urlObj.protocol}//${urlObj.host}/${destination}${urlObj.search}`,
+                        message: `Rewriting to ${destination}`,
+                        subdomains: wildcardSubdomains,
+                    };
+                }
+            }
+        }
+    }
+    // Handle cases where a customer subdomain tries to access reserved paths
+    if (pathSegments.length > 0 && reservedPaths.includes(pathSegments[0])) {
+        const reservedPath = pathSegments[0];
+        const restPath = pathSegments.slice(1).join('/');
+        // Create the destination URL with the reserved path as subdomain
+        const destinationHost = `${reservedPath}.${targetHost}`;
+        const destinationUrl = new URL(`${urlObj.protocol}//${destinationHost}`);
+        // Only add remaining path segments if they exist
+        if (restPath) {
+            destinationUrl.pathname = `/${restPath}`;
+        }
+        // Keep any query parameters
+        destinationUrl.search = urlObj.search;
+        return {
+            action: 'redirect',
+            destination: destinationUrl.toString(),
+            message: `Redirecting to ${reservedPath} subdomain`,
+            subdomains: null, // No wildcards used for reserved paths
+        };
+    }
+    // Default case - pass through
+    return {
+        action: null,
+        destination: null,
+        message: 'No action',
+        subdomains: null, // No wildcards matched
+    };
+}

package/cjs/utils/parseQuery.d.ts

@@ -0,0 +1,25 @@
+import type { KnownAny } from '../types';
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+export default function parseQuery(queryString: string): Record<string, KnownAny>;

package/cjs/utils/parseQuery.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseQuery;
+/**
+ * Parse a bracket-based key (e.g. "z[d][0][x]" or "arr[]")
+ * into an array of path segments (strings or special push-markers).
+ *
+ * Example: "z[d][0][x]" => ["z", "d", "0", "x"]
+ * Example: "arr[]"      => ["arr", "" ]  // "" indicates "push" onto array
+ */
+function parseKey(key) {
+    // The first segment is everything up to the first '[' (or the entire key if no '[')
+    const segments = [];
+    const topKeyMatch = key.match(/^([^[\]]+)/);
+    if (topKeyMatch) {
+        segments.push(topKeyMatch[1]);
+    }
+    else {
+        // If it starts with brackets, treat it as empty? (edge case)
+        segments.push('');
+    }
+    // Now capture all bracket parts: [something], [0], []
+    const bracketRegex = /\[([^[\]]*)\]/g;
+    let match;
+    while ((match = bracketRegex.exec(key)) !== null) {
+        // match[1] is the content inside the brackets
+        segments.push(match[1]);
+    }
+    return segments;
+}
+/**
+ * Recursively set a value in a nested object/array, given a path of segments.
+ * - If segment is numeric => treat as array index
+ * - If segment is empty "" => push to array
+ * - Else => object property
+ */
+function setValue(obj, path, value) {
+    let current = obj;
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        // If we're at the last segment, set the value
+        if (i === path.length - 1) {
+            if (segment === '') {
+                // Empty bracket => push
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                current.push(value);
+            }
+            else if (!isNaN(Number(segment))) {
+                // Numeric segment => array index
+                const idx = Number(segment);
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                current[idx] = value;
+            }
+            else {
+                // Object property
+                current[segment] = value;
+            }
+        }
+        else {
+            // Not the last segment: descend into existing structure or create it
+            const nextSegment = path[i + 1];
+            if (segment === '') {
+                // Empty bracket => push
+                if (!Array.isArray(current)) {
+                    // Convert the current node into an array, if not one
+                    current = [];
+                }
+                // If we are not at the last path, we need a placeholder object or array
+                // for the next segment. We'll push something and move current to that.
+                if (current.length === 0) {
+                    // nothing in array yet
+                    current.push(typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {});
+                }
+                else if (typeof nextSegment === 'string' && !isNaN(Number(nextSegment))) {
+                    // next is numeric => we want an array
+                    if (!Array.isArray(current[current.length - 1])) {
+                        current[current.length - 1] = [];
+                    }
+                }
+                else {
+                    // next is not numeric => we want an object
+                    if (typeof current[current.length - 1] !== 'object') {
+                        current[current.length - 1] = {};
+                    }
+                }
+                current = current[current.length - 1];
+            }
+            else if (!isNaN(Number(segment))) {
+                // segment is numeric => array index
+                const idx = Number(segment);
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                if (current[idx] === undefined) {
+                    // Create placeholder for next segment
+                    current[idx] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+                }
+                current = current[idx];
+            }
+            else {
+                // segment is an object key
+                if (current[segment] === undefined) {
+                    // Create placeholder
+                    current[segment] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+                }
+                current = current[segment];
+            }
+        }
+    }
+}
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+function parseQuery(queryString) {
+    const result = {};
+    if (!queryString)
+        return result;
+    // Split into key=value pairs
+    const pairs = queryString
+        .replace(/^\?/, '') // Remove leading "?" if present
+        .split('&');
+    for (const pair of pairs) {
+        const [rawKey, rawVal = ''] = pair.split('=');
+        const decodedKey = decodeURIComponent(rawKey);
+        const decodedVal = decodeURIComponent(rawVal);
+        // Parse bracket notation
+        const pathSegments = parseKey(decodedKey);
+        // Insert into the result object
+        setValue(result, pathSegments, decodedVal);
+    }
+    return result;
+}

package/cjs/utils/reqForm.d.ts

@@ -0,0 +1,2 @@
+import type { KnownAny, VovkRequest } from '../types';
+export default function reqForm<T = KnownAny>(req: VovkRequest<KnownAny, KnownAny, KnownAny>): Promise<T>;

package/cjs/utils/reqForm.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reqForm;
+const formMap = new WeakMap();
+async function reqForm(req) {
+    if (formMap.has(req)) {
+        return formMap.get(req);
+    }
+    const body = await req.formData();
+    req.formData = () => Promise.resolve(body);
+    const formData = {};
+    for (const [key, value] of body.entries()) {
+        if (value instanceof File) {
+            // If this key already exists, convert to array or append to existing array
+            if (formData[key]) {
+                if (Array.isArray(formData[key])) {
+                    formData[key].push(value);
+                }
+                else {
+                    formData[key] = [formData[key], value];
+                }
+            }
+            else {
+                formData[key] = value;
+            }
+        }
+        else {
+            formData[key] = value.toString();
+        }
+    }
+    formMap.set(req, formData);
+    return formData;
+}

package/cjs/utils/reqMeta.d.ts

@@ -0,0 +1,2 @@
+import type { KnownAny, VovkRequest } from '../types';
+export default function reqMeta<T = Record<KnownAny, KnownAny>>(req: VovkRequest<KnownAny, KnownAny, KnownAny>, meta?: T | null): T;

package/cjs/utils/reqQuery.d.ts

@@ -0,0 +1,2 @@
+import type { VovkRequest } from '../types';
+export default function reqQuery<T extends object | undefined>(req: VovkRequest<unknown, T>): T;

package/cjs/utils/reqQuery.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reqQuery;
+const parseQuery_1 = __importDefault(require("./parseQuery"));
+function reqQuery(req) {
+    return (0, parseQuery_1.default)(req.nextUrl.search);
+}