tsondb 0.2.0 → 0.3.0

package/lib/client/utils/typeSkeleton.js

@@ -26,25 +26,19 @@ export const createTypeSkeleton = (getDeclFromDeclName, type) => {
             if (referencedDecl === undefined) {
                 return undefined;
             }
-            switch (referencedDecl.kind) {
-                case "TypeAliasDecl":
-                    return createTypeSkeleton(getDeclFromDeclName, referencedDecl.type);
-                case "EnumDecl": {
-                    const firstCase = Object.entries(referencedDecl.values)[0];
-                    if (firstCase[1].type === null) {
-                        return { kind: firstCase[0] };
-                    }
-                    return {
-                        kind: firstCase[0],
-                        [firstCase[0]]: createTypeSkeleton(getDeclFromDeclName, firstCase[1].type),
-                    };
-                }
-                default:
-                    return assertExhaustive(referencedDecl);
-            }
+            return createTypeSkeleton(getDeclFromDeclName, referencedDecl.type);
         }
         case "NestedEntityMapType":
             return {};
+        case "EnumType": {
+            const firstCase = Object.entries(type.values)[0];
+            return {
+                kind: firstCase[0],
+                ...(firstCase[1].type === null
+                    ? {}
+                    : { [firstCase[0]]: createTypeSkeleton(getDeclFromDeclName, firstCase[1].type) }),
+            };
+        }
         default:
             return assertExhaustive(type);
     }

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

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

package/lib/renderers/jsonschema/index.js

@@ -1,12 +1,35 @@
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { resolveTypeArgumentsInDecls } from "../../schema/index.js";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { groupDeclarationsBySourceUrl, resolveTypeArgumentsInDecls } from "../../schema/index.js";
+import { commonPrefix } from "../../shared/utils/string.js";
 import { render } from "./render.js";
