tsondb 0.2.0 → 0.4.0

package/lib/node/server/api/declarations.js

@@ -0,0 +1,154 @@
+import Debug from "debug";
+import express from "express";
+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";
+const debug = Debug("tsondb:server:api:declarations");
+export const declarationsApi = express.Router();
+declarationsApi.use((req, _res, next) => {
+    debug(req.path);
+    next();
+});
+declarationsApi.get("/", (req, res) => {
+    let filteredEntities;
+    switch (req.query["kind"]) {
+        case "Entity":
+            filteredEntities = req.entities;
+            break;
+        case "TypeAlias":
+            filteredEntities = req.declarations.filter(isTypeAliasDecl);
+            break;
+        case "Enum":
+            filteredEntities = req.declarations.filter(isEnumDecl);
+            break;
+        default:
+            filteredEntities = req.declarations;
+    }
+    const body = {
+        declarations: filteredEntities.map(decl => ({
+            declaration: serializeDecl(decl),
+            instanceCount: req.instancesByEntityName[decl.name]?.length ?? 0,
+        })),
+        localeEntity: req.localeEntity?.name,
+    };
+    res.json(body);
+});
+declarationsApi.get("/:name", (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;
+    }
+    const body = {
+        declaration: serializeDecl(decl),
+        instanceCount: req.instancesByEntityName[decl.name]?.length ?? 0,
+        isLocaleEntity: decl === req.localeEntity,
+    };
+    res.json(body);
+});
+declarationsApi.get("/:name/instances", (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: req.instancesByEntityName[req.params.name] ?? [],
+        isLocaleEntity: decl === req.localeEntity,
+    };
+    res.json(body);
+});
+declarationsApi.post("/:name/instances", async (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 result = await createInstance(req, req.params.name, req.body, req.query["id"]);
+    if (isOk(result)) {
+        const body = {
+            instance: result.value,
+            isLocaleEntity: decl === req.localeEntity,
+        };
+        res.json(body);
+    }
+    else {
+        res.status(result.error[0]).send(result.error[1]);
+    }
+});
+declarationsApi.get("/:name/instances/:id", (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 instance = req.instancesByEntityName[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 === req.localeEntity,
+    };
+    res.json(body);
+});
+declarationsApi.put("/:name/instances/:id", async (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 result = await updateInstance(req, req.params.name, req.params.id, req.body);
+    if (isOk(result)) {
+        const body = {
+            instance: result.value,
+            isLocaleEntity: decl === req.localeEntity,
+        };
+        res.json(body);
+    }
+    else {
+        res.status(result.error[0]).send(result.error[1]);
+    }
+});
+declarationsApi.delete("/:name/instances/:id", async (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 result = await deleteInstance(req, req.params.name, req.params.id);
+    if (isOk(result)) {
+        const body = {
+            instance: result.value,
+            isLocaleEntity: decl === req.localeEntity,
+        };
+        res.json(body);
+    }
+    else {
+        res.status(result.error[0]).send(result.error[1]);
+    }
+});

package/lib/node/server/api/git.d.ts

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

package/lib/node/server/api/git.js

