fix js message size not being properly implemented

magiccodingman · magiccodingman · commit 28942c02f239 · 2025-05-31T12:17:29.000-04:00
diff --git a/Magic.IndexedDb/Cache.cs b/Magic.IndexedDb/Cache.cs
@@ -8,7 +8,6 @@ namespace Magic.IndexedDb
 {
     internal static class Cache
     {
-        public static long JsMessageSizeBytes { get; set; } = 31000;
         /// <summary>
         /// this is the wwwroot path of "./magicDB.js" for importing the script
         /// </summary>
diff --git a/Magic.IndexedDb/Extensions/MagicJsInvoke.cs b/Magic.IndexedDb/Extensions/MagicJsInvoke.cs
@@ -16,10 +16,12 @@ namespace Magic.IndexedDb.Extensions
     internal class MagicJsInvoke
     {
         private readonly IJSObjectReference _jsModule;
+        private readonly long _jsMessageSizeBytes;
 
-        public MagicJsInvoke(IJSObjectReference jsModule)
+        public MagicJsInvoke(IJSObjectReference jsModule, long jsMessageSizeBytes)
         {
             _jsModule = jsModule;
+            _jsMessageSizeBytes = jsMessageSizeBytes;
         }
 
         internal async Task CallJsAsync(string modulePath, string functionName,
@@ -131,7 +133,7 @@ internal async Task CallInvokeVoidDefaultJsAsync(string modulePath, string funct
 
             // Send to JS
             var responseStreamRef = await _jsModule.InvokeAsync<IJSStreamReference>("streamedJsHandler", 
-                streamRef, instanceId, DotNetObjectReference.Create(this), Cache.JsMessageSizeBytes);
+                streamRef, instanceId, DotNetObjectReference.Create(this), _jsMessageSizeBytes);
 
             // 🚀 Convert the stream reference back to JSON in C#
             await using var responseStream = await responseStreamRef.OpenReadStreamAsync(long.MaxValue, token);
diff --git a/Magic.IndexedDb/Extensions/MagicUtilities.cs b/Magic.IndexedDb/Extensions/MagicUtilities.cs
@@ -11,15 +11,17 @@ namespace Magic.IndexedDb.Extensions
     internal class MagicUtilities : IMagicUtilities
     {
         readonly IJSObjectReference _jsModule;
+        private readonly long _jsMessageSizeBytes;
 
         /// <summary>
         /// Ctor
         /// </summary>
         /// <param name="dbStore"></param>
         /// <param name="jsRuntime"></param>
-        public MagicUtilities(IJSObjectReference jsRuntime)
+        public MagicUtilities(IJSObjectReference jsRuntime, long jsMessageSizeBytes)
         {
             this._jsModule = jsRuntime;
+            _jsMessageSizeBytes = jsMessageSizeBytes;
         }
 
 
@@ -29,7 +31,7 @@ public MagicUtilities(IJSObjectReference jsRuntime)
         /// <returns></returns>
         public Task<QuotaUsage> GetStorageEstimateAsync(CancellationToken cancellationToken = default)
         {
-            return new MagicJsInvoke(_jsModule).
+            return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).
                 CallJsAsync<QuotaUsage>(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.GET_STORAGE_ESTIMATE, cancellationToken, [])!;
         }
diff --git a/Magic.IndexedDb/Factories/MagicDbFactory.cs b/Magic.IndexedDb/Factories/MagicDbFactory.cs
@@ -17,8 +17,12 @@ internal class MagicDbFactory : IMagicIndexedDb, IAsyncDisposable
         // null value indicates that the factory is disposed
         Lazy<Task<IJSObjectReference>>? _jsModule;
         Lazy<Task<IndexedDbManager>> _magicJsManager;
+        private readonly long _jsMessageSizeBytes;
+        public long JsMessageSizeBytes => _jsMessageSizeBytes;
+
         public MagicDbFactory(IJSRuntime jSRuntime, long jsMessageSizeBytes)
         {
+            _jsMessageSizeBytes = jsMessageSizeBytes;
             this._jsModule = new(() => jSRuntime.InvokeAsync<IJSObjectReference>(
                 "import",
                 "./_content/Magic.IndexedDb/magicDbMethods.js").AsTask(),
@@ -30,15 +34,15 @@ public MagicDbFactory(IJSRuntime jSRuntime, long jsMessageSizeBytes)
 
                 var dbSchemas = SchemaHelper.GetAllSchemas();
                 // Create & Open the database (formerly in IndexedDbManager)
-                var manager = new IndexedDbManager(jsModule);
+                var manager = new IndexedDbManager(jsModule, _jsMessageSizeBytes);
 
                 var dbSets = SchemaHelper.GetAllIndexedDbSets();
 
                 if (dbSets != null)
                 {
                     foreach (var dbSet in dbSets)
                     {
-                        await new MagicJsInvoke(jsModule).CallJsAsync(Cache.MagicDbJsImportPath,
+                        await new MagicJsInvoke(jsModule, _jsMessageSizeBytes).CallJsAsync(Cache.MagicDbJsImportPath,
                             IndexedDbFunctions.CREATE_LEGACY, default,
                             new TypedArgument<DbStore>(new DbStore()
                             {
@@ -103,7 +107,7 @@ public async Task<QuotaUsage> GetStorageEstimateAsync(CancellationToken cancella
             ObjectDisposedException.ThrowIf(this._jsModule is null, this);
 
             var jsModule = await this._jsModule.Value;
-            var magicUtility = new MagicUtilities(jsModule);
+            var magicUtility = new MagicUtilities(jsModule, _jsMessageSizeBytes);
             return await magicUtility.GetStorageEstimateAsync();
         }
         [Obsolete("Not fully implemented yet until full migration protocol finished.")]
diff --git a/Magic.IndexedDb/IndexDbManager.cs b/Magic.IndexedDb/IndexDbManager.cs
@@ -25,15 +25,17 @@ namespace Magic.IndexedDb
     internal class IndexedDbManager
     {
         private readonly IJSObjectReference _jsModule;  // Shared JS module
+        private readonly long _jsMessageSizeBytes;
 
         /// <summary>
         /// Ctor
         /// </summary>
         /// <param name="dbStore"></param>
         /// <param name="jsRuntime"></param>
-        internal IndexedDbManager(IJSObjectReference jsModule)
+        internal IndexedDbManager(IJSObjectReference jsModule, long jsMessageSizeBytes)
         {
             _jsModule = jsModule; // Use shared JS module reference
+            _jsMessageSizeBytes = jsMessageSizeBytes;
         }
 
         //public string DbName => _dbStore.Name;
@@ -49,7 +51,7 @@ internal Task DeleteDbAsync(string dbName)
             {
                 throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));
             }
-            return new MagicJsInvoke(_jsModule).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath, 
+            return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath, 
                 IndexedDbFunctions.DELETE_DB, dbName);
         }
 
@@ -59,7 +61,7 @@ internal Task CloseDbAsync(string dbName)
             {
                 throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));
             }
-            return new MagicJsInvoke(_jsModule).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,
+            return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.CLOSE_DB, dbName);
         }
 
@@ -69,7 +71,7 @@ internal Task OpenDbAsync(string dbName)
             {
                 throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));
             }
-            return new MagicJsInvoke(_jsModule).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,
+            return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.OPEN_DB, dbName);
         }
 
@@ -79,7 +81,7 @@ internal Task<bool> DoesDbExist(string dbName)
             {
                 throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));
             }
