vovk 3.0.0-draft.6 → 3.0.0-draft.60

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.6",
+  "version": "3.0.0-draft.60",
+  "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"
   },

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': 'application/jsonl',
+  };
+
+  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();
+  }
+}

package/src/VovkApp.ts

@@ -0,0 +1,242 @@
+import {
+  HttpMethod,
+  HttpStatus,
+  type RouteHandler,
+  type VovkErrorResponse,
+  type VovkController,
+  type DecoratorOptions,
+  type VovkRequest,
+  type KnownAny,
+} from './types';
+import { HttpException as HttpException } from './HttpException';
+import { StreamJSONResponse } from './StreamJSONResponse';
+import reqQuery from './utils/reqQuery';
+import reqMeta from './utils/reqMeta';
+import reqForm from './utils/reqForm';
+
+export class VovkApp {
+  private static getHeadersFromOptions(options?: DecoratorOptions) {
+    if (!options) return {};
+
+    const corsHeaders = {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS, HEAD',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    };
+
+    const headers = {
+      ...(options.cors ? corsHeaders : {}),
+      ...(options.headers ?? {}),
+    };
+
+    return headers;
+  }
+
+  routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>> = {
+    GET: new Map(),
+    POST: new Map(),
+    PUT: new Map(),
+    PATCH: new Map(),
+    DELETE: new Map(),
+    HEAD: new Map(),
+    OPTIONS: new Map(),
+  };
+
+  GET = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.GET, req, await data.params);
+
+  POST = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.POST, req, await data.params);
+
+  PUT = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.PUT, req, await data.params);
+
+  PATCH = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.PATCH, req, await data.params);
+
+  DELETE = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.DELETE, req, await data.params);
+
+  HEAD = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.HEAD, req, await data.params);
+
+  OPTIONS = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.OPTIONS, req, await data.params);
+
+  respond = (status: HttpStatus, body: unknown, options?: DecoratorOptions) => {
+    return new Response(JSON.stringify(body), {
+      status,
+      headers: {
+        'Content-Type': 'application/json',
+        ...VovkApp.getHeadersFromOptions(options),
+      },
+    });
+  };
+
+  #respondWithError = (statusCode: HttpStatus, message: string, options?: DecoratorOptions, cause?: unknown) => {
+    return this.respond(
+      statusCode,
+      {
+        cause,
+        statusCode,
+        message,
+        isError: true,
+      } satisfies VovkErrorResponse,
+      options
+    );
+  };
+
+  #callMethod = async (
+    httpMethod: HttpMethod,
+    req: VovkRequest<KnownAny, KnownAny>,
+    params: Record<string, string[]>
+  ) => {
+    const controllers = this.routes[httpMethod];
+    const methodParams: Record<string, string> = {};
+    const path = params[Object.keys(params)[0]];
+
+    const handlers: Record<string, { staticMethod: RouteHandler; controller: VovkController }> = {};
+    controllers.forEach((staticMethods, controller) => {
+      const prefix = controller._prefix ?? '';
+
+      if (!controller._activated) {
+        throw new HttpException(
+          HttpStatus.INTERNAL_SERVER_ERROR,
+          `Controller "${controller.name}" found but not activated`
+        );
+      }
+
+      Object.entries(staticMethods).forEach(([path, staticMethod]) => {
+        const fullPath = [prefix, path].filter(Boolean).join('/');
+        handlers[fullPath] = { staticMethod, controller };
+      });
+    });
+
+    const getHandler = () => {
+      if (Object.keys(params).length === 0) {
+        return handlers[''];
+      }
+
+      const allMethodKeys = Object.keys(handlers);
+
+      let methodKeys: string[] = [];
+
+      methodKeys = allMethodKeys
+        // First, try to match literal routes exactly.
+        .filter((p) => {
+          if (p.includes(':')) return false; // Skip parameterized paths
+          return p === path.join('/');
+        });
+
+      if (!methodKeys.length) {
+        methodKeys = allMethodKeys.filter((p) => {
+          const routeSegments = p.split('/');
+          if (routeSegments.length !== path.length) return false;
+
+          for (let i = 0; i < routeSegments.length; i++) {
+            const routeSegment = routeSegments[i];
+            const pathSegment = path[i];
+
+            if (routeSegment.startsWith(':')) {
+              const parameter = routeSegment.slice(1);
+
+              if (parameter in methodParams) {
+                throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}"`);
+              }
+
+              // If it's a parameterized segment, capture the parameter value.
+              methodParams[parameter] = pathSegment;
+            } else if (routeSegment !== pathSegment) {
+              // If it's a literal segment and it does not match the corresponding path segment, return false.
+              return false;
+            }
+          }
+          return true;
+        });
+      }
+
+      if (methodKeys.length > 1) {
+        throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+      }
+
+      const [methodKey] = methodKeys;
+
+      if (methodKey) {
+        return handlers[methodKey];
+      }
+
+      return null;
+    };
+
+    const handler = getHandler();
+
+    if (!handler) {
+      return this.#respondWithError(HttpStatus.NOT_FOUND, `Route ${path.join('/')} is not found`);
+    }
+
+    const { staticMethod, controller } = handler;
+
+    req.vovk = {
+      body: () => req.json(),
+      query: () => reqQuery(req),
+      meta: <T = KnownAny>(meta?: T | null) => reqMeta<T>(req, meta),
+      form: <T = KnownAny>() => reqForm<T>(req),
+    };
+
+    try {
+      const result = await staticMethod.call(controller, req, methodParams);
+
+      const isIterator =
+        typeof result === 'object' &&
+        !!result &&
+        ((Reflect.has(result, Symbol.iterator) &&
+          typeof (result as Iterable<unknown>)[Symbol.iterator] === 'function') ||
+          (Reflect.has(result, Symbol.asyncIterator) &&
+            typeof (result as AsyncIterable<unknown>)[Symbol.asyncIterator] === 'function'));
+
+      if (isIterator && !(result instanceof Array)) {
+        const streamResponse = new StreamJSONResponse({
+          headers: {
+            ...StreamJSONResponse.defaultHeaders,
+            ...VovkApp.getHeadersFromOptions(staticMethod._options),
+          },
+        });
+
+        void (async () => {
+          try {
+            for await (const chunk of result as AsyncGenerator<unknown>) {
+              streamResponse.send(chunk);
+            }
+          } catch (e) {
+            return streamResponse.throw(e);
+          }
+
+          return streamResponse.close();
+        })();
+
+        return streamResponse;
+      }
+
+      if (result instanceof Response) {
+        return result;
+      }
+
+      return this.respond(200, result ?? null, staticMethod._options);
+    } catch (e) {
+      const err = e as HttpException;
+      try {
+        await controller._onError?.(err, req);
+      } catch (onErrorError) {
+        // eslint-disable-next-line no-console
+        console.error(onErrorError);
+      }
+
+      if (err.message !== 'NEXT_REDIRECT' && err.message !== 'NEXT_NOT_FOUND') {
+        const statusCode = err.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR;
+        return this.#respondWithError(statusCode, err.message, staticMethod._options, err.cause);
+      }
+
+      throw e; // if NEXT_REDIRECT or NEXT_NOT_FOUND, rethrow it
+    }
+  };
+}