tsondb 0.3.0 → 0.5.0

package/lib/{Schema.js → node/Schema.js}

@@ -1,13 +1,14 @@
-import { getNestedDeclarations, getParameterNames, } from "./schema/declarations/Declaration.js";
+import { getNestedDeclarations, getParameterNames } from "./schema/declarations/Declaration.js";
 import { isEntityDecl } from "./schema/declarations/EntityDecl.js";
 import { isStringType } from "./schema/types/primitives/StringType.js";
 import { isNestedEntityMapType } from "./schema/types/references/NestedEntityMapType.js";
 import { findTypeAtPath } from "./schema/types/Type.js";
 const checkDuplicateIdentifier = (existingDecls, decl) => {
-    if (existingDecls
+    const existingDeclWithSameName = existingDecls
         .values()
-        .some(otherDecl => otherDecl !== decl && otherDecl.name.toLowerCase() === decl.name.toLowerCase())) {
-        throw new Error(`Duplicate declaration name: "${decl.name}". Make sure declaration names are globally unique.`);
+        .find(otherDecl => otherDecl !== decl && otherDecl.name.toLowerCase() === decl.name.toLowerCase());
+    if (existingDeclWithSameName) {
+        throw new Error(`Duplicate declaration name "${decl.name}" in "${decl.sourceUrl}" and "${existingDeclWithSameName.sourceUrl}". Make sure declaration names are globally unique.`);
     }
 };
 const checkParameterNamesShadowing = (decls) => {
@@ -21,7 +22,7 @@ const checkParameterNamesShadowing = (decls) => {
 };
 const checkEntityDisplayNamePaths = (decls, localeEntity) => {
     for (const decl of decls) {
-        if (isEntityDecl(decl)) {
+        if (isEntityDecl(decl) && decl.displayName !== null) {
             const displayName = decl.displayName ?? "name";
             if (typeof displayName === "object") {
                 const pathToLocaleMap = displayName.pathToLocaleMap ?? "translations";

package/lib/node/index.d.ts

@@ -0,0 +1,9 @@
+import type { Output } from "./renderers/Output.ts";
+import type { Schema } from "./Schema.ts";
+import type { ServerOptions } from "./server/index.ts";
+export declare const generateOutputs: (schema: Schema, outputs: Output[]) => Promise<void>;
+export declare const validate: (schema: Schema, dataRootPath: string) => Promise<void>;
+export declare const generateAndValidate: (schema: Schema, outputs: Output[], dataRootPath: string) => Promise<void>;
+export declare const serve: (schema: Schema, dataRootPath: string, serverOptions?: Partial<ServerOptions>) => Promise<void>;
+export declare const generateValidateAndServe: (schema: Schema, outputs: Output[], dataRootPath: string, serverOptions?: Partial<ServerOptions>) => Promise<void>;
+export declare const format: (schema: Schema, dataRootPath: string) => Promise<void>;

package/lib/node/index.js

@@ -0,0 +1,75 @@
+import Debug from "debug";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { parallelizeErrors } from "../shared/utils/validation.js";
+import { getEntities } from "./Schema.js";
+import { createValidators, validateEntityDecl } from "./schema/index.js";
+import { createServer } from "./server/index.js";
+import { getErrorMessageForDisplay, wrapErrorsIfAny } from "./utils/error.js";
+import { formatInstance, getInstancesByEntityName } from "./utils/instances.js";
+const debug = Debug("tsondb:schema");
+const prepareFolders = async (dataRootPath, entities) => {
+    await mkdir(dataRootPath, { recursive: true });
+    for (const entity of entities) {
+        const entityDir = join(dataRootPath, entity.name);
+        await mkdir(entityDir, { recursive: true });
+    }
+};
+export const generateOutputs = async (schema, outputs) => {
+    for (const output of outputs) {
+        await output.run(schema);
+    }
+};
+const _validate = (dataRootPath, entities, instancesByEntityName) => {
+    const errors = entities.flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file "${join(dataRootPath, entity.name, instance.fileName)}"`, validateEntityDecl(createValidators(instancesByEntityName), entity, instance.content))) ?? []));
+    if (errors.length === 0) {
+        debug("All entities are valid");
+    }
+    else {
+        debug("Errors:\n");
+        for (const error of errors) {
+            debug(getErrorMessageForDisplay(error) + "\n");
+        }
+        throw new Error("Validation failed");
+    }
+};
+export const validate = async (schema, dataRootPath) => {
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    _validate(dataRootPath, entities, instancesByEntityName);
+};
+export const generateAndValidate = async (schema, outputs, dataRootPath) => {
+    await generateOutputs(schema, outputs);
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    _validate(dataRootPath, entities, instancesByEntityName);
+};
+export const serve = async (schema, dataRootPath, serverOptions) => {
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
+};
+export const generateValidateAndServe = async (schema, outputs, dataRootPath, serverOptions) => {
+    await generateOutputs(schema, outputs);
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    _validate(dataRootPath, entities, instancesByEntityName);
+    await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
+};
+export const format = async (schema, dataRootPath) => {
+    const entities = getEntities(schema);
+    await prepareFolders(dataRootPath, entities);
+    const instancesByEntityName = await getInstancesByEntityName(dataRootPath, entities);
+    for (const entityName in instancesByEntityName) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const entity = entities.find(entity => entity.name === entityName);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        for (const instance of instancesByEntityName[entityName]) {
+            await writeFile(join(dataRootPath, entityName, instance.fileName), formatInstance(entity, instance.content), { encoding: "utf-8" });
+        }
+    }
+};

package/lib/{renderers → node/renderers}/Output.d.ts

@@ -1,4 +1,4 @@
-import { Schema } from "../Schema.js";
+import type { Schema } from "../Schema.js";
 export interface Output {
     run: (schema: Schema) => Promise<void>;
 }

package/lib/{renderers → node/renderers}/jsonschema/index.d.ts

@@ -1,5 +1,5 @@
-import { Output } from "../Output.js";
-import { JsonSchemaRendererOptions } from "./render.js";
+import type { Output } from "../Output.js";
+import type { JsonSchemaRendererOptions } from "./render.js";
 export declare const JsonSchemaOutput: (options: {
     targetPath: string;
     rendererOptions?: Partial<JsonSchemaRendererOptions>;

package/lib/{renderers → node/renderers}/jsonschema/index.js

@@ -1,17 +1,21 @@
+import Debug from "debug";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import { commonPrefix } from "../../../shared/utils/string.js";
 import { groupDeclarationsBySourceUrl, resolveTypeArgumentsInDecls } from "../../schema/index.js";
-import { commonPrefix } from "../../shared/utils/string.js";
 import { render } from "./render.js";
+const debug = Debug("tsondb:renderer:jsonschema");
 const extension = ".schema.json";
 export const JsonSchemaOutput = (options) => ({
     run: async (schema) => {
         if (options.rendererOptions?.preserveFiles === true) {
+            debug("emitting declarations to multiple files...");
             await rm(options.targetPath, { recursive: true, force: true });
             await mkdir(options.targetPath, { recursive: true });
             const declarationsBySourceUrl = groupDeclarationsBySourceUrl(resolveTypeArgumentsInDecls(schema.declarations));
             const sourceRootPath = fileURLToPath(commonPrefix(...Object.keys(declarationsBySourceUrl)));
+            debug("common source root path: %s", sourceRootPath);
             if (sourceRootPath) {
                 for (const [sourceUrl, decls] of Object.entries(declarationsBySourceUrl)) {
                     const sourcePath = fileURLToPath(sourceUrl);
@@ -19,17 +23,20 @@ export const JsonSchemaOutput = (options) => ({
                     const newDir = join(options.targetPath, relativePath);
                     const newPath = join(newDir, basename(sourcePath, extname(sourcePath)) + extension);
                     await mkdir(newDir, { recursive: true });
-                    await writeFile(newPath, render(options.rendererOptions, decls), {
+                    await writeFile(newPath, render(options.rendererOptions, decls ?? []), {
                         encoding: "utf-8",
                     });
                 }
+                debug("emitted declaration files to %s", options.targetPath);
             }
         }
         else {
+            debug("emitting declarations to single file...");
             await mkdir(dirname(options.targetPath), { recursive: true });
             await writeFile(options.targetPath, render(options.rendererOptions, resolveTypeArgumentsInDecls(schema.declarations)), {
                 encoding: "utf-8",
             });
+            debug("emitted declarations to %s", options.targetPath);
         }
     },
 });

package/lib/{renderers → node/renderers}/jsonschema/render.d.ts

@@ -1,4 +1,4 @@
-import { Decl } from "../../schema/declarations/Declaration.js";
+import type { Decl } from "../../schema/declarations/Declaration.js";
 export type JsonSchemaRendererOptions = {
     format: "minified" | "tabs" | {
         kind: "spaces";

package/lib/{renderers → node/renderers}/jsonschema/render.js

@@ -1,11 +1,11 @@
 import { dirname, relative } from "node:path";
+import { discriminatorKey } from "../../../shared/enum.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
-import { isNestedEntityMapType, } from "../../schema/types/references/NestedEntityMapType.js";
+import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { getParentDecl } from "../../schema/types/Type.js";
-import { discriminatorKey } from "../../shared/enum.js";
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 const defaultIndentation = 2;
 const defaultOptions = {
@@ -67,8 +67,8 @@ const renderStringType = (_options, type) => ({
     maxLength: type.maxLength,
     pattern: type.pattern?.source,
 });
-const renderGenericArgumentIdentifierType = (_options, _type) => {
-    throw new TypeError("GenericArgumentIdentifierType is not supported in JSON Schema.");
+const renderTypeArgumentType = (_options, _type) => {
+    throw new TypeError("TypeArgumentType is not supported in JSON Schema.");
 };
 const renderReferenceIdentifierType = (_options, type) => ({
     $ref: `#/$defs/${type.entity.name}_ID`,
@@ -98,7 +98,7 @@ const renderEnumType = (options, type) => ({
             },
             ...(caseDef.type === null ? {} : { [caseName]: renderType(options, caseDef.type) }),
         },
-        required: [discriminatorKey, ...(caseDef === null ? [] : [caseName])],
+        required: [discriminatorKey, ...(caseDef.type === null ? [] : [caseName])],
     })),
 });
 const renderType = (options, type) => {
@@ -117,8 +117,8 @@ const renderType = (options, type) => {
             return renderIntegerType(options, type);
         case NodeKind.StringType:
             return renderStringType(options, type);
-        case NodeKind.GenericArgumentIdentifierType:
-            return renderGenericArgumentIdentifierType(options, type);
+        case NodeKind.TypeArgumentType:
+            return renderTypeArgumentType(options, type);
         case NodeKind.ReferenceIdentifierType:
             return renderReferenceIdentifierType(options, type);
         case NodeKind.IncludeIdentifierType:
@@ -162,8 +162,13 @@ const renderDeclarations = (options, declarations) => Object.fromEntries(declara
 export const render = (options = defaultOptions, declarations) => {
     const finalOptions = { ...defaultOptions, ...options };
     return JSON.stringify({
-        $defs: renderDeclarations(finalOptions, flatMapAuxiliaryDecls(node => {
+        $defs: renderDeclarations(finalOptions, flatMapAuxiliaryDecls((node, existingDecls) => {
             if (isNestedEntityMapType(node)) {
+                if (existingDecls.some(decl => decl.name === node.name)) {
+                    // this may happen when a nested entity map is defined in a generic declaration and the generic declaration is used multiple times
+                    // TODO: circumvent by defining the nested entity declaration outside the generic declaration
+                    return undefined;
+                }
                 return TypeAliasDecl(getParentDecl(node)?.sourceUrl ?? "", {
                     name: node.name,
                     comment: node.comment,
@@ -179,5 +184,5 @@ export const render = (options = defaultOptions, declarations) => {
         ? undefined
         : finalOptions.format === "tabs"
             ? "\t"
-            : finalOptions.format.indentation ?? defaultIndentation);
+            : (finalOptions.format.indentation ?? defaultIndentation));
 };

package/lib/{renderers → node/renderers}/ts/index.d.ts

@@ -1,5 +1,5 @@
-import { Output } from "../Output.js";
-import { TypeScriptRendererOptions } from "./render.js";
+import type { Output } from "../Output.js";
+import type { TypeScriptRendererOptions } from "./render.js";
 export declare const TypeScriptOutput: (options: {
     targetPath: string;
     rendererOptions?: Partial<TypeScriptRendererOptions>;

package/lib/{renderers → node/renderers}/ts/index.js

@@ -2,8 +2,8 @@ import Debug from "debug";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import { commonPrefix } from "../../../shared/utils/string.js";
 import { groupDeclarationsBySourceUrl } from "../../schema/declarations/Declaration.js";
-import { commonPrefix } from "../../shared/utils/string.js";
 import { render } from "./render.js";
 const debug = Debug("tsondb:renderer:ts");
 const extension = ".d.ts";
@@ -23,7 +23,7 @@ export const TypeScriptOutput = (options) => ({
                     const newDir = join(options.targetPath, relativePath);
                     const newPath = join(newDir, basename(sourcePath, extname(sourcePath)) + extension);
                     await mkdir(newDir, { recursive: true });
-                    await writeFile(newPath, render(options.rendererOptions, decls), {
+                    await writeFile(newPath, render(options.rendererOptions, decls ?? []), {
                         encoding: "utf-8",
                     });
                 }

package/lib/{renderers → node/renderers}/ts/render.d.ts

@@ -1,4 +1,4 @@
-import { Decl } from "../../schema/declarations/Declaration.js";
+import type { Decl } from "../../schema/declarations/Declaration.js";
 export type TypeScriptRendererOptions = {
     indentation: number;
     objectTypeKeyword: "interface" | "type";

package/lib/{renderers → node/renderers}/ts/render.js

@@ -1,14 +1,15 @@
 import { EOL } from "node:os";
 import { dirname, relative } from "node:path";
+import { discriminatorKey } from "../../../shared/enum.js";
+import { unique } from "../../../shared/utils/array.js";
+import { toCamelCase } from "../../../shared/utils/string.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
 import { isObjectType } from "../../schema/types/generic/ObjectType.js";
-import { isNestedEntityMapType, } from "../../schema/types/references/NestedEntityMapType.js";
+import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { getParentDecl } from "../../schema/types/Type.js";
-import { discriminatorKey } from "../../shared/enum.js";
-import { toCamelCase } from "../../shared/utils/string.js";
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
 import { combineSyntaxes, indent, prefixLines, syntax } from "../../utils/render.js";
 const defaultOptions = {
@@ -39,7 +40,7 @@ const renderBooleanType = (_options, _type) => syntax `boolean`;
 const renderDateType = (_options, _type) => syntax `Date`;
 const renderNumericType = (_options, _type) => syntax `number`;
 const renderStringType = (_options, _type) => syntax `string`;
-const renderGenericArgumentIdentifierType = (_options, type) => syntax `${type.argument.name}`;
+const renderTypeArgumentType = (_options, type) => syntax `${type.argument.name}`;
 const renderReferenceIdentifierType = (_options, type) => [
     { [type.entity.sourceUrl]: [type.entity.name + "_ID"] },
     type.entity.name + "_ID",
@@ -70,8 +71,8 @@ const renderType = (options, type) => {
             return renderNumericType(options, type);
         case NodeKind.StringType:
             return renderStringType(options, type);
-        case NodeKind.GenericArgumentIdentifierType:
-            return renderGenericArgumentIdentifierType(options, type);
+        case NodeKind.TypeArgumentType:
+            return renderTypeArgumentType(options, type);
         case NodeKind.ReferenceIdentifierType:
             return renderReferenceIdentifierType(options, type);
         case NodeKind.IncludeIdentifierType:
@@ -110,7 +111,9 @@ const renderImports = (currentUrl, imports) => {
         names,
     ])
         .toSorted(([sourceUrlA], [sourceUrlB]) => sourceUrlA.localeCompare(sourceUrlB))
-        .map(([sourceUrl, names]) => `import { ${names.toSorted((a, b) => a.localeCompare(b)).join(", ")} } from "${sourceUrl}"`)
+        .map(([sourceUrl, names]) => `import { ${unique(names)
+        .toSorted((a, b) => a.localeCompare(b))
+        .join(", ")} } from "${sourceUrl}"`)
         .join(EOL);
     return importsSyntax.length > 0 ? importsSyntax + EOL + EOL : "";
 };
@@ -130,6 +133,7 @@ export const render = (options = defaultOptions, declarations) => {
         return undefined;
     }, declarations));
     return finalOptions.preserveFiles
-        ? renderImports(declarations[0].sourceUrl, imports) + content
+        ? (declarations[0] === undefined ? "" : renderImports(declarations[0].sourceUrl, imports)) +
+            content
         : content;
 };

package/lib/{schema → node/schema}/Node.d.ts

@@ -1,6 +1,6 @@
-import { InstancesByEntityName } from "../shared/utils/instances.js";
-import { Decl } from "./declarations/Declaration.js";
-import { Type } from "./types/Type.js";
+import type { InstancesByEntityName } from "../../shared/utils/instances.js";
+import type { Decl } from "./declarations/Declaration.js";
+import type { Type } from "./types/Type.js";
 export interface NodeKind {
     EntityDecl: "EntityDecl";
     EnumDecl: "EnumDecl";
@@ -14,7 +14,7 @@ export interface NodeKind {
     IntegerType: "IntegerType";
     StringType: "StringType";
     DateType: "DateType";
-    GenericArgumentIdentifierType: "GenericArgumentIdentifierType";
+    TypeArgumentType: "TypeArgumentType";
     GenericParameter: "GenericParameter";
     ReferenceIdentifierType: "ReferenceIdentifierType";
     IncludeIdentifierType: "IncludeIdentifierType";
@@ -26,7 +26,7 @@ export interface BaseNode {
     kind: (typeof NodeKind)[keyof typeof NodeKind];
 }
 export type Node = Decl | Type;
-export declare const flatMapAuxiliaryDecls: (callbackFn: (node: Node) => (Decl | undefined)[] | Decl | undefined, declarations: readonly Decl[]) => Decl[];
+export declare const flatMapAuxiliaryDecls: (callbackFn: (node: Node, existingDecls: Decl[]) => (Decl | undefined)[] | Decl | undefined, declarations: readonly Decl[]) => Decl[];
 export type IdentifierToCheck = {
     name: string;
     value: unknown;

package/lib/{schema → node/schema}/Node.js

@@ -1,5 +1,5 @@
-import { assertExhaustive } from "../shared/utils/typeSafety.js";
-import { enumOfObject } from "../utils/enum.js";
+import { enumOfObject } from "../../shared/utils/enum.js";
+import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 export const NodeKind = enumOfObject({
     EntityDecl: null,
     EnumDecl: null,
@@ -13,7 +13,7 @@ export const NodeKind = enumOfObject({
     IntegerType: null,
     StringType: null,
     DateType: null,
-    GenericArgumentIdentifierType: null,
+    TypeArgumentType: null,
     GenericParameter: null,
     ReferenceIdentifierType: null,
     IncludeIdentifierType: null,
@@ -48,7 +48,7 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
             case NodeKind.FloatType:
             case NodeKind.IntegerType:
             case NodeKind.StringType:
-            case NodeKind.GenericArgumentIdentifierType:
+            case NodeKind.TypeArgumentType:
             case NodeKind.ReferenceIdentifierType:
             case NodeKind.IncludeIdentifierType:
             case NodeKind.NestedEntityMapType:
@@ -62,11 +62,12 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
         }
     };
     const reducer = (node, decls) => {
-        const result = callbackFn(node);
+        const result = callbackFn(node, decls);
         const normalizedResult = (Array.isArray(result) ? result : [result]).filter(decl => decl !== undefined);
         normalizedResult.forEach(decl => {
-            if (decls.some(existingDecl => existingDecl.name === decl.name)) {
-                throw new Error(`Duplicate declaration name: "${decl.name}". Make sure declaration names are globally unique.`);
+            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);
@@ -74,7 +75,7 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
     return declarations.reduce((decls, node) => mapNodeTree(reducer, node, [...decls, node]), []);
 };
 export const createValidators = (instancesByEntityName) => ({
-    checkReferentialIntegrity: ({ name, value }) => instancesByEntityName[name].some(instance => typeof instance.content === "object" &&
+    checkReferentialIntegrity: ({ name, value }) => instancesByEntityName[name]?.some(instance => typeof instance.content === "object" &&
         instance.content !== null &&
         !Array.isArray(instance.content) &&
         instance.id === value)

package/lib/{schema/parameters → node/schema}/TypeParameter.d.ts

@@ -1,5 +1,6 @@
-import { NodeKind, Serializer } from "../Node.js";
-import { SerializedBaseType, SerializedType, Type } from "../types/Type.js";
+import type { Serializer } from "./Node.js";
+import { NodeKind } from "./Node.js";
+import type { SerializedBaseType, SerializedType, Type } from "./types/Type.js";
 export interface TypeParameter<N extends string = string, T extends Type = Type> {
     kind: NodeKind["GenericParameter"];
     name: N;

package/lib/{schema/parameters → node/schema}/TypeParameter.js

@@ -1,5 +1,5 @@
-import { NodeKind } from "../Node.js";
-import { removeParentKey, serializeType, } from "../types/Type.js";
+import { NodeKind } from "./Node.js";
+import { removeParentKey, serializeType } from "./types/Type.js";
 export const Param = (name, constraint) => ({
     kind: NodeKind.GenericParameter,
     name,

package/lib/{schema → node/schema}/declarations/Declaration.d.ts

@@ -1,12 +1,11 @@
-import { BaseNode, GetReferences, Node, Serializer } from "../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { EnumCaseDecl, SerializedEnumCaseDecl } from "../types/generic/EnumType.js";
-import { ObjectType, SerializedObjectType } from "../types/generic/ObjectType.js";
-import { SerializedType, Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { EntityDecl, SerializedEntityDecl } from "./EntityDecl.js";
-import { EnumDecl, SerializedEnumDecl } from "./EnumDecl.js";
-import { SerializedTypeAliasDecl, TypeAliasDecl } from "./TypeAliasDecl.js";
+import type { BaseNode, GetReferences, Node, Serializer } from "../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.js";
+import type { EnumCaseDecl, SerializedEnumCaseDecl } from "../types/generic/EnumType.js";
+import type { SerializedType, Type } from "../types/Type.js";
+import type { ValidatorHelpers } from "../validation/type.js";
+import type { EntityDecl, SerializedEntityDecl } from "./EntityDecl.js";
+import type { EnumDecl, SerializedEnumDecl } from "./EnumDecl.js";
+import type { SerializedTypeAliasDecl, TypeAliasDecl } from "./TypeAliasDecl.js";
 export type TypeArguments<Params extends TypeParameter[]> = {
     [K in keyof Params]: Params[K] extends TypeParameter<string, infer T> ? T : Type;
 };
@@ -17,8 +16,8 @@ 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<string, ObjectType> | EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
-export type SerializedDeclP<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> = SerializedEntityDecl<string, SerializedObjectType> | SerializedEnumDecl<string, Record<string, SerializedEnumCaseDecl>, Params> | SerializedTypeAliasDecl<string, SerializedType, Params>;
+export type DeclP<Params extends TypeParameter[] = TypeParameter[]> = EntityDecl | 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;

package/lib/{schema → node/schema}/declarations/Declaration.js

@@ -1,8 +1,8 @@
-import { assertExhaustive } from "../../shared/utils/typeSafety.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { NodeKind } from "../Node.js";
 import { getNestedDeclarationsInArrayType } from "../types/generic/ArrayType.js";
-import { getNestedDeclarationsInEnumType, } from "../types/generic/EnumType.js";
-import { getNestedDeclarationsInObjectType, } from "../types/generic/ObjectType.js";
+import { getNestedDeclarationsInEnumType } from "../types/generic/EnumType.js";
+import { getNestedDeclarationsInObjectType } from "../types/generic/ObjectType.js";
 import { getNestedDeclarationsInIncludeIdentifierType } from "../types/references/IncludeIdentifierType.js";
 import { getNestedDeclarationsInNestedEntityMapType } from "../types/references/NestedEntityMapType.js";
 import { getNestedDeclarationsInReferenceIdentifierType } from "../types/references/ReferenceIdentifierType.js";
@@ -10,7 +10,9 @@ import { getNestedDeclarationsInEntityDecl, getReferencesForEntityDecl, isEntity
 import { getNestedDeclarationsInEnumDecl, getReferencesForEnumDecl, isEnumDecl, resolveTypeArgumentsInEnumDecl, serializeEnumDecl, validateEnumDecl, } from "./EnumDecl.js";
 import { getNestedDeclarationsInTypeAliasDecl, getReferencesForTypeAliasDecl, isTypeAliasDecl, resolveTypeArgumentsInTypeAliasDecl, serializeTypeAliasDecl, validateTypeAliasDecl, } from "./TypeAliasDecl.js";
 export const getParameterNames = (decl) => decl.parameters.map(param => param.name);
-export const getTypeArgumentsRecord = (decl, args) => Object.fromEntries(args.map((arg, i) => [decl.parameters[i].name, arg]));
+export const getTypeArgumentsRecord = (decl, args) => Object.fromEntries(
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+args.slice(0, decl.parameters.length).map((arg, i) => [decl.parameters[i].name, arg]));
 export const getNestedDeclarations = (addedDecls, node) => {
     switch (node.kind) {
         case NodeKind.EntityDecl:
@@ -28,7 +30,7 @@ export const getNestedDeclarations = (addedDecls, node) => {
         case NodeKind.FloatType:
         case NodeKind.IntegerType:
         case NodeKind.StringType:
-        case NodeKind.GenericArgumentIdentifierType:
+        case NodeKind.TypeArgumentType:
             return addedDecls;
         case NodeKind.ReferenceIdentifierType:
             return getNestedDeclarationsInReferenceIdentifierType(addedDecls, node);

package/lib/{schema → node/schema}/declarations/EntityDecl.d.ts

@@ -1,11 +1,12 @@
-import { Lazy } from "../../utils/lazy.js";
-import { Leaves } from "../../utils/object.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
-import { MemberDecl, ObjectType, SerializedObjectType } from "../types/generic/ObjectType.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
+import type { Leaves } from "../../../shared/utils/object.js";
+import type { GetReferences, Node, Serializer } from "../Node.js";
+import { NodeKind } from "../Node.js";
+import type { MemberDecl, ObjectType, SerializedObjectType } from "../types/generic/ObjectType.js";
 import { StringType } from "../types/primitives/StringType.js";
-import { AsType, SerializedAsType, Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.js";
+import type { AsType, SerializedAsType } from "../types/Type.js";
+import type { ValidatorHelpers } from "../validation/type.js";
+import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.js";
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export interface EntityDecl<Name extends string = string, T extends ObjectType = ObjectType> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
@@ -23,7 +24,7 @@ export interface EntityDecl<Name extends string = string, T extends ObjectType =
          * @default "name"
          */
         pathInLocaleMap?: string;
-    };
+    } | null;
     isDeprecated?: boolean;
 }
 export interface SerializedEntityDecl<Name extends string = string, T extends SerializedObjectType = SerializedObjectType> extends SerializedBaseDecl<Name, []> {
@@ -42,7 +43,7 @@ export interface SerializedEntityDecl<Name extends string = string, T extends Se
          * @default "name"
          */
         pathInLocaleMap?: string;
-    };
+    } | null;
     isDeprecated?: boolean;
 }
 export declare const EntityDecl: <Name extends string, T extends ObjectType>(sourceUrl: string, options: {
@@ -62,7 +63,7 @@ export declare const EntityDecl: <Name extends string, T extends ObjectType>(sou
          * @default "name"
          */
         pathInLocaleMap?: string;
-    };
+    } | null;
     isDeprecated?: boolean;
 }) => EntityDecl<Name, T>;
 export { EntityDecl as Entity };
@@ -70,10 +71,10 @@ export declare const isEntityDecl: (node: Node) => node is EntityDecl;
 export declare const getNestedDeclarationsInEntityDecl: GetNestedDeclarations<EntityDecl>;
 export declare const validateEntityDecl: (helpers: ValidatorHelpers, decl: EntityDecl, value: unknown) => Error[];
 export declare const resolveTypeArgumentsInEntityDecl: (decl: EntityDecl) => EntityDecl;
-export declare const addEphemeralUUIDToType: <T extends Record<string, MemberDecl<Type, boolean>>>(decl: EntityDecl<string, ObjectType<T>>) => ObjectType<Omit<T, "id"> & {
+export declare const addEphemeralUUIDToType: <T extends Record<string, MemberDecl>>(decl: EntityDecl<string, ObjectType<T>>) => ObjectType<Omit<T, "id"> & {
     id: MemberDecl<StringType, true>;
 }>;
 export declare const createEntityIdentifierType: () => StringType;
-export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name, ObjectType>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
+export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
 export declare const serializeEntityDecl: Serializer<EntityDecl, SerializedEntityDecl>;
 export declare const getReferencesForEntityDecl: GetReferences<EntityDecl>;

package/lib/{schema → node/schema}/declarations/EntityDecl.js

@@ -1,9 +1,9 @@
-import { Lazy } from "../../utils/lazy.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
 import { NodeKind } from "../Node.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, Required, resolveTypeArgumentsInObjectType, serializeObjectType, } from "../types/generic/ObjectType.js";
 import { StringType } from "../types/primitives/StringType.js";
-import { validate } from "../types/Type.js";
-import { validateDeclName, } from "./Declaration.js";
+import { setParent, validate } from "../types/Type.js";
+import { validateDeclName } from "./Declaration.js";
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export const EntityDecl = (sourceUrl, options) => {
     validateDeclName(options.name);
@@ -19,8 +19,7 @@ export const EntityDecl = (sourceUrl, options) => {
                     throw new TypeError(`Invalid object key "${key}" for entity "${options.name}". The key "id" is reserved for the entity identifier.`);
                 }
             });
-            type.parent = decl;
-            return type;
+            return setParent(type, decl);
         }),
     };
     return decl;

package/lib/{schema → node/schema}/declarations/EnumDecl.d.ts

@@ -1,10 +1,12 @@
-import { Lazy } from "../../utils/lazy.js";
-import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { EnumCaseDecl, EnumType, SerializedEnumCaseDecl, SerializedEnumType } from "../types/generic/EnumType.js";
-import { Type } from "../types/Type.js";
-import { ValidatorHelpers } from "../validation/type.js";
-import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
+import { Lazy } from "../../../shared/utils/lazy.js";
+import type { GetReferences, Node, Serializer } from "../Node.js";
+import { NodeKind } from "../Node.js";
+import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.js";
+import type { EnumCaseDecl, SerializedEnumCaseDecl, SerializedEnumType } from "../types/generic/EnumType.js";
+import { EnumType } from "../types/generic/EnumType.js";
+import { type Type } from "../types/Type.js";
+import type { ValidatorHelpers } from "../validation/type.js";
+import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl, TypeArguments } from "./Declaration.js";
 export interface EnumDecl<Name extends string = string, T extends Record<string, EnumCaseDecl> = Record<string, EnumCaseDecl>, Params extends TypeParameter[] = TypeParameter[]> extends BaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
     type: Lazy<EnumType<T>>;