tsondb 0.1.3 → 0.3.0

package/lib/schema/types/primitives/DateType.js

@@ -15,3 +15,4 @@ export const validateDateType = (_helpers, type, value) => {
 };
 export const serializeDateType = type => removeParentKey(type);
 export const getReferencesForDateType = (_type, _value) => [];
+export const formatDateValue = (_type, value) => value;

package/lib/schema/types/primitives/FloatType.d.ts

@@ -1,7 +1,7 @@
 import { RangeBound } from "../../../shared/validation/number.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface FloatType extends BaseType {
     kind: NodeKind["FloatType"];
     minimum?: RangeBound;
@@ -24,3 +24,4 @@ export declare const isFloatType: (node: Node) => node is FloatType;
 export declare const validateFloatType: Validator<FloatType>;
 export declare const serializeFloatType: Serializer<FloatType, SerializedFloatType>;
 export declare const getReferencesForFloatType: GetReferences<FloatType>;
+export declare const formatFloatValue: StructureFormatter<FloatType>;

package/lib/schema/types/primitives/FloatType.js

@@ -15,3 +15,4 @@ export const validateFloatType = (_helpers, type, value) => {
 };
 export const serializeFloatType = type => removeParentKey(type);
 export const getReferencesForFloatType = (_type, _value) => [];
+export const formatFloatValue = (_type, value) => value;

package/lib/schema/types/primitives/IntegerType.d.ts

@@ -1,7 +1,7 @@
 import { RangeBound } from "../../../shared/validation/number.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface IntegerType extends BaseType {
     kind: NodeKind["IntegerType"];
     minimum?: RangeBound;
@@ -24,3 +24,4 @@ export declare const isIntegerType: (node: Node) => node is IntegerType;
 export declare const validateIntegerType: Validator<IntegerType>;
 export declare const serializeIntegerType: Serializer<IntegerType, SerializedIntegerType>;
 export declare const getReferencesForIntegerType: GetReferences<IntegerType>;
+export declare const formatIntegerValue: StructureFormatter<IntegerType>;

package/lib/schema/types/primitives/IntegerType.js

@@ -19,3 +19,4 @@ export const validateIntegerType = (_helpers, type, value) => {
 };
 export const serializeIntegerType = type => removeParentKey(type);
 export const getReferencesForIntegerType = (_type, _value) => [];
+export const formatIntegerValue = (_type, value) => value;

package/lib/schema/types/primitives/StringType.d.ts

@@ -1,7 +1,7 @@
 import { StringConstraints } from "../../../shared/validation/string.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType } from "../Type.js";
