@temporary-name/server 1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d → 1.9.3-alpha.59a0ffc2afa5d7ac78321380832e510591ebe734

package/dist/shared/server.Bx9JTGMu.mjs

@@ -0,0 +1,433 @@
+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;
+  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.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 MethodNotAllowedError extends APIError {
+  static status = 405;
+  static type = "method_not_allowed";
+}
+class NotAcceptableError extends APIError {
+  static status = 406;
+  static type = "not_acceptable";
+}
+class RequestTimeoutError extends APIError {
+  static status = 408;
+  static type = "request_timeout";
+}
+class ConflictError extends APIError {
+  static status = 409;
+  static type = "conflict";
+}
+class PreconditionFailedError extends APIError {
+  static status = 412;
+  static type = "precondition_failed";
+}
+class ContentTooLargeError extends APIError {
+  static status = 413;
+  static type = "content_too_large";
+}
+class UnsupportedMediaTypeError extends APIError {
+  static status = 415;
+  static type = "unsupported_media_type";
+}
+class UnprocessableContentError extends APIError {
+  static status = 422;
+  static type = "unprocessable_content";
+}
+class TooManyRequestsError extends APIError {
+  static status = 429;
+  static type = "too_many_requests";
+}
+class InternalServerError extends APIError {
+  static status = 500;
+  static type = "internal_server_error";
+}
+class NotImplementedError extends APIError {
+  static status = 501;
+  static type = "not_implemented";
+}
+class BadGatewayError extends APIError {
+  static status = 502;
+  static type = "bad_gateway";
+}
+class ServiceUnavailableError extends APIError {
+  static status = 503;
+  static type = "service_unavailable";
+}
+class GatewayTimeoutError extends APIError {
+  static status = 504;
+  static type = "gateway_timeout";
+}
+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, isLazy as D, isStartWithMiddlewares as E, ForbiddenError as F, GatewayTimeoutError as G, mergeMiddlewares as H, InternalServerError as I, getRouter as J, createAccessibleLazyRouter as K, LAZY_SYMBOL as L, MethodNotAllowedError as M, NotFoundError as N, traverseContractProcedures as O, Procedure as P, unlazyRouter as Q, RequestTimeoutError as R, ServiceUnavailableError as S, TooManyRequestsError as T, UnauthorizedError as U, ValidationError as V, endpointRegex as W, isDevelopment as X, 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, NotAcceptableError as k, lazyInternal as l, mergePrefix as m, ConflictError as n, PreconditionFailedError as o, parseEndpointDefinition as p, ContentTooLargeError as q, resolveContractProcedures as r, standardizeHTTPPath as s, toAPIError as t, unlazy as u, UnsupportedMediaTypeError as v, UnprocessableContentError as w, NotImplementedError as x, BadGatewayError as y, lazy as z };

package/dist/shared/server.C1RJffw4.mjs

@@ -0,0 +1,30 @@
+import { parse, serialize } from 'cookie';
+
+function setCookie(headers, name, value, options = {}) {
+  if (headers === void 0) {
+    return;
+  }
+  const cookieString = serialize(name, value, {
+    path: "/",
+    ...options
+  });
+  headers.append("Set-Cookie", cookieString);
+}
+function getCookie(headers, name, options = {}) {
+  if (headers === void 0) {
+    return void 0;
+  }
+  const cookieHeader = headers.get("cookie");
+  if (cookieHeader === null) {
+    return void 0;
+  }
+  return parse(cookieHeader, options)[name];
+}
+function deleteCookie(headers, name, options = {}) {
+  return setCookie(headers, name, "", {
+    ...options,
+    maxAge: 0
+  });
+}
+
+export { deleteCookie as d, getCookie as g, setCookie as s };

package/dist/shared/server.CjPiuQYH.d.mts

@@ -0,0 +1,51 @@
+import { JSONSchema, SchemaConverter } from '@temporary-name/server/openapi';
+
+interface ZodToJsonSchemaConverterOptions {
+    /**
+     * Max depth of lazy type.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 2
+     */
+    maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
+    /**
+     * The schema to be used to represent the any | unknown type.
+     *
+     * @default { }
+     */
+    anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used to represent the undefined type.
+     *
+     * @default { not: {} }
+     */
+    undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
+}
+declare class ZodToJsonSchemaConverter {
+    #private;
+    private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
+    private readonly anyJsonSchema;
+    private readonly unsupportedJsonSchema;
+    private readonly undefinedJsonSchema;
+    constructor(options?: ZodToJsonSchemaConverterOptions);
+    convert: SchemaConverter;
+}
+
+export { ZodToJsonSchemaConverter as a };
+export type { ZodToJsonSchemaConverterOptions as Z };

package/dist/shared/server.CjPiuQYH.d.ts

@@ -0,0 +1,51 @@
+import { JSONSchema, SchemaConverter } from '@temporary-name/server/openapi';
+
+interface ZodToJsonSchemaConverterOptions {
+    /**
+     * Max depth of lazy type.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 2
+     */
+    maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
+    /**
+     * The schema to be used to represent the any | unknown type.
+     *
+     * @default { }
+     */
+    anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used to represent the undefined type.
+     *
+     * @default { not: {} }
+     */
+    undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
+}
+declare class ZodToJsonSchemaConverter {
+    #private;
+    private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
+    private readonly anyJsonSchema;
+    private readonly unsupportedJsonSchema;
+    private readonly undefinedJsonSchema;
+    constructor(options?: ZodToJsonSchemaConverterOptions);
+    convert: SchemaConverter;
+}
+
+export { ZodToJsonSchemaConverter as a };
+export type { ZodToJsonSchemaConverterOptions as Z };

package/dist/shared/server.DLyn62VH.d.mts

@@ -0,0 +1,39 @@
+import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
+import { C as Context, m as Router } from './server.DpIhEnBO.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 };