tsondb 0.3.0 → 0.5.0

package/lib/{schema → node/schema}/types/primitives/NumericType.d.ts

@@ -1,5 +1,5 @@
-import { FloatType, SerializedFloatType } from "./FloatType.js";
-import { IntegerType, SerializedIntegerType } from "./IntegerType.js";
+import type { FloatType, SerializedFloatType } from "./FloatType.js";
+import type { IntegerType, SerializedIntegerType } from "./IntegerType.js";
 export type NumericType = FloatType | IntegerType;
 export type SerializedNumericType = SerializedFloatType | SerializedIntegerType;
 export * from "./FloatType.js";

package/lib/node/schema/types/primitives/PrimitiveType.d.ts

@@ -0,0 +1,6 @@
+import type { BooleanType, SerializedBooleanType } from "./BooleanType.js";
+import type { DateType, SerializedDateType } from "./DateType.js";
+import type { NumericType, SerializedNumericType } from "./NumericType.js";
+import type { SerializedStringType, StringType } from "./StringType.js";
+export type PrimitiveType = BooleanType | DateType | NumericType | StringType;
+export type SerializedPrimitiveType = SerializedBooleanType | SerializedDateType | SerializedNumericType | SerializedStringType;

package/lib/{schema → node/schema}/types/primitives/StringType.d.ts

@@ -1,7 +1,8 @@
-import { StringConstraints } from "../../../shared/validation/string.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
+import type { StringConstraints } from "../../../../shared/validation/string.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface StringType extends BaseType, StringConstraints {
     kind: NodeKind["StringType"];
     pattern?: RegExp;

package/lib/{schema → node/schema}/types/primitives/StringType.js

