@chainfuse/helpers 3.2.12 → 3.3.1

package/dist/common.d.mts

@@ -32,5 +32,12 @@ export declare class Helpers {
      * @returns `true` if the running local, otherwise `false`.
      */
     static isLocal<P extends QwikCityPlatform>(metadataOrPlatform: WorkerVersionMetadata | P): boolean;
+    /**
+     * Pauses execution for a specified number of milliseconds.
+     *
+     * @param ms - The number of milliseconds to sleep.
+     * @returns A promise that resolves after the specified delay.
+     */
+    static sleep(ms: number): Promise<void>;
 }
 export {};

package/dist/common.mjs

@@ -88,4 +88,13 @@ export class Helpers {
             return !('request' in metadataOrPlatform);
         }
     }
+    /**
+     * Pauses execution for a specified number of milliseconds.
+     *
+     * @param ms - The number of milliseconds to sleep.
+     * @returns A promise that resolves after the specified delay.
+     */
+    static sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
 }

package/dist/db.d.mts

@@ -0,0 +1,81 @@
+import { Cache as DrizzleCache, type MutationOption } from 'drizzle-orm/cache/core';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import { z } from 'zod/v4';
+/**
+ * Interface for CacheStorage-like objects that can be used as drop-in replacements.
+ * This interface ensures compatibility with the Web API CacheStorage while allowing for custom implementations that provide the same core functionality.
+ */
+export interface CacheStorageLike {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/open) */
+    open(cacheName: string): Promise<Cache>;
+}
+/**
+ * SQLCache is a cache implementation for SQL query results, using Web CacheStorage (supports drop in replacements).
+ * It supports caching strategies for explicit or global query caching, and provides mechanisms for cache invalidation based on affected tables or tags.
+ *
+ * @remarks
+ * - Designed for use with Drizzle ORM and compatible with CacheStorage APIs.
+ * - Tracks which cache keys are associated with which tables for efficient invalidation.
+ * - Supports TTL (time-to-live) configuration and custom caching strategies.
+ *
+ * @extends DrizzleCache
+ */
+export declare class SQLCache<C extends CacheStorageLike> extends DrizzleCache {
+    private dbName;
+    private dbType;
+    private cache;
+    private globalTtl;
+    private _strategy;
+    private usedTablesPerKey;
+    private static constructorArgs;
+    /**
+     * Creates an instance of the class with the specified database name, type, and cache TTL.
+     *
+     * @param dbName - The name of the database to use. Must be globally unique as it is used for cache lookup. Will be url encoded if not already url safe.
+     * @param dbType - The type of the database (e.g., `d1`, `pg` `mysql`). Will be url encoded if not already url safe.
+     * @param cacheTTL - The time-to-live (TTL) value for the cache, in seconds.
+     * @param strategy - The caching strategy to use. Defaults to 'explicit'.
+     * - `explicit`: The cache is used only when .$withCache() is added to a query.
+     * - `all`: All queries are cached globally.
+     * @param cacheStore - The cache store to use. Can be a CacheStorage or CacheStorage-like object that atleast contains the `open()` function
+     */
+    constructor(args: z.input<ReturnType<(typeof SQLCache)['constructorArgs']>>, cacheStore?: C);
+    /**
+     * For the strategy, we have two options:
+     * - `explicit`: The cache is used only when .$withCache() is added to a query.
+     * - `all`: All queries are cached globally.
+     * @default 'explicit'
+     */
+    strategy(): "explicit" | "all";
+    /**
+     * Generates a cache key as a `Request` object based on the provided tag or key.
+     *
+     * @param tagOrKey - An object containing either a `tag` or a `key` property to identify the cache entry.
+     * @param init - Optional request initialization parameters, as accepted by the `Request` constructor.
+     * @returns A `Request` object representing the cache key, constructed with a URL based on the tag or key and the database configuration.
+     */
+    private getCacheKey;
+    /**
+     * This function accepts query and parameters that cached into key param, allowing you to retrieve response values for this query from the cache.
+     * @param key - A hashed query and parameters.
+     */
+    get(key: string, _tables: string[], isTag: boolean): Promise<any[] | undefined>;
+    /**
+     * This function accepts several options to define how cached data will be stored:
+     * @param hashedQuery - A hashed query and parameters.
+     * @param response - An array of values returned by Drizzle from the database.
+     * @param tables - An array of tables involved in the select queries. This information is needed for cache invalidation.
+     *
+     * For example, if a query uses the "users" and "posts" tables, you can store this information. Later, when the app executes any mutation statements on these tables, you can remove the corresponding key from the cache.
+     * If you're okay with eventual consistency for your queries, you can skip this option.
+     */
+    put(hashedQuery: string, response: any, tables: string[], isTag: boolean, config?: CacheConfig): Promise<void>;
+    /**
+     * This function is called when insert, update, or delete statements are executed.
+     * You can either skip this step or invalidate queries that used the affected tables.
+     *
+     * @param tags - Used for queries labeled with a specific tag, allowing you to invalidate by that tag.
+     * @param tables - The actual tables affected by the insert, update, or delete statements, helping you track which tables have changed since the last cache update.
+     */
+    onMutate(params: MutationOption): Promise<void>;
+}

