tsondb 0.1.3

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

@@ -0,0 +1,47 @@
+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>>;
+export interface ObjectType<T extends TConstraint = TConstraint> extends BaseType, ObjectConstraints {
+    kind: NodeKind["ObjectType"];
+    properties: T;
+}
+type TSerializedConstraint = Record<string, SerializedMemberDecl<SerializedType, boolean>>;
+export interface SerializedObjectType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType, ObjectConstraints {
+    kind: NodeKind["ObjectType"];
+    properties: T;
+}
+export declare const ObjectType: <T extends TConstraint>(properties: T, options?: {
+    additionalProperties?: boolean;
+    minProperties?: number;
+    maxProperties?: number;
+}) => ObjectType<T>;
+export { ObjectType as Object };
+export declare const isObjectType: (node: Node) => node is ObjectType;
+export declare const getNestedDeclarationsInObjectType: GetNestedDeclarations<ObjectType>;
+export declare const validateObjectType: Validator<ObjectType>;
+export declare const resolveTypeArgumentsInObjectType: (args: Record<string, Type>, type: ObjectType) => ObjectType;
+export interface MemberDecl<T extends Type = Type, R extends boolean = boolean> {
+    kind: NodeKind["MemberDecl"];
+    isRequired: R;
+    type: T;
+    comment?: string;
+}
+export interface SerializedMemberDecl<T extends SerializedType = SerializedType, R extends boolean = boolean> {
+    kind: NodeKind["MemberDecl"];
+    isRequired: R;
+    type: T;
+    comment?: string;
+}
+export declare const Required: <T extends Type>(options: {
+    comment?: string;
+    type: T;
+}) => MemberDecl<T, true>;
+export declare const Optional: <T extends Type>(options: {
+    comment?: string;
+    type: T;
+}) => MemberDecl<T, false>;
+export declare const serializeObjectType: Serializer<ObjectType, SerializedObjectType>;
+export declare const getReferencesForObjectType: GetReferences<ObjectType>;

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

