tsondb 0.17.4 → 0.17.7

package/dist/src/node/renderers/ts/render.d.ts

@@ -12,6 +12,14 @@ export type TypeScriptRendererOptions = {
          * If `true` or a string, generates an object type with all names of entities with parent references as the key and their corresponding generated type as well as their parent reference key as their respective value. Uses `ChildEntityMap` as a default name when using `true` or the string if set to a string.
          */
         childEntityMap: boolean | string;
+        /**
+         * If `true` or a string, generates an object type with all names of the enumerations as the key and their corresponding generated type as their respective value. Uses `EnumMap` as a default name when using `true` or the string if set to a string.
+         */
+        enumMap: boolean | string;
+        /**
+         * If `true` or a string, generates an object type with all names of the type aliases as the key and their corresponding generated type as their respective value. Uses `TypeAliasMap` as a default name when using `true` or the string if set to a string.
+         */
+        typeAliasMap: boolean | string;
     }>;
     addIdentifierToEntities: boolean;
     /**

package/dist/src/node/renderers/ts/render.js

@@ -7,7 +7,8 @@ import { extractParameterTypeNamesFromMessage, mapParameterTypeNames, } from "..
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { asDecl } from "../../schema/declarations/Declaration.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, isEntityDeclWithParentReference, } from "../../schema/declarations/EntityDecl.js";
-import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
+import { isEnumDecl } from "../../schema/declarations/EnumDecl.js";
+import { isTypeAliasDecl, TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
 import { ArrayType } from "../../schema/types/generic/ArrayType.js";
 import { isObjectType } from "../../schema/types/generic/ObjectType.js";
@@ -158,21 +159,18 @@ const renderImports = (currentUrl, imports) => {
         .join(EOL);
     return importsSyntax.length > 0 ? importsSyntax + EOL + EOL : "";
 };
-const renderEntityMapType = (options, declarations) => options.generateHelpers.entityMap
-    ? `export type ${options.generateHelpers.entityMap === true ? "EntityMap" : options.generateHelpers.entityMap} = {${EOL}${prefixLines(getIndentation(options.indentation, 1), declarations
-        .filter(isEntityDecl)
+const renderMapHelperType = (options, declarations, key, defaultName, filterFn, renderKeyFn) => options.generateHelpers[key]
+    ? `export type ${options.generateHelpers[key] === true ? defaultName : options.generateHelpers[key]} = {${EOL}${prefixLines(getIndentation(options.indentation, 1), declarations
+        .filter(filterFn)
         .sort((a, b) => a.name.localeCompare(b.name))
-        .map(decl => `${decl.name}: ${decl.name}`)
-        .join(EOL))}${EOL}}${EOL + EOL}`
-    : "";
-const renderChildEntityMapType = (options, declarations) => options.generateHelpers.childEntityMap
-    ? `export type ${options.generateHelpers.childEntityMap === true ? "ChildEntityMap" : options.generateHelpers.childEntityMap} = {${EOL}${prefixLines(getIndentation(options.indentation, 1), declarations
-        .filter(isEntityDecl)
-        .filter(isEntityDeclWithParentReference)
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .map(decl => `${decl.name}: [${decl.name}, "${decl.parentReferenceKey}", ${decl.name}["${decl.parentReferenceKey}"]]`)
+        .map(renderKeyFn ??
+        (decl => `${decl.name}: ${decl.name}${decl.parameters.length > 0 ? "<" + decl.parameters.map(param => (param.constraint ? renderType(options, param.constraint)[1] : "unknown")).join(", ") + ">" : ""}`))
         .join(EOL))}${EOL}}${EOL + EOL}`
     : "";
+const renderEntityMapType = (options, declarations) => renderMapHelperType(options, declarations, "entityMap", "EntityMap", isEntityDecl);
+const renderChildEntityMapType = (options, declarations) => renderMapHelperType(options, declarations, "childEntityMap", "ChildEntityMap", decl => isEntityDecl(decl) && isEntityDeclWithParentReference(decl), decl => `${decl.name}: [${decl.name}, "${decl.parentReferenceKey}", ${decl.name}["${decl.parentReferenceKey}"]]`);
+const renderEnumMapType = (options, declarations) => renderMapHelperType(options, declarations, "enumMap", "EnumMap", isEnumDecl);
+const renderTypeAliasMapType = (options, declarations) => renderMapHelperType(options, declarations, "typeAliasMap", "TypeAliasMap", isTypeAliasDecl);
 const renderStringableTranslationParameterType = (options) => options.inferTranslationParameters?.format === "mf2"
     ? "export type StringableTranslationParameter = {" +
         EOL +
@@ -230,6 +228,8 @@ export const render = (options = defaultOptions, declarations) => {
     }, declarations));
     return (renderEntityMapType(finalOptions, declarations) +
         renderChildEntityMapType(finalOptions, declarations) +
+        renderEnumMapType(finalOptions, declarations) +
+        renderTypeAliasMapType(finalOptions, declarations) +
         renderStringableTranslationParameterType(finalOptions) +
         (finalOptions.preserveFiles
             ? (declarations[0] === undefined ? "" : renderImports(declarations[0].sourceUrl, imports)) +

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

@@ -18,6 +18,7 @@ import type { SerializedStringType } from "../../shared/schema/types/StringType.
 import type { SerializedTranslationObjectType } from "../../shared/schema/types/TranslationObjectType.ts";
 import type { SerializedTypeArgumentType } from "../../shared/schema/types/TypeArgumentType.ts";
 import type { ValidationOptions } from "../index.ts";
+import type { CustomConstraintHelpers } from "../utils/customConstraints.ts";
 import { type DatabaseInMemory } from "../utils/databaseInMemory.ts";
 import { type Decl, type IncludableDeclP } from "./declarations/Declaration.ts";
 import { type EntityDecl } from "./declarations/EntityDecl.ts";
@@ -121,3 +122,4 @@ export type Serializer<T extends Node = Node> = (node: T) => Serialized<T>;
 export declare const serializeNode: <T extends Node>(node: T) => Serialized<T>;
 export type GetReferences<T extends Node = Node> = (node: T, value: unknown, inDecl: Decl[]) => string[];
 export declare const getReferences: GetReferences;
+export type CustomConstraintValidator<T extends Node = Node, V = unknown> = (node: T, value: V, helpers: CustomConstraintHelpers) => string[];

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

@@ -1,17 +1,19 @@
 import Debug from "debug";
-import { normalizeKeyPath, renderKeyPath, } from "../../shared/schema/declarations/EntityDecl.js";
+import { renderKeyPath } from "../../shared/schema/utils/keyPath.js";
 import { anySame } from "../../shared/utils/array.js";
 import { deepEqual } from "../../shared/utils/compare.js";
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
+import { assertExhaustive, trySafe } from "../../shared/utils/typeSafety.js";
 import { getParameterNames, walkNodeTree } from "./declarations/Declaration.js";
 import { isEntityDecl } from "./declarations/EntityDecl.js";
 import { cases, isEnumDecl } from "./declarations/EnumDecl.js";
 import { getNestedDeclarations, NodeKind } from "./Node.js";
 import { isObjectType } from "./types/generic/ObjectType.js";
+import { isFloatType } from "./types/primitives/FloatType.js";
+import { isIntegerType } from "./types/primitives/IntegerType.js";
 import { isStringType } from "./types/primitives/StringType.js";
 import { isChildEntitiesType } from "./types/references/ChildEntitiesType.js";
 import { isIncludeIdentifierType } from "./types/references/IncludeIdentifierType.js";
-import { isNestedEntityMapType, } from "./types/references/NestedEntityMapType.js";
+import { isNestedEntityMapType } from "./types/references/NestedEntityMapType.js";
 import { isReferenceIdentifierType, } from "./types/references/ReferenceIdentifierType.js";
 import { findTypeAtPath } from "./types/Type.js";
 const debug = Debug("tsondb:schema");
@@ -42,6 +44,18 @@ const checkParameterNamesShadowing = (decls) => {
     }
 };
 const checkEntityDisplayNamePaths = (decls, localeEntity) => {
+    const getType = (type, keyPath) => trySafe(() => {
+        try {
+            return findTypeAtPath(type, keyPath, {
+                followTypeAliasIncludes: true,
+                throwOnPathMismatch: true,
+            });
+        }
+        catch (error) {
+            console.log(error);
+            throw error;
+        }
+    });
     for (const decl of decls) {
         if (isEntityDecl(decl) && decl.instanceDisplayName !== null) {
             const displayName = decl.instanceDisplayName ?? "name";
@@ -54,22 +68,19 @@ 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("."), {
-                    followTypeAliasIncludes: true,
-                });
+                const localeMapAtPath = getType(decl.type.value, pathToLocaleMap);
                 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("."), { followTypeAliasIncludes: true });
+                const typeAtLocaleMapPath = getType(localeMapAtPath.type.value, pathInLocaleMap);
                 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, { followTypeAliasIncludes: true });
+                const typeAtPath = getType(decl.type.value, displayName);
                 if (!typeAtPath || !isStringType(typeAtPath)) {
                     throw new Error(`Display name path "${displayName}" for entity "${decl.name}" does not lead to a value of type string.`);
                 }
@@ -218,43 +229,34 @@ const checkRecursiveGenericTypeAliasesAndEnumerationsAreOnlyParameterizedDirectl
         }, decl);
     }
 };
-const getNodeAtKeyPath = (decl, objectType, keyPath, parent, parentPath = []) => {
-    const [key, ...keyPathRest] = normalizeKeyPath(keyPath);
-    if (key === undefined) {
-        return objectType;
-    }
-    const memberDecl = objectType.properties[key];
-    if (memberDecl === undefined) {
-        throw TypeError(`key "${key}"${parentPath.length === 0 ? "" : " in " + renderKeyPath(parentPath)} in unique constraint of entity "${decl.name}" does not exist in the entity`);
-    }
-    const value = memberDecl.type;
-    const actualValue = isIncludeIdentifierType(value) ? value.reference.type.value : value;
-    if (keyPathRest.length > 0) {
-        if (isObjectType(actualValue)) {
-            return getNodeAtKeyPath(decl, actualValue, keyPathRest, parent, [...parentPath, key]);
-        }
-        throw TypeError(`value at key "${key}"${parentPath.length === 0 ? "" : ' in "' + renderKeyPath(parentPath) + '"'}${parent ? " " + parent : ""} in unique constraint of entity "${decl.name}" does not contain an object type`);
-    }
-    return value;
-};
 const checkUniqueConstraintElement = (decl, element) => {
+    const getType = (type, keyPath, additionalText = "") => {
+        try {
+            return findTypeAtPath(type, keyPath, {
+                followTypeAliasIncludes: true,
+                throwOnPathMismatch: true,
+            });
+        }
+        catch (err) {
+            throw TypeError(`invalid key path${additionalText} in unique constraint of entity "${decl.name}"`, {
+                cause: err,
+            });
+        }
+    };
     if ("keyPath" in element) {
-        getNodeAtKeyPath(decl, decl.type.value, element.keyPath);
+        getType(decl.type.value, element.keyPath);
         if (element.keyPathFallback !== undefined) {
-            getNodeAtKeyPath(decl, decl.type.value, element.keyPathFallback);
+            getType(decl.type.value, element.keyPathFallback);
         }
     }
     else {
-        const entityMapType = getNodeAtKeyPath(decl, decl.type.value, element.entityMapKeyPath);
+        const entityMapType = getType(decl.type.value, element.entityMapKeyPath);
         if (!isNestedEntityMapType(entityMapType)) {
             throw TypeError(`value at key "${renderKeyPath(element.entityMapKeyPath)}" is not a nested entity map as required by the unique constraint of entity "${decl.name}"`);
         }
-        const nestedType = entityMapType.type.value;
-        const getActualType = (type) => isIncludeIdentifierType(type) ? getActualType(type.reference.type.value) : type;
-        const actualType = getActualType(nestedType);
-        getNodeAtKeyPath(decl, actualType, element.keyPathInEntityMap, `in entity map "${renderKeyPath(element.entityMapKeyPath)}"`);
+        getType(entityMapType.type.value, element.keyPathInEntityMap, `in entity map "${renderKeyPath(element.entityMapKeyPath)}"`);
         if (element.keyPathInEntityMapFallback !== undefined) {
-            getNodeAtKeyPath(decl, actualType, element.keyPathInEntityMapFallback, `in entity map "${renderKeyPath(element.entityMapKeyPath)}"`);
+            getType(entityMapType.type.value, element.keyPathInEntityMapFallback, `in entity map "${renderKeyPath(element.entityMapKeyPath)}"`);
         }
     }
 };
@@ -277,6 +279,56 @@ const checkUniqueConstraints = (declarations) => {
         }
     }
 };
+const isValidSortOrderType = (type) => isStringType(type) || isIntegerType(type) || isFloatType(type);
+const checkSortOrders = (declarations) => {
+    for (const decl of declarations) {
+        if (isEntityDecl(decl) && decl.sortOrder !== undefined) {
+            const getType = (type, keyPath, additionalText = "") => {
+                try {
+                    return findTypeAtPath(type, keyPath, {
+                        followTypeAliasIncludes: true,
+                        throwOnPathMismatch: true,
+                    });
+                }
+                catch (err) {
+                    throw TypeError(`invalid key path${additionalText} in sort order of entity "${decl.name}"`, {
+                        cause: err,
+                    });
+                }
+            };
+            const sortOrder = decl.sortOrder;
+            if (sortOrder === "displayName") {
+                continue;
+            }
+            else if ("keyPath" in sortOrder) {
+                const type = getType(decl.type.value, sortOrder.keyPath);
+                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}"`);
+                }
+            }
+            else {
+                // const entityMapType = getType(decl.type.value, sortOrder.entityMapKeyPath)
+                // if (!isNestedEntityMapType(entityMapType)) {
+                //   throw TypeError(
+                //     `value at key "${renderKeyPath(sortOrder.entityMapKeyPath)}" is not a nested entity map as required by the sort order of entity "${decl.name}"`,
+                //   )
+                // }
+                // const nestedType = getType(
+                //   entityMapType.type.value,
+                //   sortOrder.keyPathInEntityMap,
+                //   `in entity map "${renderKeyPath(sortOrder.entityMapKeyPath)}"`,
+                // )
+                // if (!isValidSortOrderType(nestedType)) {
+                //   throw TypeError(
+                //     `type at key path "${renderKeyPath(
+                //       sortOrder.keyPathInEntityMap,
+                //     )}" in entity map "${renderKeyPath(sortOrder.entityMapKeyPath)}" is not a valid sort order type (string, integer, or float) in entity "${decl.name}"`,
+                //   )
+                // }
+            }
+        }
+    }
+};
 const addDeclarations = (existingDecls, declsToAdd) => declsToAdd.reduce((accDecls, decl) => {
     if (!accDecls.includes(decl)) {
         return getNestedDeclarations(accDecls, decl.kind === "NestedEntity" ? decl.type : decl, undefined);
@@ -306,6 +358,8 @@ export const Schema = (declarations, localeEntity) => {
     checkRecursiveGenericTypeAliasesAndEnumerationsAreOnlyParameterizedDirectlyInTypeAliases(allDeclsWithoutNestedEntities);
     debug("checking unique constraints ...");
     checkUniqueConstraints(allDeclsWithoutNestedEntities);
+    debug("checking sort orders ...");
+    checkSortOrders(allDeclsWithoutNestedEntities);
     debug("created schema, no integrity violations found");
     return {
         declarations: allDeclsWithoutNestedEntities,

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

@@ -1,4 +1,4 @@
-import type { BaseNode, Node } from "../Node.ts";
+import type { BaseNode, CustomConstraintValidator, Node } from "../Node.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
 import type { EnumCaseDecl } from "../types/generic/EnumType.ts";
 import { type Type } from "../types/Type.ts";
@@ -27,3 +27,4 @@ export declare const isDeclWithoutTypeParameters: (decl: Decl) => decl is DeclP<
 export declare const resolveTypeArgumentsInDecls: (decls: readonly Decl[]) => Decl[];
 export declare function walkNodeTree(callbackFn: (node: Node, parentTypes: Type[], parentDecl: Decl) => void, decl: Decl): void;
 export declare const groupDeclarationsBySourceUrl: (decls: readonly Decl[]) => Partial<Record<string, Decl[]>>;
+export declare const checkCustomConstraintsInNestedDecl: CustomConstraintValidator<SecondaryDecl>;

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

@@ -1,8 +1,9 @@
-import { resolveTypeArguments } from "../Node.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
+import { NodeKind, resolveTypeArguments } from "../Node.js";
 import { walkTypeNodeTree } from "../types/Type.js";
 import { isEntityDecl } from "./EntityDecl.js";
-import { isEnumDecl } from "./EnumDecl.js";
-import { isTypeAliasDecl } from "./TypeAliasDecl.js";
+import { checkCustomConstraintsInEnumDecl, isEnumDecl } from "./EnumDecl.js";
+import { checkCustomConstraintsInTypeAliasDecl, isTypeAliasDecl } from "./TypeAliasDecl.js";
 export const getParameterNames = (decl) => decl.parameters.map(param => param.name);
 export const getTypeArgumentsRecord = (decl, args) => Object.fromEntries(
 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -22,3 +23,13 @@ export function walkNodeTree(callbackFn, decl) {
     walkTypeNodeTree(callbackFn, decl.type.value, [], decl);
 }
 export const groupDeclarationsBySourceUrl = (decls) => Object.groupBy(decls, decl => decl.sourceUrl);
+export const checkCustomConstraintsInNestedDecl = (decl, value, helpers) => {
+    switch (decl.kind) {
+        case NodeKind.EnumDecl:
+            return checkCustomConstraintsInEnumDecl(decl, value, helpers);
+        case NodeKind.TypeAliasDecl:
+            return checkCustomConstraintsInTypeAliasDecl(decl, value, helpers);
+        default:
+            return assertExhaustive(decl);
+    }
+};

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

@@ -1,8 +1,10 @@
-import type { UniqueConstraints } from "../../../shared/schema/declarations/EntityDecl.ts";
+import type { SortOrder } from "../../../shared/schema/utils/sortOrder.ts";
+import type { UniqueConstraints } from "../../../shared/schema/utils/uniqueConstraint.ts";
+import type { InstanceContent } from "../../../shared/utils/instances.ts";
 import { Lazy } from "../../../shared/utils/lazy.ts";
 import type { CustomConstraint, TypedCustomConstraint } from "../../utils/customConstraints.ts";
 import type { DisplayNameCustomizer, TypedDisplayNameCustomizer } from "../../utils/displayName.ts";
-import type { GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../Node.ts";
+import type { CustomConstraintValidator, 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";
@@ -52,6 +54,10 @@ export interface EntityDecl<Name extends string = string, T extends TConstraint
     isDeprecated?: boolean;
     uniqueConstraints?: UniqueConstraints;
     customConstraints?: CustomConstraint;
+    /**
+     * The order in which instances of an entity are sorted in the editor. This affects entity details pages and reference options.
+     */
+    sortOrder?: SortOrder;
 }
 export interface EntityDeclWithParentReference<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> = Extract<keyof T, string>> extends EntityDecl<Name, T, FK> {
 }
