@temporary-name/server 1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05 → 1.9.3-alpha.62d88f5cf3908d4411b5278f1824b69334da8072

package/dist/shared/server.Blt424vz.mjs

@@ -0,0 +1,523 @@
+import { isAsyncIteratorObject, toArray } from '@temporary-name/shared';
+import { mapEventIterator } from '@temporary-name/standard-server';
+import { custom, safeParseAsync } from '@temporary-name/zod';
+import { V as ValidationError } from './server.MJ43MXYj.mjs';
+import { JSONSchemaFormat, JSONSchemaContentEncoding } from '@temporary-name/server/openapi';
+import { registry, globalRegistry } from 'zod/v4/core';
+
+const EVENT_ITERATOR_DETAILS_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_DETAILS");
+function eventIterator(yields, returns) {
+  const schema = custom(
+    (iterator) => isAsyncIteratorObject(iterator)
+  ).transform((iterator) => {
+    const mapped = mapEventIterator(iterator, {
+      async value(value, done) {
+        const schema2 = done ? returns : yields;
+        if (!schema2) {
+          return value;
+        }
+        const result = await safeParseAsync(schema2, value);
+        if (result.success) {
+          return result.data;
+        } else {
+          throw new Error("Event iterator validation failed", {
+            cause: new ValidationError({
+              issues: result.error.issues,
+              data: value
+            })
+          });
+        }
+      },
+      error: async (error) => error
+    });
+    return mapped;
+  });
+  schema[EVENT_ITERATOR_DETAILS_SYMBOL] = {
+    yields,
+    returns
+  };
+  return schema;
+}
+function getEventIteratorSchemaDetails(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  return schema[EVENT_ITERATOR_DETAILS_SYMBOL];
+}
+
+var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
+  JsonSchemaXNativeType2["BigInt"] = "bigint";
+  JsonSchemaXNativeType2["RegExp"] = "regexp";
+  JsonSchemaXNativeType2["Date"] = "date";
+  JsonSchemaXNativeType2["Url"] = "url";
+  JsonSchemaXNativeType2["Set"] = "set";
+  JsonSchemaXNativeType2["Map"] = "map";
+  return JsonSchemaXNativeType2;
+})(JsonSchemaXNativeType || {});
+
+const JSON_SCHEMA_REGISTRY = registry();
+const JSON_SCHEMA_INPUT_REGISTRY = registry();
+const JSON_SCHEMA_OUTPUT_REGISTRY = registry();
+
+class ZodToJsonSchemaConverter {
+  maxLazyDepth;
+  maxStructureDepth;
+  anyJsonSchema;
+  unsupportedJsonSchema;
+  undefinedJsonSchema;
+  constructor(options = {}) {
+    this.maxLazyDepth = options.maxLazyDepth ?? 2;
+    this.maxStructureDepth = options.maxStructureDepth ?? 10;
+    this.anyJsonSchema = options.anyJsonSchema ?? {};
+    this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
+    this.undefinedJsonSchema = options.undefinedJsonSchema ?? { not: {} };
+  }
+  convert = (schema, options) => {
+    return this.#convert(schema, options, 0, 0);
+  };
+  #convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {
+    if (structureDepth > this.maxStructureDepth) {
+      return [false, this.anyJsonSchema];
+    }
+    if (!options.minStructureDepthForRef || options.minStructureDepthForRef <= structureDepth) {
+      const components = toArray(options.components);
+      for (const component of components) {
+        if (component.schema === schema && component.allowedStrategies.includes(options.strategy)) {
+          return [component.required, { $ref: component.ref }];
+        }
+      }
+    }
+    if (!isHandledCustomJSONSchema) {
+      const customJSONSchema = this.#getCustomJsonSchema(schema, options);
+      if (customJSONSchema) {
+        const [required, json] = this.#convert(schema, options, lazyDepth, structureDepth, true);
+        return [required, { ...json, ...customJSONSchema }];
+      }
+    }
+    switch (schema._zod.def.type) {
+      case "string": {
+        const string = schema;
+        const json = { type: "string" };
+        const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
+        if (typeof minimum === "number") {
+          json.minLength = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxLength = maximum;
+        }
+        if (typeof contentEncoding === "string") {
+          json.contentEncoding = this.#handleContentEncoding(contentEncoding);
+        }
+        if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) {
+          json.format = this.#handleStringFormat(format);
+        }
+        if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) {
+          for (const pattern of patterns) {
+            if (json.pattern === void 0) {
+              json.pattern = pattern.source;
+            } else {
+              json.allOf ??= [];
+              json.allOf.push({ pattern: pattern.source });
+            }
+          }
+        }
+        if (format === "jwt" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) {
+          json.pattern = /^[\w-]+\.[\w-]+\.[\w-]+$/.source;
+        }
+        return [true, json];
+      }
+      case "number": {
+        const number = schema;
+        const json = { type: "number" };
+        const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
+        if (typeof format === "string" && format?.includes("int")) {
+          json.type = "integer";
+        }
+        if (typeof minimum === "number") {
+          json.minimum = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maximum = maximum;
+        }
+        if (typeof exclusiveMinimum === "number") {
+          json.exclusiveMinimum = exclusiveMinimum;
+        }
+        if (typeof exclusiveMaximum === "number") {
+          json.exclusiveMaximum = exclusiveMaximum;
+        }
+        if (typeof multipleOf === "number") {
+          json.multipleOf = multipleOf;
+        }
+        return [true, json];
+      }
+      case "boolean": {
+        return [true, { type: "boolean" }];
+      }
+      case "bigint": {
+        return [
+          true,
+          {
+            type: "string",
+            pattern: "^-?[0-9]+$",
+            "x-native-type": JsonSchemaXNativeType.BigInt
+          }
+        ];
+      }
+      case "date": {
+        return [
+          true,
+          {
+            type: "string",
+            format: JSONSchemaFormat.DateTime,
+            "x-native-type": JsonSchemaXNativeType.Date
+          }
+        ];
+      }
+      case "null": {
+        return [true, { type: "null" }];
+      }
+      case "undefined":
+      case "void": {
+        return [false, this.undefinedJsonSchema];
+      }
+      case "any": {
+        return [false, this.anyJsonSchema];
+      }
+      case "unknown": {
+        return [false, this.anyJsonSchema];
+      }
+      case "never": {
+        return [true, this.unsupportedJsonSchema];
+      }
+      case "array": {
+        const array = schema;
+        const json = { type: "array" };
+        const { minimum, maximum } = array._zod.bag;
+        if (typeof minimum === "number") {
+          json.minItems = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxItems = maximum;
+        }
+        json.items = this.#handleArrayItemJsonSchema(
+          this.#convert(array._zod.def.element, options, lazyDepth, structureDepth + 1),
+          options
+        );
+        return [true, json];
+      }
+      case "object": {
+        const object = schema;
+        const json = { type: "object" };
+        for (const [key, value] of Object.entries(object._zod.def.shape)) {
+          const [itemRequired, itemJson] = this.#convert(value, options, lazyDepth, structureDepth + 1);
+          json.properties ??= {};
+          json.properties[key] = itemJson;
+          if (itemRequired) {
+            json.required ??= [];
+            json.required.push(key);
+          }
+        }
+        if (object._zod.def.catchall) {
+          if (object._zod.def.catchall._zod.def.type === "never") {
+            json.additionalProperties = false;
+          } else {
+            const [_, addJson] = this.#convert(
+              object._zod.def.catchall,
+              options,
+              lazyDepth,
+              structureDepth + 1
+            );
+            json.additionalProperties = addJson;
+          }
+        }
+        return [true, json];
+      }
+      case "union": {
+        const union = schema;
+        const anyOf = [];
+        let required = true;
+        for (const item of union._zod.def.options) {
+          const [itemRequired, itemJson] = this.#convert(item, options, lazyDepth, structureDepth);
+          if (!itemRequired) {
+            required = false;
+          }
+          if (options.strategy === "input") {
+            if (itemJson !== this.undefinedJsonSchema && itemJson !== this.unsupportedJsonSchema) {
+              anyOf.push(itemJson);
+            }
+          } else {
+            if (itemJson !== this.undefinedJsonSchema) {
+              anyOf.push(itemJson);
+            }
+          }
+        }
+        return [required, anyOf.length === 1 ? anyOf[0] : { anyOf }];
+      }
+      case "intersection": {
+        const intersection = schema;
+        const json = { allOf: [] };
+        let required = false;
+        for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
+          const [itemRequired, itemJson] = this.#convert(item, options, lazyDepth, structureDepth);
+          json.allOf.push(itemJson);
+          if (itemRequired) {
+            required = true;
+          }
+        }
+        return [required, json];
+      }
+      case "tuple": {
+        const tuple = schema;
+        const json = { type: "array", prefixItems: [] };
+        for (const item of tuple._zod.def.items) {
+          json.prefixItems.push(
+            this.#handleArrayItemJsonSchema(
+              this.#convert(item, options, lazyDepth, structureDepth + 1),
+              options
+            )
+          );
+        }
+        if (tuple._zod.def.rest) {
+          json.items = this.#handleArrayItemJsonSchema(
+            this.#convert(tuple._zod.def.rest, options, lazyDepth, structureDepth + 1),
+            options
+          );
+        }
+        const { minimum, maximum } = tuple._zod.bag;
+        if (typeof minimum === "number") {
+          json.minItems = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxItems = maximum;
+        }
+        return [true, json];
+      }
+      case "record": {
+        const record = schema;
+        const json = { type: "object" };
+        json.propertyNames = this.#convert(
+          record._zod.def.keyType,
+          options,
+          lazyDepth,
+          structureDepth + 1
+        )[1];
+        json.additionalProperties = this.#convert(
+          record._zod.def.valueType,
+          options,
+          lazyDepth,
+          structureDepth + 1
+        )[1];
+        return [true, json];
+      }
+      case "map": {
+        const map = schema;
+        return [
+          true,
+          {
+            type: "array",
+            items: {
+              type: "array",
+              prefixItems: [
+                this.#handleArrayItemJsonSchema(
+                  this.#convert(map._zod.def.keyType, options, lazyDepth, structureDepth + 1),
+                  options
+                ),
+                this.#handleArrayItemJsonSchema(
+                  this.#convert(map._zod.def.valueType, options, lazyDepth, structureDepth + 1),
+                  options
+                )
+              ],
+              maxItems: 2,
+              minItems: 2
+            },
+            "x-native-type": JsonSchemaXNativeType.Map
+          }
+        ];
+      }
+      case "set": {
+        const set = schema;
+        return [
+          true,
+          {
+            type: "array",
+            uniqueItems: true,
+            items: this.#handleArrayItemJsonSchema(
+              this.#convert(set._zod.def.valueType, options, lazyDepth, structureDepth + 1),
+              options
+            ),
+            "x-native-type": JsonSchemaXNativeType.Set
+          }
+        ];
+      }
+      case "enum": {
+        const enum_ = schema;
+        return [true, { enum: Object.values(enum_._zod.def.entries) }];
+      }
+      case "literal": {
+        const literal = schema;
+        let required = true;
+        const values = /* @__PURE__ */ new Set();
+        for (const value of literal._zod.def.values) {
+          if (value === void 0) {
+            required = false;
+          } else {
+            values.add(typeof value === "bigint" ? value.toString() : value);
+          }
+        }
+        const json = values.size === 0 ? this.undefinedJsonSchema : values.size === 1 ? { const: values.values().next().value } : { enum: Array.from(values) };
+        return [required, json];
+      }
+      case "file": {
+        const file = schema;
+        const oneOf = [];
+        const { mime } = file._zod.bag;
+        if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === "string")) {
+          for (const type of mime ?? ["*/*"]) {
+            oneOf.push({
+              type: "string",
+              contentMediaType: type
+            });
+          }
+        }
+        return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];
+      }
+      case "transform": {
+        return [false, this.anyJsonSchema];
+      }
+      case "nullable": {
+        const nullable = schema;
+        const [required, json] = this.#convert(
+          nullable._zod.def.innerType,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+        return [required, { anyOf: [json, { type: "null" }] }];
+      }
+      case "nonoptional": {
+        const nonoptional = schema;
+        const [, json] = this.#convert(nonoptional._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [true, json];
+      }
+      case "success": {
+        return [true, { type: "boolean" }];
+      }
+      case "default":
+      case "prefault": {
+        const default_ = schema;
+        const [, json] = this.#convert(default_._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [
+          false,
+          {
+            ...json,
+            default: default_._zod.def.defaultValue
+          }
+        ];
+      }
+      case "catch": {
+        const catch_ = schema;
+        return this.#convert(catch_._zod.def.innerType, options, lazyDepth, structureDepth);
+      }
+      case "nan": {
+        return [true, options.strategy === "input" ? this.unsupportedJsonSchema : { type: "null" }];
+      }
+      case "pipe": {
+        const pipe = schema;
+        return this.#convert(
+          options.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+      }
+      case "readonly": {
+        const readonly_ = schema;
+        const [required, json] = this.#convert(
+          readonly_._zod.def.innerType,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+        return [required, { ...json, readOnly: true }];
+      }
+      case "template_literal": {
+        const templateLiteral = schema;
+        return [
+          true,
+          {
+            type: "string",
+            pattern: templateLiteral._zod.pattern.source
+          }
+        ];
+      }
+      case "optional": {
+        const optional = schema;
+        const [, json] = this.#convert(optional._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [false, json];
+      }
+      case "lazy": {
+        const lazy = schema;
+        const currentLazyDepth = lazyDepth + 1;
+        if (currentLazyDepth > this.maxLazyDepth) {
+          return [false, this.anyJsonSchema];
+        }
+        return this.#convert(lazy._zod.def.getter(), options, currentLazyDepth, structureDepth);
+      }
+      default: {
+        schema._zod.def.type;
+        return [true, this.unsupportedJsonSchema];
+      }
+    }
+  }
+  #getCustomJsonSchema(schema, options) {
+    if (options.strategy === "input" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_INPUT_REGISTRY.get(schema);
+    }
+    if (options.strategy === "output" && JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+    }
+    if (JSON_SCHEMA_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_REGISTRY.get(schema);
+    }
+    const global = globalRegistry.get(schema);
+    if (global) {
+      return {
+        title: global.title,
+        description: global.description,
+        examples: Array.isArray(global.examples) ? global.examples : void 0
+      };
+    }
+  }
+  #handleArrayItemJsonSchema([required, schema], options) {
+    if (required || options.strategy === "input" || schema.default !== void 0) {
+      return schema;
+    }
+    if (schema === this.undefinedJsonSchema) {
+      return { type: "null" };
+    }
+    return {
+      anyOf: [
+        // schema can contain { type: 'null' } so we should use anyOf instead of oneOf
+        schema,
+        { type: "null" }
+      ]
+    };
+  }
+  #handleStringFormat(format) {
+    if (format === "guid") {
+      return JSONSchemaFormat.UUID;
+    }
+    if (format === "url") {
+      return JSONSchemaFormat.URI;
+    }
+    if (format === "datetime") {
+      return JSONSchemaFormat.DateTime;
+    }
+    return Object.values(JSONSchemaFormat).includes(format) ? format : void 0;
+  }
+  #handleContentEncoding(contentEncoding) {
+    return Object.values(JSONSchemaContentEncoding).includes(contentEncoding) ? contentEncoding : void 0;
+  }
+}
+
+export { JsonSchemaXNativeType as J, ZodToJsonSchemaConverter as Z, JSON_SCHEMA_REGISTRY as a, JSON_SCHEMA_INPUT_REGISTRY as b, JSON_SCHEMA_OUTPUT_REGISTRY as c, eventIterator as e, getEventIteratorSchemaDetails as g };

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

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