alepha 0.20.5 → 0.20.7

package/dist/cache/database/index.d.ts

@@ -0,0 +1,156 @@
+import * as _$alepha from "alepha";
+import { Alepha, Static } from "alepha";
+import { CacheProvider } from "alepha/cache";
+import { DateTimeProvider } from "alepha/datetime";
+import * as _$alepha_logger0 from "alepha/logger";
+import * as _$alepha_orm0 from "alepha/orm";
+import * as _$typebox from "typebox";
+
+//#region ../../src/cache/database/entities/cacheEntries.d.ts
+/**
+ * Storage table for the {@link DatabaseCacheProvider}.
+ *
+ * Each row represents one cache entry:
+ * - `(container, cacheKey)` is the logical key (uniqueness enforced by index).
+ * - `value` holds base64-encoded bytes for `set/get/setTyped/getTyped`.
+ * - `count` holds an integer counter for atomic `incr` operations.
+ * - `expiresAt` is null for entries that never expire, or a timestamp after
+ *   which the entry is considered gone (filtered out at read time).
+ */
+declare const cacheEntries: _$alepha_orm0.EntityPrimitive<_$typebox.TObject<{
+  id: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$typebox.TString, typeof _$alepha_orm0.PG_PRIMARY_KEY>, typeof _$alepha_orm0.PG_DEFAULT>;
+  createdAt: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$typebox.TString, typeof _$alepha_orm0.PG_CREATED_AT>, typeof _$alepha_orm0.PG_DEFAULT>;
+  container: _$typebox.TString;
+  cacheKey: _$typebox.TString;
+  value: _$typebox.TOptional<_$typebox.TString>;
+  count: _$typebox.TOptional<_$typebox.TInteger>;
+  expiresAt: _$typebox.TOptional<_$typebox.TString>;
+}>>;
+type CacheEntry = Static<typeof cacheEntries.schema>;
+//#endregion
+//#region ../../src/cache/database/providers/DatabaseCacheProvider.d.ts
+/**
+ * Configuration atom for {@link DatabaseCacheProvider}.
+ */
+declare const databaseCacheOptions: _$alepha.Atom<_$typebox.TObject<{
+  sweepProbability: _$typebox.TNumber;
+  sweepBatchSize: _$typebox.TInteger;
+}>, "alepha.cache.database.options">;
+type DatabaseCacheOptions = Static<typeof databaseCacheOptions.schema>;
+declare module "alepha" {
+  interface State {
+    [databaseCacheOptions.key]: DatabaseCacheOptions;
+  }
+}
+/**
+ * Cache provider backed by the application's SQL database.
+ *
+ * Uses the `cache_entries` table as a generic key/value store with optional
+ * TTL. Works on every database supported by Alepha's ORM (Postgres, SQLite,
+ * Cloudflare D1, Bun SQLite).
+ *
+ * **Why use this over Cloudflare KV / Redis ?**
+ *
+ * - You already have a SQL database, no extra resource to provision/secure.
+ * - `incr()` is **atomic** through `INSERT ... ON CONFLICT DO UPDATE`.
+ * - Reads/writes are **strongly consistent** (KV is eventually consistent).
+ * - Phase-2 flows (registration, password reset) become transactional with
+ *   the user-creation INSERT.
+ *
+ * **When to prefer Cloudflare KV / Redis instead ?**
+ *
+ * - Hot read paths where DB latency matters.
+ * - Very high write rates where DB pressure becomes a concern.
+ *
+ * **Storage layout**
+ *
+ * - `value` column: base64-encoded bytes for `set/get/setTyped/getTyped`.
+ * - `count` column: integer counter for atomic `incr()`.
+ * - `expiresAt` column: nullable timestamp; expired rows are filtered at read
+ *   time and reaped opportunistically on writes.
+ *
+ * @see {@link CacheProvider}
+ */
+declare class DatabaseCacheProvider extends CacheProvider {
+  protected readonly log: _$alepha_logger0.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly repository: _$alepha_orm0.Repository<_$typebox.TObject<{
+    id: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$typebox.TString, typeof _$alepha_orm0.PG_PRIMARY_KEY>, typeof _$alepha_orm0.PG_DEFAULT>;
+    createdAt: _$alepha_orm0.PgAttr<_$alepha_orm0.PgAttr<_$typebox.TString, typeof _$alepha_orm0.PG_CREATED_AT>, typeof _$alepha_orm0.PG_DEFAULT>;
+    container: _$typebox.TString;
+    cacheKey: _$typebox.TString;
+    value: _$typebox.TOptional<_$typebox.TString>;
+    count: _$typebox.TOptional<_$typebox.TInteger>;
+    expiresAt: _$typebox.TOptional<_$typebox.TString>;
+  }>>;
+  protected readonly options: Readonly<{
+    sweepProbability: number;
+    sweepBatchSize: number;
+  }>;
+  /**
+   * Total writes performed since startup. Useful for tests and metrics.
+   */
+  writes: number;
+  /**
+   * Total opportunistic sweep cycles executed. Useful for tests.
+   */
+  sweeps: number;
+  /**
+   * Last error caught while sweeping (sweeps must never throw).
+   */
+  lastSweepError?: unknown;
+  protected readonly onStart: _$alepha.HookPrimitive<"start">;
+  get(name: string, key: string): Promise<Uint8Array | undefined>;
+  set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
+  del(name: string, ...keys: string[]): Promise<void>;
+  has(name: string, key: string): Promise<boolean>;
+  keys(name: string, filter?: string): Promise<string[]>;
+  clear(): Promise<void>;
+  incr(name: string, key: string, amount: number): Promise<number>;
+  /**
+   * Sweep all expired rows in one shot. Useful for tests and for users who
+   * want to schedule their own cleanup job.
+   */
+  sweepExpired(): Promise<number>;
+  protected unexpiredOrClause(): Record<string, any>;
+  protected unexpiredWhere(name: string, key: string): Record<string, any>;
+  protected computeExpiresAt(ttl?: number): string | null;
+  protected toBase64(value: Uint8Array): string;
+  protected fromBase64(value: string): Uint8Array;
+  /**
+   * Run an opportunistic sweep with `sweepProbability` chance per write.
+   *
+   * Sweep failures are swallowed: cleanup is best-effort, lazy expiration on
+   * read keeps correctness regardless. Errors are logged once on `lastSweepError`
+   * so tests can assert on them.
+   */
+  protected maybeSweep(): void;
+  protected runSweep(): Promise<void>;
+}
+//#endregion
+//#region ../../src/cache/database/index.d.ts
+/**
+ * Plugin for Alepha Cache that stores entries in the application's SQL database.
+ *
+ * Adds a `cache_entries` table and a {@link DatabaseCacheProvider}
+ * implementation of {@link CacheProvider} that:
+ *
+ * - reads/writes through the framework's ORM (Postgres, SQLite, D1, Bun);
+ * - exposes an **atomic** `incr()` via `INSERT ... ON CONFLICT DO UPDATE`;
+ * - filters expired rows on every read (lazy expiration);
+ * - opportunistically sweeps a small batch of expired rows on writes
+ *   (configurable via {@link databaseCacheOptions}).
+ *
+ * **Module is opt-in.** Importing this module does not change the default
+ * `CacheProvider` binding — pass `provider: DatabaseCacheProvider` explicitly
+ * to the relevant `$cache(...)` calls, or rebind globally via
+ * `alepha.with({ provide: CacheProvider, use: DatabaseCacheProvider })`.
+ *
+ * @see {@link DatabaseCacheProvider}
+ * @module alepha.cache.database
+ */
+declare const AlephaCacheDatabase: _$alepha.Service<_$alepha.Module>;
+//#endregion
+export { AlephaCacheDatabase, CacheEntry, DatabaseCacheOptions, DatabaseCacheProvider, cacheEntries, databaseCacheOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/cache/database/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/cache/database/entities/cacheEntries.ts","../../../src/cache/database/providers/DatabaseCacheProvider.ts","../../../src/cache/database/index.ts"],"mappings":";;;;;;;;;;;;;;;;;AAaA;;cAAa,YAAA,EAAY,aAAA,CAAA,eAAA,WAAA,OAAA;gDAuCvB,SAAA,CAAA,OAAA;;;;;;;;KAEU,UAAA,GAAa,MAAA,QAAc,YAAA,CAAa,MAAA;;;;;;cC1CvC,oBAAA,EAAoB,QAAA,CAAA,IAAA,WAAA,OAAA;oBAqB/B,SAAA,CAAA,OAAA;;;KAEU,oBAAA,GAAuB,MAAA,QAAc,oBAAA,CAAqB,MAAA;AAAA;EAAA,UAG1D,KAAA;IAAA,CACP,oBAAA,CAAqB,GAAA,GAAM,oBAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCnB,qBAAA,SAA8B,aAAA;EAAA,mBACtB,GAAA,EADc,gBAAA,CACX,MAAA;EAAA,mBACH,MAAA,EAAM,MAAA;EAAA,mBACN,gBAAA,EAAgB,gBAAA;EAAA,mBAChB,UAAA,EAAU,aAAA,CAAA,UAAA,WAAA,OAAA;kDADM,SAAA,CAAA,OAAA;;;;;;;;qBAEhB,OAAA,EAAO,QAAA;;;;;ADzB5B;;EC8BS,MAAA;ED9BsB;;;ECmCtB,MAAA;EDnCiD;;;ECwCjD,cAAA;EAAA,mBAIY,OAAA,EAnBO,QAAA,CAmBA,aAAA;EASb,GAAA,CAAI,IAAA,UAAc,GAAA,WAAc,OAAA,CAAQ,UAAA;EA2BxC,GAAA,CACX,IAAA,UACA,GAAA,UACA,KAAA,EAAO,UAAA,EACP,GAAA,YACC,OAAA,CAAQ,UAAA;EA+BE,GAAA,CAAI,IAAA,aAAiB,IAAA,aAAiB,OAAA;EActC,GAAA,CAAI,IAAA,UAAc,GAAA,WAAc,OAAA;EAOhC,IAAA,CAAK,IAAA,UAAc,MAAA,YAAkB,OAAA;EAgBrC,KAAA,CAAA,GAAS,OAAA;EAIT,IAAA,CACX,IAAA,UACA,GAAA,UACA,MAAA,WACC,OAAA;EA3M4B;;;;EAoPlB,YAAA,CAAA,GAAgB,OAAA;EAAA,UAUnB,iBAAA,CAAA,GAAqB,MAAA;EAAA,UAOrB,cAAA,CAAe,IAAA,UAAc,GAAA,WAAc,MAAA;EAAA,UAU3C,gBAAA,CAAiB,GAAA;EAAA,UASjB,QAAA,CAAS,KAAA,EAAO,UAAA;EAAA,UAQhB,UAAA,CAAW,KAAA,WAAgB,UAAA;EAzQ3B;;;;;;;EAAA,UAoRA,UAAA,CAAA;EAAA,UAgBM,QAAA,CAAA,GAAY,OAAA;AAAA;;;;;;;;;;AD1T9B;;;;;;;;;;;;;cEkBa,mBAAA,EAAmB,QAAA,CAAA,OAAA,CAI9B,QAAA,CAJ8B,MAAA"}

package/dist/cache/database/index.js

@@ -0,0 +1,266 @@
+import { $atom, $hook, $inject, $module, $state, Alepha, t } from "alepha";
+import { AlephaCache, CacheProvider } from "alepha/cache";
+import { DateTimeProvider } from "alepha/datetime";
+import { $logger } from "alepha/logger";
+import { $entity, $repository, db, sql } from "alepha/orm";
+//#region ../../src/cache/database/entities/cacheEntries.ts
+/**
+* Storage table for the {@link DatabaseCacheProvider}.
+*
+* Each row represents one cache entry:
+* - `(container, cacheKey)` is the logical key (uniqueness enforced by index).
+* - `value` holds base64-encoded bytes for `set/get/setTyped/getTyped`.
+* - `count` holds an integer counter for atomic `incr` operations.
+* - `expiresAt` is null for entries that never expire, or a timestamp after
+*   which the entry is considered gone (filtered out at read time).
+*/
+const cacheEntries = $entity({
+	name: "cache_entries",
+	schema: t.object({
+		id: db.primaryKey(t.uuid()),
+		createdAt: db.createdAt(),
+		container: t.text({ description: "Cache container name, set by the $cache primitive." }),
+		cacheKey: t.text({ description: "Per-container key chosen by the caller." }),
+		value: t.optional(t.string({ description: "Base64-encoded bytes. Used by set/get." })),
+		count: t.optional(t.integer({ description: "Counter value. Used by atomic incr()." })),
+		expiresAt: t.optional(t.datetime({ description: "Null means no expiration." }))
+	}),
+	indexes: [{
+		columns: ["container", "cacheKey"],
+		unique: true
+	}, "expiresAt"]
+});
+//#endregion
+//#region ../../src/cache/database/providers/DatabaseCacheProvider.ts
+/**
+* Configuration atom for {@link DatabaseCacheProvider}.
+*/
+const databaseCacheOptions = $atom({
+	name: "alepha.cache.database.options",
+	schema: t.object({
+		sweepProbability: t.number({
+			description: "Probability (0..1) that a write operation triggers a sweep of expired rows. Set to 0 to disable opportunistic sweeping.",
+			default: .01,
+			minimum: 0,
+			maximum: 1
+		}),
+		sweepBatchSize: t.integer({
+			description: "Maximum number of expired rows deleted per opportunistic sweep.",
+			default: 100,
+			minimum: 1
+		})
+	}),
+	default: {
+		sweepProbability: .01,
+		sweepBatchSize: 100
+	}
+});
+/**
+* Cache provider backed by the application's SQL database.
+*
+* Uses the `cache_entries` table as a generic key/value store with optional
+* TTL. Works on every database supported by Alepha's ORM (Postgres, SQLite,
+* Cloudflare D1, Bun SQLite).
+*
+* **Why use this over Cloudflare KV / Redis ?**
+*
+* - You already have a SQL database, no extra resource to provision/secure.
+* - `incr()` is **atomic** through `INSERT ... ON CONFLICT DO UPDATE`.
+* - Reads/writes are **strongly consistent** (KV is eventually consistent).
+* - Phase-2 flows (registration, password reset) become transactional with
+*   the user-creation INSERT.
+*
+* **When to prefer Cloudflare KV / Redis instead ?**
+*
+* - Hot read paths where DB latency matters.
+* - Very high write rates where DB pressure becomes a concern.
+*
+* **Storage layout**
+*
+* - `value` column: base64-encoded bytes for `set/get/setTyped/getTyped`.
+* - `count` column: integer counter for atomic `incr()`.
+* - `expiresAt` column: nullable timestamp; expired rows are filtered at read
+*   time and reaped opportunistically on writes.
+*
+* @see {@link CacheProvider}
+*/
+var DatabaseCacheProvider = class extends CacheProvider {
+	log = $logger();
+	alepha = $inject(Alepha);
+	dateTimeProvider = $inject(DateTimeProvider);
+	repository = $repository(cacheEntries);
+	options = $state(databaseCacheOptions);
+	/**
+	* Total writes performed since startup. Useful for tests and metrics.
+	*/
+	writes = 0;
+	/**
+	* Total opportunistic sweep cycles executed. Useful for tests.
+	*/
+	sweeps = 0;
+	/**
+	* Last error caught while sweeping (sweeps must never throw).
+	*/
+	lastSweepError;
+	onStart = $hook({
+		on: "start",
+		handler: () => {
+			this.log.debug("DatabaseCacheProvider ready");
+		}
+	});
+	async get(name, key) {
+		if (!this.alepha.isStarted()) return;
+		const row = await this.repository.findOne({ where: this.unexpiredWhere(name, key) });
+		if (!row) return;
+		if (row.value != null) return this.fromBase64(row.value);
+		if (row.count != null) return this.serialize(row.count);
+	}
+	async set(name, key, value, ttl) {
+		if (!this.alepha.isStarted()) return value;
+		const expiresAt = this.computeExpiresAt(ttl);
+		await this.repository.upsert({
+			container: name,
+			cacheKey: key,
+			value: this.toBase64(value),
+			count: null,
+			expiresAt
+		}, {
+			target: ["container", "cacheKey"],
+			set: {
+				value: this.toBase64(value),
+				count: null,
+				expiresAt
+			}
+		});
+		this.writes++;
+		this.maybeSweep();
+		return value;
+	}
+	async del(name, ...keys) {
+		if (keys.length === 0) {
+			await this.repository.deleteMany({ container: { eq: name } });
+			return;
+		}
+		await this.repository.deleteMany({
+			container: { eq: name },
+			cacheKey: { inArray: keys }
+		});
+	}
+	async has(name, key) {
+		return await this.repository.findOne({ where: this.unexpiredWhere(name, key) }) != null;
+	}
+	async keys(name, filter) {
+		const baseAnd = [{ container: { eq: name } }, this.unexpiredOrClause()];
+		if (filter) baseAnd.push({ cacheKey: { startsWith: filter } });
+		return (await this.repository.findMany({ where: { and: baseAnd } })).map((row) => row.cacheKey);
+	}
+	async clear() {
+		await this.repository.deleteMany({});
+	}
+	async incr(name, key, amount) {
+		if (!this.alepha.isStarted()) return amount;
+		const table = this.repository.table;
+		const updated = await this.repository.upsert({
+			container: name,
+			cacheKey: key,
+			count: amount,
+			value: null,
+			expiresAt: null
+		}, {
+			target: ["container", "cacheKey"],
+			set: {
+				count: sql`coalesce(${table.count}, 0) + ${amount}`,
+				value: null
+			}
+		});
+		this.writes++;
+		this.maybeSweep();
+		return Number(updated.count ?? amount);
+	}
+	/**
+	* Sweep all expired rows in one shot. Useful for tests and for users who
+	* want to schedule their own cleanup job.
+	*/
+	async sweepExpired() {
+		const nowIso = this.dateTimeProvider.nowISOString();
+		return (await this.repository.deleteMany({ expiresAt: { lt: nowIso } })).length;
+	}
+	unexpiredOrClause() {
+		return { or: [{ expiresAt: { isNull: true } }, { expiresAt: { gt: this.dateTimeProvider.nowISOString() } }] };
+	}
+	unexpiredWhere(name, key) {
+		return { and: [
+			{ container: { eq: name } },
+			{ cacheKey: { eq: key } },
+			this.unexpiredOrClause()
+		] };
+	}
+	computeExpiresAt(ttl) {
+		if (!ttl || ttl <= 0) return null;
+		return this.dateTimeProvider.of(this.dateTimeProvider.nowMillis() + ttl).toISOString();
+	}
+	toBase64(value) {
+		return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64");
+	}
+	fromBase64(value) {
+		return new Uint8Array(Buffer.from(value, "base64"));
+	}
+	/**
+	* Run an opportunistic sweep with `sweepProbability` chance per write.
+	*
+	* Sweep failures are swallowed: cleanup is best-effort, lazy expiration on
+	* read keeps correctness regardless. Errors are logged once on `lastSweepError`
+	* so tests can assert on them.
+	*/
+	maybeSweep() {
+		const probability = this.options.sweepProbability;
+		if (probability <= 0) return;
+		if (Math.random() >= probability) return;
+		this.runSweep().catch((err) => {
+			this.lastSweepError = err;
+			this.log.warn("DatabaseCacheProvider sweep failed", err);
+		});
+	}
+	async runSweep() {
+		this.sweeps++;
+		const nowIso = this.dateTimeProvider.nowISOString();
+		const expired = await this.repository.findMany({
+			where: { expiresAt: { lt: nowIso } },
+			columns: ["id"],
+			limit: this.options.sweepBatchSize
+		});
+		if (expired.length === 0) return;
+		await this.repository.deleteMany({ id: { inArray: expired.map((it) => it.id) } });
+	}
+};
+//#endregion
+//#region ../../src/cache/database/index.ts
+/**
+* Plugin for Alepha Cache that stores entries in the application's SQL database.
+*
+* Adds a `cache_entries` table and a {@link DatabaseCacheProvider}
+* implementation of {@link CacheProvider} that:
+*
+* - reads/writes through the framework's ORM (Postgres, SQLite, D1, Bun);
+* - exposes an **atomic** `incr()` via `INSERT ... ON CONFLICT DO UPDATE`;
+* - filters expired rows on every read (lazy expiration);
+* - opportunistically sweeps a small batch of expired rows on writes
+*   (configurable via {@link databaseCacheOptions}).
+*
+* **Module is opt-in.** Importing this module does not change the default
+* `CacheProvider` binding — pass `provider: DatabaseCacheProvider` explicitly
+* to the relevant `$cache(...)` calls, or rebind globally via
+* `alepha.with({ provide: CacheProvider, use: DatabaseCacheProvider })`.
+*
+* @see {@link DatabaseCacheProvider}
+* @module alepha.cache.database
+*/
+const AlephaCacheDatabase = $module({
+	name: "alepha.cache.database",
+	services: [DatabaseCacheProvider],
+	register: (alepha) => alepha.with(AlephaCache)
+});
+//#endregion
+export { AlephaCacheDatabase, DatabaseCacheProvider, cacheEntries, databaseCacheOptions };
+
+//# sourceMappingURL=index.js.map

package/dist/cache/database/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/cache/database/entities/cacheEntries.ts","../../../src/cache/database/providers/DatabaseCacheProvider.ts","../../../src/cache/database/index.ts"],"sourcesContent":["import { type Static, t } from \"alepha\";\nimport { $entity, db } from \"alepha/orm\";\n\n/**\n * Storage table for the {@link DatabaseCacheProvider}.\n *\n * Each row represents one cache entry:\n * - `(container, cacheKey)` is the logical key (uniqueness enforced by index).\n * - `value` holds base64-encoded bytes for `set/get/setTyped/getTyped`.\n * - `count` holds an integer counter for atomic `incr` operations.\n * - `expiresAt` is null for entries that never expire, or a timestamp after\n *   which the entry is considered gone (filtered out at read time).\n */\nexport const cacheEntries = $entity({\n  name: \"cache_entries\",\n  schema: t.object({\n    id: db.primaryKey(t.uuid()),\n\n    createdAt: db.createdAt(),\n\n    container: t.text({\n      description: \"Cache container name, set by the $cache primitive.\",\n    }),\n\n    cacheKey: t.text({\n      description: \"Per-container key chosen by the caller.\",\n    }),\n\n    value: t.optional(\n      // No maxLength: cache values are arbitrary-sized (especially when\n      // `compress: true` is enabled on the $cache primitive, which can\n      // produce blobs well above the default 255-char `t.text()` cap). This\n      // resolves to TEXT in both Postgres and SQLite, which have no\n      // practical length limit either.\n      t.string({\n        description: \"Base64-encoded bytes. Used by set/get.\",\n      }),\n    ),\n\n    count: t.optional(\n      t.integer({\n        description: \"Counter value. Used by atomic incr().\",\n      }),\n    ),\n\n    expiresAt: t.optional(\n      t.datetime({\n        description: \"Null means no expiration.\",\n      }),\n    ),\n  }),\n  indexes: [{ columns: [\"container\", \"cacheKey\"], unique: true }, \"expiresAt\"],\n});\n\nexport type CacheEntry = Static<typeof cacheEntries.schema>;\n","import { $atom, $hook, $inject, $state, Alepha, type Static, t } from \"alepha\";\nimport { CacheProvider } from \"alepha/cache\";\nimport { DateTimeProvider } from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport { $repository, sql } from \"alepha/orm\";\nimport { cacheEntries } from \"../entities/cacheEntries.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Configuration atom for {@link DatabaseCacheProvider}.\n */\nexport const databaseCacheOptions = $atom({\n  name: \"alepha.cache.database.options\",\n  schema: t.object({\n    sweepProbability: t.number({\n      description:\n        \"Probability (0..1) that a write operation triggers a sweep of expired rows. Set to 0 to disable opportunistic sweeping.\",\n      default: 0.01,\n      minimum: 0,\n      maximum: 1,\n    }),\n    sweepBatchSize: t.integer({\n      description:\n        \"Maximum number of expired rows deleted per opportunistic sweep.\",\n      default: 100,\n      minimum: 1,\n    }),\n  }),\n  default: {\n    sweepProbability: 0.01,\n    sweepBatchSize: 100,\n  },\n});\n\nexport type DatabaseCacheOptions = Static<typeof databaseCacheOptions.schema>;\n\ndeclare module \"alepha\" {\n  interface State {\n    [databaseCacheOptions.key]: DatabaseCacheOptions;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Cache provider backed by the application's SQL database.\n *\n * Uses the `cache_entries` table as a generic key/value store with optional\n * TTL. Works on every database supported by Alepha's ORM (Postgres, SQLite,\n * Cloudflare D1, Bun SQLite).\n *\n * **Why use this over Cloudflare KV / Redis ?**\n *\n * - You already have a SQL database, no extra resource to provision/secure.\n * - `incr()` is **atomic** through `INSERT ... ON CONFLICT DO UPDATE`.\n * - Reads/writes are **strongly consistent** (KV is eventually consistent).\n * - Phase-2 flows (registration, password reset) become transactional with\n *   the user-creation INSERT.\n *\n * **When to prefer Cloudflare KV / Redis instead ?**\n *\n * - Hot read paths where DB latency matters.\n * - Very high write rates where DB pressure becomes a concern.\n *\n * **Storage layout**\n *\n * - `value` column: base64-encoded bytes for `set/get/setTyped/getTyped`.\n * - `count` column: integer counter for atomic `incr()`.\n * - `expiresAt` column: nullable timestamp; expired rows are filtered at read\n *   time and reaped opportunistically on writes.\n *\n * @see {@link CacheProvider}\n */\nexport class DatabaseCacheProvider extends CacheProvider {\n  protected readonly log = $logger();\n  protected readonly alepha = $inject(Alepha);\n  protected readonly dateTimeProvider = $inject(DateTimeProvider);\n  protected readonly repository = $repository(cacheEntries);\n  protected readonly options = $state(databaseCacheOptions);\n\n  /**\n   * Total writes performed since startup. Useful for tests and metrics.\n   */\n  public writes = 0;\n\n  /**\n   * Total opportunistic sweep cycles executed. Useful for tests.\n   */\n  public sweeps = 0;\n\n  /**\n   * Last error caught while sweeping (sweeps must never throw).\n   */\n  public lastSweepError?: unknown;\n\n  // -------------------------------------------------------------------------------------------------------------------\n\n  protected readonly onStart = $hook({\n    on: \"start\",\n    handler: () => {\n      this.log.debug(\"DatabaseCacheProvider ready\");\n    },\n  });\n\n  // -------------------------------------------------------------------------------------------------------------------\n\n  public async get(name: string, key: string): Promise<Uint8Array | undefined> {\n    if (!this.alepha.isStarted()) {\n      return undefined;\n    }\n\n    const row = await this.repository.findOne({\n      where: this.unexpiredWhere(name, key) as any,\n    });\n\n    if (!row) {\n      return undefined;\n    }\n\n    if (row.value != null) {\n      return this.fromBase64(row.value);\n    }\n\n    if (row.count != null) {\n      // The caller wrote the entry through `incr()`. Surface the count via\n      // the same byte format that MemoryCacheProvider uses, so `getTyped`\n      // returns the number transparently.\n      return this.serialize(row.count);\n    }\n\n    return undefined;\n  }\n\n  public async set(\n    name: string,\n    key: string,\n    value: Uint8Array,\n    ttl?: number,\n  ): Promise<Uint8Array> {\n    if (!this.alepha.isStarted()) {\n      return value;\n    }\n\n    const expiresAt = this.computeExpiresAt(ttl);\n\n    await this.repository.upsert(\n      {\n        container: name,\n        cacheKey: key,\n        value: this.toBase64(value),\n        count: null,\n        expiresAt,\n      } as any,\n      {\n        target: [\"container\", \"cacheKey\"],\n        set: {\n          value: this.toBase64(value),\n          count: null,\n          expiresAt,\n        },\n      },\n    );\n\n    this.writes++;\n    this.maybeSweep();\n\n    return value;\n  }\n\n  public async del(name: string, ...keys: string[]): Promise<void> {\n    if (keys.length === 0) {\n      await this.repository.deleteMany({\n        container: { eq: name },\n      });\n      return;\n    }\n\n    await this.repository.deleteMany({\n      container: { eq: name },\n      cacheKey: { inArray: keys },\n    });\n  }\n\n  public async has(name: string, key: string): Promise<boolean> {\n    const row = await this.repository.findOne({\n      where: this.unexpiredWhere(name, key) as any,\n    });\n    return row != null;\n  }\n\n  public async keys(name: string, filter?: string): Promise<string[]> {\n    const baseAnd: any[] = [\n      { container: { eq: name } },\n      this.unexpiredOrClause(),\n    ];\n    if (filter) {\n      baseAnd.push({ cacheKey: { startsWith: filter } });\n    }\n\n    const rows = await this.repository.findMany({\n      where: { and: baseAnd } as any,\n    });\n\n    return rows.map((row) => row.cacheKey);\n  }\n\n  public async clear(): Promise<void> {\n    await this.repository.deleteMany({});\n  }\n\n  public async incr(\n    name: string,\n    key: string,\n    amount: number,\n  ): Promise<number> {\n    if (!this.alepha.isStarted()) {\n      return amount;\n    }\n\n    // Atomic upsert via `INSERT ... ON CONFLICT (container, cacheKey) DO UPDATE\n    // SET count = COALESCE(cache_entries.count, 0) + excluded.count`.\n    // Both Postgres and SQLite (incl. D1) support this in a single statement,\n    // so concurrent callers can never observe an interleaved read/write.\n    const table = this.repository.table;\n\n    const updated = await this.repository.upsert(\n      {\n        container: name,\n        cacheKey: key,\n        count: amount,\n        value: null,\n        expiresAt: null,\n      } as any,\n      {\n        target: [\"container\", \"cacheKey\"],\n        set: {\n          // `excluded.count` references the value being inserted on conflict.\n          count: sql`coalesce(${table.count}, 0) + ${amount}`,\n          value: null,\n        },\n      },\n    );\n\n    this.writes++;\n    this.maybeSweep();\n\n    return Number(updated.count ?? amount);\n  }\n\n  // -------------------------------------------------------------------------------------------------------------------\n\n  /**\n   * Sweep all expired rows in one shot. Useful for tests and for users who\n   * want to schedule their own cleanup job.\n   */\n  public async sweepExpired(): Promise<number> {\n    const nowIso = this.dateTimeProvider.nowISOString();\n    const ids = await this.repository.deleteMany({\n      expiresAt: { lt: nowIso },\n    });\n    return ids.length;\n  }\n\n  // -------------------------------------------------------------------------------------------------------------------\n\n  protected unexpiredOrClause(): Record<string, any> {\n    const nowIso = this.dateTimeProvider.nowISOString();\n    return {\n      or: [{ expiresAt: { isNull: true } }, { expiresAt: { gt: nowIso } }],\n    };\n  }\n\n  protected unexpiredWhere(name: string, key: string): Record<string, any> {\n    return {\n      and: [\n        { container: { eq: name } },\n        { cacheKey: { eq: key } },\n        this.unexpiredOrClause(),\n      ],\n    };\n  }\n\n  protected computeExpiresAt(ttl?: number): string | null {\n    if (!ttl || ttl <= 0) {\n      return null;\n    }\n    return this.dateTimeProvider\n      .of(this.dateTimeProvider.nowMillis() + ttl)\n      .toISOString();\n  }\n\n  protected toBase64(value: Uint8Array): string {\n    return Buffer.from(\n      value.buffer as ArrayBuffer,\n      value.byteOffset,\n      value.byteLength,\n    ).toString(\"base64\");\n  }\n\n  protected fromBase64(value: string): Uint8Array {\n    return new Uint8Array(Buffer.from(value, \"base64\"));\n  }\n\n  /**\n   * Run an opportunistic sweep with `sweepProbability` chance per write.\n   *\n   * Sweep failures are swallowed: cleanup is best-effort, lazy expiration on\n   * read keeps correctness regardless. Errors are logged once on `lastSweepError`\n   * so tests can assert on them.\n   */\n  protected maybeSweep(): void {\n    const probability = this.options.sweepProbability;\n    if (probability <= 0) {\n      return;\n    }\n\n    if (Math.random() >= probability) {\n      return;\n    }\n\n    this.runSweep().catch((err) => {\n      this.lastSweepError = err;\n      this.log.warn(\"DatabaseCacheProvider sweep failed\", err);\n    });\n  }\n\n  protected async runSweep(): Promise<void> {\n    this.sweeps++;\n    const nowIso = this.dateTimeProvider.nowISOString();\n\n    // Drizzle does not expose a portable LIMIT on DELETE, so we select first\n    // and then delete by ID. Two roundtrips, but only on the ~1% sweep path.\n    const expired = await this.repository.findMany({\n      where: { expiresAt: { lt: nowIso } },\n      columns: [\"id\"],\n      limit: this.options.sweepBatchSize,\n    });\n\n    if (expired.length === 0) {\n      return;\n    }\n\n    await this.repository.deleteMany({\n      id: { inArray: expired.map((it) => it.id) },\n    });\n  }\n}\n","import { $module } from \"alepha\";\nimport { AlephaCache } from \"alepha/cache\";\nimport { DatabaseCacheProvider } from \"./providers/DatabaseCacheProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./entities/cacheEntries.ts\";\nexport * from \"./providers/DatabaseCacheProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Cache that stores entries in the application's SQL database.\n *\n * Adds a `cache_entries` table and a {@link DatabaseCacheProvider}\n * implementation of {@link CacheProvider} that:\n *\n * - reads/writes through the framework's ORM (Postgres, SQLite, D1, Bun);\n * - exposes an **atomic** `incr()` via `INSERT ... ON CONFLICT DO UPDATE`;\n * - filters expired rows on every read (lazy expiration);\n * - opportunistically sweeps a small batch of expired rows on writes\n *   (configurable via {@link databaseCacheOptions}).\n *\n * **Module is opt-in.** Importing this module does not change the default\n * `CacheProvider` binding — pass `provider: DatabaseCacheProvider` explicitly\n * to the relevant `$cache(...)` calls, or rebind globally via\n * `alepha.with({ provide: CacheProvider, use: DatabaseCacheProvider })`.\n *\n * @see {@link DatabaseCacheProvider}\n * @module alepha.cache.database\n */\nexport const AlephaCacheDatabase = $module({\n  name: \"alepha.cache.database\",\n  services: [DatabaseCacheProvider],\n  register: (alepha) => alepha.with(AlephaCache),\n});\n"],"mappings":"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"}

