tsondb 0.12.7 → 0.12.9

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

@@ -4,7 +4,7 @@ import { join, sep } from "path";
 import { styleText } from "util";
 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";
@@ -30,11 +30,11 @@ 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);
     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("All entities are valid");
@@ -57,7 +57,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 +66,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

@@ -5,5 +5,11 @@ export type TypeScriptRendererOptions = {
     preserveFiles: boolean;
     generateEntityMapType: boolean;
     addIdentifierToEntities: boolean;
+    /**
+     * Infer translation parameter types from the message strings in a {@link TranslationObjectType TranslationObject} as branded types.
+     */
+    inferTranslationParameters?: {
+        format: "mf2";
+    };
 };
 export declare const render: (options: Partial<TypeScriptRendererOptions> | undefined, declarations: readonly Decl[]) => string;

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

@@ -3,6 +3,7 @@ import { dirname, relative } from "node:path";
 import { discriminatorKey } from "../../../shared/enum.js";
 import { unique } from "../../../shared/utils/array.js";
 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";
@@ -14,7 +15,7 @@ import { getTypeOfKey } from "../../schema/types/generic/TranslationObjectType.j
 import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
-import { combineSyntaxes, emptyRenderResult, indent, prefixLines, syntax, } from "../../utils/render.js";
+import { combineSyntaxes, emptyRenderResult, getIndentation, indent, prefixLines, syntax, } from "../../utils/render.js";
 const defaultOptions = {
     indentation: 2,
     objectTypeKeyword: "interface",
@@ -62,8 +63,34 @@ const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.va
     ? ""
     : syntax `${EOL}${caseName}: ${renderType(options, caseDef.type)}`}`)}${EOL}}`)));
 const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));
