@vistagenic/vista 0.2.1 → 0.2.3

package/dist/stack/server/merge-routers.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeRouters = mergeRouters;
+const procedure_1 = require("./procedure");
+const router_1 = require("./router");
+function isObjectRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function mergeProcedureRecords(target, source, currentPath = '') {
+    for (const [key, sourceNode] of Object.entries(source)) {
+        const scopedPath = [currentPath, key].filter(Boolean).join('/');
+        const targetNode = target[key];
+        if (targetNode === undefined) {
+            target[key] = sourceNode;
+            continue;
+        }
+        if ((0, procedure_1.isOperation)(targetNode) && (0, procedure_1.isOperation)(sourceNode)) {
+            throw new Error(`Duplicate procedure found while merging routers: "${scopedPath}"`);
+        }
+        if (isObjectRecord(targetNode) && isObjectRecord(sourceNode)) {
+            target[key] = mergeProcedureRecords(targetNode, sourceNode, scopedPath);
+            continue;
+        }
+        throw new Error(`Incompatible procedure nodes while merging routers: "${scopedPath}"`);
+    }
+    return target;
+}
+function mergeRouters(...routers) {
+    const mergedProcedures = {};
+    const mergedRoutes = {};
+    const mergedMiddlewares = [];
+    let sharedErrorHandler;
+    for (const router of routers) {
+        mergeProcedureRecords(mergedProcedures, router.procedures);
+        for (const [path, operation] of Object.entries(router.routes)) {
+            const normalizedPath = (0, router_1.normalizeStackRoutePath)(path);
+            if (mergedRoutes[normalizedPath]) {
+                throw new Error(`Duplicate route found while merging routers: "${normalizedPath}"`);
+            }
+            mergedRoutes[normalizedPath] = operation;
+        }
+        mergedMiddlewares.push(...router.metadata.globalMiddlewares);
+        if (router.metadata.errorHandler) {
+            if (sharedErrorHandler && sharedErrorHandler !== router.metadata.errorHandler) {
+                throw new Error('Cannot merge routers with different error handlers.');
+            }
+            sharedErrorHandler = router.metadata.errorHandler;
+        }
+    }
+    const procedureMeta = {};
+    for (const [path, operation] of Object.entries(mergedRoutes)) {
+        procedureMeta[path] = { type: operation.type };
+    }
+    const metadata = {
+        basePath: '',
+        globalMiddlewares: mergedMiddlewares,
+        procedures: procedureMeta,
+        registeredPaths: Object.keys(mergedRoutes),
+        errorHandler: sharedErrorHandler,
+    };
+    return {
+        procedures: mergedProcedures,
+        routes: mergedRoutes,
+        metadata,
+        resolve(path, method) {
+            const normalizedPath = (0, router_1.normalizeStackRoutePath)(path);
+            const operation = mergedRoutes[normalizedPath];
+            if (!operation) {
+                return null;
+            }
+            if (operation.type !== String(method).toLowerCase()) {
+                return null;
+            }
+            return {
+                path: normalizedPath,
+                operation,
+            };
+        },
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { GetOperation, InferMiddlewareOutput, InferSchemaInput, MiddlewareFunction, PostOperation, Prettify, ProcedureHandler, SchemaLike } from './types';
+type ProcedureOutputFormat = 'json';
+interface ProcedureBuilderState<TEnv> {
+    schema?: SchemaLike<any>;
+    middlewares: MiddlewareFunction<any, any, TEnv>[];
+    outputFormat: ProcedureOutputFormat;
+}
+export interface ProcedureBuilder<TCtx, TEnv, TInput = void> {
+    use<TMiddleware extends MiddlewareFunction<TCtx, any, TEnv>>(middleware: TMiddleware): ProcedureBuilder<Prettify<TCtx & InferMiddlewareOutput<TMiddleware>>, TEnv, TInput>;
+    input<TSchema extends SchemaLike<any>>(schema: TSchema): ProcedureBuilder<TCtx, TEnv, InferSchemaInput<TSchema>>;
+    query<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): GetOperation<TInput, TOutput, TCtx, TEnv>;
+    mutation<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): PostOperation<TInput, TOutput, TCtx, TEnv>;
+    get<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): GetOperation<TInput, TOutput, TCtx, TEnv>;
+    post<TOutput>(handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>): PostOperation<TInput, TOutput, TCtx, TEnv>;
+}
+export declare function createProcedureBuilder<TCtx = {}, TEnv = unknown, TInput = void>(state?: Partial<ProcedureBuilderState<TEnv>>): ProcedureBuilder<TCtx, TEnv, TInput>;
+export declare function isOperation(value: unknown): value is GetOperation | PostOperation;
+export {};

