@epoch32/visage 0.0.0-stage → 0.0.0

package/src/rpc/error.ts

@@ -0,0 +1,70 @@
+import type { ValidationIssue } from "../form/schema";
+import type { RPCErrorCode } from "./types";
+
+export const ERROR_CODE_TO_STATUS: Record<RPCErrorCode, number> = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  TIMEOUT: 408,
+  CONFLICT: 409,
+  UNPROCESSABLE_CONTENT: 422,
+  INTERNAL_SERVER_ERROR: 500
+};
+
+export const STATUS_TO_ERROR_CODE: Record<number, RPCErrorCode> = {
+  400: "BAD_REQUEST",
+  401: "UNAUTHORIZED",
+  403: "FORBIDDEN",
+  404: "NOT_FOUND",
+  405: "METHOD_NOT_ALLOWED",
+  408: "TIMEOUT",
+  409: "CONFLICT",
+  422: "UNPROCESSABLE_CONTENT",
+  500: "INTERNAL_SERVER_ERROR"
+};
+
+export class RPCError extends Error {
+  readonly code: RPCErrorCode;
+  readonly status: number;
+  readonly issues?: ValidationIssue[];
+
+  constructor(
+    codeOrStatusOrOptions:
+      | RPCErrorCode
+      | number
+      | {
+          code: RPCErrorCode;
+          message?: string;
+          issues?: ValidationIssue[];
+          cause?: unknown;
+        },
+    message?: string
+  ) {
+    if (typeof codeOrStatusOrOptions === "number") {
+      const code = STATUS_TO_ERROR_CODE[codeOrStatusOrOptions] || "INTERNAL_SERVER_ERROR";
+      super(message || code);
+      this.name = "RPCError";
+      this.code = code;
+      this.status = codeOrStatusOrOptions;
+    } else if (typeof codeOrStatusOrOptions === "string") {
+      super(message || codeOrStatusOrOptions);
+      this.name = "RPCError";
+      this.code = codeOrStatusOrOptions;
+      this.status = ERROR_CODE_TO_STATUS[codeOrStatusOrOptions] || 500;
+    } else {
+      super(codeOrStatusOrOptions.message ?? codeOrStatusOrOptions.code, {
+        cause: codeOrStatusOrOptions.cause
+      });
+      this.name = "RPCError";
+      this.code = codeOrStatusOrOptions.code;
+      this.status = ERROR_CODE_TO_STATUS[codeOrStatusOrOptions.code] ?? 500;
+      this.issues = codeOrStatusOrOptions.issues;
+    }
+  }
+
+  get statusCode(): number {
+    return this.status;
+  }
+}

package/src/rpc/index.ts

@@ -0,0 +1,52 @@
+export {
+  Schema,
+  type SchemaLike,
+  type StandardSchemaV1,
+  type ValidationIssue,
+  type ValidationResult,
+  v,
+  validateWithSchema
+} from "../form/schema";
+export { createClient } from "./client";
+export {
+  ERROR_CODE_TO_STATUS,
+  RPCError,
+  STATUS_TO_ERROR_CODE
+} from "./error";
+export {
+  createProcedure,
+  executeProcedure
+} from "./procedure";
+export {
+  createRouter,
+  mutation,
+  query,
+  RouterImpl,
+  subscription
+} from "./router";
+export { createFetchHandler } from "./server";
+export type {
+  ClientMutationMethod,
+  ClientOptions,
+  ClientProcedure,
+  ClientQueryMethod,
+  ClientRouter,
+  ClientSubscriptionMethod,
+  CORSOptions,
+  FetchHandlerOptions,
+  InferProcedureInput,
+  InferProcedureOutput,
+  MiddlewareFn,
+  Procedure,
+  ProcedureOptions,
+  ProcedureRecord,
+  ProcedureType,
+  Router,
+  Router as RPCRouter,
+  RPCErrorCode,
+  RPCResponse,
+  RPCResponseError,
+  RPCResponseSuccess,
+  SubscriptionCallbacks,
+  SubscriptionHandle
+} from "./types";

package/src/rpc/procedure.ts

