tsondb 0.18.1 → 0.19.0

package/dist/src/node/config.d.ts

@@ -1,7 +1,7 @@
 import type { Output } from "../shared/output.ts";
 import type { ValidationOptions } from "./index.ts";
-import type { EntityDecl } from "./schema/index.ts";
-import type { Schema } from "./schema/Schema.ts";
+import type { EntityDecl } from "./schema/dsl/index.ts";
+import type { Schema } from "./schema/index.ts";
 /**
  * The main configuration type for TSONDB.
  */

package/dist/src/node/index.d.ts

@@ -1,10 +1,10 @@
 import type { Output } from "../shared/output.ts";
 import type { InstanceContainer, InstanceContainerOverview } from "../shared/utils/instances.ts";
 import { Git } from "./git.js";
-import type { AnyChildEntityMap, AnyEntityMap, AnyEnumMap, AnyTypeAliasMap } from "./schema/externalTypes.ts";
-import { type IdArgsVariant } from "./schema/helpers.ts";
-import { type EntityDecl } from "./schema/index.ts";
-import type { Schema } from "./schema/Schema.ts";
+import { type EntityDecl } from "./schema/dsl/index.ts";
+import type { AnyChildEntityMap, AnyEntityMap, AnyEnumMap, AnyTypeAliasMap } from "./schema/generatedTypeHelpers.ts";
+import { type IdArgsVariant } from "./schema/generatedTypeHelpers.ts";
+import type { Schema } from "./schema/index.ts";
 import { Transaction } from "./transaction.ts";
 export interface DefaultTSONDBTypes {
     entityMap: AnyEntityMap;
@@ -215,6 +215,13 @@ export declare class TSONDB<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
             queryLowerCase: string;
         }) => number;
     }>): [string, InstanceContainerOverview][];