package/dist/cache/redis/index.d.ts

@@ -3,13 +3,14 @@ import { Alepha, Static } from "alepha";
 import { CacheProvider } from "alepha/cache";
 import * as _$alepha_logger0 from "alepha/logger";
 import { RedisProvider } from "alepha/redis";
+import * as _$typebox from "typebox";
 
 //#region ../../src/cache/redis/providers/RedisCacheProvider.d.ts
 /**
  * Redis cache configuration atom.
  */
-declare const redisCacheOptions: _$alepha.Atom<_$alepha.TObject<{
-  prefix: _$alepha.TOptional<_$alepha.TString>;
+declare const redisCacheOptions: _$alepha.Atom<_$typebox.TObject<{
+  prefix: _$typebox.TOptional<_$typebox.TString>;
 }>, "alepha.cache.redis.options">;
 type RedisCacheOptions = Static<typeof redisCacheOptions.schema>;
 declare module "alepha" {

package/dist/cache/redis/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/cache/redis/providers/RedisCacheProvider.ts","../../../src/cache/redis/index.ts"],"mappings":";;;;;;;;;;cAUa,iBAAA,EAAiB,QAAA,CAAA,IAAA,UAAA,OAAA;6BAW5B,QAAA,CAAA,OAAA;AAAA;AAAA,KAEU,iBAAA,GAAoB,MAAA,QAAc,iBAAA,CAAkB,MAAA;AAAA;EAAA,UAGpD,KAAA;IAAA,CACP,iBAAA,CAAkB,GAAA,GAAM,iBAAA;EAAA;AAAA;AAAA,cAMhB,kBAAA,SAA2B,aAAA;EAAA,mBACnB,GAAA,EADW,gBAAA,CACR,MAAA;EAAA,mBACH,aAAA,EAAa,aAAA;EAAA,mBACb,OAAA,EAAO,QAAA;;;qBACP,MAAA,EAAM,MAAA;EAEZ,GAAA,CAAI,IAAA,UAAc,GAAA,WAAc,OAAA,CAAQ,UAAA;EAmBxC,GAAA,CACX,IAAA,UACA,GAAA,UACA,KAAA,EAAO,UAAA,WACP,GAAA,YACC,OAAA,CAAQ,UAAA;EAmBE,GAAA,CAAI,IAAA,aAAiB,IAAA,aAAiB,OAAA;EAmBtC,GAAA,CAAI,IAAA,UAAc,GAAA,WAAc,OAAA;EAIhC,IAAA,CAAK,IAAA,UAAc,MAAA,YAAkB,OAAA;EAOrC,KAAA,CAAA,GAAS,OAAA;EAST,IAAA,CACX,IAAA,UACA,GAAA,UACA,MAAA,WACC,OAAA;EAAA,UAKO,MAAA,CAAA,GAAU,IAAA;AAAA;;;;;;;;;cClHT,gBAAA,EAAgB,QAAA,CAAA,OAAA,CAW3B,QAAA,CAX2B,MAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/cache/redis/providers/RedisCacheProvider.ts","../../../src/cache/redis/index.ts"],"mappings":";;;;;;;;;;;cAUa,iBAAA,EAAiB,QAAA,CAAA,IAAA,WAAA,OAAA;8BAW5B,SAAA,CAAA,OAAA;AAAA;AAAA,KAEU,iBAAA,GAAoB,MAAA,QAAc,iBAAA,CAAkB,MAAA;AAAA;EAAA,UAGpD,KAAA;IAAA,CACP,iBAAA,CAAkB,GAAA,GAAM,iBAAA;EAAA;AAAA;AAAA,cAMhB,kBAAA,SAA2B,aAAA;EAAA,mBACnB,GAAA,EADW,gBAAA,CACR,MAAA;EAAA,mBACH,aAAA,EAAa,aAAA;EAAA,mBACb,OAAA,EAAO,QAAA;;;qBACP,MAAA,EAAM,MAAA;EAEZ,GAAA,CAAI,IAAA,UAAc,GAAA,WAAc,OAAA,CAAQ,UAAA;EAmBxC,GAAA,CACX,IAAA,UACA,GAAA,UACA,KAAA,EAAO,UAAA,WACP,GAAA,YACC,OAAA,CAAQ,UAAA;EAmBE,GAAA,CAAI,IAAA,aAAiB,IAAA,aAAiB,OAAA;EAmBtC,GAAA,CAAI,IAAA,UAAc,GAAA,WAAc,OAAA;EAIhC,IAAA,CAAK,IAAA,UAAc,MAAA,YAAkB,OAAA;EAOrC,KAAA,CAAA,GAAS,OAAA;EAST,IAAA,CACX,IAAA,UACA,GAAA,UACA,MAAA,WACC,OAAA;EAAA,UAKO,MAAA,CAAA,GAAU,IAAA;AAAA;;;;;;;;;cClHT,gBAAA,EAAgB,QAAA,CAAA,OAAA,CAW3B,QAAA,CAX2B,MAAA"}

package/dist/cache/redis/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/cache/redis/providers/RedisCacheProvider.ts","../../../src/cache/redis/index.ts"],"sourcesContent":["import { $atom, $inject, $state, Alepha, type Static, t } from \"alepha\";\nimport { CacheProvider } from \"alepha/cache\";\nimport { $logger } from \"alepha/logger\";\nimport { RedisProvider } from \"alepha/redis\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Redis cache configuration atom.\n */\nexport const redisCacheOptions = $atom({\n  name: \"alepha.cache.redis.options\",\n  schema: t.object({\n    prefix: t.optional(\n      t.text({\n        description:\n          \"Prefix for all cache keys in Redis. Useful for testing or multi-tenant applications.\",\n      }),\n    ),\n  }),\n  default: {},\n});\n\nexport type RedisCacheOptions = Static<typeof redisCacheOptions.schema>;\n\ndeclare module \"alepha\" {\n  interface State {\n    [redisCacheOptions.key]: RedisCacheOptions;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class RedisCacheProvider extends CacheProvider {\n  protected readonly log = $logger();\n  protected readonly redisProvider = $inject(RedisProvider);\n  protected readonly options = $state(redisCacheOptions);\n  protected readonly alepha = $inject(Alepha);\n\n  public async get(name: string, key: string): Promise<Uint8Array | undefined> {\n    if (!this.alepha.isStarted()) {\n      return;\n    }\n\n    const keyWithPrefix = this.prefix(name, key);\n    const buffer = await this.redisProvider.get(keyWithPrefix);\n    if (!buffer) {\n      return;\n    }\n\n    this.log.debug(`Cache hit`, {\n      size: buffer.byteLength,\n      key: keyWithPrefix,\n    });\n\n    return new Uint8Array(buffer);\n  }\n\n  public async set(\n    name: string,\n    key: string,\n    value: Uint8Array | string,\n    ttl?: number,\n  ): Promise<Uint8Array> {\n    if (!this.alepha.isReady()) {\n      return new Uint8Array(Buffer.from(value));\n    }\n\n    const buffer = Buffer.from(value);\n    const prefix = this.prefix(name, key);\n\n    if (ttl) {\n      return new Uint8Array(\n        await this.redisProvider.set(prefix, buffer, {\n          expiration: { type: \"PX\", value: ttl },\n        }),\n      );\n    }\n\n    return new Uint8Array(await this.redisProvider.set(prefix, buffer));\n  }\n\n  public async del(name: string, ...keys: string[]): Promise<void> {\n    const nameKey = this.prefix(name);\n\n    if (keys.length === 0) {\n      const matched = await this.redisProvider.keys(`${nameKey}:*`);\n      if (matched.length > 0) {\n        await this.redisProvider.del(matched);\n      }\n      return;\n    }\n\n    const prefixed = keys.map((key) =>\n      key.startsWith(nameKey) ? key : this.prefix(name, key),\n    );\n    if (prefixed.length > 0) {\n      await this.redisProvider.del(prefixed);\n    }\n  }\n\n  public async has(name: string, key: string): Promise<boolean> {\n    return this.redisProvider.has(this.prefix(name, key));\n  }\n\n  public async keys(name: string, filter?: string): Promise<string[]> {\n    if (filter) {\n      return await this.redisProvider.keys(`${this.prefix(name)}:${filter}*`);\n    }\n    return this.redisProvider.keys(`${this.prefix(name)}:*`);\n  }\n\n  public async clear(): Promise<void> {\n    this.log.debug(\"Clearing all cache\");\n    const pattern = `${this.prefix()}:*`;\n    const keys = await this.redisProvider.keys(pattern);\n    if (keys.length > 0) {\n      await this.redisProvider.del(keys);\n    }\n  }\n\n  public async incr(\n    name: string,\n    key: string,\n    amount: number,\n  ): Promise<number> {\n    const keyWithPrefix = this.prefix(name, key);\n    return this.redisProvider.incr(keyWithPrefix, amount);\n  }\n\n  protected prefix(...path: string[]): string {\n    const parts = [\"cache\", ...path];\n\n    if (this.options.prefix) {\n      parts.unshift(this.options.prefix);\n    }\n\n    return parts.join(\":\");\n  }\n}\n","import { $module } from \"alepha\";\nimport { AlephaCache, CacheProvider } from \"alepha/cache\";\nimport { RedisCacheProvider } from \"./providers/RedisCacheProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/RedisCacheProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Cache that provides Redis caching capabilities.\n *\n * @see {@link RedisCacheProvider}\n * @module alepha.cache.redis\n */\nexport const AlephaCacheRedis = $module({\n  name: \"alepha.cache.redis\",\n  services: [RedisCacheProvider],\n  register: (alepha) =>\n    alepha\n      .with({\n        provide: CacheProvider,\n        use: RedisCacheProvider,\n        optional: true,\n      })\n      .with(AlephaCache),\n});\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/cache/redis/providers/RedisCacheProvider.ts","../../../src/cache/redis/index.ts"],"sourcesContent":["import { $atom, $inject, $state, Alepha, type Static, t } from \"alepha\";\nimport { CacheProvider } from \"alepha/cache\";\nimport { $logger } from \"alepha/logger\";\nimport { RedisProvider } from \"alepha/redis\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Redis cache configuration atom.\n */\nexport const redisCacheOptions = $atom({\n  name: \"alepha.cache.redis.options\",\n  schema: t.object({\n    prefix: t.optional(\n      t.text({\n        description:\n          \"Prefix for all cache keys in Redis. Useful for testing or multi-tenant applications.\",\n      }),\n    ),\n  }),\n  default: {},\n});\n\nexport type RedisCacheOptions = Static<typeof redisCacheOptions.schema>;\n\ndeclare module \"alepha\" {\n  interface State {\n    [redisCacheOptions.key]: RedisCacheOptions;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class RedisCacheProvider extends CacheProvider {\n  protected readonly log = $logger();\n  protected readonly redisProvider = $inject(RedisProvider);\n  protected readonly options = $state(redisCacheOptions);\n  protected readonly alepha = $inject(Alepha);\n\n  public async get(name: string, key: string): Promise<Uint8Array | undefined> {\n    if (!this.alepha.isStarted()) {\n      return;\n    }\n\n    const keyWithPrefix = this.prefix(name, key);\n    const buffer = await this.redisProvider.get(keyWithPrefix);\n    if (!buffer) {\n      return;\n    }\n\n    this.log.debug(`Cache hit`, {\n      size: buffer.byteLength,\n      key: keyWithPrefix,\n    });\n\n    return new Uint8Array(buffer);\n  }\n\n  public async set(\n    name: string,\n    key: string,\n    value: Uint8Array | string,\n    ttl?: number,\n  ): Promise<Uint8Array> {\n    if (!this.alepha.isReady()) {\n      return new Uint8Array(Buffer.from(value));\n    }\n\n    const buffer = Buffer.from(value);\n    const prefix = this.prefix(name, key);\n\n    if (ttl) {\n      return new Uint8Array(\n        await this.redisProvider.set(prefix, buffer, {\n          expiration: { type: \"PX\", value: ttl },\n        }),\n      );\n    }\n\n    return new Uint8Array(await this.redisProvider.set(prefix, buffer));\n  }\n\n  public async del(name: string, ...keys: string[]): Promise<void> {\n    const nameKey = this.prefix(name);\n\n    if (keys.length === 0) {\n      const matched = await this.redisProvider.keys(`${nameKey}:*`);\n      if (matched.length > 0) {\n        await this.redisProvider.del(matched);\n      }\n      return;\n    }\n\n    const prefixed = keys.map((key) =>\n      key.startsWith(nameKey) ? key : this.prefix(name, key),\n    );\n    if (prefixed.length > 0) {\n      await this.redisProvider.del(prefixed);\n    }\n  }\n\n  public async has(name: string, key: string): Promise<boolean> {\n    return this.redisProvider.has(this.prefix(name, key));\n  }\n\n  public async keys(name: string, filter?: string): Promise<string[]> {\n    if (filter) {\n      return await this.redisProvider.keys(`${this.prefix(name)}:${filter}*`);\n    }\n    return this.redisProvider.keys(`${this.prefix(name)}:*`);\n  }\n\n  public async clear(): Promise<void> {\n    this.log.debug(\"Clearing all cache\");\n    const pattern = `${this.prefix()}:*`;\n    const keys = await this.redisProvider.keys(pattern);\n    if (keys.length > 0) {\n      await this.redisProvider.del(keys);\n    }\n  }\n\n  public async incr(\n    name: string,\n    key: string,\n    amount: number,\n  ): Promise<number> {\n    const keyWithPrefix = this.prefix(name, key);\n    return this.redisProvider.incr(keyWithPrefix, amount);\n  }\n\n  protected prefix(...path: string[]): string {\n    const parts = [\"cache\", ...path];\n\n    if (this.options.prefix) {\n      parts.unshift(this.options.prefix);\n    }\n\n    return parts.join(\":\");\n  }\n}\n","import { $module } from \"alepha\";\nimport { AlephaCache, CacheProvider } from \"alepha/cache\";\nimport { RedisCacheProvider } from \"./providers/RedisCacheProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/RedisCacheProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Cache that provides Redis caching capabilities.\n *\n * @see {@link RedisCacheProvider}\n * @module alepha.cache.redis\n */\nexport const AlephaCacheRedis = $module({\n  name: \"alepha.cache.redis\",\n  services: [RedisCacheProvider],\n  register: (alepha) =>\n    alepha\n      .with({\n        provide: CacheProvider,\n        use: RedisCacheProvider,\n        optional: true,\n      })\n      .with(AlephaCache),\n});\n"],"mappings":"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"}

