@temporary-name/server 1.9.3-alpha.f9f5ce625d5edee78250b87b3a64f1d9760c2244 → 1.9.3-alpha.fb7e3a67f82deaeffad5063e136b2f3c03c4b5b3

package/dist/shared/server.DvgWQUGK.mjs

@@ -0,0 +1,496 @@
+import * as z from '@temporary-name/zod';
+import { HTTPMethods } from '@temporary-name/shared';
+
+class ValidationError extends Error {
+  issues;
+  data;
+  constructor(options) {
+    super("Validation error");
+    this.issues = options.issues;
+    this.data = options.data;
+  }
+}
+class APIError extends Error {
+  extra;
+  static extraSchema = {};
+  static status;
+  static type;
+  static staticDefaultMessage = void 0;
+  constructor(...args) {
+    const { message, cause, ...extra } = args[0] ?? {};
+    super(message, { cause });
+    this.message = message ?? this.constructor.defaultMessage;
+    this.extra = extra;
+  }
+  static get defaultMessage() {
+    return this.staticDefaultMessage ?? this.type.split("_").map((word) => word[0]?.toUpperCase() + word.slice(1)).join(" ");
+  }
+  toJSON() {
+    return {
+      type: this.constructor.type,
+      message: this.message,
+      ...this.extra
+    };
+  }
+}
+class BadRequestError extends APIError {
+  static status = 400;
+  static type = "bad_request";
+  static extraSchema = { code: z.string() };
+}
+class UnauthorizedError extends APIError {
+  static status = 401;
+  static type = "unauthorized";
+}
+class ForbiddenError extends APIError {
+  static status = 403;
+  static type = "forbidden";
+}
+class NotFoundError extends APIError {
+  static status = 404;
+  static type = "not_found";
+}
+class InternalServerError extends APIError {
+  static status = 500;
+  static type = "internal_server_error";
+}
+const COMMON_ERRORS = {
+  BadRequestError,
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  MethodNotAllowedError: class MethodNotAllowedError extends APIError {
+    static status = 405;
+    static type = "method_not_allowed";
+  },
+  NotAcceptableError: class NotAcceptableError extends APIError {
+    static status = 406;
+    static type = "not_acceptable";
+  },
+  RequestTimeoutError: class RequestTimeoutError extends APIError {
+    static status = 408;
+    static type = "request_timeout";
+  },
+  ConflictError: class ConflictError extends APIError {
+    static status = 409;
+    static type = "conflict";
+  },
+  PreconditionFailedError: class PreconditionFailedError extends APIError {
+    static status = 412;
+    static type = "precondition_failed";
+  },
+  ContentTooLargeError: class ContentTooLargeError extends APIError {
+    static status = 413;
+    static type = "content_too_large";
+  },
+  UnsupportedMediaTypeError: class UnsupportedMediaTypeError extends APIError {
+    static status = 415;
+    static type = "unsupported_media_type";
+  },
+  UnprocessableContentError: class UnprocessableContentError extends APIError {
+    static status = 422;
+    static type = "unprocessable_content";
+  },
+  TooManyRequestsError: class TooManyRequestsError extends APIError {
+    static status = 429;
+    static type = "too_many_requests";
+  },
+  InternalServerError,
+  NotImplementedError: class NotImplementedError extends APIError {
+    static status = 501;
+    static type = "not_implemented";
+  },
+  BadGatewayError: class BadGatewayError extends APIError {
+    static status = 502;
+    static type = "bad_gateway";
+  },
+  ServiceUnavailableError: class ServiceUnavailableError extends APIError {
+    static status = 503;
+    static type = "service_unavailable";
+  },
+  GatewayTimeoutError: class GatewayTimeoutError extends APIError {
+    static status = 504;
+    static type = "gateway_timeout";
+  }
+};
+const DEFAULT_ERRORS_CONFIG = {
+  BadRequestError: { extraFields: { code: z.string() } },
+  UnauthorizedError: true,
+  ForbiddenError: true,
+  NotFoundError: true,
+  InternalServerError: true
+};
+function makeErrors(config) {
+  const configWithDefaults = { ...DEFAULT_ERRORS_CONFIG, ...config };
+  const errors = {};
+  for (const [key, value] of Object.entries(configWithDefaults)) {
+    if (key in COMMON_ERRORS) {
+      const errorClass = COMMON_ERRORS[key];
+      if (value === true) {
+        errors[key] = errorClass;
+      } else if (typeof value === "object") {
+        if ("extends" in value && value["extends"] !== key) {
+          throw new Error(
+            `Invalid error config for ${key}: cannot use extends for pre-defined error class. Please us a different name or remove extends.`
+          );
+        }
+        const extraSchema = value.extraFields;
+        const childErrorClass = class extends errorClass {
+          static extraSchema = { ...errorClass.extraSchema, ...extraSchema };
+        };
+        Object.defineProperty(childErrorClass, "name", { value: key });
+        errors[key] = childErrorClass;
+      }
+    } else {
+      if (typeof value === "boolean") {
+        throw new Error(
+          `Unknown error class ${key}: custom error classes should be defined as a class, not a boolean`
+        );
+      }
+      if (!("status" in value) || !("type" in value)) {
+        throw new Error(
+          `Invalid error config for ${key}: custom error classes must have a "status" and "type" property`
+        );
+      }
+      const { status, type, defaultMessage, extraFields } = value;
+      const childErrorClass = class extends APIError {
+        static status = status;
+        static type = type;
+        static staticDefaultMessage = defaultMessage;
+        static extraSchema = extraFields ?? {};
+      };
+      Object.defineProperty(childErrorClass, "name", { value: key });
+      errors[key] = childErrorClass;
+    }
+  }
+  return errors;
+}
+function isAPIErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+function toAPIError(error) {
+  if (error instanceof APIError) {
+    return error;
+  }
+  return new InternalServerError({
+    message: error instanceof Error ? error.message : void 0,
+    cause: error
+  });
+}
+function encodeError(error) {
+  return {
+    status: error.constructor.status,
+    headers: new Headers(),
+    body: error.toJSON()
+  };
+}
+
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
+    }
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
+}
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
+}
+
+class Contract {
+  /**
+   * This property holds the defined options.
+   */
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+}
+class Procedure extends Contract {
+}
+function isProcedure(item) {
+  return item instanceof Procedure || // This is so we'll return true for Proxy-wrapped Procedures e.g. as returned by `callable`
+  (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "route" in item["~orpc"] && "meta" in item["~orpc"] && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
+}
+
+function mergeRoute(a, b) {
+  return { ...a, ...b };
+}
+function prefixRoute(route, prefix) {
+  if (!route.path) {
+    return route;
+  }
+  return {
+    ...route,
+    path: `${prefix}${route.path}`
+  };
+}
+function unshiftTagRoute(route, tags) {
+  return {
+    ...route,
+    tags: [...tags, ...route.tags ?? []]
+  };
+}
+function mergePrefix(a, b) {
+  return a ? `${a}${b}` : b;
+}
+function mergeTags(a, b) {
+  return a ? [...a, ...b] : b;
+}
+function enhanceRoute(route, options) {
+  let router = route;
+  if (options.prefix) {
+    router = prefixRoute(router, options.prefix);
+  }
+  if (options.tags?.length) {
+    router = unshiftTagRoute(router, options.tags);
+  }
+  return router;
+}
+
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
+    }
+    if (isProcedure(current)) {
+      return void 0;
+    }
+    if (!isLazy(current)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return lazyInternal(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
+}
+function createAccessibleLazyRouter(lazied) {
+  const recursive = new Proxy(lazied, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouter(lazied, [key]);
+      return createAccessibleLazyRouter(next);
+    }
+  });
+  return recursive;
+}
+function enhanceRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazyInternal(
+      async () => {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = enhanceRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      },
+      {
+        ...laziedMeta,
+        prefix: enhancedPrefix
+      }
+    );
+    const accessible = createAccessibleLazyRouter(enhanced2);
+    return accessible;
+  }
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
+      dedupeLeading: options.dedupeLeadingMiddlewares
+    });
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      route: enhanceRoute(router["~orpc"].route, options),
+      middlewares: newMiddlewares,
+      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
+    });
+    return enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceRouter(router[key], options);
+  }
+  return enhanced;
+}
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  const currentRouter = options.router;
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
+      path: options.path
+    });
+  } else if (currentRouter instanceof Contract) {
+    callback({
+      contract: currentRouter,
+      path: options.path
+    });
+  } else if (typeof currentRouter === "string") {
+    throw new Error("Unexpected: got string instead of router");
+  } else {
+    for (const key in currentRouter) {
+      traverseContractProcedures(
+        {
+          router: currentRouter[key],
+          path: [...options.path, key]
+        },
+        callback,
+        lazyOptions
+      );
+    }
+  }
+  return lazyOptions;
+}
+async function resolveContractProcedures(options, callback) {
+  const pending = [options];
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
+      pending.push({
+        router,
+        path: options3.path
+      });
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (isProcedure(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazyInternal(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function lazy(prefix, loader) {
+  return enhanceRouter(lazyInternal(loader), {
+    middlewares: [],
+    dedupeLeadingMiddlewares: true,
+    prefix
+  });
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
+const endpointRegex = new RegExp(`^(${HTTPMethods.join("|")})`);
+function isDevelopment() {
+  return process.env.NODE_ENV === "development";
+}
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+function parseEndpointDefinition(stringsOrEndpoint, values) {
+  let method, path, pathSchema;
+  if (stringsOrEndpoint instanceof Array) {
+    let endpoint = stringsOrEndpoint[0];
+    if (endpoint === void 0 || !endpointRegex.test(endpoint)) {
+      throw new Error(".endpoint() must start with a valid HTTP endpoint string.");
+    }
+    const shape = {};
+    for (let i = 1; i < stringsOrEndpoint.length; i++) {
+      const str = stringsOrEndpoint[i];
+      const value = values[i - 1];
+      if (typeof value !== "object" || value instanceof z.core.$ZodType) {
+        throw new Error(
+          `Each template value for .endpoint must be an object with a single key, whose value is a ZodType.`
+        );
+      }
+      const valueEntries = Object.entries(value);
+      if (valueEntries.length !== 1) {
+        throw new Error(
+          `Each template value for .endpoint must be an object with a single key, whose value is a ZodType.`
+        );
+      }
+      const [key, schema] = valueEntries[0];
+      endpoint += `{${key}}${str}`;
+      if (key in schema) {
+        throw new Error(`Duplicate path parameter name "${key}" in endpoint.`);
+      }
+      shape[key] = schema;
+    }
+    [method, path] = endpoint.split(" ", 2);
+    pathSchema = z.object(shape);
+  } else if (values.length <= 1) {
+    const endpoint = stringsOrEndpoint;
+    const schema = values[0];
+    [method, path] = endpoint.split(" ", 2);
+    const pathParamNames = getDynamicParams(path)?.map((p) => p.name) ?? [];
+    let schemaKeys;
+    if (schema instanceof z.core.$ZodType) {
+      if (schema instanceof z.core.$ZodObject) {
+        schemaKeys = Object.keys(schema._zod.def.shape);
+        pathSchema = schema;
+      } else {
+        throw new Error(
+          `Path schema for endpoint "${endpoint}" must be a ZodObject schema (or object where each value is a ZodType).`
+        );
+      }
+    } else if (typeof schema === "object") {
+      schemaKeys = Object.keys(schema);
+      pathSchema = z.object(schema);
+    } else if (schema !== void 0) {
+      throw new Error(
+        `Path schema for endpoint "${endpoint}" must be a ZodObject schema (or object where each value is a ZodType).`
+      );
+    } else {
+      schemaKeys = [];
+      pathSchema = z.object({});
+    }
+    if (pathParamNames.length !== schemaKeys.length || !pathParamNames.every((name) => schemaKeys.includes(name))) {
+      throw new Error(`Path schema keys do not match dynamic parameters in endpoint "${endpoint}".`);
+    }
+  } else {
+    throw new Error("Invalid arguments for .endpoint() method.");
+  }
+  return { method, path, pathSchema };
+}
+
+export { APIError as A, BadRequestError as B, Contract as C, endpointRegex as D, isDevelopment as E, ForbiddenError as F, InternalServerError as I, LAZY_SYMBOL as L, NotFoundError as N, Procedure as P, UnauthorizedError as U, ValidationError as V, mergeTags as a, enhanceRouter as b, mergeRoute as c, prefixRoute as d, encodeError as e, addMiddleware as f, getDynamicParams as g, getLazyMeta as h, isAPIErrorStatus as i, isProcedure as j, makeErrors as k, lazyInternal as l, mergePrefix as m, lazy as n, isLazy as o, parseEndpointDefinition as p, isStartWithMiddlewares as q, resolveContractProcedures as r, standardizeHTTPPath as s, toAPIError as t, unlazy as u, mergeMiddlewares as v, getRouter as w, createAccessibleLazyRouter as x, traverseContractProcedures as y, unlazyRouter as z };

package/dist/shared/server.hAH-LVh_.d.mts

@@ -0,0 +1,39 @@
+import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
+import { C as Context, m as Router } from './server.BwcJq6aP.mjs';
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    constructor(router: Router<T>);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
+}
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+/**
+ * {@link https://github.com/unjs/rou3}
+ *
+ * @internal
+ */
+declare function toRou3Pattern(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function decodeParams(params: Record<string, string>): Record<string, string>;
+
+export { StandardHandler as b, decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+export type { FriendlyStandardHandleOptions as F, StandardHandleOptions as S, StandardHandleResult as a };