@classytic/arc 2.10.3 → 2.10.8

package/dist/errorHandler-2ii4RIYr.d.mts

@@ -0,0 +1,114 @@
+import { FastifyInstance, FastifyRequest } from "fastify";
+
+//#region src/plugins/errorHandler.d.ts
+/** Class-based error mapper — maps thrown error instances to HTTP responses */
+interface ErrorMapper<T extends Error = Error> {
+  /**
+   * Error class to match. Checked at runtime via `instanceof` — the constructor
+   * arity/signature is not called by the plugin, so the signature is typed
+   * permissively to accept real-world error classes:
+   *
+   * - **Abstract classes** (e.g. base domain errors) — `abstract new` is accepted.
+   * - **Specific constructor signatures** (e.g. `new InvalidTransitionError(from, to, id?)`)
+   *   — `any[]` avoids forcing consumers to widen to `unknown[]` or cast.
+   *
+   * What matters for dispatch is the `instanceof` check, not the ctor shape.
+   */
+  type: abstract new (...args: any[]) => T;
+  /** Convert the error to an HTTP response shape */
+  toResponse: (error: T) => {
+    status: number;
+    code?: string;
+    message?: string;
+    details?: Record<string, unknown>;
+  };
+}
+interface ErrorHandlerOptions {
+  /**
+   * Include stack trace in error responses (default: false in production)
+   */
+  includeStack?: boolean;
+  /**
+   * Custom error callback for logging to external services
+   */
+  onError?: (error: Error, request: FastifyRequest) => void | Promise<void>;
+  /**
+   * Map specific error types to custom responses (by error.name string)
+   */
+  errorMap?: Record<string, {
+    statusCode: number;
+    code: string;
+    message?: string;
+  }>;
+  /**
+   * Class-based error mappers — checked via `instanceof`, highest priority.
+   *
+   * Register your domain error classes once; Arc auto-catches and maps them
+   * in every handler. Handlers just `throw` — no try/catch needed.
+   *
+   * @example
+   * ```typescript
+   * class AccountingError extends Error {
+   *   constructor(message: string, public status: number, public code: string) {
+   *     super(message);
+   *   }
+   * }
+   *
+   * const app = await createApp({
+   *   errorHandler: {
+   *     errorMappers: [
+   *       {
+   *         type: AccountingError,
+   *         toResponse: (err) => ({ status: err.status, code: err.code, message: err.message }),
+   *       },
+   *     ],
+   *   },
+   * });
+   *
+   * // Now handlers just throw:
+   * handler: async (req) => {
+   *   await ledger.post(id); // throws AccountingError → Arc maps to proper HTTP response
+   * }
+   * ```
+   */
+  errorMappers?: ErrorMapper[];
+  /**
+   * Classify an error as a duplicate-key / unique-constraint violation →
+   * mapped to `409 Conflict` with `code: "DUPLICATE_KEY"`.
+   *
+   * Mirrors `RepositoryLike.isDuplicateKeyError` for the Fastify layer: errors
+   * that escape a controller (custom routes, user hooks, raw driver calls)
+   * still land here, so the classifier is duplicated at the edge. Defaults
+   * cover MongoDB (`code 11000` / `codeName "DuplicateKey"`), Prisma
+   * (`code "P2002"`), and Postgres (`code "23505"`). Override to add other
+   * backends (DynamoDB `ConditionalCheckFailedException`, etc.) or to disable
+   * the built-in detection.
+   */
+  isDuplicateKeyError?: (err: unknown) => boolean;
+}
+/**
+ * Default duplicate-key detector covering the mainstream drivers arc sees
+ * most. Detection is strictly by known driver codes — never by message
+ * string matching — because false positives on dup-key silently mask real
+ * errors (WriteConflict, NotWritablePrimary, etc.) as 409s. For long-tail
+ * drivers (Neo4j, MSSQL, DynamoDB, custom kits), compose rather than
+ * replace:
+ *
+ * ```ts
+ * import { defaultIsDuplicateKeyError } from '@classytic/arc/plugins';
+ *
+ * errorHandler: {
+ *   isDuplicateKeyError: (err) =>
+ *     defaultIsDuplicateKeyError(err) || isNeo4jDupKey(err),
+ * }
+ * ```
+ *
+ * Drizzle apps get coverage transitively (Drizzle doesn't wrap driver
+ * errors — pg/mysql2/better-sqlite3 codes propagate as-is). Neon is
+ * Postgres-wire-compatible → `23505` covers `@neondatabase/serverless`.
+ */
+declare function defaultIsDuplicateKeyError(err: unknown): boolean;
+declare function errorHandlerPluginFn(fastify: FastifyInstance, options?: ErrorHandlerOptions): Promise<void>;
+declare const errorHandlerPlugin: typeof errorHandlerPluginFn;
+//#endregion
+export { errorHandlerPlugin as i, ErrorMapper as n, defaultIsDuplicateKeyError as r, ErrorHandlerOptions as t };

