tsondb 0.5.16 → 0.5.17

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

@@ -17,6 +17,7 @@ export declare const getTypeArgumentsRecord: <Params extends TypeParameter[]>(de
 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;

package/dist/src/node/schema/types/references/IncludeIdentifierType.d.ts

@@ -1,4 +1,4 @@
-import type { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.ts";
+import type { GetNestedDeclarations, IncludableDeclP, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.ts";
 import type { EnumDecl } from "../../declarations/EnumDecl.ts";
 import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.ts";
 import type { GetReferences, Node, Serializer } from "../../Node.ts";
@@ -23,9 +23,10 @@ export { GenIncludeIdentifierType as GenIncludeIdentifier };
 export declare const IncludeIdentifierType: <T extends TConstraint<[]>>(reference: T) => IncludeIdentifierType<[], T>;
 export { IncludeIdentifierType as IncludeIdentifier };
 export declare const isIncludeIdentifierType: (node: Node) => node is IncludeIdentifierType;
+export declare const isNoGenericIncludeIdentifierType: (node: IncludeIdentifierType) => node is IncludeIdentifierType<[], IncludableDeclP<[]>>;
 export declare const getNestedDeclarationsInIncludeIdentifierType: GetNestedDeclarations<IncludeIdentifierType>;
 export declare const validateIncludeIdentifierType: Validator<IncludeIdentifierType>;
-export declare const resolveTypeArgumentsInIncludeIdentifierType: (args: Record<string, Type>, type: IncludeIdentifierType) => Type;
+export declare const resolveTypeArgumentsInIncludeIdentifierType: <T extends IncludeIdentifierType>(args: Record<string, Type>, type: T) => T extends IncludeIdentifierType<[], IncludableDeclP<[]>> ? T : Type;
 export declare const serializeIncludeIdentifierType: Serializer<IncludeIdentifierType, SerializedIncludeIdentifierType>;
 export declare const getReferencesForIncludeIdentifierType: GetReferences<IncludeIdentifierType>;
 export declare const formatIncludeIdentifierValue: StructureFormatter<IncludeIdentifierType>;

package/dist/src/node/schema/types/references/IncludeIdentifierType.js

@@ -15,13 +15,14 @@ export const IncludeIdentifierType = (reference) => ({
 });
 export { IncludeIdentifierType as IncludeIdentifier };
 export const isIncludeIdentifierType = (node) => node.kind === NodeKind.IncludeIdentifierType;
+export const isNoGenericIncludeIdentifierType = (node) => node.args.length === 0 && node.reference.parameters.length === 0;
 export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) => type.args.reduce((accAddedDecls, arg) => getNestedDeclarations(accAddedDecls, arg), addedDecls.includes(type.reference)
     ? addedDecls
     : getNestedDeclarations([type.reference, ...addedDecls], type.reference));
 export const validateIncludeIdentifierType = (helpers, type, value) => validateDecl(helpers, type.reference, type.args, value);
-export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => type.args.length === 0
+export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => (isNoGenericIncludeIdentifierType(type)
     ? type
-    : resolveTypeArgumentsInDecl(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg))).type.value;
+    : resolveTypeArgumentsInDecl(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg))).type.value);
 export const serializeIncludeIdentifierType = type => ({
     ...removeParentKey(type),
     reference: type.reference.name,

package/dist/src/node/schema/types/references/NestedEntityMapType.d.ts

@@ -1,18 +1,21 @@
 import { Lazy } from "../../../../shared/utils/lazy.ts";
-import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
+import { type GetNestedDeclarations } from "../../declarations/Declaration.ts";
 import type { EntityDecl } from "../../declarations/EntityDecl.ts";
+import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.ts";
 import type { GetReferences, Node, Serializer } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
 import type { Validator } from "../../validation/type.ts";
 import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.ts";
 import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.ts";
+import { type IncludeIdentifier, type SerializedIncludeIdentifierType } from "./IncludeIdentifierType.ts";
 type TConstraint = Record<string, MemberDecl>;
+type PossibleType<T extends TConstraint> = ObjectType<T> | IncludeIdentifier<[], TypeAliasDecl<string, ObjectType<T>, []>>;
 export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;
     comment?: string;
     secondaryEntity: EntityDecl;
-    type: Lazy<ObjectType<T>>;
+    type: Lazy<PossibleType<T>>;
 }
 type TSerializedConstraint = Record<string, SerializedMemberDecl>;
 export interface SerializedNestedEntityMapType<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
@@ -20,13 +23,13 @@ export interface SerializedNestedEntityMapType<Name extends string = string, T e
     name: Name;
     comment?: string;
     secondaryEntity: string;
-    type: SerializedObjectType<T>;
+    type: SerializedObjectType<T> | SerializedIncludeIdentifierType;
 }
 export declare const NestedEntityMapType: <Name extends string, T extends TConstraint>(options: {
     name: Name;
     comment?: string;
     secondaryEntity: EntityDecl;
-    type: ObjectType<T>;
+    type: PossibleType<T>;
 }) => NestedEntityMapType<Name, T>;
 export { NestedEntityMapType as NestedEntityMap };
 export declare const isNestedEntityMapType: (node: Node) => node is NestedEntityMapType;

