@xtandard/webhooks 0.1.0

package/dist/entry-storage-mongodb.d.cts

@@ -0,0 +1,55 @@
+import { o as WebhooksStorage } from "./contract-8h-Azxa5.cjs";
+import { MongoClient } from "mongodb";
+
+//#region src/storage/mongodb.d.ts
+/** Options for {@link createMongoStorage}. */
+interface MongoStorageOptions {
+  /** A pre-constructed (optionally pre-connected) mongodb `MongoClient`. */
+  client?: MongoClient;
+  /**
+   * Connection string (e.g. `mongodb://localhost:27017`). When no `client` is
+   * given, a `MongoClient` is created lazily on first use via a dynamic
+   * `import("mongodb")`.
+   */
+  url?: string;
+  /** Database name. Defaults to `"xtandard_webhooks"`. */
+  dbName?: string;
+  /** Collection name. Defaults to `"webhooks_kv"`. */
+  collectionName?: string;
+}
+/**
+ * A {@link WebhooksStorage} backed by MongoDB, plus a `close()` method that
+ * disconnects the client — but only the one this adapter created. A client you
+ * passed in is left for you to manage.
+ *
+ * Note: `watch` is deliberately absent (see the module docs); this is a plain
+ * {@link WebhooksStorage}, not a {@link import("./contract.ts").WatchableWebhooksStorage}.
+ */
+interface MongoWebhooksStorage extends WebhooksStorage {
+  /** Disconnect the underlying client if this adapter created it. No-op otherwise. */
+  close(): Promise<void>;
+}
+/**
+ * Create a MongoDB-backed {@link MongoWebhooksStorage}. Connection is lazy: the
+ * client is created/connected on the first storage operation and reused
+ * thereafter, guarded by a single connection promise so concurrent calls connect
+ * once.
+ *
+ * @example
+ * ```ts
+ * import { createMongoStorage } from "@xtandard/webhooks/storage/mongodb";
+ *
+ * const storage = createMongoStorage({
+ *   url: process.env.MONGODB_URL ?? "mongodb://localhost:27017",
+ *   dbName: "myapp",
+ *   collectionName: "webhooks_kv",
+ * });
+ *
+ * // Disconnect when the process exits:
+ * // process.on("SIGTERM", () => storage.close());
+ * ```
+ */
+declare function createMongoStorage(options: MongoStorageOptions): MongoWebhooksStorage;
+//#endregion
+export { MongoStorageOptions, MongoWebhooksStorage, createMongoStorage };
+//# sourceMappingURL=entry-storage-mongodb.d.cts.map

package/dist/entry-storage-mongodb.d.mts

@@ -0,0 +1,55 @@
+import { o as WebhooksStorage } from "./contract-DhQ4JjGG.mjs";
+import { MongoClient } from "mongodb";
+
+//#region src/storage/mongodb.d.ts
+/** Options for {@link createMongoStorage}. */
+interface MongoStorageOptions {
+  /** A pre-constructed (optionally pre-connected) mongodb `MongoClient`. */
+  client?: MongoClient;
+  /**
+   * Connection string (e.g. `mongodb://localhost:27017`). When no `client` is
+   * given, a `MongoClient` is created lazily on first use via a dynamic
+   * `import("mongodb")`.
+   */
+  url?: string;
+  /** Database name. Defaults to `"xtandard_webhooks"`. */
+  dbName?: string;
+  /** Collection name. Defaults to `"webhooks_kv"`. */
+  collectionName?: string;
+}
+/**
+ * A {@link WebhooksStorage} backed by MongoDB, plus a `close()` method that
+ * disconnects the client — but only the one this adapter created. A client you
+ * passed in is left for you to manage.
+ *
+ * Note: `watch` is deliberately absent (see the module docs); this is a plain
+ * {@link WebhooksStorage}, not a {@link import("./contract.ts").WatchableWebhooksStorage}.
+ */
+interface MongoWebhooksStorage extends WebhooksStorage {
+  /** Disconnect the underlying client if this adapter created it. No-op otherwise. */
+  close(): Promise<void>;
+}
+/**
+ * Create a MongoDB-backed {@link MongoWebhooksStorage}. Connection is lazy: the
+ * client is created/connected on the first storage operation and reused
+ * thereafter, guarded by a single connection promise so concurrent calls connect
+ * once.
+ *
+ * @example
+ * ```ts
+ * import { createMongoStorage } from "@xtandard/webhooks/storage/mongodb";
+ *
+ * const storage = createMongoStorage({
+ *   url: process.env.MONGODB_URL ?? "mongodb://localhost:27017",
+ *   dbName: "myapp",
+ *   collectionName: "webhooks_kv",
+ * });
+ *
+ * // Disconnect when the process exits:
+ * // process.on("SIGTERM", () => storage.close());
+ * ```
+ */
+declare function createMongoStorage(options: MongoStorageOptions): MongoWebhooksStorage;
+//#endregion
+export { MongoStorageOptions, MongoWebhooksStorage, createMongoStorage };
+//# sourceMappingURL=entry-storage-mongodb.d.mts.map

