tsondb 0.12.3 → 0.12.5

package/dist/src/node/index.js

@@ -7,9 +7,9 @@ import { validateEntityDecl } from "./schema/declarations/EntityDecl.js";
 import { createValidators } from "./schema/Node.js";
 import { getEntities } from "./schema/Schema.js";
 import { createServer } from "./server/index.js";
+import { asyncForEachInstanceInDatabaseInMemory, createDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, } from "./utils/databaseInMemory.js";
 import { countErrors, getErrorMessageForDisplay, wrapErrorsIfAny } from "./utils/error.js";
 import { getFileNameForId, writeInstance } from "./utils/files.js";
-import { getInstancesByEntityName } from "./utils/instances.js";
 const debug = Debug("tsondb:jsapi");
 const prepareFolders = async (dataRootPath, entities) => {
     await mkdir(dataRootPath, { recursive: true });
@@ -23,18 +23,18 @@ export const generateOutputs = async (schema, outputs) => {
         await output.run(schema);
     }
 };
-const _validate = (dataRootPath, entities, instancesByEntityName, options = {}) => {
+const _validate = (dataRootPath, entities, databaseInMemory, options = {}) => {
     const { checkReferentialIntegrity = true, checkOnlyEntities = [] } = options;
     for (const onlyEntity of checkOnlyEntities) {
         if (!entities.find(entity => entity.name === onlyEntity)) {
             throw new Error(`Entity "${onlyEntity}" not found in schema`);
         }
     }
-    const validationHelpers = createValidators(instancesByEntityName, true, checkReferentialIntegrity);
+    const validationHelpers = createValidators(databaseInMemory, true, checkReferentialIntegrity);
     const errors = (checkOnlyEntities.length > 0
         ? entities.filter(entity => checkOnlyEntities.includes(entity.name))
         : entities)
-        .flatMap(entity => parallelizeErrors(instancesByEntityName[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(validationHelpers, [], entity, instance.content)))))
         .toSorted((a, b) => a.message.localeCompare(b.message));
     if (errors.length === 0) {
         debug("All entities are valid");
@@ -47,15 +47,15 @@ const _validate = (dataRootPath, entities, instancesByEntityName, options = {})
 export const validate = async (schema, dataRootPath, options) => {
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
-    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
-    _validate(dataRootPath, entities, instancesByEntityName, options);
+    const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
+    _validate(dataRootPath, entities, databaseInMemory, options);
 };
 export const generateAndValidate = async (schema, outputs, dataRootPath, validationOptions) => {
     await generateOutputs(schema, outputs);
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
-    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
-    _validate(dataRootPath, entities, instancesByEntityName, validationOptions);
+    const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
+    _validate(dataRootPath, entities, databaseInMemory, validationOptions);
 };
 export const serve = async (schema, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, customStylesheetPath) => {
     if (defaultLocales.length === 0) {
@@ -64,28 +64,25 @@ export const serve = async (schema, dataRootPath, defaultLocales, homeLayoutSect
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
     debug("prepared folders");
-    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
     debug("loaded instances");
-    await createServer(schema, dataRootPath, instancesByEntityName, defaultLocales, homeLayoutSections, serverOptions, customStylesheetPath);
+    await createServer(schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, serverOptions, customStylesheetPath);
 };
 export const generateValidateAndServe = async (schema, outputs, dataRootPath, defaultLocales, homeLayoutSections, serverOptions, validationOptions) => {
     await generateOutputs(schema, outputs);
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
-    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
-    _validate(dataRootPath, entities, instancesByEntityName, validationOptions);
-    await createServer(schema, dataRootPath, instancesByEntityName, defaultLocales, homeLayoutSections, serverOptions);
+    const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
+    _validate(dataRootPath, entities, databaseInMemory, validationOptions);
+    await createServer(schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, serverOptions);
 };
 export const format = async (schema, dataRootPath) => {
     const entities = getEntities(schema);
     await prepareFolders(dataRootPath, entities);
-    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
-    for (const entityName in instancesByEntityName) {
+    const databaseInMemory = await createDatabaseInMemory(dataRootPath, entities);
+    await asyncForEachInstanceInDatabaseInMemory(databaseInMemory, async (entityName, instance) => {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const entity = entities.find(entity => entity.name === entityName);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        for (const instance of instancesByEntityName[entityName]) {
-            await writeInstance(dataRootPath, entity, instance.id, instance.content);
-        }
-    }
+        await writeInstance(dataRootPath, entity, instance.id, instance.content);
+    });
 };

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

@@ -17,7 +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 { InstancesByEntityName } from "../../shared/utils/instances.ts";
+import { type DatabaseInMemory } from "../utils/databaseInMemory.ts";
 import { type Decl, type IncludableDeclP } from "./declarations/Declaration.ts";
 import { type EntityDecl } from "./declarations/EntityDecl.ts";
 import { type EnumDecl } from "./declarations/EnumDecl.ts";
@@ -62,7 +62,7 @@ export interface Validators {
     useStyling: boolean;
     checkReferentialIntegrity: (identifier: IdentifierToCheck) => Error[];
 }
-export declare const createValidators: (instancesByEntityName: InstancesByEntityName, useStyling: boolean, checkReferentialIntegrity?: boolean) => Validators;
+export declare const createValidators: (databaseInMemory: DatabaseInMemory, useStyling: boolean, checkReferentialIntegrity?: boolean) => Validators;
 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;

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

@@ -1,5 +1,6 @@
 import { NodeKind } from "../../shared/schema/Node.js";
 import { assertExhaustive } from "../../shared/utils/typeSafety.js";
+import { getInstancesOfEntityFromDatabaseInMemory, } from "../utils/databaseInMemory.js";
 import { entity, json } from "../utils/errorFormatting.js";
 import { isDecl } from "./declarations/Declaration.js";
 import { getNestedDeclarationsInEntityDecl, getReferencesForEntityDecl, resolveTypeArgumentsInEntityDecl, serializeEntityDecl, validateEntityDecl, } from "./declarations/EntityDecl.js";
@@ -80,13 +81,10 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => reduceNodes((
     });
     return declsWithCurrentDecl.concat(normalizedResult);
 }, declarations);
-export const createValidators = (instancesByEntityName, useStyling, checkReferentialIntegrity = true) => ({
+export const createValidators = (databaseInMemory, useStyling, checkReferentialIntegrity = true) => ({
     useStyling,
     checkReferentialIntegrity: checkReferentialIntegrity
-        ? ({ name, value }) => instancesByEntityName[name]?.some(instance => typeof instance.content === "object" &&
-            instance.content !== null &&
-            !Array.isArray(instance.content) &&
-            instance.id === value)
+        ? ({ name, value }) => getInstancesOfEntityFromDatabaseInMemory(databaseInMemory, name).some(instance => instance.id === value)
             ? []
             : [
                 ReferenceError(`Invalid reference to instance of entity ${entity(`"${name}"`, useStyling)} with identifier ${json(value, useStyling)}`),

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

@@ -23,7 +23,7 @@ export type EntityDisplayName<T extends TConstraint> = Leaves<AsType<ObjectType<
     pathInLocaleMap?: string;
 } | null;
 type TConstraint = Record<string, MemberDecl>;
-export interface EntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends (keyof T & string) | undefined = (keyof T & string) | undefined> extends BaseDecl<Name, []> {
+export interface EntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
     type: Lazy<ObjectType<T>>;
@@ -35,7 +35,7 @@ export interface EntityDecl<Name extends string = string, T extends TConstraint
     displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
     isDeprecated?: boolean;
 }
-export interface EntityDeclWithParentReference<Name extends string = string, T extends TConstraint = TConstraint, FK extends keyof T & string = keyof T & string> extends EntityDecl<Name, T, FK> {
+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> {
 }
 export declare const EntityDecl: {
     <Name extends string, T extends TConstraint>(sourceUrl: string, options: {
@@ -50,7 +50,7 @@ export declare const EntityDecl: {
         displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
         isDeprecated?: boolean;
     }): EntityDecl<Name, T, undefined>;
-    <Name extends string, T extends TConstraint, FK extends keyof T & string>(sourceUrl: string, options: {
+    <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string>>(sourceUrl: string, options: {
         name: Name;
         namePlural: string;
         comment?: string;
@@ -66,7 +66,7 @@ export declare const EntityDecl: {
 };
 export { EntityDecl as Entity };
 export declare const isEntityDecl: Predicate<EntityDecl>;
-export declare const isEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends (keyof T & string) | undefined>(decl: EntityDecl<Name, T, FK>) => decl is EntityDecl<Name, T, NonNullable<FK>>;
+export declare const isEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(decl: EntityDecl<Name, T, FK>) => decl is EntityDecl<Name, T, NonNullable<FK>>;
 export declare const getNestedDeclarationsInEntityDecl: GetNestedDeclarations<EntityDecl>;
 export declare const validateEntityDecl: Validator<EntityDecl>;
 export declare const resolveTypeArgumentsInEntityDecl: TypeArgumentsResolver<EntityDecl>;

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

@@ -29,9 +29,6 @@ export const resolveTypeArgumentsInIncludeIdentifierType = ((args, type, inDecl)
     else {
         const parentDecl = inDecl[inDecl.length - 1];
         const grandParentDecl = inDecl[inDecl.length - 2];
-        if (grandParentDecl?.name === "AdventurePointsDependingOnActiveInstancesMultiplier") {
-            console.log(type.args.every((arg, argIndex) => isTypeArgumentType(arg) && parentDecl?.parameters[argIndex] === arg.argument));
-        }
         if (type.reference === parentDecl &&
             parentDecl.parameters.length > 0 &&
             grandParentDecl &&

package/dist/src/node/server/api/declarations.js

@@ -7,6 +7,8 @@ import { isEnumDecl } from "../../schema/declarations/EnumDecl.js";
 import { isTypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { serializeNode } from "../../schema/index.js";
 import { getChildInstances } from "../../utils/childInstances.js";
+import { countInstancesOfEntityInDatabaseInMemory, getInstanceOfEntityFromDatabaseInMemory, getInstancesOfEntityFromDatabaseInMemory, } from "../../utils/databaseInMemory.js";
+import { HTTPError } from "../../utils/error.js";
 import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
 import { createInstance, deleteInstance, updateInstance } from "../utils/instanceOperations.js";
 const debug = Debug("tsondb:server:api:declarations");
@@ -33,7 +35,7 @@ declarationsApi.get("/", (req, res) => {
     const body = {
         declarations: filteredEntities.map(decl => ({
             declaration: serializeNode(decl),
-            instanceCount: req.instancesByEntityName[decl.name]?.length ?? 0,
+            instanceCount: countInstancesOfEntityInDatabaseInMemory(req.databaseInMemory, decl.name),
         })),
         localeEntity: req.localeEntity?.name,
     };
@@ -47,7 +49,7 @@ declarationsApi.get("/:name", (req, res) => {
     }
     const body = {
         declaration: serializeNode(decl),
-        instanceCount: req.instancesByEntityName[decl.name]?.length ?? 0,
+        instanceCount: countInstancesOfEntityInDatabaseInMemory(req.databaseInMemory, decl.name),
         isLocaleEntity: decl === req.localeEntity,
     };
     res.json(body);
@@ -64,9 +66,9 @@ declarationsApi.get("/:name/instances", (req, res) => {
     }
     const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
     const body = {
-        instances: req.instancesByEntityName[req.params.name]
-            ?.map(instanceContainer => getInstanceContainerOverview(decl, instanceContainer, req.getInstanceById, getChildInstancesForInstanceId, req.locales))
-            .toSorted((a, b) => a.displayName.localeCompare(b.displayName, undefined, { numeric: true })) ?? [],
+        instances: getInstancesOfEntityFromDatabaseInMemory(req.databaseInMemory, decl.name)
+            .map(instanceContainer => getInstanceContainerOverview(decl, instanceContainer, req.getInstanceById, getChildInstancesForInstanceId, req.locales))
+            .toSorted((a, b) => a.displayName.localeCompare(b.displayName, undefined, { numeric: true })),
         isLocaleEntity: decl === req.localeEntity,
     };
     res.json(body);
@@ -91,7 +93,12 @@ declarationsApi.post("/:name/instances", async (req, res) => {
         res.json(body);
     }
     else {
-        res.status(result.error[0]).send(result.error[1]);
+        if (result.error instanceof HTTPError) {
+            res.status(result.error.code).send(result.error.message);
+        }
+        else {
+            res.status(500).send(result.error.message);
+        }
     }
 });
 declarationsApi.get("/:name/instances/:id", (req, res) => {
@@ -104,7 +111,7 @@ declarationsApi.get("/:name/instances/:id", (req, res) => {
         res.status(400).send(`Declaration "${decl.name}" is not an entity`);
         return;
     }
-    const instance = req.instancesByEntityName[decl.name]?.find(instance => instance.id === req.params.id);
+    const instance = getInstanceOfEntityFromDatabaseInMemory(req.databaseInMemory, decl.name, req.params.id);
     if (instance === undefined) {
         res.status(404).send(`Instance "${req.params.id}" not found`);
         return;
@@ -135,7 +142,12 @@ declarationsApi.put("/:name/instances/:id", async (req, res) => {
         res.json(body);
     }
     else {
-        res.status(result.error[0]).send(result.error[1]);
+        if (result.error instanceof HTTPError) {
+            res.status(result.error.code).send(result.error.message);
+        }
+        else {
+            res.status(500).send(result.error.message);
+        }
     }
 });
 declarationsApi.delete("/:name/instances/:id", async (req, res) => {
@@ -157,7 +169,12 @@ declarationsApi.delete("/:name/instances/:id", async (req, res) => {
         res.json(body);
     }
     else {
-        res.status(result.error[0]).send(result.error[1]);
+        if (result.error instanceof HTTPError) {
+            res.status(result.error.code).send(result.error.message);
+        }
+        else {
+            res.status(500).send(result.error.message);
+        }
     }
 });
 declarationsApi.get("/:name/instances/:id/children", (req, res) => {
@@ -171,7 +188,7 @@ declarationsApi.get("/:name/instances/:id/children", (req, res) => {
         return;
     }
     const body = {
-        instances: getChildInstances(req.instancesByEntityName, decl, req.params.id),
+        instances: getChildInstances(req.databaseInMemory, decl, req.params.id),
     };
     res.json(body);
 });

package/dist/src/node/server/api/git.js

@@ -3,7 +3,7 @@ import express, {} from "express";
 import { join } from "node:path";
 import { hasFileChanges, splitBranchName } from "../../../shared/utils/git.js";
 import { getInstanceContainerOverview } from "../../../shared/utils/instances.js";
-import { attachGitStatusToInstancesByEntityName } from "../../utils/instances.js";
+import { getGroupedInstancesFromDatabaseInMemory } from "../../utils/databaseInMemory.js";
 import { reinit } from "../init.js";
 import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
 const debug = Debug("tsondb:server:api:git");
@@ -24,16 +24,13 @@ gitApi.get("/", (req, res) => {
 });
 gitApi.get("/status", async (req, res) => {
     const status = await req.git.status();
-    attachGitStatusToInstancesByEntityName(req.instancesByEntityName, req.dataRoot, 
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    req.gitRoot, status);
     const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
     const body = {
         currentBranch: status.current,
         trackingBranch: status.tracking,
         commitsAhead: status.ahead,
         commitsBehind: status.behind,
-        instances: Object.fromEntries(Object.entries(req.instancesByEntityName).map(([entityName, instances]) => [
+        instances: Object.fromEntries(getGroupedInstancesFromDatabaseInMemory(req.databaseInMemory).map(([entityName, instances]) => [
             entityName,
             instances
                 .filter(instance => hasFileChanges(instance.gitStatus))

package/dist/src/node/server/api/instances.js

@@ -1,5 +1,6 @@
 import Debug from "debug";
 import express from "express";
+import { getGroupedInstancesFromDatabaseInMemory } from "../../utils/databaseInMemory.js";
 import { getDisplayNameFromEntityInstance } from "../../utils/displayName.js";
 import { createChildInstancesForInstanceIdGetter } from "../utils/childInstances.js";
 const debug = Debug("tsondb:server:api:instances");
@@ -11,9 +12,7 @@ instancesApi.use((req, _res, next) => {
 instancesApi.get("/", (req, res) => {
     const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
     const body = {
-        instances: Object.fromEntries(Object.entries(req.instancesByEntityName)
-            .filter(([entityName]) => Object.hasOwn(req.entitiesByName, entityName))
-            .map(([entityName, instances]) => [
+        instances: Object.fromEntries(getGroupedInstancesFromDatabaseInMemory(req.databaseInMemory).map(([entityName, instances]) => [
             entityName,
             instances
                 .map(instance => {

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

@@ -1,10 +1,11 @@
 import type { SimpleGit } from "simple-git";
 import type { SerializedDecl } from "../../shared/schema/declarations/Declaration.ts";
-import type { InstanceContainer, InstancesByEntityName } from "../../shared/utils/instances.ts";
+import type { InstanceContainer } from "../../shared/utils/instances.ts";
 import type { HomeLayoutSection } from "../config.ts";
 import type { Decl } from "../schema/declarations/Declaration.ts";
 import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
 import type { Schema } from "../schema/Schema.ts";
+import type { DatabaseInMemory } from "../utils/databaseInMemory.ts";
 import type { ReferencesToInstances } from "../utils/references.ts";
 export type ServerOptions = {
     port: number;
@@ -15,7 +16,7 @@ export interface TSONDBRequestLocals {
     dataRoot: string;
     declarations: readonly Decl[];
     entities: readonly EntityDecl[];
-    instancesByEntityName: InstancesByEntityName;
+    databaseInMemory: DatabaseInMemory;
     entitiesByName: Record<string, EntityDecl>;
     serializedDeclarationsByName: Record<string, SerializedDecl>;
     localeEntity?: EntityDecl;
@@ -36,4 +37,4 @@ declare global {
         }
     }
 }
-export declare const createServer: (schema: Schema, dataRootPath: string, instancesByEntityName: InstancesByEntityName, 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>, 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, instancesByEntityName, defaultLocales, homeLayoutSections, options, customStylesheetPath) => {
+export const createServer = async (schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections, options, 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, instancesByEntityName,
     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, Object.assign({}, instancesByEntityName), defaultLocales, homeLayoutSections);
+    const requestLocals = await init(schema, dataRootPath, databaseInMemory, defaultLocales, 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,6 @@
-import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
 import type { HomeLayoutSection } from "../config.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, instancesByEntityName: InstancesByEntityName, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[]) => Promise<Omit<TSONDBRequestLocals, "setLocal">>;
+export declare const init: (schema: Schema, dataRootPath: string, databaseInMemory: DatabaseInMemory, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[]) => Promise<Omit<TSONDBRequestLocals, "setLocal">>;
 export declare const reinit: (locals: TSONDBRequestLocals) => Promise<void>;

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

@@ -2,7 +2,8 @@ import Debug from "debug";
 import { simpleGit } from "simple-git";
 import { isEntityDecl } from "../schema/declarations/EntityDecl.js";
 import { resolveTypeArgumentsInDecls, serializeNode } from "../schema/index.js";
-import { attachGitStatusToInstancesByEntityName, getInstancesByEntityName, } from "../utils/instances.js";
+import { createDatabaseInMemory, getInstanceFromDatabaseInMemory, } from "../utils/databaseInMemory.js";
+import { attachGitStatusToDatabaseInMemory } from "../utils/git.js";
 import { getReferencesToInstances } from "../utils/references.js";
 const debug = Debug("tsondb:server:init");
 const getGit = async (dataRootPath) => {
@@ -21,7 +22,7 @@ const getGit = async (dataRootPath) => {
         return { git };
     }
 };
-export const init = async (schema, dataRootPath, instancesByEntityName, defaultLocales, homeLayoutSections) => {
+export const init = async (schema, dataRootPath, databaseInMemory, defaultLocales, homeLayoutSections) => {
     const { git, root: gitRoot, status: gitStatus } = await getGit(dataRootPath);
     const declarations = resolveTypeArgumentsInDecls(schema.declarations);
     debug("resolved type arguments in declarations");
@@ -29,16 +30,17 @@ export const init = async (schema, dataRootPath, instancesByEntityName, defaultL
     debug("found %d entities in declarations", entities.length);
     const entitiesByName = Object.fromEntries(entities.map(entity => [entity.name, entity]));
     const serializedDeclarationsByName = Object.fromEntries(declarations.map(decl => [decl.name, serializeNode(decl)]));
-    const referencesToInstances = await getReferencesToInstances(instancesByEntityName, serializedDeclarationsByName);
+    const referencesToInstances = await getReferencesToInstances(databaseInMemory, serializedDeclarationsByName);
     debug("created references cache");
     if (gitStatus) {
-        attachGitStatusToInstancesByEntityName(instancesByEntityName, dataRootPath, gitRoot, gitStatus);
+        databaseInMemory = attachGitStatusToDatabaseInMemory(databaseInMemory, dataRootPath, gitRoot, gitStatus);
         debug("retrieved git status to instances");
     }
     const getInstanceById = id => {
-        for (const entityName in requestLocals.instancesByEntityName) {
-            const instance = requestLocals.instancesByEntityName[entityName]?.find(i => i.id === id);
-            if (instance && requestLocals.entitiesByName[entityName]) {
+        const res = getInstanceFromDatabaseInMemory(requestLocals.databaseInMemory, id);
+        if (res) {
+            const [entityName, instance] = res;
+            if (requestLocals.entitiesByName[entityName]) {
                 return { entity: requestLocals.entitiesByName[entityName], instance };
             }
         }
@@ -50,7 +52,7 @@ export const init = async (schema, dataRootPath, instancesByEntityName, defaultL
         dataRoot: dataRootPath,
         declarations: declarations,
         entities: entities,
-        instancesByEntityName: Object.assign({}, instancesByEntityName),
+        databaseInMemory,
         entitiesByName: entitiesByName,
         serializedDeclarationsByName,
         localeEntity: schema.localeEntity,
@@ -63,10 +65,11 @@ export const init = async (schema, dataRootPath, instancesByEntityName, defaultL
     return requestLocals;
 };
 export const reinit = async (locals) => {
-    locals.setLocal("instancesByEntityName", await getInstancesByEntityName(locals.dataRoot, locals.entities));
-    locals.setLocal("referencesToInstances", await getReferencesToInstances(locals.instancesByEntityName, locals.serializedDeclarationsByName));
+    let databaseInMemory = await createDatabaseInMemory(locals.dataRoot, locals.entities);
     const gitStatus = (await locals.git.checkIsRepo()) ? await locals.git.status() : undefined;
     if (locals.gitRoot && gitStatus) {
-        attachGitStatusToInstancesByEntityName(locals.instancesByEntityName, locals.dataRoot, locals.gitRoot, gitStatus);
+        databaseInMemory = attachGitStatusToDatabaseInMemory(databaseInMemory, locals.dataRoot, locals.gitRoot, gitStatus);
     }
+    locals.setLocal("databaseInMemory", databaseInMemory);
+    locals.setLocal("referencesToInstances", await getReferencesToInstances(databaseInMemory, locals.serializedDeclarationsByName));
 };

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

@@ -1,6 +1,3 @@
-import { type Result } from "../../../shared/utils/result.ts";
-import { type EntityTaggedInstanceContainerWithChildInstances, type UnsafeEntityTaggedInstanceContainerWithChildInstances } from "../../utils/childInstances.ts";
 import type { GetChildInstancesForInstanceId } from "../../utils/displayName.ts";
 import type { TSONDBRequestLocals } from "../index.ts";
-export declare const updateLocalsAfterInstanceTreeChangeToReflectDiskState: (locals: TSONDBRequestLocals, parentId: string | undefined, parentEntityName: string, oldChildInstances: EntityTaggedInstanceContainerWithChildInstances[], childInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[]) => Promise<Result<void, [code: number, message: string]>>;
 export declare const createChildInstancesForInstanceIdGetter: (locals: TSONDBRequestLocals) => GetChildInstancesForInstanceId;

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

@@ -1,46 +1,5 @@
-import { error, ok } from "../../../shared/utils/result.js";
 import { isEntityDeclWithParentReference } from "../../schema/index.js";
-import { getChildInstancesFromEntity, } from "../../utils/childInstances.js";
-import { updateLocalsAfterInstanceChangeToReflectDiskState } from "./instanceOperations.js";
-export const updateLocalsAfterInstanceTreeChangeToReflectDiskState = async (locals, parentId, parentEntityName, oldChildInstances, childInstances) => {
-    const parentEntity = locals.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) {
-                await updateLocalsAfterInstanceChangeToReflectDiskState(locals, oldChildInstance.entityName, oldChildInstance.id, undefined);
-            }
-            else {
-                await updateLocalsAfterInstanceChangeToReflectDiskState(locals, oldChildInstance.entityName, oldChildInstance.id, newChildInstance.content);
-            }
-        }
-        for (const newChildInstance of childInstances.filter(predicate => predicate.id === undefined)) {
-            if (newChildInstance.id !== undefined) {
-                await updateLocalsAfterInstanceChangeToReflectDiskState(locals, newChildInstance.entityName, newChildInstance.id, newChildInstance.content);
-            }
-        }
-    }
-    else {
-        // new parent, all child instances are new
-        for (const newChildInstance of childInstances) {
-            if (newChildInstance.id !== undefined) {
-                await updateLocalsAfterInstanceChangeToReflectDiskState(locals, newChildInstance.entityName, newChildInstance.id, newChildInstance.content);
-            }
-        }
-    }
-    // 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;
-        await updateLocalsAfterInstanceTreeChangeToReflectDiskState(locals, childInstance.id, childInstance.entityName, oldChildInstance ? oldChildInstance.childInstances : [], childInstance.childInstances);
-    }
-    return ok();
-};
+import { getChildInstancesFromEntity } from "../../utils/childInstances.js";
 export const createChildInstancesForInstanceIdGetter = (locals) => (parentEntityName, parentId, childEntityName) => {
     const parentEntity = locals.entitiesByName[parentEntityName];
     const childEntity = locals.entitiesByName[childEntityName];
@@ -49,5 +8,5 @@ export const createChildInstancesForInstanceIdGetter = (locals) => (parentEntity
         !isEntityDeclWithParentReference(childEntity)) {
         return [];
     }
-    return getChildInstancesFromEntity(locals.instancesByEntityName, parentEntity, parentId, childEntity);
+    return getChildInstancesFromEntity(locals.databaseInMemory, parentEntity, parentId, childEntity);
 };

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>>;