tsondb 0.2.0 → 0.4.0

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

@@ -0,0 +1,98 @@
+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(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    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 → node/schema}/types/generic/ObjectType.d.ts

@@ -1,14 +1,15 @@
-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";
-type TConstraint = Record<string, MemberDecl<Type, boolean>>;
+import type { ObjectConstraints } from "../../../../shared/validation/object.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
+type TConstraint = Record<string, MemberDecl>;
 export interface ObjectType<T extends TConstraint = TConstraint> extends BaseType, ObjectConstraints {
     kind: NodeKind["ObjectType"];
     properties: T;
 }
-type TSerializedConstraint = Record<string, SerializedMemberDecl<SerializedType, boolean>>;
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
 export interface SerializedObjectType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType, ObjectConstraints {
     kind: NodeKind["ObjectType"];
     properties: T;
@@ -49,3 +50,4 @@ export declare const Optional: <T extends Type>(options: {
 }) => 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 → node/schema}/types/generic/ObjectType.js

@@ -1,5 +1,6 @@
-import { parallelizeErrors } from "../../../shared/utils/validation.js";
-import { validateObjectConstraints } from "../../../shared/validation/object.js";
+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";
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
@@ -18,6 +19,7 @@ export const ObjectType = (properties, options = {}) => {
         if (!keyPattern.test(key)) {
             throw new TypeError(`Invalid object key "${key}". Object keys must not start with an underscore and may only contain letters, digits and underscores. (Pattern: ${keyPattern.source})`);
         }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         properties[key].type.parent = type;
     });
     return type;
