tsondb 0.19.3 → 0.19.6

package/dist/src/bin/tsondb.js

@@ -13,6 +13,7 @@ import { access, constants } from "node:fs/promises";
 import { join } from "node:path";
 import { cwd } from "node:process";
 import { pathToFileURL } from "node:url";
+import { styleText } from "node:util";
 import { parseArguments } from "simple-cli-args";
 import { validateConfigForData, validateConfigForGeneration, validateConfigForServer, validateConfigForTesting, } from "../node/config.js";
 import { TSONDB } from "../node/index.js";
@@ -48,6 +49,25 @@ const passedArguments = parseArguments({
         format: {
             name: "format",
         },
+        name: {
+            name: "name",
+            options: {
+                id: {
+                    name: "id",
+                    type: String,
+                },
+            },
+        },
+        list: {
+            name: "list",
+            options: {
+                entity: {
+                    name: "entity",
+                    alias: "e",
+                    type: String,
+                },
+            },
+        },
     },
 });
 // import the config
@@ -84,6 +104,10 @@ if (config === undefined) {
 if (passedArguments.command === undefined) {
     throw new Error("No command has been specified. Possible commands are: generate, serve, validate.");
 }
+const createDB = (config, validationOptions, skipReferenceCache) => TSONDB.create({
+    ...config,
+    validationOptions,
+}, skipReferenceCache);
 if (passedArguments.command.name === "generate") {
     debug(`running command: generate`);
     validateConfigForGeneration(config);
@@ -91,21 +115,14 @@ if (passedArguments.command.name === "generate") {
 }
 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":
+        case "serve": {
             debug(`running command: serve`);
             validateConfigForServer(config);
+            const db = await createDB(config, config.validationOptions, false);
             await createServer(db, config.homeLayoutSections, config.serverOptions, config.validationOptions, config.customStylesheetPath);
             break;
+        }
         case "validate": {
             debug(`running command: validate`);
             validateConfigForTesting(config);
@@ -116,15 +133,57 @@ else {
                 const entities = passedArguments.command.options.checkOnlyEntities;
                 debug(`only check the following entities: ${entities.join(", ")}`);
             }
+            const db = await createDB(config, {
+                ...config.validationOptions,
+                ...omitUndefinedKeys(passedArguments.command.options ?? {}),
+            }, false);
             const result = db.validate();
             if (!result) {
                 process.exitCode = 1;
             }
             break;
         }
-        case "format":
+        case "format": {
             debug(`running command: format`);
+            const db = await createDB(config, config.validationOptions, true);
             await db.format();
             break;
+        }
+        case "name": {
+            debug(`running command: name`);
+            const id = passedArguments.command.options?.id;
+            if (id === undefined) {
+                throw new Error("No ID specified for name command.");
+            }
+            const db = await createDB(config, config.validationOptions, true);
+            const entityName = db.getEntityNameOfInstanceId(id);
+            if (entityName === undefined) {
+                throw new Error("An instance with the specified ID does not exist in the database.");
+            }
+            const displayName = db.getDisplayName(entityName, id);
+            console.log(displayName ?? styleText(["underline"], "no display name available"));
+            break;
+        }
+        case "list": {
+            debug(`running command: list`);
+            const entity = passedArguments.command.options?.entity;
+            if (entity === undefined) {
+                throw new Error("No entity specified for list command.");
+            }
+            const db = await createDB(config, config.validationOptions, true);
+            if (!db.schema.isEntityName(entity)) {
+                throw new Error("An entity with the specified name does not exist in the database.");
+            }
+            const instances = db.getAllInstanceOverviewsOfEntity(entity);
+            if (instances.length === 0) {
+                console.log(styleText(["italic"], "no instances found"));
+                break;
+            }
+            console.log(styleText(["bold"], "UUID                                  Display Name"));
+            for (const instance of instances) {
+                console.log(`${styleText(["yellow"], instance.id)}  ${instance.displayName}`);
+            }
+            break;
+        }
     }
 }

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

@@ -1,13 +1,13 @@
 import type { Output } from "../shared/output.ts";
-import type { ValidationOptions } from "./index.ts";
+import type { DefaultTSONDBTypes, ValidationOptions } from "./index.ts";
 import type { EntityDecl } from "./schema/dsl/index.ts";
 import type { Schema } from "./schema/index.ts";
 /**
  * The main configuration type for TSONDB.
  */
-export type Config = {
+export type Config<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> = {
     serverOptions?: ServerOptions;
-    schema: Schema;
+    schema: Schema<T>;
     outputs?: Output[];
     /**
      * Default locales for the server/editor and locales used for testing via CLI.

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

@@ -83,8 +83,11 @@ export declare class TSONDB<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
     private constructor();
     /**
      * Creates a new TSONDB instance with the specified options.
+     *
+     * @param options The options for creating the TSONDB instance.
+     * @param skipReferenceCache If set to `true`, the reference cache will not be created during initialization. This can speed up the initialization process, but referential integrity checks will not work correctly until the cache is created. This should only be set to `true` if you plan to call `sync()` immediately after initialization.
      */
-    static create<Types extends DefaultTSONDBTypes = DefaultTSONDBTypes>(options: TSONDBOptions<Types>): Promise<TSONDB<Types>>;
+    static create<Types extends DefaultTSONDBTypes = DefaultTSONDBTypes>(options: TSONDBOptions<Types>, skipReferenceCache?: boolean): Promise<TSONDB<Types>>;
     /**
      * Generates outputs based on the provided schema and output configurations.
      */
@@ -218,6 +221,10 @@ export declare class TSONDB<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
             queryLowerCase: string;
         }) => number;
     }>): [string, InstanceContainerOverview][];
