vovk 3.0.0-draft.13 → 3.0.0-draft.135

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_js_1 = __importDefault(require("./parseQuery.js"));
+function reqQuery(req) {
+    return (0, parseQuery_js_1.default)(req.nextUrl.search);
+}

package/cjs/utils/serializeQuery.d.ts

@@ -0,0 +1,13 @@
+import type { KnownAny } from '../types.js';
+/**
+ * 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/cjs/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/cjs/utils/setHandlerSchema.d.ts

@@ -0,0 +1,4 @@
+import type { KnownAny, VovkController, VovkHandlerSchema } from '../types.js';
+export declare function setHandlerSchema(h: ((...args: KnownAny[]) => KnownAny) & {
+    _getSchema?: (controller: VovkController) => Omit<VovkHandlerSchema, 'httpMethod' | 'path'>;
+}, schema: Omit<VovkHandlerSchema, 'httpMethod' | 'path'>): Promise<void>;

package/cjs/utils/setHandlerSchema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHandlerSchema = setHandlerSchema;
+async function setHandlerSchema(h, schema) {
+    h._getSchema = (controller) => {
+        if (!controller) {
+            throw new Error('Error setting client validators. Controller not found. Did you forget to use an HTTP decorator?');
+        }
+        const handlerName = Object.getOwnPropertyNames(controller).find((key) => controller[key]._sourceMethod === h);
+        if (!handlerName) {
+            throw new Error('Error setting client validators. Handler not found.');
+        }
+        return schema;
+    };
+}

package/cjs/utils/withValidation.d.ts

@@ -0,0 +1,21 @@
+import { VovkValidationType, type KnownAny, type VovkRequest } from '../types.js';
+export declare function withValidation<T extends (req: KnownAny, params: KnownAny) => KnownAny, BODY_MODEL, QUERY_MODEL, PARAMS_MODEL, OUTPUT_MODEL, ITERATION_MODEL>({ disableServerSideValidation, skipSchemaEmission, validateEachIteration, body, query, params, output, iteration, handle, getJSONSchemaFromModel, validate, }: {
+    disableServerSideValidation?: boolean | VovkValidationType[];
+    skipSchemaEmission?: boolean | VovkValidationType[];
+    validateEachIteration?: boolean;
+    body?: BODY_MODEL;
+    query?: QUERY_MODEL;
+    params?: PARAMS_MODEL;
+    output?: OUTPUT_MODEL;
+    iteration?: ITERATION_MODEL;
+    handle: T;
+    getJSONSchemaFromModel?: (model: NonNullable<BODY_MODEL | QUERY_MODEL | PARAMS_MODEL | OUTPUT_MODEL | ITERATION_MODEL>, meta: {
+        type: VovkValidationType;
+    }) => KnownAny;
+    validate: (data: KnownAny, model: NonNullable<BODY_MODEL | QUERY_MODEL | PARAMS_MODEL | OUTPUT_MODEL | ITERATION_MODEL>, meta: {
+        type: VovkValidationType;
+        req: VovkRequest<KnownAny, KnownAny>;
+        status?: number;
+        i?: number;
+    }) => KnownAny;
+}): T;

package/cjs/utils/withValidation.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withValidation = withValidation;
+const HttpException_js_1 = require("../HttpException.js");
+const types_js_1 = require("../types.js");
+const setHandlerSchema_js_1 = require("./setHandlerSchema.js");
+const validationTypes = ['body', 'query', 'params', 'output', 'iteration'];
+function withValidation({ disableServerSideValidation, skipSchemaEmission, validateEachIteration, body, query, params, output, iteration, handle, getJSONSchemaFromModel, validate, }) {
+    const disableServerSideValidationKeys = disableServerSideValidation === false
+        ? []
+        : disableServerSideValidation === true
+            ? validationTypes
+            : (disableServerSideValidation ?? []);
+    const skipSchemaEmissionKeys = skipSchemaEmission === false ? [] : skipSchemaEmission === true ? validationTypes : (skipSchemaEmission ?? []);
+    const outputHandler = async (req, handlerParams) => {
+        const data = await handle(req, handlerParams);
+        if (output && iteration) {
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, "Output and iteration are mutually exclusive. You can't use them together.");
+        }
+        if (output && !disableServerSideValidationKeys.includes('output')) {
+            if (!data) {
+                throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, 'Output is required. You probably forgot to return something from your handler.');
+            }
+            await validate(data, output, { type: 'output', req });
+        }
+        if (iteration && !disableServerSideValidationKeys.includes('iteration')) {
+            // We assume `data` is an async iterable here; you might want to check that:
+            if (!data || typeof data[Symbol.asyncIterator] !== 'function') {
+                throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, 'Data is not an async iterable but iteration validation is defined.');
+            }
+            // Return a brand-new async generator that yields validated items
+            return (async function* () {
+                let i = 0;
+                for await (const item of data) {
+                    if (validateEachIteration || i === 0) {
+                        await validate(item, iteration, { type: 'iteration', req, status: 200, i });
+                    }
+                    i++;
+                    yield item;
+                }
+            })();
+        }
+        else if (validateEachIteration) {
+            throw new HttpException_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, 'validateEachIteration is set but iteration is not defined.');
+        }
+        return data;
+    };
+    const resultHandler = async (req, handlerParams) => {
+        if (body && !disableServerSideValidationKeys.includes('body')) {
+            const data = await req.json();
+            const instance = (await validate(data, body, { type: 'body', req })) ?? data;
+            // redeclare to add ability to call req.json() again
+            req.json = () => Promise.resolve(data);
+            req.vovk.body = () => Promise.resolve(instance);
+        }
+        if (query && !disableServerSideValidationKeys.includes('query')) {
+            const data = req.vovk.query();
+            const instance = (await validate(data, query, { type: 'query', req })) ?? data;
+            req.vovk.query = () => instance;
+        }
+        if (params && !disableServerSideValidationKeys.includes('params')) {
+            const data = req.vovk.params();
+            const instance = (await validate(data, params, { type: 'params', req })) ?? data;
+            req.vovk.params = () => instance;
+        }
+        return outputHandler(req, handlerParams);
+    };
+    if (getJSONSchemaFromModel) {
+        const validation = {};
+        if (body && !skipSchemaEmissionKeys.includes('body')) {
+            validation.body = getJSONSchemaFromModel(body, { type: 'body' });
+        }
+        if (query && !skipSchemaEmissionKeys.includes('query')) {
+            validation.query = getJSONSchemaFromModel(query, { type: 'query' });
+        }
+        if (params && !skipSchemaEmissionKeys.includes('params')) {
+            validation.params = getJSONSchemaFromModel(params, { type: 'params' });
+        }
+        if (output && !skipSchemaEmissionKeys.includes('output')) {
+            validation.output = getJSONSchemaFromModel(output, { type: 'output' });
+        }
+        if (iteration && !skipSchemaEmissionKeys.includes('iteration')) {
+            validation.iteration = getJSONSchemaFromModel(iteration, { type: 'iteration' });
+        }
+        (0, setHandlerSchema_js_1.setHandlerSchema)(resultHandler, { validation });
+    }
+    return resultHandler;
+}

package/mjs/HttpException.d.ts

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

package/mjs/HttpException.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpException = void 0;
+class HttpException extends Error {
+    statusCode;
+    message;
+    cause;
+    constructor(statusCode, message, cause) {
+        super(message);
+        this.statusCode = statusCode;
+        this.message = message;
+        this.cause = cause;
+    }
+}
+exports.HttpException = HttpException;

package/mjs/JSONLinesResponse.d.ts

@@ -0,0 +1,14 @@
+import type { headers } from 'next/headers';
+import type { KnownAny, StreamAbortMessage } from './types.js';
+import './utils/shim.js';
+export declare class JSONLinesResponse<T> extends Response {
+    isClosed: boolean;
+    controller?: ReadableStreamDefaultController;
+    readonly encoder: TextEncoder;
+    readonly readableStream: ReadableStream;
+    constructor(requestHeaders: Awaited<ReturnType<typeof headers>>, init?: ResponseInit);
+    send(data: T | StreamAbortMessage): void;
+    close(): void;
+    throw(e: KnownAny): void;
+    [Symbol.dispose](): void;
+}

package/mjs/JSONLinesResponse.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONLinesResponse = void 0;
+require("./utils/shim.js");
+class JSONLinesResponse extends Response {
+    isClosed = false;
+    controller;
+    encoder;
+    readableStream;
+    constructor(requestHeaders, init) {
+        const encoder = new TextEncoder();
+        let readableController;
+        const readableStream = new ReadableStream({
+            cancel: () => {
+                this.isClosed = true;
+            },
+            start: (controller) => {
+                readableController = controller;
+            },
+        });
+        if (!requestHeaders) {
+            throw new Error('Request headers are required');
+        }
+        const accept = requestHeaders.get('accept');
+        super(readableStream, {
+            ...init,
+            headers: {
+                ...init?.headers,
+                'Content-Type': accept?.includes('application/jsonl')
+                    ? 'application/jsonl; charset=utf-8'
+                    : 'text/plain; charset=utf-8',
+            },
+        });
+        this.readableStream = readableStream;
+        this.encoder = encoder;
+        this.controller = readableController;
+    }
+    send(data) {
+        const { controller, encoder } = this;
+        if (this.isClosed)
+            return;
+        return controller?.enqueue(encoder.encode(JSON.stringify(data) + '\n'));
+    }
+    close() {
+        const { controller } = this;
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        controller?.close();
+    }
+    throw(e) {
+        this.send({ isError: true, reason: e instanceof Error ? e.message : e });
+        return this.close();
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+exports.JSONLinesResponse = JSONLinesResponse;

package/mjs/VovkApp.d.ts

@@ -0,0 +1,29 @@
+import type { NextRequest } from 'next/server';
+import { HttpMethod, HttpStatus, type RouteHandler, type VovkController, type DecoratorOptions } from './types.js';
+export declare class VovkApp {
+    #private;
+    private static getHeadersFromOptions;
+    routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>>;
+    GET: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    POST: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PUT: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PATCH: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    DELETE: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    HEAD: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    OPTIONS: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    respond: (status: HttpStatus, body: unknown, options?: DecoratorOptions) => Response;
+}

package/mjs/VovkApp.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VovkApp = void 0;
+const types_js_1 = require("./types.js");
+const HttpException_js_1 = require("./HttpException.js");
+const JSONLinesResponse_js_1 = require("./JSONLinesResponse.js");
+const reqQuery_js_1 = __importDefault(require("./utils/reqQuery.js"));
+const reqMeta_js_1 = __importDefault(require("./utils/reqMeta.js"));
+const reqForm_js_1 = __importDefault(require("./utils/reqForm.js"));
+const headers_1 = require("next/headers");
+class VovkApp {
+    static getHeadersFromOptions(options) {
+        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 = {
+        GET: new Map(),
+        POST: new Map(),
+        PUT: new Map(),
+        PATCH: new Map(),
+        DELETE: new Map(),
+        HEAD: new Map(),
+        OPTIONS: new Map(),
+    };
+    GET = async (req, data) => this.#callMethod(types_js_1.HttpMethod.GET, req, await data.params);
+    POST = async (req, data) => this.#callMethod(types_js_1.HttpMethod.POST, req, await data.params);
+    PUT = async (req, data) => this.#callMethod(types_js_1.HttpMethod.PUT, req, await data.params);
+    PATCH = async (req, data) => this.#callMethod(types_js_1.HttpMethod.PATCH, req, await data.params);
+    DELETE = async (req, data) => this.#callMethod(types_js_1.HttpMethod.DELETE, req, await data.params);
+    HEAD = async (req, data) => this.#callMethod(types_js_1.HttpMethod.HEAD, req, await data.params);
+    OPTIONS = async (req, data) => this.#callMethod(types_js_1.HttpMethod.OPTIONS, req, await data.params);
+    respond = (status, body, options) => {
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: {
+                'content-type': 'application/json',
+                ..._a.getHeadersFromOptions(options),
+            },
+        });
+    };
+    #respondWithError = (statusCode, message, options, cause) => {
+        return this.respond(statusCode, {
+            cause,
+            statusCode,
+            message,
+            isError: true,
+        }, options);
+    };
+    #getHandler = ({ handlers, path, params, }) => {
+        const methodParams = {};
+        if (Object.keys(params).length === 0) {
+            return { handler: handlers[''], methodParams };
+        }
+        const allMethodKeys = Object.keys(handlers);
+        let methodKeys = [];
+        const pathStr = path.join('/');
+        methodKeys = allMethodKeys
+            // First, try to match literal routes exactly.
+            .filter((p) => {
+            if (p.includes(':'))
+                return false; // Skip parameterized paths
+            return p === pathStr;
+        });
+        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_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}" at ${p}`);
+                        }
+                        // 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_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+        }
+        const [methodKey] = methodKeys;
+        if (methodKey) {
+            return { handler: handlers[methodKey], methodParams };
+        }
+        return { handler: null, methodParams };
+    };
+    #callMethod = async (httpMethod, nextReq, params) => {
+        const req = nextReq;
+        const controllers = this.routes[httpMethod];
+        const path = params[Object.keys(params)[0]];
+        const handlers = {};
+        controllers.forEach((staticMethods, controller) => {
+            const prefix = controller._prefix ?? '';
+            if (!controller._activated) {
+                throw new HttpException_js_1.HttpException(types_js_1.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 { handler, methodParams } = this.#getHandler({ handlers, path, params });
+        if (!handler) {
+            return this.#respondWithError(types_js_1.HttpStatus.NOT_FOUND, `${Object.keys(handlers)} - Route ${path.join('/')} is not found`);
+        }
+        const { staticMethod, controller } = handler;
+        req.vovk = {
+            body: () => req.json(),
+            query: () => (0, reqQuery_js_1.default)(req),
+            meta: (meta) => (0, reqMeta_js_1.default)(req, meta),
+            form: () => (0, reqForm_js_1.default)(req),
+            params: () => methodParams,
+        };
+        try {
+            await staticMethod._options?.before?.call(controller, req);
+            const result = await staticMethod.call(controller, req, methodParams);
+            const isIterator = typeof result === 'object' &&
+                !!result &&
+                ((Reflect.has(result, Symbol.iterator) &&
+                    typeof result[Symbol.iterator] === 'function') ||
+                    (Reflect.has(result, Symbol.asyncIterator) &&
+                        typeof result[Symbol.asyncIterator] === 'function'));
+            if (isIterator && !(result instanceof Array)) {
+                const streamResponse = new JSONLinesResponse_js_1.JSONLinesResponse(await (0, headers_1.headers)(), {
+                    headers: {
+                        ..._a.getHeadersFromOptions(staticMethod._options),
+                    },
+                });
+                void (async () => {
+                    try {
+                        for await (const chunk of result) {
+                            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;
+            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 || types_js_1.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
+        }
+    };
+}
+exports.VovkApp = VovkApp;
+_a = VovkApp;

package/mjs/client/createRPC.d.ts

@@ -0,0 +1,3 @@
+import type { KnownAny, VovkSchema } from '../types.js';
+import type { VovkClientOptions, VovkClient, VovkDefaultFetcherOptions } from './types.js';
+export declare const createRPC: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions<Record<string, never>>>(schema: VovkSchema, segmentName: string, rpcModuleName: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;

package/mjs/client/createRPC.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRPC = void 0;
+const fetcher_js_1 = require("./fetcher.js");
+const defaultHandler_js_1 = require("./defaultHandler.js");
+const defaultStreamHandler_js_1 = require("./defaultStreamHandler.js");
+const serializeQuery_js_1 = __importDefault(require("../utils/serializeQuery.js"));
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const getHandlerPath = (endpoint, params, query) => {
+    let result = endpoint;
+    const queryStr = query ? (0, serializeQuery_js_1.default)(query) : null;
+    for (const [key, value] of Object.entries(params ?? {})) {
+        result = result.replace(`:${key}`, value);
+    }
+    return `${result}${queryStr ? '?' : ''}${queryStr}`;
+};
+const createRPC = (schema, segmentName, rpcModuleName, options) => {
+    const segmentSchema = schema.segments[segmentName];
+    if (!segmentSchema)
+        throw new Error(`Unable to create RPC object. Segment schema is missing. Check client template.`);
+    const controllerSchema = schema.segments[segmentName]?.controllers[rpcModuleName];
+    const client = {};
+    if (!controllerSchema)
+        throw new Error(`Unable to create RPC object. Controller schema is missing. Check client template.`);
+    const controllerPrefix = trimPath(controllerSchema.prefix ?? '');
+    const { fetcher: settingsFetcher = fetcher_js_1.fetcher } = options ?? {};
+    for (const [staticMethodName, handlerSchema] of Object.entries(controllerSchema.handlers)) {
+        const { path, httpMethod, validation } = handlerSchema;
+        const getEndpoint = ({ apiRoot, params, query, }) => {
+            const mainPrefix = (apiRoot.startsWith('http://') || apiRoot.startsWith('https://') || apiRoot.startsWith('/') ? '' : '/') +
+                (apiRoot.endsWith('/') ? apiRoot : `${apiRoot}/`) +
+                (segmentName ? `${segmentName}/` : '');
+            return mainPrefix + getHandlerPath([controllerPrefix, path].filter(Boolean).join('/'), params, query);
+        };
+        const handler = (input = {}) => {
+            const fetcher = input.fetcher ?? settingsFetcher;
+            const validate = async ({ body, query, params, endpoint, }) => {
+                const validateOnClient = input.validateOnClient ?? options?.validateOnClient;
+                if (validateOnClient && validation) {
+                    if (typeof validateOnClient !== 'function') {
+                        throw new Error('validateOnClient must be a function');
+                    }
+                    await validateOnClient({ body, query, params, endpoint }, validation, schema);
+                }
+            };
+            const internalOptions = {
+                name: staticMethodName,
+                httpMethod: httpMethod,
+                getEndpoint,
+                validate,
+                defaultHandler: defaultHandler_js_1.defaultHandler,
+                defaultStreamHandler: defaultStreamHandler_js_1.defaultStreamHandler,
+            };
+            const internalInput = {
+                ...options?.defaultOptions,
+                ...input,
+                body: input.body ?? null,
+                query: input.query ?? {},
+                params: input.params ?? {},
+                // TS workaround
+                fetcher: undefined,
+                validateOnClient: undefined,
+            };
+            delete internalInput.fetcher;
+            delete internalInput.validateOnClient;
+            if (!fetcher)
+                throw new Error('Fetcher is not provided');
+            const fetcherPromise = fetcher(internalOptions, internalInput);
+            if (!(fetcherPromise instanceof Promise))
+                return Promise.resolve(fetcherPromise);
+            return input.transform ? fetcherPromise.then(input.transform) : fetcherPromise;
+        };
+        handler.schema = handlerSchema;
+        handler.controllerSchema = controllerSchema;
+        handler.segmentSchema = segmentSchema;
+        handler.fullSchema = schema;
+        handler.isRPC = true;
+        // @ts-expect-error TODO
+        client[staticMethodName] = handler;
+    }
+    return client;
+};
+exports.createRPC = createRPC;

package/mjs/client/defaultHandler.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultHandler";
+export declare const defaultHandler: (response: Response) => Promise<unknown>;

package/mjs/client/defaultHandler.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const HttpException_js_1 = require("../HttpException.js");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultHandler';
+const defaultHandler = async (response) => {
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch (e) {
+        // handle parsing errors
+        throw new HttpException_js_1.HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.ok) {
+        // handle server errors
+        const errorResponse = result;
+        throw new HttpException_js_1.HttpException(response.status, errorResponse?.message ?? exports.DEFAULT_ERROR_MESSAGE, errorResponse?.cause);
+    }
+    return result;
+};
+exports.defaultHandler = defaultHandler;