duckerd 0.1.4 → 0.2.1

package/README.md

@@ -27,9 +27,11 @@ Generate an ERD diagram of the database schemas.
 - `-d, --database <path>`: Path to the database file
 - `-t, --theme [theme]`: Theme of the chart (choices: `default`, `forest`, `dark`, `neutral`, default: `default`)
 - `-o, --output <path>`: Path to the output file
+- `-m, --mmd-output <path>`: Path to write the Mermaid source (`.mmd`) file (default: cleaned up after rendering)
 - `-w, --width [width]`: Width of the page (default: `1024`)
 - `-H, --height [height]`: Height of the page (default: `768`)
 - `-f, --outputFormat [format]`: Output format for the generated image (choices: `svg`, `png`, `pdf`, default: `png`)
+- `-e, --expand-structs`: Expand `STRUCT` columns into individual sub-field rows (e.g. `full_name STRUCT(given VARCHAR, family VARCHAR)` becomes `full_name__given` and `full_name__family`)
 
 #### Example:
 

package/dist/commands/erd.js

@@ -1,14 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createERD = void 0;
-const duckdb_async_1 = require("duckdb-async");
+const node_api_1 = require("@duckdb/node-api");
 const metadata_1 = require("../lib/metadata");
-const createERD = async (databasePath) => {
-    const db = await duckdb_async_1.Database.create(databasePath);
-    const conn = await db.connect();
-    const metadata = await (0, metadata_1.getMetadata)(conn);
-    await db.close();
-    const mermaidCode = (0, metadata_1.generateMermaidCodeForAllDBs)(metadata);
-    return mermaidCode;
+const createERD = async (databasePath, expandStructs = false) => {
+    const instance = await node_api_1.DuckDBInstance.create(databasePath);
+    const conn = await instance.connect();
+    try {
+        const metadata = await (0, metadata_1.getMetadata)(conn);
+        return (0, metadata_1.generateMermaidCodeForAllDBs)(metadata, expandStructs);
+    }
+    finally {
+        conn.closeSync();
+        instance.closeSync();
+    }
 };
 exports.createERD = createERD;

package/dist/index.js

@@ -47,6 +47,8 @@ program
     .option('-d, --database <path>', 'Path to the database file')
     .option('-t, --theme [theme]', 'Theme of the chart (choices: "default", "forest", "dark", "neutral", default: "default")')
     .option('-o, --output <path>', 'Path to the output file')
+    .option('-m, --mmd-output <path>', 'Path to write the Mermaid source (.mmd) file (default: cleaned up after rendering)')
+    .option('-e, --expand-structs', 'Expand STRUCT type columns into individual sub-field rows')
     .option('-w, --width [width]', 'Width of the page (default: 1024)')
     .option('-H, --height [height]', 'Height of the page (default: 768)')
     .option('-f, --outputFormat [format]', 'Output format for the generated image. (choices: "svg", "png", "pdf")')
@@ -61,10 +63,13 @@ program
     run(dbPath, options);
 });
 const run = async (dbPath, options) => {
-    const mermaidDiagram = await (0, erd_1.createERD)(dbPath);
+    const mermaidDiagram = await (0, erd_1.createERD)(dbPath, options.expandStructs ?? false);
     const mermaidFile = path.resolve('schema_erd.mmd');
     if (mermaidDiagram) {
         fs.writeFileSync(mermaidFile, mermaidDiagram);
+        if (options.mmdOutput) {
+            fs.copyFileSync(mermaidFile, path.resolve(options.mmdOutput));
+        }
         // Extract the database name from the dbPath
         const dbName = dbPath === ':memory:' ? 'memory_db' : path.basename(dbPath, path.extname(dbPath));
         const outputFile = options.output || `${dbName}_erd.${options.outputFormat || 'png'}`;

package/dist/lib/metadata.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addCommentIfNecessary = exports.sanitizeDataType = exports.generateMermaidCodeForAllDBs = exports.getMetadata = void 0;
+exports.addCommentIfNecessary = exports.sanitizeDataType = exports.expandStructFields = exports.parseStructFields = exports.generateMermaidCodeForAllDBs = exports.getMetadata = void 0;
 // Database metadata query
 const databaseMetadataQuery = `SELECT database_name as databaseName FROM duckdb_databases() WHERE database_name NOT IN ('system', 'temp') ORDER BY database_name`;
 // Schema metadata query
@@ -15,14 +15,18 @@ const indexesMetadataQuery = `SELECT database_name as databaseName, schema_name
 const contraintsMetadataQuery = `SELECT database_name as databaseName, schema_name as schemaName, table_name as tableName, unnest(constraint_column_names) as columnName, constraint_type as constraintType, constraint_text as sql FROM duckdb_constraints() ORDER BY database_name, schema_name, table_name`;
 // Constraints metadata query
 const sequencesMetadataQuery = `SELECT database_name as databaseName, schema_name as schemaName, sequence_name as name, temporary as isTemporary, start_value as startValue, last_value as lastValue, min_value as minValue, max_value as maxValue, increment_by as incrementBy, sql FROM duckdb_sequences() ORDER BY database_name, schema_name, sequence_name`;
+const queryAll = async (conn, sql) => {
+    const reader = await conn.runAndReadAll(sql);
+    return reader.getRowObjectsJson();
+};
 const getMetadata = async (conn) => {
-    const databaseRaw = await conn.all(databaseMetadataQuery);
-    const schemas = await conn.all(schemaMetadataQuery);
-    const tables = await conn.all(tablesMetadataQuery);
-    const columns = await conn.all(columnsMetadataQuery);
-    const indexes = await conn.all(indexesMetadataQuery);
-    const constraints = await conn.all(contraintsMetadataQuery);
-    const sequences = await conn.all(sequencesMetadataQuery);
+    const databaseRaw = await queryAll(conn, databaseMetadataQuery);
+    const schemas = await queryAll(conn, schemaMetadataQuery);
+    const tables = await queryAll(conn, tablesMetadataQuery);
+    const columns = await queryAll(conn, columnsMetadataQuery);
+    const indexes = await queryAll(conn, indexesMetadataQuery);
+    const constraints = await queryAll(conn, contraintsMetadataQuery);
+    const sequences = await queryAll(conn, sequencesMetadataQuery);
     const databases = databaseRaw.map(database => ({
         name: database.databaseName,
         schemas: [...new Set(schemas.filter(schema => database.databaseName === schema.databaseName).map(schema => ({
@@ -73,7 +77,7 @@ const getMetadata = async (conn) => {
     return metadata;
 };
 exports.getMetadata = getMetadata;
-const generateMermaidCodeForAllDBs = (metadata) => {
+const generateMermaidCodeForAllDBs = (metadata, expandStructs = false) => {
     let mermaidCode = `erDiagram
   
   `;
@@ -84,7 +88,14 @@ const generateMermaidCodeForAllDBs = (metadata) => {
             // Add tables, columns and constraints
             mermaidCode += tables.map((table) => {
                 return `"${table.databaseName}.${table.name}" {
-${table.columns.map((column) => `      ${(0, exports.sanitizeDataType)(column.dataType.toUpperCase())} ${column.name} ${table.constraints?.filter((constraint) => constraint.columnName === column.name).map((constraint) => ((constraint.constraintType === "PRIMARY KEY" ? "PK" : "") || (constraint.constraintType === "FOREIGN KEY" ? "FK" : "") || "")).filter(str => str)}${(0, exports.addCommentIfNecessary)(column.dataType)}`).join("\n")}
+${table.columns.flatMap((column) => {
+                    const constraintMarkers = table.constraints?.filter((constraint) => constraint.columnName === column.name).map((constraint) => ((constraint.constraintType === "PRIMARY KEY" ? "PK" : "") || (constraint.constraintType === "FOREIGN KEY" ? "FK" : "") || "")).filter(str => str) ?? [];
+                    const structFields = expandStructs ? (0, exports.expandStructFields)(column.name, column.dataType) : [];
+                    if (structFields.length > 0) {
+                        return structFields.map((field) => `      ${(0, exports.sanitizeDataType)(field.type.toUpperCase())} ${field.name}`);
+                    }
+                    return [`      ${(0, exports.sanitizeDataType)(column.dataType.toUpperCase())} ${column.name} ${constraintMarkers}${(0, exports.addCommentIfNecessary)(column.dataType)}`];
+                }).join("\n")}
     }\n${table.constraints?.filter((constraint) => constraint.constraintType === "FOREIGN KEY").map((constraint) => `    "${table.databaseName}.${constraint.sql.match(/(?:^|)REFERENCES\s([^*]+?)\b\(/i)[1]}" ||--o{ "${table.databaseName}.${table.name}" : has`).join("\n")}`;
             }).join("\n    ");
             return mermaidCode;
@@ -98,15 +109,61 @@ ${table.columns.map((column) => `      ${(0, exports.sanitizeDataType)(column.da
     }
 };
 exports.generateMermaidCodeForAllDBs = generateMermaidCodeForAllDBs;
-const sanitizeDataType = (dataType) => {
-    if (dataType.startsWith("STRUCT(")) {
-        return dataType.replace("STRUCT(", "STRUCT").replace(")", "");
+const parseStructFields = (dataType) => {
+    if (!dataType.toUpperCase().startsWith("STRUCT(")) {
+        return [];
     }
-    if (dataType.startsWith("ENUM(")) {
-        return "ENUM";
+    const inner = dataType.slice(dataType.indexOf("(") + 1, dataType.lastIndexOf(")"));
+    const fields = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of inner) {
+        if (ch === "(" || ch === "<")
+            depth++;
+        else if (ch === ")" || ch === ">")
+            depth--;
+        else if (ch === "," && depth === 0) {
+            const parts = current.trim().split(/\s+/);
+            if (parts.length >= 2) {
+                fields.push({ name: parts[0].replace(/['"]/g, ""), type: parts.slice(1).join(" ") });
+            }
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim()) {
+        const parts = current.trim().split(/\s+/);
+        if (parts.length >= 2) {
+            fields.push({ name: parts[0].replace(/['"]/g, ""), type: parts.slice(1).join(" ") });
+        }
+    }
+    return fields;
+};
+exports.parseStructFields = parseStructFields;
+const expandStructFields = (prefix, dataType) => {
+    const fields = (0, exports.parseStructFields)(dataType);
+    if (fields.length === 0)
+        return [];
+    return fields.flatMap((field) => {
+        const nestedFields = (0, exports.parseStructFields)(field.type);
+        if (nestedFields.length > 0) {
+            return (0, exports.expandStructFields)(`${prefix}__${field.name}`, field.type);
+        }
+        return [{ name: `${prefix}__${field.name}`, type: field.type }];
+    });
+};
+exports.expandStructFields = expandStructFields;
+const COLLAPSIBLE_TYPES = ["STRUCT", "MAP", "ENUM"];
+const sanitizeDataType = (dataType) => {
+    const upper = dataType.toUpperCase();
+    for (const t of COLLAPSIBLE_TYPES) {
+        if (upper.startsWith(`${t}(`)) {
+            return t;
+        }
     }
     if (dataType.includes(",")) {
-        return dataType.replace(",", "_");
+        return dataType.replace(/,/g, "_");
     }
     return dataType;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "duckerd",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "A CLI tool for generating ERD diagrams from DuckDB databases",
   "author": "TobiLG <tobilg@gmail.com>",
   "repository": {
@@ -17,19 +17,20 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc",
-    "start": "ts-node src/index.ts"
+    "start": "ts-node src/index.ts",
+    "test": "ts-node src/lib/metadata.test.ts"
   },
   "engines": {
-    "node": "^18.19 || >=20.0"
+    "node": ">=22.0"
   },
   "keywords": ["duckdb", "erd", "diagram", "cli"],
   "dependencies": {
-    "commander": "^13.1.0",
-    "duckdb-async": "^1.2.0"
+    "@duckdb/node-api": "^1.5.2-r.1",
+    "commander": "^14.0.3"
   },
   "devDependencies": {
-    "@types/node": "^18.11.9",
+    "@types/node": "^22",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.2"
+    "typescript": "^6.0.3"
   }
 }