package/dist/entry-storage-mongodb.mjs

@@ -0,0 +1,2 @@
+import { t as createMongoStorage } from "./mongodb-Ddaq9mml.mjs";
+export { createMongoStorage };

package/dist/entry-storage-postgres.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_postgres = require("./postgres-C8WbchFa.cjs");
+exports.createPostgresStorage = require_postgres.createPostgresStorage;

package/dist/entry-storage-postgres.d.cts

@@ -0,0 +1,62 @@
+import { o as WebhooksStorage } from "./contract-8h-Azxa5.cjs";
+
+//#region src/storage/postgres.d.ts
+/**
+ * Minimal structural view of a SQL client. Both `pg`'s `Pool`/`Client` and
+ * `@electric-sql/pglite`'s `PGlite` satisfy this shape.
+ */
+interface SqlClient {
+  query(text: string, params?: unknown[]): Promise<{
+    rows: Array<Record<string, unknown>>;
+  }>;
+}
+/** Options for {@link createPostgresStorage}. */
+interface PostgresStorageOptions {
+  /**
+   * A pre-built client exposing `query(text, params?) => Promise<{ rows }>`.
+   * Both a `pg` `Pool`/`Client` and `@electric-sql/pglite` satisfy this.
+   */
+  client?: SqlClient;
+  /**
+   * Connection string used to lazily create a `pg` `Pool` (via dynamic import)
+   * when no `client` is supplied.
+   */
+  connectionString?: string;
+  /** Alias for {@link PostgresStorageOptions.connectionString}. */
+  url?: string;
+  /** Table name (default `"xtandard_webhooks"`). Must be a safe SQL identifier. */
+  table?: string;
+}
+/**
+ * A {@link WebhooksStorage} backed by Postgres, plus a `close()` method that
+ * ends the underlying pool — but only the one this adapter created. A client
+ * you passed in is left for you to manage.
+ */
+interface PostgresWebhooksStorage extends WebhooksStorage {
+  /** End the underlying pool if this adapter created it. No-op otherwise. */
+  close(): Promise<void>;
+}
+/**
+ * Create a Postgres-backed {@link PostgresWebhooksStorage}. The table is created
+ * lazily on first use; connection (when using `connectionString`/`url`) is also
+ * lazy — the `pg` `Pool` is imported and constructed on the first operation and
+ * reused thereafter.
+ *
+ * @example
+ * ```ts
+ * import { createPostgresStorage } from "@xtandard/webhooks/storage/postgres";
+ *
+ * // Via connection string (lazy `pg` Pool):
+ * const storage = createPostgresStorage({
+ *   connectionString: process.env.DATABASE_URL,
+ * });
+ *
+ * // Or with a pre-built pg Pool / PGlite client:
+ * // import { PGlite } from "@electric-sql/pglite";
+ * // const storage = createPostgresStorage({ client: new PGlite() });
+ * ```
+ */
+declare function createPostgresStorage(options: PostgresStorageOptions): PostgresWebhooksStorage;
+//#endregion
+export { PostgresStorageOptions, PostgresWebhooksStorage, SqlClient, createPostgresStorage };
+//# sourceMappingURL=entry-storage-postgres.d.cts.map

package/dist/entry-storage-postgres.d.mts

