@orpc/server 0.0.0-next.316c163 → 0.0.0-next.3191601

package/dist/fetch.js

@@ -1,112 +0,0 @@
-import {
-  createProcedureClient,
-  getRouterChild,
-  isProcedure,
-  unlazy
-} from "./chunk-FN62GL22.js";
-
-// src/fetch/handle-request.ts
-import { ORPCError } from "@orpc/shared/error";
-async function handleFetchRequest(options) {
-  for (const handler of options.handlers) {
-    const response = await handler(options);
-    if (response) {
-      return response;
-    }
-  }
-  const error = new ORPCError({ code: "NOT_FOUND", message: "Not found" });
-  return new Response(JSON.stringify(error.toJSON()), {
-    status: error.status,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-}
-
-// src/fetch/orpc-handler.ts
-import { executeWithHooks, ORPC_PROTOCOL_HEADER, ORPC_PROTOCOL_VALUE, trim, value } from "@orpc/shared";
-import { ORPCError as ORPCError2 } from "@orpc/shared/error";
-import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
-var serializer = new ORPCSerializer();
-var deserializer = new ORPCDeserializer();
-function createORPCHandler() {
-  return async (options) => {
-    if (!options.request.headers.get(ORPC_PROTOCOL_HEADER)?.includes(ORPC_PROTOCOL_VALUE)) {
-      return void 0;
-    }
-    const context = await value(options.context);
-    const handler = async () => {
-      const url = new URL(options.request.url);
-      const pathname = `/${trim(url.pathname.replace(options.prefix ?? "", ""), "/")}`;
-      const match = await resolveRouterMatch(options.router, pathname);
-      if (!match) {
-        throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
-      }
-      const input = await parseRequestInput(options.request);
-      const caller = createProcedureClient({
-        context,
-        procedure: match.procedure,
-        path: match.path
-      });
-      const output = await caller(input, { signal: options.signal });
-      const { body, headers } = serializer.serialize(output);
-      return new Response(body, {
-        status: 200,
-        headers
-      });
-    };
-    try {
-      return await executeWithHooks({
-        hooks: options,
-        context,
-        execute: handler,
-        input: options.request,
-        meta: {
-          signal: options.signal
-        }
-      });
-    } catch (error) {
-      return handleErrorResponse(error);
-    }
-  };
-}
-async function resolveRouterMatch(router, pathname) {
-  const pathSegments = trim(pathname, "/").split("/").map(decodeURIComponent);
-  const match = getRouterChild(router, ...pathSegments);
-  const { default: maybeProcedure } = await unlazy(match);
-  if (!isProcedure(maybeProcedure)) {
-    return void 0;
-  }
-  return {
-    procedure: maybeProcedure,
-    path: pathSegments
-  };
-}
-async function parseRequestInput(request) {
-  try {
-    return await deserializer.deserialize(request);
-  } catch (error) {
-    throw new ORPCError2({
-      code: "BAD_REQUEST",
-      message: "Cannot parse request. Please check the request body and Content-Type header.",
-      cause: error
-    });
-  }
-}
-function handleErrorResponse(error) {
-  const orpcError = error instanceof ORPCError2 ? error : new ORPCError2({
-    code: "INTERNAL_SERVER_ERROR",
-    message: "Internal server error",
-    cause: error
-  });
-  const { body, headers } = serializer.serialize(orpcError.toJSON());
-  return new Response(body, {
-    status: orpcError.status,
-    headers
-  });
-}
-export {
-  createORPCHandler,
-  handleFetchRequest
-};
-//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,518 +0,0 @@
-import {
-  LAZY_LOADER_SYMBOL,
-  Procedure,
-  createProcedureClient,
-  flatLazy,
-  getRouterChild,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  unlazy
-} from "./chunk-FN62GL22.js";
-
-// src/builder.ts
-import { ContractProcedure } from "@orpc/contract";
-
-// src/implementer-chainable.ts
-import { isContractProcedure } from "@orpc/contract";
-import { createCallableObject } from "@orpc/shared";
-
-// src/middleware-decorated.ts
-function decorateMiddleware(middleware) {
-  const decorated = middleware;
-  decorated.mapInput = (mapInput) => {
-    const mapped = decorateMiddleware(
-      (input, ...rest) => middleware(mapInput(input), ...rest)
-    );
-    return mapped;
-  };
-  decorated.concat = (concatMiddleware, mapInput) => {
-    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
-    const concatted = decorateMiddleware((input, context, meta, ...rest) => {
-      const next = async (options) => {
-        return mapped(input, mergeContext(context, options.context), meta, ...rest);
-      };
-      const merged = middleware(input, context, { ...meta, next }, ...rest);
-      return merged;
-    });
-    return concatted;
-  };
-  return decorated;
-}
-
-// src/procedure-decorated.ts
-import { DecoratedContractProcedure } from "@orpc/contract";
-function decorateProcedure(procedure) {
-  const caller = createProcedureClient({
-    procedure,
-    context: void 0
-  });
-  const decorated = caller;
-  decorated["~type"] = procedure["~type"];
-  decorated["~orpc"] = procedure["~orpc"];
-  decorated.prefix = (prefix) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).prefix(prefix)
-    }));
-  };
-  decorated.route = (route) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).route(route)
-    }));
-  };
-  decorated.use = (middleware, mapInput) => {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares: [...procedure["~orpc"].middlewares ?? [], middleware_]
-    }));
-  };
-  decorated.unshiftTag = (...tags) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).unshiftTag(...tags)
-    }));
-  };
-  decorated.unshiftMiddleware = (...middlewares) => {
-    if (procedure["~orpc"].middlewares?.length) {
-      let min = 0;
-      for (let i = 0; i < procedure["~orpc"].middlewares.length; i++) {
-        const index = middlewares.indexOf(procedure["~orpc"].middlewares[i], min);
-        if (index === -1) {
-          middlewares.push(...procedure["~orpc"].middlewares.slice(i));
-          break;
-        }
-        min = index + 1;
-      }
-    }
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares
-    }));
-  };
-  return decorated;
-}
-
-// src/procedure-implementer.ts
-var ProcedureImplementer = class _ProcedureImplementer {
-  "~type" = "ProcedureImplementer";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  use(middleware, mapInput) {
-    const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _ProcedureImplementer({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], mappedMiddleware]
-    });
-  }
-  func(func) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
-      contract: this["~orpc"].contract,
-      func
-    }));
-  }
-};
-
-// src/hidden.ts
-var ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
-function setRouterContract(obj, contract) {
-  return new Proxy(obj, {
-    get(target, key) {
-      if (key === ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getRouterContract(obj) {
-  return obj[ROUTER_CONTRACT_SYMBOL];
-}
-var LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
-function deepSetLazyRouterPrefix(router, prefix) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key !== LAZY_ROUTER_PREFIX_SYMBOL) {
-        const val = Reflect.get(target, key);
-        if (val && (typeof val === "object" || typeof val === "function")) {
-          return deepSetLazyRouterPrefix(val, prefix);
-        }
-        return val;
-      }
-      return prefix;
-    }
-  });
-}
-function getLazyRouterPrefix(obj) {
-  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
-}
-
-// src/lazy-utils.ts
-function createLazyProcedureFormAnyLazy(lazied) {
-  const lazyProcedure = lazy(async () => {
-    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
-    if (!isProcedure(maybeProcedure)) {
-      throw new Error(`
-            Expected a lazy<procedure> but got lazy<unknown>.
-            This should be caught by TypeScript compilation.
-            Please report this issue if this makes you feel uncomfortable.
-        `);
-    }
-    return { default: maybeProcedure };
-  });
-  return lazyProcedure;
-}
-
-// src/lazy-decorated.ts
-function decorateLazy(lazied) {
-  const flattenLazy = flatLazy(lazied);
-  const procedureProcedureClient = createProcedureClient({
-    procedure: createLazyProcedureFormAnyLazy(flattenLazy),
-    context: void 0
-  });
-  Object.assign(procedureProcedureClient, flattenLazy);
-  const recursive = new Proxy(procedureProcedureClient, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouterChild(flattenLazy, key);
-      return decorateLazy(next);
-    }
-  });
-  return recursive;
-}
-
-// src/router-builder.ts
-var RouterBuilder = class _RouterBuilder {
-  "~type" = "RouterBuilder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-    if (def.prefix && def.prefix.includes("{")) {
-      throw new Error(`
-        Dynamic routing in prefix not supported yet.
-        Please remove "{" from "${def.prefix}".
-      `);
-    }
-  }
-  prefix(prefix) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
-    });
-  }
-  tag(...tags) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      tags: [...this["~orpc"].tags ?? [], ...tags]
-    });
-  }
-  use(middleware) {
-    return new _RouterBuilder({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
-    });
-  }
-  router(router) {
-    const adapted = adapt(router, this["~orpc"]);
-    return adapted;
-  }
-  lazy(loader) {
-    const adapted = adapt(flatLazy(lazy(loader)), this["~orpc"]);
-    return adapted;
-  }
-};
-function adapt(item, options) {
-  if (isLazy(item)) {
-    const adaptedLazy = decorateLazy(lazy(async () => {
-      const routerOrProcedure = (await unlazy(item)).default;
-      const adapted2 = adapt(routerOrProcedure, options);
-      return { default: adapted2 };
-    }));
-    const lazyPrefix = getLazyRouterPrefix(item);
-    if (options.prefix || lazyPrefix) {
-      const prefixed = deepSetLazyRouterPrefix(adaptedLazy, `${options.prefix ?? ""}${lazyPrefix ?? ""}`);
-      return prefixed;
-    }
-    return adaptedLazy;
-  }
-  if (isProcedure(item)) {
-    let decorated = decorateProcedure(item);
-    if (options.tags?.length) {
-      decorated = decorated.unshiftTag(...options.tags);
-    }
-    if (options.prefix) {
-      decorated = decorated.prefix(options.prefix);
-    }
-    if (options.middlewares?.length) {
-      decorated = decorated.unshiftMiddleware(...options.middlewares);
-    }
-    return decorated;
-  }
-  const adapted = {};
-  for (const key in item) {
-    adapted[key] = adapt(item[key], options);
-  }
-  return adapted;
-}
-
-// src/router-implementer.ts
-var RouterImplementer = class _RouterImplementer {
-  "~type" = "RouterImplementer";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  use(middleware) {
-    return new _RouterImplementer({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
-    });
-  }
-  router(router) {
-    const adapted = new RouterBuilder(this["~orpc"]).router(router);
-    const contracted = setRouterContract(adapted, this["~orpc"].contract);
-    return contracted;
-  }
-  lazy(loader) {
-    const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
-    const contracted = setRouterContract(adapted, this["~orpc"].contract);
-    return contracted;
-  }
-};
-
-// src/implementer-chainable.ts
-function createChainableImplementer(contract, middlewares) {
-  if (isContractProcedure(contract)) {
-    const implementer = new ProcedureImplementer({
-      contract,
-      middlewares
-    });
-    return implementer;
-  }
-  const chainable = {};
-  for (const key in contract) {
-    chainable[key] = createChainableImplementer(contract[key], middlewares);
-  }
-  const routerImplementer = new RouterImplementer({ contract, middlewares });
-  const merged = new Proxy(chainable, {
-    get(target, key) {
-      const next = Reflect.get(target, key);
-      const method = Reflect.get(routerImplementer, key);
-      if (typeof key !== "string" || typeof method !== "function") {
-        return next;
-      }
-      if (!next) {
-        return method.bind(routerImplementer);
-      }
-      return createCallableObject(next, method.bind(routerImplementer));
-    }
-  });
-  return merged;
-}
-
-// src/procedure-builder.ts
-import {
-  DecoratedContractProcedure as DecoratedContractProcedure2
-} from "@orpc/contract";
-var ProcedureBuilder = class _ProcedureBuilder {
-  "~type" = "ProcedureBuilder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  route(route) {
-    return new _ProcedureBuilder({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).route(route)
-    });
-  }
-  input(schema, example) {
-    return new _ProcedureBuilder({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).input(schema, example)
-    });
-  }
-  output(schema, example) {
-    return new _ProcedureBuilder({
-      ...this["~orpc"],
-      contract: DecoratedContractProcedure2.decorate(this["~orpc"].contract).output(schema, example)
-    });
-  }
-  use(middleware, mapInput) {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this["~orpc"].contract,
-        middlewares: this["~orpc"].middlewares
-      }).use(middleware);
-    }
-    return new ProcedureImplementer({
-      contract: this["~orpc"].contract,
-      middlewares: this["~orpc"].middlewares
-    }).use(middleware, mapInput);
-  }
-  func(func) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
-      contract: this["~orpc"].contract,
-      func
-    }));
-  }
-};
-
-// src/builder.ts
-var Builder = class _Builder {
-  "~type" = "Builder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  context() {
-    return new _Builder({});
-  }
-  use(middleware) {
-    return new _Builder({
-      ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
-    });
-  }
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  route(route) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        route,
-        InputSchema: void 0,
-        OutputSchema: void 0
-      })
-    });
-  }
-  input(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example
-      })
-    });
-  }
-  output(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example
-      })
-    });
-  }
-  func(func) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: void 0
-      }),
-      func
-    }));
-  }
-  prefix(prefix) {
-    return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
-      prefix
-    });
-  }
-  tag(...tags) {
-    return new RouterBuilder({
-      middlewares: this["~orpc"].middlewares,
-      tags
-    });
-  }
-  router(router) {
-    return new RouterBuilder(this["~orpc"]).router(router);
-  }
-  lazy(loader) {
-    return new RouterBuilder(this["~orpc"]).lazy(loader);
-  }
-  contract(contract) {
-    return createChainableImplementer(contract, this["~orpc"].middlewares);
-  }
-};
-
-// src/router-client.ts
-function createRouterClient(options) {
-  if (isProcedure(options.router)) {
-    const caller = createProcedureClient({
-      ...options,
-      procedure: options.router,
-      context: options.context,
-      path: options.path
-    });
-    return caller;
-  }
-  const procedureCaller = isLazy(options.router) ? createProcedureClient({
-    ...options,
-    procedure: createLazyProcedureFormAnyLazy(options.router),
-    context: options.context,
-    path: options.path
-  }) : {};
-  const recursive = new Proxy(procedureCaller, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouterChild(options.router, key);
-      if (!next) {
-        return Reflect.get(target, key);
-      }
-      return createRouterClient({
-        ...options,
-        router: next,
-        path: [...options.path ?? [], key]
-      });
-    }
-  });
-  return recursive;
-}
-
-// src/index.ts
-export * from "@orpc/shared/error";
-var os = new Builder({});
-export {
-  Builder,
-  LAZY_LOADER_SYMBOL,
-  Procedure,
-  ProcedureBuilder,
-  ProcedureImplementer,
-  RouterBuilder,
-  RouterImplementer,
-  createChainableImplementer,
-  createProcedureClient,
-  createRouterClient,
-  decorateLazy,
-  decorateMiddleware,
-  decorateProcedure,
-  deepSetLazyRouterPrefix,
-  flatLazy,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  os,
-  setRouterContract,
-  unlazy
-};
-//# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,35 +0,0 @@
-import type { ANY_CONTRACT_PROCEDURE, ContractRouter, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { FlattenLazy } from './lazy';
-import type { Middleware } from './middleware';
-import type { DecoratedMiddleware } from './middleware-decorated';
-import type { Router } from './router';
-import type { AdaptedRouter } from './router-builder';
-import type { Context, MergeContext, WELL_CONTEXT } from './types';
-import { type ChainableImplementer } from './implementer-chainable';
-import { type ProcedureFunc } from './procedure';
-import { ProcedureBuilder } from './procedure-builder';
-import { type DecoratedProcedure } from './procedure-decorated';
-import { RouterBuilder } from './router-builder';
-export interface BuilderDef<TContext extends Context, TExtraContext extends Context> {
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any>[];
-}
-export declare class Builder<TContext extends Context, TExtraContext extends Context> {
-    '~type': "Builder";
-    '~orpc': BuilderDef<TContext, TExtraContext>;
-    constructor(def: BuilderDef<TContext, TExtraContext>);
-    context<UContext extends Context = WELL_CONTEXT>(): Builder<UContext, undefined>;
-    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown>): Builder<TContext, MergeContext<TExtraContext, U>>;
-    middleware<UExtraContext extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, TInput = unknown, TOutput = any>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput>): DecoratedMiddleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput>;
-    route(route: RouteOptions): ProcedureBuilder<TContext, TExtraContext, undefined, undefined>;
-    input<USchema extends Schema = undefined>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, undefined>;
-    output<USchema extends Schema = undefined>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, undefined, USchema>;
-    func<UFuncOutput = undefined>(func: ProcedureFunc<TContext, TExtraContext, undefined, undefined, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, undefined, undefined, UFuncOutput>;
-    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext>;
-    tag(...tags: string[]): RouterBuilder<TContext, TExtraContext>;
-    router<U extends Router<MergeContext<TContext, TExtraContext>, any>>(router: U): AdaptedRouter<TContext, U>;
-    lazy<U extends Router<MergeContext<TContext, TExtraContext>, any>>(loader: () => Promise<{
-        default: U;
-    }>): AdaptedRouter<TContext, FlattenLazy<U>>;
-    contract<U extends ANY_CONTRACT_PROCEDURE | ContractRouter>(contract: U): ChainableImplementer<TContext, TExtraContext, U>;
-}
-//# sourceMappingURL=builder.d.ts.map

package/dist/src/fetch/handle-request.d.ts

@@ -1,7 +0,0 @@
-import type { Context } from '../types';
-import type { FetchHandler, FetchHandlerOptions } from './types';
-export type HandleFetchRequestOptions<T extends Context> = FetchHandlerOptions<T> & {
-    handlers: readonly [FetchHandler, ...FetchHandler[]];
-};
-export declare function handleFetchRequest<T extends Context>(options: HandleFetchRequestOptions<T>): Promise<Response>;
-//# sourceMappingURL=handle-request.d.ts.map

package/dist/src/fetch/index.d.ts

@@ -1,4 +0,0 @@
-export * from './handle-request';
-export * from './orpc-handler';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/fetch/orpc-handler.d.ts

@@ -1,3 +0,0 @@
-import type { FetchHandler } from './types';
-export declare function createORPCHandler(): FetchHandler;
-//# sourceMappingURL=orpc-handler.d.ts.map