@chainfuse/helpers 4.1.8 → 4.2.0

package/dist/crypto.d.mts

@@ -3,6 +3,7 @@ export declare class CryptoHelpers {
     static secretBytesSync(byteSize: number): Uint8Array<ArrayBufferLike>;
     static base16secret(secretLength: number): Promise<string>;
     static base62secret(secretLength: number): Promise<string>;
+    static getHashStreaming(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', body: ReadableStream<Uint8Array>): Promise<string>;
     static getHash(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', input: string | ArrayBufferLike): Promise<string>;
     /**
      * @returns Fully formatted (double quote encapsulated) `ETag` header value

package/dist/crypto.mjs

@@ -29,6 +29,9 @@ export class CryptoHelpers {
             return randomText;
         });
     }
+    static getHashStreaming(algorithm, body) {
+        return CryptoHelpersInternals.node_getHashStreaming(algorithm, body).catch(() => CryptoHelpersInternals.browser_getHashStreaming(algorithm, body));
+    }
     static getHash(algorithm, input) {
         return CryptoHelpersInternals.node_getHash(algorithm, input).catch(() => CryptoHelpersInternals.browser_getHash(algorithm, input));
     }
@@ -37,9 +40,17 @@ export class CryptoHelpers {
      * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag#etag_value
      */
     static generateETag(response, algorithm = 'SHA-512') {
-        return response
+        return (() => {
+            const body = response.clone().body;
+            if (body) {
+                return this.getHashStreaming(algorithm, body).then((hex) => `"${hex}"`);
+            }
+            else {
+                throw new Error('Response has no body to hash');
+            }
+        })().catch(() => response
             .clone()
             .arrayBuffer()
-            .then((buffer) => this.getHash(algorithm, buffer).then((hex) => `"${hex}"`));
+            .then((buffer) => this.getHash(algorithm, buffer).then((hex) => `"${hex}"`)));
     }
 }

package/dist/cryptoInternals.d.mts

@@ -1,6 +1,9 @@
 export declare class CryptoHelpersInternals {
     static node_secretBytes(byteSize: number): Promise<Uint8Array>;
     static browser_secretBytes(byteSize: number): Uint8Array;
+    private static internal_streamAsyncIterable;
+    static node_getHashStreaming(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', body: ReadableStream<Uint8Array>): Promise<string>;
+    static browser_getHashStreaming(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', body: ReadableStream<Uint8Array>): Promise<string>;
     static node_getHash(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', input: string | ArrayBufferLike): Promise<string>;
     static browser_getHash(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', input: string | ArrayBufferLike): Promise<string>;
 }

package/dist/cryptoInternals.mjs

@@ -11,6 +11,39 @@ export class CryptoHelpersInternals {
         crypto.getRandomValues(randomBytes);
         return randomBytes;
     }
+    static async *internal_streamAsyncIterable(stream) {
+        const reader = stream.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return;
+                yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    static node_getHashStreaming(algorithm, body) {
+        return import('node:crypto').then(async ({ createHash }) => {
+            const hash = createHash(algorithm.replace('-', '').toLowerCase());
+            for await (const chunk of this.internal_streamAsyncIterable(body)) {
+                hash.update(chunk);
+            }
+            return hash.digest('hex');
+        });
+    }
+    static async browser_getHashStreaming(algorithm, body) {
+        if ('DigestStream' in crypto) {
+            const digestStream = new crypto.DigestStream(algorithm);
+            await body.pipeTo(digestStream);
+            return BufferHelpers.bufferToHex(await digestStream.digest);
+        }
+        else {
+            throw new Error('`DigestStream` is not available in this environment');
+        }
+    }
     static node_getHash(algorithm, input) {
         return import('node:crypto').then(async ({ createHash }) => {
             const hash = createHash(algorithm.replace('-', '').toLowerCase());

package/dist/db.d.mts

@@ -1,14 +1,7 @@
+import type { CacheStorageLike } from '@chainfuse/types';
 import { Cache as DrizzleCache, type MutationOption } from 'drizzle-orm/cache/core';
 import type { CacheConfig } from 'drizzle-orm/cache/core/types';
 import * as z from 'zod/mini';
-/**
- * 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.

package/dist/db.mjs

@@ -140,14 +140,14 @@ export class SQLCache extends DrizzleCache {
         else if (config?.pxat) {
             ttl = Math.floor((new Date(config.pxat).getTime() - Date.now()) / 1000);
         }
-        const cacheRequest = new Response(JSON.stringify(response), {
+        const cacheResponse = 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'));
+        cacheResponse.headers.set('ETag', await CryptoHelpers.generateETag(cacheResponse));
+        await this.cache.then(async (cache) => cache.put(this.getCacheKey(isTag ? { tag: hashedQuery } : { key: hashedQuery }), cacheResponse)).then(() => console.debug('SQLCache.put', isTag ? 'tag' : 'key', hashedQuery, 'SUCCESS'));
         for (const table of tables) {
             const keys = this.usedTablesPerKey[table];
             if (keys === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainfuse/helpers",
-	"version": "4.1.8",
+	"version": "4.2.0",
 	"description": "",
 	"author": "ChainFuse",
 	"homepage": "https://github.com/ChainFuse/packages/tree/main/packages/helpers#readme",
@@ -80,7 +80,7 @@
 	},
 	"prettier": "@demosjarco/prettier-config",
 	"dependencies": {
-		"@chainfuse/types": "^4.0.9",
+		"@chainfuse/types": "^4.1.0",
 		"@discordjs/rest": "^2.6.0",
 		"chalk": "^5.6.2",
 		"cloudflare": "^5.2.0",
@@ -93,5 +93,5 @@
 		"@cloudflare/workers-types": "^4.20251014.0",
 		"@types/node": "^24.6.0"
 	},
-	"gitHead": "0152f9e28f722d1a925594bef166656a4281000a"
+	"gitHead": "f2559bafd284760bc5fce2df9e699616cf4710a3"
 }