@@ -0,0 +1,62 @@
+import { o as WebhooksStorage } from "./contract-DhQ4JjGG.mjs";
+
+//#region src/storage/postgres.d.ts
+/**
+ * Minimal structural view of a SQL client. Both `pg`'s `Pool`/`Client` and
+ * `@electric-sql/pglite`'s `PGlite` satisfy this shape.
+ */
+interface SqlClient {
+  query(text: string, params?: unknown[]): Promise<{
+    rows: Array<Record<string, unknown>>;
+  }>;
+}
+/** Options for {@link createPostgresStorage}. */
+interface PostgresStorageOptions {
+  /**
+   * A pre-built client exposing `query(text, params?) => Promise<{ rows }>`.
+   * Both a `pg` `Pool`/`Client` and `@electric-sql/pglite` satisfy this.
+   */
+  client?: SqlClient;
+  /**
+   * Connection string used to lazily create a `pg` `Pool` (via dynamic import)
+   * when no `client` is supplied.
+   */
+  connectionString?: string;
+  /** Alias for {@link PostgresStorageOptions.connectionString}. */
+  url?: string;
+  /** Table name (default `"xtandard_webhooks"`). Must be a safe SQL identifier. */
+  table?: string;
+}
+/**
+ * A {@link WebhooksStorage} backed by Postgres, plus a `close()` method that
+ * ends the underlying pool — but only the one this adapter created. A client
+ * you passed in is left for you to manage.
+ */
+interface PostgresWebhooksStorage extends WebhooksStorage {
+  /** End the underlying pool if this adapter created it. No-op otherwise. */
+  close(): Promise<void>;
+}
+/**
+ * Create a Postgres-backed {@link PostgresWebhooksStorage}. The table is created
+ * lazily on first use; connection (when using `connectionString`/`url`) is also
+ * lazy — the `pg` `Pool` is imported and constructed on the first operation and
+ * reused thereafter.
+ *
+ * @example
+ * ```ts
+ * import { createPostgresStorage } from "@xtandard/webhooks/storage/postgres";
+ *
+ * // Via connection string (lazy `pg` Pool):
+ * const storage = createPostgresStorage({
+ *   connectionString: process.env.DATABASE_URL,
+ * });
+ *
+ * // Or with a pre-built pg Pool / PGlite client:
+ * // import { PGlite } from "@electric-sql/pglite";
+ * // const storage = createPostgresStorage({ client: new PGlite() });
+ * ```
+ */
+declare function createPostgresStorage(options: PostgresStorageOptions): PostgresWebhooksStorage;
+//#endregion
+export { PostgresStorageOptions, PostgresWebhooksStorage, SqlClient, createPostgresStorage };
+//# sourceMappingURL=entry-storage-postgres.d.mts.map

package/dist/entry-storage-postgres.mjs

@@ -0,0 +1,2 @@
+import { t as createPostgresStorage } from "./postgres-c3pAhmhr.mjs";
+export { createPostgresStorage };

package/dist/entry-storage-redis.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_redis = require("./redis-CFJkuSgB.cjs");
+exports.createRedisJSONStorage = require_redis.createRedisJSONStorage;
+exports.createRedisStorage = require_redis.createRedisStorage;

package/dist/entry-storage-redis.d.cts

@@ -0,0 +1,77 @@
+import { a as WatchableWebhooksStorage, n as DeliveryQueueStorage } from "./contract-8h-Azxa5.cjs";
+import { RedisClientType } from "redis";
+
+//#region src/storage/redis.d.ts
+/** Options for {@link createRedisStorage}. */
+interface RedisStorageOptions {
+  /** Connection URL (e.g. `redis://localhost:6379`). Used when no `client` is given. */
+  url?: string;
+  /** A pre-constructed (optionally pre-connected) node-redis client. */
+  client?: RedisClientType;
+  /** Optional key namespace prepended to every key, joined with `:`. */
+  prefix?: string;
+  /**
+   * Called on client `error` events (connection drops, reconnect failures).
+   * A handler is always attached internally so a downed Redis never crashes the
+   * process via an unhandled `error` event — this just lets you observe/log them.
+   */
+  onError?: (error: unknown) => void;
+}
+/**
+ * A {@link WatchableWebhooksStorage} + {@link DeliveryQueueStorage} backed by
+ * Redis, plus a `close()` method that disconnects the client — but only the one
+ * this adapter created. A client you passed in is left for you to manage.
+ */
+interface RedisWebhooksStorage extends WatchableWebhooksStorage, DeliveryQueueStorage {
+  /** Disconnect the underlying client if this adapter created it. No-op otherwise. */
+  close(): Promise<void>;
+}
+/**
+ * Create a Redis-backed {@link RedisWebhooksStorage}. Connection is lazy: the
+ * client is created/connected on the first storage operation and reused
+ * thereafter, guarded by a single connection promise so concurrent calls connect
+ * once.
+ *
+ * @example
+ * ```ts
+ * import { createRedisStorage } from "@xtandard/webhooks/storage/redis";
+ *
+ * const storage = createRedisStorage({
+ *   url: process.env.REDIS_URL ?? "redis://localhost:6379",
+ *   prefix: "myapp:webhooks",
+ *   onError: (err) => console.error("[webhooks/redis]", err),
+ * });
+ *
+ * // Disconnect when the process exits:
+ * // process.on("SIGTERM", () => storage.close());
+ * ```
+ */
+declare function createRedisStorage(options: RedisStorageOptions): RedisWebhooksStorage;
+/**
+ * Create a Redis-backed {@link RedisWebhooksStorage} that stores values as native
+ * **RedisJSON** documents (`JSON.SET`/`JSON.GET`) instead of strings — making
+ * the stored records queryable with JSONPath (`JSON.GET key $.status`) and
+ * indexable with RediSearch, while the webhooks system behaves identically.
+ *
+ * Requires the JSON module on the server (built into Redis 8; Redis Stack; or
+ * `redisjson` loaded). Same options and semantics as {@link createRedisStorage},
+ * including lazy connection, `SCAN`-based `getKeys`, keyspace-notification
+ * `watch`, and the native due-queue `claimDue`. **Do not point it at keys
+ * written by `createRedisStorage`** (or vice versa) — the underlying types
+ * differ and Redis answers `WRONGTYPE`.
+ *
+ * @example
+ * ```ts
+ * import { createRedisJSONStorage } from "@xtandard/webhooks/storage/redis";
+ *
+ * const storage = createRedisJSONStorage({
+ *   url: process.env.REDIS_URL ?? "redis://localhost:6379",
+ *   prefix: "myapp:webhooks",
+ * });
+ * // Then, in redis-cli: JSON.GET myapp:webhooks:whk/acme/deliveries/dlv_1 $.status
+ * ```
+ */
+declare function createRedisJSONStorage(options: RedisStorageOptions): RedisWebhooksStorage;
+//#endregion
+export { RedisStorageOptions, RedisWebhooksStorage, createRedisJSONStorage, createRedisStorage };
+//# sourceMappingURL=entry-storage-redis.d.cts.map

