tsondb 0.7.3 → 0.7.4

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

@@ -43,20 +43,22 @@ const checkEntityDisplayNamePaths = (decls, localeEntity) => {
                 if (localeEntity === undefined) {
                     throw new Error(`Display name path "${pathToLocaleMap}" for entity "${decl.name}" requires a defined locale entity.`);
                 }
-                const localeMapAtPath = findTypeAtPath(decl.type.value, pathToLocaleMap.split("."));
+                const localeMapAtPath = findTypeAtPath(decl.type.value, pathToLocaleMap.split("."), {
+                    followTypeAliasIncludes: true,
+                });
                 if (!localeMapAtPath ||
                     !isNestedEntityMapType(localeMapAtPath) ||
                     localeMapAtPath.secondaryEntity.name !== localeEntity.name) {
                     throw new Error(`Display name path "${pathToLocaleMap}" for entity "${decl.name}" does not lead to a nested entity map for the defined locale entity.`);
                 }
-                const typeAtLocaleMapPath = findTypeAtPath(localeMapAtPath.type.value, pathInLocaleMap.split("."));
+                const typeAtLocaleMapPath = findTypeAtPath(localeMapAtPath.type.value, pathInLocaleMap.split("."), { followTypeAliasIncludes: true });
                 if (!typeAtLocaleMapPath || !isStringType(typeAtLocaleMapPath)) {
                     throw new Error(`Display name path "${pathInLocaleMap}" for entity "${decl.name}" does not lead to a value of type string in nested locale map.`);
                 }
             }
             else {
                 const path = displayName.split(".");
-                const typeAtPath = findTypeAtPath(decl.type.value, path);
+                const typeAtPath = findTypeAtPath(decl.type.value, path, { followTypeAliasIncludes: true });
                 if (!typeAtPath || !isStringType(typeAtPath)) {
                     throw new Error(`Display name path "${displayName}" for entity "${decl.name}" does not lead to a value of type string.`);
                 }

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

@@ -1,4 +1,4 @@
-import type { Decl } from "../index.ts";
+import { type Decl } from "../index.ts";
 import type { BaseNode } from "../Node.ts";
 import type { ArrayType } from "./generic/ArrayType.ts";
 import type { EnumType } from "./generic/EnumType.ts";
@@ -23,7 +23,9 @@ export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[]
 export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, unknown> ? ObjectType<{
     [K in keyof T]: T[K] extends MemberDecl ? T[K] : T extends null | undefined ? MemberDecl<AsNode<NonNullable<T[K]>>, false> : MemberDecl<AsNode<T[K]>, true>;
 }> : T extends string ? StringType : T extends number ? FloatType : T extends boolean ? BooleanType : T extends Date ? DateType : never;
-export declare const findTypeAtPath: (type: Type, path: string[]) => Type | undefined;
+export declare const findTypeAtPath: (type: Type, path: string[], options?: {
+    followTypeAliasIncludes?: boolean;
+}) => Type | undefined;
 /**
  * Format the structure of a value to always look the same when serialized as JSON.
  */

package/dist/src/node/schema/types/Type.js

@@ -1,15 +1,16 @@
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
+import { isTypeAliasDecl } from "../index.js";
 import { NodeKind } from "../Node.js";
-import { formatArrayValue } from "./generic/ArrayType.js";
+import { formatArrayValue, isArrayType } from "./generic/ArrayType.js";
 import { formatEnumType } from "./generic/EnumType.js";
-import { formatObjectValue } from "./generic/ObjectType.js";
+import { formatObjectValue, isObjectType } from "./generic/ObjectType.js";
 import { formatBooleanValue } from "./primitives/BooleanType.js";
 import { formatDateValue } from "./primitives/DateType.js";
 import { formatFloatValue } from "./primitives/FloatType.js";
 import { formatIntegerValue } from "./primitives/IntegerType.js";
 import { formatStringValue } from "./primitives/StringType.js";
 import { formatChildEntitiesValue } from "./references/ChildEntitiesType.js";
-import { formatIncludeIdentifierValue } from "./references/IncludeIdentifierType.js";
+import { formatIncludeIdentifierValue, isIncludeIdentifierType, } from "./references/IncludeIdentifierType.js";
 import { formatNestedEntityMapValue } from "./references/NestedEntityMapType.js";
 import { formatReferenceIdentifierValue } from "./references/ReferenceIdentifierType.js";
 import { formatTypeArgumentValue } from "./references/TypeArgumentType.js";
@@ -63,19 +64,24 @@ export function walkTypeNodeTree(callbackFn, type, parentTypes, parentDecl) {
             return assertExhaustive(type);
     }
 }
-export const findTypeAtPath = (type, path) => {
+export const findTypeAtPath = (type, path, options = {}) => {
     const [head, ...tail] = path;
     if (head === undefined) {
         return type;
     }
-    if (type.kind === NodeKind.ObjectType) {
+    if (isObjectType(type)) {
         const prop = type.properties[head];
         if (prop) {
-            return findTypeAtPath(prop.type, tail);
+            return findTypeAtPath(prop.type, tail, options);
         }
     }
-    else if (type.kind === NodeKind.ArrayType && head === "0") {
-        return findTypeAtPath(type.items, path);
+    else if (isArrayType(type) && head === "0") {
+        return findTypeAtPath(type.items, path, options);
+    }
+    else if (isIncludeIdentifierType(type) &&
+        options.followTypeAliasIncludes &&
+        isTypeAliasDecl(type.reference)) {
+        return findTypeAtPath(type.reference.type.value, path, options);
     }
     return undefined;
 };

package/package.json

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