@tangle-network/agent-app 0.1.10 → 0.1.11

package/dist/store/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Swappable database provider — the seam that decouples the agent's persistence
+ * from any one driver.
+ *
+ * The agent core (and the app's server modules) import a single `db` and use it
+ * directly. That `db` is a lazy proxy: it forwards to whatever database instance
+ * the runtime injects via {@link DatabaseProvider.setDatabase}. So the SAME core
+ * runs on:
+ *   - Cloudflare D1            (`setDatabase(drizzle(d1, schema))`)        — prod
+ *   - SQLite / miniflare       (`setDatabase(drizzle(betterSqlite, schema))`) — eval / the portable inner shell
+ *   - libsql / Turso, Postgres (`setDatabase(drizzle(client, schema))`)    — a future hosted DB
+ *
+ * Adding a new database is one adapter (a drizzle instance over a new driver) +
+ * a `setDatabase` call. None of the modules importing `db` change. Substrate-
+ * free and driver-agnostic: this module knows nothing about D1, drizzle, or any
+ * schema — it only forwards property access to the injected instance.
+ */
+interface DatabaseProvider<DB> {
+    /** The injected database, as a lazy proxy. Throws (with `notReadyMessage`)
+     *  on any access before {@link setDatabase} is called. */
+    readonly db: DB;
+    /** Inject the active database instance (any driver's client). */
+    setDatabase(database: DB): void;
+    /** True once a database has been injected. */
+    isReady(): boolean;
+    /** Clear the injected database (next access throws again). Mainly for tests. */
+    reset(): void;
+}
+interface DatabaseProviderOptions {
+    /** Error thrown when `db` is accessed before injection. Keep the product's
+     *  existing wording so callers see a familiar message. */
+    notReadyMessage?: string;
+}
+/**
+ * Create a swappable database provider. `DB` is the injected instance's type
+ * (e.g. a drizzle `Database`); the proxy is typed as `DB` so callers keep full
+ * typing and their existing query syntax.
+ */
+declare function createDatabaseProvider<DB extends object>(options?: DatabaseProviderOptions): DatabaseProvider<DB>;
+
+export { type DatabaseProvider, type DatabaseProviderOptions, createDatabaseProvider };

package/dist/store/index.js

@@ -0,0 +1,31 @@
+// src/store/index.ts
+function createDatabaseProvider(options = {}) {
+  const message = options.notReadyMessage ?? "Database not initialized \u2014 call setDatabase() first.";
+  let current = null;
+  const db = new Proxy({}, {
+    get(_target, prop) {
+      if (!current) throw new Error(message);
+      const value = current[prop];
+      return typeof value === "function" ? value.bind(current) : value;
+    },
+    has(_target, prop) {
+      return current !== null && prop in current;
+    }
+  });
+  return {
+    db,
+    setDatabase(database) {
+      current = database;
+    },
+    isReady() {
+      return current !== null;
+    },
+    reset() {
+      current = null;
+    }
+  };
+}
+export {
+  createDatabaseProvider
+};
+//# sourceMappingURL=index.js.map

package/dist/store/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/store/index.ts"],"sourcesContent":["/**\n * Swappable database provider — the seam that decouples the agent's persistence\n * from any one driver.\n *\n * The agent core (and the app's server modules) import a single `db` and use it\n * directly. That `db` is a lazy proxy: it forwards to whatever database instance\n * the runtime injects via {@link DatabaseProvider.setDatabase}. So the SAME core\n * runs on:\n *   - Cloudflare D1            (`setDatabase(drizzle(d1, schema))`)        — prod\n *   - SQLite / miniflare       (`setDatabase(drizzle(betterSqlite, schema))`) — eval / the portable inner shell\n *   - libsql / Turso, Postgres (`setDatabase(drizzle(client, schema))`)    — a future hosted DB\n *\n * Adding a new database is one adapter (a drizzle instance over a new driver) +\n * a `setDatabase` call. None of the modules importing `db` change. Substrate-\n * free and driver-agnostic: this module knows nothing about D1, drizzle, or any\n * schema — it only forwards property access to the injected instance.\n */\n\nexport interface DatabaseProvider<DB> {\n  /** The injected database, as a lazy proxy. Throws (with `notReadyMessage`)\n   *  on any access before {@link setDatabase} is called. */\n  readonly db: DB\n  /** Inject the active database instance (any driver's client). */\n  setDatabase(database: DB): void\n  /** True once a database has been injected. */\n  isReady(): boolean\n  /** Clear the injected database (next access throws again). Mainly for tests. */\n  reset(): void\n}\n\nexport interface DatabaseProviderOptions {\n  /** Error thrown when `db` is accessed before injection. Keep the product's\n   *  existing wording so callers see a familiar message. */\n  notReadyMessage?: string\n}\n\n/**\n * Create a swappable database provider. `DB` is the injected instance's type\n * (e.g. a drizzle `Database`); the proxy is typed as `DB` so callers keep full\n * typing and their existing query syntax.\n */\nexport function createDatabaseProvider<DB extends object>(\n  options: DatabaseProviderOptions = {},\n): DatabaseProvider<DB> {\n  const message = options.notReadyMessage ?? 'Database not initialized — call setDatabase() first.'\n  let current: DB | null = null\n\n  const db = new Proxy({} as DB, {\n    get(_target, prop) {\n      if (!current) throw new Error(message)\n      const value = (current as Record<string | symbol, unknown>)[prop]\n      // Bind methods to the real instance so `this` resolves correctly through\n      // the proxy (works for drizzle's query builders and class-based stores).\n      return typeof value === 'function' ? (value as (...args: unknown[]) => unknown).bind(current) : value\n    },\n    has(_target, prop) {\n      return current !== null && prop in (current as object)\n    },\n  })\n\n  return {\n    db,\n    setDatabase(database: DB) {\n      current = database\n    },\n    isReady() {\n      return current !== null\n    },\n    reset() {\n      current = null\n    },\n  }\n}\n"],"mappings":";AAyCO,SAAS,uBACd,UAAmC,CAAC,GACd;AACtB,QAAM,UAAU,QAAQ,mBAAmB;AAC3C,MAAI,UAAqB;AAEzB,QAAM,KAAK,IAAI,MAAM,CAAC,GAAS;AAAA,IAC7B,IAAI,SAAS,MAAM;AACjB,UAAI,CAAC,QAAS,OAAM,IAAI,MAAM,OAAO;AACrC,YAAM,QAAS,QAA6C,IAAI;AAGhE,aAAO,OAAO,UAAU,aAAc,MAA0C,KAAK,OAAO,IAAI;AAAA,IAClG;AAAA,IACA,IAAI,SAAS,MAAM;AACjB,aAAO,YAAY,QAAQ,QAAS;AAAA,IACtC;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA,YAAY,UAAc;AACxB,gBAAU;AAAA,IACZ;AAAA,IACA,UAAU;AACR,aAAO,YAAY;AAAA,IACrB;AAAA,IACA,QAAQ;AACN,gBAAU;AAAA,IACZ;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "packageManager": "pnpm@10.33.4",
   "description": "Application-shell framework for Tangle agent products: a bounded tool loop, the structured agent→app tool side channel, integration-hub client, per-workspace billing, and crypto — composed over the Tangle agent substrate through typed seams.",
   "keywords": [
@@ -115,6 +115,11 @@
       "types": "./dist/redact/index.d.ts",
       "import": "./dist/redact/index.js",
       "default": "./dist/redact/index.js"
+    },
+    "./store": {
+      "types": "./dist/store/index.d.ts",
+      "import": "./dist/store/index.js",
+      "default": "./dist/store/index.js"
     }
   },
   "scripts": {