tsondb 0.2.0 → 0.4.0

package/lib/node/index.d.ts

@@ -0,0 +1,8 @@
+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>;

package/lib/node/index.js

@@ -0,0 +1,62 @@
+import Debug from "debug";
+import { mkdir } 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 { 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 = (entities, instancesByEntityName) => {
+    const errors = entities.flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file "${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(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(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(entities, instancesByEntityName);
+    await createServer(schema, dataRootPath, instancesByEntityName, serverOptions);
+};

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/node/renderers/jsonschema/index.d.ts

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

package/lib/node/renderers/jsonschema/index.js

@@ -0,0 +1,35 @@
+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 { render } from "./render.js";
+const extension = ".schema.json";
+export const JsonSchemaOutput = (options) => ({
+    run: async (schema) => {
+        if (options.rendererOptions?.preserveFiles === true) {
+            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)));
+            if (sourceRootPath) {
+                for (const [sourceUrl, decls] of Object.entries(declarationsBySourceUrl)) {
+                    const sourcePath = fileURLToPath(sourceUrl);
+                    const relativePath = dirname(relative(sourceRootPath, sourcePath));
+                    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 ?? []), {
+                        encoding: "utf-8",
+                    });
+                }
+            }
+        }
+        else {
+            await mkdir(dirname(options.targetPath), { recursive: true });
+            await writeFile(options.targetPath, render(options.rendererOptions, resolveTypeArgumentsInDecls(schema.declarations)), {
+                encoding: "utf-8",
+            });
+        }
+    },
+});

package/lib/node/renderers/jsonschema/render.d.ts

@@ -0,0 +1,9 @@
+import type { Decl } from "../../schema/declarations/Declaration.js";
+export type JsonSchemaRendererOptions = {
+    format: "minified" | "tabs" | {
+        kind: "spaces";
+        indentation?: number;
+    };
+    preserveFiles: boolean;
+};
+export declare const render: (options: Partial<JsonSchemaRendererOptions> | undefined, declarations: readonly Decl[]) => string;

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

@@ -1,12 +1,16 @@
+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 = {
-    indentation: 2,
+    format: { kind: "spaces" },
+    preserveFiles: false,
 };
 const renderArrayType = (options, type) => ({
     type: "array",
@@ -63,21 +67,40 @@ 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`,
 });
-const renderIncludeIdentifierType = (_options, type) => ({
-    $ref: `#/$defs/${type.reference.name}`,
-});
+const renderIncludeIdentifierType = (options, type) => {
+    const sourceUrl = getParentDecl(type)?.sourceUrl ?? "";
+    const filePath = options.preserveFiles && sourceUrl !== type.reference.sourceUrl
+        ? ensureSpecialDirStart(relative(dirname(sourceUrl), type.reference.sourceUrl))
+        : "";
+    return {
+        $ref: `${filePath}#/$defs/${type.reference.name}`,
+    };
+};
 const renderNestedEntityMapType = (_options, type) => ({
     type: "object",
     additionalProperties: {
         $ref: `#/$defs/${type.name}`,
     },
 });
+const renderEnumType = (options, type) => ({
+    oneOf: Object.entries(type.values).map(([caseName, caseDef]) => ({
+        type: "object",
+        deprecated: caseDef.isDeprecated,
+        properties: {
+            [discriminatorKey]: {
+                const: caseName,
+            },
+            ...(caseDef.type === null ? {} : { [caseName]: renderType(options, caseDef.type) }),
+        },
+        required: [discriminatorKey, ...(caseDef.type === null ? [] : [caseName])],
+    })),
+});
 const renderType = (options, type) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -94,14 +117,16 @@ 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:
             return renderIncludeIdentifierType(options, type);
         case NodeKind.NestedEntityMapType:
             return renderNestedEntityMapType(options, type);
+        case NodeKind.EnumType:
+            return renderEnumType(options, type);
         default:
             return assertExhaustive(type, "Unknown type");
     }
