kanel-enum-tables 1.0.0

package/README.md

@@ -0,0 +1,102 @@
+# Kanel extension to generate enum types from table values
+
+This package extends [Kanel](https://github.com/kristiandupont/kanel) with the ability to generate enum types from table values.
+
+It uses the [Postgraphile](https://www.graphile.org/postgraphile) concept of [enum tables](https://www.graphile.org/postgraphile/enums/#with-enum-tables).
+
+## Smart Comments
+
+Mark a table as an enum table by adding a `@enum` tag to its comment:
+
+```sql
+COMMENT ON TABLE animal_type IS '@enum';
+```
+
+You can optionally rename the generated type with `@enumName`:
+
+```sql
+COMMENT ON TABLE animal_type IS E'@enum\n@enumName TypeOfAnimal';
+```
+
+Both Postgraphile's space format and the colon format used by other Kanel extensions are supported:
+
+- `@enumName TypeOfAnimal` (Postgraphile convention)
+- `@enumName:TypeOfAnimal` (tagged-comment-parser convention)
+
+### `@enumDescription`
+
+You can add per-value descriptions to your enum by tagging a column with `@enumDescription`. The values in that column will be rendered as JSDoc comments on each enum member.
+
+```sql
+CREATE TABLE animal_type (
+  type text PRIMARY KEY,
+  description text NOT NULL
+);
+
+COMMENT ON TABLE animal_type IS '@enum';
+COMMENT ON COLUMN animal_type.description IS '@enumDescription';
+
+INSERT INTO animal_type VALUES
+  ('cat', 'A small domesticated feline'),
+  ('dog', 'A loyal canine companion');
+```
+
+With `enumStyle: "enum"` this generates:
+
+```typescript
+export enum AnimalType {
+  /** A small domesticated feline */
+  cat = "cat",
+  /** A loyal canine companion */
+  dog = "dog",
+}
+```
+
+With `enumStyle: "type"` (the default) this generates:
+
+```typescript
+export type AnimalType =
+  /** A small domesticated feline */
+  | "cat"
+  /** A loyal canine companion */
+  | "dog";
+```
+
+## Installation
+
+Assuming you already have Kanel installed, add this with
+
+```bash
+npm i -D kanel-enum-tables
+```
+
+## Usage
+
+Add the hook to your `.kanelrc.js` file:
+
+```javascript
+const { enumTablesPreRenderHook } = require("kanel-enum-tables");
+
+module.exports = {
+  // ... your config here.
+
+  preRenderHooks: [enumTablesPreRenderHook],
+};
+```
+
+### With kanel-kysely
+
+When using [kanel-kysely](https://github.com/kristiandupont/kanel/tree/main/packages/kanel-kysely), place `enumTablesPreRenderHook` **before** the kysely hook for best results:
+
+```javascript
+const { enumTablesPreRenderHook } = require("kanel-enum-tables");
+const { makeKyselyHook } = require("kanel-kysely");
+
+module.exports = {
+  // ... your config here.
+
+  preRenderHooks: [enumTablesPreRenderHook, makeKyselyHook()],
+};
+```
+
+The hook also works if placed after the kysely hook — it will detect the `ColumnType<>` wrappers and update them accordingly.

package/build/enumTablesPreRenderHook.d.ts

@@ -0,0 +1,44 @@
+import type { TableDetails } from "extract-pg-schema";
+import type { PreRenderHook } from "kanel";
+/**
+ * Parse smart comment tags from a database comment string.
+ *
+ * Supports both Postgraphile's newline-separated format and
+ * tagged-comment-parser's colon format:
+ *
+ * Postgraphile: `E'@enum\n@enumName TypeOfAnimal'`
+ * Colon:        `@enum @enumName:TypeOfAnimal`
+ *
+ * Since tagged-comment-parser doesn't support newline-separated tags,
+ * we parse each line individually and merge the results.
+ */
+export declare const parseSmartTags: (comment: string | null) => Record<string, string | boolean>;
+/**
+ * Resolve the value of a smart tag that may have been parsed as a boolean
+ * (Postgraphile space format) instead of a string (colon format).
+ *
+ * When tagged-comment-parser encounters `@enumName TypeOfAnimal`,
+ * it parses `enumName` as `true` and puts "TypeOfAnimal" in the comment.
+ * We fall back to regex extraction from the raw comment in that case.
+ */
+export declare const resolveTagValue: (tags: Record<string, string | boolean>, tagName: string, rawComment: string) => string | undefined;
+/**
+ * Check if a file has already been processed by kanel-kysely.
+ *
+ * kanel-kysely replaces selector interfaces with *Table interfaces
+ * that use ColumnType<> wrappers, and removes initializer/mutator interfaces.
+ * We detect this by looking for ColumnType in type imports.
+ */
+export declare const isKyselyProcessed: (declarations: unknown[]) => boolean;
+/**
+ * Update a ColumnType<S, I, M> string by replacing all occurrences of
+ * the old type name with the new enum type name.
+ */
+export declare const updateColumnType: (typeName: string, oldName: string, newName: string) => string;
+/**
+ * Find the column name marked with @enumDescription in the table's column comments.
+ * Returns the column name if found, undefined otherwise.
+ */
+export declare const findDescriptionColumn: (table: TableDetails) => string | undefined;
+declare const enumTablesPreRenderHook: PreRenderHook;
+export default enumTablesPreRenderHook;

package/build/enumTablesPreRenderHook.js

@@ -0,0 +1,299 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDescriptionColumn = exports.updateColumnType = exports.isKyselyProcessed = exports.resolveTagValue = exports.parseSmartTags = void 0;
+const kanel_1 = require("kanel");
+const knex_1 = __importDefault(require("knex"));
+const tagged_comment_parser_1 = require("tagged-comment-parser");
+/**
+ * Parse smart comment tags from a database comment string.
+ *
+ * Supports both Postgraphile's newline-separated format and
+ * tagged-comment-parser's colon format:
+ *
+ * Postgraphile: `E'@enum\n@enumName TypeOfAnimal'`
+ * Colon:        `@enum @enumName:TypeOfAnimal`
+ *
+ * Since tagged-comment-parser doesn't support newline-separated tags,
+ * we parse each line individually and merge the results.
+ */
+const parseSmartTags = (comment) => {
+    if (!comment)
+        return {};
+    const mergedTags = {};
+    for (const line of comment.split("\n")) {
+        const { tags } = (0, tagged_comment_parser_1.tryParse)(line.trim());
+        if (tags) {
+            Object.assign(mergedTags, tags);
+        }
+    }
+    return mergedTags;
+};
+exports.parseSmartTags = parseSmartTags;
+/**
+ * Resolve the value of a smart tag that may have been parsed as a boolean
+ * (Postgraphile space format) instead of a string (colon format).
+ *
+ * When tagged-comment-parser encounters `@enumName TypeOfAnimal`,
+ * it parses `enumName` as `true` and puts "TypeOfAnimal" in the comment.
+ * We fall back to regex extraction from the raw comment in that case.
+ */
+const resolveTagValue = (tags, tagName, rawComment) => {
+    const value = tags[tagName];
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === true) {
+        // Postgraphile space format — extract value from raw comment
+        const match = rawComment.match(new RegExp(`@${tagName}\\s+(\\S+)`));
+        return match?.[1];
+    }
+    return undefined;
+};
+exports.resolveTagValue = resolveTagValue;
+/**
+ * Check if a file has already been processed by kanel-kysely.
+ *
+ * kanel-kysely replaces selector interfaces with *Table interfaces
+ * that use ColumnType<> wrappers, and removes initializer/mutator interfaces.
+ * We detect this by looking for ColumnType in type imports.
+ */
+const isKyselyProcessed = (declarations) => declarations.some((d) => d?.declarationType === "interface" &&
+    d?.typeImports?.some((i) => i.name === "ColumnType" && i.path === "kysely"));
+exports.isKyselyProcessed = isKyselyProcessed;
+/**
+ * Update a ColumnType<S, I, M> string by replacing all occurrences of
+ * the old type name with the new enum type name.
+ */
+const updateColumnType = (typeName, oldName, newName) => {
+    if (!typeName.startsWith("ColumnType<"))
+        return typeName;
+    return typeName.replaceAll(oldName, newName);
+};
+exports.updateColumnType = updateColumnType;
+/**
+ * Find the column name marked with @enumDescription in the table's column comments.
+ * Returns the column name if found, undefined otherwise.
+ */
+const findDescriptionColumn = (table) => {
+    for (const column of table.columns) {
+        const tags = (0, exports.parseSmartTags)(column.comment ?? null);
+        if (tags.enumDescription) {
+            return column.name;
+        }
+    }
+    return undefined;
+};
+exports.findDescriptionColumn = findDescriptionColumn;
+const enumTablesPreRenderHook = async (outputAccumulator, instantiatedConfig) => {
+    if (!instantiatedConfig.generateIdentifierType) {
+        console.warn("kanel-enum-tables: generateIdentifierType is not configured, skipping enum table generation");
+        return outputAccumulator;
+    }
+    // Find all tables tagged with @enum
+    const enumTables = [];
+    for (const schema of Object.values(instantiatedConfig.schemas)) {
+        for (const table of schema.tables) {
+            const tags = (0, exports.parseSmartTags)(table.comment);
+            if (tags.enum) {
+                enumTables.push({
+                    table,
+                    enumName: (0, exports.resolveTagValue)(tags, "enumName", table.comment),
+                    descriptionColumn: (0, exports.findDescriptionColumn)(table),
+                });
+            }
+        }
+    }
+    if (enumTables.length === 0) {
+        return outputAccumulator;
+    }
+    const connection = instantiatedConfig.connection;
+    const db = (0, knex_1.default)({ client: "postgres", connection });
+    try {
+        const overrides = {};
+        for (const { table, enumName, descriptionColumn } of enumTables) {
+            const primaryKeyColumn = table.columns.find((column) => column.isPrimaryKey);
+            if (!primaryKeyColumn) {
+                throw new Error(`Table ${table.schemaName}.${table.name} is an enum table but has no primary key`);
+            }
+            const primaryKeyTypeDeclaration = instantiatedConfig.generateIdentifierType(primaryKeyColumn, table, instantiatedConfig);
+            // Get the resolved type for the primary key column.
+            // Pass `true` for retainInnerIdentifierType to skip identifier type
+            // wrapping and get the actual underlying type (e.g. "string").
+            const primaryKeyInnerType = (0, kanel_1.resolveType)(primaryKeyColumn, table, true);
+            if (primaryKeyInnerType !== "string") {
+                throw new Error(`The primary key of enum table ${table.schemaName}.${table.name} must be string-based, got: ${primaryKeyInnerType}`);
+            }
+            const selectorMetadata = instantiatedConfig.getMetadata(table, "selector", instantiatedConfig);
+            const initializerMetadata = instantiatedConfig.getMetadata(table, "initializer", instantiatedConfig);
+            const mutatorMetadata = instantiatedConfig.getMetadata(table, "mutator", instantiatedConfig);
+            // @enumDescription marks a column whose values provide per-enum-value descriptions.
+            // When enumStyle is "type", descriptions are rendered as inline JSDoc comments.
+            // When enumStyle is "enum", we use a GenericDeclaration to emit hand-crafted
+            // enum lines with per-value JSDoc comments (since EnumDeclaration.values is string-only).
+            const selectColumns = [primaryKeyColumn.name];
+            if (descriptionColumn) {
+                selectColumns.push(descriptionColumn);
+            }
+            const rows = await db
+                .withSchema(table.schemaName)
+                .select(...selectColumns)
+                .from(table.name)
+                .orderBy(primaryKeyColumn.name);
+            const existingFile = outputAccumulator[selectorMetadata.path];
+            const declarations = existingFile?.declarations ?? [];
+            const kyselyMode = (0, exports.isKyselyProcessed)(declarations);
+            const finalEnumName = enumName || primaryKeyTypeDeclaration.name;
+            const newDeclarations = declarations.map((declaration) => {
+                // Replace the identifier TypeDeclaration with enum values
+                if (declaration.declarationType === "typeDeclaration" &&
+                    declaration.name === primaryKeyTypeDeclaration.name) {
+                    if (instantiatedConfig.enumStyle === "type") {
+                        const typeLines = [""];
+                        for (const row of rows) {
+                            const desc = descriptionColumn && row[descriptionColumn]
+                                ? String(row[descriptionColumn])
+                                : undefined;
+                            if (desc) {
+                                typeLines.push(`/** ${desc} */`);
+                            }
+                            typeLines.push(`| '${row[primaryKeyColumn.name]}'`);
+                        }
+                        const newDeclaration = {
+                            ...declaration,
+                            name: finalEnumName,
+                            typeDefinition: typeLines,
+                        };
+                        return newDeclaration;
+                    }
+                    else if (instantiatedConfig.enumStyle === "enum") {
+                        if (descriptionColumn) {
+                            // Use GenericDeclaration to emit per-value JSDoc comments
+                            const lines = [];
+                            if (declaration.exportAs === "named") {
+                                lines.push(`export enum ${finalEnumName} {`);
+                            }
+                            else {
+                                lines.push(`enum ${finalEnumName} {`);
+                            }
+                            for (const row of rows) {
+                                const value = String(row[primaryKeyColumn.name]);
+                                const desc = row[descriptionColumn]
+                                    ? String(row[descriptionColumn])
+                                    : undefined;
+                                if (desc) {
+                                    lines.push(`  /** ${desc} */`);
+                                }
+                                // Quote the field name if it contains special characters
+                                const needsQuote = value.length === 0 ||
+                                    value.trim() !== value ||
+                                    !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(value);
+                                const fieldName = needsQuote ? `'${value}'` : value;
+                                lines.push(`  ${fieldName} = '${value}',`);
+                            }
+                            lines.push("};");
+                            if (declaration.exportAs === "default") {
+                                lines.push("", `export default ${finalEnumName};`);
+                            }
+                            const newDeclaration = {
+                                declarationType: "generic",
+                                comment: declaration.comment,
+                                typeImports: declaration.typeImports,
+                                lines,
+                            };
+                            return newDeclaration;
+                        }
+                        const newDeclaration = {
+                            declarationType: "enum",
+                            name: finalEnumName,
+                            comment: declaration.comment,
+                            exportAs: declaration.exportAs,
+                            values: rows.map((row) => row[primaryKeyColumn.name]),
+                            typeImports: declaration.typeImports,
+                        };
+                        return newDeclaration;
+                    }
+                    else {
+                        console.warn(`Unsupported enumStyle "${instantiatedConfig.enumStyle}" for enum table ${table.schemaName}.${table.name}`);
+                    }
+                }
+                // Handle initializer/mutator interfaces (not present when kanel-kysely runs first)
+                if (!kyselyMode &&
+                    declaration.declarationType === "interface" &&
+                    (declaration.name === initializerMetadata.name ||
+                        declaration.name === mutatorMetadata.name)) {
+                    const newDeclaration = {
+                        ...declaration,
+                        properties: declaration.properties.map((property) => {
+                            if (property.name === primaryKeyColumn.name) {
+                                return {
+                                    ...property,
+                                    // When inserting/updating, accept any string as a new enum value
+                                    typeName: primaryKeyInnerType,
+                                    typeImports: [],
+                                };
+                            }
+                            return property;
+                        }),
+                    };
+                    return newDeclaration;
+                }
+                // Handle selector interface — update PK property when @enumName renames the type
+                if (!kyselyMode &&
+                    declaration.declarationType === "interface" &&
+                    declaration.name === selectorMetadata.name &&
+                    enumName) {
+                    const newDeclaration = {
+                        ...declaration,
+                        properties: declaration.properties.map((property) => {
+                            if (property.name === primaryKeyColumn.name) {
+                                return {
+                                    ...property,
+                                    typeName: enumName,
+                                    typeImports: [],
+                                };
+                            }
+                            return property;
+                        }),
+                    };
+                    return newDeclaration;
+                }
+                // Handle kanel-kysely *Table interface — update ColumnType<> references
+                if (kyselyMode &&
+                    declaration.declarationType === "interface" &&
+                    enumName &&
+                    declaration.typeImports?.some((i) => i.name === "ColumnType" && i.path === "kysely")) {
+                    const oldTypeName = primaryKeyTypeDeclaration.name;
+                    const newDeclaration = {
+                        ...declaration,
+                        properties: declaration.properties.map((property) => {
+                            if (property.name === primaryKeyColumn.name) {
+                                return {
+                                    ...property,
+                                    typeName: (0, exports.updateColumnType)(property.typeName, oldTypeName, enumName),
+                                };
+                            }
+                            return property;
+                        }),
+                    };
+                    return newDeclaration;
+                }
+                return declaration;
+            });
+            overrides[selectorMetadata.path] = {
+                ...existingFile,
+                declarations: newDeclarations,
+            };
+        }
+        return {
+            ...outputAccumulator,
+            ...overrides,
+        };
+    }
+    finally {
+        await db.destroy();
+    }
+};
+exports.default = enumTablesPreRenderHook;

package/build/enumTablesPreRenderHook.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/enumTablesPreRenderHook.test.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const enumTablesPreRenderHook_1 = require("./enumTablesPreRenderHook");
+// ---------------------------------------------------------------------------
+// parseSmartTags
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)("parseSmartTags", () => {
+    (0, vitest_1.it)("should return empty object for null comment", () => {
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.parseSmartTags)(null)).toEqual({});
+    });
+    (0, vitest_1.it)("should return empty object for empty string", () => {
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.parseSmartTags)("")).toEqual({});
+    });
+    (0, vitest_1.it)("should return empty object for comment without tags", () => {
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.parseSmartTags)("just a plain comment")).toEqual({});
+    });
+    (0, vitest_1.it)("should parse a single @enum tag", () => {
+        const tags = (0, enumTablesPreRenderHook_1.parseSmartTags)("@enum");
+        (0, vitest_1.expect)(tags).toHaveProperty("enum");
+    });
+    (0, vitest_1.it)("should parse colon-format tag value", () => {
+        const tags = (0, enumTablesPreRenderHook_1.parseSmartTags)("@enumName:TypeOfAnimal");
+        (0, vitest_1.expect)(tags.enumName).toBe("TypeOfAnimal");
+    });
+    (0, vitest_1.it)("should parse newline-separated tags (Postgraphile format)", () => {
+        const tags = (0, enumTablesPreRenderHook_1.parseSmartTags)("@enum\n@enumName TypeOfAnimal");
+        (0, vitest_1.expect)(tags).toHaveProperty("enum");
+        (0, vitest_1.expect)(tags).toHaveProperty("enumName");
+    });
+    (0, vitest_1.it)("should handle multiple tags on one line", () => {
+        const tags = (0, enumTablesPreRenderHook_1.parseSmartTags)("@enum @enumName:Foo");
+        (0, vitest_1.expect)(tags).toHaveProperty("enum");
+        (0, vitest_1.expect)(tags.enumName).toBe("Foo");
+    });
+    (0, vitest_1.it)("should handle extra whitespace around lines", () => {
+        const tags = (0, enumTablesPreRenderHook_1.parseSmartTags)("  @enum  \n  @enumName:Bar  ");
+        (0, vitest_1.expect)(tags).toHaveProperty("enum");
+        (0, vitest_1.expect)(tags.enumName).toBe("Bar");
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveTagValue
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)("resolveTagValue", () => {
+    (0, vitest_1.it)("should return string value directly (colon format)", () => {
+        const tags = { enumName: "TypeOfAnimal" };
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.resolveTagValue)(tags, "enumName", "@enumName:TypeOfAnimal")).toBe("TypeOfAnimal");
+    });
+    (0, vitest_1.it)("should extract value from raw comment when tag is boolean (space format)", () => {
+        // tagged-comment-parser parses `@enumName TypeOfAnimal` as enumName: true
+        const tags = { enumName: true };
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.resolveTagValue)(tags, "enumName", "@enumName TypeOfAnimal")).toBe("TypeOfAnimal");
+    });
+    (0, vitest_1.it)("should return undefined when tag is not present", () => {
+        const tags = { enum: true };
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.resolveTagValue)(tags, "enumName", "@enum")).toBeUndefined();
+    });
+    (0, vitest_1.it)("should handle multiline raw comment for space format extraction", () => {
+        const raw = "@enum\n@enumName TypeOfAnimal";
+        const tags = { enum: true, enumName: true };
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.resolveTagValue)(tags, "enumName", raw)).toBe("TypeOfAnimal");
+    });
+});
+// ---------------------------------------------------------------------------
+// isKyselyProcessed
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)("isKyselyProcessed", () => {
+    (0, vitest_1.it)("should return true when ColumnType import from kysely is present", () => {
+        const declarations = [
+            {
+                declarationType: "interface",
+                name: "MemberTable",
+                typeImports: [{ name: "ColumnType", path: "kysely" }],
+            },
+        ];
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.isKyselyProcessed)(declarations)).toBe(true);
+    });
+    (0, vitest_1.it)("should return false without ColumnType import", () => {
+        const declarations = [
+            {
+                declarationType: "interface",
+                name: "Member",
+                typeImports: [{ name: "SomeType", path: "./types" }],
+            },
+        ];
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.isKyselyProcessed)(declarations)).toBe(false);
+    });
+    (0, vitest_1.it)("should return false for empty declarations", () => {
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.isKyselyProcessed)([])).toBe(false);
+    });
+    (0, vitest_1.it)("should return false when ColumnType is imported from a different path", () => {
+        const declarations = [
+            {
+                declarationType: "interface",
+                name: "Member",
+                typeImports: [{ name: "ColumnType", path: "other-lib" }],
+            },
+        ];
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.isKyselyProcessed)(declarations)).toBe(false);
+    });
+    (0, vitest_1.it)("should return false for non-interface declarations", () => {
+        const declarations = [
+            {
+                declarationType: "typeDeclaration",
+                name: "MemberId",
+                typeImports: [{ name: "ColumnType", path: "kysely" }],
+            },
+        ];
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.isKyselyProcessed)(declarations)).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// updateColumnType
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)("updateColumnType", () => {
+    (0, vitest_1.it)("should replace type name inside ColumnType<>", () => {
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.updateColumnType)("ColumnType<MemberId, MemberId, MemberId>", "MemberId", "MemberType")).toBe("ColumnType<MemberType, MemberType, MemberType>");
+    });
+    (0, vitest_1.it)("should handle ColumnType with different inner types", () => {
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.updateColumnType)("ColumnType<MemberId, string | MemberId, MemberId>", "MemberId", "MemberType")).toBe("ColumnType<MemberType, string | MemberType, MemberType>");
+    });
+    (0, vitest_1.it)("should return the type unchanged when not a ColumnType", () => {
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.updateColumnType)("MemberId", "MemberId", "MemberType")).toBe("MemberId");
+    });
+    (0, vitest_1.it)("should return empty ColumnType unchanged when no match", () => {
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.updateColumnType)("ColumnType<Foo, Bar, Baz>", "Other", "New")).toBe("ColumnType<Foo, Bar, Baz>");
+    });
+});
+// ---------------------------------------------------------------------------
+// findDescriptionColumn
+// ---------------------------------------------------------------------------
+const makeColumn = (name, comment = null) => ({
+    name,
+    comment,
+    expandedType: "pg_catalog.text",
+    type: { fullName: "pg_catalog.text", kind: "base" },
+    defaultValue: null,
+    isArray: false,
+    dimensions: 0,
+    references: [],
+    reference: null,
+    indices: [],
+    maxLength: null,
+    isNullable: false,
+    isPrimaryKey: name === "id",
+    generated: "NEVER",
+    isUpdatable: true,
+    isIdentity: false,
+    ordinalPosition: 1,
+    parentTable: null,
+    informationSchemaValue: {},
+});
+const makeTable = (name, columns, comment = null) => ({
+    name,
+    schemaName: "public",
+    kind: "table",
+    comment,
+    columns,
+    indices: [],
+    checks: [],
+    isRowLevelSecurityEnabled: false,
+    isRowLevelSecurityEnforced: false,
+    securityPolicies: [],
+    triggers: [],
+    informationSchemaValue: {},
+});
+(0, vitest_1.describe)("findDescriptionColumn", () => {
+    (0, vitest_1.it)("should return column name when @enumDescription tag is present", () => {
+        const table = makeTable("member_type", [
+            makeColumn("id"),
+            makeColumn("description", "@enumDescription"),
+        ]);
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.findDescriptionColumn)(table)).toBe("description");
+    });
+    (0, vitest_1.it)("should return undefined when no column has @enumDescription", () => {
+        const table = makeTable("member_type", [
+            makeColumn("id"),
+            makeColumn("label", "A human-readable label"),
+        ]);
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.findDescriptionColumn)(table)).toBeUndefined();
+    });
+    (0, vitest_1.it)("should handle @enumDescription with colon format", () => {
+        const table = makeTable("status", [
+            makeColumn("code"),
+            makeColumn("display_name", "@enumDescription:true"),
+        ]);
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.findDescriptionColumn)(table)).toBe("display_name");
+    });
+    (0, vitest_1.it)("should return the first column with @enumDescription when multiple match", () => {
+        const table = makeTable("status", [
+            makeColumn("code"),
+            makeColumn("short_desc", "@enumDescription"),
+            makeColumn("long_desc", "@enumDescription"),
+        ]);
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.findDescriptionColumn)(table)).toBe("short_desc");
+    });
+    (0, vitest_1.it)("should return undefined when table has no columns", () => {
+        const table = makeTable("empty_table", []);
+        (0, vitest_1.expect)((0, enumTablesPreRenderHook_1.findDescriptionColumn)(table)).toBeUndefined();
+    });
+});

