tsondb 0.12.9 → 0.13.0

package/dist/src/node/index.js

@@ -2,6 +2,7 @@ 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 { createValidationContext } from "./schema/Node.js";
@@ -10,6 +11,7 @@ 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 });
@@ -31,11 +33,32 @@ const _validate = (dataRootPath, entities, databaseInMemory, options = {}) => {
         }
     }
     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(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");
     }

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/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/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/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/package.json

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