tsondb 0.7.7 → 0.7.8

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`);
     }
 });

package/dist/src/node/server/index.js

@@ -21,6 +21,8 @@ export const createServer = async (schema, dataRootPath, instancesByEntityName,
     const app = express();
     app.use(express.static(join(import.meta.dirname, "../../../../public")));
     app.use("/js/node_modules/preact", staticNodeModule("preact"));
+    app.use("/js/node_modules/@preact/signals", staticNodeModule("@preact/signals"));
+    app.use("/js/node_modules/@preact/signals-core", staticNodeModule("@preact/signals-core"));
     app.use("/js/node_modules/preact-iso", staticNodeModule("preact-iso"));
     app.use("/js/client", express.static(join(import.meta.dirname, "../../../../dist/src/web")));
     app.use("/js/shared", express.static(join(import.meta.dirname, "../../../../dist/src/shared")));
@@ -42,6 +44,8 @@ export const createServer = async (schema, dataRootPath, instancesByEntityName,
             "preact/hooks": "/js/node_modules/preact/hooks/dist/hooks.module.js",
             "preact/jsx-runtime": "/js/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js",
             "preact-iso": "/js/node_modules/preact-iso/src/index.js",
+            "@preact/signals": "/js/node_modules/@preact/signals/dist/signals.module.js",
+            "@preact/signals-core": "/js/node_modules/@preact/signals-core/dist/signals-core.module.js",
         },
     }, null, 2);
     const customStylesheetLinkHeader = customStylesheetPath

package/dist/src/node/utils/instanceOperations.d.ts

@@ -2,7 +2,7 @@ import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
 import { type Result } from "../../shared/utils/result.ts";
 import type { EntityDecl } from "../schema/declarations/EntityDecl.js";
 import { type ReferencesToInstances } from "./references.ts";
-export declare const createNewId: () => string;
+export declare const createNewId: () => `${string}-${string}-${string}-${string}-${string}`;
 export declare const checkCreateInstancePossible: (localeEntity: EntityDecl | undefined, instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown, customId: unknown) => Result<string, [code: number, message: string]>;
 export declare const createInstance: (dataRoot: string, localeEntity: EntityDecl | undefined, instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown, customId: unknown) => Promise<Result<string, [code: number, message: string]>>;
 export declare const checkUpdateInstancePossible: (instancesByEntityName: InstancesByEntityName, entity: EntityDecl, instanceContent: unknown) => Result<void, [code: number, message: string]>;

package/dist/src/node/utils/instanceOperations.js

@@ -1,10 +1,10 @@
-import { v4 as uuidv4 } from "uuid";
+import { randomUUID } from "node:crypto";
 import { error, isOk, map, ok } from "../../shared/utils/result.js";
 import { createValidators, validateEntityDecl } from "../schema/index.js";
 import { getErrorMessageForDisplay } from "./error.js";
 import * as Files from "./files.js";
 import { isReferencedByOtherInstances } from "./references.js";
-export const createNewId = () => uuidv4();
+export const createNewId = () => randomUUID();
 export const checkCreateInstancePossible = (localeEntity, instancesByEntityName, entity, instanceContent, customId) => {
     const newInstanceId = entity === localeEntity ? customId : createNewId();
     if (typeof newInstanceId !== "string") {

package/dist/src/shared/api.d.ts

@@ -53,16 +53,32 @@ export interface GetAllInstancesResponseBody {
         }[];
     };
 }
+export interface IsRepoResponseBody {
+    isRepo: boolean;
+}
 export interface GitStatusResponseBody {
+    currentBranch: string | null;
+    trackingBranch: string | null;
     commitsAhead: number;
     commitsBehind: number;
     instances: {
         [entity: string]: InstanceContainerOverview[];
     };
 }
+export interface GetAllGitBranchesResponseBodyBranchSummary {
+    current: boolean;
+    name: string;
+    commit: string;
+    label: string;
+    linkedWorkTree: boolean;
+}
 export interface GetAllGitBranchesResponseBody {
-    allBranches: string[];
+    isDetached: boolean;
     currentBranch: string;
+    allBranches: string[];
+    branches: {
+        [key: string]: GetAllGitBranchesResponseBodyBranchSummary;
+    };
 }
 export interface CreateCommitRequestBody {
     message: string;

package/dist/src/shared/utils/git.d.ts

@@ -10,3 +10,7 @@ export type GitFileStatusForDisplay = "U" | "M" | "A" | "D" | "R" | undefined;
 export declare const hasFileChanges: (fileStatus: GitFileStatus | undefined) => boolean;
 export declare const getGitStatusForDisplay: (fileStatus: GitFileStatus | undefined) => GitFileStatusForDisplay;
 export declare const getLabelForGitStatus: (status: GitFileStatusForDisplay) => string;
+export declare const splitBranchName: (branch: string) => {
+    remote?: string;
+    name: string;
+};

package/dist/src/shared/utils/git.js

@@ -87,7 +87,7 @@ export const getLabelForGitStatus = (status) => {
         case "M":
             return "modified";
         case "A":
-            return "sdded";
+            return "added";
         case "D":
             return "deleted";
         case "R":
@@ -96,3 +96,8 @@ export const getLabelForGitStatus = (status) => {
             return "";
     }
 };
+const remotePattern = /^remotes\/(\w+?)\/(.+)$/;
+export const splitBranchName = (branch) => {
+    const [_, remote, actualBranch] = branch.match(remotePattern) ?? ["", undefined, branch];
+    return { remote, name: actualBranch };
+};

package/dist/src/shared/utils/markdown.d.ts

@@ -2,50 +2,69 @@ type TextNode = {
     kind: "text";
     content: string;
 };
-export type InlineMarkdownNode = {
-    kind: "bold" | "italic";
+type BoldMarkdownNode = {
+    kind: "bold";
     content: InlineMarkdownNode[];
-} | {
+};
+type ItalicMarkdownNode = {
+    kind: "italic";
+    content: InlineMarkdownNode[];
+};
+type CodeMarkdownNode = {
     kind: "code";
     content: string;
-} | {
+};
+type LinkMarkdownNode = {
     kind: "link";
     href: string;
     content: InlineMarkdownNode[];
-} | {
+};
+type AttributedStringMarkdownNode = {
     kind: "attributed";
     attributes: Record<string, string | number | boolean>;
     content: InlineMarkdownNode[];
-} | TextNode;
-export type BlockMarkdownNode = {
+};
+export type InlineMarkdownNode = BoldMarkdownNode | ItalicMarkdownNode | CodeMarkdownNode | LinkMarkdownNode | AttributedStringMarkdownNode | TextNode;
+type ParagraphBlockNode = {
     kind: "paragraph";
     content: InlineMarkdownNode[];
-} | {
+};
+type HeadingBlockNode = {
     kind: "heading";
     level: number;
     content: InlineMarkdownNode[];
-} | {
+};
+type ListBlockNode = {
     kind: "list";
     ordered: boolean;
-    content: {
-        kind: "listitem";
-        content: InlineMarkdownNode[];
-    }[];
-} | {
+    content: ListItemNode[];
+};
+type ListItemNode = {
+    kind: "listitem";
+    content: InlineMarkdownNode[];
+};
+type TableBlockNode = {
     kind: "table";
+    caption?: InlineMarkdownNode[];
     header: InlineMarkdownNode[][];
     rows: InlineMarkdownNode[][][];
 };
-export type BlockSyntaxMarkdownNode = InlineMarkdownNode | {
+export type BlockMarkdownNode = ParagraphBlockNode | HeadingBlockNode | ListBlockNode | TableBlockNode;
+type ListItemMarkerSyntaxNode = {
     kind: "listitemmarker";
     content: string;
-} | {
+};
+type TableMarkerSyntaxNode = {
     kind: "tablemarker";
     content: string;
-} | {
+};
+type HeadingMarkerSyntaxNode = {
     kind: "headingmarker";
     content: string;
 };
+type SyntaxNode = ListItemMarkerSyntaxNode | TableMarkerSyntaxNode | HeadingMarkerSyntaxNode;
+export type BlockSyntaxMarkdownNode = InlineMarkdownNode | SyntaxNode;
 export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
 export declare const parseBlockMarkdownForSyntaxHighlighting: (text: string) => BlockSyntaxMarkdownNode[];
+export declare const reduceSyntaxNodes: <T extends BlockSyntaxMarkdownNode>(nodes: T[]) => T[];
 export {};