tsondb 0.1.3

package/lib/schema/declarations/EntityDecl.js

@@ -0,0 +1,57 @@
+import { Lazy } from "../../utils/lazy.js";
+import { NodeKind } from "../Node.js";
+import { getNestedDeclarationsInObjectType, getReferencesForObjectType, Required, resolveTypeArgumentsInObjectType, serializeObjectType, } from "../types/generic/ObjectType.js";
+import { StringType } from "../types/primitives/StringType.js";
+import { validate } from "../types/Type.js";
+import { validateDeclName, } from "./Declaration.js";
+import { TypeAliasDecl } from "./TypeAliasDecl.js";
+export const EntityDecl = (sourceUrl, options) => {
+    validateDeclName(options.name);
+    const decl = {
+        ...options,
+        kind: NodeKind.EntityDecl,
+        sourceUrl,
+        parameters: [],
+        type: Lazy.of(() => {
+            const type = options.type();
+            Object.keys(type.properties).forEach(key => {
+                if (key === "id") {
+                    throw new TypeError(`Invalid object key "${key}" for entity "${options.name}". The key "id" is reserved for the entity identifier.`);
+                }
+            });
+            type.parent = decl;
+            return type;
+        }),
+    };
+    return decl;
+};
+export { EntityDecl as Entity };
+export const isEntityDecl = (node) => node.kind === NodeKind.EntityDecl;
+export const getNestedDeclarationsInEntityDecl = (isDeclAdded, decl) => getNestedDeclarationsInObjectType(isDeclAdded, decl.type.value);
+export const validateEntityDecl = (helpers, decl, value) => validate(helpers, decl.type.value, value);
+export const resolveTypeArgumentsInEntityDecl = (decl) => EntityDecl(decl.sourceUrl, {
+    ...decl,
+    type: () => resolveTypeArgumentsInObjectType({}, decl.type.value),
+});
+const createEntityIdentifierComment = () => "The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.";
+export const addEphemeralUUIDToType = (decl) => ({
+    ...decl.type.value,
+    properties: {
+        id: Required({
+            comment: createEntityIdentifierComment(),
+            type: createEntityIdentifierType(),
+        }),
+        ...Object.fromEntries(Object.entries(decl.type.value.properties).filter(([key]) => key !== "id")),
+    },
+});
+export const createEntityIdentifierType = () => StringType();
+export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sourceUrl, {
+    comment: createEntityIdentifierComment(),
+    name: (decl.name + "_ID"),
+    type: createEntityIdentifierType,
+});
+export const serializeEntityDecl = type => ({
+    ...type,
+    type: serializeObjectType(type.type.value),
+});
+export const getReferencesForEntityDecl = (decl, value) => getReferencesForObjectType(decl.type.value, value);

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

@@ -0,0 +1,33 @@
+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 { 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> {
+    kind: NodeKind["EnumDecl"];
+    values: Lazy<T>;
+}
+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> {
+    kind: NodeKind["EnumDecl"];
+    values: T;
+}
+export declare const GenEnumDecl: <Name extends string, T extends Record<string, Type | null>, 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: {
+    name: Name;
+    comment?: string;
+    values: () => T;
+}) => EnumDecl<Name, T, []>;
+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 serializeEnumDecl: Serializer<EnumDecl, SerializedEnumDecl>;
+export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;

package/lib/schema/declarations/EnumDecl.js

@@ -0,0 +1,104 @@
+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";
+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;
+                }
+            });
+            return type;
+        }),
+    };
+    return decl;
+};
+export { GenEnumDecl as GenEnum };
+export const EnumDecl = (sourceUrl, options) => {
+    validateDeclName(options.name);
+    const decl = {
+        ...options,
+        kind: NodeKind.EnumDecl,
+        sourceUrl,
+        parameters: [],
+        values: Lazy.of(() => {
+            const type = options.values();
+            Object.values(type).forEach(type => {
+                if (type) {
+                    type.parent = decl;
+                }
+            });
+            return type;
+        }),
+    };
+    return decl;
+};
+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 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),
+        ])),
+    });
+};
+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 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]])
+    : [];

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

