tsondb 0.12.3 → 0.12.6

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

@@ -2,7 +2,6 @@ import type { InstanceContainer } from "../../../shared/utils/instances.ts";
 import { type Result } from "../../../shared/utils/result.ts";
 import { type CreatedEntityTaggedInstanceContainerWithChildInstances, type UpdatedEntityTaggedInstanceContainerWithChildInstances } from "../../utils/childInstances.ts";
 import type { TSONDBRequestLocals } from "../index.ts";
-export declare const updateLocalsAfterInstanceChangeToReflectDiskState: (locals: TSONDBRequestLocals, entityName: string, instanceId: string, newInstanceContent: unknown) => Promise<InstanceContainer>;
-export declare const createInstance: (locals: TSONDBRequestLocals, instance: CreatedEntityTaggedInstanceContainerWithChildInstances, idQueryParam: unknown) => Promise<Result<InstanceContainer, [code: number, message: string]>>;
-export declare const updateInstance: (locals: TSONDBRequestLocals, instance: UpdatedEntityTaggedInstanceContainerWithChildInstances) => Promise<Result<InstanceContainer, [code: number, message: string]>>;
-export declare const deleteInstance: (locals: TSONDBRequestLocals, entityName: string, instanceId: string) => Promise<Result<InstanceContainer, [code: number, message: string]>>;
+export declare const createInstance: (locals: TSONDBRequestLocals, instance: CreatedEntityTaggedInstanceContainerWithChildInstances, idQueryParam: unknown) => Promise<Result<InstanceContainer, Error>>;
+export declare const updateInstance: (locals: TSONDBRequestLocals, instance: UpdatedEntityTaggedInstanceContainerWithChildInstances) => Promise<Result<InstanceContainer, Error>>;
+export declare const deleteInstance: (locals: TSONDBRequestLocals, entityName: string, instanceId: string) => Promise<Result<InstanceContainer, Error>>;

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

@@ -1,107 +1,67 @@
-import { removeAt } from "../../../shared/utils/array.js";
 import { error, isError, ok } from "../../../shared/utils/result.js";
-import { checkWriteInstanceTreePossible, getChildInstances, unsafeApplyInstanceTree, } from "../../utils/childInstances.js";
-import { getFileNameForId } from "../../utils/files.js";
-import { getGitFileStatusFromStatusResult } from "../../utils/git.js";
-import * as Instances from "../../utils/instanceOperations.js";
-import { updateReferencesToInstances } from "../../utils/references.js";
-import { updateLocalsAfterInstanceTreeChangeToReflectDiskState } from "./childInstances.js";
-export const updateLocalsAfterInstanceChangeToReflectDiskState = async (locals, entityName, instanceId, newInstanceContent) => {
-    const oldInstances = locals.instancesByEntityName[entityName] ?? [];
-    const oldInstanceContainerIndex = oldInstances.findIndex(instance => instance.id === instanceId);
-    const oldInstanceContainer = oldInstanceContainerIndex > -1 ? oldInstances[oldInstanceContainerIndex] : undefined;
-    const instanceContainer = oldInstanceContainer ?? {
-        id: instanceId,
-        content: undefined,
-    };
-    // old content as alternative if instance is deleted to restore old instance container
-    instanceContainer.content = newInstanceContent ?? instanceContainer.content;
-    instanceContainer.gitStatus =
-        locals.gitRoot === undefined
-            ? undefined
-            : getGitFileStatusFromStatusResult(await locals.git.status(), locals.gitRoot, locals.dataRoot, entityName, getFileNameForId(instanceId));
-    if (oldInstanceContainer === undefined) {
-        locals.instancesByEntityName[entityName] = [...oldInstances, instanceContainer];
-    }
-    else if (newInstanceContent === undefined) {
-        locals.instancesByEntityName[entityName] = removeAt(oldInstances, oldInstanceContainerIndex);
-    }
-    Object.assign(locals.referencesToInstances, updateReferencesToInstances(locals.entitiesByName, locals.referencesToInstances, entityName, instanceId, oldInstanceContainer?.content, newInstanceContent));
-    return instanceContainer;
-};
+import { getChildInstances, saveInstanceTree, } from "../../utils/childInstances.js";
+import { getInstanceOfEntityFromDatabaseInMemory } from "../../utils/databaseInMemory.js";
+import { runDatabaseTransaction } from "../../utils/databaseTransactions.js";
+import { HTTPError } from "../../utils/error.js";
 export const createInstance = async (locals, instance, idQueryParam) => {
     const entity = locals.entitiesByName[instance.entityName];
     if (entity === undefined) {
-        return error([400, "Entity not found"]);
+        return error(new HTTPError(400, "Entity not found"));
     }
-    const checkTreeResult = checkWriteInstanceTreePossible(locals.entitiesByName, locals.instancesByEntityName, locals.referencesToInstances, instance.id, entity.name, [], instance.childInstances);
-    if (isError(checkTreeResult)) {
-        return checkTreeResult;
+    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));
+    if (isError(databaseTransactionResult)) {
+        return databaseTransactionResult;
     }
