duckerd 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# DuckERD CLI
+
+A CLI tool for generating ERD diagrams from DuckDB databases.
+
+## Prerequisites
+
+- Node.js (v18.19.0 or later)
+
+## Installation
+
+To install the CLI tool, run:
+
+```
+npm install -g duckerd
+```
+
+## Usage
+
+```
+duckerd [options]
+```
+
+Generate an ERD diagram of the database schemas.
+
+#### Options:
+
+- `-d, --database <path>`: Path to the database file
+- `-t, --theme [theme]`: Theme of the chart (choices: `default`, `forest`, `dark`, `neutral`, default: `default`)
+- `-o, --output [output]`: Path to the output file
+- `-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`)
+
+#### Example:
+
+```bash
+duckerd -d ./mydb.duckdb -o ./erd.png -f png -t neutral -w 1600
+```

package/dist/commands/erd.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createERD = void 0;
+const duckdb_async_1 = require("duckdb-async");
+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;
+};
+exports.createERD = createERD;

package/dist/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const erd_1 = require("./commands/erd");
+const program = new commander_1.Command();
+program
+    .version('0.1.0')
+    .description('A CLI tool for generating ERD diagrams from DuckDB databases')
+    .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('-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")')
+    .action((options) => {
+    const dbPath = options.database ? path.resolve(options.database) : ':memory:';
+    console.log('Generating ERD diagram...');
+    // Check if the database file exists
+    if (dbPath !== ':memory:' && !fs.existsSync(dbPath)) {
+        console.error(`Error: Database file not found at ${dbPath}`);
+        process.exit(1);
+    }
+    runErd(dbPath, options);
+});
+const runErd = async (dbPath, options) => {
+    const mermaidDiagram = await (0, erd_1.createERD)(dbPath);
+    const mermaidFile = path.resolve('schema_erd.mmd');
+    if (mermaidDiagram) {
+        fs.writeFileSync(mermaidFile, mermaidDiagram);
+        // 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'}`;
+        const width = options.width || 1024;
+        const height = options.height || 768;
+        const theme = options.theme || 'default';
+        const command = `npx mmdc -i ${mermaidFile} -o ${outputFile} -t ${theme} -w ${width} -H ${height}`;
+        (0, child_process_1.exec)(command, (error, stdout, stderr) => {
+            if (error) {
+                console.error(`Error generating ERD: ${error.message}`);
+                return;
+            }
+            if (stderr) {
+                console.error(`ERD generation stderr: ${stderr}`);
+                return;
+            }
+            console.log(`ERD diagram generated: ${outputFile}`);
+            fs.unlinkSync(mermaidFile);
+        });
+    }
+};
+program.parse(process.argv);

