@fedify/cfworkers 2.0.1 → 2.0.2-dev.407

package/dist/mod.d.ts

@@ -4,40 +4,41 @@ import { KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions, MessageQueue, Mess
 //#region src/mod.d.ts
 
 /**
- * Result from {@link WorkersMessageQueue.processMessage}.
- * @since 2.0.0
- */
+* Result from {@link WorkersMessageQueue.processMessage}.
+* @since 2.0.0
+*/
 interface ProcessMessageResult {
   /**
-   * Whether the message should be processed.  If `false`, the message has not
-   * been processed (for example, because an ordering key lock is still held)
-   * and the caller is responsible for re-enqueuing or retrying it when
-   * appropriate.
-   */
+  * Whether the message should be processed.  If `false`, the message has not
+  * been processed (for example, because an ordering key lock is still held)
+  * and the caller is responsible for re-enqueuing or retrying it when
+  * appropriate.
+  */
   readonly shouldProcess: boolean;
   /**
-   * The unwrapped message payload to process.
-   * Only present when `shouldProcess` is `true`.
-   */
+  * The unwrapped message payload to process.
+  * Only present when `shouldProcess` is `true`.
+  */
+  // deno-lint-ignore no-explicit-any
   readonly message?: any;
   /**
-   * A cleanup function that must be called after processing the message.
-   * This releases the ordering key lock.  Only present when `shouldProcess`
-   * is `true` and the message had an ordering key.
-   */
+  * A cleanup function that must be called after processing the message.
+  * This releases the ordering key lock.  Only present when `shouldProcess`
+  * is `true` and the message had an ordering key.
+  */
   readonly release?: () => Promise<void>;
 }
 /**
- * Implementation of the {@link KvStore} interface for Cloudflare Workers KV
- * binding.  This class provides a wrapper around Cloudflare's KV namespace to
- * store and retrieve JSON-serializable values using structured keys.
- *
- * Note that this implementation does not support the {@link KvStore.cas}
- * operation, as Cloudflare Workers KV does not support atomic compare-and-swap
- * operations.  If you need this functionality, consider using a different
- * key–value store that supports atomic operations.
- * @since 1.9.0
- */
+* Implementation of the {@link KvStore} interface for Cloudflare Workers KV
+* binding.  This class provides a wrapper around Cloudflare's KV namespace to
+* store and retrieve JSON-serializable values using structured keys.
+*
+* Note that this implementation does not support the {@link KvStore.cas}
+* operation, as Cloudflare Workers KV does not support atomic compare-and-swap
+* operations.  If you need this functionality, consider using a different
+* key–value store that supports atomic operations.
+* @since 1.9.0
+*/
 declare class WorkersKvStore implements KvStore {
   #private;
   constructor(namespace: KVNamespace<string>);
@@ -45,103 +46,104 @@ declare class WorkersKvStore implements KvStore {
   set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
   delete(key: KvKey): Promise<void>;
   /**
-   * {@inheritDoc KvStore.list}
-   * @since 1.10.0
-   */
+  * {@inheritDoc KvStore.list}
+  * @since 1.10.0
+  */
   list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
 }
 /**
- * Options for {@link WorkersMessageQueue}.
- * @since 2.0.0
- */
+* Options for {@link WorkersMessageQueue}.
+* @since 2.0.0
+*/
 interface WorkersMessageQueueOptions {
   /**
-   * The KV namespace to use for ordering key locks.  If not provided, ordering
-   * keys will not be supported.
-   *
-   * Note: Cloudflare Workers KV has eventual consistency, so ordering key
-   * guarantees are best-effort.  For strict ordering requirements, consider
-   * using Durable Objects.
-   */
+  * The KV namespace to use for ordering key locks.  If not provided, ordering
+  * keys will not be supported.
+  *
+  * Note: Cloudflare Workers KV has eventual consistency, so ordering key
+  * guarantees are best-effort.  For strict ordering requirements, consider
+  * using Durable Objects.
+  */
   readonly orderingKv?: KVNamespace<string>;
   /**
-   * The prefix for ordering key lock keys.  Defaults to `"__fedify_ordering_"`.
-   * @default `"__fedify_ordering_"`
-   */
+  * The prefix for ordering key lock keys.  Defaults to `"__fedify_ordering_"`.
+  * @default `"__fedify_ordering_"`
+  */
   readonly orderingKeyPrefix?: string;
   /**
-   * The TTL (time-to-live) for ordering key locks in seconds.
-   * Defaults to 60 seconds.  Must be at least 60 seconds due to
-   * Cloudflare KV minimum TTL requirement.
-   * @default 60
-   */
+  * The TTL (time-to-live) for ordering key locks in seconds.
+  * Defaults to 60 seconds.  Must be at least 60 seconds due to
+  * Cloudflare KV minimum TTL requirement.
+  * @default 60
+  */
   readonly orderingLockTtl?: number;
 }
 /**
- * Implementation of the {@link MessageQueue} interface for Cloudflare
- * Workers Queues binding.  This class provides a wrapper around Cloudflare's
- * Queues to send messages to a queue.
- *
- * Note that this implementation does not support the `listen()` method,
- * as Cloudflare Workers Queues do not support message consumption in the same
- * way as other message queue systems.  Instead, you should use
- * the {@link WorkersMessageQueue.processMessage} method to handle ordering key
- * locks before calling {@link Federation.processQueuedTask}.
- * @since 1.9.0
- */
+* Implementation of the {@link MessageQueue} interface for Cloudflare
+* Workers Queues binding.  This class provides a wrapper around Cloudflare's
+* Queues to send messages to a queue.
+*
+* Note that this implementation does not support the `listen()` method,
+* as Cloudflare Workers Queues do not support message consumption in the same
+* way as other message queue systems.  Instead, you should use
+* the {@link WorkersMessageQueue.processMessage} method to handle ordering key
+* locks before calling {@link Federation.processQueuedTask}.
+* @since 1.9.0
+*/
 declare class WorkersMessageQueue implements MessageQueue {
   #private;
   /**
-   * Cloudflare Queues provide automatic retry with exponential backoff
-   * and Dead Letter Queues.
-   * @since 1.7.0
-   */
-  readonly nativeRetrial = true;
+  * Cloudflare Queues provide automatic retry with exponential backoff
+  * and Dead Letter Queues.
+  * @since 1.7.0
+  */
+  readonly nativeRetrial: true;
   /**
-   * Constructs a new {@link WorkersMessageQueue} with the given queue and
-   * optional ordering key configuration.
-   * @param queue The Cloudflare Queue binding.
-   * @param options Options for ordering key support.
-   */
+  * Constructs a new {@link WorkersMessageQueue} with the given queue and
+  * optional ordering key configuration.
+  * @param queue The Cloudflare Queue binding.
+  * @param options Options for ordering key support.
+  */
   constructor(queue: Queue, options?: WorkersMessageQueueOptions);
   enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
   enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
   /**
-   * Processes a message from the queue, handling ordering key locks.
-   * Call this method before {@link Federation.processQueuedTask} to ensure
-   * ordering key semantics are respected.
-   *
-   * Example usage in a Cloudflare Worker queue handler:
-   *
-   * ```typescript ignore
-   * export default {
-   *   async queue(batch, env, ctx) {
-   *     const queue = new WorkersMessageQueue(env.QUEUE, {
-   *       orderingKv: env.ORDERING_KV,
-   *     });
-   *     for (const msg of batch.messages) {
-   *       const result = await queue.processMessage(msg.body);
-   *       if (!result.shouldProcess) {
-   *         msg.retry();  // Re-enqueue to wait for lock
-   *         continue;
-   *       }
-   *       try {
-   *         await federation.processQueuedTask(ctx, result.message);
-   *         msg.ack();
-   *       } catch (e) {
-   *         msg.retry();
-   *       } finally {
-   *         await result.release?.();
-   *       }
-   *     }
-   *   }
-   * };
-   * ```
-   *
-   * @param rawMessage The raw message body from the queue.
-   * @returns A result object indicating whether to process the message.
-   * @since 2.0.0
-   */
+  * Processes a message from the queue, handling ordering key locks.
+  * Call this method before {@link Federation.processQueuedTask} to ensure
+  * ordering key semantics are respected.
+  *
+  * Example usage in a Cloudflare Worker queue handler:
+  *
+  * ```typescript ignore
+  * export default {
+  *   async queue(batch, env, ctx) {
+  *     const queue = new WorkersMessageQueue(env.QUEUE, {
+  *       orderingKv: env.ORDERING_KV,
+  *     });
+  *     for (const msg of batch.messages) {
+  *       const result = await queue.processMessage(msg.body);
+  *       if (!result.shouldProcess) {
+  *         msg.retry();  // Re-enqueue to wait for lock
+  *         continue;
+  *       }
+  *       try {
+  *         await federation.processQueuedTask(ctx, result.message);
+  *         msg.ack();
+  *       } catch (e) {
+  *         msg.retry();
+  *       } finally {
+  *         await result.release?.();
+  *       }
+  *     }
+  *   }
+  * };
+  * ```
+  *
+  * @param rawMessage The raw message body from the queue.
+  * @returns A result object indicating whether to process the message.
+  * @since 2.0.0
+  */
+  // deno-lint-ignore no-explicit-any
   processMessage(rawMessage: any): Promise<ProcessMessageResult>;
   listen(_handler: (message: any) => Promise<void> | void, _options?: MessageQueueListenOptions): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/cfworkers",
-  "version": "2.0.1",
+  "version": "2.0.2-dev.407+6f4b2e28",
   "description": "Adapt Fedify with Cloudflare Workers",
   "keywords": [
     "Fedify",
@@ -52,7 +52,7 @@
   ],
   "peerDependencies": {
     "@cloudflare/workers-types": "^4.20250906.0",
-    "@fedify/fedify": "^2.0.1"
+    "@fedify/fedify": "^2.0.2-dev.407+6f4b2e28"
   },
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "^0.8.31",