@@ -0,0 +1,88 @@
+import { validateWithSchema } from "../form/schema";
+import { RPCError } from "./error";
+import type { MiddlewareFn, Procedure, ProcedureOptions, ProcedureType } from "./types";
+
+export function createProcedure<
+  TType extends ProcedureType,
+  TInput = any,
+  TOutput = any,
+  TContext = any
+>(
+  type: TType,
+  options: ProcedureOptions<TInput, TOutput, TContext>,
+  middlewares: MiddlewareFn<any, any>[] = []
+): Procedure<TType, TInput, TOutput, TContext> {
+  return {
+    type,
+    inputSchema: options.input,
+    outputSchema: options.output,
+    middlewares: [...middlewares],
+    resolve: options.resolve as any
+  };
+}
+
+export async function executeProcedure(
+  procedure: Procedure<any, any, any, any>,
+  opts: {
+    rawInput: unknown;
+    ctx: any;
+    req: Request;
+    signal: AbortSignal;
+  }
+): Promise<any> {
+  let input = opts.rawInput;
+
+  if (procedure.inputSchema) {
+    const res = validateWithSchema(procedure.inputSchema, opts.rawInput);
+    if (!res.success) {
+      throw new RPCError({
+        code: "BAD_REQUEST",
+        message: "Invalid procedure input",
+        issues: res.issues
+      });
+    }
+    input = res.data;
+  }
+
+  // Middleware pipeline runner
+  let currentIndex = 0;
+  let currentContext = opts.ctx;
+
+  const runPipeline = async (ctx: any): Promise<any> => {
+    currentContext = ctx;
+    if (currentIndex < procedure.middlewares.length) {
+      const mw = procedure.middlewares[currentIndex++]!;
+      return mw({
+        ctx: currentContext,
+        req: opts.req,
+        signal: opts.signal,
+        next: async (nextOpts) => {
+          return runPipeline(nextOpts?.ctx ?? currentContext);
+        }
+      });
+    }
+
+    return procedure.resolve({
+      input,
+      ctx: currentContext,
+      req: opts.req,
+      signal: opts.signal
+    });
+  };
+
+  const output = await runPipeline(currentContext);
+
+  if (procedure.outputSchema && procedure.type !== "subscription") {
+    const res = validateWithSchema(procedure.outputSchema, output);
+    if (!res.success) {
+      throw new RPCError({
+        code: "INTERNAL_SERVER_ERROR",
+        message: "Invalid procedure output",
+        issues: res.issues
+      });
+    }
+    return res.data;
+  }
+
+  return output;
+}

package/src/rpc/router.ts

@@ -0,0 +1,105 @@
+import { createProcedure } from "./procedure";
+import type { MiddlewareFn, Procedure, ProcedureOptions, ProcedureRecord, Router } from "./types";
+
+export class RouterImpl<TRecord extends ProcedureRecord = ProcedureRecord, TContext = any>
+  implements Router<TRecord, TContext>
+{
+  _def: {
+    record: TRecord;
+    middlewares: MiddlewareFn<any, any>[];
+  };
+
+  constructor(record: TRecord = {} as TRecord, middlewares: MiddlewareFn<any, any>[] = []) {
+    this._def = {
+      record: { ...record },
+      middlewares: [...middlewares]
+    };
+  }
+
+  query(name: string, options: any): any {
+    const proc = createProcedure("query", options, this._def.middlewares);
+    const newRecord = {
+      ...this._def.record,
+      [name]: proc
+    };
+
+    return new RouterImpl(newRecord, this._def.middlewares);
+  }
+
+  mutation(name: string, options: any): any {
+    const proc = createProcedure("mutation", options, this._def.middlewares);
+    const newRecord = {
+      ...this._def.record,
+      [name]: proc
+    };
+
+    return new RouterImpl(newRecord, this._def.middlewares);
+  }
+
+  subscription(name: string, options: any): any {
+    const proc = createProcedure("subscription", options, this._def.middlewares);
+    const newRecord = {
+      ...this._def.record,
+      [name]: proc
+    };
+
+    return new RouterImpl(newRecord, this._def.middlewares);
+  }
+
+  use<TNewContext = TContext>(
+    middleware: MiddlewareFn<TContext, TNewContext>
+  ): Router<TRecord, TNewContext> {
+    const updatedMiddlewares = [...this._def.middlewares, middleware];
+    // Re-bind existing procedures with new middleware
+    const updatedRecord: ProcedureRecord = {};
+    for (const key in this._def.record) {
+      const item = this._def.record[key]!;
+      if ("type" in item) {
+        updatedRecord[key] = {
+          ...item,
+          middlewares: [...updatedMiddlewares]
+        };
+      } else {
+        updatedRecord[key] = item;
+      }
+    }
+    return new RouterImpl(updatedRecord as TRecord, updatedMiddlewares);
+  }
+
+  merge<TPrefix extends string, TSubRecord extends ProcedureRecord>(
+    prefix: TPrefix,
+    router: Router<TSubRecord, TContext>
+  ): Router<TRecord & { [K in TPrefix]: Router<TSubRecord, TContext> }, TContext> {
+    const newRecord = {
+      ...this._def.record,
+      [prefix]: router
+    } as TRecord & { [K in TPrefix]: Router<TSubRecord, TContext> };
+
+    return new RouterImpl(newRecord, this._def.middlewares);
+  }
+}
+
+export function createRouter<
+  TRecord extends ProcedureRecord = Record<string, never>,
+  TContext = any
+>(record?: TRecord): Router<TRecord, TContext> {
+  return new RouterImpl<TRecord, TContext>(record ?? ({} as TRecord));
+}
+
+export function query<TInput = any, TOutput = any, TContext = any>(
+  options: ProcedureOptions<TInput, TOutput, TContext>
+): Procedure<"query", TInput, TOutput, TContext> {
+  return createProcedure("query", options);
+}
+
+export function mutation<TInput = any, TOutput = any, TContext = any>(
+  options: ProcedureOptions<TInput, TOutput, TContext>
+): Procedure<"mutation", TInput, TOutput, TContext> {
+  return createProcedure("mutation", options);
+}
+
+export function subscription<TInput = any, TOutput = any, TContext = any>(
+  options: ProcedureOptions<TInput, TOutput, TContext>
+): Procedure<"subscription", TInput, TOutput, TContext> {
+  return createProcedure("subscription", options);
+}