@classytic/arc 1.1.0 → 2.1.3

package/dist/fields-CTd_CrKr.mjs

@@ -0,0 +1,114 @@
+//#region src/permissions/fields.ts
+/**
+* Field-Level Permissions
+*
+* Control field visibility and writability per role.
+* Integrated into the response path (read) and sanitization path (write).
+*
+* @example
+* ```typescript
+* import { fields, defineResource } from '@classytic/arc';
+*
+* const userResource = defineResource({
+*   name: 'user',
+*   adapter: userAdapter,
+*   fields: {
+*     salary: fields.visibleTo(['admin', 'hr']),
+*     internalNotes: fields.writableBy(['admin']),
+*     email: fields.redactFor(['viewer']),
+*     password: fields.hidden(),
+*   },
+* });
+* ```
+*/
+/** Type guard for Mongoose-like documents with toObject() */
+function isMongooseDoc(obj) {
+	return !!obj && typeof obj === "object" && "toObject" in obj && typeof obj.toObject === "function";
+}
+const fields = {
+	hidden() {
+		return { _type: "hidden" };
+	},
+	visibleTo(roles) {
+		return {
+			_type: "visibleTo",
+			roles
+		};
+	},
+	writableBy(roles) {
+		return {
+			_type: "writableBy",
+			roles
+		};
+	},
+	redactFor(roles, redactValue = "***") {
+		return {
+			_type: "redactFor",
+			roles,
+			redactValue
+		};
+	}
+};
+/**
+* Apply field-level READ permissions to a response object.
+* Strips hidden fields, enforces visibility, and applies redaction.
+*
+* @param data - The response object (mutated in place for performance)
+* @param fieldPermissions - Field permission map from resource config
+* @param userRoles - Current user's roles (empty array for unauthenticated)
+* @returns The filtered object
+*/
+function applyFieldReadPermissions(data, fieldPermissions, userRoles) {
+	if (!data || typeof data !== "object") return data;
+	const result = { ...isMongooseDoc(data) ? data.toObject() : data };
+	for (const [field, perm] of Object.entries(fieldPermissions)) switch (perm._type) {
+		case "hidden":
+			delete result[field];
+			break;
+		case "visibleTo":
+			if (!perm.roles?.some((r) => userRoles.includes(r))) delete result[field];
+			break;
+		case "redactFor":
+			if (perm.roles?.some((r) => userRoles.includes(r))) result[field] = perm.redactValue ?? "***";
+			break;
+		case "writableBy": break;
+	}
+	return result;
+}
+/**
+* Apply field-level WRITE permissions to request body.
+* Strips fields that the user doesn't have permission to write.
+*
+* @param body - The request body (returns a new filtered copy)
+* @param fieldPermissions - Field permission map from resource config
+* @param userRoles - Current user's roles
+* @returns Filtered body
+*/
+function applyFieldWritePermissions(body, fieldPermissions, userRoles) {
+	const result = { ...body };
+	for (const [field, perm] of Object.entries(fieldPermissions)) switch (perm._type) {
+		case "hidden":
+			delete result[field];
+			break;
+		case "writableBy":
+			if (field in result && !perm.roles?.some((r) => userRoles.includes(r))) delete result[field];
+			break;
+	}
+	return result;
+}
+/**
+* Resolve effective roles by merging global user roles with org-level roles.
+*
+* Global roles come from `req.user.role` (normalized via getUserRoles()).
+* Org roles come from `req.context.orgRoles` (set by BA adapter's org bridge).
+*
+* When no org context exists, returns global roles only — backward compatible.
+*/
+function resolveEffectiveRoles(userRoles, orgRoles) {
+	if (orgRoles.length === 0) return [...userRoles];
+	if (userRoles.length === 0) return [...orgRoles];
+	return [...new Set([...userRoles, ...orgRoles])];
+}
+
+//#endregion
+export { resolveEffectiveRoles as i, applyFieldWritePermissions as n, fields as r, applyFieldReadPermissions as t };

package/dist/hooks/index.d.mts

@@ -0,0 +1,4 @@
+import "../elevation-DGo5shaX.mjs";
+import { $ as beforeUpdate, B as DefineHookOptions, G as HookRegistration, H as HookHandler, J as afterCreate, K as HookSystem, Q as beforeDelete, U as HookOperation, V as HookContext, W as HookPhase, X as afterUpdate, Y as afterDelete, Z as beforeCreate, et as createHookSystem, q as HookSystemOptions, tt as defineHook } from "../interface-e9XfSsUV.mjs";
+import "../types-RLkFVgaw.mjs";
+export { type DefineHookOptions, type HookContext, type HookHandler, type HookOperation, type HookPhase, type HookRegistration, HookSystem, type HookSystemOptions, afterCreate, afterDelete, afterUpdate, beforeCreate, beforeDelete, beforeUpdate, createHookSystem, defineHook };