@@ -81,6 +87,10 @@ export declare const EntityDecl: {
         isDeprecated?: boolean;
         uniqueConstraints?: UniqueConstraints;
         customConstraints?: TypedCustomConstraint<Name>;
+        /**
+         * The order in which instances of an entity are sorted in the editor. This affects entity details pages and reference options.
+         */
+        sortOrder?: SortOrder;
     }): EntityDecl<Name, T, undefined>;
     <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string>>(sourceUrl: string, options: {
         name: Name;
@@ -108,6 +118,10 @@ export declare const EntityDecl: {
         isDeprecated?: boolean;
         uniqueConstraints?: UniqueConstraints;
         customConstraints?: TypedCustomConstraint<Name>;
+        /**
+         * The order in which instances of an entity are sorted in the editor. This affects entity details pages and reference options.
+         */
+        sortOrder?: SortOrder;
     }): EntityDecl<Name, T, FK>;
 };
 export { EntityDecl as Entity };
@@ -123,3 +137,7 @@ export declare const createEntityIdentifierType: () => StringType;
 export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
 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>;
+export declare const checkCustomConstraintsInEntityDecl: CustomConstraintValidator<EntityDecl, [
+    id: string,
+    content: InstanceContent
+]>;

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

@@ -2,6 +2,7 @@ import { Lazy } from "../../../shared/utils/lazy.js";
 import { NodeKind, resolveTypeArguments, validateType } from "../Node.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, Required, serializeObjectType, } from "../types/generic/ObjectType.js";
 import { StringType } from "../types/primitives/StringType.js";