@@ -0,0 +1,33 @@
+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 { ValidatorHelpers } from "../validation/type.js";
+import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
+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>;
+}
+export interface SerializedTypeAliasDecl<Name extends string = string, T extends SerializedType = SerializedType, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseDecl<Name, Params> {
+    kind: NodeKind["TypeAliasDecl"];
+    type: T;
+}
+export declare const GenTypeAliasDecl: <Name extends string, T extends Type, Params extends TypeParameter[]>(sourceUrl: string, options: {
+    name: Name;
+    comment?: string;
+    parameters: Params;
+    type: (...args: Params) => T;
+}) => TypeAliasDecl<Name, T, Params>;
+export { GenTypeAliasDecl as GenTypeAlias };
+export declare const TypeAliasDecl: <Name extends string, T extends Type>(sourceUrl: string, options: {
+    name: Name;
+    comment?: string;
+    type: () => T;
+}) => TypeAliasDecl<Name, T, []>;
+export { TypeAliasDecl as TypeAlias };
+export declare const isTypeAliasDecl: (node: Node) => node is TypeAliasDecl<string, Type, TypeParameter[]>;
+export declare const getNestedDeclarationsInTypeAliasDecl: GetNestedDeclarations<TypeAliasDecl>;
+export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: ValidatorHelpers, decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
+export declare const resolveTypeArgumentsInTypeAliasDecl: <Params extends TypeParameter[]>(decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>) => TypeAliasDecl<string, Type, []>;
+export declare const serializeTypeAliasDecl: Serializer<TypeAliasDecl, SerializedTypeAliasDecl>;
+export declare const getReferencesForTypeAliasDecl: GetReferences<TypeAliasDecl>;

package/lib/schema/declarations/TypeAliasDecl.js

@@ -0,0 +1,49 @@
+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";
+export const GenTypeAliasDecl = (sourceUrl, options) => {
+    validateDeclName(options.name);
+    const decl = {
+        ...options,
+        kind: NodeKind.TypeAliasDecl,
+        sourceUrl,
+        type: Lazy.of(() => {
+            const type = options.type(...options.parameters);
+            type.parent = decl;
+            return type;
+        }),
+    };
+    return decl;
+};
+export { GenTypeAliasDecl as GenTypeAlias };
+export const TypeAliasDecl = (sourceUrl, options) => {
+    validateDeclName(options.name);
+    const decl = {
+        ...options,
+        kind: NodeKind.TypeAliasDecl,
+        sourceUrl,
+        parameters: [],
+        type: Lazy.of(() => {
+            const type = options.type();
+            type.parent = decl;
+            return type;
+        }),
+    };
+    return decl;
+};
+export { TypeAliasDecl as TypeAlias };
+export const isTypeAliasDecl = (node) => node.kind === NodeKind.TypeAliasDecl;
+export const getNestedDeclarationsInTypeAliasDecl = (isDeclAdded, decl) => getNestedDeclarations(isDeclAdded, 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,
+    type: () => resolveTypeArgumentsInType(getTypeArgumentsRecord(decl, args), decl.type.value),
+});
+export const serializeTypeAliasDecl = type => ({
+    ...type,
+    type: serializeType(type.type.value),
+    parameters: type.parameters.map(param => serializeTypeParameter(param)),
+});
+export const getReferencesForTypeAliasDecl = (decl, value) => getReferencesForType(decl.type.value, value);

package/lib/schema/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./declarations/Declaration.js";
+export * from "./declarations/EntityDecl.js";
+export * from "./declarations/EnumDecl.js";
+export * from "./declarations/TypeAliasDecl.js";
+export * from "./Node.js";
+export * from "./parameters/TypeParameter.js";
+export * from "./types/generic/ArrayType.js";
+export * from "./types/generic/ObjectType.js";
+export * from "./types/primitives/BooleanType.js";
+export * from "./types/primitives/DateType.js";
+export * from "./types/primitives/FloatType.js";
+export * from "./types/primitives/IntegerType.js";
+export * from "./types/primitives/NumericType.js";
+export * from "./types/primitives/PrimitiveType.js";
+export * from "./types/primitives/StringType.js";
+export * from "./types/references/GenericArgumentIdentifierType.js";
+export * from "./types/references/IncludeIdentifierType.js";
+export * from "./types/references/NestedEntityMapType.js";
+export * from "./types/references/ReferenceIdentifierType.js";
+export * from "./types/Type.js";

package/lib/schema/index.js