-    const res = await Instances.createInstance(locals.dataRoot, locals.localeEntity, locals.instancesByEntityName, entity, instance.content, idQueryParam);
-    if (isError(res)) {
-        return res;
-    }
-    const newInstanceId = res.value;
-    const treeRes = await unsafeApplyInstanceTree(locals.dataRoot, locals.entitiesByName, locals.instancesByEntityName, newInstanceId, instance.entityName, [], instance.childInstances);
-    if (isError(treeRes)) {
-        return treeRes;
-    }
-    const instanceContainer = await updateLocalsAfterInstanceChangeToReflectDiskState(locals, entity.name, newInstanceId, instance.content);
-    await updateLocalsAfterInstanceTreeChangeToReflectDiskState(locals, newInstanceId, entity.name, [], instance.childInstances);
+    const { db: newDatabaseInMemory, refs: newReferencesToInstances, instanceContainer, } = databaseTransactionResult.value;
+    locals.setLocal("databaseInMemory", newDatabaseInMemory);
+    locals.setLocal("referencesToInstances", newReferencesToInstances);
     return ok(instanceContainer);
 };
 export const updateInstance = async (locals, instance) => {
-    const instanceContainer = locals.instancesByEntityName[instance.entityName]?.find(instance => instance.id === instance.id);
+    const instanceContainer = getInstanceOfEntityFromDatabaseInMemory(locals.databaseInMemory, instance.entityName, instance.id);
     if (instanceContainer === undefined) {
-        return error([404, "Instance not found"]);
+        return error(new HTTPError(400, "Instance not found"));
     }
     const entity = locals.entitiesByName[instance.entityName];
     if (entity === undefined) {
-        return error([400, "Entity not found"]);
-    }
-    const oldChildInstances = getChildInstances(locals.instancesByEntityName, entity, instance.id);
-    const checkTreeResult = checkWriteInstanceTreePossible(locals.entitiesByName, locals.instancesByEntityName, locals.referencesToInstances, instance.id, entity.name, oldChildInstances, instance.childInstances);
-    if (isError(checkTreeResult)) {
-        return checkTreeResult;
-    }
-    const res = await Instances.updateInstance(locals.dataRoot, locals.instancesByEntityName, entity, instance.id, instance.content);
-    if (isError(res)) {
-        return res;
-    }
-    const treeRes = await unsafeApplyInstanceTree(locals.dataRoot, locals.entitiesByName, locals.instancesByEntityName, instance.id, instance.entityName, oldChildInstances, instance.childInstances);
-    if (isError(treeRes)) {
-        return treeRes;
-    }
-    const newInstanceContainer = await updateLocalsAfterInstanceChangeToReflectDiskState(locals, entity.name, instance.id, instance.content);
-    await updateLocalsAfterInstanceTreeChangeToReflectDiskState(locals, instance.id, instance.entityName, oldChildInstances, instance.childInstances);
+        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, {
+        id: instance.id,
+        content: instanceContainer.content,
+        childInstances: oldChildInstances,
+        entityName: instance.entityName,
+    }, instance, undefined, res));
+    if (isError(databaseTransactionResult)) {
+        return databaseTransactionResult;
+    }
+    const { db: newDatabaseInMemory, refs: newReferencesToInstances, instanceContainer: newInstanceContainer, } = databaseTransactionResult.value;
+    locals.setLocal("databaseInMemory", newDatabaseInMemory);
+    locals.setLocal("referencesToInstances", newReferencesToInstances);
     return ok(newInstanceContainer);
 };
 export const deleteInstance = async (locals, entityName, instanceId) => {
-    const instances = locals.instancesByEntityName[entityName] ?? [];
-    const instanceContainerIndex = instances.findIndex(instance => instance.id === instanceId);
-    const instanceContainer = instances[instanceContainerIndex];
+    const instanceContainer = getInstanceOfEntityFromDatabaseInMemory(locals.databaseInMemory, entityName, instanceId);
     if (instanceContainer === undefined) {
-        return error([404, "Instance not found"]);
+        return error(new HTTPError(400, "Instance not found"));
     }
     const entity = locals.entitiesByName[entityName];
     if (entity === undefined) {
-        return error([400, "Entity not found"]);
-    }
-    const oldChildInstances = getChildInstances(locals.instancesByEntityName, entity, instanceContainer.id);
-    const checkTreeResult = checkWriteInstanceTreePossible(locals.entitiesByName, locals.instancesByEntityName, locals.referencesToInstances, instanceContainer.id, entityName, oldChildInstances, []);
-    if (isError(checkTreeResult)) {
-        return checkTreeResult;
+        return error(new HTTPError(400, "Entity not found"));
     }
-    const res = await Instances.deleteInstance(locals.dataRoot, locals.referencesToInstances, entityName, instanceId);
-    if (isError(res)) {
-        return res;
-    }
-    const treeRes = await unsafeApplyInstanceTree(locals.dataRoot, locals.entitiesByName, locals.instancesByEntityName, instanceContainer.id, entityName, oldChildInstances, []);
-    if (isError(treeRes)) {
-        return treeRes;
-    }
-    const oldInstanceContainer = await updateLocalsAfterInstanceChangeToReflectDiskState(locals, entity.name, instanceContainer.id, undefined);
-    await updateLocalsAfterInstanceTreeChangeToReflectDiskState(locals, instanceContainer.id, entityName, oldChildInstances, []);
+    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, {
+        id: instanceId,
+        content: instanceContainer.content,
+        childInstances: oldChildInstances,
+        entityName,
+    }, undefined, undefined, res));
+    if (isError(databaseTransactionResult)) {
+        return databaseTransactionResult;
+    }
+    const { db: newDatabaseInMemory, refs: newReferencesToInstances, instanceContainer: oldInstanceContainer, } = databaseTransactionResult.value;
+    locals.setLocal("databaseInMemory", newDatabaseInMemory);
+    locals.setLocal("referencesToInstances", newReferencesToInstances);
     return ok(oldInstanceContainer);
 };

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

