tsondb 0.2.0 → 0.3.0

package/lib/server/index.js

@@ -1,17 +1,14 @@
+import Debug from "debug";
 import express from "express";
 import { join } from "node:path";
-import { serializeDecl } from "../schema/declarations/Declaration.js";
-import { isEntityDecl, serializeEntityDecl } from "../schema/declarations/EntityDecl.js";
-import { isEnumDecl } from "../schema/declarations/EnumDecl.js";
-import { isTypeAliasDecl } from "../schema/declarations/TypeAliasDecl.js";
-import { getDisplayNameFromEntityInstance } from "../shared/utils/displayName.js";
-import { isOk } from "../utils/result.js";
-import { createInstance, deleteInstance, updateInstance } from "./instanceOperations.js";
+import { api } from "./api/index.js";
+import { init } from "./init.js";
+const debug = Debug("tsondb:server");
 const defaultOptions = {
     name: "tsondb server",
     port: 3000,
 };
-export const createServer = (modelContainer, instancesByEntityName, options) => {
+export const createServer = async (modelContainer, instancesByEntityName, options) => {
     const { name, port } = { ...defaultOptions, ...options };
     const app = express();
     app.use(express.static(join(import.meta.dirname, "../../public")));
@@ -19,163 +16,12 @@ export const createServer = (modelContainer, instancesByEntityName, options) =>
     app.use("/js/client", express.static(join(import.meta.dirname, "../../lib/client")));
     app.use("/js/shared", express.static(join(import.meta.dirname, "../../lib/shared")));
     app.use(express.json());
-    const declarations = modelContainer.schema.declarations;
-    const entities = declarations.filter(isEntityDecl);
-    const entitiesByName = Object.fromEntries(entities.map(entity => [entity.name, entity]));
-    const instancesByEntityNameInMemory = { ...instancesByEntityName };
-    app.get("/api/declarations", (req, res) => {
-        let filteredEntities;
-        switch (req.query["kind"]) {
-            case "Entity":
-                filteredEntities = entities.filter(isEntityDecl);
-                break;
-            case "TypeAlias":
-                filteredEntities = entities.filter(isTypeAliasDecl);
-                break;
-            case "Enum":
-                filteredEntities = entities.filter(isEnumDecl);
-                break;
-            default:
-                filteredEntities = declarations;
-        }
-        const body = {
-            declarations: filteredEntities.map(decl => ({
-                declaration: serializeDecl(decl),
-                instanceCount: instancesByEntityNameInMemory[decl.name]?.length ?? 0,
-            })),
-            localeEntity: modelContainer.schema.localeEntity?.name,
-        };
-        res.json(body);
-    });
-    app.get("/api/declarations/:name", (req, res) => {
-        const decl = 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: instancesByEntityNameInMemory[decl.name]?.length ?? 0,
-            isLocaleEntity: decl === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.get("/api/declarations/:name/instances", (req, res) => {
-        const decl = 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: instancesByEntityNameInMemory[req.params.name] ?? [],
-            isLocaleEntity: decl === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.post("/api/declarations/:name/instances", async (req, res) => {
-        const decl = 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(modelContainer, entitiesByName, instancesByEntityNameInMemory, decl.name, req.body, req.query["id"]);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.get("/api/declarations/:name/instances/:id", (req, res) => {
-        const decl = 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 = instancesByEntityNameInMemory[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 === modelContainer.schema.localeEntity,
-        };
-        res.json(body);
-    });
-    app.put("/api/declarations/:name/instances/:id", async (req, res) => {
-        const decl = 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(modelContainer, entitiesByName, instancesByEntityNameInMemory, decl.name, req.params.id, req.body);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.delete("/api/declarations/:name/instances/:id", async (req, res) => {
-        const decl = 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(modelContainer, instancesByEntityNameInMemory, decl.name, req.params.id);
-        if (isOk(result)) {
-            const body = {
-                instance: result.value,
-                isLocaleEntity: decl === modelContainer.schema.localeEntity,
-            };
-            res.json(body);
-        }
-        else {
-            res.status(result.error[0]).send(result.error[1]);
-        }
-    });
-    app.get("/api/instances", (req, res) => {
-        const locales = (Array.isArray(req.query["locales"]) ? req.query["locales"] : [req.query["locales"]]).filter(locale => typeof locale === "string");
-        const body = {
-            instances: Object.fromEntries(Object.entries(instancesByEntityNameInMemory).map(([entityName, instances]) => [
-                entityName,
-                instances.map(instance => ({
-                    id: instance.id,
-                    name: getDisplayNameFromEntityInstance(serializeEntityDecl(entitiesByName[entityName]), instance.content, instance.id, locales),
-                })),
-            ])),
-        };
-        res.json(body);
+    const requestLocals = await init(modelContainer, Object.assign({}, instancesByEntityName));
+    app.use((req, _res, next) => {
+        Object.assign(req, requestLocals);
+        next();
     });
+    app.use("/api", api);
     app.get(/^\/.*/, (_req, res) => {
         res.send(`<!DOCTYPE html>
 <html lang="en">
@@ -202,6 +48,6 @@ export const createServer = (modelContainer, instancesByEntityName, options) =>
 </html>`);
     });
     app.listen(port, () => {
-        console.log(`${name} listening on http://localhost:${port}`);
+        debug(`${name} listening on http://localhost:${port}`);
     });
 };

package/lib/server/init.d.ts

@@ -0,0 +1,5 @@
+import { ModelContainer } from "../ModelContainer.js";
+import { InstancesByEntityName } from "../shared/utils/instances.js";
+import { TSONDBRequestLocals } from "./index.js";
+export declare const init: (modelContainer: ModelContainer, instancesByEntityName: InstancesByEntityName) => Promise<TSONDBRequestLocals>;
+export declare const reinit: (locals: TSONDBRequestLocals) => Promise<void>;

package/lib/server/init.js

@@ -0,0 +1,56 @@
+import { simpleGit } from "simple-git";
+import { isEntityDecl } from "../schema/declarations/EntityDecl.js";
+import { resolveTypeArgumentsInDecls } from "../schema/index.js";
+import { attachGitStatusToInstancesByEntityName, getInstancesByEntityName, } from "../utils/instances.js";
+import { getReferencesToInstances } from "../utils/references.js";
+const getGit = async (modelContainer) => {
+    const git = simpleGit({ baseDir: modelContainer.dataRootPath });
+    if (await git.checkIsRepo()) {
+        try {
+            const root = await git.revparse({ "--show-toplevel": null });
+            const status = await git.status();
+            return { git, root, status };
+        }
+        catch {
+            return { git };
+        }
+    }
+    else {
+        return { git };
+    }
+};
+export const init = async (modelContainer, instancesByEntityName) => {
+    const { git, root: gitRoot, status: gitStatus } = await getGit(modelContainer);
+    const declarations = resolveTypeArgumentsInDecls(modelContainer.schema.declarations);
+    const entities = declarations.filter(isEntityDecl);
+    const entitiesByName = Object.fromEntries(entities.map(entity => [entity.name, entity]));
+    const instancesByEntityNameInMemory = Object.assign({}, instancesByEntityName);
+    const referencesToInstances = getReferencesToInstances(instancesByEntityName, entitiesByName);
+    if (gitStatus) {
+        attachGitStatusToInstancesByEntityName(instancesByEntityName, modelContainer.dataRootPath, gitRoot, gitStatus);
+    }
+    const requestLocals = {
+        git: git,
+        gitRoot: gitRoot,
+        dataRoot: modelContainer.dataRootPath,
+        declarations: declarations,
+        entities: entities,
+        instancesByEntityName: instancesByEntityNameInMemory,
+        entitiesByName: entitiesByName,
+        localeEntity: modelContainer.schema.localeEntity,
+        referencesToInstances,
+    };
+    return requestLocals;
+};
+export const reinit = async (locals) => {
+    const gitStatus = (await locals.git.checkIsRepo()) ? await locals.git.status() : undefined;
+    const instancesByEntityName = await getInstancesByEntityName(locals.dataRoot, locals.entities);
+    const referencesToInstances = getReferencesToInstances(instancesByEntityName, locals.entitiesByName);
+    if (locals.gitRoot && gitStatus) {
+        attachGitStatusToInstancesByEntityName(instancesByEntityName, locals.dataRoot, locals.gitRoot, gitStatus);
+    }
+    Object.assign(locals, {
+        instancesByEntityName,
+        referencesToInstances,
+    });
+};

package/lib/shared/api.d.ts

@@ -1,5 +1,5 @@
 import { SerializedDecl } from "../schema/declarations/Declaration.js";
-import { InstanceContainer } from "./utils/instances.js";
+import { InstanceContainer, InstanceContainerOverview } from "./utils/instances.js";
 export interface GetAllDeclarationsResponseBody<D extends SerializedDecl = SerializedDecl> {
     declarations: {
         declaration: D;
@@ -40,3 +40,14 @@ export interface GetAllInstancesResponseBody {
         }[];
     };
 }
+export interface GitStatusResponseBody {
+    commitsAhead: number;
+    commitsBehind: number;
+    instances: {
+        [entity: string]: InstanceContainerOverview[];
+    };
+}
+export interface GetAllGitBranchesResponseBody {
+    allBranches: string[];
+    currentBranch: string;
+}

package/lib/shared/utils/array.d.ts

@@ -0,0 +1,19 @@
+export declare const removeAt: <T>(arr: T[], index: number) => T[];
+export declare const insertAt: <T>(arr: T[], index: number, item: T) => T[];
+/**
+ * Calculates the difference between two arrays, including duplicated values.
+ * @param oldArr - The original array.
+ * @param newArr - The new array to compare against.
+ * @returns An object containing the added and removed elements.
+ */
+export declare const difference: <T>(oldArr: T[], newArr: T[]) => ArrayDiffResult<T>;
+export interface ArrayDiffResult<T> {
+    /**
+     * Elements in `newArr` that are not in `oldArr`.
+     */
+    added: T[];
+    /**
+     * Elements in `oldArr` that are not in `newArr`.
+     */
+    removed: T[];
+}

package/lib/shared/utils/array.js

@@ -0,0 +1,27 @@
+export const removeAt = (arr, index) => [
+    ...arr.slice(0, index),
+    ...arr.slice(index + 1),
+];
+export const insertAt = (arr, index, item) => [
+    ...arr.slice(0, index),
+    item,
+    ...arr.slice(index),
+];
+/**
+ * Calculates the difference between two arrays, including duplicated values.
+ * @param oldArr - The original array.
+ * @param newArr - The new array to compare against.
+ * @returns An object containing the added and removed elements.
+ */
+export const difference = (oldArr, newArr) => newArr.reduce((acc, item) => {
+    const oldIndex = acc.removed.indexOf(item);
+    const newIndex = acc.added.indexOf(item);
+    if (oldIndex > -1) {
+        return {
+            ...acc,
+            removed: removeAt(acc.removed, oldIndex),
+            added: removeAt(acc.added, newIndex),
+        };
+    }
+    return acc;
+}, { removed: oldArr, added: newArr });

package/lib/shared/utils/git.d.ts

@@ -0,0 +1,12 @@
+export type GitFileStatus = {
+    index: GitFileStatusCode;
+    workingDir: GitFileStatusCode;
+};
+export declare const isChangedInIndex: (fileStatus: GitFileStatus) => boolean;
+export declare const isChangedInWorkingDir: (fileStatus: GitFileStatus) => boolean;
+export type GitFileStatusCode = " " | "M" | "T" | "A" | "D" | "R" | "C" | "U" | "m" | "?" | "!";
+export declare const isUnchangedStatus: (code: GitFileStatusCode) => boolean;
+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;

package/lib/shared/utils/git.js

@@ -0,0 +1,98 @@
+export const isChangedInIndex = (fileStatus) => {
+    const { index } = fileStatus;
+    switch (index) {
+        case "M":
+        case "T":
+        case "A":
+        case "D":
+        case "R":
+        case "C":
+        case "U":
+            return true;
+        case " ":
+        case "m":
+        case "?":
+        case "!":
+            return false;
+    }
+};
+export const isChangedInWorkingDir = (fileStatus) => {
+    const { workingDir } = fileStatus;
+    switch (workingDir) {
+        case "M":
+        case "T":
+        case "A":
+        case "D":
+        case "R":
+        case "C":
+        case "U":
+        case "?":
+            return true;
+        case " ":
+        case "m":
+        case "!":
+            return false;
+    }
+};
+const unchangedStatusCodes = new Set([" ", "!", "C", "T", "m", "U"]);
+export const isUnchangedStatus = (code) => unchangedStatusCodes.has(code);
+export const hasFileChanges = (fileStatus) => {
+    if (fileStatus === undefined) {
+        return false;
+    }
+    const { index, workingDir } = fileStatus;
+    return !isUnchangedStatus(index) || !isUnchangedStatus(workingDir);
+};
+export const getGitStatusForDisplay = (fileStatus) => {
+    if (fileStatus === undefined) {
+        return undefined;
+    }
+    const { index, workingDir } = fileStatus;
+    switch (workingDir) {
+        case " ":
+            switch (index) {
+                case " ":
+                    return undefined;
+                case "M":
+                    return "M";
+                case "A":
+                    return "A";
+                case "D":
+                    return "D";
+                case "R":
+                    return "R";
+                case "?":
+                    return "U";
+                default:
+                    return undefined;
+            }
+        case "M":
+            return "M";
+        case "A":
+            return "A";
+        case "D":
+            return "D";
+        case "R":
+            return "R";
+        case "?":
+            return "U";
+        default:
+            return undefined;
+    }
+};
+export const getLabelForGitStatus = (status) => {
+    switch (status) {
+        case "U":
+            return "untracked";
+        case "M":
+            return "modified";
+        case "A":
+            return "sdded";
+        case "D":
+            return "deleted";
+        case "R":
+            return "renamed";
+        default:
+            return "";
+    }
+};

package/lib/shared/utils/instances.d.ts

@@ -1,6 +1,16 @@
+import { SerializedEntityDecl } from "../../schema/index.js";
+import { GitFileStatus } from "./git.js";
 export interface InstanceContainer {
     fileName: string;
     id: string;
     content: unknown;
+    gitStatus?: GitFileStatus;
 }
+export interface InstanceContainerOverview {
+    fileName: string;
+    id: string;
+    gitStatus?: GitFileStatus;
+    displayName: string;
+}
+export declare const getInstanceContainerOverview: (entity: SerializedEntityDecl, instanceContainer: InstanceContainer, locales?: string[]) => InstanceContainerOverview;
 export type InstancesByEntityName = Record<string, InstanceContainer[]>;

package/lib/shared/utils/instances.js

@@ -1 +1,8 @@
-export {};
+import { getDisplayNameFromEntityInstance } from "./displayName.js";
+export const getInstanceContainerOverview = (entity, instanceContainer, locales) => {
+    const { content: _, ...rest } = instanceContainer;
+    return {
+        ...rest,
+        displayName: getDisplayNameFromEntityInstance(entity, instanceContainer.content, instanceContainer.id, locales),
+    };
+};

package/lib/shared/utils/markdown.d.ts

@@ -0,0 +1,14 @@
+type TextNode = {
+    kind: "text";
+    content: string;
+};
+export type InlineMarkdownNode = {
+    kind: "bold" | "italic";
+    content: InlineMarkdownNode[];
+} | TextNode;
+export type BlockMarkdownNode = {
+    kind: "paragraph";
+    content: InlineMarkdownNode[];
+} | TextNode;
+export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
+export {};

package/lib/shared/utils/markdown.js

@@ -0,0 +1,42 @@
+const boldWithItalicRule = {
+    pattern: /\*\*(.*?\*.+?\*.*?)\*\*/,
+    map: (result, parseInside) => ({ kind: "bold", content: parseInside(result[1]) }),
+};
+const italicWithBoldRule = {
+    pattern: /\*(.*?\*\*.+?\*\*.*?)\*/,
+    map: (result, parseInside) => ({ kind: "italic", content: parseInside(result[1]) }),
+};
+const boldRule = {
+    pattern: /\*\*(.+?)\*\*/,
+    map: (result, parseInside) => ({ kind: "bold", content: parseInside(result[1]) }),
+};
+const italicRule = {
+    pattern: /\*(.+?)\*/,
+    map: (result, parseInside) => ({ kind: "italic", content: parseInside(result[1]) }),
+};
+const rules = [boldWithItalicRule, italicWithBoldRule, boldRule, italicRule];
+export const parseBlockMarkdown = (text) => text.split(/\n{2,}/).map(par => ({ kind: "paragraph", content: parseInlineMarkdown(par) }));
+const parseForRules = (rules, text) => {
+    if (text.length === 0) {
+        return [];
+    }
+    if (rules.length === 0) {
+        return [{ kind: "text", content: text }];
+    }
+    const activeRule = rules[0];
+    const res = activeRule.pattern.exec(text);
+    if (res && (activeRule.predicate?.(res) ?? true)) {
+        const { index } = res;
+        const before = text.slice(0, index);
+        const after = text.slice(index + res[0].length);
+        return [
+            ...(before.length > 0 ? parseForRules(rules.slice(1), before) : []),
+            activeRule.map(res, text => parseForRules(rules.slice(1), text)),
+            ...(after.length > 0 ? parseForRules(rules, after) : []),
+        ];
+    }
+    else {
+        return parseForRules(rules.slice(1), text);
+    }
+};
+const parseInlineMarkdown = (text) => parseForRules(rules, text);

package/lib/shared/utils/object.d.ts

@@ -1,2 +1,3 @@
 export declare const sortObjectKeys: (obj: Record<string, unknown>, keys: string[]) => Record<string, unknown>;
 export declare const sortObjectKeysAlphabetically: (obj: Record<string, unknown>) => Record<string, unknown>;
+export declare const mergeObjects: <T>(obj1: Record<string, T>, obj2: Record<string, T>, solveConflict: (a: T, b: T) => T) => Record<string, T>;

package/lib/shared/utils/object.js

@@ -1,2 +1,6 @@
 export const sortObjectKeys = (obj, keys) => Object.fromEntries(keys.flatMap(key => (obj[key] === undefined ? [] : [[key, obj[key]]])));
 export const sortObjectKeysAlphabetically = (obj) => Object.fromEntries(Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)));
+export const mergeObjects = (obj1, obj2, solveConflict) => Object.entries(obj2).reduce((acc, [key, value]) => ({
+    ...acc,
+    [key]: Object.hasOwn(acc, key) ? solveConflict(acc[key], value) : value,
+}), obj1);

package/lib/shared/utils/string.d.ts

@@ -4,3 +4,4 @@ export declare const toCamelCase: (str: string) => string;
 export declare const toKebabCase: (str: string) => string;
 export declare const toSnakeCase: (str: string) => string;
 export declare const toTitleCase: (str: string) => string;
+export declare const commonPrefix: (...strs: string[]) => string;

package/lib/shared/utils/string.js

@@ -50,3 +50,12 @@ export const toSnakeCase = (str) => splitStringParts(str)
 export const toTitleCase = (str) => splitStringParts(str)
     .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
     .join(" ");
+export const commonPrefix = (...strs) => {
+    if (strs.length === 0) {
+        return "";
+    }
+    return strs.reduce((accPrefix, str) => {
+        const indexOfDifference = Array.from(accPrefix).findIndex((char, i) => str[i] !== char);
+        return indexOfDifference === -1 ? accPrefix : accPrefix.slice(0, indexOfDifference);
+    });
+};