vovk 3.0.0-draft.7 → 3.0.0-draft.70

package/dist/utils/generateStaticAPI.d.ts

@@ -0,0 +1,4 @@
+import type { StaticClass } from '../types';
+export declare function generateStaticAPI(c: Record<string, StaticClass>, slug?: string): {
+    [x: string]: string[];
+}[];

package/{generateStaticAPI.js → dist/utils/generateStaticAPI.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._generateStaticAPI = _generateStaticAPI;
-function _generateStaticAPI(c, slug = 'vovk') {
+exports.generateStaticAPI = generateStaticAPI;
+function generateStaticAPI(c, slug = 'vovk') {
     const controllers = c;
     return [
-        { [slug]: ['_vovk-ping_'] },
+        { [slug]: ['_schema_'] },
         ...Object.values(controllers)
             .map((controller) => {
             const handlers = controller._handlers;

package/{utils → dist/utils}/getSchema.d.ts

@@ -1,8 +1,7 @@
-import { _VovkSchema as VovkSchema, _StaticClass as StaticClass } from '../types';
+import type { VovkSchema, StaticClass } from '../types';
 export default function getSchema(options: {
     emitSchema?: boolean;
     segmentName?: string;
     controllers: Record<string, StaticClass>;
-    workers?: Record<string, StaticClass>;
     exposeValidation?: boolean;
 }): VovkSchema;

package/{utils → dist/utils}/getSchema.js

@@ -8,31 +8,20 @@ function getSchema(options) {
         emitSchema,
         segmentName: options.segmentName ?? '',
         controllers: {},
-        workers: {},
     };
     if (!emitSchema)
         return schema;
     for (const [controllerName, controller] of Object.entries(options.controllers)) {
         schema.controllers[controllerName] = {
-            _controllerName: controllerName,
-            _originalControllerName: controller.name,
-            _prefix: controller._prefix ?? '',
-            _handlers: {
+            controllerName: controllerName,
+            originalControllerName: controller.name,
+            prefix: controller._prefix ?? '',
+            handlers: {
                 ...(exposeValidation
                     ? controller._handlers
-                    : Object.fromEntries(Object.entries(controller._handlers).map(([key, value]) => [
-                        key,
-                        { ...value, clientValidators: undefined },
-                    ]))),
+                    : Object.fromEntries(Object.entries(controller._handlers ?? {}).map(([key, value]) => [key, { ...value, validation: {} }]))),
             },
         };
     }
-    for (const [workerName, worker] of Object.entries(options.workers ?? {})) {
-        schema.workers[workerName] = {
-            _workerName: workerName,
-            _originalWorkerName: worker.name,
-            _handlers: { ...worker._handlers },
-        };
-    }
     return schema;
 }

package/dist/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/dist/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/dist/utils/reqForm.d.ts

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

package/dist/utils/reqForm.js

@@ -0,0 +1,13 @@
+"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();
+    const formData = Object.fromEntries(body.entries());
+    formMap.set(req, formData);
+    return formData;
+}

package/{utils → dist/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/{utils → dist/utils}/reqQuery.d.ts

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

package/dist/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/dist/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;

package/dist/utils/serializeQuery.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = serializeQuery;
+/**
+ * Recursively build query parameters from an object.
+ *
+ * @param key      - The query key so far (e.g. 'user', 'user[0]', 'user[0][name]')
+ * @param value    - The current value to serialize
+ * @returns        - An array of `key=value` strings
+ */
+function buildParams(key, value) {
+    if (value === null || value === undefined) {
+        return []; // skip null/undefined values entirely
+    }
+    // If value is an object or array, we need to recurse
+    if (typeof value === 'object') {
+        // Array case
+        if (Array.isArray(value)) {
+            /**
+             * We use index-based bracket notation here:
+             *   e.g. for value = ['aa', 'bb'] and key = 'foo'
+             *   => "foo[0]=aa&foo[1]=bb"
+             *
+             * If you prefer "foo[]=aa&foo[]=bb" style, replace:
+             *   `${key}[${i}]`
+             * with:
+             *   `${key}[]`
+             */
+            return value.flatMap((v, i) => {
+                const newKey = `${key}[${i}]`;
+                return buildParams(newKey, v);
+            });
+        }
+        // Plain object case
+        return Object.keys(value).flatMap((k) => {
+            const newKey = `${key}[${k}]`;
+            return buildParams(newKey, value[k]);
+        });
+    }
+    return [`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`];
+}
+/**
+ * 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 "?")
+ */
+function serializeQuery(obj) {
+    if (!obj || typeof obj !== 'object')
+        return '';
+    // Collect query segments
+    const segments = [];
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const value = obj[key];
+            segments.push(...buildParams(key, value));
+        }
+    }
+    return segments.join('&');
+}

package/dist/utils/setClientValidatorsForHandler.d.ts

@@ -0,0 +1,5 @@
+import type { KnownAny } from '../types';
+export declare function setClientValidatorsForHandler(h: (...args: KnownAny[]) => KnownAny, validation: {
+    body: unknown;
+    query: unknown;
+}): Promise<void>;

package/{utils → dist/utils}/setClientValidatorsForHandler.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = setClientValidatorsForHandler;
-function setClientValidatorsForHandler(h, validators) {
+exports.setClientValidatorsForHandler = setClientValidatorsForHandler;
+function setClientValidatorsForHandler(h, validation) {
     return new Promise((resolve) => {
+        // the setTimeout is necessary to ensure that the _controller is already defined
         setTimeout(() => {
             const controller = h._controller;
             if (!controller) {
@@ -16,10 +17,7 @@ function setClientValidatorsForHandler(h, validators) {
                 ...controller._handlers,
                 [handlerName]: {
                     ...controller._handlers[handlerName],
-                    clientValidators: {
-                        body: validators.body,
-                        query: validators.query,
-                    },
+                    validation,
                 },
             };
             resolve();

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "vovk",
-  "version": "3.0.0-draft.7",
+  "version": "3.0.0-draft.70",
+  "main": "dist/index.js",
   "description": "RESTful RPC for Next.js - Transforms Next.js into a powerful REST API platform with RPC capabilities.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/finom/vovk.git"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc && cp {package.json,LICENSE,.npmignore} dist && cp ../../README.md dist",
+    "build": "tsc",
+    "rm-dist": "shx rm -rf dist",
     "lint": "eslint . --fix",
+    "tsc": "tsc --noEmit",
     "npm-publish": "if [ -z \"$NPM_TAG\" ]; then echo 'Error: NPM_TAG is not set'; exit 1; fi; cd ./dist && npm publish --tag=$NPM_TAG && cd ..",
     "ncu": "npm-check-updates -u"
   },
@@ -24,5 +27,8 @@
   "homepage": "https://vovk.dev",
   "peerDependencies": {
     "next": "*"
+  },
+  "optionalDependencies": {
+    "openapi3-ts": "^4.4.0"
   }
 }

package/src/HttpException.ts

@@ -0,0 +1,16 @@
+import type { HttpStatus } from './types';
+
+export class HttpException extends Error {
+  statusCode: HttpStatus;
+
+  message: string;
+
+  cause?: unknown;
+
+  constructor(statusCode: HttpStatus, message: string, cause?: unknown) {
+    super(message);
+    this.statusCode = statusCode;
+    this.message = message;
+    this.cause = cause;
+  }
+}

package/src/StreamJSONResponse.ts

@@ -0,0 +1,61 @@
+import type { KnownAny, StreamAbortMessage } from './types';
+import './utils/shim';
+
+export class StreamJSONResponse<T> extends Response {
+  public static defaultHeaders = {
+    'content-type': 'text/plain; format=jsonlines',
+  };
+
+  public isClosed = false;
+
+  public controller?: ReadableStreamDefaultController;
+
+  public readonly encoder: TextEncoder;
+
+  public readonly readableStream: ReadableStream;
+
+  constructor(init?: ResponseInit) {
+    const encoder = new TextEncoder();
+    let readableController: ReadableStreamDefaultController;
+
+    const readableStream = new ReadableStream({
+      cancel: () => {
+        this.isClosed = true;
+      },
+      start: (controller) => {
+        readableController = controller;
+      },
+    });
+
+    super(readableStream, {
+      ...init,
+      headers: init?.headers ?? StreamJSONResponse.defaultHeaders,
+    });
+
+    this.readableStream = readableStream;
+    this.encoder = encoder;
+    this.controller = readableController!;
+  }
+
+  public send(data: T | StreamAbortMessage) {
+    const { controller, encoder } = this;
+    if (this.isClosed) return;
+    return controller?.enqueue(encoder.encode(JSON.stringify(data) + '\n'));
+  }
+
+  public close() {
+    const { controller } = this;
+    if (this.isClosed) return;
+    this.isClosed = true;
+    controller?.close();
+  }
+
+  public throw(e: KnownAny) {
+    this.send({ isError: true, reason: e instanceof Error ? e.message : (e as unknown) });
+    return this.close();
+  }
+
+  public [Symbol.dispose]() {
+    this.close();
+  }
+}