@@ -0,0 +1,20 @@
+export * from "./declarations/Declaration.js";
+export * from "./declarations/EntityDecl.js";
+export * from "./declarations/EnumDecl.js";
+export * from "./declarations/TypeAliasDecl.js";
+export * from "./Node.js";
+export * from "./parameters/TypeParameter.js";
+export * from "./types/generic/ArrayType.js";
+export * from "./types/generic/ObjectType.js";
+export * from "./types/primitives/BooleanType.js";
+export * from "./types/primitives/DateType.js";
+export * from "./types/primitives/FloatType.js";
+export * from "./types/primitives/IntegerType.js";
+export * from "./types/primitives/NumericType.js";
+export * from "./types/primitives/PrimitiveType.js";
+export * from "./types/primitives/StringType.js";
+export * from "./types/references/GenericArgumentIdentifierType.js";
+export * from "./types/references/IncludeIdentifierType.js";
+export * from "./types/references/NestedEntityMapType.js";
+export * from "./types/references/ReferenceIdentifierType.js";
+export * from "./types/Type.js";

package/lib/schema/parameters/TypeParameter.d.ts

@@ -0,0 +1,14 @@
+import { NodeKind, Serializer } from "../Node.js";
+import { SerializedBaseType, SerializedType, Type } from "../types/Type.js";
+export interface TypeParameter<N extends string = string, T extends Type = Type> {
+    kind: NodeKind["GenericParameter"];
+    name: N;
+    constraint?: T;
+}
+export interface SerializedTypeParameter<N extends string = string, T extends SerializedType = SerializedType> extends SerializedBaseType {
+    kind: NodeKind["GenericParameter"];
+    name: N;
+    constraint?: T;
+}
+export declare const Param: <N extends string = string, T extends Type = Type>(name: N, constraint?: T) => TypeParameter<N, T>;
+export declare const serializeTypeParameter: Serializer<TypeParameter, SerializedTypeParameter>;

package/lib/schema/parameters/TypeParameter.js

@@ -0,0 +1,11 @@
+import { NodeKind } from "../Node.js";
+import { removeParentKey, serializeType, } from "../types/Type.js";
+export const Param = (name, constraint) => ({
+    kind: NodeKind.GenericParameter,
+    name,
+    constraint,
+});
+export const serializeTypeParameter = type => ({
+    ...removeParentKey(type),
+    constraint: type.constraint ? serializeType(type.constraint) : undefined,
+});

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

@@ -0,0 +1,42 @@
+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 { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "./generic/ObjectType.js";
+import { BooleanType, SerializedBooleanType } from "./primitives/BooleanType.js";
+import { DateType, SerializedDateType } from "./primitives/DateType.js";
+import { FloatType, SerializedFloatType } from "./primitives/FloatType.js";
+import { IntegerType, SerializedIntegerType } from "./primitives/IntegerType.js";
+import { PrimitiveType, SerializedPrimitiveType } from "./primitives/PrimitiveType.js";
+import { SerializedStringType, StringType } from "./primitives/StringType.js";
+import { GenericArgumentIdentifierType, SerializedGenericArgumentIdentifierType } from "./references/GenericArgumentIdentifierType.js";
+import { IncludeIdentifierType, SerializedIncludeIdentifierType } from "./references/IncludeIdentifierType.js";
+import { NestedEntityMapType, SerializedNestedEntityMapType } from "./references/NestedEntityMapType.js";
+import { ReferenceIdentifierType, SerializedReferenceIdentifierType } from "./references/ReferenceIdentifierType.js";
+export interface BaseType extends BaseNode {
+    /**
+     * The parent node of this type will be set when the type is used in a declaration or nested in another type.
+     */
+    parent?: Type | Decl;
+}
+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 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;
+export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
+} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends GenericArgumentIdentifierType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? unknown : never;
+export type SerializedAsType<T extends SerializedType> = T extends SerializedArrayType<infer I> ? SerializedAsType<I>[] : T extends SerializedObjectType<infer P> ? {
+    [K in keyof P]: P[K] extends SerializedMemberDecl<SerializedType, true> ? SerializedAsType<P[K]["type"]> : SerializedAsType<P[K]["type"]> | undefined;
+} : T extends SerializedBooleanType ? boolean : T extends SerializedDateType ? Date : T extends SerializedFloatType ? number : T extends SerializedIntegerType ? number : T extends SerializedStringType ? string : T extends SerializedGenericArgumentIdentifierType ? unknown : T extends SerializedIncludeIdentifierType ? unknown : T extends SerializedNestedEntityMapType ? unknown : T extends SerializedReferenceIdentifierType ? unknown : never;
+export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, any> ? ObjectType<{
+    [K in keyof T]: T[K] extends MemberDecl<Type, boolean> ? T[K] : T extends null | undefined ? MemberDecl<AsNode<NonNullable<T[K]>>, false> : MemberDecl<AsNode<T[K]>, true>;
+}> : T extends string ? StringType : T extends number ? FloatType : T extends boolean ? BooleanType : never;
+export declare const getParentDecl: (type: Type) => Decl | undefined;
+export declare const findTypeAtPath: (type: Type, path: string[]) => Type | undefined;
+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>;