package/dist/db.mjs

@@ -0,0 +1,174 @@
+import { Cache as DrizzleCache } from 'drizzle-orm/cache/core';
+import { is } from 'drizzle-orm/entity';
+import { getTableName, Table } from 'drizzle-orm/table';
+import { z } from 'zod/v4';
+import { CryptoHelpers } from "./crypto.mjs";
+/**
+ * SQLCache is a cache implementation for SQL query results, using Web CacheStorage (supports drop in replacements).
+ * It supports caching strategies for explicit or global query caching, and provides mechanisms for cache invalidation based on affected tables or tags.
+ *
+ * @remarks
+ * - Designed for use with Drizzle ORM and compatible with CacheStorage APIs.
+ * - Tracks which cache keys are associated with which tables for efficient invalidation.
+ * - Supports TTL (time-to-live) configuration and custom caching strategies.
+ *
+ * @extends DrizzleCache
+ */
+export class SQLCache extends DrizzleCache {
+    dbName;
+    dbType;
+    cache;
+    globalTtl;
+    _strategy;
+    // This object will be used to store which query keys were used
+    // for a specific table, so we can later use it for invalidation.
+    usedTablesPerKey = {};
+    static constructorArgs() {
+        return z.object({
+            dbName: z
+                .string()
+                .nonempty()
+                .transform((val) => encodeURIComponent(val)),
+            dbType: z
+                .string()
+                .nonempty()
+                .transform((val) => encodeURIComponent(val)),
+            cacheTTL: z
+                .int()
+                .nonnegative()
+                .default(5 * 60),
+            strategy: z.enum(['explicit', 'all']).default('explicit'),
+        });
+    }
+    /**
+     * Creates an instance of the class with the specified database name, type, and cache TTL.
+     *
+     * @param dbName - The name of the database to use. Must be globally unique as it is used for cache lookup. Will be url encoded if not already url safe.
+     * @param dbType - The type of the database (e.g., `d1`, `pg` `mysql`). Will be url encoded if not already url safe.
+     * @param cacheTTL - The time-to-live (TTL) value for the cache, in seconds.
+     * @param strategy - The caching strategy to use. Defaults to 'explicit'.
+     * - `explicit`: The cache is used only when .$withCache() is added to a query.
+     * - `all`: All queries are cached globally.
+     * @param cacheStore - The cache store to use. Can be a CacheStorage or CacheStorage-like object that atleast contains the `open()` function
+     */
+    constructor(args, cacheStore) {
+        super();
+        const { dbName, dbType, cacheTTL, strategy } = SQLCache.constructorArgs().parse(args);
+        this.dbName = dbName;
+        this.dbType = dbType;
+        cacheStore ??= globalThis.caches;
+        if ('open' in cacheStore && typeof cacheStore.open === 'function') {
+            this.cache = cacheStore.open(`${dbType}:${dbName}`);
+        }
+        else {
+            throw new Error('Cache store must be a CacheStorage (or subclass/instance of)');
+        }
+        this.globalTtl = cacheTTL;
+        this._strategy = strategy;
+    }
+    /**
+     * For the strategy, we have two options:
+     * - `explicit`: The cache is used only when .$withCache() is added to a query.
+     * - `all`: All queries are cached globally.
+     * @default 'explicit'
+     */
+    strategy() {
+        return this._strategy;
+    }
+    /**
+     * Generates a cache key as a `Request` object based on the provided tag or key.
+     *
+     * @param tagOrKey - An object containing either a `tag` or a `key` property to identify the cache entry.
+     * @param init - Optional request initialization parameters, as accepted by the `Request` constructor.
+     * @returns A `Request` object representing the cache key, constructed with a URL based on the tag or key and the database configuration.
+     */
+    getCacheKey(tagOrKey, init) {
+        return new Request(new URL(('tag' in tagOrKey ? ['tag', tagOrKey.tag] : ['key', tagOrKey.key]).join('/'), `https://${this.dbName}.${this.dbType}`), init);
+    }
+    /**
+     * This function accepts query and parameters that cached into key param, allowing you to retrieve response values for this query from the cache.
+     * @param key - A hashed query and parameters.
+     */
+    async get(key, _tables, isTag) {
+        const response = await this.cache.then(async (cache) => cache.match(this.getCacheKey(isTag ? { tag: key } : { key })));
+        console.debug('SQLCache.get', isTag ? 'tag' : 'key', key, response?.ok ? 'HIT' : 'MISS');
+        if (response) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return response.json();
+        }
+        else {
+            return response;
+        }
+    }
+    /**
+     * This function accepts several options to define how cached data will be stored:
+     * @param hashedQuery - A hashed query and parameters.
+     * @param response - An array of values returned by Drizzle from the database.
+     * @param tables - An array of tables involved in the select queries. This information is needed for cache invalidation.
+     *
+     * For example, if a query uses the "users" and "posts" tables, you can store this information. Later, when the app executes any mutation statements on these tables, you can remove the corresponding key from the cache.
+     * If you're okay with eventual consistency for your queries, you can skip this option.
+     */
+    async put(hashedQuery, response, tables, isTag, config) {
+        let ttl = this.globalTtl;
+        if (config?.ex) {
+            ttl = config.ex;
+        }
+        else if (config?.px) {
+            ttl = Math.floor(config.px / 1000);
+        }
+        else if (config?.exat) {
+            ttl = Math.floor((new Date(config.exat * 1000).getTime() - Date.now()) / 1000);
+        }
+        else if (config?.pxat) {
+            ttl = Math.floor((new Date(config.pxat).getTime() - Date.now()) / 1000);
+        }
+        const cacheRequest = new Response(JSON.stringify(response), {
+            headers: {
+                'Content-Type': 'application/json',
+                'Cache-Control': `public, max-age=${ttl}, s-maxage=${ttl}`,
+            },
+        });
+        cacheRequest.headers.set('ETag', await CryptoHelpers.generateETag(cacheRequest));
+        await this.cache.then(async (cache) => cache.put(this.getCacheKey(isTag ? { tag: hashedQuery } : { key: hashedQuery }), cacheRequest)).then(() => console.debug('SQLCache.put', isTag ? 'tag' : 'key', hashedQuery, 'SUCCESS'));
+        for (const table of tables) {
+            const keys = this.usedTablesPerKey[table];
+            if (keys === undefined) {
+                this.usedTablesPerKey[table] = [hashedQuery];
+            }
+            else {
+                keys.push(hashedQuery);
+            }
+        }
+    }
+    /**
+     * This function is called when insert, update, or delete statements are executed.
+     * You can either skip this step or invalidate queries that used the affected tables.
+     *
+     * @param tags - Used for queries labeled with a specific tag, allowing you to invalidate by that tag.
+     * @param tables - The actual tables affected by the insert, update, or delete statements, helping you track which tables have changed since the last cache update.
+     */
+    async onMutate(params) {
+        const tagsArray = params.tags ? (Array.isArray(params.tags) ? params.tags : [params.tags]) : [];
+        const tablesArray = params.tables ? (Array.isArray(params.tables) ? params.tables : [params.tables]) : [];
+        const keysToDelete = new Set();
+        for (const table of tablesArray) {
+            const tableName = is(table, Table) ? getTableName(table) : table;
+            const keys = this.usedTablesPerKey[tableName] ?? [];
+            for (const key of keys)
+                keysToDelete.add(key);
+        }
+        if (keysToDelete.size > 0 || tagsArray.length > 0) {
+            for (const tag of tagsArray) {
+                await this.cache.then(async (cache) => cache.delete(this.getCacheKey({ tag }))).then(() => console.debug('SQLCache.delete', 'tag', tag, 'SUCCESS'));
+            }
+            for (const key of keysToDelete) {
+                await this.cache.then(async (cache) => cache.delete(this.getCacheKey({ key }))).then(() => console.debug('SQLCache.delete', 'key', key, 'SUCCESS'));
+                for (const table of tablesArray) {
+                    const tableName = is(table, Table) ? getTableName(table) : table;
+                    this.usedTablesPerKey[tableName] = [];
+                }
+            }
+        }
+    }
+}

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 export * from './buffers.mjs';
 export * from './common.mjs';
 export * from './crypto.mjs';
