tsondb 0.21.11 → 0.23.0

package/dist/src/node/index.js

@@ -1,61 +1,21 @@
-import { exists } from "@elyukai/utils/async/node";
-import { on } from "@elyukai/utils/function";
 import { Lazy } from "@elyukai/utils/lazy";
-import { nullableToArray } from "@elyukai/utils/nullable";
-import { compareNumber, reduceCompare } from "@elyukai/utils/ordering";
 import { isError } from "@elyukai/utils/result";
-import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import Debug from "debug";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { findPackageJSON } from "node:module";
-import { join, sep } from "node:path";
-import { stderr } from "node:process";
-import { styleText } from "node:util";
+import { writeFile } from "node:fs/promises";
 import semver from "semver";
 import { simpleGit } from "simple-git";
-import { NodeKind } from "../shared/schema/Node.js";
-import { countError, countErrors, getErrorMessageForDisplay, HTTPError, wrapErrorsIfAny, } from "../shared/utils/error.js";
-import { parallelizeErrors } from "../shared/utils/validation.js";
+import { HTTPError } from "../shared/utils/error.js";
 import { Git } from "./git.js";
-import { getDisplayName, getDisplayNameWithId } from "./schema/detached.js";
-import { isEntityDecl, isEntityDeclWithParentReference } from "./schema/guards.js";
-import { serializeNode } from "./schema/treeOperations/serialization.js";
-import { createEntityNameValidator, createReferenceValidator, validateDeclReferentialIntegrity, validateDeclStructuralIntegrity, } from "./schema/treeOperations/validation.js";
+import { ReadonlyTSONDB } from "./readonly.js";
+import { validateDeclStructuralIntegrity, } from "./schema/treeOperations/validation.js";
+import { createServer } from "./server/index.js";
+import { createCompressedDatabaseFile, getTSONDBVersion, initData, prepareFolders, validate, writeMetaFile, } from "./shared.js";
 import { Transaction } from "./transaction.js";
-import { checkCustomConstraintsForAllEntities } from "./utils/customConstraints.js";
 import { DatabaseInMemory } from "./utils/databaseInMemory.js";
 import { applyStepsToDisk } from "./utils/databaseOnDisk.js";
-import { getAllInstanceOverviewsByEntityName, getDisplayNameFromEntityInstance, getInstanceOverview, getInstanceOverviewsByEntityName, } from "./utils/displayName.js";
-import { formatInstance, getFileNameForId, getSingletonFileName, readInstance, readSingletonInstance, writeInstance, writeSingletonInstance, } from "./utils/files.js";
+import { writeInstance, writeSingletonInstance } from "./utils/files.js";
 import { attachGitStatusToDatabaseInMemory } from "./utils/git.js";