package/lib/schema/types/Type.js

@@ -0,0 +1,177 @@
+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";
+export const validate = (helpers, type, value) => {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            return validateArrayType(helpers, type, value);
+        case NodeKind.ObjectType:
+            return validateObjectType(helpers, type, value);
+        case NodeKind.BooleanType:
+            return validateBooleanType(helpers, type, value);
+        case NodeKind.DateType:
+            return validateDateType(helpers, type, value);
+        case NodeKind.FloatType:
+            return validateFloatType(helpers, type, value);
+        case NodeKind.IntegerType:
+            return validateIntegerType(helpers, type, value);
+        case NodeKind.StringType:
+            return validateStringType(helpers, type, value);
+        case NodeKind.GenericArgumentIdentifierType:
+            return validateGenericArgumentIdentifierType(helpers, type, value);
+        case NodeKind.ReferenceIdentifierType:
+            return validateReferenceIdentifierType(helpers, type, value);
+        case NodeKind.IncludeIdentifierType:
+            return validateIncludeIdentifierType(helpers, type, value);
+        case NodeKind.NestedEntityMapType:
+            return validateNestedEntityMapType(helpers, type, value);
+        default:
+            return assertExhaustive(type);
+    }
+};
+export const resolveTypeArgumentsInType = (args, type) => {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            return resolveTypeArgumentsInArrayType(args, type);
+        case NodeKind.ObjectType:
+            return resolveTypeArgumentsInObjectType(args, type);
+        case NodeKind.BooleanType:
+        case NodeKind.DateType:
+        case NodeKind.FloatType:
+        case NodeKind.IntegerType:
+        case NodeKind.StringType:
+            return type;
+        case NodeKind.GenericArgumentIdentifierType:
+            return resolveTypeArgumentsInGenericArgumentIdentifierType(args, type);
+        case NodeKind.ReferenceIdentifierType:
+            return resolveTypeArgumentsInReferenceIdentifierType(args, type);
+        case NodeKind.IncludeIdentifierType:
+            return resolveTypeArgumentsInIncludeIdentifierType(args, type);
+        case NodeKind.NestedEntityMapType:
+            return resolveTypeArgumentsInNestedEntityMapType(args, type);
+        default:
+            return assertExhaustive(type);
+    }
+};
+export function walkTypeNodeTree(callbackFn, type) {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            callbackFn(type);
+            return walkTypeNodeTree(callbackFn, type.items);
+        case NodeKind.ObjectType:
+            callbackFn(type);
+            return Object.values(type.properties).forEach(prop => walkTypeNodeTree(callbackFn, prop.type));
+        case NodeKind.NestedEntityMapType:
+            callbackFn(type);
+            return walkTypeNodeTree(callbackFn, type.type.value);
+        case NodeKind.BooleanType:
+        case NodeKind.DateType:
+        case NodeKind.FloatType:
+        case NodeKind.IntegerType:
+        case NodeKind.StringType:
+        case NodeKind.GenericArgumentIdentifierType:
+        case NodeKind.ReferenceIdentifierType:
+        case NodeKind.IncludeIdentifierType:
+            return callbackFn(type);
+        default:
+            return assertExhaustive(type);
+    }
+}
+export const getParentDecl = (type) => {
+    if (type.parent === undefined) {
+        return undefined;
+    }
+    else if (isDecl(type.parent)) {
+        return type.parent;
+    }
+    else {
+        return getParentDecl(type.parent);
+    }
+};
+export const findTypeAtPath = (type, path) => {
+    if (path.length === 0) {
+        return type;
+    }
+    const [head, ...tail] = path;
+    if (type.kind === NodeKind.ObjectType) {
+        const prop = type.properties[head];
+        if (prop) {
+            return findTypeAtPath(prop.type, tail);
+        }
+    }
+    else if (type.kind === NodeKind.ArrayType && head === "0") {
+        return findTypeAtPath(type.items, path);
+    }
+    return undefined;
+};
+export const serializeType = type => {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            return serializeArrayType(type);
+        case NodeKind.ObjectType:
+            return serializeObjectType(type);
+        case NodeKind.BooleanType:
+            return serializeBooleanType(type);
+        case NodeKind.DateType:
+            return serializeDateType(type);
+        case NodeKind.FloatType:
+            return serializeFloatType(type);
+        case NodeKind.IntegerType:
+            return serializeIntegerType(type);
+        case NodeKind.StringType:
+            return serializeStringType(type);
+        case NodeKind.GenericArgumentIdentifierType:
+            return serializeGenericArgumentIdentifierType(type);
+        case NodeKind.ReferenceIdentifierType:
+            return serializeReferenceIdentifierType(type);
+        case NodeKind.IncludeIdentifierType:
+            return serializeIncludeIdentifierType(type);
+        case NodeKind.NestedEntityMapType:
+            return serializeNestedEntityMapType(type);
+        default:
+            return assertExhaustive(type);
+    }
+};
+export const removeParentKey = (type) => {
+    const { parent: _parent, ...rest } = type;
+    return rest;
+};
+export const getReferencesForType = (type, value) => {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            return getReferencesForArrayType(type, value);
+        case NodeKind.ObjectType:
+            return getReferencesForObjectType(type, value);
+        case NodeKind.BooleanType:
+            return getReferencesForBooleanType(type, value);
+        case NodeKind.DateType:
+            return getReferencesForDateType(type, value);
+        case NodeKind.FloatType:
+            return getReferencesForFloatType(type, value);
+        case NodeKind.IntegerType:
+            return getReferencesForIntegerType(type, value);
+        case NodeKind.StringType:
+            return getReferencesForStringType(type, value);
+        case NodeKind.GenericArgumentIdentifierType:
+            return getReferencesForGenericArgumentIdentifierType(type, value);
+        case NodeKind.ReferenceIdentifierType:
+            return getReferencesForReferenceIdentifierType(type, value);
+        case NodeKind.IncludeIdentifierType:
+            return getReferencesForIncludeIdentifierType(type, value);
+        case NodeKind.NestedEntityMapType:
+            return getReferencesForNestedEntityMapType(type, value);
+        default:
+            return assertExhaustive(type);
+    }
+};

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

