tsondb 0.1.3 → 0.3.0

package/lib/client/routes/Home.js

@@ -1,18 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
-import { useEffect, useState } from "preact/hooks";
 import { toTitleCase } from "../../shared/utils/string.js";
 import { getAllEntities } from "../api.js";
 import { Layout } from "../components/Layout.js";
+import { useMappedAPIResource } from "../hooks/useMappedAPIResource.js";
 export const Home = () => {
-    const [entities, setEntities] = useState([]);
-    useEffect(() => {
-        getAllEntities()
-            .then(data => {
-            setEntities(data.declarations.sort((a, b) => a.declaration.name.localeCompare(b.declaration.name)));
-        })
-            .catch(error => {
-            console.error("Error fetching entities:", error);
-        });
-    }, []);
-    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: "Home" }], children: [_jsx("h1", { children: "Entities" }), _jsx("ul", { class: "entities", children: entities.map(entity => (_jsxs("li", { class: "entity-item", children: [_jsxs("div", { className: "title", children: [_jsx("h2", { children: toTitleCase(entity.declaration.name) }), entity.declaration.comment && _jsx("p", { children: entity.declaration.comment })] }), _jsxs("p", { class: "meta", children: [entity.instanceCount, " instance", entity.instanceCount === 1 ? "" : "s"] }), _jsx("div", { className: "btns", children: _jsx("a", { href: `/entities/${entity.declaration.name}`, class: "btn", children: "View" }) })] }, entity.declaration.name))) })] }));
+    const [entities] = useMappedAPIResource(getAllEntities, data => data.declarations.sort((a, b) => a.declaration.name.localeCompare(b.declaration.name)));
+    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: "Home" }], children: [_jsx("h1", { children: "Entities" }), _jsx("ul", { class: "entities", children: (entities ?? []).map(entity => (_jsxs("li", { class: "entity-item", children: [_jsxs("div", { className: "title", children: [_jsx("h2", { children: toTitleCase(entity.declaration.name) }), entity.declaration.comment && _jsx("p", { children: entity.declaration.comment })] }), _jsxs("p", { class: "meta", children: [entity.instanceCount, " instance", entity.instanceCount === 1 ? "" : "s"] }), _jsx("div", { className: "btns", children: _jsx("a", { href: `/entities/${entity.declaration.name}`, class: "btn", children: "View" }) })] }, entity.declaration.name))) })] }));
 };

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] === null) {
-                        return { kind: firstCase[0] };
-                    }
-                    return {
-                        kind: firstCase[0],
-                        [firstCase[0]]: createTypeSkeleton(getDeclFromDeclName, firstCase[1]),
-                    };
-                }
-                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",
@@ -19,7 +23,11 @@ const renderObjectType = (options, type) => ({
     type: "object",
     properties: Object.fromEntries(Object.entries(type.properties).map(([name, config]) => [
         name,
-        { description: config.comment, ...renderType(options, config.type) },
+        {
+            description: config.comment,
+            deprecated: config.isDeprecated,
+            ...renderType(options, config.type),
+        },
     ])),
     required: Object.entries(type.properties)
         .filter(([, config]) => config.isRequired)
@@ -65,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:
@@ -98,29 +125,25 @@ 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) => ({
     description: decl.comment,
+    deprecated: decl.isDeprecated,
     ...renderType(options, addEphemeralUUIDToType(decl)),
 });
 const renderEnumDecl = (options, decl) => ({
     description: decl.comment,
-    oneOf: Object.entries(decl.values.value).map(([caseName, caseDef]) => ({
-        type: "object",
-        properties: {
-            [discriminatorKey]: {
-                const: caseName,
-            },
-            ...(caseDef === null ? {} : { [caseName]: renderType(options, caseDef) }),
-        },
-        required: [discriminatorKey, ...(caseDef === null ? [] : [caseName])],
-    })),
+    deprecated: decl.isDeprecated,
+    ...renderEnumType(options, decl.type.value),
 });
 const renderTypeAliasDecl = (options, decl) => ({
     description: decl.comment,
+    deprecated: decl.isDeprecated,
     ...renderType(options, decl.type.value),
 });
 const renderDecl = (options, decl) => {
@@ -152,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,38 +9,51 @@ 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) => comment === undefined
+const renderDocumentation = (comment, isDeprecated) => syntax `${comment === undefined
     ? ""
     : syntax `/**
-${prefixLines(" * ", comment, true)}
+${prefixLines(" * ", comment, true)}${isDeprecated
+        ? syntax `
+ * @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), 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:
@@ -64,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), "export interface ", decl.name, " ", renderType(options, addEphemeralUUIDToType(decl)));
-const renderEnumDecl = (options, decl) => joinSyntax(renderDocumentation(decl.comment), "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 === null
-    ? ""
-    : joinSyntax(EOL, caseName + ": ", renderType(options, caseDef))), options.indentation), EOL, "}"), options.indentation)));
-const renderTypeAliasDecl = (options, decl) => {
-    const type = decl.type.value;
-    return isObjectType(type)
-        ? joinSyntax(renderDocumentation(decl.comment), "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:
@@ -90,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,
@@ -106,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

@@ -4,6 +4,7 @@ import { Type } from "./types/Type.js";
 export interface NodeKind {
     EntityDecl: "EntityDecl";
     EnumDecl: "EnumDecl";
+    EnumCaseDecl: "EnumCaseDecl";
     TypeAliasDecl: "TypeAliasDecl";
     MemberDecl: "MemberDecl";
     ArrayType: "ArrayType";
@@ -18,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

@@ -3,6 +3,7 @@ import { enumOfObject } from "../utils/enum.js";
 export const NodeKind = enumOfObject({
     EntityDecl: null,
     EnumDecl: null,
+    EnumCaseDecl: null,
     TypeAliasDecl: null,
     MemberDecl: null,
     ArrayType: null,
@@ -17,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) => {
@@ -27,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 === null ? newDecls : mapNodeTree(callbackFn, caseDef, newDeclsAcc), newDecls);
+                return mapNodeTree(callbackFn, node.type.value, newDecls);
             }
             case NodeKind.TypeAliasDecl: {
                 const newDecls = callbackFn(node, decls);
@@ -51,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,5 +1,6 @@
 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";
@@ -16,12 +17,12 @@ 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, Type | null>, Params> | TypeAliasDecl<string, Type, Params>;
-export type SerializedDeclP<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> = SerializedEntityDecl<string, SerializedObjectType> | SerializedEnumDecl<string, Record<string, SerializedType | null>, Params> | SerializedTypeAliasDecl<string, SerializedType, Params>;
+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 SecondaryDecl = EnumDecl | TypeAliasDecl;
 export type SerializedSecondaryDecl = SerializedEnumDecl | SerializedTypeAliasDecl;
 export declare const getNestedDeclarations: GetNestedDeclarations;
-export type GetNestedDeclarations<T extends Node = Node> = (isDeclarationAdded: (decl: Decl) => boolean, node: T) => Decl[];
+export type GetNestedDeclarations<T extends Node = Node> = (addedDecls: Decl[], node: T) => Decl[];
 export declare const isDecl: (node: Node) => node is Decl;
 export interface BaseDecl<Name extends string = string, Params extends TypeParameter[] = TypeParameter[]> extends BaseNode {
     sourceUrl: string;
@@ -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";
@@ -10,31 +11,33 @@ import { getNestedDeclarationsInEnumDecl, getReferencesForEnumDecl, isEnumDecl,
 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 getNestedDeclarations = (isDeclAdded, node) => {
+export const getNestedDeclarations = (addedDecls, node) => {
     switch (node.kind) {
         case NodeKind.EntityDecl:
-            return isDeclAdded(node) ? [] : getNestedDeclarationsInEntityDecl(isDeclAdded, node);
+            return getNestedDeclarationsInEntityDecl(addedDecls, node);
         case NodeKind.EnumDecl:
-            return isDeclAdded(node) ? [] : getNestedDeclarationsInEnumDecl(isDeclAdded, node);
+            return getNestedDeclarationsInEnumDecl(addedDecls, node);
         case NodeKind.TypeAliasDecl:
-            return isDeclAdded(node) ? [] : getNestedDeclarationsInTypeAliasDecl(isDeclAdded, node);
+            return getNestedDeclarationsInTypeAliasDecl(addedDecls, node);
         case NodeKind.ArrayType:
-            return getNestedDeclarationsInArrayType(isDeclAdded, node);
+            return getNestedDeclarationsInArrayType(addedDecls, node);
         case NodeKind.ObjectType:
-            return getNestedDeclarationsInObjectType(isDeclAdded, node);
+            return getNestedDeclarationsInObjectType(addedDecls, node);
         case NodeKind.BooleanType:
         case NodeKind.DateType:
         case NodeKind.FloatType:
         case NodeKind.IntegerType:
         case NodeKind.StringType:
         case NodeKind.GenericArgumentIdentifierType:
-            return [];
+            return addedDecls;
         case NodeKind.ReferenceIdentifierType:
-            return getNestedDeclarationsInReferenceIdentifierType(isDeclAdded, node);
+            return getNestedDeclarationsInReferenceIdentifierType(addedDecls, node);
         case NodeKind.IncludeIdentifierType:
-            return getNestedDeclarationsInIncludeIdentifierType(isDeclAdded, node);
+            return getNestedDeclarationsInIncludeIdentifierType(addedDecls, node);
         case NodeKind.NestedEntityMapType:
-            return getNestedDeclarationsInNestedEntityMapType(isDeclAdded, node);
+            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"
@@ -23,9 +24,11 @@ export interface EntityDecl<Name extends string = string, T extends ObjectType =
          */
         pathInLocaleMap?: string;
     };
+    isDeprecated?: boolean;
 }
 export interface SerializedEntityDecl<Name extends string = string, T extends SerializedObjectType = SerializedObjectType> extends SerializedBaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
+    namePlural: string;
     type: T;
     /**
      * @default "name"
@@ -40,9 +43,11 @@ export interface SerializedEntityDecl<Name extends string = string, T extends Se
          */
         pathInLocaleMap?: string;
     };
+    isDeprecated?: boolean;
 }
 export declare const EntityDecl: <Name extends string, T extends ObjectType>(sourceUrl: string, options: {
     name: Name;
+    namePlural: string;
     comment?: string;
     type: () => T;
     /**
@@ -58,6 +63,7 @@ export declare const EntityDecl: <Name extends string, T extends ObjectType>(sou
          */
         pathInLocaleMap?: string;
     };
+    isDeprecated?: boolean;
 }) => EntityDecl<Name, T>;
 export { EntityDecl as Entity };
 export declare const isEntityDecl: (node: Node) => node is EntityDecl;