tsondb 0.12.6 → 0.12.7

package/dist/src/node/schema/declarations/EntityDecl.d.ts

@@ -1,28 +1,30 @@
 import { Lazy } from "../../../shared/utils/lazy.ts";
-import type { Leaves } from "../../../shared/utils/object.ts";
 import type { DisplayNameCustomizer } from "../../utils/displayName.ts";
-import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validator } from "../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
 import type { MemberDecl, ObjectType } from "../types/generic/ObjectType.ts";
 import { StringType } from "../types/primitives/StringType.ts";
-import type { AsType } from "../types/Type.ts";
+import type { NestedEntityMapType } from "../types/references/NestedEntityMapType.ts";
 import type { BaseDecl } from "./Declaration.ts";
 import { TypeAliasDecl } from "./TypeAliasDecl.ts";
 export type GenericEntityDisplayName = string | {
     pathToLocaleMap?: string;
     pathInLocaleMap?: string;
 } | null;
-export type EntityDisplayName<T extends TConstraint> = Leaves<AsType<ObjectType<T>>> | {
+export type EntityDisplayName<T extends TConstraint> = PathTo<T, StringType> | {
     /**
      * @default "translations"
      */
-    pathToLocaleMap?: Leaves<AsType<ObjectType<T>>>;
+    pathToLocaleMap?: PathTo<T, NestedEntityMapType>;
     /**
      * @default "name"
      */
     pathInLocaleMap?: string;
 } | null;
 type TConstraint = Record<string, MemberDecl>;
+type PathTo<T extends TConstraint, R> = {
+    [K in keyof T]: T[K] extends MemberDecl<infer V> ? V extends R ? K : R extends V ? string : T[K] extends ObjectType<infer P> ? `${Extract<K, string>}.${PathTo<P, R>}` : never : never;
+}[Extract<keyof T, string>];
 export interface EntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
@@ -31,7 +33,7 @@ export interface EntityDecl<Name extends string = string, T extends TConstraint
     /**
      * @default "name"
      */
-    displayName?: EntityDisplayName<T>;
+    displayName?: GenericEntityDisplayName;
     displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
     isDeprecated?: boolean;
 }
@@ -75,5 +77,5 @@ export declare const addEphemeralUUIDToType: <T extends TConstraint>(decl: Entit
 }>;
 export declare const createEntityIdentifierType: () => StringType;
 export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
-export declare const serializeEntityDecl: Serializer<EntityDecl>;
+export declare const serializeEntityDecl: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(type: EntityDecl<Name, T, FK>) => Serialized<EntityDecl<Name, T, FK>>;
 export declare const getReferencesForEntityDecl: GetReferences<EntityDecl>;

package/dist/src/node/schema/declarations/EntityDecl.js

@@ -49,12 +49,12 @@ export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sou
     name: (decl.name + "_ID"),
     type: createEntityIdentifierType,
 });
-export const serializeEntityDecl = (type) => ({
+export const serializeEntityDecl = ((type) => ({
     ...type,
     type: serializeObjectType(type.type.value),
     displayName: typeof type.displayName === "function"
         ? null
         : type.displayName,
     displayNameCustomizer: type.displayNameCustomizer !== undefined,
-});
+}));
 export const getReferencesForEntityDecl = (decl, value, inDecl) => getReferencesForObjectType(decl.type.value, value, [...inDecl, decl]);

package/dist/src/node/schema/declarations/EnumDecl.d.ts

@@ -1,3 +1,4 @@
+import { type EnumValue } from "../../../shared/schema/declarations/EnumDecl.ts";
 import { Lazy } from "../../../shared/utils/lazy.ts";
 import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidatorOfParamDecl } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
@@ -33,3 +34,4 @@ export declare const resolveTypeArgumentsInEnumDecl: TypeArgumentsResolver<EnumD
 export declare const serializeEnumDecl: Serializer<EnumDecl>;
 export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;
 export declare const cases: <T extends TConstraint>(decl: EnumDecl<string, T>) => EnumCaseDecl<T[keyof T]["type"]>[];
