tsondb 0.5.19 → 0.6.1

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

@@ -1,49 +1,55 @@
-import { enumOfObject } from "../../shared/utils/enum.js";
+import { NodeKind } from "../../shared/schema/Node.js";
 import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { entity, json } from "../utils/errorFormatting.js";
-export const NodeKind = enumOfObject({
-    EntityDecl: null,
-    EnumDecl: null,
-    EnumCaseDecl: null,
-    TypeAliasDecl: null,
-    MemberDecl: null,
-    ArrayType: null,
-    ObjectType: null,
-    BooleanType: null,
-    FloatType: null,
-    IntegerType: null,
-    StringType: null,
-    DateType: null,
-    TypeArgumentType: null,
-    GenericParameter: null,
-    ReferenceIdentifierType: null,
-    IncludeIdentifierType: null,
-    NestedEntityMapType: null,
-    EnumType: null,
-});
-export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
-    const mapNodeTree = (callbackFn, node, decls) => {
+import { isDecl } from "./declarations/Declaration.js";
+import { getNestedDeclarationsInEntityDecl, getReferencesForEntityDecl, resolveTypeArgumentsInEntityDecl, serializeEntityDecl, validateEntityDecl, } from "./declarations/EntityDecl.js";
+import { getNestedDeclarationsInEnumDecl, getReferencesForEnumDecl, resolveTypeArgumentsInEnumDecl, serializeEnumDecl, validateEnumDecl, } from "./declarations/EnumDecl.js";
+import { getNestedDeclarationsInTypeAliasDecl, getReferencesForTypeAliasDecl, resolveTypeArgumentsInTypeAliasDecl, serializeTypeAliasDecl, validateTypeAliasDecl, } from "./declarations/TypeAliasDecl.js";
+import { getNestedDeclarationsInTypeParameter, getReferencesForTypeParameter, resolveTypeArgumentsInTypeParameter, serializeTypeParameter, } from "./TypeParameter.js";
+import { getNestedDeclarationsInArrayType, getReferencesForArrayType, resolveTypeArgumentsInArrayType, serializeArrayType, validateArrayType, } from "./types/generic/ArrayType.js";
+import { getNestedDeclarationsInEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "./types/generic/EnumType.js";
+import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "./types/generic/ObjectType.js";
+import { getNestedDeclarationsInBooleanType, getReferencesForBooleanType, resolveTypeArgumentsInBooleanType, serializeBooleanType, validateBooleanType, } from "./types/primitives/BooleanType.js";
+import { getNestedDeclarationsInDateType, getReferencesForDateType, resolveTypeArgumentsInDateType, serializeDateType, validateDateType, } from "./types/primitives/DateType.js";
+import { getNestedDeclarationsInFloatType, getReferencesForFloatType, resolveTypeArgumentsInFloatType, serializeFloatType, validateFloatType, } from "./types/primitives/FloatType.js";
+import { getNestedDeclarationsInIntegerType, getReferencesForIntegerType, resolveTypeArgumentsInIntegerType, serializeIntegerType, validateIntegerType, } from "./types/primitives/IntegerType.js";
+import { getNestedDeclarationsInStringType, getReferencesForStringType, resolveTypeArgumentsInStringType, serializeStringType, validateStringType, } from "./types/primitives/StringType.js";
+import { getNestedDeclarationsInChildEntitiesType, getReferencesForChildEntitiesType, resolveTypeArgumentsInChildEntitiesType, serializeChildEntitiesType, validateChildEntitiesType, } from "./types/references/ChildEntitiesType.js";
+import { getNestedDeclarationsInIncludeIdentifierType, getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, validateIncludeIdentifierType, } from "./types/references/IncludeIdentifierType.js";
+import { getNestedDeclarationsInNestedEntityMapType, getReferencesForNestedEntityMapType, resolveTypeArgumentsInNestedEntityMapType, serializeNestedEntityMapType, validateNestedEntityMapType, } from "./types/references/NestedEntityMapType.js";
+import { getNestedDeclarationsInReferenceIdentifierType, getReferencesForReferenceIdentifierType, resolveTypeArgumentsInReferenceIdentifierType, serializeReferenceIdentifierType, validateReferenceIdentifierType, } from "./types/references/ReferenceIdentifierType.js";
+import { getNestedDeclarationsInTypeArgumentType, getReferencesForTypeArgumentType, resolveTypeArgumentsInTypeArgumentType, serializeTypeArgumentType, validateTypeArgumentType, } from "./types/references/TypeArgumentType.js";
+export { NodeKind };
+export const reduceNodes = (reducer, nodes, options = {}) => {
+    const { initialResults = [], followIncludes = false, followChildEntities = false } = options;
+    const reduceNodeTree = (parentNodes, node, collectedResults, reducedDecls) => {
         switch (node.kind) {
-            case NodeKind.EntityDecl: {
-                const newDecls = callbackFn(node, decls);
-                return mapNodeTree(callbackFn, node.type.value, newDecls);
-            }
-            case NodeKind.EnumDecl: {
-                const newDecls = callbackFn(node, decls);
-                return mapNodeTree(callbackFn, node.type.value, newDecls);
-            }
-            case NodeKind.TypeAliasDecl: {
-                const newDecls = callbackFn(node, decls);
-                return mapNodeTree(callbackFn, node.type.value, newDecls);
-            }
-            case NodeKind.ArrayType: {
-                const newDecls = callbackFn(node, decls);
-                return mapNodeTree(callbackFn, node.items, newDecls);
-            }
-            case NodeKind.ObjectType: {
-                const newDecls = callbackFn(node, decls);
-                return Object.values(node.properties).reduce((newDeclsAcc, prop) => mapNodeTree(callbackFn, prop.type, newDeclsAcc), newDecls);
-            }
+            case NodeKind.EntityDecl:
+            case NodeKind.EnumDecl:
+            case NodeKind.TypeAliasDecl:
+                return reduceNodeTree([node], node.type.value, reducer(parentNodes, node, collectedResults), [...reducedDecls, node]);
+            case NodeKind.ArrayType:
+                return reduceNodeTree([...parentNodes, node], node.items, reducer(parentNodes, node, collectedResults), reducedDecls);
+            case NodeKind.ObjectType:
+                return Object.values(node.properties).reduce((collectedResultsAcc, prop) => reduceNodeTree([...parentNodes, node], prop.type, collectedResultsAcc.results, collectedResultsAcc.reducedDecls), { results: reducer(parentNodes, node, collectedResults), reducedDecls });
+            case NodeKind.EnumType:
+                return Object.values(node.values).reduce((collectedResultsAcc, caseDef) => caseDef.type === null
+                    ? collectedResultsAcc
+                    : reduceNodeTree([...parentNodes, node], caseDef.type, collectedResultsAcc.results, collectedResultsAcc.reducedDecls), { results: reducer(parentNodes, node, collectedResults), reducedDecls });
+            case NodeKind.IncludeIdentifierType:
+                if (followIncludes && !reducedDecls.includes(node.reference)) {
+                    return reduceNodeTree([], node.reference, reducer(parentNodes, node, collectedResults), reducedDecls);
+                }
+                else {
+                    return { results: reducer(parentNodes, node, collectedResults), reducedDecls };
+                }
+            case NodeKind.ChildEntitiesType:
+                if (followChildEntities && !reducedDecls.includes(node.entity)) {
+                    return reduceNodeTree([], node.entity, reducer(parentNodes, node, collectedResults), reducedDecls);
+                }
+                else {
+                    return { results: reducer(parentNodes, node, collectedResults), reducedDecls };
+                }
             case NodeKind.BooleanType:
             case NodeKind.DateType:
             case NodeKind.FloatType:
@@ -51,30 +57,27 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
             case NodeKind.StringType:
             case NodeKind.TypeArgumentType:
             case NodeKind.ReferenceIdentifierType:
-            case NodeKind.IncludeIdentifierType:
             case NodeKind.NestedEntityMapType:
-                return callbackFn(node, decls);
-            case NodeKind.EnumType: {
-                const newDecls = callbackFn(node, decls);
-                return Object.values(node.values).reduce((newDeclsAcc, caseDef) => caseDef.type === null ? newDecls : mapNodeTree(callbackFn, caseDef.type, newDeclsAcc), newDecls);
-            }
+            case NodeKind.TypeParameter:
+                return { results: reducer(parentNodes, node, collectedResults), reducedDecls };
             default:
                 return assertExhaustive(node);
         }
     };
-    const reducer = (node, decls) => {
-        const result = callbackFn(node, decls);
-        const normalizedResult = (Array.isArray(result) ? result : [result]).filter(decl => decl !== undefined);
-        normalizedResult.forEach(decl => {
-            const existingDeclWithSameName = decls.find(existingDecl => existingDecl !== decl && existingDecl.name === decl.name);
-            if (existingDeclWithSameName) {
-                throw new Error(`Duplicate declaration name: "${decl.name}" in "${decl.sourceUrl}" and "${existingDeclWithSameName.sourceUrl}". Make sure declaration names are globally unique.`);
-            }
-        });
-        return decls.concat(normalizedResult);
-    };
-    return declarations.reduce((decls, node) => mapNodeTree(reducer, node, [...decls, node]), []);
+    return nodes.reduce(({ results, reducedDecls }, node) => reduceNodeTree([], node, results, reducedDecls), { results: initialResults, reducedDecls: [] }).results;
 };
+export const flatMapAuxiliaryDecls = (callbackFn, declarations) => reduceNodes((parentNodes, node, decls) => {
+    const declsWithCurrentDecl = isDecl(node) ? [...decls, node] : decls;
+    const result = callbackFn(parentNodes, node, declsWithCurrentDecl);
+    const normalizedResult = (Array.isArray(result) ? result : [result]).filter(decl => decl !== undefined);
+    normalizedResult.forEach(decl => {
+        const existingDeclWithSameName = decls.find(existingDecl => existingDecl !== decl && existingDecl.name === decl.name);
+        if (existingDeclWithSameName) {
+            throw new Error(`Duplicate declaration name: "${decl.name}" in "${decl.sourceUrl}" and "${existingDeclWithSameName.sourceUrl}". Make sure declaration names are globally unique.`);
+        }
+    });
+    return declsWithCurrentDecl.concat(normalizedResult);
+}, declarations);
 export const createValidators = (instancesByEntityName, useStyling, checkReferentialIntegrity = true) => ({
     useStyling,
     checkReferentialIntegrity: checkReferentialIntegrity
@@ -88,3 +91,207 @@ export const createValidators = (instancesByEntityName, useStyling, checkReferen
             ]
         : () => [],
 });
+export const getNestedDeclarations = (addedDecls, node) => {
+    switch (node.kind) {
+        case NodeKind.EntityDecl:
+            return getNestedDeclarationsInEntityDecl(addedDecls, node);
+        case NodeKind.EnumDecl:
+            return getNestedDeclarationsInEnumDecl(addedDecls, node);
+        case NodeKind.TypeAliasDecl:
+            return getNestedDeclarationsInTypeAliasDecl(addedDecls, node);
+        case NodeKind.ArrayType:
+            return getNestedDeclarationsInArrayType(addedDecls, node);
+        case NodeKind.ObjectType:
+            return getNestedDeclarationsInObjectType(addedDecls, node);
+        case NodeKind.BooleanType:
+            return getNestedDeclarationsInBooleanType(addedDecls, node);
+        case NodeKind.DateType:
+            return getNestedDeclarationsInDateType(addedDecls, node);
+        case NodeKind.FloatType:
+            return getNestedDeclarationsInFloatType(addedDecls, node);
+        case NodeKind.IntegerType:
+            return getNestedDeclarationsInIntegerType(addedDecls, node);
+        case NodeKind.StringType:
+            return getNestedDeclarationsInStringType(addedDecls, node);
+        case NodeKind.TypeArgumentType:
+            return getNestedDeclarationsInTypeArgumentType(addedDecls, node);
+        case NodeKind.ReferenceIdentifierType:
+            return getNestedDeclarationsInReferenceIdentifierType(addedDecls, node);
+        case NodeKind.IncludeIdentifierType:
+            return getNestedDeclarationsInIncludeIdentifierType(addedDecls, node);
+        case NodeKind.NestedEntityMapType:
+            return getNestedDeclarationsInNestedEntityMapType(addedDecls, node);
+        case NodeKind.EnumType:
+            return getNestedDeclarationsInEnumType(addedDecls, node);
+        case NodeKind.TypeParameter:
+            return getNestedDeclarationsInTypeParameter(addedDecls, node);
+        case NodeKind.ChildEntitiesType:
+            return getNestedDeclarationsInChildEntitiesType(addedDecls, node);
+        default:
+            return assertExhaustive(node);
+    }
+};
+export const validateDecl = (helpers, decl, typeArgs, value) => {
+    switch (decl.kind) {
+        case NodeKind.EntityDecl:
+            return validateEntityDecl(helpers, decl, value);
+        case NodeKind.EnumDecl:
+            return validateEnumDecl(helpers, decl, typeArgs, value);
+        case NodeKind.TypeAliasDecl:
+            return validateTypeAliasDecl(helpers, decl, typeArgs, value);
+        default:
+            return assertExhaustive(decl);
+    }
+};
+export const validateType = (helpers, type, value) => {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            return validateArrayType(helpers, type, value);
+        case NodeKind.ObjectType:
+            return validateObjectType(helpers, type, value);
+        case NodeKind.BooleanType:
+            return validateBooleanType(helpers, type, value);
+        case NodeKind.DateType:
+            return validateDateType(helpers, type, value);
+        case NodeKind.FloatType:
+            return validateFloatType(helpers, type, value);
+        case NodeKind.IntegerType:
+            return validateIntegerType(helpers, type, value);
+        case NodeKind.StringType:
+            return validateStringType(helpers, type, value);
+        case NodeKind.TypeArgumentType:
+            return validateTypeArgumentType(helpers, type, value);
+        case NodeKind.ReferenceIdentifierType:
+            return validateReferenceIdentifierType(helpers, type, value);
+        case NodeKind.IncludeIdentifierType:
+            return validateIncludeIdentifierType(helpers, type, value);
+        case NodeKind.NestedEntityMapType:
+            return validateNestedEntityMapType(helpers, type, value);
+        case NodeKind.EnumType:
+            return validateEnumType(helpers, type, value);
+        case NodeKind.ChildEntitiesType:
+            return validateChildEntitiesType(helpers, type, value);
+        default:
+            return assertExhaustive(type);
+    }
+};
+export const resolveTypeArguments = (args, node) => {
+    switch (node.kind) {
+        case NodeKind.EntityDecl:
+            return resolveTypeArgumentsInEntityDecl(args, node);
+        case NodeKind.EnumDecl:
+            return resolveTypeArgumentsInEnumDecl(args, node);
+        case NodeKind.TypeAliasDecl:
+            return resolveTypeArgumentsInTypeAliasDecl(args, node);
+        case NodeKind.ArrayType:
+            return resolveTypeArgumentsInArrayType(args, node);
+        case NodeKind.ObjectType:
+            return resolveTypeArgumentsInObjectType(args, node);
+        case NodeKind.BooleanType:
+            return resolveTypeArgumentsInBooleanType(args, node);
+        case NodeKind.DateType:
+            return resolveTypeArgumentsInDateType(args, node);
+        case NodeKind.FloatType:
+            return resolveTypeArgumentsInFloatType(args, node);
+        case NodeKind.IntegerType:
+            return resolveTypeArgumentsInIntegerType(args, node);
+        case NodeKind.StringType:
+            return resolveTypeArgumentsInStringType(args, node);
+        case NodeKind.TypeArgumentType:
+            return resolveTypeArgumentsInTypeArgumentType(args, node);
+        case NodeKind.ReferenceIdentifierType:
+            return resolveTypeArgumentsInReferenceIdentifierType(args, node);
+        case NodeKind.IncludeIdentifierType:
+            return resolveTypeArgumentsInIncludeIdentifierType(args, node);
+        case NodeKind.NestedEntityMapType:
+            return resolveTypeArgumentsInNestedEntityMapType(args, node);
+        case NodeKind.EnumType:
+            return resolveTypeArgumentsInEnumType(args, node);
+        case NodeKind.TypeParameter:
+            return resolveTypeArgumentsInTypeParameter(args, node);
+        case NodeKind.ChildEntitiesType:
+            return resolveTypeArgumentsInChildEntitiesType(args, node);
+        default:
+            return assertExhaustive(node);
+    }
+};
+export const serializeNode = (node) => {
+    switch (node.kind) {
+        case NodeKind.EntityDecl:
+            return serializeEntityDecl(node);
+        case NodeKind.EnumDecl:
+            return serializeEnumDecl(node);
+        case NodeKind.TypeAliasDecl:
+            return serializeTypeAliasDecl(node);
+        case NodeKind.ArrayType:
+            return serializeArrayType(node);
+        case NodeKind.ObjectType:
+            return serializeObjectType(node);
+        case NodeKind.BooleanType:
+            return serializeBooleanType(node);
+        case NodeKind.DateType:
+            return serializeDateType(node);
+        case NodeKind.FloatType:
+            return serializeFloatType(node);
+        case NodeKind.IntegerType:
+            return serializeIntegerType(node);
+        case NodeKind.StringType:
+            return serializeStringType(node);
+        case NodeKind.TypeArgumentType:
+            return serializeTypeArgumentType(node);
+        case NodeKind.ReferenceIdentifierType:
+            return serializeReferenceIdentifierType(node);
+        case NodeKind.IncludeIdentifierType:
+            return serializeIncludeIdentifierType(node);
+        case NodeKind.NestedEntityMapType:
+            return serializeNestedEntityMapType(node);
+        case NodeKind.EnumType:
+            return serializeEnumType(node);
+        case NodeKind.TypeParameter:
+            return serializeTypeParameter(node);
+        case NodeKind.ChildEntitiesType:
+            return serializeChildEntitiesType(node);
+        default:
+            return assertExhaustive(node);
+    }
+};
+export const getReferences = (node, value) => {
+    switch (node.kind) {
+        case NodeKind.EntityDecl:
+            return getReferencesForEntityDecl(node, value);
+        case NodeKind.EnumDecl:
+            return getReferencesForEnumDecl(node, value);
+        case NodeKind.TypeAliasDecl:
+            return getReferencesForTypeAliasDecl(node, value);
+        case NodeKind.ArrayType:
+            return getReferencesForArrayType(node, value);
+        case NodeKind.ObjectType:
+            return getReferencesForObjectType(node, value);
+        case NodeKind.BooleanType:
+            return getReferencesForBooleanType(node, value);
+        case NodeKind.DateType:
+            return getReferencesForDateType(node, value);
+        case NodeKind.FloatType:
+            return getReferencesForFloatType(node, value);
+        case NodeKind.IntegerType:
+            return getReferencesForIntegerType(node, value);
+        case NodeKind.StringType:
+            return getReferencesForStringType(node, value);
+        case NodeKind.TypeArgumentType:
+            return getReferencesForTypeArgumentType(node, value);
+        case NodeKind.ReferenceIdentifierType:
+            return getReferencesForReferenceIdentifierType(node, value);
+        case NodeKind.IncludeIdentifierType:
+            return getReferencesForIncludeIdentifierType(node, value);
+        case NodeKind.NestedEntityMapType:
+            return getReferencesForNestedEntityMapType(node, value);
+        case NodeKind.EnumType:
+            return getReferencesForEnumType(node, value);
+        case NodeKind.TypeParameter:
+            return getReferencesForTypeParameter(node, value);
+        case NodeKind.ChildEntitiesType:
+            return getReferencesForChildEntitiesType(node, value);
+        default:
+            return assertExhaustive(node);
+    }
+};

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

@@ -1,9 +1,14 @@
 import Debug from "debug";
-import { getNestedDeclarations, getParameterNames, walkNodeTree, } from "./declarations/Declaration.js";
+import { getParameterNames, walkNodeTree } from "./declarations/Declaration.js";
 import { isEntityDecl } from "./declarations/EntityDecl.js";
+import { cases, isEnumDecl } from "./declarations/EnumDecl.js";
+import { getNestedDeclarations } from "./Node.js";
+import { isObjectType } from "./types/generic/ObjectType.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 { isReferenceIdentifierType, } from "./types/references/ReferenceIdentifierType.js";
 import { findTypeAtPath } from "./types/Type.js";
 const debug = Debug("tsondb:schema");
 const checkDuplicateIdentifier = (existingDecls, decl) => {
@@ -59,6 +64,92 @@ const checkEntityDisplayNamePaths = (decls, localeEntity) => {
         }
     }
 };
