@temporary-name/server 0.0.1-alpha.0cb08cf84b740850e7d8dcd1d8b87f78af26071b

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.CWiZN27E.d.mts

@@ -0,0 +1,39 @@
+import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
+import { C as Context, I as ImplementedResource, a as InferResourceContext } from './server.BTVDgKdb.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 ImplementedResource> {
+    private readonly matcher;
+    constructor(resources: T[]);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<InferResourceContext<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 };

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.D7jtfDRy.mjs

@@ -0,0 +1,288 @@
+import { parseHTTPEndpoint, HTTPMethods } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
+
+function apiResource(name, config) {
+  const { methods, ...restConfig } = config;
+  return { name, methods, config: restConfig };
+}
+function lazyResource(loader, endpoints) {
+  return { endpoints, loader };
+}
+function isLazyResource(resource) {
+  return "loader" in resource;
+}
+function unlazyResources(resources) {
+  return Promise.all(
+    resources.map(async (resource) => {
+      if (!isLazyResource(resource)) {
+        return resource;
+      }
+      const apiResource2 = await resource.loader();
+      validateLazyLoadedResource(resource, apiResource2);
+      return apiResource2;
+    })
+  );
+}
+function validateLazyLoadedResource(lazyResource2, loadedResource) {
+  const { endpoints } = lazyResource2;
+  const loadedLength = Object.keys(loadedResource.methods).length;
+  const endpointsLength = Object.keys(endpoints).length;
+  if (loadedLength !== endpointsLength) {
+    throw new Error(
+      `lazyResource loader returned an object with ${loadedLength} item(s), but the endpoints object has ${endpointsLength} item(s). These must match.`
+    );
+  }
+  for (const methodName in endpoints) {
+    const endpoint = endpoints[methodName];
+    const method = loadedResource.methods[methodName];
+    if (method === void 0) {
+      throw new Error(
+        `lazyResource endpoint "${methodName}" does not have a corresponding method in the object returned by the loader`
+      );
+    }
+    const [httpMethod, httpPath] = parseHTTPEndpoint(endpoint);
+    const { methodConfig } = method["~def"];
+    if (methodConfig.method !== httpMethod || methodConfig.path !== httpPath) {
+      throw new Error(
+        `lazyResource endpoint "${methodName}" routes to "${httpMethod} ${httpPath}", but the corresponding method from its loader routes to "${methodConfig.method} ${methodConfig.path}"`
+      );
+    }
+  }
+}
+
+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() {
+    const devExtra = {};
+    if (process.env.NODE_ENV === "development" && this.cause) {
+      devExtra.dev_only_details = this.cause instanceof Error ? { name: this.cause.name, message: this.cause.message, stack: this.cause.stack } : { cause: this.cause };
+    }
+    return {
+      ...devExtra,
+      type: this.constructor.type,
+      message: this.message,
+      ...this.extra
+    };
+  }
+}
+function safeTraverseData(data, path) {
+  let current = data;
+  for (const segment of path) {
+    if (current && typeof current === "object" && Object.prototype.hasOwnProperty.call(current, segment)) {
+      current = current[segment];
+    } else {
+      return null;
+    }
+  }
+  if (Array.isArray(current)) {
+    return "an array";
+  } else if (typeof current === "object") {
+    return "an object";
+  }
+  return `${typeof current}: ${JSON.stringify(current)}`;
+}
+function detailsFromValidationError(error) {
+  const issue = error.issues[0];
+  if (!issue) {
+    console.warn("ValidationError has no issues");
+    return null;
+  }
+  const param = issue.path.slice(1).join(".");
+  const location = issue.path[0];
+  if (issue.code === "invalid_type") {
+    const actualValue = safeTraverseData(error.data, issue.path);
+    if (actualValue === null) {
+      return {
+        code: "parameter_missing",
+        message: `Missing required parameter of type ${issue.expected}: ${String(issue.path.at(-1))}`,
+        location,
+        param
+      };
+    }
+    return {
+      code: "invalid_type",
+      message: `Expected ${issue.expected}, received ${actualValue}`,
+      location,
+      param
+    };
+  }
+  return {
+    code: issue.code,
+    message: issue.message,
+    param,
+    location
+  };
+}
+class BadRequestError extends ApiError {
+  static status = 400;
+  static type = "bad_request";
+  static extraSchema = {
+    code: z.string(),
+    param: z.string().optional(),
+    location: z.string().optional()
+  };
+  toJSON() {
+    if (this.cause instanceof ValidationError) {
+      return {
+        ...super.toJSON(),
+        ...detailsFromValidationError(this.cause) ?? {}
+      };
+    }
+    return super.toJSON();
+  }
+}
+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({
+    cause: error
+  });
+}
+function encodeError(error) {
+  return {
+    status: error.constructor.status,
+    headers: new Headers(),
+    body: { error: error.toJSON() }
+  };
+}
+
+function wrapShape(schema) {
+  return schema instanceof z.core.$ZodType ? schema : z.object(schema);
+}
+const zEmptyObject = z.object({});
+
+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(endpoint, schema) {
+  let pathSchema;
+  const [method, path] = parseHTTPEndpoint(endpoint);
+  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 = zEmptyObject;
+  }
+  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}".`);
+  }
+  return { method, path, pathSchema };
+}
+
+export { ApiError as A, BadRequestError as B, ConflictError as C, ForbiddenError as F, GatewayTimeoutError as G, InternalServerError as I, MethodNotAllowedError as M, NotFoundError as N, PreconditionFailedError as P, RequestTimeoutError as R, ServiceUnavailableError as S, TooManyRequestsError as T, UnauthorizedError as U, ValidationError as V, apiResource as a, NotAcceptableError as b, ContentTooLargeError as c, UnsupportedMediaTypeError as d, encodeError as e, UnprocessableContentError as f, getDynamicParams as g, NotImplementedError as h, isLazyResource as i, BadGatewayError as j, isApiErrorStatus as k, lazyResource as l, endpointRegex as m, isDevelopment as n, parseEndpointDefinition as p, standardizeHTTPPath as s, toApiError as t, unlazyResources as u, validateLazyLoadedResource as v, wrapShape as w, zEmptyObject as z };