package/dist/entry-storage-redis.d.mts

@@ -0,0 +1,77 @@
+import { a as WatchableWebhooksStorage, n as DeliveryQueueStorage } from "./contract-DhQ4JjGG.mjs";
+import { RedisClientType } from "redis";
+
+//#region src/storage/redis.d.ts
+/** Options for {@link createRedisStorage}. */
+interface RedisStorageOptions {
+  /** Connection URL (e.g. `redis://localhost:6379`). Used when no `client` is given. */
+  url?: string;
+  /** A pre-constructed (optionally pre-connected) node-redis client. */
+  client?: RedisClientType;
+  /** Optional key namespace prepended to every key, joined with `:`. */
+  prefix?: string;
+  /**
+   * Called on client `error` events (connection drops, reconnect failures).
+   * A handler is always attached internally so a downed Redis never crashes the
+   * process via an unhandled `error` event — this just lets you observe/log them.
+   */
+  onError?: (error: unknown) => void;
+}
+/**
+ * A {@link WatchableWebhooksStorage} + {@link DeliveryQueueStorage} backed by
+ * Redis, plus a `close()` method that disconnects the client — but only the one
+ * this adapter created. A client you passed in is left for you to manage.
+ */
+interface RedisWebhooksStorage extends WatchableWebhooksStorage, DeliveryQueueStorage {
+  /** Disconnect the underlying client if this adapter created it. No-op otherwise. */
+  close(): Promise<void>;
+}
+/**
+ * Create a Redis-backed {@link RedisWebhooksStorage}. Connection is lazy: the
+ * client is created/connected on the first storage operation and reused
+ * thereafter, guarded by a single connection promise so concurrent calls connect
+ * once.
+ *
+ * @example
+ * ```ts
+ * import { createRedisStorage } from "@xtandard/webhooks/storage/redis";
+ *
+ * const storage = createRedisStorage({
+ *   url: process.env.REDIS_URL ?? "redis://localhost:6379",
+ *   prefix: "myapp:webhooks",
+ *   onError: (err) => console.error("[webhooks/redis]", err),
+ * });
+ *
+ * // Disconnect when the process exits:
+ * // process.on("SIGTERM", () => storage.close());
+ * ```
+ */
+declare function createRedisStorage(options: RedisStorageOptions): RedisWebhooksStorage;
+/**
+ * Create a Redis-backed {@link RedisWebhooksStorage} that stores values as native
+ * **RedisJSON** documents (`JSON.SET`/`JSON.GET`) instead of strings — making
+ * the stored records queryable with JSONPath (`JSON.GET key $.status`) and
+ * indexable with RediSearch, while the webhooks system behaves identically.
+ *
+ * Requires the JSON module on the server (built into Redis 8; Redis Stack; or
+ * `redisjson` loaded). Same options and semantics as {@link createRedisStorage},
+ * including lazy connection, `SCAN`-based `getKeys`, keyspace-notification
+ * `watch`, and the native due-queue `claimDue`. **Do not point it at keys
+ * written by `createRedisStorage`** (or vice versa) — the underlying types
+ * differ and Redis answers `WRONGTYPE`.
+ *
+ * @example
+ * ```ts
+ * import { createRedisJSONStorage } from "@xtandard/webhooks/storage/redis";
+ *
+ * const storage = createRedisJSONStorage({
+ *   url: process.env.REDIS_URL ?? "redis://localhost:6379",
+ *   prefix: "myapp:webhooks",
+ * });
+ * // Then, in redis-cli: JSON.GET myapp:webhooks:whk/acme/deliveries/dlv_1 $.status
+ * ```
+ */
+declare function createRedisJSONStorage(options: RedisStorageOptions): RedisWebhooksStorage;
+//#endregion
+export { RedisStorageOptions, RedisWebhooksStorage, createRedisJSONStorage, createRedisStorage };
+//# sourceMappingURL=entry-storage-redis.d.mts.map