+const extension = ".schema.json";
 export const JsonSchemaOutput = (options) => ({
     run: async (schema) => {
-        await mkdir(dirname(options.targetPath), { recursive: true });
-        await writeFile(options.targetPath, render(options.rendererOptions, resolveTypeArgumentsInDecls(schema.declarations)), {
-            encoding: "utf-8",
-        });
+        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/renderers/jsonschema/render.d.ts

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

package/lib/renderers/jsonschema/render.js

@@ -1,3 +1,4 @@
+import { dirname, relative } from "node:path";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
@@ -5,8 +6,11 @@ import { isNestedEntityMapType, } from "../../schema/types/references/NestedEnti
 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",
@@ -69,15 +73,34 @@ const renderGenericArgumentIdentifierType = (_options, _type) => {
 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 === null ? [] : [caseName])],
+    })),
+});
 const renderType = (options, type) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -102,6 +125,8 @@ const renderType = (options, type) => {
             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/renderers/ts/index.d.ts

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

package/lib/renderers/ts/index.js

@@ -1,11 +1,42 @@
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
+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 { 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";
 export const TypeScriptOutput = (options) => ({
     run: async (schema) => {
-        await mkdir(dirname(options.targetPath), { recursive: true });
-        await writeFile(options.targetPath, render(options.rendererOptions, schema.declarations), {
-            encoding: "utf-8",
-        });
+        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/ts/render.d.ts

@@ -1,5 +1,7 @@
 import { 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/renderers/ts/render.js

@@ -1,4 +1,5 @@
 import { EOL } from "node:os";
+import { dirname, relative } from "node:path";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
@@ -8,11 +9,14 @@ 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 { applyIndentation, joinSyntax, prefixLines, syntax } from "../../utils/render.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) => comment === undefined
+const renderDocumentation = (comment, isDeprecated) => syntax `${comment === undefined
     ? ""
     : syntax `/**
 ${prefixLines(" * ", comment, true)}${isDeprecated
@@ -20,29 +24,36 @@ ${prefixLines(" * ", comment, true)}${isDeprecated
  * @deprecated`
         : ""}
  */
-`;
-const renderTypeParameters = (options, params) => params.length === 0
+`}`;
+const renderTypeParameters = (options, params) => syntax `${params.length === 0
     ? ""
-    : `<${params
-        .map(param => param.constraint === undefined
+    : syntax `<${combineSyntaxes(params.map(param => param.constraint === undefined
         ? param.name
-        : joinSyntax(param.name, " extends ", renderType(options, param.constraint)))
-        .join(", ")}>`;
-const renderArrayType = (options, type) => `${renderType(options, type.items)}[]`;
-const wrapAsObject = (options, syntax) => joinSyntax("{", EOL, applyIndentation(1, syntax, options.indentation), EOL, "}");
+        : 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, Object.entries(type.properties)
-        .map(([name, config]) => joinSyntax(renderDocumentation(config.comment, config.isDeprecated), name, config.isRequired ? "" : "?", ": ", renderType(options, config.type)))
-        .join(Object.values(type.properties).some(prop => prop.comment !== undefined) ? EOL + EOL : EOL));
+    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) => "boolean";
-const renderDateType = (_options, _type) => "Date";
-const renderNumericType = (_options, _type) => "number";
-const renderStringType = (_options, _type) => "string";
-const renderGenericArgumentIdentifierType = (_options, type) => type.argument.name;
-const renderReferenceIdentifierType = (_options, type) => type.entity.name + "_ID";
-const renderIncludeIdentifierType = (_options, type) => type.reference.name;
+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 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:
@@ -67,20 +78,17 @@ const renderType = (options, type) => {
             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) => joinSyntax(renderDocumentation(decl.comment, decl.isDeprecated), "export interface ", decl.name, " ", renderType(options, addEphemeralUUIDToType(decl)));
-const renderEnumDecl = (options, decl) => joinSyntax(renderDocumentation(decl.comment, decl.isDeprecated), "export type ", decl.name, renderTypeParameters(options, decl.parameters), " =", ...Object.entries(decl.values.value).map(([caseName, caseDef]) => applyIndentation(1, joinSyntax(EOL, "| {", EOL, applyIndentation(1, joinSyntax(`${discriminatorKey}: "${caseName}"`, caseDef.type === null
-    ? ""
-    : joinSyntax(EOL, caseName + ": ", renderType(options, caseDef.type))), options.indentation), EOL, "}"), options.indentation)));
-const renderTypeAliasDecl = (options, decl) => {
-    const type = decl.type.value;
-    return isObjectType(type)
-        ? joinSyntax(renderDocumentation(decl.comment, decl.isDeprecated), "export interface ", decl.name, renderTypeParameters(options, decl.parameters), " ", renderType(options, type))
-        : joinSyntax(renderDocumentation(decl.comment), "export type ", decl.name, renderTypeParameters(options, decl.parameters), " = ", renderType(options, 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:
@@ -93,10 +101,22 @@ const renderDecl = (options, decl) => {
             return assertExhaustive(decl, "Unknown declaration");
     }
 };
-const renderDeclarations = (options, declarations) => declarations.map(decl => renderDecl(options, decl)).join(EOL + EOL);
+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 };
-    return renderDeclarations(finalOptions, flatMapAuxiliaryDecls(node => {
+    const [imports, content] = renderDeclarations(finalOptions, flatMapAuxiliaryDecls(node => {
         if (isNestedEntityMapType(node)) {
             return TypeAliasDecl(getParentDecl(node)?.sourceUrl ?? "", {
                 name: node.name,
@@ -109,4 +129,7 @@ export const render = (options = defaultOptions, declarations) => {
         }
         return undefined;
     }, declarations));
+    return finalOptions.preserveFiles
+        ? renderImports(declarations[0].sourceUrl, imports) + content
+        : content;
 };

package/lib/schema/Node.d.ts

@@ -19,6 +19,7 @@ export interface NodeKind {
     ReferenceIdentifierType: "ReferenceIdentifierType";
     IncludeIdentifierType: "IncludeIdentifierType";
     NestedEntityMapType: "NestedEntityMapType";
+    EnumType: "EnumType";
 }
 export declare const NodeKind: NodeKind;
 export interface BaseNode {

package/lib/schema/Node.js

@@ -18,6 +18,7 @@ export const NodeKind = enumOfObject({
     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);
@@ -52,6 +53,10 @@ export const flatMapAuxiliaryDecls = (callbackFn, declarations) => {
             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);
         }

package/lib/schema/declarations/Declaration.d.ts

@@ -1,10 +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 { EnumCaseDecl, EnumDecl, SerializedEnumCaseDecl, SerializedEnumDecl } from "./EnumDecl.js";
+import { EnumDecl, SerializedEnumDecl } from "./EnumDecl.js";
 import { SerializedTypeAliasDecl, TypeAliasDecl } from "./TypeAliasDecl.js";
 export type TypeArguments<Params extends TypeParameter[]> = {
     [K in keyof Params]: Params[K] extends TypeParameter<string, infer T> ? T : Type;
@@ -42,3 +43,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/declarations/Declaration.js

@@ -1,6 +1,7 @@
 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 { getNestedDeclarationsInIncludeIdentifierType } from "../types/references/IncludeIdentifierType.js";
 import { getNestedDeclarationsInNestedEntityMapType } from "../types/references/NestedEntityMapType.js";
@@ -35,6 +36,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 +99,4 @@ export const getReferencesForDecl = (decl, value) => {
             return assertExhaustive(decl);
     }
 };
+export const groupDeclarationsBySourceUrl = (decls) => Object.groupBy(decls, decl => decl.sourceUrl);

package/lib/schema/declarations/EntityDecl.d.ts

@@ -9,6 +9,7 @@ import { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declarati
 import { TypeAliasDecl } from "./TypeAliasDecl.js";
 export interface EntityDecl<Name extends string = string, T extends ObjectType = ObjectType> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
+    namePlural: string;
     type: Lazy<T>;
     /**
      * @default "name"
@@ -27,6 +28,7 @@ export interface EntityDecl<Name extends string = string, T extends ObjectType =
 }
 export interface SerializedEntityDecl<Name extends string = string, T extends SerializedObjectType = SerializedObjectType> extends SerializedBaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
+    namePlural: string;
     type: T;
     /**
      * @default "name"
@@ -45,6 +47,7 @@ export interface SerializedEntityDecl<Name extends string = string, T extends Se
 }
 export declare const EntityDecl: <Name extends string, T extends ObjectType>(sourceUrl: string, options: {
     name: Name;
+    namePlural: string;
     comment?: string;
     type: () => T;
     /**

package/lib/schema/declarations/EnumDecl.d.ts

@@ -1,17 +1,18 @@
 import { Lazy } from "../../utils/lazy.js";
 import { GetReferences, Node, NodeKind, Serializer } from "../Node.js";
 import { SerializedTypeParameter, TypeParameter } from "../parameters/TypeParameter.js";
-import { SerializedType, Type } from "../types/Type.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";
 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"];
-    values: Lazy<T>;
+    type: Lazy<EnumType<T>>;
     isDeprecated?: boolean;
 }
 export interface SerializedEnumDecl<Name extends string = string, T extends Record<string, SerializedEnumCaseDecl> = Record<string, SerializedEnumCaseDecl>, Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> extends SerializedBaseDecl<Name, Params> {
     kind: NodeKind["EnumDecl"];
-    values: T;
+    type: SerializedEnumType<T>;
     isDeprecated?: boolean;
 }
 export declare const GenEnumDecl: <Name extends string, T extends Record<string, EnumCaseDecl>, Params extends TypeParameter[]>(sourceUrl: string, options: {
@@ -31,23 +32,5 @@ export declare const isEnumDecl: (node: Node) => node is EnumDecl;
 export declare const getNestedDeclarationsInEnumDecl: GetNestedDeclarations<EnumDecl>;
 export declare const validateEnumDecl: (helpers: ValidatorHelpers, decl: EnumDecl, args: Type[], value: unknown) => Error[];
 export declare const resolveTypeArgumentsInEnumDecl: <Params extends TypeParameter[]>(decl: EnumDecl<string, Record<string, EnumCaseDecl>, Params>, args: TypeArguments<Params>) => EnumDecl<string, Record<string, EnumCaseDecl>, []>;
-export interface EnumCaseDecl<T extends Type | null = Type | null> {
-    kind: NodeKind["EnumCaseDecl"];
-    type: T;
-    comment?: string;
-    isDeprecated?: boolean;
-}
-export interface SerializedEnumCaseDecl<T extends SerializedType | null = SerializedType | null> {
-    kind: NodeKind["EnumCaseDecl"];
-    type: T;
-    comment?: string;
-    isDeprecated?: boolean;
-}
-export declare const EnumCaseDecl: <T extends Type | null>(options: {
-    type: T;
-    comment?: string;
-    isDeprecated?: boolean;
-}) => EnumCaseDecl<T>;
-export { EnumCaseDecl as EnumCase };
 export declare const serializeEnumDecl: Serializer<EnumDecl, SerializedEnumDecl>;
 export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;