@apex-stack/data 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -1,23 +1,42 @@
 import { ApexResource } from '@apex-stack/core';
-import Database from 'better-sqlite3';
-import { drizzle } from 'drizzle-orm/better-sqlite3';
 import { ZodRawShape } from 'zod';
 
-type ApexDb = ReturnType<typeof drizzle>;
-/** Open a SQLite database and wrap it with Drizzle. */
-declare function createDb(path: string): {
-    db: ApexDb;
-    sqlite: Database.Database;
+type Dialect = 'sqlite' | 'postgres';
+/** A driver-agnostic database handle. `db` is a Drizzle instance (async API). */
+interface ApexDbHandle {
+    db: any;
+    dialect: Dialect;
+    /** Run raw SQL (one or more statements). */
+    exec(sql: string): Promise<void>;
+    /** Run a query and return rows. */
+    query(sql: string): Promise<Array<Record<string, unknown>>>;
+    close(): Promise<void>;
+}
+type CreateDbConfig = string | {
+    driver: 'sqlite' | 'libsql';
+    url: string;
+} | {
+    driver: 'postgres';
+    url: string;
+} | {
+    driver: 'pglite';
+    dir?: string;
 };
+/**
+ * Open a database and wrap it with Drizzle behind a driver-agnostic handle.
+ * All drivers use Drizzle's async query API, so `defineResource` works unchanged
+ * across SQLite (libSQL/Turso), Postgres (Supabase/Neon) and embedded PGlite.
+ * Postgres/PGlite drivers are loaded on demand — install only what you use.
+ */
+declare function createDb(config: CreateDbConfig): Promise<ApexDbHandle>;
 /**
  * Apply pending `*.sql` migrations from `dir`, tracked in `_apex_migrations`.
- * Idempotent: each file runs once, in filename order, inside a transaction.
- * Returns the names of migrations applied this run.
+ * Idempotent; runs each file once in filename order. Works on any dialect.
  */
-declare function applyMigrations(sqlite: Database.Database, dir: string): string[];
+declare function applyMigrations(handle: ApexDbHandle, dir: string): Promise<string[]>;
 interface DefineResourceOptions {
-    db: ApexDb;
-    /** A Drizzle table. */
+    db: any;
+    /** A Drizzle table (from `drizzle-orm/sqlite-core` or `…/pg-core`). */
     table: any;
     /** Zod raw shape validating the create payload. */
     insert: ZodRawShape;
@@ -25,12 +44,10 @@ interface DefineResourceOptions {
     pk?: string;
 }
 /**
- * Turn one table into a REST + MCP resource: `list`, `get`, and `create` routes,
- * each also an MCP tool. This is the moat — your data is AI-callable by construction.
- *   GET  /api/<name>        → list
- *   GET  /api/<name>/:id    → get
- *   POST /api/<name>        → create
+ * Turn one table into a REST + MCP resource (list/get/create/update/delete),
+ * each also an MCP tool. Dialect-agnostic — the same definition works whether
+ * `db` is backed by SQLite, Turso, Supabase, Neon, or embedded PGlite.
  */
 declare function defineResource(name: string, opts: DefineResourceOptions): ApexResource;
 
-export { type ApexDb, type DefineResourceOptions, applyMigrations, createDb, defineResource };
+export { type ApexDbHandle, type CreateDbConfig, type DefineResourceOptions, type Dialect, applyMigrations, createDb, defineResource };

package/dist/index.js

@@ -1,32 +1,77 @@
 // src/index.ts
-import { readdirSync, readFileSync } from "fs";
+import { existsSync, readdirSync, readFileSync } from "fs";
 import { join } from "path";
 import { defineApexRoute } from "@apex-stack/core";
-import Database from "better-sqlite3";
-import { drizzle } from "drizzle-orm/better-sqlite3";
 import { eq } from "drizzle-orm";
 import { z } from "zod";
-function createDb(path) {
-  const sqlite = new Database(path);
-  sqlite.pragma("journal_mode = WAL");
-  return { db: drizzle(sqlite), sqlite };
+function libsqlUrl(pathOrUrl) {
+  return /^(file:|libsql:|https?:|:memory:)/.test(pathOrUrl) ? pathOrUrl : `file:${pathOrUrl}`;
 }
-function applyMigrations(sqlite, dir) {
-  sqlite.exec(
+async function createDb(config) {
+  const cfg = typeof config === "string" ? { driver: "libsql", url: config } : config;
+  if (cfg.driver === "sqlite" || cfg.driver === "libsql") {
+    const { createClient } = await import("@libsql/client");
+    const { drizzle: drizzle2 } = await import("drizzle-orm/libsql");
+    const client2 = createClient({ url: libsqlUrl(cfg.url) });
+    return {
+      db: drizzle2(client2),
+      dialect: "sqlite",
+      exec: async (sql) => {
+        await client2.executeMultiple(sql);
+      },
+      query: async (sql) => (await client2.execute(sql)).rows,
+      close: async () => {
+        client2.close();
+      }
+    };
+  }
+  if (cfg.driver === "postgres") {
+    const postgres = (await import("postgres")).default;
+    const { drizzle: drizzle2 } = await import("drizzle-orm/postgres-js");
+    const client2 = postgres(cfg.url);
+    return {
+      db: drizzle2(client2),
+      dialect: "postgres",
+      exec: async (sql) => {
+        await client2.unsafe(sql);
+      },
+      query: async (sql) => await client2.unsafe(sql),
+      close: async () => {
+        await client2.end();
+      }
+    };
+  }
+  const { PGlite } = await import("@electric-sql/pglite");
+  const { drizzle } = await import("drizzle-orm/pglite");
+  const client = new PGlite(cfg.dir ?? "memory://");
+  return {
+    db: drizzle(client),
+    dialect: "postgres",
+    exec: async (sql) => {
+      await client.exec(sql);
+    },
+    query: async (sql) => (await client.query(sql)).rows,
+    close: async () => {
+      await client.close();
+    }
+  };
+}
+async function applyMigrations(handle, dir) {
+  if (!existsSync(dir)) return [];
+  await handle.exec(
     "CREATE TABLE IF NOT EXISTS _apex_migrations (name TEXT PRIMARY KEY, applied_at TEXT NOT NULL)"
   );
   const applied = new Set(
-    sqlite.prepare("SELECT name FROM _apex_migrations").all().map((r) => r.name)
+    (await handle.query("SELECT name FROM _apex_migrations")).map((r) => r.name)
   );
   const done = [];
   for (const file of readdirSync(dir).filter((f) => f.endsWith(".sql")).sort()) {
     if (applied.has(file)) continue;
-    const sql = readFileSync(join(dir, file), "utf8");
+    await handle.exec(readFileSync(join(dir, file), "utf8"));
     const at = (/* @__PURE__ */ new Date()).toISOString();
-    sqlite.transaction(() => {
-      sqlite.exec(sql);
-      sqlite.prepare("INSERT INTO _apex_migrations (name, applied_at) VALUES (?, ?)").run(file, at);
-    })();
+    await handle.exec(
+      `INSERT INTO _apex_migrations (name, applied_at) VALUES ('${file.replace(/'/g, "''")}', '${at}')`
+    );
     done.push(file);
   }
   return done;
@@ -51,7 +96,7 @@ function defineResource(name, opts) {
           method: "GET",
           description: `List all ${name}`,
           mcp: true,
-          handler: () => db.select().from(table).all()
+          handler: async () => await db.select().from(table)
         })
       },
       {
@@ -62,7 +107,7 @@ function defineResource(name, opts) {
           description: `Get a single ${name} by id`,
           input: { id: z.coerce.number() },
           mcp: true,
-          handler: ({ input }) => db.select().from(table).where(eq(pkCol, input.id)).get() ?? null
+          handler: async ({ input }) => (await db.select().from(table).where(eq(pkCol, input.id)))[0] ?? null
         })
       },
       {
@@ -73,7 +118,7 @@ function defineResource(name, opts) {
           description: `Create a ${name}`,
           input: insert,
           mcp: true,
-          handler: ({ input }) => db.insert(table).values(input).returning().get()
+          handler: async ({ input }) => (await db.insert(table).values(input).returning())[0]
         })
       },
       {
@@ -84,9 +129,9 @@ function defineResource(name, opts) {
           description: `Update a ${name} by id (partial)`,
           input: updateShape,
           mcp: true,
-          handler: ({ input }) => {
+          handler: async ({ input }) => {
             const { id, ...fields } = input;
-            return db.update(table).set(fields).where(eq(pkCol, id)).returning().get() ?? null;
+            return (await db.update(table).set(fields).where(eq(pkCol, id)).returning())[0] ?? null;
           }
         })
       },
@@ -98,7 +143,7 @@ function defineResource(name, opts) {
           description: `Delete a ${name} by id`,
           input: { id: z.coerce.number() },
           mcp: true,
-          handler: ({ input }) => db.delete(table).where(eq(pkCol, input.id)).returning().get() ?? null
+          handler: async ({ input }) => (await db.delete(table).where(eq(pkCol, input.id)).returning())[0] ?? null
         })
       }
     ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apex-stack/data",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Data layer for Apex JS — Drizzle-backed resources that are REST + MCP by default",
   "type": "module",
   "license": "MIT",
@@ -15,16 +15,19 @@
     "dist"
   ],
   "dependencies": {
+    "@libsql/client": "^0.17.4",
     "better-sqlite3": "^11.0.0",
     "drizzle-orm": "^0.38.0",
     "zod": "^4.4.3",
-    "@apex-stack/core": "0.1.1"
+    "@apex-stack/core": "0.1.3"
   },
   "engines": {
     "node": ">=20.19"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13"
+    "@electric-sql/pglite": "^0.5.4",
+    "@types/better-sqlite3": "^7.6.13",
+    "postgres": "^3.4.9"
   },
   "scripts": {
     "build": "tsup",