@@ -114,17 +139,7 @@ const renderEntityDecl = (options, decl) => ({
 const renderEnumDecl = (options, decl) => ({
     description: decl.comment,
     deprecated: decl.isDeprecated,
-    oneOf: Object.entries(decl.values.value).map(([caseName, caseDef]) => ({
-        type: "object",
-        deprecated: caseDef.isDeprecated,
-        properties: {
-            [discriminatorKey]: {
-                const: caseName,
-            },
-            ...(caseDef.type === null ? {} : { [caseName]: renderType(options, caseDef.type) }),
-        },
-        required: [discriminatorKey, ...(caseDef === null ? [] : [caseName])],
-    })),
+    ...renderEnumType(options, decl.type.value),
 });
 const renderTypeAliasDecl = (options, decl) => ({
     description: decl.comment,
@@ -160,5 +175,9 @@ export const render = (options = defaultOptions, declarations) => {
             }
             return undefined;
         }, declarations)),
-    }, undefined, finalOptions.indentation);
+    }, undefined, finalOptions.format === "minified"
+        ? undefined
+        : finalOptions.format === "tabs"
+            ? "\t"
+            : (finalOptions.format.indentation ?? defaultIndentation));
 };

package/lib/node/renderers/ts/index.d.ts

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

package/lib/node/renderers/ts/index.js

@@ -0,0 +1,42 @@
+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 { render } from "./render.js";
+const debug = Debug("tsondb:renderer:ts");
+const extension = ".d.ts";
+export const TypeScriptOutput = (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(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);
+                    const relativePath = dirname(relative(sourceRootPath, sourcePath));
+                    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 ?? []), {
+                        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, schema.declarations), {
+                encoding: "utf-8",
+            });
+            debug("emitted declarations to %s", options.targetPath);
+        }
+    },
+});

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

@@ -1,5 +1,7 @@
-import { Decl } from "../../schema/declarations/Declaration.js";
+import type { Decl } from "../../schema/declarations/Declaration.js";
 export type TypeScriptRendererOptions = {
     indentation: number;
+    objectTypeKeyword: "interface" | "type";
+    preserveFiles: boolean;
 };
 export declare const render: (options: Partial<TypeScriptRendererOptions> | undefined, declarations: readonly Decl[]) => string;

package/lib/node/renderers/ts/render.js