+import { checkCustomConstraintsInType } from "../types/Type.js";
 import { validateDeclName } from "./Declaration.js";
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export const EntityDecl = (sourceUrl, options) => {
@@ -59,3 +60,4 @@ export const serializeEntityDecl = ((type) => ({
     customConstraints: type.customConstraints !== undefined,
 }));
 export const getReferencesForEntityDecl = (decl, value, inDecl) => getReferencesForObjectType(decl.type.value, value, [...inDecl, decl]);
+export const checkCustomConstraintsInEntityDecl = (decl, value, helpers) => (decl.customConstraints?.({ ...helpers, instanceId: value[0], instanceContent: value[1] }) ?? []).concat(checkCustomConstraintsInType(decl.type.value, value, helpers));

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

@@ -1,6 +1,7 @@
 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 type { NestedCustomConstraint, TypedNestedCustomConstraint } from "../../utils/customConstraints.ts";
+import type { CustomConstraintValidator, GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidatorOfParamDecl } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
 import type { EnumCaseDecl } from "../types/generic/EnumType.ts";
@@ -11,6 +12,7 @@ export interface EnumDecl<Name extends string = string, T extends TConstraint =
     kind: NodeKind["EnumDecl"];
     type: Lazy<EnumType<T>>;
     isDeprecated?: boolean;
+    customConstraints?: NestedCustomConstraint;
 }
 export declare const GenEnumDecl: <Name extends string, T extends TConstraint, Params extends TypeParameter[]>(sourceUrl: string, options: {
     name: Name;
@@ -18,6 +20,7 @@ export declare const GenEnumDecl: <Name extends string, T extends TConstraint, P
     parameters: Params;
     isDeprecated?: boolean;
     values: (...args: Params) => T;
+    customConstraints?: TypedNestedCustomConstraint<Name>;
 }) => EnumDecl<Name, T, Params>;
 export { GenEnumDecl as GenEnum };
 export declare const EnumDecl: <Name extends string, T extends Record<string, EnumCaseDecl>>(sourceUrl: string, options: {
@@ -25,6 +28,7 @@ export declare const EnumDecl: <Name extends string, T extends Record<string, En
     comment?: string;
     isDeprecated?: boolean;
     values: () => T;
+    customConstraints?: TypedNestedCustomConstraint<Name>;
 }) => EnumDecl<Name, T, []>;
 export { EnumDecl as Enum };
 export declare const isEnumDecl: Predicate<EnumDecl>;