package/dist/hooks/index.mjs

@@ -0,0 +1,3 @@
+import { a as beforeCreate, c as createHookSystem, i as afterUpdate, l as defineHook, n as afterCreate, o as beforeDelete, r as afterDelete, s as beforeUpdate, t as HookSystem } from "../HookSystem-BsGV-j2l.mjs";
+
+export { HookSystem, afterCreate, afterDelete, afterUpdate, beforeCreate, beforeDelete, beforeUpdate, createHookSystem, defineHook };

package/dist/idempotency/index.d.mts

@@ -0,0 +1,96 @@
+import { i as createIdempotencyResult, n as IdempotencyResult, r as IdempotencyStore, t as IdempotencyLock } from "../interface-CSNjltAc.mjs";
+import { r as RedisIdempotencyStoreOptions, t as RedisClient } from "../redis-UwjEp8Ea.mjs";
+import { n as MongoIdempotencyStoreOptions } from "../mongodb-Dg8O_gvd.mjs";
+import { FastifyPluginAsync } from "fastify";
+
+//#region src/idempotency/idempotencyPlugin.d.ts
+interface IdempotencyPluginOptions {
+  /** Enable idempotency (default: false) */
+  enabled?: boolean;
+  /** Header name for idempotency key (default: 'idempotency-key') */
+  headerName?: string;
+  /** TTL for cached responses in ms (default: 86400000 = 24h) */
+  ttlMs?: number;
+  /** Lock timeout in ms (default: 30000 = 30s) */
+  lockTimeoutMs?: number;
+  /** HTTP methods to apply idempotency to (default: ['POST', 'PUT', 'PATCH']) */
+  methods?: string[];
+  /** URL patterns to include (regex). If set, only matching URLs use idempotency */
+  include?: RegExp[];
+  /** URL patterns to exclude (regex). Excluded patterns take precedence */
+  exclude?: RegExp[];
+  /** Custom store (default: MemoryIdempotencyStore) */
+  store?: IdempotencyStore;
+  /** Retry-After header value in seconds when request is in-flight (default: 1) */
+  retryAfterSeconds?: number;
+}
+declare module 'fastify' {
+  interface FastifyRequest {
+    /** The idempotency key for this request (if present) */
+    idempotencyKey?: string;
+    /** Whether this response was replayed from cache */
+    idempotencyReplayed?: boolean;
+    /** @internal Full key with fingerprint for store lookups */
+    _idempotencyFullKey?: string;
+  }
+  interface FastifyInstance {
+    /** Idempotency utilities */
+    idempotency: {
+      /** Manually invalidate an idempotency key */invalidate: (key: string) => Promise<void>; /** Check if a key has a cached response */
+      has: (key: string) => Promise<boolean>;
+      /**
+       * Route-level preHandler for idempotency check + lock.
+       * Wire AFTER authenticate in the preHandler chain so that
+       * `request.user` is populated before the fingerprint is computed.
+       *
+       * `createCrudRouter` injects this automatically for mutation routes.
+       * For custom routes, add it manually:
+       * ```typescript
+       * fastify.post('/orders', {
+       *   preHandler: [fastify.authenticate, fastify.idempotency.middleware],
+       * }, handler);
+       * ```
+       */
+      middleware: (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+    };
+  }
+}
+declare const idempotencyPlugin: FastifyPluginAsync<IdempotencyPluginOptions>;
+declare const _default: FastifyPluginAsync<IdempotencyPluginOptions>;
+//#endregion
+//#region src/idempotency/stores/memory.d.ts
+interface MemoryIdempotencyStoreOptions {
+  /** Default TTL in milliseconds (default: 86400000 = 24h) */
+  ttlMs?: number;
+  /** Cleanup interval in milliseconds (default: 60000 = 1 min) */
+  cleanupIntervalMs?: number;
+  /** Maximum entries before oldest are evicted (default: 10000) */
+  maxEntries?: number;
+}
+declare class MemoryIdempotencyStore implements IdempotencyStore {
+  readonly name = "memory";
+  private results;
+  private locks;
+  private ttlMs;
+  private maxEntries;
+  private cleanupInterval;
+  constructor(options?: MemoryIdempotencyStoreOptions);
+  get(key: string): Promise<IdempotencyResult | undefined>;
+  set(key: string, result: Omit<IdempotencyResult, 'key'>): Promise<void>;
+  tryLock(key: string, requestId: string, ttlMs: number): Promise<boolean>;
+  unlock(key: string, requestId: string): Promise<void>;
+  isLocked(key: string): Promise<boolean>;
+  delete(key: string): Promise<void>;
+  deleteByPrefix(prefix: string): Promise<number>;
+  findByPrefix(prefix: string): Promise<IdempotencyResult | undefined>;
+  close(): Promise<void>;
+  /** Get current stats (for debugging/monitoring) */
+  getStats(): {
+    results: number;
+    locks: number;
+  };
+  private cleanup;
+  private evictOldest;
+}
+//#endregion
+export { type IdempotencyLock, type IdempotencyPluginOptions, type IdempotencyResult, type IdempotencyStore, MemoryIdempotencyStore, type MemoryIdempotencyStoreOptions, type MongoIdempotencyStoreOptions, type RedisClient, type RedisIdempotencyStoreOptions, createIdempotencyResult, _default as idempotencyPlugin, idempotencyPlugin as idempotencyPluginFn };

package/dist/idempotency/index.mjs

@@ -0,0 +1,319 @@
+import fp from "fastify-plugin";
+import { createHash } from "crypto";
+
+//#region src/idempotency/stores/interface.ts
+/**
+* Helper to create a result object
+*/
+function createIdempotencyResult(statusCode, body, headers, ttlMs) {
+	const now = /* @__PURE__ */ new Date();
+	return {
+		statusCode,
+		headers,
+		body,
+		createdAt: now,
+		expiresAt: new Date(now.getTime() + ttlMs)
+	};
+}
+
+//#endregion
+//#region src/idempotency/stores/memory.ts
+var MemoryIdempotencyStore = class {
+	name = "memory";
+	results = /* @__PURE__ */ new Map();
+	locks = /* @__PURE__ */ new Map();
+	ttlMs;
+	maxEntries;
+	cleanupInterval = null;
+	constructor(options = {}) {
+		this.ttlMs = options.ttlMs ?? 864e5;
+		this.maxEntries = options.maxEntries ?? 1e4;
+		const cleanupIntervalMs = options.cleanupIntervalMs ?? 6e4;
+		this.cleanupInterval = setInterval(() => {
+			this.cleanup();
+		}, cleanupIntervalMs);
+		if (this.cleanupInterval.unref) this.cleanupInterval.unref();
+	}
+	async get(key) {
+		const result = this.results.get(key);
+		if (!result) return void 0;
+		if (/* @__PURE__ */ new Date() > result.expiresAt) {
+			this.results.delete(key);
+			return;
+		}
+		return result;
+	}
+	async set(key, result) {
+		if (this.results.size >= this.maxEntries) this.evictOldest();
+		this.results.set(key, {
+			...result,
+			key
+		});
+	}
+	async tryLock(key, requestId, ttlMs) {
+		const existing = this.locks.get(key);
+		if (existing) if (/* @__PURE__ */ new Date() > existing.expiresAt) this.locks.delete(key);
+		else return false;
+		this.locks.set(key, {
+			key,
+			requestId,
+			lockedAt: /* @__PURE__ */ new Date(),
+			expiresAt: new Date(Date.now() + ttlMs)
+		});
+		return true;
+	}
+	async unlock(key, requestId) {
+		const lock = this.locks.get(key);
+		if (lock && lock.requestId === requestId) this.locks.delete(key);
+	}
+	async isLocked(key) {
+		const lock = this.locks.get(key);
+		if (!lock) return false;
+		if (/* @__PURE__ */ new Date() > lock.expiresAt) {
+			this.locks.delete(key);
+			return false;
+		}
+		return true;
+	}
+	async delete(key) {
+		this.results.delete(key);
+		this.locks.delete(key);
+	}
+	async deleteByPrefix(prefix) {
+		let count = 0;
+		for (const key of this.results.keys()) if (key.startsWith(prefix)) {
+			this.results.delete(key);
+			count++;
+		}
+		for (const key of this.locks.keys()) if (key.startsWith(prefix)) this.locks.delete(key);
+		return count;
+	}
+	async findByPrefix(prefix) {
+		const now = /* @__PURE__ */ new Date();
+		for (const [key, result] of this.results) if (key.startsWith(prefix)) {
+			if (now > result.expiresAt) {
+				this.results.delete(key);
+				continue;
+			}
+			return result;
+		}
+	}
+	async close() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = null;
+		}
+		this.results.clear();
+		this.locks.clear();
+	}
+	/** Get current stats (for debugging/monitoring) */
+	getStats() {
+		return {
+			results: this.results.size,
+			locks: this.locks.size
+		};
+	}
+	cleanup() {
+		const now = /* @__PURE__ */ new Date();
+		for (const [key, result] of this.results) if (now > result.expiresAt) this.results.delete(key);
+		for (const [key, lock] of this.locks) if (now > lock.expiresAt) this.locks.delete(key);
+	}
+	evictOldest() {
+		const entries = Array.from(this.results.entries()).sort((a, b) => a[1].createdAt.getTime() - b[1].createdAt.getTime());
+		const toRemove = Math.max(1, Math.floor(entries.length * .1));
+		for (let i = 0; i < toRemove; i++) {
+			const entry = entries[i];
+			if (entry) this.results.delete(entry[0]);
+		}
+	}
+};
+
+//#endregion
+//#region src/idempotency/idempotencyPlugin.ts
+/**
+* Idempotency Plugin
+*
+* Duplicate request protection for mutating operations.
+* Uses idempotency keys to ensure safe retries.
+*
+* ## Auth Safety
+*
+* The idempotency check runs as a **route-level middleware**
+* (`idempotency.middleware`) that must be wired AFTER authentication in the
+* preHandler chain. This ensures the fingerprint includes the real caller
+* identity, preventing cross-user replay attacks.
+*
+* Arc's `createCrudRouter` does this automatically for mutation routes.
+* For custom routes, wire it manually:
+*
+* ```typescript
+* fastify.post('/orders', {
+*   preHandler: [fastify.authenticate, fastify.idempotency.middleware],
+* }, handler);
+* ```
+*
+* @example
+* import { idempotencyPlugin } from '@classytic/arc/idempotency';
+*
+* await fastify.register(idempotencyPlugin, {
+*   enabled: true,
+*   headerName: 'idempotency-key',
+*   ttlMs: 86400000, // 24 hours
+* });
+*
+* // Client sends:
+* // POST /api/orders
+* // Idempotency-Key: order-123-abc
+*
+* // If same key sent again within TTL, returns cached response
+*/
+const HEADER_IDEMPOTENCY_REPLAYED = "x-idempotency-replayed";
+const HEADER_IDEMPOTENCY_KEY = "x-idempotency-key";
+const idempotencyPlugin = async (fastify, opts = {}) => {
+	const { enabled = false, headerName = "idempotency-key", ttlMs = 864e5, lockTimeoutMs = 3e4, methods = [
+		"POST",
+		"PUT",
+		"PATCH"
+	], include, exclude, store = new MemoryIdempotencyStore({ ttlMs }), retryAfterSeconds = 1 } = opts;
+	if (!enabled) {
+		fastify.decorate("idempotency", {
+			invalidate: async () => {},
+			has: async () => false,
+			middleware: async () => {}
+		});
+		fastify.decorateRequest("idempotencyKey", void 0);
+		fastify.decorateRequest("idempotencyReplayed", false);
+		fastify.log?.debug?.("Idempotency plugin disabled");
+		return;
+	}
+	const methodSet = new Set(methods.map((m) => m.toUpperCase()));
+	fastify.decorateRequest("idempotencyKey", void 0);
+	fastify.decorateRequest("idempotencyReplayed", false);
+	/**
+	* Check if this request should use idempotency
+	*/
+	function shouldApplyIdempotency(request) {
+		if (!methodSet.has(request.method)) return false;
+		const url = request.url;
+		if (exclude?.some((pattern) => pattern.test(url))) return false;
+		if (include && !include.some((pattern) => pattern.test(url))) return false;
+		return true;
+	}
+	/**
+	* Normalize body for consistent hashing (sort keys recursively)
+	*/
+	function normalizeBody(obj) {
+		if (obj === null || typeof obj !== "object") return obj;
+		if (Array.isArray(obj)) return obj.map(normalizeBody);
+		const sorted = {};
+		const keys = Object.keys(obj).sort();
+		for (const key of keys) sorted[key] = normalizeBody(obj[key]);
+		return sorted;
+	}
+	/**
+	* Generate a fingerprint for the request (for key generation).
+	* Includes caller identity so the same idempotency key from different
+	* users doesn't replay one user's response to another.
+	*
+	* IMPORTANT: This must be called AFTER auth has populated request.user,
+	* otherwise userId falls back to 'anon' and cross-user replay is possible.
+	*/
+	function getRequestFingerprint(request) {
+		let bodyHash = "nobody";
+		if (request.body && typeof request.body === "object") {
+			const normalized = normalizeBody(request.body);
+			const bodyString = JSON.stringify(normalized);
+			bodyHash = createHash("sha256").update(bodyString).digest("hex").substring(0, 16);
+			if (request.log && request.log.debug) request.log.debug({ bodyHash }, "Generated body hash");
+		}
+		const user = request.user;
+		const userId = user?.id ?? user?._id ?? "anon";
+		return `${request.method}:${request.url}:${bodyHash}:u=${userId}`;
+	}
+	const idempotencyMiddleware = async (request, reply) => {
+		if (!shouldApplyIdempotency(request)) return;
+		const keyHeader = request.headers[headerName.toLowerCase()];
+		const idempotencyKey = typeof keyHeader === "string" ? keyHeader.trim() : void 0;
+		if (!idempotencyKey) return;
+		request.idempotencyKey = idempotencyKey;
+		const fullKey = `${idempotencyKey}:${getRequestFingerprint(request)}`;
+		const cached = await store.get(fullKey);
+		if (cached) {
+			request.idempotencyReplayed = true;
+			reply.header(HEADER_IDEMPOTENCY_REPLAYED, "true");
+			reply.header(HEADER_IDEMPOTENCY_KEY, idempotencyKey);
+			for (const [key, value] of Object.entries(cached.headers)) if (!key.startsWith("x-idempotency")) reply.header(key, value);
+			reply.code(cached.statusCode).send(cached.body);
+			return;
+		}
+		if (!await store.tryLock(fullKey, request.id, lockTimeoutMs)) {
+			reply.code(409).header("Retry-After", retryAfterSeconds.toString()).send({
+				error: "Request with this idempotency key is already in progress",
+				code: "IDEMPOTENCY_CONFLICT",
+				retryAfter: retryAfterSeconds
+			});
+			return;
+		}
+		request._idempotencyFullKey = fullKey;
+	};
+	fastify.decorate("idempotency", {
+		invalidate: async (key) => {
+			await store.deleteByPrefix(`${key}:`);
+		},
+		has: async (key) => {
+			return !!await store.findByPrefix(`${key}:`);
+		},
+		middleware: idempotencyMiddleware
+	});
+	fastify.addHook("onSend", async (request, reply, payload) => {
+		if (request.idempotencyReplayed) return payload;
+		const fullKey = request._idempotencyFullKey;
+		if (!fullKey) return payload;
+		const statusCode = reply.statusCode;
+		if (statusCode < 200 || statusCode >= 300) {
+			await store.unlock(fullKey, request.id);
+			return payload;
+		}
+		const headersToCache = {};
+		const excludeHeaders = new Set([
+			"content-length",
+			"transfer-encoding",
+			"connection",
+			"keep-alive",
+			"date",
+			"set-cookie"
+		]);
+		const rawHeaders = reply.getHeaders();
+		for (const [key, value] of Object.entries(rawHeaders)) if (!excludeHeaders.has(key.toLowerCase()) && typeof value === "string") headersToCache[key] = value;
+		let body;
+		try {
+			body = typeof payload === "string" ? JSON.parse(payload) : payload;
+		} catch {
+			body = payload;
+		}
+		const result = createIdempotencyResult(statusCode, body, headersToCache, ttlMs);
+		await store.set(fullKey, result);
+		await store.unlock(fullKey, request.id);
+		reply.header(HEADER_IDEMPOTENCY_KEY, request.idempotencyKey);
+		return payload;
+	});
+	fastify.addHook("onError", async (request) => {
+		const fullKey = request._idempotencyFullKey;
+		if (fullKey) await store.unlock(fullKey, request.id);
+	});
+	fastify.addHook("onClose", async () => {
+		await store.close?.();
+	});
+	fastify.log?.debug?.({
+		headerName,
+		ttlMs,
+		methods
+	}, "Idempotency plugin enabled");
+};
+var idempotencyPlugin_default = fp(idempotencyPlugin, {
+	name: "arc-idempotency",
+	fastify: "5.x"
+});
+
+//#endregion
+export { MemoryIdempotencyStore, createIdempotencyResult, idempotencyPlugin_default as idempotencyPlugin, idempotencyPlugin as idempotencyPluginFn };

