schemalens 0.0.2 → 0.0.4

package/README.md

@@ -2,7 +2,7 @@
 
 A local-first developer tool that generates living architecture diagrams from your database schema. Point it at a database, and SchemaLens visualizes tables, columns, and foreign-key relationships on an interactive canvas.
 
-Supports **PostgreSQL** and **SQLite**.
+Supports **PostgreSQL**, **MySQL**, **SQL Server**, **Oracle**, and **SQLite**.
 
 ## Features
 

package/dist/index.js

@@ -40378,9 +40378,37 @@ var postgresConfigSchema = external_exports.object({
   password: external_exports.string(),
   ssl: external_exports.boolean().optional()
 });
+var mysqlConfigSchema = external_exports.object({
+  dialect: external_exports.literal("mysql"),
+  host: external_exports.string(),
+  port: external_exports.number(),
+  database: external_exports.string(),
+  user: external_exports.string(),
+  password: external_exports.string()
+});
+var mssqlConfigSchema = external_exports.object({
+  dialect: external_exports.literal("mssql"),
+  host: external_exports.string(),
+  port: external_exports.number(),
+  database: external_exports.string(),
+  user: external_exports.string(),
+  password: external_exports.string(),
+  trustServerCertificate: external_exports.boolean().optional()
+});
+var oracleConfigSchema = external_exports.object({
+  dialect: external_exports.literal("oracle"),
+  host: external_exports.string(),
+  port: external_exports.number(),
+  serviceName: external_exports.string(),
+  user: external_exports.string(),
+  password: external_exports.string()
+});
 var connectionConfigSchema = external_exports.discriminatedUnion("dialect", [
   sqliteConfigSchema,
-  postgresConfigSchema
+  postgresConfigSchema,
+  mysqlConfigSchema,
+  mssqlConfigSchema,
+  oracleConfigSchema
 ]);
 var connectionIdSchema = external_exports.object({
   connectionId: external_exports.string().uuid()
@@ -40393,7 +40421,7 @@ var saveWorkspaceSchema = external_exports.object({
   id: external_exports.string().uuid().optional(),
   name: external_exports.string().min(1),
   databaseLabel: external_exports.string(),
-  dialect: external_exports.enum(["sqlite", "postgres"]),
+  dialect: external_exports.enum(["sqlite", "postgres", "mysql", "mssql", "oracle"]),
   startTable: external_exports.string(),
   startSchema: external_exports.string().nullable(),
   depth: external_exports.number().int().positive(),
@@ -40539,37 +40567,287 @@ var PostgresDialect = class {
   }
 };
 
+// ../core/dist/introspection/dialects/mysql.js
+var MysqlDialect = class {
+  async listTables(knex2) {
+    const [rows] = await knex2.raw(`SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.tables
+       WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'
+       ORDER BY TABLE_NAME`);
+    return rows.map((r) => ({ name: r.TABLE_NAME, schema: r.TABLE_SCHEMA }));
+  }
+  async getTable(knex2, name, schema = null) {
+    const s = schema ?? await this.currentDatabase(knex2);
+    const columns = await this.getColumns(knex2, name, s);
+    const foreignKeys = await this.getForeignKeys(knex2, name, s);
+    return { name, schema: s, columns, foreignKeys };
+  }
+  async currentDatabase(knex2) {
+    const [[row]] = await knex2.raw("SELECT DATABASE() AS db");
+    return row.db;
+  }
+  async getColumns(knex2, table, schema) {
+    const [rows] = await knex2.raw(`SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, ORDINAL_POSITION, COLUMN_KEY
+       FROM information_schema.columns
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+       ORDER BY ORDINAL_POSITION`, [schema, table]);
+    return rows.map((r) => ({
+      name: r.COLUMN_NAME,
+      dataType: r.DATA_TYPE,
+      nullable: r.IS_NULLABLE === "YES",
+      isPrimaryKey: r.COLUMN_KEY === "PRI",
+      defaultValue: r.COLUMN_DEFAULT,
+      ordinalPosition: r.ORDINAL_POSITION - 1
+    }));
+  }
+  async getForeignKeys(knex2, table, schema) {
+    const [rows] = await knex2.raw(`SELECT kcu.CONSTRAINT_NAME, kcu.COLUMN_NAME,
+              kcu.REFERENCED_TABLE_NAME, kcu.REFERENCED_TABLE_SCHEMA, kcu.REFERENCED_COLUMN_NAME
+       FROM information_schema.key_column_usage kcu
+       JOIN information_schema.referential_constraints rc
+         ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+         AND kcu.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA
+       WHERE kcu.TABLE_SCHEMA = ? AND kcu.TABLE_NAME = ?
+         AND kcu.REFERENCED_TABLE_NAME IS NOT NULL`, [schema, table]);
+    return rows.map((r) => ({
+      constraintName: r.CONSTRAINT_NAME,
+      columnName: r.COLUMN_NAME,
+      referencedTable: r.REFERENCED_TABLE_NAME,
+      referencedSchema: r.REFERENCED_TABLE_SCHEMA,
+      referencedColumn: r.REFERENCED_COLUMN_NAME
+    }));
+  }
+};
+
+// ../core/dist/introspection/dialects/mssql.js
+var MssqlDialect = class {
+  async listTables(knex2) {
+    const result = await knex2.raw(`SELECT TABLE_SCHEMA AS table_schema, TABLE_NAME AS table_name
+       FROM INFORMATION_SCHEMA.TABLES
+       WHERE TABLE_TYPE = 'BASE TABLE'
+         AND TABLE_SCHEMA NOT IN ('sys', 'INFORMATION_SCHEMA')
+       ORDER BY TABLE_SCHEMA, TABLE_NAME`);
+    return result.map((r) => ({
+      name: r.table_name,
+      schema: r.table_schema
+    }));
+  }
+  async getTable(knex2, name, schema = "dbo") {
+    const s = schema ?? "dbo";
+    const columns = await this.getColumns(knex2, name, s);
+    const foreignKeys = await this.getForeignKeys(knex2, name, s);
+    return { name, schema: s, columns, foreignKeys };
+  }
+  async getColumns(knex2, table, schema) {
+    const rows = await knex2.raw(`SELECT c.COLUMN_NAME AS column_name,
+              c.DATA_TYPE AS data_type,
+              c.IS_NULLABLE AS is_nullable,
+              c.COLUMN_DEFAULT AS column_default,
+              c.ORDINAL_POSITION AS ordinal_position,
+              CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS is_pk
+       FROM INFORMATION_SCHEMA.COLUMNS c
+       LEFT JOIN (
+         SELECT kcu.COLUMN_NAME, kcu.TABLE_NAME, kcu.TABLE_SCHEMA
+         FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+         JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+           ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+           AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA
+         WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+       ) pk ON pk.COLUMN_NAME = c.COLUMN_NAME
+           AND pk.TABLE_NAME = c.TABLE_NAME
+           AND pk.TABLE_SCHEMA = c.TABLE_SCHEMA
+       WHERE c.TABLE_SCHEMA = @p0 AND c.TABLE_NAME = @p1
+       ORDER BY c.ORDINAL_POSITION`, [schema, table]);
+    return rows.map((r) => ({
+      name: r.column_name,
+      dataType: r.data_type,
+      nullable: r.is_nullable === "YES",
+      isPrimaryKey: r.is_pk === 1,
+      defaultValue: r.column_default,
+      ordinalPosition: r.ordinal_position - 1
+    }));
+  }
+  async getForeignKeys(knex2, table, schema) {
+    const rows = await knex2.raw(`SELECT
+         fk.CONSTRAINT_NAME AS constraint_name,
+         cu.COLUMN_NAME AS column_name,
+         pk.TABLE_NAME AS referenced_table,
+         pk.TABLE_SCHEMA AS referenced_schema,
+         pt.COLUMN_NAME AS referenced_column
+       FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS fk
+       JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE cu
+         ON fk.CONSTRAINT_NAME = cu.CONSTRAINT_NAME
+         AND fk.CONSTRAINT_SCHEMA = cu.TABLE_SCHEMA
+       JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS pkc
+         ON fk.UNIQUE_CONSTRAINT_NAME = pkc.CONSTRAINT_NAME
+         AND fk.UNIQUE_CONSTRAINT_SCHEMA = pkc.TABLE_SCHEMA
+       JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE pt
+         ON pkc.CONSTRAINT_NAME = pt.CONSTRAINT_NAME
+         AND pkc.TABLE_SCHEMA = pt.TABLE_SCHEMA
+         AND cu.ORDINAL_POSITION = pt.ORDINAL_POSITION
+       CROSS APPLY (
+         SELECT pkc.TABLE_NAME, pkc.TABLE_SCHEMA
+       ) pk
+       WHERE cu.TABLE_SCHEMA = @p0 AND cu.TABLE_NAME = @p1`, [schema, table]);
+    return rows.map((r) => ({
+      constraintName: r.constraint_name,
+      columnName: r.column_name,
+      referencedTable: r.referenced_table,
+      referencedSchema: r.referenced_schema,
+      referencedColumn: r.referenced_column
+    }));
+  }
+};
+
+// ../core/dist/introspection/dialects/oracle.js
+var OracleDialect = class {
+  async listTables(knex2) {
+    const rows = await knex2.raw(`SELECT OWNER, TABLE_NAME FROM ALL_TABLES
+       WHERE OWNER NOT IN ('SYS','SYSTEM','OUTLN','DIP','ORACLE_OCM','DBSNMP','APPQOSSYS','WMSYS','XDB','CTXSYS','MDSYS','OLAPSYS','ORDDATA','ORDSYS','LBACSYS','DVSYS','AUDSYS','GSMADMIN_INTERNAL')
+       ORDER BY OWNER, TABLE_NAME`);
+    return rows.map((r) => ({
+      name: r.table_name,
+      schema: r.owner
+    }));
+  }
+  async getTable(knex2, name, schema = null) {
+    const s = schema ?? await this.currentSchema(knex2);
+    const columns = await this.getColumns(knex2, name, s);
+    const foreignKeys = await this.getForeignKeys(knex2, name, s);
+    return { name, schema: s, columns, foreignKeys };
+  }
+  async currentSchema(knex2) {
+    const rows = await knex2.raw("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') AS current_schema FROM DUAL");
+    return rows[0].current_schema;
+  }
+  async getColumns(knex2, table, schema) {
+    const rows = await knex2.raw(`SELECT c.COLUMN_NAME AS column_name,
+              c.DATA_TYPE AS data_type,
+              c.NULLABLE AS nullable,
+              c.DATA_DEFAULT AS data_default,
+              c.COLUMN_ID AS column_id,
+              CASE WHEN pc.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS is_pk
+       FROM ALL_TAB_COLUMNS c
+       LEFT JOIN (
+         SELECT cc.COLUMN_NAME, cc.TABLE_NAME, cc.OWNER
+         FROM ALL_CONSTRAINTS con
+         JOIN ALL_CONS_COLUMNS cc
+           ON con.CONSTRAINT_NAME = cc.CONSTRAINT_NAME AND con.OWNER = cc.OWNER
+         WHERE con.CONSTRAINT_TYPE = 'P'
+       ) pc ON pc.COLUMN_NAME = c.COLUMN_NAME
+           AND pc.TABLE_NAME = c.TABLE_NAME
+           AND pc.OWNER = c.OWNER
+       WHERE c.OWNER = :schema AND c.TABLE_NAME = :table
+       ORDER BY c.COLUMN_ID`, { schema, table });
+    return rows.map((r) => ({
+      name: r.column_name,
+      dataType: r.data_type,
+      nullable: r.nullable === "Y",
+      isPrimaryKey: r.is_pk === 1,
+      defaultValue: r.data_default?.trim() ?? null,
+      ordinalPosition: r.column_id - 1
+    }));
+  }
+  async getForeignKeys(knex2, table, schema) {
+    const rows = await knex2.raw(`SELECT
+         c.CONSTRAINT_NAME AS constraint_name,
+         cc.COLUMN_NAME AS column_name,
+         rc.TABLE_NAME AS referenced_table,
+         rc.OWNER AS referenced_schema,
+         rc.COLUMN_NAME AS referenced_column
+       FROM ALL_CONSTRAINTS c
+       JOIN ALL_CONS_COLUMNS cc
+         ON c.CONSTRAINT_NAME = cc.CONSTRAINT_NAME AND c.OWNER = cc.OWNER
+       JOIN ALL_CONS_COLUMNS rc
+         ON c.R_CONSTRAINT_NAME = rc.CONSTRAINT_NAME AND c.R_OWNER = rc.OWNER
+         AND cc.POSITION = rc.POSITION
+       WHERE c.CONSTRAINT_TYPE = 'R'
+         AND c.OWNER = :schema AND c.TABLE_NAME = :table`, { schema, table });
+    return rows.map((r) => ({
+      constraintName: r.constraint_name,
+      columnName: r.column_name,
+      referencedTable: r.referenced_table,
+      referencedSchema: r.referenced_schema,
+      referencedColumn: r.referenced_column
+    }));
+  }
+};
+
 // ../core/dist/introspection/introspector.js
 var SchemaIntrospector = class {
   knex;
   dialect;
   constructor(config2) {
-    if (config2.dialect === "sqlite") {
-      this.knex = knex({
-        client: "better-sqlite3",
-        connection: { filename: config2.filePath },
-        useNullAsDefault: true,
-        pool: {
-          afterCreate(conn, done) {
-            conn.pragma("foreign_keys = ON");
-            done(null, conn);
+    switch (config2.dialect) {
+      case "sqlite":
+        this.knex = knex({
+          client: "better-sqlite3",
+          connection: { filename: config2.filePath },
+          useNullAsDefault: true,
+          pool: {
+            afterCreate(conn, done) {
+              conn.pragma("foreign_keys = ON");
+              done(null, conn);
+            }
           }
-        }
-      });
-      this.dialect = new SqliteDialect();
-    } else {
-      this.knex = knex({
-        client: "pg",
-        connection: {
-          host: config2.host,
-          port: config2.port,
-          database: config2.database,
-          user: config2.user,
-          password: config2.password,
-          ssl: config2.ssl ? { rejectUnauthorized: false } : false
-        }
-      });
-      this.dialect = new PostgresDialect();
+        });
+        this.dialect = new SqliteDialect();
+        break;
+      case "postgres":
+        this.knex = knex({
+          client: "pg",
+          connection: {
+            host: config2.host,
+            port: config2.port,
+            database: config2.database,
+            user: config2.user,
+            password: config2.password,
+            ssl: config2.ssl ? { rejectUnauthorized: false } : false
+          }
+        });
+        this.dialect = new PostgresDialect();
+        break;
+      case "mysql":
+        this.knex = knex({
+          client: "mysql2",
+          connection: {
+            host: config2.host,
+            port: config2.port,
+            database: config2.database,
+            user: config2.user,
+            password: config2.password
+          }
+        });
+        this.dialect = new MysqlDialect();
+        break;
+      case "mssql":
+        this.knex = knex({
+          client: "mssql",
+          connection: {
+            server: config2.host,
+            port: config2.port,
+            database: config2.database,
+            user: config2.user,
+            password: config2.password,
+            options: {
+              trustServerCertificate: config2.trustServerCertificate ?? false
+            }
+          }
+        });
+        this.dialect = new MssqlDialect();
+        break;
+      case "oracle":
+        this.knex = knex({
+          client: "oracledb",
+          connection: {
+            host: config2.host,
+            port: config2.port,
+            user: config2.user,
+            password: config2.password,
+            connectString: `${config2.host}:${config2.port}/${config2.serviceName}`
+          }
+        });
+        this.dialect = new OracleDialect();
+        break;
     }
   }
   async listTables() {
@@ -40680,7 +40958,7 @@ var connectionStore = {
   list() {
     return Array.from(connections.entries()).map(([connectionId, stored]) => {
       const { config: config2, createdAt } = stored;
-      const displayConfig = config2.dialect === "sqlite" ? { dialect: config2.dialect, filePath: config2.filePath } : { dialect: config2.dialect, host: config2.host, port: config2.port, database: config2.database, user: config2.user, ssl: config2.ssl };
+      const displayConfig = config2.dialect === "sqlite" ? { dialect: config2.dialect, filePath: config2.filePath } : config2.dialect === "oracle" ? { dialect: config2.dialect, host: config2.host, port: config2.port, serviceName: config2.serviceName, user: config2.user } : { dialect: config2.dialect, host: config2.host, port: config2.port, database: config2.database, user: config2.user };
       return { connectionId, dialect: config2.dialect, createdAt, displayConfig };
     });
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schemalens",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "bin": {
     "schemalens": "dist/index.js"
@@ -18,11 +18,14 @@
   "dependencies": {
     "better-sqlite3": "^11.0.0",
     "knex": "^3.1.0",
-    "pg": "^8.13.0"
+    "mysql2": "^3.16.2",
+    "oracledb": "^6.10.0",
+    "pg": "^8.13.0",
+    "tedious": "^19.2.0"
   },
   "devDependencies": {
     "@schemalens/server": "*",
-    "open": "^10.1.0",
-    "esbuild": "^0.24.0"
+    "esbuild": "^0.24.0",
+    "open": "^10.1.0"
   }
 }