package/dist/entry-storage-redis.mjs

@@ -0,0 +1,2 @@
+import { n as createRedisStorage, t as createRedisJSONStorage } from "./redis-CvLi0KF7.mjs";
+export { createRedisJSONStorage, createRedisStorage };

package/dist/entry-storage-sqlite.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sqlite = require("./sqlite-Dcufk0x3.cjs");
+exports.createSqliteStorage = require_sqlite.createSqliteStorage;

package/dist/entry-storage-sqlite.d.cts

@@ -0,0 +1,36 @@
+import { o as WebhooksStorage } from "./contract-8h-Azxa5.cjs";
+import { Database } from "bun:sqlite";
+
+//#region src/storage/sqlite.d.ts
+/** Options for {@link createSqliteStorage}. */
+interface SqliteStorageOptions {
+  /** File path for the database. Default `":memory:"`. Ignored when `database` is given. */
+  path?: string;
+  /** An existing `bun:sqlite` Database instance to use instead of opening one. */
+  database?: Database;
+  /** Table name (default `"xtandard_webhooks"`). Validated as a safe identifier. */
+  table?: string;
+}
+/** A {@link WebhooksStorage} backed by SQLite, plus `close()`. */
+interface SqliteWebhooksStorage extends WebhooksStorage {
+  /** Close the database if this adapter opened it; no-op for a borrowed instance. */
+  close(): void;
+}
+/**
+ * Create a SQLite-backed storage. Requires the Bun runtime (`bun:sqlite`).
+ *
+ * @example
+ * ```ts
+ * import { createSqliteStorage } from "@xtandard/webhooks/storage/sqlite";
+ *
+ * // File-backed (persists across restarts):
+ * const storage = createSqliteStorage({ path: "./webhooks.sqlite" });
+ *
+ * // In-memory (reset each run, useful for tests):
+ * // const storage = createSqliteStorage({ path: ":memory:" });
+ * ```
+ */
+declare function createSqliteStorage(options?: SqliteStorageOptions): SqliteWebhooksStorage;
+//#endregion
+export { SqliteStorageOptions, SqliteWebhooksStorage, createSqliteStorage };
+//# sourceMappingURL=entry-storage-sqlite.d.cts.map

package/dist/entry-storage-sqlite.d.mts

@@ -0,0 +1,36 @@
+import { o as WebhooksStorage } from "./contract-DhQ4JjGG.mjs";
+import { Database } from "bun:sqlite";
+
+//#region src/storage/sqlite.d.ts
+/** Options for {@link createSqliteStorage}. */
+interface SqliteStorageOptions {
+  /** File path for the database. Default `":memory:"`. Ignored when `database` is given. */
+  path?: string;
+  /** An existing `bun:sqlite` Database instance to use instead of opening one. */
+  database?: Database;
+  /** Table name (default `"xtandard_webhooks"`). Validated as a safe identifier. */
+  table?: string;
+}
+/** A {@link WebhooksStorage} backed by SQLite, plus `close()`. */
+interface SqliteWebhooksStorage extends WebhooksStorage {
+  /** Close the database if this adapter opened it; no-op for a borrowed instance. */
+  close(): void;
+}
+/**
+ * Create a SQLite-backed storage. Requires the Bun runtime (`bun:sqlite`).
+ *
+ * @example
+ * ```ts
+ * import { createSqliteStorage } from "@xtandard/webhooks/storage/sqlite";
+ *
+ * // File-backed (persists across restarts):
+ * const storage = createSqliteStorage({ path: "./webhooks.sqlite" });
+ *
+ * // In-memory (reset each run, useful for tests):
+ * // const storage = createSqliteStorage({ path: ":memory:" });
+ * ```
+ */
+declare function createSqliteStorage(options?: SqliteStorageOptions): SqliteWebhooksStorage;
+//#endregion
+export { SqliteStorageOptions, SqliteWebhooksStorage, createSqliteStorage };
+//# sourceMappingURL=entry-storage-sqlite.d.mts.map

package/dist/entry-storage-sqlite.mjs

@@ -0,0 +1,2 @@
+import { t as createSqliteStorage } from "./sqlite-Cmqnrjes.mjs";
+export { createSqliteStorage };

