planche 0.2.0 → 0.3.0

package/README.md

@@ -1,7 +1,7 @@
 # planche
 
 Local agent for [Planche](https://planche.dev), a browser-based SQL client for
-MySQL, MariaDB, PostgreSQL and SQLite.
+MySQL, MariaDB, PostgreSQL, SQLite, SQL Server and Oracle.
 
 Browsers cannot open TCP connections to a database, so Planche runs this small
 agent on your machine. The app in your browser talks to the agent over
@@ -90,7 +90,14 @@ database connections open and forwards queries with the matching driver
 - **SQLite** — opens a file on your disk by path. Set `PLANCHE_SQLITE_DIR` to
   limit which files can be opened. (Small SQLite files can also be opened
   directly in the browser without the agent.)
-- **SSH tunnel** — MySQL and PostgreSQL profiles can go through an SSH jump
+- **SQL Server** — same model as PostgreSQL: the connection is bound to one
+  database and the app's "database" is a schema (`dbo`, ...). `USE` works in
+  the editor because every statement runs on the same session; scripts may
+  contain `GO` lines.
+- **Oracle** — thin-mode driver, no Instant Client needed. Schemas (users) are
+  the app's "databases", switched with `ALTER SESSION SET CURRENT_SCHEMA`.
+  PL/SQL blocks end with a `/` line as in SQL*Plus.
+- **SSH tunnel** — MySQL, PostgreSQL, SQL Server and Oracle profiles can go through an SSH jump
   host (password, private key, or the local `ssh-agent`). The agent opens the
   tunnel with `ssh2` on a loopback port and points the driver at it. The host
   may be a `Host` alias from `~/.ssh/config`: `HostName`, `Port`, `User` and

package/dist/index.js

@@ -80,13 +80,13 @@ var MySqlDriver = class {
    * dropping temporary tables and user variables.
    */
   currentDatabase;
-  async query(sql, database) {
+  async query(sql2, database) {
     if (database && database !== this.currentDatabase) {
       await this.connection.query(`USE ${mysql.escapeId(database)}`);
       this.currentDatabase = database;
     }
-    const [results, fields] = await this.connection.query(sql);
-    if (USE_STATEMENT.test(sql)) this.currentDatabase = null;
+    const [results, fields] = await this.connection.query(sql2);
+    if (USE_STATEMENT.test(sql2)) this.currentDatabase = null;
     if (Array.isArray(results) && fields) {
       const fieldPackets = fields;
       const mappedFields = fieldPackets.map((field) => ({
@@ -269,13 +269,13 @@ var PostgresDriver = class {
     } catch {
     }
   }
-  async query(sql, database) {
+  async query(sql2, database) {
     if (database && database !== this.currentSchema) {
       await this.client.query(`SET search_path TO ${quoteIdent(database)}, public`);
       this.currentSchema = database;
     }
-    const result = await this.client.query({ text: sql, rowMode: "array" });
-    if (SEARCH_PATH_STATEMENT.test(sql)) this.currentSchema = null;
+    const result = await this.client.query({ text: sql2, rowMode: "array" });
+    if (SEARCH_PATH_STATEMENT.test(sql2)) this.currentSchema = null;
     const results = Array.isArray(result) ? result : [result];
     const last = [...results].reverse().find((r) => r.fields.length > 0) ?? results[results.length - 1];
     if (last.fields.length > 0) {
@@ -385,13 +385,13 @@ var SqliteDriver = class {
   db;
   type = "sqlite";
   label;
-  async query(sql) {
+  async query(sql2) {
     let statement;
     try {
-      statement = this.db.prepare(sql);
+      statement = this.db.prepare(sql2);
     } catch (err) {
       if (err instanceof RangeError && /more than one statement/i.test(err.message)) {
-        this.db.exec(sql);
+        this.db.exec(sql2);
         return { fields: [], records: [], affectedRows: 0, insertId: 0, isResultQuery: false };
       }
       throw err;
@@ -466,6 +466,291 @@ var sqliteDriverFactory = {
   }
 };
 
+// src/drivers/mssql.ts
+import sql from "mssql";
+function toPoolConfig(config) {
+  return {
+    server: config.host,
+    port: config.port,
+    user: config.user,
+    password: config.password,
+    database: config.database,
+    // One physical connection: manual transactions and USE need session affinity.
+    pool: { min: 1, max: 1, idleTimeoutMillis: 24 * 60 * 60 * 1e3 },
+    options: {
+      encrypt: config.ssl === true,
+      trustServerCertificate: true,
+      // Keep date/time values as sent by the server rather than shifting to UTC.
+      useUTC: false,
+      enableArithAbort: true
+    },
+    requestTimeout: 0
+  };
+}
+var pad = (n, width = 2) => String(n).padStart(width, "0");
+function formatDate(d) {
+  const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+  const ms = d.getMilliseconds();
+  return `${date} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}${ms ? "." + pad(ms, 3) : ""}`;
+}
+function normalizeValue(value) {
+  if (value instanceof Date) return formatDate(value);
+  if (Buffer.isBuffer(value)) return value.toString("hex");
+  return value;
+}
+var RESULT_QUERY = /^\s*(?:WITH|SELECT|\()/i;
+var MssqlDriver = class {
+  constructor(pool, config) {
+    this.pool = pool;
+    this.label = `${config.user}@${config.host}:${config.port}/${config.database}`;
+  }
+  pool;
+  type = "mssql";
+  label;
+  /** Source columns per SQL text; `sys.dm_exec_describe_first_result_set` is not free. */
+  sources = /* @__PURE__ */ new Map();
+  /**
+   * The `mssql` driver does not report which table a result column comes
+   * from; ask the server to describe the statement instead so the grid can
+   * decide whether it is editable and address rows by primary key.
+   */
+  async describe(text) {
+    const cached = this.sources.get(text);
+    if (cached !== void 0) return cached;
+    let result = null;
+    try {
+      const req = this.pool.request();
+      req.input("sql", sql.NVarChar(sql.MAX), text);
+      const res = await req.query(
+        "SELECT name, source_schema, source_table, source_column, system_type_name FROM sys.dm_exec_describe_first_result_set(@sql, NULL, 1) WHERE is_hidden = 0 ORDER BY column_ordinal"
+      );
+      result = res.recordset.map((r) => ({
+        schema: r.source_schema ?? "",
+        table: r.source_table ?? "",
+        column: r.source_column ?? "",
+        type: (r.system_type_name ?? "").toLowerCase()
+      }));
+    } catch {
+      result = null;
+    }
+    if (this.sources.size > 200) this.sources.clear();
+    this.sources.set(text, result);
+    return result;
+  }
+  async query(text) {
+    const req = this.pool.request();
+    req.arrayRowMode = true;
+    const res = await req.query(text);
+    const sets = res.recordsets;
+    const last = sets.length > 0 ? sets[sets.length - 1] : void 0;
+    const columns = last?.columns;
+    if (last && columns) {
+      const meta = Object.values(columns).sort((a, b) => a.index - b.index);
+      const sources = RESULT_QUERY.test(text) ? await this.describe(text) : null;
+      const fields = meta.map((col, i) => {
+        const src = sources && sources.length === meta.length ? sources[i] : void 0;
+        const typeName = col.type?.declaration ?? "";
+        return {
+          name: col.name,
+          orgName: src?.column || col.name,
+          type: src?.type || typeName.toLowerCase(),
+          table: src?.table ?? "",
+          orgTable: src?.table ?? "",
+          db: src?.schema ?? "",
+          maxLength: typeof col.length === "number" ? col.length : 0
+        };
+      });
+      const records = last.map((row) => row.map(normalizeValue));
+      return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+    }
+    return {
+      fields: [],
+      records: [],
+      affectedRows: res.rowsAffected.reduce((sum, n) => sum + n, 0),
+      insertId: 0,
+      isResultQuery: false
+    };
+  }
+  async close() {
+    await this.pool.close();
+  }
+};
+var mssqlDriverFactory = {
+  async open(config) {
+    const pool = new sql.ConnectionPool(toPoolConfig(config));
+    await pool.connect();
+    return new MssqlDriver(pool, config);
+  },
+  async test(config) {
+    const pool = new sql.ConnectionPool(toPoolConfig(config));
+    await pool.connect();
+    await pool.close();
+  },
+  parseConfig(body) {
+    const host = typeof body.host === "string" ? body.host.trim() : "";
+    const user = typeof body.user === "string" ? body.user : "";
+    if (!host || !user) {
+      throw new Error("host and user are required");
+    }
+    return {
+      driver: "mssql",
+      host,
+      port: Number(body.port) || 1433,
+      user,
+      password: typeof body.password === "string" ? body.password : "",
+      database: typeof body.database === "string" && body.database ? body.database : "master",
+      ssl: body.ssl === true
+    };
+  }
+};
+
+// src/drivers/oracle.ts
+import oracledb from "oracledb";
+oracledb.autoCommit = true;
+oracledb.fetchAsString = [oracledb.CLOB];
+var fetchTypeHandler = (meta) => meta.dbType === oracledb.DB_TYPE_NUMBER ? { type: oracledb.STRING } : void 0;
+var pad2 = (n, width = 2) => String(n).padStart(width, "0");
+function formatDate2(d) {
+  const ms = d.getMilliseconds();
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}${ms ? "." + pad2(ms, 3) : ""}`;
+}
+function normalizeValue2(value) {
+  if (value instanceof Date) return formatDate2(value);
+  if (Buffer.isBuffer(value)) return value.toString("hex");
+  return value;
+}
+var SESSION_FORMATS = [
+  "ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'",
+  "ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF3'",
+  "ALTER SESSION SET NLS_TIMESTAMP_TZ_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF3 TZH:TZM'"
+];
+var quoteIdent2 = (name) => `"${name.replaceAll('"', '""')}"`;
+var PLSQL = /^\s*(BEGIN|DECLARE|CREATE\s+(OR\s+REPLACE\s+)?((NON)?EDITIONABLE\s+)?(PROCEDURE|FUNCTION|TRIGGER|PACKAGE|TYPE)\b)/i;
+function normalizeStatement(sql2) {
+  const trimmed = sql2.trim().replace(/\n\/\s*$/, "");
+  if (PLSQL.test(trimmed)) return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+  return trimmed.replace(/;\s*$/, "");
+}
+var SET_SCHEMA = /^\s*ALTER\s+SESSION\s+SET\s+CURRENT_SCHEMA\b/i;
+var START_TX = /^\s*SET\s+TRANSACTION\b/i;
+var END_TX = /^\s*(COMMIT|ROLLBACK)\b/i;
+function singleSourceTable(sql2) {
+  const m = /\bFROM\s+("?[\w$#]+"?)(?:\s*\.\s*("?[\w$#]+"?))?([\s\S]*)$/i.exec(sql2);
+  if (!m) return null;
+  const rest = m[3].replace(/\b(WHERE|ORDER\s+BY|GROUP\s+BY|HAVING|FETCH|OFFSET|UNION|MINUS|INTERSECT|FOR\s+UPDATE)\b[\s\S]*$/i, "");
+  if (/,|\bJOIN\b|\(/i.test(rest) || rest.trim().split(/\s+/).filter(Boolean).length > 2) return null;
+  const unquote = (v) => v.startsWith('"') ? v.slice(1, -1).replaceAll('""', '"') : v.toUpperCase();
+  return m[2] ? { schema: unquote(m[1]), table: unquote(m[2]) } : { table: unquote(m[1]) };
+}
+var OracleDriver = class {
+  constructor(conn, config) {
+    this.conn = conn;
+    this.label = `${config.user}@${config.host}:${config.port}/${config.serviceName}`;
+    this.currentSchema = config.user.toUpperCase();
+  }
+  conn;
+  type = "oracle";
+  label;
+  currentSchema;
+  manualTx = false;
+  /** Column names per `OWNER.TABLE`, for result-source resolution. */
+  columns = /* @__PURE__ */ new Map();
+  async init() {
+    for (const stmt of SESSION_FORMATS) await this.conn.execute(stmt);
+  }
+  async tableColumns(schema, table) {
+    const key = `${schema}.${table}`;
+    const cached = this.columns.get(key);
+    if (cached !== void 0) return cached;
+    let out = null;
+    try {
+      const res = await this.conn.execute(
+        "SELECT column_name FROM all_tab_columns WHERE owner = :o AND table_name = :t",
+        { o: schema, t: table },
+        { outFormat: oracledb.OUT_FORMAT_ARRAY }
+      );
+      out = res.rows && res.rows.length > 0 ? new Set(res.rows.map((r) => r[0])) : null;
+    } catch {
+      out = null;
+    }
+    if (this.columns.size > 200) this.columns.clear();
+    this.columns.set(key, out);
+    return out;
+  }
+  async query(sql2, database) {
+    if (database && database !== this.currentSchema) {
+      await this.conn.execute(`ALTER SESSION SET CURRENT_SCHEMA = ${quoteIdent2(database)}`);
+      this.currentSchema = database;
+    }
+    const text = normalizeStatement(sql2);
+    if (START_TX.test(text)) this.manualTx = true;
+    const res = await this.conn.execute(text, [], {
+      outFormat: oracledb.OUT_FORMAT_ARRAY,
+      fetchTypeHandler,
+      autoCommit: !this.manualTx
+    });
+    if (SET_SCHEMA.test(text)) this.currentSchema = null;
+    if (END_TX.test(text)) this.manualTx = false;
+    if (res.metaData && res.metaData.length > 0) {
+      const source = singleSourceTable(text);
+      const schema = source?.schema ?? this.currentSchema ?? "";
+      const known = source && schema ? await this.tableColumns(schema, source.table) : null;
+      const fields = res.metaData.map((col) => {
+        const fromTable = known?.has(col.name) ?? false;
+        return {
+          name: col.name,
+          orgName: col.name,
+          type: (col.dbTypeName ?? "").toLowerCase(),
+          table: fromTable ? source.table : "",
+          orgTable: fromTable ? source.table : "",
+          db: fromTable ? schema : "",
+          maxLength: col.byteSize ?? 0
+        };
+      });
+      const records = (res.rows ?? []).map((row) => row.map(normalizeValue2));
+      return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+    }
+    return { fields: [], records: [], affectedRows: res.rowsAffected ?? 0, insertId: 0, isResultQuery: false };
+  }
+  async close() {
+    await this.conn.close();
+  }
+};
+function connectionAttributes(config) {
+  return {
+    user: config.user,
+    password: config.password,
+    connectString: `${config.host}:${config.port}/${config.serviceName}`
+  };
+}
+var oracleDriverFactory = {
+  async open(config) {
+    const conn = await oracledb.getConnection(connectionAttributes(config));
+    const driver = new OracleDriver(conn, config);
+    await driver.init();
+    return driver;
+  },
+  async test(config) {
+    const conn = await oracledb.getConnection(connectionAttributes(config));
+    await conn.close();
+  },
+  parseConfig(body) {
+    const host = typeof body.host === "string" ? body.host.trim() : "";
+    const user = typeof body.user === "string" ? body.user : "";
+    if (!host || !user) {
+      throw new Error("host and user are required");
+    }
+    return {
+      driver: "oracle",
+      host,
+      port: Number(body.port) || 1521,
+      user,
+      password: typeof body.password === "string" ? body.password : "",
+      serviceName: typeof body.serviceName === "string" && body.serviceName ? body.serviceName : "FREEPDB1"
+    };
+  }
+};
+
 // src/ssh-tunnel.ts
 import { createServer } from "net";
 import { mkdir, readFile as readFile2, appendFile } from "fs/promises";
@@ -811,7 +1096,9 @@ async function openSshTunnel(requested, target) {
 var factories = {
   mysql: mysqlDriverFactory,
   postgres: postgresDriverFactory,
-  sqlite: sqliteDriverFactory
+  sqlite: sqliteDriverFactory,
+  mssql: mssqlDriverFactory,
+  oracle: oracleDriverFactory
 };
 function isDriverType(value) {
   return typeof value === "string" && value in factories;
@@ -840,7 +1127,7 @@ function tunneled(driver, tunnel, label) {
   return {
     type: driver.type,
     label,
-    query: (sql, database) => driver.query(sql, database),
+    query: (sql2, database) => driver.query(sql2, database),
     async close() {
       try {
         await driver.close();
@@ -875,6 +1162,10 @@ function openDirect(config) {
       return factories.postgres.open(config);
     case "sqlite":
       return factories.sqlite.open(config);
+    case "mssql":
+      return factories.mssql.open(config);
+    case "oracle":
+      return factories.oracle.open(config);
   }
 }
 function testDirect(config) {
@@ -885,6 +1176,10 @@ function testDirect(config) {
       return factories.postgres.test(config);
     case "sqlite":
       return factories.sqlite.test(config);
+    case "mssql":
+      return factories.mssql.test(config);
+    case "oracle":
+      return factories.oracle.test(config);
   }
 }
 
@@ -925,13 +1220,13 @@ var ConnectionManager = class {
    * Execute a SQL query on an existing connection.
    * Optionally switch database before executing (drivers that support it).
    */
-  async query(connectionId, sql, database) {
+  async query(connectionId, sql2, database) {
     const driver = this.connections.get(connectionId);
     if (!driver) {
       throw new Error(`Connection not found: ${connectionId}`);
     }
     this.lastUsed.set(connectionId, Date.now());
-    return driver.query(sql, database);
+    return driver.query(sql2, database);
   }
   /**
    * Close and remove a connection.
@@ -1073,8 +1368,8 @@ function createAgent(options) {
   });
   app.post("/query", async (req, res) => {
     try {
-      const { connectionId, sql, database } = req.body;
-      if (typeof connectionId !== "string" || typeof sql !== "string" || !connectionId || !sql) {
+      const { connectionId, sql: sql2, database } = req.body;
+      if (typeof connectionId !== "string" || typeof sql2 !== "string" || !connectionId || !sql2) {
         fail(res, 400, "connectionId and sql are required");
         return;
       }
@@ -1083,7 +1378,7 @@ function createAgent(options) {
         return;
       }
       const start = Date.now();
-      const result = await manager.query(connectionId, sql, database);
+      const result = await manager.query(connectionId, sql2, database);
       const execTime = Date.now() - start;
       res.json({
         success: true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "planche",
-  "version": "0.2.0",
-  "description": "Local agent for Planche — lets the browser-based Planche SQL client reach MySQL/MariaDB/PostgreSQL/SQLite databases from your machine.",
+  "version": "0.3.0",
+  "description": "Local agent for Planche — lets the browser-based Planche SQL client reach MySQL/MariaDB/PostgreSQL/SQLite/SQL Server/Oracle databases from your machine.",
   "license": "MIT",
   "homepage": "https://planche.dev",
   "repository": {
@@ -28,6 +28,9 @@
     "postgres",
     "postgresql",
     "sqlite",
+    "mssql",
+    "sqlserver",
+    "oracle",
     "sql",
     "client",
     "gui"
@@ -42,14 +45,18 @@
   "dependencies": {
     "better-sqlite3": "^12.11.1",
     "express": "^5.1.0",
+    "mssql": "^12.7.0",
     "mysql2": "^3.14.1",
+    "oracledb": "^7.0.1",
     "pg": "^8.23.0",
     "ssh2": "^1.17.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^9.6.0",
     "@types/express": "^5.0.0",
+    "@types/mssql": "^12.3.0",
     "@types/node": "^24.0.0",
+    "@types/oracledb": "^7.0.2",
     "@types/pg": "^8.23.1",
     "@types/ssh2": "^1.15.5",
     "tsup": "^8.5.0",