tsondb 0.1.3 → 0.3.0

package/lib/server/api/instanceOperations.js

@@ -0,0 +1,82 @@
+import { rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { v4 as uuidv4 } from "uuid";
+import { validateEntityDecl } from "../../schema/declarations/EntityDecl.js";
+import { formatValue } from "../../schema/index.js";
+import { createValidators } from "../../schema/Node.js";
+import { removeAt } from "../../shared/utils/array.js";
+import { getErrorMessageForDisplay } from "../../utils/error.js";
+import { getGitFileStatusFromStatusResult } from "../../utils/git.js";
+import { updateReferencesToInstances } from "../../utils/references.js";
+import { error, ok } from "../../utils/result.js";
+export const createInstance = async (locals, entityName, instance, idQueryParam) => {
+    const entity = locals.entitiesByName[entityName];
+    const validationErrors = validateEntityDecl(createValidators(locals.instancesByEntityName), entity, instance);
+    if (validationErrors.length > 0) {
+        return error([400, validationErrors.map(getErrorMessageForDisplay).join("\n\n")]);
+    }
+    if (locals.localeEntity === entity && typeof idQueryParam !== "string") {
+        return error([400, "Missing id for locale entity"]);
+    }
+    const id = locals.localeEntity === entity ? idQueryParam : uuidv4();
+    if (locals.localeEntity === entity &&
+        locals.instancesByEntityName[entity.name].some(instance => instance.id === id)) {
+        return error([400, `Duplicate id "${id}" for locale entity`]);
+    }
+    const fileName = `${id}.json`;
+    await writeFile(join(locals.dataRoot, entity.name, fileName), JSON.stringify(formatValue(entity.type.value, instance), undefined, 2), { encoding: "utf-8" });
+    const instanceContainer = {
+        fileName,
+        id,
+        content: instance,
+        gitStatus: locals.gitRoot === undefined
+            ? undefined
+            : getGitFileStatusFromStatusResult(await locals.git.status(), locals.gitRoot, locals.dataRoot, entity.name, fileName),
+    };
+    locals.instancesByEntityName[entity.name] = [
+        ...(locals.instancesByEntityName[entity.name] ?? []),
+        instanceContainer,
+    ];
+    Object.assign(locals.referencesToInstances, updateReferencesToInstances(locals.entitiesByName, locals.referencesToInstances, entity.name, id, undefined, instance));
+    return ok(instanceContainer);
+};
+export const updateInstance = async (locals, entityName, instanceId, instance) => {
+    const instanceContainer = locals.instancesByEntityName[entityName]?.find(instance => instance.id === instanceId);
+    if (instanceContainer === undefined) {
+        return error([404, "Instance not found"]);
+    }
+    const entity = locals.entitiesByName[entityName];
+    const validationErrors = validateEntityDecl(createValidators(locals.instancesByEntityName), entity, instance);
+    if (validationErrors.length > 0) {
+        return error([400, validationErrors.map(getErrorMessageForDisplay).join("\n\n")]);
+    }
+    await writeFile(join(locals.dataRoot, entity.name, instanceContainer.fileName), JSON.stringify(formatValue(entity.type.value, instance), undefined, 2), { encoding: "utf-8" });
+    const oldInstance = instanceContainer.content;
+    instanceContainer.content = instance;
+    instanceContainer.gitStatus =
+        locals.gitRoot === undefined
+            ? undefined
+            : getGitFileStatusFromStatusResult(await locals.git.status(), locals.gitRoot, locals.dataRoot, entity.name, instanceContainer.fileName);
+    Object.assign(locals.referencesToInstances, updateReferencesToInstances(locals.entitiesByName, locals.referencesToInstances, entity.name, instanceId, oldInstance, instance));
+    return ok(instanceContainer);
+};
+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"]);
+    }
+    if (locals.referencesToInstances[instanceId]?.some(ref => ref !== instanceId)) {
+        return error([400, "Cannot delete instance that is referenced by other instances"]);
+    }
+    try {
+        await rm(join(locals.dataRoot, entityName, instanceContainer.fileName));
+        locals.instancesByEntityName[entityName] = removeAt(instances, instanceContainerIndex);
+        Object.assign(locals.referencesToInstances, updateReferencesToInstances(locals.entitiesByName, locals.referencesToInstances, entityName, instanceId, instanceContainer.content, undefined));
+        return ok(instanceContainer);
+    }
+    catch (err) {
+        return error([500, `Failed to delete instance: ${err}`]);
+    }
+};

