tsondb 0.21.1 → 0.21.2

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

@@ -1,6 +1,7 @@
-import type { DeclarationName, DefaultTSONDBTypes, EntityName } from "../index.ts";
+import type { DeclarationName, DefaultTSONDBTypes, EntityName, SingletonEntityName } from "../index.ts";
 import type { Decl } from "./dsl/declarations/Decl.ts";
 import type { EntityDecl } from "./dsl/declarations/EntityDecl.ts";
+import type { SingletonEntityDecl } from "./dsl/index.ts";
 export declare class Schema<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
     #private;
     constructor(declarations: Decl[], localeEntity?: EntityDecl);
@@ -8,6 +9,10 @@ export declare class Schema<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
     get resolvedEntities(): EntityDecl<EntityName<T>>[];
     getEntity<E extends EntityName<T>>(name: E): EntityDecl<E> | undefined;
     getResolvedEntity<E extends EntityName<T>>(name: E): EntityDecl<E> | undefined;
+    get singletonEntities(): SingletonEntityDecl<SingletonEntityName<T>>[];
+    get resolvedSingletonEntities(): SingletonEntityDecl<SingletonEntityName<T>>[];
+    getSingletonEntity<E extends SingletonEntityName<T>>(name: E): SingletonEntityDecl<E> | undefined;
+    getResolvedSingletonEntity<E extends SingletonEntityName<T>>(name: E): SingletonEntityDecl<E> | undefined;
     get declarations(): Decl[];
     get resolvedDeclarations(): Decl[];
     getDeclaration<E extends DeclarationName<T>>(name: E): Decl<E> | undefined;
@@ -19,6 +24,12 @@ export declare class Schema<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
      * This includes all entity declarations, but not nested entity declarations, as they cannot be referenced directly by their name.
      */
     isEntityName(name: string): name is EntityName<T>;
