tsondb 0.15.0 → 0.17.0

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

@@ -1,5 +1,5 @@
 import { dirname, relative } from "node:path";
-import { discriminatorKey } from "../../../shared/enum.js";
+import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { asDecl } from "../../schema/declarations/Declaration.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
@@ -96,12 +96,12 @@ const renderEnumType = (options, type) => ({
         type: "object",
         deprecated: caseDef.isDeprecated,
         properties: {
-            [discriminatorKey]: {
+            [ENUM_DISCRIMINATOR_KEY]: {
                 const: caseName,
             },
             ...(caseDef.type === null ? {} : { [caseName]: renderType(options, caseDef.type) }),
         },
-        required: [discriminatorKey, ...(caseDef.type === null ? [] : [caseName])],
+        required: [ENUM_DISCRIMINATOR_KEY, ...(caseDef.type === null ? [] : [caseName])],
     })),
 });
 const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));

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

@@ -1,6 +1,6 @@
 import { EOL } from "node:os";
 import { dirname, relative } from "node:path";
-import { discriminatorKey } from "../../../shared/enum.js";
+import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
 import { unique } from "../../../shared/utils/array.js";
 import { toCamelCase } from "../../../shared/utils/string.js";
 import { extractParameterTypeNamesFromMessage, mapParameterTypeNames, } from "../../../shared/utils/translation.js";
@@ -59,7 +59,7 @@ const renderIncludeIdentifierType = (options, type) => combineSyntaxes([
         : syntax `<${combineSyntaxes(type.args.map(arg => renderType(options, arg)), ", ")}>`,
 ]);
 const renderNestedEntityMapType = (options, type) => wrapAsObject(options, syntax `[${toCamelCase(type.secondaryEntity.name)}Id: string]: ${type.name}`);
-const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.values).map(([caseName, caseDef]) => indent(options.indentation, 1, syntax `${EOL}| {${EOL}${indent(options.indentation, 1, syntax `${discriminatorKey}: "${caseName}"${caseDef.type === null
+const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.values).map(([caseName, caseDef]) => indent(options.indentation, 1, syntax `${EOL}| {${EOL}${indent(options.indentation, 1, syntax `${ENUM_DISCRIMINATOR_KEY}: "${caseName}"${caseDef.type === null
     ? ""
     : syntax `${EOL}${caseName}: ${renderType(options, caseDef.type)}`}`)}${EOL}}`)));
 const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));

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