package/lib/server/api/instances.d.ts

@@ -0,0 +1 @@
+export declare const instancesApi: import("express-serve-static-core").Router;

package/lib/server/api/instances.js

@@ -0,0 +1,23 @@
+import Debug from "debug";
+import express from "express";
+import { serializeEntityDecl } from "../../schema/declarations/EntityDecl.js";
+import { getDisplayNameFromEntityInstance } from "../../shared/utils/displayName.js";
+const debug = Debug("tsondb:server:api:instances");
+export const instancesApi = express.Router();
+instancesApi.use((req, _res, next) => {
+    debug(req.path);
+    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).map(([entityName, instances]) => [
+            entityName,
+            instances.map(instance => ({
+                id: instance.id,
+                name: getDisplayNameFromEntityInstance(serializeEntityDecl(req.entitiesByName[entityName]), instance.content, instance.id, locales),
+            })),
+        ])),
+    };
+    res.json(body);
+});

package/lib/server/index.d.ts

@@ -1,8 +1,29 @@
+import { SimpleGit } from "simple-git";
 import { ModelContainer } from "../ModelContainer.js";
+import { Decl } from "../schema/declarations/Declaration.js";
+import { EntityDecl } from "../schema/declarations/EntityDecl.js";
 import { InstancesByEntityName } from "../shared/utils/instances.js";
+import { ReferencesToInstances } from "../utils/references.js";
 type ServerOptions = {
     name: string;
     port: number;
 };
-export declare const createServer: (modelContainer: ModelContainer, instancesByEntityName: InstancesByEntityName, options?: Partial<ServerOptions>) => void;
+export interface TSONDBRequestLocals {
+    git: SimpleGit;
+    gitRoot: string | undefined;
+    dataRoot: string;
+    declarations: readonly Decl[];
+    entities: readonly EntityDecl[];
+    instancesByEntityName: InstancesByEntityName;
+    entitiesByName: Record<string, EntityDecl>;
+    localeEntity?: EntityDecl;
+    referencesToInstances: ReferencesToInstances;
+}
+declare global {
+    namespace Express {
+        interface Request extends TSONDBRequestLocals {
+        }
+    }
+}
+export declare const createServer: (modelContainer: ModelContainer, instancesByEntityName: InstancesByEntityName, options?: Partial<ServerOptions>) => Promise<void>;
 export {};

package/lib/server/index.js

@@ -1,17 +1,14 @@
+import Debug from "debug";
 import express from "express";
 import { join } from "node:path";
-import { serializeDecl } from "../schema/declarations/Declaration.js";
-import { isEntityDecl, serializeEntityDecl } from "../schema/declarations/EntityDecl.js";
-import { isEnumDecl } from "../schema/declarations/EnumDecl.js";
-import { isTypeAliasDecl } from "../schema/declarations/TypeAliasDecl.js";
-import { getDisplayNameFromEntityInstance } from "../shared/utils/displayName.js";
-import { isOk } from "../utils/result.js";
-import { createInstance, deleteInstance, updateInstance } from "./instanceOperations.js";
+import { api } from "./api/index.js";
+import { init } from "./init.js";
+const debug = Debug("tsondb:server");
 const defaultOptions = {
     name: "tsondb server",
     port: 3000,
 };