+    /**
+     * Checks if the given name is a valid singleton entity name in the schema.
+     *
+     * This includes all entity declarations, but not nested entity declarations, as they cannot be referenced directly by their name.
+     */
+    isSingletonEntityName(name: string): name is SingletonEntityName<T>;
     /**
      * Checks if the given name is a valid declaration name in the schema. This includes entity declarations, enum declarations and type alias declarations.
      *

package/dist/src/node/schema/index.js

@@ -8,6 +8,7 @@ import { renderKeyPath } from "../../shared/schema/utils/keyPath.js";
 import { getParameterNames, resolveTypeArgumentsInDecls, walkNodeTree, } from "./dsl/declarations/Decl.js";
 import { isEntityDecl } from "./dsl/declarations/EntityDecl.js";
 import { cases, isEnumDecl } from "./dsl/declarations/EnumDecl.js";
+import { isSingletonEntityDecl } from "./dsl/declarations/SingletonEntityDecl.js";
 import { isChildEntitiesType } from "./dsl/types/ChildEntitiesType.js";
 import { isFloatType } from "./dsl/types/FloatType.js";
 import { isIncludeIdentifierType } from "./dsl/types/IncludeIdentifierType.js";
@@ -23,8 +24,10 @@ const debug = Debug("tsondb:schema");
 export class Schema {
     #declarations;
     #entities;
+    #singletonEntities;
     #resolvedDeclarations;
     #resolvedEntities;
+    #resolvedSingletonEntities;
     #localeEntity;
     #declarationMap;
     #resolvedDeclarationMap;
@@ -58,6 +61,8 @@ export class Schema {
         this.#resolvedDeclarations = resolveTypeArgumentsInDecls(allDeclsWithoutNestedEntities);
         this.#entities = allDeclsWithoutNestedEntities.filter(isEntityDecl);
         this.#resolvedEntities = this.#resolvedDeclarations.filter(isEntityDecl);
+        this.#singletonEntities = allDeclsWithoutNestedEntities.filter(isSingletonEntityDecl);
+        this.#resolvedSingletonEntities = this.#resolvedDeclarations.filter(isSingletonEntityDecl);
         this.#declarationMap = Dictionary.fromEntries(allDeclsWithoutNestedEntities.map(decl => [decl.name, decl]));
         this.#resolvedDeclarationMap = Dictionary.fromEntries(this.#resolvedDeclarations.map(decl => [decl.name, decl]));
         debug("created schema, no integrity violations found");
@@ -76,6 +81,20 @@ export class Schema {
         const decl = this.#resolvedDeclarationMap.get(name);
         return decl && isEntityDecl(decl) ? decl : undefined;
     }
+    get singletonEntities() {
+        return this.#singletonEntities;
+    }
+    get resolvedSingletonEntities() {
+        return this.#resolvedSingletonEntities;
+    }
+    getSingletonEntity(name) {
+        const decl = this.#declarationMap.get(name);
+        return decl && isSingletonEntityDecl(decl) ? decl : undefined;
+    }
+    getResolvedSingletonEntity(name) {
+        const decl = this.#resolvedDeclarationMap.get(name);
+        return decl && isSingletonEntityDecl(decl) ? decl : undefined;
+    }
     get declarations() {
         return this.#declarations;
     }
@@ -99,6 +118,14 @@ export class Schema {
     isEntityName(name) {
         return this.#entities.some(entity => entity.name === name);
     }
+    /**
+     * Checks if the given name is a valid singleton entity name in the schema.
+     *
+     * This includes all entity declarations, but not nested entity declarations, as they cannot be referenced directly by their name.
+     */
+    isSingletonEntityName(name) {
+        return this.#singletonEntities.some(entity => entity.name === name);
+    }
     /**
      * Checks if the given name is a valid declaration name in the schema. This includes entity declarations, enum declarations and type alias declarations.
      *
@@ -234,6 +261,19 @@ const checkChildEntityTypeInEntityDecl = (checkedDecls, entityDecl, decl) => {
         }, decl);
     }
 };
+const checkChildEntityTypeInSingletonEntityDecl = (checkedDecls, entityDecl, decl) => {
+    if (!checkedDecls.has(decl)) {
+        checkedDecls.add(decl);
+        walkNodeTree(node => {
+            if (isIncludeIdentifierType(node)) {
+                checkChildEntityTypeInSingletonEntityDecl(checkedDecls, entityDecl, node.reference);
+            }
+            else if (isChildEntitiesType(node)) {
+                throw new Error(`Child entities type for entity "${node.entity.name}" in entity declaration "${entityDecl.name}" is not allowed in a singleton entity. Use a regular entity instead.`);
+            }
+        }, decl);
+    }
+};
 const checkChildEntityTypes = (localeEntity, decls) => {
     if (localeEntity && localeEntity.parentReferenceKey !== undefined) {
         throw new TypeError(`The locale entity "${localeEntity.name}" cannot be used as a child entity to other entities.`);
@@ -246,6 +286,9 @@ const checkChildEntityTypes = (localeEntity, decls) => {
         if (isEntityDecl(decl)) {
             checkChildEntityTypeInEntityDecl(new Set(), decl, decl);
         }
+        if (isSingletonEntityDecl(decl)) {
+            checkChildEntityTypeInSingletonEntityDecl(new Set(), decl, decl);
+        }
     }
 };
 const checkChildEntitiesProvideCorrectPathToParentReferenceIdentifierType = (decls) => {
@@ -269,6 +312,7 @@ const isDeclarationRecursive = (declToCheck) => {
     const isDeclarationIncludedInNode = (visitedDecls, node) => {
         switch (node.kind) {
             case NodeKind.EntityDecl:
+            case NodeKind.SingletonEntityDecl:
             case NodeKind.EnumDecl:
             case NodeKind.TypeAliasDecl:
                 return visitedDecls.includes(node)

package/dist/src/node/schema/treeOperations/customConstraints.d.ts

@@ -1,5 +1,6 @@
 import type { InstanceContent } from "../../../shared/utils/instances.ts";
 import type { CustomConstraintHelpers } from "../../utils/customConstraints.ts";
 import type { EntityDecl } from "../dsl/declarations/EntityDecl.ts";
+import type { SingletonEntityDecl } from "../dsl/index.ts";
 export declare const checkCustomConstraintsInEntityDecl: (node: EntityDecl, value: [id: string, content: InstanceContent], helpers: CustomConstraintHelpers) => string[];
-export { checkCustomConstraintsInEntityDecl as checkCustomConstraints };
+export declare const checkCustomConstraintsInSingletonEntityDecl: (node: SingletonEntityDecl, value: InstanceContent, helpers: CustomConstraintHelpers) => string[];

package/dist/src/node/schema/treeOperations/customConstraints.js

@@ -1,31 +1,31 @@
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
 import { NodeKind } from "../../../shared/schema/Node.js";
-export const checkCustomConstraintsInEntityDecl = (node, value, helpers) => (node.customConstraints?.({ ...helpers, instanceId: value[0], instanceContent: value[1] }) ?? []).concat(checkCustomConstraints(node.type.value, value, helpers));
-export { checkCustomConstraintsInEntityDecl as checkCustomConstraints };
-const checkCustomConstraints = (node, value, helpers) => {
+export const checkCustomConstraintsInEntityDecl = (node, value, helpers) => (node.customConstraints?.({ ...helpers, instanceId: value[0], instanceContent: value[1] }) ?? []).concat(checkNestedCustomConstraints(node.type.value, value, helpers));
+export const checkCustomConstraintsInSingletonEntityDecl = (node, value, helpers) => (node.customConstraints?.({ ...helpers, instanceId: node.name, instanceContent: value }) ?? []).concat(checkNestedCustomConstraints(node.type.value, value, helpers));
+const checkNestedCustomConstraints = (node, value, helpers) => {
     switch (node.kind) {
         case NodeKind.EnumDecl:
-            return (node.customConstraints?.({ ...helpers, value }) ?? []).concat(checkCustomConstraints(node.type.value, value, helpers));
+            return (node.customConstraints?.({ ...helpers, value }) ?? []).concat(checkNestedCustomConstraints(node.type.value, value, helpers));
         case NodeKind.TypeAliasDecl:
-            return (node.customConstraints?.({ ...helpers, value }) ?? []).concat(checkCustomConstraints(node.type.value, value, helpers));
+            return (node.customConstraints?.({ ...helpers, value }) ?? []).concat(checkNestedCustomConstraints(node.type.value, value, helpers));
         case NodeKind.ArrayType:
             return Array.isArray(value)
-                ? value.flatMap(item => checkCustomConstraints(node.items, item, helpers))
+                ? value.flatMap(item => checkNestedCustomConstraints(node.items, item, helpers))
                 : [];
         case NodeKind.ObjectType:
             return typeof value === "object" && value !== null
                 ? Object.entries(value).flatMap(([key, propValue]) => node.properties[key]
-                    ? checkCustomConstraints(node.properties[key].type, propValue, helpers)
+                    ? checkNestedCustomConstraints(node.properties[key].type, propValue, helpers)
                     : [])
                 : [];
         case NodeKind.TypeArgumentType: {
             throw new TypeError(`type argument "${node.argument.name}" is unresolved. Make sure to resolve all type arguments before checking for nested custom constraints.`);
         }
         case NodeKind.IncludeIdentifierType:
-            return checkCustomConstraints(node.reference, value, helpers);
+            return checkNestedCustomConstraints(node.reference, value, helpers);
         case NodeKind.NestedEntityMapType:
-            return checkCustomConstraints(node.type.value, value, helpers);
+            return checkNestedCustomConstraints(node.type.value, value, helpers);
         case NodeKind.EnumType: {
             if (typeof value !== "object" ||
                 value === null ||
@@ -39,7 +39,7 @@ const checkCustomConstraints = (node, value, helpers) => {
                 node.values[enumCase] !== undefined &&
                 node.values[enumCase].type !== null &&
                 enumCase in value
-                ? checkCustomConstraints(node.values[enumCase].type, value[enumCase], helpers)
+                ? checkNestedCustomConstraints(node.values[enumCase].type, value[enumCase], helpers)
                 : [];
         }
         case NodeKind.BooleanType:

package/dist/src/node/schema/treeOperations/implicitSchema.js

@@ -3,6 +3,7 @@ import { NodeKind } from "../../../shared/schema/Node.js";
 export const getNestedDeclarations = (addedDecls, node, parentDecl) => {
     switch (node.kind) {
         case NodeKind.EntityDecl:
+        case NodeKind.SingletonEntityDecl:
         case NodeKind.EnumDecl:
         case NodeKind.TypeAliasDecl:
             return addedDecls.includes(node)

package/dist/src/node/schema/treeOperations/references.js

@@ -6,6 +6,7 @@ import { resolveTypeArguments } from "./typeResolution.js";
 export const getReferences = (node, value, inDecl) => {
     switch (node.kind) {
         case NodeKind.EntityDecl:
+        case NodeKind.SingletonEntityDecl:
         case NodeKind.EnumDecl:
         case NodeKind.TypeAliasDecl:
             return getReferences(node.type.value, value, [...inDecl, node]);

package/dist/src/node/schema/treeOperations/serialization.d.ts

@@ -1,5 +1,6 @@
 import type { SerializedEntityDecl } from "../../../shared/schema/declarations/EntityDecl.ts";
 import type { SerializedEnumDecl } from "../../../shared/schema/declarations/EnumDecl.ts";
+import type { SerializedSingletonEntityDecl } from "../../../shared/schema/declarations/SingletonEntityDecl.ts";
 import type { SerializedTypeAliasDecl } from "../../../shared/schema/declarations/TypeAliasDecl.ts";
 import { NodeKind } from "../../../shared/schema/Node.js";
 import type { SerializedTypeParameter } from "../../../shared/schema/TypeParameter.ts";
@@ -19,6 +20,7 @@ import type { SerializedTranslationObjectType } from "../../../shared/schema/typ
 import type { SerializedTypeArgumentType } from "../../../shared/schema/types/TypeArgumentType.ts";
 import { type EntityDecl } from "../dsl/declarations/EntityDecl.ts";
 import { type EnumDecl } from "../dsl/declarations/EnumDecl.ts";
+import type { SingletonEntityDecl } from "../dsl/declarations/SingletonEntityDecl.ts";
 import { type TypeAliasDecl } from "../dsl/declarations/TypeAliasDecl.ts";
 import type { Node, Type } from "../dsl/index.ts";
 import { type TypeParameter } from "../dsl/TypeParameter.ts";
@@ -38,6 +40,7 @@ import { type TranslationObjectType } from "../dsl/types/TranslationObjectType.t
 import { type TypeArgumentType } from "../dsl/types/TypeArgumentType.ts";
 export type SerializedNodeMap = {
     [NodeKind.EntityDecl]: [EntityDecl, SerializedEntityDecl];
+    [NodeKind.SingletonEntityDecl]: [EntityDecl, SerializedSingletonEntityDecl];
     [NodeKind.EnumDecl]: [EnumDecl, SerializedEnumDecl];
     [NodeKind.TypeAliasDecl]: [TypeAliasDecl, SerializedTypeAliasDecl];
     [NodeKind.ArrayType]: [ArrayType, SerializedArrayType];
@@ -65,7 +68,7 @@ export type SerializedMemberDeclObject<T extends Record<string, MemberDecl>> = {
 export type SerializedEnumCaseDeclObject<T extends Record<string, EnumCaseDecl>> = {
     [K in keyof T]: T[K] extends EnumCaseDecl<infer CT> ? SerializedEnumCaseDecl<CT extends Type ? Serialized<CT> : null> : never;
 };
-export type Serialized<T extends Node> = T extends EntityDecl<infer Name, infer T, infer FK> ? SerializedEntityDecl<Name, SerializedMemberDeclObject<T>, FK> : T extends EnumDecl<infer Name, infer T, infer Params> ? SerializedEnumDecl<Name, SerializedEnumCaseDeclObject<T>, SerializedTypeParameters<Params>> : T extends TypeAliasDecl<infer Name, infer T, infer Params> ? SerializedTypeAliasDecl<Name, Serialized<T>, SerializedTypeParameters<Params>> : T extends ArrayType<infer T> ? SerializedArrayType<Serialized<T>> : T extends ObjectType<infer T> ? SerializedObjectType<SerializedMemberDeclObject<T>> : T extends BooleanType ? SerializedBooleanType : T extends DateType ? SerializedDateType : T extends FloatType ? SerializedFloatType : T extends IntegerType ? SerializedIntegerType : T extends StringType ? SerializedStringType : T extends TypeArgumentType<infer T> ? SerializedTypeArgumentType<Serialized<T>> : T extends ReferenceIdentifierType ? SerializedReferenceIdentifierType : T extends IncludeIdentifierType<infer Params> ? SerializedIncludeIdentifierType<SerializedTypeParameters<Params>> : T extends NestedEntityMapType<infer Name, infer T> ? SerializedNestedEntityMapType<Name, SerializedMemberDeclObject<T>> : T extends EnumType<infer T> ? SerializedEnumType<SerializedEnumCaseDeclObject<T>> : T extends TypeParameter<infer N, infer C> ? SerializedTypeParameter<N, C extends Type ? Serialized<C> : undefined> : T extends ChildEntitiesType ? SerializedChildEntitiesType : T extends TranslationObjectType<infer E> ? SerializedTranslationObjectType<E> : never;
+export type Serialized<T extends Node> = T extends EntityDecl<infer Name, infer T, infer FK> ? SerializedEntityDecl<Name, SerializedMemberDeclObject<T>, FK> : T extends SingletonEntityDecl<infer Name, infer T> ? SerializedSingletonEntityDecl<Name, SerializedMemberDeclObject<T>> : T extends EnumDecl<infer Name, infer T, infer Params> ? SerializedEnumDecl<Name, SerializedEnumCaseDeclObject<T>, SerializedTypeParameters<Params>> : T extends TypeAliasDecl<infer Name, infer T, infer Params> ? SerializedTypeAliasDecl<Name, Serialized<T>, SerializedTypeParameters<Params>> : T extends ArrayType<infer T> ? SerializedArrayType<Serialized<T>> : T extends ObjectType<infer T> ? SerializedObjectType<SerializedMemberDeclObject<T>> : T extends BooleanType ? SerializedBooleanType : T extends DateType ? SerializedDateType : T extends FloatType ? SerializedFloatType : T extends IntegerType ? SerializedIntegerType : T extends StringType ? SerializedStringType : T extends TypeArgumentType<infer T> ? SerializedTypeArgumentType<Serialized<T>> : T extends ReferenceIdentifierType ? SerializedReferenceIdentifierType : T extends IncludeIdentifierType<infer Params> ? SerializedIncludeIdentifierType<SerializedTypeParameters<Params>> : T extends NestedEntityMapType<infer Name, infer T> ? SerializedNestedEntityMapType<Name, SerializedMemberDeclObject<T>> : T extends EnumType<infer T> ? SerializedEnumType<SerializedEnumCaseDeclObject<T>> : T extends TypeParameter<infer N, infer C> ? SerializedTypeParameter<N, C extends Type ? Serialized<C> : undefined> : T extends ChildEntitiesType ? SerializedChildEntitiesType : T extends TranslationObjectType<infer E> ? SerializedTranslationObjectType<E> : never;
 export type SerializedOf<T extends Node> = SerializedNodeMap[T["kind"]][1];
 export type Serializer<T extends Node = Node> = (node: T) => Serialized<T>;
 export declare const serializeNode: <T extends Node>(node: T) => Serialized<T>;

package/dist/src/node/schema/treeOperations/serialization.js

@@ -30,6 +30,14 @@ export const serializeNode = (node) => {
             };
             return serializedNode;
         }
+        case NodeKind.SingletonEntityDecl: {
+            const serializedNode = {
+                ...node,
+                type: serializeNode(node.type.value),
+                customConstraints: node.customConstraints !== undefined,
+            };
+            return serializedNode;
+        }
         case NodeKind.EnumDecl: {
             const serializedNode = {
                 ...node,

package/dist/src/node/schema/treeOperations/typeResolution.d.ts

@@ -1,6 +1,7 @@
 import { type Decl, type IncludableDeclP } from "../dsl/declarations/Decl.ts";
 import { EntityDecl } from "../dsl/declarations/EntityDecl.ts";
 import { EnumDecl } from "../dsl/declarations/EnumDecl.ts";
+import { SingletonEntityDecl } from "../dsl/declarations/SingletonEntityDecl.ts";
 import { TypeAliasDecl } from "../dsl/declarations/TypeAliasDecl.ts";
 import type { Node, Type } from "../dsl/index.ts";
 import type { TypeParameter } from "../dsl/TypeParameter.ts";
@@ -22,7 +23,9 @@ import type { TranslationObjectType } from "../dsl/types/TranslationObjectType.t
 import { type TypeArgumentType } from "../dsl/types/TypeArgumentType.ts";
 export type NodeWithResolvedTypeArguments<T extends Node | null> = T extends BooleanType | DateType | FloatType | IntegerType | StringType | ReferenceIdentifierType | ChildEntitiesType | TranslationObjectType ? T : T extends EntityDecl<infer N, infer P, infer FK> ? EntityDecl<N, {
     [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
-}, FK> : T extends EnumDecl<infer N, infer V, TypeParameter[]> ? EnumDecl<N, {
+}, FK> : T extends SingletonEntityDecl<infer N, infer P> ? SingletonEntityDecl<N, {
+    [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
+}> : T extends EnumDecl<infer N, infer V, TypeParameter[]> ? EnumDecl<N, {
     [K in keyof V]: V[K] extends EnumCaseDecl<infer CT> ? EnumCaseDecl<NodeWithResolvedTypeArguments<CT>> : never;
 }, [
 ]> : T extends TypeAliasDecl<infer N, infer U, TypeParameter[]> ? TypeAliasDecl<N, NodeWithResolvedTypeArguments<U>, []> : T extends ArrayType<infer I> ? ArrayType<NodeWithResolvedTypeArguments<I>> : T extends EnumType<infer V> ? EnumType<{

package/dist/src/node/schema/treeOperations/typeResolution.js

@@ -3,6 +3,7 @@ import { NodeKind } from "../../../shared/schema/Node.js";
 import { getTypeArgumentsRecord, isDeclWithoutTypeParameters, } from "../dsl/declarations/Decl.js";
 import { EntityDecl } from "../dsl/declarations/EntityDecl.js";
 import { EnumDecl } from "../dsl/declarations/EnumDecl.js";
+import { SingletonEntityDecl } from "../dsl/declarations/SingletonEntityDecl.js";
 import { isTypeAliasDecl, TypeAliasDecl } from "../dsl/declarations/TypeAliasDecl.js";
 import { ArrayType } from "../dsl/types/ArrayType.js";
 import {} from "../dsl/types/BooleanType.js";
@@ -24,6 +25,11 @@ export const resolveTypeArguments = (args, node, inDecl) => {
                 ...node,
                 type: () => resolveTypeArguments({}, node.type.value, [...inDecl, node]),
             });
+        case NodeKind.SingletonEntityDecl:
+            return SingletonEntityDecl(node.sourceUrl, {
+                ...node,
+                type: () => resolveTypeArguments({}, node.type.value, [...inDecl, node]),
+            });
         case NodeKind.EnumDecl:
             return EnumDecl(node.sourceUrl, {
                 name: node.name,

package/dist/src/node/schema/treeOperations/validation.js

@@ -34,6 +34,7 @@ export const createReferenceValidator = (isEntityName, databaseInMemory, useStyl
 export const validateDeclStructuralIntegrity = (helpers, inDecls, decl, typeArgs, value) => {
     switch (decl.kind) {
         case NodeKind.EntityDecl:
+        case NodeKind.SingletonEntityDecl:
             return validateTypeStructuralIntegrity(helpers, inDecls, decl.type.value, value);
         case NodeKind.EnumDecl:
         case NodeKind.TypeAliasDecl:
@@ -286,6 +287,7 @@ export const validateTypeStructuralIntegrity = (helpers, inDecls, type, value) =
 export const validateDeclReferentialIntegrity = (helpers, checkEntityName, checkReferentialIntegrity, inDecls, decl, typeArgs, value) => {
     switch (decl.kind) {
         case NodeKind.EntityDecl:
+        case NodeKind.SingletonEntityDecl:
             return validateTypeReferentialIntegrity(helpers, checkEntityName, checkReferentialIntegrity, inDecls, decl.type.value, value);
         case NodeKind.EnumDecl:
         case NodeKind.TypeAliasDecl:

package/dist/src/node/server/api/declarations.js

@@ -1,8 +1,11 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import Debug from "debug";
 import express from "express";
+import { NodeKind } from "../../../shared/schema/Node.js";
 import { isEntityDecl } from "../../schema/dsl/declarations/EntityDecl.js";
 import { isEnumDecl } from "../../schema/dsl/declarations/EnumDecl.js";
 import { isTypeAliasDecl } from "../../schema/dsl/declarations/TypeAliasDecl.js";
+import { isSingletonEntityDecl } from "../../schema/guards.js";
 import { serializeNode } from "../../schema/treeOperations/serialization.js";
 import { getChildInstances } from "../../utils/childInstances.js";
 import { sendErrorResponse } from "../../utils/error.js";
@@ -14,28 +17,58 @@ declarationsApi.use((req, _res, next) => {
     next();
 });
 declarationsApi.get("/", (req, res) => {
-    let filteredEntities;
     switch (req.query["kind"]) {
-        case "Entity":
-            filteredEntities = req.db.schema.resolvedEntities;
+        case "Entity": {
+            const body = {
+                declarations: req.db.schema.resolvedEntities.map(decl => ({
+                    declaration: serializeNode(decl),
+                    instanceCount: req.db.countInstancesOfEntity(decl.name),
+                })),
+                localeEntity: req.db.schema.localeEntity?.name,
+            };
+            res.json(body);
             break;
-        case "TypeAlias":
-            filteredEntities = req.db.schema.resolvedDeclarations.filter(isTypeAliasDecl);
+        }
+        case "SingletonEntity": {
+            const body = {
+                declarations: req.db.schema.resolvedSingletonEntities.map(decl => ({
+                    declaration: serializeNode(decl),
+                    hasInstance: req.db.hasInstanceOfSingletonEntity(decl.name),
+                })),
+            };
+            res.json(body);
             break;
-        case "Enum":
-            filteredEntities = req.db.schema.resolvedDeclarations.filter(isEnumDecl);
+        }
+        case "TypeAlias": {
+            const body = {
+                declarations: req.db.schema.resolvedDeclarations.filter(isTypeAliasDecl).map(decl => ({
+                    declaration: serializeNode(decl),
+                })),
+                localeEntity: req.db.schema.localeEntity?.name,
+            };
+            res.json(body);
             break;
-        default:
-            filteredEntities = req.db.schema.resolvedDeclarations;
+        }
+        case "Enum": {
+            const body = {
+                declarations: req.db.schema.resolvedDeclarations.filter(isEnumDecl).map(decl => ({
+                    declaration: serializeNode(decl),
+                })),
+                localeEntity: req.db.schema.localeEntity?.name,
+            };
+            res.json(body);
+            break;
+        }
+        default: {
+            const body = {
+                declarations: req.db.schema.resolvedDeclarations.map(decl => ({
+                    declaration: serializeNode(decl),
+                })),
+                localeEntity: req.db.schema.localeEntity?.name,
+            };
+            res.json(body);
+        }
     }
-    const body = {
-        declarations: filteredEntities.map(decl => ({
-            declaration: serializeNode(decl),
-            instanceCount: req.db.countInstancesOfEntity(decl.name),
-        })),
-        localeEntity: req.db.schema.localeEntity?.name,
-    };
-    res.json(body);
 });
 declarationsApi.get("/:name", (req, res) => {
     const decl = req.db.schema.getResolvedDeclaration(req.params.name);
@@ -43,12 +76,36 @@ declarationsApi.get("/:name", (req, res) => {
         res.status(404).send(`Declaration "${req.params.name}" not found`);
         return;
     }
-    const body = {
-        declaration: serializeNode(decl),
-        instanceCount: req.db.countInstancesOfEntity(decl.name),
-        isLocaleEntity: decl === req.db.schema.localeEntity,
-    };
-    res.json(body);
+    switch (decl.kind) {
+        case NodeKind.EntityDecl: {
+            const body = {
+                declaration: serializeNode(decl),
+                instanceCount: req.db.countInstancesOfEntity(decl.name),
+                isLocaleEntity: decl === req.db.schema.localeEntity,
+            };
+            res.json(body);
+            break;
+        }
+        case NodeKind.SingletonEntityDecl: {
+            const body = {
+                declaration: serializeNode(decl),
+                hasInstance: req.db.hasInstanceOfSingletonEntity(decl.name),
+            };
+            res.json(body);
+            break;
+        }
+        case NodeKind.TypeAliasDecl:
+        case NodeKind.EnumDecl: {
+            const body = {
+                declaration: serializeNode(decl),
+            };
+            res.json(body);
+            break;
+        }
+        default: {
+            return assertExhaustive(decl);
+        }
+    }
 });
 declarationsApi.get("/:name/instances", (req, res) => {
     const decl = req.db.schema.getResolvedDeclaration(req.params.name);
@@ -172,3 +229,88 @@ declarationsApi.get("/:name/instances/:id/children", (req, res) => {
     };
     res.json(body);
 });
+declarationsApi.get("/:name/instance", (req, res) => {
+    const decl = req.db.schema.getResolvedDeclaration(req.params.name);
+    if (decl === undefined) {
+        res.status(404).send(`Declaration "${req.params.name}" not found`);
+        return;
+    }
+    if (!isSingletonEntityDecl(decl)) {
+        res.status(400).send(`Declaration "${decl.name}" is not a singleton entity`);
+        return;
+    }
+    const instance = req.db.getSingletonInstanceContainerOfEntity(decl.name);
+    if (instance === undefined) {
+        res.status(404).send(`Singleton instance of entity ${decl.name} not found`);
+        return;
+    }
+    const body = {
+        instance: instance,
+    };
+    res.json(body);
+});
+declarationsApi.post("/:name/instance", async (req, res) => {
+    const decl = req.db.schema.getResolvedDeclaration(req.params.name);
+    if (decl === undefined) {
+        res.status(404).send(`Declaration "${req.params.name}" not found`);
+        return;
+    }
+    if (!isSingletonEntityDecl(decl)) {
+        res.status(400).send(`Declaration "${decl.name}" is not a singleton entity`);
+        return;
+    }
+    const requestBody = req.body;
+    try {
+        const result = await req.db.createSingletonInstance(requestBody.instance.entityName, requestBody.instance.content);
+        const body = {
+            instance: result,
+        };
+        res.json(body);
+    }
+    catch (err) {
+        sendErrorResponse(res, err);
+    }
+});
+declarationsApi.put("/:name/instance", async (req, res) => {
+    const decl = req.db.schema.getResolvedDeclaration(req.params.name);
+    if (decl === undefined) {
+        res.status(404).send(`Declaration "${req.params.name}" not found`);
+        return;
+    }
+    if (!isSingletonEntityDecl(decl)) {
+        res.status(400).send(`Declaration "${decl.name}" is not a singleton entity`);
+        return;
+    }
+    const requestBody = req.body;
+    try {
+        const result = await req.db.updateSingletonInstance(requestBody.instance.entityName, requestBody.instance.content);
+        const body = {
+            instance: result,
+        };
+        res.json(body);
+    }
+    catch (err) {
+        sendErrorResponse(res, err);
+    }
+});
+declarationsApi.delete("/:name/instance", async (req, res) => {
+    const decl = req.db.schema.getResolvedDeclaration(req.params.name);
+    if (decl === undefined) {
+        res.status(404).send(`Declaration "${req.params.name}" not found`);
+        return;
+    }
+    if (!isSingletonEntityDecl(decl)) {
+        res.status(400).send(`Declaration "${decl.name}" is not a singleton entity`);
+        return;
+    }
+    try {
+        const result = await req.db.deleteSingletonInstance(req.params.name);
+        const body = {
+            instance: { content: result },
+        };
+        res.json(body);
+    }
+    catch (err) {
+        sendErrorResponse(res, err);
+    }
+});

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

@@ -1,6 +1,6 @@
-import type { InstanceContainer, InstanceContent } from "../shared/utils/instances.ts";
-import { type EntityDecl } from "./schema/dsl/index.ts";
-import type { AnyEntityMap, GetEntityByName, RegisteredEntityMap } from "./schema/generatedTypeHelpers.ts";
+import type { InstanceContainer, InstanceContent, SingletonInstanceContainer } from "../shared/utils/instances.ts";
+import { type EntityDecl, type SingletonEntityDecl } from "./schema/dsl/index.ts";
+import type { AnyEntityMap, AnySingletonEntityMap, GetEntityByName, GetSingletonEntityByName, RegisteredEntityMap, RegisteredSingletonEntityMap } from "./schema/generatedTypeHelpers.ts";
 import { type DatabaseInMemory } from "./utils/databaseInMemory.ts";
 import { type ReferencesToInstances } from "./utils/references.ts";
 export type TransactionStep = {
@@ -19,22 +19,39 @@ export type TransactionStep = {
     entity: EntityDecl;
     instanceId: string;
     oldInstance: InstanceContent;
+} | {
+    kind: "createSingleton";
+    entity: SingletonEntityDecl;
+    instanceContent: InstanceContent;
+} | {
+    kind: "updateSingleton";
+    entity: SingletonEntityDecl;
+    instanceContent: InstanceContent;
+    oldInstance: InstanceContent;
+} | {
+    kind: "deleteSingleton";
+    entity: SingletonEntityDecl;
+    oldInstance: InstanceContent;
 };
-type TransactionShared<EM extends AnyEntityMap = RegisteredEntityMap> = {
-    data: DatabaseInMemory<EM>;
+type TransactionShared<EM extends AnyEntityMap = RegisteredEntityMap, SEM extends AnySingletonEntityMap = RegisteredSingletonEntityMap> = {
+    data: DatabaseInMemory<EM, SEM>;
     referencesToInstances: ReferencesToInstances;
     steps: TransactionStep[];
     getEntity: GetEntityByName<EM>;
-    validate: (entity: EntityDecl, instanceContent: InstanceContent) => Error[];
+    getSingletonEntity: GetSingletonEntityByName<EM>;
+    validate: (entity: EntityDecl | SingletonEntityDecl, instanceContent: InstanceContent) => Error[];
     localeEntity: EntityDecl | undefined;
 };
 export declare const createNewId: () => `${string}-${string}-${string}-${string}-${string}`;
-export declare class Transaction<EM extends AnyEntityMap = RegisteredEntityMap> {
+export declare class Transaction<EM extends AnyEntityMap = RegisteredEntityMap, SEM extends AnySingletonEntityMap = RegisteredSingletonEntityMap> {
     #private;
-    constructor(values: TransactionShared<EM>);
-    createInstance(entity: EntityDecl<Extract<keyof EM, string>>, instanceContent: InstanceContent, instanceId?: string): [Transaction<EM>, InstanceContainer];
-    updateInstance(entity: EntityDecl<Extract<keyof EM, string>>, instanceId: string, instanceContent: InstanceContent): [Transaction<EM>, InstanceContainer];
-    deleteInstance(entity: EntityDecl<Extract<keyof EM, string>>, instanceId: string): [Transaction<EM>, InstanceContainer];
+    constructor(values: TransactionShared<EM, SEM>);
+    createInstance(entity: EntityDecl<Extract<keyof EM, string>>, instanceContent: InstanceContent, instanceId?: string): [Transaction<EM, SEM>, InstanceContainer];
+    updateInstance(entity: EntityDecl<Extract<keyof EM, string>>, instanceId: string, instanceContent: InstanceContent): [Transaction<EM, SEM>, InstanceContainer];
+    deleteInstance(entity: EntityDecl<Extract<keyof EM, string>>, instanceId: string): [Transaction<EM, SEM>, InstanceContainer];
+    createSingletonInstance(entity: SingletonEntityDecl<Extract<keyof SEM, string>>, instanceContent: InstanceContent): [Transaction<EM, SEM>, SingletonInstanceContainer];
+    updateSingletonInstance(entity: SingletonEntityDecl<Extract<keyof SEM, string>>, instanceContent: InstanceContent): [Transaction<EM, SEM>, SingletonInstanceContainer];
+    deleteSingletonInstance(entity: SingletonEntityDecl<Extract<keyof SEM, string>>): [Transaction<EM, SEM>, SingletonInstanceContainer];
     /**
      * @package
      */