package/dist/entry-storage-unstorage.cjs

@@ -0,0 +1,42 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/storage/unstorage.ts
+/** Convert an unstorage `:`-separated key back to the `/`-separated form. */
+const fromUnstorageKey = (key) => key.replace(/:/g, "/");
+/**
+* Create a {@link WebhooksStorage} backed by an unstorage `Storage` instance.
+* unstorage auto-serializes/deserializes JSON values, so values round-trip
+* structurally; missing keys read back as `null`.
+*
+* @example
+* ```ts
+* import { createUnstorageStorage } from "@xtandard/webhooks/storage/unstorage";
+* import { createStorage } from "unstorage";
+* import fsDriver from "unstorage/drivers/fs";
+*
+* const storage = createUnstorageStorage({
+*   storage: createStorage({ driver: fsDriver({ base: "./data/webhooks" }) }),
+* });
+* ```
+*/
+function createUnstorageStorage(options) {
+	const { storage } = options;
+	return {
+		async getItem(key) {
+			const value = await storage.getItem(key);
+			return value === void 0 ? null : value;
+		},
+		async setItem(key, value) {
+			await storage.setItem(key, value);
+		},
+		async removeItem(key) {
+			await storage.removeItem(key);
+		},
+		async getKeys(prefix) {
+			return (await storage.getKeys(prefix)).map(fromUnstorageKey).filter((key) => key.startsWith(prefix));
+		}
+	};
+}
+//#endregion
+exports.createUnstorageStorage = createUnstorageStorage;
+
+//# sourceMappingURL=entry-storage-unstorage.cjs.map

package/dist/entry-storage-unstorage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-storage-unstorage.cjs","names":[],"sources":["../src/storage/unstorage.ts"],"sourcesContent":["/**\n * Adapter that wraps an [unstorage](https://unstorage.unjs.io) `Storage`\n * instance as a {@link WebhooksStorage}. The caller constructs and configures\n * their own unstorage instance (with whatever driver they like) and passes it in\n * — we never import `unstorage` at runtime, only its type. `unstorage` therefore\n * remains an optional peer dependency.\n *\n * unstorage normalizes key separators to `:` internally. We write `/`-style keys\n * (which unstorage accepts), but its `getKeys(base)` returns `:`-separated keys.\n * This adapter converts those back to `/` so callers always see the keys they\n * wrote.\n *\n * @module\n */\n\nimport type { Storage } from \"unstorage\";\nimport type { WebhooksStorage } from \"./contract.ts\";\n\n/** Options for {@link createUnstorageStorage}. */\nexport interface UnstorageStorageOptions {\n  /** A pre-constructed unstorage `Storage` instance (any driver). */\n  storage: Storage;\n}\n\n/** Convert an unstorage `:`-separated key back to the `/`-separated form. */\nconst fromUnstorageKey = (key: string): string => key.replace(/:/g, \"/\");\n\n/**\n * Create a {@link WebhooksStorage} backed by an unstorage `Storage` instance.\n * unstorage auto-serializes/deserializes JSON values, so values round-trip\n * structurally; missing keys read back as `null`.\n *\n * @example\n * ```ts\n * import { createUnstorageStorage } from \"@xtandard/webhooks/storage/unstorage\";\n * import { createStorage } from \"unstorage\";\n * import fsDriver from \"unstorage/drivers/fs\";\n *\n * const storage = createUnstorageStorage({\n *   storage: createStorage({ driver: fsDriver({ base: \"./data/webhooks\" }) }),\n * });\n * ```\n */\nexport function createUnstorageStorage(options: UnstorageStorageOptions): WebhooksStorage {\n  const { storage } = options;\n\n  return {\n    async getItem<T>(key: string): Promise<T | null> {\n      const value = await storage.getItem<T>(key);\n      return value === undefined ? null : value;\n    },\n\n    async setItem<T>(key: string, value: T): Promise<void> {\n      // unstorage's setItem rejects `undefined`; the contract never stores it.\n      await storage.setItem(key, value as NonNullable<T>);\n    },\n\n    async removeItem(key: string): Promise<void> {\n      await storage.removeItem(key);\n    },\n\n    async getKeys(prefix: string): Promise<string[]> {\n      // unstorage's getKeys takes a base and returns matching keys with `:`\n      // separators; convert them back so callers get their original `/` keys.\n      const keys = await storage.getKeys(prefix);\n      return keys.map(fromUnstorageKey).filter((key) => key.startsWith(prefix));\n    },\n  } satisfies WebhooksStorage;\n}\n"],"mappings":";;;AAyBA,MAAM,oBAAoB,QAAwB,IAAI,QAAQ,MAAM,GAAG;;;;;;;;;;;;;;;;;AAkBvE,SAAgB,uBAAuB,SAAmD;CACxF,MAAM,EAAE,YAAY;CAEpB,OAAO;EACL,MAAM,QAAW,KAAgC;GAC/C,MAAM,QAAQ,MAAM,QAAQ,QAAW,GAAG;GAC1C,OAAO,UAAU,KAAA,IAAY,OAAO;EACtC;EAEA,MAAM,QAAW,KAAa,OAAyB;GAErD,MAAM,QAAQ,QAAQ,KAAK,KAAuB;EACpD;EAEA,MAAM,WAAW,KAA4B;GAC3C,MAAM,QAAQ,WAAW,GAAG;EAC9B;EAEA,MAAM,QAAQ,QAAmC;GAI/C,QAAO,MADY,QAAQ,QAAQ,MAAM,GAC7B,IAAI,gBAAgB,EAAE,QAAQ,QAAQ,IAAI,WAAW,MAAM,CAAC;EAC1E;CACF;AACF"}