@@ -0,0 +1,70 @@
+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";
+import { validateOption } from "../../validation/options.js";
+import { getReferencesForType, removeParentKey, resolveTypeArgumentsInType, serializeType, validate, } from "../Type.js";
+const keyPattern = /^[a-zA-Z0-9][a-zA-Z0-9_]*$/;
+export const ObjectType = (properties, options = {}) => {
+    const type = {
+        ...options,
+        kind: NodeKind.ObjectType,
+        minProperties: validateOption(options.minProperties, "minProperties", option => Number.isInteger(option) && option >= 0),
+        maxProperties: validateOption(options.maxProperties, "maxProperties", option => Number.isInteger(option) && option >= 0),
+        properties,
+    };
+    Object.keys(properties).forEach(key => {
+        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})`);
+        }
+        properties[key].type.parent = type;
+    });
+    return type;
+};
+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 validateObjectType = (helpers, type, value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return [TypeError(`expected an object, but got ${JSON.stringify(value)}`)];
+    }
+    const expectedKeys = Object.keys(type.properties);
+    return parallelizeErrors([
+        ...validateObjectConstraints(type, expectedKeys, value),
+        ...expectedKeys.map(key => {
+            const prop = type.properties[key];
+            if (prop.isRequired && !(key in value)) {
+                return TypeError(`missing required property "${key}"`);
+            }
+            else if (prop.isRequired || value[key] !== undefined) {
+                return wrapErrorsIfAny(`at object key "${key}"`, validate(helpers, prop.type, value[key]));
+            }
+            return undefined;
+        }),
+    ]);
+};
+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) => ({
+    kind: NodeKind.MemberDecl,
+    isRequired,
+    type,
+    comment,
+});
+export const Required = (options) => MemberDecl(true, options.type, options.comment);
+export const Optional = (options) => MemberDecl(false, options.type, options.comment);
+export const serializeObjectType = type => ({
+    ...removeParentKey(type),
+    properties: Object.fromEntries(Object.entries(type.properties).map(([key, prop]) => [
+        key,
+        {
+            ...prop,
+            type: serializeType(prop.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) : [])
+    : [];

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

@@ -0,0 +1,15 @@
+import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
+import { Validator } from "../../validation/type.js";
+import { BaseType, SerializedBaseType } from "../Type.js";
+export interface BooleanType extends BaseType {
+    kind: NodeKind["BooleanType"];
+}
+export interface SerializedBooleanType extends SerializedBaseType {
+    kind: NodeKind["BooleanType"];
+}
+export declare const BooleanType: () => BooleanType;
+export { BooleanType as Boolean };
+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>;

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

@@ -0,0 +1,15 @@
+import { NodeKind } from "../../Node.js";
+import { removeParentKey } from "../Type.js";
+export const BooleanType = () => ({
+    kind: NodeKind.BooleanType,
+});
+export { BooleanType as Boolean };
+export const isBooleanType = (node) => node.kind === NodeKind.BooleanType;
+export const validateBooleanType = (_helpers, _type, value) => {
+    if (typeof value !== "boolean") {
+        return [TypeError(`expected a boolean value, but got ${JSON.stringify(value)}`)];
+    }
+    return [];
+};
+export const serializeBooleanType = type => removeParentKey(type);
+export const getReferencesForBooleanType = (_type, _value) => [];

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

@@ -0,0 +1,16 @@
+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";
+export interface DateType extends BaseType, DateConstraints {
+    kind: NodeKind["DateType"];
+}
+export interface SerializedDateType extends SerializedBaseType, DateConstraints {
+    kind: NodeKind["DateType"];
+}
+export declare const DateType: (options?: DateConstraints) => DateType;
+export { DateType as Date };
+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>;

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

@@ -0,0 +1,17 @@
+import { validateDateConstraints } from "../../../shared/validation/date.js";
+import { NodeKind } from "../../Node.js";
+import { removeParentKey } from "../Type.js";
+export const DateType = (options) => ({
+    ...options,
+    kind: NodeKind.DateType,
+});
+export { DateType as Date };
+export const isDateType = (node) => node.kind === NodeKind.DateType;
+export const validateDateType = (_helpers, type, value) => {
+    if (typeof value !== "string") {
+        return [TypeError(`expected a string, but got ${JSON.stringify(value)}`)];
+    }
+    return validateDateConstraints(type, value);
+};
+export const serializeDateType = type => removeParentKey(type);
+export const getReferencesForDateType = (_type, _value) => [];

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

@@ -0,0 +1,26 @@
+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";
+export interface FloatType extends BaseType {
+    kind: NodeKind["FloatType"];
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}
+export interface SerializedFloatType extends SerializedBaseType {
+    kind: NodeKind["FloatType"];
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}
+export declare const FloatType: (options?: {
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}) => FloatType;
+export { FloatType as Float };
+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>;

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

@@ -0,0 +1,17 @@
+import { validateNumberConstraints } from "../../../shared/validation/number.js";
+import { NodeKind } from "../../Node.js";
+import { removeParentKey } from "../Type.js";
+export const FloatType = (options = {}) => ({
+    ...options,
+    kind: NodeKind.FloatType,
+});
+export { FloatType as Float };
+export const isFloatType = (node) => node.kind === NodeKind.FloatType;
+export const validateFloatType = (_helpers, type, value) => {
+    if (typeof value !== "number") {
+        return [TypeError(`expected a floating-point number, but got ${JSON.stringify(value)}`)];
+    }
+    return validateNumberConstraints(type, value);
+};
+export const serializeFloatType = type => removeParentKey(type);
+export const getReferencesForFloatType = (_type, _value) => [];

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

@@ -0,0 +1,26 @@
+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";
+export interface IntegerType extends BaseType {
+    kind: NodeKind["IntegerType"];
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}
+export interface SerializedIntegerType extends SerializedBaseType {
+    kind: NodeKind["IntegerType"];
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}
+export declare const IntegerType: (options?: {
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}) => IntegerType;
+export { IntegerType as Integer };
+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>;

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

@@ -0,0 +1,21 @@
+import { validateNumberConstraints } from "../../../shared/validation/number.js";
+import { NodeKind } from "../../Node.js";
+import { validateOption } from "../../validation/options.js";
+import { removeParentKey } from "../Type.js";
+const isIntegerRangeBoundOption = (option) => Number.isInteger(typeof option === "number" ? option : option.value);
+export const IntegerType = (options = {}) => ({
+    kind: NodeKind.IntegerType,
+    minimum: validateOption(options.minimum, "minimum", isIntegerRangeBoundOption),
+    maximum: validateOption(options.maximum, "maximum", isIntegerRangeBoundOption),
+    multipleOf: options.multipleOf,
+});
+export { IntegerType as Integer };
+export const isIntegerType = (node) => node.kind === NodeKind.IntegerType;
+export const validateIntegerType = (_helpers, type, value) => {
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        return [TypeError(`expected an integer, but got ${JSON.stringify(value)}`)];
+    }
+    return validateNumberConstraints(type, value);
+};
+export const serializeIntegerType = type => removeParentKey(type);
+export const getReferencesForIntegerType = (_type, _value) => [];

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

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

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

@@ -0,0 +1,2 @@
+export * from "./FloatType.js";
+export * from "./IntegerType.js";

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

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,25 @@
+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";
+export interface StringType extends BaseType, StringConstraints {
+    kind: NodeKind["StringType"];
+    pattern?: RegExp;
+    isMarkdown?: boolean;
+}
+export interface SerializedStringType extends SerializedBaseType, StringConstraints {
+    kind: NodeKind["StringType"];
+    pattern?: string;
+    isMarkdown?: boolean;
+}
+export declare const StringType: (options?: {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    isMarkdown?: boolean;
+}) => StringType;
+export { StringType as String };
+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>;

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

@@ -0,0 +1,20 @@
+import { validateStringConstraints } from "../../../shared/validation/string.js";
+import { NodeKind } from "../../Node.js";
+import { removeParentKey } from "../Type.js";
+export const StringType = (options = {}) => ({
+    ...options,
+    kind: NodeKind.StringType,
+});
+export { StringType as String };
+export const isStringType = (node) => node.kind === NodeKind.StringType;
+export const validateStringType = (_helpers, type, value) => {
+    if (typeof value !== "string") {
+        return [TypeError(`expected a string, but got ${JSON.stringify(value)}`)];
+    }
+    return validateStringConstraints(type, value);
+};
+export const serializeStringType = type => removeParentKey({
+    ...type,
+    pattern: type.pattern?.source,
+});
+export const getReferencesForStringType = (_type, _value) => [];

package/lib/schema/types/references/GenericArgumentIdentifierType.d.ts

@@ -0,0 +1,21 @@
+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";
+type TConstraint = TypeParameter;
+export interface GenericArgumentIdentifierType<T extends TConstraint = TConstraint> extends BaseType {
+    kind: NodeKind["GenericArgumentIdentifierType"];
+    argument: T;
+}
+type TSerializedConstraint = SerializedTypeParameter;
+export interface SerializedGenericArgumentIdentifierType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
+    kind: NodeKind["GenericArgumentIdentifierType"];
+    argument: T;
+}
+export declare const GenericArgumentIdentifierType: <T extends TConstraint>(argument: T) => GenericArgumentIdentifierType<T>;
+export { GenericArgumentIdentifierType as GenericArgumentIdentifier };
+export declare const isGenericArgumentIdentifierType: (node: Node) => node is GenericArgumentIdentifierType;
+export declare const validateGenericArgumentIdentifierType: Validator<GenericArgumentIdentifierType>;
+export declare const resolveTypeArgumentsInGenericArgumentIdentifierType: <T extends TConstraint, Args extends Record<string, Type>>(args: Args, type: GenericArgumentIdentifierType<T>) => Args[T["name"]];
+export declare const serializeGenericArgumentIdentifierType: Serializer<GenericArgumentIdentifierType, SerializedGenericArgumentIdentifierType>;
+export declare const getReferencesForGenericArgumentIdentifierType: GetReferences<GenericArgumentIdentifierType>;

package/lib/schema/types/references/GenericArgumentIdentifierType.js

@@ -0,0 +1,18 @@
+import { NodeKind } from "../../Node.js";
+import { serializeTypeParameter, } from "../../parameters/TypeParameter.js";
+import { removeParentKey } from "../Type.js";
+export const GenericArgumentIdentifierType = (argument) => ({
+    kind: NodeKind.GenericArgumentIdentifierType,
+    argument,
+});
+export { GenericArgumentIdentifierType as GenericArgumentIdentifier };
+export const isGenericArgumentIdentifierType = (node) => node.kind === NodeKind.GenericArgumentIdentifierType;
+export const validateGenericArgumentIdentifierType = (_helpers, type, _value) => {
+    throw new TypeError(`generic argument "${type.argument.name}" has not been replaced with a concrete type`);
+};
+export const resolveTypeArgumentsInGenericArgumentIdentifierType = (args, type) => args[type.argument.name];
+export const serializeGenericArgumentIdentifierType = type => ({
+    ...removeParentKey(type),
+    argument: serializeTypeParameter(type.argument),
+});
+export const getReferencesForGenericArgumentIdentifierType = (_type, _value) => [];

package/lib/schema/types/references/IncludeIdentifierType.d.ts

@@ -0,0 +1,28 @@
+import { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.js";
+import { 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";
+type TConstraint<Params extends TypeParameter[]> = TypeAliasDecl<string, Type, Params> | EnumDecl<string, Record<string, Type | null>, Params>;
+export interface IncludeIdentifierType<Params extends TypeParameter[] = TypeParameter[], T extends TConstraint<Params> = TConstraint<Params>> extends BaseType {
+    kind: NodeKind["IncludeIdentifierType"];
+    reference: T;
+    args: TypeArguments<Params>;
+}
+export interface SerializedIncludeIdentifierType<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseType {
+    kind: NodeKind["IncludeIdentifierType"];
+    reference: string;
+    args: SerializedTypeArguments<Params>;
+}
+export declare const GenIncludeIdentifierType: <T extends TConstraint<Params>, Params extends TypeParameter[] = []>(reference: T, args: TypeArguments<Params>) => IncludeIdentifierType<Params, T>;
+export { GenIncludeIdentifierType as GenIncludeIdentifier };
+export declare const IncludeIdentifierType: <T extends TConstraint<[]>>(reference: T) => IncludeIdentifierType<[], T>;
+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 serializeIncludeIdentifierType: Serializer<IncludeIdentifierType, SerializedIncludeIdentifierType>;
+export declare const getReferencesForIncludeIdentifierType: GetReferences<IncludeIdentifierType>;

package/lib/schema/types/references/IncludeIdentifierType.js

@@ -0,0 +1,25 @@
+import { getNestedDeclarations, getReferencesForDecl, resolveTypeArgumentsInDecl, validateDecl, } from "../../declarations/Declaration.js";
+import { NodeKind } from "../../Node.js";
+import { removeParentKey, resolveTypeArgumentsInType, serializeType, } from "../Type.js";
+export const GenIncludeIdentifierType = (reference, args) => ({
+    kind: NodeKind.IncludeIdentifierType,
+    reference,
+    args,
+});
+export { GenIncludeIdentifierType as GenIncludeIdentifier };
+export const IncludeIdentifierType = (reference) => ({
+    kind: NodeKind.IncludeIdentifierType,
+    reference,
+    args: [],
+});
+export { IncludeIdentifierType as IncludeIdentifier };
+export const isIncludeIdentifierType = (node) => node.kind === NodeKind.IncludeIdentifierType;
+export const getNestedDeclarationsInIncludeIdentifierType = (isDeclAdded, type) => [type.reference, ...getNestedDeclarations(isDeclAdded, 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 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);

package/lib/schema/types/references/NestedEntityMapType.d.ts

@@ -0,0 +1,36 @@
+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>>;
+export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
+    kind: NodeKind["NestedEntityMapType"];
+    name: Name;
+    comment?: string;
+    secondaryEntity: EntityDecl;
+    type: Lazy<ObjectType<T>>;
+}
+type TSerializedConstraint = Record<string, SerializedMemberDecl<SerializedType, boolean>>;
+export interface SerializedNestedEntityMapType<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
+    kind: NodeKind["NestedEntityMapType"];
+    name: Name;
+    comment?: string;
+    secondaryEntity: string;
+    type: SerializedObjectType<T>;
+}
+export declare const NestedEntityMapType: <Name extends string, T extends TConstraint>(options: {
+    name: Name;
+    comment?: string;
+    secondaryEntity: EntityDecl;
+    type: ObjectType<T>;
+}) => NestedEntityMapType<Name, T>;
+export { NestedEntityMapType as NestedEntityMap };
+export declare const isNestedEntityMapType: (node: Node) => node is NestedEntityMapType;
+export declare const getNestedDeclarationsInNestedEntityMapType: GetNestedDeclarations<NestedEntityMapType>;
+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>;

package/lib/schema/types/references/NestedEntityMapType.js

@@ -0,0 +1,67 @@
+import { parallelizeErrors } from "../../../shared/utils/validation.js";
+import { wrapErrorsIfAny } from "../../../utils/error.js";
+import { Lazy } from "../../../utils/lazy.js";
+import { isEntityDecl } from "../../declarations/EntityDecl.js";
+import { NodeKind } from "../../Node.js";
+import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "../generic/ObjectType.js";
+import { getParentDecl, removeParentKey, } from "../Type.js";
+export const NestedEntityMapType = (options) => {
+    const nestedEntityMapType = {
+        ...options,
+        kind: NodeKind.NestedEntityMapType,
+        type: Lazy.of(() => {
+            const parentDecl = getParentDecl(nestedEntityMapType);
+            if (!parentDecl) {
+                throw new Error("Parent declaration not found");
+            }
+            if (!isEntityDecl(parentDecl)) {
+                throw new Error(`Parent declaration "${parentDecl.name}" is not an entity declaration`);
+            }
+            const type = options.type;
+            type.parent = nestedEntityMapType;
+            return type;
+        }),
+    };
+    return nestedEntityMapType;
+};
+export { NestedEntityMapType as NestedEntityMap };
+const _NestedEntityMapType = (options) => {
+    const nestedEntityMapType = {
+        ...options,
+        kind: NodeKind.NestedEntityMapType,
+        type: Lazy.of(() => {
+            const type = options.type();
+            type.parent = nestedEntityMapType;
+            return type;
+        }),
+    };
+    return nestedEntityMapType;
+};
+export const isNestedEntityMapType = (node) => node.kind === NodeKind.NestedEntityMapType;
+export const getNestedDeclarationsInNestedEntityMapType = (isDeclAdded, type) => [
+    type.secondaryEntity,
+    ...getNestedDeclarationsInObjectType(isDeclAdded, type.type.value),
+];
+export const validateNestedEntityMapType = (helpers, type, value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return [TypeError(`expected an object, but got ${JSON.stringify(value)}`)];
+    }
+    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map "${type.name}" at key "${key}"`, validateObjectType(helpers, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
+        name: type.secondaryEntity.name,
+        value: key,
+    })))));
+};
+export const resolveTypeArgumentsInNestedEntityMapType = (args, type) => _NestedEntityMapType({
+    ...type,
+    type: () => resolveTypeArgumentsInObjectType(args, type.type.value),
+});
+export const serializeNestedEntityMapType = type => ({
+    ...removeParentKey(type),
+    secondaryEntity: type.secondaryEntity.name,
+    type: serializeObjectType(type.type.value),
+});
+export const getReferencesForNestedEntityMapType = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? Object.values(value)
+        .flatMap(item => getReferencesForObjectType(type.type.value, item))
+        .concat(Object.keys(value))
+    : [];

