@orpc/contract 0.0.0-next.a2e4a58 → 0.0.0-next.a4ecb29

package/dist/index.js

@@ -1,503 +0,0 @@
-// src/procedure.ts
-var ContractProcedure = class {
-  "~type" = "ContractProcedure";
-  "~orpc";
-  constructor(def) {
-    if (def.route?.successStatus && (def.route.successStatus < 200 || def.route?.successStatus > 299)) {
-      throw new Error("[ContractProcedure] The successStatus must be between 200 and 299");
-    }
-    if (Object.values(def.errorMap ?? {}).some((val) => val && val.status && (val.status < 400 || val.status > 599))) {
-      throw new Error("[ContractProcedure] The error status code must be in the 400-599 range.");
-    }
-    this["~orpc"] = def;
-  }
-};
-function isContractProcedure(item) {
-  if (item instanceof ContractProcedure) {
-    return true;
-  }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "ContractProcedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "InputSchema" in item["~orpc"] && "OutputSchema" in item["~orpc"] && "errorMap" in item["~orpc"];
-}
-
-// src/procedure-decorated.ts
-var DecoratedContractProcedure = class _DecoratedContractProcedure extends ContractProcedure {
-  static decorate(procedure) {
-    if (procedure instanceof _DecoratedContractProcedure) {
-      return procedure;
-    }
-    return new _DecoratedContractProcedure(procedure["~orpc"]);
-  }
-  errors(errors) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
-    });
-  }
-  route(route) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      route: {
-        ...this["~orpc"].route,
-        ...route
-      }
-    });
-  }
-  prefix(prefix) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      ...this["~orpc"].route?.path ? {
-        route: {
-          ...this["~orpc"].route,
-          path: `${prefix}${this["~orpc"].route.path}`
-        }
-      } : void 0
-    });
-  }
-  unshiftTag(...tags) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      route: {
-        ...this["~orpc"].route,
-        tags: [
-          ...tags,
-          ...this["~orpc"].route?.tags?.filter((tag) => !tags.includes(tag)) ?? []
-        ]
-      }
-    });
-  }
-};
-
-// src/procedure-builder-with-input.ts
-var ContractProcedureBuilderWithInput = class _ContractProcedureBuilderWithInput extends ContractProcedure {
-  errors(errors) {
-    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
-    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
-  }
-  route(route) {
-    const decorated = DecoratedContractProcedure.decorate(this).route(route);
-    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
-  }
-  prefix(prefix) {
-    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
-    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
-  }
-  unshiftTag(...tags) {
-    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
-    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
-  }
-  output(schema, example) {
-    return new DecoratedContractProcedure({
-      ...this["~orpc"],
-      OutputSchema: schema,
-      outputExample: example
-    });
-  }
-};
-
-// src/procedure-builder-with-output.ts
-var ContractProcedureBuilderWithOutput = class _ContractProcedureBuilderWithOutput extends ContractProcedure {
-  errors(errors) {
-    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
-    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
-  }
-  route(route) {
-    const decorated = DecoratedContractProcedure.decorate(this).route(route);
-    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
-  }
-  prefix(prefix) {
-    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
-    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
-  }
-  unshiftTag(...tags) {
-    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
-    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
-  }
-  input(schema, example) {
-    return new DecoratedContractProcedure({
-      ...this["~orpc"],
-      InputSchema: schema,
-      inputExample: example
-    });
-  }
-};
-
-// src/procedure-builder.ts
-var ContractProcedureBuilder = class _ContractProcedureBuilder extends ContractProcedure {
-  errors(errors) {
-    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
-    return new _ContractProcedureBuilder(decorated["~orpc"]);
-  }
-  route(route) {
-    const decorated = DecoratedContractProcedure.decorate(this).route(route);
-    return new _ContractProcedureBuilder(decorated["~orpc"]);
-  }
-  prefix(prefix) {
-    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
-    return new _ContractProcedureBuilder(decorated["~orpc"]);
-  }
-  unshiftTag(...tags) {
-    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
-    return new _ContractProcedureBuilder(decorated["~orpc"]);
-  }
-  input(schema, example) {
-    return new ContractProcedureBuilderWithInput({
-      ...this["~orpc"],
-      InputSchema: schema,
-      inputExample: example
-    });
-  }
-  output(schema, example) {
-    return new ContractProcedureBuilderWithOutput({
-      ...this["~orpc"],
-      OutputSchema: schema,
-      outputExample: example
-    });
-  }
-};
-
-// src/router-builder.ts
-var ContractRouterBuilder = class _ContractRouterBuilder {
-  "~type" = "ContractProcedure";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  prefix(prefix) {
-    return new _ContractRouterBuilder({
-      ...this["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
-    });
-  }
-  tag(...tags) {
-    return new _ContractRouterBuilder({
-      ...this["~orpc"],
-      tags: [...this["~orpc"].tags ?? [], ...tags]
-    });
-  }
-  errors(errors) {
-    return new _ContractRouterBuilder({
-      ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
-    });
-  }
-  router(router) {
-    if (isContractProcedure(router)) {
-      let decorated = DecoratedContractProcedure.decorate(router);
-      if (this["~orpc"].tags) {
-        decorated = decorated.unshiftTag(...this["~orpc"].tags);
-      }
-      if (this["~orpc"].prefix) {
-        decorated = decorated.prefix(this["~orpc"].prefix);
-      }
-      decorated = decorated.errors(this["~orpc"].errorMap);
-      return decorated;
-    }
-    const adapted = {};
-    for (const key in router) {
-      adapted[key] = this.router(router[key]);
-    }
-    return adapted;
-  }
-};
-
-// src/builder.ts
-var ContractBuilder = class _ContractBuilder extends ContractProcedure {
-  constructor(def) {
-    super(def);
-  }
-  config(config) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      config: {
-        ...this["~orpc"].config,
-        ...config
-      }
-    });
-  }
-  errors(errors) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
-    });
-  }
-  route(route) {
-    return new ContractProcedureBuilder({
-      route: {
-        ...this["~orpc"].config.initialRoute,
-        ...route
-      },
-      InputSchema: void 0,
-      OutputSchema: void 0,
-      errorMap: this["~orpc"].errorMap
-    });
-  }
-  input(schema, example) {
-    return new ContractProcedureBuilderWithInput({
-      route: this["~orpc"].config.initialRoute,
-      InputSchema: schema,
-      inputExample: example,
-      OutputSchema: void 0,
-      errorMap: this["~orpc"].errorMap
-    });
-  }
-  output(schema, example) {
-    return new ContractProcedureBuilderWithOutput({
-      route: this["~orpc"].config.initialRoute,
-      OutputSchema: schema,
-      outputExample: example,
-      InputSchema: void 0,
-      errorMap: this["~orpc"].errorMap
-    });
-  }
-  prefix(prefix) {
-    return new ContractRouterBuilder({
-      prefix,
-      errorMap: this["~orpc"].errorMap
-    });
-  }
-  tag(...tags) {
-    return new ContractRouterBuilder({
-      tags,
-      errorMap: this["~orpc"].errorMap
-    });
-  }
-  router(router) {
-    return new ContractRouterBuilder({
-      errorMap: this["~orpc"].errorMap
-    }).router(router);
-  }
-};
-
-// src/error-orpc.ts
-import { isPlainObject } from "@orpc/shared";
-var COMMON_ORPC_ERROR_DEFS = {
-  BAD_REQUEST: {
-    status: 400,
-    message: "Bad Request"
-  },
-  UNAUTHORIZED: {
-    status: 401,
-    message: "Unauthorized"
-  },
-  FORBIDDEN: {
-    status: 403,
-    message: "Forbidden"
-  },
-  NOT_FOUND: {
-    status: 404,
-    message: "Not Found"
-  },
-  METHOD_NOT_SUPPORTED: {
-    status: 405,
-    message: "Method Not Supported"
-  },
-  NOT_ACCEPTABLE: {
-    status: 406,
-    message: "Not Acceptable"
-  },
-  TIMEOUT: {
-    status: 408,
-    message: "Request Timeout"
-  },
-  CONFLICT: {
-    status: 409,
-    message: "Conflict"
-  },
-  PRECONDITION_FAILED: {
-    status: 412,
-    message: "Precondition Failed"
-  },
-  PAYLOAD_TOO_LARGE: {
-    status: 413,
-    message: "Payload Too Large"
-  },
-  UNSUPPORTED_MEDIA_TYPE: {
-    status: 415,
-    message: "Unsupported Media Type"
-  },
-  UNPROCESSABLE_CONTENT: {
-    status: 422,
-    message: "Unprocessable Content"
-  },
-  TOO_MANY_REQUESTS: {
-    status: 429,
-    message: "Too Many Requests"
-  },
-  CLIENT_CLOSED_REQUEST: {
-    status: 499,
-    message: "Client Closed Request"
-  },
-  INTERNAL_SERVER_ERROR: {
-    status: 500,
-    message: "Internal Server Error"
-  },
-  NOT_IMPLEMENTED: {
-    status: 501,
-    message: "Not Implemented"
-  },
-  BAD_GATEWAY: {
-    status: 502,
-    message: "Bad Gateway"
-  },
-  SERVICE_UNAVAILABLE: {
-    status: 503,
-    message: "Service Unavailable"
-  },
-  GATEWAY_TIMEOUT: {
-    status: 504,
-    message: "Gateway Timeout"
-  }
-};
-function fallbackORPCErrorStatus(code, status) {
-  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
-}
-function fallbackORPCErrorMessage(code, message) {
-  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
-}
-var ORPCError = class extends Error {
-  defined;
-  code;
-  status;
-  data;
-  constructor(options) {
-    if (options.status && (options.status < 400 || options.status >= 600)) {
-      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
-    }
-    const message = fallbackORPCErrorMessage(options.code, options.message);
-    super(message, options);
-    this.code = options.code;
-    this.status = fallbackORPCErrorStatus(options.code, options.status);
-    this.defined = options.defined ?? false;
-    this.data = options.data;
-  }
-  toJSON() {
-    return {
-      defined: this.defined,
-      code: this.code,
-      status: this.status,
-      message: this.message,
-      data: this.data
-    };
-  }
-  static isValidJSON(json) {
-    return isPlainObject(json) && "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
-  }
-};
-function isDefinedError(error) {
-  return error instanceof ORPCError && error.defined;
-}
-async function validateORPCError(map, error) {
-  const { code, status, message, data, cause, defined } = error;
-  const config = map?.[error.code];
-  if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
-    return defined ? new ORPCError({ defined: false, code, status, message, data, cause }) : error;
-  }
-  if (!config.data) {
-    return defined ? error : new ORPCError({ defined: true, code, status, message, data, cause });
-  }
-  const validated = await config.data["~standard"].validate(error.data);
-  if (validated.issues) {
-    return defined ? new ORPCError({ defined: false, code, status, message, data, cause }) : error;
-  }
-  return new ORPCError({
-    defined: true,
-    code,
-    status,
-    message,
-    data: validated.value,
-    cause
-  });
-}
-
-// src/client-utils.ts
-async function safe(promise) {
-  try {
-    const output = await promise;
-    return [output, void 0, false];
-  } catch (e) {
-    const error = e;
-    if (isDefinedError(error)) {
-      return [void 0, error, true];
-    }
-    return [void 0, error, false];
-  }
-}
-
-// src/config.ts
-var DEFAULT_CONFIG = {
-  defaultMethod: "POST",
-  defaultSuccessStatus: 200,
-  defaultSuccessDescription: "OK",
-  defaultInputStructure: "compact",
-  defaultOutputStructure: "compact"
-};
-function fallbackContractConfig(key, value) {
-  if (value === void 0) {
-    return DEFAULT_CONFIG[key];
-  }
-  return value;
-}
-
-// src/error.ts
-var ValidationError = class extends Error {
-  issues;
-  constructor(options) {
-    super(options.message, options);
-    this.issues = options.issues;
-  }
-};
-
-// src/schema-utils.ts
-function type(...[map]) {
-  return {
-    "~standard": {
-      vendor: "custom",
-      version: 1,
-      async validate(value) {
-        if (map) {
-          return { value: await map(value) };
-        }
-        return { value };
-      }
-    }
-  };
-}
-
-// src/index.ts
-var oc = new ContractBuilder({
-  errorMap: {},
-  InputSchema: void 0,
-  OutputSchema: void 0,
-  config: {}
-});
-export {
-  COMMON_ORPC_ERROR_DEFS,
-  ContractBuilder,
-  ContractProcedure,
-  ContractProcedureBuilder,
-  ContractProcedureBuilderWithInput,
-  ContractProcedureBuilderWithOutput,
-  ContractRouterBuilder,
-  DecoratedContractProcedure,
-  ORPCError,
-  ValidationError,
-  fallbackContractConfig,
-  fallbackORPCErrorMessage,
-  fallbackORPCErrorStatus,
-  isContractProcedure,
-  isDefinedError,
-  oc,
-  safe,
-  type,
-  validateORPCError
-};
-//# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,29 +0,0 @@
-import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
-import type { ContractProcedureDef, RouteOptions } from './procedure';
-import type { ContractRouter } from './router';
-import type { AdaptedContractRouter } from './router-builder';
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
-import { ContractProcedure } from './procedure';
-import { ContractProcedureBuilder } from './procedure-builder';
-import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input';
-import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output';
-import { ContractRouterBuilder } from './router-builder';
-export interface ContractBuilderConfig {
-    initialRoute?: RouteOptions;
-}
-export interface ContractBuilderDef<TErrorMap extends ErrorMap> extends ContractProcedureDef<undefined, undefined, TErrorMap> {
-    config: ContractBuilderConfig;
-}
-export declare class ContractBuilder<TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, TErrorMap> {
-    '~orpc': ContractBuilderDef<TErrorMap>;
-    constructor(def: ContractBuilderDef<TErrorMap>);
-    config(config: ContractBuilderConfig): ContractBuilder<TErrorMap>;
-    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractBuilder<U & TErrorMap>;
-    route(route: RouteOptions): ContractProcedureBuilder<TErrorMap>;
-    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap>;
-    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap>;
-    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap>;
-    tag(...tags: string[]): ContractRouterBuilder<TErrorMap>;
-    router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap>;
-}
-//# sourceMappingURL=builder.d.ts.map