package/dist/stack/server/procedure.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProcedureBuilder = createProcedureBuilder;
+exports.isOperation = isOperation;
+function cloneState(state) {
+    return {
+        schema: state?.schema,
+        middlewares: [...(state?.middlewares ?? [])],
+        outputFormat: state?.outputFormat ?? 'json',
+    };
+}
+function createOperation(type, state, handler) {
+    return {
+        type,
+        schema: state.schema,
+        handler,
+        middlewares: [...state.middlewares],
+        outputFormat: state.outputFormat,
+    };
+}
+function createProcedureBuilder(state) {
+    const currentState = cloneState(state);
+    return {
+        use(middleware) {
+            return createProcedureBuilder({
+                ...currentState,
+                middlewares: [...currentState.middlewares, middleware],
+            });
+        },
+        input(schema) {
+            return createProcedureBuilder({
+                ...currentState,
+                schema,
+            });
+        },
+        query(handler) {
+            return createOperation('get', currentState, handler);
+        },
+        mutation(handler) {
+            return createOperation('post', currentState, handler);
+        },
+        get(handler) {
+            return createOperation('get', currentState, handler);
+        },
+        post(handler) {
+            return createOperation('post', currentState, handler);
+        },
+    };
+}
+function isOperation(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return ((candidate.type === 'get' || candidate.type === 'post') &&
+        typeof candidate.handler === 'function' &&
+        Array.isArray(candidate.middlewares));
+}

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

@@ -0,0 +1,9 @@
+import type { MiddlewareFunction, ProcedureRecord, StackErrorHandler, StackRouter } from './types';
+export interface CreateRouterOptions<TEnv = unknown> {
+    basePath?: string;
+    middlewares?: MiddlewareFunction<any, any, TEnv>[];
+    errorHandler?: StackErrorHandler;
+    config?: Record<string, unknown>;
+}
+export declare function createRouter<TProcedures extends ProcedureRecord, TCtx = {}, TEnv = unknown>(procedures: TProcedures, options?: CreateRouterOptions<TEnv>): StackRouter<TProcedures, TCtx, TEnv>;
+export declare function normalizeStackRoutePath(path: string): string;