@@ -0,0 +1,136 @@
+import { EOL } from "node:os";
+import { dirname, relative } from "node:path";
+import { discriminatorKey } from "../../../shared/enum.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 { getParentDecl } from "../../schema/types/Type.js";
+import { ensureSpecialDirStart } from "../../utils/path.js";
+import { combineSyntaxes, indent, prefixLines, syntax } from "../../utils/render.js";
+const defaultOptions = {
+    indentation: 2,
+    objectTypeKeyword: "interface",
+    preserveFiles: false,
+};
+const renderDocumentation = (comment, isDeprecated) => syntax `${comment === undefined
+    ? ""
+    : syntax `/**
+${prefixLines(" * ", comment, true)}${isDeprecated
+        ? syntax `
+ * @deprecated`
+        : ""}
+ */
+`}`;
+const renderTypeParameters = (options, params) => syntax `${params.length === 0
+    ? ""
+    : syntax `<${combineSyntaxes(params.map(param => param.constraint === undefined
+        ? param.name
+        : syntax `${param.name} extends ${renderType(options, param.constraint)}`), ", ")}>`}`;
+const renderArrayType = (options, type) => syntax `${renderType(options, type.items)}[]`;
+const wrapAsObject = (options, str) => syntax `{${EOL}${indent(options.indentation, 1, str)}${EOL}}`;
+const renderObjectType = (options, type) => {
+    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `${renderDocumentation(config.comment, config.isDeprecated)}${name}${config.isRequired ? "" : "?"}: ${renderType(options, config.type)}`), Object.values(type.properties).some(prop => prop.comment !== undefined) ? EOL + EOL : EOL));
+};
+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 renderTypeArgumentType = (_options, type) => syntax `${type.argument.name}`;
+const renderReferenceIdentifierType = (_options, type) => [
+    { [type.entity.sourceUrl]: [type.entity.name + "_ID"] },
+    type.entity.name + "_ID",
+];
+const renderIncludeIdentifierType = (options, type) => combineSyntaxes([
+    [{ [type.reference.sourceUrl]: [type.reference.name] }, type.reference.name],
+    type.args.length === 0
+        ? ""
+        : syntax `<${combineSyntaxes(type.args.map(arg => renderType(options, arg)), ", ")}>`,
+]);
+const renderNestedEntityMapType = (options, type) => wrapAsObject(options, syntax `[${toCamelCase(type.secondaryEntity.name)}Id: string]: ${type.name}`);
+const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.values).map(([caseName, caseDef]) => indent(options.indentation, 1, syntax `${EOL}| {${EOL}${indent(options.indentation, 1, syntax `${discriminatorKey}: "${caseName}"${caseDef.type === null
+    ? ""
+    : syntax `${EOL}${caseName}: ${renderType(options, caseDef.type)}`}`)}${EOL}}`)));
+const renderType = (options, type) => {
+    switch (type.kind) {
+        case NodeKind.ArrayType:
+            return renderArrayType(options, type);
+        case NodeKind.ObjectType:
+            return renderObjectType(options, type);
+        case NodeKind.BooleanType:
+            return renderBooleanType(options, type);
+        case NodeKind.DateType:
+            return renderDateType(options, type);
+        case NodeKind.FloatType:
+            return renderNumericType(options, type);
+        case NodeKind.IntegerType:
+            return renderNumericType(options, type);
+        case NodeKind.StringType:
+            return renderStringType(options, type);
+        case NodeKind.TypeArgumentType:
+            return renderTypeArgumentType(options, type);
+        case NodeKind.ReferenceIdentifierType:
+            return renderReferenceIdentifierType(options, type);
+        case NodeKind.IncludeIdentifierType:
+            return renderIncludeIdentifierType(options, type);
+        case NodeKind.NestedEntityMapType:
+            return renderNestedEntityMapType(options, type);
+        case NodeKind.EnumType:
+            return renderEnumType(options, type);
+        default:
+            return assertExhaustive(type, "Unknown type");
+    }
+};
+const renderEntityDecl = (options, decl) => syntax `${renderDocumentation(decl.comment, decl.isDeprecated)}export ${options.objectTypeKeyword} ${decl.name} ${options.objectTypeKeyword === "type" ? "= " : ""}${renderType(options, addEphemeralUUIDToType(decl))}`;
+const renderEnumDecl = (options, decl) => syntax `${renderDocumentation(decl.comment, decl.isDeprecated)}export type ${decl.name}${renderTypeParameters(options, decl.parameters)} =${renderEnumType(options, decl.type.value)}`;
+const renderTypeAliasDecl = (options, decl) => isObjectType(decl.type.value)
+    ? syntax `${renderDocumentation(decl.comment, decl.isDeprecated)}export ${options.objectTypeKeyword} ${decl.name}${renderTypeParameters(options, decl.parameters)} ${options.objectTypeKeyword === "type" ? "= " : ""}${renderType(options, decl.type.value)}`
+    : syntax `${renderDocumentation(decl.comment, decl.isDeprecated)}export type ${decl.name}${renderTypeParameters(options, decl.parameters)} = ${renderType(options, decl.type.value)}`;
+const renderDecl = (options, decl) => {
+    switch (decl.kind) {
+        case NodeKind.EntityDecl:
+            return renderEntityDecl(options, decl);
+        case NodeKind.EnumDecl:
+            return renderEnumDecl(options, decl);
+        case NodeKind.TypeAliasDecl:
+            return renderTypeAliasDecl(options, decl);
+        default:
+            return assertExhaustive(decl, "Unknown declaration");
+    }
+};
+const renderDeclarations = (options, declarations) => combineSyntaxes(declarations.map(decl => renderDecl(options, decl)), EOL + EOL);
+const renderImports = (currentUrl, imports) => {
+    const importsSyntax = Object.entries(imports)
+        .filter(([sourceUrl]) => sourceUrl !== currentUrl)
+        .map(([sourceUrl, names]) => [
+        ensureSpecialDirStart(relative(dirname(currentUrl), sourceUrl)),
+        names,
+    ])
+        .toSorted(([sourceUrlA], [sourceUrlB]) => sourceUrlA.localeCompare(sourceUrlB))
+        .map(([sourceUrl, names]) => `import { ${names.toSorted((a, b) => a.localeCompare(b)).join(", ")} } from "${sourceUrl}"`)
+        .join(EOL);
+    return importsSyntax.length > 0 ? importsSyntax + EOL + EOL : "";
+};
+export const render = (options = defaultOptions, declarations) => {
+    const finalOptions = { ...defaultOptions, ...options };
+    const [imports, content] = renderDeclarations(finalOptions, flatMapAuxiliaryDecls(node => {
+        if (isNestedEntityMapType(node)) {
+            return TypeAliasDecl(getParentDecl(node)?.sourceUrl ?? "", {
+                name: node.name,
+                comment: node.comment,
+                type: () => node.type.value,
+            });
+        }
+        else if (isEntityDecl(node)) {
+            return createEntityIdentifierTypeAsDecl(node);
+        }
+        return undefined;
+    }, declarations));
+    return finalOptions.preserveFiles
+        ? (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,11 +14,12 @@ export interface NodeKind {
     IntegerType: "IntegerType";
     StringType: "StringType";
     DateType: "DateType";
-    GenericArgumentIdentifierType: "GenericArgumentIdentifierType";
+    TypeArgumentType: "TypeArgumentType";
     GenericParameter: "GenericParameter";
     ReferenceIdentifierType: "ReferenceIdentifierType";
     IncludeIdentifierType: "IncludeIdentifierType";
     NestedEntityMapType: "NestedEntityMapType";
+    EnumType: "EnumType";
 }
 export declare const NodeKind: NodeKind;
 export interface BaseNode {

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,11 +13,12 @@ export const NodeKind = enumOfObject({
     IntegerType: null,
     StringType: null,
     DateType: null,
-    GenericArgumentIdentifierType: null,
+    TypeArgumentType: null,
     GenericParameter: null,
     ReferenceIdentifierType: null,
     IncludeIdentifierType: null,
     NestedEntityMapType: null,
+    EnumType: null,
 });
 export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
     const mapNodeTree = (callbackFn, node, decls) => {
@@ -28,7 +29,7 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
             }
             case NodeKind.EnumDecl: {
                 const newDecls = callbackFn(node, decls);
-                return Object.values(node.values.value).reduce((newDeclsAcc, caseDef) => caseDef.type === null ? newDecls : mapNodeTree(callbackFn, caseDef.type, newDeclsAcc), newDecls);
+                return mapNodeTree(callbackFn, node.type.value, newDecls);
             }
             case NodeKind.TypeAliasDecl: {
                 const newDecls = callbackFn(node, decls);
@@ -47,11 +48,15 @@ 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:
                 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);
+            }
             default:
                 return assertExhaustive(node);
         }
@@ -69,7 +74,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,11 +1,11 @@
-import { BaseNode, GetReferences, Node, Serializer } from "../Node.js";
-import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.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 { EnumCaseDecl, EnumDecl, SerializedEnumCaseDecl, 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;
 };
@@ -16,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;
@@ -42,3 +42,4 @@ export declare const isDeclWithoutTypeParameters: (decl: Decl) => decl is DeclP<
 export declare const resolveTypeArgumentsInDecls: (decls: readonly Decl[]) => DeclP<[]>[];
 export declare const serializeDecl: Serializer<Decl, SerializedDecl>;
 export declare const getReferencesForDecl: GetReferences<Decl>;
+export declare const groupDeclarationsBySourceUrl: (decls: readonly Decl[]) => Partial<Record<string, Decl[]>>;

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

@@ -1,7 +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 { 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";
@@ -9,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:
@@ -27,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);
@@ -35,6 +38,8 @@ export const getNestedDeclarations = (addedDecls, node) => {
             return getNestedDeclarationsInIncludeIdentifierType(addedDecls, node);
         case NodeKind.NestedEntityMapType:
             return getNestedDeclarationsInNestedEntityMapType(addedDecls, node);
+        case NodeKind.EnumType:
+            return getNestedDeclarationsInEnumType(addedDecls, node);
         default:
             return assertExhaustive(node);
     }
@@ -96,3 +101,4 @@ export const getReferencesForDecl = (decl, value) => {
             return assertExhaustive(decl);
     }
 };
+export const groupDeclarationsBySourceUrl = (decls) => Object.groupBy(decls, decl => decl.sourceUrl);