+    /**
+     * Compresses the entire database into a single JSON file at the specified path.
+     *
+     * Instead of storing each instance in its own file, this method serializes the entire database into a single JSON file. This can be useful for backup, transfer or archiving purposes. The resulting file contains all instances organized by entity names. No spaces or indentation are used in the JSON output to minimize file size.
+     * @param path The file path where the compressed database will be saved.
+     */
+    compressToSingleFile(path: string): Promise<void>;
 }
 export type TSONDBWithGit<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> = TSONDB<T> & {
     git: Git<T>;

package/dist/src/node/index.js

@@ -2,15 +2,18 @@ import { deepEqual } from "@elyukai/utils/equality";
 import { Lazy } from "@elyukai/utils/lazy";
 import { isError } from "@elyukai/utils/result";
 import Debug from "debug";
-import { mkdir } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import { join, sep } from "node:path";
 import { stderr } from "node:process";
 import { styleText } from "node:util";
 import { simpleGit } from "simple-git";
 import { parallelizeErrors } from "../shared/utils/validation.js";
 import { Git } from "./git.js";
-import { normalizedIdArgs } from "./schema/helpers.js";
-import { createValidationContext, isEntityDeclWithParentReference, serializeNode, validateEntityDecl, } from "./schema/index.js";
+import {} from "./schema/dsl/index.js";
+import { normalizedIdArgs } from "./schema/generatedTypeHelpers.js";
+import { isEntityDeclWithParentReference } from "./schema/guards.js";
+import { serializeNode } from "./schema/treeOperations/serialization.js";
+import { createValidationContext, validateDecl } from "./schema/treeOperations/validation.js";
 import { Transaction } from "./transaction.js";
 import { checkCustomConstraintsForAllEntities } from "./utils/customConstraints.js";
 import { asyncForEachInstanceInDatabaseInMemory, countInstancesInDatabaseInMemory, countInstancesOfEntityInDatabaseInMemory, createDatabaseInMemory, getGroupedInstancesFromDatabaseInMemory, getInstanceOfEntityFromDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, hasInstanceOfEntityFromDatabaseInMemory, } from "./utils/databaseInMemory.js";
@@ -159,7 +162,7 @@ export class TSONDB {
         const errors = (checkOnlyEntities.length > 0
             ? entities.filter(entity => checkOnlyEntities.includes(entity.name))
             : entities)
-            .flatMap(entity => parallelizeErrors(getInstancesOfEntityFromDatabaseInMemory(this.#data, entity.name).map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateEntityDecl(validationContext, [], entity, instance.content)))))
+            .flatMap(entity => parallelizeErrors(getInstancesOfEntityFromDatabaseInMemory(this.#data, entity.name).map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateDecl(validationContext, [], entity, [], instance.content)))))
             .toSorted((a, b) => a.message.localeCompare(b.message));
         if (errors.length > 0) {
             const errorCount = countErrors(errors);
@@ -471,4 +474,13 @@ export class TSONDB {
             .toSorted((a, b) => a[1].relevance - b[1].relevance ||
             a[1].displayName.localeCompare(b[1].displayName, a[1].displayNameLocaleId));
     }
+    /**
+     * Compresses the entire database into a single JSON file at the specified path.
+     *
+     * Instead of storing each instance in its own file, this method serializes the entire database into a single JSON file. This can be useful for backup, transfer or archiving purposes. The resulting file contains all instances organized by entity names. No spaces or indentation are used in the JSON output to minimize file size.
+     * @param path The file path where the compressed database will be saved.
+     */
+    async compressToSingleFile(path) {
+        await writeFile(path, JSON.stringify(this.#data), "utf-8");
+    }
 }

package/dist/src/node/renderers/jsonschema/index.js

@@ -3,7 +3,7 @@ import Debug from "debug";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import { groupDeclarationsBySourceUrl } from "../../schema/index.js";
+import { groupDeclarationsBySourceUrl } from "../../schema/dsl/declarations/Decl.js";
 import { render } from "./render.js";
 const debug = Debug("tsondb:renderer:jsonschema");
 const extension = ".schema.json";

package/dist/src/node/renderers/jsonschema/render.d.ts

@@ -1,4 +1,4 @@
-import { type Decl } from "../../schema/declarations/Declaration.ts";
+import { type Decl } from "../../schema/dsl/declarations/Decl.ts";
 export type JsonSchemaRendererOptions = {
     format: "minified" | "tabs" | {
         kind: "spaces";

package/dist/src/node/renderers/jsonschema/render.js

@@ -1,14 +1,15 @@
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { dirname, relative } from "node:path";
 import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
-import { asDecl } from "../../schema/declarations/Declaration.js";
-import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
-import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
-import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
-import { ArrayType } from "../../schema/types/generic/ArrayType.js";
-import { getTypeOfKey } from "../../schema/types/generic/TranslationObjectType.js";
-import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
-import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
+import { NodeKind } from "../../../shared/schema/Node.js";
+import { asDecl } from "../../schema/dsl/declarations/Decl.js";
+import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/dsl/declarations/EntityDecl.js";
+import { TypeAliasDecl } from "../../schema/dsl/declarations/TypeAliasDecl.js";
+import { ArrayType } from "../../schema/dsl/types/ArrayType.js";
+import { isNestedEntityMapType } from "../../schema/dsl/types/NestedEntityMapType.js";
+import { ReferenceIdentifierType } from "../../schema/dsl/types/ReferenceIdentifierType.js";
+import { getTypeOfKey } from "../../schema/dsl/types/TranslationObjectType.js";
+import { flatMapAuxiliaryDecls } from "../../schema/helpers.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 const defaultIndentation = 2;
 const defaultOptions = {

package/dist/src/node/renderers/ts/index.js

@@ -3,7 +3,7 @@ import Debug from "debug";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import { groupDeclarationsBySourceUrl } from "../../schema/declarations/Declaration.js";
+import { groupDeclarationsBySourceUrl } from "../../schema/dsl/declarations/Decl.js";
 import { render } from "./render.js";
 const debug = Debug("tsondb:renderer:ts");
 const extension = ".d.ts";

package/dist/src/node/renderers/ts/render.d.ts

@@ -1,4 +1,4 @@
-import { type Decl } from "../../schema/declarations/Declaration.ts";
+import { type Decl } from "../../schema/dsl/declarations/Decl.ts";
 export type TypeScriptRendererOptions = {
     indentation: number;
     objectTypeKeyword: "interface" | "type";

package/dist/src/node/renderers/ts/render.js

@@ -4,17 +4,18 @@ import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { EOL } from "node:os";
 import { dirname, relative } from "node:path";
 import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
+import { NodeKind } from "../../../shared/schema/Node.js";
 import { extractParameterTypeNamesFromMessage, mapParameterTypeNames, } from "../../../shared/utils/translation.js";
-import { asDecl } from "../../schema/declarations/Declaration.js";
-import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, isEntityDeclWithParentReference, } from "../../schema/declarations/EntityDecl.js";
-import { isEnumDecl } from "../../schema/declarations/EnumDecl.js";
-import { isTypeAliasDecl, TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
-import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
-import { ArrayType } from "../../schema/types/generic/ArrayType.js";
-import { isObjectType } from "../../schema/types/generic/ObjectType.js";
-import { getTypeOfKey } from "../../schema/types/generic/TranslationObjectType.js";
-import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
-import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
+import { asDecl } from "../../schema/dsl/declarations/Decl.js";
+import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, isEntityDeclWithParentReference, } from "../../schema/dsl/declarations/EntityDecl.js";
+import { isEnumDecl } from "../../schema/dsl/declarations/EnumDecl.js";
+import { isTypeAliasDecl, TypeAliasDecl } from "../../schema/dsl/declarations/TypeAliasDecl.js";
+import { ArrayType } from "../../schema/dsl/types/ArrayType.js";
+import { isNestedEntityMapType } from "../../schema/dsl/types/NestedEntityMapType.js";
+import { isObjectType } from "../../schema/dsl/types/ObjectType.js";
+import { ReferenceIdentifierType } from "../../schema/dsl/types/ReferenceIdentifierType.js";
+import { getTypeOfKey } from "../../schema/dsl/types/TranslationObjectType.js";
+import { flatMapAuxiliaryDecls } from "../../schema/helpers.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 import { combineSyntaxes, emptyRenderResult, getIndentation, indent, prefixLines, syntax, } from "../../utils/render.js";
 const defaultOptions = {

package/dist/src/node/schema/dsl/TypeParameter.d.ts

@@ -0,0 +1,9 @@
+import { NodeKind } from "../../../shared/schema/Node.ts";
+import type { Type } from "./types/Type.ts";
+export interface TypeParameter<N extends string = string, T extends Type = Type> {
+    kind: NodeKind["TypeParameter"];
+    name: N;
+    constraint?: T;
+}
+export declare const TypeParameter: <N extends string = string, T extends Type = Type>(name: N, constraint?: T) => TypeParameter<N, T>;
+export { TypeParameter as Param };

package/dist/src/node/schema/dsl/TypeParameter.js

@@ -0,0 +1,7 @@
+import { NodeKind } from "../../../shared/schema/Node.js";
+export const TypeParameter = (name, constraint) => ({
+    kind: NodeKind.TypeParameter,
+    name,
+    constraint,
+});
+export { TypeParameter as Param };

package/dist/src/node/schema/{declarations/Declaration.d.ts → dsl/declarations/Decl.d.ts}

@@ -1,7 +1,8 @@
-import type { BaseNode, CustomConstraintValidator, Node } from "../Node.ts";
+import type { BaseNode } from "../../../../shared/schema/Node.ts";
+import type { Node } from "../index.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
-import type { EnumCaseDecl } from "../types/generic/EnumType.ts";
-import { type Type } from "../types/Type.ts";
+import type { EnumCaseDecl } from "../types/EnumType.ts";
+import type { Type } from "../types/Type.ts";
 import type { EntityDecl } from "./EntityDecl.ts";
 import type { EnumDecl } from "./EnumDecl.ts";
 import type { TypeAliasDecl } from "./TypeAliasDecl.ts";
@@ -27,4 +28,3 @@ export declare const isDeclWithoutTypeParameters: (decl: Decl) => decl is DeclP<
 export declare const resolveTypeArgumentsInDecls: (decls: readonly Decl[]) => Decl[];
 export declare function walkNodeTree(callbackFn: (node: Node, parentTypes: Type[], parentDecl: Decl) => void, decl: Decl): void;
 export declare const groupDeclarationsBySourceUrl: (decls: readonly Decl[]) => Partial<Record<string, Decl[]>>;
-export declare const checkCustomConstraintsInNestedDecl: CustomConstraintValidator<SecondaryDecl>;

package/dist/src/node/schema/{declarations/Declaration.js → dsl/declarations/Decl.js}

@@ -1,9 +1,8 @@
-import { assertExhaustive } from "@elyukai/utils/typeSafety";
-import { NodeKind, resolveTypeArguments } from "../Node.js";
-import { walkTypeNodeTree } from "../types/Type.js";
+import { walkTypeNodeTree } from "../../helpers.js";
+import { resolveTypeArguments } from "../../treeOperations/typeResolution.js";
 import { isEntityDecl } from "./EntityDecl.js";
-import { checkCustomConstraintsInEnumDecl, isEnumDecl } from "./EnumDecl.js";
-import { checkCustomConstraintsInTypeAliasDecl, isTypeAliasDecl } from "./TypeAliasDecl.js";
+import { isEnumDecl } from "./EnumDecl.js";
+import { isTypeAliasDecl } from "./TypeAliasDecl.js";
 export const getParameterNames = (decl) => decl.parameters.map(param => param.name);
 export const getTypeArgumentsRecord = (decl, args) => Object.fromEntries(
 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -23,13 +22,3 @@ export function walkNodeTree(callbackFn, decl) {
     walkTypeNodeTree(callbackFn, decl.type.value, [], decl);
 }
 export const groupDeclarationsBySourceUrl = (decls) => Object.groupBy(decls, decl => decl.sourceUrl);
-export const checkCustomConstraintsInNestedDecl = (decl, value, helpers) => {
-    switch (decl.kind) {
-        case NodeKind.EnumDecl:
-            return checkCustomConstraintsInEnumDecl(decl, value, helpers);
-        case NodeKind.TypeAliasDecl:
-            return checkCustomConstraintsInTypeAliasDecl(decl, value, helpers);
-        default:
-            return assertExhaustive(decl);
-    }
-};

package/dist/src/node/schema/{declarations → dsl/declarations}/EntityDecl.d.ts

@@ -1,15 +1,14 @@
 import { Lazy } from "@elyukai/utils/lazy";
-import type { SortOrder } from "../../../shared/schema/utils/sortOrder.ts";
-import type { UniqueConstraints } from "../../../shared/schema/utils/uniqueConstraint.ts";
-import type { InstanceContent } from "../../../shared/utils/instances.ts";
-import type { CustomConstraint, TypedCustomConstraint } from "../../utils/customConstraints.ts";
-import type { DisplayNameCustomizer, TypedDisplayNameCustomizer } from "../../utils/displayName.ts";
-import type { CustomConstraintValidator, GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../Node.ts";
-import { NodeKind } from "../Node.ts";
-import type { MemberDecl, ObjectType } from "../types/generic/ObjectType.ts";
-import { StringType } from "../types/primitives/StringType.ts";
-import type { NestedEntityMapType } from "../types/references/NestedEntityMapType.ts";
-import type { BaseDecl } from "./Declaration.ts";
+import { NodeKind } from "../../../../shared/schema/Node.js";
+import type { SortOrder } from "../../../../shared/schema/utils/sortOrder.ts";
+import type { UniqueConstraints } from "../../../../shared/schema/utils/uniqueConstraint.ts";
+import type { CustomConstraint, TypedCustomConstraint } from "../../../utils/customConstraints.ts";
+import type { DisplayNameCustomizer, TypedDisplayNameCustomizer } from "../../../utils/displayName.ts";
+import type { Node } from "../index.ts";
+import type { NestedEntityMapType } from "../types/NestedEntityMapType.ts";
+import type { MemberDecl, ObjectType } from "../types/ObjectType.ts";
+import { StringType } from "../types/StringType.ts";
+import type { BaseDecl } from "./Decl.ts";
 import { TypeAliasDecl } from "./TypeAliasDecl.ts";
 export type GenericEntityDisplayName = string | {
     pathToLocaleMap?: string;
@@ -125,19 +124,10 @@ export declare const EntityDecl: {
     }): EntityDecl<Name, T, FK>;
 };
 export { EntityDecl as Entity };
-export declare const isEntityDecl: Predicate<EntityDecl>;
+export declare const isEntityDecl: (node: Node) => node is EntityDecl;
 export declare const isEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(decl: EntityDecl<Name, T, FK>) => decl is EntityDecl<Name, T, NonNullable<FK>>;
-export declare const getNestedDeclarationsInEntityDecl: GetNestedDeclarations<EntityDecl>;
-export declare const validateEntityDecl: Validator<EntityDecl>;
-export declare const resolveTypeArgumentsInEntityDecl: TypeArgumentsResolver<EntityDecl>;
 export declare const addEphemeralUUIDToType: <T extends TConstraint>(decl: EntityDecl<string, T>) => ObjectType<Omit<T, "id"> & {
     id: MemberDecl<StringType, true>;
 }>;
 export declare const createEntityIdentifierType: () => StringType;
 export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
-export declare const serializeEntityDecl: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(type: EntityDecl<Name, T, FK>) => Serialized<EntityDecl<Name, T, FK>>;
-export declare const getReferencesForEntityDecl: GetReferences<EntityDecl>;
-export declare const checkCustomConstraintsInEntityDecl: CustomConstraintValidator<EntityDecl, [
-    id: string,
-    content: InstanceContent
-]>;

package/dist/src/node/schema/{declarations → dsl/declarations}/EntityDecl.js

@@ -1,9 +1,8 @@
 import { Lazy } from "@elyukai/utils/lazy";
-import { NodeKind, resolveTypeArguments, validateType } from "../Node.js";
-import { getNestedDeclarationsInObjectType, getReferencesForObjectType, Required, serializeObjectType, } from "../types/generic/ObjectType.js";
-import { StringType } from "../types/primitives/StringType.js";
-import { checkCustomConstraintsInType } from "../types/Type.js";
-import { validateDeclName } from "./Declaration.js";
+import { NodeKind } from "../../../../shared/schema/Node.js";
+import { Required } from "../types/ObjectType.js";
+import { StringType } from "../types/StringType.js";
+import { validateDeclName } from "./Decl.js";
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export const EntityDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
@@ -27,14 +26,8 @@ export const EntityDecl = (sourceUrl, options) => {
     };
 };
 export { EntityDecl as Entity };
-export const isEntityDecl = node => node.kind === NodeKind.EntityDecl;
+export const isEntityDecl = (node) => node.kind === NodeKind.EntityDecl;
 export const isEntityDeclWithParentReference = (decl) => decl.parentReferenceKey !== undefined;
-export const getNestedDeclarationsInEntityDecl = (isDeclAdded, decl) => getNestedDeclarationsInObjectType(isDeclAdded, decl.type.value, decl);
-export const validateEntityDecl = (helpers, inDecls, decl, value) => validateType(helpers, inDecls, decl.type.value, value);
-export const resolveTypeArgumentsInEntityDecl = (_args, decl, inDecl) => EntityDecl(decl.sourceUrl, {
-    ...decl,
-    type: () => resolveTypeArguments({}, decl.type.value, [...inDecl, decl]),
-});
 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,
@@ -52,12 +45,3 @@ export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sou
     name: (decl.name + "_ID"),
     type: createEntityIdentifierType,
 });
-export const serializeEntityDecl = ((type) => ({
-    ...type,
-    type: serializeObjectType(type.type.value),
-    instanceDisplayName: type.instanceDisplayName,
-    instanceDisplayNameCustomizer: type.instanceDisplayNameCustomizer !== undefined,
-    customConstraints: type.customConstraints !== undefined,
-}));
-export const getReferencesForEntityDecl = (decl, value, inDecl) => getReferencesForObjectType(decl.type.value, value, [...inDecl, decl]);
-export const checkCustomConstraintsInEntityDecl = (decl, value, helpers) => (decl.customConstraints?.({ ...helpers, instanceId: value[0], instanceContent: value[1] }) ?? []).concat(checkCustomConstraintsInType(decl.type.value, value, helpers));

package/dist/src/node/schema/{declarations → dsl/declarations}/EnumDecl.d.ts

@@ -1,12 +1,12 @@
 import { Lazy } from "@elyukai/utils/lazy";
-import { type EnumValue } from "../../../shared/schema/declarations/EnumDecl.ts";
-import type { NestedCustomConstraint, TypedNestedCustomConstraint } from "../../utils/customConstraints.ts";
-import type { CustomConstraintValidator, GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidatorOfParamDecl } from "../Node.ts";
-import { NodeKind } from "../Node.ts";
+import { type EnumValue } from "../../../../shared/schema/declarations/EnumDecl.ts";
+import { NodeKind } from "../../../../shared/schema/Node.ts";
+import type { NestedCustomConstraint, TypedNestedCustomConstraint } from "../../../utils/customConstraints.ts";
+import type { Node } from "../index.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
-import type { EnumCaseDecl } from "../types/generic/EnumType.ts";
-import { EnumType } from "../types/generic/EnumType.ts";
-import type { BaseDecl } from "./Declaration.ts";
+import type { EnumCaseDecl } from "../types/EnumType.ts";
+import { EnumType } from "../types/EnumType.ts";
+import type { BaseDecl } from "./Decl.ts";
 type TConstraint = Record<string, EnumCaseDecl>;
 export interface EnumDecl<Name extends string = string, T extends TConstraint = TConstraint, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
@@ -68,12 +68,6 @@ export declare const GenEnumDecl: <Name extends string, T extends TConstraint, P
     customConstraints?: TypedNestedCustomConstraint<Name>;
 }) => EnumDecl<Name, T, Params>;
 export { GenEnumDecl as GenEnum };
-export declare const isEnumDecl: Predicate<EnumDecl>;
-export declare const getNestedDeclarationsInEnumDecl: GetNestedDeclarations<EnumDecl>;
-export declare const validateEnumDecl: ValidatorOfParamDecl<EnumDecl>;
-export declare const resolveTypeArgumentsInEnumDecl: TypeArgumentsResolver<EnumDecl>;
-export declare const serializeEnumDecl: Serializer<EnumDecl>;
-export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;
+export declare const isEnumDecl: (node: Node) => node is EnumDecl;
 export declare const cases: <T extends TConstraint>(decl: EnumDecl<string, T>) => EnumCaseDecl<T[keyof T]["type"]>[];
 export declare const getAnyEnumCaseValue: <K extends string, V>(enumValue: { [Key in K]: EnumValue<Key, V>; }[K]) => V;
-export declare const checkCustomConstraintsInEnumDecl: CustomConstraintValidator<EnumDecl>;

package/dist/src/node/schema/dsl/declarations/EnumDecl.js

@@ -0,0 +1,26 @@
+import { Lazy } from "@elyukai/utils/lazy";
+import { onlyKeys } from "@elyukai/utils/object";
+import { ENUM_DISCRIMINATOR_KEY, } from "../../../../shared/schema/declarations/EnumDecl.js";
+import { NodeKind } from "../../../../shared/schema/Node.js";
+import { EnumType } from "../types/EnumType.js";
+import { validateDeclName } from "./Decl.js";
+const EnumDeclConstructor = (sourceUrl, options) => {
+    validateDeclName(options.name);
+    const parameters = (options.parameters ?? []);
+    const decl = {
+        ...onlyKeys(options, "name", "comment", "isDeprecated"),
+        kind: NodeKind.EnumDecl,
+        sourceUrl,
+        parameters,
+        type: Lazy.of(() => EnumType(options.values(...parameters))),
+        customConstraints: options.customConstraints, // ignore contravariance of registered enum type
+    };
+    return decl;
+};
+export const EnumDecl = EnumDeclConstructor;
+export { EnumDecl as Enum };
+export const GenEnumDecl = EnumDeclConstructor;
+export { GenEnumDecl as GenEnum };
+export const isEnumDecl = (node) => node.kind === NodeKind.EnumDecl;
+export const cases = (decl) => Object.values(decl.type.value.values);
+export const getAnyEnumCaseValue = (enumValue) => enumValue[enumValue[ENUM_DISCRIMINATOR_KEY]];

package/dist/src/node/schema/{declarations → dsl/declarations}/TypeAliasDecl.d.ts

@@ -1,10 +1,10 @@
 import { Lazy } from "@elyukai/utils/lazy";
-import type { NestedCustomConstraint, TypedNestedCustomConstraint } from "../../utils/customConstraints.ts";
-import type { CustomConstraintValidator, GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidationContext } from "../Node.ts";
-import { NodeKind } from "../Node.ts";
+import { NodeKind } from "../../../../shared/schema/Node.js";
+import type { NestedCustomConstraint, TypedNestedCustomConstraint } from "../../../utils/customConstraints.ts";
+import type { Node } from "../index.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
-import { type Type } from "../types/Type.ts";
-import type { BaseDecl, Decl, TypeArguments } from "./Declaration.ts";
+import type { Type } from "../types/Type.ts";
+import type { BaseDecl } from "./Decl.ts";
 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>;
@@ -63,10 +63,4 @@ export declare const GenTypeAliasDecl: <Name extends string, T extends Type, Par
     customConstraints?: TypedNestedCustomConstraint<Name>;
 }) => TypeAliasDecl<Name, T, Params>;
 export { GenTypeAliasDecl as GenTypeAlias };
-export declare const isTypeAliasDecl: Predicate<TypeAliasDecl>;
-export declare const getNestedDeclarationsInTypeAliasDecl: GetNestedDeclarations<TypeAliasDecl>;
-export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: ValidationContext, inDecls: Decl[], decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
-export declare const resolveTypeArgumentsInTypeAliasDecl: TypeArgumentsResolver<TypeAliasDecl>;
-export declare const serializeTypeAliasDecl: Serializer<TypeAliasDecl>;
-export declare const getReferencesForTypeAliasDecl: GetReferences<TypeAliasDecl>;
-export declare const checkCustomConstraintsInTypeAliasDecl: CustomConstraintValidator<TypeAliasDecl>;
+export declare const isTypeAliasDecl: (node: Node) => node is TypeAliasDecl;

package/dist/src/node/schema/dsl/declarations/TypeAliasDecl.js

@@ -0,0 +1,22 @@
+import { Lazy } from "@elyukai/utils/lazy";
+import { onlyKeys } from "@elyukai/utils/object";
+import { NodeKind } from "../../../../shared/schema/Node.js";
+import { validateDeclName } from "./Decl.js";
+const TypeAliasDeclConstructor = (sourceUrl, options) => {
+    validateDeclName(options.name);
+    const parameters = (options.parameters ?? []);
+    const decl = {
+        ...onlyKeys(options, "name", "comment", "isDeprecated"),
+        kind: NodeKind.TypeAliasDecl,
+        sourceUrl,
+        parameters,
+        type: Lazy.of(() => options.type(...parameters)),
+        customConstraints: options.customConstraints, // ignore contravariance of registered type alias type
+    };
+    return decl;
+};
+export const TypeAliasDecl = TypeAliasDeclConstructor;
+export { TypeAliasDecl as TypeAlias };
+export const GenTypeAliasDecl = TypeAliasDeclConstructor;
+export { GenTypeAliasDecl as GenTypeAlias };
+export const isTypeAliasDecl = (node) => node.kind === NodeKind.TypeAliasDecl;

package/dist/src/node/schema/dsl/index.d.ts

@@ -0,0 +1,24 @@
+import type { TypeParameter } from "./TypeParameter.ts";
+import type { Decl } from "./declarations/Decl.ts";
+import type { Type } from "./types/Type.ts";
+export { Param, TypeParameter } from "./TypeParameter.ts";
+export { type Decl, type DeclP, type IncludableDeclP, type SecondaryDecl, } from "./declarations/Decl.ts";
+export { Entity, EntityDecl, type EntityDeclWithParentReference, type EntityDisplayName, type GenericEntityDisplayName, } from "./declarations/EntityDecl.ts";
+export { Enum, EnumDecl, GenEnum, GenEnumDecl } from "./declarations/EnumDecl.ts";
+export { GenTypeAlias, GenTypeAliasDecl, TypeAlias, TypeAliasDecl, } from "./declarations/TypeAliasDecl.ts";
+export { Array, ArrayType } from "./types/ArrayType.ts";
+export { Boolean, BooleanType } from "./types/BooleanType.ts";
+export { ChildEntities, ChildEntitiesType } from "./types/ChildEntitiesType.ts";
+export { Date, DateType } from "./types/DateType.ts";
+export { EnumCase, EnumCaseDecl } from "./types/EnumType.ts";
+export { Float, FloatType } from "./types/FloatType.ts";
+export { GenIncludeIdentifier, GenIncludeIdentifierType, IncludeIdentifier, IncludeIdentifierType, } from "./types/IncludeIdentifierType.ts";
+export { Integer, IntegerType } from "./types/IntegerType.ts";
+export { NestedEntityMap, NestedEntityMapType } from "./types/NestedEntityMapType.ts";
+export { Object, ObjectType, Optional, Required, type MemberDecl } from "./types/ObjectType.ts";
+export { ReferenceIdentifier, ReferenceIdentifierType } from "./types/ReferenceIdentifierType.ts";
+export { String, StringType } from "./types/StringType.ts";
+export { TranslationObject, TranslationObjectType } from "./types/TranslationObjectType.ts";
+export type { Type } from "./types/Type.ts";
+export { TypeArgument, TypeArgumentType } from "./types/TypeArgumentType.ts";
+export type Node = Decl | Type | TypeParameter;

package/dist/src/node/schema/dsl/index.js

@@ -0,0 +1,19 @@
+export { Param, TypeParameter } from "./TypeParameter.js";
+export {} from "./declarations/Decl.js";
+export { Entity, EntityDecl, } from "./declarations/EntityDecl.js";
+export { Enum, EnumDecl, GenEnum, GenEnumDecl } from "./declarations/EnumDecl.js";
+export { GenTypeAlias, GenTypeAliasDecl, TypeAlias, TypeAliasDecl, } from "./declarations/TypeAliasDecl.js";
+export { Array, ArrayType } from "./types/ArrayType.js";
+export { Boolean, BooleanType } from "./types/BooleanType.js";
+export { ChildEntities, ChildEntitiesType } from "./types/ChildEntitiesType.js";
+export { Date, DateType } from "./types/DateType.js";
+export { EnumCase, EnumCaseDecl } from "./types/EnumType.js";
+export { Float, FloatType } from "./types/FloatType.js";
+export { GenIncludeIdentifier, GenIncludeIdentifierType, IncludeIdentifier, IncludeIdentifierType, } from "./types/IncludeIdentifierType.js";
+export { Integer, IntegerType } from "./types/IntegerType.js";
+export { NestedEntityMap, NestedEntityMapType } from "./types/NestedEntityMapType.js";
+export { Object, ObjectType, Optional, Required } from "./types/ObjectType.js";
+export { ReferenceIdentifier, ReferenceIdentifierType } from "./types/ReferenceIdentifierType.js";
+export { String, StringType } from "./types/StringType.js";
+export { TranslationObject, TranslationObjectType } from "./types/TranslationObjectType.js";
+export { TypeArgument, TypeArgumentType } from "./types/TypeArgumentType.js";

package/dist/src/node/schema/dsl/types/ArrayType.d.ts

@@ -0,0 +1,17 @@
+import { NodeKind } from "../../../../shared/schema/Node.ts";
+import type { Node } from "../index.ts";
+import type { BaseType, Type } from "./Type.ts";
+export interface ArrayType<T extends Type = Type> extends BaseType {
+    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;

package/dist/src/node/schema/dsl/types/ArrayType.js

@@ -0,0 +1,11 @@
+import { NodeKind } from "../../../../shared/schema/Node.js";
+import { validateOption } from "../../validation/options.js";
+export const ArrayType = (items, options = {}) => ({
+    ...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,
+});
+export { ArrayType as Array };
+export const isArrayType = (node) => node.kind === NodeKind.ArrayType;

package/dist/src/node/schema/dsl/types/BooleanType.d.ts

@@ -0,0 +1,9 @@
+import { NodeKind } from "../../../../shared/schema/Node.ts";
+import type { Node } from "../index.ts";
+import type { BaseType } from "./Type.ts";
+export interface BooleanType extends BaseType {
+    kind: NodeKind["BooleanType"];
+}
+export declare const BooleanType: () => BooleanType;
+export { BooleanType as Boolean };
+export declare const isBooleanType: (node: Node) => node is BooleanType;

package/dist/src/node/schema/dsl/types/BooleanType.js

@@ -0,0 +1,6 @@
+import { NodeKind } from "../../../../shared/schema/Node.js";
+export const BooleanType = () => ({
+    kind: NodeKind.BooleanType,
+});
+export { BooleanType as Boolean };
+export const isBooleanType = (node) => node.kind === NodeKind.BooleanType;

package/dist/src/node/schema/dsl/types/ChildEntitiesType.d.ts

@@ -0,0 +1,12 @@
+import { NodeKind } from "../../../../shared/schema/Node.ts";
+import { type EntityDecl } from "../declarations/EntityDecl.ts";
+import type { Node } from "../index.ts";
+import type { MemberDecl } from "./ObjectType.ts";
+import type { BaseType } from "./Type.ts";
+export interface ChildEntitiesType<T extends EntityDecl<string, Record<string, MemberDecl>, string> = EntityDecl<string, Record<string, MemberDecl>, string>> extends BaseType {
+    kind: NodeKind["ChildEntitiesType"];
+    entity: T;
+}
+export declare const ChildEntitiesType: <T extends EntityDecl<string, Record<string, MemberDecl>, string>>(entity: T) => ChildEntitiesType<T>;
+export { ChildEntitiesType as ChildEntities };
+export declare const isChildEntitiesType: (node: Node) => node is ChildEntitiesType;

package/dist/src/node/schema/dsl/types/ChildEntitiesType.js

@@ -0,0 +1,8 @@
+import { NodeKind } from "../../../../shared/schema/Node.js";
+import {} from "../declarations/EntityDecl.js";
+export const ChildEntitiesType = (entity) => ({
+    kind: NodeKind.ChildEntitiesType,
+    entity,
+});
+export { ChildEntitiesType as ChildEntities };
+export const isChildEntitiesType = (node) => node.kind === NodeKind.ChildEntitiesType;

package/dist/src/node/schema/dsl/types/DateType.d.ts

@@ -0,0 +1,10 @@
+import { NodeKind } from "../../../../shared/schema/Node.ts";
+import type { DateConstraints } from "../../../../shared/validation/date.ts";
+import type { Node } from "../index.ts";
+import type { BaseType } from "./Type.ts";
+export interface DateType extends BaseType, DateConstraints {
+    kind: NodeKind["DateType"];
+}
+export declare const DateType: (options?: DateConstraints) => DateType;
+export { DateType as Date };
+export declare const isDateType: (node: Node) => node is DateType;

package/dist/src/node/schema/dsl/types/DateType.js

@@ -0,0 +1,7 @@
+import { NodeKind } from "../../../../shared/schema/Node.js";
+export const DateType = (options) => ({
+    ...options,
+    kind: NodeKind.DateType,
+});
+export { DateType as Date };
+export const isDateType = (node) => node.kind === NodeKind.DateType;