-import { getReferencesToInstances, isReferencedByOtherInstances, } from "./utils/references.js";
-import { checkUniqueConstraintsForAllEntities } from "./utils/unique.js";
-const debug = Debug("tsondb:class");
-const getMetaFilePath = (dataRootPath) => join(dataRootPath, ".meta.json");
-const getTSONDBVersion = async () => {
-    const packageJsonPath = findPackageJSON(".", import.meta.url);
-    if (!packageJsonPath) {
-        throw new Error("Could not find package.json for TSONDB");
-    }
-    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
-    return packageJson.version;
-};
-const readMetaFile = async (dataRootPath) => JSON.parse(await readFile(getMetaFilePath(dataRootPath), "utf-8"));
-const writeMetaFile = async (dataRootPath, meta) => writeFile(getMetaFilePath(dataRootPath), JSON.stringify(meta, null, 2), "utf-8");
-const prepareFolders = async (schemaVersion, dataRootPath, entities) => {
-    await mkdir(dataRootPath, { recursive: true });
-    await Promise.all(entities.map(entity => mkdir(join(dataRootPath, entity.name), { recursive: true })));
-    if (!(await exists(getMetaFilePath(dataRootPath)))) {
-        const newMetaFile = {
-            version: await getTSONDBVersion(),
-            schemaVersion,
-        };
-        await writeMetaFile(dataRootPath, newMetaFile);
-    }
-};
-const generateOutputs = async (schema, outputs) => {
-    await Promise.all(outputs.map(output => output.run(schema)));
-};
+const debug = Debug("tsondb:main");
 const getGit = async (dataRootPath) => {
     const git = simpleGit({ baseDir: dataRootPath });
     if (await git.checkIsRepo()) {
@@ -72,62 +32,20 @@ const getGit = async (dataRootPath) => {
         return { git };
     }
 };
-const checkLocales = (schema, data, locales) => {
-    const { localeEntity } = schema;
-    if (localeEntity &&
-        !locales.every(locale => data.hasInstanceOfEntityById(localeEntity.name, locale))) {
-        throw new Error("All provided locales must exist in the database.");
-    }
-};
-const initData = async (dataRootPath, schema, locales, git, gitStatus, skipReferenceCache) => {
-    debug("loading database into memory ...");
-    let data = await DatabaseInMemory.load(dataRootPath, schema.entities, schema.singletonEntities);
-    debug("done");
-    checkLocales(schema, data, locales);
-    const serializedDeclarationsByName = Object.fromEntries(schema.resolvedDeclarations.map(decl => [decl.name, serializeNode(decl)]));
-    let referencesToInstances = {};
-    if (!skipReferenceCache) {
-        debug("creating references cache ...");
-        referencesToInstances = await getReferencesToInstances(data, serializedDeclarationsByName);
-        debug("done");
-    }
-    else {
-        debug("skipping references cache creation");
-    }
-    if (git) {
-        const status = gitStatus ?? (await git.client.status());
-        data = attachGitStatusToDatabaseInMemory(data, dataRootPath, git.root, status);
-        debug("attached git status to instances");
-    }
-    return { data, referencesToInstances };
-};
 /**
  * The main class for managing a typed JSON database.
  */
-export class TSONDB {
-    #data;
-    #dataRootPath;
-    #schema;
-    #locales;
+export class TSONDB extends ReadonlyTSONDB {
     #git;
-    #referencesToInstances;
-    #validationOptions;
-    #formatterOptions;
     #gitWrapper;
     #locked = false;
     #hooks = {};
     constructor(options) {
-        this.#dataRootPath = options.dataRootPath;
-        this.#data = options.data;
-        this.#schema = options.schema;
-        this.#locales = options.locales ?? [];
+        super(options);
         this.#git = options.git;
-        this.#referencesToInstances = options.referencesToInstances;
-        this.#validationOptions = options.validationOptions;
-        this.#formatterOptions = options.formatterOptions;
         this.#gitWrapper = Lazy.of(() => this.#git
-            ? new Git(this, this.#git.client, this.#git.root, this.#dataRootPath, () => this.#data, (data) => {
-                this.#data = data;
+            ? new Git(this, this.#git.client, this.#git.root, this.dataRootPath, () => this._data, (data) => {
+                this._data = data;
             })
             : undefined);
     }
@@ -154,7 +72,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, skipReferenceCache);
+        const { data, referencesToInstances, meta } = await initData(options.dataRootPath, options.schema, options.locales ?? [], git, gitStatus, skipReferenceCache, false);
         const db = new TSONDB({
             ...options,
             data,
@@ -166,9 +84,9 @@ export class TSONDB {
                 ...options.validationOptions,
             },
         });
-        const metaFile = await readMetaFile(options.dataRootPath);
-        if (metaFile.schemaVersion !== options.schema.version && options.migrationStages) {
-            debug("migrating database from schema version %s to %s", metaFile.schemaVersion, options.schema.version);
+        meta.version = await getTSONDBVersion();
+        if (meta.schemaVersion !== options.schema.version && options.migrationStages) {
+            debug("migrating database from schema version %s to %s", meta.schemaVersion, options.schema.version);
             for (const stage of options.migrationStages) {
                 if (semver.valid(stage.toVersion) === null ||
                     semver.validRange(stage.fromVersion) === null) {
@@ -176,11 +94,13 @@ export class TSONDB {
                 }
             }
             for (const stage of options.migrationStages) {
-                if (semver.satisfies(metaFile.schemaVersion, stage.fromVersion)) {
+                if (semver.satisfies(meta.schemaVersion, stage.fromVersion)) {
                     debug("applying migration stage from %s to %s", stage.fromVersion, stage.toVersion);
                     // oxlint-disable-next-line no-await-in-loop
                     await stage.willMigrate?.(db);
-                    metaFile.schemaVersion = stage.toVersion;
+                    meta.schemaVersion = stage.toVersion;
+                    // oxlint-disable-next-line no-await-in-loop
+                    await writeMetaFile(options.dataRootPath, meta);
                 }
                 else {
                     debug("skipping migration stage from %s to %s", stage.fromVersion, stage.toVersion);
@@ -190,244 +110,41 @@ export class TSONDB {
         else {
             debug("no migration needed, schema version is up to date");
         }
-        metaFile.version = await getTSONDBVersion();
-        metaFile.schemaVersion = options.schema.version;
-        await writeMetaFile(options.dataRootPath, metaFile);
         return db;
     }
-    /**
-     * Generates outputs based on the provided schema and output configurations.
-     */
-    static async generateOutputs(options) {
-        await generateOutputs(options.schema, options.outputs);
-    }
-    /**
-     * Generates outputs based on the current schema and the provided output configurations.
-     */
-    async generateOutputs(outputs) {
-        await generateOutputs(this.#schema, outputs);
-    }
     #strucurallyValidateInstance(entity, instanceContent) {
         const validationContext = {
-            validationOptions: this.#validationOptions,
+            validationOptions: this._validationOptions,
             useStyling: true,
         };
         return validateDeclStructuralIntegrity(validationContext, [], entity, [], instanceContent);
     }
-    #validate(data, options = {}) {
-        const { checkReferentialIntegrity, checkOnlyEntities } = this.#validationOptions;
-        const { skipStructuralValidation = false, logToConsole = true, changedEntities: changedEntityNames, } = options;
-        const entities = [...this.#schema.entities, ...this.#schema.singletonEntities];
-        const getEntity = this.#schema.getEntity.bind(this.#schema);
-        for (const onlyEntity of checkOnlyEntities) {
-            if (!entities.find(entity => entity.name === onlyEntity)) {
-                throw new Error(`Entity "${onlyEntity}" not found in schema`);
-            }
-        }
-        const onlyEntities = checkOnlyEntities.length > 0
-            ? entities.filter(entity => checkOnlyEntities.includes(entity.name))
-            : entities;
-        const changedEntities = changedEntityNames
-            ? entities.filter(entity => changedEntityNames.includes(entity.name))
-            : undefined;
-        const validationContext = {
-            validationOptions: this.#validationOptions,
-            useStyling: true,
-        };
-        const errors = [];
-        const summary = [];
-        const debugAndAddToSummary = (message) => {
-            debug(message);
-            summary.push(message);
-        };
-        if (!skipStructuralValidation) {
-            debug("Checking structural integrity ...");
-            const structureErrors = onlyEntities
-                .flatMap(entity => {
-                switch (entity.kind) {
-                    case NodeKind.EntityDecl:
-                        return parallelizeErrors(data
-                            .getAllInstanceContainersOfEntity(entity.name)
-                            .map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateDeclStructuralIntegrity(validationContext, [], entity, [], instance.content))));
-                    case NodeKind.SingletonEntityDecl: {
-                        const instance = data.getSingletonInstanceContainerOfEntity(entity.name);
-                        if (instance) {
-                            return nullableToArray(wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", getSingletonFileName(entity.name))}"`)}`, validateDeclStructuralIntegrity(validationContext, [], entity, [], instance.content)));
-                        }
-                        return [];
-                    }
-                    default:
-                        return assertExhaustive(entity);
-                }
-            })
-                .toSorted((a, b) => a.message.localeCompare(b.message));
-            if (structureErrors.length > 0) {
-                const errorCount = countErrors(structureErrors);
-                debugAndAddToSummary(`${errorCount.toString()} structural integrity violation${errorCount === 1 ? "" : "s"} found`);
-                errors.push(...structureErrors);
-            }
-            else {
-                debug("No structural integrity violations found");
-            }
-        }
-        if (errors.length === 0) {
-            if (!skipStructuralValidation) {
-                if (checkReferentialIntegrity) {
-                    debug("Checking referential integrity ...");
-                    const entityNameValidator = createEntityNameValidator(this.#schema.isEntityName.bind(this.#schema), true);
-                    const referenceValidator = createReferenceValidator(this.#schema.isEntityName.bind(this.#schema), data, true);
-                    const referenceErrors = onlyEntities
-                        .flatMap(entity => {
-                        switch (entity.kind) {
-                            case NodeKind.EntityDecl:
-                                return parallelizeErrors(data
-                                    .getAllInstanceContainersOfEntity(entity.name)
-                                    .map(instance => wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", join(entity.name, getFileNameForId(instance.id)))}"`)}`, validateDeclReferentialIntegrity(validationContext, entityNameValidator, referenceValidator, [], entity, [], instance.content))));
-                            case NodeKind.SingletonEntityDecl: {
-                                const instance = data.getSingletonInstanceContainerOfEntity(entity.name);
-                                if (instance) {
-                                    return nullableToArray(wrapErrorsIfAny(`in file ${styleText("white", `"${this.#dataRootPath}${sep}${styleText("bold", getSingletonFileName(entity.name))}"`)}`, validateDeclReferentialIntegrity(validationContext, entityNameValidator, referenceValidator, [], entity, [], instance.content)));
-                                }
-                                return [];
-                            }
-                            default:
-                                return assertExhaustive(entity);
-                        }
-                    })
-                        .toSorted((a, b) => a.message.localeCompare(b.message));
-                    if (referenceErrors.length > 0) {
-                        const errorCount = countErrors(referenceErrors);
-                        debugAndAddToSummary(`${errorCount.toString()} referential integrity violation${errorCount === 1 ? "" : "s"} found`);
-                        errors.push(...referenceErrors);
-                    }
-                    else {
-                        debug("No referential integrity violations found");
-                    }
-                }
-                else {
-                    debug("Disabled referential integrity checks, skipping them");
-                }
-            }
-            debug("Checking unique constraints ...");
-            const instanceOverviewsByEntityName = getAllInstanceOverviewsByEntityName(getEntity, data, this.#locales);
-            const uniqueConstraintResult = checkUniqueConstraintsForAllEntities(data, (changedEntities ?? onlyEntities).filter(e => isEntityDecl(e)), instanceOverviewsByEntityName);
-            if (isError(uniqueConstraintResult)) {
-                const errorCount = countError(uniqueConstraintResult.error);
-                debugAndAddToSummary(`${errorCount.toString()} unique constraint violation${errorCount === 1 ? "" : "s"} found`);
-                errors.push(uniqueConstraintResult.error);
-            }
-            else {
-                debug("No unique constraint violations found");
-            }
-            debug("Checking custom constraints ...");
-            const customConstraintResult = checkCustomConstraintsForAllEntities((...args) => getDisplayName(getEntity, this.#locales, data, ...args), (...args) => getDisplayNameWithId(getEntity, this.#locales, data, ...args), (...args) => getInstanceOverview(data.getInstanceContainerOfEntityById.bind(data), data.getAllChildInstanceContainersForParent.bind(data, getEntity), getEntity, this.#locales, args), getEntity, data, entities);
-            if (isError(customConstraintResult)) {
-                const errorCount = countError(customConstraintResult.error);
-                debugAndAddToSummary(`${errorCount.toString()} custom constraint violation${errorCount === 1 ? "" : "s"} found`);
-                errors.push(customConstraintResult.error);
-            }
-            else {
-                debug("No custom constraint violations found");
-            }
-        }
-        else {
-            debugAndAddToSummary("Skipping further checks due to previous structural integrity errors");
-        }
-        if (logToConsole) {
-            console.log(`${data.totalSize.toString()} instance${data.totalSize === 1 ? "" : "s"} checked`);
-            if (errors.length === 0) {
-                console.log(styleText("green", "All instances are valid"));
-            }
-            else {
-                const errorCount = countErrors(errors);
-                console.error(styleText("red", `${errors.map(err => getErrorMessageForDisplay(err)).join("\n\n")}\n`, {
-                    stream: stderr,
-                }));
-                console.error(styleText(["red", "bold"], "Summary", { stream: stderr }));
-                console.error(styleText("red", [
-                    `${errorCount.toString()} validation error${errorCount === 1 ? "" : "s"} found`,
-                    ...summary,
-                ].join("\n"), { stream: stderr }));
-            }
-        }
-        return errors;
-    }
-    /**
-     * Validates the data in the database.
-     *
-     * Returns `true` if the data is valid, `false` otherwise.
-     */
-    validate() {
-        debug("Validating database ...");
-        return this.#validate(this.#data).length === 0;
+    #validate(data, options) {
+        return validate({
+            data,
+            dataRootPath: this.dataRootPath,
+            locales: this.locales,
+            schema: this.schema,
+            validationOptions: this._validationOptions,
+        }, options);
     }
     /**
      * Formats the data on disk according to the current in-memory representation.
      */
     async format() {
         debug("Formatting database ...");
-        await this.#data.forEachInstance(async (entityName, instance) => {
+        await this._data.forEachInstance(async (entityName, instance) => {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const entity = this.#schema.getEntity(entityName);
-            await writeInstance(this.#dataRootPath, entity, instance.id, instance.content, this.#formatterOptions);
+            const entity = this.schema.getEntity(entityName);
+            await writeInstance(this.dataRootPath, entity, instance.id, instance.content, this._formatterOptions);
         }, true);
-        await this.#data.forEachSingletonInstance(async (entityName, instance) => {
+        await this._data.forEachSingletonInstance(async (entityName, instance) => {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const entity = this.#schema.getSingletonEntity(entityName);
-            await writeSingletonInstance(this.#dataRootPath, entity, instance.content, this.#formatterOptions);
+            const entity = this.schema.getSingletonEntity(entityName);
+            await writeSingletonInstance(this.dataRootPath, entity, instance.content, this._formatterOptions);
         }, true);
         debug("All data is formatted");
     }
-    /**
-     * Checks if the data on disk is formatted according to the current in-memory representation.
-     */
-    async checkFormat() {
-        debug("Check database formatting ...");
-        let counter = 0;
-        let total = 0;
-        await this.#data.forEachInstance(async (entityName, instance) => {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const entity = this.#schema.getEntity(entityName);
-            const instanceOnDisk = await readInstance(this.#dataRootPath, entity, instance.id);
-            const currentFormatted = formatInstance(entity, instance.content, this.#formatterOptions);
-            if (instanceOnDisk !== currentFormatted) {
-                console.log(`Instance ${styleText("yellow", instance.id)} of entity ${styleText("cyan", entityName)} is not formatted correctly.`);
-                counter++;
-            }
-            total++;
-        }, true);
-        await this.#data.forEachSingletonInstance(async (entityName, instance) => {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const entity = this.#schema.getSingletonEntity(entityName);
-            const instanceOnDisk = await readSingletonInstance(this.#dataRootPath, entity);
-            const currentFormatted = formatInstance(entity, instance.content, this.#formatterOptions);
-            if (instanceOnDisk !== currentFormatted) {
-                console.log(`Singleton instance of entity ${styleText("cyan", entityName)} is not formatted correctly.`);
-                counter++;
-            }
-            total++;
-        }, true);
-        if (counter === 0) {
-            console.log(styleText("green", `All ${total.toFixed()} instance${total === 1 ? "" : "s"} are formatted correctly`));
-            return true;
-        }
-        else {
-            console.error(styleText("red", `${counter.toFixed()} instance${counter === 1 ? "" : "s"} of ${total.toFixed()} instance${total === 1 ? "" : "s"} are not formatted correctly`, {
-                stream: stderr,
-            }));
-            return false;
-        }
-    }
-    /**
-     * Reloads the data from disk into memory.
-     */
-    async sync() {
-        debug("Syncing with disk ...");
-        const { data, referencesToInstances } = await initData(this.#dataRootPath, this.#schema, this.#locales, this.#git, undefined, false);
-        this.#data = data;
-        this.#referencesToInstances = referencesToInstances;
-        debug("Synced with disk");
-    }
     /**
      * Runs a transaction on the database.
      *
@@ -443,15 +160,15 @@ export class TSONDB {
         this.#hooks["transaction:before"]?.forEach(hook => hook(this));
         this.#locked = true;
         try {
-            const getEntity = this.#schema.getEntity.bind(this.#schema);
-            const getSingletonEntity = this.#schema.getSingletonEntity.bind(this.#schema);
+            const getEntity = this.schema.getEntity.bind(this.schema);
+            const getSingletonEntity = this.schema.getSingletonEntity.bind(this.schema);
             const [txn, res] = fn(new Transaction({
-                data: this.#data,
+                data: this._data,
                 getEntity,
                 getSingletonEntity,
-                referencesToInstances: this.#referencesToInstances,
+                referencesToInstances: this._referencesToInstances,
                 validate: this.#strucurallyValidateInstance.bind(this),
-                localeEntity: this.#schema.localeEntity,
+                localeEntity: this.schema.localeEntity,
                 steps: [],
             }));
             const txtResult = txn.getResult();
@@ -467,7 +184,7 @@ export class TSONDB {
                 throw new AggregateError(errors, "Validation errors occurred");
             }
             debug("Applying changes to disk ...");
-            const diskResult = await applyStepsToDisk(this.#dataRootPath, steps, this.#formatterOptions);
+            const diskResult = await applyStepsToDisk(this.dataRootPath, steps, this._formatterOptions);
             if (isError(diskResult)) {
                 debug("Error applying changes to disk: %s", diskResult.error.message);
                 throw diskResult.error;
@@ -478,15 +195,15 @@ export class TSONDB {
             if (this.#git) {
                 debug("Updating git status ...");
                 const status = await this.#git.client.status();
-                const newDbWithUpdatedGit = attachGitStatusToDatabaseInMemory(newData, this.#dataRootPath, this.#git.root, status);
+                const newDbWithUpdatedGit = attachGitStatusToDatabaseInMemory(newData, this.dataRootPath, this.#git.root, status);
                 debug("Git status updated");
-                this.#data = newDbWithUpdatedGit;
+                this._data = newDbWithUpdatedGit;
             }
             else {
                 debug("No git repository, skipping git status update");
-                this.#data = newData;
+                this._data = newData;
             }
-            this.#referencesToInstances = newRefs;
+            this._referencesToInstances = newRefs;
             this.#locked = false;
             debug("Transaction successful, released lock");
             this.#hooks["transaction:after"]?.forEach(hook => hook(this));
@@ -506,7 +223,7 @@ export class TSONDB {
     async createInstance(entityName, content, id) {
         const res = await this.runTransaction(txn => 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        txn.createInstance(this.#schema.getEntity(entityName), content, id));
+        txn.createInstance(this.schema.getEntity(entityName), content, id));
         return res;
     }
     /**
@@ -517,7 +234,7 @@ export class TSONDB {
     async updateInstance(entityName, id, content) {
         const res = await this.runTransaction(txn => 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        txn.updateInstance(this.#schema.getEntity(entityName), id, content));
+        txn.updateInstance(this.schema.getEntity(entityName), id, content));
         return res;
     }
     /**
@@ -528,7 +245,7 @@ export class TSONDB {
     async deleteInstance(entityName, id) {
         const res = await this.runTransaction(txn => 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        txn.deleteInstance(this.#schema.getEntity(entityName), id));
+        txn.deleteInstance(this.schema.getEntity(entityName), id));
         return res.content;
     }
     /**
@@ -540,7 +257,7 @@ export class TSONDB {
     async createSingletonInstance(entityName, content) {
         const res = await this.runTransaction(txn => 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        txn.createSingletonInstance(this.#schema.getSingletonEntity(entityName), content));
+        txn.createSingletonInstance(this.schema.getSingletonEntity(entityName), content));
         return res;
     }
     /**
@@ -551,7 +268,7 @@ export class TSONDB {
     async updateSingletonInstance(entityName, content) {
         const res = await this.runTransaction(txn => 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        txn.updateSingletonInstance(this.#schema.getSingletonEntity(entityName), content));
+        txn.updateSingletonInstance(this.schema.getSingletonEntity(entityName), content));
         return res;
     }
     /**
@@ -562,7 +279,7 @@ export class TSONDB {
     async deleteSingletonInstance(entityName) {
         const res = await this.runTransaction(txn => 
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        txn.deleteSingletonInstance(this.#schema.getSingletonEntity(entityName)));
+        txn.deleteSingletonInstance(this.schema.getSingletonEntity(entityName)));
         return res.content;
     }
     /**
@@ -576,7 +293,7 @@ export class TSONDB {
         return this.runTransaction(txn => [
             txn.reorderAllInstancesOfEntity(
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            typeof entityName === "string" ? this.#schema.getEntity(entityName) : entityName, newOrder),
+            typeof entityName === "string" ? this.schema.getEntity(entityName) : entityName, newOrder),
             undefined,
         ]);
     }
@@ -590,124 +307,7 @@ export class TSONDB {
     async reorderInstanceOfEntity(entityName, instanceId, newIndex) {
         return this.runTransaction(txn => txn.reorderInstanceOfEntity(
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        typeof entityName === "string" ? this.#schema.getEntity(entityName) : entityName, instanceId, newIndex));
-    }
-    /**
-     * Retrieves an instance of the specified entity by its identifier.
-     */
-    getInstanceOfEntityById(...args) {
-        return this.#data.getInstanceContainerOfEntityById(...args)?.content;
-    }
-    /**
-     * Retrieves the instance container of the specified entity by its identifier.
-     */
-    getInstanceContainerOfEntityById(...args) {
-        return this.#data.getInstanceContainerOfEntityById(...args);
-    }
-    /**
-     * Retrieves the overview of an instance of the specified entity by its identifier.
-     */
-    getInstanceOverviewOfEntityById(...args) {
-        return getInstanceOverview(this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), this.#schema.getEntity.bind(this.#schema), this.#locales, args);
-    }
-    /**
-     * Retrieves all instances of the specified entity.
-     */
-    getAllInstancesOfEntity(entityName) {
-        return this.#data.getAllInstanceContainersOfEntity(entityName).map(ic => ic.content);
-    }
-    /**
-     * Retrieves all instance containers of the specified entity.
-     */
-    getAllInstanceContainersOfEntity(entityName) {
-        return this.#data.getAllInstanceContainersOfEntity(entityName);
-    }
-    /**
-     * Retrieves all instance overviews of the specified entity.
-     */
-    getAllInstanceOverviewsOfEntity(entity) {
-        const normEntity = typeof entity === "object" ? entity : this.#schema.getEntity(entity);
-        if (!normEntity) {
-            return [];
-        }
-        return getInstanceOverviewsByEntityName(this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), this.#schema.getEntity.bind(this.#schema), normEntity, this.getAllInstanceContainersOfEntity(normEntity.name), this.#locales);
-    }
-    /**
-     * Retrieves an instance of the specified entity by its identifier.
-     */
-    getSingletonInstanceOfEntity(entityName) {
-        return this.#data.getSingletonInstanceOfEntity(entityName);
-    }
-    /**
-     * Retrieves the instance container of the specified entity by its identifier.
-     */
-    getSingletonInstanceContainerOfEntity(entityName) {
-        return this.#data.getSingletonInstanceContainerOfEntity(entityName);
-    }
-    /**
-     * Counts the number of instances registered for the specified entity.
-     */
-    countInstancesOfEntity(entityName) {
-        return this.#data.countInstancesOfEntity(entityName);
-    }
-    /**
-     * Returns whether the singleton entity has an instance.
-     */
-    hasInstanceOfSingletonEntity(entityName) {
-        return this.#data.hasInstanceOfSingletonEntity(entityName);
-    }
-    /**
-     * Retrieves overviews for all instances in the database, grouped by entity name.
-     */
-    getAllInstanceOverviews() {
-        return getAllInstanceOverviewsByEntityName(this.#schema.getEntity.bind(this.#schema), this.#data, this.#locales);
-    }
-    /**
-     * Retrieves all instance containers of the specified child entity for a given parent instance.
-     */
-    getAllChildInstanceContainersForParent(childEntityName, parentId) {
-        return this.#data.getAllChildInstanceContainersForParent(this.#schema.getEntity.bind(this.#schema), childEntityName, parentId);
-    }
-    /**
-     * Displays the name of an entity instance including its ID. If no display name is found, `undefined` is returned.
-     */
-    getDisplayName(...args) {
-        return getDisplayName(this.#schema.getEntity.bind(this.#schema), this.#locales, this.#data, ...args);
-    }
-    /**
-     * Displays the name of an entity instance including its ID. If no display name is found, only the ID is returned.
-     */
-    getDisplayNameWithId(...args) {
-        return getDisplayNameWithId(this.#schema.getEntity.bind(this.#schema), this.#locales, this.#data, ...args);
-    }
-    /**
-     * Checks if a given instance is referenced by other instances in the database.
-     *
-     * If `otherInstancesToDelete` is provided, those instances will be excluded from the check. This can be useful when planning to delete multiple instances at once and wanting to ignore references from those instances.
-     */
-    isReferencedByOtherInstances(instance, otherInstancesToDelete) {
-        return isReferencedByOtherInstances(this.#referencesToInstances, instance, otherInstancesToDelete);
-    }
-    /**
-     * The configured locales for this TSONDB instance.
-     */
-    get locales() {
-        return this.#locales;
-    }
-    /**
-     * Sets the locales for this TSONDB instance.
-     *
-     * The provided locales must exist in the database if a locale entity is defined in the schema.
-     */
-    setLocales(locales) {
-        checkLocales(this.#schema, this.#data, locales);
-        this.#locales = locales;
-    }
-    /**
-     * The loaded schema for this TSONDB instance.
-     */
-    get schema() {
-        return this.#schema;
+        typeof entityName === "string" ? this.schema.getEntity(entityName) : entityName, instanceId, newIndex));
     }
     /**
      * The Git wrapper for this TSONDB instance, if a git repository is connected.
@@ -721,73 +321,6 @@ export class TSONDB {
     isGitRepo() {
         return this.#git !== undefined;
     }
-    /**
-     * Searches for instances matching the provided query in their ID or display name.
-     *
-     * The results are sorted by relevance. A custom relevance score function can be provided.
-     */
-    search(query, options = {}) {
-        if (!query || query.trim().length === 0) {
-            return [];
-        }
-        const { getRelevanceScore = ({ id, displayName }) => {
-            const searchableName = displayName.toLowerCase();
-            return id.startsWith(query) || searchableName.startsWith(lowerCaseQuery)
-                ? 1
-                : id.includes(query) || searchableName.includes(lowerCaseQuery)
-                    ? 0.5
-                    : 0;
-        }, } = options;
-        const lowerCaseQuery = query.toLowerCase();
-        return this.#data
-            .getAllInstances()
-            .flatMap(([entityName, instances]) => {
-            const entity = this.#schema.getEntity(entityName);
-            if (entity && isEntityDeclWithParentReference(entity)) {
-                return [];
-            }
-            return instances
-                .map((instance) => {
-                const { name, localeId } = getDisplayNameFromEntityInstance(
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                entity, instance, this.#schema.getEntity.bind(this.#schema), this.getInstanceContainerOfEntityById.bind(this), this.getAllChildInstanceContainersForParent.bind(this), this.#locales);
-                return [
-                    entityName,
-                    {
-                        id: instance.id,
-                        displayName: name,
-                        displayNameLocaleId: localeId,
-                        relevance: getRelevanceScore({
-                            entityName,
-                            id: instance.id,
-                            content: instance.content,
-                            displayName: name,
-                            displayNameLocaleId: localeId,
-                            query,
-                            queryLowerCase: lowerCaseQuery,
-                        }),
-                    },
-                ];
-            })
-                .filter(instance => instance[1].relevance > 0);
-        })
-            .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.
-     *
-     * Instead of storing each instance in its own file, this method serializes the entire database into a single JSON file. This can be useful for backup, transfer or archiving purposes. The resulting file contains all instances organized by entity names. No spaces or indentation are used in the JSON output to minimize file size.
-     * @param path The file path where the compressed database will be saved.
-     */
-    async compressToSingleFile(path) {
-        await writeFile(path, JSON.stringify(this.#data), "utf-8");
-    }
     /**
      * Registers a new hook for the specified trigger. The callback will be invoked whenever the trigger is activated.
      */
@@ -807,5 +340,17 @@ export class TSONDB {
             }
         }
     }
+    /**
+     * Compresses the entire database into a single JSON file at the specified path.
+     *
+     * Instead of storing each instance in its own file, this method serializes the entire database into a single JSON file. This can be useful for backup, transfer or archiving purposes. The resulting file contains all instances organized by entity names. No spaces or indentation are used in the JSON output to minimize file size.
+     * @param path The file path where the compressed database will be saved.
+     * @param indentation Optional. If provided, the JSON output will be formatted with the specified number of spaces for indentation. If not provided, the output will be minified without any extra spaces.
+     */
+    async compressToSingleFile(path, indentation) {
+        await writeFile(path, JSON.stringify(createCompressedDatabaseFile(this._data, this.schema.version), undefined, indentation), "utf-8");
+    }
+    serve(config, callback) {
+        createServer(this, { serverOptions: config, validationOptions: this._validationOptions }, callback);
+    }
 }
-export { createServer } from "./server/index.js";