feat: support pglite

docs/2.connectors/pglite.md

@@ -0,0 +1,95 @@
+---
+icon: simple-icons:postgresql
+---
+
+# PGlite
+
+> Connect DB0 to Postgres using PGlite
+
+:read-more{to="https://pglite.dev"}
+
+## Usage
+
+For this connector, you need to install [`@electric-sql/pglite`](https://www.npmjs.com/package/@electric-sql/pglite) dependency:
+
+:pm-i{name="@electric-sql/pglite"}
+
+Use `pglite` connector:
+
+```js
+import { createDatabase, sql } from "db0";
+import pglite from "db0/connectors/pglite";
+
+const db = createDatabase(
+  pglite({
+    /* options */
+  }),
+);
+```
+
+<!-- copy from https://pglite.dev/docs/api#main-constructor -->
+## Options
+
+### `dataDir`
+
+Path to the directory for storing the Postgres database. You can provide a URI scheme for various storage backends:
+
+- **`file://` or unprefixed**: File system storage, available in Node and Bun.
+- **`idb://`**: IndexedDB storage, available in the browser.
+- **`memory://`**: In-memory ephemeral storage, available on all platforms.
+
+### `options`
+
+#### `dataDir`
+
+The directory in which to store the Postgres database when not provided as the first argument.
+
+**Type:** `string`
+
+#### `debug`
+
+Postgres debug level. Logs are sent to the console.
+
+**Type:** `1 | 2 | 3 | 4 | 5`
+
+#### `relaxedDurability`
+
+Under relaxed durability mode, PGlite will not wait for flushes to storage to complete after each query before returning results. This is particularly useful when using the IndexedDB file system.
+
+**Type:** `boolean`
+
+#### `fs`
+
+An alternative to providing a `dataDir` with a filesystem prefix. Initialize a `Filesystem` yourself and provide it here.
+
+**Type:** `Filesystem`
+
+#### `loadDataDir`
+
+A tarball of a PGlite datadir to load when the database starts. This should be a tarball produced from the related `.dumpDataDir()` method.
+
+**Type:** `Blob | File`
+
+#### `extensions`
+
+An object containing the extensions you wish to load.
+
+**Type:** `{ [namespace: string]: Extension }`
+
+#### `username`
+
+The username of the user to connect to the database as. Permissions will be applied in the context of this user.
+
+**Type:** `string`
+
+#### `database`
+
+The database from the Postgres cluster within the `dataDir` to connect to.
+
+**Type:** `string`
+
+#### `initialMemory`
+
+The initial amount of memory in bytes to allocate for the PGlite instance. PGlite will grow the memory automatically, but if you have a particularly large database, you can set this higher to prevent the pause during memory growth.
+
+**Type:** `number`

package.json

@@ -50,6 +50,7 @@
     "test:bun": "bun test ./test/connectors/bun-test.ts"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "^0.2.4",
     "@libsql/client": "^0.14.0",
     "@planetscale/database": "^1.19.0",
     "@types/better-sqlite3": "^7.6.11",
@@ -76,7 +77,8 @@
     "@libsql/client": "*",
     "better-sqlite3": "*",
     "drizzle-orm": "*",
-    "mysql2": "*"
+    "mysql2": "*",
+    "@electric-sql/pglite": "*"
   },
   "peerDependenciesMeta": {
     "@libsql/client": {
@@ -90,6 +92,9 @@
     },
     "mysql2": {
       "optional": true
+    },
+    "@electric-sql/pglite": {
+      "optional": true
     }
   },
   "packageManager": "pnpm@9.12.1"

src/connectors/pglite.ts

@@ -0,0 +1,75 @@
+import { PGlite, type PGliteOptions } from "@electric-sql/pglite";
+import type { Connector, Statement } from "../types";
+
+export type ConnectorOptions = PGliteOptions
+
+export default function pgliteConnector(opts: ConnectorOptions = {}) {
+  let _client: PGlite | undefined;
+
+  function getClient(): PGlite {
+    if (_client) {
+      return _client;
+    }
+    _client = new PGlite(opts);
+    return _client;
+  }
+
+  async function query(sql: string, params: unknown[] = []) {
+    const client = await getClient();
+    const normalizedSql = normalizeParams(sql);
+    const result = await client.query(normalizedSql, params);
+    return result;
+  }
+
+  return <Connector>{
+    name: "pglite",
+    dialect: "postgresql",
+    exec(sql: string) {
+      return query(sql);
+    },
+    prepare(sql: string) {
+      const stmt = <Statement>{
+        _sql: sql,
+        _params: [],
+        bind(...params: unknown[]) {
+          if (params.length > 0) {
+            this._params = params;
+          }
+          return this;
+        },
+        async all(...params: unknown[]) {
+          const result = await query(
+            this._sql,
+            params.length > 0 ? params : this._params
+          );
+          return result.rows;
+        },
+        async run(...params: unknown[]) {
+          const result = await query(
+            this._sql,
+            params.length > 0 ? params : this._params
+          );
+          return {
+            success: true,  // Adding the success property to match the expected type
+            result,
+            rows: result.rows,
+          };
+        },
+        async get(...params: unknown[]) {
+          const result = await query(
+            this._sql,
+            params.length > 0 ? params : this._params
+          );
+          return result.rows[0];
+        },
+      };
+      return stmt;
+    },
+  };
+}
+
+// https://www.postgresql.org/docs/9.3/sql-prepare.html
+function normalizeParams(sql: string) {
+  let i = 0;
+  return sql.replace(/\?/g, () => `$${++i}`);
+}

src/index.ts

@@ -9,6 +9,7 @@ export * from "./types";
 export const connectors = {
   sqlite: "db0/connectors/better-sqlite3",
   postgresql: "db0/connectors/postgresql",
+  pglite: "db0/connectors/pglite",
   "cloudflare-d1": "db0/connectors/cloudflare-d1",
   libsql: "db0/connectors/libsql/node",
   "libsql-node": "db0/connectors/libsql/node",

test/connectors/pglite.test.ts

@@ -0,0 +1,16 @@
+import { fileURLToPath } from "node:url";
+import { rm, mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { describe } from "vitest";
+import PGlite from "../../src/connectors/pglite"
+import { testConnector } from "./_tests";
+
+describe("connectors: pglite", async () => {
+  const dataDir = fileURLToPath(new URL(".tmp/pglite", import.meta.url));
+  await rm(dataDir, { recursive: true }).catch(() => { /* */ });
+  await mkdir(dirname(dataDir), { recursive: true });
+  testConnector({
+    dialect: "postgresql",
+    connector: PGlite({ dataDir }),
+  });
+});