tsondb 0.13.2 → 0.15.0

package/README.md

@@ -48,6 +48,13 @@ export default {
 
 See the following sections for details on how the different parts come together.
 
+## Terms
+
+The following list will define common terms used in TSONDB.
+
+- **Entity:** The type of group of values, e.g. employees.
+- **Instance:** A singular group of values of an *entity*, e.g. Jane Doe.
+
 ## Define a Schema
 
 You define a schema by declarations that consist of types.

package/dist/src/bin/tsondb.js

@@ -92,7 +92,7 @@ switch (passedArguments.command.name) {
     case "serve":
         debug(`running command: serve`);
         validateConfigForServer(config);
-        await serve(config.schema, config.dataRootPath, config.defaultLocales, config.homeLayoutSections, config.serverOptions, config.validationOptions, config.customStylesheetPath);
+        await serve(config.schema, config.dataRootPath, config.locales, config.homeLayoutSections, config.serverOptions, config.validationOptions, config.customStylesheetPath);
         break;
     case "validate":
         debug(`running command: validate`);
@@ -104,7 +104,7 @@ switch (passedArguments.command.name) {
             const entities = passedArguments.command.options.checkOnlyEntities;
             debug(`only check the following entities: ${entities.join(", ")}`);
         }
-        await validate(config.schema, config.dataRootPath, {
+        await validate(config.schema, config.dataRootPath, config.locales, {
             ...config.validationOptions,
             ...omitUndefinedKeys(passedArguments.command.options ?? {}),
         });

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

@@ -9,7 +9,10 @@ export type Config = {
     serverOptions?: ServerOptions;
     schema: Schema;
     outputs?: Output[];
-    defaultLocales?: string[];
+    /**
+     * Default locales for the server/editor and locales used for testing via CLI.
+     */
+    locales?: string[];
     dataRootPath?: string;
     homeLayoutSections?: HomeLayoutSection[];
     customStylesheetPath?: string;
@@ -43,7 +46,7 @@ export type DataConfig = {
  */
 export type ServerConfig = DataConfig & {
     serverOptions?: ServerOptions;
-    defaultLocales: string[];
+    locales: string[];
     homeLayoutSections?: HomeLayoutSection[];
     validationOptions?: Partial<ValidationOptions>;
     customStylesheetPath?: string;
@@ -52,6 +55,7 @@ export type ServerConfig = DataConfig & {
  * The configuration type required for validating the contents of the database.
  */
 export type TestingConfig = DataConfig & {
+    locales: string[];
     validationOptions?: Partial<ValidationOptions>;
 };
 /**

package/dist/src/node/config.js

@@ -4,14 +4,17 @@ export const validateConfigForGeneration = config => {
     }
 };
 export const validateConfigForServer = config => {
-    if ((config.defaultLocales?.length ?? 0) === 0) {
-        throw new Error("At least one default locale must be specified in the config.");
+    if ((config.locales?.length ?? 0) === 0) {
+        throw new Error("At least one locale must be specified in the config.");
     }
     if (config.dataRootPath === undefined) {
         throw new Error("A data root path must be specified in the config.");
     }
 };
 export const validateConfigForTesting = config => {
+    if ((config.locales?.length ?? 0) === 0) {
+        throw new Error("At least one locale must be specified in the config.");
+    }
     if (config.dataRootPath === undefined) {
         throw new Error("A data root path must be specified in the config.");
     }

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

@@ -14,8 +14,8 @@ export type ValidationOptions = {
         matchParametersInKeys?: boolean;
     };
 };
-export declare const validate: (schema: Schema, dataRootPath: string, options?: Partial<ValidationOptions>) => Promise<void>;
-export declare const generateAndValidate: (schema: Schema, outputs: Output[], dataRootPath: string, validationOptions?: Partial<ValidationOptions>) => Promise<void>;
-export declare const serve: (schema: Schema, dataRootPath: string, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[], serverOptions?: Partial<ServerOptions>, validationOptions?: Partial<ValidationOptions>, customStylesheetPath?: string) => Promise<void>;
-export declare const generateValidateAndServe: (schema: Schema, outputs: Output[], dataRootPath: string, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[], serverOptions?: Partial<ServerOptions>, validationOptions?: Partial<ValidationOptions>, customStylesheetPath?: string) => Promise<void>;
+export declare const validate: (schema: Schema, dataRootPath: string, locales: string[], options?: Partial<ValidationOptions>) => Promise<void>;
+export declare const generateAndValidate: (schema: Schema, outputs: Output[], dataRootPath: string, locales: string[], validationOptions?: Partial<ValidationOptions>) => Promise<void>;
+export declare const serve: (schema: Schema, dataRootPath: string, locales: string[], homeLayoutSections?: HomeLayoutSection[], serverOptions?: Partial<ServerOptions>, validationOptions?: Partial<ValidationOptions>, customStylesheetPath?: string) => Promise<void>;
+export declare const generateValidateAndServe: (schema: Schema, outputs: Output[], dataRootPath: string, locales: string[], homeLayoutSections?: HomeLayoutSection[], serverOptions?: Partial<ServerOptions>, validationOptions?: Partial<ValidationOptions>, customStylesheetPath?: string) => Promise<void>;
 export declare const format: (schema: Schema, dataRootPath: string) => Promise<void>;

package/dist/src/node/index.js

@@ -1,6 +1,7 @@
 import Debug from "debug";
 import { mkdir } from "fs/promises";
 import { join, sep } from "path";
+import { stderr } from "process";
 import { styleText } from "util";
 import { isError } from "../shared/utils/result.js";
 import { parallelizeErrors } from "../shared/utils/validation.js";
@@ -8,7 +9,9 @@ import { validateEntityDecl } from "./schema/declarations/EntityDecl.js";
 import { createValidationContext } from "./schema/Node.js";
 import { getEntities } from "./schema/Schema.js";
 import { createServer } from "./server/index.js";
-import { asyncForEachInstanceInDatabaseInMemory, createDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, } from "./utils/databaseInMemory.js";
+import { checkCustomConstraintsForAllEntities } from "./utils/customConstraints.js";
+import { asyncForEachInstanceInDatabaseInMemory, countInstancesInDatabaseInMemory, createDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, } from "./utils/databaseInMemory.js";
+import { getAllInstanceOverviewsByEntityName } from "./utils/displayName.js";
 import { countError, countErrors, getErrorMessageForDisplay, wrapErrorsIfAny, } from "./utils/error.js";
 import { getFileNameForId, writeInstance } from "./utils/files.js";
 import { checkUniqueConstraintsForAllEntities } from "./utils/unique.js";
@@ -25,7 +28,7 @@ export const generateOutputs = async (schema, outputs) => {
         await output.run(schema);
     }
 };
-const _validate = (dataRootPath, entities, databaseInMemory, options = {}) => {
+const _validate = (dataRootPath, entities, databaseInMemory, locales, options = {}) => {
     const { checkReferentialIntegrity = true, checkOnlyEntities = [] } = options;
     for (const onlyEntity of checkOnlyEntities) {
         if (!entities.find(entity => entity.name === onlyEntity)) {
@@ -48,45 +51,59 @@ const _validate = (dataRootPath, entities, databaseInMemory, options = {}) => {
     }
     if (errors.length === 0) {
         debug("Checking unique constraints ...");
-        const constraintResult = checkUniqueConstraintsForAllEntities(databaseInMemory, entities);
-        if (isError(constraintResult)) {
-            const errorCount = countError(constraintResult.error);
+        const entitiesByName = Object.fromEntries(entities.map(entity => [entity.name, entity]));
+        const instanceOverviewsByEntityName = getAllInstanceOverviewsByEntityName(entitiesByName, databaseInMemory, locales);
+        const uniqueConstraintResult = checkUniqueConstraintsForAllEntities(databaseInMemory, entitiesByName, instanceOverviewsByEntityName);
+        if (isError(uniqueConstraintResult)) {
+            const errorCount = countError(uniqueConstraintResult.error);
             debug(`${errorCount.toString()} unique constraint violation${errorCount === 1 ? "" : "s"} found`);
-            errors.push(constraintResult.error);
+            errors.push(uniqueConstraintResult.error);
         }
         else {
             debug("No unique constraint violations found");
         }
+        debug("Checking custom constraints ...");
+        const customConstraintResult = checkCustomConstraintsForAllEntities(databaseInMemory, entitiesByName, instanceOverviewsByEntityName);
+        if (isError(customConstraintResult)) {
+            const errorCount = countError(customConstraintResult.error);
+            debug(`${errorCount.toString()} custom constraint violation${errorCount === 1 ? "" : "s"} found`);
+            errors.push(customConstraintResult.error);
+        }
+        else {
+            debug("No custom constraint violations found");
+        }
     }
     else {
         debug("Skipping unique constraint checks due to previous structural integrity errors");
     }
+    const totalInstanceCount = countInstancesInDatabaseInMemory(databaseInMemory);
+    console.log(`${totalInstanceCount.toString()} instance${totalInstanceCount === 1 ? "" : "s"} checked`);
     if (errors.length === 0) {
-        console.log("All entities are valid");
+        console.log(styleText("green", "All instances are valid"));
         return true;
     }
     else {
         const errorCount = countErrors(errors);
-        console.error(`${errorCount.toString()} validation error${errorCount === 1 ? "" : "s"} found\n\n${errors.map(err => getErrorMessageForDisplay(err)).join("\n\n")}`);
+        console.error(styleText("red", `${errorCount.toString()} validation error${errorCount === 1 ? "" : "s"} found\n\n${errors.map(err => getErrorMessageForDisplay(err)).join("\n\n")}`, { stream: stderr }));
         process.exitCode = 1;
         return false;
     }
 };
-export const validate = async (schema, dataRootPath, options) => {
+export const validate = async (schema, dataRootPath, locales, options) => {
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
-    _validate(dataRootPath, entities, databaseInMemory, options);
+    _validate(dataRootPath, entities, databaseInMemory, locales, options);
 };
-export const generateAndValidate = async (schema, outputs, dataRootPath, validationOptions) => {
+export const generateAndValidate = async (schema, outputs, dataRootPath, locales, validationOptions) => {
     await generateOutputs(schema, outputs);
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
-    _validate(dataRootPath, entities, databaseInMemory, validationOptions);
+    _validate(dataRootPath, entities, databaseInMemory, locales, validationOptions);
 };
-export const serve = async (schema, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath) => {
-    if (defaultLocales.length === 0) {
+export const serve = async (schema, dataRootPath, locales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath) => {
+    if (locales.length === 0) {
         throw new Error("At least one default locale must be specified to start the server.");
     }
     const entities = getEntities(schema);
@@ -94,16 +111,16 @@ export const serve = async (schema, dataRootPath, defaultLocales, homeLayoutSect
     debug("prepared folders");
     const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
     debug("loaded instances");
-    await createServer(schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath);
+    await createServer(schema, dataRootPath, databaseInMemory, locales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath);
 };
-export const generateValidateAndServe = async (schema, outputs, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath) => {
+export const generateValidateAndServe = async (schema, outputs, dataRootPath, locales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath) => {
     await generateOutputs(schema, outputs);
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
-    const isValid = _validate(dataRootPath, entities, databaseInMemory, validationOptions);
+    const isValid = _validate(dataRootPath, entities, databaseInMemory, locales, validationOptions);
     if (isValid) {
-        await createServer(schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath);
+        await createServer(schema, dataRootPath, databaseInMemory, locales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath);
     }
     else {
         console.error("Not starting server due to invalid database");

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

@@ -6,3 +6,4 @@ export interface Schema {
 }
 export declare const Schema: (declarations: Decl[], localeEntity?: EntityDecl) => Schema;
 export declare const getEntities: (schema: Schema) => EntityDecl[];
+export type * from "./externalTypes.ts";

package/dist/src/node/schema/declarations/EntityDecl.d.ts

@@ -1,6 +1,7 @@
 import type { UniqueConstraints } from "../../../shared/schema/declarations/EntityDecl.ts";
 import { Lazy } from "../../../shared/utils/lazy.ts";
-import type { DisplayNameCustomizer } from "../../utils/displayName.ts";
+import type { CustomConstraint, TypedCustomConstraint } from "../../utils/customConstraints.ts";
+import type { DisplayNameCustomizer, TypedDisplayNameCustomizer } from "../../utils/displayName.ts";
 import type { GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
 import type { MemberDecl, ObjectType } from "../types/generic/ObjectType.ts";
@@ -35,9 +36,10 @@ export interface EntityDecl<Name extends string = string, T extends TConstraint
      * @default "name"
      */
     displayName?: GenericEntityDisplayName;
-    displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
+    displayNameCustomizer?: DisplayNameCustomizer;
     isDeprecated?: boolean;
     uniqueConstraints?: UniqueConstraints;
+    customConstraint?: CustomConstraint;
 }
 export interface EntityDeclWithParentReference<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> = Extract<keyof T, string>> extends EntityDecl<Name, T, FK> {
 }
@@ -51,9 +53,10 @@ export declare const EntityDecl: {
          * @default "name"
          */
         displayName?: EntityDisplayName<T>;
-        displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
+        displayNameCustomizer?: TypedDisplayNameCustomizer<Name>;
         isDeprecated?: boolean;
         uniqueConstraints?: UniqueConstraints;
+        customConstraint?: TypedCustomConstraint<Name>;
     }): EntityDecl<Name, T, undefined>;
     <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string>>(sourceUrl: string, options: {
         name: Name;
@@ -65,9 +68,10 @@ export declare const EntityDecl: {
          * @default "name"
          */
         displayName?: EntityDisplayName<T>;
-        displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
+        displayNameCustomizer?: TypedDisplayNameCustomizer<Name>;
         isDeprecated?: boolean;
         uniqueConstraints?: UniqueConstraints;
+        customConstraint?: TypedCustomConstraint<Name>;
     }): EntityDecl<Name, T, FK>;
 };
 export { EntityDecl as Entity };

package/dist/src/node/schema/declarations/EntityDecl.js

@@ -8,6 +8,8 @@ export const EntityDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
     return {
         ...options,
+        displayNameCustomizer: options.displayNameCustomizer, // ignore contravariance of registered entity type
+        customConstraint: options.customConstraint, // ignore contravariance of registered entity type
         kind: NodeKind.EntityDecl,
         sourceUrl,
         parameters: [],

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

@@ -0,0 +1,20 @@
+import type { InstanceContent } from "../../shared/utils/instances.ts";
+export interface Register {
+}
+export type AnyEntityMap = Record<string, InstanceContent>;
+export type RegisteredEntityMap<T = Register> = T extends {
+    entityMap: AnyEntityMap;
+} ? T["entityMap"] : AnyEntityMap;
+export type RegisteredEntity<Name extends string, T = Register> = T extends {
+    entityMap: {
+        [K in Name]: InstanceContent;
+    };
+} ? T["entityMap"][Name] : InstanceContent;
+export type AnyChildEntityMap = Record<string, [
+    content: InstanceContent,
+    parentKey: string,
+    parentValue: string | object
+]>;
+export type RegisteredChildEntityMap<T = Register> = T extends {
+    childEntityMap: AnyChildEntityMap;
+} ? T["childEntityMap"] : AnyChildEntityMap;

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

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

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

@@ -0,0 +1,4 @@
+import type { RegisteredChildEntityMap, RegisteredEntityMap } from "./externalTypes.ts";
+export type GetInstanceById = <U extends keyof RegisteredEntityMap>(entity: U, id: string) => RegisteredEntityMap[U] | undefined;
+export type GetAllInstances = <U extends keyof RegisteredEntityMap>(entity: U) => RegisteredEntityMap[U][];
+export type GetAllChildInstancesForParent = <U extends keyof RegisteredChildEntityMap>(entity: U, parentId: RegisteredChildEntityMap[U][2]) => RegisteredChildEntityMap[U][0][];

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

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

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

@@ -2,6 +2,7 @@ export * from "./declarations/Declaration.ts";
 export * from "./declarations/EntityDecl.ts";
 export * from "./declarations/EnumDecl.ts";
 export * from "./declarations/TypeAliasDecl.ts";
+export type * from "./helpers.ts";
 export * from "./Node.ts";
 export * from "./TypeParameter.ts";
 export * from "./types/generic/ArrayType.ts";

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

@@ -28,7 +28,7 @@ export declare const NestedEntityMapType: <Name extends string, T extends TConst
      * @default "name"
      */
     displayName?: EntityDisplayName<T>;
-    displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
+    displayNameCustomizer?: DisplayNameCustomizer;
     isDeprecated?: boolean;
 }) => NestedEntityMapType<Name, T>;
 export { NestedEntityMapType as NestedEntityMap };

package/dist/src/node/server/api/declarations.js

@@ -7,7 +7,7 @@ import { isEnumDecl } from "../../schema/declarations/EnumDecl.js";
 import { isTypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { serializeNode } from "../../schema/index.js";
 import { getChildInstances } from "../../utils/childInstances.js";
-import { countInstancesOfEntityInDatabaseInMemory, getInstanceOfEntityFromDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, } from "../../utils/databaseInMemory.js";
+import { countInstancesOfEntityInDatabaseInMemory, createInstanceFromDatabaseInMemoryGetter, getInstanceOfEntityFromDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, } from "../../utils/databaseInMemory.js";
 import { HTTPError } from "../../utils/error.js";
 import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
 import { createInstance, deleteInstance, updateInstance } from "../utils/instanceOperations.js";
@@ -64,10 +64,11 @@ declarationsApi.get("/:name/instances", (req, res) => {
         res.status(400).send(`Declaration "${decl.name}" is not an entity`);
         return;
     }
-    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
+    const getInstanceById = createInstanceFromDatabaseInMemoryGetter(req.databaseInMemory, req.entitiesByName);
+    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req.entitiesByName, req.databaseInMemory);
     const body = {
         instances: getInstancesOfEntityFromDatabaseInMemory(req.databaseInMemory, decl.name)
-            .map(instanceContainer => getInstanceContainerOverview(decl, instanceContainer, req.getInstanceById, getChildInstancesForInstanceId, req.locales))
+            .map(instanceContainer => getInstanceContainerOverview(decl, instanceContainer, getInstanceById, getChildInstancesForInstanceId, req.locales))
             .toSorted((a, b) => a.displayName.localeCompare(b.displayName, undefined, { numeric: true })),
         isLocaleEntity: decl === req.localeEntity,
     };

package/dist/src/node/server/api/git.js

@@ -3,7 +3,7 @@ import express, {} from "express";
 import { join } from "node:path";
 import { hasFileChanges, splitBranchName } from "../../../shared/utils/git.js";
 import { getInstanceContainerOverview } from "../../../shared/utils/instances.js";
-import { getGroupedInstancesFromDatabaseInMemory } from "../../utils/databaseInMemory.js";
+import { createInstanceFromDatabaseInMemoryGetter, getGroupedInstancesFromDatabaseInMemory, } from "../../utils/databaseInMemory.js";
 import { attachGitStatusToDatabaseInMemory } from "../../utils/git.js";
 import { reinit } from "../init.js";
 import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
@@ -28,7 +28,8 @@ gitApi.get("/status", async (req, res) => {
     req.setLocal("databaseInMemory", attachGitStatusToDatabaseInMemory(req.databaseInMemory, req.dataRoot, 
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     req.gitRoot, status));
-    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
+    const getInstanceById = createInstanceFromDatabaseInMemoryGetter(req.databaseInMemory, req.entitiesByName);
+    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req.entitiesByName, req.databaseInMemory);
     const body = {
         currentBranch: status.current,
         trackingBranch: status.tracking,
@@ -40,7 +41,7 @@ gitApi.get("/status", async (req, res) => {
                 .filter(instance => hasFileChanges(instance.gitStatus))
                 .map(instance => getInstanceContainerOverview(
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            req.entitiesByName[entityName], instance, req.getInstanceById, getChildInstancesForInstanceId, req.locales)),
+            req.entitiesByName[entityName], instance, getInstanceById, getChildInstancesForInstanceId, req.locales)),
         ])),
         latestCommit: await req.git.revparse(["HEAD"]),
     };

package/dist/src/node/server/api/instances.js

@@ -1,8 +1,6 @@
 import Debug from "debug";
 import express from "express";
-import { getGroupedInstancesFromDatabaseInMemory } from "../../utils/databaseInMemory.js";
-import { getDisplayNameFromEntityInstance } from "../../utils/displayName.js";
-import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
+import { getAllInstanceOverviewsByEntityName } from "../../utils/displayName.js";
 const debug = Debug("tsondb:server:api:instances");
 export const instancesApi = express.Router();
 instancesApi.use((req, _res, next) => {
@@ -10,23 +8,8 @@ instancesApi.use((req, _res, next) => {
     next();
 });
 instancesApi.get("/", (req, res) => {
-    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
     const body = {
-        instances: Object.fromEntries(getGroupedInstancesFromDatabaseInMemory(req.databaseInMemory).map(([entityName, instances]) => [
-            entityName,
-            instances
-                .map(instance => {
-                const { name, localeId } = getDisplayNameFromEntityInstance(
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                req.entitiesByName[entityName], instance, req.getInstanceById, getChildInstancesForInstanceId, req.locales);
-                return {
-                    id: instance.id,
-                    name,
-                    displayNameLocaleId: localeId,
-                };
-            })
-                .toSorted((a, b) => a.name.localeCompare(b.name, a.displayNameLocaleId)),
-        ])),
+        instances: getAllInstanceOverviewsByEntityName(req.entitiesByName, req.databaseInMemory, req.locales),
     };
     res.json(body);
 });

package/dist/src/node/server/api/search.js

@@ -1,7 +1,7 @@
 import Debug from "debug";
 import express from "express";
 import { isEntityDeclWithParentReference } from "../../schema/index.js";
-import { getGroupedInstancesFromDatabaseInMemory } from "../../utils/databaseInMemory.js";
+import { createInstanceFromDatabaseInMemoryGetter, getGroupedInstancesFromDatabaseInMemory, } from "../../utils/databaseInMemory.js";
 import { getDisplayNameFromEntityInstance } from "../../utils/displayName.js";
 import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
 import { getQueryParamString } from "../utils/query.js";
@@ -10,7 +10,8 @@ export const searchApi = express.Router();
 searchApi.get("/", (req, res) => {
     const query = getQueryParamString(req.query, "q")?.toLowerCase() ?? "";
     debug('search for items containing "%s"', query);
-    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
+    const getInstanceById = createInstanceFromDatabaseInMemoryGetter(req.databaseInMemory, req.entitiesByName);
+    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req.entitiesByName, req.databaseInMemory);
     const body = {
         query,
         results: query.length === 0
@@ -25,7 +26,7 @@ searchApi.get("/", (req, res) => {
                     .map((instance) => {
                     const { name, localeId } = getDisplayNameFromEntityInstance(
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    req.entitiesByName[entityName], instance, req.getInstanceById, getChildInstancesForInstanceId, req.locales);
+                    req.entitiesByName[entityName], instance, getInstanceById, getChildInstancesForInstanceId, req.locales);
                     const searchableName = name.toLowerCase();
                     return [
                         entityName,

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

@@ -1,6 +1,5 @@
 import type { SimpleGit } from "simple-git";
 import type { SerializedDecl } from "../../shared/schema/declarations/Declaration.ts";
-import type { InstanceContainer } from "../../shared/utils/instances.ts";
 import type { HomeLayoutSection } from "../config.ts";
 import type { ValidationOptions } from "../index.ts";
 import type { Decl } from "../schema/declarations/Declaration.ts";
@@ -26,13 +25,8 @@ export interface TSONDBRequestLocals {
     locales: string[];
     homeLayoutSections?: HomeLayoutSection[];
     validationOptions: Partial<ValidationOptions>;
-    getInstanceById: GetInstanceById;
     setLocal: <K extends keyof Omit<TSONDBRequestLocals, "setLocal">>(key: K, value: TSONDBRequestLocals[K]) => void;
 }
-export type GetInstanceById = (id: string) => {
-    entity: EntityDecl;
-    instance: InstanceContainer;
-} | undefined;
 declare global {
     namespace Express {
         interface Request extends TSONDBRequestLocals {

package/dist/src/node/server/init.js

@@ -2,7 +2,7 @@ import Debug from "debug";
 import { simpleGit } from "simple-git";
 import { isEntityDecl } from "../schema/declarations/EntityDecl.js";
 import { resolveTypeArgumentsInDecls, serializeNode } from "../schema/index.js";
-import { createDatabaseInMemory, getInstanceFromDatabaseInMemory, } from "../utils/databaseInMemory.js";
+import { createDatabaseInMemory } from "../utils/databaseInMemory.js";
 import { attachGitStatusToDatabaseInMemory } from "../utils/git.js";
 import { getReferencesToInstances } from "../utils/references.js";
 const debug = Debug("tsondb:server:init");
@@ -36,16 +36,6 @@ export const init = async (schema, dataRootPath, databaseInMemory, defaultLocale
         databaseInMemory = attachGitStatusToDatabaseInMemory(databaseInMemory, dataRootPath, gitRoot, gitStatus);
         debug("retrieved git status to instances");
     }
-    const getInstanceById = id => {
-        const res = getInstanceFromDatabaseInMemory(requestLocals.databaseInMemory, id);
-        if (res) {
-            const [entityName, instance] = res;
-            if (requestLocals.entitiesByName[entityName]) {
-                return { entity: requestLocals.entitiesByName[entityName], instance };
-            }
-        }
-        return undefined;
-    };
     const requestLocals = {
         git: git,
         gitRoot: gitRoot,
@@ -56,7 +46,6 @@ export const init = async (schema, dataRootPath, databaseInMemory, defaultLocale
         entitiesByName: entitiesByName,
         serializedDeclarationsByName,
         localeEntity: schema.localeEntity,
-        getInstanceById,
         referencesToInstances,
         defaultLocales,
         locales: defaultLocales,

package/dist/src/node/server/utils/childInstances.d.ts

@@ -1,3 +1,4 @@
+import { type EntityDecl } from "../../schema/index.ts";
+import type { DatabaseInMemory } from "../../utils/databaseInMemory.ts";
 import type { GetChildInstancesForInstanceId } from "../../utils/displayName.ts";
-import type { TSONDBRequestLocals } from "../index.ts";
-export declare const createChildInstancesForInstanceIdGetter: (locals: TSONDBRequestLocals) => GetChildInstancesForInstanceId;
+export declare const createChildInstancesForInstanceIdGetter: (entitiesByName: Record<string, EntityDecl>, databaseInMemory: DatabaseInMemory) => GetChildInstancesForInstanceId;

package/dist/src/node/server/utils/childInstances.js

@@ -1,12 +1,12 @@
 import { isEntityDeclWithParentReference } from "../../schema/index.js";
 import { getChildInstancesFromEntity } from "../../utils/childInstances.js";
-export const createChildInstancesForInstanceIdGetter = (locals) => (parentEntityName, parentId, childEntityName) => {
-    const parentEntity = locals.entitiesByName[parentEntityName];
-    const childEntity = locals.entitiesByName[childEntityName];
+export const createChildInstancesForInstanceIdGetter = (entitiesByName, databaseInMemory) => (parentEntityName, parentId, childEntityName) => {
+    const parentEntity = entitiesByName[parentEntityName];
+    const childEntity = entitiesByName[childEntityName];
     if (parentEntity === undefined ||
         childEntity === undefined ||
         !isEntityDeclWithParentReference(childEntity)) {
         return [];
     }
-    return getChildInstancesFromEntity(locals.databaseInMemory, parentEntity, parentId, childEntity);
+    return getChildInstancesFromEntity(databaseInMemory, parentEntity, parentId, childEntity);
 };

package/dist/src/node/server/utils/instanceOperations.js

@@ -8,7 +8,7 @@ export const createInstance = async (locals, instance, idQueryParam) => {
     if (entity === undefined) {
         return error(new HTTPError(400, "Entity not found"));
     }
-    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.validationOptions, locals.entitiesByName, undefined, undefined, locals.localeEntity, instance.entityName, undefined, instance, idQueryParam, res));
+    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, locals.locales, res => saveInstanceTree(locals.validationOptions, locals.entitiesByName, undefined, undefined, locals.localeEntity, instance.entityName, undefined, instance, idQueryParam, res));
     if (isError(databaseTransactionResult)) {
         return databaseTransactionResult;
     }
@@ -27,7 +27,7 @@ export const updateInstance = async (locals, instance) => {
         return error(new HTTPError(400, "Entity not found"));
     }
     const oldChildInstances = getChildInstances(locals.databaseInMemory, entity, instance.id, true);
-    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.validationOptions, locals.entitiesByName, undefined, undefined, locals.localeEntity, instance.entityName, {
+    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, locals.locales, res => saveInstanceTree(locals.validationOptions, locals.entitiesByName, undefined, undefined, locals.localeEntity, instance.entityName, {
         id: instance.id,
         content: instanceContainer.content,
         childInstances: oldChildInstances,
@@ -51,7 +51,7 @@ export const deleteInstance = async (locals, entityName, instanceId) => {
         return error(new HTTPError(400, "Entity not found"));
     }
     const oldChildInstances = getChildInstances(locals.databaseInMemory, entity, instanceId, true);
-    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, res => saveInstanceTree(locals.validationOptions, locals.entitiesByName, undefined, undefined, locals.localeEntity, entityName, {
+    const databaseTransactionResult = await runDatabaseTransaction(locals.dataRoot, locals.gitRoot ? locals.git : undefined, locals.entitiesByName, locals.databaseInMemory, locals.referencesToInstances, locals.locales, res => saveInstanceTree(locals.validationOptions, locals.entitiesByName, undefined, undefined, locals.localeEntity, entityName, {
         id: instanceId,
         content: instanceContainer.content,
         childInstances: oldChildInstances,

package/dist/src/node/utils/customConstraints.d.ts

@@ -0,0 +1,46 @@
+import type { InstanceContainerOverview, InstanceContent } from "../../shared/utils/instances.ts";
+import { type Result } from "../../shared/utils/result.ts";
+import type { RegisteredEntity } from "../schema/externalTypes.ts";
+import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../schema/helpers.ts";
+import type { EntityDecl } from "../schema/index.ts";
+import { type DatabaseInMemory } from "./databaseInMemory.ts";
+/**
+ * A constraint that can be defined on an entity to enforce custom validation logic.
+ *
+ * The constraint function receives the instance to validate and helper functions
+ * to retrieve other instances from the database.
+ *
+ * It should return an array of strings describing the parts of the constraint
+ * that were violated. If the array is empty, the instance is considered valid.
+ */
+export type CustomConstraint = (params: {
+    instanceId: string;
+    instanceContent: InstanceContent;
+    getInstanceById: GetInstanceById;
+    getAllInstance: GetAllInstances;
+    getAllChildInstancesForParent: GetAllChildInstancesForParent;
+}) => string[];
+/**
+ * A constraint that can be defined on an entity to enforce custom validation logic.
+ *
+ * The constraint function receives the instance to validate and helper functions
+ * to retrieve other instances from the database.
+ *
+ * It should return an array of strings describing the parts of the constraint
+ * that were violated. If the array is empty, the instance is considered valid.
+ */
+export type TypedCustomConstraint<Name extends string> = (params: {
+    instanceId: string;
+    instanceContent: RegisteredEntity<Name>;
+    getInstanceById: GetInstanceById;
+    getAllInstance: GetAllInstances;
+    getAllChildInstancesForParent: GetAllChildInstancesForParent;
+}) => string[];
+/**
+ * Checks all custom constraints for all provided entities and their instances.
+ *
+ * Returns `Ok` when no violations have been found and an `Error` with a list of
+ * `AggregateError`s for each entity if there are any violations of any custom
+ * constraint.
+ */
+export declare const checkCustomConstraintsForAllEntities: (db: DatabaseInMemory, entitiesByName: Record<string, EntityDecl>, instanceOverviewsByEntityName: Record<string, InstanceContainerOverview[]>) => Result<void, AggregateError>;

package/dist/src/node/utils/customConstraints.js

@@ -0,0 +1,58 @@
+import { deepEqual } from "../../shared/utils/compare.js";
+import { error, isError, mapError, ok } from "../../shared/utils/result.js";
+import { getInstanceOfEntityFromDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, } from "./databaseInMemory.js";
+/**
+ * Checks all custom constraints for all provided entities and their instances.
+ *
+ * Returns `Ok` when no violations have been found and an `Error` with a list of
+ * `AggregateError`s for each entity if there are any violations of any custom
+ * constraint.
+ */
+export const checkCustomConstraintsForAllEntities = (db, entitiesByName, instanceOverviewsByEntityName) => {
+    const accessors = {
+        getInstanceById: (entityName, id) => getInstanceOfEntityFromDatabaseInMemory(db, entityName, id),
+        getAllInstance: entityName => getInstancesOfEntityFromDatabaseInMemory(db, entityName),
+        getAllChildInstancesForParent: (entityName, parentId) => {
+            const entity = entitiesByName[entityName];
+            if (!entity || !entity.parentReferenceKey) {
+                return [];
+            }
+            const parentKey = entity.parentReferenceKey;
+            return getInstancesOfEntityFromDatabaseInMemory(db, entityName).filter(instance => deepEqual(instance.content[parentKey], parentId));
+        },
+    };
+    return mapError(Object.values(entitiesByName).reduce((acc, entity) => {
+        const constraintFn = entity.customConstraint;
+        if (!constraintFn) {
+            return acc;
+        }
+        const errors = getInstancesOfEntityFromDatabaseInMemory(db, entity.name)
+            .map((instance) => [
+            instance,
+            constraintFn({
+                ...accessors,
+                instanceId: instance.id,
+                instanceContent: instance.content,
+            }),
+        ])
+            .filter(([, violations]) => violations.length > 0)
+            .map(([instance, violations]) => {
+            const instanceOverview = instanceOverviewsByEntityName[entity.name]?.find(o => o.id === instance.id);
+            const name = instanceOverview
+                ? `"${instanceOverview.displayName}" (${instance.id})`
+                : instance.id;
+            return new AggregateError(violations.map(violation => new Error(violation)), `in instance ${name}`);
+        });
+        const aggregate = errors.length > 0 ? new AggregateError(errors, `in entity "${entity.name}"`) : undefined;
+        if (isError(acc)) {
+            if (aggregate) {
+                return error([...acc.error, aggregate]);
+            }
+            return acc;
+        }
+        if (aggregate) {
+            return error([aggregate]);
+        }
+        return acc;
+    }, ok()), errors => new AggregateError(errors.toSorted((a, b) => a.message.localeCompare(b.message)), "at least one custom constraint has been violated"));
+};

package/dist/src/node/utils/databaseInMemory.d.ts

@@ -4,7 +4,15 @@ import type { EntityDecl } from "../schema/index.ts";
 export type DatabaseInMemory = Dictionary<InstancesInMemory>;
 export type InstancesInMemory = Dictionary<InstanceContainer>;
 export declare const emptyDatabaseInMemory: DatabaseInMemory;
-export declare const getInstanceFromDatabaseInMemory: (db: DatabaseInMemory, instanceId: string) => [entityName: string, InstanceContainer] | undefined;
+export declare const getInstanceFromDatabaseInMemory: (db: DatabaseInMemory, instanceId: string) => {
+    entityName: string;
+    instance: InstanceContainer;
+} | undefined;
+export type InstanceFromDatabaseInMemoryGetter = (instanceId: string) => {
+    entity: EntityDecl;
+    instance: InstanceContainer;
+} | undefined;
+export declare const createInstanceFromDatabaseInMemoryGetter: (db: DatabaseInMemory, entitiesByName: Record<string, EntityDecl>) => InstanceFromDatabaseInMemoryGetter;
 export declare const getInstanceOfEntityFromDatabaseInMemory: (db: DatabaseInMemory, entityName: string, instanceId: string) => InstanceContainer | undefined;
 export declare const getInstancesOfEntityFromDatabaseInMemory: (db: DatabaseInMemory, entityName: string) => InstanceContainer[];
 export declare const getGroupedInstancesFromDatabaseInMemory: (db: DatabaseInMemory) => [entityName: string, InstanceContainer[]][];
@@ -12,6 +20,7 @@ export declare const forEachInstanceOfEntityInDatabaseInMemory: (db: DatabaseInM
 export declare const asyncForEachInstanceOfEntityInDatabaseInMemory: (db: DatabaseInMemory, entityName: string, fn: (instance: InstanceContainer) => Promise<void>) => Promise<void>;
 export declare const forEachInstanceInDatabaseInMemory: (db: DatabaseInMemory, fn: (entityName: string, instance: InstanceContainer) => void) => void;
 export declare const asyncForEachInstanceInDatabaseInMemory: (db: DatabaseInMemory, fn: (entityName: string, instance: InstanceContainer) => Promise<void>) => Promise<void>;
+export declare const countInstancesInDatabaseInMemory: (db: DatabaseInMemory) => number;
 export declare const countInstancesOfEntityInDatabaseInMemory: (db: DatabaseInMemory, entityName: string) => number;
 export declare const createDatabaseInMemory: (dataRoot: string, entities: readonly EntityDecl[]) => Promise<DatabaseInMemory>;
 export declare const setInstanceInDatabaseInMemory: (db: DatabaseInMemory, entityName: string, instance: InstanceContainer) => [DatabaseInMemory, oldInstance: InstanceContent | undefined];

package/dist/src/node/utils/databaseInMemory.js

@@ -4,15 +4,26 @@ import { basename, extname, join } from "node:path";
 import { platform } from "node:process";
 import { promisify } from "node:util";
 import { mapAsync } from "../../shared/utils/async.js";
-import { emptyD, forEachAsyncD, forEachD, fromEntriesD, getD, getMapD, hasD, mapFirstD, removeD, setD, sizeD, toEntriesD, toValuesD, } from "../../shared/utils/dictionary.js";
+import { emptyD, forEachAsyncD, forEachD, fromEntriesD, getD, getMapD, hasD, mapFirstD, reduceD, removeD, setD, sizeD, toEntriesD, toValuesD, } from "../../shared/utils/dictionary.js";
 export const emptyDatabaseInMemory = emptyD;
 export const getInstanceFromDatabaseInMemory = (db, instanceId) => mapFirstD(db, (instances, entityName) => {
     const instance = getD(instances, instanceId);
     if (instance) {
-        return [entityName, instance];
+        return { entityName, instance };
     }
     return undefined;
 });
+export const createInstanceFromDatabaseInMemoryGetter = (db, entitiesByName) => instanceId => {
+    const res = getInstanceFromDatabaseInMemory(db, instanceId);
+    if (res) {
+        const { entityName, instance } = res;
+        const entity = entitiesByName[entityName];
+        if (entity) {
+            return { entity, instance };
+        }
+    }
+    return undefined;
+};
 export const getInstanceOfEntityFromDatabaseInMemory = (db, entityName, instanceId) => getMapD(db, entityName, instances => getD(instances, instanceId));
 export const getInstancesOfEntityFromDatabaseInMemory = (db, entityName) => getMapD(db, entityName, toValuesD) ?? [];
 export const getGroupedInstancesFromDatabaseInMemory = (db) => toEntriesD(db).map(([entityName, instances]) => [entityName, Object.values(instances[0])]);
@@ -34,6 +45,7 @@ export const forEachInstanceInDatabaseInMemory = (db, fn) => {
     });
 };
 export const asyncForEachInstanceInDatabaseInMemory = async (db, fn) => forEachAsyncD(db, (instances, entityName) => forEachAsyncD(instances, instance => fn(entityName, instance)));
+export const countInstancesInDatabaseInMemory = (db) => reduceD(db, (sum, instances) => sum + sizeD(instances), 0);
 export const countInstancesOfEntityInDatabaseInMemory = (db, entityName) => getMapD(db, entityName, sizeD) ?? 0;
 const exec = promisify(child_process.exec);
 const ulimit = platform === "win32" ? 2048 : Number.parseInt((await exec("ulimit -n")).stdout);

package/dist/src/node/utils/databaseTransactions.d.ts

@@ -25,7 +25,7 @@ export type TransactionResult<A extends object = object> = Result<{
 /**
  * Run a transaction on the database in memory, applying all changes to disk if successful.
  */
-export declare const runDatabaseTransaction: (root: string, git: SimpleGit | undefined, entitiesByName: Record<string, EntityDecl>, database: DatabaseInMemory, references: ReferencesToInstances, transactionFn: (db: TransactionResult) => TransactionResult<{
+export declare const runDatabaseTransaction: (root: string, git: SimpleGit | undefined, entitiesByName: Record<string, EntityDecl>, database: DatabaseInMemory, references: ReferencesToInstances, locales: string[], transactionFn: (db: TransactionResult) => TransactionResult<{
     instanceContainer: InstanceContainer;
 }>) => Promise<Result<{
     db: DatabaseInMemory;

package/dist/src/node/utils/databaseTransactions.js

@@ -1,13 +1,15 @@
 import { isError, map, ok } from "../../shared/utils/result.js";
+import { checkCustomConstraintsForAllEntities } from "./customConstraints.js";
 import { deleteInstanceInDatabaseInMemory, setInstanceInDatabaseInMemory, } from "./databaseInMemory.js";
 import { applyStepsToDisk } from "./databaseOnDisk.js";
+import { getAllInstanceOverviewsByEntityName } from "./displayName.js";
 import { attachGitStatusToDatabaseInMemory } from "./git.js";
 import { updateReferencesToInstances } from "./references.js";
 import { checkUniqueConstraintsForAllEntities } from "./unique.js";
 /**
  * Run a transaction on the database in memory, applying all changes to disk if successful.
  */
-export const runDatabaseTransaction = async (root, git, entitiesByName, database, references, transactionFn) => {
+export const runDatabaseTransaction = async (root, git, entitiesByName, database, references, locales, transactionFn) => {
     const result = transactionFn(ok({
         db: database,
         entitiesByName,
@@ -18,9 +20,14 @@ export const runDatabaseTransaction = async (root, git, entitiesByName, database
         return result;
     }
     const { db: newDb, refs: newRefs, steps, instanceContainer } = result.value;
-    const constraintResult = checkUniqueConstraintsForAllEntities(newDb, Object.values(entitiesByName));
-    if (isError(constraintResult)) {
-        return constraintResult;
+    const instanceOverviewsByEntityName = getAllInstanceOverviewsByEntityName(entitiesByName, newDb, locales);
+    const uniqueConstraintResult = checkUniqueConstraintsForAllEntities(newDb, entitiesByName, instanceOverviewsByEntityName);
+    if (isError(uniqueConstraintResult)) {
+        return uniqueConstraintResult;
+    }
+    const customConstraintResult = checkCustomConstraintsForAllEntities(newDb, entitiesByName, instanceOverviewsByEntityName);
+    if (isError(customConstraintResult)) {
+        return customConstraintResult;
     }
     const diskResult = await applyStepsToDisk(root, steps);
     if (isError(diskResult)) {

package/dist/src/node/utils/displayName.d.ts

@@ -1,14 +1,14 @@
-import type { GetInstanceById } from "../../node/server/index.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 EntityDecl } from "../schema/declarations/EntityDecl.ts";
-import type { AsDeepType, Type } from "../schema/types/Type.ts";
+import type { RegisteredEntity } from "../schema/externalTypes.ts";
+import { type DatabaseInMemory, type InstanceFromDatabaseInMemoryGetter } from "./databaseInMemory.ts";
 export type GetChildInstancesForInstanceId = (parentEntityName: string, parentId: string, childEntityName: string) => {
     id: string;
     content: InstanceContent;
 }[];
-export type DisplayNameCustomizer<T extends Type> = (params: {
-    instance: AsDeepType<T>;
+export type DisplayNameCustomizer = (params: {
+    instance: unknown;
     instanceId: string;
     instanceDisplayName: string;
     instanceDisplayNameLocaleId: string | undefined;
@@ -17,4 +17,15 @@ export type DisplayNameCustomizer<T extends Type> = (params: {
     getDisplayNameForInstanceId: (id: string) => DisplayNameResult | undefined;
     getChildInstancesForInstanceId: GetChildInstancesForInstanceId;
 }) => DisplayNameResult;
-export declare const getDisplayNameFromEntityInstance: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: GetInstanceById, getChildInstancesForInstanceId: GetChildInstancesForInstanceId, locales: string[], defaultName?: string, useCustomizer?: boolean) => DisplayNameResult;
+export type TypedDisplayNameCustomizer<Name extends string> = (params: {
+    instance: RegisteredEntity<Name>;
+    instanceId: string;
+    instanceDisplayName: string;
+    instanceDisplayNameLocaleId: string | undefined;
+    locales: string[];
+    getInstanceById: (id: string) => InstanceContent | undefined;
+    getDisplayNameForInstanceId: (id: string) => DisplayNameResult | undefined;
+    getChildInstancesForInstanceId: GetChildInstancesForInstanceId;
+}) => DisplayNameResult;
+export declare const getDisplayNameFromEntityInstance: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: InstanceFromDatabaseInMemoryGetter, getChildInstancesForInstanceId: GetChildInstancesForInstanceId, locales: string[], defaultName?: string, useCustomizer?: boolean) => DisplayNameResult;
+export declare const getAllInstanceOverviewsByEntityName: (entitiesByName: Record<string, EntityDecl>, databaseInMemory: DatabaseInMemory, locales: string[]) => Record<string, InstanceContainerOverview[]>;

package/dist/src/node/utils/displayName.js

@@ -1,10 +1,11 @@
 import { getSerializedDisplayNameFromEntityInstance, } from "../../shared/utils/displayName.js";
 import { serializeEntityDecl } from "../schema/declarations/EntityDecl.js";
+import { createChildInstancesForInstanceIdGetter } from "../server/utils/childInstances.js";
+import { createInstanceFromDatabaseInMemoryGetter, getGroupedInstancesFromDatabaseInMemory, } from "./databaseInMemory.js";
 export const getDisplayNameFromEntityInstance = (entity, instanceContainer, getInstanceById, getChildInstancesForInstanceId, locales, defaultName = "", useCustomizer = true) => {
     if (useCustomizer && entity.displayNameCustomizer) {
         const calculatedName = getDisplayNameFromEntityInstance(entity, instanceContainer, getInstanceById, getChildInstancesForInstanceId, locales, defaultName, false);
         return entity.displayNameCustomizer({
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment -- otherwise type instiatiation too deep
             instance: instanceContainer.content,
             instanceId: instanceContainer.id,
             instanceDisplayName: calculatedName.name,
@@ -28,3 +29,23 @@ export const getDisplayNameFromEntityInstance = (entity, instanceContainer, getI
         return getSerializedDisplayNameFromEntityInstance(serializeEntityDecl(entity), instanceContainer.content, defaultName, locales);
     }
 };
+export const getAllInstanceOverviewsByEntityName = (entitiesByName, databaseInMemory, locales) => {
+    const getInstanceById = createInstanceFromDatabaseInMemoryGetter(databaseInMemory, entitiesByName);
+    const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(entitiesByName, databaseInMemory);
+    return Object.fromEntries(getGroupedInstancesFromDatabaseInMemory(databaseInMemory).map(([entityName, instances]) => [
+        entityName,
+        instances
+            .map((instance) => {
+            const { name, localeId } = getDisplayNameFromEntityInstance(
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            entitiesByName[entityName], instance, getInstanceById, getChildInstancesForInstanceId, locales);
+            return {
+                id: instance.id,
+                displayName: name,
+                displayNameLocaleId: localeId,
+                gitStatus: instance.gitStatus,
+            };
+        })
+            .toSorted((a, b) => a.displayName.localeCompare(b.displayName, a.displayNameLocaleId)),
+    ]));
+};

package/dist/src/node/utils/error.d.ts

@@ -1,4 +1,4 @@
-export declare const getErrorMessageForDisplay: (error: Error) => string;
+export declare const getErrorMessageForDisplay: (error: Error, indentation?: number) => string;
 export declare const countError: (error: Error) => number;
 export declare const countErrors: (errors: Error[]) => number;
 export declare const wrapErrorsIfAny: (message: string, errors: Error[]) => AggregateError | undefined;

package/dist/src/node/utils/error.js

@@ -1,13 +1,17 @@
 import { applyIndentation } from "./render.js";
-export const getErrorMessageForDisplay = (error) => {
+import { UniqueConstraintError } from "./unique.js";
+export const getErrorMessageForDisplay = (error, indentation = 2) => {
     if (error instanceof AggregateError) {
         return `${error.message}\n${applyIndentation(1, error.errors
             .filter(subError => subError instanceof Error)
-            .map(subError => getErrorMessageForDisplay(subError))
-            .join("\n"), 2)}`;
+            .map(subError => getErrorMessageForDisplay(subError, indentation))
+            .join("\n"), indentation)}`;
     }
     else if (error.cause instanceof Error) {
-        return `${error.message}\n${applyIndentation(1, getErrorMessageForDisplay(error.cause), 2)}`;
+        return `${error.message}\n${applyIndentation(1, getErrorMessageForDisplay(error.cause, indentation), indentation)}`;
+    }
+    else if (error instanceof UniqueConstraintError) {
+        return `${error.message}\n${applyIndentation(1, error.parts.join("\n"), indentation)}`;
     }
     else {
         return error.message;

package/dist/src/node/utils/unique.d.ts

@@ -1,14 +1,18 @@
-import type { InstanceContainer } from "../../shared/utils/instances.ts";
+import type { InstanceContainer, InstanceContainerOverview } from "../../shared/utils/instances.ts";
 import { type Result } from "../../shared/utils/result.ts";
 import type { EntityDecl } from "../schema/index.ts";
 import { type DatabaseInMemory } from "./databaseInMemory.ts";
+export declare class UniqueConstraintError extends Error {
+    readonly parts: string[];
+    constructor(message: string, parts: string[]);
+}
 /**
  * Checks all unique constraints for the provided entity and its instances.
  *
  * Returns `Ok` when no violations have been found and an `Error` with an
  * `AggregateError` if there are any violations of any unique constraint.
  */
-export declare const checkUniqueConstraintsForEntity: (entity: EntityDecl, instances: InstanceContainer[]) => Result<void, AggregateError>;
+export declare const checkUniqueConstraintsForEntity: (entity: EntityDecl, instances: InstanceContainer[], instanceOverviews: InstanceContainerOverview[]) => Result<void, AggregateError>;
 /**
  * Checks all unique constraints for all provided entities and their instances.
  *
@@ -16,4 +20,4 @@ export declare const checkUniqueConstraintsForEntity: (entity: EntityDecl, insta
  * `AggregateError`s for each entity if there are any violations of any unique
  * constraint.
  */
-export declare const checkUniqueConstraintsForAllEntities: (db: DatabaseInMemory, entities: EntityDecl[]) => Result<void, AggregateError>;
+export declare const checkUniqueConstraintsForAllEntities: (db: DatabaseInMemory, entitiesByName: Record<string, EntityDecl>, instanceOverviewsByEntityName: Record<string, InstanceContainerOverview[]>) => Result<void, AggregateError>;

package/dist/src/node/utils/unique.js

@@ -3,13 +3,21 @@ import { anySameIndices, flatCombine } from "../../shared/utils/array.js";
 import { deepEqual } from "../../shared/utils/compare.js";
 import { error, isError, mapError, ok } from "../../shared/utils/result.js";
 import { getInstancesOfEntityFromDatabaseInMemory, } from "./databaseInMemory.js";
-const listFormatter = new Intl.ListFormat("en-US", { type: "conjunction" });
-const printUniqueConstraint = (constraint) => (Array.isArray(constraint) ? constraint : [constraint])
-    .map(elem => "keyPath" in elem
+export class UniqueConstraintError extends Error {
+    parts;
+    constructor(message, parts) {
+        super(message);
+        this.parts = parts;
+    }
+}
+const printUniqueConstraint = (constraint, values) => (Array.isArray(constraint) ? constraint : [constraint])
+    .map((elem, i) => "keyPath" in elem
     ? renderKeyPath(elem.keyPath) +
         (elem.keyPathFallback ? "|" + renderKeyPath(elem.keyPathFallback) : "")
     : renderKeyPath(elem.entityMapKeyPath) +
-        "[...]." +
+        "[" +
+        (Array.isArray(values[i]) ? values[i][0] : "...") +
+        "]." +
         (elem.keyPathInEntityMapFallback
             ? "(" +
                 renderKeyPath(elem.keyPathInEntityMap) +
@@ -31,7 +39,7 @@ const unsafeGetValueAtKeyPath = (value, keyPath) => {
  * Returns `Ok` when no violations have been found and an `Error` with an
  * `AggregateError` if there are any violations of any unique constraint.
  */
-export const checkUniqueConstraintsForEntity = (entity, instances) => {
+export const checkUniqueConstraintsForEntity = (entity, instances, instanceOverviews) => {
     const constraintErrors = [];
     const constraints = entity.uniqueConstraints ?? [];
     for (const [constraintIndex, constraint] of constraints.entries()) {
@@ -61,14 +69,17 @@ export const checkUniqueConstraintsForEntity = (entity, instances) => {
             constraintErrors.push([
                 constraintIndex,
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Indices returned by anySameIndices must exist
-                duplicates.map(duplicateSet => duplicateSet.map(rowIndex => index[rowIndex][0])),
+                duplicates.map(duplicateSet => duplicateSet.map(rowIndex => index[rowIndex])),
             ]);
         }
     }
     if (constraintErrors.length > 0) {
-        return error(new AggregateError(constraintErrors.map(([constraintIndex, constraintErrors]) => new AggregateError(constraintErrors.map(error => new Error(`instances ${listFormatter.format(error)} contain duplicate values`)), 
+        return error(new AggregateError(constraintErrors.flatMap(([constraintIndex, constraintErrors]) => constraintErrors.map(error => new UniqueConstraintError(
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- constraint must be present
-        `in unique constraint ${printUniqueConstraint(constraints[constraintIndex])}`)), `in entity "${entity.name}"`));
+        `for unique constraint ${printUniqueConstraint(constraints[constraintIndex], error[0][1])}:`, error.map(row => {
+            const instanceOverview = instanceOverviews.find(o => o.id === row[0]);
+            return instanceOverview ? `"${instanceOverview.displayName}" (${row[0]})` : row[0];
+        })))), `in entity "${entity.name}"`));
     }
     return ok();
 };
@@ -79,8 +90,8 @@ export const checkUniqueConstraintsForEntity = (entity, instances) => {
  * `AggregateError`s for each entity if there are any violations of any unique
  * constraint.
  */
-export const checkUniqueConstraintsForAllEntities = (db, entities) => mapError(entities.reduce((acc, entity) => {
-    const resultForEntity = checkUniqueConstraintsForEntity(entity, getInstancesOfEntityFromDatabaseInMemory(db, entity.name));
+export const checkUniqueConstraintsForAllEntities = (db, entitiesByName, instanceOverviewsByEntityName) => mapError(Object.values(entitiesByName).reduce((acc, entity) => {
+    const resultForEntity = checkUniqueConstraintsForEntity(entity, getInstancesOfEntityFromDatabaseInMemory(db, entity.name), instanceOverviewsByEntityName[entity.name] ?? []);
     if (isError(acc)) {
         if (isError(resultForEntity)) {
             return error([...acc.error, resultForEntity.error]);
@@ -91,4 +102,4 @@ export const checkUniqueConstraintsForAllEntities = (db, entities) => mapError(e
         return error([resultForEntity.error]);
     }
     return acc;
-}, ok()), errors => new AggregateError(errors, "at least one unique constraint has been violated"));
+}, ok()), errors => new AggregateError(errors.toSorted((a, b) => a.message.localeCompare(b.message)), "at least one unique constraint has been violated"));

package/dist/src/shared/api.d.ts

@@ -48,7 +48,7 @@ export interface GetAllInstancesResponseBody {
     instances: {
         [entity: string]: {
             id: string;
-            name: string;
+            displayName: string;
             displayNameLocaleId?: string;
         }[];
     };

package/dist/src/shared/utils/dictionary.d.ts

@@ -15,3 +15,4 @@ export declare const modifyD: <T>(dict: Dictionary<T>, key: string, modifyFn: (c
 export declare const findD: <T>(dict: Dictionary<T>, predicate: (value: T, key: string) => boolean) => T | undefined;
 export declare const mapFirstD: <T, U>(dict: Dictionary<T>, mapFn: (value: T, key: string) => U | undefined) => U | undefined;
 export declare const mapD: <T, U>(dict: Dictionary<T>, mapFn: (value: T, key: string) => U) => Dictionary<U>;
+export declare const reduceD: <T, U>(dict: Dictionary<T>, reducer: (acc: U, value: T, key: string) => U, initialValue: U) => U;

package/dist/src/shared/utils/dictionary.js

@@ -74,3 +74,4 @@ export const mapD = (dict, mapFn) => {
     }
     return [newRecord, dict[1]];
 };
+export const reduceD = (dict, reducer, initialValue) => Object.entries(dict[0]).reduce((acc, [key, item]) => reducer(acc, item, key), initialValue);

package/dist/src/shared/utils/instances.d.ts

@@ -1,5 +1,5 @@
 import type { EntityDecl } from "../../node/schema/index.ts";
-import type { GetInstanceById } from "../../node/server/index.ts";
+import type { InstanceFromDatabaseInMemoryGetter } from "../../node/utils/databaseInMemory.ts";
 import { type GetChildInstancesForInstanceId } from "../../node/utils/displayName.ts";
 import type { GitFileStatus } from "./git.ts";
 export type InstanceContent = object;
@@ -14,4 +14,4 @@ export interface InstanceContainerOverview {
     displayName: string;
     displayNameLocaleId?: string;
 }
-export declare const getInstanceContainerOverview: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: GetInstanceById, getChildInstancesForInstanceId: GetChildInstancesForInstanceId, locales: string[]) => InstanceContainerOverview;
+export declare const getInstanceContainerOverview: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: InstanceFromDatabaseInMemoryGetter, getChildInstancesForInstanceId: GetChildInstancesForInstanceId, locales: string[]) => InstanceContainerOverview;

package/dist/src/web/components/typeInputs/NestedEntityMapTypeInput.js

@@ -16,11 +16,11 @@ export const NestedEntityMapTypeInput = props => {
     const secondaryInstances = (instanceNamesByEntity[type.secondaryEntity] ?? [])
         .slice()
         .filter(instance => !existingKeys.includes(instance.id))
-        .sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
+        .sort((a, b) => a.displayName.localeCompare(b.displayName, undefined, { numeric: true }));
     const isLocaleEntity = checkIsLocaleEntity(type.secondaryEntity);
     return (_jsxs("div", { class: "field field--container field--nestedentitymap", children: [existingKeys.length > 0 && (_jsx("ul", { children: Object.entries(value).map(([key, item]) => {
                     const name = instanceNamesByEntity[type.secondaryEntity]?.find(instance => instance.id === key)
-                        ?.name ?? key;
+                        ?.displayName ?? key;
                     return (_jsxs("li", { class: "container-item dict-item", ...(isLocaleEntity ? { lang: key } : {}), children: [_jsxs("div", { className: "container-item-header", children: [_jsx("div", { className: "container-item-title", children: _jsxs("span", { children: [_jsx("strong", { children: name }), " ", _jsx("span", { className: "id", children: key })] }) }), _jsx("div", { className: "btns", children: _jsxs("button", { class: "destructive", onClick: () => {
                                                 const newObj = { ...value };
                                                 // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
@@ -31,7 +31,7 @@ export const NestedEntityMapTypeInput = props => {
                                 } })] }, key));
                 }) })), _jsxs("div", { class: "add-item-container", children: [_jsxs(Select, { value: newKey, onInput: event => {
                             setNewKey(event.currentTarget.value);
-                        }, disabled: disabled || secondaryInstances.length === 0, children: [secondaryInstances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), secondaryInstances.map(instance => (_jsx("option", { value: instance.id, children: instance.name }, instance.id)))] }), _jsxs("button", { onClick: () => {
+                        }, disabled: disabled || secondaryInstances.length === 0, children: [secondaryInstances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), secondaryInstances.map(instance => (_jsx("option", { value: instance.id, children: instance.displayName }, instance.id)))] }), _jsxs("button", { onClick: () => {
                             onChange(sortObjectKeysAlphabetically({
                                 ...value,
                                 [newKey]: createTypeSkeleton(getDeclFromDeclName, type.type),

package/dist/src/web/components/typeInputs/ReferenceIdentifierTypeInput.js

@@ -9,5 +9,5 @@ export const ReferenceIdentifierTypeInput = ({ type, value, instanceNamesByEntit
     const instances = instanceNamesByEntity[type.entity] ?? [];
     return (_jsxs("div", { class: "field", children: [_jsxs(Select, { value: value, onInput: event => {
                     onChange(event.currentTarget.value);
-                }, disabled: disabled || instances.length === 0, "aria-invalid": !value, children: [instances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), instances.map(instance => (_jsx("option", { value: instance.id, children: instance.name }, instance.id)))] }), _jsx(ValidationErrors, { disabled: disabled, errors: !value ? [ReferenceError("no reference provided")] : [] })] }));
+                }, disabled: disabled || instances.length === 0, "aria-invalid": !value, children: [instances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), instances.map(instance => (_jsx("option", { value: instance.id, children: instance.displayName }, instance.id)))] }), _jsx(ValidationErrors, { disabled: disabled, errors: !value ? [ReferenceError("no reference provided")] : [] })] }));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.13.2",
+  "version": "0.15.0",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",