package/dist/src/client-utils.d.ts

@@ -1,5 +0,0 @@
-import type { ClientPromiseResult } from './client';
-import { type ORPCError } from './error-orpc';
-export type SafeResult<TOutput, TError extends Error> = [output: TOutput, error: undefined, isDefinedError: false] | [output: undefined, error: TError, isDefinedError: false] | [output: undefined, error: Extract<TError, ORPCError<any, any>>, isDefinedError: true];
-export declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
-//# sourceMappingURL=client-utils.d.ts.map

package/dist/src/client.d.ts

@@ -1,19 +0,0 @@
-import type { AbortSignal } from './types';
-export type ClientOptions<TClientContext> = {
-    signal?: AbortSignal;
-} & (undefined extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-export type ClientRest<TClientContext, TInput> = [input: TInput, options: ClientOptions<TClientContext>] | (undefined extends TInput & TClientContext ? [] : never) | (undefined extends TClientContext ? [input: TInput] : never);
-export type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __typeError?: TError;
-};
-export interface Client<TClientContext, TInput, TOutput, TError extends Error> {
-    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
-}
-export type NestedClient<TClientContext> = Client<TClientContext, any, any, any> | {
-    [k: string]: NestedClient<TClientContext>;
-};
-//# sourceMappingURL=client.d.ts.map

