tsondb 0.19.0 → 0.19.1

package/dist/src/node/git.js

@@ -35,7 +35,7 @@ export class Git {
             trackingBranch: status.tracking,
             commitsAhead: status.ahead,
             commitsBehind: status.behind,
-            instances: getAllInstanceOverviewsByEntityName(this.#db.getInstanceContainerOfEntityById.bind(this.#db), this.#db.getAllChildInstanceContainersForParent.bind(this.#db), this.#db.schema.getEntity.bind(this.#db.schema), data, this.#db.locales),
+            instances: getAllInstanceOverviewsByEntityName(this.#db.schema.getEntity.bind(this.#db.schema), data, this.#db.locales),
             latestCommit: await this.#git.revparse(["HEAD"]),
         };
     }

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

@@ -14,6 +14,9 @@ export interface DefaultTSONDBTypes {
 }
 export type Entity<T extends DefaultTSONDBTypes, E extends EntityName<T>> = T["entityMap"][E];
 export type EntityName<T extends DefaultTSONDBTypes> = Extract<keyof T["entityMap"], string>;
+export type EnumName<T extends DefaultTSONDBTypes> = Extract<keyof T["enumMap"], string>;
+export type TypeAliasName<T extends DefaultTSONDBTypes> = Extract<keyof T["typeAliasMap"], string>;
+export type DeclarationName<T extends DefaultTSONDBTypes> = EntityName<T> | EnumName<T> | TypeAliasName<T>;
 export type ChildEntity<T extends DefaultTSONDBTypes, E extends ChildEntityName<T>> = T["childEntityMap"][E][0];
 export type ChildEntityConfig<T extends DefaultTSONDBTypes, E extends ChildEntityName<T>> = T["childEntityMap"][E];
 export type ChildEntityName<T extends DefaultTSONDBTypes> = Extract<keyof T["childEntityMap"], string>;

package/dist/src/node/index.js

@@ -1,4 +1,3 @@
-import { deepEqual } from "@elyukai/utils/equality";
 import { Lazy } from "@elyukai/utils/lazy";
 import { isError } from "@elyukai/utils/result";
 import Debug from "debug";
@@ -9,14 +8,15 @@ import { styleText } from "node:util";
 import { simpleGit } from "simple-git";
 import { parallelizeErrors } from "../shared/utils/validation.js";
 import { Git } from "./git.js";
+import { getDisplayName, getDisplayNameWithId } from "./schema/detached.js";
 import {} from "./schema/dsl/index.js";
-import { normalizedIdArgs } from "./schema/generatedTypeHelpers.js";
+import {} 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 { createReferenceValidator, validateDeclReferentialIntegrity, validateDeclStructuralIntegrity, } 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";
+import { DatabaseInMemory } from "./utils/databaseInMemory.js";
 import { applyStepsToDisk } from "./utils/databaseOnDisk.js";
 import { getAllInstanceOverviewsByEntityName, getDisplayNameFromEntityInstance, getInstanceOverview, getInstanceOverviewsByEntityName, } from "./utils/displayName.js";
 import { countError, countErrors, getErrorMessageForDisplay, wrapErrorsIfAny, } from "./utils/error.js";
@@ -41,7 +41,7 @@ const getGit = async (dataRootPath) => {
     const git = simpleGit({ baseDir: dataRootPath });
     if (await git.checkIsRepo()) {
         try {
-            const root = await git.revparse({ "--show-toplevel": null });
+            const root = await git.revparse(["--show-toplevel"]);
             const status = await git.status();
             return { git, root, status };
         }
@@ -55,11 +55,11 @@ const getGit = async (dataRootPath) => {
 };
 const initData = async (dataRootPath, schema, locales, git, gitStatus) => {
     debug("loading database into memory ...");
-    let data = await createDatabaseInMemory(dataRootPath, schema.entities);
+    let data = await DatabaseInMemory.load(dataRootPath, schema.entities);
     debug("done");
     const localeEntity = schema.localeEntity;
     if (localeEntity &&
-        !locales.every(locale => hasInstanceOfEntityFromDatabaseInMemory(data, localeEntity.name, locale))) {
+        !locales.every(locale => data.hasInstanceOfEntityById(localeEntity.name, locale))) {
         throw new Error("All provided locales must exist in the database.");
     }
     const serializedDeclarationsByName = Object.fromEntries(schema.resolvedDeclarations.map(decl => [decl.name, serializeNode(decl)]));
@@ -144,25 +144,34 @@ export class TSONDB {
     async generateOutputs(outputs) {
         await generateOutputs(this.#schema, outputs);
     }
-    /**
-     * Validates the data in the database.
-     *
-     * Returns `true` if the data is valid, `false` otherwise.
-     */
-    validate() {
+    #strucurallyValidateInstance(entity, instanceContent) {
+        const validationContext = {
+            validationOptions: this.#validationOptions,
+            useStyling: true,
+        };
+        return validateDeclStructuralIntegrity(validationContext, [], entity, [], instanceContent);
+    }
+    #validate(data) {
         const { checkReferentialIntegrity, checkOnlyEntities } = this.#validationOptions;
         const entities = this.#schema.entities;
+        const getEntity = this.#schema.getEntity.bind(this.#schema);
         for (const onlyEntity of checkOnlyEntities) {
             if (!entities.find(entity => entity.name === onlyEntity)) {
                 throw new Error(`Entity "${onlyEntity}" not found in schema`);
             }
         }
-        const validationContext = createValidationContext(this.#validationOptions, this.#data, true, checkReferentialIntegrity);
-        debug("Checking structural integrity ...");
-        const errors = (checkOnlyEntities.length > 0
+        const onlyEntities = 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)))}"`)}`, validateDecl(validationContext, [], entity, [], instance.content)))))
+            : entities;
+        const validationContext = {
+            validationOptions: this.#validationOptions,
+            useStyling: true,
+        };
+        debug("Checking structural integrity ...");
+        const errors = onlyEntities
+            .flatMap(entity => parallelizeErrors(data
+            .getAllInstanceContainersOfEntity(entity.name)
+            .map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateDeclStructuralIntegrity(validationContext, [], entity, [], instance.content)))))
             .toSorted((a, b) => a.message.localeCompare(b.message));
         if (errors.length > 0) {
             const errorCount = countErrors(errors);
@@ -172,9 +181,29 @@ export class TSONDB {
             debug("No structural integrity violations found");
         }
         if (errors.length === 0) {
+            if (checkReferentialIntegrity) {
+                debug("Checking referential integrity ...");
+                const referenceValidator = createReferenceValidator(this.#schema.isEntityName.bind(this.#schema), data, true);
+                const referenceErrors = onlyEntities
+                    .flatMap(entity => parallelizeErrors(data
+                    .getAllInstanceContainersOfEntity(entity.name)
+                    .map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateDeclReferentialIntegrity(validationContext, referenceValidator, [], entity, [], instance.content)))))
+                    .toSorted((a, b) => a.message.localeCompare(b.message));
+                if (referenceErrors.length > 0) {
+                    const errorCount = countErrors(referenceErrors);
+                    debug(`${errorCount.toString()} referential integrity violation${errorCount === 1 ? "" : "s"} found`);
+                    errors.push(...referenceErrors);
+                }
+                else {
+                    debug("No referential integrity violations found");
+                }
+            }
+            else {
+                debug("Disabled referential integrity checks, skipping them");
+            }
             debug("Checking unique constraints ...");
-            const instanceOverviewsByEntityName = this.getAllInstanceOverviews();
-            const uniqueConstraintResult = checkUniqueConstraintsForAllEntities(this.#data, this.#schema.entities, instanceOverviewsByEntityName);
+            const instanceOverviewsByEntityName = getAllInstanceOverviewsByEntityName(getEntity, data, this.#locales);
+            const uniqueConstraintResult = checkUniqueConstraintsForAllEntities(data, onlyEntities, instanceOverviewsByEntityName);
             if (isError(uniqueConstraintResult)) {
                 const errorCount = countError(uniqueConstraintResult.error);
                 debug(`${errorCount.toString()} unique constraint violation${errorCount === 1 ? "" : "s"} found`);
@@ -184,7 +213,7 @@ export class TSONDB {
                 debug("No unique constraint violations found");
             }
             debug("Checking custom constraints ...");
-            const customConstraintResult = checkCustomConstraintsForAllEntities(this);
+            const customConstraintResult = checkCustomConstraintsForAllEntities((...args) => getDisplayName(getEntity, this.#locales, data, ...args), (...args) => getDisplayNameWithId(getEntity, this.#locales, data, ...args), (...args) => getInstanceOverview(data.getInstanceContainerOfEntityById.bind(data), data.getAllChildInstanceContainersForParent.bind(data, getEntity), getEntity, this.#locales, args), getEntity, data, entities);
             if (isError(customConstraintResult)) {
                 const errorCount = countError(customConstraintResult.error);
                 debug(`${errorCount.toString()} custom constraint violation${errorCount === 1 ? "" : "s"} found`);
@@ -195,29 +224,35 @@ export class TSONDB {
             }
         }
         else {
-            debug("Skipping unique constraint checks due to previous structural integrity errors");
+            debug("Skipping further checks due to previous structural integrity errors");
         }
-        const totalInstanceCount = countInstancesInDatabaseInMemory(this.#data);
-        console.log(`${totalInstanceCount.toString()} instance${totalInstanceCount === 1 ? "" : "s"} checked`);
+        console.log(`${data.totalSize.toString()} instance${data.totalSize === 1 ? "" : "s"} checked`);
         if (errors.length === 0) {
             console.log(styleText("green", "All instances are valid"));
-            return true;
         }
         else {
             const errorCount = countErrors(errors);
             console.error(styleText("red", `${errorCount.toString()} validation error${errorCount === 1 ? "" : "s"} found\n\n${errors.map(err => getErrorMessageForDisplay(err)).join("\n\n")}`, { stream: stderr }));
-            return false;
         }
+        return errors;
+    }
+    /**
+     * Validates the data in the database.
+     *
+     * Returns `true` if the data is valid, `false` otherwise.
+     */
+    validate() {
+        return this.#validate(this.#data).length === 0;
     }
     /**
      * Formats the data on disk according to the current in-memory representation.
      */
     async format() {
-        await asyncForEachInstanceInDatabaseInMemory(this.#data, async (entityName, instance) => {
+        await this.#data.forEachInstance(async (entityName, instance) => {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const entity = this.#schema.getEntity(entityName);
             await writeInstance(this.#dataRootPath, entity, instance.id, instance.content);
-        });
+        }, true);
     }
     /**
      * Reloads the data from disk into memory.
@@ -239,20 +274,15 @@ export class TSONDB {
             data: this.#data,
             getEntity,
             referencesToInstances: this.#referencesToInstances,
-            validationOptions: this.#validationOptions,
+            validate: this.#strucurallyValidateInstance.bind(this),
             localeEntity: this.#schema.localeEntity,
             steps: [],
         }));
         const txtResult = txn.getResult();
         const { data: newData, referencesToInstances: newRefs, steps } = txtResult;
-        const instanceOverviewsByEntityName = getAllInstanceOverviewsByEntityName(this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), getEntity, newData, this.#locales);
-        const uniqueConstraintResult = checkUniqueConstraintsForAllEntities(newData, this.#schema.entities, instanceOverviewsByEntityName);
-        if (isError(uniqueConstraintResult)) {
-            throw uniqueConstraintResult.error;
-        }
-        const customConstraintResult = checkCustomConstraintsForAllEntities(this);
-        if (isError(customConstraintResult)) {
-            throw customConstraintResult.error;
+        const errors = this.#validate(newData);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, "Validation errors occurred");
         }
         const diskResult = await applyStepsToDisk(this.#dataRootPath, steps);
         if (isError(diskResult)) {
@@ -260,8 +290,7 @@ export class TSONDB {
         }
         if (this.#git) {
             const status = await this.#git.client.status();
-            const repoRoot = await this.#git.client.revparse(["--show-toplevel"]);
-            const newDbWithUpdatedGit = attachGitStatusToDatabaseInMemory(newData, this.#dataRootPath, repoRoot, status);
+            const newDbWithUpdatedGit = attachGitStatusToDatabaseInMemory(newData, this.#dataRootPath, this.#git.root, status);
             this.#data = newDbWithUpdatedGit;
         }
         else {
@@ -308,14 +337,13 @@ export class TSONDB {
      * Retrieves an instance of the specified entity by its identifier.
      */
     getInstanceOfEntityById(...args) {
-        return this.getInstanceContainerOfEntityById(...args)?.content;
+        return this.#data.getInstanceContainerOfEntityById(...args)?.content;
     }
     /**
      * Retrieves the instance container of the specified entity by its identifier.
      */
     getInstanceContainerOfEntityById(...args) {
-        const { entityName, id } = normalizedIdArgs(args);
-        return getInstanceOfEntityFromDatabaseInMemory(this.#data, entityName, id);
+        return this.#data.getInstanceContainerOfEntityById(...args);
     }
     /**
      * Retrieves the overview of an instance of the specified entity by its identifier.
@@ -327,13 +355,13 @@ export class TSONDB {
      * Retrieves all instances of the specified entity.
      */
     getAllInstancesOfEntity(entityName) {
-        return this.getAllInstanceContainersOfEntity(entityName).map(ic => ic.content);
+        return this.#data.getAllInstanceContainersOfEntity(entityName).map(ic => ic.content);
     }
     /**
      * Retrieves all instance containers of the specified entity.
      */
     getAllInstanceContainersOfEntity(entityName) {
-        return getInstancesOfEntityFromDatabaseInMemory(this.#data, entityName);
+        return this.#data.getAllInstanceContainersOfEntity(entityName);
     }
     /**
      * Retrieves all instance overviews of the specified entity.
@@ -349,48 +377,31 @@ export class TSONDB {
      * Counts the number of instances registered for the specified entity.
      */
     countInstancesOfEntity(entityName) {
-        return countInstancesOfEntityInDatabaseInMemory(this.#data, entityName);
+        return this.#data.countInstancesOfEntity(entityName);
     }
     /**
      * Retrieves overviews for all instances in the database, grouped by entity name.
      */
     getAllInstanceOverviews() {
-        return getAllInstanceOverviewsByEntityName(this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), this.#schema.getEntity.bind(this.#schema), this.#data, this.#locales);
+        return getAllInstanceOverviewsByEntityName(this.#schema.getEntity.bind(this.#schema), this.#data, this.#locales);
     }
     /**
      * Retrieves all instance containers of the specified child entity for a given parent instance.
      */
     getAllChildInstanceContainersForParent(childEntityName, parentId) {
-        const entity = this.#schema.getEntity(childEntityName);
-        if (!entity || !entity.parentReferenceKey) {
-            return [];
-        }
-        const parentKey = entity.parentReferenceKey;
-        return getInstancesOfEntityFromDatabaseInMemory(this.#data, childEntityName).filter(instance => deepEqual(instance.content[parentKey], parentId));
+        return this.#data.getAllChildInstanceContainersForParent(this.#schema.getEntity.bind(this.#schema), childEntityName, parentId);
     }
     /**
      * Displays the name of an entity instance including its ID. If no display name is found, `undefined` is returned.
      */
     getDisplayName(...args) {
-        const { entityName, id } = normalizedIdArgs(args);
-        // return instanceOverviewsByEntityName[entityName]?.find(o => o.id === id)?.displayName
-        const entity = this.#schema.getEntity(entityName);
-        if (!entity) {
-            return undefined;
-        }
-        const instance = getInstanceOfEntityFromDatabaseInMemory(this.#data, entity.name, id);
-        if (!instance) {
-            return undefined;
-        }
-        return getDisplayNameFromEntityInstance(entity, instance, this.#schema.getEntity.bind(this.#schema), this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), this.#locales).name;
+        return getDisplayName(this.#schema.getEntity.bind(this.#schema), this.#locales, this.#data, ...args);
     }
     /**
      * Displays the name of an entity instance including its ID. If no display name is found, only the ID is returned.
      */
     getDisplayNameWithId(...args) {
-        const { id } = normalizedIdArgs(args);
-        const displayName = this.getDisplayName(...args);
-        return displayName ? `"${displayName}" (${id})` : id;
+        return getDisplayNameWithId(this.#schema.getEntity.bind(this.#schema), this.#locales, this.#data, ...args);
     }
     /**
      * Checks if a given instance is referenced by other instances in the database.
@@ -442,7 +453,8 @@ export class TSONDB {
                     : 0;
         }, } = options;
         const lowerCaseQuery = query.toLowerCase();
-        return getGroupedInstancesFromDatabaseInMemory(this.#data)
+        return this.#data
+            .getAllInstances()
             .flatMap(([entityName, instances]) => {
             const entity = this.#schema.getEntity(entityName);
             if (entity && isEntityDeclWithParentReference(entity)) {

package/dist/src/node/schema/detached.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Standalone functions for database operations without needing a full TSONDB instance.
+ */
+import { type DatabaseInMemory } from "../utils/databaseInMemory.ts";
+import { type AnyEntityMap, type GetEntityByName, type IdArgsVariant } from "./generatedTypeHelpers.ts";
+export declare const getDisplayName: <EM extends AnyEntityMap>(getEntity: GetEntityByName<EM>, locales: string[], data: DatabaseInMemory<EM>, ...args: IdArgsVariant<EM>) => string | undefined;
+export declare const getDisplayNameWithId: <EM extends AnyEntityMap>(getEntity: GetEntityByName<EM>, locales: string[], data: DatabaseInMemory<EM>, ...args: IdArgsVariant<EM>) => string;

package/dist/src/node/schema/detached.js

@@ -0,0 +1,24 @@
+/**
+ * Standalone functions for database operations without needing a full TSONDB instance.
+ */
+import {} from "../utils/databaseInMemory.js";
+import { getDisplayNameFromEntityInstance } from "../utils/displayName.js";
+import { normalizedIdArgs, } from "./generatedTypeHelpers.js";
+export const getDisplayName = (getEntity, locales, data, ...args) => {
+    const { entityName, id } = normalizedIdArgs(args);
+    // return instanceOverviewsByEntityName[entityName]?.find(o => o.id === id)?.displayName
+    const entity = getEntity(entityName);
+    if (!entity) {
+        return undefined;
+    }
+    const instance = data.getInstanceContainerOfEntityById(entity.name, id);
+    if (!instance) {
+        return undefined;
+    }
+    return getDisplayNameFromEntityInstance(entity, instance, getEntity, data.getInstanceContainerOfEntityById.bind(data), data.getAllChildInstanceContainersForParent.bind(data, getEntity), locales).name;
+};
+export const getDisplayNameWithId = (getEntity, locales, data, ...args) => {
+    const { id } = normalizedIdArgs(args);
+    const displayName = getDisplayName(getEntity, locales, data, ...args);
+    return displayName ? `"${displayName}" (${id})` : id;
+};

package/dist/src/node/schema/dsl/declarations/Decl.d.ts

@@ -11,7 +11,7 @@ export type TypeArguments<Params extends TypeParameter[]> = {
 };
 export declare const getParameterNames: (decl: Decl) => string[];
 export declare const getTypeArgumentsRecord: <Params extends TypeParameter[]>(decl: DeclP<Params>, args: TypeArguments<Params>) => Record<string, Type>;
-export type Decl = EntityDecl | EnumDecl | TypeAliasDecl;
+export type Decl<Name extends string = string> = EntityDecl<Name> | EnumDecl<Name> | TypeAliasDecl<Name>;
 export type DeclP<Params extends TypeParameter[] = TypeParameter[]> = EntityDecl | EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
 export type IncludableDeclP<Params extends TypeParameter[] = TypeParameter[]> = EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
 export type SecondaryDecl = EnumDecl | TypeAliasDecl;

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

@@ -17,6 +17,8 @@ export interface NestedEntityMapType<Name extends string = string, T extends TCo
     comment?: string;
     secondaryEntity: EntityDecl;
     type: Lazy<PossibleType<T>>;
+    minProperties?: number;
+    maxProperties?: number;
 }
 export declare const NestedEntityMapType: <Name extends string, T extends TConstraint>(options: {
     name: Name;
@@ -24,7 +26,8 @@ export declare const NestedEntityMapType: <Name extends string, T extends TConst
     comment?: string;
     secondaryEntity: EntityDecl;
     type: PossibleType<T>;
-    isDeprecated?: boolean;
+    minProperties?: number;
+    maxProperties?: number;
 }) => NestedEntityMapType<Name, T>;
 export { NestedEntityMapType as NestedEntityMap };
 export declare const _NestedEntityMapType: <Name extends string, T extends TConstraint>(options: {
@@ -33,6 +36,7 @@ export declare const _NestedEntityMapType: <Name extends string, T extends TCons
     comment?: string;
     secondaryEntity: EntityDecl;
     type: () => PossibleType<T>;
-    isDeprecated?: boolean;
+    minProperties?: number;
+    maxProperties?: number;
 }) => NestedEntityMapType<Name, T>;
 export declare const isNestedEntityMapType: (node: Node) => node is NestedEntityMapType;

package/dist/src/node/schema/generatedTypeHelpers.d.ts

@@ -4,7 +4,8 @@
  */
 import { ENUM_DISCRIMINATOR_KEY } from "../../shared/schema/declarations/EnumDecl.ts";
 import type { DisplayNameResult } from "../../shared/utils/displayName.ts";
-import type { InstanceContainer, InstanceContent } from "../../shared/utils/instances.ts";
+import type { InstanceContainer, InstanceContainerOverview, InstanceContent } from "../../shared/utils/instances.ts";
+import type { DeclarationName, DefaultTSONDBTypes } from "../index.ts";
 import type { EntityDecl } from "./dsl/declarations/EntityDecl.ts";
 export interface Register {
 }
@@ -89,6 +90,10 @@ export type GetInstanceById<T extends AnyEntityMap = RegisteredEntityMap> = <E e
  * A function that retrieves an instance container by its entity and identifier.
  */
 export type GetInstanceContainerById<T extends AnyEntityMap = RegisteredEntityMap> = <E extends Extract<keyof T, string> = Extract<keyof T, string>>(...args: IdArgsVariant<T, E>) => InstanceContainer<T[E]> | undefined;
+/**
+ * A function that retrieves an instance container by its entity and identifier.
+ */
+export type GetInstanceOverviewOfEntityById<T extends AnyEntityMap = RegisteredEntityMap> = <E extends Extract<keyof T, string> = Extract<keyof T, string>>(...args: IdArgsVariant<T, E>) => InstanceContainerOverview | undefined;
 /**
  * A function that retrieves all instances of a given entity.
  */
@@ -121,4 +126,12 @@ export type GetDisplayNameAndId<T extends AnyEntityMap = RegisteredEntityMap> =
  * A function that retrieves an entity declaration by its name.
  */
 export type GetEntityByName<T extends AnyEntityMap = RegisteredEntityMap> = <E extends Extract<keyof T, string> = Extract<keyof T, string>>(name: E) => EntityDecl<E> | undefined;
+/**
+ * A type guard function that checks if a given string is a valid declaration name.
+ */
+export type DeclarationNameGuard<T extends DefaultTSONDBTypes> = (name: string) => name is DeclarationName<T>;
+/**
+ * A type guard function that checks if a given string is a valid entity name.
+ */
+export type EntityNameGuard<T extends AnyEntityMap = RegisteredEntityMap> = (name: string) => name is Extract<keyof T, string>;
 export {};

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

@@ -1,4 +1,4 @@
-import type { DefaultTSONDBTypes, EntityName } from "../index.ts";
+import type { DeclarationName, DefaultTSONDBTypes, EntityName } from "../index.ts";
 import type { Decl } from "./dsl/declarations/Decl.ts";
 import type { EntityDecl } from "./dsl/declarations/EntityDecl.ts";
 export declare class Schema<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
@@ -10,7 +10,19 @@ export declare class Schema<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
     getResolvedEntity<E extends EntityName<T>>(name: E): EntityDecl<E> | undefined;
     get declarations(): Decl[];
     get resolvedDeclarations(): Decl[];
-    getDeclaration(name: string): Decl | undefined;
-    getResolvedDeclaration(name: string): Decl | undefined;
+    getDeclaration<E extends DeclarationName<T>>(name: E): Decl<E> | undefined;
+    getResolvedDeclaration<E extends DeclarationName<T>>(name: E): Decl<E> | undefined;
     get localeEntity(): EntityDecl<EntityName<T>> | undefined;
+    /**
+     * Checks if the given name is a valid entity name in the schema.
+     *
+     * This includes all entity declarations, but not nested entity declarations, as they cannot be referenced directly by their name.
+     */
+    isEntityName(name: string): name is EntityName<T>;
+    /**
+     * Checks if the given name is a valid declaration name in the schema. This includes entity declarations, enum declarations and type alias declarations.
+     *
+     * Note that this does not include nested entity declarations, as they cannot be referenced directly by their name.
+     */
+    isDeclarationName(name: string): name is DeclarationName<T>;
 }

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

@@ -91,6 +91,22 @@ export class Schema {
     get localeEntity() {
         return this.#localeEntity;
     }
+    /**
+     * Checks if the given name is a valid entity name in the schema.
+     *
+     * This includes all entity declarations, but not nested entity declarations, as they cannot be referenced directly by their name.
+     */
+    isEntityName(name) {
+        return this.#entities.some(entity => entity.name === name);
+    }
+    /**
+     * Checks if the given name is a valid declaration name in the schema. This includes entity declarations, enum declarations and type alias declarations.
+     *
+     * Note that this does not include nested entity declarations, as they cannot be referenced directly by their name.
+     */
+    isDeclarationName(name) {
+        return this.#declarationMap.has(name);
+    }
 }
 const checkDuplicateIdentifier = (existingDecls, decl) => {
     const existingDeclWithSameName = existingDecls

package/dist/src/node/schema/treeOperations/validation.d.ts

@@ -2,15 +2,18 @@ import type { ValidationOptions } from "../../index.ts";
 import { type DatabaseInMemory } from "../../utils/databaseInMemory.ts";
 import { type Decl } from "../dsl/declarations/Decl.ts";
 import type { Type } from "../dsl/index.ts";
+import type { AnyEntityMap } from "../generatedTypeHelpers.ts";
 export type IdentifierToCheck = {
     name: string;
     value: unknown;
 };
+export type ReferenceValidator = (entityName: string, instanceId: unknown) => ReferenceError[];
 export interface ValidationContext {
     useStyling: boolean;
-    checkReferentialIntegrity: (identifier: IdentifierToCheck) => Error[];
-    checkTranslations?: ValidationOptions["checkTranslations"];
+    validationOptions: ValidationOptions;
 }
-export declare const createValidationContext: (options: Partial<ValidationOptions>, databaseInMemory: DatabaseInMemory, useStyling: boolean, checkReferentialIntegrity?: boolean) => ValidationContext;
-export declare const validateDecl: (helpers: ValidationContext, inDecls: Decl[], decl: Decl, typeArgs: Type[], value: unknown) => Error[];
-export declare const validateType: (helpers: ValidationContext, inDecls: Decl[], type: Type, value: unknown) => Error[];
+export declare const createReferenceValidator: <EM extends AnyEntityMap>(isEntityName: (name: string) => name is Extract<keyof EM, string>, databaseInMemory: DatabaseInMemory<EM>, useStyling: boolean) => ReferenceValidator;
+export declare const validateDeclStructuralIntegrity: (helpers: ValidationContext, inDecls: Decl[], decl: Decl, typeArgs: Type[], value: unknown) => TypeError[];
+export declare const validateTypeStructuralIntegrity: (helpers: ValidationContext, inDecls: Decl[], type: Type, value: unknown) => TypeError[];
+export declare const validateDeclReferentialIntegrity: (helpers: ValidationContext, checkReferentialIntegrity: ReferenceValidator, inDecls: Decl[], decl: Decl, typeArgs: Type[], value: unknown) => ReferenceError[];
+export declare const validateTypeReferentialIntegrity: (helpers: ValidationContext, checkReferentialIntegrity: ReferenceValidator, inDecls: Decl[], type: Type, value: unknown) => ReferenceError[];