tsondb 0.17.7 → 0.18.1

package/dist/src/bin/tsondb.js

@@ -7,15 +7,16 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import { omitUndefinedKeys } from "@elyukai/utils/object";
 import Debug from "debug";
 import { access, constants } from "node:fs/promises";
 import { join } from "node:path";
 import { cwd } from "node:process";
 import { pathToFileURL } from "node:url";
 import { parseArguments } from "simple-cli-args";
-import { validateConfigForFormatting, validateConfigForGeneration, validateConfigForServer, validateConfigForTesting, } from "../node/config.js";
-import { format, generateOutputs, serve, validate } from "../node/index.js";
-import { omitUndefinedKeys } from "../shared/utils/object.js";
+import { validateConfigForData, validateConfigForGeneration, validateConfigForServer, validateConfigForTesting, } from "../node/config.js";
+import { TSONDB } from "../node/index.js";
+import { createServer } from "../node/server/index.js";
 const debug = Debug("tsondb:cli");
 const passedArguments = parseArguments({
     commands: {
@@ -83,35 +84,47 @@ if (config === undefined) {
 if (passedArguments.command === undefined) {
     throw new Error("No command has been specified. Possible commands are: generate, serve, validate.");
 }
-switch (passedArguments.command.name) {
-    case "generate":
-        debug(`running command: generate`);
-        validateConfigForGeneration(config);
-        await generateOutputs(config.schema, config.outputs);
-        break;
-    case "serve":
-        debug(`running command: serve`);
-        validateConfigForServer(config);
-        await serve(config.schema, config.dataRootPath, config.locales, config.homeLayoutSections, config.serverOptions, config.validationOptions, config.customStylesheetPath);
-        break;
-    case "validate":
-        debug(`running command: validate`);
-        validateConfigForTesting(config);
-        if (passedArguments.command.options?.checkReferentialIntegrity !== undefined) {
-            debug(`check referential integrity: ${passedArguments.command.options.checkReferentialIntegrity ? "yes" : "no"}`);
-        }
-        if (passedArguments.command.options?.checkOnlyEntities !== undefined) {
-            const entities = passedArguments.command.options.checkOnlyEntities;
-            debug(`only check the following entities: ${entities.join(", ")}`);
+if (passedArguments.command.name === "generate") {
+    debug(`running command: generate`);
+    validateConfigForGeneration(config);
+    await TSONDB.generateOutputs(config);
+}
+else {
+    validateConfigForData(config);
+    const db = await TSONDB.create({
+        ...config,
+        validationOptions: passedArguments.command.name === "validate"
+            ? {
+                ...config.validationOptions,
+                ...omitUndefinedKeys(passedArguments.command.options ?? {}),
+            }
+            : config.validationOptions,
+    });
+    switch (passedArguments.command.name) {
+        case "serve":
+            debug(`running command: serve`);
+            validateConfigForServer(config);
+            await createServer(db, config.homeLayoutSections, config.serverOptions, config.validationOptions, config.customStylesheetPath);
+            break;
+        case "validate": {
+            debug(`running command: validate`);
+            validateConfigForTesting(config);
+            if (passedArguments.command.options?.checkReferentialIntegrity !== undefined) {
+                debug(`check referential integrity: ${passedArguments.command.options.checkReferentialIntegrity ? "yes" : "no"}`);
+            }
+            if (passedArguments.command.options?.checkOnlyEntities !== undefined) {
+                const entities = passedArguments.command.options.checkOnlyEntities;
+                debug(`only check the following entities: ${entities.join(", ")}`);
+            }
+            const result = db.validate();
+            if (!result) {
+                process.exitCode = 1;
+            }
+            break;
         }
-        await validate(config.schema, config.dataRootPath, config.locales, {
-            ...config.validationOptions,
-            ...omitUndefinedKeys(passedArguments.command.options ?? {}),
-        });
-        break;
-    case "format":
-        debug(`running command: format`);
-        validateConfigForFormatting(config);
-        await format(config.schema, config.dataRootPath);
-        break;
+        case "format":
+            debug(`running command: format`);
+            await db.format();
+            break;
+    }
 }

package/dist/src/node/config.d.ts

@@ -37,10 +37,11 @@ export declare const validateConfigForGeneration: (config: Config) => asserts co
 /**
  * The configuration type required for any commands that need to read data stored in the database.
  */
-export type DataConfig = {
+export type DataConfig = Config & {
     schema: Schema;
     dataRootPath: string;
 };
+export declare const validateConfigForData: (config: Config) => asserts config is DataConfig;
 /**
  * The configuration type required for running the server for the editor.
  */

package/dist/src/node/config.js

@@ -3,6 +3,11 @@ export const validateConfigForGeneration = config => {
         throw new Error("At least one output must be specified in the config.");
     }
 };
+export const validateConfigForData = config => {
+    if (config.dataRootPath === undefined) {
+        throw new Error("A data root path must be specified in the config.");
+    }
+};
 export const validateConfigForServer = config => {
     if ((config.locales?.length ?? 0) === 0) {
         throw new Error("At least one locale must be specified in the config.");

package/dist/src/node/git.d.ts

@@ -0,0 +1,130 @@
+import type { SimpleGit } from "simple-git";
+import type { InstanceContainerOverview } from "../shared/utils/instances.ts";
+import type { DefaultTSONDBTypes, EntityName, TSONDB } from "./index.ts";
+import type { DatabaseInMemory } from "./utils/databaseInMemory.ts";
+export declare class Git<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
+    #private;
+    constructor(db: TSONDB<T>, git: SimpleGit, gitRoot: string, dataRoot: string, getData: () => DatabaseInMemory<T["entityMap"]>, setData: (data: DatabaseInMemory<T["entityMap"]>) => void);
+    /**
+     * Runs a `git status` operation and updates the in-memory database with the latest statuses.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    status(): Promise<{
+        currentBranch: string | null;
+        trackingBranch: string | null;
+        commitsAhead: number;
+        commitsBehind: number;
+        latestCommit: string;
+        instances: Record<string, InstanceContainerOverview[]>;
+    }>;
+    /**
+     * Fetches updates from remote git repositories.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    fetch(options: Partial<{
+        all: boolean;
+        prune: boolean;
+    }>): Promise<void>;
+    /**
+     * Adds files to the git staging area.
+     *
+     * - If the function is called without parameters, all changes to all instances are added.
+     * - If the function is called with only the `entity` parameter, all changes to instances of that entity are added.
+     * - If both `entity` and `id` parameters are provided, only the changes to that specific instance are added.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    stage(entity?: EntityName<T>, id?: string): Promise<void>;
+    /**
+     * Removes files from the git staging area.
+     *
+     * - If the function is called without parameters, all changes to all instances are removed.
+     * - If the function is called with only the `entity` parameter, all changes to instances of that entity are removed.
+     * - If both `entity` and `id` parameters are provided, only the changes to that specific instance are removed.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    unstage(entity?: EntityName<T>, id?: string): Promise<void>;
+    /**
+     * Restores files in the git repository to their last committed state.
+     *
+     * - If the function is called without parameters, all changes to all instances are restored.
+     * - If the function is called with only the `entity` parameter, all changes to instances of that entity are restored.
+     * - If both `entity` and `id` parameters are provided, only the changes to that specific instance are restored.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    restore(entity?: EntityName<T>, id?: string): Promise<void>;
+    /**
+     * Commits staged changes to the git repository with the provided commit message.
+     *
+     * @throws {HTTPError} when no git repository is found
+     * @throws {HTTPError} when the commit message is empty
+     */
+    commit(message: string): Promise<void>;
+    /**
+     * Pushes committed changes to the remote git repository.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    push(): Promise<void>;
+    /**
+     * Pulls changes from the remote git repository.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    pull(): Promise<void>;
+    /**
+     * Retrieves information about the branches in the git repository.
+     */
+    branch(): Promise<{
+        isDetached: boolean;
+        currentBranch: string;
+        allBranches: string[];
+        branches: {
+            [key: string]: {
+                current: boolean;
+                name: string;
+                commit: string;
+                label: string;
+                linkedWorkTree: boolean;
+            };
+        };
+    }>;
+    /**
+     * Creates a new branch in the git repository and checks it out.
+     *
+     * @param branchName The name of the branch to create.
+     * @throws {HTTPError} when no git repository is found
+     */
+    createBranch(branchName: string): Promise<void>;
+    /**
+     * Switches to an existing branch in the git repository.
+     *
+     * @param branchName The name of the branch to switch to.
+     * @throws {HTTPError} when no git repository is found
+     */
+    switchBranch(branchName: string): Promise<void>;
+    /**
+     * Deletes a branch in the git repository.
+     *
+     * @param branchName The name of the branch to delete.
+     * @param options Options for deleting the branch.
+     * @throws {HTTPError} when no git repository is found
+     * @throws {HTTPError} when trying to delete the currently checked out branch
+     */
+    deleteBranch(branchName: string, options: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Run a custom git operation.
+     *
+     * @param commands The git commands to run as an array of strings.
+     * @param commandMayChangeDataOnDisk Whether the command may change data on disk and thus requires a sync afterwards.
+     * @returns The raw output of the git command.
+     * @throws {HTTPError} when no git repository is found
+     */
+    raw(commands: string[], commandMayChangeDataOnDisk: boolean): Promise<string>;
+}

package/dist/src/node/git.js

@@ -0,0 +1,233 @@
+import Debug from "debug";
+import { join } from "path";
+import { getAllInstanceOverviewsByEntityName } from "./utils/displayName.js";
+import { HTTPError } from "./utils/error.js";
+import { getFileNameForId } from "./utils/files.js";
+import { attachGitStatusToDatabaseInMemory } from "./utils/git.js";
+const debug = Debug("tsondb:git");
+export class Git {
+    #db;
+    #git;
+    #gitRoot;
+    #dataRoot;
+    #getData;
+    #setData;
+    constructor(db, git, gitRoot, dataRoot, getData, setData) {
+        this.#db = db;
+        this.#git = git;
+        this.#gitRoot = gitRoot;
+        this.#dataRoot = dataRoot;
+        this.#getData = getData;
+        this.#setData = setData;
+    }
+    /**
+     * Runs a `git status` operation and updates the in-memory database with the latest statuses.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    async status() {
+        debug("status");
+        const status = await this.#git.status();
+        const data = attachGitStatusToDatabaseInMemory(this.#getData(), this.#dataRoot, this.#gitRoot, status);
+        this.#setData(data);
+        return {
+            currentBranch: status.current,
+            trackingBranch: status.tracking,
+            commitsAhead: status.ahead,
+            commitsBehind: status.behind,
+            instances: getAllInstanceOverviewsByEntityName(this.#db.getInstanceContainerOfEntityById.bind(this.#db), this.#db.getAllChildInstanceContainersForParent.bind(this.#db), this.#db.schema.getEntity.bind(this.#db.schema), data, this.#db.locales),
+            latestCommit: await this.#git.revparse(["HEAD"]),
+        };
+    }
+    /**
+     * Fetches updates from remote git repositories.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    async fetch(options) {
+        debug("fetch");
+        const args = {
+            all: options.all ? "--all" : undefined,
+            prune: options.prune ? "-p" : undefined,
+        };
+        await this.#git.fetch(Object.values(args));
+    }
+    /**
+     * Adds files to the git staging area.
+     *
+     * - If the function is called without parameters, all changes to all instances are added.
+     * - If the function is called with only the `entity` parameter, all changes to instances of that entity are added.
+     * - If both `entity` and `id` parameters are provided, only the changes to that specific instance are added.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    async stage(entity, id) {
+        if (entity) {
+            if (id) {
+                debug("add instance %s of entity %s", id, entity);
+                await this.#git.add(join(this.#dataRoot, entity, getFileNameForId(id)));
+            }
+            else {
+                debug("add all instances of entity %s", entity);
+                await this.#git.add(join(this.#dataRoot, entity));
+            }
+        }
+        else {
+            debug("add all instances");
+            await this.#git.add(this.#dataRoot);
+        }
+    }
+    /**
+     * Removes files from the git staging area.
+     *
+     * - If the function is called without parameters, all changes to all instances are removed.
+     * - If the function is called with only the `entity` parameter, all changes to instances of that entity are removed.
+     * - If both `entity` and `id` parameters are provided, only the changes to that specific instance are removed.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    async unstage(entity, id) {
+        if (entity) {
+            if (id) {
+                debug("reset HEAD instance %s of entity %s", id, entity);
+                await this.#git.reset(["HEAD", "--", join(this.#dataRoot, entity, getFileNameForId(id))]);
+            }
+            else {
+                debug("reset HEAD all instances of entity %s", entity);
+                await this.#git.reset(["HEAD", "--", join(this.#dataRoot, entity)]);
+            }
+        }
+        else {
+            debug("reset HEAD all instances");
+            await this.#git.reset(["HEAD", "--", this.#dataRoot]);
+        }
+    }
+    /**
+     * Restores files in the git repository to their last committed state.
+     *
+     * - If the function is called without parameters, all changes to all instances are restored.
+     * - If the function is called with only the `entity` parameter, all changes to instances of that entity are restored.
+     * - If both `entity` and `id` parameters are provided, only the changes to that specific instance are restored.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    async restore(entity, id) {
+        if (entity) {
+            if (id) {
+                debug("restore instance %s of entity %s", id, entity);
+                await this.#git.raw(["restore", "--", join(this.#dataRoot, entity, getFileNameForId(id))]);
+            }
+            else {
+                debug("restore all instances of entity %s", entity);
+                await this.#git.raw(["restore", "--", join(this.#dataRoot, entity)]);
+            }
+        }
+        else {
+            debug("restore all instances");
+            await this.#git.raw(["restore", "--", this.#dataRoot]);
+        }
+        await this.#db.sync();
+    }
+    /**
+     * Commits staged changes to the git repository with the provided commit message.
+     *
+     * @throws {HTTPError} when no git repository is found
+     * @throws {HTTPError} when the commit message is empty
+     */
+    async commit(message) {
+        debug("commit");
+        if (message.trim().length === 0) {
+            throw new HTTPError(400, "Commit message cannot be empty.");
+        }
+        await this.#git.commit(message);
+    }
+    /**
+     * Pushes committed changes to the remote git repository.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    async push() {
+        debug("push");
+        const status = await this.#git.status();
+        const remotes = await this.#git.getRemotes();
+        await this.#git.push(remotes[0]?.name, status.current ?? undefined);
+    }
+    /**
+     * Pulls changes from the remote git repository.
+     *
+     * @throws {HTTPError} when no git repository is found
+     */
+    async pull() {
+        debug("pull");
+        const status = await this.#git.status();
+        const remotes = await this.#git.getRemotes();
+        await this.#git.pull(remotes[0]?.name, status.current ?? undefined);
+        await this.#db.sync();
+    }
+    /**
+     * Retrieves information about the branches in the git repository.
+     */
+    async branch() {
+        debug("branch");
+        const branchSummary = await this.#git.branch();
+        return {
+            allBranches: branchSummary.all,
+            currentBranch: branchSummary.current,
+            isDetached: branchSummary.detached,
+            branches: branchSummary.branches,
+        };
+    }
+    /**
+     * Creates a new branch in the git repository and checks it out.
+     *
+     * @param branchName The name of the branch to create.
+     * @throws {HTTPError} when no git repository is found
+     */
+    async createBranch(branchName) {
+        debug("create branch %s", branchName);
+        await this.#git.checkoutLocalBranch(branchName);
+    }
+    /**
+     * Switches to an existing branch in the git repository.
+     *
+     * @param branchName The name of the branch to switch to.
+     * @throws {HTTPError} when no git repository is found
+     */
+    async switchBranch(branchName) {
+        debug("switch branch %s", branchName);
+        await this.#git.raw("switch", branchName);
+        await this.#db.sync();
+    }
+    /**
+     * Deletes a branch in the git repository.
+     *
+     * @param branchName The name of the branch to delete.
+     * @param options Options for deleting the branch.
+     * @throws {HTTPError} when no git repository is found
+     * @throws {HTTPError} when trying to delete the currently checked out branch
+     */
+    async deleteBranch(branchName, options) {
+        debug("delete branch %s", branchName);
+        const branchSummary = await this.#git.branchLocal();
+        if (branchSummary.current === branchName) {
+            throw new HTTPError(400, "Cannot delete the branch currently checked out.");
+        }
+        await this.#git.deleteLocalBranch(branchName, options.force ?? false);
+    }
+    /**
+     * Run a custom git operation.
+     *
+     * @param commands The git commands to run as an array of strings.
+     * @param commandMayChangeDataOnDisk Whether the command may change data on disk and thus requires a sync afterwards.
+     * @returns The raw output of the git command.
+     * @throws {HTTPError} when no git repository is found
+     */
+    async raw(commands, commandMayChangeDataOnDisk) {
+        debug("raw %O", commands);
+        const result = await this.#git.raw(...commands);
+        if (commandMayChangeDataOnDisk) {
+            await this.#db.sync();
+        }
+        return result;
+    }
+}