+    /**
+     * Retrieves the name of the entity for a given instance ID. If no instance with the provided ID is found, `undefined` is returned.
+     */
+    getEntityNameOfInstanceId(id: string): string | undefined;
     /**
      * Compresses the entire database into a single JSON file at the specified path.
      *

package/dist/src/node/index.js

@@ -21,7 +21,7 @@ import { checkCustomConstraintsForAllEntities } from "./utils/customConstraints.
 import { DatabaseInMemory } from "./utils/databaseInMemory.js";
 import { applyStepsToDisk } from "./utils/databaseOnDisk.js";
 import { getAllInstanceOverviewsByEntityName, getDisplayNameFromEntityInstance, getInstanceOverview, getInstanceOverviewsByEntityName, } from "./utils/displayName.js";
-import { countError, countErrors, getErrorMessageForDisplay, wrapErrorsIfAny, } from "./utils/error.js";
+import { countError, countErrors, getErrorMessageForDisplay, HTTPError, wrapErrorsIfAny, } from "./utils/error.js";
 import { getFileNameForId, writeInstance } from "./utils/files.js";
 import { attachGitStatusToDatabaseInMemory } from "./utils/git.js";
 import { getReferencesToInstances, isReferencedByOtherInstances, } from "./utils/references.js";
@@ -55,7 +55,7 @@ const getGit = async (dataRootPath) => {
         return { git };
     }
 };
-const initData = async (dataRootPath, schema, locales, git, gitStatus) => {
+const initData = async (dataRootPath, schema, locales, git, gitStatus, skipReferenceCache) => {
     debug("loading database into memory ...");
     let data = await DatabaseInMemory.load(dataRootPath, schema.entities);
     debug("done");
@@ -65,9 +65,16 @@ const initData = async (dataRootPath, schema, locales, git, gitStatus) => {
         throw new Error("All provided locales must exist in the database.");
     }
     const serializedDeclarationsByName = Object.fromEntries(schema.resolvedDeclarations.map(decl => [decl.name, serializeNode(decl)]));
-    debug("creating references cache ...");
-    const referencesToInstances = await getReferencesToInstances(data, serializedDeclarationsByName);
-    debug("done");
+    let referencesToInstances;
+    if (!skipReferenceCache) {
+        debug("creating references cache ...");
+        referencesToInstances = await getReferencesToInstances(data, serializedDeclarationsByName);
+        debug("done");
+    }
+    else {
+        debug("skipping references cache creation");
+        referencesToInstances = {};
+    }
     if (git) {
         const status = gitStatus ?? (await git.client.status());
         data = attachGitStatusToDatabaseInMemory(data, dataRootPath, git.root, status);
@@ -87,6 +94,7 @@ export class TSONDB {
     #referencesToInstances;
     #validationOptions;
     #gitWrapper;
+    #locked = false;
     constructor(options) {
         this.#dataRootPath = options.dataRootPath;
         this.#data = options.data;
@@ -103,8 +111,11 @@ export class TSONDB {
     }
     /**
      * Creates a new TSONDB instance with the specified options.
+     *
+     * @param options The options for creating the TSONDB instance.
+     * @param skipReferenceCache If set to `true`, the reference cache will not be created during initialization. This can speed up the initialization process, but referential integrity checks will not work correctly until the cache is created. This should only be set to `true` if you plan to call `sync()` immediately after initialization.
      */