+import { BaseType, SerializedBaseType, StructureFormatter } from "../Type.js";
 export interface StringType extends BaseType, StringConstraints {
     kind: NodeKind["StringType"];
     pattern?: RegExp;
@@ -23,3 +23,4 @@ export declare const isStringType: (node: Node) => node is StringType;
 export declare const validateStringType: Validator<StringType>;
 export declare const serializeStringType: Serializer<StringType, SerializedStringType>;
 export declare const getReferencesForStringType: GetReferences<StringType>;
+export declare const formatStringValue: StructureFormatter<StringType>;

package/lib/schema/types/primitives/StringType.js

@@ -18,3 +18,4 @@ export const serializeStringType = type => removeParentKey({
     pattern: type.pattern?.source,
 });
 export const getReferencesForStringType = (_type, _value) => [];
+export const formatStringValue = (_type, value) => value;

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

@@ -1,7 +1,7 @@
 import { GetReferences, Node, NodeKind, Serializer } from "../../Node.js";
 import { SerializedTypeParameter, TypeParameter } from "../../parameters/TypeParameter.js";
 import { Validator } from "../../validation/type.js";
-import { BaseType, SerializedBaseType, Type } from "../Type.js";
+import { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
 type TConstraint = TypeParameter;
 export interface GenericArgumentIdentifierType<T extends TConstraint = TConstraint> extends BaseType {
     kind: NodeKind["GenericArgumentIdentifierType"];
@@ -19,3 +19,4 @@ export declare const validateGenericArgumentIdentifierType: Validator<GenericArg
 export declare const resolveTypeArgumentsInGenericArgumentIdentifierType: <T extends TConstraint, Args extends Record<string, Type>>(args: Args, type: GenericArgumentIdentifierType<T>) => Args[T["name"]];
 export declare const serializeGenericArgumentIdentifierType: Serializer<GenericArgumentIdentifierType, SerializedGenericArgumentIdentifierType>;
 export declare const getReferencesForGenericArgumentIdentifierType: GetReferences<GenericArgumentIdentifierType>;
+export declare const formatGenericArgumentIdentifierValue: StructureFormatter<GenericArgumentIdentifierType>;

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

@@ -16,3 +16,4 @@ export const serializeGenericArgumentIdentifierType = type => ({
     argument: serializeTypeParameter(type.argument),
 });
 export const getReferencesForGenericArgumentIdentifierType = (_type, _value) => [];
+export const formatGenericArgumentIdentifierValue = (_type, value) => value;

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

@@ -4,8 +4,9 @@ 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 { BaseType, SerializedBaseType, Type } from "../Type.js";
-type TConstraint<Params extends TypeParameter[]> = TypeAliasDecl<string, Type, Params> | EnumDecl<string, Record<string, Type | null>, Params>;
+import { EnumCaseDecl } from "../generic/EnumType.js";
+import { 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"];
     reference: T;
@@ -23,6 +24,7 @@ export { IncludeIdentifierType as IncludeIdentifier };
 export declare const isIncludeIdentifierType: (node: Node) => node is IncludeIdentifierType;
 export declare const getNestedDeclarationsInIncludeIdentifierType: GetNestedDeclarations<IncludeIdentifierType>;
 export declare const validateIncludeIdentifierType: Validator<IncludeIdentifierType>;
-export declare const resolveTypeArgumentsInIncludeIdentifierType: (args: Record<string, Type>, type: IncludeIdentifierType) => IncludeIdentifierType;
+export declare const resolveTypeArgumentsInIncludeIdentifierType: (args: Record<string, Type>, type: IncludeIdentifierType) => Type;
 export declare const serializeIncludeIdentifierType: Serializer<IncludeIdentifierType, SerializedIncludeIdentifierType>;
 export declare const getReferencesForIncludeIdentifierType: GetReferences<IncludeIdentifierType>;
+export declare const formatIncludeIdentifierValue: StructureFormatter<IncludeIdentifierType>;

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,
@@ -14,12 +15,26 @@ export const IncludeIdentifierType = (reference) => ({
 });
 export { IncludeIdentifierType as IncludeIdentifier };
 export const isIncludeIdentifierType = (node) => node.kind === NodeKind.IncludeIdentifierType;
-export const getNestedDeclarationsInIncludeIdentifierType = (isDeclAdded, type) => [type.reference, ...getNestedDeclarations(isDeclAdded, type.reference)];
+export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) => addedDecls.includes(type.reference)
+    ? 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,22 +1,15 @@
+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 { isEntityDecl } from "../../declarations/EntityDecl.js";
 import { NodeKind } from "../../Node.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "../generic/ObjectType.js";
-import { getParentDecl, removeParentKey, } from "../Type.js";
+import { removeParentKey, } from "../Type.js";
 export const NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,
         kind: NodeKind.NestedEntityMapType,
         type: Lazy.of(() => {
-            const parentDecl = getParentDecl(nestedEntityMapType);
-            if (!parentDecl) {
-                throw new Error("Parent declaration not found");
-            }
-            if (!isEntityDecl(parentDecl)) {
-                throw new Error(`Parent declaration "${parentDecl.name}" is not an entity declaration`);
-            }
             const type = options.type;
             type.parent = nestedEntityMapType;
             return type;
@@ -38,10 +31,7 @@ const _NestedEntityMapType = (options) => {
     return nestedEntityMapType;
 };
 export const isNestedEntityMapType = (node) => node.kind === NodeKind.NestedEntityMapType;
-export const getNestedDeclarationsInNestedEntityMapType = (isDeclAdded, type) => [
-    type.secondaryEntity,
-    ...getNestedDeclarationsInObjectType(isDeclAdded, type.type.value),
-];
+export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type) => getNestedDeclarationsInObjectType(addedDecls.includes(type.secondaryEntity) ? addedDecls : [type.secondaryEntity, ...addedDecls], type.type.value);
 export const validateNestedEntityMapType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${JSON.stringify(value)}`)];
@@ -65,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,22 +2,21 @@ 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 } from "../generic/ObjectType.js";
-import { BaseType, SerializedBaseType, Type } from "../Type.js";
-type TConstraint = Record<string, MemberDecl<Type, boolean>>;
-export interface ReferenceIdentifierType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
+import { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.js";
+export interface ReferenceIdentifierType extends BaseType {
     kind: NodeKind["ReferenceIdentifierType"];
-    entity: EntityDecl<Name, ObjectType<T>>;
+    entity: EntityDecl;
 }
 export interface SerializedReferenceIdentifierType extends SerializedBaseType {
     kind: NodeKind["ReferenceIdentifierType"];
     entity: string;
 }
-export declare const ReferenceIdentifierType: <Name extends string, T extends TConstraint>(entity: EntityDecl<Name, ObjectType<T>>) => ReferenceIdentifierType<Name, T>;
+export declare const ReferenceIdentifierType: (entity: EntityDecl) => ReferenceIdentifierType;
 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: <Name extends string, T extends TConstraint, Args extends Record<string, Type>>(_args: Args, type: ReferenceIdentifierType<Name, T>) => ReferenceIdentifierType<Name, T>;
+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,14 +1,16 @@
 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,
 });
 export { ReferenceIdentifierType as ReferenceIdentifier };
 export const isReferenceIdentifierType = (node) => node.kind === NodeKind.ReferenceIdentifierType;
-export const getNestedDeclarationsInReferenceIdentifierType = (isDeclAdded, type) => [type.entity, ...getNestedDeclarations(isDeclAdded, type.entity)];
+export const getNestedDeclarationsInReferenceIdentifierType = (addedDecls, type) => addedDecls.includes(type.entity)
+    ? addedDecls
+    : getNestedDeclarations([...addedDecls, type.entity], type.entity);
 export const validateReferenceIdentifierType = (helpers, type, value) => validate(helpers, createEntityIdentifierType(), value).concat(helpers.checkReferentialIntegrity({
     name: type.entity.name,
     value: value,
@@ -19,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]>>;