package/dist/captcha/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/captcha/providers/CaptchaProvider.ts","../../src/captcha/providers/MemoryCaptchaProvider.ts","../../src/captcha/providers/TurnstileCaptchaProvider.ts","../../src/captcha/index.ts"],"sourcesContent":["/**\n * Captcha verification provider interface.\n *\n * Verifies that a user-submitted captcha token is valid. Implementations\n * call the relevant captcha service (Turnstile, reCAPTCHA, hCaptcha, etc.)\n * to validate the token server-side.\n */\nexport abstract class CaptchaProvider {\n  /**\n   * Verify a captcha token.\n   *\n   * @param token - The captcha response token submitted by the client.\n   * @param ip - Optional client IP address for additional validation.\n   * @returns Whether the token is valid.\n   */\n  public abstract verify(token: string, ip?: string): Promise<boolean>;\n\n  /**\n   * Public site/widget key to hand to the browser, when applicable.\n   *\n   * Returns `undefined` for providers that don't need a client key\n   * (e.g. in-memory/test providers).\n   */\n  public getSiteKey(): string | undefined {\n    return undefined;\n  }\n}\n","import { $logger } from \"alepha/logger\";\nimport type { CaptchaProvider } from \"./CaptchaProvider.ts\";\n\nexport interface CaptchaRecord {\n  token: string;\n  ip?: string;\n  verifiedAt: Date;\n}\n\n/**\n * In-memory captcha provider for testing.\n *\n * Accepts all tokens by default. Use `reject()` to make verification fail,\n * and `accept()` to restore. All verification attempts are recorded for assertions.\n */\nexport class MemoryCaptchaProvider implements CaptchaProvider {\n  protected readonly log = $logger();\n\n  /**\n   * All verification attempts.\n   */\n  public records: CaptchaRecord[] = [];\n\n  protected shouldAccept = true;\n\n  public getSiteKey(): string | undefined {\n    return undefined;\n  }\n\n  public async verify(token: string, ip?: string): Promise<boolean> {\n    this.log.debug(\"Verifying captcha in memory store\", { token, ip });\n\n    this.records.push({\n      token,\n      ip,\n      verifiedAt: new Date(),\n    });\n\n    return this.shouldAccept;\n  }\n\n  /**\n   * Make all subsequent verifications fail.\n   */\n  public reject(): void {\n    this.shouldAccept = false;\n  }\n\n  /**\n   * Make all subsequent verifications pass (default behavior).\n   */\n  public accept(): void {\n    this.shouldAccept = true;\n  }\n\n  /**\n   * Whether a token was verified.\n   */\n  public wasVerified(token: string): boolean {\n    return this.records.some((r) => r.token === token);\n  }\n\n  /**\n   * Get the last verification attempt.\n   */\n  public get last(): CaptchaRecord | undefined {\n    return this.records[this.records.length - 1];\n  }\n}\n","import { $context, AlephaError, t } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport type { CaptchaProvider } from \"./CaptchaProvider.ts\";\n\n/**\n * Cloudflare Turnstile captcha verification provider.\n *\n * Validates captcha tokens against the Cloudflare Turnstile siteverify API.\n * Free, privacy-friendly, and supports invisible mode.\n *\n * ## Setup\n *\n * 1. Create a Turnstile widget at https://dash.cloudflare.com/?to=/:account/turnstile\n * 2. Copy the **Site Key** (public, for the client) and **Secret Key** (private, for the server)\n * 3. Set `TURNSTILE_SECRET_KEY` in your environment\n *\n * ## Client-side integration\n *\n * Add the Turnstile script and widget to your form:\n *\n * ```html\n * <script src=\"https://challenges.cloudflare.com/turnstile/v0/api.js\" async defer></script>\n * <form>\n *   <div class=\"cf-turnstile\" data-sitekey=\"YOUR_SITE_KEY\"></div>\n *   <button type=\"submit\">Submit</button>\n * </form>\n * ```\n *\n * The widget injects a hidden `cf-turnstile-response` input into the form.\n * Send this value as the `captchaToken` in your registration request.\n *\n * For explicit rendering (React, SPA):\n *\n * ```ts\n * turnstile.render(\"#container\", {\n *   sitekey: \"YOUR_SITE_KEY\",\n *   callback: (token) => setCaptchaToken(token),\n * });\n * ```\n *\n * ## Server-side usage\n *\n * Register the provider in your app:\n *\n * ```ts\n * import { CaptchaProvider } from \"alepha/captcha\";\n * import { TurnstileCaptchaProvider } from \"alepha/captcha\";\n *\n * alepha.with({ provide: CaptchaProvider, use: TurnstileCaptchaProvider });\n * ```\n *\n * ## Test keys (for development)\n *\n * - Always passes: site `1x00000000000000000000AA`, secret `1x0000000000000000000000000000000AA`\n * - Always blocks: site `2x00000000000000000000AB`, secret `2x0000000000000000000000000000000AB`\n * - Forces interactive: site `3x00000000000000000000FF`\n *\n * ## Environment Variables\n *\n * - `TURNSTILE_SECRET_KEY`: The secret key from the Cloudflare Turnstile dashboard.\n *\n * @see https://developers.cloudflare.com/turnstile/get-started/server-side-validation/\n */\nexport class TurnstileCaptchaProvider implements CaptchaProvider {\n  protected readonly log = $logger();\n  protected readonly secretKey: string;\n  protected readonly siteKey: string;\n\n  constructor() {\n    const { alepha } = $context();\n\n    const env = alepha.parseEnv(\n      t.object({\n        TURNSTILE_SECRET_KEY: t.text({\n          description:\n            \"The secret key from the Cloudflare Turnstile dashboard.\",\n        }),\n        TURNSTILE_SITE_KEY: t.text({\n          description:\n            \"The public site key from the Cloudflare Turnstile dashboard, rendered on the client.\",\n        }),\n      }),\n    );\n\n    this.secretKey = env.TURNSTILE_SECRET_KEY;\n    this.siteKey = env.TURNSTILE_SITE_KEY;\n  }\n\n  public getSiteKey(): string {\n    return this.siteKey;\n  }\n\n  public async verify(token: string, ip?: string): Promise<boolean> {\n    const body = new URLSearchParams();\n    body.set(\"secret\", this.secretKey);\n    body.set(\"response\", token);\n\n    if (ip) {\n      body.set(\"remoteip\", ip);\n    }\n\n    try {\n      const res = await fetch(\n        \"https://challenges.cloudflare.com/turnstile/v0/siteverify\",\n        {\n          method: \"POST\",\n          body,\n        },\n      );\n\n      const data = (await res.json()) as TurnstileResponse;\n\n      if (!data.success) {\n        this.log.debug(\"Turnstile verification failed\", {\n          errorCodes: data[\"error-codes\"],\n        });\n      }\n\n      return data.success;\n    } catch (error) {\n      throw new AlephaError(\"Failed to verify Turnstile captcha token\", {\n        cause: error,\n      });\n    }\n  }\n}\n\ninterface TurnstileResponse {\n  success: boolean;\n  \"error-codes\"?: string[];\n  challenge_ts?: string;\n  hostname?: string;\n  action?: string;\n  cdata?: string;\n}\n","import { $module } from \"alepha\";\nimport { CaptchaProvider } from \"./providers/CaptchaProvider.ts\";\nimport { MemoryCaptchaProvider } from \"./providers/MemoryCaptchaProvider.ts\";\nimport { TurnstileCaptchaProvider } from \"./providers/TurnstileCaptchaProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/CaptchaProvider.ts\";\nexport * from \"./providers/MemoryCaptchaProvider.ts\";\nexport * from \"./providers/TurnstileCaptchaProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Captcha verification for bot protection.\n *\n * **Features:**\n * - Provider abstraction for captcha services\n * - Cloudflare Turnstile support (free, privacy-friendly)\n * - In-memory provider for testing\n *\n * @module alepha.captcha\n */\nexport const AlephaCaptcha = $module({\n  name: \"alepha.captcha\",\n  services: [CaptchaProvider],\n  variants: [MemoryCaptchaProvider, TurnstileCaptchaProvider],\n  register: (alepha) =>\n    alepha.with({\n      optional: true,\n      provide: CaptchaProvider,\n      use: MemoryCaptchaProvider,\n    }),\n});\n"],"mappings":";;;;;;;;;;AAOA,IAAsB,kBAAtB,MAAsC;;;;;;;CAgBpC,aAAwC;;;;;;;;;;ACR1C,IAAa,wBAAb,MAA8D;CAC5D,MAAyB,SAAS;;;;CAKlC,UAAkC,EAAE;CAEpC,eAAyB;CAEzB,aAAwC;CAIxC,MAAa,OAAO,OAAe,IAA+B;AAChE,OAAK,IAAI,MAAM,qCAAqC;GAAE;GAAO;GAAI,CAAC;AAElE,OAAK,QAAQ,KAAK;GAChB;GACA;GACA,4BAAY,IAAI,MAAM;GACvB,CAAC;AAEF,SAAO,KAAK;;;;;CAMd,SAAsB;AACpB,OAAK,eAAe;;;;;CAMtB,SAAsB;AACpB,OAAK,eAAe;;;;;CAMtB,YAAmB,OAAwB;AACzC,SAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,MAAM;;;;;CAMpD,IAAW,OAAkC;AAC3C,SAAO,KAAK,QAAQ,KAAK,QAAQ,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACH9C,IAAa,2BAAb,MAAiE;CAC/D,MAAyB,SAAS;CAClC;CACA;CAEA,cAAc;EACZ,MAAM,EAAE,WAAW,UAAU;EAE7B,MAAM,MAAM,OAAO,SACjB,EAAE,OAAO;GACP,sBAAsB,EAAE,KAAK,EAC3B,aACE,2DACH,CAAC;GACF,oBAAoB,EAAE,KAAK,EACzB,aACE,wFACH,CAAC;GACH,CAAC,CACH;AAED,OAAK,YAAY,IAAI;AACrB,OAAK,UAAU,IAAI;;CAGrB,aAA4B;AAC1B,SAAO,KAAK;;CAGd,MAAa,OAAO,OAAe,IAA+B;EAChE,MAAM,OAAO,IAAI,iBAAiB;AAClC,OAAK,IAAI,UAAU,KAAK,UAAU;AAClC,OAAK,IAAI,YAAY,MAAM;AAE3B,MAAI,GACF,MAAK,IAAI,YAAY,GAAG;AAG1B,MAAI;GASF,MAAM,OAAQ,OAAM,MARF,MAChB,6DACA;IACE,QAAQ;IACR;IACD,CACF,EAEuB,MAAM;AAE9B,OAAI,CAAC,KAAK,QACR,MAAK,IAAI,MAAM,iCAAiC,EAC9C,YAAY,KAAK,gBAClB,CAAC;AAGJ,UAAO,KAAK;WACL,OAAO;AACd,SAAM,IAAI,YAAY,4CAA4C,EAChE,OAAO,OACR,CAAC;;;;;;;;;;;;;;;;ACnGR,MAAa,gBAAgB,QAAQ;CACnC,MAAM;CACN,UAAU,CAAC,gBAAgB;CAC3B,UAAU,CAAC,uBAAuB,yBAAyB;CAC3D,WAAW,WACT,OAAO,KAAK;EACV,UAAU;EACV,SAAS;EACT,KAAK;EACN,CAAC;CACL,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/captcha/providers/CaptchaProvider.ts","../../src/captcha/providers/MemoryCaptchaProvider.ts","../../src/captcha/providers/TurnstileCaptchaProvider.ts","../../src/captcha/index.ts"],"sourcesContent":["/**\n * Captcha verification provider interface.\n *\n * Verifies that a user-submitted captcha token is valid. Implementations\n * call the relevant captcha service (Turnstile, reCAPTCHA, hCaptcha, etc.)\n * to validate the token server-side.\n */\nexport abstract class CaptchaProvider {\n  /**\n   * Verify a captcha token.\n   *\n   * @param token - The captcha response token submitted by the client.\n   * @param ip - Optional client IP address for additional validation.\n   * @returns Whether the token is valid.\n   */\n  public abstract verify(token: string, ip?: string): Promise<boolean>;\n\n  /**\n   * Public site/widget key to hand to the browser, when applicable.\n   *\n   * Returns `undefined` for providers that don't need a client key\n   * (e.g. in-memory/test providers).\n   */\n  public getSiteKey(): string | undefined {\n    return undefined;\n  }\n}\n","import { $logger } from \"alepha/logger\";\nimport type { CaptchaProvider } from \"./CaptchaProvider.ts\";\n\nexport interface CaptchaRecord {\n  token: string;\n  ip?: string;\n  verifiedAt: Date;\n}\n\n/**\n * In-memory captcha provider for testing.\n *\n * Accepts all tokens by default. Use `reject()` to make verification fail,\n * and `accept()` to restore. All verification attempts are recorded for assertions.\n */\nexport class MemoryCaptchaProvider implements CaptchaProvider {\n  protected readonly log = $logger();\n\n  /**\n   * All verification attempts.\n   */\n  public records: CaptchaRecord[] = [];\n\n  protected shouldAccept = true;\n\n  public getSiteKey(): string | undefined {\n    return undefined;\n  }\n\n  public async verify(token: string, ip?: string): Promise<boolean> {\n    this.log.debug(\"Verifying captcha in memory store\", { token, ip });\n\n    this.records.push({\n      token,\n      ip,\n      verifiedAt: new Date(),\n    });\n\n    return this.shouldAccept;\n  }\n\n  /**\n   * Make all subsequent verifications fail.\n   */\n  public reject(): void {\n    this.shouldAccept = false;\n  }\n\n  /**\n   * Make all subsequent verifications pass (default behavior).\n   */\n  public accept(): void {\n    this.shouldAccept = true;\n  }\n\n  /**\n   * Whether a token was verified.\n   */\n  public wasVerified(token: string): boolean {\n    return this.records.some((r) => r.token === token);\n  }\n\n  /**\n   * Get the last verification attempt.\n   */\n  public get last(): CaptchaRecord | undefined {\n    return this.records[this.records.length - 1];\n  }\n}\n","import { $context, AlephaError, t } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport type { CaptchaProvider } from \"./CaptchaProvider.ts\";\n\n/**\n * Cloudflare Turnstile captcha verification provider.\n *\n * Validates captcha tokens against the Cloudflare Turnstile siteverify API.\n * Free, privacy-friendly, and supports invisible mode.\n *\n * ## Setup\n *\n * 1. Create a Turnstile widget at https://dash.cloudflare.com/?to=/:account/turnstile\n * 2. Copy the **Site Key** (public, for the client) and **Secret Key** (private, for the server)\n * 3. Set `TURNSTILE_SECRET_KEY` in your environment\n *\n * ## Client-side integration\n *\n * Add the Turnstile script and widget to your form:\n *\n * ```html\n * <script src=\"https://challenges.cloudflare.com/turnstile/v0/api.js\" async defer></script>\n * <form>\n *   <div class=\"cf-turnstile\" data-sitekey=\"YOUR_SITE_KEY\"></div>\n *   <button type=\"submit\">Submit</button>\n * </form>\n * ```\n *\n * The widget injects a hidden `cf-turnstile-response` input into the form.\n * Send this value as the `captchaToken` in your registration request.\n *\n * For explicit rendering (React, SPA):\n *\n * ```ts\n * turnstile.render(\"#container\", {\n *   sitekey: \"YOUR_SITE_KEY\",\n *   callback: (token) => setCaptchaToken(token),\n * });\n * ```\n *\n * ## Server-side usage\n *\n * Register the provider in your app:\n *\n * ```ts\n * import { CaptchaProvider } from \"alepha/captcha\";\n * import { TurnstileCaptchaProvider } from \"alepha/captcha\";\n *\n * alepha.with({ provide: CaptchaProvider, use: TurnstileCaptchaProvider });\n * ```\n *\n * ## Test keys (for development)\n *\n * - Always passes: site `1x00000000000000000000AA`, secret `1x0000000000000000000000000000000AA`\n * - Always blocks: site `2x00000000000000000000AB`, secret `2x0000000000000000000000000000000AB`\n * - Forces interactive: site `3x00000000000000000000FF`\n *\n * ## Environment Variables\n *\n * - `TURNSTILE_SECRET_KEY`: The secret key from the Cloudflare Turnstile dashboard.\n *\n * @see https://developers.cloudflare.com/turnstile/get-started/server-side-validation/\n */\nexport class TurnstileCaptchaProvider implements CaptchaProvider {\n  protected readonly log = $logger();\n  protected readonly secretKey: string;\n  protected readonly siteKey: string;\n\n  constructor() {\n    const { alepha } = $context();\n\n    const env = alepha.parseEnv(\n      t.object({\n        TURNSTILE_SECRET_KEY: t.text({\n          description:\n            \"The secret key from the Cloudflare Turnstile dashboard.\",\n        }),\n        TURNSTILE_SITE_KEY: t.text({\n          description:\n            \"The public site key from the Cloudflare Turnstile dashboard, rendered on the client.\",\n        }),\n      }),\n    );\n\n    this.secretKey = env.TURNSTILE_SECRET_KEY;\n    this.siteKey = env.TURNSTILE_SITE_KEY;\n  }\n\n  public getSiteKey(): string {\n    return this.siteKey;\n  }\n\n  public async verify(token: string, ip?: string): Promise<boolean> {\n    const body = new URLSearchParams();\n    body.set(\"secret\", this.secretKey);\n    body.set(\"response\", token);\n\n    if (ip) {\n      body.set(\"remoteip\", ip);\n    }\n\n    try {\n      const res = await fetch(\n        \"https://challenges.cloudflare.com/turnstile/v0/siteverify\",\n        {\n          method: \"POST\",\n          body,\n        },\n      );\n\n      const data = (await res.json()) as TurnstileResponse;\n\n      if (!data.success) {\n        this.log.debug(\"Turnstile verification failed\", {\n          errorCodes: data[\"error-codes\"],\n        });\n      }\n\n      return data.success;\n    } catch (error) {\n      throw new AlephaError(\"Failed to verify Turnstile captcha token\", {\n        cause: error,\n      });\n    }\n  }\n}\n\ninterface TurnstileResponse {\n  success: boolean;\n  \"error-codes\"?: string[];\n  challenge_ts?: string;\n  hostname?: string;\n  action?: string;\n  cdata?: string;\n}\n","import { $module } from \"alepha\";\nimport { CaptchaProvider } from \"./providers/CaptchaProvider.ts\";\nimport { MemoryCaptchaProvider } from \"./providers/MemoryCaptchaProvider.ts\";\nimport { TurnstileCaptchaProvider } from \"./providers/TurnstileCaptchaProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/CaptchaProvider.ts\";\nexport * from \"./providers/MemoryCaptchaProvider.ts\";\nexport * from \"./providers/TurnstileCaptchaProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Captcha verification for bot protection.\n *\n * **Features:**\n * - Provider abstraction for captcha services\n * - Cloudflare Turnstile support (free, privacy-friendly)\n * - In-memory provider for testing\n *\n * @module alepha.captcha\n */\nexport const AlephaCaptcha = $module({\n  name: \"alepha.captcha\",\n  services: [CaptchaProvider],\n  variants: [MemoryCaptchaProvider, TurnstileCaptchaProvider],\n  register: (alepha) =>\n    alepha.with({\n      optional: true,\n      provide: CaptchaProvider,\n      use: MemoryCaptchaProvider,\n    }),\n});\n"],"mappings":";;;;;;;;;;AAOA,IAAsB,kBAAtB,MAAsC;;;;;;;CAgBpC,aAAwC;;;;;;;;;;ACR1C,IAAa,wBAAb,MAA8D;CAC5D,MAAyB,SAAS;;;;CAKlC,UAAkC,EAAE;CAEpC,eAAyB;CAEzB,aAAwC;CAIxC,MAAa,OAAO,OAAe,IAA+B;EAChE,KAAK,IAAI,MAAM,qCAAqC;GAAE;GAAO;GAAI,CAAC;EAElE,KAAK,QAAQ,KAAK;GAChB;GACA;GACA,4BAAY,IAAI,MAAM;GACvB,CAAC;EAEF,OAAO,KAAK;;;;;CAMd,SAAsB;EACpB,KAAK,eAAe;;;;;CAMtB,SAAsB;EACpB,KAAK,eAAe;;;;;CAMtB,YAAmB,OAAwB;EACzC,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,MAAM;;;;;CAMpD,IAAW,OAAkC;EAC3C,OAAO,KAAK,QAAQ,KAAK,QAAQ,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACH9C,IAAa,2BAAb,MAAiE;CAC/D,MAAyB,SAAS;CAClC;CACA;CAEA,cAAc;EACZ,MAAM,EAAE,WAAW,UAAU;EAE7B,MAAM,MAAM,OAAO,SACjB,EAAE,OAAO;GACP,sBAAsB,EAAE,KAAK,EAC3B,aACE,2DACH,CAAC;GACF,oBAAoB,EAAE,KAAK,EACzB,aACE,wFACH,CAAC;GACH,CAAC,CACH;EAED,KAAK,YAAY,IAAI;EACrB,KAAK,UAAU,IAAI;;CAGrB,aAA4B;EAC1B,OAAO,KAAK;;CAGd,MAAa,OAAO,OAAe,IAA+B;EAChE,MAAM,OAAO,IAAI,iBAAiB;EAClC,KAAK,IAAI,UAAU,KAAK,UAAU;EAClC,KAAK,IAAI,YAAY,MAAM;EAE3B,IAAI,IACF,KAAK,IAAI,YAAY,GAAG;EAG1B,IAAI;GASF,MAAM,OAAQ,OAAM,MARF,MAChB,6DACA;IACE,QAAQ;IACR;IACD,CACF,EAEuB,MAAM;GAE9B,IAAI,CAAC,KAAK,SACR,KAAK,IAAI,MAAM,iCAAiC,EAC9C,YAAY,KAAK,gBAClB,CAAC;GAGJ,OAAO,KAAK;WACL,OAAO;GACd,MAAM,IAAI,YAAY,4CAA4C,EAChE,OAAO,OACR,CAAC;;;;;;;;;;;;;;;;ACnGR,MAAa,gBAAgB,QAAQ;CACnC,MAAM;CACN,UAAU,CAAC,gBAAgB;CAC3B,UAAU,CAAC,uBAAuB,yBAAyB;CAC3D,WAAW,WACT,OAAO,KAAK;EACV,UAAU;EACV,SAAS;EACT,KAAK;EACN,CAAC;CACL,CAAC"}