@@ -0,0 +1,178 @@
+import Debug from "debug";
+import express, {} from "express";
+import { join } from "node:path";
+import { hasFileChanges } from "../../../shared/utils/git.js";
+import { getInstanceContainerOverview } from "../../../shared/utils/instances.js";
+import { serializeEntityDecl } from "../../schema/index.js";
+import { attachGitStatusToInstancesByEntityName } from "../../utils/instances.js";
+import { reinit } from "../init.js";
+const debug = Debug("tsondb:server:api:git");
+export const gitApi = express.Router();
+gitApi.use((req, res, next) => {
+    debug(req.path);
+    if (req.gitRoot === undefined) {
+        res.status(500).send("Git repository not found");
+        return;
+    }
+    next();
+});
+gitApi.get("/status", async (req, res) => {
+    const locales = (Array.isArray(req.query["locales"]) ? req.query["locales"] : [req.query["locales"]]).filter(locale => typeof locale === "string");
+    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 body = {
+        commitsAhead: status.ahead,
+        commitsBehind: status.behind,
+        instances: Object.fromEntries(Object.entries(req.instancesByEntityName).map(([entityName, instances]) => [
+            entityName,
+            instances
+                .filter(instance => hasFileChanges(instance.gitStatus))
+                .map(instance => getInstanceContainerOverview(
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            serializeEntityDecl(req.entitiesByName[entityName]), instance, locales)),
+        ])),
+    };
+    res.json(body);
+});
+gitApi.post("/stage", async (req, res) => {
+    try {
+        await req.git.add(req.dataRoot);
+        res.status(200).send("Added all database files to index");
+    }
+    catch (error) {
+        debug(`${req.path}: ${error.message}`);
+        res.status(500).send("Adding all database files to index failed");
+    }
+});
+gitApi.post("/stage/:entityName", async (req, res) => {
+    try {
+        await req.git.add(join(req.dataRoot, req.params.entityName));
+        res.status(200).send(`Added all database files for entity ${req.params.entityName} to index`);
+    }
+    catch (error) {
+        debug(`${req.path}: ${error.message}`);
+        res
+            .status(500)
+            .send(`Adding all database files for entity ${req.params.entityName} to index failed`);
+    }
+});
+gitApi.post("/stage/:entityName/:instanceId", async (req, res) => {
+    try {
+        await req.git.add(join(req.dataRoot, req.params.entityName, `${req.params.instanceId}.json`));
+        res
+            .status(200)
+            .send(`Added database file ${req.params.instanceId} for entity ${req.params.entityName} to index`);
+    }
+    catch (error) {
+        debug(`${req.path}: ${error.message}`);
+        res
+            .status(500)
+            .send(`Adding database file ${req.params.instanceId} for entity ${req.params.entityName} to index failed`);
+    }
+});
+gitApi.post("/unstage", async (req, res) => {
+    try {
+        await req.git.reset(["HEAD", "--", req.dataRoot]);
+        res.status(200).send("Removed all database files to index");
+    }
+    catch (error) {
+        debug(`${req.path}: ${error.message}`);
+        res.status(500).send("Removing all database files to index failed");
+    }
+});
+gitApi.post("/unstage/:entityName", async (req, res) => {
+    try {
+        await req.git.reset(["HEAD", "--", join(req.dataRoot, req.params.entityName)]);
+        res.status(200).send(`Removed all database files for entity ${req.params.entityName} to index`);
+    }
+    catch (error) {
+        debug(`${req.path}: ${error.message}`);
+        res
+            .status(500)
+            .send(`Removing all database files for entity ${req.params.entityName} to index failed`);
+    }
+});
+gitApi.post("/unstage/:entityName/:instanceId", async (req, res) => {
+    try {
+        await req.git.reset([
+            "HEAD",
+            "--",
+            join(req.dataRoot, req.params.entityName, `${req.params.instanceId}.json`),
+        ]);
+        res
+            .status(200)
+            .send(`Removed database file ${req.params.instanceId} for entity ${req.params.entityName} to index`);
+    }
+    catch (error) {
+        debug(`${req.path}: ${error.message}`);
+        res
+            .status(500)
+            .send(`Removing database file ${req.params.instanceId} for entity ${req.params.entityName} to index failed`);
+    }
+});
+gitApi.post("/commit", async (req, res) => {
+    const message = req.body.message;
+    if (typeof message !== "string" || message.length === 0) {
+        res.status(400).send("Invalid commit message");
+        return;
+    }
+    try {
+        await req.git.commit(message);
+        res.status(200).send("Commit successful");
+    }
+    catch {
+        res.status(500).send("Commit failed");
+    }
+});
+gitApi.post("/push", async (req, res) => {
+    try {
+        await req.git.push();
+        res.status(200).send("Push successful");
+    }
+    catch {
+        res.status(500).send("Push failed");
+    }
+});
+gitApi.post("/pull", async (req, res) => {
+    try {
+        await req.git.pull();
+        res.status(200).send("Pull successful");
+    }
+    catch {
+        res.status(500).send("Pull failed");
+    }
+});
+gitApi.get("/branch", async (req, res) => {
+    const branchSummary = await req.git.branchLocal();
+    const body = {
+        allBranches: branchSummary.all,
+        currentBranch: branchSummary.current,
+    };
+    res.json(body);
+});
+gitApi.post("/branch", async (req, res) => {
+    const branchName = req.body.branchName;
+    if (typeof branchName !== "string" || branchName.length === 0) {
+        res.status(400).send("Invalid branch name");
+        return;
+    }
+    try {
+        await req.git.checkoutLocalBranch(branchName);
+        await reinit(req);
+        res.status(200).send(`Creation of branch "${branchName}" successful`);
+    }
+    catch {
+        res.status(500).send(`Creation of branch "${branchName}" failed`);
+    }
+});
+gitApi.post("/branch/:branchName", async (req, res) => {
+    try {
+        await req.git.checkout(req.params.branchName);
+        res.status(200).send(`Switch to branch "${req.params.branchName}" successful`);
+    }
+    catch {
+        res.status(500).send(`Switch to branch "${req.params.branchName}" failed`);
+    }
+});