-export const createServer = (modelContainer, instancesByEntityName, options) => {
+export const createServer = async (modelContainer, instancesByEntityName, options) => {
     const { name, port } = { ...defaultOptions, ...options };
     const app = express();
     app.use(express.static(join(import.meta.dirname, "../../public")));
@@ -19,163 +16,12 @@ export const createServer = (modelContainer, instancesByEntityName, options) =>
     app.use("/js/client", express.static(join(import.meta.dirname, "../../lib/client")));
     app.use("/js/shared", express.static(join(import.meta.dirname, "../../lib/shared")));
     app.use(express.json());
-    const declarations = modelContainer.schema.declarations;
-    const entities = declarations.filter(isEntityDecl);
-    const entitiesByName = Object.fromEntries(entities.map(entity => [entity.name, entity]));
-    const instancesByEntityNameInMemory = { ...instancesByEntityName };
-    app.get("/api/declarations", (req, res) => {
-        let filteredEntities;
-        switch (req.query["kind"]) {
-            case "Entity":
-                filteredEntities = entities.filter(isEntityDecl);
-                break;
-            case "TypeAlias":
-                filteredEntities = entities.filter(isTypeAliasDecl);
-                break;
-            case "Enum":
-                filteredEntities = entities.filter(isEnumDecl);
-                break;
-            default:
-                filteredEntities = declarations;
-        }
-        const body = {
-            declarations: filteredEntities.map(decl => ({
-                declaration: serializeDecl(decl),
-                instanceCount: instancesByEntityNameInMemory[decl.name]?.length ?? 0,
-            })),
-            localeEntity: modelContainer.schema.localeEntity?.name,
-        };
-        res.json(body);
-    });
-    app.get("/api/declarations/:name", (req, res) => {
-        const decl = declarations.find(decl => decl.name === req.params.name);
-        if (decl === undefined) {
-            res.status(404).send(`Declaration "${req.params.name}" not found`);
-            return;
-        }
-        const body = {
-            declaration: serializeDecl(decl),
-            instanceCount: instancesByEntityNameInMemory[decl.name]?.length ?? 0,
-            isLocaleEntity: decl === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.get("/api/declarations/:name/instances", (req, res) => {
-        const decl = 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: instancesByEntityNameInMemory[req.params.name] ?? [],
-            isLocaleEntity: decl === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.post("/api/declarations/:name/instances", async (req, res) => {
-        const decl = 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 result = await createInstance(modelContainer, entitiesByName, instancesByEntityNameInMemory, decl.name, req.body, req.query["id"]);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.get("/api/declarations/:name/instances/:id", (req, res) => {
-        const decl = 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 instance = instancesByEntityNameInMemory[decl.name]?.find(instance => instance.id === req.params.id);
-        if (instance === undefined) {
-            res.status(404).send(`Instance "${req.params.id}" not found`);
-            return;
-        }
-        const body = {
-            instance: instance,
-            isLocaleEntity: decl === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.put("/api/declarations/:name/instances/:id", async (req, res) => {
-        const decl = 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 result = await updateInstance(modelContainer, entitiesByName, instancesByEntityNameInMemory, decl.name, req.params.id, req.body);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.delete("/api/declarations/:name/instances/:id", async (req, res) => {
-        const decl = 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 result = await deleteInstance(modelContainer, instancesByEntityNameInMemory, decl.name, req.params.id);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.get("/api/instances", (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(instancesByEntityNameInMemory).map(([entityName, instances]) => [
-                entityName,
-                instances.map(instance => ({
-                    id: instance.id,
-                    name: getDisplayNameFromEntityInstance(serializeEntityDecl(entitiesByName[entityName]), instance.content, instance.id, locales),
-                })),
-            ])),
-        };
-        res.json(body);
+    const requestLocals = await init(modelContainer, Object.assign({}, instancesByEntityName));
+    app.use((req, _res, next) => {
+        Object.assign(req, requestLocals);
+        next();
     });
+    app.use("/api", api);
     app.get(/^\/.*/, (_req, res) => {
         res.send(`<!DOCTYPE html>
 <html lang="en">
@@ -202,6 +48,6 @@ export const createServer = (modelContainer, instancesByEntityName, options) =>
 </html>`);
     });
     app.listen(port, () => {
-        console.log(`${name} listening on http://localhost:${port}`);
+        debug(`${name} listening on http://localhost:${port}`);
     });
 };

package/lib/server/init.d.ts

@@ -0,0 +1,5 @@
+import { ModelContainer } from "../ModelContainer.js";
+import { InstancesByEntityName } from "../shared/utils/instances.js";
+import { TSONDBRequestLocals } from "./index.js";
+export declare const init: (modelContainer: ModelContainer, instancesByEntityName: InstancesByEntityName) => Promise<TSONDBRequestLocals>;
+export declare const reinit: (locals: TSONDBRequestLocals) => Promise<void>;

package/lib/server/init.js

@@ -0,0 +1,56 @@
+import { simpleGit } from "simple-git";
+import { isEntityDecl } from "../schema/declarations/EntityDecl.js";
+import { resolveTypeArgumentsInDecls } from "../schema/index.js";
+import { attachGitStatusToInstancesByEntityName, getInstancesByEntityName, } from "../utils/instances.js";
+import { getReferencesToInstances } from "../utils/references.js";
+const getGit = async (modelContainer) => {
+    const git = simpleGit({ baseDir: modelContainer.dataRootPath });
+    if (await git.checkIsRepo()) {
+        try {
+            const root = await git.revparse({ "--show-toplevel": null });
+            const status = await git.status();
+            return { git, root, status };
+        }
+        catch {
+            return { git };
+        }
+    }
+    else {
+        return { git };
+    }
+};
+export const init = async (modelContainer, instancesByEntityName) => {
+    const { git, root: gitRoot, status: gitStatus } = await getGit(modelContainer);
+    const declarations = resolveTypeArgumentsInDecls(modelContainer.schema.declarations);
+    const entities = declarations.filter(isEntityDecl);
+    const entitiesByName = Object.fromEntries(entities.map(entity => [entity.name, entity]));
+    const instancesByEntityNameInMemory = Object.assign({}, instancesByEntityName);
+    const referencesToInstances = getReferencesToInstances(instancesByEntityName, entitiesByName);
+    if (gitStatus) {
+        attachGitStatusToInstancesByEntityName(instancesByEntityName, modelContainer.dataRootPath, gitRoot, gitStatus);
+    }
+    const requestLocals = {
+        git: git,
+        gitRoot: gitRoot,
+        dataRoot: modelContainer.dataRootPath,
+        declarations: declarations,
+        entities: entities,
+        instancesByEntityName: instancesByEntityNameInMemory,
+        entitiesByName: entitiesByName,
+        localeEntity: modelContainer.schema.localeEntity,
+        referencesToInstances,
+    };
+    return requestLocals;
+};
+export const reinit = async (locals) => {
+    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);
+    }
+    Object.assign(locals, {
+        instancesByEntityName,
+        referencesToInstances,
+    });
+};

package/lib/shared/api.d.ts

@@ -1,5 +1,5 @@
 import { SerializedDecl } from "../schema/declarations/Declaration.js";
-import { InstanceContainer } from "./utils/instances.js";
+import { InstanceContainer, InstanceContainerOverview } from "./utils/instances.js";
 export interface GetAllDeclarationsResponseBody<D extends SerializedDecl = SerializedDecl> {
     declarations: {
         declaration: D;
@@ -40,3 +40,14 @@ export interface GetAllInstancesResponseBody {
         }[];
     };
 }
+export interface GitStatusResponseBody {
+    commitsAhead: number;
+    commitsBehind: number;
+    instances: {
+        [entity: string]: InstanceContainerOverview[];
+    };
+}
+export interface GetAllGitBranchesResponseBody {
+    allBranches: string[];
+    currentBranch: string;
+}

package/lib/shared/utils/array.d.ts

@@ -0,0 +1,19 @@
+export declare const removeAt: <T>(arr: T[], index: number) => T[];
+export declare const insertAt: <T>(arr: T[], index: number, item: T) => T[];
+/**
+ * Calculates the difference between two arrays, including duplicated values.
+ * @param oldArr - The original array.
+ * @param newArr - The new array to compare against.
+ * @returns An object containing the added and removed elements.
+ */
+export declare const difference: <T>(oldArr: T[], newArr: T[]) => ArrayDiffResult<T>;
+export interface ArrayDiffResult<T> {
+    /**
+     * Elements in `newArr` that are not in `oldArr`.
+     */
+    added: T[];
+    /**
+     * Elements in `oldArr` that are not in `newArr`.
+     */
+    removed: T[];
+}

package/lib/shared/utils/array.js

@@ -0,0 +1,27 @@
+export const removeAt = (arr, index) => [
+    ...arr.slice(0, index),
+    ...arr.slice(index + 1),
+];
+export const insertAt = (arr, index, item) => [
+    ...arr.slice(0, index),
+    item,
+    ...arr.slice(index),
+];
+/**
+ * Calculates the difference between two arrays, including duplicated values.
+ * @param oldArr - The original array.
+ * @param newArr - The new array to compare against.
+ * @returns An object containing the added and removed elements.
+ */
+export const difference = (oldArr, newArr) => newArr.reduce((acc, item) => {
+    const oldIndex = acc.removed.indexOf(item);
+    const newIndex = acc.added.indexOf(item);
+    if (oldIndex > -1) {
+        return {
+            ...acc,
+            removed: removeAt(acc.removed, oldIndex),
+            added: removeAt(acc.added, newIndex),
+        };
+    }
+    return acc;
+}, { removed: oldArr, added: newArr });

package/lib/shared/utils/git.d.ts

@@ -0,0 +1,12 @@
+export type GitFileStatus = {
+    index: GitFileStatusCode;
+    workingDir: GitFileStatusCode;
+};
+export declare const isChangedInIndex: (fileStatus: GitFileStatus) => boolean;
+export declare const isChangedInWorkingDir: (fileStatus: GitFileStatus) => boolean;
+export type GitFileStatusCode = " " | "M" | "T" | "A" | "D" | "R" | "C" | "U" | "m" | "?" | "!";
+export declare const isUnchangedStatus: (code: GitFileStatusCode) => boolean;
+export type GitFileStatusForDisplay = "U" | "M" | "A" | "D" | "R" | undefined;
+export declare const hasFileChanges: (fileStatus: GitFileStatus | undefined) => boolean;
+export declare const getGitStatusForDisplay: (fileStatus: GitFileStatus | undefined) => GitFileStatusForDisplay;
+export declare const getLabelForGitStatus: (status: GitFileStatusForDisplay) => string;

package/lib/shared/utils/git.js

@@ -0,0 +1,98 @@
+export const isChangedInIndex = (fileStatus) => {
+    const { index } = fileStatus;
+    switch (index) {
+        case "M":
+        case "T":
+        case "A":
+        case "D":
+        case "R":
+        case "C":
+        case "U":
+            return true;
+        case " ":
+        case "m":
+        case "?":
+        case "!":
+            return false;
+    }
+};
+export const isChangedInWorkingDir = (fileStatus) => {
+    const { workingDir } = fileStatus;
+    switch (workingDir) {
+        case "M":
+        case "T":
+        case "A":
+        case "D":
+        case "R":
+        case "C":
+        case "U":
+        case "?":
+            return true;
+        case " ":
+        case "m":
+        case "!":
+            return false;
+    }
+};
+const unchangedStatusCodes = new Set([" ", "!", "C", "T", "m", "U"]);
+export const isUnchangedStatus = (code) => unchangedStatusCodes.has(code);
+export const hasFileChanges = (fileStatus) => {
+    if (fileStatus === undefined) {
+        return false;
+    }
+    const { index, workingDir } = fileStatus;
+    return !isUnchangedStatus(index) || !isUnchangedStatus(workingDir);
+};
+export const getGitStatusForDisplay = (fileStatus) => {
+    if (fileStatus === undefined) {
+        return undefined;
+    }
+    const { index, workingDir } = fileStatus;
+    switch (workingDir) {
+        case " ":
+            switch (index) {
+                case " ":
+                    return undefined;
+                case "M":
+                    return "M";
+                case "A":
+                    return "A";
+                case "D":
+                    return "D";
+                case "R":
+                    return "R";
+                case "?":
+                    return "U";
+                default:
+                    return undefined;
+            }
+        case "M":
+            return "M";
+        case "A":
+            return "A";
+        case "D":
+            return "D";
+        case "R":
+            return "R";
+        case "?":
+            return "U";
+        default:
+            return undefined;
+    }
+};
+export const getLabelForGitStatus = (status) => {
+    switch (status) {
+        case "U":
+            return "untracked";
+        case "M":
+            return "modified";
+        case "A":
+            return "sdded";
+        case "D":
+            return "deleted";
+        case "R":
+            return "renamed";
+        default:
+            return "";
+    }
+};

package/lib/shared/utils/instances.d.ts

@@ -1,6 +1,16 @@
+import { SerializedEntityDecl } from "../../schema/index.js";
+import { GitFileStatus } from "./git.js";
 export interface InstanceContainer {
     fileName: string;
     id: string;
     content: unknown;
+    gitStatus?: GitFileStatus;
 }
+export interface InstanceContainerOverview {
+    fileName: string;
+    id: string;
+    gitStatus?: GitFileStatus;
+    displayName: string;
+}
+export declare const getInstanceContainerOverview: (entity: SerializedEntityDecl, instanceContainer: InstanceContainer, locales?: string[]) => InstanceContainerOverview;
 export type InstancesByEntityName = Record<string, InstanceContainer[]>;

package/lib/shared/utils/instances.js

@@ -1 +1,8 @@
-export {};
+import { getDisplayNameFromEntityInstance } from "./displayName.js";
+export const getInstanceContainerOverview = (entity, instanceContainer, locales) => {
+    const { content: _, ...rest } = instanceContainer;
+    return {
+        ...rest,
+        displayName: getDisplayNameFromEntityInstance(entity, instanceContainer.content, instanceContainer.id, locales),
+    };
+};

package/lib/shared/utils/markdown.d.ts

@@ -0,0 +1,14 @@
+type TextNode = {
+    kind: "text";
+    content: string;
+};
+export type InlineMarkdownNode = {
+    kind: "bold" | "italic";
+    content: InlineMarkdownNode[];
+} | TextNode;
+export type BlockMarkdownNode = {
+    kind: "paragraph";
+    content: InlineMarkdownNode[];
+} | TextNode;
+export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
+export {};