@@ -33,6 +35,7 @@ export const validateObjectType = (helpers, type, value) => {
     return parallelizeErrors([
         ...validateObjectConstraints(type, expectedKeys, value),
         ...expectedKeys.map(key => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const prop = type.properties[key];
             if (prop.isRequired && !(key in value)) {
                 return TypeError(`missing required property "${key}"`);
@@ -67,5 +70,10 @@ 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) : [])
+    ? Object.entries(value).flatMap(([key, propValue]) => 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    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 → node/schema}/types/primitives/BooleanType.d.ts

@@ -1,6 +1,7 @@
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface BooleanType extends BaseType {
     kind: NodeKind["BooleanType"];
 }
@@ -13,3 +14,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 → node/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 → node/schema}/types/primitives/DateType.d.ts

@@ -1,7 +1,8 @@
-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 type { DateConstraints } from "../../../../shared/validation/date.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface DateType extends BaseType, DateConstraints {
     kind: NodeKind["DateType"];
 }
@@ -14,3 +15,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>;

package/lib/{schema → node/schema}/types/primitives/DateType.js

@@ -1,4 +1,4 @@
-import { validateDateConstraints } from "../../../shared/validation/date.js";
+import { validateDateConstraints } from "../../../../shared/validation/date.js";
 import { NodeKind } from "../../Node.js";
 import { removeParentKey } from "../Type.js";
 export const DateType = (options) => ({
@@ -15,3 +15,4 @@ export const validateDateType = (_helpers, type, value) => {
 };
 export const serializeDateType = type => removeParentKey(type);
 export const getReferencesForDateType = (_type, _value) => [];
+export const formatDateValue = (_type, value) => value;

package/lib/{schema → node/schema}/types/primitives/FloatType.d.ts

@@ -1,7 +1,8 @@
-import { RangeBound } from "../../../shared/validation/number.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import type { RangeBound } from "../../../../shared/validation/number.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface FloatType extends BaseType {
     kind: NodeKind["FloatType"];
     minimum?: RangeBound;
@@ -24,3 +25,4 @@ export declare const isFloatType: (node: Node) => node is FloatType;
 export declare const validateFloatType: Validator<FloatType>;
 export declare const serializeFloatType: Serializer<FloatType, SerializedFloatType>;
 export declare const getReferencesForFloatType: GetReferences<FloatType>;
+export declare const formatFloatValue: StructureFormatter<FloatType>;

package/lib/{schema → node/schema}/types/primitives/FloatType.js

@@ -1,4 +1,4 @@
-import { validateNumberConstraints } from "../../../shared/validation/number.js";
+import { validateNumberConstraints } from "../../../../shared/validation/number.js";
 import { NodeKind } from "../../Node.js";
 import { removeParentKey } from "../Type.js";
 export const FloatType = (options = {}) => ({
@@ -15,3 +15,4 @@ export const validateFloatType = (_helpers, type, value) => {
 };
 export const serializeFloatType = type => removeParentKey(type);
 export const getReferencesForFloatType = (_type, _value) => [];
+export const formatFloatValue = (_type, value) => value;

package/lib/{schema → node/schema}/types/primitives/IntegerType.d.ts

@@ -1,7 +1,8 @@
-import { RangeBound } from "../../../shared/validation/number.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import type { RangeBound } from "../../../../shared/validation/number.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface IntegerType extends BaseType {
     kind: NodeKind["IntegerType"];
     minimum?: RangeBound;
@@ -24,3 +25,4 @@ export declare const isIntegerType: (node: Node) => node is IntegerType;
 export declare const validateIntegerType: Validator<IntegerType>;
 export declare const serializeIntegerType: Serializer<IntegerType, SerializedIntegerType>;
 export declare const getReferencesForIntegerType: GetReferences<IntegerType>;
+export declare const formatIntegerValue: StructureFormatter<IntegerType>;

package/lib/{schema → node/schema}/types/primitives/IntegerType.js

@@ -1,4 +1,4 @@
-import { validateNumberConstraints } from "../../../shared/validation/number.js";
+import { validateNumberConstraints } from "../../../../shared/validation/number.js";
 import { NodeKind } from "../../Node.js";
 import { validateOption } from "../../validation/options.js";
 import { removeParentKey } from "../Type.js";
@@ -19,3 +19,4 @@ export const validateIntegerType = (_helpers, type, value) => {
 };
 export const serializeIntegerType = type => removeParentKey(type);
 export const getReferencesForIntegerType = (_type, _value) => [];
+export const formatIntegerValue = (_type, value) => value;

package/lib/{schema → node/schema}/types/primitives/NumericType.d.ts

@@ -1,5 +1,5 @@
-import { FloatType, SerializedFloatType } from "./FloatType.js";
-import { IntegerType, SerializedIntegerType } from "./IntegerType.js";
+import type { FloatType, SerializedFloatType } from "./FloatType.js";
+import type { IntegerType, SerializedIntegerType } from "./IntegerType.js";
 export type NumericType = FloatType | IntegerType;
 export type SerializedNumericType = SerializedFloatType | SerializedIntegerType;
 export * from "./FloatType.js";

package/lib/node/schema/types/primitives/PrimitiveType.d.ts

@@ -0,0 +1,6 @@
+import type { BooleanType, SerializedBooleanType } from "./BooleanType.js";
+import type { DateType, SerializedDateType } from "./DateType.js";
+import type { NumericType, SerializedNumericType } from "./NumericType.js";
+import type { SerializedStringType, StringType } from "./StringType.js";
+export type PrimitiveType = BooleanType | DateType | NumericType | StringType;
+export type SerializedPrimitiveType = SerializedBooleanType | SerializedDateType | SerializedNumericType | SerializedStringType;

package/lib/{schema → node/schema}/types/primitives/StringType.d.ts

@@ -1,7 +1,8 @@
-import { StringConstraints } from "../../../shared/validation/string.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import type { StringConstraints } from "../../../../shared/validation/string.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface StringType extends BaseType, StringConstraints {
     kind: NodeKind["StringType"];
     pattern?: RegExp;
@@ -23,3 +24,4 @@ export declare const isStringType: (node: Node) => node is StringType;
 export declare const validateStringType: Validator<StringType>;
 export declare const serializeStringType: Serializer<StringType, SerializedStringType>;
 export declare const getReferencesForStringType: GetReferences<StringType>;
+export declare const formatStringValue: StructureFormatter<StringType>;

package/lib/{schema → node/schema}/types/primitives/StringType.js

@@ -1,4 +1,4 @@
-import { validateStringConstraints } from "../../../shared/validation/string.js";
+import { validateStringConstraints } from "../../../../shared/validation/string.js";
 import { NodeKind } from "../../Node.js";
 import { removeParentKey } from "../Type.js";
 export const StringType = (options = {}) => ({
@@ -18,3 +18,4 @@ export const serializeStringType = type => removeParentKey({
     pattern: type.pattern?.source,
 });
 export const getReferencesForStringType = (_type, _value) => [];
+export const formatStringValue = (_type, value) => value;

package/lib/{schema → node/schema}/types/references/IncludeIdentifierType.d.ts

@@ -1,10 +1,12 @@
-import { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.js";
-import { EnumCaseDecl, EnumDecl } from "../../declarations/EnumDecl.js";
-import { TypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../../parameters/TypeParameter.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, Type } from "../Type.js";
+import type { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.js";
+import type { EnumDecl } from "../../declarations/EnumDecl.js";
+import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../../TypeParameter.js";
+import type { Validator } from "../../validation/type.js";
+import type { EnumCaseDecl } from "../generic/EnumType.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
 type TConstraint<Params extends TypeParameter[]> = TypeAliasDecl<string, Type, Params> | EnumDecl<string, Record<string, EnumCaseDecl>, Params>;
 export interface IncludeIdentifierType<Params extends TypeParameter[] = TypeParameter[], T extends TConstraint<Params> = TConstraint<Params>> extends BaseType {
     kind: NodeKind["IncludeIdentifierType"];
@@ -23,6 +25,7 @@ export { IncludeIdentifierType as IncludeIdentifier };
 export declare const isIncludeIdentifierType: (node: Node) => node is IncludeIdentifierType;
 export declare const getNestedDeclarationsInIncludeIdentifierType: GetNestedDeclarations<IncludeIdentifierType>;
 export declare const validateIncludeIdentifierType: Validator<IncludeIdentifierType>;
-export declare const resolveTypeArgumentsInIncludeIdentifierType: (args: Record<string, Type>, type: IncludeIdentifierType) => IncludeIdentifierType;
+export declare const resolveTypeArgumentsInIncludeIdentifierType: (args: Record<string, Type>, type: IncludeIdentifierType) => Type;
 export declare const serializeIncludeIdentifierType: Serializer<IncludeIdentifierType, SerializedIncludeIdentifierType>;
 export declare const getReferencesForIncludeIdentifierType: GetReferences<IncludeIdentifierType>;
+export declare const formatIncludeIdentifierValue: StructureFormatter<IncludeIdentifierType>;

package/lib/{schema → node/schema}/types/references/IncludeIdentifierType.js

@@ -1,6 +1,7 @@
 import { getNestedDeclarations, getReferencesForDecl, resolveTypeArgumentsInDecl, validateDecl, } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
-import { removeParentKey, resolveTypeArgumentsInType, serializeType, } from "../Type.js";
+import { formatEnumType } from "../generic/EnumType.js";
+import { formatValue, removeParentKey, resolveTypeArgumentsInType, serializeType } from "../Type.js";
 export const GenIncludeIdentifierType = (reference, args) => ({
     kind: NodeKind.IncludeIdentifierType,
     reference,
@@ -18,10 +19,22 @@ export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) =
     ? addedDecls
     : getNestedDeclarations([type.reference, ...addedDecls], type.reference);
 export const validateIncludeIdentifierType = (helpers, type, value) => validateDecl(helpers, type.reference, type.args, value);
-export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => GenIncludeIdentifierType(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg)));
+export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => type.args.length === 0
+    ? type
+    : resolveTypeArgumentsInDecl(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg))).type.value;
 export const serializeIncludeIdentifierType = type => ({
     ...removeParentKey(type),
     reference: type.reference.name,
     args: type.args.map(arg => serializeType(arg)),
 });
 export const getReferencesForIncludeIdentifierType = (type, value) => getReferencesForDecl(resolveTypeArgumentsInDecl(type.reference, type.args), value);
+export const formatIncludeIdentifierValue = (type, value) => {
+    switch (type.reference.kind) {
+        case NodeKind.TypeAliasDecl:
+            return formatValue(type.reference.type.value, value);
+        case NodeKind.EnumDecl:
+            return formatEnumType(type.reference.type.value, value);
+        default:
+            return value;
+    }
+};

package/lib/{schema → node/schema}/types/references/NestedEntityMapType.d.ts

@@ -1,11 +1,12 @@
-import { Lazy } from "../../../utils/lazy.js";
-import { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import { EntityDecl } from "../../declarations/EntityDecl.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.js";
-import { BaseType, SerializedBaseType, SerializedType, Type } from "../Type.js";
-type TConstraint = Record<string, MemberDecl<Type, boolean>>;
+import { Lazy } from "../../../../shared/utils/lazy.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { EntityDecl } from "../../declarations/EntityDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+type TConstraint = Record<string, MemberDecl>;
 export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;
@@ -13,7 +14,7 @@ export interface NestedEntityMapType<Name extends string = string, T extends TCo
     secondaryEntity: EntityDecl;
     type: Lazy<ObjectType<T>>;
 }
-type TSerializedConstraint = Record<string, SerializedMemberDecl<SerializedType, boolean>>;
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
 export interface SerializedNestedEntityMapType<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;
@@ -34,3 +35,4 @@ export declare const validateNestedEntityMapType: Validator<NestedEntityMapType>
 export declare const resolveTypeArgumentsInNestedEntityMapType: (args: Record<string, Type>, type: NestedEntityMapType) => NestedEntityMapType;
 export declare const serializeNestedEntityMapType: Serializer<NestedEntityMapType, SerializedNestedEntityMapType>;
 export declare const getReferencesForNestedEntityMapType: GetReferences<NestedEntityMapType>;
+export declare const formatNestedEntityMapValue: StructureFormatter<NestedEntityMapType>;

package/lib/{schema → node/schema}/types/references/NestedEntityMapType.js

@@ -1,6 +1,7 @@
-import { parallelizeErrors } from "../../../shared/utils/validation.js";
+import { Lazy } from "../../../../shared/utils/lazy.js";
+import { sortObjectKeysAlphabetically } from "../../../../shared/utils/object.js";
+import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
-import { Lazy } from "../../../utils/lazy.js";
 import { NodeKind } from "../../Node.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "../generic/ObjectType.js";
 import { removeParentKey } from "../Type.js";
@@ -54,3 +55,6 @@ export const getReferencesForNestedEntityMapType = (type, value) => typeof value
         .flatMap(item => getReferencesForObjectType(type.type.value, item))
         .concat(Object.keys(value))
     : [];
+export const formatNestedEntityMapValue = (_type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? sortObjectKeysAlphabetically(value)
+    : value;

package/lib/{schema → node/schema}/types/references/ReferenceIdentifierType.d.ts

@@ -1,8 +1,9 @@
-import { GetNestedDeclarations } from "../../declarations/Declaration.js";
-import { EntityDecl } from "../../declarations/EntityDecl.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, Type } from "../Type.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { EntityDecl } from "../../declarations/EntityDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
 export interface ReferenceIdentifierType extends BaseType {
     kind: NodeKind["ReferenceIdentifierType"];
     entity: EntityDecl;
@@ -16,6 +17,7 @@ export { ReferenceIdentifierType as ReferenceIdentifier };
 export declare const isReferenceIdentifierType: (node: Node) => node is ReferenceIdentifierType;
 export declare const getNestedDeclarationsInReferenceIdentifierType: GetNestedDeclarations<ReferenceIdentifierType>;
 export declare const validateReferenceIdentifierType: Validator<ReferenceIdentifierType>;
-export declare const resolveTypeArgumentsInReferenceIdentifierType: <Args extends Record<string, Type>>(_args: Args, type: ReferenceIdentifierType) => ReferenceIdentifierType;
+export declare const resolveTypeArgumentsInReferenceIdentifierType: (_args: Record<string, Type>, type: ReferenceIdentifierType) => ReferenceIdentifierType;
 export declare const serializeReferenceIdentifierType: Serializer<ReferenceIdentifierType, SerializedReferenceIdentifierType>;
 export declare const getReferencesForReferenceIdentifierType: GetReferences<ReferenceIdentifierType>;
+export declare const formatReferenceIdentifierValue: StructureFormatter<ReferenceIdentifierType>;

package/lib/{schema → node/schema}/types/references/ReferenceIdentifierType.js

@@ -21,3 +21,4 @@ export const serializeReferenceIdentifierType = type => ({
     entity: type.entity.name,
 });
 export const getReferencesForReferenceIdentifierType = (_type, value) => (typeof value === "string" ? [value] : []);
+export const formatReferenceIdentifierValue = (_type, value) => value;

package/lib/node/schema/types/references/TypeArgumentType.d.ts

@@ -0,0 +1,23 @@
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../../TypeParameter.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+type TConstraint = TypeParameter;
+export interface TypeArgumentType<T extends TConstraint = TConstraint> extends BaseType {
+    kind: NodeKind["TypeArgumentType"];
+    argument: T;
+}
+type TSerializedConstraint = SerializedTypeParameter;
+export interface SerializedTypeArgumentType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
+    kind: NodeKind["TypeArgumentType"];
+    argument: T;
+}
+export declare const TypeArgumentType: <T extends TConstraint>(argument: T) => TypeArgumentType<T>;
+export { TypeArgumentType as TypeArgument };
+export declare const isTypeArgumentType: (node: Node) => node is TypeArgumentType;
+export declare const validateTypeArgumentType: Validator<TypeArgumentType>;
+export declare const resolveTypeArgumentsInTypeArgumentType: <T extends TConstraint, Args extends Record<string, Type>>(args: Args, type: TypeArgumentType<T>) => Args[T["name"]];
+export declare const serializeTypeArgumentType: Serializer<TypeArgumentType, SerializedTypeArgumentType>;
+export declare const getReferencesForTypeArgumentType: GetReferences<TypeArgumentType>;
+export declare const formatTypeArgumentValue: StructureFormatter<TypeArgumentType>;

package/lib/node/schema/types/references/TypeArgumentType.js

@@ -0,0 +1,19 @@
+import { NodeKind } from "../../Node.js";
+import { serializeTypeParameter } from "../../TypeParameter.js";
+import { removeParentKey } from "../Type.js";
+export const TypeArgumentType = (argument) => ({
+    kind: NodeKind.TypeArgumentType,
+    argument,
+});
+export { TypeArgumentType as TypeArgument };
+export const isTypeArgumentType = (node) => node.kind === NodeKind.TypeArgumentType;
+export const validateTypeArgumentType = (_helpers, type, _value) => {
+    throw new TypeError(`generic argument "${type.argument.name}" has not been replaced with a concrete type`);
+};
+export const resolveTypeArgumentsInTypeArgumentType = (args, type) => args[type.argument.name];
+export const serializeTypeArgumentType = type => ({
+    ...removeParentKey(type),
+    argument: serializeTypeParameter(type.argument),
+});
+export const getReferencesForTypeArgumentType = (_type, _value) => [];
+export const formatTypeArgumentValue = (_type, value) => value;

package/lib/node/schema/validation/type.d.ts

@@ -0,0 +1,4 @@
+import type { Validators } from "../Node.js";
+import type { Type } from "../types/Type.js";
+export type ValidatorHelpers = Validators;
+export type Validator<T extends Type, Args extends unknown[] = []> = (helpers: ValidatorHelpers, type: T, value: unknown, ...args: Args) => Error[];

package/lib/node/server/api/declarations.d.ts

@@ -0,0 +1 @@
+export declare const declarationsApi: import("express-serve-static-core").Router;