tsondb 0.2.0 → 0.3.0

package/lib/schema/types/references/IncludeIdentifierType.js

@@ -1,6 +1,7 @@
 import { getNestedDeclarations, getReferencesForDecl, resolveTypeArgumentsInDecl, validateDecl, } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
-import { removeParentKey, resolveTypeArgumentsInType, serializeType, } from "../Type.js";
+import { formatEnumType } from "../generic/EnumType.js";
+import { formatValue, removeParentKey, resolveTypeArgumentsInType, serializeType, } from "../Type.js";
 export const GenIncludeIdentifierType = (reference, args) => ({
     kind: NodeKind.IncludeIdentifierType,
     reference,
@@ -18,10 +19,22 @@ export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) =
     ? addedDecls
     : getNestedDeclarations([type.reference, ...addedDecls], type.reference);
 export const validateIncludeIdentifierType = (helpers, type, value) => validateDecl(helpers, type.reference, type.args, value);
-export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => GenIncludeIdentifierType(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg)));
+export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => type.args.length === 0
+    ? type
+    : resolveTypeArgumentsInDecl(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg))).type.value;
 export const serializeIncludeIdentifierType = type => ({
     ...removeParentKey(type),
     reference: type.reference.name,
     args: type.args.map(arg => serializeType(arg)),
 });
 export const getReferencesForIncludeIdentifierType = (type, value) => getReferencesForDecl(resolveTypeArgumentsInDecl(type.reference, type.args), value);
+export const formatIncludeIdentifierValue = (type, value) => {
+    switch (type.reference.kind) {
+        case NodeKind.TypeAliasDecl:
+            return formatValue(type.reference.type.value, value);
+        case NodeKind.EnumDecl:
+            return formatEnumType(type.reference.type.value, value);
+        default:
+            return value;
+    }
+};

package/lib/schema/types/references/NestedEntityMapType.d.ts

@@ -4,7 +4,7 @@ import { EntityDecl } from "../../declarations/EntityDecl.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
 import { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.js";
-import { BaseType, SerializedBaseType, SerializedType, Type } from "../Type.js";
+import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
 type TConstraint = Record<string, MemberDecl<Type, boolean>>;
 export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
     kind: NodeKind["NestedEntityMapType"];
@@ -34,3 +34,4 @@ export declare const validateNestedEntityMapType: Validator<NestedEntityMapType>
 export declare const resolveTypeArgumentsInNestedEntityMapType: (args: Record<string, Type>, type: NestedEntityMapType) => NestedEntityMapType;
 export declare const serializeNestedEntityMapType: Serializer<NestedEntityMapType, SerializedNestedEntityMapType>;
 export declare const getReferencesForNestedEntityMapType: GetReferences<NestedEntityMapType>;
+export declare const formatNestedEntityMapValue: StructureFormatter<NestedEntityMapType>;

package/lib/schema/types/references/NestedEntityMapType.js

@@ -1,9 +1,10 @@
+import { sortObjectKeysAlphabetically } from "../../../shared/utils/object.js";
 import { parallelizeErrors } from "../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { Lazy } from "../../../utils/lazy.js";
 import { NodeKind } from "../../Node.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "../generic/ObjectType.js";
-import { removeParentKey } from "../Type.js";
+import { removeParentKey, } from "../Type.js";
 export const NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,
@@ -54,3 +55,6 @@ export const getReferencesForNestedEntityMapType = (type, value) => typeof value
         .flatMap(item => getReferencesForObjectType(type.type.value, item))
         .concat(Object.keys(value))
     : [];
+export const formatNestedEntityMapValue = (_type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? sortObjectKeysAlphabetically(value)
+    : value;

package/lib/schema/types/references/ReferenceIdentifierType.d.ts

@@ -2,7 +2,7 @@ import { GetNestedDeclarations } from "../../declarations/Declaration.js";
 import { EntityDecl } from "../../declarations/EntityDecl.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, Type } from "../Type.js";
+import { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
 export interface ReferenceIdentifierType extends BaseType {
     kind: NodeKind["ReferenceIdentifierType"];
     entity: EntityDecl;
@@ -19,3 +19,4 @@ export declare const validateReferenceIdentifierType: Validator<ReferenceIdentif
 export declare const resolveTypeArgumentsInReferenceIdentifierType: <Args extends Record<string, Type>>(_args: Args, type: ReferenceIdentifierType) => ReferenceIdentifierType;
 export declare const serializeReferenceIdentifierType: Serializer<ReferenceIdentifierType, SerializedReferenceIdentifierType>;
 export declare const getReferencesForReferenceIdentifierType: GetReferences<ReferenceIdentifierType>;
+export declare const formatReferenceIdentifierValue: StructureFormatter<ReferenceIdentifierType>;

package/lib/schema/types/references/ReferenceIdentifierType.js

@@ -1,7 +1,7 @@
 import { getNestedDeclarations } from "../../declarations/Declaration.js";
 import { createEntityIdentifierType } from "../../declarations/EntityDecl.js";
 import { NodeKind } from "../../Node.js";
-import { removeParentKey, validate } from "../Type.js";
+import { removeParentKey, validate, } from "../Type.js";
 export const ReferenceIdentifierType = (entity) => ({
     kind: NodeKind.ReferenceIdentifierType,
     entity,
@@ -21,3 +21,4 @@ export const serializeReferenceIdentifierType = type => ({
     entity: type.entity.name,
 });
 export const getReferencesForReferenceIdentifierType = (_type, value) => (typeof value === "string" ? [value] : []);
+export const formatReferenceIdentifierValue = (_type, value) => value;

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

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

package/lib/server/api/declarations.js

@@ -0,0 +1,154 @@
+import Debug from "debug";
+import express from "express";
+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 { isOk } from "../../utils/result.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/server/api/git.d.ts

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

package/lib/server/api/git.js

@@ -0,0 +1,174 @@
+import Debug from "debug";
+import express from "express";
+import { join } from "node:path";
+import { serializeEntityDecl } from "../../schema/index.js";
+import { hasFileChanges } from "../../shared/utils/git.js";
+import { getInstanceContainerOverview } from "../../shared/utils/instances.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, 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(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 (error) {
+        res.status(500).send("Commit failed");
+    }
+});
+gitApi.post("/push", async (req, res) => {
+    try {
+        await req.git.push();
+        res.status(200).send("Push successful");
+    }
+    catch (error) {
+        res.status(500).send("Push failed");
+    }
+});
+gitApi.post("/pull", async (req, res) => {
+    try {
+        await req.git.pull();
+        res.status(200).send("Pull successful");
+    }
+    catch (error) {
+        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 (error) {
+        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 (error) {
+        res.status(500).send(`Switch to branch "${req.params.branchName}" failed`);
+    }
+});

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

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

package/lib/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/server/api/instanceOperations.d.ts

@@ -0,0 +1,6 @@
+import { InstanceContainer } from "../../shared/utils/instances.js";
+import { Result } from "../../utils/result.js";
+import { 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/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 {};