@arrirpc/schema 0.81.0 → 0.81.2

package/README.md

@@ -53,6 +53,7 @@ Originally this library was created as a way for building schemas for [Json Type
     - [Serialize](#serialize)
     - [Serialize Unsafe](#serialize-unsafe)
     - [Errors](#errors)
+    - [To JSON Schema](#to-json-schema)
 - [Metadata](#metadata)
 - [Compiled Validators](#compiled-validators)
 - [Benchmarks](#benchmarks)
@@ -989,6 +990,79 @@ a.errors(User, { id: 1, date: 'hello world' });
  */
 ```
 
+### To JSON Schema
+
+Use `a.toJsonSchema()` to convert an Arri schema to [JSON Schema](https://json-schema.org/) format. This is useful for:
+
+- **Editor support** - YAML/JSON files using Arri-defined schemas can get autocomplete in VS Code, IntelliJ, etc.
+- **Interoperability** - Integration with tools that consume JSON Schema (OpenAPI, documentation generators, etc.)
+- **Configuration validation** - Users defining config files can reference a JSON Schema URL for validation
+
+```ts
+const User = a.object(
+    {
+        id: a.string(),
+        name: a.string(),
+        email: a.nullable(a.string()),
+        role: a.enumerator(['USER', 'ADMIN']),
+        createdAt: a.timestamp(),
+    },
+    { id: 'User', description: 'A user in the system' },
+);
+
+const jsonSchema = a.toJsonSchema(User, {
+    $id: 'https://example.com/schemas/user.json',
+    title: 'User Schema',
+});
+```
+
+**Result:**
+
+```json
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://example.com/schemas/user.json",
+    "title": "User Schema",
+    "type": "object",
+    "properties": {
+        "id": { "type": "string" },
+        "name": { "type": "string" },
+        "email": { "type": ["string", "null"] },
+        "role": { "type": "string", "enum": ["USER", "ADMIN"] },
+        "createdAt": { "type": "string", "format": "date-time" }
+    },
+    "required": ["id", "name", "email", "role", "createdAt"]
+}
+```
+
+#### Options
+
+| Option        | Type   | Description                                                                             |
+| ------------- | ------ | --------------------------------------------------------------------------------------- |
+| `$id`         | string | The `$id` to use for the root schema                                                    |
+| `title`       | string | The title to use for the root schema                                                    |
+| `description` | string | The description to use for the root schema                                              |
+| `$schema`     | string | The JSON Schema draft version (default: `https://json-schema.org/draft/2020-12/schema`) |
+
+#### Type Mappings
+
+| Arri Schema         | JSON Schema Equivalent                                         |
+| ------------------- | -------------------------------------------------------------- |
+| `a.any()`           | `{}` (any)                                                     |
+| `a.string()`        | `{ "type": "string" }`                                         |
+| `a.boolean()`       | `{ "type": "boolean" }`                                        |
+| `a.timestamp()`     | `{ "type": "string", "format": "date-time" }`                  |
+| `a.float32/64()`    | `{ "type": "number" }`                                         |
+| `a.int8/16/32()`    | `{ "type": "integer", "minimum": X, "maximum": Y }`            |
+| `a.uint8/16/32()`   | `{ "type": "integer", "minimum": 0, "maximum": Y }`            |
+| `a.int64/uint64()`  | `{ "type": "string", "pattern": "^-?[0-9]+$" }`                |
+| `a.enumerator()`    | `{ "type": "string", "enum": [...] }`                          |
+| `a.array()`         | `{ "type": "array", "items": {...} }`                          |
+| `a.object()`        | `{ "type": "object", "properties": {...}, "required": [...] }` |
+| `a.record()`        | `{ "type": "object", "additionalProperties": {...} }`          |
+| `a.discriminator()` | `{ "oneOf": [...] }` with const discriminator                  |
+| `a.nullable()`      | Adds `"null"` to type array                                    |
+
 ## Metadata
 
 Metadata is used during cross-language code generation. Arri schemas allow you to specify the following metadata fields:

package/dist/index.cjs

@@ -2818,6 +2818,136 @@ function enumerator(paramA, paramB) {
   return result;
 }
 
+function toJsonSchema(schema, options) {
+  return applyRootOptions(
+    schemaToJsonSchema(schema),
+    options
+  );
+}
+function schemaToJsonSchema(schema) {
+  return convertSchema(schema);
+}
+function applyRootOptions(schema, options) {
+  return {
+    ...schema,
+    $schema: options?.$schema ?? "https://json-schema.org/draft/2020-12/schema",
+    ...options?.$id && { $id: options.$id },
+    ...options?.title && { title: options.title },
+    ...options?.description && { description: options.description }
+  };
+}
+const SCALAR_MAPPINGS = {
+  string: { type: "string" },
+  boolean: { type: "boolean" },
+  timestamp: { type: "string", format: "date-time" },
+  float32: { type: "number" },
+  float64: { type: "number" },
+  int8: { type: "integer", minimum: int8Min, maximum: int8Max },
+  uint8: { type: "integer", minimum: uint8Min, maximum: uint8Max },
+  int16: { type: "integer", minimum: int16Min, maximum: int16Max },
+  uint16: { type: "integer", minimum: uint16Min, maximum: uint16Max },
+  int32: { type: "integer", minimum: int32Min, maximum: int32Max },
+  uint32: { type: "integer", minimum: uint32Min, maximum: uint32Max },
+  int64: { type: "string", pattern: "^-?[0-9]+$" },
+  uint64: { type: "string", pattern: "^[0-9]+$" }
+};
+function convertSchema(schema) {
+  const base = getBaseSchema(schema);
+  return schema.isNullable ? makeNullable(base, schema) : applyMetadata(base, schema);
+}
+function getBaseSchema(schema) {
+  if (typeDefs.isSchemaFormType(schema)) {
+    const mapping = SCALAR_MAPPINGS[schema.type];
+    return mapping ? { ...mapping } : {};
+  }
+  if (typeDefs.isSchemaFormEnum(schema)) {
+    return {
+      type: "string",
+      enum: [...schema.enum]
+    };
+  }
+  if (typeDefs.isSchemaFormElements(schema)) {
+    return {
+      type: "array",
+      items: convertSchema(schema.elements)
+    };
+  }
+  if (typeDefs.isSchemaFormProperties(schema)) {
+    return convertObject(schema);
+  }
+  if (typeDefs.isSchemaFormValues(schema)) {
+    return {
+      type: "object",
+      additionalProperties: convertSchema(schema.values)
+    };
+  }
+  if (typeDefs.isSchemaFormDiscriminator(schema)) {
+    return convertDiscriminator(schema);
+  }
+  if (typeDefs.isSchemaFormRef(schema)) {
+    return { $ref: `#/$defs/${schema.ref}` };
+  }
+  if (typeDefs.isSchemaFormEmpty(schema)) return {};
+  return {};
+}
+function convertObject(schema) {
+  const properties = {};
+  const required = [];
+  for (const [key, prop] of Object.entries(schema.properties ?? {})) {
+    properties[key] = convertSchema(prop);
+    required.push(key);
+  }
+  for (const [key, prop] of Object.entries(schema.optionalProperties ?? {})) {
+    properties[key] = convertSchema(prop);
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 && { required },
+    ...schema.isStrict && { additionalProperties: false }
+  };
+}
+function convertDiscriminator(schema) {
+  const oneOf = Object.entries(schema.mapping).map(
+    ([value, mappingSchema]) => {
+      const variant = convertObject(mappingSchema);
+      variant.properties = {
+        ...variant.properties,
+        [schema.discriminator]: { type: "string", const: value }
+      };
+      variant.required = [
+        ...variant.required ?? [],
+        schema.discriminator
+      ];
+      return variant;
+    }
+  );
+  return { oneOf };
+}
+function makeNullable(jsonSchema, atdSchema) {
+  if (jsonSchema.$ref || jsonSchema.oneOf) {
+    return applyMetadata(
+      { anyOf: [jsonSchema, { type: "null" }] },
+      atdSchema
+    );
+  }
+  if (jsonSchema.type) {
+    const types = Array.isArray(jsonSchema.type) ? jsonSchema.type : [jsonSchema.type];
+    jsonSchema.type = types.includes("null") ? types : [...types, "null"];
+    return applyMetadata(jsonSchema, atdSchema);
+  }
+  return applyMetadata({ anyOf: [jsonSchema, { type: "null" }] }, atdSchema);
+}
+function applyMetadata(jsonSchema, { metadata }) {
+  if (!metadata) return jsonSchema;
+  return {
+    ...jsonSchema,
+    ...metadata.id && { title: metadata.id },
+    ...metadata.description && { description: metadata.description },
+    ...metadata.isDeprecated && { deprecated: true }
+  };
+}
+
 function nullable(schema, opts = {}) {
   const isType = (val) => {
     if (val === null) {
@@ -4279,11 +4409,13 @@ const _namespace = {
     pick: pick,
     record: record,
     recursive: recursive,
+    schemaToJsonSchema: schemaToJsonSchema,
     serialize: serialize,
     serializeUnsafe: serializeUnsafe,
     string: string,
     stringEnum: stringEnum,
     timestamp: timestamp,
+    toJsonSchema: toJsonSchema,
     uint16: uint16,
     uint32: uint32,
     uint64: uint64,
@@ -4353,6 +4485,7 @@ exports.pick = pick;
 exports.record = record;
 exports.recursive = recursive;
 exports.sanitizeJson = sanitizeJson;
+exports.schemaToJsonSchema = schemaToJsonSchema;
 exports.serialize = serialize;
 exports.serializeObject = serializeObject;
 exports.serializeSmallString = serializeSmallString;
@@ -4361,6 +4494,7 @@ exports.serializeUnsafe = serializeUnsafe;
 exports.string = string;
 exports.stringEnum = stringEnum;
 exports.timestamp = timestamp;
+exports.toJsonSchema = toJsonSchema;
 exports.uint16 = uint16;
 exports.uint16Max = uint16Max;
 exports.uint16Min = uint16Min;

package/dist/index.d.cts

@@ -149,6 +149,69 @@ declare function enumerator<TKeys extends string, TValues extends TKeys[]>(value
  */
 declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: string, values: TValues): AStringEnumSchemaWithAdapters<TValues>;
 
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    type?: JsonSchemaType | JsonSchemaType[];
+    pattern?: string;
+    format?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    enum?: unknown[];
+    const?: unknown;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    [key: string]: unknown;
+}
+interface ToJsonSchemaOptions {
+    /** The $id to use for the root schema */
+    $id?: string;
+    /** The title to use for the root schema */
+    title?: string;
+    /** The description to use for the root schema */
+    description?: string;
+    /** The JSON Schema draft version to target */
+    $schema?: string;
+}
+/**
+ * Convert an Arri schema to JSON Schema format
+ *
+ * @example
+ * const User = a.object({
+ *   id: a.string(),
+ *   name: a.string(),
+ *   email: a.nullable(a.string()),
+ * });
+ *
+ * const jsonSchema = toJsonSchema(User, {
+ *   $id: 'https://example.com/schemas/user.json',
+ *   title: 'User',
+ * });
+ */
+declare function toJsonSchema<T>(schema: ASchema<T>, options?: ToJsonSchemaOptions): JsonSchema;
+/**
+ * Convert a raw ATD Schema object to JSON Schema format.
+ * This is useful when working with plain schema objects from AppDefinition.
+ */
+declare function schemaToJsonSchema(schema: Schema): JsonSchema;
+
 /**
  * Transforms a schema into a nullable type
  *
@@ -375,6 +438,8 @@ declare function serialize<T = any>(schema: ASchema<T>, input: T): Result<string
 declare function serializeUnsafe<T = any>(schema: ASchema<T>, input: T): string;
 declare function errors(schema: ASchema, input: unknown, exitOnFirstError?: boolean): ValueError[];
 
+type _namespace_JsonSchema = JsonSchema;
+type _namespace_ToJsonSchemaOptions = ToJsonSchemaOptions;
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -403,11 +468,13 @@ declare const _namespace_partial: typeof partial;
 declare const _namespace_pick: typeof pick;
 declare const _namespace_record: typeof record;
 declare const _namespace_recursive: typeof recursive;
+declare const _namespace_schemaToJsonSchema: typeof schemaToJsonSchema;
 declare const _namespace_serialize: typeof serialize;
 declare const _namespace_serializeUnsafe: typeof serializeUnsafe;
 declare const _namespace_string: typeof string;
 declare const _namespace_stringEnum: typeof stringEnum;
 declare const _namespace_timestamp: typeof timestamp;
+declare const _namespace_toJsonSchema: typeof toJsonSchema;
 declare const _namespace_uint16: typeof uint16;
 declare const _namespace_uint32: typeof uint32;
 declare const _namespace_uint64: typeof uint64;
@@ -415,50 +482,9 @@ declare const _namespace_uint8: typeof uint8;
 declare const _namespace_undefinable: typeof undefinable;
 declare const _namespace_validate: typeof validate;
 declare namespace _namespace {
-  export {
-    _namespace_any as any,
-    _namespace_array as array,
-    _namespace_boolean as boolean,
-    _namespace_clone as clone,
-    _namespace_coerce as coerce,
-    _namespace_coerceUnsafe as coerceUnsafe,
-    _namespace_compile as compile,
-    _namespace_discriminator as discriminator,
-    _namespace_enumerator as enumerator,
-    _namespace_errors as errors,
-    _namespace_extend as extend,
-    _namespace_float32 as float32,
-    _namespace_float64 as float64,
-    InferType as infer,
-    InferSubType as inferSubType,
-    _namespace_int16 as int16,
-    _namespace_int32 as int32,
-    _namespace_int64 as int64,
-    _namespace_int8 as int8,
-    _namespace_nullable as nullable,
-    _namespace_number as number,
-    _namespace_object as object,
-    _namespace_omit as omit,
-    _namespace_optional as optional,
-    _namespace_parse as parse,
-    _namespace_parseUnsafe as parseUnsafe,
-    _namespace_partial as partial,
-    _namespace_pick as pick,
-    _namespace_record as record,
-    _namespace_recursive as recursive,
-    _namespace_serialize as serialize,
-    _namespace_serializeUnsafe as serializeUnsafe,
-    _namespace_string as string,
-    _namespace_stringEnum as stringEnum,
-    _namespace_timestamp as timestamp,
-    _namespace_uint16 as uint16,
-    _namespace_uint32 as uint32,
-    _namespace_uint64 as uint64,
-    _namespace_uint8 as uint8,
-    _namespace_undefinable as undefinable,
-    _namespace_validate as validate,
-  };
+  export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_coerceUnsafe as coerceUnsafe, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_parseUnsafe as parseUnsafe, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_schemaToJsonSchema as schemaToJsonSchema, _namespace_serialize as serialize, _namespace_serializeUnsafe as serializeUnsafe, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_toJsonSchema as toJsonSchema, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_undefinable as undefinable, _namespace_validate as validate };
+  export type { _namespace_JsonSchema as JsonSchema, _namespace_ToJsonSchemaOptions as ToJsonSchemaOptions };
 }
 
-export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
-export type { CompiledValidator, CompiledValidatorCompiledCode };
+export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, schemaToJsonSchema, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, toJsonSchema, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
+export type { CompiledValidator, CompiledValidatorCompiledCode, JsonSchema, JsonSchemaType, ToJsonSchemaOptions };

package/dist/index.d.mts

@@ -149,6 +149,69 @@ declare function enumerator<TKeys extends string, TValues extends TKeys[]>(value
  */
 declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: string, values: TValues): AStringEnumSchemaWithAdapters<TValues>;
 
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    type?: JsonSchemaType | JsonSchemaType[];
+    pattern?: string;
+    format?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    enum?: unknown[];
+    const?: unknown;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    [key: string]: unknown;
+}
+interface ToJsonSchemaOptions {
+    /** The $id to use for the root schema */
+    $id?: string;
+    /** The title to use for the root schema */
+    title?: string;
+    /** The description to use for the root schema */
+    description?: string;
+    /** The JSON Schema draft version to target */
+    $schema?: string;
+}
+/**
+ * Convert an Arri schema to JSON Schema format
+ *
+ * @example
+ * const User = a.object({
+ *   id: a.string(),
+ *   name: a.string(),
+ *   email: a.nullable(a.string()),
+ * });
+ *
+ * const jsonSchema = toJsonSchema(User, {
+ *   $id: 'https://example.com/schemas/user.json',
+ *   title: 'User',
+ * });
+ */
+declare function toJsonSchema<T>(schema: ASchema<T>, options?: ToJsonSchemaOptions): JsonSchema;
+/**
+ * Convert a raw ATD Schema object to JSON Schema format.
+ * This is useful when working with plain schema objects from AppDefinition.
+ */
+declare function schemaToJsonSchema(schema: Schema): JsonSchema;
+
 /**
  * Transforms a schema into a nullable type
  *
@@ -375,6 +438,8 @@ declare function serialize<T = any>(schema: ASchema<T>, input: T): Result<string
 declare function serializeUnsafe<T = any>(schema: ASchema<T>, input: T): string;
 declare function errors(schema: ASchema, input: unknown, exitOnFirstError?: boolean): ValueError[];
 
+type _namespace_JsonSchema = JsonSchema;
+type _namespace_ToJsonSchemaOptions = ToJsonSchemaOptions;
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -403,11 +468,13 @@ declare const _namespace_partial: typeof partial;
 declare const _namespace_pick: typeof pick;
 declare const _namespace_record: typeof record;
 declare const _namespace_recursive: typeof recursive;
+declare const _namespace_schemaToJsonSchema: typeof schemaToJsonSchema;
 declare const _namespace_serialize: typeof serialize;
 declare const _namespace_serializeUnsafe: typeof serializeUnsafe;
 declare const _namespace_string: typeof string;
 declare const _namespace_stringEnum: typeof stringEnum;
 declare const _namespace_timestamp: typeof timestamp;
+declare const _namespace_toJsonSchema: typeof toJsonSchema;
 declare const _namespace_uint16: typeof uint16;
 declare const _namespace_uint32: typeof uint32;
 declare const _namespace_uint64: typeof uint64;
@@ -415,50 +482,9 @@ declare const _namespace_uint8: typeof uint8;
 declare const _namespace_undefinable: typeof undefinable;
 declare const _namespace_validate: typeof validate;
 declare namespace _namespace {
-  export {
-    _namespace_any as any,
-    _namespace_array as array,
-    _namespace_boolean as boolean,
-    _namespace_clone as clone,
-    _namespace_coerce as coerce,
-    _namespace_coerceUnsafe as coerceUnsafe,
-    _namespace_compile as compile,
-    _namespace_discriminator as discriminator,
-    _namespace_enumerator as enumerator,
-    _namespace_errors as errors,
-    _namespace_extend as extend,
-    _namespace_float32 as float32,
-    _namespace_float64 as float64,
-    InferType as infer,
-    InferSubType as inferSubType,
-    _namespace_int16 as int16,
-    _namespace_int32 as int32,
-    _namespace_int64 as int64,
-    _namespace_int8 as int8,
-    _namespace_nullable as nullable,
-    _namespace_number as number,
-    _namespace_object as object,
-    _namespace_omit as omit,
-    _namespace_optional as optional,
-    _namespace_parse as parse,
-    _namespace_parseUnsafe as parseUnsafe,
-    _namespace_partial as partial,
-    _namespace_pick as pick,
-    _namespace_record as record,
-    _namespace_recursive as recursive,
-    _namespace_serialize as serialize,
-    _namespace_serializeUnsafe as serializeUnsafe,
-    _namespace_string as string,
-    _namespace_stringEnum as stringEnum,
-    _namespace_timestamp as timestamp,
-    _namespace_uint16 as uint16,
-    _namespace_uint32 as uint32,
-    _namespace_uint64 as uint64,
-    _namespace_uint8 as uint8,
-    _namespace_undefinable as undefinable,
-    _namespace_validate as validate,
-  };
+  export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_coerceUnsafe as coerceUnsafe, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_parseUnsafe as parseUnsafe, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_schemaToJsonSchema as schemaToJsonSchema, _namespace_serialize as serialize, _namespace_serializeUnsafe as serializeUnsafe, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_toJsonSchema as toJsonSchema, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_undefinable as undefinable, _namespace_validate as validate };
+  export type { _namespace_JsonSchema as JsonSchema, _namespace_ToJsonSchemaOptions as ToJsonSchemaOptions };
 }
 
-export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
-export type { CompiledValidator, CompiledValidatorCompiledCode };
+export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, schemaToJsonSchema, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, toJsonSchema, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
+export type { CompiledValidator, CompiledValidatorCompiledCode, JsonSchema, JsonSchemaType, ToJsonSchemaOptions };

package/dist/index.d.ts

@@ -149,6 +149,69 @@ declare function enumerator<TKeys extends string, TValues extends TKeys[]>(value
  */
 declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: string, values: TValues): AStringEnumSchemaWithAdapters<TValues>;
 
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    $schema?: string;
+    $id?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema>;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    type?: JsonSchemaType | JsonSchemaType[];
+    pattern?: string;
+    format?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    enum?: unknown[];
+    const?: unknown;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    [key: string]: unknown;
+}
+interface ToJsonSchemaOptions {
+    /** The $id to use for the root schema */
+    $id?: string;
+    /** The title to use for the root schema */
+    title?: string;
+    /** The description to use for the root schema */
+    description?: string;
+    /** The JSON Schema draft version to target */
+    $schema?: string;
+}
+/**
+ * Convert an Arri schema to JSON Schema format
+ *
+ * @example
+ * const User = a.object({
+ *   id: a.string(),
+ *   name: a.string(),
+ *   email: a.nullable(a.string()),
+ * });
+ *
+ * const jsonSchema = toJsonSchema(User, {
+ *   $id: 'https://example.com/schemas/user.json',
+ *   title: 'User',
+ * });
+ */
+declare function toJsonSchema<T>(schema: ASchema<T>, options?: ToJsonSchemaOptions): JsonSchema;
+/**
+ * Convert a raw ATD Schema object to JSON Schema format.
+ * This is useful when working with plain schema objects from AppDefinition.
+ */
+declare function schemaToJsonSchema(schema: Schema): JsonSchema;
+
 /**
  * Transforms a schema into a nullable type
  *
@@ -375,6 +438,8 @@ declare function serialize<T = any>(schema: ASchema<T>, input: T): Result<string
 declare function serializeUnsafe<T = any>(schema: ASchema<T>, input: T): string;
 declare function errors(schema: ASchema, input: unknown, exitOnFirstError?: boolean): ValueError[];
 
+type _namespace_JsonSchema = JsonSchema;
+type _namespace_ToJsonSchemaOptions = ToJsonSchemaOptions;
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -403,11 +468,13 @@ declare const _namespace_partial: typeof partial;
 declare const _namespace_pick: typeof pick;
 declare const _namespace_record: typeof record;
 declare const _namespace_recursive: typeof recursive;
+declare const _namespace_schemaToJsonSchema: typeof schemaToJsonSchema;
 declare const _namespace_serialize: typeof serialize;
 declare const _namespace_serializeUnsafe: typeof serializeUnsafe;
 declare const _namespace_string: typeof string;
 declare const _namespace_stringEnum: typeof stringEnum;
 declare const _namespace_timestamp: typeof timestamp;
+declare const _namespace_toJsonSchema: typeof toJsonSchema;
 declare const _namespace_uint16: typeof uint16;
 declare const _namespace_uint32: typeof uint32;
 declare const _namespace_uint64: typeof uint64;
@@ -415,50 +482,9 @@ declare const _namespace_uint8: typeof uint8;
 declare const _namespace_undefinable: typeof undefinable;
 declare const _namespace_validate: typeof validate;
 declare namespace _namespace {
-  export {
-    _namespace_any as any,
-    _namespace_array as array,
-    _namespace_boolean as boolean,
-    _namespace_clone as clone,
-    _namespace_coerce as coerce,
-    _namespace_coerceUnsafe as coerceUnsafe,
-    _namespace_compile as compile,
-    _namespace_discriminator as discriminator,
-    _namespace_enumerator as enumerator,
-    _namespace_errors as errors,
-    _namespace_extend as extend,
-    _namespace_float32 as float32,
-    _namespace_float64 as float64,
-    InferType as infer,
-    InferSubType as inferSubType,
-    _namespace_int16 as int16,
-    _namespace_int32 as int32,
-    _namespace_int64 as int64,
-    _namespace_int8 as int8,
-    _namespace_nullable as nullable,
-    _namespace_number as number,
-    _namespace_object as object,
-    _namespace_omit as omit,
-    _namespace_optional as optional,
-    _namespace_parse as parse,
-    _namespace_parseUnsafe as parseUnsafe,
-    _namespace_partial as partial,
-    _namespace_pick as pick,
-    _namespace_record as record,
-    _namespace_recursive as recursive,
-    _namespace_serialize as serialize,
-    _namespace_serializeUnsafe as serializeUnsafe,
-    _namespace_string as string,
-    _namespace_stringEnum as stringEnum,
-    _namespace_timestamp as timestamp,
-    _namespace_uint16 as uint16,
-    _namespace_uint32 as uint32,
-    _namespace_uint64 as uint64,
-    _namespace_uint8 as uint8,
-    _namespace_undefinable as undefinable,
-    _namespace_validate as validate,
-  };
+  export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_coerceUnsafe as coerceUnsafe, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_parseUnsafe as parseUnsafe, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_schemaToJsonSchema as schemaToJsonSchema, _namespace_serialize as serialize, _namespace_serializeUnsafe as serializeUnsafe, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_toJsonSchema as toJsonSchema, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_undefinable as undefinable, _namespace_validate as validate };
+  export type { _namespace_JsonSchema as JsonSchema, _namespace_ToJsonSchemaOptions as ToJsonSchemaOptions };
 }
 
-export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
-export type { CompiledValidator, CompiledValidatorCompiledCode };
+export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, VALIDATOR_KEY, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, schemaToJsonSchema, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, toJsonSchema, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
+export type { CompiledValidator, CompiledValidatorCompiledCode, JsonSchema, JsonSchemaType, ToJsonSchemaOptions };

package/dist/index.mjs

@@ -2817,6 +2817,136 @@ function enumerator(paramA, paramB) {
   return result;
 }
 
+function toJsonSchema(schema, options) {
+  return applyRootOptions(
+    schemaToJsonSchema(schema),
+    options
+  );
+}
+function schemaToJsonSchema(schema) {
+  return convertSchema(schema);
+}
+function applyRootOptions(schema, options) {
+  return {
+    ...schema,
+    $schema: options?.$schema ?? "https://json-schema.org/draft/2020-12/schema",
+    ...options?.$id && { $id: options.$id },
+    ...options?.title && { title: options.title },
+    ...options?.description && { description: options.description }
+  };
+}
+const SCALAR_MAPPINGS = {
+  string: { type: "string" },
+  boolean: { type: "boolean" },
+  timestamp: { type: "string", format: "date-time" },
+  float32: { type: "number" },
+  float64: { type: "number" },
+  int8: { type: "integer", minimum: int8Min, maximum: int8Max },
+  uint8: { type: "integer", minimum: uint8Min, maximum: uint8Max },
+  int16: { type: "integer", minimum: int16Min, maximum: int16Max },
+  uint16: { type: "integer", minimum: uint16Min, maximum: uint16Max },
+  int32: { type: "integer", minimum: int32Min, maximum: int32Max },
+  uint32: { type: "integer", minimum: uint32Min, maximum: uint32Max },
+  int64: { type: "string", pattern: "^-?[0-9]+$" },
+  uint64: { type: "string", pattern: "^[0-9]+$" }
+};
+function convertSchema(schema) {
+  const base = getBaseSchema(schema);
+  return schema.isNullable ? makeNullable(base, schema) : applyMetadata(base, schema);
+}
+function getBaseSchema(schema) {
+  if (isSchemaFormType(schema)) {
+    const mapping = SCALAR_MAPPINGS[schema.type];
+    return mapping ? { ...mapping } : {};
+  }
+  if (isSchemaFormEnum(schema)) {
+    return {
+      type: "string",
+      enum: [...schema.enum]
+    };
+  }
+  if (isSchemaFormElements(schema)) {
+    return {
+      type: "array",
+      items: convertSchema(schema.elements)
+    };
+  }
+  if (isSchemaFormProperties(schema)) {
+    return convertObject(schema);
+  }
+  if (isSchemaFormValues(schema)) {
+    return {
+      type: "object",
+      additionalProperties: convertSchema(schema.values)
+    };
+  }
+  if (isSchemaFormDiscriminator(schema)) {
+    return convertDiscriminator(schema);
+  }
+  if (isSchemaFormRef(schema)) {
+    return { $ref: `#/$defs/${schema.ref}` };
+  }
+  if (isSchemaFormEmpty(schema)) return {};
+  return {};
+}
+function convertObject(schema) {
+  const properties = {};
+  const required = [];
+  for (const [key, prop] of Object.entries(schema.properties ?? {})) {
+    properties[key] = convertSchema(prop);
+    required.push(key);
+  }
+  for (const [key, prop] of Object.entries(schema.optionalProperties ?? {})) {
+    properties[key] = convertSchema(prop);
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 && { required },
+    ...schema.isStrict && { additionalProperties: false }
+  };
+}
+function convertDiscriminator(schema) {
+  const oneOf = Object.entries(schema.mapping).map(
+    ([value, mappingSchema]) => {
+      const variant = convertObject(mappingSchema);
+      variant.properties = {
+        ...variant.properties,
+        [schema.discriminator]: { type: "string", const: value }
+      };
+      variant.required = [
+        ...variant.required ?? [],
+        schema.discriminator
+      ];
+      return variant;
+    }
+  );
+  return { oneOf };
+}
+function makeNullable(jsonSchema, atdSchema) {
+  if (jsonSchema.$ref || jsonSchema.oneOf) {
+    return applyMetadata(
+      { anyOf: [jsonSchema, { type: "null" }] },
+      atdSchema
+    );
+  }
+  if (jsonSchema.type) {
+    const types = Array.isArray(jsonSchema.type) ? jsonSchema.type : [jsonSchema.type];
+    jsonSchema.type = types.includes("null") ? types : [...types, "null"];
+    return applyMetadata(jsonSchema, atdSchema);
+  }
+  return applyMetadata({ anyOf: [jsonSchema, { type: "null" }] }, atdSchema);
+}
+function applyMetadata(jsonSchema, { metadata }) {
+  if (!metadata) return jsonSchema;
+  return {
+    ...jsonSchema,
+    ...metadata.id && { title: metadata.id },
+    ...metadata.description && { description: metadata.description },
+    ...metadata.isDeprecated && { deprecated: true }
+  };
+}
+
 function nullable(schema, opts = {}) {
   const isType = (val) => {
     if (val === null) {
@@ -4278,11 +4408,13 @@ const _namespace = {
     pick: pick,
     record: record,
     recursive: recursive,
+    schemaToJsonSchema: schemaToJsonSchema,
     serialize: serialize,
     serializeUnsafe: serializeUnsafe,
     string: string,
     stringEnum: stringEnum,
     timestamp: timestamp,
+    toJsonSchema: toJsonSchema,
     uint16: uint16,
     uint32: uint32,
     uint64: uint64,
@@ -4291,4 +4423,4 @@ const _namespace = {
     validate: validate
 };
 
-export { STR_ESCAPE, VALIDATOR_KEY, ValidationException, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errorMessageFromErrors, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAAraySchema, isADiscriminatorSchema, isAObjectSchema, isARecordSchema, isARefSchema, isAScalarSchema, isAStringEnumSchema, isObject, isValidationException, isValueError, newValidationContext, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };
+export { STR_ESCAPE, VALIDATOR_KEY, ValidationException, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errorMessageFromErrors, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAAraySchema, isADiscriminatorSchema, isAObjectSchema, isARecordSchema, isARefSchema, isAScalarSchema, isAStringEnumSchema, isObject, isValidationException, isValueError, newValidationContext, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, schemaToJsonSchema, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, toJsonSchema, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, undefinable, validate, validateObjectSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrirpc/schema",
-  "version": "0.81.0",
+  "version": "0.81.2",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -25,7 +25,7 @@
     "@standard-schema/spec": "1.0.0",
     "scule": "^1.3.0",
     "uncrypto": "^0.1.3",
-    "@arrirpc/type-defs": "0.81.0"
+    "@arrirpc/type-defs": "0.81.2"
   },
   "devDependencies": {
     "@samchon/openapi": "^5.1.0",