@@ -35,3 +39,4 @@ 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;
+export declare const checkCustomConstraintsInEnumDecl: CustomConstraintValidator<EnumDecl>;

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

@@ -4,6 +4,7 @@ import { onlyKeys } from "../../../shared/utils/object.js";
 import { NodeKind } from "../Node.js";
 import { serializeTypeParameter } from "../TypeParameter.js";
 import { EnumType, getNestedDeclarationsInEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "../types/generic/EnumType.js";
+import { checkCustomConstraintsInType } from "../types/Type.js";
 import { getTypeArgumentsRecord, validateDeclName } from "./Declaration.js";
 export const GenEnumDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
@@ -12,6 +13,7 @@ export const GenEnumDecl = (sourceUrl, options) => {
         kind: NodeKind.EnumDecl,
         sourceUrl,
         type: Lazy.of(() => EnumType(options.values(...options.parameters))),
+        customConstraints: options.customConstraints, // ignore contravariance of registered enum type
     };
     return decl;
 };
@@ -24,6 +26,7 @@ export const EnumDecl = (sourceUrl, options) => {
         sourceUrl,
         parameters: [],
         type: Lazy.of(() => EnumType(options.values())),
+        customConstraints: options.customConstraints, // ignore contravariance of registered enum type
     };
     return decl;
 };