package/dist/idempotency/mongodb.d.mts

@@ -0,0 +1,2 @@
+import { n as MongoIdempotencyStoreOptions, t as MongoIdempotencyStore } from "../mongodb-Dg8O_gvd.mjs";
+export { MongoIdempotencyStore, type MongoIdempotencyStoreOptions };

package/dist/idempotency/mongodb.mjs

@@ -0,0 +1,114 @@
+//#region src/idempotency/stores/mongodb.ts
+var MongoIdempotencyStore = class {
+	name = "mongodb";
+	connection;
+	collectionName;
+	ttlMs;
+	indexCreated = false;
+	constructor(options) {
+		this.connection = options.connection;
+		this.collectionName = options.collection ?? "arc_idempotency";
+		this.ttlMs = options.ttlMs ?? 864e5;
+		if (options.createIndex !== false) this.ensureIndex().catch((err) => {
+			console.warn("[MongoIdempotencyStore] Failed to create index:", err);
+		});
+	}
+	get collection() {
+		return this.connection.db.collection(this.collectionName);
+	}
+	async ensureIndex() {
+		if (this.indexCreated) return;
+		try {
+			await this.collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+			this.indexCreated = true;
+		} catch {
+			this.indexCreated = true;
+		}
+	}
+	async get(key) {
+		const doc = await this.collection.findOne({ _id: key });
+		if (!doc || !doc.result) return void 0;
+		if (new Date(doc.expiresAt) < /* @__PURE__ */ new Date()) return;
+		return {
+			key,
+			statusCode: doc.result.statusCode,
+			headers: doc.result.headers,
+			body: doc.result.body,
+			createdAt: new Date(doc.createdAt),
+			expiresAt: new Date(doc.expiresAt)
+		};
+	}
+	async set(key, result) {
+		await this.collection.updateOne({ _id: key }, {
+			$set: {
+				result: {
+					statusCode: result.statusCode,
+					headers: result.headers,
+					body: result.body
+				},
+				createdAt: result.createdAt,
+				expiresAt: result.expiresAt
+			},
+			$unset: { lock: "" }
+		}, { upsert: true });
+	}
+	async tryLock(key, requestId, ttlMs) {
+		const now = /* @__PURE__ */ new Date();
+		const expiresAt = new Date(now.getTime() + ttlMs);
+		try {
+			const result = await this.collection.updateOne({
+				_id: key,
+				$or: [{ lock: { $exists: false } }, { "lock.expiresAt": { $lt: now } }]
+			}, {
+				$set: { lock: {
+					requestId,
+					expiresAt
+				} },
+				$setOnInsert: {
+					createdAt: now,
+					expiresAt: new Date(now.getTime() + this.ttlMs)
+				}
+			}, { upsert: true });
+			return result.matchedCount === 1 || result.modifiedCount === 1;
+		} catch {
+			return false;
+		}
+	}
+	async unlock(key, requestId) {
+		await this.collection.updateOne({
+			_id: key,
+			"lock.requestId": requestId
+		}, { $unset: { lock: "" } });
+	}
+	async isLocked(key) {
+		const doc = await this.collection.findOne({ _id: key });
+		if (!doc || !doc.lock) return false;
+		return new Date(doc.lock.expiresAt) > /* @__PURE__ */ new Date();
+	}
+	async delete(key) {
+		await this.collection.deleteOne({ _id: key });
+	}
+	async deleteByPrefix(prefix) {
+		return (await this.collection.deleteMany({ _id: { $regex: `^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}` } })).deletedCount;
+	}
+	async findByPrefix(prefix) {
+		const doc = await this.collection.findOne({
+			_id: { $regex: `^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}` },
+			result: { $exists: true },
+			expiresAt: { $gt: /* @__PURE__ */ new Date() }
+		});
+		if (!doc || !doc.result) return void 0;
+		return {
+			key: doc._id,
+			statusCode: doc.result.statusCode,
+			headers: doc.result.headers,
+			body: doc.result.body,
+			createdAt: new Date(doc.createdAt),
+			expiresAt: new Date(doc.expiresAt)
+		};
+	}
+	async close() {}
+};
+
+//#endregion
+export { MongoIdempotencyStore };

package/dist/idempotency/redis.d.mts

@@ -0,0 +1,2 @@
+import { n as RedisIdempotencyStore, r as RedisIdempotencyStoreOptions, t as RedisClient } from "../redis-UwjEp8Ea.mjs";
+export { type RedisClient, RedisIdempotencyStore, type RedisIdempotencyStoreOptions };