package/build/index.d.ts

@@ -0,0 +1 @@
+export { default as enumTablesPreRenderHook, findDescriptionColumn, isKyselyProcessed, parseSmartTags, resolveTagValue, updateColumnType, } from "./enumTablesPreRenderHook";

package/build/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateColumnType = exports.resolveTagValue = exports.parseSmartTags = exports.isKyselyProcessed = exports.findDescriptionColumn = exports.enumTablesPreRenderHook = void 0;
+var enumTablesPreRenderHook_1 = require("./enumTablesPreRenderHook");
+Object.defineProperty(exports, "enumTablesPreRenderHook", { enumerable: true, get: function () { return __importDefault(enumTablesPreRenderHook_1).default; } });
+Object.defineProperty(exports, "findDescriptionColumn", { enumerable: true, get: function () { return enumTablesPreRenderHook_1.findDescriptionColumn; } });
+Object.defineProperty(exports, "isKyselyProcessed", { enumerable: true, get: function () { return enumTablesPreRenderHook_1.isKyselyProcessed; } });
+Object.defineProperty(exports, "parseSmartTags", { enumerable: true, get: function () { return enumTablesPreRenderHook_1.parseSmartTags; } });
+Object.defineProperty(exports, "resolveTagValue", { enumerable: true, get: function () { return enumTablesPreRenderHook_1.resolveTagValue; } });
+Object.defineProperty(exports, "updateColumnType", { enumerable: true, get: function () { return enumTablesPreRenderHook_1.updateColumnType; } });

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "kanel-enum-tables",
+  "version": "1.0.0",
+  "keywords": [
+    "enum",
+    "postgresql",
+    "schema",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kristiandupont/kanel.git"
+  },
+  "description": "Kanel extension for generating enums from table values",
+  "homepage": "https://kristiandupont.github.io/kanel",
+  "author": {
+    "name": "Simon Fridlund",
+    "url": "http://github.com/zimme"
+  },
+  "files": [
+    "build/"
+  ],
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "rm -rf ./build && tsc",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "knex": "^3.0.0",
+    "tagged-comment-parser": "^1.3.8"
+  },
+  "devDependencies": {
+    "extract-pg-schema": "^5.8.1",
+    "kanel": "*",
+    "vitest": "^4.0.0"
+  }
+}