package/dist/entry-storage-unstorage.d.cts

@@ -0,0 +1,29 @@
+import { o as WebhooksStorage } from "./contract-8h-Azxa5.cjs";
+import { Storage } from "unstorage";
+
+//#region src/storage/unstorage.d.ts
+/** Options for {@link createUnstorageStorage}. */
+interface UnstorageStorageOptions {
+  /** A pre-constructed unstorage `Storage` instance (any driver). */
+  storage: Storage;
+}
+/**
+ * Create a {@link WebhooksStorage} backed by an unstorage `Storage` instance.
+ * unstorage auto-serializes/deserializes JSON values, so values round-trip
+ * structurally; missing keys read back as `null`.
+ *
+ * @example
+ * ```ts
+ * import { createUnstorageStorage } from "@xtandard/webhooks/storage/unstorage";
+ * import { createStorage } from "unstorage";
+ * import fsDriver from "unstorage/drivers/fs";
+ *
+ * const storage = createUnstorageStorage({
+ *   storage: createStorage({ driver: fsDriver({ base: "./data/webhooks" }) }),
+ * });
+ * ```
+ */
+declare function createUnstorageStorage(options: UnstorageStorageOptions): WebhooksStorage;
+//#endregion
+export { UnstorageStorageOptions, createUnstorageStorage };
+//# sourceMappingURL=entry-storage-unstorage.d.cts.map

package/dist/entry-storage-unstorage.d.mts

@@ -0,0 +1,29 @@
+import { o as WebhooksStorage } from "./contract-DhQ4JjGG.mjs";
+import { Storage } from "unstorage";
+
+//#region src/storage/unstorage.d.ts
+/** Options for {@link createUnstorageStorage}. */
+interface UnstorageStorageOptions {
+  /** A pre-constructed unstorage `Storage` instance (any driver). */
+  storage: Storage;
+}
+/**
+ * Create a {@link WebhooksStorage} backed by an unstorage `Storage` instance.
+ * unstorage auto-serializes/deserializes JSON values, so values round-trip
+ * structurally; missing keys read back as `null`.
+ *
+ * @example
+ * ```ts
+ * import { createUnstorageStorage } from "@xtandard/webhooks/storage/unstorage";
+ * import { createStorage } from "unstorage";
+ * import fsDriver from "unstorage/drivers/fs";
+ *
+ * const storage = createUnstorageStorage({
+ *   storage: createStorage({ driver: fsDriver({ base: "./data/webhooks" }) }),
+ * });
+ * ```
+ */
+declare function createUnstorageStorage(options: UnstorageStorageOptions): WebhooksStorage;
+//#endregion
+export { UnstorageStorageOptions, createUnstorageStorage };
+//# sourceMappingURL=entry-storage-unstorage.d.mts.map

package/dist/entry-storage-unstorage.mjs

@@ -0,0 +1,41 @@
+//#region src/storage/unstorage.ts
+/** Convert an unstorage `:`-separated key back to the `/`-separated form. */
+const fromUnstorageKey = (key) => key.replace(/:/g, "/");
+/**
+* Create a {@link WebhooksStorage} backed by an unstorage `Storage` instance.
+* unstorage auto-serializes/deserializes JSON values, so values round-trip
+* structurally; missing keys read back as `null`.
+*
+* @example
+* ```ts
+* import { createUnstorageStorage } from "@xtandard/webhooks/storage/unstorage";
+* import { createStorage } from "unstorage";
+* import fsDriver from "unstorage/drivers/fs";
+*
+* const storage = createUnstorageStorage({
+*   storage: createStorage({ driver: fsDriver({ base: "./data/webhooks" }) }),
+* });
+* ```
+*/
+function createUnstorageStorage(options) {
+	const { storage } = options;
+	return {
+		async getItem(key) {
+			const value = await storage.getItem(key);
+			return value === void 0 ? null : value;
+		},
+		async setItem(key, value) {
+			await storage.setItem(key, value);
+		},
+		async removeItem(key) {
+			await storage.removeItem(key);
+		},
+		async getKeys(prefix) {
+			return (await storage.getKeys(prefix)).map(fromUnstorageKey).filter((key) => key.startsWith(prefix));
+		}
+	};
+}
+//#endregion
+export { createUnstorageStorage };
+
+//# sourceMappingURL=entry-storage-unstorage.mjs.map