+export declare const getAnyEnumCaseValue: <K extends string, V>(enumValue: { [Key in K]: EnumValue<Key, V>; }[K]) => V;

package/dist/src/node/schema/declarations/EnumDecl.js

@@ -1,3 +1,4 @@
+import { ENUM_DISCRIMINATOR_KEY, } from "../../../shared/schema/declarations/EnumDecl.js";
 import { Lazy } from "../../../shared/utils/lazy.js";
 import { onlyKeys } from "../../../shared/utils/object.js";
 import { NodeKind } from "../Node.js";
@@ -46,3 +47,4 @@ export const serializeEnumDecl = decl => ({
 });
 export const getReferencesForEnumDecl = (decl, value, inDecl) => getReferencesForEnumType(decl.type.value, value, [...inDecl, decl]);
 export const cases = (decl) => Object.values(decl.type.value.values);
+export const getAnyEnumCaseValue = (enumValue) => enumValue[enumValue[ENUM_DISCRIMINATOR_KEY]];

package/dist/src/node/schema/types/Type.d.ts

@@ -25,14 +25,28 @@ type EnumCaseTypeAsType<Case extends string, T extends Type | null> = T extends
 } : {
     kind: Case;
 };
-export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
+type EnumCaseTypeAsDeepType<Case extends string, T extends Type | null> = T extends object ? {
+    kind: Case;
+} & {
+    [AV in Case]: AsDeepType<T>;
+} : {
+    kind: Case;
+};
+type MemberDeclsAsType<P extends Record<string, MemberDecl>> = {
     [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsType<TA> : Decl extends EnumDecl<string, infer EC> ? AsType<EnumType<EC>> : unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
-    [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
+};
+type MemberDeclsAsDeepType<P extends Record<string, MemberDecl>> = {
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsDeepType<P[K]["type"]> : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents -- it does make a difference here
+    AsDeepType<P[K]["type"]> | undefined;
+};
+export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsDeepType<I>[] : T extends ObjectType<infer P> ? MemberDeclsAsDeepType<P> : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsDeepType<TA> : Decl extends EnumDecl<string, infer EC> ? AsDeepType<EnumType<EC>> : unknown : T extends NestedEntityMapType<string, infer TC> ? {
+    [id: string]: MemberDeclsAsDeepType<TC>;
+} : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? never : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+    [Case in keyof EC]: EnumCaseTypeAsDeepType<Case & string, EC[Case]["type"]>;
 }[keyof EC] : never : never;
-export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
-    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? MemberDeclsAsType<P> : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType<string, infer TC> ? {
+    [id: string]: MemberDeclsAsType<TC>;
+} : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
     [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
 }[keyof EC] : never : never;
 export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, unknown> ? ObjectType<{

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

@@ -4,6 +4,7 @@ export const getDisplayNameFromEntityInstance = (entity, instanceContainer, getI
     if (useCustomizer && entity.displayNameCustomizer) {
         const calculatedName = getDisplayNameFromEntityInstance(entity, instanceContainer, getInstanceById, getChildInstancesForInstanceId, locales, defaultName, false);
         return entity.displayNameCustomizer({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment -- otherwise type instiatiation too deep
             instance: instanceContainer.content,
             instanceId: instanceContainer.id,
             instanceDisplayName: calculatedName.name,

package/dist/src/shared/schema/declarations/EntityDecl.d.ts

@@ -1,20 +1,24 @@
-import type { Leaves } from "../../../shared/utils/object.ts";
+import type { GenericEntityDisplayName } from "../../../node/schema/index.ts";
 import { NodeKind, type GetReferencesSerialized, type SerializedNode, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedNestedEntityMapType } from "../types/NestedEntityMapType.ts";
 import { type SerializedMemberDecl, type SerializedObjectType } from "../types/ObjectType.ts";
-import type { SerializedAsType } from "../types/Type.ts";
+import type { SerializedStringType } from "../types/StringType.ts";
 import type { SerializedBaseDecl } from "./Declaration.ts";
-export type SerializedEntityDisplayName<T extends SerializedObjectType> = Leaves<SerializedAsType<T>> | {
+export type SerializedEntityDisplayName<T extends TSerializedConstraint> = SerializedPathTo<T, SerializedStringType> | {
     /**
      * @default "translations"
      */
-    pathToLocaleMap?: Leaves<SerializedAsType<T>>;
+    pathToLocaleMap?: SerializedPathTo<T, SerializedNestedEntityMapType>;
     /**
      * @default "name"
      */
     pathInLocaleMap?: string;
 } | null;
-type TConstraint = Record<string, SerializedMemberDecl>;
-export interface SerializedEntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends SerializedBaseDecl<Name, []> {
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
+type SerializedPathTo<T extends TSerializedConstraint, R> = {
+    [K in keyof T]: T[K] extends SerializedMemberDecl<infer V> ? V extends R ? K : R extends V ? string : T[K] extends SerializedObjectType<infer P> ? `${Extract<K, string>}.${SerializedPathTo<P, R>}` : never : never;
+}[Extract<keyof T, string>];
+export interface SerializedEntityDecl<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends SerializedBaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
     type: SerializedObjectType<T>;
@@ -22,13 +26,13 @@ export interface SerializedEntityDecl<Name extends string = string, T extends TC
     /**
      * @default "name"
      */
-    displayName?: SerializedEntityDisplayName<SerializedObjectType<T>>;
+    displayName?: GenericEntityDisplayName;
     displayNameCustomizer: boolean;
     isDeprecated?: boolean;
 }
 export declare const isSerializedEntityDecl: (node: SerializedNode) => node is SerializedEntityDecl;
-export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
-export declare const isSerializedEntityDeclWithoutParentReference: <Name extends string, T extends TConstraint>(decl: SerializedEntityDecl<Name, T>) => decl is SerializedEntityDecl<Name, T, undefined>;
+export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TSerializedConstraint, FK extends Extract<keyof T, string> | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
+export declare const isSerializedEntityDeclWithoutParentReference: <Name extends string, T extends TSerializedConstraint>(decl: SerializedEntityDecl<Name, T>) => decl is SerializedEntityDecl<Name, T, undefined>;
 export declare const resolveTypeArgumentsInSerializedEntityDecl: SerializedTypeArgumentsResolver<SerializedEntityDecl>;
 export declare const getReferencesForSerializedEntityDecl: GetReferencesSerialized<SerializedEntityDecl>;
 export {};

package/dist/src/shared/utils/object.d.ts

@@ -2,7 +2,7 @@ export declare const sortObjectKeys: (obj: Record<string, unknown>, keys: string
 export declare const sortObjectKeysAlphabetically: (obj: Record<string, unknown>) => Record<string, unknown>;
 export declare const mergeObjects: <T>(obj1: Record<string, T>, obj2: Record<string, T>, solveConflict: (a: T, b: T) => T) => Record<string, T>;
 export type Leaves<T> = T extends object ? {
-    [K in keyof T]: T[K] extends unknown[] ? never : `${Exclude<K, symbol>}${Leaves<T[K]> extends never ? "" : `.${Leaves<T[K]>}`}`;
+    [K in keyof T]: T[K] extends unknown[] ? never : `${Extract<K, string>}${Leaves<T[K]> extends never ? "" : `.${Leaves<T[K]>}`}`;
 }[keyof T] : never;
 export declare const onlyKeys: <T extends object, K extends keyof T>(obj: T, ...keys: K[]) => Pick<T, K>;
 export declare const hasKey: <T extends object, K extends PropertyKey>(obj: T, key: K) => obj is T & { [k in K]: unknown; };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.12.6",
+  "version": "0.12.7",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",