planche 0.3.0 → 0.4.1

package/README.md

@@ -1,7 +1,8 @@
 # planche
 
 Local agent for [Planche](https://planche.dev), a browser-based SQL client for
-MySQL, MariaDB, PostgreSQL, SQLite, SQL Server and Oracle.
+MySQL, MariaDB, PostgreSQL, SQLite, SQL Server, Oracle, Neon, Supabase and
+Cloudflare D1.
 
 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
@@ -141,4 +142,4 @@ database connections open and forwards queries with the matching driver
 
 ## License
 
-MIT
+All rights reserved. Not yet released under an open-source license.

package/dist/index.js

@@ -209,7 +209,7 @@ function toClientConfig(config) {
     user: config.user,
     password: config.password,
     database: config.database,
-    ssl: config.ssl ? { rejectUnauthorized: false } : void 0,
+    ssl: config.ssl ? { rejectUnauthorized: config.sslVerify === true } : void 0,
     types
   };
 }
@@ -332,7 +332,8 @@ var postgresDriverFactory = {
       user,
       password: typeof body.password === "string" ? body.password : "",
       database: typeof body.database === "string" && body.database ? body.database : "postgres",
-      ssl: body.ssl === true
+      ssl: body.ssl === true,
+      sslVerify: body.sslVerify === true
     };
   }
 };
@@ -751,6 +752,175 @@ var oracleDriverFactory = {
   }
 };
 