package/dist/entry-storage-unstorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-storage-unstorage.mjs","names":[],"sources":["../src/storage/unstorage.ts"],"sourcesContent":["/**\n * Adapter that wraps an [unstorage](https://unstorage.unjs.io) `Storage`\n * instance as a {@link WebhooksStorage}. The caller constructs and configures\n * their own unstorage instance (with whatever driver they like) and passes it in\n * — we never import `unstorage` at runtime, only its type. `unstorage` therefore\n * remains an optional peer dependency.\n *\n * unstorage normalizes key separators to `:` internally. We write `/`-style keys\n * (which unstorage accepts), but its `getKeys(base)` returns `:`-separated keys.\n * This adapter converts those back to `/` so callers always see the keys they\n * wrote.\n *\n * @module\n */\n\nimport type { Storage } from \"unstorage\";\nimport type { WebhooksStorage } from \"./contract.ts\";\n\n/** Options for {@link createUnstorageStorage}. */\nexport interface UnstorageStorageOptions {\n  /** A pre-constructed unstorage `Storage` instance (any driver). */\n  storage: Storage;\n}\n\n/** Convert an unstorage `:`-separated key back to the `/`-separated form. */\nconst fromUnstorageKey = (key: string): string => key.replace(/:/g, \"/\");\n\n/**\n * Create a {@link WebhooksStorage} backed by an unstorage `Storage` instance.\n * unstorage auto-serializes/deserializes JSON values, so values round-trip\n * structurally; missing keys read back as `null`.\n *\n * @example\n * ```ts\n * import { createUnstorageStorage } from \"@xtandard/webhooks/storage/unstorage\";\n * import { createStorage } from \"unstorage\";\n * import fsDriver from \"unstorage/drivers/fs\";\n *\n * const storage = createUnstorageStorage({\n *   storage: createStorage({ driver: fsDriver({ base: \"./data/webhooks\" }) }),\n * });\n * ```\n */\nexport function createUnstorageStorage(options: UnstorageStorageOptions): WebhooksStorage {\n  const { storage } = options;\n\n  return {\n    async getItem<T>(key: string): Promise<T | null> {\n      const value = await storage.getItem<T>(key);\n      return value === undefined ? null : value;\n    },\n\n    async setItem<T>(key: string, value: T): Promise<void> {\n      // unstorage's setItem rejects `undefined`; the contract never stores it.\n      await storage.setItem(key, value as NonNullable<T>);\n    },\n\n    async removeItem(key: string): Promise<void> {\n      await storage.removeItem(key);\n    },\n\n    async getKeys(prefix: string): Promise<string[]> {\n      // unstorage's getKeys takes a base and returns matching keys with `:`\n      // separators; convert them back so callers get their original `/` keys.\n      const keys = await storage.getKeys(prefix);\n      return keys.map(fromUnstorageKey).filter((key) => key.startsWith(prefix));\n    },\n  } satisfies WebhooksStorage;\n}\n"],"mappings":";;AAyBA,MAAM,oBAAoB,QAAwB,IAAI,QAAQ,MAAM,GAAG;;;;;;;;;;;;;;;;;AAkBvE,SAAgB,uBAAuB,SAAmD;CACxF,MAAM,EAAE,YAAY;CAEpB,OAAO;EACL,MAAM,QAAW,KAAgC;GAC/C,MAAM,QAAQ,MAAM,QAAQ,QAAW,GAAG;GAC1C,OAAO,UAAU,KAAA,IAAY,OAAO;EACtC;EAEA,MAAM,QAAW,KAAa,OAAyB;GAErD,MAAM,QAAQ,QAAQ,KAAK,KAAuB;EACpD;EAEA,MAAM,WAAW,KAA4B;GAC3C,MAAM,QAAQ,WAAW,GAAG;EAC9B;EAEA,MAAM,QAAQ,QAAmC;GAI/C,QAAO,MADY,QAAQ,QAAQ,MAAM,GAC7B,IAAI,gBAAgB,EAAE,QAAQ,QAAQ,IAAI,WAAW,MAAM,CAAC;EAC1E;CACF;AACF"}