package/dist/src/node/schema/types/references/NestedEntityMapType.js

@@ -3,9 +3,11 @@ import { sortObjectKeysAlphabetically } from "../../../../shared/utils/object.js
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { entity, json, key as keyColor } from "../../../utils/errorFormatting.js";
+import { getNestedDeclarations, } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
-import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "../generic/ObjectType.js";
-import { formatValue, removeParentKey, setParent } from "../Type.js";
+import { getReferencesForObjectType, isObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, } from "../generic/ObjectType.js";
+import { formatValue, removeParentKey, setParent, validate } from "../Type.js";
+import { formatIncludeIdentifierValue, getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, } from "./IncludeIdentifierType.js";
 export const NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,
@@ -24,30 +26,38 @@ const _NestedEntityMapType = (options) => {
     return nestedEntityMapType;
 };
 export const isNestedEntityMapType = (node) => node.kind === NodeKind.NestedEntityMapType;
-export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type) => getNestedDeclarationsInObjectType(addedDecls.includes(type.secondaryEntity) ? addedDecls : [type.secondaryEntity, ...addedDecls], type.type.value);
+export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type) => getNestedDeclarations(addedDecls.includes(type.secondaryEntity) ? addedDecls : [type.secondaryEntity, ...addedDecls], type.type.value);
 export const validateNestedEntityMapType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
     }
-    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateObjectType(helpers, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
+    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${keyColor(`"${key}"`, helpers.useStyling)}`, validate(helpers, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
         name: type.secondaryEntity.name,
         value: key,
     })))));
 };
 export const resolveTypeArgumentsInNestedEntityMapType = (args, type) => _NestedEntityMapType({
     ...type,
-    type: () => resolveTypeArgumentsInObjectType(args, type.type.value),
+    type: () => isObjectType(type.type.value)
+        ? resolveTypeArgumentsInObjectType(args, type.type.value)
+        : resolveTypeArgumentsInIncludeIdentifierType(args, type.type.value),
 });
 export const serializeNestedEntityMapType = type => ({
     ...removeParentKey(type),
     secondaryEntity: type.secondaryEntity.name,
-    type: serializeObjectType(type.type.value),
+    type: isObjectType(type.type.value)
+        ? serializeObjectType(type.type.value)
+        : serializeIncludeIdentifierType(type.type.value),
 });
 export const getReferencesForNestedEntityMapType = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
     ? Object.values(value)
-        .flatMap(item => getReferencesForObjectType(type.type.value, item))
+        .flatMap(item => isObjectType(type.type.value)
+        ? getReferencesForObjectType(type.type.value, item)
+        : getReferencesForIncludeIdentifierType(type.type.value, item))
         .concat(Object.keys(value))
     : [];
-export const formatNestedEntityMapValue = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
-    ? sortObjectKeysAlphabetically(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, formatValue(type.type.value, item)])))
-    : value;
+export const formatNestedEntityMapValue = (type, value) => isObjectType(type.type.value)
+    ? typeof value === "object" && value !== null && !Array.isArray(value)
+        ? sortObjectKeysAlphabetically(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, formatValue(type.type.value, item)])))
+        : value
+    : formatIncludeIdentifierValue(type.type.value, value);

package/package.json

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