tsondb 0.7.7 → 0.7.8

package/dist/src/web/hooks/useGitClient.js

@@ -0,0 +1,313 @@
+import { useCallback, useContext, useEffect, useMemo, useState } from "preact/hooks";
+import { isSerializedEntityDecl, isSerializedEntityDeclWithParentReference, } from "../../shared/schema/declarations/EntityDecl.js";
+import { isChangedInIndex, isChangedInWorkingDir, splitBranchName, } from "../../shared/utils/git.js";
+import { deleteInstanceByEntityNameAndId } from "../api/declarations.js";
+import * as GitApi from "../api/git.js";
+import { EntitiesContext } from "../context/entities.js";
+import { runWithLoading } from "../signals/loading.js";
+import { logAndAlertError } from "../utils/debug.js";
+import { useSetting } from "./useSettings.js";
+const filterFilesForDisplay = (predicate, entities, data) => Object.entries(data.instances)
+    .map(([entityName, instances]) => [
+    entityName,
+    entities.find(entity => entity.declaration.name === entityName)?.declaration.namePlural ??
+        entityName,
+    instances
+        .filter(instance => instance.gitStatus !== undefined && predicate(instance.gitStatus))
+        .sort((a, b) => a.displayName.localeCompare(b.displayName, undefined, { numeric: true })),
+])
+    .filter(([_1, _2, instances]) => instances.length > 0)
+    .sort((a, b) => a[1].localeCompare(b[1]));
+export const useGitClient = () => {
+    const [locales] = useSetting("displayedLocales");
+    const { entities } = useContext(EntitiesContext);
+    const [isRepo, setIsRepo] = useState(false);
+    const [commitsAhead, setCommitsAhead] = useState(0);
+    const [commitsBehind, setCommitsBehind] = useState(0);
+    const [indexFiles, setIndexFiles] = useState([]);
+    const [workingTreeFiles, setWorkingTreeFiles] = useState([]);
+    const [allBranches, setAllBranches] = useState([]);
+    const [currentBranch, setCurrentBranch] = useState("");
+    const [branches, setBranches] = useState({});
+    const [isDetached, setIsDetached] = useState(false);
+    const updateGitStatus = useCallback(async () => {
+        const { isRepo } = await GitApi.isRepo(locales);
+        setIsRepo(isRepo);
+        if (isRepo && entities.length > 0) {
+            try {
+                const [statusData, branchesData] = await Promise.all([
+                    GitApi.getStatus(locales),
+                    GitApi.getBranches(locales),
+                ]);
+                setIndexFiles(filterFilesForDisplay(isChangedInIndex, entities, statusData));
+                setWorkingTreeFiles(filterFilesForDisplay(isChangedInWorkingDir, entities, statusData));
+                setCommitsAhead(statusData.commitsAhead);
+                setCommitsBehind(statusData.commitsBehind);
+                setAllBranches(branchesData.allBranches);
+                setCurrentBranch(branchesData.currentBranch);
+                setBranches(Object.fromEntries(Object.entries(branchesData.branches).map(([branch, branchSummary]) => {
+                    const { remote, name } = splitBranchName(branch);
+                    return [
+                        branch,
+                        {
+                            ...branchSummary,
+                            remote,
+                            name,
+                        },
+                    ];
+                })));
+                setIsDetached(branchesData.isDetached);
+            }
+            catch (error) {
+                logAndAlertError(error, "Error updating git status: ");
+            }
+        }
+    }, [entities, locales]);
+    useEffect(() => {
+        void updateGitStatus();
+    }, [updateGitStatus]);
+    const getGitStatusOfInstance = useCallback((entityName, instanceId) => {
+        const entity = indexFiles.find(([name]) => name === entityName);
+        const instanceInIndex = entity?.[2].find(instance => instance.id === instanceId);
+        if (instanceInIndex?.gitStatus !== undefined) {
+            return instanceInIndex.gitStatus;
+        }
+        const workingTreeEntity = workingTreeFiles.find(([name]) => name === entityName);
+        const instanceInWorkingTree = workingTreeEntity?.[2].find(instance => instance.id === instanceId);
+        return instanceInWorkingTree?.gitStatus;
+    }, [indexFiles, workingTreeFiles]);
+    const fetch = useCallback(async () => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.fetch(locales);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error fetching from remote: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const stage = useCallback(async (entityName, instance) => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.stageFileOfEntity(locales, entityName, instance.id);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error staging instance: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const stageAll = useCallback(async (entityName) => {
+        await runWithLoading(async () => {
+            try {
+                if (entityName) {
+                    await GitApi.stageAllFilesOfEntity(locales, entityName);
+                }
+                else {
+                    await GitApi.stageAllFiles(locales);
+                }
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error staging all instances: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const unstage = useCallback(async (entityName, instance) => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.unstageFileOfEntity(locales, entityName, instance.id);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error unstaging instance: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const unstageAll = useCallback(async (entityName) => {
+        await runWithLoading(async () => {
+            try {
+                if (entityName) {
+                    await GitApi.unstageAllFilesOfEntity(locales, entityName);
+                }
+                else {
+                    await GitApi.unstageAllFiles(locales);
+                }
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error unstaging all instances: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const reset = useCallback(async (entityName, instance) => {
+        await runWithLoading(async () => {
+            if (!confirm(`Are you sure you want to reset instance "${instance.displayName}" (${instance.id})?`)) {
+                return;
+            }
+            const entity = entities.find(e => e.declaration.name === entityName)?.declaration;
+            if (instance.gitStatus?.workingDir === "D" &&
+                entity &&
+                isSerializedEntityDecl(entity) &&
+                isSerializedEntityDeclWithParentReference(entity) &&
+                !confirm(`If you deleted the parent of "${instance.displayName}" (${instance.id}) before, make sure to restore it as well. Continue?`)) {
+                return;
+            }
+            try {
+                if (instance.gitStatus?.workingDir === "?") {
+                    await deleteInstanceByEntityNameAndId(locales, entityName, instance.id);
+                }
+                else {
+                    await GitApi.resetFileOfEntity(locales, entityName, instance.id);
+                }
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error resetting instance: ");
+            }
+        });
+    }, [entities, locales, updateGitStatus]);
+    const commit = useCallback(async (commitMessage) => {
+        await runWithLoading(async () => {
+            if (commitMessage.length > 0 &&
+                indexFiles.length > 0 &&
+                confirm("Do you want to commit all staged files?")) {
+                try {
+                    await GitApi.commitStagedFiles(locales, commitMessage);
+                    await updateGitStatus();
+                }
+                catch (error) {
+                    logAndAlertError(error, "Error committing instances: ");
+                }
+            }
+        });
+    }, [indexFiles.length, locales, updateGitStatus]);
+    const push = useCallback(async () => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.pushCommits(locales);
+                alert("Pushed commits successfully");
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error pushing commits: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const pull = useCallback(async () => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.pullCommits(locales);
+                alert("Pulled commits successfully");
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error pulling commits: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const createBranch = useCallback(async (newBranchName) => {
+        await runWithLoading(async () => {
+            if (newBranchName.length === 0) {
+                alert("Branch name cannot be empty");
+                return;
+            }
+            if (allBranches.includes(newBranchName)) {
+                alert("Branch name already exists");
+                return;
+            }
+            try {
+                await GitApi.createBranch(locales, newBranchName);
+                alert(`Created branch "${newBranchName}" successfully`);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error creating branch: ");
+            }
+        });
+    }, [allBranches, locales, updateGitStatus]);
+    const switchBranch = useCallback(async (targetBranch) => {
+        await runWithLoading(async () => {
+            try {
+                await GitApi.switchBranch(locales, targetBranch);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error switching branch: ");
+            }
+        });
+    }, [locales, updateGitStatus]);
+    const deleteBranch = useCallback(async (targetBranch) => {
+        await runWithLoading(async () => {
+            if (targetBranch === currentBranch) {
+                alert("Cannot delete the current branch");
+                return;
+            }
+            if (!allBranches.includes(targetBranch)) {
+                alert(`Branch "${targetBranch}" does not exist`);
+                return;
+            }
+            if (!confirm(`Are you sure you want to delete branch "${targetBranch}"?`)) {
+                return;
+            }
+            try {
+                await GitApi.deleteBranch(locales, targetBranch);
+                alert(`Deleted branch "${targetBranch}" successfully`);
+                await updateGitStatus();
+            }
+            catch (error) {
+                logAndAlertError(error, "Error deleting branch: ");
+            }
+        });
+    }, [allBranches, currentBranch, locales, updateGitStatus]);
+    return useMemo(() => ({
+        isRepo,
+        commitsAhead,
+        commitsBehind,
+        indexFiles,
+        workingTreeFiles,
+        allBranches,
+        currentBranch,
+        branches,
+        isDetached,
+        getGitStatusOfInstance,
+        updateLocalState: updateGitStatus,
+        fetch,
+        stage,
+        stageAll,
+        unstage,
+        unstageAll,
+        reset,
+        commit,
+        push,
+        pull,
+        createBranch,
+        switchBranch,
+        deleteBranch,
+    }), [
+        allBranches,
+        branches,
+        commit,
+        commitsAhead,
+        commitsBehind,
+        createBranch,
+        currentBranch,
+        deleteBranch,
+        fetch,
+        getGitStatusOfInstance,
+        indexFiles,
+        isDetached,
+        isRepo,
+        pull,
+        push,
+        reset,
+        stage,
+        stageAll,
+        switchBranch,
+        unstage,
+        unstageAll,
+        updateGitStatus,
+        workingTreeFiles,
+    ]);
+};

package/dist/src/web/index.js

@@ -4,11 +4,15 @@ import { LocationProvider, Route, Router, useLocation } from "preact-iso";
 import { useEffect, useState } from "preact/hooks";
 import { getAllEntities } from "./api/declarations.js";
 import { getWebConfig } from "./api/index.js";
-import { Git } from "./components/Git.js";
+import { ContextProviderWrapper } from "./components/ContextProviderWrapper.js";
+import { Git } from "./components/git/Git.js";
+import { LoadingOverlay } from "./components/LoadingOverlay.js";
 import { ConfigContext } from "./context/config.js";
 import { EntitiesContext } from "./context/entities.js";
 import { GitContext } from "./context/git.js";
+import { GitClientContext } from "./context/gitClient.js";
 import { SettingsContext } from "./context/settings.js";
+import { useGitClient } from "./hooks/useGitClient.js";
 import { useMappedAPIResource } from "./hooks/useMappedAPIResource.js";
 import { useSettings } from "./hooks/useSettings.js";
 import { CreateInstance } from "./routes/CreateInstance.js";
@@ -29,7 +33,7 @@ const App = ({ config }) => {
             alert("Error reloading entities: " + String(error));
         });
     }, [location.path, reloadEntities]);
-    return (_jsx(ConfigContext.Provider, { value: config, children: _jsx(SettingsContext.Provider, { value: settingsContext, children: _jsx(GitContext.Provider, { value: [isGitOpen, setIsGitOpen], children: _jsx(LocationProvider, { children: _jsxs(EntitiesContext.Provider, { value: { entities: entities ?? [], reloadEntities }, children: [_jsxs(Router, { children: [_jsx(Route, { path: "/", component: Home }), _jsx(Route, { path: "/entities/:name", component: Entity }), _jsx(Route, { path: "/entities/:name/instances/create", component: CreateInstance }), _jsx(Route, { path: "/entities/:name/instances/:id", component: Instance }), _jsx(Route, { default: true, component: NotFound })] }), _jsx(Git, {})] }) }) }) }) }));
+    return (_jsx(ConfigContext.Provider, { value: config, children: _jsx(SettingsContext.Provider, { value: settingsContext, children: _jsx(GitContext.Provider, { value: [isGitOpen, setIsGitOpen], children: _jsx(LocationProvider, { children: _jsx(EntitiesContext.Provider, { value: { entities: entities ?? [], reloadEntities }, children: _jsxs(ContextProviderWrapper, { context: GitClientContext, useValue: useGitClient, children: [_jsx(LoadingOverlay, {}), _jsxs(Router, { children: [_jsx(Route, { path: "/", component: Home }), _jsx(Route, { path: "/entities/:name", component: Entity }), _jsx(Route, { path: "/entities/:name/instances/create", component: CreateInstance }), _jsx(Route, { path: "/entities/:name/instances/:id", component: Instance }), _jsx(Route, { default: true, component: NotFound })] }), _jsx(Git, {})] }) }) }) }) }) }));
 };
 const config = await getWebConfig();
 const root = document.getElementById("app");

package/dist/src/web/routes/CreateInstance.js

@@ -11,7 +11,7 @@ const titleBuilder = ({ entity }) => {
     const entityName = entity.name;
     return "New " + toTitleCase(entityName) + " — TSONDB";
 };
-const onSubmit = async ({ locales, entity, buttonName, instanceContent, isLocaleEntity, customId, childInstances, setInstanceContent, setCustomId, route, getDeclFromDeclName, }) => {
+const onSubmit = async ({ locales, entity, buttonName, instanceContent, isLocaleEntity, customId, childInstances, setInstanceContent, setCustomId, route, getDeclFromDeclName, updateLocalGitState, }) => {
     try {
         if (buttonName) {
             const createdInstance = await createInstanceByEntityNameAndId(locales, entity.name, {
@@ -20,6 +20,7 @@ const onSubmit = async ({ locales, entity, buttonName, instanceContent, isLocale
                 content: instanceContent,
                 id: undefined,
             }, isLocaleEntity ? customId : undefined);
+            await updateLocalGitState?.();
             switch (buttonName) {
                 case "saveandcontinue": {
                     route(`/entities/${entity.name}/instances/${createdInstance.instance.id}`);

package/dist/src/web/routes/Entity.js

@@ -1,12 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useRoute } from "preact-iso";
 import { useContext, useEffect, useState } from "preact/hooks";
-import { getGitStatusForDisplay, getLabelForGitStatus } from "../../shared/utils/git.js";
+import { getGitStatusForDisplay } from "../../shared/utils/git.js";
 import { toTitleCase } from "../../shared/utils/string.js";
 import { deleteInstanceByEntityNameAndId, getInstancesByEntityName, getLocaleInstances, } from "../api/declarations.js";
+import { GitStatusIndicator } from "../components/git/GitStatusIndicator.js";
 import { Layout } from "../components/Layout.js";
 import { ConfigContext } from "../context/config.js";
 import { EntitiesContext } from "../context/entities.js";
+import { GitClientContext } from "../context/gitClient.js";
 import { useEntityFromRoute } from "../hooks/useEntityFromRoute.js";
 import { useMappedAPIResource } from "../hooks/useMappedAPIResource.js";
 import { useSetting } from "../hooks/useSettings.js";
@@ -21,6 +23,7 @@ export const Entity = () => {
     const [searchText, setSearchText] = useState("");
     const entityFromRoute = useEntityFromRoute();
     const config = useContext(ConfigContext);
+    const gitClient = useContext(GitClientContext);
     const { reloadEntities } = useContext(EntitiesContext);
     const { declaration: entity, isLocaleEntity } = entityFromRoute ?? {};
     const [instances, reloadInstances] = useMappedAPIResource(getInstancesByEntityName, mapInstances, locales, name ?? "");
@@ -43,10 +46,13 @@ export const Entity = () => {
         return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: homeTitle }], children: [_jsxs("div", { class: "header-with-btns", children: [_jsx("h1", { children: toTitleCase(entity?.namePlural ?? name) }), _jsx("a", { class: "btn btn--primary", "aria-disabled": true, children: "Add" })] }), _jsx("p", { class: "loading", children: "Loading \u2026" })] }));
     }
     const lowerSearchText = searchText.toLowerCase();
-    const filteredInstances = searchText.length === 0
+    const filteredInstances = (searchText.length === 0
         ? instances
         : instances.filter(instance => instance.id.includes(searchText) ||
-            instance.displayName.toLowerCase().includes(lowerSearchText));
+            instance.displayName.toLowerCase().includes(lowerSearchText))).map(instance => ({
+        ...instance,
+        gitStatus: gitClient?.getGitStatusOfInstance(entity.name, instance.id),
+    }));
     const instancesByLocale = Object.groupBy(filteredInstances, instance => instance.displayNameLocaleId ?? "undefined");
     const groupedInstances = [...locales, "undefined"]
         .map(key => ({
@@ -59,7 +65,7 @@ export const Entity = () => {
         .filter(group => group.instances.length > 0);
     const instanceMapper = (instance) => {
         const gitStatusForDisplay = getGitStatusForDisplay(instance.gitStatus);
-        return (_jsxs("li", { id: `instance-${instance.id}`, class: `entries-item ${created === instance.id ? "entries-item--created" : ""} ${gitStatusForDisplay === undefined ? "" : `git-status--${gitStatusForDisplay}`}`, children: [_jsx("h2", { class: "entries-item__title", children: instance.displayName }), _jsx("p", { "aria-hidden": true, class: "entries-item__subtitle entries-item__subtitle--id", children: instance.id }), _jsxs("div", { class: "entries-item__side", children: [gitStatusForDisplay !== undefined && (_jsx("p", { class: `git-status git-status--${gitStatusForDisplay}`, title: getLabelForGitStatus(gitStatusForDisplay), children: gitStatusForDisplay })), _jsxs("div", { class: "btns", children: [_jsx("a", { href: `/entities/${entity.name}/instances/${instance.id}`, class: "btn", children: "Edit" }), _jsx("button", { class: "destructive", onClick: () => {
+        return (_jsxs("li", { id: `instance-${instance.id}`, class: `entries-item ${created === instance.id ? "entries-item--created" : ""} ${gitStatusForDisplay === undefined ? "" : `git-status--${gitStatusForDisplay}`}`, children: [_jsx("h2", { class: "entries-item__title", children: instance.displayName }), _jsx("p", { "aria-hidden": true, class: "entries-item__subtitle entries-item__subtitle--id", children: instance.id }), _jsxs("div", { class: "entries-item__side", children: [_jsx(GitStatusIndicator, { status: instance.gitStatus }), _jsxs("div", { class: "btns", children: [_jsx("a", { href: `/entities/${entity.name}/instances/${instance.id}`, class: "btn", children: "Edit" }), _jsx("button", { class: "destructive", onClick: () => {
                                         if (confirm("Are you sure you want to delete this instance?")) {
                                             deleteInstanceByEntityNameAndId(locales, entity.name, instance.id)
                                                 .then(() => reloadInstances())

package/dist/src/web/routes/Instance.js

@@ -21,7 +21,7 @@ const titleBuilder = ({ locales, entity, instanceId, instanceContent, }) => {
     }
     return undefined;
 };
-const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonName, childInstances, route, }) => {
+const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonName, childInstances, route, updateLocalGitState, }) => {
     try {
         if (instanceId && buttonName) {
             await updateInstanceByEntityNameAndId(locales, entity.name, instanceId, {
@@ -30,6 +30,7 @@ const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonNa
                 content: instanceContent,
                 id: instanceId,
             });
+            await updateLocalGitState?.();
             switch (buttonName) {
                 case "saveandcontinue": {
                     break;

package/dist/src/web/signals/loading.d.ts

@@ -0,0 +1,2 @@
+export declare const loading: import("@preact/signals-core").Signal<boolean>;
+export declare const runWithLoading: <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/src/web/signals/loading.js

@@ -0,0 +1,11 @@
+import { signal } from "@preact/signals";
+export const loading = signal(false);
+export const runWithLoading = async (fn) => {
+    loading.value = true;
+    try {
+        return await fn();
+    }
+    finally {
+        loading.value = false;
+    }
+};

package/dist/src/web/utils/BlockMarkdown.js

@@ -15,7 +15,7 @@ export const BlockMarkdown = ({ node, outerHeadingLevel = 0 }) => {
                 return (_jsx("ul", { children: node.content.map((item, ii) => (_jsx("li", { children: item.content.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ii))) }));
             }
         case "table":
-            return (_jsxs("table", { children: [_jsx("thead", { children: _jsx("tr", { children: node.header.map((th, hi) => (_jsx("th", { children: th.map((inline, hii) => (_jsx(InlineMarkdown, { node: inline }, hii))) }, hi))) }) }), _jsx("tbody", { children: node.rows.map((tr, ri) => (_jsx("tr", { children: tr.map((tc, ci) => (_jsx("td", { children: tc.map((inline, cii) => (_jsx(InlineMarkdown, { node: inline }, cii))) }, ci))) }, ri))) })] }));
+            return (_jsxs("table", { children: [node.caption !== undefined && (_jsx("caption", { children: node.caption.map((inline, ci) => (_jsx(InlineMarkdown, { node: inline }, ci))) })), _jsx("thead", { children: _jsx("tr", { children: node.header.map((th, hi) => (_jsx("th", { children: th.map((inline, hii) => (_jsx(InlineMarkdown, { node: inline }, hii))) }, hi))) }) }), _jsx("tbody", { children: node.rows.map((tr, ri) => (_jsx("tr", { children: tr.map((tc, ci) => (_jsx("td", { children: tc.map((inline, cii) => (_jsx(InlineMarkdown, { node: inline }, cii))) }, ci))) }, ri))) })] }));
         default:
             return null;
     }

package/dist/src/web/utils/debug.d.ts

@@ -1 +1,2 @@
 export declare const printJson: (data: unknown) => string;
+export declare const logAndAlertError: (error: unknown, prependedMessage?: string) => void;

package/dist/src/web/utils/debug.js

@@ -3,3 +3,7 @@ export const printJson = (data) => JSON.stringify(data, undefined, 2)
     .replace(/((?:^|\n *)[{[])\n +/g, "$1 ")
     .replace(/"(.+?)":/g, '<span style="color: darkorange">$1</span>:')
     .replace(/ "(.*?)"([ ,])/g, ' <span style="color: darkgreen">"$1"</span>$2');
+export const logAndAlertError = (error, prependedMessage) => {
+    console.error(error);
+    alert((prependedMessage ?? "") + (error instanceof Error ? error.toString() : String(error)));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -47,13 +47,13 @@
     "typescript-eslint": "^8.45.0"
   },
   "dependencies": {
+    "@preact/signals": "^2.3.2",
     "debug": "^4.4.3",
     "express": "^5.1.0",
     "preact": "^10.27.2",
     "preact-iso": "^2.11.0",
     "simple-cli-args": "^0.1.3",
-    "simple-git": "^3.28.0",
-    "uuid": "^13.0.0"
+    "simple-git": "^3.28.0"
   },
   "repository": "github:elyukai/tsondb",
   "bugs": {