+// src/drivers/d1.ts
+var API = "https://api.cloudflare.com/client/v4";
+var D1Error = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var SCHEMA_PRAGMA = /^\s*PRAGMA\s+(?:"main"|main|'main'|\[main\])\s*\.\s*/i;
+var DATABASE_LIST = /^\s*PRAGMA\s+database_list\s*;?\s*$/i;
+var RESULT_KIND = /^\s*(SELECT|WITH|PRAGMA|EXPLAIN|VALUES)\b/i;
+function singleSourceTable2(sql2) {
+  const m = /\bFROM\s+(?:"?main"?\s*\.\s*)?("[^"]+"|`[^`]+`|\[[^\]]+\]|[\w$]+)([\s\S]*)$/i.exec(sql2);
+  if (!m) return null;
+  const rest = m[2].replace(/\b(WHERE|ORDER\s+BY|GROUP\s+BY|HAVING|LIMIT|OFFSET|UNION|EXCEPT|INTERSECT|WINDOW)\b[\s\S]*$/i, "");
+  if (/,|\bJOIN\b|\(/i.test(rest) || rest.trim().split(/\s+/).filter(Boolean).length > 2) return null;
+  const raw = m[1];
+  const first = raw[0];
+  if (first === '"') return raw.slice(1, -1).replaceAll('""', '"');
+  if (first === "`") return raw.slice(1, -1).replaceAll("``", "`");
+  if (first === "[") return raw.slice(1, -1);
+  return raw;
+}
+function normalizeDeclaredType2(declared) {
+  if (typeof declared !== "string") return null;
+  const base = declared.trim().toLowerCase().replace(/\(.*$/, "").trim();
+  return base || null;
+}
+function inferTypeFromValue2(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "real";
+  if (Array.isArray(value)) return "blob";
+  return "text";
+}
+function firstNonNull2(records, index) {
+  for (const row of records) {
+    const value = row[index];
+    if (value !== null && value !== void 0) return value;
+  }
+  return null;
+}
+var D1Driver = class {
+  type = "d1";
+  label;
+  url;
+  headers;
+  /** Declared column types per table, for result-source resolution. */
+  columns = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.label = `d1:${config.databaseId}`;
+    this.url = `${API}/accounts/${encodeURIComponent(config.accountId)}/d1/database/${encodeURIComponent(config.databaseId)}/raw`;
+    this.headers = { Authorization: `Bearer ${config.apiToken}`, "Content-Type": "application/json" };
+  }
+  async raw(sql2) {
+    let res;
+    try {
+      res = await fetch(this.url, { method: "POST", headers: this.headers, body: JSON.stringify({ sql: sql2 }) });
+    } catch (err) {
+      throw new D1Error(`Cannot reach the Cloudflare API: ${err instanceof Error ? err.message : String(err)}`, 400);
+    }
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {
+    }
+    if (!res.ok || !body?.success) {
+      const message = body?.errors?.map((e) => e.message).join("; ") || `Cloudflare API responded ${res.status}`;
+      throw new D1Error(message, res.status === 401 || res.status === 403 ? 401 : res.ok ? void 0 : 400);
+    }
+    const result = body.result?.[0];
+    if (!result) throw new D1Error("Cloudflare API returned no result");
+    return result;
+  }
+  async tableColumns(table) {
+    const cached = this.columns.get(table);
+    if (cached !== void 0) return cached;
+    let out = null;
+    try {
+      const info = await this.raw(`PRAGMA table_info("${table.replaceAll('"', '""')}")`);
+      const cols = info.results?.columns ?? [];
+      const name = cols.indexOf("name");
+      const type = cols.indexOf("type");
+      const rows = info.results?.rows ?? [];
+      if (rows.length > 0 && name >= 0) {
+        out = new Map(rows.map((r) => [String(r[name]), normalizeDeclaredType2(type >= 0 ? r[type] : null)]));
+      }
+    } catch {
+      out = null;
+    }
+    if (this.columns.size > 200) this.columns.clear();
+    this.columns.set(table, out);
+    return out;
+  }
+  async query(sql2) {
+    if (DATABASE_LIST.test(sql2)) {
+      return {
+        fields: [
+          { name: "seq", orgName: "seq", type: "integer", table: "", orgTable: "", db: "", maxLength: 0 },
+          { name: "name", orgName: "name", type: "text", table: "", orgTable: "", db: "", maxLength: 0 },
+          { name: "file", orgName: "file", type: "text", table: "", orgTable: "", db: "", maxLength: 0 }
+        ],
+        records: [[0, "main", ""]],
+        affectedRows: 0,
+        insertId: 0,
+        isResultQuery: true
+      };
+    }
+    const text = sql2.replace(SCHEMA_PRAGMA, "PRAGMA ");
+    if (/^\s*(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(text)) {
+      throw new D1Error("Cloudflare D1 does not support transaction statements over the API; every request auto-commits.");
+    }
+    if (this.isDdl(text)) this.columns.clear();
+    const result = await this.raw(text);
+    const columns = result.results?.columns ?? [];
+    const records = result.results?.rows ?? [];
+    if (columns.length === 0 && !RESULT_KIND.test(text)) {
+      return {
+        fields: [],
+        records: [],
+        affectedRows: result.meta?.changes ?? 0,
+        insertId: result.meta?.last_row_id ?? 0,
+        isResultQuery: false
+      };
+    }
+    const source = RESULT_KIND.test(text) ? singleSourceTable2(text) : null;
+    const known = source ? await this.tableColumns(source) : null;
+    const fields = columns.map((name, index) => {
+      const fromTable = known?.has(name) ?? false;
+      const type = (fromTable ? known?.get(name) : null) ?? inferTypeFromValue2(firstNonNull2(records, index));
+      return {
+        name,
+        orgName: name,
+        type,
+        table: fromTable && source ? source : "",
+        orgTable: fromTable && source ? source : "",
+        db: fromTable ? "main" : "",
+        maxLength: 0
+      };
+    });
+    return { fields, records, affectedRows: 0, insertId: 0, isResultQuery: true };
+  }
+  isDdl(sql2) {
+    return /^\s*(CREATE|ALTER|DROP)\b/i.test(sql2);
+  }
+  async close() {
+    this.columns.clear();
+  }
+};
+var d1DriverFactory = {
+  async open(config) {
+    const driver = new D1Driver(config);
+    await driver.raw("SELECT 1");
+    return driver;
+  },
+  async test(config) {
+    await new D1Driver(config).raw("SELECT 1");
+  },
+  parseConfig(body) {
+    const accountId = typeof body.accountId === "string" ? body.accountId.trim() : "";
+    const databaseId = typeof body.databaseId === "string" ? body.databaseId.trim() : "";
+    const apiToken = typeof body.apiToken === "string" ? body.apiToken.trim() : "";
+    if (!accountId || !databaseId || !apiToken) {
+      throw new Error("accountId, databaseId and apiToken are required");
+    }
+    return { driver: "d1", accountId, databaseId, apiToken };
+  }
+};
+
 // src/ssh-tunnel.ts
 import { createServer } from "net";
 import { mkdir, readFile as readFile2, appendFile } from "fs/promises";
@@ -1098,7 +1268,8 @@ var factories = {
   postgres: postgresDriverFactory,
   sqlite: sqliteDriverFactory,
   mssql: mssqlDriverFactory,
-  oracle: oracleDriverFactory
+  oracle: oracleDriverFactory,
+  d1: d1DriverFactory
 };
 function isDriverType(value) {
   return typeof value === "string" && value in factories;
@@ -1109,12 +1280,12 @@ function parseDriverConfig(body) {
     throw new Error(`Unsupported driver: ${String(driver)}`);
   }
   const config = factories[driver].parseConfig(body);
-  if (config.driver === "sqlite") return config;
+  if (config.driver === "sqlite" || config.driver === "d1") return config;
   const ssh = parseSshConfig(body.ssh);
   return ssh ? { ...config, ssh } : config;
 }
 async function withTunnel(config, run) {
-  if (config.driver === "sqlite" || !config.ssh) return run(config, void 0);
+  if (config.driver === "sqlite" || config.driver === "d1" || !config.ssh) return run(config, void 0);
   const tunnel = await openSshTunnel(config.ssh, { host: config.host, port: config.port });
   try {
     return await run({ ...config, host: tunnel.host, port: tunnel.port, ssh: void 0 }, tunnel);
@@ -1140,7 +1311,7 @@ function tunneled(driver, tunnel, label) {
 function openDriver(config) {
   return withTunnel(config, async (direct, tunnel) => {
     const driver = await openDirect(direct);
-    if (!tunnel || config.driver === "sqlite" || !config.ssh) return driver;
+    if (!tunnel || config.driver === "sqlite" || config.driver === "d1" || !config.ssh) return driver;
     const label = `${config.user}@${config.host}:${config.port} via ssh ${config.ssh.user}@${config.ssh.host}:${config.ssh.port}`;
     return tunneled(driver, tunnel, label);
   });
@@ -1166,6 +1337,8 @@ function openDirect(config) {
       return factories.mssql.open(config);
     case "oracle":
       return factories.oracle.open(config);
+    case "d1":
+      return factories.d1.open(config);
   }
 }
 function testDirect(config) {
@@ -1180,6 +1353,8 @@ function testDirect(config) {
       return factories.mssql.test(config);
     case "oracle":
       return factories.oracle.test(config);
+    case "d1":
+      return factories.d1.test(config);
   }
 }
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "planche",
-  "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",
+  "version": "0.4.1",
+  "description": "Local agent for Planche — lets the browser-based Planche SQL client reach MySQL/MariaDB/PostgreSQL/SQLite/SQL Server/Oracle/Neon/Supabase/Cloudflare D1 databases from your machine.",
+  "license": "UNLICENSED",
   "homepage": "https://planche.dev",
   "repository": {
     "type": "git",
@@ -31,6 +31,10 @@
     "mssql",
     "sqlserver",
     "oracle",
+    "neon",
+    "supabase",
+    "cloudflare-d1",
+    "d1",
     "sql",
     "client",
     "gui"