@@ -0,0 +1,2 @@
+import type { Request } from "express";
+export declare const getQueryParamString: (parsedQueryString: Request["query"], key: string) => string | undefined;

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

@@ -0,0 +1,7 @@
+export const getQueryParamString = (parsedQueryString, key) => {
+    const value = parsedQueryString[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    return;
+};

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

@@ -1,17 +1,17 @@
 import type { GitFileStatus } from "../../shared/utils/git.ts";
-import type { InstanceContainer, InstancesByEntityName } from "../../shared/utils/instances.ts";
-import { type Result } from "../../shared/utils/result.ts";
+import type { InstanceContainer, InstanceContent } from "../../shared/utils/instances.ts";
 import type { EntityDecl, EntityDeclWithParentReference } from "../schema/declarations/EntityDecl.ts";
-import { type ReferencesToInstances } from "./references.ts";
+import { type DatabaseInMemory } from "./databaseInMemory.ts";
+import type { TransactionResult } from "./databaseTransactions.ts";
 export interface ChildInstanceContainer {
     id?: string;
-    content: unknown;
+    content: InstanceContent;
     gitStatus?: GitFileStatus;
 }
 export interface EntityTaggedInstanceContainer {
     entityName: string;
     id: string;
-    content: unknown;
+    content: InstanceContent;
 }
 export interface CreatedEntityTaggedInstanceContainerWithChildInstances extends GenEntityTaggedInstanceContainerWithChildInstances<undefined, UnsafeEntityTaggedInstanceContainerWithChildInstances> {
 }
@@ -24,10 +24,11 @@ export interface EntityTaggedInstanceContainerWithChildInstances extends GenEnti
 export interface GenEntityTaggedInstanceContainerWithChildInstances<ID extends string | undefined, C> {
     entityName: string;
     id: ID;
-    content: unknown;
+    content: InstanceContent;
     childInstances: C[];
 }
-export declare const getChildInstancesFromEntity: (instancesByEntityName: InstancesByEntityName, parentEntity: EntityDecl, parentId: string, childEntity: EntityDeclWithParentReference) => InstanceContainer[];
-export declare const getChildInstances: (instancesByEntityName: InstancesByEntityName, parentEntity: EntityDecl, parentId: string, recursive?: boolean) => EntityTaggedInstanceContainerWithChildInstances[];
-export declare const checkWriteInstanceTreePossible: (entitiesByName: Record<string, EntityDecl>, instancesByEntityName: InstancesByEntityName, referencesToInstances: ReferencesToInstances, parentId: string | undefined, parentEntityName: string, oldChildInstances: EntityTaggedInstanceContainerWithChildInstances[], childInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[]) => Result<void, [code: number, message: string]>;
-export declare const unsafeApplyInstanceTree: (dataRoot: string, entitiesByName: Record<string, EntityDecl>, instancesByEntityName: InstancesByEntityName, parentId: string | undefined, parentEntityName: string, oldChildInstances: EntityTaggedInstanceContainerWithChildInstances[], childInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[]) => Promise<Result<void, [code: number, message: string]>>;
+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<{
+    instanceContainer: InstanceContainer;
+}>;

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

@@ -1,9 +1,11 @@
+import { createEnumCaseValue } from "../../shared/schema/declarations/EnumDecl.js";
 import { hasKey } from "../../shared/utils/object.js";
-import { error, isError, ok } from "../../shared/utils/result.js";
-import { reduceNodes } from "../schema/index.js";
+import { error, isError, map, ok } from "../../shared/utils/result.js";
+import { isEntityDeclWithParentReference, isEnumDecl, isIncludeIdentifierType, reduceNodes, } from "../schema/index.js";
 import { isChildEntitiesType } from "../schema/types/references/ChildEntitiesType.js";
-import { checkCreateNonLocaleInstancePossible, checkDeleteInstancePossible, checkUpdateInstancePossible, createNewId, unsafeDeleteInstance, unsafeWriteInstance, } from "./instanceOperations.js";
-import {} from "./references.js";
+import { getInstancesOfEntityFromDatabaseInMemory, } from "./databaseInMemory.js";
+import { HTTPError } from "./error.js";
+import { createInstance, deleteInstance, updateInstance } from "./instanceTransactionSteps.js";
 const isParentReferenceReferencingParent = (value, parentEntityName, parentId) => {
     if (typeof value === "object" && value !== null && hasKey(value, "kind")) {
         return (value.kind === parentEntityName &&
@@ -17,149 +19,83 @@ const isParentReferenceReferencingParent = (value, parentEntityName, parentId) =
         return false;
     }
 };
-export const getChildInstancesFromEntity = (instancesByEntityName, parentEntity, parentId, childEntity) => instancesByEntityName[childEntity.name]?.filter(instanceContainer => typeof instanceContainer.content === "object" &&
-    instanceContainer.content !== null &&
-    hasKey(instanceContainer.content, childEntity.parentReferenceKey) &&
-    isParentReferenceReferencingParent(instanceContainer.content[childEntity.parentReferenceKey], parentEntity.name, parentId)) ?? [];
-export const getChildInstances = (instancesByEntityName, parentEntity, parentId, recursive = true) => {
+export const getChildInstancesFromEntity = (databaseInMemory, parentEntity, parentId, childEntity) => getInstancesOfEntityFromDatabaseInMemory(databaseInMemory, childEntity.name).filter(instanceContainer => hasKey(instanceContainer.content, childEntity.parentReferenceKey) &&
+    isParentReferenceReferencingParent(instanceContainer.content[childEntity.parentReferenceKey], parentEntity.name, parentId));
+export const getChildInstances = (databaseInMemory, parentEntity, parentId, recursive = true) => {
     const childEntities = reduceNodes((_parentNodes, node, collectedResults) => isChildEntitiesType(node) ? [...collectedResults, node.entity] : collectedResults, [parentEntity], { followIncludes: true });
-    return childEntities.flatMap(childEntity => getChildInstancesFromEntity(instancesByEntityName, parentEntity, parentId, childEntity).map(container => ({
+    return childEntities.flatMap(childEntity => getChildInstancesFromEntity(databaseInMemory, parentEntity, parentId, childEntity).map(container => ({
         ...container,
         entityName: childEntity.name,
         childInstances: recursive
-            ? getChildInstances(instancesByEntityName, childEntity, container.id)
+            ? getChildInstances(databaseInMemory, childEntity, container.id)
             : [],
     })));
 };
-export const checkWriteInstanceTreePossible = (entitiesByName, instancesByEntityName, referencesToInstances, parentId, parentEntityName, oldChildInstances, childInstances) => {
-    const parentEntity = entitiesByName[parentEntityName];
-    if (parentEntity === undefined) {
-        return error([400, `Unknown entity "${parentEntityName}"`]);
-    }
-    if (parentId !== undefined) {
-        // existing parent, some child instances may already exist
-        for (const oldChildInstance of oldChildInstances) {
-            const newChildInstance = childInstances.find(ci => ci.id === oldChildInstance.id);
-            if (newChildInstance === undefined) {
-                const prerequisiteCheckResult = checkDeleteInstancePossible(referencesToInstances, oldChildInstance.id);
-                if (isError(prerequisiteCheckResult)) {
-                    return prerequisiteCheckResult;
-                }
-            }
-            else {
-                const entity = entitiesByName[newChildInstance.entityName];
-                if (entity === undefined) {
-                    return error([400, `Unknown entity "${newChildInstance.entityName}"`]);
-                }
-                const prerequisiteCheckResult = checkUpdateInstancePossible(instancesByEntityName, entity, newChildInstance.content);
-                if (isError(prerequisiteCheckResult)) {
-                    return prerequisiteCheckResult;
-                }
-            }
-        }
-        for (const newChildInstance of childInstances.filter(predicate => predicate.id === undefined)) {
-            const entity = entitiesByName[newChildInstance.entityName];
-            if (entity === undefined) {
-                return error([400, `Unknown entity "${newChildInstance.entityName}"`]);
-            }
-            const prerequisiteCheckResult = checkCreateNonLocaleInstancePossible(instancesByEntityName, entity, newChildInstance.content);
-            if (isError(prerequisiteCheckResult)) {
-                return prerequisiteCheckResult;
-            }
+const prepareNewChildInstanceContent = (entity, parentEntityName, parentId, content) => {
+    if (isEntityDeclWithParentReference(entity)) {
+        if (parentEntityName === undefined || parentId === undefined) {
+            return error(new HTTPError(400, `Cannot create instance of child entity "${entity.name}" without parent reference`));
         }
+        const parentReferenceType = entity.type.value.properties[entity.parentReferenceKey]?.type;
+        return ok({
+            ...content,
+            [entity.parentReferenceKey]: parentReferenceType &&
+                isIncludeIdentifierType(parentReferenceType) &&
+                isEnumDecl(parentReferenceType.reference)
+                ? createEnumCaseValue(parentEntityName, parentId)
+                : parentId,
+        });
     }
     else {
-        // new parent, all child instances are new
-        for (const newChildInstance of childInstances) {
-            const entity = entitiesByName[newChildInstance.entityName];
-            if (entity === undefined) {
-                return error([400, `Unknown entity "${newChildInstance.entityName}"`]);
-            }
-            const prerequisiteCheckResult = checkCreateNonLocaleInstancePossible(instancesByEntityName, entity, newChildInstance.content);
-            if (isError(prerequisiteCheckResult)) {
-                return prerequisiteCheckResult;
-            }
-        }
-    }
-    // check recursively for child instances of child instances
-    for (const childInstance of childInstances) {
-        const oldChildInstance = childInstance.id
-            ? oldChildInstances.find(ci => ci.id === childInstance.id)
-            : undefined;
-        const prerequisiteCheckResult = checkWriteInstanceTreePossible(entitiesByName, instancesByEntityName, referencesToInstances, childInstance.id, childInstance.entityName, oldChildInstance ? oldChildInstance.childInstances : [], childInstance.childInstances);
-        if (isError(prerequisiteCheckResult)) {
-            return prerequisiteCheckResult;
-        }
+        return ok(content);
     }
-    return ok();
 };
-export const unsafeApplyInstanceTree = async (dataRoot, entitiesByName, instancesByEntityName, parentId, parentEntityName, oldChildInstances, childInstances) => {
-    const parentEntity = entitiesByName[parentEntityName];
-    if (parentEntity === undefined) {
-        return error([400, `Unknown entity "${parentEntityName}"`]);
+export const saveInstanceTree = (entitiesByName, parentEntityName, parentId, localeEntity, entityName, oldInstance, newInstance, customId, res) => {
+    if (isError(res)) {
+        return res;
     }
-    if (parentId !== undefined) {
-        // existing parent, some child instances may already exist
-        for (const oldChildInstance of oldChildInstances) {
-            const newChildInstance = childInstances.find(ci => ci.id === oldChildInstance.id);
-            if (newChildInstance === undefined) {
-                const oldGrandChildInstancesResult = await unsafeApplyInstanceTree(dataRoot, entitiesByName, instancesByEntityName, oldChildInstance.id, oldChildInstance.entityName, oldChildInstance.childInstances, []);
-                if (isError(oldGrandChildInstancesResult)) {
-                    return oldGrandChildInstancesResult;
-                }
-                const prerequisiteCheckResult = await unsafeDeleteInstance(dataRoot, oldChildInstance.entityName, oldChildInstance.id);
-                if (isError(prerequisiteCheckResult)) {
-                    return prerequisiteCheckResult;
-                }
-            }
-            else {
-                const entity = entitiesByName[newChildInstance.entityName];
-                if (entity === undefined) {
-                    return error([400, `Unknown entity "${newChildInstance.entityName}"`]);
-                }
-                const prerequisiteCheckResult = await unsafeWriteInstance(dataRoot, entity, oldChildInstance.id, newChildInstance.content);
-                if (isError(prerequisiteCheckResult)) {
-                    return prerequisiteCheckResult;
-                }
-            }
-        }
-        for (const newChildInstance of childInstances.filter(predicate => predicate.id === undefined)) {
-            const entity = entitiesByName[newChildInstance.entityName];
-            if (entity === undefined) {
-                return error([400, `Unknown entity "${newChildInstance.entityName}"`]);
-            }
-            const newInstanceID = createNewId();
-            const prerequisiteCheckResult = await unsafeWriteInstance(dataRoot, entity, newInstanceID, newChildInstance.content);
-            if (isError(prerequisiteCheckResult)) {
-                return prerequisiteCheckResult;
-            }
-            newChildInstance.id = newInstanceID;
+    const entity = entitiesByName[entityName];
+    if (entity === undefined) {
+        return error(new HTTPError(400, `Unknown entity "${entityName}"`));
+    }
+    if (newInstance === undefined) {
+        if (oldInstance === undefined) {
+            // no-op
+            return map(res, data => ({ ...data, instanceContainer: { id: "", content: {} } }));
         }
+        // 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 => ({
+            ...data,
+            instanceContainer: { id: oldInstance.id, content: oldInstance.content },
+        }));
     }
     else {
-        // new parent, all child instances are new
-        for (const newChildInstance of childInstances) {
-            const entity = entitiesByName[newChildInstance.entityName];
-            if (entity === undefined) {
-                return error([400, `Unknown entity "${newChildInstance.entityName}"`]);
-            }
-            const newInstanceID = createNewId();
-            const prerequisiteCheckResult = await unsafeWriteInstance(dataRoot, entity, newInstanceID, newChildInstance.content);
-            if (isError(prerequisiteCheckResult)) {
-                return prerequisiteCheckResult;
-            }
-            newChildInstance.id = newInstanceID;
+        const preparedContent = newInstance.id === undefined
+            ? prepareNewChildInstanceContent(entity, parentEntityName, parentId, newInstance.content)
+            : ok(newInstance.content);
+        if (isError(preparedContent)) {
+            return preparedContent;
         }
-    }
-    // check recursively for child instances of child instances
-    for (const childInstance of childInstances) {
-        const oldChildInstance = childInstance.id
-            ? oldChildInstances.find(ci => ci.id === childInstance.id)
-            : undefined;
-        const prerequisiteCheckResult = await unsafeApplyInstanceTree(dataRoot, entitiesByName, instancesByEntityName, childInstance.id, childInstance.entityName, oldChildInstance ? oldChildInstance.childInstances : [], childInstance.childInstances);
-        if (isError(prerequisiteCheckResult)) {
-            return prerequisiteCheckResult;
+        const setRes = newInstance.id === undefined
+            ? createInstance(res, localeEntity, entity, preparedContent.value, customId)
+            : map(updateInstance(res, entity, newInstance.id, preparedContent.value), data => ({
+                ...data,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                instanceId: newInstance.id,
+            }));
+        if (isError(setRes)) {
+            return setRes;
         }
+        const instanceId = setRes.value.instanceId;
+        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)
+            : setResWithoutInfo), data => ({
+            ...data,
+            instanceContainer: { id: instanceId, content: preparedContent.value },
+        }));
     }
-    return ok();
 };

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

@@ -0,0 +1,18 @@
+import { type Dictionary } from "../../shared/utils/dictionary.ts";
+import type { InstanceContainer, InstanceContent } from "../../shared/utils/instances.ts";
+import type { EntityDecl } from "../schema/index.ts";
+export type DatabaseInMemory = Dictionary<InstancesInMemory>;
+export type InstancesInMemory = Dictionary<InstanceContainer>;
+export declare const emptyDatabaseInMemory: DatabaseInMemory;
+export declare const getInstanceFromDatabaseInMemory: (db: DatabaseInMemory, instanceId: string) => [entityName: string, InstanceContainer] | undefined;
+export declare const getInstanceOfEntityFromDatabaseInMemory: (db: DatabaseInMemory, entityName: string, instanceId: string) => InstanceContainer | undefined;
+export declare const getInstancesOfEntityFromDatabaseInMemory: (db: DatabaseInMemory, entityName: string) => InstanceContainer[];
+export declare const getGroupedInstancesFromDatabaseInMemory: (db: DatabaseInMemory) => [entityName: string, InstanceContainer[]][];
+export declare const forEachInstanceOfEntityInDatabaseInMemory: (db: DatabaseInMemory, entityName: string, fn: (instance: InstanceContainer) => void) => void;
+export declare const asyncForEachInstanceOfEntityInDatabaseInMemory: (db: DatabaseInMemory, entityName: string, fn: (instance: InstanceContainer) => Promise<void>) => Promise<void>;
+export declare const forEachInstanceInDatabaseInMemory: (db: DatabaseInMemory, fn: (entityName: string, instance: InstanceContainer) => void) => void;
+export declare const asyncForEachInstanceInDatabaseInMemory: (db: DatabaseInMemory, fn: (entityName: string, instance: InstanceContainer) => Promise<void>) => Promise<void>;
+export declare const countInstancesOfEntityInDatabaseInMemory: (db: DatabaseInMemory, entityName: string) => number;
+export declare const createDatabaseInMemory: (dataRoot: string, entities: readonly EntityDecl[]) => Promise<DatabaseInMemory>;
+export declare const setInstanceInDatabaseInMemory: (db: DatabaseInMemory, entityName: string, instance: InstanceContainer) => [DatabaseInMemory, oldInstance: InstanceContent | undefined];
+export declare const deleteInstanceInDatabaseInMemory: (db: DatabaseInMemory, entityName: string, instanceId: string) => [DatabaseInMemory, oldInstance: InstanceContent | undefined];

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

@@ -0,0 +1,86 @@
+import child_process from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { platform } from "node:process";
+import { promisify } from "node:util";
+import { mapAsync } from "../../shared/utils/async.js";
+import { emptyD, forEachAsyncD, forEachD, fromEntriesD, getD, getMapD, hasD, mapFirstD, removeD, setD, sizeD, toEntriesD, toValuesD, } from "../../shared/utils/dictionary.js";
+export const emptyDatabaseInMemory = emptyD;
+export const getInstanceFromDatabaseInMemory = (db, instanceId) => mapFirstD(db, (instances, entityName) => {
+    const instance = getD(instances, instanceId);
+    if (instance) {
+        return [entityName, instance];
+    }
+    return undefined;
+});
+export const getInstanceOfEntityFromDatabaseInMemory = (db, entityName, instanceId) => getMapD(db, entityName, instances => getD(instances, instanceId));
+export const getInstancesOfEntityFromDatabaseInMemory = (db, entityName) => getMapD(db, entityName, toValuesD) ?? [];
+export const getGroupedInstancesFromDatabaseInMemory = (db) => toEntriesD(db).map(([entityName, instances]) => [entityName, Object.values(instances[0])]);
+export const forEachInstanceOfEntityInDatabaseInMemory = (db, entityName, fn) => {
+    for (const instance of Object.values(getMapD(db, entityName, toValuesD) ?? {})) {
+        fn(instance);
+    }
+};
+export const asyncForEachInstanceOfEntityInDatabaseInMemory = async (db, entityName, fn) => {
+    for (const instance of Object.values(getMapD(db, entityName, toValuesD) ?? {})) {
+        await fn(instance);
+    }
+};
+export const forEachInstanceInDatabaseInMemory = (db, fn) => {
+    forEachD(db, (instances, entityName) => {
+        forEachD(instances, instance => {
+            fn(entityName, instance);
+        });
+    });
+};
+export const asyncForEachInstanceInDatabaseInMemory = async (db, fn) => forEachAsyncD(db, (instances, entityName) => forEachAsyncD(instances, instance => fn(entityName, instance)));
+export const countInstancesOfEntityInDatabaseInMemory = (db, entityName) => getMapD(db, entityName, sizeD) ?? 0;
+const exec = promisify(child_process.exec);
+const ulimit = platform === "win32" ? 2048 : Number.parseInt((await exec("ulimit -n")).stdout);
+export const createDatabaseInMemory = async (dataRoot, entities) => fromEntriesD(await mapAsync(entities, async (entity) => {
+    const entityDir = join(dataRoot, entity.name);
+    const instanceFileNames = await readdir(entityDir);
+    const instances = await mapAsync(instanceFileNames, async (instanceFileName) => {
+        const id = basename(instanceFileName, extname(instanceFileName));
+        return [
+            id,
+            {
+                id,
+                content: JSON.parse(await readFile(join(entityDir, instanceFileName), "utf-8")),
+            },
+        ];
+    }, ulimit);
+    const instancesById = fromEntriesD(instances);
+    return [entity.name, instancesById];
+}, 1));
+const setInstanceInMemory = (instances, instance) => {
+    const oldInstance = getD(instances, instance.id);
+    return [setD(instances, instance.id, instance), oldInstance?.content];
+};
+export const setInstanceInDatabaseInMemory = (db, entityName, instance) => {
+    const [entityInstances, oldInstance] = setInstanceInMemory(getD(db, entityName) ?? emptyD, instance);
+    return [setD(db, entityName, entityInstances), oldInstance];
+};
+const deleteInstanceInMemory = (instances, instanceId) => {
+    if (!hasD(instances, instanceId)) {
+        return [instances, undefined];
+    }
+    const oldInstance = getD(instances, instanceId);
+    const remainingInstancesById = removeD(instances, instanceId);
+    return [remainingInstancesById, oldInstance?.content];
+};
+export const deleteInstanceInDatabaseInMemory = (db, entityName, instanceId) => {
+    const entityInstances = getD(db, entityName);
+    if (entityInstances === undefined) {
+        return [db, undefined];
+    }
+    const [remainingInstances, oldInstance] = deleteInstanceInMemory(entityInstances, instanceId);
+    if (entityInstances === remainingInstances) {
+        return [db, undefined];
+    }
+    if (remainingInstances[1].length === 0) {
+        const remainingEntities = removeD(db, entityName);
+        return [remainingEntities, oldInstance];
+    }
+    return [setD(db, entityName, remainingInstances), oldInstance];
+};

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

@@ -0,0 +1,2 @@
+import type { TransactionStep } from "./databaseTransactions.ts";
+export declare const applyStepsToDisk: (root: string, steps: TransactionStep[]) => Promise<import("../../shared/utils/result.ts").Ok<void> | import("../../shared/utils/result.ts").Error<Error>>;

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

@@ -0,0 +1,62 @@
+import { error, isError, ok } from "../../shared/utils/result.js";
+import * as DatabaseFilesystem from "./files.js";
+const setInstanceOnDisk = async (root, entity, instanceId, instanceContent) => {
+    try {
+        await DatabaseFilesystem.writeInstance(root, entity, instanceId, instanceContent);
+        return ok();
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+const deleteInstanceOnDisk = async (root, entityName, instanceId) => {
+    try {
+        await DatabaseFilesystem.deleteInstance(root, entityName, instanceId);
+        return ok();
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+const rollbackChanges = async (root, steps) => {
+    for (const step of steps) {
+        const res = await runReverseStepAction(root, step);
+        if (isError(res)) {
+            return res;
+        }
+    }
+    return ok();
+};
+const runStepAction = (root, step) => {
+    switch (step.kind) {
+        case "set":
+            return setInstanceOnDisk(root, step.entity, step.instanceId, step.instance);
+        case "delete":
+            return deleteInstanceOnDisk(root, step.entity.name, step.instanceId);
+    }
+};
+const runReverseStepAction = (root, step) => {
+    switch (step.kind) {
+        case "set":
+            if (step.oldInstance === undefined) {
+                return deleteInstanceOnDisk(root, step.entity.name, step.instanceId);
+            }
+            else {
+                return setInstanceOnDisk(root, step.entity, step.instanceId, step.oldInstance);
+            }
+        case "delete":
+            return setInstanceOnDisk(root, step.entity, step.instanceId, step.oldInstance);
+    }
+};
+export const applyStepsToDisk = async (root, steps) => {
+    for (let i = 0; i < steps.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const step = steps[i];
+        const res = await runStepAction(root, step);
+        if (isError(res)) {
+            await rollbackChanges(root, steps.slice(0, i));
+            return res;
+        }
+    }
+    return ok();
+};