package/dist/cli/config/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/cli/config/defineConfig.ts"],"sourcesContent":["import type { Alepha, Service } from \"alepha\";\nimport {\n  type AppEntryOptions,\n  appEntryOptions,\n  type BuildOptions,\n  buildOptions,\n  type DevOptions,\n  devOptions,\n} from \"alepha/cli\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface AlephaCliConfig {\n  /**\n   * Override entry paths.\n   */\n  entry?: AppEntryOptions;\n\n  /**\n   * Register more services to the Alepha CLI (enhancements, commands, etc.).\n   */\n  services?: Array<Service>;\n\n  /**\n   * @alias services Register more services to the Alepha CLI (enhancements, commands, etc.).\n   */\n  plugins?: Array<Service>;\n\n  /**\n   * Configure Alepha build command.\n   */\n  build?: BuildOptions;\n\n  /**\n   * Configure Alepha dev command.\n   */\n  dev?: DevOptions;\n\n  /**\n   * Environment variables to set before running commands.\n   *\n   * Always use .env files by default, this is only for dynamic values.\n   */\n  env?: Record<string, unknown>;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport const defineConfig = (config: AlephaCliConfig) => {\n  return (alepha: Alepha) => {\n    if (config.services) {\n      for (const it of config.services) {\n        alepha.with(it);\n      }\n    }\n\n    if (config.plugins) {\n      for (const it of config.plugins) {\n        alepha.with(it);\n      }\n    }\n\n    if (config.env) {\n      for (const [key, value] of Object.entries(config.env)) {\n        process.env[key] = String(value);\n      }\n    }\n\n    if (config.build) {\n      alepha.set(buildOptions, config.build);\n    }\n\n    if (config.dev) {\n      alepha.set(devOptions, config.dev);\n    }\n\n    if (config.entry) {\n      alepha.set(appEntryOptions, config.entry);\n    }\n\n    return {};\n  };\n};\n"],"mappings":";;AAgDA,MAAa,gBAAgB,WAA4B;AACvD,SAAQ,WAAmB;AACzB,MAAI,OAAO,SACT,MAAK,MAAM,MAAM,OAAO,SACtB,QAAO,KAAK,GAAG;AAInB,MAAI,OAAO,QACT,MAAK,MAAM,MAAM,OAAO,QACtB,QAAO,KAAK,GAAG;AAInB,MAAI,OAAO,IACT,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,IAAI,CACnD,SAAQ,IAAI,OAAO,OAAO,MAAM;AAIpC,MAAI,OAAO,MACT,QAAO,IAAI,cAAc,OAAO,MAAM;AAGxC,MAAI,OAAO,IACT,QAAO,IAAI,YAAY,OAAO,IAAI;AAGpC,MAAI,OAAO,MACT,QAAO,IAAI,iBAAiB,OAAO,MAAM;AAG3C,SAAO,EAAE"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/cli/config/defineConfig.ts"],"sourcesContent":["import type { Alepha, Service } from \"alepha\";\nimport {\n  type AppEntryOptions,\n  appEntryOptions,\n  type BuildOptions,\n  buildOptions,\n  type DevOptions,\n  devOptions,\n} from \"alepha/cli\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface AlephaCliConfig {\n  /**\n   * Override entry paths.\n   */\n  entry?: AppEntryOptions;\n\n  /**\n   * Register more services to the Alepha CLI (enhancements, commands, etc.).\n   */\n  services?: Array<Service>;\n\n  /**\n   * @alias services Register more services to the Alepha CLI (enhancements, commands, etc.).\n   */\n  plugins?: Array<Service>;\n\n  /**\n   * Configure Alepha build command.\n   */\n  build?: BuildOptions;\n\n  /**\n   * Configure Alepha dev command.\n   */\n  dev?: DevOptions;\n\n  /**\n   * Environment variables to set before running commands.\n   *\n   * Always use .env files by default, this is only for dynamic values.\n   */\n  env?: Record<string, unknown>;\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport const defineConfig = (config: AlephaCliConfig) => {\n  return (alepha: Alepha) => {\n    if (config.services) {\n      for (const it of config.services) {\n        alepha.with(it);\n      }\n    }\n\n    if (config.plugins) {\n      for (const it of config.plugins) {\n        alepha.with(it);\n      }\n    }\n\n    if (config.env) {\n      for (const [key, value] of Object.entries(config.env)) {\n        process.env[key] = String(value);\n      }\n    }\n\n    if (config.build) {\n      alepha.set(buildOptions, config.build);\n    }\n\n    if (config.dev) {\n      alepha.set(devOptions, config.dev);\n    }\n\n    if (config.entry) {\n      alepha.set(appEntryOptions, config.entry);\n    }\n\n    return {};\n  };\n};\n"],"mappings":";;AAgDA,MAAa,gBAAgB,WAA4B;CACvD,QAAQ,WAAmB;EACzB,IAAI,OAAO,UACT,KAAK,MAAM,MAAM,OAAO,UACtB,OAAO,KAAK,GAAG;EAInB,IAAI,OAAO,SACT,KAAK,MAAM,MAAM,OAAO,SACtB,OAAO,KAAK,GAAG;EAInB,IAAI,OAAO,KACT,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,IAAI,EACnD,QAAQ,IAAI,OAAO,OAAO,MAAM;EAIpC,IAAI,OAAO,OACT,OAAO,IAAI,cAAc,OAAO,MAAM;EAGxC,IAAI,OAAO,KACT,OAAO,IAAI,YAAY,OAAO,IAAI;EAGpC,IAAI,OAAO,OACT,OAAO,IAAI,iBAAiB,OAAO,MAAM;EAG3C,OAAO,EAAE"}