@@ -1,4 +1,4 @@
-import { validateStringConstraints } from "../../../shared/validation/string.js";
+import { validateStringConstraints } from "../../../../shared/validation/string.js";
 import { NodeKind } from "../../Node.js";
 import { removeParentKey } from "../Type.js";
 export const StringType = (options = {}) => ({

package/lib/{schema → node/schema}/types/references/IncludeIdentifierType.d.ts

@@ -1,11 +1,12 @@
-import { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.js";
-import { EnumDecl } from "../../declarations/EnumDecl.js";
-import { TypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../../parameters/TypeParameter.js";
-import { Validator } from "../../validation/type.js";
-import { EnumCaseDecl } from "../generic/EnumType.js";
-import { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+import type { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.js";
+import type { EnumDecl } from "../../declarations/EnumDecl.js";
+import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../../TypeParameter.js";
+import type { Validator } from "../../validation/type.js";
+import type { EnumCaseDecl } from "../generic/EnumType.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
 type TConstraint<Params extends TypeParameter[]> = TypeAliasDecl<string, Type, Params> | EnumDecl<string, Record<string, EnumCaseDecl>, Params>;
 export interface IncludeIdentifierType<Params extends TypeParameter[] = TypeParameter[], T extends TConstraint<Params> = TConstraint<Params>> extends BaseType {
     kind: NodeKind["IncludeIdentifierType"];

package/lib/{schema → node/schema}/types/references/IncludeIdentifierType.js

@@ -1,7 +1,7 @@
 import { getNestedDeclarations, getReferencesForDecl, resolveTypeArgumentsInDecl, validateDecl, } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
 import { formatEnumType } from "../generic/EnumType.js";
-import { formatValue, removeParentKey, resolveTypeArgumentsInType, serializeType, } from "../Type.js";
+import { formatValue, removeParentKey, resolveTypeArgumentsInType, serializeType } from "../Type.js";
 export const GenIncludeIdentifierType = (reference, args) => ({
     kind: NodeKind.IncludeIdentifierType,
     reference,

package/lib/{schema → node/schema}/types/references/NestedEntityMapType.d.ts

@@ -1,11 +1,12 @@
-import { Lazy } from "../../../utils/lazy.js";
-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 { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.js";
-import { BaseType, SerializedBaseType, SerializedType, StructureFormatter, Type } from "../Type.js";
-type TConstraint = Record<string, MemberDecl<Type, boolean>>;
+import { Lazy } from "../../../../shared/utils/lazy.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { EntityDecl } from "../../declarations/EntityDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+type TConstraint = Record<string, MemberDecl>;
 export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;
@@ -13,7 +14,7 @@ export interface NestedEntityMapType<Name extends string = string, T extends TCo
     secondaryEntity: EntityDecl;
     type: Lazy<ObjectType<T>>;
 }
-type TSerializedConstraint = Record<string, SerializedMemberDecl<SerializedType, boolean>>;
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
 export interface SerializedNestedEntityMapType<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;

package/lib/{schema → node/schema}/types/references/NestedEntityMapType.js

@@ -1,19 +1,15 @@
-import { sortObjectKeysAlphabetically } from "../../../shared/utils/object.js";
-import { parallelizeErrors } from "../../../shared/utils/validation.js";
+import { Lazy } from "../../../../shared/utils/lazy.js";
+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 { formatValue, removeParentKey, setParent } from "../Type.js";
 export const NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,
         kind: NodeKind.NestedEntityMapType,
-        type: Lazy.of(() => {
-            const type = options.type;
-            type.parent = nestedEntityMapType;
-            return type;
-        }),
+        type: Lazy.of(() => setParent(options.type, nestedEntityMapType)),
     };
     return nestedEntityMapType;
 };
@@ -22,11 +18,7 @@ const _NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,
         kind: NodeKind.NestedEntityMapType,
-        type: Lazy.of(() => {
-            const type = options.type();
-            type.parent = nestedEntityMapType;
-            return type;
-        }),
+        type: Lazy.of(() => setParent(options.type(), nestedEntityMapType)),
     };
     return nestedEntityMapType;
 };
@@ -55,6 +47,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)
+export const formatNestedEntityMapValue = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? sortObjectKeysAlphabetically(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, formatValue(type.type.value, item)])))
     : value;

package/lib/{schema → node/schema}/types/references/ReferenceIdentifierType.d.ts

@@ -1,8 +1,9 @@
-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, StructureFormatter, Type } from "../Type.js";
+import type { GetNestedDeclarations } from "../../declarations/Declaration.js";
+import type { EntityDecl } from "../../declarations/EntityDecl.js";
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
 export interface ReferenceIdentifierType extends BaseType {
     kind: NodeKind["ReferenceIdentifierType"];
     entity: EntityDecl;
@@ -16,7 +17,7 @@ export { ReferenceIdentifierType as ReferenceIdentifier };
 export declare const isReferenceIdentifierType: (node: Node) => node is ReferenceIdentifierType;
 export declare const getNestedDeclarationsInReferenceIdentifierType: GetNestedDeclarations<ReferenceIdentifierType>;
 export declare const validateReferenceIdentifierType: Validator<ReferenceIdentifierType>;
-export declare const resolveTypeArgumentsInReferenceIdentifierType: <Args extends Record<string, Type>>(_args: Args, type: ReferenceIdentifierType) => ReferenceIdentifierType;
+export declare const resolveTypeArgumentsInReferenceIdentifierType: (_args: Record<string, Type>, 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 → node/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,

package/lib/node/schema/types/references/TypeArgumentType.d.ts

@@ -0,0 +1,23 @@
+import type { GetReferences, Node, Serializer } from "../../Node.js";
+import { NodeKind } from "../../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../../TypeParameter.js";
+import type { Validator } from "../../validation/type.js";
+import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+type TConstraint = TypeParameter;
+export interface TypeArgumentType<T extends TConstraint = TConstraint> extends BaseType {
+    kind: NodeKind["TypeArgumentType"];
+    argument: T;
+}
+type TSerializedConstraint = SerializedTypeParameter;
+export interface SerializedTypeArgumentType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
+    kind: NodeKind["TypeArgumentType"];
+    argument: T;
+}
+export declare const TypeArgumentType: <T extends TConstraint>(argument: T) => TypeArgumentType<T>;
+export { TypeArgumentType as TypeArgument };
+export declare const isTypeArgumentType: (node: Node) => node is TypeArgumentType;
+export declare const validateTypeArgumentType: Validator<TypeArgumentType>;
+export declare const resolveTypeArgumentsInTypeArgumentType: <T extends TConstraint, Args extends Record<string, Type>>(args: Args, type: TypeArgumentType<T>) => Args[T["name"]];
+export declare const serializeTypeArgumentType: Serializer<TypeArgumentType, SerializedTypeArgumentType>;
+export declare const getReferencesForTypeArgumentType: GetReferences<TypeArgumentType>;
+export declare const formatTypeArgumentValue: StructureFormatter<TypeArgumentType>;

package/lib/node/schema/types/references/TypeArgumentType.js

@@ -0,0 +1,19 @@
+import { NodeKind } from "../../Node.js";
+import { serializeTypeParameter } from "../../TypeParameter.js";
+import { removeParentKey } from "../Type.js";
+export const TypeArgumentType = (argument) => ({
+    kind: NodeKind.TypeArgumentType,
+    argument,
+});
+export { TypeArgumentType as TypeArgument };
+export const isTypeArgumentType = (node) => node.kind === NodeKind.TypeArgumentType;
+export const validateTypeArgumentType = (_helpers, type, _value) => {
+    throw new TypeError(`generic argument "${type.argument.name}" has not been replaced with a concrete type`);
+};
+export const resolveTypeArgumentsInTypeArgumentType = (args, type) => args[type.argument.name];
+export const serializeTypeArgumentType = type => ({
+    ...removeParentKey(type),
+    argument: serializeTypeParameter(type.argument),
+});
+export const getReferencesForTypeArgumentType = (_type, _value) => [];
+export const formatTypeArgumentValue = (_type, value) => value;

package/lib/node/schema/validation/type.d.ts

@@ -0,0 +1,4 @@
+import type { Validators } from "../Node.js";
+import type { Type } from "../types/Type.js";
+export type ValidatorHelpers = Validators;
+export type Validator<T extends Type, Args extends unknown[] = []> = (helpers: ValidatorHelpers, type: T, value: unknown, ...args: Args) => Error[];

package/lib/{server → node/server}/api/declarations.js

@@ -1,10 +1,11 @@
 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 { isEntityDecl, serializeEntityDecl } 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();
@@ -59,8 +60,11 @@ declarationsApi.get("/:name/instances", (req, res) => {
         res.status(400).send(`Declaration "${decl.name}" is not an entity`);
         return;
     }
+    const serializedEntityDecl = serializeEntityDecl(decl);
     const body = {
-        instances: req.instancesByEntityName[req.params.name] ?? [],
+        instances: req.instancesByEntityName[req.params.name]
+            ?.map(instanceContainer => getInstanceContainerOverview(serializedEntityDecl, instanceContainer, req.locales))
+            .toSorted((a, b) => a.displayName.localeCompare(b.displayName)) ?? [],
         isLocaleEntity: decl === req.localeEntity,
     };
     res.json(body);

package/lib/{server → node/server}/api/git.js

@@ -1,9 +1,9 @@
 import Debug from "debug";
-import express from "express";
+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 { 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");
@@ -17,9 +17,10 @@ gitApi.use((req, res, next) => {
     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);
+    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,
@@ -27,7 +28,9 @@ gitApi.get("/status", async (req, res) => {
             entityName,
             instances
                 .filter(instance => hasFileChanges(instance.gitStatus))
-                .map(instance => getInstanceContainerOverview(serializeEntityDecl(req.entitiesByName[entityName]), instance, locales)),
+                .map(instance => getInstanceContainerOverview(
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            serializeEntityDecl(req.entitiesByName[entityName]), instance, req.locales)),
         ])),
     };
     res.json(body);
@@ -118,7 +121,7 @@ gitApi.post("/commit", async (req, res) => {
         await req.git.commit(message);
         res.status(200).send("Commit successful");
     }
-    catch (error) {
+    catch {
         res.status(500).send("Commit failed");
     }
 });
@@ -127,7 +130,7 @@ gitApi.post("/push", async (req, res) => {
         await req.git.push();
         res.status(200).send("Push successful");
     }
-    catch (error) {
+    catch {
         res.status(500).send("Push failed");
     }
 });
@@ -136,7 +139,7 @@ gitApi.post("/pull", async (req, res) => {
         await req.git.pull();
         res.status(200).send("Pull successful");
     }
-    catch (error) {
+    catch {
         res.status(500).send("Pull failed");
     }
 });
@@ -159,7 +162,7 @@ gitApi.post("/branch", async (req, res) => {
         await reinit(req);
         res.status(200).send(`Creation of branch "${branchName}" successful`);
     }
-    catch (error) {
+    catch {
         res.status(500).send(`Creation of branch "${branchName}" failed`);
     }
 });
@@ -168,7 +171,7 @@ gitApi.post("/branch/:branchName", async (req, res) => {
         await req.git.checkout(req.params.branchName);
         res.status(200).send(`Switch to branch "${req.params.branchName}" successful`);
     }
-    catch (error) {
+    catch {
         res.status(500).send(`Switch to branch "${req.params.branchName}" failed`);
     }
 });

package/lib/{server → node/server}/api/instanceOperations.d.ts

@@ -1,6 +1,6 @@
-import { InstanceContainer } from "../../shared/utils/instances.js";
-import { Result } from "../../utils/result.js";
-import { TSONDBRequestLocals } from "../index.js";
+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/{server → node/server}/api/instanceOperations.js

@@ -1,16 +1,19 @@
 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 { removeAt } from "../../shared/utils/array.js";
 import { getErrorMessageForDisplay } from "../../utils/error.js";
 import { getGitFileStatusFromStatusResult } from "../../utils/git.js";
+import { formatInstance } from "../../utils/instances.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];
+    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")]);
@@ -20,11 +23,13 @@ export const createInstance = async (locals, entityName, instance, idQueryParam)
     }
     const id = locals.localeEntity === entity ? idQueryParam : uuidv4();
     if (locals.localeEntity === entity &&
-        locals.instancesByEntityName[entity.name].some(instance => instance.id === id)) {
+        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" });
+    await writeFile(join(locals.dataRoot, entity.name, fileName), formatInstance(entity, instance), {
+        encoding: "utf-8",
+    });
     const instanceContainer = {
         fileName,
         id,
@@ -46,11 +51,14 @@ export const updateInstance = async (locals, entityName, instanceId, instance) =
         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" });
+    await writeFile(join(locals.dataRoot, entity.name, instanceContainer.fileName), formatInstance(entity, instance), { encoding: "utf-8" });
     const oldInstance = instanceContainer.content;
     instanceContainer.content = instance;
     instanceContainer.gitStatus =
@@ -77,6 +85,9 @@ export const deleteInstance = async (locals, entityName, instanceId) => {
         return ok(instanceContainer);
     }
     catch (err) {
-        return error([500, `Failed to delete instance: ${err}`]);
+        return error([
+            500,
+            `Failed to delete instance: ${err instanceof Error ? err.toString() : String(err)}`,
+        ]);
     }
 };

package/lib/{server → node/server}/api/instances.js

@@ -1,7 +1,7 @@
 import Debug from "debug";
 import express from "express";
+import { getDisplayNameFromEntityInstance } from "../../../shared/utils/displayName.js";
 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) => {
@@ -11,11 +11,15 @@ instancesApi.use((req, _res, 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]) => [
+        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(serializeEntityDecl(req.entitiesByName[entityName]), instance.content, instance.id, locales),
+                name: getDisplayNameFromEntityInstance(
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                serializeEntityDecl(req.entitiesByName[entityName]), instance.content, instance.id, locales),
             })),
         ])),
     };

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 = {
+    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;
+    locales: string[];
+}
+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/{server → node/server}/index.js