@@ -0,0 +1,30 @@
+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";
+export interface ArrayType<T extends Type = Type> extends BaseType {
+    kind: NodeKind["ArrayType"];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    items: T;
+}
+export interface SerializedArrayType<T extends SerializedType = SerializedType> extends SerializedBaseType {
+    kind: NodeKind["ArrayType"];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    items: T;
+}
+export declare const ArrayType: <T extends Type>(items: T, options?: {
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+}) => ArrayType<T>;
+export { ArrayType as Array };
+export declare const isArrayType: (node: Node) => node is ArrayType;
+export declare const getNestedDeclarationsInArrayType: GetNestedDeclarations<ArrayType>;
+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>;

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

@@ -0,0 +1,38 @@
+import { parallelizeErrors } from "../../../shared/utils/validation.js";
+import { validateArrayConstraints } from "../../../shared/validation/array.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";
+export const ArrayType = (items, options = {}) => {
+    const type = {
+        ...options,
+        kind: NodeKind.ArrayType,
+        minItems: validateOption(options.minItems, "minItems", option => Number.isInteger(option) && option >= 0),
+        maxItems: validateOption(options.maxItems, "maxItems", option => Number.isInteger(option) && option >= 0),
+        items,
+    };
+    items.parent = type;
+    return type;
+};
+export { ArrayType as Array };
+export const isArrayType = (node) => node.kind === NodeKind.ArrayType;
+export const getNestedDeclarationsInArrayType = (isDeclAdded, type) => getNestedDeclarations(isDeclAdded, type.items);
+export const validateArrayType = (helpers, type, value) => {
+    if (!Array.isArray(value)) {
+        return [TypeError(`expected an array, but got ${JSON.stringify(value)}`)];
+    }
+    return parallelizeErrors([
+        ...validateArrayConstraints(type, value),
+        ...value.map((item, index) => wrapErrorsIfAny(`at index ${index}`, validate(helpers, type.items, item))),
+    ]);
+};
+export const resolveTypeArgumentsInArrayType = (args, type) => ArrayType(resolveTypeArgumentsInType(args, type.items), {
+    ...type,
+});
+export const serializeArrayType = type => ({
+    ...removeParentKey(type),
+    items: serializeType(type.items),
+});
+export const getReferencesForArrayType = (type, value) => Array.isArray(value) ? value.flatMap(item => getReferencesForType(type.items, item)) : [];