package/lib/node/server/api/index.d.ts

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

package/lib/node/server/api/index.js

@@ -0,0 +1,8 @@
+import express from "express";
+import { declarationsApi } from "./declarations.js";
+import { gitApi } from "./git.js";
+import { instancesApi } from "./instances.js";
+export const api = express.Router();
+api.use("/declarations", declarationsApi);
+api.use("/instances", instancesApi);
+api.use("/git", gitApi);

package/lib/node/server/api/instanceOperations.d.ts

@@ -0,0 +1,6 @@
+import type { InstanceContainer } from "../../../shared/utils/instances.js";
+import type { Result } from "../../../shared/utils/result.js";
+import type { TSONDBRequestLocals } from "../index.js";
+export declare const createInstance: (locals: TSONDBRequestLocals, entityName: string, instance: unknown, idQueryParam: unknown) => Promise<Result<InstanceContainer, [code: number, message: string]>>;
+export declare const updateInstance: (locals: TSONDBRequestLocals, entityName: string, instanceId: string, instance: unknown) => 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/lib/node/server/api/instanceOperations.js

@@ -0,0 +1,91 @@
+import { rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { v4 as uuidv4 } from "uuid";
+import { removeAt } from "../../../shared/utils/array.js";
+import { error, ok } from "../../../shared/utils/result.js";
+import { validateEntityDecl } from "../../schema/declarations/EntityDecl.js";
+import { formatValue } from "../../schema/index.js";
+import { createValidators } from "../../schema/Node.js";
+import { getErrorMessageForDisplay } from "../../utils/error.js";
+import { getGitFileStatusFromStatusResult } from "../../utils/git.js";
+import { updateReferencesToInstances } from "../../utils/references.js";
+export const createInstance = async (locals, entityName, instance, idQueryParam) => {
+    const entity = locals.entitiesByName[entityName];
+    if (entity === undefined) {
+        return error([400, "Entity not found"]);
+    }
+    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];
+    if (entity === undefined) {
+        return error([400, "Entity not found"]);
+    }
+    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 instanceof Error ? err.toString() : String(err)}`,
+        ]);
+    }
+};

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

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

package/lib/node/server/api/instances.js

@@ -0,0 +1,27 @@
+import Debug from "debug";
+import express from "express";
+import { getDisplayNameFromEntityInstance } from "../../../shared/utils/displayName.js";
+import { serializeEntityDecl } from "../../schema/declarations/EntityDecl.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)
+            .filter(([entityName]) => Object.hasOwn(req.entitiesByName, entityName))
+            .map(([entityName, instances]) => [
+            entityName,
+            instances.map(instance => ({
+                id: instance.id,
+                name: getDisplayNameFromEntityInstance(
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                serializeEntityDecl(req.entitiesByName[entityName]), instance.content, instance.id, locales),
+            })),
+        ])),
+    };
+    res.json(body);
+});

package/lib/node/server/index.d.ts

@@ -0,0 +1,28 @@
+import type { SimpleGit } from "simple-git";
+import type { InstancesByEntityName } from "../../shared/utils/instances.js";
+import type { Schema } from "../Schema.ts";
+import type { Decl } from "../schema/declarations/Declaration.js";
+import type { EntityDecl } from "../schema/declarations/EntityDecl.js";
+import type { ReferencesToInstances } from "../utils/references.js";
+export type ServerOptions = {
+    name: string;
+    port: number;
+};
+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: (schema: Schema, dataRootPath: string, instancesByEntityName: InstancesByEntityName, options?: Partial<ServerOptions>) => Promise<void>;

package/lib/node/server/index.js

@@ -0,0 +1,53 @@
+import Debug from "debug";
+import express from "express";
+import { join } from "node:path";
+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 = async (schema, dataRootPath, instancesByEntityName, options) => {
+    const { name, port } = { ...defaultOptions, ...options };
+    const app = express();
+    app.use(express.static(join(import.meta.dirname, "../../public")));
+    app.use("/js/node_modules", express.static(join(import.meta.dirname, "../../node_modules")));
+    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 requestLocals = await init(schema, dataRootPath, 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">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>TSONDB</title>
+  <link rel="stylesheet" href="/css/styles.css">
+  <script type="importmap">
+    {
+      "imports": {
+        "preact": "/js/node_modules/preact/dist/preact.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"
+      }
+    }
+  </script>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="/js/client/index.js"></script>
+</body>
+</html>`);
+    });
+    app.listen(port, () => {
+        debug(`${name} listening on http://localhost:${port.toString()}`);
+    });
+};