@@ -5,19 +5,19 @@ 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 (modelContainer, instancesByEntityName, options) => {
-    const { name, port } = { ...defaultOptions, ...options };
+export const createServer = async (schema, dataRootPath, instancesByEntityName, options) => {
+    const { 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.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/web")));
+    app.use("/js/shared", express.static(join(import.meta.dirname, "../../../lib/shared")));
     app.use(express.json());
-    const requestLocals = await init(modelContainer, Object.assign({}, instancesByEntityName));
+    const requestLocals = await init(schema, dataRootPath, Object.assign({}, instancesByEntityName));
     app.use((req, _res, next) => {
+        debug("%s %s", req.method, req.originalUrl);
         Object.assign(req, requestLocals);
         next();
     });
@@ -30,9 +30,6 @@ export const createServer = async (modelContainer, instancesByEntityName, option
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>TSONDB</title>
   <link rel="stylesheet" href="/css/styles.css">
-</head>
-<body>
-  <div id="app"></div>
   <script type="importmap">
     {
       "imports": {
@@ -43,11 +40,24 @@ export const createServer = async (modelContainer, instancesByEntityName, option
       }
     }
   </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}`);
+    app.listen(port, (error) => {
+        if (error) {
+            if (error.code === "EADDRINUSE") {
+                debug(`port ${port.toString()} is already in use`);
+            }
+            else {
+                debug("error starting server:", error);
+            }
+        }
+        else {
+            debug(`server 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/{server → node/server}/init.js

@@ -3,8 +3,8 @@ 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 });
+const getGit = async (dataRootPath) => {
+    const git = simpleGit({ baseDir: dataRootPath });
     if (await git.checkIsRepo()) {
         try {
             const root = await git.revparse({ "--show-toplevel": null });
@@ -19,26 +19,27 @@ const getGit = async (modelContainer) => {
         return { git };
     }
 };
-export const init = async (modelContainer, instancesByEntityName) => {
-    const { git, root: gitRoot, status: gitStatus } = await getGit(modelContainer);
-    const declarations = resolveTypeArgumentsInDecls(modelContainer.schema.declarations);
+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, modelContainer.dataRootPath, gitRoot, gitStatus);
+        attachGitStatusToInstancesByEntityName(instancesByEntityName, dataRootPath, gitRoot, gitStatus);
     }
     const requestLocals = {
         git: git,
         gitRoot: gitRoot,
-        dataRoot: modelContainer.dataRootPath,
+        dataRoot: dataRootPath,
         declarations: declarations,
         entities: entities,
         instancesByEntityName: instancesByEntityNameInMemory,
         entitiesByName: entitiesByName,
-        localeEntity: modelContainer.schema.localeEntity,
+        localeEntity: schema.localeEntity,
         referencesToInstances,
+        locales: ["de-DE", "en-US"], // TODO: Make this configurable
     };
     return requestLocals;
 };

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/{utils → node/utils}/git.d.ts

@@ -1,3 +1,3 @@
-import { StatusResult } from "simple-git";
-import { GitFileStatus } from "../shared/utils/git.js";
+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;