-            return new MagicJsInvoke(_jsModule).CallInvokeDefaultJsAsync<bool>(Cache.MagicDbJsImportPath,
+            return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeDefaultJsAsync<bool>(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.DOES_DB_EXIST, dbName);
         }
 
@@ -89,7 +91,7 @@ internal Task<bool> IsDbOpen(string dbName)
             {
                 throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));
             }
-            return new MagicJsInvoke(_jsModule).CallInvokeDefaultJsAsync<bool>(Cache.MagicDbJsImportPath,
+            return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeDefaultJsAsync<bool>(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.IS_DB_CLosed, dbName);
         }
 
@@ -103,7 +105,7 @@ internal async Task<TKey> AddAsync<T, TKey>(T record, string dbName, Cancellatio
                 StoreName = schemaName,
                 Record = record
             };
-            return await new MagicJsInvoke(_jsModule).CallJsAsync<TKey>(Cache.MagicDbJsImportPath, 
+            return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<TKey>(Cache.MagicDbJsImportPath, 
                 IndexedDbFunctions.ADD_ITEM, cancellationToken, new TypedArgument<StoreRecord<T?>>(RecordToSend))
                 ?? throw new Exception($"An Error occurred trying to add your record of type: {typeof(T).Name}");
         }
@@ -122,7 +124,7 @@ internal Task BulkAddRecordAsync<T>(
         {
             // TODO: https://github.com/magiccodingman/Magic.IndexedDb/issues/9
 
-            return new MagicJsInvoke(_jsModule).CallJsAsync(Cache.MagicDbJsImportPath, IndexedDbFunctions.BULKADD_ITEM, cancellationToken,
+            return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync(Cache.MagicDbJsImportPath, IndexedDbFunctions.BULKADD_ITEM, cancellationToken,
                 new ITypedArgument[] { new TypedArgument<string>(dbName),
                     new TypedArgument<string>(storeName),
                     new TypedArgument<IEnumerable<T>>(recordsToBulkAdd) });
@@ -146,13 +148,13 @@ internal async Task<int> UpdateAsync<T>(T item, string dbName, CancellationToken
                 Record = item
             };
 
-            return await new MagicJsInvoke(_jsModule).CallJsAsync<int>(Cache.MagicDbJsImportPath,
+            return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<int>(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.UPDATE_ITEM, cancellationToken, new TypedArgument<UpdateRecord<T?>>(record));
         }
 
         internal async Task<int> CountEntireTableAsync<T>(string schemaName, string dbName)
         {
-            return await new MagicJsInvoke(_jsModule).CallInvokeDefaultJsAsync<int>(Cache.MagicDbJsImportPath,
+            return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeDefaultJsAsync<int>(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.COUNT_TABLE,
                 dbName, schemaName
                 );
@@ -179,7 +181,7 @@ internal async Task<int> UpdateRangeAsync<T>(
                 };
             });
 
-            return await new MagicJsInvoke(_jsModule).CallJsAsync<int>(Cache.MagicDbJsImportPath,
+            return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<int>(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.BULKADD_UPDATE, cancellationToken, new TypedArgument<IEnumerable<UpdateRecord<T>>>(recordsToUpdate));
         }
 
@@ -218,7 +220,7 @@ internal IMagicDatabaseScoped Database(IndexedDbManager manager, IndexedDbSet in
                 new TypedArgument<bool>(query?.ForceCursorMode??false),
             };
 
-            return await new MagicJsInvoke(_jsModule).CallJsAsync<IEnumerable<T>>
+            return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<IEnumerable<T>>
                 (Cache.MagicDbJsImportPath, IndexedDbFunctions.MAGIC_QUERY_ASYNC, cancellationToken,
                 args);
         }
@@ -249,7 +251,7 @@ internal IMagicDatabaseScoped Database(IndexedDbManager manager, IndexedDbSet in
     };
 
             // Yield results **as they arrive** from JS
-            await foreach (var item in new MagicJsInvoke(_jsModule).CallYieldJsAsync<T>(Cache.MagicDbJsImportPath, IndexedDbFunctions.MAGIC_QUERY_YIELD, cancellationToken, args))
+            await foreach (var item in new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallYieldJsAsync<T>(Cache.MagicDbJsImportPath, IndexedDbFunctions.MAGIC_QUERY_YIELD, cancellationToken, args))
             {
                 yield return item; // Stream each item immediately
             }
@@ -269,7 +271,7 @@ internal async Task DeleteAsync<T>(T item, string dbName, CancellationToken canc
                 Record = item
             };
 
-            await new MagicJsInvoke(_jsModule).CallJsAsync(Cache.MagicDbJsImportPath, IndexedDbFunctions.DELETE_ITEM, cancellationToken, new TypedArgument<UpdateRecord<T?>>(record));
+            await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync(Cache.MagicDbJsImportPath, IndexedDbFunctions.DELETE_ITEM, cancellationToken, new TypedArgument<UpdateRecord<T?>>(record));
         }
 
         internal async Task<int> DeleteRangeAsync<T>(
@@ -290,7 +292,7 @@ internal async Task<int> DeleteRangeAsync<T>(
                 new TypedArgument<string>(schemaName),
                 new TypedArgument<IEnumerable<object>?>(keys) };
 
-            return await new MagicJsInvoke(_jsModule).CallJsAsync<int>(Cache.MagicDbJsImportPath,
+            return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<int>(Cache.MagicDbJsImportPath,
                 IndexedDbFunctions.BULK_DELETE, cancellationToken,
                 args);
         }
@@ -304,7 +306,7 @@ internal async Task<int> DeleteRangeAsync<T>(
         /// <returns></returns>
         internal Task ClearTableAsync(string storeName, string dbName)
         {
-            return new MagicJsInvoke(_jsModule).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath, 
+            return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath, 
                 IndexedDbFunctions.CLEAR_TABLE, dbName, storeName);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@ namespace Magic.IndexedDb`
`8`	`8`	`{`
`9`	`9`	`internal static class Cache`
`10`	`10`	`{`
`11`		`- public static long JsMessageSizeBytes { get; set; } = 31000;`
`12`	`11`	`/// <summary>`
`13`	`12`	`/// this is the wwwroot path of "./magicDB.js" for importing the script`
`14`	`13`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -16,10 +16,12 @@ namespace Magic.IndexedDb.Extensions`
`16`	`16`	`internal class MagicJsInvoke`
`17`	`17`	`{`
`18`	`18`	`private readonly IJSObjectReference _jsModule;`
	`19`	`+ private readonly long _jsMessageSizeBytes;`
`19`	`20`
`20`		`- public MagicJsInvoke(IJSObjectReference jsModule)`
	`21`	`+ public MagicJsInvoke(IJSObjectReference jsModule, long jsMessageSizeBytes)`
`21`	`22`	`{`
`22`	`23`	`_jsModule = jsModule;`
	`24`	`+ _jsMessageSizeBytes = jsMessageSizeBytes;`
`23`	`25`	`}`
`24`	`26`
`25`	`27`	`internal async Task CallJsAsync(string modulePath, string functionName,`
`@@ -131,7 +133,7 @@ internal async Task CallInvokeVoidDefaultJsAsync(string modulePath, string funct`
`131`	`133`
`132`	`134`	`// Send to JS`
`133`	`135`	`var responseStreamRef = await _jsModule.InvokeAsync<IJSStreamReference>("streamedJsHandler",`
`134`		`- streamRef, instanceId, DotNetObjectReference.Create(this), Cache.JsMessageSizeBytes);`
	`136`	`+ streamRef, instanceId, DotNetObjectReference.Create(this), _jsMessageSizeBytes);`
`135`	`137`
`136`	`138`	`// 🚀 Convert the stream reference back to JSON in C#`
`137`	`139`	`await using var responseStream = await responseStreamRef.OpenReadStreamAsync(long.MaxValue, token);`
Original file line number	Diff line number	Diff line change
`@@ -11,15 +11,17 @@ namespace Magic.IndexedDb.Extensions`
`11`	`11`	`internal class MagicUtilities : IMagicUtilities`
`12`	`12`	`{`
`13`	`13`	`readonly IJSObjectReference _jsModule;`
	`14`	`+ private readonly long _jsMessageSizeBytes;`
`14`	`15`
`15`	`16`	`/// <summary>`
`16`	`17`	`/// Ctor`
`17`	`18`	`/// </summary>`
`18`	`19`	`/// <param name="dbStore"></param>`
`19`	`20`	`/// <param name="jsRuntime"></param>`
`20`		`- public MagicUtilities(IJSObjectReference jsRuntime)`
	`21`	`+ public MagicUtilities(IJSObjectReference jsRuntime, long jsMessageSizeBytes)`
`21`	`22`	`{`
`22`	`23`	`this._jsModule = jsRuntime;`
	`24`	`+ _jsMessageSizeBytes = jsMessageSizeBytes;`
`23`	`25`	`}`
`24`	`26`
`25`	`27`
`@@ -29,7 +31,7 @@ public MagicUtilities(IJSObjectReference jsRuntime)`
`29`	`31`	`/// <returns></returns>`
`30`	`32`	`public Task<QuotaUsage> GetStorageEstimateAsync(CancellationToken cancellationToken = default)`
`31`	`33`	`{`
`32`		`- return new MagicJsInvoke(_jsModule).`
	`34`	`+ return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).`
`33`	`35`	`CallJsAsync<QuotaUsage>(Cache.MagicDbJsImportPath,`
`34`	`36`	`IndexedDbFunctions.GET_STORAGE_ESTIMATE, cancellationToken, [])!;`
`35`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,15 +25,17 @@ namespace Magic.IndexedDb`
`25`	`25`	`internal class IndexedDbManager`
`26`	`26`	`{`
`27`	`27`	`private readonly IJSObjectReference _jsModule; // Shared JS module`
	`28`	`+ private readonly long _jsMessageSizeBytes;`
`28`	`29`
`29`	`30`	`/// <summary>`
`30`	`31`	`/// Ctor`
`31`	`32`	`/// </summary>`
`32`	`33`	`/// <param name="dbStore"></param>`
`33`	`34`	`/// <param name="jsRuntime"></param>`
`34`		`- internal IndexedDbManager(IJSObjectReference jsModule)`
	`35`	`+ internal IndexedDbManager(IJSObjectReference jsModule, long jsMessageSizeBytes)`
`35`	`36`	`{`
`36`	`37`	`_jsModule = jsModule; // Use shared JS module reference`
	`38`	`+ _jsMessageSizeBytes = jsMessageSizeBytes;`
`37`	`39`	`}`
`38`	`40`
`39`	`41`	`//public string DbName => _dbStore.Name;`
`@@ -49,7 +51,7 @@ internal Task DeleteDbAsync(string dbName)`
`49`	`51`	`{`
`50`	`52`	`throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));`
`51`	`53`	`}`
`52`		`- return new MagicJsInvoke(_jsModule).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,`
	`54`	`+ return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,`
`53`	`55`	`IndexedDbFunctions.DELETE_DB, dbName);`
`54`	`56`	`}`
`55`	`57`
`@@ -59,7 +61,7 @@ internal Task CloseDbAsync(string dbName)`
`59`	`61`	`{`
`60`	`62`	`throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));`
`61`	`63`	`}`
`62`		`- return new MagicJsInvoke(_jsModule).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,`
	`64`	`+ return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,`
`63`	`65`	`IndexedDbFunctions.CLOSE_DB, dbName);`
`64`	`66`	`}`
`65`	`67`
`@@ -69,7 +71,7 @@ internal Task OpenDbAsync(string dbName)`
`69`	`71`	`{`
`70`	`72`	`throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));`
`71`	`73`	`}`
`72`		`- return new MagicJsInvoke(_jsModule).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,`
	`74`	`+ return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,`
`73`	`75`	`IndexedDbFunctions.OPEN_DB, dbName);`
`74`	`76`	`}`
`75`	`77`
`@@ -79,7 +81,7 @@ internal Task<bool> DoesDbExist(string dbName)`
`79`	`81`	`{`
`80`	`82`	`throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));`
`81`	`83`	`}`
`82`		`- return new MagicJsInvoke(_jsModule).CallInvokeDefaultJsAsync<bool>(Cache.MagicDbJsImportPath,`
	`84`	`+ return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeDefaultJsAsync<bool>(Cache.MagicDbJsImportPath,`
`83`	`85`	`IndexedDbFunctions.DOES_DB_EXIST, dbName);`
`84`	`86`	`}`
`85`	`87`
`@@ -89,7 +91,7 @@ internal Task<bool> IsDbOpen(string dbName)`
`89`	`91`	`{`
`90`	`92`	`throw new ArgumentException("dbName cannot be null or empty", nameof(dbName));`
`91`	`93`	`}`
`92`		`- return new MagicJsInvoke(_jsModule).CallInvokeDefaultJsAsync<bool>(Cache.MagicDbJsImportPath,`
	`94`	`+ return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeDefaultJsAsync<bool>(Cache.MagicDbJsImportPath,`
`93`	`95`	`IndexedDbFunctions.IS_DB_CLosed, dbName);`
`94`	`96`	`}`
`95`	`97`
`@@ -103,7 +105,7 @@ internal async Task<TKey> AddAsync<T, TKey>(T record, string dbName, Cancellatio`
`103`	`105`	`StoreName = schemaName,`
`104`	`106`	`Record = record`
`105`	`107`	`};`
`106`		`- return await new MagicJsInvoke(_jsModule).CallJsAsync<TKey>(Cache.MagicDbJsImportPath,`
	`108`	`+ return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<TKey>(Cache.MagicDbJsImportPath,`
`107`	`109`	`IndexedDbFunctions.ADD_ITEM, cancellationToken, new TypedArgument<StoreRecord<T?>>(RecordToSend))`
`108`	`110`	`?? throw new Exception($"An Error occurred trying to add your record of type: {typeof(T).Name}");`
`109`	`111`	`}`
`@@ -122,7 +124,7 @@ internal Task BulkAddRecordAsync<T>(`
`122`	`124`	`{`
`123`	`125`	`// TODO: https://github.com/magiccodingman/Magic.IndexedDb/issues/9`
`124`	`126`
`125`		`- return new MagicJsInvoke(_jsModule).CallJsAsync(Cache.MagicDbJsImportPath, IndexedDbFunctions.BULKADD_ITEM, cancellationToken,`
	`127`	`+ return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync(Cache.MagicDbJsImportPath, IndexedDbFunctions.BULKADD_ITEM, cancellationToken,`
`126`	`128`	`new ITypedArgument[] { new TypedArgument<string>(dbName),`
`127`	`129`	`new TypedArgument<string>(storeName),`
`128`	`130`	`new TypedArgument<IEnumerable<T>>(recordsToBulkAdd) });`
`@@ -146,13 +148,13 @@ internal async Task<int> UpdateAsync<T>(T item, string dbName, CancellationToken`
`146`	`148`	`Record = item`
`147`	`149`	`};`
`148`	`150`
`149`		`- return await new MagicJsInvoke(_jsModule).CallJsAsync<int>(Cache.MagicDbJsImportPath,`
	`151`	`+ return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<int>(Cache.MagicDbJsImportPath,`
`150`	`152`	`IndexedDbFunctions.UPDATE_ITEM, cancellationToken, new TypedArgument<UpdateRecord<T?>>(record));`
`151`	`153`	`}`
`152`	`154`
`153`	`155`	`internal async Task<int> CountEntireTableAsync<T>(string schemaName, string dbName)`
`154`	`156`	`{`
`155`		`- return await new MagicJsInvoke(_jsModule).CallInvokeDefaultJsAsync<int>(Cache.MagicDbJsImportPath,`
	`157`	`+ return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeDefaultJsAsync<int>(Cache.MagicDbJsImportPath,`
`156`	`158`	`IndexedDbFunctions.COUNT_TABLE,`
`157`	`159`	`dbName, schemaName`
`158`	`160`	`);`
`@@ -179,7 +181,7 @@ internal async Task<int> UpdateRangeAsync<T>(`
`179`	`181`	`};`
`180`	`182`	`});`
`181`	`183`
`182`		`- return await new MagicJsInvoke(_jsModule).CallJsAsync<int>(Cache.MagicDbJsImportPath,`
	`184`	`+ return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<int>(Cache.MagicDbJsImportPath,`
`183`	`185`	`IndexedDbFunctions.BULKADD_UPDATE, cancellationToken, new TypedArgument<IEnumerable<UpdateRecord<T>>>(recordsToUpdate));`
`184`	`186`	`}`
`185`	`187`
`@@ -218,7 +220,7 @@ internal IMagicDatabaseScoped Database(IndexedDbManager manager, IndexedDbSet in`
`218`	`220`	`new TypedArgument<bool>(query?.ForceCursorMode??false),`
`219`	`221`	`};`
`220`	`222`
`221`		`- return await new MagicJsInvoke(_jsModule).CallJsAsync<IEnumerable<T>>`
	`223`	`+ return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<IEnumerable<T>>`
`222`	`224`	`(Cache.MagicDbJsImportPath, IndexedDbFunctions.MAGIC_QUERY_ASYNC, cancellationToken,`
`223`	`225`	`args);`
`224`	`226`	`}`
`@@ -249,7 +251,7 @@ internal IMagicDatabaseScoped Database(IndexedDbManager manager, IndexedDbSet in`
`249`	`251`	`};`
`250`	`252`
`251`	`253`	`// Yield results as they arrive from JS`
`252`		`- await foreach (var item in new MagicJsInvoke(_jsModule).CallYieldJsAsync<T>(Cache.MagicDbJsImportPath, IndexedDbFunctions.MAGIC_QUERY_YIELD, cancellationToken, args))`
	`254`	`+ await foreach (var item in new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallYieldJsAsync<T>(Cache.MagicDbJsImportPath, IndexedDbFunctions.MAGIC_QUERY_YIELD, cancellationToken, args))`
`253`	`255`	`{`
`254`	`256`	`yield return item; // Stream each item immediately`
`255`	`257`	`}`
`@@ -269,7 +271,7 @@ internal async Task DeleteAsync<T>(T item, string dbName, CancellationToken canc`
`269`	`271`	`Record = item`
`270`	`272`	`};`
`271`	`273`
`272`		`- await new MagicJsInvoke(_jsModule).CallJsAsync(Cache.MagicDbJsImportPath, IndexedDbFunctions.DELETE_ITEM, cancellationToken, new TypedArgument<UpdateRecord<T?>>(record));`
	`274`	`+ await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync(Cache.MagicDbJsImportPath, IndexedDbFunctions.DELETE_ITEM, cancellationToken, new TypedArgument<UpdateRecord<T?>>(record));`
`273`	`275`	`}`
`274`	`276`
`275`	`277`	`internal async Task<int> DeleteRangeAsync<T>(`
`@@ -290,7 +292,7 @@ internal async Task<int> DeleteRangeAsync<T>(`
`290`	`292`	`new TypedArgument<string>(schemaName),`
`291`	`293`	`new TypedArgument<IEnumerable<object>?>(keys) };`
`292`	`294`
`293`		`- return await new MagicJsInvoke(_jsModule).CallJsAsync<int>(Cache.MagicDbJsImportPath,`
	`295`	`+ return await new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallJsAsync<int>(Cache.MagicDbJsImportPath,`
`294`	`296`	`IndexedDbFunctions.BULK_DELETE, cancellationToken,`
`295`	`297`	`args);`
`296`	`298`	`}`
`@@ -304,7 +306,7 @@ internal async Task<int> DeleteRangeAsync<T>(`
`304`	`306`	`/// <returns></returns>`
`305`	`307`	`internal Task ClearTableAsync(string storeName, string dbName)`
`306`	`308`	`{`
`307`		`- return new MagicJsInvoke(_jsModule).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,`
	`309`	`+ return new MagicJsInvoke(_jsModule, _jsMessageSizeBytes).CallInvokeVoidDefaultJsAsync(Cache.MagicDbJsImportPath,`
`308`	`310`	`IndexedDbFunctions.CLEAR_TABLE, dbName, storeName);`
`309`	`311`	`}`
`310`	`312`