package/lib/node/server/init.d.ts

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

package/lib/node/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 (dataRootPath) => {
+    const git = simpleGit({ baseDir: 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 (schema, dataRootPath, instancesByEntityName) => {
+    const { git, root: gitRoot, status: gitStatus } = await getGit(dataRootPath);
+    const declarations = resolveTypeArgumentsInDecls(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, dataRootPath, gitRoot, gitStatus);
+    }
+    const requestLocals = {
+        git: git,
+        gitRoot: gitRoot,
+        dataRoot: dataRootPath,
+        declarations: declarations,
+        entities: entities,
+        instancesByEntityName: instancesByEntityNameInMemory,
+        entitiesByName: entitiesByName,
+        localeEntity: 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/{utils → node/utils}/error.js

@@ -1,7 +1,10 @@
 import { applyIndentation } from "./render.js";
 export const getErrorMessageForDisplay = (error) => {
     if (error instanceof AggregateError) {
-        return `${error.message}\n${applyIndentation(1, error.errors.map(subError => getErrorMessageForDisplay(subError)).join("\n"), 2)}`;
+        return `${error.message}\n${applyIndentation(1, error.errors
+            .filter(subError => subError instanceof Error)
+            .map(subError => getErrorMessageForDisplay(subError))
+            .join("\n"), 2)}`;
     }
     else if (error.cause instanceof Error) {
         return `${error.message}\n${applyIndentation(1, getErrorMessageForDisplay(error.cause), 2)}`;

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

@@ -0,0 +1,3 @@
+import type { StatusResult } from "simple-git";
+import type { GitFileStatus } from "../../shared/utils/git.js";
+export declare const getGitFileStatusFromStatusResult: (statusResult: StatusResult, repoRoot: string, dataRoot: string, entityName: string, fileName: string) => GitFileStatus | undefined;

package/lib/node/utils/git.js

@@ -0,0 +1,12 @@
+import { join } from "path";
+export const getGitFileStatusFromStatusResult = (statusResult, repoRoot, dataRoot, entityName, fileName) => {
+    const filePath = join(dataRoot, entityName, fileName);
+    const gitFile = statusResult.files.find(file => join(repoRoot, file.path) === filePath);
+    if (gitFile === undefined) {
+        return;
+    }
+    return {
+        index: gitFile.index,
+        workingDir: gitFile.working_dir,
+    };
+};

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

@@ -0,0 +1,5 @@
+import type { StatusResult } from "simple-git";
+import type { InstancesByEntityName } from "../../shared/utils/instances.js";
+import type { EntityDecl } from "../schema/declarations/EntityDecl.js";
+export declare const getInstancesByEntityName: (dataRoot: string, entities: readonly EntityDecl[]) => Promise<InstancesByEntityName>;
+export declare const attachGitStatusToInstancesByEntityName: (instancesByEntityName: InstancesByEntityName, dataRoot: string, gitRoot: string, gitStatus: StatusResult) => void;