tsondb 0.7.6 → 0.7.8

package/dist/src/node/schema/Node.d.ts

@@ -39,6 +39,13 @@ import type { Type } from "./types/Type.ts";
 export type { BaseNode } from "../../shared/schema/Node.ts";
 export { NodeKind };
 export type Node = Decl | Type | TypeParameter;
+export type NestedDecl = Decl | NestedEntity;
+export type NestedEntity = {
+    kind: "NestedEntity";
+    sourceUrl: string;
+    name: string;
+    type: NestedEntityMapType;
+};
 export declare const reduceNodes: <R>(reducer: (parentNodes: Node[], node: Node, collectedResults: R[]) => R[], nodes: readonly Node[], options?: {
     initialResults?: R[];
     followIncludes?: boolean;
@@ -55,7 +62,7 @@ export interface Validators {
 }
 export declare const createValidators: (instancesByEntityName: InstancesByEntityName, useStyling: boolean, checkReferentialIntegrity?: boolean) => Validators;
 export type Predicate<T extends Node> = (node: Node) => node is T;
-export type GetNestedDeclarations<T extends Node = Node> = (addedDecls: Decl[], node: T) => Decl[];
+export type GetNestedDeclarations<T extends Node = Node> = (addedDecls: NestedDecl[], node: T, parentDecl: Decl | undefined) => NestedDecl[];
 export declare const getNestedDeclarations: GetNestedDeclarations;
 export type Validator<T extends Node = Node> = (helpers: Validators, node: T, value: unknown) => Error[];
 export type ValidatorOfParamDecl<T extends Node = Node> = (helpers: Validators, node: T, typeArgs: Type[], value: unknown) => Error[];

package/dist/src/node/schema/Node.js

@@ -91,42 +91,58 @@ export const createValidators = (instancesByEntityName, useStyling, checkReferen
             ]
         : () => [],
 });
-export const getNestedDeclarations = (addedDecls, node) => {
+export const getNestedDeclarations = (addedDecls, node, parentDecl) => {
     switch (node.kind) {
         case NodeKind.EntityDecl:
-            return getNestedDeclarationsInEntityDecl(addedDecls, node);
+            return addedDecls.includes(node)
+                ? addedDecls
+                : getNestedDeclarationsInEntityDecl([...addedDecls, node], node, parentDecl);
         case NodeKind.EnumDecl:
-            return getNestedDeclarationsInEnumDecl(addedDecls, node);
+            return addedDecls.includes(node)
+                ? addedDecls
+                : getNestedDeclarationsInEnumDecl([...addedDecls, node], node, parentDecl);
         case NodeKind.TypeAliasDecl:
-            return getNestedDeclarationsInTypeAliasDecl(addedDecls, node);
+            return addedDecls.includes(node)
+                ? addedDecls
+                : getNestedDeclarationsInTypeAliasDecl([...addedDecls, node], node, parentDecl);
         case NodeKind.ArrayType:
-            return getNestedDeclarationsInArrayType(addedDecls, node);
+            return getNestedDeclarationsInArrayType(addedDecls, node, parentDecl);
         case NodeKind.ObjectType:
-            return getNestedDeclarationsInObjectType(addedDecls, node);
+            return getNestedDeclarationsInObjectType(addedDecls, node, parentDecl);
         case NodeKind.BooleanType:
-            return getNestedDeclarationsInBooleanType(addedDecls, node);
+            return getNestedDeclarationsInBooleanType(addedDecls, node, parentDecl);
         case NodeKind.DateType:
-            return getNestedDeclarationsInDateType(addedDecls, node);
+            return getNestedDeclarationsInDateType(addedDecls, node, parentDecl);
         case NodeKind.FloatType:
-            return getNestedDeclarationsInFloatType(addedDecls, node);
+            return getNestedDeclarationsInFloatType(addedDecls, node, parentDecl);
         case NodeKind.IntegerType:
-            return getNestedDeclarationsInIntegerType(addedDecls, node);
+            return getNestedDeclarationsInIntegerType(addedDecls, node, parentDecl);
         case NodeKind.StringType:
-            return getNestedDeclarationsInStringType(addedDecls, node);
+            return getNestedDeclarationsInStringType(addedDecls, node, parentDecl);
         case NodeKind.TypeArgumentType:
-            return getNestedDeclarationsInTypeArgumentType(addedDecls, node);
+            return getNestedDeclarationsInTypeArgumentType(addedDecls, node, parentDecl);
         case NodeKind.ReferenceIdentifierType:
-            return getNestedDeclarationsInReferenceIdentifierType(addedDecls, node);
+            return getNestedDeclarationsInReferenceIdentifierType(addedDecls, node, parentDecl);
         case NodeKind.IncludeIdentifierType:
-            return getNestedDeclarationsInIncludeIdentifierType(addedDecls, node);
+            return getNestedDeclarationsInIncludeIdentifierType(addedDecls, node, parentDecl);
         case NodeKind.NestedEntityMapType:
-            return getNestedDeclarationsInNestedEntityMapType(addedDecls, node);
+            return addedDecls.some(addedDecl => addedDecl.kind === "NestedEntity" && addedDecl.type === node)
+                ? addedDecls
+                : getNestedDeclarationsInNestedEntityMapType([
+                    ...addedDecls,
+                    {
+                        kind: "NestedEntity",
+                        sourceUrl: parentDecl?.sourceUrl ?? "",
+                        name: node.name,
+                        type: node,
+                    },
+                ], node, parentDecl);
         case NodeKind.EnumType:
-            return getNestedDeclarationsInEnumType(addedDecls, node);
+            return getNestedDeclarationsInEnumType(addedDecls, node, parentDecl);
         case NodeKind.TypeParameter:
-            return getNestedDeclarationsInTypeParameter(addedDecls, node);
+            return getNestedDeclarationsInTypeParameter(addedDecls, node, parentDecl);
         case NodeKind.ChildEntitiesType:
-            return getNestedDeclarationsInChildEntitiesType(addedDecls, node);
+            return getNestedDeclarationsInChildEntitiesType(addedDecls, node, parentDecl);
         default:
             return assertExhaustive(node);
     }

package/dist/src/node/schema/Schema.js

@@ -152,29 +152,33 @@ const checkChildEntitiesProvideCorrectPathToParentReferenceIdentifierType = (dec
         }
     }
 };
