tsondb 0.1.3 → 0.3.0

package/lib/schema/declarations/EnumDecl.d.ts

@@ -1,25 +1,28 @@
 import { Lazy } from "../../utils/lazy.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
 import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { SerializedType, Type } from "../types/Type.js";
+import { EnumCaseDecl, EnumType, SerializedEnumCaseDecl, SerializedEnumType } from "../types/generic/EnumType.js";
+import { Type } from "../types/Type.js";
 import { ValidatorHelpers } from "../validation/type.js";
 import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
-export interface EnumDecl<Name extends string = string, T extends Record<string, Type | null> = Record<string, Type | null>, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
+export interface EnumDecl<Name extends string = string, T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
-    values: Lazy<T>;
+    type: Lazy<EnumType<T>>;
+    isDeprecated?: boolean;
 }
-export interface SerializedEnumDecl<Name extends string = string, T extends Record<string, SerializedType | null> = Record<string, SerializedType | null>, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseDecl<Name, Params> {
+export interface SerializedEnumDecl<Name extends string = string, T extends Record<string, SerializedEnumCaseDecl> = Record<string, SerializedEnumCaseDecl>, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
-    values: T;
+    type: SerializedEnumType<T>;
+    isDeprecated?: boolean;
 }
-export declare const GenEnumDecl: <Name extends string, T extends Record<string, Type | null>, Params extends TypeParameter[]>(sourceUrl: string, options: {
+export declare const GenEnumDecl: <Name extends string, T extends Record<string, EnumCaseDecl>, Params extends TypeParameter[]>(sourceUrl: string, options: {
     name: Name;
     comment?: string;
     parameters: Params;
     values: (...args: Params) => T;
 }) => EnumDecl<Name, T, Params>;
 export { GenEnumDecl as GenEnum };
-export declare const EnumDecl: <Name extends string, T extends Record<string, Type | null>>(sourceUrl: string, options: {
+export declare const EnumDecl: <Name extends string, T extends Record<string, EnumCaseDecl>>(sourceUrl: string, options: {
     name: Name;
     comment?: string;
     values: () => T;
@@ -28,6 +31,6 @@ export { EnumDecl as Enum };
 export declare const isEnumDecl: (node: Node) => node is EnumDecl;
 export declare const getNestedDeclarationsInEnumDecl: GetNestedDeclarations<EnumDecl>;
 export declare const validateEnumDecl: (helpers: ValidatorHelpers, decl: EnumDecl, args: Type[], value: unknown) => Error[];
-export declare const resolveTypeArgumentsInEnumDecl: <Params extends TypeParameter[]>(decl: EnumDecl<string, Record<string, Type | null>, Params>, args: TypeArguments<Params>) => EnumDecl<string, Record<string, Type | null>, []>;
+export declare const resolveTypeArgumentsInEnumDecl: <Params extends TypeParameter[]>(decl: EnumDecl<string, Record<string, EnumCaseDecl>, Params>, args: TypeArguments<Params>) => EnumDecl<string, Record<string, EnumCaseDecl>, []>;
 export declare const serializeEnumDecl: Serializer<EnumDecl, SerializedEnumDecl>;
 export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;

package/lib/schema/declarations/EnumDecl.js

@@ -1,22 +1,17 @@
-import { discriminatorKey } from "../../shared/enum.js";
 import { Lazy } from "../../utils/lazy.js";
 import { NodeKind } from "../Node.js";
 import { serializeTypeParameter, } from "../parameters/TypeParameter.js";
-import { getReferencesForType, resolveTypeArgumentsInType, serializeType, validate, } from "../types/Type.js";
-import { getNestedDeclarations, getTypeArgumentsRecord, validateDeclName, } from "./Declaration.js";
+import { EnumType, getNestedDeclarationsInEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "../types/generic/EnumType.js";
+import { getTypeArgumentsRecord, validateDeclName, } from "./Declaration.js";
 export const GenEnumDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
     const decl = {
         ...options,
         kind: NodeKind.EnumDecl,
         sourceUrl,
-        values: Lazy.of(() => {
-            const type = options.values(...options.parameters);
-            Object.values(type).forEach(type => {
-                if (type) {
-                    type.parent = decl;
-                }
-            });
+        type: Lazy.of(() => {
+            const type = EnumType(options.values(...options.parameters));
+            type.parent = decl;
             return type;
         }),
     };
@@ -30,13 +25,9 @@ export const EnumDecl = (sourceUrl, options) => {
         kind: NodeKind.EnumDecl,
         sourceUrl,
         parameters: [],
-        values: Lazy.of(() => {
-            const type = options.values();
-            Object.values(type).forEach(type => {
-                if (type) {
-                    type.parent = decl;
-                }
-            });
+        type: Lazy.of(() => {
+            const type = EnumType(options.values());
+            type.parent = decl;
             return type;
         }),
     };
@@ -44,61 +35,18 @@ export const EnumDecl = (sourceUrl, options) => {
 };
 export { EnumDecl as Enum };
 export const isEnumDecl = (node) => node.kind === NodeKind.EnumDecl;
-export const getNestedDeclarationsInEnumDecl = (isDeclAdded, decl) => Object.values(decl.values.value).flatMap(caseDef => caseDef === null ? [] : getNestedDeclarations(isDeclAdded, caseDef));
-export const validateEnumDecl = (helpers, decl, args, value) => {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return [TypeError(`expected an object, but got ${JSON.stringify(value)}`)];
-    }
-    const actualKeys = Object.keys(value);
-    if (!(discriminatorKey in value) || typeof value[discriminatorKey] !== "string") {
-        return [
-            TypeError(`missing required discriminator value at key "${discriminatorKey}" of type string`),
-        ];
-    }
-    const caseName = value[discriminatorKey];
-    if (!(caseName in decl.values.value)) {
-        return [TypeError(`discriminator "${caseName}" is not a valid enum case`)];
-    }
-    const unknownKeyErrors = actualKeys.flatMap(actualKey => actualKey === discriminatorKey || actualKey in decl.values.value
-        ? []
-        : [TypeError(`key "${actualKey}" is not the discriminator key or a valid enum case`)]);
-    if (unknownKeyErrors.length > 0) {
-        return unknownKeyErrors;
-    }
-    const associatedType = decl.values.value[caseName];
-    if (associatedType != null) {
-        if (!(caseName in value)) {
-            return [TypeError(`missing required associated value for case "${caseName}"`)];
-        }
-        return validate(helpers, resolveTypeArgumentsInType(getTypeArgumentsRecord(decl, args), associatedType), value[caseName]);
-    }
-    return [];
-};
+export const getNestedDeclarationsInEnumDecl = (addedDecls, decl) => getNestedDeclarationsInEnumType(addedDecls, decl.type.value);
+export const validateEnumDecl = (helpers, decl, args, value) => validateEnumType(helpers, resolveTypeArgumentsInEnumType(getTypeArgumentsRecord(decl, args), decl.type.value), value);
 export const resolveTypeArgumentsInEnumDecl = (decl, args) => {
     const resolvedArgs = getTypeArgumentsRecord(decl, args);
     return EnumDecl(decl.sourceUrl, {
         ...decl,
-        values: () => Object.fromEntries(Object.entries(decl.values.value).map(([key, value]) => [
-            key,
-            value === null ? null : resolveTypeArgumentsInType(resolvedArgs, value),
-        ])),
+        values: () => resolveTypeArgumentsInEnumType(resolvedArgs, decl.type.value).values,
     });
 };
-export const serializeEnumDecl = type => ({
-    ...type,
-    values: Object.fromEntries(Object.entries(type.values.value).map(([key, value]) => [
-        key,
-        value === null ? null : serializeType(value),
-    ])),
-    parameters: type.parameters.map(param => serializeTypeParameter(param)),
+export const serializeEnumDecl = decl => ({
+    ...decl,
+    type: serializeEnumType(decl.type.value),
+    parameters: decl.parameters.map(param => serializeTypeParameter(param)),
 });
-export const getReferencesForEnumDecl = (decl, value) => typeof value === "object" &&
-    value !== null &&
-    !Array.isArray(value) &&
-    discriminatorKey in value &&
-    typeof value[discriminatorKey] === "string" &&
-    value[discriminatorKey] in decl.values.value &&
-    decl.values.value[value[discriminatorKey]] !== null &&
-    value[discriminatorKey] in value
-    ? getReferencesForType(decl.values.value[value[discriminatorKey]], value[value[discriminatorKey]])
-    : [];
+export const getReferencesForEnumDecl = (decl, value) => getReferencesForEnumType(decl.type.value, value);

package/lib/schema/declarations/TypeAliasDecl.d.ts

@@ -7,14 +7,17 @@ import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } fr
 export interface TypeAliasDecl<Name extends string = string, T extends Type = Type, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["TypeAliasDecl"];
     type: Lazy<T>;
+    isDeprecated?: boolean;
 }
 export interface SerializedTypeAliasDecl<Name extends string = string, T extends SerializedType = SerializedType, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseDecl<Name, Params> {
     kind: NodeKind["TypeAliasDecl"];
     type: T;
+    isDeprecated?: boolean;
 }
 export declare const GenTypeAliasDecl: <Name extends string, T extends Type, Params extends TypeParameter[]>(sourceUrl: string, options: {
     name: Name;
     comment?: string;
+    isDeprecated?: boolean;
     parameters: Params;
     type: (...args: Params) => T;
 }) => TypeAliasDecl<Name, T, Params>;
@@ -22,6 +25,7 @@ export { GenTypeAliasDecl as GenTypeAlias };
 export declare const TypeAliasDecl: <Name extends string, T extends Type>(sourceUrl: string, options: {
     name: Name;
     comment?: string;
+    isDeprecated?: boolean;
     type: () => T;
 }) => TypeAliasDecl<Name, T, []>;
 export { TypeAliasDecl as TypeAlias };

package/lib/schema/declarations/TypeAliasDecl.js

@@ -35,7 +35,7 @@ export const TypeAliasDecl = (sourceUrl, options) => {
 };
 export { TypeAliasDecl as TypeAlias };
 export const isTypeAliasDecl = (node) => node.kind === NodeKind.TypeAliasDecl;
-export const getNestedDeclarationsInTypeAliasDecl = (isDeclAdded, decl) => getNestedDeclarations(isDeclAdded, decl.type.value);
+export const getNestedDeclarationsInTypeAliasDecl = (addedDecls, decl) => getNestedDeclarations(addedDecls, decl.type.value);
 export const validateTypeAliasDecl = (helpers, decl, args, value) => validate(helpers, resolveTypeArgumentsInType(getTypeArgumentsRecord(decl, args), decl.type.value), value);
 export const resolveTypeArgumentsInTypeAliasDecl = (decl, args) => TypeAliasDecl(decl.sourceUrl, {
     ...decl,

package/lib/schema/index.d.ts

@@ -5,6 +5,7 @@ export * from "./declarations/TypeAliasDecl.js";
 export * from "./Node.js";
 export * from "./parameters/TypeParameter.js";
 export * from "./types/generic/ArrayType.js";
+export { EnumCase } from "./types/generic/EnumType.js";
 export * from "./types/generic/ObjectType.js";
 export * from "./types/primitives/BooleanType.js";
 export * from "./types/primitives/DateType.js";

package/lib/schema/index.js

@@ -5,6 +5,7 @@ export * from "./declarations/TypeAliasDecl.js";
 export * from "./Node.js";
 export * from "./parameters/TypeParameter.js";
 export * from "./types/generic/ArrayType.js";
+export { EnumCase } from "./types/generic/EnumType.js";
 export * from "./types/generic/ObjectType.js";
 export * from "./types/primitives/BooleanType.js";
 export * from "./types/primitives/DateType.js";

package/lib/schema/types/Type.d.ts

@@ -2,6 +2,7 @@ import { Decl } from "../declarations/Declaration.js";
 import { BaseNode, GetReferences, Serializer } from "../Node.js";
 import { Validator } from "../validation/type.js";
 import { ArrayType, SerializedArrayType } from "./generic/ArrayType.js";
+import { EnumType, SerializedEnumType } from "./generic/EnumType.js";
 import { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "./generic/ObjectType.js";
 import { BooleanType, SerializedBooleanType } from "./primitives/BooleanType.js";
 import { DateType, SerializedDateType } from "./primitives/DateType.js";
@@ -21,8 +22,8 @@ export interface BaseType extends BaseNode {
 }
 export interface SerializedBaseType extends BaseNode {
 }
-export type Type = PrimitiveType | ArrayType | ObjectType | GenericArgumentIdentifierType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType;
-export type SerializedType = SerializedPrimitiveType | SerializedArrayType | SerializedObjectType | SerializedGenericArgumentIdentifierType | SerializedReferenceIdentifierType | SerializedIncludeIdentifierType | SerializedNestedEntityMapType;
+export type Type = PrimitiveType | ArrayType | ObjectType | GenericArgumentIdentifierType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType | EnumType;
+export type SerializedType = SerializedPrimitiveType | SerializedArrayType | SerializedObjectType | SerializedGenericArgumentIdentifierType | SerializedReferenceIdentifierType | SerializedIncludeIdentifierType | SerializedNestedEntityMapType | SerializedEnumType;
 export declare const validate: Validator<Type>;
 export declare const resolveTypeArgumentsInType: <Args extends Record<string, Type>>(args: Args, type: Type) => Type;
 export declare function walkTypeNodeTree(callbackFn: (type: Type) => void, type: Type): void;
@@ -40,3 +41,8 @@ export declare const findTypeAtPath: (type: Type, path: string[]) => Type | unde
 export declare const serializeType: Serializer<Type, SerializedType>;
 export declare const removeParentKey: <T extends BaseType>(type: T) => Omit<T, "parent">;
 export declare const getReferencesForType: GetReferences<Type>;
+/**
+ * Format the structure of a value to always look the same when serialized as JSON.
+ */
+export type StructureFormatter<T extends Type> = (type: T, value: unknown) => unknown;
+export declare const formatValue: StructureFormatter<Type>;

package/lib/schema/types/Type.js

@@ -1,17 +1,18 @@
 import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { isDecl } from "../declarations/Declaration.js";
 import { NodeKind } from "../Node.js";
-import { getReferencesForArrayType, resolveTypeArgumentsInArrayType, serializeArrayType, validateArrayType, } from "./generic/ArrayType.js";
-import { getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "./generic/ObjectType.js";
-import { getReferencesForBooleanType, serializeBooleanType, validateBooleanType, } from "./primitives/BooleanType.js";
-import { getReferencesForDateType, serializeDateType, validateDateType, } from "./primitives/DateType.js";
-import { getReferencesForFloatType, serializeFloatType, validateFloatType, } from "./primitives/FloatType.js";
-import { getReferencesForIntegerType, serializeIntegerType, validateIntegerType, } from "./primitives/IntegerType.js";
-import { getReferencesForStringType, serializeStringType, validateStringType, } from "./primitives/StringType.js";
-import { getReferencesForGenericArgumentIdentifierType, resolveTypeArgumentsInGenericArgumentIdentifierType, serializeGenericArgumentIdentifierType, validateGenericArgumentIdentifierType, } from "./references/GenericArgumentIdentifierType.js";
-import { getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, validateIncludeIdentifierType, } from "./references/IncludeIdentifierType.js";
-import { getReferencesForNestedEntityMapType, resolveTypeArgumentsInNestedEntityMapType, serializeNestedEntityMapType, validateNestedEntityMapType, } from "./references/NestedEntityMapType.js";
-import { getReferencesForReferenceIdentifierType, resolveTypeArgumentsInReferenceIdentifierType, serializeReferenceIdentifierType, validateReferenceIdentifierType, } from "./references/ReferenceIdentifierType.js";
+import { formatArrayValue, getReferencesForArrayType, resolveTypeArgumentsInArrayType, serializeArrayType, validateArrayType, } from "./generic/ArrayType.js";
+import { formatEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "./generic/EnumType.js";
+import { formatObjectValue, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "./generic/ObjectType.js";
+import { formatBooleanValue, getReferencesForBooleanType, serializeBooleanType, validateBooleanType, } from "./primitives/BooleanType.js";
+import { formatDateValue, getReferencesForDateType, serializeDateType, validateDateType, } from "./primitives/DateType.js";
+import { formatFloatValue, getReferencesForFloatType, serializeFloatType, validateFloatType, } from "./primitives/FloatType.js";
+import { formatIntegerValue, getReferencesForIntegerType, serializeIntegerType, validateIntegerType, } from "./primitives/IntegerType.js";
+import { formatStringValue, getReferencesForStringType, serializeStringType, validateStringType, } from "./primitives/StringType.js";
+import { formatGenericArgumentIdentifierValue, getReferencesForGenericArgumentIdentifierType, resolveTypeArgumentsInGenericArgumentIdentifierType, serializeGenericArgumentIdentifierType, validateGenericArgumentIdentifierType, } from "./references/GenericArgumentIdentifierType.js";
+import { formatIncludeIdentifierValue, getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, validateIncludeIdentifierType, } from "./references/IncludeIdentifierType.js";
+import { formatNestedEntityMapValue, getReferencesForNestedEntityMapType, resolveTypeArgumentsInNestedEntityMapType, serializeNestedEntityMapType, validateNestedEntityMapType, } from "./references/NestedEntityMapType.js";
+import { formatReferenceIdentifierValue, getReferencesForReferenceIdentifierType, resolveTypeArgumentsInReferenceIdentifierType, serializeReferenceIdentifierType, validateReferenceIdentifierType, } from "./references/ReferenceIdentifierType.js";
 export const validate = (helpers, type, value) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -36,6 +37,8 @@ export const validate = (helpers, type, value) => {
             return validateIncludeIdentifierType(helpers, type, value);
         case NodeKind.NestedEntityMapType:
             return validateNestedEntityMapType(helpers, type, value);
+        case NodeKind.EnumType:
+            return validateEnumType(helpers, type, value);
         default:
             return assertExhaustive(type);
     }
@@ -60,6 +63,8 @@ export const resolveTypeArgumentsInType = (args, type) => {
             return resolveTypeArgumentsInIncludeIdentifierType(args, type);
         case NodeKind.NestedEntityMapType:
             return resolveTypeArgumentsInNestedEntityMapType(args, type);
+        case NodeKind.EnumType:
+            return resolveTypeArgumentsInEnumType(args, type);
         default:
             return assertExhaustive(type);
     }
@@ -84,6 +89,13 @@ export function walkTypeNodeTree(callbackFn, type) {
         case NodeKind.ReferenceIdentifierType:
         case NodeKind.IncludeIdentifierType:
             return callbackFn(type);
+        case NodeKind.EnumType:
+            callbackFn(type);
+            return Object.values(type.values).forEach(value => {
+                if (value.type) {
+                    walkTypeNodeTree(callbackFn, value.type);
+                }
+            });
         default:
             return assertExhaustive(type);
     }
@@ -139,6 +151,8 @@ export const serializeType = type => {
             return serializeIncludeIdentifierType(type);
         case NodeKind.NestedEntityMapType:
             return serializeNestedEntityMapType(type);
+        case NodeKind.EnumType:
+            return serializeEnumType(type);
         default:
             return assertExhaustive(type);
     }
@@ -171,6 +185,38 @@ export const getReferencesForType = (type, value) => {
             return getReferencesForIncludeIdentifierType(type, value);
         case NodeKind.NestedEntityMapType:
             return getReferencesForNestedEntityMapType(type, value);
+        case NodeKind.EnumType:
+            return getReferencesForEnumType(type, value);
+        default:
+            return assertExhaustive(type);
+    }
+};
+export const formatValue = (type, value) => {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            return formatArrayValue(type, value);
+        case NodeKind.ObjectType:
+            return formatObjectValue(type, value);
+        case NodeKind.BooleanType:
+            return formatBooleanValue(type, value);
+        case NodeKind.DateType:
+            return formatDateValue(type, value);
+        case NodeKind.FloatType:
+            return formatFloatValue(type, value);
+        case NodeKind.IntegerType:
+            return formatIntegerValue(type, value);
+        case NodeKind.StringType:
+            return formatStringValue(type, value);
+        case NodeKind.GenericArgumentIdentifierType:
+            return formatGenericArgumentIdentifierValue(type, value);
+        case NodeKind.IncludeIdentifierType:
+            return formatIncludeIdentifierValue(type, value);
+        case NodeKind.NestedEntityMapType:
+            return formatNestedEntityMapValue(type, value);
+        case NodeKind.ReferenceIdentifierType:
+            return formatReferenceIdentifierValue(type, value);
+        case NodeKind.EnumType:
+            return formatEnumType(type, value);
         default:
             return assertExhaustive(type);
     }

package/lib/schema/types/generic/ArrayType.d.ts

@@ -1,7 +1,7 @@
 import { GetNestedDeclarations } from "../../declarations/Declaration.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, SerializedType, Type } from "../Type.js";
+import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
 export interface ArrayType<T extends Type = Type> extends BaseType {
     kind: NodeKind["ArrayType"];
     minItems?: number;
@@ -28,3 +28,4 @@ export declare const validateArrayType: Validator<ArrayType>;
 export declare const resolveTypeArgumentsInArrayType: (args: Record<string, Type>, type: ArrayType) => ArrayType;
 export declare const serializeArrayType: Serializer<ArrayType, SerializedArrayType>;
 export declare const getReferencesForArrayType: GetReferences<ArrayType>;
+export declare const formatArrayValue: StructureFormatter<ArrayType>;

package/lib/schema/types/generic/ArrayType.js

@@ -4,7 +4,7 @@ import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
 import { validateOption } from "../../validation/options.js";
-import { getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
+import { formatValue, getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
 export const ArrayType = (items, options = {}) => {
     const type = {
         ...options,
@@ -18,7 +18,7 @@ export const ArrayType = (items, options = {}) => {
 };
 export { ArrayType as Array };
 export const isArrayType = (node) => node.kind === NodeKind.ArrayType;
-export const getNestedDeclarationsInArrayType = (isDeclAdded, type) => getNestedDeclarations(isDeclAdded, type.items);
+export const getNestedDeclarationsInArrayType = (addedDecls, type) => getNestedDeclarations(addedDecls, type.items);
 export const validateArrayType = (helpers, type, value) => {
     if (!Array.isArray(value)) {
         return [TypeError(`expected an array, but got ${JSON.stringify(value)}`)];
@@ -36,3 +36,4 @@ export const serializeArrayType = type => ({
     items: serializeType(type.items),
 });
 export const getReferencesForArrayType = (type, value) => Array.isArray(value) ? value.flatMap(item => getReferencesForType(type.items, item)) : [];
+export const formatArrayValue = (type, value) => Array.isArray(value) ? value.map(item => formatValue(type.items, item)) : value;

package/lib/schema/types/generic/EnumType.d.ts

@@ -0,0 +1,38 @@
+import { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
+import { Validator } from "../../validation/type.js";
+import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+export interface EnumType<T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>> extends BaseType {
+    kind: NodeKind["EnumType"];
+    values: T;
+}
+export interface SerializedEnumType<T extends Record<string, SerializedEnumCaseDecl> = Record<string, SerializedEnumCaseDecl>> extends SerializedBaseType {
+    kind: NodeKind["EnumType"];
+    values: T;
+}
+export declare const EnumType: <T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>>(values: T) => EnumType<T>;
+export declare const isEnumType: (node: Node) => node is EnumType;
+export declare const getNestedDeclarationsInEnumType: GetNestedDeclarations<EnumType>;
+export declare const validateEnumType: Validator<EnumType>;
+export declare const resolveTypeArgumentsInEnumType: (args: Record<string, Type>, type: EnumType) => EnumType;
+export interface EnumCaseDecl<T extends Type | null = Type | null> {
+    kind: NodeKind["EnumCaseDecl"];
+    type: T;
+    comment?: string;
+    isDeprecated?: boolean;
+}
+export interface SerializedEnumCaseDecl<T extends SerializedType | null = SerializedType | null> {
+    kind: NodeKind["EnumCaseDecl"];
+    type: T;
+    comment?: string;
+    isDeprecated?: boolean;
+}
+export declare const EnumCaseDecl: <T extends Type | null>(options: {
+    type: T;
+    comment?: string;
+    isDeprecated?: boolean;
+}) => EnumCaseDecl<T>;
+export { EnumCaseDecl as EnumCase };
+export declare const serializeEnumType: Serializer<EnumType, SerializedEnumType>;
+export declare const getReferencesForEnumType: GetReferences<EnumType>;
+export declare const formatEnumType: StructureFormatter<EnumType>;

package/lib/schema/types/generic/EnumType.js

@@ -0,0 +1,96 @@
+import { discriminatorKey } from "../../../shared/enum.js";
+import { getNestedDeclarations } from "../../declarations/Declaration.js";
+import { NodeKind } from "../../Node.js";
+import { formatValue, getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
+export const EnumType = (values) => {
+    const type = {
+        kind: NodeKind.EnumType,
+        values,
+    };
+    type.values = Object.fromEntries(Object.entries(values).map(([caseName, caseDef]) => [
+        caseName,
+        { ...caseDef, type: caseDef.type === null ? null : { ...caseDef.type, parent: type } },
+    ]));
+    return type;
+};
+export const isEnumType = (node) => node.kind === NodeKind.EnumType;
+export const getNestedDeclarationsInEnumType = (addedDecls, type) => Object.values(type.values).reduce((acc, caseMember) => caseMember.type === null ? acc : getNestedDeclarations(acc, caseMember.type), addedDecls);
+export const validateEnumType = (helpers, type, value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return [TypeError(`expected an object, but got ${JSON.stringify(value)}`)];
+    }
+    const actualKeys = Object.keys(value);
+    if (!(discriminatorKey in value) || typeof value[discriminatorKey] !== "string") {
+        return [
+            TypeError(`missing required discriminator value at key "${discriminatorKey}" of type string`),
+        ];
+    }
+    const caseName = value[discriminatorKey];
+    if (!(caseName in type.values)) {
+        return [TypeError(`discriminator "${caseName}" is not a valid enum case`)];
+    }
+    const unknownKeyErrors = actualKeys.flatMap(actualKey => actualKey === discriminatorKey || actualKey in type.values
+        ? []
+        : [TypeError(`key "${actualKey}" is not the discriminator key or a valid enum case`)]);
+    if (unknownKeyErrors.length > 0) {
+        return unknownKeyErrors;
+    }
+    const associatedType = type.values[caseName]?.type;
+    if (associatedType != null) {
+        if (!(caseName in value)) {
+            return [TypeError(`missing required associated value for case "${caseName}"`)];
+        }
+        return validate(helpers, associatedType, value[caseName]);
+    }
+    return [];
+};
+export const resolveTypeArgumentsInEnumType = (args, type) => EnumType(Object.fromEntries(Object.entries(type.values).map(([key, { type, ...caseMember }]) => [
+    key,
+    {
+        ...caseMember,
+        type: type === null ? null : resolveTypeArgumentsInType(args, type),
+    },
+])));
+export const EnumCaseDecl = (options) => ({
+    ...options,
+    kind: NodeKind.EnumCaseDecl,
+});
+export { EnumCaseDecl as EnumCase };
+export const serializeEnumType = type => ({
+    ...removeParentKey(type),
+    values: Object.fromEntries(Object.entries(type.values).map(([key, caseMember]) => [
+        key,
+        {
+            ...caseMember,
+            type: caseMember.type === null ? null : serializeType(caseMember.type),
+        },
+    ])),
+});
+export const getReferencesForEnumType = (type, value) => typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    discriminatorKey in value &&
+    typeof value[discriminatorKey] === "string" &&
+    value[discriminatorKey] in type.values &&
+    type.values[value[discriminatorKey]]?.type == null &&
+    value[discriminatorKey] in value
+    ? getReferencesForType(type.values[value[discriminatorKey]].type, value[value[discriminatorKey]])
+    : [];
+export const formatEnumType = (type, value) => {
+    if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        discriminatorKey in value &&
+        typeof value[discriminatorKey] === "string") {
+        const caseName = value[discriminatorKey];
+        const caseValue = value[caseName];
+        const caseType = type.values[caseName]?.type;
+        return {
+            [discriminatorKey]: caseName,
+            ...(caseValue == null || caseType == null
+                ? {}
+                : { [caseName]: formatValue(caseType, caseValue) }),
+        };
+    }
+    return value;
+};

package/lib/schema/types/generic/ObjectType.d.ts

@@ -2,7 +2,7 @@ import { ObjectConstraints } from "../../../shared/validation/object.js";
 import { GetNestedDeclarations } from "../../declarations/Declaration.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, SerializedType, Type } from "../Type.js";
+import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
 type TConstraint = Record<string, MemberDecl<Type, boolean>>;
 export interface ObjectType<T extends TConstraint = TConstraint> extends BaseType, ObjectConstraints {
     kind: NodeKind["ObjectType"];
@@ -28,20 +28,25 @@ export interface MemberDecl<T extends Type = Type, R extends boolean = boolean>
     isRequired: R;
     type: T;
     comment?: string;
+    isDeprecated?: boolean;
 }
 export interface SerializedMemberDecl<T extends SerializedType = SerializedType, R extends boolean = boolean> {
     kind: NodeKind["MemberDecl"];
     isRequired: R;
     type: T;
     comment?: string;
+    isDeprecated?: boolean;
 }
 export declare const Required: <T extends Type>(options: {
     comment?: string;
+    isDeprecated?: boolean;
     type: T;
 }) => MemberDecl<T, true>;
 export declare const Optional: <T extends Type>(options: {
     comment?: string;
+    isDeprecated?: boolean;
     type: T;
 }) => MemberDecl<T, false>;
 export declare const serializeObjectType: Serializer<ObjectType, SerializedObjectType>;
 export declare const getReferencesForObjectType: GetReferences<ObjectType>;
+export declare const formatObjectValue: StructureFormatter<ObjectType>;

package/lib/schema/types/generic/ObjectType.js

@@ -1,3 +1,4 @@
+import { sortObjectKeys } from "../../../shared/utils/object.js";
 import { parallelizeErrors } from "../../../shared/utils/validation.js";
 import { validateObjectConstraints } from "../../../shared/validation/object.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
@@ -24,7 +25,7 @@ export const ObjectType = (properties, options = {}) => {
 };
 export { ObjectType as Object };
 export const isObjectType = (node) => node.kind === NodeKind.ObjectType;
-export const getNestedDeclarationsInObjectType = (isDeclAdded, type) => Object.values(type.properties).flatMap(prop => getNestedDeclarations(isDeclAdded, prop.type));
+export const getNestedDeclarationsInObjectType = (addedDecls, type) => Object.values(type.properties).reduce((acc, prop) => getNestedDeclarations(acc, prop.type), addedDecls);
 export const validateObjectType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${JSON.stringify(value)}`)];
@@ -47,14 +48,15 @@ export const validateObjectType = (helpers, type, value) => {
 export const resolveTypeArgumentsInObjectType = (args, type) => ObjectType(Object.fromEntries(Object.entries(type.properties).map(([key, config]) => [key, { ...config, type: resolveTypeArgumentsInType(args, config.type) }])), {
     ...type,
 });
-const MemberDecl = (isRequired, type, comment) => ({
+const MemberDecl = (isRequired, type, comment, isDeprecated) => ({
     kind: NodeKind.MemberDecl,
     isRequired,
     type,
     comment,
+    isDeprecated,
 });
-export const Required = (options) => MemberDecl(true, options.type, options.comment);
-export const Optional = (options) => MemberDecl(false, options.type, options.comment);
+export const Required = (options) => MemberDecl(true, options.type, options.comment, options.isDeprecated);
+export const Optional = (options) => MemberDecl(false, options.type, options.comment, options.isDeprecated);
 export const serializeObjectType = type => ({
     ...removeParentKey(type),
     properties: Object.fromEntries(Object.entries(type.properties).map(([key, prop]) => [
@@ -68,3 +70,6 @@ export const serializeObjectType = type => ({
 export const getReferencesForObjectType = (type, value) => typeof value === "object" && value !== null
     ? Object.entries(value).flatMap(([key, propValue]) => key in type.properties ? getReferencesForType(type.properties[key].type, propValue) : [])
     : [];
+export const formatObjectValue = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? sortObjectKeys(value, Object.keys(type.properties))
+    : value;

package/lib/schema/types/primitives/BooleanType.d.ts

@@ -1,6 +1,6 @@
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface BooleanType extends BaseType {
     kind: NodeKind["BooleanType"];
 }
@@ -13,3 +13,4 @@ export declare const isBooleanType: (node: Node) => node is BooleanType;
 export declare const validateBooleanType: Validator<BooleanType>;
 export declare const serializeBooleanType: Serializer<BooleanType, SerializedBooleanType>;
 export declare const getReferencesForBooleanType: GetReferences<BooleanType>;
+export declare const formatBooleanValue: StructureFormatter<BooleanType>;

package/lib/schema/types/primitives/BooleanType.js

@@ -13,3 +13,4 @@ export const validateBooleanType = (_helpers, _type, value) => {
 };
 export const serializeBooleanType = type => removeParentKey(type);
 export const getReferencesForBooleanType = (_type, _value) => [];
+export const formatBooleanValue = (_type, value) => value;

package/lib/schema/types/primitives/DateType.d.ts

@@ -1,7 +1,7 @@
 import { DateConstraints } from "../../../shared/validation/date.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface DateType extends BaseType, DateConstraints {
     kind: NodeKind["DateType"];
 }
@@ -14,3 +14,4 @@ export declare const isDateType: (node: Node) => node is DateType;
 export declare const validateDateType: Validator<DateType>;
 export declare const serializeDateType: Serializer<DateType, SerializedDateType>;
 export declare const getReferencesForDateType: GetReferences<DateType>;
+export declare const formatDateValue: StructureFormatter<DateType>;