@@ -43,8 +43,8 @@ const checkParameterNamesShadowing = (decls) => {
 };
 const checkEntityDisplayNamePaths = (decls, localeEntity) => {
     for (const decl of decls) {
-        if (isEntityDecl(decl) && decl.displayName !== null) {
-            const displayName = decl.displayName ?? "name";
+        if (isEntityDecl(decl) && decl.instanceDisplayName !== null) {
+            const displayName = decl.instanceDisplayName ?? "name";
             if (typeof displayName === "function") {
                 continue;
             }

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

@@ -30,16 +30,28 @@ type PathTo<T extends TConstraint, R> = {
 export interface EntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
+    /**
+     * Changes the appearance of the entity’s name in singular form.
+     */
+    displayName?: string;
+    /**
+     * Changes the appearance of the entity’s name in plural form.
+     */
+    displayNamePlural?: string;
     type: Lazy<ObjectType<T>>;
     parentReferenceKey: FK;
     /**
+     * Sets the property used to retrieve the display name of an instance in editor forms (such as when selecting a reference) and error messages.
      * @default "name"
      */
-    displayName?: GenericEntityDisplayName;
-    displayNameCustomizer?: DisplayNameCustomizer;
+    instanceDisplayName?: GenericEntityDisplayName;
+    /**
+     * A function that is used to further customize the display name of an instance.
+     */
+    instanceDisplayNameCustomizer?: DisplayNameCustomizer;
     isDeprecated?: boolean;
     uniqueConstraints?: UniqueConstraints;
-    customConstraint?: CustomConstraint;
+    customConstraints?: 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> {
 }
@@ -50,13 +62,17 @@ export declare const EntityDecl: {
         comment?: string;
         type: () => ObjectType<T>;
         /**
+         * Sets the property used to retrieve the display name of an instance in editor forms (such as when selecting a reference) and error messages.
          * @default "name"
          */
-        displayName?: EntityDisplayName<T>;
-        displayNameCustomizer?: TypedDisplayNameCustomizer<Name>;
+        instanceDisplayName?: EntityDisplayName<T>;
+        /**
+         * A function that is used to further customize the display name of an instance.
+         */
+        instanceDisplayNameCustomizer?: TypedDisplayNameCustomizer<Name>;
         isDeprecated?: boolean;
         uniqueConstraints?: UniqueConstraints;
-        customConstraint?: TypedCustomConstraint<Name>;
+        customConstraints?: TypedCustomConstraint<Name>;
     }): EntityDecl<Name, T, undefined>;
     <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string>>(sourceUrl: string, options: {
         name: Name;
@@ -65,13 +81,17 @@ export declare const EntityDecl: {
         type: () => ObjectType<T>;
         parentReferenceKey: FK;
         /**
+         * Sets the property used to retrieve the display name of an instance in editor forms (such as when selecting a reference) and error messages.
          * @default "name"
          */
-        displayName?: EntityDisplayName<T>;
-        displayNameCustomizer?: TypedDisplayNameCustomizer<Name>;
+        instanceDisplayName?: EntityDisplayName<T>;
+        /**
+         * A function that is used to further customize the display name of an instance.
+         */
+        instanceDisplayNameCustomizer?: TypedDisplayNameCustomizer<Name>;
         isDeprecated?: boolean;
         uniqueConstraints?: UniqueConstraints;
-        customConstraint?: TypedCustomConstraint<Name>;
+        customConstraints?: TypedCustomConstraint<Name>;
     }): EntityDecl<Name, T, FK>;
 };
 export { EntityDecl as Entity };

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

@@ -8,8 +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
+        instanceDisplayNameCustomizer: options.instanceDisplayNameCustomizer, // ignore contravariance of registered entity type
+        customConstraints: options.customConstraints, // ignore contravariance of registered entity type
         kind: NodeKind.EntityDecl,
         sourceUrl,
         parameters: [],
@@ -54,9 +54,8 @@ export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sou
 export const serializeEntityDecl = ((type) => ({
     ...type,
     type: serializeObjectType(type.type.value),
-    displayName: typeof type.displayName === "function"
-        ? null
-        : type.displayName,
-    displayNameCustomizer: type.displayNameCustomizer !== undefined,
+    instanceDisplayName: type.instanceDisplayName,
+    instanceDisplayNameCustomizer: type.instanceDisplayNameCustomizer !== undefined,
+    customConstraints: type.customConstraints !== undefined,
 }));
 export const getReferencesForEntityDecl = (decl, value, inDecl) => getReferencesForObjectType(decl.type.value, value, [...inDecl, decl]);

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

@@ -1,4 +1,41 @@
+import { ENUM_DISCRIMINATOR_KEY } from "../../shared/schema/declarations/EnumDecl.ts";
 import type { RegisteredChildEntityMap, RegisteredEntityMap } from "./externalTypes.ts";
-export type GetInstanceById = <U extends keyof RegisteredEntityMap>(entity: U, id: string) => RegisteredEntityMap[U] | undefined;
+/**
+ * Creates an enum case object.
+ */
+export declare const Case: {
+    <T extends string>(type: T): Case<T>;
+    <T extends string, V extends NonNullable<unknown> | null>(type: T, value: V): Case<T, V>;
+};
+/**
+ * Type representing an enum case object.
+ */
+export type Case<K extends string, T = undefined> = {
+    [P in K]: T extends NonNullable<unknown> | null ? {
+        [Key in ENUM_DISCRIMINATOR_KEY]: P;
+    } & {
+        [Key in P]: Extract<T, NonNullable<unknown> | null>;
+    } : {
+        [Key in ENUM_DISCRIMINATOR_KEY]: P;
+    };
+}[K];
+/**
+ * A single instance might be defined by entity and identifier separately or by
+ * them being wrapped in an enum case.
+ */
+export type IdArgsVariant<U extends keyof RegisteredEntityMap = keyof RegisteredEntityMap> = [entity: U, id: string] | [enumCase: Case<U, string>];
+export declare const normalizedIdArgs: <U extends keyof RegisteredEntityMap>(args: IdArgsVariant<U>) => {
+    entityName: U;
+    id: string;
+};
+export type GetInstanceById = <U extends keyof RegisteredEntityMap>(...args: IdArgsVariant<U>) => 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][];
+/**
+ * Displays the name of an entity instance including its ID. If no display name is found, `undefined` is returned.
+ */
+export type GetDisplayName = (...args: IdArgsVariant) => string | undefined;
+/**
+ * Displays the name of an entity instance including its ID. If no display name is found, only the ID is returned.
+ */
+export type GetDisplayNameWithId = (...args: IdArgsVariant) => string;

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

@@ -1 +1,20 @@
-export {};
+import { ENUM_DISCRIMINATOR_KEY } from "../../shared/schema/declarations/EnumDecl.js";
+/**
+ * Creates an enum case object.
+ */
+export const Case = ((type, value) => (value === undefined
+    ? { [ENUM_DISCRIMINATOR_KEY]: type }
+    : { [ENUM_DISCRIMINATOR_KEY]: type, [type]: value }));
+export const normalizedIdArgs = (args) => {
+    if (typeof args[0] === "object") {
+        const [enumCase] = args;
+        return {
+            entityName: enumCase[ENUM_DISCRIMINATOR_KEY],
+            id: enumCase[enumCase[ENUM_DISCRIMINATOR_KEY]],
+        };
+    }
+    else {
+        const [entityName, id] = args;
+        return { entityName, id };
+    }
+};

package/dist/src/node/schema/types/generic/EnumType.d.ts

@@ -13,11 +13,19 @@ export declare const resolveTypeArgumentsInEnumType: TypeArgumentsResolver<EnumT
 export interface EnumCaseDecl<T extends Type | null = Type | null> {
     kind: NodeKind["EnumCaseDecl"];
     type: T;
+    /**
+     * Changes the appearance of the enum case’s name in editor forms.
+     */
+    displayName?: string;
     comment?: string;
     isDeprecated?: boolean;
 }
 export declare const EnumCaseDecl: <T extends Type | null>(options: {
     type: T;
+    /**
+     * Changes the appearance of the enum case’s name in editor forms.
+     */
+    displayName?: string;
     comment?: string;
     isDeprecated?: boolean;
 }) => EnumCaseDecl<T>;

package/dist/src/node/schema/types/generic/EnumType.js

@@ -1,4 +1,4 @@
-import { discriminatorKey } from "../../../../shared/enum.js";
+import { ENUM_DISCRIMINATOR_KEY } from "../../../../shared/schema/declarations/EnumDecl.js";
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { json, key } from "../../../utils/errorFormatting.js";
@@ -15,18 +15,18 @@ export const validateEnumType = (helpers, inDecls, type, value) => {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
     }
     const actualKeys = Object.keys(value);
-    if (!(discriminatorKey in value) || typeof value[discriminatorKey] !== "string") {
+    if (!(ENUM_DISCRIMINATOR_KEY in value) || typeof value[ENUM_DISCRIMINATOR_KEY] !== "string") {
         return [
-            TypeError(`missing required discriminator value at key ${key(`"${discriminatorKey}"`, helpers.useStyling)} of type string`),
+            TypeError(`missing required discriminator value at key ${key(`"${ENUM_DISCRIMINATOR_KEY}"`, helpers.useStyling)} of type string`),
         ];
     }
-    const caseName = value[discriminatorKey];
+    const caseName = value[ENUM_DISCRIMINATOR_KEY];
     if (!(caseName in type.values)) {
         return [
             TypeError(`discriminator ${key(`"${caseName}"`, helpers.useStyling)} is not a valid enum case, possible cases are: ${Object.keys(type.values).join(", ")}`),
         ];
     }
-    const unknownKeyErrors = actualKeys.flatMap(actualKey => actualKey === discriminatorKey || actualKey in type.values
+    const unknownKeyErrors = actualKeys.flatMap(actualKey => actualKey === ENUM_DISCRIMINATOR_KEY || actualKey in type.values
         ? []
         : [
             TypeError(`key ${key(`"${actualKey}"`, helpers.useStyling)} is not the discriminator key ${key(`"${caseName}"`, helpers.useStyling)} or a valid enum case, possible cases are: ${Object.keys(type.values).join(", ")}`),
@@ -73,10 +73,10 @@ export const getReferencesForEnumType = (type, value, inDecl) => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
-        !(discriminatorKey in value)) {
+        !(ENUM_DISCRIMINATOR_KEY in value)) {
         return [];
     }
-    const enumCase = value[discriminatorKey];
+    const enumCase = value[ENUM_DISCRIMINATOR_KEY];
     return typeof enumCase === "string" &&
         enumCase in type.values &&
         type.values[enumCase] !== undefined &&
@@ -89,13 +89,13 @@ export const formatEnumType = (type, value) => {
     if (typeof value === "object" &&
         value !== null &&
         !Array.isArray(value) &&
-        discriminatorKey in value &&
-        typeof value[discriminatorKey] === "string") {
-        const caseName = value[discriminatorKey];
+        ENUM_DISCRIMINATOR_KEY in value &&
+        typeof value[ENUM_DISCRIMINATOR_KEY] === "string") {
+        const caseName = value[ENUM_DISCRIMINATOR_KEY];
         const caseValue = value[caseName];
         const caseType = type.values[caseName]?.type;
         return {
-            [discriminatorKey]: caseName,
+            [ENUM_DISCRIMINATOR_KEY]: caseName,
             ...(caseValue == null || caseType == null
                 ? {}
                 : { [caseName]: formatValue(caseType, caseValue) }),

package/dist/src/node/schema/types/generic/ObjectType.d.ts

@@ -21,15 +21,27 @@ export interface MemberDecl<T extends Type = Type, R extends boolean = boolean>
     kind: NodeKind["MemberDecl"];
     isRequired: R;
     type: T;
+    /**
+     * Changes the appearance of the member’s name in editor forms.
+     */
+    displayName?: string;
     comment?: string;
     isDeprecated?: boolean;
 }
 export declare const Required: <T extends Type>(options: {
+    /**
+     * Changes the appearance of the member’s name in editor forms.
+     */
+    displayName?: string;
     comment?: string;
     isDeprecated?: boolean;
     type: T;
 }) => MemberDecl<T, true>;
 export declare const Optional: <T extends Type>(options: {
+    /**
+     * Changes the appearance of the member’s name in editor forms.
+     */
+    displayName?: string;
     comment?: string;
     isDeprecated?: boolean;
     type: T;

package/dist/src/node/schema/types/generic/ObjectType.js

@@ -49,15 +49,13 @@ export const validateObjectType = (helpers, inDecls, type, value) => {
 export const resolveTypeArgumentsInObjectType = (args, type, inDecl) => ObjectType(Object.fromEntries(Object.entries(type.properties).map(([key, config]) => [key, { ...config, type: resolveTypeArguments(args, config.type, inDecl) }])), {
     ...type,
 });
-const MemberDecl = (isRequired, type, comment, isDeprecated) => ({
+const MemberDecl = (isRequired, options) => ({
+    ...options,
     kind: NodeKind.MemberDecl,
     isRequired,
-    type,
-    comment,
-    isDeprecated,
 });
-export const Required = (options) => MemberDecl(true, options.type, options.comment, options.isDeprecated);
-export const Optional = (options) => MemberDecl(false, options.type, options.comment, options.isDeprecated);
+export const Required = (options) => MemberDecl(true, options);
+export const Optional = (options) => MemberDecl(false, options);
 export const serializeObjectType = (type) => ({
     ...type,
     properties: Object.fromEntries(Object.entries(type.properties).map(([key, prop]) => [

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

@@ -1,7 +1,5 @@
 import { Lazy } from "../../../../shared/utils/lazy.ts";
-import type { DisplayNameCustomizer } from "../../../utils/displayName.ts";
 import type { EntityDecl } from "../../declarations/EntityDecl.js";
-import { type EntityDisplayName } from "../../declarations/EntityDecl.js";
 import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
 import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
@@ -24,11 +22,6 @@ export declare const NestedEntityMapType: <Name extends string, T extends TConst
     comment?: string;
     secondaryEntity: EntityDecl;
     type: PossibleType<T>;
-    /**
-     * @default "name"
-     */
-    displayName?: EntityDisplayName<T>;
-    displayNameCustomizer?: DisplayNameCustomizer;
     isDeprecated?: boolean;
 }) => NestedEntityMapType<Name, T>;
 export { NestedEntityMapType as NestedEntityMap };

package/dist/src/node/schema/types/references/NestedEntityMapType.js

@@ -3,7 +3,6 @@ import { sortObjectKeysAlphabetically } from "../../../../shared/utils/object.js
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { entity, json, key as keyColor } from "../../../utils/errorFormatting.js";
-import {} from "../../declarations/EntityDecl.js";
 import { getNestedDeclarations, NodeKind, resolveTypeArguments, validateType } from "../../Node.js";
 import { getReferencesForObjectType, isObjectType, serializeObjectType, } from "../generic/ObjectType.js";
 import { formatValue } from "../Type.js";

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

@@ -1,4 +1,4 @@
-import { createEnumCaseValue } from "../../shared/schema/declarations/EnumDecl.js";
+import { createEnumCaseValue, ENUM_DISCRIMINATOR_KEY, } from "../../shared/schema/declarations/EnumDecl.js";
 import { hasKey } from "../../shared/utils/object.js";
 import { error, isError, map, ok } from "../../shared/utils/result.js";
 import { isEntityDeclWithParentReference, isEnumDecl, isIncludeIdentifierType, reduceNodes, } from "../schema/index.js";
@@ -7,8 +7,8 @@ import { getInstancesOfEntityFromDatabaseInMemory, } from "./databaseInMemory.js
 import { HTTPError } from "./error.js";
 import { createInstance, deleteInstance, updateInstance } from "./instanceTransactionSteps.js";
 const isParentReferenceReferencingParent = (value, parentEntityName, parentId) => {
-    if (typeof value === "object" && value !== null && hasKey(value, "kind")) {
-        return (value.kind === parentEntityName &&
+    if (typeof value === "object" && value !== null && hasKey(value, ENUM_DISCRIMINATOR_KEY)) {
+        return (value[ENUM_DISCRIMINATOR_KEY] === parentEntityName &&
             hasKey(value, parentEntityName) &&
             value[parentEntityName] === parentId);
     }

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

@@ -1,7 +1,7 @@
 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 GetAllChildInstancesForParent, type GetAllInstances, type GetDisplayName, type GetDisplayNameWithId, type GetInstanceById } from "../schema/helpers.ts";
 import type { EntityDecl } from "../schema/index.ts";
 import { type DatabaseInMemory } from "./databaseInMemory.ts";
 /**
@@ -17,8 +17,10 @@ export type CustomConstraint = (params: {
     instanceId: string;
     instanceContent: InstanceContent;
     getInstanceById: GetInstanceById;
-    getAllInstance: GetAllInstances;
+    getAllInstances: GetAllInstances;
     getAllChildInstancesForParent: GetAllChildInstancesForParent;
+    getDisplayName: GetDisplayName;
+    getDisplayNameWithId: GetDisplayNameWithId;
 }) => string[];
 /**
  * A constraint that can be defined on an entity to enforce custom validation logic.
@@ -33,8 +35,10 @@ export type TypedCustomConstraint<Name extends string> = (params: {
     instanceId: string;
     instanceContent: RegisteredEntity<Name>;
     getInstanceById: GetInstanceById;
-    getAllInstance: GetAllInstances;
+    getAllInstances: GetAllInstances;
     getAllChildInstancesForParent: GetAllChildInstancesForParent;
+    getDisplayName: GetDisplayName;
+    getDisplayNameWithId: GetDisplayNameWithId;
 }) => string[];
 /**
  * Checks all custom constraints for all provided entities and their instances.

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

@@ -1,5 +1,6 @@
 import { deepEqual } from "../../shared/utils/compare.js";
 import { error, isError, mapError, ok } from "../../shared/utils/result.js";
+import { normalizedIdArgs, } from "../schema/helpers.js";
 import { getInstanceOfEntityFromDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, } from "./databaseInMemory.js";
 /**
  * Checks all custom constraints for all provided entities and their instances.
@@ -9,20 +10,32 @@ import { getInstanceOfEntityFromDatabaseInMemory, getInstancesOfEntityFromDataba
  * 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));
-        },
+    const getInstanceById = (...args) => {
+        const { entityName, id } = normalizedIdArgs(args);
+        return getInstanceOfEntityFromDatabaseInMemory(db, entityName, id)?.content;
+    };
+    const getAllInstances = entityName => getInstancesOfEntityFromDatabaseInMemory(db, entityName).map(i => i.content);
+    const 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))
+            .map(i => i.content);
+    };
+    const getDisplayName = (...args) => {
+        const { entityName, id } = normalizedIdArgs(args);
+        return instanceOverviewsByEntityName[entityName]?.find(o => o.id === id)?.displayName;
+    };
+    const getDisplayNameWithId = (...args) => {
+        const { id } = normalizedIdArgs(args);
+        const displayName = getDisplayName(...args);
+        return displayName ? `"${displayName}" (${id})` : id;
     };
     return mapError(Object.values(entitiesByName).reduce((acc, entity) => {
-        const constraintFn = entity.customConstraint;
+        const constraintFn = entity.customConstraints;
         if (!constraintFn) {
             return acc;
         }
@@ -30,7 +43,11 @@ export const checkCustomConstraintsForAllEntities = (db, entitiesByName, instanc
             .map((instance) => [
             instance,
             constraintFn({
-                ...accessors,
+                getInstanceById,
+                getAllInstances,
+                getAllChildInstancesForParent,
+                getDisplayName,
+                getDisplayNameWithId,
                 instanceId: instance.id,
                 instanceContent: instance.content,
             }),

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

@@ -3,9 +3,9 @@ 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) {
+    if (useCustomizer && entity.instanceDisplayNameCustomizer) {
         const calculatedName = getDisplayNameFromEntityInstance(entity, instanceContainer, getInstanceById, getChildInstancesForInstanceId, locales, defaultName, false);
-        return entity.displayNameCustomizer({
+        return entity.instanceDisplayNameCustomizer({
             instance: instanceContainer.content,
             instanceId: instanceContainer.id,
             instanceDisplayName: calculatedName.name,

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

@@ -48,15 +48,24 @@ export type UniqueConstraints = UniqueConstraint[];
 export interface SerializedEntityDecl<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends SerializedBaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
+    /**
+     * Changes the appearance of the entity’s name in singular form.
+     */
+    displayName?: string;
+    /**
+     * Changes the appearance of the entity’s name in plural form.
+     */
+    displayNamePlural?: string;
     type: SerializedObjectType<T>;
     parentReferenceKey: FK;
     /**
      * @default "name"
      */
-    displayName?: GenericEntityDisplayName;
-    displayNameCustomizer: boolean;
+    instanceDisplayName?: GenericEntityDisplayName;
+    instanceDisplayNameCustomizer: boolean;
     isDeprecated?: boolean;
     uniqueConstraints?: UniqueConstraints;
+    customConstraints: boolean;
 }
 export declare const isSerializedEntityDecl: (node: SerializedNode) => node is SerializedEntityDecl;
 export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TSerializedConstraint, FK extends Extract<keyof T, string> | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;

package/dist/src/shared/schema/types/EnumType.d.ts

@@ -7,6 +7,10 @@ export interface SerializedEnumType<T extends Record<string, SerializedEnumCaseD
 export interface SerializedEnumCaseDecl<T extends SerializedType | null = SerializedType | null> {
     kind: NodeKind["EnumCaseDecl"];
     type: T;
+    /**
+     * Changes the appearance of the enum case’s name in editor forms.
+     */
+    displayName?: string;
     comment?: string;
     isDeprecated?: boolean;
 }

package/dist/src/shared/schema/types/EnumType.js

@@ -1,4 +1,4 @@
-import { discriminatorKey } from "../../enum.js";
+import { ENUM_DISCRIMINATOR_KEY } from "../declarations/EnumDecl.js";
 import { getReferencesSerialized, resolveSerializedTypeArguments, } from "../Node.js";
 export const resolveTypeArgumentsInSerializedEnumType = (decls, args, type) => ({
     ...type,
@@ -14,10 +14,10 @@ export const getReferencesForSerializedEnumType = (decls, type, value) => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
-        !(discriminatorKey in value)) {
+        !(ENUM_DISCRIMINATOR_KEY in value)) {
         return [];
     }
-    const enumCase = value[discriminatorKey];
+    const enumCase = value[ENUM_DISCRIMINATOR_KEY];
     return typeof enumCase === "string" &&
         enumCase in type.values &&
         type.values[enumCase] !== undefined &&

package/dist/src/shared/schema/types/ObjectType.d.ts

@@ -10,6 +10,10 @@ export interface SerializedMemberDecl<T extends SerializedType = SerializedType,
     kind: NodeKind["MemberDecl"];
     isRequired: R;
     type: T;
+    /**
+     * Changes the appearance of the member’s name in editor forms.
+     */
+    displayName?: string;
     comment?: string;
     isDeprecated?: boolean;
 }

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

@@ -12,10 +12,7 @@ const getValueAtPath = (value, path) => {
     return current;
 };
 export const getSerializedDisplayNameFromEntityInstance = (entity, instance, defaultName, locales) => {
-    if (entity.displayName === null) {
-        return { name: defaultName, localeId: locales[0] };
-    }
-    const displayNamePath = entity.displayName ?? "name";
+    const displayNamePath = entity.instanceDisplayName ?? "name";
     if (typeof displayNamePath === "string") {
         return {
             name: getValueAtPath(instance, displayNamePath) ?? defaultName,

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

@@ -30,6 +30,23 @@ export const ChildEntitiesTypeInput = props => {
             { entityName, childInstances: [], id: undefined, content: value },
         ]);
     }, [setChildInstances]);
+    const onChildDuplicate = useCallback((index) => {
+        const setChildInstancesAsNew = (childInstances) => childInstances.map(ci => ({
+            ...ci,
+            childInstances: setChildInstancesAsNew(ci.childInstances),
+            id: undefined,
+        }));
+        setChildInstances(old => old[index]
+            ? [
+                ...old,
+                {
+                    ...old[index],
+                    childInstances: setChildInstancesAsNew(old[index].childInstances),
+                    id: undefined,
+                },
+            ]
+            : old);
+    }, [setChildInstances]);
     const onChildRemove = useCallback((index) => {
         setChildInstances(old => removeAt(old, index));
     }, [setChildInstances]);
@@ -39,9 +56,11 @@ export const ChildEntitiesTypeInput = props => {
     if (path === undefined) {
         return _jsx("div", { role: "alert", children: "A child entities type cannot be the root type of a document." });
     }
-    return (_jsxs("div", { class: "field field--container field--array", children: [childInstancesForEntity.length > 0 ? (_jsx("ol", { children: childInstancesForEntity.map(([item, originalIndex], i) => (_jsxs("li", { class: "container-item array-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [i + 1, "."] }), _jsx("button", { class: "destructive", onClick: () => {
-                                        onChildRemove(i);
-                                    }, disabled: disabled, children: "Delete Item" })] }), _jsx(TypeInput, { ...props, type: childEntity.type, value: item.content, parentKey: childEntity.parentReferenceKey, onChange: newItem => {
+    return (_jsxs("div", { class: "field field--container field--array", children: [childInstancesForEntity.length > 0 ? (_jsx("ol", { children: childInstancesForEntity.map(([item, originalIndex], i) => (_jsxs("li", { class: "container-item array-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [i + 1, "."] }), _jsxs("div", { class: "container-item-actions", children: [_jsxs("button", { onClick: () => {
+                                                onChildDuplicate(i);
+                                            }, disabled: disabled, children: ["Duplicate Item #", i + 1] }), _jsxs("button", { class: "destructive", onClick: () => {
+                                                onChildRemove(i);
+                                            }, disabled: disabled, children: ["Delete Item #", i + 1] })] })] }), _jsx(TypeInput, { ...props, type: childEntity.type, value: item.content, parentKey: childEntity.parentReferenceKey, onChange: newItem => {
                                 onChildChange(originalIndex, newItem); // guaranteed to be an object because of the ObjectType in the child entity
                             }, childInstances: item.childInstances, setChildInstances: newChildInstances => {
                                 onGrandChildrenChange(originalIndex, newChildInstances);

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

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
-import { discriminatorKey } from "../../../shared/enum.js";
+import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
 import { toTitleCase } from "../../../shared/utils/string.js";
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { useSetting } from "../../hooks/useSettings.js";
@@ -14,12 +14,12 @@ export const EnumTypeInput = props => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
-        !(discriminatorKey in value) ||
-        typeof value[discriminatorKey] !== "string") {
+        !(ENUM_DISCRIMINATOR_KEY in value) ||
+        typeof value[ENUM_DISCRIMINATOR_KEY] !== "string") {
         return _jsx(MismatchingTypeError, { expected: "enumeration value", actual: value });
     }
     const enumValues = Object.entries(type.values);
-    const activeEnumCase = value[discriminatorKey];
+    const activeEnumCase = value[ENUM_DISCRIMINATOR_KEY];
     const activeCaseMember = type.values[activeEnumCase];
     switch (enumDisplay) {
         case "select":
@@ -27,18 +27,18 @@ export const EnumTypeInput = props => {
                             const caseMember = type.values[event.currentTarget.value];
                             if (caseMember?.type == null) {
                                 onChange({
-                                    [discriminatorKey]: event.currentTarget.value,
+                                    [ENUM_DISCRIMINATOR_KEY]: event.currentTarget.value,
                                 });
                             }
                             else {
                                 onChange({
-                                    [discriminatorKey]: event.currentTarget.value,
+                                    [ENUM_DISCRIMINATOR_KEY]: event.currentTarget.value,
                                     [event.currentTarget.value]: createTypeSkeleton(getDeclFromDeclName, caseMember.type),
                                 });
                             }
-                        }, disabled: disabled, children: enumValues.map(([enumValue]) => (_jsx("option", { value: enumValue, selected: enumValue === activeEnumCase, children: toTitleCase(enumValue) }, enumValue))) }), activeCaseMember?.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: activeCaseMember.comment })), activeCaseMember?.type == null ? null : (_jsx("div", { className: "associated-type", children: _jsx(TypeInput, { ...props, parentKey: undefined, type: activeCaseMember.type, path: path === undefined ? `{${activeEnumCase}}` : `${path}.{${activeEnumCase}}`, value: value[activeEnumCase], onChange: newValue => {
+                        }, disabled: disabled, children: enumValues.map(([enumValue, caseMember]) => (_jsx("option", { value: enumValue, selected: enumValue === activeEnumCase, children: caseMember.displayName ?? toTitleCase(enumValue) }, enumValue))) }), activeCaseMember?.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: activeCaseMember.comment })), activeCaseMember?.type == null ? null : (_jsx("div", { className: "associated-type", children: _jsx(TypeInput, { ...props, parentKey: undefined, type: activeCaseMember.type, path: path === undefined ? `{${activeEnumCase}}` : `${path}.{${activeEnumCase}}`, value: value[activeEnumCase], onChange: newValue => {
                                 onChange({
-                                    [discriminatorKey]: activeEnumCase,
+                                    [ENUM_DISCRIMINATOR_KEY]: activeEnumCase,
                                     [activeEnumCase]: newValue,
                                 });
                             } }) }))] }));
@@ -46,22 +46,22 @@ export const EnumTypeInput = props => {
             return (_jsx("div", { class: "field field--enum", children: enumValues.map(([enumValue, caseMember]) => (_jsxs("div", { class: "field--option", children: [_jsx("input", { type: "radio", name: path, value: enumValue, id: path === undefined ? enumValue : `${path}-${enumValue}`, checked: enumValue === activeEnumCase, onInput: () => {
                                 if (caseMember.type == null) {
                                     onChange({
-                                        [discriminatorKey]: enumValue,
+                                        [ENUM_DISCRIMINATOR_KEY]: enumValue,
                                     });
                                 }
                                 else {
                                     onChange({
-                                        [discriminatorKey]: enumValue,
+                                        [ENUM_DISCRIMINATOR_KEY]: enumValue,
                                         [enumValue]: createTypeSkeleton(getDeclFromDeclName, caseMember.type),
                                     });
                                 }
-                            }, disabled: disabled }), _jsxs("div", { children: [_jsx("label", { htmlFor: path === undefined ? enumValue : `${path}-${enumValue}`, children: toTitleCase(enumValue) }), caseMember.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: caseMember.comment })), caseMember.type == null ? null : (_jsx("div", { className: "associated-type", children: _jsx(TypeInput, { ...props, parentKey: undefined, type: caseMember.type, path: path === undefined ? `{${activeEnumCase}}` : `${path}.{${activeEnumCase}}`, value: enumValue === activeEnumCase
+                            }, disabled: disabled }), _jsxs("div", { children: [_jsx("label", { htmlFor: path === undefined ? enumValue : `${path}-${enumValue}`, children: caseMember.displayName ?? toTitleCase(enumValue) }), caseMember.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: caseMember.comment })), caseMember.type == null ? null : (_jsx("div", { className: "associated-type", children: _jsx(TypeInput, { ...props, parentKey: undefined, type: caseMember.type, path: path === undefined ? `{${activeEnumCase}}` : `${path}.{${activeEnumCase}}`, value: enumValue === activeEnumCase
                                             ? value[activeEnumCase]
                                             : createTypeSkeleton(getDeclFromDeclName, caseMember.type), disabled: disabled || enumValue !== activeEnumCase, onChange: disabled
                                             ? () => { }
                                             : newValue => {
                                                 onChange({
-                                                    [discriminatorKey]: activeEnumCase,
+                                                    [ENUM_DISCRIMINATOR_KEY]: activeEnumCase,
                                                     [activeEnumCase]: newValue,
                                                 });
                                             } }) }))] })] }, enumValue))) }));

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

@@ -15,18 +15,18 @@ export const ObjectTypeInput = props => {
     const errors = validateObjectConstraints(type, Object.keys(type.properties), value);
     return (_jsxs("div", { class: "field field--container field--object" + (disabled ? " field--disabled" : ""), children: [_jsx("ul", { children: Object.entries(type.properties)
                     .filter(([key]) => key !== parentKey)
-                    .map(([key, memberDecl]) => (_jsxs("li", { class: "container-item object-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [_jsx("strong", { children: toTitleCase(key) }), memberDecl.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: memberDecl.comment }))] }), memberDecl.isRequired ? null : value[key] ===
+                    .map(([key, memberDecl]) => (_jsxs("li", { class: "container-item object-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [_jsx("strong", { children: memberDecl.displayName ?? toTitleCase(key) }), memberDecl.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: memberDecl.comment }))] }), memberDecl.isRequired ? null : value[key] ===
                                     undefined ? (_jsxs("button", { onClick: () => {
                                         onChange(sortObjectKeys({
                                             ...value,
                                             [key]: createTypeSkeleton(getDeclFromDeclName, memberDecl.type),
                                         }, Object.keys(type.properties)));
-                                    }, disabled: disabled, children: ["Add ", toTitleCase(key)] })) : (_jsxs("button", { class: "destructive", onClick: () => {
+                                    }, disabled: disabled, children: ["Add ", memberDecl.displayName ?? toTitleCase(key)] })) : (_jsxs("button", { class: "destructive", onClick: () => {
                                         const newObj = { ...value };
                                         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                                         delete newObj[key];
                                         onChange(newObj);
-                                    }, disabled: disabled, children: ["Remove ", toTitleCase(key)] }))] }), memberDecl.isRequired || value[key] !== undefined ? (_jsx(TypeInput, { ...props, parentKey: undefined, type: memberDecl.type, path: path === undefined ? key : `${path}.${key}`, value: value[key], onChange: newItem => {
+                                    }, disabled: disabled, children: ["Remove ", memberDecl.displayName ?? toTitleCase(key)] }))] }), memberDecl.isRequired || value[key] !== undefined ? (_jsx(TypeInput, { ...props, parentKey: undefined, type: memberDecl.type, path: path === undefined ? key : `${path}.${key}`, value: value[key], onChange: newItem => {
                                 onChange(sortObjectKeys({ ...value, [key]: newItem }, Object.keys(type.properties)));
                             } })) : null] }, key))) }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }));
 };

package/dist/src/web/routes/Entity.js

@@ -36,8 +36,9 @@ export const Entity = () => {
             .catch(logAndAlertError);
     }, [latestCommit, reloadInstances, reloadLocaleInstances]);
     useEffect(() => {
-        document.title = toTitleCase(entity?.namePlural ?? name ?? "") + " — TSONDB";
-    }, [entity?.namePlural, name]);
+        document.title =
+            (entity?.displayNamePlural ?? toTitleCase(entity?.namePlural ?? name ?? "")) + " — TSONDB";
+    }, [entity?.displayNamePlural, entity?.namePlural, name]);
     useEffect(() => {
         if (created) {
             const instanceElement = document.getElementById(`instance-${created}`);

package/dist/src/web/routes/Home.js

@@ -34,7 +34,7 @@ export const Home = () => {
             },
         ].filter(section => section.entities.length > 0)
         : undefined;
-    const mapEntity = (entity) => (_jsxs("li", { class: "entries-item", children: [_jsxs("div", { class: "entries-item__title", children: [_jsx("h2", { children: toTitleCase(entity.declaration.namePlural) }), entity.declaration.comment && (_jsx(Markdown, { class: "description", string: entity.declaration.comment }))] }), _jsxs("p", { class: "entries-item__subtitle", children: [entity.instanceCount, " instance", entity.instanceCount === 1 ? "" : "s"] }), _jsx("div", { class: "entries-item__side", children: _jsx("div", { class: "btns", children: _jsx("a", { href: `/entities/${entity.declaration.name}`, class: "btn", children: "View" }) }) })] }, entity.declaration.name));
+    const mapEntity = (entity) => (_jsxs("li", { class: "entries-item", children: [_jsxs("div", { class: "entries-item__title", children: [_jsx("h2", { children: entity.declaration.displayNamePlural ?? toTitleCase(entity.declaration.namePlural) }), entity.declaration.comment && (_jsx(Markdown, { class: "description", string: entity.declaration.comment }))] }), _jsxs("p", { class: "entries-item__subtitle", children: [entity.instanceCount, " instance", entity.instanceCount === 1 ? "" : "s"] }), _jsx("div", { class: "entries-item__side", children: _jsx("div", { class: "btns", children: _jsx("a", { href: `/entities/${entity.declaration.name}`, class: "btn", children: "View" }) }) })] }, entity.declaration.name));
     return (_jsxs(Layout, { breadcrumbs: [], children: [_jsx("h1", { children: homeTitle }), _jsxs("div", { className: "list-header", children: [_jsxs("p", { class: "instance-count", children: [searchText === "" ? "" : `${filteredEntities.length.toString()} of `, entities.length, " entit", entities.length === 1 ? "y" : "ies"] }), _jsxs("form", { action: "", rel: "search", onSubmit: e => {
                             e.preventDefault();
                         }, children: [_jsx("label", { htmlFor: "entity-search", class: "visually-hidden", children: "Search" }), _jsx("input", { type: "text", id: "entity-search", value: searchText, onInput: event => {

package/package.json

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

package/public/css/styles.css

@@ -856,6 +856,13 @@ form > .field--container {
   margin: 0.125rem 0 0;
 }
 
+.container-item-actions {
+  flex: none;
+  display: flex;
+  gap: 0.5rem;
+  margin-left: 1rem;
+}
+
 .add-item-container {
   display: flex;
   margin-top: 1rem;

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

@@ -1 +0,0 @@
-export declare const discriminatorKey = "kind";

package/dist/src/shared/enum.js

@@ -1 +0,0 @@
-export const discriminatorKey = "kind";