@apex-stack/data 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { ApexResource } from '@apex-stack/core';
+import { ZodRawShape } from 'zod';
+
+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.
+ * Every driver is an OPTIONAL peer dependency, loaded on demand — install only
+ * the one your database uses (`@libsql/client`, `postgres`, or `@electric-sql/pglite`).
+ */
+declare function createDb(config: CreateDbConfig): Promise<ApexDbHandle>;
+/**
+ * Apply pending `*.sql` migrations from `dir`, tracked in `_apex_migrations`.
+ * Idempotent; runs each file once in filename order. Works on any dialect.
+ */
+declare function applyMigrations(handle: ApexDbHandle, dir: string): Promise<string[]>;
+interface DefineResourceOptions {
+    db: any;
+    /** A Drizzle table (from `drizzle-orm/sqlite-core` or `…/pg-core`). */
+    table: any;
+    /** Zod raw shape validating the create payload. */
+    insert: ZodRawShape;
+    /** Primary-key column name. Defaults to `id`. */
+    pk?: string;
+}
+/**
+ * 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 ApexDbHandle, type CreateDbConfig, type DefineResourceOptions, type Dialect, applyMigrations, createDb, defineResource };

package/dist/index.js

@@ -0,0 +1,165 @@
+// src/index.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { defineApexRoute } from "@apex-stack/core";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+function libsqlUrl(pathOrUrl) {
+  return /^(file:|libsql:|https?:|:memory:)/.test(pathOrUrl) ? pathOrUrl : `file:${pathOrUrl}`;
+}
+async function loadDriver(spec) {
+  try {
+    return await import(spec);
+  } catch {
+    throw new Error(
+      `@apex-stack/data: the "${spec}" driver isn't installed. Install only the driver your database needs \u2014 e.g. \`npm i ${spec}\`.`
+    );
+  }
+}
+async function createDb(config) {
+  const cfg = typeof config === "string" ? { driver: "libsql", url: config } : config;
+  if (cfg.driver === "sqlite" || cfg.driver === "libsql") {
+    const { createClient } = await loadDriver("@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 loadDriver("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 loadDriver("@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(
+    (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;
+    await handle.exec(readFileSync(join(dir, file), "utf8"));
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    await handle.exec(
+      `INSERT INTO _apex_migrations (name, applied_at) VALUES ('${file.replace(/'/g, "''")}', '${at}')`
+    );
+    done.push(file);
+  }
+  return done;
+}
+function defineResource(name, opts) {
+  const { db, table, insert, pk = "id" } = opts;
+  const pkCol = table[pk];
+  const updateShape = { id: z.coerce.number() };
+  for (const [key, schema] of Object.entries(
+    insert
+  )) {
+    updateShape[key] = schema.optional();
+  }
+  return {
+    __apexResource: true,
+    name,
+    routes: [
+      {
+        pathSuffix: "",
+        mcpName: `${name}_list`,
+        route: defineApexRoute({
+          method: "GET",
+          description: `List all ${name}`,
+          mcp: true,
+          handler: async () => await db.select().from(table)
+        })
+      },
+      {
+        pathSuffix: "/:id",
+        mcpName: `${name}_get`,
+        route: defineApexRoute({
+          method: "GET",
+          description: `Get a single ${name} by id`,
+          input: { id: z.coerce.number() },
+          mcp: true,
+          handler: async ({ input }) => (await db.select().from(table).where(eq(pkCol, input.id)))[0] ?? null
+        })
+      },
+      {
+        pathSuffix: "",
+        mcpName: `${name}_create`,
+        route: defineApexRoute({
+          method: "POST",
+          description: `Create a ${name}`,
+          input: insert,
+          mcp: true,
+          handler: async ({ input }) => (await db.insert(table).values(input).returning())[0]
+        })
+      },
+      {
+        pathSuffix: "/:id",
+        mcpName: `${name}_update`,
+        route: defineApexRoute({
+          method: "PATCH",
+          description: `Update a ${name} by id (partial)`,
+          input: updateShape,
+          mcp: true,
+          handler: async ({ input }) => {
+            const { id, ...fields } = input;
+            return (await db.update(table).set(fields).where(eq(pkCol, id)).returning())[0] ?? null;
+          }
+        })
+      },
+      {
+        pathSuffix: "/:id",
+        mcpName: `${name}_delete`,
+        route: defineApexRoute({
+          method: "DELETE",
+          description: `Delete a ${name} by id`,
+          input: { id: z.coerce.number() },
+          mcp: true,
+          handler: async ({ input }) => (await db.delete(table).where(eq(pkCol, input.id)).returning())[0] ?? null
+        })
+      }
+    ]
+  };
+}
+export {
+  applyMigrations,
+  createDb,
+  defineResource
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apex-stack/data",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Data layer for Apex JS — Drizzle-backed resources that are REST + MCP by default",
   "type": "module",
   "license": "MIT",
@@ -36,7 +36,7 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@apex-stack/core": "0.1.19"
+    "@apex-stack/core": "0.2.0"
   },
   "peerDependencies": {
     "@electric-sql/pglite": "^0.5.0",