package/dist/src/config.d.ts

@@ -1,10 +0,0 @@
-import type { HTTPMethod, InputStructure } from './types';
-export interface ContractConfig {
-    defaultMethod: HTTPMethod;
-    defaultSuccessStatus: number;
-    defaultSuccessDescription: string;
-    defaultInputStructure: InputStructure;
-    defaultOutputStructure: InputStructure;
-}
-export declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
-//# sourceMappingURL=config.d.ts.map

package/dist/src/error-map.d.ts

@@ -1,58 +0,0 @@
-import type { CommonORPCErrorCode } from './error-orpc';
-import type { Schema } from './types';
-export type ErrorMapItem<TDataSchema extends Schema> = {
-    /**
-     *
-     * @default 500
-     */
-    status?: number;
-    message?: string;
-    description?: string;
-    data?: TDataSchema;
-};
-export interface ErrorMap {
-    [k: string]: ErrorMapItem<Schema>;
-}
-/**
- * const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions
- *
- * Purpose:
- * - Helps `U` suggest `CommonORPCErrorCode` to the user when typing.
- *
- * Why not replace `ErrorMap` with `ErrorMapSuggestions`?
- * - `ErrorMapSuggestions` has a drawback: it allows `undefined` values for items.
- * - `ErrorMapGuard<TErrorMap>` uses `Partial`, which can introduce `undefined` values.
- *
- * This could lead to unintended behavior where `undefined` values override `TErrorMap`,
- * potentially resulting in a `never` type after merging.
- *
- * Recommendation:
- * - Use `ErrorMapSuggestions` to assist users in typing correctly but do not replace `ErrorMap`.
- * - Ensure `ErrorMapGuard<TErrorMap>` is adjusted to prevent `undefined` values.
- */
-export type ErrorMapSuggestions = {
-    [key in CommonORPCErrorCode | (string & {})]?: ErrorMapItem<Schema>;
-};
-/**
- * `U` extends `ErrorMap` & `ErrorMapGuard<TErrorMap>`
- *
- * `ErrorMapGuard` is a utility type that ensures `U` cannot redefine the structure of `TErrorMap`.
- * It achieves this by setting each key in `TErrorMap` to `never`, effectively preventing any redefinition.
- *
- * Why not just use `Partial<TErrorMap>`?
- * - Allowing users to redefine existing error map items would require using `StrictErrorMap`.
- * - However, I prefer not to use `StrictErrorMap` frequently, due to perceived performance concerns,
- *   though this has not been benchmarked and is based on personal preference.
- *
- */
-export type ErrorMapGuard<TErrorMap extends ErrorMap> = {
-    [K in keyof TErrorMap]?: never;
-};
-/**
- * Since `undefined` has a specific meaning (it use default value),
- * we ensure all additional properties in each item of the ErrorMap are explicitly set to `undefined`.
- */
-export type StrictErrorMap<T extends ErrorMap> = {
-    [K in keyof T]: T[K] & Partial<Record<Exclude<keyof ErrorMapItem<any>, keyof T[K]>, undefined>>;
-};
-//# sourceMappingURL=error-map.d.ts.map