+const checkChildEntityTypeNotInEnumDecl = (checkedDecls, decl) => {
+    if (!checkedDecls.has(decl)) {
+        checkedDecls.add(decl);
+        walkNodeTree(node => {
+            if (isChildEntitiesType(node)) {
+                throw new Error(`Child entities type for entity "${node.entity.name}" in declaration "${decl.name}" cannot be used inside an enum declaration.`);
+            }
+            else if (isIncludeIdentifierType(node)) {
+                checkChildEntityTypeNotInEnumDecl(checkedDecls, node.reference);
+            }
+        }, decl);
+    }
+};
+const checkChildEntityTypeInEntityDecl = (checkedDecls, entityDecl, decl) => {
+    if (!checkedDecls.has(decl)) {
+        checkedDecls.add(decl);
+        walkNodeTree((node, parentTypes) => {
+            if (isIncludeIdentifierType(node)) {
+                checkChildEntityTypeInEntityDecl(checkedDecls, entityDecl, node.reference);
+            }
+            else if (isChildEntitiesType(node)) {
+                if (!parentTypes.every(parentType => isObjectType(parentType))) {
+                    throw new Error(`Child entities type for entity "${node.entity.name}" in entity declaration "${entityDecl.name}" must be a constant child of the entity declaration, i.e. it must only be contained directly in the entity declaration or in nested object types.`);
+                }
+                const backReferenceMemberDeclAtParent = node.entity.type.value.properties[node.entity.parentReferenceKey];
+                if (backReferenceMemberDeclAtParent === undefined) {
+                    throw new Error(`Child entities type for entity "${node.entity.name}" in entity declaration "${entityDecl.name}" requires that the child entity has a reference to its parent defined.`);
+                }
+                if (!backReferenceMemberDeclAtParent.isRequired) {
+                    throw new Error(`The parent reference "${node.entity.parentReferenceKey}" in child entity "${node.entity.name}" must be required.`);
+                }
+                if (isReferenceIdentifierType(backReferenceMemberDeclAtParent.type)) {
+                    if (backReferenceMemberDeclAtParent.type.entity !== entityDecl) {
+                        throw new Error(`The parent reference "${node.entity.parentReferenceKey}" in child entity "${node.entity.name}" must reference the entity "${entityDecl.name}". If the parent entity is polymorphic, use an enum of reference identifier types instead.`);
+                    }
+                }
+                else if (isIncludeIdentifierType(backReferenceMemberDeclAtParent.type)) {
+                    if (!isEnumDecl(backReferenceMemberDeclAtParent.type.reference)) {
+                        throw new Error(`The parent reference "${node.entity.parentReferenceKey}" in child entity "${node.entity.name}" must reference an enum declaration if it is an IncludeIdentifierType.`);
+                    }
+                    const enumCases = cases(backReferenceMemberDeclAtParent.type.reference);
+                    if (!enumCases.every((caseDecl) => caseDecl.type !== null && isReferenceIdentifierType(caseDecl.type))) {
+                        throw new Error(`All cases of the enum "${backReferenceMemberDeclAtParent.type.reference.name}" referenced by the parent reference "${node.entity.parentReferenceKey}" in child entity "${node.entity.name}" must be ReferenceIdentifierTypes.`);
+                    }
+                    if (!enumCases.some(caseDecl => caseDecl.type.entity === entityDecl)) {
+                        throw new Error(`At least one case of the enum "${backReferenceMemberDeclAtParent.type.reference.name}" referenced by the parent reference "${node.entity.parentReferenceKey}" in child entity "${node.entity.name}" must reference the entity "${decl.name}".`);
+                    }
+                }
+                else {
+                    throw new Error(`The parent reference "${node.entity.parentReferenceKey}" in child entity "${node.entity.name}" must be either a ReferenceIdentifierType or an IncludeIdentifierType that references an enum declaration.`);
+                }
+            }
+        }, 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.`);
+    }
+    // TODO: Check that no cycles exist in child entity relations
+    for (const decl of decls) {
+        if (isEnumDecl(decl)) {
+            checkChildEntityTypeNotInEnumDecl(new Set(), decl);
+        }
+        if (isEntityDecl(decl)) {
+            checkChildEntityTypeInEntityDecl(new Set(), decl, decl);
+        }
+    }
+};
+const checkChildEntitiesProvideCorrectPathToParentReferenceIdentifierType = (decls) => {
+    for (const decl of decls) {
+        if (isEntityDecl(decl) && decl.parentReferenceKey !== undefined) {
+            const valueAtParentReferenceKey = decl.type.value.properties[decl.parentReferenceKey];
+            if (valueAtParentReferenceKey) {
+                const typeAtProperty = valueAtParentReferenceKey.type;
+                // the parent reference must either be an enum of reference types (for polymorphic relations) or a reference identifier type
+                if (!((isIncludeIdentifierType(typeAtProperty) &&
+                    isEnumDecl(typeAtProperty.reference) &&
+                    cases(typeAtProperty.reference).every(caseDecl => caseDecl.type !== null && isReferenceIdentifierType(caseDecl.type))) ||
+                    isReferenceIdentifierType(typeAtProperty))) {
+                    throw new TypeError(`Parent reference key "${decl.parentReferenceKey}" in entity declaration "${decl.name}" must be an IncludeIdentifierType that references an enum declaration whose cases all have a ReferenceIdentifierType.`);
+                }
+            }
+        }
+    }
+};
 const addDeclarations = (existingDecls, declsToAdd, nested) => declsToAdd.reduce((accDecls, decl) => {
     if (!accDecls.includes(decl)) {
         checkDuplicateIdentifier(accDecls, decl);
@@ -75,6 +166,10 @@ export const Schema = (declarations, localeEntity) => {
     checkParameterNamesShadowing(allDecls);
     debug("checking entity display name paths ...");
     checkEntityDisplayNamePaths(allDecls, localeEntity);
+    debug("checking child entities ...");
+    checkChildEntitiesProvideCorrectPathToParentReferenceIdentifierType(allDecls);
+    debug("checking child entity types ...");
+    checkChildEntityTypes(localeEntity, allDecls);
     debug("created schema, no integrity violations found");
     return {
         declarations: allDecls,

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

@@ -1,15 +1,13 @@
-import type { Serializer } from "./Node.ts";
+import type { GetNestedDeclarations, GetReferences, Serializer, TypeArgumentsResolver } from "./Node.ts";
 import { NodeKind } from "./Node.ts";
-import type { SerializedBaseType, SerializedType, Type } from "./types/Type.ts";
+import type { Type } from "./types/Type.ts";
 export interface TypeParameter<N extends string = string, T extends Type = Type> {
-    kind: NodeKind["GenericParameter"];
-    name: N;
-    constraint?: T;
-}
-export interface SerializedTypeParameter<N extends string = string, T extends SerializedType = SerializedType> extends SerializedBaseType {
-    kind: NodeKind["GenericParameter"];
+    kind: NodeKind["TypeParameter"];
     name: N;
     constraint?: T;
 }
 export declare const Param: <N extends string = string, T extends Type = Type>(name: N, constraint?: T) => TypeParameter<N, T>;
-export declare const serializeTypeParameter: Serializer<TypeParameter, SerializedTypeParameter>;
+export declare const getNestedDeclarationsInTypeParameter: GetNestedDeclarations<TypeParameter>;
+export declare const resolveTypeArgumentsInTypeParameter: TypeArgumentsResolver<TypeParameter>;
+export declare const serializeTypeParameter: Serializer<TypeParameter>;
+export declare const getReferencesForTypeParameter: GetReferences<TypeParameter>;

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

@@ -1,11 +1,13 @@
-import { NodeKind } from "./Node.js";
-import { removeParentKey, serializeType } from "./types/Type.js";
+import { getNestedDeclarations, NodeKind, serializeNode } from "./Node.js";
 export const Param = (name, constraint) => ({
-    kind: NodeKind.GenericParameter,
+    kind: NodeKind.TypeParameter,
     name,
     constraint,
 });
+export const getNestedDeclarationsInTypeParameter = (addedDecls, param) => (param.constraint ? getNestedDeclarations(addedDecls, param.constraint) : addedDecls);
+export const resolveTypeArgumentsInTypeParameter = (_args, param) => param;
 export const serializeTypeParameter = type => ({
-    ...removeParentKey(type),
-    constraint: type.constraint ? serializeType(type.constraint) : undefined,
+    ...type,
+    constraint: type.constraint ? serializeNode(type.constraint) : undefined,
 });
+export const getReferencesForTypeParameter = () => [];

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

@@ -1,47 +1,29 @@
-import type { BaseNode, GetReferences, Node, Serializer } from "../Node.ts";
-import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.ts";
-import type { EnumCaseDecl, SerializedEnumCaseDecl } from "../types/generic/EnumType.ts";
-import { type SerializedType, type Type } from "../types/Type.ts";
-import type { ValidatorHelpers } from "../validation/type.ts";
-import type { EntityDecl, SerializedEntityDecl } from "./EntityDecl.ts";
-import type { EnumDecl, SerializedEnumDecl } from "./EnumDecl.ts";
-import type { SerializedTypeAliasDecl, TypeAliasDecl } from "./TypeAliasDecl.ts";
+import type { BaseNode, 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";
+import type { EntityDecl } from "./EntityDecl.ts";
+import type { EnumDecl } from "./EnumDecl.ts";
+import type { TypeAliasDecl } from "./TypeAliasDecl.ts";
 export type TypeArguments<Params extends TypeParameter[]> = {
     [K in keyof Params]: Params[K] extends TypeParameter<string, infer T> ? T : Type;
 };
-export type SerializedTypeArguments<Params extends SerializedTypeParameter[]> = {
-    [K in keyof Params]: Params[K] extends SerializedTypeParameter<string, infer T> ? T : Type;
-};
 export declare const getParameterNames: (decl: Decl) => string[];
 export declare const getTypeArgumentsRecord: <Params extends TypeParameter[]>(decl: DeclP<Params>, args: TypeArguments<Params>) => Record<string, Type>;
 export type Decl = EntityDecl | EnumDecl | TypeAliasDecl;
-export type SerializedDecl = SerializedEntityDecl | SerializedEnumDecl | SerializedTypeAliasDecl;
 export type DeclP<Params extends TypeParameter[] = TypeParameter[]> = EntityDecl | EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
 export type IncludableDeclP<Params extends TypeParameter[] = TypeParameter[]> = EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
-export type SerializedDeclP<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> = SerializedEntityDecl | SerializedEnumDecl<string, Record<string, SerializedEnumCaseDecl>, Params> | SerializedTypeAliasDecl<string, SerializedType, Params>;
 export type SecondaryDecl = EnumDecl | TypeAliasDecl;
-export type SerializedSecondaryDecl = SerializedEnumDecl | SerializedTypeAliasDecl;
-export declare const getNestedDeclarations: GetNestedDeclarations;
-export type GetNestedDeclarations<T extends Node = Node> = (addedDecls: Decl[], node: T) => Decl[];
 export declare const isDecl: (node: Node) => node is Decl;
+export declare const asDecl: (node: Node | undefined) => Decl | undefined;
 export interface BaseDecl<Name extends string = string, Params extends TypeParameter[] = TypeParameter[]> extends BaseNode {
     sourceUrl: string;
     name: Name;
     comment?: string;
     parameters: Params;
 }
-export interface SerializedBaseDecl<Name extends string = string, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends BaseNode {
-    sourceUrl: string;
-    name: Name;
-    comment?: string;
-    parameters: Params;
-}
-export declare const validateDecl: (helpers: ValidatorHelpers, decl: Decl, args: Type[], value: unknown) => Error[];
 export declare const validateDeclName: (name: string) => void;
-export declare const resolveTypeArgumentsInDecl: <Params extends TypeParameter[]>(decl: DeclP<Params>, args: TypeArguments<Params>) => DeclP<[]>;
 export declare const isDeclWithoutTypeParameters: (decl: Decl) => decl is DeclP<[]>;
-export declare const resolveTypeArgumentsInDecls: (decls: readonly Decl[]) => DeclP<[]>[];
-export declare function walkNodeTree(callbackFn: (node: Node) => void, decl: Decl): void;
-export declare const serializeDecl: Serializer<Decl, SerializedDecl>;
-export declare const getReferencesForDecl: GetReferences<Decl>;
+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[]>>;