tsondb 0.12.8 → 0.13.0

package/dist/src/bin/tsondb.js

@@ -15,6 +15,7 @@ import { pathToFileURL } from "node:url";
 import { parseArguments } from "simple-cli-args";
 import { validateConfigForFormatting, validateConfigForGeneration, validateConfigForServer, validateConfigForTesting, } from "../node/config.js";
 import { format, generateOutputs, serve, validate } from "../node/index.js";
+import { omitUndefinedKeys } from "../shared/utils/object.js";
 const debug = Debug("tsondb:cli");
 const passedArguments = parseArguments({
     commands: {
@@ -25,7 +26,11 @@ const passedArguments = parseArguments({
                     name: "check-referential-integrity",
                     type: Boolean,
                 },
-                entities: {
+                checkTranslationParameters: {
+                    name: "check-translation-parameters",
+                    type: Boolean,
+                },
+                checkOnlyEntities: {
                     name: "entities",
                     alias: "e",
                     multiple: true,
@@ -87,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.customStylesheetPath);
+        await serve(config.schema, config.dataRootPath, config.defaultLocales, config.homeLayoutSections, config.serverOptions, config.validationOptions, config.customStylesheetPath);
         break;
     case "validate":
         debug(`running command: validate`);
@@ -95,13 +100,13 @@ switch (passedArguments.command.name) {
         if (passedArguments.command.options?.checkReferentialIntegrity !== undefined) {
             debug(`check referential integrity: ${passedArguments.command.options.checkReferentialIntegrity ? "yes" : "no"}`);
         }
-        if (passedArguments.command.options?.entities !== undefined) {
-            const entities = passedArguments.command.options.entities;
+        if (passedArguments.command.options?.checkOnlyEntities !== undefined) {
+            const entities = passedArguments.command.options.checkOnlyEntities;
             debug(`only check the following entities: ${entities.join(", ")}`);
         }
         await validate(config.schema, config.dataRootPath, {
-            checkReferentialIntegrity: passedArguments.command.options?.checkReferentialIntegrity,
-            checkOnlyEntities: passedArguments.command.options?.entities,
+            ...config.validationOptions,
+            ...omitUndefinedKeys(passedArguments.command.options ?? {}),
         });
         break;
     case "format":

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

@@ -1,4 +1,5 @@
 import type { Output } from "../shared/output.ts";
+import type { ValidationOptions } from "./index.ts";
 import type { EntityDecl } from "./schema/index.ts";
 import type { Schema } from "./schema/Schema.ts";
 /**
@@ -12,6 +13,7 @@ export type Config = {
     dataRootPath?: string;
     homeLayoutSections?: HomeLayoutSection[];
     customStylesheetPath?: string;
+    validationOptions?: Partial<ValidationOptions>;
 };
 export type ServerOptions = {
     port: number;
@@ -43,8 +45,19 @@ export type ServerConfig = DataConfig & {
     serverOptions?: ServerOptions;
     defaultLocales: string[];
     homeLayoutSections?: HomeLayoutSection[];
+    validationOptions?: Partial<ValidationOptions>;
     customStylesheetPath?: string;
 };
+/**
+ * The configuration type required for validating the contents of the database.
+ */
+export type TestingConfig = DataConfig & {
+    validationOptions?: Partial<ValidationOptions>;
+};
+/**
+ * The configuration type required for formatting the contents of the database.
+ */
+export type FormattingConfig = DataConfig;
 export declare const validateConfigForServer: (config: Config) => asserts config is ServerConfig;
-export declare const validateConfigForTesting: (config: Config) => asserts config is DataConfig;
-export declare const validateConfigForFormatting: (config: Config) => asserts config is DataConfig;
+export declare const validateConfigForTesting: (config: Config) => asserts config is TestingConfig;
+export declare const validateConfigForFormatting: (config: Config) => asserts config is FormattingConfig;

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

@@ -3,13 +3,19 @@ import type { HomeLayoutSection } from "./config.ts";
 import { type Schema } from "./schema/Schema.ts";
 import type { ServerOptions } from "./server/index.ts";
 export declare const generateOutputs: (schema: Schema, outputs: Output[]) => Promise<void>;
-type ValidationOptions = {
+export type ValidationOptions = {
     checkReferentialIntegrity: boolean;
     checkOnlyEntities: string[];
+    checkTranslations?: {
+        format: "mf2";
+        /**
+         * If set to `true`, translation keys will be treated as message format strings and their parameters must match the ones in the values.
+         */
+        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>, customStylesheetPath?: string) => Promise<void>;
-export declare const generateValidateAndServe: (schema: Schema, outputs: Output[], dataRootPath: string, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[], serverOptions?: Partial<ServerOptions>, 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 format: (schema: Schema, dataRootPath: string) => Promise<void>;
-export {};

package/dist/src/node/index.js

@@ -2,14 +2,16 @@ import Debug from "debug";
 import { mkdir } from "fs/promises";
 import { join, sep } from "path";
 import { styleText } from "util";
+import { isError } from "../shared/utils/result.js";
 import { parallelizeErrors } from "../shared/utils/validation.js";
 import { validateEntityDecl } from "./schema/declarations/EntityDecl.js";
-import { createValidators } from "./schema/Node.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 { countErrors, getErrorMessageForDisplay, wrapErrorsIfAny } from "./utils/error.js";
 import { getFileNameForId, writeInstance } from "./utils/files.js";
+import { checkUniqueConstraintsForAllEntities } from "./utils/unique.js";
 const debug = Debug("tsondb:jsapi");
 const prepareFolders = async (dataRootPath, entities) => {
     await mkdir(dataRootPath, { recursive: true });
@@ -30,12 +32,33 @@ const _validate = (dataRootPath, entities, databaseInMemory, options = {}) => {
             throw new Error(`Entity "${onlyEntity}" not found in schema`);
         }
     }
-    const validationHelpers = createValidators(databaseInMemory, true, checkReferentialIntegrity);
+    const validationContext = createValidationContext(options, databaseInMemory, true, checkReferentialIntegrity);
+    debug("Checking structural integrity ...");
     const errors = (checkOnlyEntities.length > 0
         ? entities.filter(entity => checkOnlyEntities.includes(entity.name))
         : entities)
-        .flatMap(entity => parallelizeErrors(getInstancesOfEntityFromDatabaseInMemory(databaseInMemory, entity.name).map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateEntityDecl(validationHelpers, [], entity, instance.content)))))
+        .flatMap(entity => parallelizeErrors(getInstancesOfEntityFromDatabaseInMemory(databaseInMemory, entity.name).map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateEntityDecl(validationContext, [], entity, instance.content)))))
         .toSorted((a, b) => a.message.localeCompare(b.message));
+    if (errors.length > 0) {
+        debug(`${errors.length.toString()} structural integrity violation${errors.length === 1 ? "" : "s"} found`);
+    }
+    else {
+        debug("No structural integrity violations found");
+    }
+    if (errors.length === 0) {
+        debug("Checking unique constraints ...");
+        const constraintResult = checkUniqueConstraintsForAllEntities(databaseInMemory, entities);
+        if (isError(constraintResult)) {
+            debug(`${constraintResult.error.errors.length.toString()} unique constraint violation${constraintResult.error.errors.length === 1 ? "" : "s"} found`);
+            errors.push(constraintResult.error);
+        }
+        else {
+            debug("No unique constraint violations found");
+        }
+    }
+    else {
+        debug("Skipping unique constraint checks due to previous structural integrity errors");
+    }
     if (errors.length === 0) {
         debug("All entities are valid");
     }
@@ -57,7 +80,7 @@ export const generateAndValidate = async (schema, outputs, dataRootPath, validat
     const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
     _validate(dataRootPath, entities, databaseInMemory, validationOptions);
 };
-export const serve = async (schema, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, customStylesheetPath) => {
+export const serve = async (schema, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath) => {
     if (defaultLocales.length === 0) {
         throw new Error("At least one default locale must be specified to start the server.");
     }
@@ -66,15 +89,15 @@ 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, customStylesheetPath);
+    await createServer(schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath);
 };
-export const generateValidateAndServe = async (schema, outputs, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, validationOptions) => {
+export const generateValidateAndServe = async (schema, outputs, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath) => {
     await generateOutputs(schema, outputs);
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
     _validate(dataRootPath, entities, databaseInMemory, validationOptions);
-    await createServer(schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, serverOptions);
+    await createServer(schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, serverOptions, validationOptions, customStylesheetPath);
 };
 export const format = async (schema, dataRootPath) => {
     const entities = getEntities(schema);

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

@@ -3,7 +3,16 @@ export type TypeScriptRendererOptions = {
     indentation: number;
     objectTypeKeyword: "interface" | "type";
     preserveFiles: boolean;
-    generateEntityMapType: boolean;
+    generateHelpers: Partial<{
+        /**
+         * If `true` or a string, generates an object type with all names of the entities as the key and their corresponding generated type as their respective value. Uses `EntityMap` as a default name when using `true` or the string if set to a string.
+         */
+        entityMap: boolean | string;
+        /**
+         * If `true` or a string, generates an object type with all names of entities with parent references as the key and their corresponding generated type as well as their parent reference key as their respective value. Uses `ChildEntityMap` as a default name when using `true` or the string if set to a string.
+         */
+        childEntityMap: boolean | string;
+    }>;
     addIdentifierToEntities: boolean;
     /**
      * Infer translation parameter types from the message strings in a {@link TranslationObjectType TranslationObject} as branded types.

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

@@ -6,7 +6,7 @@ import { toCamelCase } from "../../../shared/utils/string.js";
 import { extractParameterTypeNamesFromMessage, mapParameterTypeNames, } from "../../../shared/utils/translation.js";
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { asDecl } from "../../schema/declarations/Declaration.js";
-import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
+import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, isEntityDeclWithParentReference, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
 import { ArrayType } from "../../schema/types/generic/ArrayType.js";
@@ -20,7 +20,7 @@ const defaultOptions = {
     indentation: 2,
     objectTypeKeyword: "interface",
     preserveFiles: false,
-    generateEntityMapType: false,
+    generateHelpers: {},
     addIdentifierToEntities: false,
 };
 const renderDocumentation = (comment, isDeprecated) => syntax `${comment === undefined
@@ -158,20 +158,63 @@ const renderImports = (currentUrl, imports) => {
         .join(EOL);
     return importsSyntax.length > 0 ? importsSyntax + EOL + EOL : "";
 };
-const renderEntityMapType = (options, declarations) => syntax `export type EntityMap = {${EOL}${indent(options.indentation, 1, combineSyntaxes(declarations
-    .filter(isEntityDecl)
-    .sort((a, b) => a.name.localeCompare(b.name))
-    .map(decl => syntax `${decl.name}: ${decl.name}`), EOL))}${EOL}}${EOL + EOL}`;
+const renderEntityMapType = (options, declarations) => options.generateHelpers.entityMap
+    ? `export type ${options.generateHelpers.entityMap === true ? "EntityMap" : options.generateHelpers.entityMap} = {${EOL}${prefixLines(getIndentation(options.indentation, 1), declarations
+        .filter(isEntityDecl)
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(decl => `${decl.name}: ${decl.name}`)
+        .join(EOL))}${EOL}}${EOL + EOL}`
+    : "";
+const renderChildEntityMapType = (options, declarations) => options.generateHelpers.childEntityMap
+    ? `export type ${options.generateHelpers.childEntityMap === true ? "ChildEntityMap" : options.generateHelpers.childEntityMap} = {${EOL}${prefixLines(getIndentation(options.indentation, 1), declarations
+        .filter(isEntityDecl)
+        .filter(isEntityDeclWithParentReference)
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(decl => `${decl.name}: [${decl.name}, "${decl.parentReferenceKey}", ${decl.name}["${decl.parentReferenceKey}"]]`)
+        .join(EOL))}${EOL}}${EOL + EOL}`
+    : "";
 const renderStringableTranslationParameterType = (options) => options.inferTranslationParameters?.format === "mf2"
-    ? "export type StringableTranslationParameter = {\n" +
+    ? "export type StringableTranslationParameter = {" +
+        EOL +
         prefixLines(getIndentation(options.indentation, 1), "toString(): string") +
-        "\n}\n\n"
+        EOL +
+        "}" +
+        EOL +
+        EOL
     : "";
+// const renderGetterConstruct = (
+//   config: GetterOptions | undefined,
+//   getterType: "all" | "byId",
+//   defaultReturnTypeBuilder: (entity: EntityDecl) => string,
+//   declarations: readonly Decl[],
+// ) => {
+//   if (!config) {
+//     return ""
+//   }
+//   const { returnTypeBuilder = defaultReturnTypeBuilder } = config
+//   const getLine: (decl: EntityDecl) => string = decl =>
+//     `export type ${decl.name} = (${getterType === "byId" ? `id: ${decl.name}_ID` : ""}) => ${returnTypeBuilder(decl)}`
+//   return (declarations.filter(isEntityDecl).map(getLine).join(EOL), EOL + EOL)
+// }
+// const renderGetters = (
+//   config:
+//     | Partial<{
+//         byId: GetterOptions
+//         all: GetterOptions
+//       }>
+//     | undefined,
+//   declarations: readonly Decl[],
+// ): string =>
+//   (
+//     [
+//       ["all", (entity: EntityDecl) => entity.name + "[]"],
+//       ["byId", (entity: EntityDecl) => entity.name + " | undefined"],
+//     ] as const
+//   )
+//     .map(key => renderGetterConstruct(config?.[key[0]], key[0], key[1], declarations))
+//     .join("")
 export const render = (options = defaultOptions, declarations) => {
     const finalOptions = { ...defaultOptions, ...options };
-    const [_, entityMap] = finalOptions.generateEntityMapType
-        ? renderEntityMapType(finalOptions, declarations)
-        : emptyRenderResult;
     const [imports, content] = renderDeclarations(finalOptions, flatMapAuxiliaryDecls((parentNodes, node) => {
         if (isNestedEntityMapType(node)) {
             return TypeAliasDecl(asDecl(parentNodes[0])?.sourceUrl ?? "", {
@@ -185,7 +228,8 @@ export const render = (options = defaultOptions, declarations) => {
         }
         return undefined;
     }, declarations));
-    return (entityMap +
+    return (renderEntityMapType(finalOptions, declarations) +
+        renderChildEntityMapType(finalOptions, declarations) +
         renderStringableTranslationParameterType(finalOptions) +
         (finalOptions.preserveFiles
             ? (declarations[0] === undefined ? "" : renderImports(declarations[0].sourceUrl, imports)) +

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

@@ -17,6 +17,7 @@ import type { SerializedReferenceIdentifierType } from "../../shared/schema/type
 import type { SerializedStringType } from "../../shared/schema/types/StringType.ts";
 import type { SerializedTranslationObjectType } from "../../shared/schema/types/TranslationObjectType.ts";
 import type { SerializedTypeArgumentType } from "../../shared/schema/types/TypeArgumentType.ts";
+import type { ValidationOptions } from "../index.ts";
 import { type DatabaseInMemory } from "../utils/databaseInMemory.ts";
 import { type Decl, type IncludableDeclP } from "./declarations/Declaration.ts";
 import { type EntityDecl } from "./declarations/EntityDecl.ts";
@@ -58,16 +59,17 @@ export type IdentifierToCheck = {
     name: string;
     value: unknown;
 };
-export interface Validators {
+export interface ValidationContext {
     useStyling: boolean;
     checkReferentialIntegrity: (identifier: IdentifierToCheck) => Error[];
+    checkTranslations?: ValidationOptions["checkTranslations"];
 }
-export declare const createValidators: (databaseInMemory: DatabaseInMemory, useStyling: boolean, checkReferentialIntegrity?: boolean) => Validators;
+export declare const createValidationContext: (options: Partial<ValidationOptions>, databaseInMemory: DatabaseInMemory, useStyling: boolean, checkReferentialIntegrity?: boolean) => ValidationContext;
 export type Predicate<T extends Node> = (node: Node) => node is T;
 export type GetNestedDeclarations<T extends Node = Node> = (addedDecls: NestedDecl[], node: T, parentDecl: Decl | undefined) => NestedDecl[];
 export declare const getNestedDeclarations: GetNestedDeclarations;
-export type Validator<T extends Node = Node> = (helpers: Validators, inDecls: Decl[], node: T, value: unknown) => Error[];
-export type ValidatorOfParamDecl<T extends Node = Node> = (helpers: Validators, inDecls: Decl[], node: T, typeArgs: Type[], value: unknown) => Error[];
+export type Validator<T extends Node = Node> = (helpers: ValidationContext, inDecls: Decl[], node: T, value: unknown) => Error[];
+export type ValidatorOfParamDecl<T extends Node = Node> = (helpers: ValidationContext, inDecls: Decl[], node: T, typeArgs: Type[], value: unknown) => Error[];
 export declare const validateDecl: ValidatorOfParamDecl<Decl>;
 export declare const validateType: Validator<Type>;
 export type NodeWithResolvedTypeArguments<T extends Node | null> = T extends BooleanType | DateType | FloatType | IntegerType | StringType | ReferenceIdentifierType | ChildEntitiesType | TranslationObjectType ? T : T extends EntityDecl<infer N, infer P, infer FK> ? EntityDecl<N, {

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

@@ -81,7 +81,7 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => reduceNodes((
     });
     return declsWithCurrentDecl.concat(normalizedResult);
 }, declarations);
-export const createValidators = (databaseInMemory, useStyling, checkReferentialIntegrity = true) => ({
+export const createValidationContext = (options, databaseInMemory, useStyling, checkReferentialIntegrity = true) => ({
     useStyling,
     checkReferentialIntegrity: checkReferentialIntegrity
         ? ({ name, value }) => getInstancesOfEntityFromDatabaseInMemory(databaseInMemory, name).some(instance => instance.id === value)
@@ -90,6 +90,7 @@ export const createValidators = (databaseInMemory, useStyling, checkReferentialI
                 ReferenceError(`Invalid reference to instance of entity ${entity(`"${name}"`, useStyling)} with identifier ${json(value, useStyling)}`),
             ]
         : () => [],
+    checkTranslations: options.checkTranslations,
 });
 export const getNestedDeclarations = (addedDecls, node, parentDecl) => {
     switch (node.kind) {

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

@@ -1,4 +1,7 @@
 import Debug from "debug";
+import { normalizeKeyPath, renderKeyPath, } from "../../shared/schema/declarations/EntityDecl.js";
+import { anySame } from "../../shared/utils/array.js";
+import { deepEqual } from "../../shared/utils/compare.js";
 import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { getParameterNames, walkNodeTree } from "./declarations/Declaration.js";
 import { isEntityDecl } from "./declarations/EntityDecl.js";
@@ -215,6 +218,66 @@ const checkRecursiveGenericTypeAliasesAndEnumerationsAreOnlyParameterizedDirectl
         }, decl);
     }
 };
+const getNodeAtKeyPath = (decl, objectType, keyPath, parent, parentPath = []) => {
+    const [key, ...keyPathRest] = normalizeKeyPath(keyPath);
+    if (key === undefined) {
+        return objectType;
+    }
+    const memberDecl = objectType.properties[key];
+    if (memberDecl === undefined) {
+        throw TypeError(`key "${key}"${parentPath.length === 0 ? "" : " in " + renderKeyPath(parentPath)} in unique constraint of entity "${decl.name}" does not exist in the entity`);
+    }
+    const value = memberDecl.type;
+    const actualValue = isIncludeIdentifierType(value) ? value.reference.type.value : value;
+    if (keyPathRest.length > 0) {
+        if (isObjectType(actualValue)) {
+            return getNodeAtKeyPath(decl, actualValue, keyPathRest, parent, [...parentPath, key]);
+        }
+        throw TypeError(`value at key "${key}"${parentPath.length === 0 ? "" : ' in "' + renderKeyPath(parentPath) + '"'}${parent ? " " + parent : ""} in unique constraint of entity "${decl.name}" does not contain an object type`);
+    }
+    return value;
+};
+const checkUniqueConstraintElement = (decl, element) => {
+    if ("keyPath" in element) {
+        getNodeAtKeyPath(decl, decl.type.value, element.keyPath);
+        if (element.keyPathFallback !== undefined) {
+            getNodeAtKeyPath(decl, decl.type.value, element.keyPathFallback);
+        }
+    }
+    else {
+        const entityMapType = getNodeAtKeyPath(decl, decl.type.value, element.entityMapKeyPath);
+        if (!isNestedEntityMapType(entityMapType)) {
+            throw TypeError(`value at key "${renderKeyPath(element.entityMapKeyPath)}" is not a nested entity map as required by the unique constraint of entity "${decl.name}"`);
+        }
+        const nestedType = entityMapType.type.value;
+        const actualType = isIncludeIdentifierType(nestedType)
+            ? nestedType.reference.type.value
+            : nestedType;
+        getNodeAtKeyPath(decl, actualType, element.keyPathInEntityMap, `in entity map "${renderKeyPath(element.entityMapKeyPath)}"`);
+        if (element.keyPathInEntityMapFallback !== undefined) {
+            getNodeAtKeyPath(decl, actualType, element.keyPathInEntityMapFallback, `in entity map "${renderKeyPath(element.entityMapKeyPath)}"`);
+        }
+    }
+};
+const checkUniqueConstraints = (declarations) => {
+    for (const decl of declarations) {
+        if (isEntityDecl(decl)) {
+            for (const constraint of decl.uniqueConstraints ?? []) {
+                if (Array.isArray(constraint)) {
+                    for (const constraintPart of constraint) {
+                        checkUniqueConstraintElement(decl, constraintPart);
+                    }
+                    if (anySame(constraint, deepEqual)) {
+                        throw TypeError(`there are duplicate key descriptions in a combined constraint of entity "${decl.name}"`);
+                    }
+                }
+                else {
+                    checkUniqueConstraintElement(decl, constraint);
+                }
+            }
+        }
+    }
+};
 const addDeclarations = (existingDecls, declsToAdd) => declsToAdd.reduce((accDecls, decl) => {
     if (!accDecls.includes(decl)) {
         return getNestedDeclarations(accDecls, decl.kind === "NestedEntity" ? decl.type : decl, undefined);
@@ -242,6 +305,8 @@ export const Schema = (declarations, localeEntity) => {
     checkChildEntityTypes(localeEntity, allDeclsWithoutNestedEntities);
     debug("checking generic recursive types ...");
     checkRecursiveGenericTypeAliasesAndEnumerationsAreOnlyParameterizedDirectlyInTypeAliases(allDeclsWithoutNestedEntities);
+    debug("checking unique constraints ...");
+    checkUniqueConstraints(allDeclsWithoutNestedEntities);
     debug("created schema, no integrity violations found");
     return {
         declarations: allDeclsWithoutNestedEntities,

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

@@ -1,3 +1,4 @@
+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 { GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../Node.ts";
@@ -36,6 +37,7 @@ export interface EntityDecl<Name extends string = string, T extends TConstraint
     displayName?: GenericEntityDisplayName;
     displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
     isDeprecated?: boolean;
+    uniqueConstraints?: UniqueConstraints;
 }
 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,6 +53,7 @@ export declare const EntityDecl: {
         displayName?: EntityDisplayName<T>;
         displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
         isDeprecated?: boolean;
+        uniqueConstraints?: UniqueConstraints;
     }): EntityDecl<Name, T, undefined>;
     <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string>>(sourceUrl: string, options: {
         name: Name;
@@ -64,6 +67,7 @@ export declare const EntityDecl: {
         displayName?: EntityDisplayName<T>;
         displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
         isDeprecated?: boolean;
+        uniqueConstraints?: UniqueConstraints;
     }): EntityDecl<Name, T, FK>;
 };
 export { EntityDecl as Entity };

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

@@ -1,5 +1,5 @@
 import { Lazy } from "../../../shared/utils/lazy.ts";
-import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validators } from "../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidationContext } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
 import type { Type } from "../types/Type.ts";
@@ -26,7 +26,7 @@ export declare const TypeAliasDecl: <Name extends string, T extends Type>(source
 export { TypeAliasDecl as TypeAlias };
 export declare const isTypeAliasDecl: Predicate<TypeAliasDecl>;
 export declare const getNestedDeclarationsInTypeAliasDecl: GetNestedDeclarations<TypeAliasDecl>;
-export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: Validators, inDecls: Decl[], decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
+export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(helpers: ValidationContext, inDecls: Decl[], decl: TypeAliasDecl<string, Type, Params>, args: TypeArguments<Params>, value: unknown) => Error[];
 export declare const resolveTypeArgumentsInTypeAliasDecl: TypeArgumentsResolver<TypeAliasDecl>;
 export declare const serializeTypeAliasDecl: Serializer<TypeAliasDecl>;
 export declare const getReferencesForTypeAliasDecl: GetReferences<TypeAliasDecl>;

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

@@ -1,4 +1,6 @@
+import { MessageError, parseMessage, validate } from "messageformat";
 import { sortObjectKeys } from "../../../../shared/utils/object.js";
+import { extendsParameterTypes, extractParameterTypeNamesFromMessage, } from "../../../../shared/utils/translation.js";
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { validateUnknownKeys } from "../../../../shared/validation/object.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
@@ -16,9 +18,9 @@ export const TranslationObjectType = (properties, options = {}) => {
 export { TranslationObjectType as TranslationObject };
 export const isTranslationObjectType = node => node.kind === NodeKind.TranslationObjectType;
 export const getNestedDeclarationsInTranslationObjectType = addedDecls => addedDecls;
-const validateRecursively = (helpers, allKeysAreRequired, type, value) => {
+const validateRecursively = (context, allKeysAreRequired, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
+        return [TypeError(`expected an object, but got ${json(value, context.useStyling)}`)];
     }
     const expectedKeys = Object.keys(type).filter(key => type[key] !== undefined);
     return parallelizeErrors([
@@ -27,19 +29,36 @@ const validateRecursively = (helpers, allKeysAreRequired, type, value) => {
             const propType = type[key];
             const propValue = value[key];
             if (allKeysAreRequired && propValue === undefined) {
-                return TypeError(`missing required translation ${keyColor(`"${key}"`, helpers.useStyling)}`);
+                return TypeError(`missing required translation ${keyColor(`"${key}"`, context.useStyling)}`);
             }
             if (propType === null && propValue !== undefined && typeof propValue !== "string") {
-                return TypeError(`expected a string at translation key ${keyColor(`"${key}"`, helpers.useStyling)}, but got ${json(propValue, helpers.useStyling)}`);
+                return TypeError(`expected a string at translation key ${keyColor(`"${key}"`, context.useStyling)}, but got ${json(propValue, context.useStyling)}`);
             }
             if (propType === null &&
                 typeof propValue === "string" &&
                 allKeysAreRequired &&
                 propValue.length === 0) {
-                return TypeError(`expected a non-empty string at translation key ${keyColor(`"${key}"`, helpers.useStyling)}`);
+                return TypeError(`expected a non-empty string at translation key ${keyColor(`"${key}"`, context.useStyling)}`);
+            }
+            if (typeof propValue === "string" && context.checkTranslations) {
+                try {
+                    validate(parseMessage(propValue));
+                }
+                catch (err) {
+                    if (err instanceof MessageError) {
+                        return TypeError(`invalid translation string at key ${keyColor(`"${key}"`, context.useStyling)}: ${err.message} in message ${json(propValue, context.useStyling)}`);
+                    }
+                }
+                if (context.checkTranslations.matchParametersInKeys) {
+                    const expectedParams = extractParameterTypeNamesFromMessage(key);
+                    const actualParams = extractParameterTypeNamesFromMessage(propValue);
+                    if (!extendsParameterTypes(expectedParams, actualParams)) {
+                        return TypeError(`parameter types in translation string at key ${keyColor(`"${key}"`, context.useStyling)} do not match the expected parameter types. Expected: ${json(expectedParams, context.useStyling)} Actual: ${json(actualParams, context.useStyling)}`);
+                    }
+                }
             }
             if (propType !== null && propValue !== undefined) {
-                return wrapErrorsIfAny(`at translation object key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateRecursively(helpers, allKeysAreRequired, propType, propValue));
+                return wrapErrorsIfAny(`at translation object key ${keyColor(`"${key}"`, context.useStyling)}`, validateRecursively(context, allKeysAreRequired, propType, propValue));
             }
             return undefined;
         }),

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

@@ -2,6 +2,7 @@ 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";
 import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
 import type { Schema } from "../schema/Schema.ts";
@@ -24,6 +25,7 @@ export interface TSONDBRequestLocals {
     defaultLocales: string[];
     locales: string[];
     homeLayoutSections?: HomeLayoutSection[];
+    validationOptions: Partial<ValidationOptions>;
     getInstanceById: GetInstanceById;
     setLocal: <K extends keyof Omit<TSONDBRequestLocals, "setLocal">>(key: K, value: TSONDBRequestLocals[K]) => void;
 }
@@ -37,4 +39,4 @@ declare global {
         }
     }
 }
-export declare const createServer: (schema: Schema, dataRootPath: string, databaseInMemory: DatabaseInMemory, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[], options?: Partial<ServerOptions>, customStylesheetPath?: string) => Promise<void>;
+export declare const createServer: (schema: Schema, dataRootPath: string, databaseInMemory: DatabaseInMemory, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[], options?: Partial<ServerOptions>, validationOptions?: Partial<ValidationOptions>, customStylesheetPath?: string) => Promise<void>;

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

@@ -16,7 +16,7 @@ const staticNodeModule = (moduleName) => {
     }
     return express.static(dirname(pathToPackageJson));
 };
-export const createServer = async (schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, options, customStylesheetPath) => {
+export const createServer = async (schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, options, validationOptions, customStylesheetPath) => {
     const { port } = { ...defaultOptions, ...options };
     const app = express();
     app.use(express.static(join(import.meta.dirname, "../../../../public")));
@@ -27,7 +27,7 @@ export const createServer = async (schema, dataRootPath, databaseInMemory, defau
     app.use("/js/client", express.static(join(import.meta.dirname, "../../../../dist/src/web")));
     app.use("/js/shared", express.static(join(import.meta.dirname, "../../../../dist/src/shared")));
     app.use(express.json());
-    const requestLocals = await init(schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections);
+    const requestLocals = await init(schema, dataRootPath, databaseInMemory, defaultLocales, validationOptions, homeLayoutSections);
     app.use((req, _res, next) => {
         debug("%s %s", req.method, req.originalUrl);
         requestLocals.setLocal = (key, value) => {

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

@@ -1,6 +1,7 @@
 import type { HomeLayoutSection } from "../config.ts";
+import type { ValidationOptions } from "../index.ts";
 import type { Schema } from "../schema/Schema.ts";
 import { type DatabaseInMemory } from "../utils/databaseInMemory.ts";
 import type { TSONDBRequestLocals } from "./index.ts";
-export declare const init: (schema: Schema, dataRootPath: string, databaseInMemory: DatabaseInMemory, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[]) => Promise<Omit<TSONDBRequestLocals, "setLocal">>;
+export declare const init: (schema: Schema, dataRootPath: string, databaseInMemory: DatabaseInMemory, defaultLocales: string[], validationOptions?: Partial<ValidationOptions>, homeLayoutSections?: HomeLayoutSection[]) => Promise<Omit<TSONDBRequestLocals, "setLocal">>;
 export declare const reinit: (locals: TSONDBRequestLocals) => Promise<void>;

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

@@ -22,7 +22,7 @@ const getGit = async (dataRootPath) => {
         return { git };
     }
 };
-export const init = async (schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections) => {
+export const init = async (schema, dataRootPath, databaseInMemory, defaultLocales, validationOptions = {}, homeLayoutSections) => {
     const { git, root: gitRoot, status: gitStatus } = await getGit(dataRootPath);
     const declarations = resolveTypeArgumentsInDecls(schema.declarations);
     debug("resolved type arguments in declarations");
@@ -61,6 +61,7 @@ export const init = async (schema, dataRootPath, databaseInMemory, defaultLocale
         defaultLocales,
         locales: defaultLocales,
         homeLayoutSections,
+        validationOptions,
     };
     return requestLocals;
 };

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.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, 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.entitiesByName, undefined, undefined, locals.localeEntity, instance.entityName, {
+    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, {
         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.entitiesByName, undefined, undefined, locals.localeEntity, entityName, {
+    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, {
         id: instanceId,
         content: instanceContainer.content,
         childInstances: oldChildInstances,

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

@@ -1,5 +1,6 @@
 import type { GitFileStatus } from "../../shared/utils/git.ts";
 import type { InstanceContainer, InstanceContent } from "../../shared/utils/instances.ts";
+import type { ValidationOptions } from "../index.ts";
 import type { EntityDecl, EntityDeclWithParentReference } from "../schema/declarations/EntityDecl.ts";
 import { type DatabaseInMemory } from "./databaseInMemory.ts";
 import type { TransactionResult } from "./databaseTransactions.ts";
@@ -29,6 +30,6 @@ export interface GenEntityTaggedInstanceContainerWithChildInstances<ID extends s
 }
 export declare const getChildInstancesFromEntity: (databaseInMemory: DatabaseInMemory, parentEntity: EntityDecl, parentId: string, childEntity: EntityDeclWithParentReference) => InstanceContainer[];
 export declare const getChildInstances: (databaseInMemory: DatabaseInMemory, parentEntity: EntityDecl, parentId: string, recursive?: boolean) => EntityTaggedInstanceContainerWithChildInstances[];
-export declare const saveInstanceTree: (entitiesByName: Record<string, EntityDecl>, parentEntityName: string | undefined, parentId: string | undefined, localeEntity: EntityDecl | undefined, entityName: string, oldInstance: EntityTaggedInstanceContainerWithChildInstances | undefined, newInstance: UnsafeEntityTaggedInstanceContainerWithChildInstances | undefined, customId: unknown, res: TransactionResult) => TransactionResult<{
+export declare const saveInstanceTree: (validationOptions: Partial<ValidationOptions>, entitiesByName: Record<string, EntityDecl>, parentEntityName: string | undefined, parentId: string | undefined, localeEntity: EntityDecl | undefined, entityName: string, oldInstance: EntityTaggedInstanceContainerWithChildInstances | undefined, newInstance: UnsafeEntityTaggedInstanceContainerWithChildInstances | undefined, customId: unknown, res: TransactionResult) => TransactionResult<{
     instanceContainer: InstanceContainer;
 }>;

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

@@ -50,7 +50,7 @@ const prepareNewChildInstanceContent = (entity, parentEntityName, parentId, cont
         return ok(content);
     }
 };
-export const saveInstanceTree = (entitiesByName, parentEntityName, parentId, localeEntity, entityName, oldInstance, newInstance, customId, res) => {
+export const saveInstanceTree = (validationOptions, entitiesByName, parentEntityName, parentId, localeEntity, entityName, oldInstance, newInstance, customId, res) => {
     if (isError(res)) {
         return res;
     }
@@ -65,7 +65,7 @@ export const saveInstanceTree = (entitiesByName, parentEntityName, parentId, loc
         }
         // delete all child instances recursively
         const deletedRes = deleteInstance(res, entity, oldInstance.id);
-        return map(oldInstance.childInstances.reduce((resAcc, oldChildInstance) => saveInstanceTree(entitiesByName, oldInstance.entityName, oldInstance.id, localeEntity, oldChildInstance.entityName, oldChildInstance, undefined, undefined, resAcc), deletedRes), data => ({
+        return map(oldInstance.childInstances.reduce((resAcc, oldChildInstance) => saveInstanceTree(validationOptions, entitiesByName, oldInstance.entityName, oldInstance.id, localeEntity, oldChildInstance.entityName, oldChildInstance, undefined, undefined, resAcc), deletedRes), data => ({
             ...data,
             instanceContainer: { id: oldInstance.id, content: oldInstance.content },
         }));
@@ -78,8 +78,8 @@ export const saveInstanceTree = (entitiesByName, parentEntityName, parentId, loc
             return preparedContent;
         }
         const setRes = newInstance.id === undefined
-            ? createInstance(res, localeEntity, entity, preparedContent.value, customId)
-            : map(updateInstance(res, entity, newInstance.id, preparedContent.value), data => ({
+            ? createInstance(validationOptions, res, localeEntity, entity, preparedContent.value, customId)
+            : map(updateInstance(validationOptions, res, entity, newInstance.id, preparedContent.value), data => ({
                 ...data,
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 instanceId: newInstance.id,
@@ -91,8 +91,8 @@ export const saveInstanceTree = (entitiesByName, parentEntityName, parentId, loc
         const setResWithoutInfo = ok({ ...setRes.value, additionalInformation: undefined });
         return map(newInstance.childInstances
             .filter(newChildInstance => newChildInstance.id === undefined)
-            .reduce((resAcc, newChildInstance) => saveInstanceTree(entitiesByName, newInstance.entityName, instanceId, localeEntity, newChildInstance.entityName, undefined, newChildInstance, undefined, resAcc), oldInstance
-            ? oldInstance.childInstances.reduce((resAcc, oldChildInstance) => saveInstanceTree(entitiesByName, oldInstance.entityName, instanceId, localeEntity, oldChildInstance.entityName, oldChildInstance, newInstance.childInstances.find(ci => ci.id === oldChildInstance.id), undefined, resAcc), setResWithoutInfo)
+            .reduce((resAcc, newChildInstance) => saveInstanceTree(validationOptions, entitiesByName, newInstance.entityName, instanceId, localeEntity, newChildInstance.entityName, undefined, newChildInstance, undefined, resAcc), oldInstance
+            ? oldInstance.childInstances.reduce((resAcc, oldChildInstance) => saveInstanceTree(validationOptions, entitiesByName, oldInstance.entityName, instanceId, localeEntity, oldChildInstance.entityName, oldChildInstance, newInstance.childInstances.find(ci => ci.id === oldChildInstance.id), undefined, resAcc), setResWithoutInfo)
             : setResWithoutInfo), data => ({
             ...data,
             instanceContainer: { id: instanceId, content: preparedContent.value },

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

@@ -3,6 +3,7 @@ import { deleteInstanceInDatabaseInMemory, setInstanceInDatabaseInMemory, } from
 import { applyStepsToDisk } from "./databaseOnDisk.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.
  */
@@ -17,6 +18,10 @@ 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 diskResult = await applyStepsToDisk(root, steps);
     if (isError(diskResult)) {
         return diskResult;

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

@@ -1,9 +1,10 @@
 import type { InstanceContent } from "../../shared/utils/instances.ts";
+import type { ValidationOptions } from "../index.ts";
 import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
 import { type TransactionResult } from "./databaseTransactions.ts";
 export declare const createNewId: () => `${string}-${string}-${string}-${string}-${string}`;
-export declare const createInstance: (res: TransactionResult, localeEntity: EntityDecl | undefined, entity: EntityDecl, instanceContent: InstanceContent, customId: unknown) => TransactionResult<{
+export declare const createInstance: (validationOptions: Partial<ValidationOptions>, res: TransactionResult, localeEntity: EntityDecl | undefined, entity: EntityDecl, instanceContent: InstanceContent, customId: unknown) => TransactionResult<{
     instanceId: string;
 }>;
-export declare const updateInstance: (res: TransactionResult, entity: EntityDecl, instanceId: string, instanceContent: InstanceContent) => TransactionResult;
+export declare const updateInstance: (validationOptions: Partial<ValidationOptions>, res: TransactionResult, entity: EntityDecl, instanceId: string, instanceContent: InstanceContent) => TransactionResult;
 export declare const deleteInstance: (res: TransactionResult, entity: EntityDecl, instanceId: string) => TransactionResult;

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

@@ -1,12 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { error, map, ok, then } from "../../shared/utils/result.js";
-import { createValidators, validateEntityDecl } from "../schema/index.js";
+import { createValidationContext, validateEntityDecl } from "../schema/index.js";
 import { getInstanceOfEntityFromDatabaseInMemory, } from "./databaseInMemory.js";
 import { deleteInstanceT, setInstanceT } from "./databaseTransactions.js";
 import { getErrorMessageForDisplay, HTTPError } from "./error.js";
 import { isReferencedByOtherInstances } from "./references.js";
 export const createNewId = () => randomUUID();
-const checkCreateInstancePossible = (localeEntity, databaseInMemory, entity, instanceContent, customId) => {
+const checkCreateInstancePossible = (validationOptions, localeEntity, databaseInMemory, entity, instanceContent, customId) => {
     const newInstanceId = entity === localeEntity ? customId : createNewId();
     if (typeof newInstanceId !== "string") {
         return error(new HTTPError(400, `New identifier "${String(newInstanceId)}" is not a string`));
@@ -16,11 +16,11 @@ const checkCreateInstancePossible = (localeEntity, databaseInMemory, entity, ins
             undefined) {
         return error(new HTTPError(400, `Duplicate id "${newInstanceId}" for locale entity`));
     }
-    return map(checkUpdateInstancePossible(databaseInMemory, entity, instanceContent), () => newInstanceId);
+    return map(checkUpdateInstancePossible(validationOptions, databaseInMemory, entity, instanceContent), () => newInstanceId);
 };
-export const createInstance = (res, localeEntity, entity, instanceContent, customId) => then(res, data => then(checkCreateInstancePossible(localeEntity, data.db, entity, instanceContent, customId), newInstanceId => map(setInstanceT(ok(data), entity, { id: newInstanceId, content: instanceContent }), data => ({ ...data, instanceId: newInstanceId }))));
-const checkUpdateInstancePossible = (databaseInMemory, entity, instanceContent) => {
-    const validationErrors = validateEntityDecl(createValidators(databaseInMemory, false), [], entity, instanceContent);
+export const createInstance = (validationOptions, res, localeEntity, entity, instanceContent, customId) => then(res, data => then(checkCreateInstancePossible(validationOptions, localeEntity, data.db, entity, instanceContent, customId), newInstanceId => map(setInstanceT(ok(data), entity, { id: newInstanceId, content: instanceContent }), data => ({ ...data, instanceId: newInstanceId }))));
+const checkUpdateInstancePossible = (validationOptions, databaseInMemory, entity, instanceContent) => {
+    const validationErrors = validateEntityDecl(createValidationContext(validationOptions, databaseInMemory, false), [], entity, instanceContent);
     if (validationErrors.length > 0) {
         return error(new HTTPError(400, validationErrors.map(getErrorMessageForDisplay).join("\n\n")));
     }
@@ -28,7 +28,7 @@ const checkUpdateInstancePossible = (databaseInMemory, entity, instanceContent)
         return ok();
     }
 };
-export const updateInstance = (res, entity, instanceId, instanceContent) => then(res, data => then(checkUpdateInstancePossible(data.db, entity, instanceContent), () => setInstanceT(ok(data), entity, { id: instanceId, content: instanceContent })));
+export const updateInstance = (validationOptions, res, entity, instanceId, instanceContent) => then(res, data => then(checkUpdateInstancePossible(validationOptions, data.db, entity, instanceContent), () => setInstanceT(ok(data), entity, { id: instanceId, content: instanceContent })));
 const checkDeleteInstancePossible = (referencesToInstances, instanceId) => {
     if (isReferencedByOtherInstances(referencesToInstances, instanceId)) {
         return error(new HTTPError(400, "Cannot delete instance that is referenced by other instances"));

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

@@ -0,0 +1,19 @@
+import type { InstanceContainer } 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";
+/**
+ * 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>;
+/**
+ * Checks all unique 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 unique
+ * constraint.
+ */
+export declare const checkUniqueConstraintsForAllEntities: (db: DatabaseInMemory, entities: EntityDecl[]) => Result<void, AggregateError>;

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

@@ -0,0 +1,94 @@
+import { normalizeKeyPath, renderKeyPath, } from "../../shared/schema/declarations/EntityDecl.js";
+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
+    ? renderKeyPath(elem.keyPath) +
+        (elem.keyPathFallback ? "|" + renderKeyPath(elem.keyPathFallback) : "")
+    : renderKeyPath(elem.entityMapKeyPath) +
+        "[...]." +
+        (elem.keyPathInEntityMapFallback
+            ? "(" +
+                renderKeyPath(elem.keyPathInEntityMap) +
+                "|" +
+                renderKeyPath(elem.keyPathInEntityMapFallback) +
+                ")"
+            : renderKeyPath(elem.keyPathInEntityMap)))
+    .join("+");
+const unsafeGetValueAtKeyPath = (value, keyPath) => {
+    let acc = value;
+    for (const key of normalizeKeyPath(keyPath)) {
+        acc = acc[key];
+    }
+    return acc;
+};
+/**
+ * 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 const checkUniqueConstraintsForEntity = (entity, instances) => {
+    const constraintErrors = [];
+    const constraints = entity.uniqueConstraints ?? [];
+    for (const [constraintIndex, constraint] of constraints.entries()) {
+        const normalizedConstraint = Array.isArray(constraint) ? constraint : [constraint];
+        // the index contains all instances as rows with multiple rows per instance for all possible combinations of nested entity map values
+        const index = instances.flatMap(({ id, content }) => flatCombine(normalizedConstraint.map(elem => {
+            if ("keyPath" in elem) {
+                return [
+                    unsafeGetValueAtKeyPath(content, elem.keyPath) ??
+                        (elem.keyPathFallback
+                            ? unsafeGetValueAtKeyPath(content, elem.keyPathFallback)
+                            : undefined),
+                ];
+            }
+            else {
+                return Object.entries(unsafeGetValueAtKeyPath(content, elem.entityMapKeyPath)).map(([nestedId, nestedContent]) => [
+                    nestedId,
+                    unsafeGetValueAtKeyPath(nestedContent, elem.keyPathInEntityMap) ??
+                        (elem.keyPathInEntityMapFallback
+                            ? unsafeGetValueAtKeyPath(nestedContent, elem.keyPathInEntityMapFallback)
+                            : undefined),
+                ]);
+            }
+        })).map((row) => [id, row]));
+        const duplicates = anySameIndices(index, (a, b) => deepEqual(a[1], b[1]));
+        if (duplicates.length > 0) {
+            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])),
+            ]);
+        }
+    }
+    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`)), 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- constraint must be present
+        `in unique constraint ${printUniqueConstraint(constraints[constraintIndex])}`)), `in entity "${entity.name}"`));
+    }
+    return ok();
+};
+/**
+ * Checks all unique 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 unique
+ * constraint.
+ */
+export const checkUniqueConstraintsForAllEntities = (db, entities) => mapError(entities.reduce((acc, entity) => {
+    const resultForEntity = checkUniqueConstraintsForEntity(entity, getInstancesOfEntityFromDatabaseInMemory(db, entity.name));
+    if (isError(acc)) {
+        if (isError(resultForEntity)) {
+            return error([...acc.error, resultForEntity.error]);
+        }
+        return acc;
+    }
+    if (isError(resultForEntity)) {
+        return error([resultForEntity.error]);
+    }
+    return acc;
+}, ok()), errors => new AggregateError(errors, "at least one unique constraint has been violated"));

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

@@ -18,6 +18,33 @@ type TSerializedConstraint = Record<string, SerializedMemberDecl>;
 type SerializedPathTo<T extends TSerializedConstraint, R> = {
     [K in keyof T]: T[K] extends SerializedMemberDecl<infer V> ? V extends R ? K : R extends V ? string : T[K] extends SerializedObjectType<infer P> ? `${Extract<K, string>}.${SerializedPathTo<P, R>}` : never : never;
 }[Extract<keyof T, string>];
+export type KeyPath = string | string[];
+export declare const normalizeKeyPath: (keyPath: KeyPath) => string[];
+export declare const renderKeyPath: (keyPath: KeyPath) => string;
+/**
+ * A uniquing element can be the full value of a key or the value of a key in a nested entity map.
+ */
+export type UniquingElement = {
+    keyPath: KeyPath;
+    keyPathFallback?: KeyPath;
+} | {
+    entityMapKeyPath: KeyPath;
+    keyPathInEntityMap: KeyPath;
+    keyPathInEntityMapFallback?: KeyPath;
+};
+export type UniqueConstraint = UniquingElement | UniquingElement[];
+/**
+ * A list of keys or key descriptions whose values need to be unique across all instances in the entity.
+ *
+ * One or more constraints may be provided. A nested array indicates that the combination of described values must be unique.
+ *
+ * @example
+ *
+ * ["name"] // all `name` keys must be unique across the entity
+ * ["name", "age"] // all `name` keys and all `age` keys must be unique across the entity
+ * [["name", "age"]] // the combination of `name` and `age` must be unique across the entity
+ */
+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;
@@ -29,6 +56,7 @@ export interface SerializedEntityDecl<Name extends string = string, T extends TS
     displayName?: GenericEntityDisplayName;
     displayNameCustomizer: boolean;
     isDeprecated?: boolean;
+    uniqueConstraints?: UniqueConstraints;
 }
 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/declarations/EntityDecl.js

@@ -1,5 +1,7 @@
 import { NodeKind, resolveSerializedTypeArguments, } from "../Node.js";
 import { getReferencesForSerializedObjectType, } from "../types/ObjectType.js";
+export const normalizeKeyPath = (keyPath) => Array.isArray(keyPath) ? keyPath : [keyPath];
+export const renderKeyPath = (keyPath) => normalizeKeyPath(keyPath).join(".");
 export const isSerializedEntityDecl = (node) => node.kind === NodeKind.EntityDecl;
 export const isSerializedEntityDeclWithParentReference = (decl) => decl.parentReferenceKey !== undefined;
 export const isSerializedEntityDeclWithoutParentReference = (decl) => decl.parentReferenceKey === undefined;

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

@@ -18,6 +18,24 @@ export interface ArrayDiffResult<T> {
     removed: T[];
 }
 export declare const unique: <T>(arr: T[], equalityCheck?: (a: T, b: T) => boolean) => T[];
+/**
+ * Checks if there are any duplicate elements in the array.
+ */
+export declare const anySame: <T>(arr: T[], equalityCheck?: (a: T, b: T) => boolean) => boolean;
+/**
+ * Checks if there are any duplicate elements in the array and returns an array
+ * of found duplicates where the values are the indices of these values.
+ */
+export declare const anySameIndices: <T>(arr: T[], equalityCheck?: (a: T, b: T) => boolean) => number[][];
+/**
+ * Returns the possibilities of all the combinations of nested array values.
+ *
+ * @example
+ *
+ * flatCombine([["a", "b"], ["c"]]) // [["a", "c"], ["b", "c"]]
+ * flatCombine([["a", "b"], ["c", "d"]]) // [["a", "c"], ["b", "c"], ["a", "d"], ["b", "d"]]
+ */
+export declare const flatCombine: <T>(arr: T[][]) => T[][];
 /**
  * Moves an element from one position to another within the array.
  */

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

@@ -29,6 +29,38 @@ export const difference = (oldArr, newArr) => newArr.reduce((acc, item) => {
     return acc;
 }, { removed: oldArr, added: newArr });
 export const unique = (arr, equalityCheck = (a, b) => a === b) => arr.filter((item, index) => arr.findIndex(other => equalityCheck(item, other)) === index);
+/**
+ * Checks if there are any duplicate elements in the array.
+ */
+export const anySame = (arr, equalityCheck = (a, b) => a === b) => arr.some((item, index) => arr.findIndex(other => equalityCheck(item, other)) !== index);
+/**
+ * Checks if there are any duplicate elements in the array and returns an array
+ * of found duplicates where the values are the indices of these values.
+ */
+export const anySameIndices = (arr, equalityCheck = (a, b) => a === b) => arr.reduce((acc, item, index) => {
+    const firstIndex = arr.findIndex(other => equalityCheck(item, other));
+    if (firstIndex === index) {
+        return acc;
+    }
+    const accIndex = acc.findIndex(accElem => accElem[0] === firstIndex);
+    return accIndex === -1
+        ? [...acc, [firstIndex, index]]
+        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- The index must exist according to the findIndex above
+            acc.with(accIndex, [...acc[accIndex], index]);
+}, []);
+/**
+ * Returns the possibilities of all the combinations of nested array values.
+ *
+ * @example
+ *
+ * flatCombine([["a", "b"], ["c"]]) // [["a", "c"], ["b", "c"]]
+ * flatCombine([["a", "b"], ["c", "d"]]) // [["a", "c"], ["b", "c"], ["a", "d"], ["b", "d"]]
+ */
+export const flatCombine = (arr) => arr.length === 0
+    ? []
+    : arr.slice(1).reduce((acc, elem) => elem.flatMap(elemInner => acc.map(accElem => [...accElem, elemInner])), 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- it is checked before if the array is empty
+    arr[0].map(elem => [elem]));
 /**
  * Moves an element from one position to another within the array.
  */

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

@@ -1,2 +1,7 @@
 export declare const extractParameterTypeNamesFromMessage: (message: string) => Record<string, string | null>;
 export declare const mapParameterTypeNames: <T>(typeMap: Record<string, string | null>, map: (typeName: string | null) => T) => Record<string, T>;
+/**
+ * Checks whether one set of parameter types (`ext`) is a subset of (or equals)
+ * another (`base`).
+ */
+export declare const extendsParameterTypes: (base: Record<string, string | null>, ext: Record<string, string | null>) => boolean;

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

@@ -26,6 +26,12 @@ const extractParameterFromDeclaration = (decl) => {
     }
 };
 const extractParametersFromDeclarations = (decls) => decls.reduce((acc, decl) => reduceMapAssoc(extractParameterFromDeclaration, acc, decl), {});
+const ignoreLocalVariables = (decls, acc) => decls.reduce((acc, decl) => reduceADT({
+    local: (acc, localDecl) => {
+        const { [localDecl.name]: _, ...rest } = acc;
+        return rest;
+    },
+}, acc, decl), acc);
 const reduceParametersFromPattern = (acc, pattern) => pattern.reduce((acc, element) => {
     if (typeof element === "string") {
         return acc;
@@ -46,9 +52,9 @@ export const extractParameterTypeNamesFromMessage = (message) => {
         const dataModel = parseMessage(message);
         switch (dataModel.type) {
             case "message":
-                return reduceParametersFromPattern(extractParametersFromDeclarations(dataModel.declarations), dataModel.pattern);
+                return ignoreLocalVariables(dataModel.declarations, reduceParametersFromPattern(extractParametersFromDeclarations(dataModel.declarations), dataModel.pattern));
             case "select": {
-                return dataModel.selectors.reduce((acc, variable) => mergeAssoc(acc, variable.name, null), dataModel.variants.reduce((acc, variant) => reduceParametersFromPattern(acc, variant.value), extractParametersFromDeclarations(dataModel.declarations)));
+                return ignoreLocalVariables(dataModel.declarations, dataModel.selectors.reduce((acc, variable) => mergeAssoc(acc, variable.name, null), dataModel.variants.reduce((acc, variant) => reduceParametersFromPattern(acc, variant.value), extractParametersFromDeclarations(dataModel.declarations))));
             }
             default:
                 return assertExhaustive(dataModel);
@@ -64,3 +70,23 @@ export const extractParameterTypeNamesFromMessage = (message) => {
     }
 };
 export const mapParameterTypeNames = (typeMap, map) => Object.fromEntries(Object.entries(typeMap).map(([key, typeName]) => [key, map(typeName)]));
+/**
+ * Checks whether one set of parameter types (`ext`) is a subset of (or equals)
+ * another (`base`).
+ */
+export const extendsParameterTypes = (base, ext) => {
+    for (const [key, typeName] of Object.entries(ext)) {
+        if (typeName === null || typeof typeName === "string") {
+            const baseTypeName = base[key];
+            if (baseTypeName === undefined) {
+                // extra parameter not in base
+                return false;
+            }
+            if (typeof typeName === "string" && baseTypeName !== typeName) {
+                // type in extension is neither null (any) nor matches the base type
+                return false;
+            }
+        }
+    }
+    return true;
+};

package/package.json

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