+export * from './db.mjs';
 export * from './discord.mjs';
 export * from './dns.mjs';
 export * from './net.mjs';

package/dist/index.mjs

@@ -1,6 +1,7 @@
 export * from './buffers.mjs';
 export * from './common.mjs';
 export * from './crypto.mjs';
+export * from './db.mjs';
 export * from './discord.mjs';
 export * from './dns.mjs';
 export * from './net.mjs';

package/dist/net.d.mts

@@ -1,5 +1,6 @@
-import type { z } from 'zod/v3';
-export type LoggingFetchInitType<RI extends RequestInit = RequestInit> = RI & z.input<Awaited<ReturnType<typeof NetHelpers.loggingFetchInit>>>;
+import type { z as z3 } from 'zod/v3';
+import type { z as z4 } from 'zod/v4';
+export type LoggingFetchInitType<RI extends RequestInit = RequestInit> = RI & z3.input<Awaited<ReturnType<typeof NetHelpers.loggingFetchInit>>>;
 /**
  * Enum representing HTTP request methods.
  *
@@ -17,12 +18,12 @@ export declare enum Methods {
     'PATCH' = "PATCH"
 }
 export declare class NetHelpers {
-    static cfApiLogging(): Promise<z.ZodDefault<z.ZodObject<{
-        level: z.ZodDefault<z.ZodNumber>;
-        error: z.ZodDefault<z.ZodNumber>;
-        color: z.ZodDefault<z.ZodBoolean>;
-        custom: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodVoid, z.ZodPromise<z.ZodVoid>]>>>;
-    }, "strip", z.ZodTypeAny, {
+    static cfApiLogging(): Promise<z3.ZodDefault<z3.ZodObject<{
+        level: z3.ZodDefault<z3.ZodNumber>;
+        error: z3.ZodDefault<z3.ZodNumber>;
+        color: z3.ZodDefault<z3.ZodBoolean>;
+        custom: z3.ZodOptional<z3.ZodFunction<z3.ZodTuple<[], z3.ZodUnknown>, z3.ZodUnion<[z3.ZodVoid, z3.ZodPromise<z3.ZodVoid>]>>>;
+    }, "strip", z3.ZodTypeAny, {
         error: number;
         level: number;
         color: boolean;
@@ -51,14 +52,14 @@ export declare class NetHelpers {
      * - Formatting and coloring log output for better readability.
      * - Stripping redundant parts of URLs and wrapping unique IDs in brackets with color coding.
      */
