@rawdash/adapter-libsql 0.4.0

package/README.md

@@ -0,0 +1,54 @@
+# @rawdash/adapter-libsql
+
+[![npm version](https://img.shields.io/npm/v/@rawdash/adapter-libsql)](https://www.npmjs.com/package/@rawdash/adapter-libsql)
+[![license](https://img.shields.io/npm/l/@rawdash/adapter-libsql)](https://github.com/rawdash/rawdash/blob/main/LICENSE)
+
+libSQL / Turso storage adapter for rawdash.
+
+## What it is
+
+`@rawdash/adapter-libsql` is a `ServerStorage` implementation backed by [libSQL](https://github.com/tursodatabase/libsql) — works against any libSQL endpoint (Turso Cloud, self-hosted libsql-server, or a local file).
+
+Internals: [Kysely](https://kysely.dev) for type-safe queries on top of `@libsql/client`. Runs on Node and Cloudflare Workers / V8 edge from the same package.
+
+## Install
+
+```sh
+npm install @rawdash/adapter-libsql @libsql/client
+```
+
+## Quick example
+
+```ts
+import { createClient } from '@libsql/client';
+import { LibsqlStorage } from '@rawdash/adapter-libsql';
+import { defineConfig } from '@rawdash/core';
+import { serve } from '@rawdash/server';
+
+const storage = new LibsqlStorage({
+  client: createClient({
+    url: process.env.TURSO_DATABASE_URL!,
+    authToken: process.env.TURSO_AUTH_TOKEN,
+  }),
+});
+
+const config = defineConfig({
+  connectors: [],
+  dashboards: {},
+});
+
+serve(config, { storage });
+```
+
+On Cloudflare Workers, import from `@libsql/client/web` and pass the resulting client in the same way.
+
+## Migrations
+
+The Drizzle schema in `src/drizzle-schema.ts` is the source of truth.
+
+- `pnpm db:generate` runs `drizzle-kit generate` to emit a new `drizzle/NNNN_*.sql` file, then re-inlines the SQL into `src/migrations.ts`.
+- At runtime, `LibsqlStorage` applies pending migrations from `MIGRATIONS` on first use and records applied versions in a `schema_migrations` table. The runtime applier reads from the inlined array — no filesystem access — so it works on Workers.
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { Client } from '@libsql/client/web';
+import { ServerStorage, StorageHandle, SyncState } from '@rawdash/core';
+
+declare function initLibsqlSchema(client: Client): Promise<void>;
+interface LibsqlStorageOptions {
+    client: Client;
+    initSchema?: boolean;
+}
+declare class LibsqlStorage implements ServerStorage {
+    private client;
+    private db;
+    private ready;
+    private initError;
+    constructor(options: LibsqlStorageOptions);
+    private init;
+    waitUntilReady(): Promise<void>;
+    getStorageHandle(connectorId: string): StorageHandle;
+    getSyncState(): Promise<SyncState>;
+    setSyncing(): Promise<boolean>;
+    setSyncSuccess(): Promise<void>;
+    setSyncError(error: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+declare function applyMigrations(client: Client): Promise<void>;
+
+interface BundledMigration {
+    tag: string;
+    statements: string[];
+}
+declare const MIGRATIONS: readonly BundledMigration[];
+
+export { type BundledMigration, LibsqlStorage, type LibsqlStorageOptions, MIGRATIONS, applyMigrations, initLibsqlSchema };

package/dist/index.js

@@ -0,0 +1,563 @@
+// src/libsql-storage.ts
+import { Kysely } from "kysely";
+import { LibsqlDialect } from "kysely-libsql";
+
+// src/migrations-bundle.ts
+var MIGRATIONS = [
+  {
+    tag: "0000_nosy_wendell_vaughn",
+    statements: [
+      "CREATE TABLE `distributions` (\n	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n	`connector_id` text NOT NULL,\n	`name` text NOT NULL,\n	`ts` integer NOT NULL,\n	`kind` text NOT NULL,\n	`data` text NOT NULL,\n	`attributes` text DEFAULT '{}' NOT NULL\n);",
+      "CREATE INDEX `distributions_conn_name_ts` ON `distributions` (`connector_id`,`name`,`ts`);",
+      "CREATE TABLE `edges` (\n	`connector_id` text NOT NULL,\n	`from_type` text NOT NULL,\n	`from_id` text NOT NULL,\n	`kind` text NOT NULL,\n	`to_type` text NOT NULL,\n	`to_id` text NOT NULL,\n	`attributes` text DEFAULT '{}' NOT NULL,\n	`updated_at` integer NOT NULL,\n	PRIMARY KEY(`connector_id`, `from_type`, `from_id`, `kind`, `to_type`, `to_id`)\n);",
+      "CREATE INDEX `edges_conn_kind` ON `edges` (`connector_id`,`kind`);",
+      "CREATE INDEX `edges_conn_from` ON `edges` (`connector_id`,`from_type`,`from_id`);",
+      "CREATE TABLE `entities` (\n	`connector_id` text NOT NULL,\n	`type` text NOT NULL,\n	`id` text NOT NULL,\n	`attributes` text DEFAULT '{}' NOT NULL,\n	`updated_at` integer NOT NULL,\n	PRIMARY KEY(`connector_id`, `type`, `id`)\n);",
+      "CREATE INDEX `entities_conn_type` ON `entities` (`connector_id`,`type`);",
+      "CREATE TABLE `events` (\n	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n	`connector_id` text NOT NULL,\n	`name` text NOT NULL,\n	`start_ts` integer NOT NULL,\n	`end_ts` integer,\n	`attributes` text DEFAULT '{}' NOT NULL\n);",
+      "CREATE INDEX `events_conn_name_start` ON `events` (`connector_id`,`name`,`start_ts`);",
+      "CREATE TABLE `metrics` (\n	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n	`connector_id` text NOT NULL,\n	`name` text NOT NULL,\n	`ts` integer NOT NULL,\n	`value` real NOT NULL,\n	`attributes` text DEFAULT '{}' NOT NULL\n);",
+      "CREATE INDEX `metrics_conn_name_ts` ON `metrics` (`connector_id`,`name`,`ts`);"
+    ]
+  },
+  {
+    tag: "0001_clumsy_siren",
+    statements: [
+      "CREATE TABLE `sync_state` (\n	`id` integer PRIMARY KEY NOT NULL,\n	`status` text NOT NULL,\n	`last_sync_at` text,\n	`last_error` text\n);"
+    ]
+  }
+];
+
+// src/migrate.ts
+var SCHEMA_MIGRATIONS_TABLE = "schema_migrations";
+var LEGACY_BASELINE_TABLE = "events";
+async function tableExists(client, name) {
+  const result = await client.execute({
+    sql: "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1",
+    args: [name]
+  });
+  return result.rows.length > 0;
+}
+async function readAppliedTags(client) {
+  const result = await client.execute(
+    `SELECT tag FROM ${SCHEMA_MIGRATIONS_TABLE}`
+  );
+  return new Set(result.rows.map((r) => String(r["tag"])));
+}
+async function applyMigrations(client) {
+  const hadSchemaTable = await tableExists(client, SCHEMA_MIGRATIONS_TABLE);
+  await client.execute(
+    `CREATE TABLE IF NOT EXISTS ${SCHEMA_MIGRATIONS_TABLE} (
+      tag TEXT PRIMARY KEY,
+      applied_at INTEGER NOT NULL
+    )`
+  );
+  if (!hadSchemaTable) {
+    const hasLegacySchema = await tableExists(client, LEGACY_BASELINE_TABLE);
+    if (hasLegacySchema) {
+      const now = Date.now();
+      for (const migration of MIGRATIONS) {
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO ${SCHEMA_MIGRATIONS_TABLE} (tag, applied_at) VALUES (?, ?)`,
+          args: [migration.tag, now]
+        });
+      }
+      return;
+    }
+  }
+  let applied = await readAppliedTags(client);
+  for (const migration of MIGRATIONS) {
+    if (applied.has(migration.tag)) {
+      continue;
+    }
+    const batch = [
+      {
+        sql: `INSERT INTO ${SCHEMA_MIGRATIONS_TABLE} (tag, applied_at) VALUES (?, ?)`,
+        args: [migration.tag, Date.now()]
+      },
+      ...migration.statements
+    ];
+    try {
+      await client.batch(batch, "write");
+    } catch (err) {
+      applied = await readAppliedTags(client);
+      if (!applied.has(migration.tag)) {
+        throw err;
+      }
+    }
+  }
+}
+
+// src/libsql-storage.ts
+var SYNC_STATE_ID = 1;
+async function initLibsqlSchema(client) {
+  await applyMigrations(client);
+  await client.execute({
+    sql: "INSERT OR IGNORE INTO sync_state (id, status, last_sync_at, last_error) VALUES (?, 'idle', NULL, NULL)",
+    args: [SYNC_STATE_ID]
+  });
+}
+function parseJson(value, fallback) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function createDb(client) {
+  return new Kysely({
+    dialect: new LibsqlDialect({ client })
+  });
+}
+function toBatchStmt(q) {
+  return { sql: q.sql, args: q.parameters };
+}
+var LibsqlStorage = class {
+  client;
+  db;
+  ready;
+  initError = null;
+  constructor(options) {
+    this.client = options.client;
+    this.db = createDb(options.client);
+    this.ready = options.initSchema === false ? Promise.resolve() : this.init();
+  }
+  async init() {
+    try {
+      await initLibsqlSchema(this.client);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.initError = `init failed: ${message}`;
+      throw err;
+    }
+  }
+  async waitUntilReady() {
+    return this.ready;
+  }
+  getStorageHandle(connectorId) {
+    const ready = this.ready;
+    const db = this.db;
+    const client = this.client;
+    const eventRow = (e) => ({
+      connector_id: connectorId,
+      name: e.name,
+      start_ts: e.start_ts,
+      end_ts: e.end_ts,
+      attributes: JSON.stringify(e.attributes)
+    });
+    const entityRow = (e) => ({
+      connector_id: connectorId,
+      type: e.type,
+      id: e.id,
+      attributes: JSON.stringify(e.attributes),
+      updated_at: e.updated_at
+    });
+    const metricRow = (m) => ({
+      connector_id: connectorId,
+      name: m.name,
+      ts: m.ts,
+      value: m.value,
+      attributes: JSON.stringify(m.attributes)
+    });
+    const edgeRow = (e) => ({
+      connector_id: connectorId,
+      from_type: e.from_type,
+      from_id: e.from_id,
+      kind: e.kind,
+      to_type: e.to_type,
+      to_id: e.to_id,
+      attributes: JSON.stringify(e.attributes),
+      updated_at: e.updated_at
+    });
+    const distributionRow = (d) => ({
+      connector_id: connectorId,
+      name: d.name,
+      ts: d.ts,
+      kind: d.kind,
+      data: JSON.stringify(d.data),
+      attributes: JSON.stringify(d.attributes)
+    });
+    return {
+      event: async (e) => {
+        await ready;
+        await db.insertInto("events").values(eventRow(e)).execute();
+      },
+      entity: async (e) => {
+        await ready;
+        await db.insertInto("entities").values(entityRow(e)).onConflict(
+          (oc) => oc.columns(["connector_id", "type", "id"]).doUpdateSet({
+            attributes: (eb) => eb.ref("excluded.attributes"),
+            updated_at: (eb) => eb.ref("excluded.updated_at")
+          })
+        ).execute();
+      },
+      metric: async (m) => {
+        await ready;
+        await db.insertInto("metrics").values(metricRow(m)).execute();
+      },
+      edge: async (e) => {
+        await ready;
+        await db.insertInto("edges").values(edgeRow(e)).onConflict(
+          (oc) => oc.columns([
+            "connector_id",
+            "from_type",
+            "from_id",
+            "kind",
+            "to_type",
+            "to_id"
+          ]).doUpdateSet({
+            attributes: (eb) => eb.ref("excluded.attributes"),
+            updated_at: (eb) => eb.ref("excluded.updated_at")
+          })
+        ).execute();
+      },
+      distribution: async (d) => {
+        await ready;
+        await db.insertInto("distributions").values(distributionRow(d)).execute();
+      },
+      events: async (es, scope) => {
+        await ready;
+        const names = Array.from(
+          new Set(scope?.names ?? es.map((e) => e.name))
+        );
+        const stmts = [];
+        if (names.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.deleteFrom("events").where("connector_id", "=", connectorId).where("name", "in", names).compile()
+            )
+          );
+        }
+        if (es.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.insertInto("events").values(es.map(eventRow)).compile()
+            )
+          );
+        }
+        if (stmts.length > 0) {
+          await client.batch(stmts, "write");
+        }
+      },
+      entities: async (es, scope) => {
+        await ready;
+        const types = Array.from(
+          new Set(scope?.types ?? es.map((e) => e.type))
+        );
+        const stmts = [];
+        if (types.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.deleteFrom("entities").where("connector_id", "=", connectorId).where("type", "in", types).compile()
+            )
+          );
+        }
+        if (es.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.insertInto("entities").values(es.map(entityRow)).onConflict(
+                (oc) => oc.columns(["connector_id", "type", "id"]).doUpdateSet({
+                  attributes: (eb) => eb.ref("excluded.attributes"),
+                  updated_at: (eb) => eb.ref("excluded.updated_at")
+                })
+              ).compile()
+            )
+          );
+        }
+        if (stmts.length > 0) {
+          await client.batch(stmts, "write");
+        }
+      },
+      metrics: async (ms, scope) => {
+        await ready;
+        const names = Array.from(
+          new Set(scope?.names ?? ms.map((m) => m.name))
+        );
+        const stmts = [];
+        if (names.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.deleteFrom("metrics").where("connector_id", "=", connectorId).where("name", "in", names).compile()
+            )
+          );
+        }
+        if (ms.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.insertInto("metrics").values(ms.map(metricRow)).compile()
+            )
+          );
+        }
+        if (stmts.length > 0) {
+          await client.batch(stmts, "write");
+        }
+      },
+      edges: async (es, scope) => {
+        await ready;
+        const kinds = Array.from(
+          new Set(scope?.kinds ?? es.map((e) => e.kind))
+        );
+        const stmts = [];
+        if (kinds.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.deleteFrom("edges").where("connector_id", "=", connectorId).where("kind", "in", kinds).compile()
+            )
+          );
+        }
+        if (es.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.insertInto("edges").values(es.map(edgeRow)).onConflict(
+                (oc) => oc.columns([
+                  "connector_id",
+                  "from_type",
+                  "from_id",
+                  "kind",
+                  "to_type",
+                  "to_id"
+                ]).doUpdateSet({
+                  attributes: (eb) => eb.ref("excluded.attributes"),
+                  updated_at: (eb) => eb.ref("excluded.updated_at")
+                })
+              ).compile()
+            )
+          );
+        }
+        if (stmts.length > 0) {
+          await client.batch(stmts, "write");
+        }
+      },
+      distributions: async (ds, scope) => {
+        await ready;
+        const names = Array.from(
+          new Set(scope?.names ?? ds.map((d) => d.name))
+        );
+        const stmts = [];
+        if (names.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.deleteFrom("distributions").where("connector_id", "=", connectorId).where("name", "in", names).compile()
+            )
+          );
+        }
+        if (ds.length > 0) {
+          stmts.push(
+            toBatchStmt(
+              db.insertInto("distributions").values(ds.map(distributionRow)).compile()
+            )
+          );
+        }
+        if (stmts.length > 0) {
+          await client.batch(stmts, "write");
+        }
+      },
+      queryEvents: async (q) => {
+        await ready;
+        let qb = db.selectFrom("events").select(["name", "start_ts", "end_ts", "attributes"]).where("connector_id", "=", connectorId);
+        if (q.name !== void 0) {
+          qb = qb.where("name", "=", q.name);
+        }
+        if (q.start !== void 0) {
+          qb = qb.where("start_ts", ">=", q.start);
+        }
+        if (q.end !== void 0) {
+          qb = qb.where("start_ts", "<=", q.end);
+        }
+        const rows = await qb.execute();
+        return rows.map(
+          (r) => ({
+            name: r.name,
+            start_ts: Number(r.start_ts),
+            end_ts: r.end_ts === null ? null : Number(r.end_ts),
+            attributes: parseJson(r.attributes, {})
+          })
+        );
+      },
+      getEntity: async (type, id) => {
+        await ready;
+        const r = await db.selectFrom("entities").select(["type", "id", "attributes", "updated_at"]).where("connector_id", "=", connectorId).where("type", "=", type).where("id", "=", id).limit(1).executeTakeFirst();
+        if (!r) {
+          return null;
+        }
+        return {
+          type: r.type,
+          id: r.id,
+          attributes: parseJson(r.attributes, {}),
+          updated_at: Number(r.updated_at)
+        };
+      },
+      queryEntities: async (q) => {
+        await ready;
+        const rows = await db.selectFrom("entities").select(["type", "id", "attributes", "updated_at"]).where("connector_id", "=", connectorId).where("type", "=", q.type).execute();
+        return rows.map(
+          (r) => ({
+            type: r.type,
+            id: r.id,
+            attributes: parseJson(r.attributes, {}),
+            updated_at: Number(r.updated_at)
+          })
+        );
+      },
+      queryMetrics: async (q) => {
+        await ready;
+        let qb = db.selectFrom("metrics").select(["name", "ts", "value", "attributes"]).where("connector_id", "=", connectorId);
+        if (q.name !== void 0) {
+          qb = qb.where("name", "=", q.name);
+        }
+        if (q.start !== void 0) {
+          qb = qb.where("ts", ">=", q.start);
+        }
+        if (q.end !== void 0) {
+          qb = qb.where("ts", "<=", q.end);
+        }
+        const rows = await qb.execute();
+        return rows.map(
+          (r) => ({
+            name: r.name,
+            ts: Number(r.ts),
+            value: Number(r.value),
+            attributes: parseJson(r.attributes, {})
+          })
+        );
+      },
+      traverse: async (q) => {
+        await ready;
+        let qb = db.selectFrom("edges").select([
+          "from_type",
+          "from_id",
+          "kind",
+          "to_type",
+          "to_id",
+          "attributes",
+          "updated_at"
+        ]).where("connector_id", "=", connectorId);
+        if (q.fromType !== void 0) {
+          qb = qb.where("from_type", "=", q.fromType);
+        }
+        if (q.fromId !== void 0) {
+          qb = qb.where("from_id", "=", q.fromId);
+        }
+        if (q.kind !== void 0) {
+          qb = qb.where("kind", "=", q.kind);
+        }
+        if (q.toType !== void 0) {
+          qb = qb.where("to_type", "=", q.toType);
+        }
+        if (q.toId !== void 0) {
+          qb = qb.where("to_id", "=", q.toId);
+        }
+        const rows = await qb.execute();
+        return rows.map(
+          (r) => ({
+            from_type: r.from_type,
+            from_id: r.from_id,
+            kind: r.kind,
+            to_type: r.to_type,
+            to_id: r.to_id,
+            attributes: parseJson(r.attributes, {}),
+            updated_at: Number(r.updated_at)
+          })
+        );
+      },
+      queryDistributions: async (q) => {
+        await ready;
+        let qb = db.selectFrom("distributions").select(["name", "ts", "kind", "data", "attributes"]).where("connector_id", "=", connectorId);
+        if (q.name !== void 0) {
+          qb = qb.where("name", "=", q.name);
+        }
+        if (q.start !== void 0) {
+          qb = qb.where("ts", ">=", q.start);
+        }
+        if (q.end !== void 0) {
+          qb = qb.where("ts", "<=", q.end);
+        }
+        const rows = await qb.execute();
+        return rows.map((r) => {
+          const base = {
+            name: r.name,
+            ts: Number(r.ts),
+            attributes: parseJson(r.attributes, {})
+          };
+          const data = parseJson(r.data, {
+            count: 0,
+            sum: 0
+          });
+          if (r.kind === "histogram") {
+            return { ...base, kind: "histogram", data };
+          }
+          if (r.kind === "summary") {
+            return { ...base, kind: "summary", data };
+          }
+          throw new Error(
+            `Unknown distribution kind: ${r.kind} (name=${base.name})`
+          );
+        });
+      },
+      deleteOlderThan: async (shape, tsUnixMs) => {
+        await ready;
+        if (shape === "events") {
+          const r = await db.deleteFrom("events").where("connector_id", "=", connectorId).where("start_ts", "<", tsUnixMs).executeTakeFirst();
+          return { rowsDeleted: Number(r.numDeletedRows) };
+        }
+        if (shape === "metrics") {
+          const r = await db.deleteFrom("metrics").where("connector_id", "=", connectorId).where("ts", "<", tsUnixMs).executeTakeFirst();
+          return { rowsDeleted: Number(r.numDeletedRows) };
+        }
+        if (shape === "distributions") {
+          const r = await db.deleteFrom("distributions").where("connector_id", "=", connectorId).where("ts", "<", tsUnixMs).executeTakeFirst();
+          return { rowsDeleted: Number(r.numDeletedRows) };
+        }
+        throw new Error(
+          `Unsupported shape for deleteOlderThan: ${String(shape)}`
+        );
+      }
+    };
+  }
+  async getSyncState() {
+    if (this.initError !== null) {
+      return { status: "error", lastSyncAt: null, lastError: this.initError };
+    }
+    await this.ready;
+    const r = await this.db.selectFrom("sync_state").select(["status", "last_sync_at", "last_error"]).where("id", "=", SYNC_STATE_ID).limit(1).executeTakeFirst();
+    if (!r) {
+      return { status: "idle", lastSyncAt: null, lastError: null };
+    }
+    return {
+      status: r.status,
+      lastSyncAt: r.last_sync_at,
+      lastError: r.last_error
+    };
+  }
+  async setSyncing() {
+    await this.ready;
+    const r = await this.db.updateTable("sync_state").set({ status: "syncing" }).where("id", "=", SYNC_STATE_ID).where("status", "!=", "syncing").executeTakeFirst();
+    return Number(r.numUpdatedRows) > 0;
+  }
+  async setSyncSuccess() {
+    await this.ready;
+    await this.db.updateTable("sync_state").set({
+      status: "idle",
+      last_sync_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_error: null
+    }).where("id", "=", SYNC_STATE_ID).execute();
+  }
+  async setSyncError(error) {
+    await this.ready;
+    await this.db.updateTable("sync_state").set({ status: "error", last_error: error }).where("id", "=", SYNC_STATE_ID).execute();
+  }
+  async close() {
+    await this.ready.catch(() => void 0);
+    this.client.close();
+  }
+};
+export {
+  LibsqlStorage,
+  MIGRATIONS,
+  applyMigrations,
+  initLibsqlSchema
+};
+//# sourceMappingURL=index.js.map