package/dist/stack/server/router.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = createRouter;
+exports.normalizeStackRoutePath = normalizeStackRoutePath;
+const procedure_1 = require("./procedure");
+function normalizePathSegment(path) {
+    return path
+        .split('/')
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .join('/');
+}
+function normalizeBasePath(basePath = '') {
+    const normalized = normalizePathSegment(basePath);
+    return normalized ? `/${normalized}` : '';
+}
+function normalizeRoutePath(basePath, relativePath) {
+    const normalizedRelativePath = normalizePathSegment(relativePath);
+    const normalizedBasePath = normalizeBasePath(basePath);
+    const combined = normalizePathSegment([normalizedBasePath, normalizedRelativePath].filter(Boolean).join('/'));
+    return combined ? `/${combined}` : '/';
+}
+function flattenProcedures(procedures, basePath, currentPath, routes) {
+    for (const [segment, node] of Object.entries(procedures)) {
+        const nextPath = [currentPath, segment].filter(Boolean).join('/');
+        if ((0, procedure_1.isOperation)(node)) {
+            const routePath = normalizeRoutePath(basePath, nextPath);
+            if (routes[routePath]) {
+                throw new Error(`Duplicate stack route detected: "${routePath}"`);
+            }
+            routes[routePath] = node;
+            continue;
+        }
+        if (node && typeof node === 'object' && !Array.isArray(node)) {
+            flattenProcedures(node, basePath, nextPath, routes);
+            continue;
+        }
+        throw new Error(`Invalid procedure node at "${nextPath || '/'}"`);
+    }
+}
+function createRouter(procedures, options = {}) {
+    const basePath = options.basePath ?? '';
+    const globalMiddlewares = [...(options.middlewares ?? [])];
+    const routes = {};
+    flattenProcedures(procedures, basePath, '', routes);
+    const procedureMeta = {};
+    for (const [path, operation] of Object.entries(routes)) {
+        procedureMeta[path] = { type: operation.type };
+    }
+    const metadata = {
+        basePath: normalizeBasePath(basePath),
+        globalMiddlewares,
+        procedures: procedureMeta,
+        registeredPaths: Object.keys(routes),
+        errorHandler: options.errorHandler,
+        config: options.config,
+    };
+    return {
+        procedures,
+        routes: routes,
+        metadata,
+        resolve(path, method) {
+            const normalizedPath = normalizeRoutePath('', path);
+            const route = routes[normalizedPath];
+            if (!route) {
+                return null;
+            }
+            if (route.type !== String(method).toLowerCase()) {
+                return null;
+            }
+            return {
+                path: normalizedPath,
+                operation: route,
+            };
+        },
+    };
+}
+function normalizeStackRoutePath(path) {
+    return normalizeRoutePath('', path);
+}

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

@@ -0,0 +1,9 @@
+import type { StackSerializationMode } from './types';
+export interface StackSerializer {
+    mode: StackSerializationMode;
+    serialize(value: unknown): unknown;
+    deserialize(value: unknown): unknown;
+}
+export declare function serializeWithMode(value: unknown, mode?: StackSerializationMode): unknown;
+export declare function deserializeWithMode<T = unknown>(value: unknown, mode?: StackSerializationMode): T;
+export declare function createSerializer(mode?: StackSerializationMode): StackSerializer;

package/dist/stack/server/serialization.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeWithMode = serializeWithMode;
+exports.deserializeWithMode = deserializeWithMode;
+exports.createSerializer = createSerializer;
+const SUPERJSON_TYPE_KEY = '__vistaSuperType';
+const SUPERJSON_VALUE_KEY = 'value';
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    return Object.getPrototypeOf(value) === Object.prototype;
+}
+function isTagged(value) {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    return typeof value[SUPERJSON_TYPE_KEY] === 'string' && SUPERJSON_VALUE_KEY in value;
+}
+function encodeSuperJson(value) {
+    if (value instanceof Date) {
+        return {
+            [SUPERJSON_TYPE_KEY]: 'Date',
+            [SUPERJSON_VALUE_KEY]: value.toISOString(),
+        };
+    }
+    if (typeof value === 'bigint') {
+        return {
+            [SUPERJSON_TYPE_KEY]: 'BigInt',
+            [SUPERJSON_VALUE_KEY]: value.toString(),
+        };
+    }
+    if (value instanceof Map) {
+        return {
+            [SUPERJSON_TYPE_KEY]: 'Map',
+            [SUPERJSON_VALUE_KEY]: Array.from(value.entries()).map(([key, mapValue]) => [
+                encodeSuperJson(key),
+                encodeSuperJson(mapValue),
+            ]),
+        };
+    }
+    if (value instanceof Set) {
+        return {
+            [SUPERJSON_TYPE_KEY]: 'Set',
+            [SUPERJSON_VALUE_KEY]: Array.from(value.values()).map((entry) => encodeSuperJson(entry)),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => encodeSuperJson(entry));
+    }
+    if (isPlainObject(value)) {
+        const encoded = {};
+        for (const [key, entry] of Object.entries(value)) {
+            encoded[key] = encodeSuperJson(entry);
+        }
+        return encoded;
+    }
+    return value;
+}
+function decodeSuperJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => decodeSuperJson(entry));
+    }
+    if (isTagged(value)) {
+        const type = value[SUPERJSON_TYPE_KEY];
+        const taggedValue = value[SUPERJSON_VALUE_KEY];
+        if (type === 'Date') {
+            return new Date(String(taggedValue));
+        }
+        if (type === 'BigInt') {
+            return BigInt(String(taggedValue));
+        }
+        if (type === 'Map') {
+            const entries = Array.isArray(taggedValue) ? taggedValue : [];
+            return new Map(entries.map((entry) => {
+                const pair = Array.isArray(entry) ? entry : [undefined, undefined];
+                return [decodeSuperJson(pair[0]), decodeSuperJson(pair[1])];
+            }));
+        }
+        if (type === 'Set') {
+            const values = Array.isArray(taggedValue) ? taggedValue : [];
+            return new Set(values.map((entry) => decodeSuperJson(entry)));
+        }
+    }
+    if (isPlainObject(value)) {
+        const decoded = {};
+        for (const [key, entry] of Object.entries(value)) {
+            decoded[key] = decodeSuperJson(entry);
+        }
+        return decoded;
+    }
+    return value;
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function serializeWithMode(value, mode = 'json') {
+    if (mode === 'superjson') {
+        return encodeSuperJson(value);
+    }
+    return cloneJson(value);
+}
+function deserializeWithMode(value, mode = 'json') {
+    if (mode === 'superjson') {
+        return decodeSuperJson(value);
+    }
+    return value;
+}
+function createSerializer(mode = 'json') {
+    return {
+        mode,
+        serialize(value) {
+            return serializeWithMode(value, mode);
+        },
+        deserialize(value) {
+            return deserializeWithMode(value, mode);
+        },
+    };
+}

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

