tsondb 0.21.1 → 0.21.2

package/dist/src/node/transaction.js

@@ -33,6 +33,27 @@ const checkDeleteInstancePossible = (referencesToInstances, instanceId) => {
         throw new HTTPError(400, "Cannot delete instance that is referenced by other instances");
     }
 };
+/**
+ * @throws {HTTPError}
+ */
+const checkCreateSingletonInstancePossible = (validate, databaseInMemory, entity, instanceContent) => {
+    if (databaseInMemory.hasInstanceOfSingletonEntity(entity.name)) {
+        throw new HTTPError(400, `Duplicate instance for singleton entity`);
+    }
+    checkUpdateSingletonInstancePossible(validate, entity, instanceContent);
+};
+/**
+ * @throws {HTTPError}
+ */
+const checkUpdateSingletonInstancePossible = (validate, entity, instanceContent) => {
+    const validationErrors = validate(entity, instanceContent);
+    if (validationErrors.length > 0) {
+        throw new HTTPError(400, validationErrors.map(getErrorMessageForDisplay).join("\n\n"));
+    }
+};
+const checkDeleteSingletonInstancePossible = () => {
+    // cannot be referenced and does not have any integration into other areas, so no checks needed
+};
 export class Transaction {
     #values;
     constructor(values) {
@@ -115,6 +136,78 @@ export class Transaction {
             { id: instanceId, content: oldInstance },
         ];
     }
+    createSingletonInstance(entity, instanceContent) {
+        const { data, steps, referencesToInstances, getEntity, validate } = this.#values;
+        checkCreateSingletonInstancePossible(validate, data, entity, instanceContent);
+        const [updatedDb] = data.setInstanceContainerOfSingletonEntity(entity.name, {
+            content: instanceContent,
+        });
+        const updatedRefs = updateReferencesToInstances(getEntity, referencesToInstances, entity.name, entity.name, undefined, instanceContent);
+        const step = {
+            kind: "createSingleton",
+            entity,
+            instanceContent,
+        };
+        return [
+            new Transaction({
+                ...this.#values,
+                data: updatedDb,
+                steps: [...steps, step],
+                referencesToInstances: updatedRefs,
+            }),
+            { content: instanceContent },
+        ];
+    }
+    updateSingletonInstance(entity, instanceContent) {
+        const { data, steps, referencesToInstances, getEntity, validate } = this.#values;
+        checkUpdateSingletonInstancePossible(validate, entity, instanceContent);
+        const [updatedDb, oldInstance] = data.setInstanceContainerOfSingletonEntity(entity.name, {
+            content: instanceContent,
+        });
+        if (oldInstance === undefined) {
+            throw new HTTPError(400, `Singleton instance of entity "${entity.name}" did not yet exist`);
+        }
+        const updatedRefs = updateReferencesToInstances(getEntity, referencesToInstances, entity.name, entity.name, oldInstance, instanceContent);
+        const step = {
+            kind: "updateSingleton",
+            entity,
+            instanceContent,
+            oldInstance,
+        };
+        return [
+            new Transaction({
+                ...this.#values,
+                data: updatedDb,
+                steps: [...steps, step],
+                referencesToInstances: updatedRefs,
+            }),
+            { content: instanceContent },
+        ];
+    }
+    deleteSingletonInstance(entity) {
+        const { data, steps, referencesToInstances, getEntity } = this.#values;
+        checkDeleteSingletonInstancePossible();
+        const [updatedDb, oldInstance] = data.deleteInstanceContainerOfSingletonEntity(entity.name);
+        if (oldInstance === undefined) {
+            // instance did not exist
+            throw new Error("Instance did not exist");
+        }
+        const updatedRefs = updateReferencesToInstances(getEntity, referencesToInstances, entity.name, entity.name, oldInstance, undefined);
+        const step = {
+            kind: "deleteSingleton",
+            entity,
+            oldInstance,
+        };
+        return [
+            new Transaction({
+                ...this.#values,
+                data: updatedDb,
+                steps: [...steps, step],
+                referencesToInstances: updatedRefs,
+            }),
+            { content: oldInstance },
+        ];
+    }
     /**
      * @package
      */

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

@@ -1,16 +1,17 @@
 import { type Result } from "@elyukai/utils/result";
 import type { InstanceContent } from "../../shared/utils/instances.ts";
-import type { DefaultTSONDBTypes, EntityName } from "../index.ts";
-import { type EntityDecl } from "../schema/dsl/index.ts";
-import type { AnyChildEntityMap, AnyEntityMap, GetAllChildInstanceContainersForParent, GetAllInstanceContainers, GetAllInstances, GetDisplayName, GetDisplayNameAndId, GetEntityByName, GetInstanceById, GetInstanceOverviewOfEntityById, RegisteredChildEntityMap, RegisteredEntity, RegisteredEntityMap, RegisteredEnumOrTypeAlias } from "../schema/generatedTypeHelpers.ts";
+import type { DefaultTSONDBTypes, EntityName, SingletonEntityName } from "../index.ts";
+import { type EntityDecl, type SingletonEntityDecl } from "../schema/dsl/index.ts";
+import type { AnyChildEntityMap, AnyEntityMap, AnySingletonEntityMap, GetAllChildInstanceContainersForParent, GetAllInstanceContainers, GetAllInstances, GetDisplayName, GetDisplayNameAndId, GetEntityByName, GetInstanceById, GetInstanceOverviewOfEntityById, GetSingletonInstance, RegisteredChildEntityMap, RegisteredEntity, RegisteredEntityMap, RegisteredEnumOrTypeAlias, RegisteredSingletonEntityMap } from "../schema/generatedTypeHelpers.ts";
 import type { DatabaseInMemory } from "./databaseInMemory.ts";
-export type CustomConstraintHelpers<EM extends AnyEntityMap = RegisteredEntityMap, CEM extends AnyChildEntityMap = RegisteredChildEntityMap> = {
+export type CustomConstraintHelpers<EM extends AnyEntityMap = RegisteredEntityMap, CEM extends AnyChildEntityMap = RegisteredChildEntityMap, SEM extends AnySingletonEntityMap = RegisteredSingletonEntityMap> = {
     getInstanceById: GetInstanceById<EM>;
     getAllInstances: GetAllInstances<EM>;
     getAllInstanceContainers: GetAllInstanceContainers<EM>;
     getAllChildInstancesForParent: GetAllChildInstanceContainersForParent<CEM>;
     getDisplayName: GetDisplayName<EM>;
     getDisplayNameAndId: GetDisplayNameAndId<EM>;
+    getSingletonInstance: GetSingletonInstance<SEM>;
 };
 /**
  * A constraint that can be defined on an entity to enforce custom validation logic.
@@ -71,4 +72,4 @@ export type TypedNestedCustomConstraint<Name extends string, EM extends AnyEntit
  * `AggregateError`s for each entity if there are any violations of any custom
  * constraint.
  */
-export declare const checkCustomConstraintsForAllEntities: <T extends DefaultTSONDBTypes>(getDisplayName: GetDisplayName<T["entityMap"]>, getDisplayNameAndId: GetDisplayNameAndId<T["entityMap"]>, getInstanceOverviewOfEntityById: GetInstanceOverviewOfEntityById<T["entityMap"]>, getEntityByName: GetEntityByName<T["entityMap"]>, data: DatabaseInMemory<T["entityMap"]>, entities: EntityDecl<EntityName<T>>[]) => Result<void, AggregateError>;
+export declare const checkCustomConstraintsForAllEntities: <T extends DefaultTSONDBTypes>(getDisplayName: GetDisplayName<T["entityMap"]>, getDisplayNameAndId: GetDisplayNameAndId<T["entityMap"]>, getInstanceOverviewOfEntityById: GetInstanceOverviewOfEntityById<T["entityMap"]>, getEntityByName: GetEntityByName<T["entityMap"]>, data: DatabaseInMemory<T["entityMap"], T["singletonEntityMap"]>, entities: (EntityDecl<EntityName<T>> | SingletonEntityDecl<SingletonEntityName<T>>)[]) => Result<void, AggregateError>;

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

@@ -1,6 +1,37 @@
 import { error, isError, mapError, ok } from "@elyukai/utils/result";
+import { NodeKind } from "../../shared/schema/Node.js";
 import {} from "../schema/dsl/index.js";
-import { checkCustomConstraints } from "../schema/treeOperations/customConstraints.js";
+import { checkCustomConstraintsInEntityDecl, checkCustomConstraintsInSingletonEntityDecl, } from "../schema/treeOperations/customConstraints.js";
+const collectErrorsForEntity = (data, entity, getInstanceOverviewOfEntityById, helpers) => {
+    switch (entity.kind) {
+        case NodeKind.EntityDecl:
+            return data
+                .getAllInstanceContainersOfEntity(entity.name)
+                .map((instance) => [
+                instance,
+                checkCustomConstraintsInEntityDecl(entity, [instance.id, instance.content], helpers),
+            ])
+                .filter(([, violations]) => violations.length > 0)
+                .map(([instance, violations]) => {
+                const instanceOverview = getInstanceOverviewOfEntityById(entity.name, instance.id);
+                const name = instanceOverview
+                    ? `"${instanceOverview.displayName}" (${instance.id})`
+                    : instance.id;
+                return new AggregateError(violations.map(violation => new Error(violation)), `in instance ${name}`);
+            });
+        case NodeKind.SingletonEntityDecl: {
+            const instance = data.getSingletonInstanceContainerOfEntity(entity.name);
+            if (instance) {
+                return checkCustomConstraintsInSingletonEntityDecl(entity, instance.content, helpers);
+            }
+            else {
+                return [];
+            }
+        }
+        default:
+            return [];
+    }
+};
 /**
  * Checks all custom constraints for all provided entities and their instances.
  *
@@ -16,22 +47,10 @@ export const checkCustomConstraintsForAllEntities = (getDisplayName, getDisplayN
         getAllChildInstancesForParent: data.getAllChildInstanceContainersForParent.bind(data, getEntityByName),
         getDisplayName,
         getDisplayNameAndId,
+        getSingletonInstance: data.getSingletonInstanceOfEntity.bind(data),
     };
     return mapError(entities.reduce((acc, entity) => {
-        const errors = data
-            .getAllInstanceContainersOfEntity(entity.name)
-            .map((instance) => [
-            instance,
-            checkCustomConstraints(entity, [instance.id, instance.content], helpers),
-        ])
-            .filter(([, violations]) => violations.length > 0)
-            .map(([instance, violations]) => {
-            const instanceOverview = getInstanceOverviewOfEntityById(entity.name, instance.id);
-            const name = instanceOverview
-                ? `"${instanceOverview.displayName}" (${instance.id})`
-                : instance.id;
-            return new AggregateError(violations.map(violation => new Error(violation)), `in instance ${name}`);
-        });
+        const errors = collectErrorsForEntity(data, entity, getInstanceOverviewOfEntityById, helpers);
         const aggregate = errors.length > 0 ? new AggregateError(errors, `in entity "${entity.name}"`) : undefined;
         if (isError(acc)) {
             if (aggregate) {

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

@@ -1,25 +1,37 @@
 import { Dictionary } from "@elyukai/utils/dictionary";
-import type { InstanceContainer, InstanceContent } from "../../shared/utils/instances.ts";
-import type { EntityDecl } from "../schema/dsl/index.ts";
-import { type AnyChildEntityMap, type AnyEntityMap, type GetEntityByName, type IdArgsVariant, type RegisteredEntityMap } from "../schema/generatedTypeHelpers.ts";
-export declare class DatabaseInMemory<EM extends AnyEntityMap = RegisteredEntityMap> {
+import type { InstanceContainer, InstanceContent, SingletonInstanceContainer } from "../../shared/utils/instances.ts";
+import type { EntityDecl, SingletonEntityDecl } from "../schema/dsl/index.ts";
+import { type AnyChildEntityMap, type AnyEntityMap, type AnySingletonEntityMap, type GetEntityByName, type IdArgsVariant, type RegisteredEntityMap, type RegisteredSingletonEntityMap } from "../schema/generatedTypeHelpers.ts";
+export declare class DatabaseInMemory<EM extends AnyEntityMap = RegisteredEntityMap, SEM extends AnySingletonEntityMap = RegisteredSingletonEntityMap> {
     #private;
     private constructor();
-    static load<EM extends AnyEntityMap = RegisteredEntityMap>(dataRoot: string, entities: readonly EntityDecl<Extract<keyof EM, string>>[]): Promise<DatabaseInMemory<EM>>;
+    static load<EM extends AnyEntityMap = RegisteredEntityMap, SEM extends AnySingletonEntityMap = RegisteredSingletonEntityMap>(dataRoot: string, entities: readonly EntityDecl<Extract<keyof EM, string>>[], singletonEntities: readonly SingletonEntityDecl<Extract<keyof SEM, string>>[]): Promise<DatabaseInMemory<EM, SEM>>;
     getAllInstanceContainersOfEntity<E extends Extract<keyof EM, string>>(entityName: E): InstanceContainer<EM[E]>[];
     getAllInstancesOfEntity<E extends Extract<keyof EM, string>>(entityName: E): EM[E][];
     getAllInstances(): [entityName: Extract<keyof EM, string>, instances: InstanceContainer[]][];
+    getAllSingletonInstances(): [
+        entityName: Extract<keyof SEM, string>,
+        instance: SingletonInstanceContainer
+    ][];
     getInstanceContainerOfEntityById<E extends Extract<keyof EM, string>>(...args: IdArgsVariant<EM, E>): InstanceContainer<EM[E]> | undefined;
     getInstanceOfEntityById<E extends Extract<keyof EM, string>>(...args: IdArgsVariant<EM, E>): EM[E] | undefined;
+    getSingletonInstanceContainerOfEntity<E extends Extract<keyof SEM, string>>(entityName: E): SingletonInstanceContainer<SEM[E]> | undefined;
+    getSingletonInstanceOfEntity<E extends Extract<keyof SEM, string>>(entityName: E): SEM[E] | undefined;
     hasInstanceOfEntityById<E extends Extract<keyof EM, string>>(...args: IdArgsVariant<EM, E>): boolean;
+    hasInstanceOfSingletonEntity(entityName: Extract<keyof SEM, string>): boolean;
     forEachInstance(fn: (entityName: Extract<keyof EM, string>, instance: InstanceContainer) => Promise<void>, async: true): Promise<void>;
     forEachInstance(fn: (entityName: Extract<keyof EM, string>, instance: InstanceContainer) => void, async?: false): void;
+    forEachSingletonInstance(fn: (entityName: Extract<keyof SEM, string>, instance: SingletonInstanceContainer) => Promise<void>, async: true): Promise<void>;
+    forEachSingletonInstance(fn: (entityName: Extract<keyof SEM, string>, instance: SingletonInstanceContainer) => void, async?: false): void;
     countInstancesOfEntity(entityName: Extract<keyof EM, string>): number;
     get totalSize(): number;
     getAllChildInstanceContainersForParent: <CEM extends AnyChildEntityMap, CE extends Extract<keyof CEM, string>>(getEntityByName: GetEntityByName<EM>, childEntityName: CE, parentId: CEM[CE][2]) => InstanceContainer<CEM[CE][0]>[];
     getAllChildInstancesForParent: <CEM extends AnyChildEntityMap, CE extends Extract<keyof CEM, string>>(getEntityByName: GetEntityByName<EM>, childEntityName: CE, parentId: CEM[CE][2]) => CEM[CE][0][];
-    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>;
+    setInstanceContainerOfEntityById(entityName: Extract<keyof EM, string>, instance: InstanceContainer): [DatabaseInMemory<EM, SEM>, oldInstance: InstanceContent | undefined];
+    setInstanceContainerOfSingletonEntity(entityName: Extract<keyof SEM, string>, instance: SingletonInstanceContainer): [DatabaseInMemory<EM, SEM>, oldInstance: InstanceContent | undefined];
+    deleteInstanceContainerOfEntityById(entityName: Extract<keyof EM, string>, instanceId: string): [DatabaseInMemory<EM, SEM>, oldInstance: InstanceContent | undefined];
+    deleteInstanceContainerOfSingletonEntity(entityName: Extract<keyof SEM, string>): [DatabaseInMemory<EM, SEM>, oldInstance: InstanceContent | undefined];
+    map(fn: (instances: Dictionary<InstanceContainer>, entityName: Extract<keyof EM, string>) => Dictionary<InstanceContainer>): DatabaseInMemory<EM, SEM>;
+    mapSingletons(fn: (instance: SingletonInstanceContainer, entityName: Extract<keyof SEM, string>) => SingletonInstanceContainer): DatabaseInMemory<EM, SEM>;
     getEntityNameOfInstanceId(id: string): Extract<keyof EM, string> | undefined;
 }

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

@@ -3,19 +3,22 @@ import { Dictionary } from "@elyukai/utils/dictionary";
 import { deepEqual } from "@elyukai/utils/equality";
 import { Lazy } from "@elyukai/utils/lazy";
 import child_process from "node:child_process";
-import { readdir, readFile } from "node:fs/promises";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import { platform } from "node:process";
 import { promisify } from "node:util";
 import { normalizedIdArgs, } from "../schema/generatedTypeHelpers.js";
+import { getPathToSingletonInstance, readSingletonInstance } from "./files.js";
 const exec = promisify(child_process.exec);
 const ulimit = platform === "win32" ? 2048 : Number.parseInt((await exec("ulimit -n")).stdout);
 export class DatabaseInMemory {
     #data;
-    constructor(data) {
+    #singletonData;
+    constructor(data, singletonData) {
         this.#data = data;
+        this.#singletonData = singletonData;
     }
-    static async load(dataRoot, entities) {
+    static async load(dataRoot, entities, singletonEntities) {
         return new DatabaseInMemory(Dictionary.fromEntries(await mapAsync(entities, async (entity) => {
             const entityDir = join(dataRoot, entity.name);
             const instanceFileNames = await readdir(entityDir);
@@ -38,7 +41,21 @@ export class DatabaseInMemory {
             }, ulimit);
             const instancesById = Dictionary.fromEntries(instances);
             return [entity.name, instancesById];
-        }, 1)));
+        }, 1)), Dictionary.fromEntries((await mapAsync(singletonEntities, async (singletonEntity) => {
+            const pathToSingletonFile = getPathToSingletonInstance(dataRoot, singletonEntity.name);
+            try {
+                await stat(pathToSingletonFile);
+                return [
+                    singletonEntity.name,
+                    {
+                        content: JSON.parse(await readSingletonInstance(dataRoot, singletonEntity)),
+                    },
+                ];
+            }
+            catch {
+                return [singletonEntity.name, undefined];
+            }
+        }, 1)).filter((pair) => pair[1] !== undefined)));
     }
     getAllInstanceContainersOfEntity(entityName) {
         return (this.#data.getMap(entityName, instances => instances.values()) ?? []);
@@ -49,6 +66,9 @@ export class DatabaseInMemory {
     getAllInstances() {
         return this.#data.entries().map(([entityName, instances]) => [entityName, instances.values()]);
     }
+    getAllSingletonInstances() {
+        return this.#singletonData.entries();
+    }
     getInstanceContainerOfEntityById(...args) {
         const { entityName, id } = normalizedIdArgs(args);
         return this.#data.getMap(entityName, instances => instances.get(id));
@@ -56,10 +76,19 @@ export class DatabaseInMemory {
     getInstanceOfEntityById(...args) {
         return this.getInstanceContainerOfEntityById(...args)?.content;
     }
+    getSingletonInstanceContainerOfEntity(entityName) {
+        return this.#singletonData.get(entityName);
+    }
+    getSingletonInstanceOfEntity(entityName) {
+        return this.getSingletonInstanceContainerOfEntity(entityName)?.content;
+    }
     hasInstanceOfEntityById(...args) {
         const { entityName, id } = normalizedIdArgs(args);
         return this.#data.getMap(entityName, instances => instances.has(id)) ?? false;
     }
+    hasInstanceOfSingletonEntity(entityName) {
+        return this.#singletonData.get(entityName) !== undefined;
+    }
     forEachInstance(...args) {
         const [fn, async] = args;
         if (async) {
@@ -73,10 +102,21 @@ export class DatabaseInMemory {
             });
         }
     }
+    forEachSingletonInstance(...args) {
+        const [fn, async] = args;
+        if (async) {
+            return this.#singletonData.forEach((instance, entityName) => fn(entityName, instance), true);
+        }
+        else {
+            this.#singletonData.forEach((instance, entityName) => {
+                fn(entityName, instance);
+            });
+        }
+    }
     countInstancesOfEntity(entityName) {
         return this.#data.getMap(entityName, instances => instances.size) ?? 0;
     }
-    #totalSize = Lazy.of(() => this.#data.reduce((total, instances) => total + instances.size, 0));
+    #totalSize = Lazy.of(() => this.#data.reduce((total, instances) => total + instances.size, 0) + this.#singletonData.size);
     get totalSize() {
         return this.#totalSize.value;
     }
@@ -94,8 +134,14 @@ export class DatabaseInMemory {
     setInstanceContainerOfEntityById(entityName, instance) {
         const instances = this.#data.get(entityName) ?? Dictionary.empty;
         return [
-            new DatabaseInMemory(this.#data.set(entityName, instances.set(instance.id, instance))),
-            instances.get(instance.id),
+            new DatabaseInMemory(this.#data.set(entityName, instances.set(instance.id, instance)), this.#singletonData),
+            instances.get(instance.id)?.content,
+        ];
+    }
+    setInstanceContainerOfSingletonEntity(entityName, instance) {
+        return [
+            new DatabaseInMemory(this.#data, this.#singletonData.set(entityName, instance)),
+            this.#singletonData.get(entityName)?.content,
         ];
     }
     deleteInstanceContainerOfEntityById(entityName, instanceId) {
@@ -109,13 +155,25 @@ export class DatabaseInMemory {
                     }
                     const remainingInstances = instances.remove(instanceId);
                     return remainingInstances.size === 0 ? undefined : remainingInstances;
-                })),
+                }), this.#singletonData),
+                oldInstance.content,
+            ]
+            : [this, undefined];
+    }
+    deleteInstanceContainerOfSingletonEntity(entityName) {
+        const oldInstance = this.#singletonData.get(entityName);
+        return oldInstance
+            ? [
+                new DatabaseInMemory(this.#data, this.#singletonData.remove(entityName)),
                 oldInstance.content,
             ]
             : [this, undefined];
     }
     map(fn) {
-        return new DatabaseInMemory(this.#data.map(fn));
+        return new DatabaseInMemory(this.#data.map(fn), this.#singletonData);
+    }
+    mapSingletons(fn) {
+        return new DatabaseInMemory(this.#data, this.#singletonData.map(fn));
     }
     getEntityNameOfInstanceId(id) {
         return this.#data.findKey(instances => instances.has(id));

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

@@ -1,28 +1,12 @@
-import { error, isError, ok } from "@elyukai/utils/result";
+import { error, ok } from "@elyukai/utils/result";
 import * as DatabaseFilesystem from "./files.js";
-const setInstanceOnDisk = async (root, entity, instanceId, instanceContent, formatterOptions) => {
-    try {
-        await DatabaseFilesystem.writeInstance(root, entity, instanceId, instanceContent, formatterOptions);
-        return ok();
-    }
-    catch (e) {
-        return error(e);
-    }
-};
-const deleteInstanceOnDisk = async (root, entityName, instanceId) => {
-    try {
-        await DatabaseFilesystem.deleteInstance(root, entityName, instanceId);
-        return ok();
-    }
-    catch (e) {
-        return error(e);
-    }
-};
 const rollbackChanges = async (root, steps, formatterOptions) => {
     for (const step of steps) {
-        const res = await runReverseStepAction(root, step, formatterOptions);
-        if (isError(res)) {
-            return res;
+        try {
+            await runReverseStepAction(root, step, formatterOptions);
+        }
+        catch (e) {
+            return error(e);
         }
     }
     return ok();
@@ -31,29 +15,42 @@ const runStepAction = (root, step, formatterOptions) => {
     switch (step.kind) {
         case "create":
         case "update":
-            return setInstanceOnDisk(root, step.entity, step.instanceId, step.instanceContent, formatterOptions);
+            return DatabaseFilesystem.writeInstance(root, step.entity, step.instanceId, step.instanceContent, formatterOptions);
         case "delete":
-            return deleteInstanceOnDisk(root, step.entity.name, step.instanceId);
+            return DatabaseFilesystem.deleteInstance(root, step.entity.name, step.instanceId);
+        case "createSingleton":
+        case "updateSingleton":
+            return DatabaseFilesystem.writeSingletonInstance(root, step.entity, step.instanceContent, formatterOptions);
+        case "deleteSingleton":
+            return DatabaseFilesystem.deleteSingletonInstance(root, step.entity.name);
     }
 };
 const runReverseStepAction = (root, step, formatterOptions) => {
     switch (step.kind) {
         case "create":
-            return deleteInstanceOnDisk(root, step.entity.name, step.instanceId);
+            return DatabaseFilesystem.deleteInstance(root, step.entity.name, step.instanceId);
         case "update":
-            return setInstanceOnDisk(root, step.entity, step.instanceId, step.oldInstance, formatterOptions);
+            return DatabaseFilesystem.writeInstance(root, step.entity, step.instanceId, step.oldInstance, formatterOptions);
         case "delete":
-            return setInstanceOnDisk(root, step.entity, step.instanceId, step.oldInstance, formatterOptions);
+            return DatabaseFilesystem.writeInstance(root, step.entity, step.instanceId, step.oldInstance, formatterOptions);
+        case "createSingleton":
+            return DatabaseFilesystem.deleteSingletonInstance(root, step.entity.name);
+        case "updateSingleton":
+            return DatabaseFilesystem.writeSingletonInstance(root, step.entity, step.oldInstance, formatterOptions);
+        case "deleteSingleton":
+            return DatabaseFilesystem.writeSingletonInstance(root, step.entity, step.oldInstance, formatterOptions);
     }
 };
 export const applyStepsToDisk = async (root, steps, formatterOptions) => {
     for (let i = 0; i < steps.length; i++) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const step = steps[i];
-        const res = await runStepAction(root, step, formatterOptions);
-        if (isError(res)) {
+        try {
+            await runStepAction(root, step, formatterOptions);
+        }
+        catch (e) {
             await rollbackChanges(root, steps.slice(0, i), formatterOptions);
-            return res;
+            return error(e);
         }
     }
     return ok();

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

@@ -1,9 +1,14 @@
 import type { InstanceContent } from "../../shared/utils/instances.ts";
 import type { FormatterOptions } from "../config.ts";
-import { type EntityDecl } from "../schema/dsl/index.ts";
+import { type EntityDecl, type SingletonEntityDecl } from "../schema/dsl/index.ts";
 export declare const getFileNameForId: (id: string) => string;
+export declare const getSingletonFileName: (entityName: string) => string;
 export declare const getPathToInstance: (dataRoot: string, entityName: string, id: string) => string;
+export declare const getPathToSingletonInstance: (dataRoot: string, entityName: string) => string;
 export declare const readInstance: (dataRoot: string, entity: EntityDecl, id: string) => Promise<string>;
+export declare const readSingletonInstance: (dataRoot: string, entity: SingletonEntityDecl) => Promise<string>;
 export declare const writeInstance: (dataRoot: string, entity: EntityDecl, id: string, instance: InstanceContent, formatterOptions: Partial<FormatterOptions> | undefined) => Promise<void>;
+export declare const writeSingletonInstance: (dataRoot: string, entity: SingletonEntityDecl, instance: InstanceContent, formatterOptions: Partial<FormatterOptions> | undefined) => Promise<void>;
 export declare const deleteInstance: (dataRoot: string, entityName: string, id: string) => Promise<void>;
-export declare const formatInstance: (entity: EntityDecl, instanceContent: InstanceContent, options: Partial<FormatterOptions> | undefined) => string;
+export declare const deleteSingletonInstance: (dataRoot: string, entityName: string) => Promise<void>;
+export declare const formatInstance: (entity: EntityDecl | SingletonEntityDecl, instanceContent: InstanceContent, options: Partial<FormatterOptions> | undefined) => string;

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

@@ -3,12 +3,21 @@ import { join } from "node:path";
 import {} from "../schema/dsl/index.js";
 import { formatValue } from "../schema/treeOperations/format.js";
 export const getFileNameForId = (id) => `${id}.json`;
+export const getSingletonFileName = (entityName) => `${entityName}.json`;
 export const getPathToInstance = (dataRoot, entityName, id) => join(dataRoot, entityName, getFileNameForId(id));
+export const getPathToSingletonInstance = (dataRoot, entityName) => join(dataRoot, getSingletonFileName(entityName));
 export const readInstance = (dataRoot, entity, id) => readFile(getPathToInstance(dataRoot, entity.name, id), {
     encoding: "utf-8",
 });
+export const readSingletonInstance = (dataRoot, entity) => readFile(getPathToSingletonInstance(dataRoot, entity.name), {
+    encoding: "utf-8",
+});
 export const writeInstance = (dataRoot, entity, id, instance, formatterOptions) => writeFile(getPathToInstance(dataRoot, entity.name, id), formatInstance(entity, instance, formatterOptions), {
     encoding: "utf-8",
 });
+export const writeSingletonInstance = (dataRoot, entity, instance, formatterOptions) => writeFile(getPathToSingletonInstance(dataRoot, entity.name), formatInstance(entity, instance, formatterOptions), {
+    encoding: "utf-8",
+});
 export const deleteInstance = (dataRoot, entityName, id) => rm(getPathToInstance(dataRoot, entityName, id));
+export const deleteSingletonInstance = (dataRoot, entityName) => rm(getPathToSingletonInstance(dataRoot, entityName));
 export const formatInstance = (entity, instanceContent, options) => JSON.stringify(formatValue(entity.type.value, instanceContent, {}, options), undefined, 2) + "\n";

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

@@ -4,6 +4,8 @@ import type { AnyEntityMap, GetEntityByName, RegisteredEntityMap } from "../sche
 import { type DatabaseInMemory } from "./databaseInMemory.ts";
 /**
  * A mapping from instance IDs to the list of instance IDs that reference them.
+ *
+ * For single instance entities, the instance ID is the entity name.
  */
 export type ReferencesToInstances = {
     [instanceId: string]: string[];

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

@@ -2,6 +2,7 @@ import { removeAt } from "@elyukai/utils/array/modify";
 import { difference } from "@elyukai/utils/array/sets";
 import { isOk } from "@elyukai/utils/result";
 import { resolve } from "node:path";
+import { getReferencesForSerializedSingletonEntityDecl, } from "../../shared/schema/declarations/SingletonEntityDecl.js";
 import { getReferences } from "../schema/treeOperations/references.js";
 import {} from "./databaseInMemory.js";
 import { WorkerPool } from "./workers.js";
@@ -52,7 +53,11 @@ export const getReferencesToInstances = async (databaseInMemory, serializedDecla
         }
     })));
     await pool.close();
