@vistagenic/vista 0.2.1 → 0.2.3

package/dist/stack/client/create-client.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVistaClient = createVistaClient;
+const serialization_1 = require("../server/serialization");
+const error_1 = require("./error");
+function resolveFetchImpl(fetchImpl) {
+    if (fetchImpl) {
+        return fetchImpl;
+    }
+    if (typeof fetch !== 'function') {
+        throw new Error('Global fetch is not available. Provide a fetch implementation via createVistaClient({ fetch }).');
+    }
+    return fetch;
+}
+function normalizeBaseUrl(baseUrl) {
+    if (!baseUrl) {
+        return '';
+    }
+    return baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+}
+function normalizePath(path) {
+    if (!path) {
+        return '/';
+    }
+    return path.startsWith('/') ? path : `/${path}`;
+}
+function toQueryParams(input, serialization) {
+    const params = new URLSearchParams();
+    if (input === undefined || input === null) {
+        return params;
+    }
+    const serializedInput = (0, serialization_1.serializeWithMode)(input, serialization);
+    if (typeof serializedInput !== 'object' ||
+        serializedInput === null ||
+        Array.isArray(serializedInput)) {
+        params.set('input', String(serializedInput));
+        return params;
+    }
+    for (const [key, value] of Object.entries(serializedInput)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (value === null) {
+            params.set(key, 'null');
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                params.append(key, typeof entry === 'object' ? JSON.stringify(entry) : String(entry));
+            }
+            continue;
+        }
+        if (typeof value === 'object') {
+            params.set(key, JSON.stringify(value));
+            continue;
+        }
+        params.set(key, String(value));
+    }
+    return params;
+}
+async function resolveHeaders(headers) {
+    if (!headers) {
+        return new Headers();
+    }
+    const value = typeof headers === 'function' ? await headers() : headers;
+    return new Headers(value);
+}
+async function parseErrorResponse(response) {
+    const contentType = response.headers.get('content-type') ?? '';
+    if (contentType.includes('application/json')) {
+        try {
+            const json = await response.json();
+            const message = (json && typeof json.error === 'string' && json.error) ||
+                (json && typeof json.message === 'string' && json.message) ||
+                response.statusText ||
+                `Request failed with status ${response.status}`;
+            return { message, details: json };
+        }
+        catch {
+            // Fall through to text parsing.
+        }
+    }
+    try {
+        const text = await response.text();
+        if (text) {
+            return { message: text };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return {
+        message: response.statusText || `Request failed with status ${response.status}`,
+    };
+}
+async function parseSuccessResponse(response, serialization) {
+    if (response.status === 204) {
+        return undefined;
+    }
+    const contentType = response.headers.get('content-type') ?? '';
+    if (!contentType.includes('application/json')) {
+        return response.text();
+    }
+    const json = await response.json();
+    return (0, serialization_1.deserializeWithMode)(json, serialization);
+}
+function buildRequestUrl(baseUrl, path, query) {
+    const normalizedPath = normalizePath(path);
+    const rawUrl = baseUrl ? `${baseUrl}${normalizedPath}` : normalizedPath;
+    const queryString = query?.toString();
+    if (!queryString) {
+        return rawUrl;
+    }
+    return `${rawUrl}${rawUrl.includes('?') ? '&' : '?'}${queryString}`;
+}
+async function requestRoute(options) {
+    const requestHeaders = await resolveHeaders(options.headers);
+    const normalizedPath = normalizePath(options.path);
+    let url = buildRequestUrl(options.baseUrl, normalizedPath);
+    const requestInit = {
+        method: options.method,
+        headers: requestHeaders,
+    };
+    if (options.method === 'GET') {
+        const query = toQueryParams(options.input, options.serialization);
+        url = buildRequestUrl(options.baseUrl, normalizedPath, query);
+    }
+    else {
+        if (!requestHeaders.has('content-type')) {
+            requestHeaders.set('content-type', 'application/json');
+        }
+        requestInit.body = JSON.stringify((0, serialization_1.serializeWithMode)(options.input, options.serialization));
+    }
+    const response = await options.fetchImpl(url, requestInit);
+    if (!response.ok) {
+        const parsedError = await parseErrorResponse(response);
+        throw new error_1.VistaClientError({
+            status: response.status,
+            message: parsedError.message,
+            path: normalizedPath,
+            method: options.method,
+            url,
+            response,
+            details: parsedError.details,
+        });
+    }
+    return (await parseSuccessResponse(response, options.serialization));
+}
+function assertPath(path) {
+    if (!path || typeof path !== 'string') {
+        throw new Error('Route path must be a non-empty string.');
+    }
+}
+function createVistaClient(options = {}) {
+    const fetchImpl = resolveFetchImpl(options.fetch);
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    const serialization = options.serialization ?? 'json';
+    function $url(path, ...args) {
+        const routePath = String(path);
+        assertPath(routePath);
+        const query = toQueryParams(args[0], serialization);
+        return buildRequestUrl(baseUrl, routePath, query);
+    }
+    async function $get(path, ...args) {
+        const routePath = String(path);
+        assertPath(routePath);
+        return requestRoute({
+            fetchImpl,
+            method: 'GET',
+            baseUrl,
+            path: routePath,
+            input: args[0],
+            serialization,
+            headers: options.headers,
+        });
+    }
+    async function $post(path, ...args) {
+        const routePath = String(path);
+        assertPath(routePath);
+        return requestRoute({
+            fetchImpl,
+            method: 'POST',
+            baseUrl,
+            path: routePath,
+            input: args[0],
+            serialization,
+            headers: options.headers,
+        });
+    }
+    return {
+        $url,
+        $get,
+        $post,
+    };
+}

package/dist/stack/client/error.d.ts

@@ -0,0 +1,18 @@
+export interface VistaClientErrorInit {
+    status: number;
+    message: string;
+    path: string;
+    method: 'GET' | 'POST';
+    url: string;
+    response?: Response;
+    details?: unknown;
+}
+export declare class VistaClientError extends Error {
+    status: number;
+    path: string;
+    method: 'GET' | 'POST';
+    url: string;
+    response?: Response;
+    details?: unknown;
+    constructor(init: VistaClientErrorInit);
+}

package/dist/stack/client/error.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VistaClientError = void 0;
+class VistaClientError extends Error {
+    status;
+    path;
+    method;
+    url;
+    response;
+    details;
+    constructor(init) {
+        super(init.message);
+        this.name = 'VistaClientError';
+        this.status = init.status;
+        this.path = init.path;
+        this.method = init.method;
+        this.url = init.url;
+        this.response = init.response;
+        this.details = init.details;
+    }
+}
+exports.VistaClientError = VistaClientError;

package/dist/stack/client/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Package entry for `@vistagenic/vista/stack/client`.
+ *
+ * Example:
+ *   import { createVistaClient } from '@vistagenic/vista/stack/client'
+ */
+export { createVistaClient } from './create-client';
+export { VistaClientError } from './error';
+export type { AppRouterLike, ClientRoutes, CreateVistaClientOptions, GetRoutePath, OptionalInputArg, PostRoutePath, RouteInput, RouteOutput, RoutePath, VistaClient, VistaFetch, } from './types';

package/dist/stack/client/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VistaClientError = exports.createVistaClient = void 0;
+/**
+ * Package entry for `@vistagenic/vista/stack/client`.
+ *
+ * Example:
+ *   import { createVistaClient } from '@vistagenic/vista/stack/client'
+ */
+var create_client_1 = require("./create-client");
+Object.defineProperty(exports, "createVistaClient", { enumerable: true, get: function () { return create_client_1.createVistaClient; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "VistaClientError", { enumerable: true, get: function () { return error_1.VistaClientError; } });

package/dist/stack/client/types.d.ts

@@ -0,0 +1,39 @@
+import type { FlatRouteMap, OperationType, ProcedureRecord, StackRouter, StackSerializationMode } from '../server/types';
+type NormalizeRoutePathKey<TPath extends string> = TPath extends `/${string}` ? TPath : `/${TPath}`;
+export type OperationRouteMap<TValue> = {
+    [TPath in Extract<keyof TValue, string> as TValue[TPath] extends OperationType<any, any, any, any> ? NormalizeRoutePathKey<TPath> : never]: Extract<TValue[TPath], OperationType<any, any, any, any>>;
+};
+export type AppRouterLike = StackRouter<ProcedureRecord, any, any> | {
+    routes: unknown;
+} | object;
+export type ClientRoutes<TAppRouter> = TAppRouter extends StackRouter<infer TProcedures, any, any> ? FlatRouteMap<TProcedures> : TAppRouter extends {
+    routes: infer TRoutes;
+} ? OperationRouteMap<TRoutes> : OperationRouteMap<TAppRouter>;
+type NormalizedClientRoutes<TRoutes> = OperationRouteMap<TRoutes>;
+export type RoutePath<TRoutes> = Extract<keyof NormalizedClientRoutes<TRoutes>, string>;
+export type GetRoutePath<TRoutes> = {
+    [TPath in RoutePath<TRoutes>]: NormalizedClientRoutes<TRoutes>[TPath] extends {
+        type: 'get';
+    } ? TPath : never;
+}[RoutePath<TRoutes>];
+export type PostRoutePath<TRoutes> = {
+    [TPath in RoutePath<TRoutes>]: NormalizedClientRoutes<TRoutes>[TPath] extends {
+        type: 'post';
+    } ? TPath : never;
+}[RoutePath<TRoutes>];
+export type RouteInput<TRoutes, TPath extends RoutePath<TRoutes>> = NormalizedClientRoutes<TRoutes>[TPath] extends OperationType<infer TInput, any, any, any> ? TInput : never;
+export type RouteOutput<TRoutes, TPath extends RoutePath<TRoutes>> = NormalizedClientRoutes<TRoutes>[TPath] extends OperationType<any, infer TOutput, any, any> ? TOutput : never;
+export type OptionalInputArg<TInput> = [TInput] extends [void] ? [input?: undefined] : [input: TInput];
+export type VistaFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface CreateVistaClientOptions {
+    baseUrl?: string;
+    fetch?: VistaFetch;
+    serialization?: StackSerializationMode;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+}
+export interface VistaClient<TRoutes> {
+    $url<TPath extends RoutePath<TRoutes>>(path: TPath, ...args: OptionalInputArg<RouteInput<TRoutes, TPath>>): string;
+    $get<TPath extends GetRoutePath<TRoutes>>(path: TPath, ...args: OptionalInputArg<RouteInput<TRoutes, TPath>>): Promise<RouteOutput<TRoutes, TPath>>;
+    $post<TPath extends PostRoutePath<TRoutes>>(path: TPath, ...args: OptionalInputArg<RouteInput<TRoutes, TPath>>): Promise<RouteOutput<TRoutes, TPath>>;
+}
+export {};

package/dist/stack/client/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/stack/index.d.ts

@@ -0,0 +1,32 @@
+import { mergeRouters as mergeStackRouters } from './server/merge-routers';
+import { type ProcedureBuilder } from './server/procedure';
+import { type CreateRouterOptions } from './server/router';
+import { type StackSerializer } from './server/serialization';
+import type { MiddlewareFunction, ProcedureRecord, StackRouter, StackSerializationMode } from './server/types';
+/**
+ * Package entry for `@vistagenic/vista/stack`.
+ *
+ * Example:
+ *   import { vstack } from '@vistagenic/vista/stack'
+ *   const v = vstack.init()
+ */
+export interface VStackInitOptions {
+    serialization?: StackSerializationMode;
+}
+export interface VStackInstance<TCtx, TEnv> {
+    procedure: ProcedureBuilder<TCtx, TEnv>;
+    middleware<TCurrentCtx extends TCtx, TOutput extends Record<string, unknown> = {}>(handler: MiddlewareFunction<TCurrentCtx, TOutput, TEnv>): MiddlewareFunction<TCurrentCtx, TOutput, TEnv>;
+    router<TProcedures extends ProcedureRecord>(procedures: TProcedures, options?: CreateRouterOptions<TEnv>): StackRouter<TProcedures, TCtx, TEnv>;
+    mergeRouters: typeof mergeStackRouters;
+    serializer: StackSerializer;
+    options: Required<VStackInitOptions>;
+}
+export declare function initStack<TCtx extends Record<string, unknown> = {}, TEnv = unknown>(options?: VStackInitOptions): VStackInstance<TCtx, TEnv>;
+export declare const vstack: {
+    init: typeof initStack;
+};
+/**
+ * Re-export server stack primitives from `@vistagenic/vista/stack`.
+ */
+export type { CreateRouterOptions } from './server/router';
+export * from './server';

package/dist/stack/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vstack = void 0;
+exports.initStack = initStack;
+const merge_routers_1 = require("./server/merge-routers");
+const procedure_1 = require("./server/procedure");
+const router_1 = require("./server/router");
+const serialization_1 = require("./server/serialization");
+function initStack(options = {}) {
+    const normalizedOptions = {
+        serialization: options.serialization ?? 'json',
+    };
+    return {
+        procedure: (0, procedure_1.createProcedureBuilder)(),
+        middleware(handler) {
+            return handler;
+        },
+        router(procedures, routerOptions) {
+            return (0, router_1.createRouter)(procedures, routerOptions);
+        },
+        mergeRouters(...routers) {
+            return (0, merge_routers_1.mergeRouters)(...routers);
+        },
+        serializer: (0, serialization_1.createSerializer)(normalizedOptions.serialization),
+        options: normalizedOptions,
+    };
+}
+exports.vstack = {
+    init: initStack,
+};
+__exportStar(require("./server"), exports);

package/dist/stack/server/executor.d.ts

@@ -0,0 +1,36 @@
+import type { MiddlewareFunction, OperationType, ProcedureRecord, StackExecutionContext, StackRequestLike, StackResponseToolkit, StackRouter, StackSerializationMode } from './types';
+export declare class StackRouteNotFoundError extends Error {
+    status: number;
+    constructor(path: string);
+}
+export declare class StackMethodNotAllowedError extends Error {
+    status: number;
+    constructor(path: string, method: string);
+}
+export declare class StackValidationError extends Error {
+    status: number;
+    cause: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare function createResponseToolkit(mode?: StackSerializationMode): StackResponseToolkit;
+export declare function runMiddlewareChain<TCtx, TEnv>(middlewares: MiddlewareFunction<any, any, TEnv>[], context: TCtx, env: TEnv, req: StackRequestLike, c: StackResponseToolkit): Promise<TCtx>;
+export interface ExecuteOperationOptions<TCtx, TEnv> extends StackExecutionContext<TCtx, TEnv> {
+    middlewares?: MiddlewareFunction<any, any, TEnv>[];
+    serialization?: StackSerializationMode;
+}
+export declare function executeOperation<TCtx, TInput, TOutput, TEnv>(operation: OperationType<TInput, TOutput, TCtx, TEnv>, options: ExecuteOperationOptions<TCtx, TEnv>): Promise<TOutput>;
+export interface ExecuteRouteOptions<TCtx, TEnv> {
+    path: string;
+    method: string;
+    req: StackRequestLike;
+    ctx: TCtx;
+    env: TEnv;
+    serialization?: StackSerializationMode;
+}
+export interface ExecuteRouteResult<TData = unknown> {
+    path: string;
+    method: string;
+    data: TData;
+    serializedData: unknown;
+}
+export declare function executeRoute<TProcedures extends ProcedureRecord, TCtx, TEnv>(router: StackRouter<TProcedures, TCtx, TEnv>, options: ExecuteRouteOptions<TCtx, TEnv>): Promise<ExecuteRouteResult>;

package/dist/stack/server/executor.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackValidationError = exports.StackMethodNotAllowedError = exports.StackRouteNotFoundError = void 0;
+exports.createResponseToolkit = createResponseToolkit;
+exports.runMiddlewareChain = runMiddlewareChain;
+exports.executeOperation = executeOperation;
+exports.executeRoute = executeRoute;
+const serialization_1 = require("./serialization");
+const router_1 = require("./router");
+function isObjectRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeResponseInit(init) {
+    if (typeof init === 'number') {
+        return { status: init };
+    }
+    return init ?? {};
+}
+class StackRouteNotFoundError extends Error {
+    status = 404;
+    constructor(path) {
+        super(`No typed API route found for "${path}"`);
+        this.name = 'StackRouteNotFoundError';
+    }
+}
+exports.StackRouteNotFoundError = StackRouteNotFoundError;
+class StackMethodNotAllowedError extends Error {
+    status = 405;
+    constructor(path, method) {
+        super(`Method "${method.toUpperCase()}" is not allowed for "${path}"`);
+        this.name = 'StackMethodNotAllowedError';
+    }
+}
+exports.StackMethodNotAllowedError = StackMethodNotAllowedError;
+class StackValidationError extends Error {
+    status = 400;
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = 'StackValidationError';
+        this.cause = cause;
+    }
+}
+exports.StackValidationError = StackValidationError;
+function createResponseToolkit(mode = 'json') {
+    return {
+        json(data, init) {
+            const payload = (0, serialization_1.serializeWithMode)(data, 'json');
+            return Response.json(payload, normalizeResponseInit(init));
+        },
+        text(data, init) {
+            return new Response(String(data), normalizeResponseInit(init));
+        },
+        superjson(data, init) {
+            const payload = {
+                mode: 'superjson',
+                data: (0, serialization_1.serializeWithMode)(data, 'superjson'),
+            };
+            return Response.json(payload, normalizeResponseInit(init));
+        },
+    };
+}
+async function runMiddlewareChain(middlewares, context, env, req, c) {
+    const executeAt = async (index, currentContext) => {
+        if (index >= middlewares.length) {
+            return currentContext;
+        }
+        const middleware = middlewares[index];
+        let nextCalled = false;
+        let nextContextPromise;
+        const next = async (extension = {}) => {
+            if (nextCalled) {
+                throw new Error('next() can only be called once per middleware');
+            }
+            nextCalled = true;
+            const mergedContext = isObjectRecord(extension) && isObjectRecord(currentContext)
+                ? { ...currentContext, ...extension }
+                : currentContext;
+            nextContextPromise = executeAt(index + 1, mergedContext);
+            return nextContextPromise;
+        };
+        const result = await middleware({
+            ctx: currentContext,
+            env,
+            req,
+            c,
+            next,
+        });
+        if (nextCalled) {
+            const downstreamContext = await nextContextPromise;
+            if (isObjectRecord(result) && isObjectRecord(downstreamContext)) {
+                return { ...downstreamContext, ...result };
+            }
+            return downstreamContext;
+        }
+        if (isObjectRecord(result) && isObjectRecord(currentContext)) {
+            return executeAt(index + 1, { ...currentContext, ...result });
+        }
+        return executeAt(index + 1, currentContext);
+    };
+    return (await executeAt(0, context));
+}
+function resolveRawInput(operation, req) {
+    if (operation.type === 'get') {
+        if (req.query !== undefined) {
+            return req.query;
+        }
+        return req.body;
+    }
+    if (req.body !== undefined) {
+        return req.body;
+    }
+    return req.query;
+}
+function resolveInput(operation, req, serialization) {
+    const rawInput = resolveRawInput(operation, req);
+    const input = (0, serialization_1.deserializeWithMode)(rawInput, serialization);
+    if (!operation.schema) {
+        return input;
+    }
+    try {
+        return operation.schema.parse(input);
+    }
+    catch (error) {
+        throw new StackValidationError('Invalid typed API input', error);
+    }
+}
+async function executeOperation(operation, options) {
+    const middlewareChain = [...(options.middlewares ?? []), ...operation.middlewares];
+    const finalContext = await runMiddlewareChain(middlewareChain, options.ctx, options.env, options.req, options.c);
+    const input = resolveInput(operation, options.req, options.serialization ?? 'json');
+    return operation.handler({
+        ctx: finalContext,
+        input,
+        env: options.env,
+        req: options.req,
+        c: options.c,
+    });
+}
+function hasPath(routes, path) {
+    return Object.prototype.hasOwnProperty.call(routes, path);
+}
+async function executeRoute(router, options) {
+    const normalizedPath = (0, router_1.normalizeStackRoutePath)(options.path);
+    const normalizedMethod = String(options.method).toLowerCase();
+    const routes = router.routes;
+    const candidateRoute = routes[normalizedPath];
+    if (!candidateRoute) {
+        throw new StackRouteNotFoundError(normalizedPath);
+    }
+    if (candidateRoute.type !== normalizedMethod) {
+        if (hasPath(routes, normalizedPath)) {
+            throw new StackMethodNotAllowedError(normalizedPath, normalizedMethod);
+        }
+        throw new StackRouteNotFoundError(normalizedPath);
+    }
+    const serialization = options.serialization ?? 'json';
+    const responseToolkit = createResponseToolkit(serialization);
+    const payload = await executeOperation(candidateRoute, {
+        ctx: options.ctx,
+        env: options.env,
+        req: options.req,
+        c: responseToolkit,
+        middlewares: router.metadata.globalMiddlewares,
+        serialization,
+    });
+    const serializedData = (0, serialization_1.serializeWithMode)(payload, serialization);
+    return {
+        path: normalizedPath,
+        method: normalizedMethod,
+        data: (0, serialization_1.deserializeWithMode)(payload, serialization),
+        serializedData,
+    };
+}

package/dist/stack/server/index.d.ts

@@ -0,0 +1,10 @@
+export { createProcedureBuilder, isOperation } from './procedure';
+export type { ProcedureBuilder } from './procedure';
+export { createRouter, normalizeStackRoutePath } from './router';
+export type { CreateRouterOptions } from './router';
+export { mergeRouters } from './merge-routers';
+export { createResponseToolkit, executeOperation, executeRoute, runMiddlewareChain, StackMethodNotAllowedError, StackRouteNotFoundError, StackValidationError, } from './executor';
+export type { ExecuteOperationOptions, ExecuteRouteOptions, ExecuteRouteResult, } from './executor';
+export { createSerializer, deserializeWithMode, serializeWithMode, } from './serialization';
+export type { StackSerializer } from './serialization';
+export type { FlatRouteMap, GetOperation, InferMiddlewareOutput, InferSchemaInput, MaybePromise, MiddlewareFunction, MiddlewareParams, NormalizeMiddlewareResult, OperationType, PostOperation, Prettify, ProcedureHandler, ProcedureHandlerParams, ProcedureNode, ProcedureRecord, ResolvedRoute, RouterMetadata, SchemaLike, StackErrorHandler, StackErrorWithStatus, StackExecutionContext, StackRequestLike, StackResponseToolkit, StackRouter, StackSerializationMode, } from './types';

package/dist/stack/server/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeWithMode = exports.deserializeWithMode = exports.createSerializer = exports.StackValidationError = exports.StackRouteNotFoundError = exports.StackMethodNotAllowedError = exports.runMiddlewareChain = exports.executeRoute = exports.executeOperation = exports.createResponseToolkit = exports.mergeRouters = exports.normalizeStackRoutePath = exports.createRouter = exports.isOperation = exports.createProcedureBuilder = void 0;
+var procedure_1 = require("./procedure");
+Object.defineProperty(exports, "createProcedureBuilder", { enumerable: true, get: function () { return procedure_1.createProcedureBuilder; } });
+Object.defineProperty(exports, "isOperation", { enumerable: true, get: function () { return procedure_1.isOperation; } });
+var router_1 = require("./router");
+Object.defineProperty(exports, "createRouter", { enumerable: true, get: function () { return router_1.createRouter; } });
+Object.defineProperty(exports, "normalizeStackRoutePath", { enumerable: true, get: function () { return router_1.normalizeStackRoutePath; } });
+var merge_routers_1 = require("./merge-routers");
+Object.defineProperty(exports, "mergeRouters", { enumerable: true, get: function () { return merge_routers_1.mergeRouters; } });
+var executor_1 = require("./executor");
+Object.defineProperty(exports, "createResponseToolkit", { enumerable: true, get: function () { return executor_1.createResponseToolkit; } });
+Object.defineProperty(exports, "executeOperation", { enumerable: true, get: function () { return executor_1.executeOperation; } });
+Object.defineProperty(exports, "executeRoute", { enumerable: true, get: function () { return executor_1.executeRoute; } });
+Object.defineProperty(exports, "runMiddlewareChain", { enumerable: true, get: function () { return executor_1.runMiddlewareChain; } });
+Object.defineProperty(exports, "StackMethodNotAllowedError", { enumerable: true, get: function () { return executor_1.StackMethodNotAllowedError; } });
+Object.defineProperty(exports, "StackRouteNotFoundError", { enumerable: true, get: function () { return executor_1.StackRouteNotFoundError; } });
+Object.defineProperty(exports, "StackValidationError", { enumerable: true, get: function () { return executor_1.StackValidationError; } });
+var serialization_1 = require("./serialization");
+Object.defineProperty(exports, "createSerializer", { enumerable: true, get: function () { return serialization_1.createSerializer; } });
+Object.defineProperty(exports, "deserializeWithMode", { enumerable: true, get: function () { return serialization_1.deserializeWithMode; } });
+Object.defineProperty(exports, "serializeWithMode", { enumerable: true, get: function () { return serialization_1.serializeWithMode; } });

package/dist/stack/server/merge-routers.d.ts

@@ -0,0 +1,2 @@
+import type { ProcedureRecord, StackRouter } from './types';
+export declare function mergeRouters(...routers: Array<StackRouter<ProcedureRecord, any, any>>): StackRouter<ProcedureRecord, any, any>;