package/dist/lib/metadata.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeDataType = 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
+const schemaMetadataQuery = `SELECT database_name as databaseName, schema_name as schemaName FROM duckdb_schemas() WHERE database_name NOT IN ('system', 'temp') and schema_name NOT IN ('information_schema', 'pg_catalog') ORDER BY database_name, schema_name`;
+// Table metadata query
+const tablesMetadataQuery = `SELECT database_name as databaseName, schema_name as schemaName, table_name as name, has_primary_key as hasPrimaryKey, estimated_size as estimatedRowCount, column_count as columnCount, index_count as indexCount, check_constraint_count as checkConstraintCount, sql FROM duckdb_tables() WHERE internal = false ORDER BY database_name, schema_name, table_name`;
+// Column metadata query
+const columnsMetadataQuery = `SELECT database_name as databaseName, schema_name as schemaName, table_name as tableName, column_name as name, data_type as dataType, numeric_precision as precision, numeric_scale as scale, is_nullable as isNullable FROM duckdb_columns() WHERE internal = false ORDER BY database_name, schema_name, table_name, column_index`;
+// Index metadata query
+const indexesMetadataQuery = `SELECT database_name as databaseName, schema_name as schemaName, table_name as tableName, index_name as name, is_unique as isUnique, sql FROM duckdb_indexes() ORDER BY database_name, schema_name, table_name, index_name`;
+// Constraints metadata query
+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 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 databases = databaseRaw.map(database => ({
+        name: database.databaseName,
+        schemas: [...new Set(schemas.filter(schema => database.databaseName === schema.databaseName).map(schema => ({
+                name: schema.schemaName,
+                tables: [...new Set(tables.filter(table => schema.databaseName === table.databaseName && schema.schemaName === table.schemaName).map(table => ({
+                        databaseName: database.databaseName,
+                        schemaName: schema.schemaName,
+                        name: table.name,
+                        hasPrimaryKey: table.hasPrimaryKey,
+                        estimatedRowCount: table.estimatedRowCount,
+                        columnCount: table.columnCount,
+                        indexCount: table.indexCount,
+                        checkConstraintCount: table.checkConstraintCount,
+                        sql: table.sql,
+                        columns: [...new Set(columns.filter(column => column.databaseName === table.databaseName && column.schemaName === table.schemaName && column.tableName === table.name).map(column => ({
+                                name: column.name,
+                                dataType: column.dataType,
+                                precision: column.precision,
+                                scale: column.scale,
+                                isNullable: column.isNullable,
+                            })))],
+                        indexes: [...new Set(indexes.filter(index => index.databaseName === table.databaseName && index.schemaName === table.schemaName && index.tableName === table.name).map(index => ({
+                                name: index.name,
+                                isUnique: index.isUnique,
+                                sql: index.sql,
+                            })))],
+                        constraints: [...new Set(constraints.filter((constraint) => constraint.databaseName === table.databaseName && constraint.schemaName === table.schemaName && constraint.tableName === table.name).map(constraint => ({
+                                columnName: constraint.columnName,
+                                constraintType: constraint.constraintType,
+                                sql: constraint.sql,
+                            })))],
+                    })))],
+                sequences: [...new Set(sequences.filter(sequence => sequence.databaseName === schema.databaseName && sequence.schemaName === schema.schemaName).map(sequence => ({
+                        name: sequence.name,
+                        isTemporary: sequence.isTemporary,
+                        startValue: sequence.startValue,
+                        lastValue: sequence.lastValue,
+                        minValue: sequence.minValue,
+                        maxValue: sequence.maxValue,
+                        incrementBy: sequence.incrementBy,
+                        sql: sequence.sql,
+                    })))],
+            })))],
+    }));
+    const metadata = {
+        databases,
+    };
+    return metadata;
+};
+exports.getMetadata = getMetadata;
+const generateMermaidCodeForAllDBs = (metadata) => {
+    let mermaidCode = `erDiagram
+  
+  `;
+    if (metadata.databases && metadata.databases.length > 0 && metadata.databases[0].schemas && metadata.databases[0].schemas?.length > 0) {
+        // Get tables
+        const tables = metadata.databases.map((db) => db.schemas.map((s) => s.tables).flat()).flat();
+        if (tables && tables.length > 0) {
+            // 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)}`).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;
+        }
+        else {
+            return undefined;
+        }
+    }
+    else {
+        return undefined;
+    }
+};
+exports.generateMermaidCodeForAllDBs = generateMermaidCodeForAllDBs;
+const sanitizeDataType = (dataType) => {
+    return dataType.startsWith("STRUCT(") ? "STRUCT" : dataType;
+};
+exports.sanitizeDataType = sanitizeDataType;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "duckerd",
+  "version": "0.1.0",
+  "description": "A CLI tool for generating ERD diagrams from DuckDB databases",
+  "author": "TobiLG <tobilg@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tobilg/duckerd.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/tobilg/duckerd/issues"
+  },
+  "homepage": "https://github.com/tobilg/duckerd#readme",
+  "bin": {
+    "duckerd": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/index.ts"
+  },
+  "engines": {
+    "node": "^18.19 || >=20.0"
+  },
+  "keywords": ["duckdb", "erd", "diagram", "cli"],
+  "dependencies": {
+    "@mermaid-js/mermaid-cli": "^11.1.1",
+    "commander": "^12.1.0",
+    "duckdb-async": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.6.2"
+  }
+}