@@ -0,0 +1,100 @@
+export type MaybePromise<T> = T | Promise<T>;
+export type StackSerializationMode = 'json' | 'superjson';
+export interface SchemaLike<T = unknown> {
+    parse(value: unknown): T;
+}
+export type InferSchemaInput<TSchema> = TSchema extends SchemaLike<infer T> ? T : void;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type UnionToIntersection<TUnion> = (TUnion extends unknown ? (value: TUnion) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type JoinPath<TLeft extends string, TRight extends string> = TLeft extends '' ? TRight : `${TLeft}/${TRight}`;
+export interface StackRequestLike {
+    method?: string;
+    path?: string;
+    query?: Record<string, unknown>;
+    body?: unknown;
+    headers?: Record<string, string | string[] | undefined>;
+    [key: string]: unknown;
+}
+export interface StackResponseToolkit {
+    json<T>(data: T, init?: number | ResponseInit): Response;
+    text(data: string, init?: number | ResponseInit): Response;
+    superjson<T>(data: T, init?: number | ResponseInit): Response;
+}
+export interface ProcedureHandlerParams<TCtx, TInput, TEnv> {
+    ctx: TCtx;
+    input: TInput;
+    env: TEnv;
+    req: StackRequestLike;
+    c: StackResponseToolkit;
+}
+export type ProcedureHandler<TCtx, TInput, TEnv, TOutput> = (params: ProcedureHandlerParams<TCtx, TInput, TEnv>) => MaybePromise<TOutput>;
+export interface MiddlewareParams<TCtx, TEnv> {
+    ctx: TCtx;
+    env: TEnv;
+    req: StackRequestLike;
+    c: StackResponseToolkit;
+    next<TAdded extends Record<string, unknown> = {}>(extension?: TAdded): Promise<TCtx & TAdded>;
+}
+export type MiddlewareFunction<TCtx = {}, TReturn = void, TEnv = unknown> = (params: MiddlewareParams<TCtx, TEnv>) => MaybePromise<TReturn | void>;
+export type NormalizeMiddlewareResult<TValue> = TValue extends void | undefined ? {} : TValue extends Record<string, unknown> ? TValue : {};
+export interface OperationBase<TInput, TOutput, TCtx, TEnv> {
+    schema?: SchemaLike<TInput>;
+    handler: ProcedureHandler<TCtx, TInput, TEnv, TOutput>;
+    middlewares: MiddlewareFunction<any, any, TEnv>[];
+    outputFormat: 'json';
+}
+export interface GetOperation<TInput = void, TOutput = unknown, TCtx = {}, TEnv = unknown> extends OperationBase<TInput, TOutput, TCtx, TEnv> {
+    type: 'get';
+}
+export interface PostOperation<TInput = void, TOutput = unknown, TCtx = {}, TEnv = unknown> extends OperationBase<TInput, TOutput, TCtx, TEnv> {
+    type: 'post';
+}
+export type OperationType<TInput = unknown, TOutput = unknown, TCtx = {}, TEnv = unknown> = GetOperation<TInput, TOutput, TCtx, TEnv> | PostOperation<TInput, TOutput, TCtx, TEnv>;
+export interface ProcedureRecord {
+    [key: string]: ProcedureNode;
+}
+export type ProcedureNode = OperationType<any, any, any, any> | ProcedureRecord;
+type FlatRouteMapUnion<TRecord extends Record<string, any>, TPrefix extends string> = {
+    [TKey in Extract<keyof TRecord, string>]: TRecord[TKey] extends OperationType<any, any, any, any> ? {
+        [TPath in JoinPath<TPrefix, TKey>]: TRecord[TKey];
+    } : TRecord[TKey] extends Record<string, any> ? FlatRouteMapUnion<TRecord[TKey], JoinPath<TPrefix, TKey>> : never;
+}[Extract<keyof TRecord, string>];
+type FlatRouteMapInternal<TRecord extends Record<string, any>> = [
+    FlatRouteMapUnion<TRecord, ''>
+] extends [never] ? {} : UnionToIntersection<FlatRouteMapUnion<TRecord, ''>>;
+export type FlatRouteMap<TRecord extends Record<string, any>> = Prettify<FlatRouteMapInternal<TRecord>>;
+export type InferMiddlewareOutput<TMiddleware> = TMiddleware extends MiddlewareFunction<any, infer TOutput, any> ? NormalizeMiddlewareResult<TOutput> : {};
+export interface StackErrorWithStatus {
+    status?: number;
+    message?: string;
+}
+export type StackErrorHandler = (error: unknown, req?: StackRequestLike) => Response;
+export interface ResolvedRoute<TEnv = unknown> {
+    path: string;
+    operation: OperationType<any, any, any, TEnv>;
+}
+export interface RouterMetadata {
+    basePath: string;
+    globalMiddlewares: unknown[];
+    procedures: Record<string, {
+        type: 'get' | 'post';
+    }>;
+    registeredPaths: string[];
+    errorHandler?: StackErrorHandler;
+    config?: Record<string, unknown>;
+}
+export interface StackRouter<TProcedures extends ProcedureRecord, TCtx = {}, TEnv = unknown> {
+    procedures: TProcedures;
+    routes: FlatRouteMap<TProcedures>;
+    metadata: RouterMetadata;
+    resolve(path: string, method: string): ResolvedRoute<TEnv> | null;
+}
+export interface StackExecutionContext<TCtx, TEnv> {
+    ctx: TCtx;
+    env: TEnv;
+    req: StackRequestLike;
+    c: StackResponseToolkit;
+}
+export {};

package/dist/stack/server/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vistagenic/vista",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "The React Framework for Visionaries - Rust-powered SSR with Server Components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -77,6 +77,14 @@
       "types": "./dist/config.d.ts",
       "default": "./dist/config.js"
     },
+    "./stack": {
+      "types": "./dist/stack/index.d.ts",
+      "default": "./dist/stack/index.js"
+    },
+    "./stack/client": {
+      "types": "./dist/stack/client/index.d.ts",
+      "default": "./dist/stack/client/index.js"
+    },
     "./client/rsc-router": {
       "types": "./dist/client/rsc-router.d.ts",
       "default": "./dist/client/rsc-router.js"
@@ -124,5 +132,6 @@
     "@types/webpack": "^5.28.5",
     "@types/webpack-hot-middleware": "^2.25.9",
     "typescript": "^5.7.2"
-  }
+  },
+  "gitHead": "4a9f1db26023c01465b997f6955b3d3a57b6ac84"
 }