package/lib/schema/types/references/ReferenceIdentifierType.d.ts

@@ -0,0 +1,23 @@
+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 } from "../generic/ObjectType.js";
+import { BaseType, SerializedBaseType, Type } from "../Type.js";
+type TConstraint = Record<string, MemberDecl<Type, boolean>>;
+export interface ReferenceIdentifierType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
+    kind: NodeKind["ReferenceIdentifierType"];
+    entity: EntityDecl<Name, ObjectType<T>>;
+}
+export interface SerializedReferenceIdentifierType extends SerializedBaseType {
+    kind: NodeKind["ReferenceIdentifierType"];
+    entity: string;
+}
+export declare const ReferenceIdentifierType: <Name extends string, T extends TConstraint>(entity: EntityDecl<Name, ObjectType<T>>) => ReferenceIdentifierType<Name, T>;
+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: <Name extends string, T extends TConstraint, Args extends Record<string, Type>>(_args: Args, type: ReferenceIdentifierType<Name, T>) => ReferenceIdentifierType<Name, T>;
+export declare const serializeReferenceIdentifierType: Serializer<ReferenceIdentifierType, SerializedReferenceIdentifierType>;
+export declare const getReferencesForReferenceIdentifierType: GetReferences<ReferenceIdentifierType>;

package/lib/schema/types/references/ReferenceIdentifierType.js