-    static async create(options) {
+    static async create(options, skipReferenceCache = false) {
         const entities = options.schema.entities;
         debug("using data root path: %s", options.dataRootPath);
         await prepareFolders(options.dataRootPath, entities);
@@ -121,7 +132,7 @@ export class TSONDB {
             throw new Error("Schema does not contain a locale entity, locales cannot be provided.");
         }
         const git = gitRoot ? { client: gitClient, root: gitRoot } : undefined;
-        const { data, referencesToInstances } = await initData(options.dataRootPath, options.schema, options.locales ?? [], git, gitStatus);
+        const { data, referencesToInstances } = await initData(options.dataRootPath, options.schema, options.locales ?? [], git, gitStatus, skipReferenceCache);
         return new TSONDB({
             ...options,
             data,
@@ -266,7 +277,7 @@ export class TSONDB {
      * Reloads the data from disk into memory.
      */
     async sync() {
-        const { data, referencesToInstances } = await initData(this.#dataRootPath, this.#schema, this.#locales, this.#git);
+        const { data, referencesToInstances } = await initData(this.#dataRootPath, this.#schema, this.#locales, this.#git, undefined, false);
         this.#data = data;
         this.#referencesToInstances = referencesToInstances;
     }
@@ -277,35 +288,46 @@ export class TSONDB {
      * @throws {Error} when the transaction could not be completed
      */
     async runTransaction(fn) {
-        const getEntity = this.#schema.getEntity.bind(this.#schema);
-        const [txn, res] = fn(new Transaction({
-            data: this.#data,
-            getEntity,
-            referencesToInstances: this.#referencesToInstances,
-            validate: this.#strucurallyValidateInstance.bind(this),
-            localeEntity: this.#schema.localeEntity,
-            steps: [],
-        }));
-        const txtResult = txn.getResult();
-        const { data: newData, referencesToInstances: newRefs, steps } = txtResult;
-        const errors = this.#validate(newData, true);
-        if (errors.length > 0) {
-            throw new AggregateError(errors, "Validation errors occurred");
-        }
-        const diskResult = await applyStepsToDisk(this.#dataRootPath, steps);
-        if (isError(diskResult)) {
-            throw diskResult.error;
+        if (this.#locked) {
+            throw new HTTPError(503, "Another transaction is currently running. Transactions cannot be run concurrently.");
         }
-        if (this.#git) {
-            const status = await this.#git.client.status();
-            const newDbWithUpdatedGit = attachGitStatusToDatabaseInMemory(newData, this.#dataRootPath, this.#git.root, status);
-            this.#data = newDbWithUpdatedGit;
+        this.#locked = true;
+        try {
+            const getEntity = this.#schema.getEntity.bind(this.#schema);
+            const [txn, res] = fn(new Transaction({
+                data: this.#data,
+                getEntity,
+                referencesToInstances: this.#referencesToInstances,
+                validate: this.#strucurallyValidateInstance.bind(this),
+                localeEntity: this.#schema.localeEntity,
+                steps: [],
+            }));
+            const txtResult = txn.getResult();
+            const { data: newData, referencesToInstances: newRefs, steps } = txtResult;
+            const errors = this.#validate(newData, true);
+            if (errors.length > 0) {
+                throw new AggregateError(errors, "Validation errors occurred");
+            }
+            const diskResult = await applyStepsToDisk(this.#dataRootPath, steps);
+            if (isError(diskResult)) {
+                throw diskResult.error;
+            }
+            if (this.#git) {
+                const status = await this.#git.client.status();
+                const newDbWithUpdatedGit = attachGitStatusToDatabaseInMemory(newData, this.#dataRootPath, this.#git.root, status);
+                this.#data = newDbWithUpdatedGit;
+            }
+            else {
+                this.#data = newData;
+            }
+            this.#referencesToInstances = newRefs;
+            this.#locked = false;
+            return res;
         }
-        else {
-            this.#data = newData;
+        catch (error) {
+            this.#locked = false;
+            throw error;
         }
-        this.#referencesToInstances = newRefs;
-        return res;
     }
     /**
      * Creates a new instance in the database.
@@ -495,6 +517,12 @@ export class TSONDB {
         })
             .toSorted(reduceCompare(on(item => item[1].relevance, compareNumber), (a, b) => a[1].displayName.localeCompare(b[1].displayName, a[1].displayNameLocaleId)));
     }
+    /**
+     * Retrieves the name of the entity for a given instance ID. If no instance with the provided ID is found, `undefined` is returned.
+     */
+    getEntityNameOfInstanceId(id) {
+        return this.#data.getEntityNameOfInstanceId(id);
+    }
     /**
      * Compresses the entire database into a single JSON file at the specified path.
      *

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

@@ -21,4 +21,5 @@ export declare class DatabaseInMemory<EM extends AnyEntityMap = RegisteredEntity
     setInstanceContainerOfEntityById(entityName: Extract<keyof EM, string>, instance: InstanceContainer): [DatabaseInMemory<EM>, oldInstance: InstanceContent | undefined];
     deleteInstanceContainerOfEntityById(entityName: Extract<keyof EM, string>, instanceId: string): [DatabaseInMemory<EM>, oldInstance: InstanceContent | undefined];
     map(fn: (instances: Dictionary<InstanceContainer>, entityName: Extract<keyof EM, string>) => Dictionary<InstanceContainer>): DatabaseInMemory<EM>;
+    getEntityNameOfInstanceId(id: string): Extract<keyof EM, string> | undefined;
 }

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

@@ -110,4 +110,7 @@ export class DatabaseInMemory {
     map(fn) {
         return new DatabaseInMemory(this.#data.map(fn));
     }
+    getEntityNameOfInstanceId(id) {
+        return this.#data.findKey(instances => instances.has(id));
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.19.3",
+  "version": "0.19.6",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -48,7 +48,7 @@
     "typescript-eslint": "^8.54.0"
   },
   "dependencies": {
-    "@elyukai/utils": "^0.2.0",
+    "@elyukai/utils": "^0.2.1",
     "@preact/signals": "^2.7.0",
     "debug": "^4.4.3",
     "express": "^5.2.1",