-    const results = separateResults.reduce(mergeReferences, {});
+    const results = separateResults
+        .concat(databaseInMemory
+        .getAllSingletonInstances()
+        .reduce((acc, [entityName, instance]) => addReferences(acc, getReferencesForSerializedSingletonEntityDecl(serializedDeclarationsByName, serializedDeclarationsByName[entityName], instance.content), entityName), {}))
+        .reduce(mergeReferences, {});
     return results;
 };
 export const updateReferencesToInstances = (getEntity, referencesToInstances, entityName, instanceId, oldInstance, newInstance) => {

package/dist/src/shared/api.d.ts

@@ -1,6 +1,8 @@
 import type { SerializedDecl } from "./schema/declarations/Declaration.ts";
-import type { CreatedEntityTaggedInstanceContainerWithChildInstances, EntityTaggedInstanceContainerWithChildInstances, UpdatedEntityTaggedInstanceContainerWithChildInstances } from "./utils/childInstances.ts";
-import type { InstanceContainer, InstanceContainerOverview } from "./utils/instances.ts";
+import type { SerializedEntityDecl } from "./schema/declarations/EntityDecl.ts";
+import type { SerializedSingletonEntityDecl } from "./schema/declarations/SingletonEntityDecl.ts";
+import type { CreatedEntityTaggedInstanceContainerWithChildInstances, EntityTaggedInstanceContainerWithChildInstances, EntityTaggedSingletonInstanceContainer, UpdatedEntityTaggedInstanceContainerWithChildInstances } from "./utils/childInstances.ts";
+import type { InstanceContainer, InstanceContainerOverview, SingletonInstanceContainer } from "./utils/instances.ts";
 export type WebConfig = {
     localeEntityName: string | undefined;
     defaultLocales: string[];
@@ -12,17 +14,36 @@ export type WebConfig = {
 };
 export type GetWebConfigResponseBody = WebConfig;
 export interface GetAllDeclarationsResponseBody<D extends SerializedDecl = SerializedDecl> {
+    declarations: {
+        declaration: D;
+    }[];
+    localeEntity?: string;
+}
+export interface GetAllEntityDeclarationsResponseBody<D extends SerializedEntityDecl = SerializedEntityDecl> {
     declarations: {
         declaration: D;
         instanceCount: number;
     }[];
     localeEntity?: string;
 }
+export interface GetAllSingletonEntityDeclarationsResponseBody<D extends SerializedSingletonEntityDecl = SerializedSingletonEntityDecl> {
+    declarations: {
+        declaration: D;
+        hasInstance: boolean;
+    }[];
+}
 export interface GetDeclarationResponseBody<D extends SerializedDecl = SerializedDecl> {
     declaration: D;
+}
+export interface GetEntityDeclarationResponseBody<D extends SerializedEntityDecl = SerializedEntityDecl> {
+    declaration: D;
     instanceCount: number;
     isLocaleEntity: boolean;
 }
+export interface GetSingletonEntityDeclarationResponseBody<D extends SerializedSingletonEntityDecl = SerializedSingletonEntityDecl> {
+    declaration: D;
+    hasInstance: boolean;
+}
 export interface GetAllInstancesOfEntityResponseBody {
     instances: InstanceContainerOverview[];
     isLocaleEntity: boolean;
@@ -52,6 +73,24 @@ export interface DeleteInstanceOfEntityResponseBody {
     instance: InstanceContainer;
     isLocaleEntity: boolean;
 }
+export interface CreateSingletonInstanceOfEntityRequestBody {
+    instance: EntityTaggedSingletonInstanceContainer;
+}
+export interface CreateSingletonInstanceOfEntityResponseBody {
+    instance: SingletonInstanceContainer;
+}
+export interface GetSingletonInstanceOfEntityResponseBody {
+    instance: SingletonInstanceContainer;
+}
+export interface UpdateSingletonInstanceOfEntityRequestBody {
+    instance: EntityTaggedSingletonInstanceContainer;
+}
+export interface UpdateSingletonInstanceOfEntityResponseBody {
+    instance: SingletonInstanceContainer;
+}
+export interface DeleteSingletonInstanceOfEntityResponseBody {
+    instance: SingletonInstanceContainer;
+}
 export interface GetAllInstancesResponseBody {
     instances: {
         [entity: string]: {