@@ -44,7 +47,9 @@ export const serializeEnumDecl = decl => ({
     ...decl,
     type: serializeEnumType(decl.type.value),
     parameters: decl.parameters.map(param => serializeTypeParameter(param)),
+    customConstraints: decl.customConstraints !== undefined,
 });
 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]];
+export const checkCustomConstraintsInEnumDecl = (decl, value, helpers) => (decl.customConstraints?.({ ...helpers, value }) ?? []).concat(checkCustomConstraintsInType(decl.type.value, value, helpers));

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

@@ -1,13 +1,15 @@
 import { Lazy } from "../../../shared/utils/lazy.ts";
-import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidationContext } from "../Node.ts";
+import type { NestedCustomConstraint, TypedNestedCustomConstraint } from "../../utils/customConstraints.ts";
+import type { CustomConstraintValidator, GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidationContext } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
 import type { TypeParameter } from "../TypeParameter.ts";
-import type { Type } from "../types/Type.ts";
+import { type Type } from "../types/Type.ts";
 import type { BaseDecl, Decl, TypeArguments } from "./Declaration.ts";
 export interface TypeAliasDecl<Name extends string = string, T extends Type = Type, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["TypeAliasDecl"];
     type: Lazy<T>;
     isDeprecated?: boolean;
+    customConstraints?: NestedCustomConstraint;
 }
 export declare const GenTypeAliasDecl: <Name extends string, T extends Type, Params extends TypeParameter[]>(sourceUrl: string, options: {
     name: Name;
@@ -15,6 +17,7 @@ export declare const GenTypeAliasDecl: <Name extends string, T extends Type, Par
     isDeprecated?: boolean;
     parameters: Params;
     type: (...args: Params) => T;
+    customConstraints?: TypedNestedCustomConstraint<Name>;
 }) => TypeAliasDecl<Name, T, Params>;
 export { GenTypeAliasDecl as GenTypeAlias };
 export declare const TypeAliasDecl: <Name extends string, T extends Type>(sourceUrl: string, options: {
@@ -22,6 +25,7 @@ export declare const TypeAliasDecl: <Name extends string, T extends Type>(source
     comment?: string;
     isDeprecated?: boolean;
     type: () => T;
+    customConstraints?: TypedNestedCustomConstraint<Name>;
 }) => TypeAliasDecl<Name, T, []>;
 export { TypeAliasDecl as TypeAlias };
 export declare const isTypeAliasDecl: Predicate<TypeAliasDecl>;
@@ -30,3 +34,4 @@ export declare const validateTypeAliasDecl: <Params extends TypeParameter[]>(hel
 export declare const resolveTypeArgumentsInTypeAliasDecl: TypeArgumentsResolver<TypeAliasDecl>;
 export declare const serializeTypeAliasDecl: Serializer<TypeAliasDecl>;
 export declare const getReferencesForTypeAliasDecl: GetReferences<TypeAliasDecl>;
+export declare const checkCustomConstraintsInTypeAliasDecl: CustomConstraintValidator<TypeAliasDecl>;

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

@@ -1,6 +1,7 @@
 import { Lazy } from "../../../shared/utils/lazy.js";
 import { getNestedDeclarations, getReferences, NodeKind, resolveTypeArguments, serializeNode, validateType, } from "../Node.js";
 import { serializeTypeParameter } from "../TypeParameter.js";
+import { checkCustomConstraintsInType } from "../types/Type.js";
 import { getTypeArgumentsRecord, validateDeclName } from "./Declaration.js";
 export const GenTypeAliasDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
@@ -9,6 +10,7 @@ export const GenTypeAliasDecl = (sourceUrl, options) => {
         kind: NodeKind.TypeAliasDecl,
         sourceUrl,
         type: Lazy.of(() => options.type(...options.parameters)),
+        customConstraints: options.customConstraints, // ignore contravariance of registered enum type
     };
     return decl;
 };
@@ -21,6 +23,7 @@ export const TypeAliasDecl = (sourceUrl, options) => {
         sourceUrl,
         parameters: [],
         type: Lazy.of(() => options.type()),
+        customConstraints: options.customConstraints, // ignore contravariance of registered type alias type
     };
     return decl;
 };