package/dist/{errorHandler-Bb49BvPD.mjs → errorHandler-CSxe7KIM.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { p as isArcError } from "./errors-D5c-5BJL.mjs";
+import { p as isArcError } from "./errors-BqdUDja_.mjs";
 import fp from "fastify-plugin";
 //#region src/plugins/errorHandler.ts
 var errorHandler_exports = /* @__PURE__ */ __exportAll({

package/dist/{eventPlugin-DCUjuiQT.mjs → eventPlugin-ByU4Cv0e.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { t as requestContext } from "./requestContext-xHIKedG6.mjs";
+import { t as requestContext } from "./requestContext-C38GskNt.mjs";
 import fp from "fastify-plugin";
 //#region src/events/EventTransport.ts
 /**

package/dist/{eventPlugin-CxWgpd6K.d.mts → eventPlugin-D1ThQ1Pp.d.mts}

@@ -1,4 +1,4 @@
-import { i as EventLogger, n as DomainEvent, o as EventTransport, r as EventHandler } from "./EventTransport-CUw5NNWe.mjs";
+import { i as EventLogger, n as DomainEvent, o as EventTransport, r as EventHandler } from "./EventTransport-CfVEGaEl.mjs";
 import { FastifyPluginAsync } from "fastify";
 
 //#region src/events/defineEvent.d.ts

package/dist/events/index.d.mts

@@ -1,8 +1,8 @@
-import { kt as RepositoryLike } from "../index-Cl0uoKd5.mjs";
-import { a as EventMeta, c as MemoryEventTransportOptions, d as createEvent, i as EventLogger, l as PublishManyResult, n as DomainEvent, o as EventTransport, r as EventHandler, s as MemoryEventTransport, t as DeadLetteredEvent, u as createChildEvent } from "../EventTransport-CUw5NNWe.mjs";
-import { a as withRetry, c as EventDefinitionOutput, d as EventSchema, f as ValidationResult, i as createDeadLetterPublisher, l as EventRegistry, m as defineEvent, n as eventPlugin, o as CustomValidator, p as createEventRegistry, r as RetryOptions, s as EventDefinitionInput, t as EventPluginOptions, u as EventRegistryOptions } from "../eventPlugin-CxWgpd6K.mjs";
+import { _n as RepositoryLike } from "../index-BGbpGVyM.mjs";
+import { a as EventMeta, c as MemoryEventTransportOptions, d as createEvent, i as EventLogger, l as PublishManyResult, n as DomainEvent, o as EventTransport, r as EventHandler, s as MemoryEventTransport, t as DeadLetteredEvent, u as createChildEvent } from "../EventTransport-CfVEGaEl.mjs";
+import { a as withRetry, c as EventDefinitionOutput, d as EventSchema, f as ValidationResult, i as createDeadLetterPublisher, l as EventRegistry, m as defineEvent, n as eventPlugin, o as CustomValidator, p as createEventRegistry, r as RetryOptions, s as EventDefinitionInput, t as EventPluginOptions, u as EventRegistryOptions } from "../eventPlugin-D1ThQ1Pp.mjs";
 import { RedisEventTransportOptions, RedisLike } from "./transports/redis.mjs";
-import { r as RedisStreamTransportOptions, t as RedisStreamLike } from "../redis-stream-CakIQmwR.mjs";
+import { r as RedisStreamTransportOptions, t as RedisStreamLike } from "../redis-stream-bkO88VHx.mjs";
 
 //#region src/events/eventTypes.d.ts
 /**

package/dist/events/index.mjs

@@ -1,5 +1,7 @@
-import { a as MemoryEventTransport, i as withRetry, o as createChildEvent, r as createDeadLetterPublisher, s as createEvent, t as eventPlugin } from "../eventPlugin-DCUjuiQT.mjs";
-import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-ZCSMJJAX.mjs";
+import { a as MemoryEventTransport, i as withRetry, o as createChildEvent, r as createDeadLetterPublisher, s as createEvent, t as eventPlugin } from "../eventPlugin-ByU4Cv0e.mjs";
+import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-DYYUQbQN.mjs";
+import { and, anyOf, eq, lte, ne, or } from "@classytic/repo-core/filter";
+import { update } from "@classytic/repo-core/update";
 //#region src/events/defineEvent.ts
 /**
 * defineEvent — Typed Event Definitions with Optional Schema Validation
@@ -339,6 +341,30 @@ var MemoryOutboxStore = class {
 };
 //#endregion
 //#region src/events/repository-outbox-adapter.ts
+/**
+* RepositoryLike → OutboxStore adapter.
+*
+* Maps the `OutboxStore` vocabulary (save / claimPending / acknowledge /
+* fail / getDeadLettered / purge) onto arc's own `RepositoryLike` primitives
+* (create / getOne / findAll / deleteMany / findOneAndUpdate). `EventOutbox`
+* wraps a passed repository with this helper when you use the
+* `{ repository }` option; the function is also re-exported from
+* `@classytic/arc/events` so consumers can build and decorate the store
+* manually (metrics, tracing, multi-transport fan-out).
+*
+* Portability: filters compose via `@classytic/repo-core/filter` and
+* updates via `@classytic/repo-core/update`. The primary-key column name
+* is read from `repository.idField` — mongokit defaults to `_id`,
+* sqlitekit / pgkit / prismakit to the schema's declared PK. The adapter
+* therefore runs on any kit that implements `StandardRepo.findOneAndUpdate`
+* + `getOne` + `getAll` + `deleteMany` + `create`.
+*
+* `fail()` uses a lease-gated read-then-write pair to preserve
+* `firstFailedAt` across retries without relying on Mongo's aggregation-
+* pipeline `$ifNull`. Leases guarantee single-writer during the failure
+* window (`claimPending` filters out non-owned rows), so the two calls are
+* safe under concurrent relayers.
+*/
 const DEFAULT_LEASE_MS$1 = 3e4;
 const DEFAULT_CLAIM_LIMIT = 100;
 const DEFAULT_PURGE_BATCH = 500;
@@ -351,6 +377,7 @@ function repositoryAsOutboxStore(repository) {
 	if (typeof repository.findOneAndUpdate !== "function") missing.push("findOneAndUpdate");
 	if (missing.length > 0) throw new Error(`EventOutbox: repository is missing required methods: ${missing.join(", ")}. mongokit ≥3.10.2 satisfies all five; other kits must implement them to back the outbox.`);
 	const r = repository;
+	const idField = repository.idField ?? "_id";
 	/**
 	* Unwrap mongokit's pagination envelope ({ docs, total, ... }) — some
 	* kits may return a bare array when pagination is disabled. Handle both.
@@ -362,13 +389,20 @@ function repositoryAsOutboxStore(repository) {
 	const isDuplicateKeyError = createIsDuplicateKeyError(repository);
 	const safeGetOne = createSafeGetOne(repository);
 	const isWellFormed = (event) => !!event && typeof event.type === "string" && !!event.meta?.id;
+	/**
+	* Filter matching every row that's eligible to be claimed by a relayer:
+	* status=pending, visible now, and either unleased or under an expired
+	* lease. Used by `getPending` and `claimPending` — defined once so the
+	* two code paths stay in lockstep.
+	*/
+	const claimableFilter = (now) => and(eq("status", "pending"), lte("visibleAt", now), or(eq("leaseOwner", null), lte("leaseExpiresAt", now)));
 	return {
 		async save(event, options) {
 			if (!event?.type || typeof event.type !== "string") throw new InvalidOutboxEventError("event.type is required");
 			if (!event.meta?.id || typeof event.meta.id !== "string") throw new InvalidOutboxEventError("event.meta.id is required");
 			const now = /* @__PURE__ */ new Date();
 			const doc = {
-				_id: event.meta.id,
+				[idField]: event.meta.id,
 				event,
 				type: event.type,
 				status: "pending",
@@ -395,11 +429,7 @@ function repositoryAsOutboxStore(repository) {
 		async getPending(limit) {
 			const now = /* @__PURE__ */ new Date();
 			return unwrapDocs(await r.getAll({
-				filters: {
-					status: "pending",
-					visibleAt: { $lte: now },
-					$or: [{ leaseOwner: null }, { leaseExpiresAt: { $lte: now } }]
-				},
+				filters: claimableFilter(now),
 				sort: { createdAt: 1 },
 				page: 1,
 				limit
@@ -409,23 +439,19 @@ function repositoryAsOutboxStore(repository) {
 			const limit = options?.limit ?? DEFAULT_CLAIM_LIMIT;
 			const leaseMs = options?.leaseMs ?? DEFAULT_LEASE_MS$1;
 			const consumerId = options?.consumerId ?? "anonymous";
-			const typeFilter = options?.types?.length ? { type: { $in: options.types } } : {};
+			const typeFilter = options?.types?.length ? anyOf("type", options.types) : null;
 			const claimed = [];
 			for (let i = 0; i < limit; i++) {
 				const now = /* @__PURE__ */ new Date();
 				const leaseExpiresAt = new Date(now.getTime() + leaseMs);
-				const doc = await r.findOneAndUpdate({
-					status: "pending",
-					visibleAt: { $lte: now },
-					$or: [{ leaseOwner: null }, { leaseExpiresAt: { $lte: now } }],
-					...typeFilter
-				}, {
-					$set: {
+				const filter = typeFilter ? and(claimableFilter(now), typeFilter) : claimableFilter(now);
+				const doc = await r.findOneAndUpdate(filter, update({
+					set: {
 						leaseOwner: consumerId,
 						leaseExpiresAt
 					},
-					$inc: { attempts: 1 }
-				}, {
+					inc: { attempts: 1 }
+				}), {
 					sort: { createdAt: 1 },
 					returnDocument: "after"
 				});
@@ -436,18 +462,15 @@ function repositoryAsOutboxStore(repository) {
 		},
 		async acknowledge(eventId, options) {
 			const now = /* @__PURE__ */ new Date();
-			const filter = {
-				_id: eventId,
-				status: { $ne: "delivered" }
-			};
-			if (options?.consumerId) filter.leaseOwner = options.consumerId;
-			if (await r.findOneAndUpdate(filter, { $set: {
+			const baseFilter = and(eq(idField, eventId), ne("status", "delivered"));
+			const filter = options?.consumerId ? and(baseFilter, eq("leaseOwner", options.consumerId)) : baseFilter;
+			if (await r.findOneAndUpdate(filter, update({ set: {
 				status: "delivered",
 				deliveredAt: now,
 				leaseOwner: null,
 				leaseExpiresAt: null
-			} }, { returnDocument: "after" })) return;
-			const current = await safeGetOne({ _id: eventId });
+			} }), { returnDocument: "after" })) return;
+			const current = await safeGetOne(eq(idField, eventId));
 			if (!current) return;
 			if (current.status === "delivered") return;
 			if (options?.consumerId && current.leaseOwner !== options.consumerId) throw new OutboxOwnershipError(eventId, options.consumerId, current.leaseOwner);
@@ -456,32 +479,30 @@ function repositoryAsOutboxStore(repository) {
 			const now = /* @__PURE__ */ new Date();
 			const targetStatus = options?.deadLetter ? "dead_letter" : "pending";
 			const visibleAt = options?.retryAt ?? now;
-			const filter = { _id: eventId };
-			if (options?.consumerId) filter.leaseOwner = options.consumerId;
-			const pipeline = [{ $set: {
+			const baseFilter = eq(idField, eventId);
+			const filter = options?.consumerId ? and(baseFilter, eq("leaseOwner", options.consumerId)) : baseFilter;
+			const current = await safeGetOne(baseFilter);
+			if (!current) return;
+			if (options?.consumerId && current.leaseOwner !== options.consumerId) throw new OutboxOwnershipError(eventId, options.consumerId, current.leaseOwner);
+			const errorInfo = error.code ? {
+				message: error.message,
+				code: error.code
+			} : { message: error.message };
+			const firstFailedAt = current.firstFailedAt ?? now;
+			await r.findOneAndUpdate(filter, update({ set: {
 				status: targetStatus,
 				visibleAt,
 				leaseOwner: null,
 				leaseExpiresAt: null,
 				lastFailedAt: now,
-				lastError: {
-					message: error.message,
-					...error.code ? { code: error.code } : {}
-				},
-				firstFailedAt: { $ifNull: ["$firstFailedAt", now] }
-			} }];
-			if (await r.findOneAndUpdate(filter, pipeline, {
-				returnDocument: "after",
-				updatePipeline: true
-			})) return;
-			const current = await safeGetOne({ _id: eventId });
-			if (!current) return;
-			if (options?.consumerId && current.leaseOwner !== options.consumerId) throw new OutboxOwnershipError(eventId, options.consumerId, current.leaseOwner);
+				lastError: errorInfo,
+				firstFailedAt
+			} }), { returnDocument: "after" });
 		},
 		async getDeadLettered(limit) {
 			return unwrapDocs(await r.getAll({
-				filters: { status: "dead_letter" },
-				sort: { _id: 1 },
+				filters: eq("status", "dead_letter"),
+				sort: { [idField]: 1 },
 				page: 1,
 				limit
 			})).filter((d) => isWellFormed(d.event)).map((d) => ({
@@ -500,18 +521,15 @@ function repositoryAsOutboxStore(repository) {
 			let totalDeleted = 0;
 			for (;;) {
 				const batch = unwrapDocs(await r.getAll({
-					filters: {
-						status: "delivered",
-						deliveredAt: { $lte: cutoff }
-					},
+					filters: and(eq("status", "delivered"), lte("deliveredAt", cutoff)),
 					sort: { deliveredAt: 1 },
 					page: 1,
 					limit: DEFAULT_PURGE_BATCH,
-					select: "_id"
+					select: idField
 				}));
 				if (batch.length === 0) break;
-				const ids = batch.map((d) => d._id);
-				const res = await r.deleteMany({ _id: { $in: ids } });
+				const ids = batch.map((d) => d[idField]);
+				const res = await r.deleteMany(anyOf(idField, ids));
 				totalDeleted += res.deletedCount ?? 0;
 				if (batch.length < DEFAULT_PURGE_BATCH) break;
 			}

package/dist/events/transports/redis-stream-entry.d.mts

@@ -1,2 +1,2 @@
-import { n as RedisStreamTransport, r as RedisStreamTransportOptions, t as RedisStreamLike } from "../../redis-stream-CakIQmwR.mjs";
+import { n as RedisStreamTransport, r as RedisStreamTransportOptions, t as RedisStreamLike } from "../../redis-stream-bkO88VHx.mjs";
 export { type RedisStreamLike, RedisStreamTransport, type RedisStreamTransportOptions };

package/dist/events/transports/redis.d.mts

@@ -1,4 +1,4 @@
-import { i as EventLogger, n as DomainEvent, o as EventTransport, r as EventHandler } from "../../EventTransport-CUw5NNWe.mjs";
+import { i as EventLogger, n as DomainEvent, o as EventTransport, r as EventHandler } from "../../EventTransport-CfVEGaEl.mjs";
 
 //#region src/events/transports/redis.d.ts
 interface RedisLike {

package/dist/factory/index.d.mts

@@ -1,4 +1,4 @@
-import { a as CustomPluginAuthOption, c as RawBodyOptions, d as ResourceLike, f as loadResources, i as CustomAuthenticatorOption, l as UnderPressureOptions, n as BetterAuthOption, o as JwtAuthOption, r as CreateAppOptions, s as MultipartOptions, t as AuthOption, u as LoadResourcesOptions } from "../types-Co8k3NyS.mjs";
+import { a as CustomPluginAuthOption, c as RawBodyOptions, d as ResourceLike, f as loadResources, i as CustomAuthenticatorOption, l as UnderPressureOptions, n as BetterAuthOption, o as JwtAuthOption, r as CreateAppOptions, s as MultipartOptions, t as AuthOption, u as LoadResourcesOptions } from "../types-CVdgPXBW.mjs";
 import { FastifyInstance } from "fastify";
 
 //#region src/factory/createApp.d.ts

package/dist/factory/index.mjs

@@ -1,5 +1,5 @@
-import { a as edgePreset, c as testingPreset, i as developmentPreset, n as createApp, o as getPreset, s as productionPreset, t as ArcFactory } from "../createApp-BuvPma24.mjs";
-import { t as loadResources } from "../loadResources-BAzJItAJ.mjs";
+import { a as edgePreset, c as testingPreset, i as developmentPreset, n as createApp, o as getPreset, s as productionPreset, t as ArcFactory } from "../createApp-BwnEAO2h.mjs";
+import { t as loadResources } from "../loadResources-Bksk8ydA.mjs";
 //#region src/factory/edge.ts
 /**
 * Convert a Fastify app into a Web Standards fetch handler.

package/dist/{fields-Lo1VUDpt.d.mts → fields-C8Y0XLAu.d.mts}

@@ -1,4 +1,4 @@
-import { r as RequestScope } from "./types-BD85MlEK.mjs";
+import { r as RequestScope } from "./types-tgR4Pt8F.mjs";
 import { FastifyRequest } from "fastify";
 
 //#region src/permissions/types.d.ts

package/dist/hooks/index.d.mts

@@ -1,2 +1,2 @@
-import { $t as HookPhase, Qt as HookOperation, Xt as HookContext, Yt as DefineHookOptions, Zt as HookHandler, an as afterUpdate, cn as beforeUpdate, en as HookRegistration, in as afterDelete, ln as createHookSystem, nn as HookSystemOptions, on as beforeCreate, rn as afterCreate, sn as beforeDelete, tn as HookSystem, un as defineHook } from "../index-Cl0uoKd5.mjs";
+import { $ as beforeCreate, G as HookOperation, H as DefineHookOptions, J as HookSystem, K as HookPhase, Q as afterUpdate, U as HookContext, W as HookHandler, X as afterCreate, Y as HookSystemOptions, Z as afterDelete, et as beforeDelete, nt as createHookSystem, q as HookRegistration, rt as defineHook, tt as beforeUpdate } from "../index-BGbpGVyM.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

@@ -1,2 +1,2 @@
-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-BNYKnrXF.mjs";
+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-BjFu7zf1.mjs";
 export { HookSystem, afterCreate, afterDelete, afterUpdate, beforeCreate, beforeDelete, beforeUpdate, createHookSystem, defineHook };

package/dist/idempotency/index.d.mts

@@ -1,6 +1,6 @@
-import { kt as RepositoryLike } from "../index-Cl0uoKd5.mjs";
-import { i as createIdempotencyResult, n as IdempotencyResult, r as IdempotencyStore, t as IdempotencyLock } from "../interface-CSbZdv_3.mjs";
-import { i as RedisIdempotencyStoreOptions, n as RedisClient } from "../redis-DqyeggCa.mjs";
+import { _n as RepositoryLike } from "../index-BGbpGVyM.mjs";
+import { i as createIdempotencyResult, n as IdempotencyResult, r as IdempotencyStore, t as IdempotencyLock } from "../interface-B-pe8fhj.mjs";
+import { i as RedisIdempotencyStoreOptions, n as RedisClient } from "../redis-MXLp1oOf.mjs";
 import { FastifyPluginAsync } from "fastify";
 
 //#region src/idempotency/idempotencyPlugin.d.ts

package/dist/idempotency/index.mjs

@@ -1,7 +1,28 @@
-import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-ZCSMJJAX.mjs";
+import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-DYYUQbQN.mjs";
 import { createHash } from "node:crypto";
 import fp from "fastify-plugin";
+import { and, eq, exists, gt, lt, or, startsWith } from "@classytic/repo-core/filter";
+import { update } from "@classytic/repo-core/update";
 //#region src/idempotency/repository-idempotency-adapter.ts
+/**
+* RepositoryLike → IdempotencyStore adapter.
+*
+* Maps the idempotency store's verbs (get / set / tryLock / unlock / delete /
+* deleteByPrefix / findByPrefix) onto arc's canonical repository primitives
+* (`getOne` / `deleteMany` / `findOneAndUpdate`). `idempotencyPlugin` wraps
+* a passed repository with this helper when you use the `{ repository }`
+* option; the function is also re-exported from `@classytic/arc/idempotency`
+* so consumers can build and decorate the store (metrics, tracing, key
+* namespacing) before passing it via `store:`.
+*
+* Portability: filters compose via `@classytic/repo-core/filter` builders
+* (`and` / `or` / `eq` / `gt` / `lt` / `exists` / `startsWith`) and updates
+* via `@classytic/repo-core/update` (`update({ set, unset, setOnInsert })`).
+* Both IRs compile to Mongo operators on mongokit, SQL predicates on
+* sqlitekit / pgkit, and `WhereInput` / `update` on prismakit. The store
+* therefore runs identically on every backend that implements the
+* `StandardRepo.findOneAndUpdate` + `getOne` + `deleteMany` surface.
+*/
 function repositoryAsIdempotencyStore(repository, defaultTtlMs) {
 	const missing = [];
 	if (typeof repository.getOne !== "function") missing.push("getOne");
@@ -9,13 +30,13 @@ function repositoryAsIdempotencyStore(repository, defaultTtlMs) {
 	if (typeof repository.findOneAndUpdate !== "function") missing.push("findOneAndUpdate");
 	if (missing.length > 0) throw new Error(`idempotencyPlugin: repository is missing required methods: ${missing.join(", ")}. mongokit ≥3.8 satisfies these; other kits must implement them to back idempotency via a repository.`);
 	const r = repository;
+	const idField = repository.idField ?? "_id";
 	const isDuplicateKeyError = createIsDuplicateKeyError(repository);
 	const safeGetOne = createSafeGetOne(repository);
-	const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 	return {
 		name: "repository",
 		async get(key) {
-			const doc = await safeGetOne({ _id: key });
+			const doc = await safeGetOne(eq(idField, key));
 			if (!doc?.result) return void 0;
 			if (new Date(doc.expiresAt) < /* @__PURE__ */ new Date()) return void 0;
 			return {
@@ -28,8 +49,8 @@ function repositoryAsIdempotencyStore(repository, defaultTtlMs) {
 			};
 		},
 		async set(key, result) {
-			await r.findOneAndUpdate({ _id: key }, {
-				$set: {
+			await r.findOneAndUpdate(eq(idField, key), update({
+				set: {
 					result: {
 						statusCode: result.statusCode,
 						headers: result.headers,
@@ -38,8 +59,8 @@ function repositoryAsIdempotencyStore(repository, defaultTtlMs) {
 					createdAt: result.createdAt,
 					expiresAt: result.expiresAt
 				},
-				$unset: { lock: "" }
-			}, {
+				unset: ["lock"]
+			}), {
 				upsert: true,
 				returnDocument: "after"
 			});
@@ -49,19 +70,16 @@ function repositoryAsIdempotencyStore(repository, defaultTtlMs) {
 			const lockExpiresAt = new Date(now.getTime() + ttlMs);
 			const docExpiresAt = new Date(now.getTime() + defaultTtlMs);
 			try {
-				const doc = await r.findOneAndUpdate({
-					_id: key,
-					$or: [{ lock: { $exists: false } }, { "lock.expiresAt": { $lt: now } }]
-				}, {
-					$set: { lock: {
+				const doc = await r.findOneAndUpdate(and(eq(idField, key), or(exists("lock", false), lt("lock.expiresAt", now))), update({
+					set: { lock: {
 						requestId,
 						expiresAt: lockExpiresAt
 					} },
-					$setOnInsert: {
+					setOnInsert: {
 						createdAt: now,
 						expiresAt: docExpiresAt
 					}
-				}, {
+				}), {
 					upsert: true,
 					returnDocument: "after"
 				});
@@ -72,31 +90,24 @@ function repositoryAsIdempotencyStore(repository, defaultTtlMs) {
 			}
 		},
 		async unlock(key, requestId) {
-			await r.findOneAndUpdate({
-				_id: key,
-				"lock.requestId": requestId
-			}, { $unset: { lock: "" } });
+			await r.findOneAndUpdate(and(eq(idField, key), eq("lock.requestId", requestId)), update({ unset: ["lock"] }));
 		},
 		async isLocked(key) {
-			const doc = await safeGetOne({ _id: key });
+			const doc = await safeGetOne(eq(idField, key));
 			if (!doc?.lock) return false;
 			return new Date(doc.lock.expiresAt) > /* @__PURE__ */ new Date();
 		},
 		async delete(key) {
-			await r.deleteMany({ _id: key });
+			await r.deleteMany(eq(idField, key));
 		},
 		async deleteByPrefix(prefix) {
-			return (await r.deleteMany({ _id: { $regex: `^${escapeRegex(prefix)}` } })).deletedCount ?? 0;
+			return (await r.deleteMany(startsWith(idField, prefix, "sensitive"))).deletedCount ?? 0;
 		},
 		async findByPrefix(prefix) {
-			const doc = await safeGetOne({
-				_id: { $regex: `^${escapeRegex(prefix)}` },
-				result: { $exists: true },
-				expiresAt: { $gt: /* @__PURE__ */ new Date() }
-			});
+			const doc = await safeGetOne(and(startsWith(idField, prefix, "sensitive"), exists("result", true), gt("expiresAt", /* @__PURE__ */ new Date())));
 			if (!doc?.result) return void 0;
 			return {
-				key: doc._id,
+				key: String(doc[idField] ?? prefix),
 				statusCode: doc.result.statusCode,
 				headers: doc.result.headers,
 				body: doc.result.body,

package/dist/idempotency/redis.d.mts

@@ -1,2 +1,2 @@
-import { a as UpstashRedisLike, i as RedisIdempotencyStoreOptions, n as RedisClient, o as ioredisAsIdempotencyClient, r as RedisIdempotencyStore, s as upstashAsIdempotencyClient, t as IoredisLike } from "../redis-DqyeggCa.mjs";
+import { a as UpstashRedisLike, i as RedisIdempotencyStoreOptions, n as RedisClient, o as ioredisAsIdempotencyClient, r as RedisIdempotencyStore, s as upstashAsIdempotencyClient, t as IoredisLike } from "../redis-MXLp1oOf.mjs";
 export { type IoredisLike, type RedisClient, RedisIdempotencyStore, type RedisIdempotencyStoreOptions, type UpstashRedisLike, ioredisAsIdempotencyClient, upstashAsIdempotencyClient };