loom-weaver 1.0.0

package/README.md

@@ -0,0 +1,157 @@
+# Loom CLI
+
+> Turn SQL `CREATE TABLE` scripts and Prisma schemas into clean, realistic seed data.
+
+Loom CLI parses your SQL DDL (`.sql`) or Prisma model (`.prisma`) files and generates realistic mock data. It supports 5 major SQL dialects (PostgreSQL, MySQL, SQLite, MS SQL Server, Oracle) and can export to SQL `INSERT` statements, CSV, JSON, or a Prisma Client seed script.
+
+---
+
+## Features
+
+- **Dual Parsing**: Handles both raw SQL `CREATE TABLE` definitions and Prisma `schema.prisma` models.
+- **Multi-Table Extraction**: Automatically detects all tables/models in a file and lets you choose which one to generate data for (or specify with `-t`).
+- **5 Database Dialects**: Adjusts quoting, string escaping, booleans, binary hex literals, and arrays for Postgres, MySQL, SQLite, T-SQL, and Oracle.
+- **4 Export Formats**: Output as SQL `INSERT` queries, RFC 4180 CSV, formatted JSON, or a runnable `seed.js` Prisma script.
+- **Interactive Terminal UI**: Step-by-step terminal prompts using arrow keys, with live path validation (no crash on typos).
+- **Smart Extensions**: Pass `-o mydata` and Loom auto-detects `.json`, `.csv`, `.sql`, or `.js` based on your chosen format.
+- **Aesthetic Overwrite Safeguard**: If an output file exists and you choose not to overwrite, Loom automatically saves to a fresh aesthetic filename (like `mango.sql` or `aurora.sql`).
+- **Primary Key Safety**: Detects `AUTO_INCREMENT`, `SERIAL`, `IDENTITY`, `nextval()`, and `@default(autoincrement())` fields and excludes them from `INSERT`s so the database auto-generates IDs naturally.
+- **Smart Data Generators**: Generates realistic names, emails, addresses, phones, CGPAs, UUIDs, XML, JSON, OpenGIS spatial geometries (`ST_GeomFromText`), network IPs, MAC addresses, and string length-checked `VARCHAR(N)` fields.
+
+---
+
+## Installation
+
+```bash
+npm install -g loom-weaver-cli
+```
+
+Or for local development:
+```bash
+git clone https://github.com/your-username/loom-cli.git
+cd loom-cli
+npm install
+npm link
+```
+
+---
+
+## Quick Start
+
+### Interactive Prompt
+Run `loom weave` to launch interactive mode:
+
+```bash
+loom weave
+```
+
+Example session:
+```text
+? Schema file path: schema.sql
+? Select table to weave data for: users
+? Select target export format: SQL INSERT statements (.sql)
+? Select target SQL dialect: PostgreSQL
+? Number of rows to generate: 25
+? Output file name: seed.sql
+
+✔ Success! Woven 25 rows for 'users' into seed.sql
+```
+
+### CLI Flags (Non-interactive)
+Skip prompts with `-s` and pass options directly:
+
+```bash
+# Export 50 rows for MySQL
+loom weave schema.sql -d mysql -r 50 -o mysql_seed.sql -s
+
+# Target a specific table in a multi-table SQL script
+loom weave migration.sql -t users -r 50 -o users.sql -s
+
+# Export 100 rows to CSV (auto-appends .csv)
+loom weave schema.sql -f csv -r 100 -o users -s
+
+# Export 25 rows to JSON (auto-appends .json)
+loom weave schema.sql -f json -r 25 -o users -s
+
+# Generate a Prisma Client seed script (seed.js)
+loom weave schema.prisma -f prisma -r 50 -o seed -s
+```
+
+---
+
+## Options
+
+| Flag | Short | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `--table <name>` | `-t` | Table or model name to extract | First table in schema |
+| `--rows <number>` | `-r` | Number of rows to generate | `10` |
+| `--output <file>` | `-o` | Output file name | `seed.sql` (or `.csv`/`.json`/`.js`) |
+| `--format <type>` | `-f` | Output format (`sql`, `csv`, `json`, `prisma`) | `sql` |
+| `--dialect <name>` | `-d` | SQL engine (`postgres`, `mysql`, `sqlite`, `mssql`, `oracle`) | `postgres` |
+| `--skip-prompts` | `-s` | Skip interactive prompt and use flags | `false` |
+
+---
+
+## Supported Data Types
+
+| Category | Schema Types | Example Generated Output |
+| :--- | :--- | :--- |
+| **Identifiers** | `UUID`, `cuid()`, `ulid()`, `@db.Uuid`, `*_id` | `'89dcaf73-7010-484a-bef1-80cd389faa45'` |
+| **Auto-Increment** | `SERIAL`, `BIGSERIAL`, `AUTO_INCREMENT`, `IDENTITY`, `nextval()` | *Omitted from INSERT list* |
+| **Integers** | `INT`, `BIGINT`, `SMALLINT`, `TINYINT` | `42`, `8921` |
+| **Decimals & Floats**| `DECIMAL(10,2)`, `NUMERIC`, `FLOAT`, `DOUBLE PRECISION`, `REAL` | `154.50`, `3.85` |
+| **Booleans** | `BOOLEAN`, `BIT`, `is_*`, `has_*` | `TRUE` / `FALSE` (or `1` / `0`) |
+| **Dates & Times** | `DATE`, `TIME`, `TIMETZ`, `TIMESTAMP`, `TIMESTAMPTZ` | `'2026-03-31'`, `'13:39:24'`, `'2026-02-06 10:28:36'` |
+| **Intervals** | `INTERVAL`, `*_duration` | `'2 hours 30 mins'`, `'1 day'` |
+| **JSON** | `JSON`, `JSONB`, Prisma `Json` | `'{"theme":"dark", "views":150}'` |
+| **XML** | `XML`, `@db.Xml` | `'<document><id>123</id><content>data</content></document>'` |
+| **Binary** | `BYTEA`, `BLOB`, `BINARY`, Prisma `Bytes` | Hex format per dialect (`'\x...'`, `X'...'`, `0x...`) |
+| **Spatial / GIS** | `POINT`, `LSEG`, `LINESTRING`, `POLYGON` | `ST_GeomFromText('POINT(-87.39 41.88)')` |
+| **Network** | `INET`, `CIDR`, `MACADDR` | `'192.168.1.1'`, `'00:1A:2B:3C:4D:5E'` |
+| **Enums** | SQL `ENUM(...)` or Prisma `enum Role { ... }` | Selected from enum values (`'ADMIN'`, `'USER'`) |
+| **Arrays / Lists** | Postgres `TEXT[]`, `INT[]` or Prisma `String[]` | Native array syntax (`'{"a", "b"}'` or `JSON_ARRAY(...)`) |
+
+---
+
+## Programmatic API
+
+You can also use Loom as a library inside your Node.js code:
+
+```javascript
+import { weave, parseSchema, generateRow, formatData } from 'loom-weaver-cli';
+
+// Weave directly from a schema file
+const result = weave('schema.sql', {
+  table: 'users',
+  rows: 50,
+  format: 'json',
+  output: 'users' // Auto-resolves to users.json
+});
+
+console.log(`Generated ${result.rowCount} rows into ${result.outputFile}`);
+
+// Low-level schema parsing & row generation
+const schemaText = `
+  CREATE TABLE users (
+    id UUID PRIMARY KEY,
+    name VARCHAR(100),
+    email VARCHAR(100)
+  );
+`;
+
+const parsed = parseSchema(schemaText, false); // false = SQL
+const rows = Array.from({ length: 5 }, () => generateRow(parsed.columns));
+
+const sql = formatData(parsed.tableName, rows, {
+  format: 'sql',
+  dialect: 'mysql'
+});
+
+console.log(sql);
+```
+
+---
+
+## License
+
+ISC

