vovk 3.0.0-draft.33 → 3.0.0-draft.331

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/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;
+            openapi?: import("openapi3-ts/oas31").OperationObject;
+            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,170 @@
+"use strict";
+/*
+Function "multitenant" accepts an object with "requestUrl", "requestHost", "targetHost" and "overrides" properties.
+The requestHost parameter comes from request headers and should be used instead of the hostname in the requestUrl.
+The keys in overrides are subdomains relative to the "targetHost". They can include a dot to indicate lower-level
+subdomains, and can use square brackets to indicate wildcard values. The values are arrays of objects with "from"
+and "to" properties, which are strings indicating the override paths for Next.js.
+
+If a path matches a specific subdomain name (e.g., "/admin" matches the "admin" subdomain),
+the request will be redirected to that specific subdomain instead of being processed on the current subdomain.
+
+If a path ends with "_schema_", it will not be processed by any overrides and will be passed through as-is.
+
+Example:
+
+const { action, destination, message, subdomains } = multitenant({
+  requestUrl: request.url,
+  requestHost: request.headers.get('host'),
+  targetHost: "localhost:3000",
+  overrides: {
+    "[customer_name].customer": [
+      { from: "api", to: "api/customer" }, // API
+      { from: "", to: "[customer_name]" } // UI
+    ],
+    "pro.[customer_name].customer": [
+        { from: "api", to: "api/customer/pro" }, // API
+        { from: "", to: "pro/[customer_name]" } // UI
+    ],
+    "admin": [
+      { from: "api", to: "api/admin" }, // API
+      { from: "", to: "admin" } // UI
+    ],
+  },
+});
+
+subdomains is a Record<string, string> | null where keys are subdomain names and values are their corresponding values. If non-wildcard subdomains are used, should be equal to null.
+action is one of "rewrite", "redirect", "notfound", or null.
+message is a string describing the action taken
+destination is a string URL to redirect or rewrite to, or null if no action is taken or "notfound"
+*/
+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/{utils → cjs/utils}/reqForm.d.ts

@@ -1,3 +1,2 @@
-import { VovkRequest } from 'vovk';
-import { _KnownAny as KnownAny } from '../types';
+import type { KnownAny, VovkRequest } from '../types';
 export default function reqForm<T = KnownAny>(req: VovkRequest<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/{utils → cjs/utils}/reqMeta.d.ts

@@ -1,3 +1,2 @@
-import { VovkRequest } from 'vovk';
-import { _KnownAny as KnownAny } from '../types';
+import type { KnownAny, VovkRequest } from '../types';
 export default function reqMeta<T = Record<KnownAny, KnownAny>>(req: VovkRequest<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);
+}

package/cjs/utils/serializeQuery.d.ts

@@ -0,0 +1,13 @@
+import type { KnownAny } from '../types';
+/**
+ * Serialize a nested object (including arrays, arrays of objects, etc.)
+ * into a bracket-based query string.
+ *
+ * @example
+ *   serializeQuery({ x: 'xx', y: [1, 2], z: { f: 'x' } })
+ *   => "x=xx&y[0]=1&y[1]=2&z[f]=x"
+ *
+ * @param obj - The input object to be serialized
+ * @returns   - A bracket-based query string (without leading "?")
+ */
+export default function serializeQuery(obj: Record<string, KnownAny>): string;