@@ -0,0 +1,21 @@
+import { getNestedDeclarations } from "../../declarations/Declaration.js";
+import { createEntityIdentifierType } from "../../declarations/EntityDecl.js";
+import { NodeKind } from "../../Node.js";
+import { removeParentKey, validate } from "../Type.js";
+export const ReferenceIdentifierType = (entity) => ({
+    kind: NodeKind.ReferenceIdentifierType,
+    entity,
+});
+export { ReferenceIdentifierType as ReferenceIdentifier };
+export const isReferenceIdentifierType = (node) => node.kind === NodeKind.ReferenceIdentifierType;
+export const getNestedDeclarationsInReferenceIdentifierType = (isDeclAdded, type) => [type.entity, ...getNestedDeclarations(isDeclAdded, type.entity)];
+export const validateReferenceIdentifierType = (helpers, type, value) => validate(helpers, createEntityIdentifierType(), value).concat(helpers.checkReferentialIntegrity({
+    name: type.entity.name,
+    value: value,
+}));
+export const resolveTypeArgumentsInReferenceIdentifierType = (_args, type) => type;
+export const serializeReferenceIdentifierType = type => ({
+    ...removeParentKey(type),
+    entity: type.entity.name,
+});
+export const getReferencesForReferenceIdentifierType = (_type, value) => (typeof value === "string" ? [value] : []);

package/lib/schema/validation/options.d.ts

@@ -0,0 +1,4 @@
+export declare class OptionError extends Error {
+    constructor(message: string);
+}
+export declare const validateOption: <T>(value: T, name: string, validator: (option: NonNullable<T>) => boolean) => T;

package/lib/schema/validation/options.js

@@ -0,0 +1,12 @@
+export class OptionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OptionError";
+    }
+}
+export const validateOption = (value, name, validator) => {
+    if (value == null || validator(value)) {
+        return value;
+    }
+    throw new OptionError(`Invalid value for "${name}": ${JSON.stringify(value)}`);
+};

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

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

package/lib/schema/validation/type.js

@@ -0,0 +1 @@
+export {};