@@ -31,10 +34,13 @@ export const validateTypeAliasDecl = ((helpers, inDecls, decl, args, value) => v
 export const resolveTypeArgumentsInTypeAliasDecl = (args, decl, inDecl) => TypeAliasDecl(decl.sourceUrl, {
     ...decl,
     type: () => resolveTypeArguments(args, decl.type.value, [...inDecl, decl]),
+    customConstraints: decl.customConstraints, // ignore contravariance of registered type alias type
 });
 export const serializeTypeAliasDecl = type => ({
     ...type,
     type: serializeNode(type.type.value),
     parameters: type.parameters.map(param => serializeTypeParameter(param)),
+    customConstraints: type.customConstraints !== undefined,
 });
 export const getReferencesForTypeAliasDecl = (decl, value, inDecl) => getReferences(decl.type.value, value, [...inDecl, decl]);
+export const checkCustomConstraintsInTypeAliasDecl = (decl, value, helpers) => (decl.customConstraints?.({ ...helpers, value }) ?? []).concat(checkCustomConstraintsInType(decl.type.value, value, helpers));

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

@@ -18,3 +18,27 @@ export type AnyChildEntityMap = Record<string, [
 export type RegisteredChildEntityMap<T = Register> = T extends {
     childEntityMap: AnyChildEntityMap;
 } ? T["childEntityMap"] : AnyChildEntityMap;
+type EnumContent = object;
+export type AnyEnumMap = Record<string, EnumContent>;
+export type RegisteredEnumMap<T = Register> = T extends {
+    enumMap: AnyEnumMap;
+} ? T["enumMap"] : AnyEnumMap;
+export type RegisteredEnum<Name extends string, T = Register> = T extends {
+    enumMap: {
+        [K in Name]: EnumContent;
+    };
+} ? T["enumMap"][Name] : EnumContent;
+type TypeAliasContent = unknown;
+export type AnyTypeAliasMap = Record<string, TypeAliasContent>;
+export type RegisteredTypeAliasMap<T = Register> = T extends {
+    typeAliasMap: AnyTypeAliasMap;
+} ? T["typeAliasMap"] : AnyTypeAliasMap;
+export type RegisteredTypeAlias<Name extends string, T = Register> = T extends {
+    typeAliasMap: {
+        [K in Name]: TypeAliasContent;
+    };
+} ? T["typeAliasMap"][Name] : TypeAliasContent;
+export type RegisteredEnumOrTypeAlias<Name extends string, T = Register> = RegisteredEnumMap extends {
+    [K in Name]: unknown;
+} ? RegisteredEnum<Name, T> : RegisteredTypeAlias<Name, T>;
+export {};

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

@@ -1,5 +1,6 @@
+import { type KeyPath } from "../../../shared/schema/utils/keyPath.ts";
 import { type Decl, type EnumDecl, type TypeAliasDecl, type TypeParameter } from "../index.ts";
-import type { BaseNode } from "../Node.ts";
+import type { BaseNode, CustomConstraintValidator } from "../Node.ts";
 import type { ArrayType } from "./generic/ArrayType.ts";
 import type { EnumCaseDecl, EnumType } from "./generic/EnumType.ts";
 import type { MemberDecl, ObjectType } from "./generic/ObjectType.ts";
@@ -36,8 +37,7 @@ 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;
 };
 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;
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsDeepType<P[K]["type"]> : 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>;
@@ -52,12 +52,14 @@ 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[], options?: {
+export declare const findTypeAtPath: (type: Type, path: KeyPath, options?: {
     followTypeAliasIncludes?: boolean;
-}) => Type | undefined;
+    throwOnPathMismatch?: boolean;
+}) => Type;
 /**
  * Format the structure of a value to always look the same when serialized as JSON.
  */
 export type StructureFormatter<T extends Type> = (type: T, value: unknown) => unknown;
 export declare const formatValue: StructureFormatter<Type>;
+export declare const checkCustomConstraintsInType: CustomConstraintValidator<Type>;
 export {};