+const mapTypeNameToType = (typeName) => {
+    switch (typeName) {
+        case "string":
+            return "string";
+        case "number":
+        case "integer":
+            return "number";
+        case "date":
+        case "datetime":
+        case "time":
+            return "Date";
+        case null:
+        default:
+            return "StringableTranslationParameter";
+    }
+};
+const renderTranslationParameterBrand = (options, params) => {
+    if (options.inferTranslationParameters === undefined) {
+        return emptyRenderResult;
+    }
+    const entries = Object.entries(params);
+    if (entries.length === 0) {
+        return emptyRenderResult;
+    }
+    return syntax ` & { __params: { ${entries.map(([name, type]) => `"${name}": ${type}`).join("; ")} } }`;
+};
 const renderTranslationObjectType = (options, type) => {
-    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}`), EOL));
+    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}${renderTranslationParameterBrand(options, mapParameterTypeNames(extractParameterTypeNamesFromMessage(name), mapTypeNameToType))}`), EOL));
 };
 const renderType = (options, type) => {
     switch (type.kind) {
@@ -135,6 +162,11 @@ const renderEntityMapType = (options, declarations) => syntax `export type Entit
     .filter(isEntityDecl)
     .sort((a, b) => a.name.localeCompare(b.name))
     .map(decl => syntax `${decl.name}: ${decl.name}`), EOL))}${EOL}}${EOL + EOL}`;
+const renderStringableTranslationParameterType = (options) => options.inferTranslationParameters?.format === "mf2"
+    ? "export type StringableTranslationParameter = {\n" +
+        prefixLines(getIndentation(options.indentation, 1), "toString(): string") +
+        "\n}\n\n"
+    : "";
 export const render = (options = defaultOptions, declarations) => {
     const finalOptions = { ...defaultOptions, ...options };
     const [_, entityMap] = finalOptions.generateEntityMapType
@@ -154,6 +186,7 @@ export const render = (options = defaultOptions, declarations) => {
         return undefined;
     }, declarations));
     return (entityMap +
+        renderStringableTranslationParameterType(finalOptions) +
         (finalOptions.preserveFiles
             ? (declarations[0] === undefined ? "" : renderImports(declarations[0].sourceUrl, imports)) +
                 content

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

@@ -20,6 +20,13 @@ const checkDuplicateIdentifier = (existingDecls, decl) => {
         throw new Error(`Duplicate declaration name "${decl.name}" in "${decl.sourceUrl}" and "${existingDeclWithSameName.sourceUrl}". Make sure declaration names are globally unique.`);
     }
 };
+// const checkReservedIdentifier = (decl: NestedDecl) => {
+//   if (RESERVED_DECLARATION_IDENTIFIER.includes(decl.name)) {
+//     throw new Error(
+//       `Declaration "${decl.name}" in "${decl.sourceUrl}" uses a reserved identifier name.`,
+//     )
+//   }
+// }
 const checkParameterNamesShadowing = (decls) => {
     for (const decl of decls) {
         for (const param of getParameterNames(decl)) {
@@ -219,9 +226,10 @@ export const Schema = (declarations, localeEntity) => {
     debug("collecting nested declarations ...");
     const allDecls = addDeclarations([], localeEntity ? declarations.concat(localeEntity) : declarations);
     debug("found %d nested declarations", allDecls.length);
-    debug("checking for duplicate identifiers ...");
+    debug("checking for duplicate identifiers ..."); // debug("checking for duplicate or reserved identifiers ...")
     allDecls.forEach((decl, declIndex) => {
         checkDuplicateIdentifier(allDecls.slice(0, declIndex), decl);
+        // checkReservedIdentifier(decl)
     });
     const allDeclsWithoutNestedEntities = allDecls.filter(decl => decl.kind !== "NestedEntity");
     debug("checking name shadowing ...");

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/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/render.d.ts

@@ -7,4 +7,5 @@ export type RenderResult = [imports: {
 export declare const emptyRenderResult: RenderResult;
 export declare const combineSyntaxes: (syntaxes: (RenderResult | string | undefined)[], separator?: string) => RenderResult;
 export declare const syntax: (strings: TemplateStringsArray, ...values: (RenderResult | string | undefined)[]) => RenderResult;
+export declare const getIndentation: (spaces: number, indentLevel: number) => string;
 export declare const indent: (spaces: number, indentLevel: number, text: RenderResult) => RenderResult;

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

@@ -28,7 +28,8 @@ export const syntax = (strings, ...values) => strings.reduce((acc, str, i) => {
         return [acc[0], acc[1] + str.replace(/\n/g, EOL)];
     }
 }, emptyRenderResult);
+export const getIndentation = (spaces, indentLevel) => " ".repeat(spaces * indentLevel);
 export const indent = (spaces, indentLevel, text) => [
     text[0],
-    prefixLines(" ".repeat(spaces * indentLevel), text[1]),
+    prefixLines(getIndentation(spaces, indentLevel), text[1]),
 ];

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

@@ -0,0 +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

@@ -0,0 +1,92 @@
+import { MessageError, parseMessage } from "messageformat";
+import { assertExhaustive } from "./typeSafety.js";
+const mergeAssoc = (acc, key, value) => {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- if there is a previous value and the current result is null, keep the more specific one
+    return { ...acc, [key]: value ?? acc[key] };
+};
+const reduceMapAssoc = (map, acc, item) => {
+    const result = map(item);
+    if (result) {
+        return mergeAssoc(acc, result[0], result[1]);
+    }
+    return acc;
+};
+const reduceADT = (cases, acc, item) => {
+    const caseFn = cases[item.type];
+    return caseFn?.(acc, item) ?? acc;
+};
+const extractParameterFromDeclaration = (decl) => {
+    switch (decl.type) {
+        case "input":
+            return [decl.name, decl.value.functionRef?.name ?? null];
+        case "local":
+            return undefined;
+        default:
+            return assertExhaustive(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;
+    }
+    return reduceADT({
+        expression: (acc, element) => {
+            if (!element.arg) {
+                return acc;
+            }
+            return reduceADT({
+                variable: (acc, variable) => mergeAssoc(acc, variable.name, element.functionRef?.name ?? null),
+            }, acc, element.arg);
+        },
+    }, acc, element);
+}, acc);
+export const extractParameterTypeNamesFromMessage = (message) => {
+    try {
+        const dataModel = parseMessage(message);
+        switch (dataModel.type) {
+            case "message":
+                return ignoreLocalVariables(dataModel.declarations, reduceParametersFromPattern(extractParametersFromDeclarations(dataModel.declarations), dataModel.pattern));
+            case "select": {
+                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);
+        }
+    }
+    catch (error) {
+        if (error instanceof MessageError) {
+            throw new MessageError(error.message, message);
+        }
+        else {
+            throw error;
+        }
+    }
+};
+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.7",
+  "version": "0.12.9",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -50,6 +50,7 @@
     "@preact/signals": "^2.5.1",
     "debug": "^4.4.3",
     "express": "^5.1.0",
+    "messageformat": "^4.0.0",
     "preact": "^10.27.2",
     "preact-iso": "^2.11.0",
     "simple-cli-args": "^0.1.3",