package/bin/loom.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runCLI } from '../src/cli.js';
+
+runCLI();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "loom-weaver",
+  "version": "1.0.0",
+  "description": "A CLI to weave mock data from your database schemas",
+  "main": "src/index.js",
+  "bin": {
+    "loom": "bin/loom.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "mock-data",
+    "faker",
+    "sql",
+    "prisma",
+    "generator",
+    "postgres",
+    "mysql",
+    "sqlite",
+    "seed"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "@faker-js/faker": "^10.5.0",
+    "@inquirer/prompts": "^8.5.2",
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "ora": "^9.4.1"
+  }
+}

package/src/cli.js

@@ -0,0 +1,248 @@
+import { program } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { input, select } from '@inquirer/prompts';
+import { weave } from './index.js';
+import { stripSqlComments } from './parsers/sqlParser.js';
+import { getSchemaTableNames } from './parsers/index.js';
+
+const AESTHETIC_WORDS = [
+  'mango', 'aurora', 'velvet', 'nebula', 'breeze',
+  'cascade', 'horizon', 'zenith', 'solar', 'lunar',
+  'prism', 'echo', 'ember', 'drift', 'orbit'
+];
+
+function getUniqueAestheticFilename(ext = '.sql') {
+  for (const word of AESTHETIC_WORDS) {
+    const candidate = `${word}${ext}`;
+    if (!fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  let count = 1;
+  while (fs.existsSync(`seed_${count}${ext}`)) {
+    count++;
+  }
+  return `seed_${count}${ext}`;
+}
+
+function validateSchemaFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File '${filePath}' does not exist.`);
+  }
+
+  const isPrisma = filePath.endsWith('.prisma');
+  const rawText = fs.readFileSync(filePath, 'utf-8');
+
+  if (isPrisma) {
+    const cleanText = rawText.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*/g, '');
+    const modelMatch = cleanText.match(/model\s+(\w+)\s*{([\s\S]+?)}/i);
+    if (!modelMatch) {
+      throw new Error(`File '${filePath}' does not contain a valid Prisma model.`);
+    }
+  } else {
+    const cleanText = stripSqlComments(rawText);
+    const tableMatch = cleanText.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:[`"]?[\w]+[`"]?\.)?[`"]?[\w]+[`"]?|\"[^\"]+\"|`[^`]+`)\s*\(([\s\S]+?)\);/i);
+    if (!tableMatch) {
+      throw new Error(`File '${filePath}' does not contain a valid CREATE TABLE statement.`);
+    }
+  }
+}
+
+program
+  .name('loom')
+  .description('A CLI to weave mock data from your database schemas')
+  .version('1.0.0');
+
+program
+  .command('ping')
+  .description('Check if the CLI is working')
+  .action(() => {
+    console.log(chalk.green('Pong! Loom is alive and well.'));
+  });
+
+program
+  .command('weave [file]')
+  .description('Read a schema file to prepare for data generation')
+  .option('-r, --rows <number>', 'Number of rows to generate')
+  .option('-o, --output <filename>', 'Output file name')
+  .option('-f, --format <type>', 'Export format (sql, csv, json, prisma)')
+  .option('-d, --dialect <name>', 'Target SQL dialect (postgres, mysql, sqlite, mssql, oracle)')
+  .option('-t, --table <name>', 'Target table or model name in multi-entity schema')
+  .option('-s, --skip-prompts', 'Skip interactive prompts and use defaults or passed flags')
+  .action(async (file, options) => {
+    let schemaFile = file;
+    let rowCount = options.rows;
+    let outputFile = options.output;
+    let format = options.format;
+    let dialect = options.dialect;
+    let targetTable = options.table;
+    const skipPrompts = options.skipPrompts;
+
+    if (!skipPrompts) {
+      try {
+        if (!schemaFile) {
+          schemaFile = await input({
+            message: 'Schema file path:',
+            validate: (val) => {
+              const trimmed = val.trim();
+              if (!trimmed) return 'Schema file path is required.';
+              try {
+                validateSchemaFile(trimmed);
+                return true;
+              } catch (err) {
+                return err.message;
+              }
+            }
+          });
+          schemaFile = schemaFile.trim();
+        } else {
+          try {
+            validateSchemaFile(schemaFile);
+          } catch (err) {
+            console.log(chalk.red(`Error: ${err.message}`));
+            process.exit(1);
+          }
+        }
+
+        // If schema has multiple tables/models, prompt user to select target entity
+        const schemaContent = fs.readFileSync(schemaFile, 'utf-8');
+        const isPrismaFile = schemaFile.endsWith('.prisma');
+        const availableTables = getSchemaTableNames(schemaContent, isPrismaFile);
+
+        if (availableTables.length > 1 && !targetTable) {
+          targetTable = await select({
+            message: `Select ${isPrismaFile ? 'model' : 'table'} to weave data for:`,
+            choices: availableTables.map(t => ({ name: t, value: t })),
+            default: availableTables[0]
+          });
+        }
+
+        if (!format) {
+          format = await select({
+            message: 'Select target export format:',
+            choices: [
+              { name: 'SQL INSERT statements (.sql)', value: 'sql' },
+              { name: 'CSV data file (.csv)', value: 'csv' },
+              { name: 'JSON data file (.json)', value: 'json' },
+              { name: 'Prisma Client seed script (.js)', value: 'prisma' }
+            ],
+            default: 'sql'
+          });
+        }
+
+        if (format === 'sql' && !dialect) {
+          dialect = await select({
+            message: 'Select target SQL dialect:',
+            choices: [
+              { name: 'PostgreSQL', value: 'postgres' },
+              { name: 'MySQL / MariaDB', value: 'mysql' },
+              { name: 'SQLite', value: 'sqlite' },
+              { name: 'MS SQL Server (T-SQL)', value: 'mssql' },
+              { name: 'Oracle Database', value: 'oracle' }
+            ],
+            default: 'postgres'
+          });
+        }
+
+        if (!rowCount) {
+          const answer = await input({
+            message: 'Number of rows to generate:',
+            default: '10'
+          });
+          rowCount = answer.trim() || '10';
+        }
+
+        let defaultExt = '.sql';
+        if (format === 'csv') defaultExt = '.csv';
+        else if (format === 'json') defaultExt = '.json';
+        else if (format === 'prisma') defaultExt = '.js';
+
+        if (!outputFile) {
+          const defaultFileName = `seed${defaultExt}`;
+          const answer = await input({
+            message: 'Output file name:',
+            default: defaultFileName
+          });
+          outputFile = answer.trim() || defaultFileName;
+        }
+
+        // Auto-append format extension if no file extension was specified
+        if (!path.extname(outputFile)) {
+          outputFile = `${outputFile}${defaultExt}`;
+        }
+
+        // Check if output file already exists and contains data
+        if (fs.existsSync(outputFile)) {
+          const stats = fs.statSync(outputFile);
+          if (stats.size > 0) {
+            const ext = path.extname(outputFile) || defaultExt;
+            const alternativeFile = getUniqueAestheticFilename(ext);
+
+            const shouldOverwrite = await select({
+              message: `Output file '${outputFile}' already exists. Overwrite?`,
+              choices: [
+                { name: `No  (Generate to a new file instead)`, value: false },
+                { name: `Yes (Overwrite ${outputFile})`, value: true }
+              ],
+              default: false
+            });
+
+            if (!shouldOverwrite) {
+              outputFile = alternativeFile;
+            }
+          }
+        }
+      } catch (err) {
+        if (err.name === 'ExitPromptError' || err.name === 'AbortError' || err.code === 'ABORT_ERR') {
+          console.log(chalk.yellow('\nOperation cancelled.'));
+          process.exit(0);
+        }
+        throw err;
+      }
+    } else {
+      if (!schemaFile) {
+        console.log(chalk.red('Error: Schema file path is required when skipping prompts.'));
+        process.exit(1);
+      }
+
+      try {
+        validateSchemaFile(schemaFile);
+      } catch (err) {
+        console.log(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+
+      format = format || 'sql';
+      dialect = dialect || 'postgres';
+      rowCount = rowCount || '10';
+
+      let defaultExt = '.sql';
+      if (format === 'csv') defaultExt = '.csv';
+      else if (format === 'json') defaultExt = '.json';
+      else if (format === 'prisma') defaultExt = '.js';
+
+      if (!outputFile) {
+        outputFile = `seed${defaultExt}`;
+      } else if (!path.extname(outputFile)) {
+        outputFile = `${outputFile}${defaultExt}`;
+      }
+    }
+
+    const spinner = ora(`Reading ${schemaFile}...`).start(); 
+
+    try {
+      spinner.text = 'Parsing schema & weaving mock data...';
+      const result = weave(schemaFile, { rows: rowCount, output: outputFile, format, dialect, table: targetTable });
+      
+      spinner.succeed(chalk.green(`Success! Woven ${result.rowCount} rows for '${result.tableName}' into ${result.outputFile}`));
+    } catch (error) {
+      spinner.fail(chalk.red(`Error: ${error.message || "Could not process file."}`));
+    }
+  });
+
+export function runCLI() {
+  program.parse(process.argv);
+}

package/src/formatters/csvFormatter.js

@@ -0,0 +1,41 @@
+/**
+ * Formats mock data objects into RFC 4180 compliant CSV text.
+ * @param {Array<Record<string, any>>} mockData - Array of mock data row objects.
+ * @returns {string} CSV text.
+ */
+export function generateCSV(mockData) {
+  if (!mockData || mockData.length === 0) return '';
+
+  const headers = Object.keys(mockData[0]);
+  const lines = [headers.join(',')];
+
+  mockData.forEach(row => {
+    const rowCells = headers.map(header => {
+      let val = row[header];
+      if (val === null || val === undefined) return '';
+      
+      if (val && typeof val === 'object') {
+        if (val.rawSql) {
+          const geomMatch = val.rawSql.match(/ST_GeomFromText\('([^']+)'\)/i);
+          val = geomMatch ? geomMatch[1] : val.rawSql;
+        } else if (val.rawHex) {
+          val = val.rawHex;
+        } else {
+          val = JSON.stringify(val);
+        }
+      } else if (Array.isArray(val)) {
+        val = JSON.stringify(val);
+      }
+
+      val = String(val);
+      if (val.includes(',') || val.includes('"') || val.includes('\n') || val.includes('\r')) {
+        return `"${val.replace(/"/g, '""')}"`;
+      }
+      return val;
+    });
+
+    lines.push(rowCells.join(','));
+  });
+
+  return lines.join('\n');
+}

package/src/formatters/dialects.js

@@ -0,0 +1,62 @@
+export const DIALECTS = {
+  postgres: {
+    name: 'PostgreSQL',
+    quoteIdentifier: (name) => `"${name}"`,
+    formatBoolean: (val) => (val ? 'TRUE' : 'FALSE'),
+    formatBinary: (hex) => `'\\x${hex}'`,
+    escapeString: (str) => str.replace(/'/g, "''"),
+    formatArray: (val) => {
+      const elements = val.map(el => typeof el === 'string' ? `"${el.replace(/"/g, '\\"')}"` : el);
+      return "'{" + elements.join(', ') + "}'";
+    }
+  },
+  mysql: {
+    name: 'MySQL',
+    quoteIdentifier: (name) => `\`${name}\``,
+    formatBoolean: (val) => (val ? 'TRUE' : 'FALSE'),
+    formatBinary: (hex) => `X'${hex}'`,
+    escapeString: (str) => str.replace(/\\/g, '\\\\').replace(/'/g, "''"),
+    formatArray: (val) => {
+      const items = val.map(el => typeof el === 'string' ? `'${el.replace(/\\/g, '\\\\').replace(/'/g, "''")}'` : el);
+      return `JSON_ARRAY(${items.join(', ')})`;
+    }
+  },
+  sqlite: {
+    name: 'SQLite',
+    quoteIdentifier: (name) => `"${name}"`,
+    formatBoolean: (val) => (val ? '1' : '0'),
+    formatBinary: (hex) => `X'${hex}'`,
+    escapeString: (str) => str.replace(/'/g, "''"),
+    formatArray: (val) => {
+      const items = val.map(el => typeof el === 'string' ? `'${el.replace(/'/g, "''")}'` : el);
+      return `json_array(${items.join(', ')})`;
+    }
+  },
+  mssql: {
+    name: 'MS SQL Server',
+    quoteIdentifier: (name) => `[${name}]`,
+    formatBoolean: (val) => (val ? '1' : '0'),
+    formatBinary: (hex) => `0x${hex}`,
+    escapeString: (str) => str.replace(/'/g, "''"),
+    formatArray: (val) => {
+      const jsonStr = JSON.stringify(val).replace(/'/g, "''");
+      return `'${jsonStr}'`;
+    }
+  },
+  oracle: {
+    name: 'Oracle Database',
+    quoteIdentifier: (name) => `"${name.toUpperCase()}"`,
+    formatBoolean: (val) => (val ? '1' : '0'),
+    formatBinary: (hex) => `hextoraw('${hex}')`,
+    escapeString: (str) => str.replace(/'/g, "''"),
+    formatArray: (val) => {
+      const jsonStr = JSON.stringify(val).replace(/'/g, "''");
+      return `'${jsonStr}'`;
+    }
+  }
+};
+
+export function getDialect(name = 'postgres') {
+  const normalized = (name || 'postgres').toLowerCase().trim();
+  return DIALECTS[normalized] || DIALECTS.postgres;
+}

package/src/formatters/index.js

@@ -0,0 +1,41 @@
+import { generateSQL } from './sqlFormatter.js';
+import { generateCSV } from './csvFormatter.js';
+import { generateJSON } from './jsonFormatter.js';
+import { generatePrismaSeed } from './prismaSeedFormatter.js';
+import { DIALECTS, getDialect } from './dialects.js';
+
+export {
+  generateSQL,
+  generateCSV,
+  generateJSON,
+  generatePrismaSeed,
+  DIALECTS,
+  getDialect
+};
+
+/**
+ * Formats mock data according to format type (sql, csv, json, prisma) and SQL dialect.
+ * @param {string} tableName - Name of table / model.
+ * @param {Array<Record<string, any>>} mockData - Mock rows array.
+ * @param {object} [options] - Options map.
+ * @param {string} [options.format='sql'] - Output format (sql, csv, json, prisma).
+ * @param {string} [options.dialect='postgres'] - Target SQL dialect (postgres, mysql, sqlite, mssql, oracle).
+ * @returns {string} Formatted output content.
+ */
+export function formatData(tableName, mockData, options = {}) {
+  const fmt = (options.format || 'sql').toLowerCase().trim();
+  const dialect = options.dialect || 'postgres';
+
+  switch (fmt) {
+    case 'csv':
+      return generateCSV(mockData);
+    case 'json':
+      return generateJSON(mockData);
+    case 'prisma':
+    case 'prismaseed':
+      return generatePrismaSeed(tableName, mockData);
+    case 'sql':
+    default:
+      return generateSQL(tableName, mockData, dialect);
+  }
+}

package/src/formatters/jsonFormatter.js

@@ -0,0 +1,27 @@
+/**
+ * Formats mock data objects into pretty-printed JSON text.
+ * @param {Array<Record<string, any>>} mockData - Array of mock data row objects.
+ * @returns {string} JSON text.
+ */
+export function generateJSON(mockData) {
+  if (!mockData) return '[]';
+
+  const cleanedData = mockData.map(row => {
+    const cleanRow = {};
+    Object.keys(row).forEach(key => {
+      let val = row[key];
+      if (val && typeof val === 'object') {
+        if (val.rawSql) {
+          const geomMatch = val.rawSql.match(/ST_GeomFromText\('([^']+)'\)/i);
+          val = geomMatch ? geomMatch[1] : val.rawSql;
+        } else if (val.rawHex) {
+          val = val.rawHex;
+        }
+      }
+      cleanRow[key] = val;
+    });
+    return cleanRow;
+  });
+
+  return JSON.stringify(cleanedData, null, 2);
+}

package/src/formatters/prismaSeedFormatter.js

@@ -0,0 +1,52 @@
+/**
+ * Formats mock data objects into a runnable Prisma Client seed script.
+ * @param {string} tableName - Target Prisma model / table name.
+ * @param {Array<Record<string, any>>} mockData - Array of mock data row objects.
+ * @returns {string} Runnable JavaScript Prisma seed script.
+ */
+export function generatePrismaSeed(tableName, mockData) {
+  if (!mockData || mockData.length === 0) return '';
+
+  const modelName = tableName.charAt(0).toLowerCase() + tableName.slice(1);
+  const cleanedData = mockData.map(row => {
+    const cleanRow = {};
+    Object.keys(row).forEach(key => {
+      let val = row[key];
+      if (val && typeof val === 'object') {
+        if (val.rawSql) {
+          const geomMatch = val.rawSql.match(/ST_GeomFromText\('([^']+)'\)/i);
+          val = geomMatch ? geomMatch[1] : val.rawSql;
+        } else if (val.rawHex) {
+          val = val.rawHex;
+        }
+      }
+      cleanRow[key] = val;
+    });
+    return cleanRow;
+  });
+
+  const jsonPayload = JSON.stringify(cleanedData, null, 4);
+
+  return `import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+async function main() {
+  console.log('Seeding ${tableName} model...');
+  const result = await prisma.${modelName}.createMany({
+    data: ${jsonPayload},
+    skipDuplicates: true,
+  });
+  console.log(\`Successfully seeded \${result.count} rows into ${tableName}.\`);
+}
+
+main()
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });
+`;
+}

package/src/formatters/sqlFormatter.js

@@ -0,0 +1,49 @@
+import { getDialect } from './dialects.js';
+
+/**
+ * Generates an SQL INSERT statement from table name and array of mock data row objects.
+ * @param {string} tableName - Target SQL table name.
+ * @param {Array<Record<string, any>>} mockData - Array of generated mock rows.
+ * @param {string} [dialectName='postgres'] - Target SQL dialect (postgres, mysql, sqlite, mssql, oracle).
+ * @returns {string} Formatted SQL INSERT statement.
+ */
+export function generateSQL(tableName, mockData, dialectName = 'postgres') {
+  if (!mockData || mockData.length === 0) return '';
+
+  const dialect = getDialect(dialectName);
+  const quotedTable = dialect.quoteIdentifier(tableName);
+  const rawColumns = Object.keys(mockData[0]);
+  const quotedColumns = rawColumns.map(col => dialect.quoteIdentifier(col)).join(', ');
+
+  const values = mockData.map(row => {
+    const rowValues = Object.values(row).map(val => {
+      if (val === null || val === undefined) return 'NULL';
+      if (typeof val === 'boolean') return dialect.formatBoolean(val);
+      if (typeof val === 'number') return val;
+
+      if (val && typeof val === 'object') {
+        if (val.rawSql) return val.rawSql;
+        if (val.rawHex) return dialect.formatBinary(val.rawHex);
+      }
+
+      if (Array.isArray(val)) {
+        return dialect.formatArray(val);
+      }
+
+      if (typeof val === 'object') {
+        const jsonStr = dialect.escapeString(JSON.stringify(val));
+        return `'${jsonStr}'`;
+      }
+
+      if (typeof val === 'string') {
+        const escaped = dialect.escapeString(val);
+        return `'${escaped}'`;
+      }
+
+      return `'${val}'`;
+    });
+    return `(${rowValues.join(', ')})`;
+  });
+
+  return `INSERT INTO ${quotedTable} (${quotedColumns})\nVALUES\n  ${values.join(',\n  ')};`;
+}

package/src/generators/dataGenerator.js

@@ -0,0 +1,264 @@
+import { faker } from '@faker-js/faker';
+
+/**
+ * Generates a mock data row object for the given column definitions.
+ * @param {Array<{ name: string, type: string, fullLine?: string, isEnum?: boolean, enumValues?: string[] }>} columns
+ * @returns {Record<string, any>} Mock row data map
+ */
+export function generateRow(columns) {
+  const row = {};
+  
+  columns.forEach(col => {
+    const colName = col.name;
+    const colNameLower = colName.toLowerCase();
+    const rawType = (col.type || '').trim();
+    const typeLower = rawType.toLowerCase();
+    const fullLineLower = (col.fullLine || '').toLowerCase();
+    
+    const isArray = rawType.endsWith('[]') || typeLower.includes('array');
+    const baseTypeLower = typeLower.replace(/\[\]/g, '').replace(/\?/g, '').replace(/array/g, '').trim();
+
+    const generateSingleValue = (tLower, nameLower, lineLower) => {
+      // 0. Explicit Schema Enums
+      if (col.isEnum && col.enumValues && col.enumValues.length > 0) {
+        return faker.helpers.arrayElement(col.enumValues);
+      }
+
+      // 1. UUID / CUID / Identifiers
+      if (
+        tLower.includes('uuid') ||
+        lineLower.includes('uuid()') ||
+        lineLower.includes('cuid()') ||
+        lineLower.includes('ulid()') ||
+        lineLower.includes('@db.uuid') ||
+        (nameLower.endsWith('id') && (tLower.includes('string') || tLower.includes('varchar') || tLower.includes('char') || tLower.includes('text')))
+      ) {
+        return faker.string.uuid();
+      }
+
+      // 2. Geometric / Spatial Types (OpenGIS ST_GeomFromText standard)
+      if (tLower.includes('point') || lineLower.includes('@db.point')) {
+        const lng = faker.location.longitude().toFixed(2);
+        const lat = faker.location.latitude().toFixed(2);
+        return { rawSql: `ST_GeomFromText('POINT(${lng} ${lat})')` };
+      }
+      if (tLower.includes('linestring') || tLower.includes('lseg') || lineLower.includes('@db.lseg')) {
+        return { rawSql: `ST_GeomFromText('LINESTRING(0 0, 30 48)')` };
+      }
+      if (tLower.includes('polygon') || lineLower.includes('@db.polygon')) {
+        return { rawSql: `ST_GeomFromText('POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))')` };
+      }
+      if (tLower === 'circle' || tLower === 'box' || tLower === 'path') {
+        return { rawSql: `ST_GeomFromText('POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))')` };
+      }
+
+      // 3. XML & Document Types
+      if (tLower === 'xml' || lineLower.includes('@db.xml')) {
+        return `<document><id>${faker.number.int()}</id><content>${faker.lorem.word()}</content></document>`;
+      }
+
+      // 4. Money / Currency Types
+      if (tLower.includes('money') || lineLower.includes('@db.money')) {
+        return parseFloat(faker.finance.amount({ min: 10, max: 5000, dec: 2 }));
+      }
+
+      // 5. Time Interval / Duration Types
+      if (tLower.includes('interval') || nameLower.includes('duration') || nameLower.includes('interval') || lineLower.includes('@db.interval')) {
+        return faker.helpers.arrayElement(['1 day', '2 hours 30 mins', '5 days 12 hours', '01:30:00']);
+      }
+
+      // 6. Inline SQL Enum Types
+      if (tLower.startsWith('enum')) {
+        const enumMatch = rawType.match(/enum\s*\(([^)]+)\)/i);
+        if (enumMatch) {
+          const values = enumMatch[1]
+            .split(',')
+            .map(v => v.trim().replace(/^['"]|['"]$/g, ''));
+          if (values.length > 0) return faker.helpers.arrayElement(values);
+        }
+      }
+      if (nameLower.includes('role')) return faker.helpers.arrayElement(['ADMIN', 'USER', 'GUEST']);
+      if (nameLower.includes('status') || nameLower.includes('state')) return faker.helpers.arrayElement(['ACTIVE', 'INACTIVE', 'PENDING', 'COMPLETED']);
+
+      // 7. Integer Types (Int, BigInt, SmallInt, TinyInt, Serial, etc.)
+      if (
+        tLower.includes('int') ||
+        tLower.includes('serial') ||
+        tLower.includes('number') ||
+        lineLower.includes('@db.smallint') ||
+        lineLower.includes('@db.tinyint') ||
+        (nameLower.endsWith('id') && !tLower.includes('string'))
+      ) {
+        if (tLower.includes('smallint') || tLower.includes('tinyint') || tLower.includes('int2') || tLower.includes('smallserial') || lineLower.includes('@db.smallint')) {
+          return faker.number.int({ min: 1, max: 100 });
+        }
+        if (nameLower.includes('age')) {
+          return faker.number.int({ min: 18, max: 80 });
+        }
+        if (nameLower.includes('year')) {
+          return faker.number.int({ min: 1995, max: 2026 });
+        }
+        if (nameLower.includes('count') || nameLower.includes('quantity') || nameLower.includes('stock')) {
+          return faker.number.int({ min: 0, max: 500 });
+        }
+        return faker.number.int({ min: 1, max: 10000 });
+      }
+
+      // 8. Float / Double / Decimal / Real / Numeric Types
+      if (
+        tLower.includes('float') ||
+        tLower.includes('decimal') ||
+        tLower.includes('double') ||
+        tLower.includes('real') ||
+        tLower.includes('numeric') ||
+        nameLower.includes('price') ||
+        nameLower.includes('amount') ||
+        nameLower.includes('cost') ||
+        nameLower.includes('balance') ||
+        nameLower.includes('salary') ||
+        nameLower.includes('rate') ||
+        nameLower.includes('tax') ||
+        nameLower.includes('cgpa') ||
+        nameLower.includes('gpa')
+      ) {
+        if (nameLower.includes('cgpa') || nameLower.includes('gpa')) {
+          return parseFloat(faker.number.float({ min: 2.0, max: 4.0, fractionDigits: 2 }).toFixed(2));
+        }
+        if (nameLower.includes('rate') || nameLower.includes('percent')) {
+          return parseFloat(faker.number.float({ min: 0, max: 1, fractionDigits: 2 }).toFixed(2));
+        }
+        return parseFloat(faker.finance.amount({ min: 10, max: 1000, dec: 2 }));
+      }
+
+      // 9. Boolean Types
+      if (
+        tLower.includes('bool') ||
+        tLower.includes('bit') ||
+        nameLower.startsWith('is_') ||
+        nameLower.startsWith('has_') ||
+        nameLower.startsWith('can_') ||
+        nameLower.startsWith('should_') ||
+        nameLower.startsWith('is') ||
+        nameLower.startsWith('has')
+      ) {
+        return faker.datatype.boolean();
+      }
+
+      // 10. Date & Time Types (Date, Time, Timetz, Timestamp, Timestamptz, DateTime)
+      if (tLower.includes('date') || tLower.includes('time') || tLower.includes('timestamp') || lineLower.includes('@db.date') || lineLower.includes('@db.time')) {
+        if (nameLower.includes('birth') || nameLower.includes('dob') || nameLower.includes('birthday')) {
+          return faker.date.birthdate().toISOString().slice(0, 10);
+        }
+        if (tLower === 'date' || lineLower.includes('@db.date')) {
+          return faker.date.past().toISOString().slice(0, 10);
+        }
+        if (tLower.includes('timetz') || tLower.includes('with time zone')) {
+          return faker.date.past().toISOString().slice(11, 19) + '+00';
+        }
+        if (tLower === 'time' || lineLower.includes('@db.time')) {
+          return faker.date.past().toISOString().slice(11, 19);
+        }
+        return faker.date.past().toISOString().slice(0, 19).replace('T', ' ');
+      }
+
+      // 11. JSON / Semi-Structured Types
+      if (tLower.includes('json')) {
+        return {
+          theme: faker.helpers.arrayElement(['dark', 'light']),
+          notifications: faker.datatype.boolean(),
+          views: faker.number.int({ min: 10, max: 500 })
+        };
+      }
+
+      // 12. Binary / Bytes / Blob Types
+      if (
+        tLower.includes('byte') ||
+        tLower.includes('blob') ||
+        tLower.includes('binary')
+      ) {
+        const hex = faker.string.hexadecimal({ length: 16, prefix: '' });
+        return { rawHex: hex };
+      }
+
+      // 13. Network / IP / MAC Types
+      if (tLower.includes('inet') || lineLower.includes('@db.inet') || tLower.includes('cidr')) {
+        return faker.internet.ip();
+      }
+      if (tLower.includes('macaddr') || lineLower.includes('@db.macaddr') || tLower.includes('mac')) {
+        return faker.internet.mac();
+      }
+
+      // 14. Strings & Character Types with Smart Field Heuristics
+      let strVal = '';
+      if (nameLower.includes('email') || nameLower.includes('mail')) {
+        strVal = faker.internet.email();
+      } else if (nameLower.includes('first_name') || nameLower.includes('firstname')) {
+        strVal = faker.person.firstName();
+      } else if (nameLower.includes('last_name') || nameLower.includes('lastname')) {
+        strVal = faker.person.lastName();
+      } else if (nameLower.includes('full_name') || nameLower.includes('fullname') || (nameLower.includes('name') && !nameLower.includes('file'))) {
+        strVal = faker.person.fullName();
+      } else if (nameLower.includes('user') || nameLower.includes('username') || nameLower.includes('handle')) {
+        strVal = faker.internet.username();
+      } else if (nameLower.includes('phone') || nameLower.includes('mobile') || nameLower.includes('tel') || nameLower.includes('cell')) {
+        strVal = faker.phone.number();
+      } else if (nameLower.includes('url') || nameLower.includes('website') || nameLower.includes('link') || nameLower.includes('domain')) {
+        strVal = faker.internet.url();
+      } else if (nameLower.includes('avatar') || nameLower.includes('image') || nameLower.includes('photo') || nameLower.includes('picture') || nameLower.includes('logo') || nameLower.includes('icon')) {
+        strVal = faker.image.avatar();
+      } else if (nameLower.includes('company') || nameLower.includes('org') || nameLower.includes('publisher')) {
+        strVal = faker.company.name();
+      } else if (nameLower.includes('job') || nameLower.includes('position') || nameLower.includes('occupation')) {
+        strVal = faker.person.jobTitle();
+      } else if (nameLower.includes('gender') || nameLower === 'sex') {
+        strVal = faker.person.sex();
+      } else if (nameLower.includes('department') || nameLower.includes('dept')) {
+        strVal = faker.commerce.department();
+      } else if (nameLower.includes('currency')) {
+        strVal = faker.finance.currencyCode();
+      } else if (nameLower.includes('birth') || nameLower.includes('dob') || nameLower.includes('birthday')) {
+        strVal = faker.date.birthdate().toISOString().slice(0, 10);
+      } else if (nameLower.includes('address') || nameLower.includes('street')) {
+        strVal = faker.location.streetAddress();
+      } else if (nameLower.includes('city')) {
+        strVal = faker.location.city();
+      } else if (nameLower.includes('country')) {
+        strVal = faker.location.country();
+      } else if (nameLower.includes('zip') || nameLower.includes('postal') || nameLower.includes('zipcode')) {
+        strVal = faker.location.zipCode();
+      } else if (nameLower.includes('bio') || nameLower.includes('description') || nameLower.includes('content') || nameLower.includes('body') || nameLower.includes('summary') || nameLower.includes('notes')) {
+        strVal = faker.lorem.paragraph();
+      } else if (nameLower.includes('title') || nameLower.includes('subject') || nameLower.includes('headline') || nameLower.includes('caption')) {
+        strVal = faker.lorem.sentence();
+      } else if (nameLower.includes('slug')) {
+        strVal = faker.lorem.slug();
+      } else {
+        strVal = faker.lorem.word();
+      }
+
+      // Truncate string if type specifies length VARCHAR(N) or CHAR(N)
+      const lengthMatch = rawType.match(/(?:varchar|char|nvarchar|nchar)\s*\(\s*(\d+)\s*\)/i);
+      if (lengthMatch && typeof strVal === 'string') {
+        const maxLen = parseInt(lengthMatch[1], 10);
+        if (maxLen > 0 && strVal.length > maxLen) {
+          strVal = strVal.slice(0, maxLen);
+        }
+      }
+
+      return strVal;
+    };
+
+    if (isArray) {
+      const count = faker.number.int({ min: 2, max: 4 });
+      const list = [];
+      for (let k = 0; k < count; k++) {
+        list.push(generateSingleValue(baseTypeLower, colNameLower, fullLineLower));
+      }
+      row[colName] = list;
+    } else {
+      row[colName] = generateSingleValue(typeLower, colNameLower, fullLineLower);
+    }
+  });
+
+  return row;
+}

package/src/index.js

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import path from 'path';
+import { parseSchema, parseSqlSchema, parsePrismaSchema, getSchemaTableNames } from './parsers/index.js';
+import { generateRow } from './generators/dataGenerator.js';
+import { formatData, generateSQL, generateCSV, generateJSON, generatePrismaSeed } from './formatters/index.js';
+
+export {
+  parseSchema,
+  parseSqlSchema,
+  parsePrismaSchema,
+  getSchemaTableNames,
+  generateRow,
+  formatData,
+  generateSQL,
+  generateCSV,
+  generateJSON,
+  generatePrismaSeed
+};
+
+/**
+ * Weaves mock data from a schema file and writes formatted output to a destination file.
+ * @param {string} file - Path to schema file (.sql or .prisma).
+ * @param {object} [options] - Options map.
+ * @param {number} [options.rows=10] - Number of rows to generate.
+ * @param {string} [options.output] - Target output file.
+ * @param {string} [options.format='sql'] - Target format (sql, csv, json, prisma).
+ * @param {string} [options.dialect='postgres'] - Target SQL dialect (postgres, mysql, sqlite, mssql, oracle).
+ * @param {string} [options.table] - Target table/model name to extract from multi-entity schema.
+ * @returns {{ tableName: string, rowCount: number, outputFile: string, content: string }}
+ */
+export function weave(file, options = {}) {
+  const rowCount = parseInt(options.rows || 10, 10);
+  const format = (options.format || 'sql').toLowerCase().trim();
+  const dialect = (options.dialect || 'postgres').toLowerCase().trim();
+  const targetTable = options.table || options.targetTable;
+
+  let defaultExt = '.sql';
+  if (format === 'csv') defaultExt = '.csv';
+  else if (format === 'json') defaultExt = '.json';
+  else if (format === 'prisma' || format === 'prismaseed') defaultExt = '.js';
+
+  let outputFile = options.output;
+  if (!outputFile) {
+    outputFile = `seed${defaultExt}`;
+  } else if (!path.extname(outputFile)) {
+    outputFile = `${outputFile}${defaultExt}`;
+  }
+
+  const schemaText = fs.readFileSync(file, 'utf-8');
+  const isPrisma = file.endsWith('.prisma');
+  
+  const parsedData = parseSchema(schemaText, isPrisma, targetTable);
+  
+  const mockData = [];
+  for (let i = 0; i < rowCount; i++) {
+    mockData.push(generateRow(parsedData.columns));
+  }
+  
+  const finalContent = formatData(parsedData.tableName, mockData, { format, dialect });
+  fs.writeFileSync(outputFile, finalContent);
+  
+  return {
+    tableName: parsedData.tableName,
+    rowCount,
+    outputFile,
+    content: finalContent
+  };
+}

package/src/parsers/index.js

@@ -0,0 +1,31 @@
+import { parseSqlSchema, getSqlTableNames } from './sqlParser.js';
+import { parsePrismaSchema, getPrismaModelNames } from './prismaParser.js';
+
+export { parseSqlSchema, parsePrismaSchema, getSqlTableNames, getPrismaModelNames };
+
+/**
+ * Gets all entity (table or model) names from a schema text.
+ * @param {string} text - Raw schema text.
+ * @param {boolean} isPrisma - True if Prisma schema.
+ * @returns {string[]} Array of table / model names.
+ */
+export function getSchemaTableNames(text, isPrisma) {
+  return isPrisma ? getPrismaModelNames(text) : getSqlTableNames(text);
+}
+
+/**
+ * Parses a database schema (SQL or Prisma) into a normalized representation.
+ * @param {string} text - The raw schema text.
+ * @param {boolean} isPrisma - True if the schema is a Prisma file, false for SQL.
+ * @param {string} [targetTable] - Optional table/model name to target.
+ * @returns {{ tableName: string, columns: Array<{ name: string, type: string, isAutoIncrement?: boolean }> }}
+ */
+export function parseSchema(text, isPrisma, targetTable) {
+  const parsed = isPrisma ? parsePrismaSchema(text, targetTable) : parseSqlSchema(text, targetTable);
+  // Omit auto-incrementing columns so the database handles primary key generation naturally
+  const filteredColumns = parsed.columns.filter(col => !col.isAutoIncrement);
+  return {
+    tableName: parsed.tableName,
+    columns: filteredColumns.length > 0 ? filteredColumns : parsed.columns
+  };
+}

package/src/parsers/prismaParser.js

@@ -0,0 +1,73 @@
+// --- HELPER TO STRIP PRISMA COMMENTS ---
+export function stripPrismaComments(text) {
+  let clean = text.replace(/\/\*[\s\S]*?\*\//g, '');
+  clean = clean.replace(/\/\/.*/g, '');
+  return clean;
+}
+
+// --- HELPER TO GET ALL MODEL NAMES FROM PRISMA SCHEMA ---
+export function getPrismaModelNames(text) {
+  const cleanText = stripPrismaComments(text);
+  const matches = cleanText.matchAll(/model\s+(\w+)\s*{/gi);
+  const names = [];
+  for (const match of matches) {
+    names.push(match[1]);
+  }
+  return names;
+}
+
+// --- PRISMA SCHEMA PARSER ---
+export function parsePrismaSchema(text, targetModel) {
+  const cleanText = stripPrismaComments(text);
+  const allModelNames = getPrismaModelNames(text);
+  
+  const enums = {};
+  const enumMatches = cleanText.matchAll(/enum\s+(\w+)\s*{([\s\S]+?)}/gi);
+  for (const match of enumMatches) {
+    const enumName = match[1];
+    const values = match[2]
+      .split('\n')
+      .map(v => v.trim())
+      .filter(v => v && !v.startsWith('//'));
+    enums[enumName] = values;
+  }
+
+  const modelMatches = [...cleanText.matchAll(/model\s+(\w+)\s*{([\s\S]+?)}/gi)];
+  if (modelMatches.length === 0) throw new Error("Could not find a valid Prisma model.");
+  
+  let selectedMatch = modelMatches[0];
+  if (targetModel) {
+    const targetLower = targetModel.toLowerCase().trim();
+    const found = modelMatches.find(m => m[1].toLowerCase() === targetLower);
+    if (found) {
+      selectedMatch = found;
+    } else {
+      throw new Error(`Prisma model '${targetModel}' not found in schema.`);
+    }
+  }
+
+  const tableName = selectedMatch[1];
+  const columns = selectedMatch[2].trim().split('\n').map(line => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@')) return null;
+    if (trimmed.includes('@relation')) return null;
+
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 2) return null;
+    
+    const name = parts[0];
+    const rawType = parts[1];
+    const cleanType = rawType.replace(/\?$/, '').replace(/\[\]$/, '');
+
+    // Skip implicit and explicit Prisma relation fields
+    if (allModelNames.includes(cleanType)) return null;
+
+    const isEnum = Boolean(enums[cleanType]);
+    const enumValues = enums[cleanType] || null;
+    const isAutoIncrement = trimmed.includes('@default(autoincrement())');
+    
+    return { name, type: rawType, fullLine: trimmed, isEnum, enumValues, isAutoIncrement };
+  }).filter(Boolean);
+  
+  return { tableName, columns };
+}

package/src/parsers/sqlParser.js

@@ -0,0 +1,129 @@
+// --- HELPER TO STRIP SQL COMMENTS ---
+export function stripSqlComments(text) {
+  let clean = text.replace(/\/\*[\s\S]*?\*\//g, '');
+  clean = clean.replace(/--.*$/gm, '');
+  return clean;
+}
+
+// --- HELPER TO GET ALL TABLE NAMES FROM SQL SCHEMA ---
+export function getSqlTableNames(text) {
+  const cleanText = stripSqlComments(text);
+  const matches = cleanText.matchAll(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:[`"]?[\w]+[`"]?\.)?[`"]?[\w]+[`"]?|\"[^\"]+\"|`[^`]+`)\s*\(/gi);
+  const names = [];
+  for (const match of matches) {
+    const rawName = match[1].replace(/[`"]/g, '');
+    names.push(rawName);
+  }
+  return names;
+}
+
+// --- SQL COLUMN PARSER ---
+export function parseSqlColumnLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  const match = trimmed.match(/^([`"]?[\w.]+\b[`"]?)\s+(.+)$/i);
+  if (!match) return null;
+
+  const rawName = match[1].replace(/[`"]/g, '');
+  const remainder = match[2];
+
+  const upperName = rawName.toUpperCase();
+  if (['PRIMARY', 'FOREIGN', 'CONSTRAINT', 'UNIQUE', 'INDEX', 'KEY', 'CHECK', 'FULLTEXT', 'SPATIAL'].includes(upperName)) {
+    return null;
+  }
+
+  const constraintKeywords = ['NOT', 'NULL', 'PRIMARY', 'DEFAULT', 'UNIQUE', 'REFERENCES', 'AUTO_INCREMENT', 'GENERATED', 'IDENTITY', 'CHECK', 'COMMENT'];
+
+  let typeStr = '';
+  let parenDepth = 0;
+  let i = 0;
+  while (i < remainder.length) {
+    const char = remainder[i];
+    if (char === '(') parenDepth++;
+    else if (char === ')') parenDepth--;
+
+    if (parenDepth === 0) {
+      const rest = remainder.slice(i).trim();
+      const nextWord = rest.split(/\s+/)[0].toUpperCase();
+      if (typeStr.trim().length > 0 && constraintKeywords.includes(nextWord)) {
+        break;
+      }
+    }
+    typeStr += char;
+    i++;
+  }
+
+  const lineLower = trimmed.toLowerCase();
+  const typeLower = typeStr.trim().toLowerCase();
+  const isAutoIncrement = 
+    lineLower.includes('auto_increment') || 
+    lineLower.includes('autoincrement') || 
+    lineLower.includes('identity') || 
+    lineLower.includes('nextval(') ||
+    lineLower.includes('generated') ||
+    typeLower === 'serial' || 
+    typeLower === 'bigserial' || 
+    typeLower === 'smallserial';
+
+  return { name: rawName, type: typeStr.trim(), isAutoIncrement };
+}
+
+// --- MAIN SQL SCHEMA PARSER ---
+export function parseSqlSchema(text, targetTable) {
+  const cleanText = stripSqlComments(text);
+  const tableMatches = [...cleanText.matchAll(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:[`"]?[\w]+[`"]?\.)?[`"]?[\w]+[`"]?|\"[^\"]+\"|`[^`]+`)\s*\(([\s\S]+?)\)(?:;|\s*$|\s*(?=CREATE))/gi)];
+  
+  if (tableMatches.length === 0) {
+    throw new Error("Could not find a valid CREATE TABLE statement.");
+  }
+
+  let selectedMatch = tableMatches[0];
+  if (targetTable) {
+    const targetLower = targetTable.toLowerCase().trim();
+    const found = tableMatches.find(m => m[1].replace(/[`"]/g, '').toLowerCase() === targetLower);
+    if (found) {
+      selectedMatch = found;
+    } else {
+      throw new Error(`Table '${targetTable}' not found in schema.`);
+    }
+  }
+
+  const tableName = selectedMatch[1].replace(/[`"]/g, '');
+  const body = selectedMatch[2];
+
+  const columnDefs = [];
+  let current = '';
+  let parenDepth = 0;
+  let inString = false;
+  let quoteChar = '';
+
+  for (let i = 0; i < body.length; i++) {
+    const char = body[i];
+
+    if ((char === "'" || char === '"' || char === '`') && (i === 0 || body[i - 1] !== '\\')) {
+      if (!inString) {
+        inString = true;
+        quoteChar = char;
+      } else if (quoteChar === char) {
+        inString = false;
+      }
+    }
+
+    if (!inString) {
+      if (char === '(') parenDepth++;
+      else if (char === ')') parenDepth--;
+    }
+
+    if (char === ',' && parenDepth === 0 && !inString) {
+      if (current.trim()) columnDefs.push(current.trim());
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) columnDefs.push(current.trim());
+
+  const columns = columnDefs.map(parseSqlColumnLine).filter(Boolean);
+  return { tableName, columns };
+}