-const addDeclarations = (existingDecls, declsToAdd, nested) => declsToAdd.reduce((accDecls, decl) => {
+const addDeclarations = (existingDecls, declsToAdd) => declsToAdd.reduce((accDecls, decl) => {
     if (!accDecls.includes(decl)) {
-        checkDuplicateIdentifier(accDecls, decl);
-        const nestedDecls = nested ? getNestedDeclarations(accDecls, decl) : [];
-        return addDeclarations([...accDecls, decl], nestedDecls, false);
+        return getNestedDeclarations(accDecls, decl.kind === "NestedEntity" ? decl.type : decl, undefined);
     }
     return accDecls;
 }, existingDecls);
 export const Schema = (declarations, localeEntity) => {
     debug("creating schema from %d declarations", declarations.length);
     debug("collecting nested declarations ...");
-    const allDecls = addDeclarations([], localeEntity ? declarations.concat(localeEntity) : declarations, true);
+    const allDecls = addDeclarations([], localeEntity ? declarations.concat(localeEntity) : declarations);
+    debug("found %d nested declarations", allDecls.length);
+    debug("checking for duplicate identifiers ...");
+    allDecls.forEach((decl, declIndex) => {
+        checkDuplicateIdentifier(allDecls.slice(0, declIndex), decl);
+    });
+    const allDeclsWithoutNestedEntities = allDecls.filter(decl => decl.kind !== "NestedEntity");
     debug("checking name shadowing ...");
-    checkParameterNamesShadowing(allDecls);
+    checkParameterNamesShadowing(allDeclsWithoutNestedEntities);
     debug("checking entity display name paths ...");
-    checkEntityDisplayNamePaths(allDecls, localeEntity);
+    checkEntityDisplayNamePaths(allDeclsWithoutNestedEntities, localeEntity);
     debug("checking child entities ...");
-    checkChildEntitiesProvideCorrectPathToParentReferenceIdentifierType(allDecls);
+    checkChildEntitiesProvideCorrectPathToParentReferenceIdentifierType(allDeclsWithoutNestedEntities);
     debug("checking child entity types ...");
-    checkChildEntityTypes(localeEntity, allDecls);
+    checkChildEntityTypes(localeEntity, allDeclsWithoutNestedEntities);
     debug("created schema, no integrity violations found");
     return {
-        declarations: allDecls,
+        declarations: allDeclsWithoutNestedEntities,
         localeEntity,
     };
 };

package/dist/src/node/schema/TypeParameter.js

@@ -4,7 +4,7 @@ export const Param = (name, constraint) => ({
     name,
     constraint,
 });
-export const getNestedDeclarationsInTypeParameter = (addedDecls, param) => (param.constraint ? getNestedDeclarations(addedDecls, param.constraint) : addedDecls);
+export const getNestedDeclarationsInTypeParameter = (addedDecls, param, parentDecl) => param.constraint ? getNestedDeclarations(addedDecls, param.constraint, parentDecl) : addedDecls;
 export const resolveTypeArgumentsInTypeParameter = (_args, param) => param;
 export const serializeTypeParameter = type => ({
     ...type,

package/dist/src/node/schema/declarations/EntityDecl.js

@@ -26,7 +26,7 @@ export const EntityDecl = (sourceUrl, options) => {
 export { EntityDecl as Entity };
 export const isEntityDecl = node => node.kind === NodeKind.EntityDecl;
 export const isEntityDeclWithParentReference = (decl) => decl.parentReferenceKey !== undefined;
-export const getNestedDeclarationsInEntityDecl = (isDeclAdded, decl) => getNestedDeclarationsInObjectType(isDeclAdded, decl.type.value);
+export const getNestedDeclarationsInEntityDecl = (isDeclAdded, decl) => getNestedDeclarationsInObjectType(isDeclAdded, decl.type.value, decl);
 export const validateEntityDecl = (helpers, decl, value) => validateType(helpers, decl.type.value, value);
 export const resolveTypeArgumentsInEntityDecl = (_args, decl) => EntityDecl(decl.sourceUrl, {
     ...decl,

package/dist/src/node/schema/declarations/EnumDecl.js

@@ -28,7 +28,7 @@ export const EnumDecl = (sourceUrl, options) => {
 };
 export { EnumDecl as Enum };
 export const isEnumDecl = node => node.kind === NodeKind.EnumDecl;
-export const getNestedDeclarationsInEnumDecl = (addedDecls, decl) => getNestedDeclarationsInEnumType(addedDecls, decl.type.value);
+export const getNestedDeclarationsInEnumDecl = (addedDecls, decl) => getNestedDeclarationsInEnumType(addedDecls, decl.type.value, decl);
 export const validateEnumDecl = (helpers, decl, args, value) => validateEnumType(helpers, resolveTypeArgumentsInEnumType(getTypeArgumentsRecord(decl, args), decl.type.value), value);
 export const resolveTypeArgumentsInEnumDecl = (args, decl) => EnumDecl(decl.sourceUrl, {
     name: decl.name,

package/dist/src/node/schema/declarations/TypeAliasDecl.js

@@ -26,7 +26,7 @@ export const TypeAliasDecl = (sourceUrl, options) => {
 };
 export { TypeAliasDecl as TypeAlias };
 export const isTypeAliasDecl = node => node.kind === NodeKind.TypeAliasDecl;
-export const getNestedDeclarationsInTypeAliasDecl = (addedDecls, decl) => getNestedDeclarations(addedDecls, decl.type.value);
+export const getNestedDeclarationsInTypeAliasDecl = (addedDecls, decl) => getNestedDeclarations(addedDecls, decl.type.value, decl);
 export const validateTypeAliasDecl = ((helpers, decl, args, value) => validateType(helpers, resolveTypeArguments(getTypeArgumentsRecord(decl, args), decl.type.value), value));
 export const resolveTypeArgumentsInTypeAliasDecl = (args, decl) => TypeAliasDecl(decl.sourceUrl, {
     ...decl,

package/dist/src/node/schema/types/generic/ArrayType.js

@@ -14,7 +14,7 @@ export const ArrayType = (items, options = {}) => ({
 });
 export { ArrayType as Array };
 export const isArrayType = node => node.kind === NodeKind.ArrayType;
-export const getNestedDeclarationsInArrayType = (addedDecls, type) => getNestedDeclarations(addedDecls, type.items);
+export const getNestedDeclarationsInArrayType = (addedDecls, type, parentDecl) => getNestedDeclarations(addedDecls, type.items, parentDecl);
 export const validateArrayType = (helpers, type, value) => {
     if (!Array.isArray(value)) {
         return [TypeError(`expected an array, but got ${json(value, helpers.useStyling)}`)];

package/dist/src/node/schema/types/generic/EnumType.js

@@ -9,7 +9,7 @@ export const EnumType = (values) => ({
     values,
 });
 export const isEnumType = node => node.kind === NodeKind.EnumType;
-export const getNestedDeclarationsInEnumType = (addedDecls, type) => Object.values(type.values).reduce((acc, caseMember) => caseMember.type === null ? acc : getNestedDeclarations(acc, caseMember.type), addedDecls);
+export const getNestedDeclarationsInEnumType = (addedDecls, type, parentDecl) => Object.values(type.values).reduce((acc, caseMember) => caseMember.type === null ? acc : getNestedDeclarations(acc, caseMember.type, parentDecl), addedDecls);
 export const validateEnumType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];

package/dist/src/node/schema/types/generic/ObjectType.js

@@ -25,7 +25,7 @@ export const ObjectType = (properties, options = {}) => {
 };
 export { ObjectType as Object };
 export const isObjectType = node => node.kind === NodeKind.ObjectType;
-export const getNestedDeclarationsInObjectType = (addedDecls, type) => Object.values(type.properties).reduce((acc, prop) => getNestedDeclarations(acc, prop.type), addedDecls);
+export const getNestedDeclarationsInObjectType = (addedDecls, type, parentDecl) => Object.values(type.properties).reduce((acc, prop) => getNestedDeclarations(acc, prop.type, parentDecl), addedDecls);
 export const validateObjectType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];

package/dist/src/node/schema/types/references/ChildEntitiesType.js

@@ -7,7 +7,7 @@ export const ChildEntitiesType = (entity) => ({
 });
 export { ChildEntitiesType as ChildEntities };
 export const isChildEntitiesType = node => node.kind === NodeKind.ChildEntitiesType;
-export const getNestedDeclarationsInChildEntitiesType = (addedDecls, type) => getNestedDeclarations([type.entity, ...addedDecls], type.entity);
+export const getNestedDeclarationsInChildEntitiesType = (addedDecls, type, parentDecl) => getNestedDeclarations(addedDecls, type.entity, parentDecl);
 export const validateChildEntitiesType = () => [];
 export const resolveTypeArgumentsInChildEntitiesType = (_args, type) => type;
 export const serializeChildEntitiesType = type => ({

package/dist/src/node/schema/types/references/IncludeIdentifierType.js

@@ -16,9 +16,9 @@ export const IncludeIdentifierType = (reference) => ({
 export { IncludeIdentifierType as IncludeIdentifier };
 export const isIncludeIdentifierType = node => node.kind === NodeKind.IncludeIdentifierType;
 const isNoGenericIncludeIdentifierType = (node) => node.args.length === 0 && node.reference.parameters.length === 0;
-export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) => type.args.reduce((accAddedDecls, arg) => getNestedDeclarations(accAddedDecls, arg), addedDecls.includes(type.reference)
+export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type, parentDecl) => type.args.reduce((accAddedDecls, arg) => getNestedDeclarations(accAddedDecls, arg, parentDecl), addedDecls.includes(type.reference)
     ? addedDecls
-    : getNestedDeclarations([type.reference, ...addedDecls], type.reference));
+    : getNestedDeclarations(addedDecls, type.reference, parentDecl));
 export const validateIncludeIdentifierType = (helpers, type, value) => validateDecl(helpers, type.reference, type.args, value);
 export const resolveTypeArgumentsInIncludeIdentifierType = ((args, type) => (isNoGenericIncludeIdentifierType(type)
     ? type

package/dist/src/node/schema/types/references/NestedEntityMapType.d.ts

@@ -1,6 +1,8 @@
 import { Lazy } from "../../../../shared/utils/lazy.ts";
-import type { EntityDecl } from "../../declarations/EntityDecl.ts";
-import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.ts";
+import type { DisplayNameCustomizer } from "../../../utils/displayName.ts";
+import type { EntityDecl } from "../../declarations/EntityDecl.js";
+import { type EntityDisplayName } from "../../declarations/EntityDecl.js";
+import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.js";
 import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validator } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
 import type { MemberDecl, ObjectType } from "../generic/ObjectType.ts";
@@ -11,15 +13,23 @@ type PossibleType<T extends TConstraint> = ObjectType<T> | IncludeIdentifier<[],
 export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;
+    namePlural: string;
     comment?: string;
     secondaryEntity: EntityDecl;
     type: Lazy<PossibleType<T>>;
 }
 export declare const NestedEntityMapType: <Name extends string, T extends TConstraint>(options: {
     name: Name;
+    namePlural: string;
     comment?: string;
     secondaryEntity: EntityDecl;
     type: PossibleType<T>;
+    /**
+     * @default "name"
+     */
+    displayName?: EntityDisplayName<T>;
+    displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
+    isDeprecated?: boolean;
 }) => NestedEntityMapType<Name, T>;
 export { NestedEntityMapType as NestedEntityMap };
 export declare const isNestedEntityMapType: Predicate<NestedEntityMapType>;

package/dist/src/node/schema/types/references/NestedEntityMapType.js

@@ -3,7 +3,7 @@ import { sortObjectKeysAlphabetically } from "../../../../shared/utils/object.js
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { entity, json, key as keyColor } from "../../../utils/errorFormatting.js";
-import {} from "../../declarations/Declaration.js";
+import {} from "../../declarations/EntityDecl.js";
 import { getNestedDeclarations, NodeKind, resolveTypeArguments, validateType } from "../../Node.js";
 import { getReferencesForObjectType, isObjectType, serializeObjectType, } from "../generic/ObjectType.js";
 import { formatValue } from "../Type.js";
@@ -26,7 +26,7 @@ const _NestedEntityMapType = (options) => {
     return nestedEntityMapType;
 };
 export const isNestedEntityMapType = node => node.kind === NodeKind.NestedEntityMapType;
-export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type) => getNestedDeclarations(addedDecls.includes(type.secondaryEntity) ? addedDecls : [type.secondaryEntity, ...addedDecls], type.type.value);
+export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type, parentDecl) => getNestedDeclarations(getNestedDeclarations(addedDecls, type.secondaryEntity, parentDecl), type.type.value, parentDecl);
 export const validateNestedEntityMapType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];

package/dist/src/node/schema/types/references/ReferenceIdentifierType.js

@@ -6,9 +6,9 @@ export const ReferenceIdentifierType = (entity) => ({
 });
 export { ReferenceIdentifierType as ReferenceIdentifier };
 export const isReferenceIdentifierType = (node) => node.kind === NodeKind.ReferenceIdentifierType;
-export const getNestedDeclarationsInReferenceIdentifierType = (addedDecls, type) => addedDecls.includes(type.entity)
+export const getNestedDeclarationsInReferenceIdentifierType = (addedDecls, type, parentDecl) => addedDecls.includes(type.entity)
     ? addedDecls
-    : getNestedDeclarations([...addedDecls, type.entity], type.entity);
+    : getNestedDeclarations(addedDecls, type.entity, parentDecl);
 export const validateReferenceIdentifierType = (helpers, type, value) => validateType(helpers, createEntityIdentifierType(), value).concat(helpers.checkReferentialIntegrity({
     name: type.entity.name,
     value: value,

package/dist/src/node/server/api/git.js

@@ -1,7 +1,7 @@
 import Debug from "debug";
 import express, {} from "express";
 import { join } from "node:path";
-import { hasFileChanges } from "../../../shared/utils/git.js";
+import { hasFileChanges, splitBranchName } from "../../../shared/utils/git.js";
 import { getInstanceContainerOverview } from "../../../shared/utils/instances.js";
 import { attachGitStatusToInstancesByEntityName } from "../../utils/instances.js";
 import { reinit } from "../init.js";
@@ -10,12 +10,18 @@ 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");
+    if (req.path !== "/" && req.gitRoot === undefined) {
+        res.status(400).send("Git repository not found");
         return;
     }
     next();
 });
+gitApi.get("/", (req, res) => {
+    const body = {
+        isRepo: req.gitRoot !== undefined,
+    };
+    res.json(body);
+});
 gitApi.get("/status", async (req, res) => {
     const status = await req.git.status();
     attachGitStatusToInstancesByEntityName(req.instancesByEntityName, req.dataRoot, 
@@ -23,6 +29,8 @@ gitApi.get("/status", async (req, res) => {
     req.gitRoot, status);
     const getChildInstancesForInstanceId = createChildInstancesForInstanceIdGetter(req);
     const body = {
+        currentBranch: status.current,
+        trackingBranch: status.tracking,
         commitsAhead: status.ahead,
         commitsBehind: status.behind,
         instances: Object.fromEntries(Object.entries(req.instancesByEntityName).map(([entityName, instances]) => [
@@ -36,62 +44,94 @@ gitApi.get("/status", async (req, res) => {
     };
     res.json(body);
 });
+gitApi.post("/fetch", async (req, res) => {
+    try {
+        await req.git.fetch(["--all", "-p"]);
+        res.set("Content-Type", "text/plain");
+        res.status(200).send("Fetched all remotes");
+    }
+    catch (error) {
+        debug(`${req.path}: ${error.message}`);
+        res.set("Content-Type", "text/plain");
+        res.status(500).send(error instanceof Error ? error.message : "Fetching all remotes failed");
+    }
+});
 gitApi.post("/stage", async (req, res) => {
     try {
         await req.git.add(req.dataRoot);
+        res.set("Content-Type", "text/plain");
         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");
+        res.set("Content-Type", "text/plain");
+        res
+            .status(500)
+            .send(error instanceof Error ? error.message : "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.set("Content-Type", "text/plain");
         res.status(200).send(`Added all database files for entity ${req.params.entityName} to index`);
     }
     catch (error) {
         debug(`${req.path}: ${error.message}`);
+        res.set("Content-Type", "text/plain");
         res
             .status(500)
-            .send(`Adding all database files for entity ${req.params.entityName} to index failed`);
+            .send(error instanceof Error
+            ? error.message
+            : `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.set("Content-Type", "text/plain");
         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.set("Content-Type", "text/plain");
         res
             .status(500)
-            .send(`Adding database file ${req.params.instanceId} for entity ${req.params.entityName} to index failed`);
+            .send(error instanceof Error
+            ? error.message
+            : `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.set("Content-Type", "text/plain");
         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");
+        res.set("Content-Type", "text/plain");
+        res
+            .status(500)
+            .send(error instanceof Error ? error.message : "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.set("Content-Type", "text/plain");
         res.status(200).send(`Removed all database files for entity ${req.params.entityName} to index`);
     }
     catch (error) {
         debug(`${req.path}: ${error.message}`);
+        res.set("Content-Type", "text/plain");
         res
             .status(500)
-            .send(`Removing all database files for entity ${req.params.entityName} to index failed`);
+            .send(error instanceof Error
+            ? error.message
+            : `Removing all database files for entity ${req.params.entityName} to index failed`);
     }
 });
 gitApi.post("/unstage/:entityName/:instanceId", async (req, res) => {
@@ -101,78 +141,170 @@ gitApi.post("/unstage/:entityName/:instanceId", async (req, res) => {
             "--",
             join(req.dataRoot, req.params.entityName, `${req.params.instanceId}.json`),
         ]);
+        res.set("Content-Type", "text/plain");
         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.set("Content-Type", "text/plain");
         res
             .status(500)
-            .send(`Removing database file ${req.params.instanceId} for entity ${req.params.entityName} to index failed`);
+            .send(error instanceof Error
+            ? error.message
+            : `Removing database file ${req.params.instanceId} for entity ${req.params.entityName} to index failed`);
+    }
+});
+gitApi.post("/reset", async (req, res) => {
+    try {
+        await req.git.raw(["restore", "--", req.dataRoot]);
+        res.set("Content-Type", "text/plain");
+        res.status(200).send("Removed all database files to index");
+    }
+    catch (error) {
+        debug(`${req.path}: ${error.message}`);
+        res.set("Content-Type", "text/plain");
+        res
+            .status(500)
+            .send(error instanceof Error ? error.message : "Removing all database files to index failed");
+    }
+});
+gitApi.post("/reset/:entityName/:instanceId", async (req, res) => {
+    try {
+        await req.git.raw([
+            "restore",
+            "--",
+            join(req.dataRoot, req.params.entityName, `${req.params.instanceId}.json`),
+        ]);
+        await reinit(req);
+        res.set("Content-Type", "text/plain");
+        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.set("Content-Type", "text/plain");
+        res
+            .status(500)
+            .send(error instanceof Error
+            ? error.message
+            : `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.set("Content-Type", "text/plain");
         res.status(400).send("Invalid commit message");
         return;
     }
     try {
         await req.git.commit(message);
+        res.set("Content-Type", "text/plain");
         res.status(200).send("Commit successful");
     }
-    catch {
-        res.status(500).send("Commit failed");
+    catch (error) {
+        res.set("Content-Type", "text/plain");
+        res.status(500).send(error instanceof Error ? error.message : "Commit failed");
     }
 });
 gitApi.post("/push", async (req, res) => {
     try {
-        await req.git.push();
+        const status = await req.git.status();
+        const remotes = await req.git.getRemotes();
+        await req.git.push(remotes[0]?.name, status.current ?? undefined);
+        res.set("Content-Type", "text/plain");
         res.status(200).send("Push successful");
     }
-    catch {
-        res.status(500).send("Push failed");
+    catch (error) {
+        res.set("Content-Type", "text/plain");
+        res.status(500).send(error instanceof Error ? error.message : "Push failed");
     }
 });
 gitApi.post("/pull", async (req, res) => {
     try {
-        await req.git.pull();
+        const status = await req.git.status();
+        const remotes = await req.git.getRemotes();
+        await req.git.pull(remotes[0]?.name, status.current ?? undefined);
+        res.set("Content-Type", "text/plain");
         res.status(200).send("Pull successful");
     }
-    catch {
-        res.status(500).send("Pull failed");
+    catch (error) {
+        res.set("Content-Type", "text/plain");
+        res.status(500).send(error instanceof Error ? error.message : "Pull failed");
     }
 });
 gitApi.get("/branch", async (req, res) => {
-    const branchSummary = await req.git.branchLocal();
+    const branchSummary = await req.git.branch();
     const body = {
         allBranches: branchSummary.all,
         currentBranch: branchSummary.current,
+        isDetached: branchSummary.detached,
+        branches: branchSummary.branches,
     };
     res.json(body);
 });
 gitApi.post("/branch", async (req, res) => {
     const branchName = req.body.branchName;
     if (typeof branchName !== "string" || branchName.length === 0) {
+        res.set("Content-Type", "text/plain");
         res.status(400).send("Invalid branch name");
         return;
     }
     try {
         await req.git.checkoutLocalBranch(branchName);
         await reinit(req);
+        res.set("Content-Type", "text/plain");
         res.status(200).send(`Creation of branch "${branchName}" successful`);
     }
-    catch {
-        res.status(500).send(`Creation of branch "${branchName}" failed`);
+    catch (error) {
+        res.set("Content-Type", "text/plain");
+        res
+            .status(500)
+            .send(error instanceof Error ? error.message : `Creation of branch "${branchName}" failed`);
     }
 });
 gitApi.post("/branch/:branchName", async (req, res) => {
+    const branchName = decodeURIComponent(req.params.branchName);
     try {
-        await req.git.checkout(req.params.branchName);
-        res.status(200).send(`Switch to branch "${req.params.branchName}" successful`);
+        const { remote, name: actualBranch } = splitBranchName(branchName);
+        if (remote) {
+            debug(`Switch to remote branch "${remote}/${actualBranch}"`);
+        }
+        else {
+            debug(`Switch to local branch "${actualBranch}"`);
+        }
+        await req.git.raw("switch", actualBranch);
+        await reinit(req);
+        res.set("Content-Type", "text/plain");
+        res.status(200).send(`Switch to branch "${branchName}" successful`);
+    }
+    catch (error) {
+        res.set("Content-Type", "text/plain");
+        res
+            .status(500)
+            .send(error instanceof Error ? error.message : `Switch to branch "${branchName}" failed`);
     }
-    catch {
-        res.status(500).send(`Switch to branch "${req.params.branchName}" failed`);
+});
+gitApi.delete("/branch/:branchName", async (req, res) => {
+    const branchName = decodeURIComponent(req.params.branchName);
+    try {
+        const branchSummary = await req.git.branchLocal();
+        if (branchSummary.current === branchName) {
+            res.set("Content-Type", "text/plain");
+            res.status(400).send("Cannot delete the branch currently checked out");
+            return;
+        }
+        await req.git.deleteLocalBranch(branchName, true);
+        res.set("Content-Type", "text/plain");
+        res.status(200).send(`Deletion of branch "${branchName}" successful`);
+    }
+    catch (error) {
+        res.set("Content-Type", "text/plain");
+        res
+            .status(500)
+            .send(error instanceof Error ? error.message : `Deletion of branch "${branchName}" failed`);
     }
 });