tsondb 0.21.1 → 0.21.3

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

@@ -8,6 +8,7 @@ import type { DisplayNameResult } from "../../shared/utils/displayName.ts";
 import type { InstanceContainer, InstanceContainerOverview, InstanceContent } from "../../shared/utils/instances.ts";
 import type { DeclarationName, DefaultTSONDBTypes } from "../index.ts";
 import type { EntityDecl } from "./dsl/declarations/EntityDecl.ts";
+import type { SingletonEntityDecl } from "./dsl/declarations/SingletonEntityDecl.ts";
 export interface Register {
 }
 export type AnyEntityMap = Record<string, InstanceContent>;
@@ -19,6 +20,15 @@ export type RegisteredEntity<Name extends string, T = Register> = T extends {
         [K in Name]: InstanceContent;
     };
 } ? T["entityMap"][Name] : InstanceContent;
+export type AnySingletonEntityMap = Record<string, InstanceContent>;
+export type RegisteredSingletonEntityMap<T = Register> = T extends {
+    singletonEntityMap: AnySingletonEntityMap;
+} ? T["singletonEntityMap"] : AnySingletonEntityMap;
+export type RegisteredSingletonEntity<Name extends string, T = Register> = T extends {
+    singletonEntityMap: {
+        [K in Name]: InstanceContent;
+    };
+} ? T["singletonEntityMap"][Name] : InstanceContent;
 export type AnyChildEntityMap = Record<string, [
     content: InstanceContent,
     parentKey: string,
@@ -133,6 +143,14 @@ export type GetDisplayNameAndId<T extends AnyEntityMap = RegisteredEntityMap> =
  * A function that retrieves an entity declaration by its name.
  */
 export type GetEntityByName<T extends AnyEntityMap = RegisteredEntityMap> = <E extends Extract<keyof T, string> = Extract<keyof T, string>>(name: E) => EntityDecl<E> | undefined;
+/**
+ * A function that retrieves an entity declaration by its name.
+ */
+export type GetSingletonEntityByName<T extends AnySingletonEntityMap = RegisteredSingletonEntityMap> = <E extends Extract<keyof T, string> = Extract<keyof T, string>>(name: E) => SingletonEntityDecl<E> | undefined;
+/**
+ * A function that retrieves the singleton instance by its entity if available.
+ */
+export type GetSingletonInstance<T extends AnySingletonEntityMap = RegisteredSingletonEntityMap> = <E extends Extract<keyof T, string> = Extract<keyof T, string>>(entity: E) => T[E] | undefined;
 /**
  * A type guard function that checks if a given string is a valid declaration name.
  */

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

@@ -1,6 +1,7 @@
 export { isDecl, isDeclWithoutTypeParameters } from "./dsl/declarations/Decl.ts";
 export { isEntityDecl, isEntityDeclWithParentReference } from "./dsl/declarations/EntityDecl.ts";
 export { isEnumDecl } from "./dsl/declarations/EnumDecl.ts";
+export { isSingletonEntityDecl } from "./dsl/declarations/SingletonEntityDecl.ts";
 export { isTypeAliasDecl } from "./dsl/declarations/TypeAliasDecl.ts";
 export { isArrayType } from "./dsl/types/ArrayType.ts";
 export { isBooleanType } from "./dsl/types/BooleanType.ts";

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

@@ -1,6 +1,7 @@
 export { isDecl, isDeclWithoutTypeParameters } from "./dsl/declarations/Decl.js";
 export { isEntityDecl, isEntityDeclWithParentReference } from "./dsl/declarations/EntityDecl.js";
 export { isEnumDecl } from "./dsl/declarations/EnumDecl.js";
+export { isSingletonEntityDecl } from "./dsl/declarations/SingletonEntityDecl.js";
 export { isTypeAliasDecl } from "./dsl/declarations/TypeAliasDecl.js";
 export { isArrayType } from "./dsl/types/ArrayType.js";
 export { isBooleanType } from "./dsl/types/BooleanType.js";

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

@@ -12,6 +12,7 @@ export const reduceNodes = (reducer, nodes, options = {}) => {
     const reduceNodeTree = (parentNodes, node, collectedResults, reducedDecls) => {
         switch (node.kind) {
             case NodeKind.EntityDecl:
+            case NodeKind.SingletonEntityDecl:
             case NodeKind.EnumDecl:
             case NodeKind.TypeAliasDecl:
                 return reduceNodeTree([node], node.type.value, reducer(parentNodes, node, collectedResults), [...reducedDecls, node]);

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)
@@ -396,6 +440,13 @@ const checkSortOrders = (declarations) => {
                 if (!isValidSortOrderType(type)) {
                     throw TypeError(`type at key path "${renderKeyPath(sortOrder.keyPath)}" is not a valid sort order type (string, integer, or float) in entity "${decl.name}"`);
                 }
+                if (sortOrder.isIndex &&
+                    (!isIntegerType(type) ||
+                        type.maximum !== undefined ||
+                        (typeof type.minimum === "object" && type.minimum.isExclusive) ||
+                        type.multipleOf !== undefined)) {
+                    throw TypeError(`type at key path ${renderKeyPath(sortOrder.keyPath)} is not a valid index sort order type (integer, optional inclusive minimum, no other constraints) in entity "${decl.name}"`);
+                }
             }
             else {
                 // const entityMapType = getType(decl.type.value, sortOrder.entityMapKeyPath)

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

@@ -4,6 +4,7 @@ import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { MessageError, parseMessage, validate } from "messageformat";
 import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
 import { NodeKind } from "../../../shared/schema/Node.js";
+import { wrapErrorsIfAny } from "../../../shared/utils/error.js";
 import { extendsParameterTypes, extractParameterTypeNamesFromMessage, } from "../../../shared/utils/translation.js";
 import { parallelizeErrors } from "../../../shared/utils/validation.js";
 import { validateArrayConstraints } from "../../../shared/validation/array.js";
@@ -12,7 +13,6 @@ import { validateNumberConstraints } from "../../../shared/validation/number.js"
 import { validateObjectConstraints, validateObjectRangeConstraints, validateUnknownKeys, } from "../../../shared/validation/object.js";
 import { validateStringConstraints } from "../../../shared/validation/string.js";
 import {} from "../../utils/databaseInMemory.js";
-import { wrapErrorsIfAny } from "../../utils/error.js";
 import { entity, json, key } from "../../utils/errorFormatting.js";
 import { getTypeArgumentsRecord } from "../dsl/declarations/Decl.js";
 import { createEntityIdentifierType } from "../dsl/declarations/EntityDecl.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: