tsondb 0.5.18 → 0.6.0

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

@@ -2,11 +2,12 @@ import Debug from "debug";
 import express from "express";
 import { getInstanceContainerOverview } from "../../../shared/utils/instances.js";
 import { isOk } from "../../../shared/utils/result.js";
-import { serializeDecl } from "../../schema/declarations/Declaration.js";
 import { isEntityDecl } from "../../schema/declarations/EntityDecl.js";
 import { isEnumDecl } from "../../schema/declarations/EnumDecl.js";
 import { isTypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
-import { createInstance, deleteInstance, updateInstance } from "./instanceOperations.js";
+import { serializeNode } from "../../schema/index.js";
+import { getChildInstances } from "../../utils/childInstances.js";
+import { createInstance, deleteInstance, updateInstance } from "../utils/instanceOperations.js";
 const debug = Debug("tsondb:server:api:declarations");
 export const declarationsApi = express.Router();
 declarationsApi.use((req, _res, next) => {
@@ -30,7 +31,7 @@ declarationsApi.get("/", (req, res) => {
     }
     const body = {
         declarations: filteredEntities.map(decl => ({
-            declaration: serializeDecl(decl),
+            declaration: serializeNode(decl),
             instanceCount: req.instancesByEntityName[decl.name]?.length ?? 0,
         })),
         localeEntity: req.localeEntity?.name,
@@ -44,7 +45,7 @@ declarationsApi.get("/:name", (req, res) => {
         return;
     }
     const body = {
-        declaration: serializeDecl(decl),
+        declaration: serializeNode(decl),
         instanceCount: req.instancesByEntityName[decl.name]?.length ?? 0,
         isLocaleEntity: decl === req.localeEntity,
     };
@@ -78,7 +79,8 @@ declarationsApi.post("/:name/instances", async (req, res) => {
         res.status(400).send(`Declaration "${decl.name}" is not an entity`);
         return;
     }
-    const result = await createInstance(req, req.params.name, req.body, req.query["id"]);
+    const requestBody = req.body;
+    const result = await createInstance(req, requestBody.instance, req.query["id"]);
     if (isOk(result)) {
         const body = {
             instance: result.value,
@@ -121,7 +123,8 @@ declarationsApi.put("/:name/instances/:id", async (req, res) => {
         res.status(400).send(`Declaration "${decl.name}" is not an entity`);
         return;
     }
-    const result = await updateInstance(req, req.params.name, req.params.id, req.body);
+    const requestBody = req.body;
+    const result = await updateInstance(req, requestBody.instance);
     if (isOk(result)) {
         const body = {
             instance: result.value,
@@ -155,3 +158,18 @@ declarationsApi.delete("/:name/instances/:id", async (req, res) => {
         res.status(result.error[0]).send(result.error[1]);
     }
 });
+declarationsApi.get("/:name/instances/:id/children", (req, res) => {
+    const decl = req.declarations.find(decl => decl.name === req.params.name);
+    if (decl === undefined) {
+        res.status(404).send(`Declaration "${req.params.name}" not found`);
+        return;
+    }
+    if (!isEntityDecl(decl)) {
+        res.status(400).send(`Declaration "${decl.name}" is not an entity`);
+        return;
+    }
+    const body = {
+        instances: getChildInstances(req.instancesByEntityName, decl, req.params.id),
+    };
+    res.json(body);
+});

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

@@ -6,3 +6,14 @@ export const api = express.Router();
 api.use("/declarations", declarationsApi);
 api.use("/instances", instancesApi);
 api.use("/git", gitApi);
+api.get("/config", (req, res) => {
+    const body = {
+        localeEntityName: req.localeEntity?.name,
+        defaultLocales: req.defaultLocales,
+        homeLayoutSections: req.homeLayoutSections?.map(section => ({
+            ...section,
+            entities: section.entities.map(entity => entity.name),
+        })),
+    };
+    res.json(body);
+});

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

@@ -8,18 +8,21 @@ instancesApi.use((req, _res, next) => {
     next();
 });
 instancesApi.get("/", (req, res) => {
-    const locales = (Array.isArray(req.query["locales"]) ? req.query["locales"] : [req.query["locales"]]).filter(locale => typeof locale === "string");
     const body = {
         instances: Object.fromEntries(Object.entries(req.instancesByEntityName)
             .filter(([entityName]) => Object.hasOwn(req.entitiesByName, entityName))
             .map(([entityName, instances]) => [
             entityName,
-            instances.map(instance => ({
-                id: instance.id,
-                name: getDisplayNameFromEntityInstance(
+            instances.map(instance => {
+                const { name, localeId } = getDisplayNameFromEntityInstance(
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                req.entitiesByName[entityName], instance.content, req.getInstanceById, locales),
-            })),
+                req.entitiesByName[entityName], instance.content, req.getInstanceById, req.locales);
+                return {
+                    id: instance.id,
+                    name,
+                    displayNameLocaleId: localeId,
+                };
+            }),
         ])),
     };
     res.json(body);

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

@@ -1,5 +1,7 @@
 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 { 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";
@@ -15,9 +17,12 @@ export interface TSONDBRequestLocals {
     entities: readonly EntityDecl[];
     instancesByEntityName: InstancesByEntityName;
     entitiesByName: Record<string, EntityDecl>;
+    serializedDeclarationsByName: Record<string, SerializedDecl>;
     localeEntity?: EntityDecl;
     referencesToInstances: ReferencesToInstances;
+    defaultLocales: string[];
     locales: string[];
+    homeLayoutSections?: HomeLayoutSection[];
     getInstanceById: GetInstanceById;
 }
 export type GetInstanceById = (id: string) => {
@@ -30,4 +35,4 @@ declare global {
         }
     }
 }
-export declare const createServer: (schema: Schema, dataRootPath: string, instancesByEntityName: InstancesByEntityName, options?: Partial<ServerOptions>) => Promise<void>;
+export declare const createServer: (schema: Schema, dataRootPath: string, instancesByEntityName: InstancesByEntityName, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[], options?: Partial<ServerOptions>) => Promise<void>;

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

@@ -4,6 +4,7 @@ import { findPackageJSON } from "node:module";
 import { dirname, join } from "node:path";
 import { api } from "./api/index.js";
 import { init } from "./init.js";
+import { getLocalesFromRequest } from "./utils/locales.js";
 const debug = Debug("tsondb:server");
 const defaultOptions = {
     port: 3000,
@@ -15,7 +16,7 @@ const staticNodeModule = (moduleName) => {
     }
     return express.static(dirname(pathToPackageJson));
 };
-export const createServer = async (schema, dataRootPath, instancesByEntityName, options) => {
+export const createServer = async (schema, dataRootPath, instancesByEntityName, defaultLocales, homeLayoutSections, options) => {
     const { port } = { ...defaultOptions, ...options };
     const app = express();
     app.use(express.static(join(import.meta.dirname, "../../../../public")));
@@ -24,18 +25,21 @@ 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));
+    const requestLocals = await init(schema, dataRootPath, Object.assign({}, instancesByEntityName), defaultLocales, homeLayoutSections);
     app.use((req, _res, next) => {
         debug("%s %s", req.method, req.originalUrl);
         Object.assign(req, requestLocals);
+        req.locales = getLocalesFromRequest(req) ?? defaultLocales;
         next();
     });
     app.use("/api", api);
     const importMap = JSON.stringify({
         imports: {
             preact: "/js/node_modules/preact/dist/preact.module.js",
-            "preact/hooks": "/js/node_modules/preact/hooks/dist/hooks.module.js",
             "preact/compat": "/js/node_modules/preact/compat/dist/compat.module.js",
+            "preact/debug": "/js/node_modules/preact/debug/dist/debug.module.js",
+            "preact/devtools": "/js/node_modules/preact/devtools/dist/devtools.module.js",
+            "preact/hooks": "/js/node_modules/preact/hooks/dist/hooks.module.js",
             "preact/jsx-runtime": "/js/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js",
             "preact-iso": "/js/node_modules/preact-iso/src/index.js",
         },

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

@@ -1,5 +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 { TSONDBRequestLocals } from "./index.ts";
-export declare const init: (schema: Schema, dataRootPath: string, instancesByEntityName: InstancesByEntityName) => Promise<TSONDBRequestLocals>;
+export declare const init: (schema: Schema, dataRootPath: string, instancesByEntityName: InstancesByEntityName, defaultLocales: string[], homeLayoutSections?: HomeLayoutSection[]) => Promise<TSONDBRequestLocals>;
 export declare const reinit: (locals: TSONDBRequestLocals) => Promise<void>;

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

@@ -1,7 +1,7 @@
 import Debug from "debug";
 import { simpleGit } from "simple-git";
 import { isEntityDecl } from "../schema/declarations/EntityDecl.js";
-import { resolveTypeArgumentsInDecls } from "../schema/index.js";
+import { resolveTypeArgumentsInDecls, serializeNode } from "../schema/index.js";
 import { attachGitStatusToInstancesByEntityName, getInstancesByEntityName, } from "../utils/instances.js";
 import { getReferencesToInstances } from "../utils/references.js";
 const debug = Debug("tsondb:server:init");
@@ -21,15 +21,16 @@ const getGit = async (dataRootPath) => {
         return { git };
     }
 };
-export const init = async (schema, dataRootPath, instancesByEntityName) => {
+export const init = async (schema, dataRootPath, instancesByEntityName, defaultLocales, homeLayoutSections) => {
     const { git, root: gitRoot, status: gitStatus } = await getGit(dataRootPath);
     const declarations = resolveTypeArgumentsInDecls(schema.declarations);
     debug("resolved type arguments in declarations");
     const entities = declarations.filter(isEntityDecl);
     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 instancesByEntityNameInMemory = Object.assign({}, instancesByEntityName);
-    const referencesToInstances = getReferencesToInstances(instancesByEntityName, entitiesByName);
+    const referencesToInstances = await getReferencesToInstances(instancesByEntityName, serializedDeclarationsByName);
     debug("created references cache");
     if (gitStatus) {
         attachGitStatusToInstancesByEntityName(instancesByEntityName, dataRootPath, gitRoot, gitStatus);
@@ -52,22 +53,21 @@ export const init = async (schema, dataRootPath, instancesByEntityName) => {
         entities: entities,
         instancesByEntityName: instancesByEntityNameInMemory,
         entitiesByName: entitiesByName,
+        serializedDeclarationsByName,
         localeEntity: schema.localeEntity,
         getInstanceById,
         referencesToInstances,
-        locales: ["de-DE", "en-US"], // TODO: Make this configurable
+        defaultLocales,
+        locales: defaultLocales,
+        homeLayoutSections,
     };
     return requestLocals;
 };
 export const reinit = async (locals) => {
+    locals.instancesByEntityName = await getInstancesByEntityName(locals.dataRoot, locals.entities);
+    locals.referencesToInstances = await getReferencesToInstances(locals.instancesByEntityName, locals.serializedDeclarationsByName);
     const gitStatus = (await locals.git.checkIsRepo()) ? await locals.git.status() : undefined;
-    const instancesByEntityName = await getInstancesByEntityName(locals.dataRoot, locals.entities);
-    const referencesToInstances = getReferencesToInstances(instancesByEntityName, locals.entitiesByName);
     if (locals.gitRoot && gitStatus) {
-        attachGitStatusToInstancesByEntityName(instancesByEntityName, locals.dataRoot, locals.gitRoot, gitStatus);
+        attachGitStatusToInstancesByEntityName(locals.instancesByEntityName, locals.dataRoot, locals.gitRoot, gitStatus);
     }
-    Object.assign(locals, {
-        instancesByEntityName,
-        referencesToInstances,
-    });
 };

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

@@ -0,0 +1,4 @@
+import { type Result } from "../../../shared/utils/result.ts";
+import type { EntityTaggedInstanceContainerWithChildInstances, UnsafeEntityTaggedInstanceContainerWithChildInstances } from "../../utils/childInstances.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]>>;

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

@@ -0,0 +1,41 @@
+import { error, ok } from "../../../shared/utils/result.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();
+};

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

@@ -0,0 +1,8 @@
+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]>>;

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

@@ -0,0 +1,107 @@
+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;
+};
+export const createInstance = async (locals, instance, idQueryParam) => {
+    const entity = locals.entitiesByName[instance.entityName];
+    if (entity === undefined) {
+        return error([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 res = await Instances.createInstance(locals.dataRoot, locals.localeEntity, locals.instancesByEntityName, entity, instance.content, idQueryParam);
+    if (isError(res)) {
+        return res;
+    }
+    const treeRes = await unsafeApplyInstanceTree(locals.dataRoot, locals.entitiesByName, locals.instancesByEntityName, instance.id, instance.entityName, [], instance.childInstances);
+    if (isError(treeRes)) {
+        return treeRes;
+    }
+    const newInstanceId = res.value;
+    const instanceContainer = await updateLocalsAfterInstanceChangeToReflectDiskState(locals, entity.name, newInstanceId, instance.content);
+    await updateLocalsAfterInstanceTreeChangeToReflectDiskState(locals, newInstanceId, entity.name, [], instance.childInstances);
+    return ok(instanceContainer);
+};
+export const updateInstance = async (locals, instance) => {
+    const instanceContainer = locals.instancesByEntityName[instance.entityName]?.find(instance => instance.id === instance.id);
+    if (instanceContainer === undefined) {
+        return error([404, "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 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];
+    if (instanceContainer === undefined) {
+        return error([404, "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;
+    }
+    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, []);
+    return ok(oldInstanceContainer);
+};

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

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

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

@@ -0,0 +1,8 @@
+export const getLocalesFromRequest = (req) => {
+    const requestLocales = req.query["locales"];
+    return Array.isArray(requestLocales) && requestLocales.every(locale => typeof locale === "string")
+        ? requestLocales
+        : typeof requestLocales === "string"
+            ? [requestLocales]
+            : undefined;
+};

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

@@ -0,0 +1,32 @@
+import type { GitFileStatus } from "../../shared/utils/git.ts";
+import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
+import { type Result } from "../../shared/utils/result.ts";
+import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
+import { type ReferencesToInstances } from "./references.ts";
+export interface ChildInstanceContainer {
+    id?: string;
+    content: unknown;
+    gitStatus?: GitFileStatus;
+}
+export interface EntityTaggedInstanceContainer {
+    entityName: string;
+    id: string;
+    content: unknown;
+}
+export interface CreatedEntityTaggedInstanceContainerWithChildInstances extends GenEntityTaggedInstanceContainerWithChildInstances<undefined, UnsafeEntityTaggedInstanceContainerWithChildInstances> {
+}
+export interface UpdatedEntityTaggedInstanceContainerWithChildInstances extends GenEntityTaggedInstanceContainerWithChildInstances<string, UnsafeEntityTaggedInstanceContainerWithChildInstances> {
+}
+export interface UnsafeEntityTaggedInstanceContainerWithChildInstances extends GenEntityTaggedInstanceContainerWithChildInstances<string | undefined, UnsafeEntityTaggedInstanceContainerWithChildInstances> {
+}
+export interface EntityTaggedInstanceContainerWithChildInstances extends GenEntityTaggedInstanceContainerWithChildInstances<string, EntityTaggedInstanceContainerWithChildInstances> {
+}
+export interface GenEntityTaggedInstanceContainerWithChildInstances<ID extends string | undefined, C> {
+    entityName: string;
+    id: ID;
+    content: unknown;
+    childInstances: C[];
+}
+export declare const getChildInstances: (instancesByEntityName: InstancesByEntityName, parentEntity: EntityDecl, parentId: string) => 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]>>;

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

@@ -0,0 +1,164 @@
+import { hasKey } from "../../shared/utils/object.js";
+import { error, isError, ok } from "../../shared/utils/result.js";
+import { 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";
+const isParentReferenceReferencingParent = (value, parentEntityName, parentId) => {
+    if (typeof value === "object" && value !== null && hasKey(value, "kind")) {
+        return (value.kind === parentEntityName &&
+            hasKey(value, parentEntityName) &&
+            value[parentEntityName] === parentId);
+    }
+    else if (typeof value === "string") {
+        return value === parentId;
+    }
+    else {
+        return false;
+    }
+};
+export const getChildInstances = (instancesByEntityName, parentEntity, parentId) => {
+    const childEntities = reduceNodes((_parentNodes, node, collectedResults) => isChildEntitiesType(node) ? [...collectedResults, node.entity] : collectedResults, [parentEntity], { followIncludes: true });
+    return childEntities.flatMap(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))
+        .map(container => ({
+        ...container,
+        entityName: childEntity.name,
+        childInstances: getChildInstances(instancesByEntityName, 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;
+            }
+        }
+    }
+    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();
+};
+export const unsafeApplyInstanceTree = async (dataRoot, entitiesByName, instancesByEntityName, 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 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;
+        }
+    }
+    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;
+        }
+    }
+    // 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;
+        }
+    }
+    return ok();
+};

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

@@ -1,3 +1,4 @@
 import { type EntityDecl } from "../../node/schema/index.ts";
 import type { GetInstanceById } from "../../node/server/index.ts";
-export declare const getDisplayNameFromEntityInstance: (entity: EntityDecl, instance: unknown, getInstanceById: GetInstanceById, locales?: string[], defaultName?: string, useCustomizer?: boolean) => string;
+import { type DisplayNameResult } from "../../shared/utils/displayName.ts";
+export declare const getDisplayNameFromEntityInstance: (entity: EntityDecl, instance: unknown, getInstanceById: GetInstanceById, locales: string[], defaultName?: string, useCustomizer?: boolean) => DisplayNameResult;