-    static cfApi(apiKey: string, logging?: z.input<Awaited<ReturnType<typeof NetHelpers.cfApiLogging>>>): Promise<import("cloudflare").Cloudflare>;
-    static loggingFetchInit(): Promise<z.ZodObject<{
-        logging: z.ZodDefault<z.ZodObject<{
-            level: z.ZodDefault<z.ZodNumber>;
-            error: z.ZodDefault<z.ZodNumber>;
-            color: z.ZodDefault<z.ZodBoolean>;
-            custom: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodVoid, z.ZodPromise<z.ZodVoid>]>>>;
-        }, "strip", z.ZodTypeAny, {
+    static cfApi(apiKey: string, logging?: z3.input<Awaited<ReturnType<typeof NetHelpers.cfApiLogging>>>): Promise<import("cloudflare").Cloudflare>;
+    static loggingFetchInit(): Promise<z3.ZodObject<{
+        logging: z3.ZodDefault<z3.ZodObject<{
+            level: z3.ZodDefault<z3.ZodNumber>;
+            error: z3.ZodDefault<z3.ZodNumber>;
+            color: z3.ZodDefault<z3.ZodBoolean>;
+            custom: z3.ZodOptional<z3.ZodFunction<z3.ZodTuple<[], z3.ZodUnknown>, z3.ZodUnion<[z3.ZodVoid, z3.ZodPromise<z3.ZodVoid>]>>>;
+        }, "strip", z3.ZodTypeAny, {
             error: number;
             level: number;
             color: boolean;
@@ -69,7 +70,7 @@ export declare class NetHelpers {
             level?: number | undefined;
             color?: boolean | undefined;
         }>>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strip", z3.ZodTypeAny, {
         logging: {
             error: number;
             level: number;
@@ -84,12 +85,12 @@ export declare class NetHelpers {
             color?: boolean | undefined;
         } | undefined;
     }>>;
-    static loggingFetchInitLogging(): Promise<z.ZodDefault<z.ZodObject<{
-        level: z.ZodDefault<z.ZodNumber>;
-        error: z.ZodDefault<z.ZodNumber>;
-        color: z.ZodDefault<z.ZodBoolean>;
-        custom: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodVoid, z.ZodPromise<z.ZodVoid>]>>>;
-    }, "strip", z.ZodTypeAny, {
+    static loggingFetchInitLogging(): Promise<z3.ZodDefault<z3.ZodObject<{
+        level: z3.ZodDefault<z3.ZodNumber>;
+        error: z3.ZodDefault<z3.ZodNumber>;
+        color: z3.ZodDefault<z3.ZodBoolean>;
+        custom: z3.ZodOptional<z3.ZodFunction<z3.ZodTuple<[], z3.ZodUnknown>, z3.ZodUnion<[z3.ZodVoid, z3.ZodPromise<z3.ZodVoid>]>>>;
+    }, "strip", z3.ZodTypeAny, {
         error: number;
         level: number;
         color: boolean;
@@ -171,4 +172,36 @@ export declare class NetHelpers {
      * @returns {Record<string, number | null>} An object where keys are metric names (with optional descriptions) and values are the durations in milliseconds or null.
      */
     static serverTiming(serverTimingHeader?: string): Record<string, number | null>;
+    static withRetryInit(): Promise<z4.ZodDefault<z4.ZodObject<{
+        maxRetries: z4.ZodDefault<z4.ZodInt>;
+        initialDelay: z4.ZodDefault<z4.ZodInt>;
+        maxDelay: z4.ZodDefault<z4.ZodInt>;
+        backoffFactor: z4.ZodDefault<z4.ZodInt>;
+    }, z4.core.$strip>>>;
+    /**
+     * Executes an asynchronous operation with configurable retry logic.
+     *
+     * The operation function can be a simple parameterless function or a function that has been bound with arguments (using .bind(), arrow functions, or closures).
+     *
+     * @param operation - A function that returns a Promise. Arguments should be bound/captured beforehand.
+     * @param config - Optional retry configuration
+     * @returns Promise that resolves to the result of the operation
+     *
+     * @example
+     * // Simple function with no arguments
+     * await NetHelpers.withRetry(() => fetch('/api/data'))
+     *
+     * @example
+     * // Function with arguments using arrow function closure
+     * await NetHelpers.withRetry(() => fetch(url, options))
+     *
+     * @example
+     * // Function with arguments using .bind()
+     * await NetHelpers.withRetry(fetch.bind(null, url, options))
+     *
+     * @example
+     * // With custom retry configuration
+     * await NetHelpers.withRetry(() => apiCall(), { maxRetries: 5, initialDelay: 200 })
+     */
+    static withRetry<T>(operation: () => Promise<T>, config?: z4.input<Awaited<ReturnType<typeof NetHelpers.withRetryInit>>>): Promise<T>;
 }

package/dist/net.mjs

@@ -17,15 +17,15 @@ export var Methods;
 })(Methods || (Methods = {}));
 export class NetHelpers {
     static cfApiLogging() {
-        return import('zod').then(({ z }) => z
+        return import('zod/v3').then(({ z: z3 }) => z3
             .object({
-            level: z.coerce.number().int().min(0).max(3).default(0),
-            error: z.coerce.number().int().min(0).max(3).default(1),
-            color: z.boolean().default(true),
-            custom: z
+            level: z3.coerce.number().int().min(0).max(3).default(0),
+            error: z3.coerce.number().int().min(0).max(3).default(1),
+            color: z3.boolean().default(true),
+            custom: z3
                 .function()
                 .args()
-                .returns(z.union([z.void(), z.promise(z.void())]))
+                .returns(z3.union([z3.void(), z3.promise(z3.void())]))
                 .optional(),
         })
             .default({}));
@@ -162,19 +162,19 @@ export class NetHelpers {
         }));
     }
     static loggingFetchInit() {
-        return Promise.all([import('zod'), this.loggingFetchInitLogging()]).then(([{ z }, logging]) => z.object({
+        return Promise.all([import('zod/v3'), this.loggingFetchInitLogging()]).then(([{ z: z3 }, logging]) => z3.object({
             logging,
         }));
     }
     static loggingFetchInitLogging() {
-        return import('zod').then(({ z }) => z
+        return import('zod/v3').then(({ z: z3 }) => z3
             .object({
-            level: z.coerce.number().int().min(0).max(3).default(0),
-            error: z.coerce.number().int().min(0).max(3).default(1),
-            color: z.boolean().default(true),
-            custom: z
+            level: z3.coerce.number().int().min(0).max(3).default(0),
+            error: z3.coerce.number().int().min(0).max(3).default(1),
+            color: z3.boolean().default(true),
+            custom: z3
                 .function()
-                .returns(z.union([z.void(), z.promise(z.void())]))
+                .returns(z3.union([z3.void(), z3.promise(z3.void())]))
                 .optional(),
         })
             .default({}));
@@ -501,4 +501,68 @@ export class NetHelpers {
         }
         return result;
     }
+    static withRetryInit() {
+        return import('zod/v4').then(({ z: z4 }) => z4
+            .object({
+            maxRetries: z4.int().nonnegative().default(3),
+            initialDelay: z4.int().nonnegative().default(100),
+            maxDelay: z4.int().nonnegative().default(1000),
+            backoffFactor: z4.int().nonnegative().default(2),
+        })
+            .default({
+            maxRetries: 3,
+            initialDelay: 100,
+            maxDelay: 1000,
+            backoffFactor: 2,
+        }));
+    }
+    /**
+     * Executes an asynchronous operation with configurable retry logic.
+     *
+     * The operation function can be a simple parameterless function or a function that has been bound with arguments (using .bind(), arrow functions, or closures).
+     *
+     * @param operation - A function that returns a Promise. Arguments should be bound/captured beforehand.
+     * @param config - Optional retry configuration
+     * @returns Promise that resolves to the result of the operation
+     *
+     * @example
+     * // Simple function with no arguments
+     * await NetHelpers.withRetry(() => fetch('/api/data'))
+     *
+     * @example
+     * // Function with arguments using arrow function closure
+     * await NetHelpers.withRetry(() => fetch(url, options))
+     *
+     * @example
+     * // Function with arguments using .bind()
+     * await NetHelpers.withRetry(fetch.bind(null, url, options))
+     *
+     * @example
+     * // With custom retry configuration
+     * await NetHelpers.withRetry(() => apiCall(), { maxRetries: 5, initialDelay: 200 })
+     */
+    static withRetry(operation, config) {
+        return Promise.all([NetHelpers.withRetryInit().then((parser) => parser.parseAsync(config)), import('./common.mjs')]).then(async ([config, { Helpers }]) => {
+            let lastError;
+            let delay = config.initialDelay;
+            for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+                try {
+                    const result = await operation();
+                    return result;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempt === config.maxRetries) {
+                        throw error;
+                    }
+                    // Add randomness to avoid synchronizing retries
+                    // Wait for a random delay between delay and delay*2
+                    await Helpers.sleep(delay * (1 + Math.random()));
+                    // Calculate next delay with exponential backoff
+                    delay = Math.min(delay * config.backoffFactor, config.maxDelay);
+                }
+            }
+            throw lastError;
+        });
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainfuse/helpers",
-	"version": "3.2.12",
+	"version": "3.3.1",
 	"description": "",
 	"author": "ChainFuse",
 	"homepage": "https://github.com/ChainFuse/packages/tree/main/packages/helpers#readme",
@@ -57,6 +57,10 @@
 			"import": "./dist/crypto.js",
 			"types": "./dist/crypto.d.ts"
 		},
+		"./db": {
+			"import": "./dist/db.js",
+			"types": "./dist/db.d.ts"
+		},
 		"./discord": {
 			"import": "./dist/discord.js",
 			"types": "./dist/discord.d.ts"
@@ -72,17 +76,18 @@
 	},
 	"prettier": "@demosjarco/prettier-config",
 	"dependencies": {
-		"@chainfuse/types": "^2.10.20",
+		"@chainfuse/types": "^2.10.21",
 		"@discordjs/rest": "^2.5.0",
 		"chalk": "^5.4.1",
 		"cloudflare": "^4.3.0",
+		"drizzle-orm": "^0.44.2",
 		"strip-ansi": "^7.1.0",
 		"uuid": "^11.1.0",
-		"zod": "^3.25.49"
+		"zod": "^3.25.51"
 	},
 	"devDependencies": {
-		"@cloudflare/workers-types": "^4.20250603.0",
+		"@cloudflare/workers-types": "^4.20250605.0",
 		"@types/node": "^22.15.29"
 	},
-	"gitHead": "932b7500502575cce5fc6751d594f14098bdd543"
+	"gitHead": "726cf6c05c96cf75a1213019de78835853d470aa"
 }