@salesforce/lds-runtime-mobile 1.112.1 → 1.113.0

package/dist/durableStore/NimbusSqliteStore/tables/LdsDraftIdMapDataTable.d.ts

@@ -1,4 +1,4 @@
-import type { SqliteStorePlugin } from 'packages/lds-mobile-nimbus-plugins/dist';
+import type { SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
 import { AbstractKeyValueDataTable } from './AbstractKeyValueDataTable';
 export declare class LdsDraftIdMapDataTable extends AbstractKeyValueDataTable {
     constructor(plugin: SqliteStorePlugin);

package/dist/durableStore/NimbusSqliteStore/tables/LdsDraftsDataTable.d.ts

@@ -1,4 +1,4 @@
-import type { SqliteStorePlugin } from 'packages/lds-mobile-nimbus-plugins/dist';
+import type { SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
 import { AbstractKeyValueDataTable } from './AbstractKeyValueDataTable';
 export declare class LdsDraftsDataTable extends AbstractKeyValueDataTable {
     constructor(plugin: SqliteStorePlugin);

package/dist/main.js

@@ -15003,8 +15003,14 @@ class PrimingSession extends EventEmitter {
         }
         // pop any pending work off the queue
         const batches = typedBatches.splice(0, typedBatches.length);
+        const before = Date.now();
         // fetch the metadata for the batches
-        const { availableBatches, unavailableTypes, unavailableIds } = await this.fetchMetadata(batches);
+        const { availableBatches, unavailableTypes, unavailableIds, availableTypes } = await this.fetchMetadata(batches);
+        this.emit('metadata-fetched', {
+            duration: Date.now() - before,
+            availableTypes,
+            unavailableTypes,
+        });
         if (unavailableIds.length > 0) {
             this.emit('error', {
                 ids: unavailableIds,
@@ -15023,14 +15029,21 @@ class PrimingSession extends EventEmitter {
     // parallelizes batches of priming work
     enqueueBatches(batches) {
         for (const batch of batches) {
+            const queuedTime = Date.now();
             this.networkWorkerPool.push({
                 workFn: (abortController) => {
+                    const workTime = Date.now();
+                    this.emit('batch-starting', { queuedTime: workTime - queuedTime });
                     return this.recordLoader
                         .fetchRecordData(batch, abortController)
                         .then(async (result) => {
                         if (abortController.signal.aborted) {
                             return;
                         }
+                        this.emit('batch-fetched', {
+                            ids: batch.ids,
+                            duration: Date.now() - workTime,
+                        });
                         if (result.ok === false) {
                             const { error } = result;
                             const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
@@ -15050,13 +15063,31 @@ class PrimingSession extends EventEmitter {
                             });
                         }
                         const { records } = result;
+                        const beforeWrite = Date.now();
                         // dispatch the write but DO NOT wait on it to unblock the network pool
                         this.recordIngestor
                             .insertRecords(records)
-                            .then(({ written, conflicted }) => {
+                            .then(({ written, conflicted, errors }) => {
+                            this.emit('batch-written', {
+                                written,
+                                conflicted,
+                                errors: errors
+                                    .map((e) => e.ids)
+                                    .reduce((a, b) => a.concat(b), []),
+                                duration: Date.now() - beforeWrite,
+                            });
                             if (abortController.signal.aborted) {
                                 return;
                             }
+                            if (errors.length > 0) {
+                                errors.forEach(({ ids, message }) => {
+                                    this.emit('error', {
+                                        ids,
+                                        code: 'unknown',
+                                        message: message,
+                                    });
+                                });
+                            }
                             // now that the records are persisted, emit the primed event
                             if (written.length > 0) {
                                 this.emit('primed', Array.from(written));
@@ -15089,6 +15120,7 @@ class PrimingSession extends EventEmitter {
         }, new Set()));
         const objectInfoMap = await this.objectInfoLoader.getObjectInfos(apiNames);
         const unavailableTypes = apiNames.filter((x) => !objectInfoMap[x]);
+        const availableTypes = apiNames.filter((x) => objectInfoMap[x]);
         const unavilableBatches = batches.filter((x) => unavailableTypes.includes(x.type));
         const availableBatches = batches.filter((x) => !unavailableTypes.includes(x.type));
         const unavailableIds = unavilableBatches.reduce((acc, x) => {
@@ -15096,9 +15128,11 @@ class PrimingSession extends EventEmitter {
             return acc;
         }, []);
         return {
+            apiNames,
             availableBatches,
             unavilableBatches,
             unavailableTypes,
+            availableTypes,
             unavailableIds,
         };
     }
@@ -15258,45 +15292,30 @@ class RecordIngestor {
      */
     async insertRecords(syntheticRecords) {
         if (syntheticRecords.length === 0) {
-            return { written: [], conflicted: [] };
+            return { written: [], conflicted: [], errors: [] };
         }
         const luvio = this.getLuvio();
         const ingestionTimestamp = Date.now();
         const ttlOverride = await luvio.storeGetTTLOverride(UiApiNamespace, RecordRepresentationType);
-        const metadata = JSON.stringify({
+        const metadata = {
             ingestionTimestamp,
             expirationTimestamp: (ttlOverride !== null && ttlOverride !== void 0 ? ttlOverride : RecordRepresentationTTL) + ingestionTimestamp,
             namespace: UiApiNamespace,
             representationName: RecordRepresentationType,
             metadataVersion: DURABLE_METADATA_VERSION,
             version: RecordRepresentationVersion,
-        });
-        const idsToPrime = new Set();
-        const written = [];
-        const rows = syntheticRecords.map((record) => {
-            idsToPrime.add(record.id);
-            return `('${keyBuilderRecord(luvio, { recordId: record.id })}', '${JSON.stringify(record)}', '${metadata}')`;
-        });
-        const dml = `INSERT or IGNORE INTO lds_data (key, data, metadata) VALUES ${rows.join(',\n')} returning key;`;
-        const result = await this.store.query(dml, []);
-        for (const row of result.rows) {
-            const id = extractRecordIdFromStoreKey(row[0]);
-            if (id) {
-                written.push(id);
-                idsToPrime.delete(id);
-            }
-        }
-        return { written: Array.from(written), conflicted: Array.from(idsToPrime) };
+        };
+        return this.store.writeRecords(syntheticRecords.map((record) => ({ record, metadata })));
     }
 }
 
 function instrumentPrimingSession(session) {
     reportPrimingSessionCreated();
-    session.on('error', (payload) => {
-        reportPrimingError(payload.code, payload.ids.length);
+    session.on('error', ({ code, ids }) => {
+        reportPrimingError(code, ids.length);
     });
-    session.on('primed', (payload) => {
-        reportPrimingSuccess(payload.length);
+    session.on('primed', ({ length }) => {
+        reportPrimingSuccess(length);
     });
     return session;
 }
@@ -15349,11 +15368,78 @@ class NimbusPrimingNetworkAdapter {
     }
 }
 
+// ref: https://gnome.pages.gitlab.gnome.org/tracker/docs/developer/limits.html?gi-language=c
+const SQLITE_MAX_VARIABLE_NUMBER = 999;
+const PARAMS_PER_RECORD = 3;
+// We need to batch the records to avoid hitting the SQLITE_MAX_VARIABLE_NUMBER limit. Each record has 3 parameters
+const BATCH_SIZE = Math.floor(SQLITE_MAX_VARIABLE_NUMBER / PARAMS_PER_RECORD);
+class SqlitePrimingStore {
+    constructor(getLuvio, store) {
+        this.getLuvio = getLuvio;
+        this.store = store;
+    }
+    async writeRecords(records) {
+        const batches = batchArray(records);
+        const writeResult = { written: [], conflicted: [], errors: [] };
+        return (await Promise.all(batches.map((batch) => this.writeBatch(batch)))).reduce((acc, curr) => {
+            acc.written.push(...curr.written);
+            acc.conflicted.push(...curr.conflicted);
+            acc.errors.push(...curr.errors);
+            return acc;
+        }, writeResult);
+    }
+    async writeBatch(records) {
+        const idsToPrime = new Set();
+        const written = [];
+        const statement = `INSERT or IGNORE INTO lds_data (key, data, metadata) VALUES ${records
+            .map((_) => `(?,?,?)`)
+            .join(',')} returning key;`;
+        const params = [];
+        records.forEach(({ record, metadata }) => {
+            idsToPrime.add(record.id);
+            const key = keyBuilderRecord(this.getLuvio(), { recordId: record.id });
+            params.push(key);
+            params.push(JSON.stringify(record));
+            params.push(JSON.stringify(metadata));
+        });
+        try {
+            const result = await this.store.query(statement, params);
+            for (const row of result.rows) {
+                const id = extractRecordIdFromStoreKey(row[0]);
+                if (id) {
+                    written.push(id);
+                    idsToPrime.delete(id);
+                }
+            }
+            return { written, conflicted: Array.from(idsToPrime), errors: [] };
+        }
+        catch (e) {
+            return {
+                written: [],
+                conflicted: [],
+                errors: [{ ids: Array.from(idsToPrime), message: e }],
+            };
+        }
+    }
+}
+function batchArray(arr, batchSize = BATCH_SIZE) {
+    const batches = [];
+    // If the array length is less than or equal to the batch size, return the array as a single batch
+    if (arr.length <= batchSize) {
+        return [arr];
+    }
+    // Split the array into batches of size batchSize
+    for (let i = 0; i < arr.length; i += batchSize) {
+        batches.push(arr.slice(i, i + batchSize));
+    }
+    return batches;
+}
+
 function primingSessionFactory(config) {
     const { store, objectInfoService, getLuvio } = config;
     const networkAdapter = new NimbusPrimingNetworkAdapter();
     const recordLoader = new RecordLoaderGraphQL(networkAdapter);
-    const recordIngestor = new RecordIngestor(store, getLuvio);
+    const recordIngestor = new RecordIngestor(new SqlitePrimingStore(getLuvio, store), getLuvio);
     const session = new PrimingSession({
         recordLoader,
         recordIngestor,
@@ -15499,4 +15585,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.112.1-1a0875b1d
+// version: 1.113.0-a8af103c9

package/dist/mocks.d.ts

@@ -0,0 +1 @@
+export { MockNimbusBinaryStorePlugin, mockNimbusBinaryStorePlugin, } from './__tests__/MockNimbusBinaryStorePlugin.js';

package/dist/priming/SqlitePrimingStore.d.ts

@@ -0,0 +1,10 @@
+import type { PrimingStore, RecordWithMetadata, WriteResult } from '@salesforce/lds-priming';
+import type { Luvio } from '@luvio/engine';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+export declare class SqlitePrimingStore implements PrimingStore {
+    private readonly getLuvio;
+    private readonly store;
+    constructor(getLuvio: () => Luvio, store: SqliteStore);
+    writeRecords(records: RecordWithMetadata[]): Promise<WriteResult>;
+    private writeBatch;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-mobile",
-    "version": "1.112.1",
+    "version": "1.113.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for mobile/hybrid environments.",
     "main": "dist/main.js",
@@ -32,10 +32,10 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-mobile"
     },
     "dependencies": {
-        "@salesforce/lds-adapters-uiapi": "^1.112.1",
-        "@salesforce/lds-bindings": "^1.112.1",
-        "@salesforce/lds-instrumentation": "^1.112.1",
-        "@salesforce/lds-priming": "^1.112.1",
+        "@salesforce/lds-adapters-uiapi": "^1.113.0",
+        "@salesforce/lds-bindings": "^1.113.0",
+        "@salesforce/lds-instrumentation": "^1.113.0",
+        "@salesforce/lds-priming": "^1.113.0",
         "@salesforce/user": "0.0.12",
         "o11y": "244.0.0"
     },
@@ -43,16 +43,16 @@
         "@luvio/engine": "0.137.1",
         "@luvio/environments": "0.137.1",
         "@luvio/graphql-parser": "0.137.1",
-        "@salesforce/lds-adapters-graphql": "^1.112.1",
-        "@salesforce/lds-drafts": "^1.112.1",
-        "@salesforce/lds-drafts-adapters-uiapi": "^1.112.1",
-        "@salesforce/lds-graphql-eval": "^1.112.1",
-        "@salesforce/lds-network-adapter": "^1.112.1",
-        "@salesforce/lds-network-nimbus": "^1.112.1",
-        "@salesforce/lds-store-binary": "^1.112.1",
-        "@salesforce/lds-store-sql": "^1.112.1",
-        "@salesforce/lds-utils-adapters": "^1.112.1",
-        "@salesforce/nimbus-plugin-lds": "^1.112.1",
+        "@salesforce/lds-adapters-graphql": "^1.113.0",
+        "@salesforce/lds-drafts": "^1.113.0",
+        "@salesforce/lds-drafts-adapters-uiapi": "^1.113.0",
+        "@salesforce/lds-graphql-eval": "^1.113.0",
+        "@salesforce/lds-network-adapter": "^1.113.0",
+        "@salesforce/lds-network-nimbus": "^1.113.0",
+        "@salesforce/lds-store-binary": "^1.113.0",
+        "@salesforce/lds-store-sql": "^1.113.0",
+        "@salesforce/lds-utils-adapters": "^1.113.0",
+        "@salesforce/nimbus-plugin-lds": "^1.113.0",
         "babel-plugin-dynamic-import-node": "^2.3.3",
         "wait-for-expect": "^3.0.2"
     },

package/sfdc/durableStore/NimbusSqliteStore/tables/LdsDraftIdMapDataTable.d.ts

@@ -1,4 +1,4 @@
-import type { SqliteStorePlugin } from 'packages/lds-mobile-nimbus-plugins/dist';
+import type { SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
 import { AbstractKeyValueDataTable } from './AbstractKeyValueDataTable';
 export declare class LdsDraftIdMapDataTable extends AbstractKeyValueDataTable {
     constructor(plugin: SqliteStorePlugin);

package/sfdc/durableStore/NimbusSqliteStore/tables/LdsDraftsDataTable.d.ts

@@ -1,4 +1,4 @@
-import type { SqliteStorePlugin } from 'packages/lds-mobile-nimbus-plugins/dist';
+import type { SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
 import { AbstractKeyValueDataTable } from './AbstractKeyValueDataTable';
 export declare class LdsDraftsDataTable extends AbstractKeyValueDataTable {
     constructor(plugin: SqliteStorePlugin);

package/sfdc/main.js

@@ -15003,8 +15003,14 @@ class PrimingSession extends EventEmitter {
         }
         // pop any pending work off the queue
         const batches = typedBatches.splice(0, typedBatches.length);
+        const before = Date.now();
         // fetch the metadata for the batches
-        const { availableBatches, unavailableTypes, unavailableIds } = await this.fetchMetadata(batches);
+        const { availableBatches, unavailableTypes, unavailableIds, availableTypes } = await this.fetchMetadata(batches);
+        this.emit('metadata-fetched', {
+            duration: Date.now() - before,
+            availableTypes,
+            unavailableTypes,
+        });
         if (unavailableIds.length > 0) {
             this.emit('error', {
                 ids: unavailableIds,
@@ -15023,14 +15029,21 @@ class PrimingSession extends EventEmitter {
     // parallelizes batches of priming work
     enqueueBatches(batches) {
         for (const batch of batches) {
+            const queuedTime = Date.now();
             this.networkWorkerPool.push({
                 workFn: (abortController) => {
+                    const workTime = Date.now();
+                    this.emit('batch-starting', { queuedTime: workTime - queuedTime });
                     return this.recordLoader
                         .fetchRecordData(batch, abortController)
                         .then(async (result) => {
                         if (abortController.signal.aborted) {
                             return;
                         }
+                        this.emit('batch-fetched', {
+                            ids: batch.ids,
+                            duration: Date.now() - workTime,
+                        });
                         if (result.ok === false) {
                             const { error } = result;
                             const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
@@ -15050,13 +15063,31 @@ class PrimingSession extends EventEmitter {
                             });
                         }
                         const { records } = result;
+                        const beforeWrite = Date.now();
                         // dispatch the write but DO NOT wait on it to unblock the network pool
                         this.recordIngestor
                             .insertRecords(records)
-                            .then(({ written, conflicted }) => {
+                            .then(({ written, conflicted, errors }) => {
+                            this.emit('batch-written', {
+                                written,
+                                conflicted,
+                                errors: errors
+                                    .map((e) => e.ids)
+                                    .reduce((a, b) => a.concat(b), []),
+                                duration: Date.now() - beforeWrite,
+                            });
                             if (abortController.signal.aborted) {
                                 return;
                             }
+                            if (errors.length > 0) {
+                                errors.forEach(({ ids, message }) => {
+                                    this.emit('error', {
+                                        ids,
+                                        code: 'unknown',
+                                        message: message,
+                                    });
+                                });
+                            }
                             // now that the records are persisted, emit the primed event
                             if (written.length > 0) {
                                 this.emit('primed', Array.from(written));
@@ -15089,6 +15120,7 @@ class PrimingSession extends EventEmitter {
         }, new Set()));
         const objectInfoMap = await this.objectInfoLoader.getObjectInfos(apiNames);
         const unavailableTypes = apiNames.filter((x) => !objectInfoMap[x]);
+        const availableTypes = apiNames.filter((x) => objectInfoMap[x]);
         const unavilableBatches = batches.filter((x) => unavailableTypes.includes(x.type));
         const availableBatches = batches.filter((x) => !unavailableTypes.includes(x.type));
         const unavailableIds = unavilableBatches.reduce((acc, x) => {
@@ -15096,9 +15128,11 @@ class PrimingSession extends EventEmitter {
             return acc;
         }, []);
         return {
+            apiNames,
             availableBatches,
             unavilableBatches,
             unavailableTypes,
+            availableTypes,
             unavailableIds,
         };
     }
@@ -15258,45 +15292,30 @@ class RecordIngestor {
      */
     async insertRecords(syntheticRecords) {
         if (syntheticRecords.length === 0) {
-            return { written: [], conflicted: [] };
+            return { written: [], conflicted: [], errors: [] };
         }
         const luvio = this.getLuvio();
         const ingestionTimestamp = Date.now();
         const ttlOverride = await luvio.storeGetTTLOverride(UiApiNamespace, RecordRepresentationType);
-        const metadata = JSON.stringify({
+        const metadata = {
             ingestionTimestamp,
             expirationTimestamp: (ttlOverride !== null && ttlOverride !== void 0 ? ttlOverride : RecordRepresentationTTL) + ingestionTimestamp,
             namespace: UiApiNamespace,
             representationName: RecordRepresentationType,
             metadataVersion: DURABLE_METADATA_VERSION,
             version: RecordRepresentationVersion,
-        });
-        const idsToPrime = new Set();
-        const written = [];
-        const rows = syntheticRecords.map((record) => {
-            idsToPrime.add(record.id);
-            return `('${keyBuilderRecord(luvio, { recordId: record.id })}', '${JSON.stringify(record)}', '${metadata}')`;
-        });
-        const dml = `INSERT or IGNORE INTO lds_data (key, data, metadata) VALUES ${rows.join(',\n')} returning key;`;
-        const result = await this.store.query(dml, []);
-        for (const row of result.rows) {
-            const id = extractRecordIdFromStoreKey(row[0]);
-            if (id) {
-                written.push(id);
-                idsToPrime.delete(id);
-            }
-        }
-        return { written: Array.from(written), conflicted: Array.from(idsToPrime) };
+        };
+        return this.store.writeRecords(syntheticRecords.map((record) => ({ record, metadata })));
     }
 }
 
 function instrumentPrimingSession(session) {
     reportPrimingSessionCreated();
-    session.on('error', (payload) => {
-        reportPrimingError(payload.code, payload.ids.length);
+    session.on('error', ({ code, ids }) => {
+        reportPrimingError(code, ids.length);
     });
-    session.on('primed', (payload) => {
-        reportPrimingSuccess(payload.length);
+    session.on('primed', ({ length }) => {
+        reportPrimingSuccess(length);
     });
     return session;
 }
@@ -15349,11 +15368,78 @@ class NimbusPrimingNetworkAdapter {
     }
 }
 
+// ref: https://gnome.pages.gitlab.gnome.org/tracker/docs/developer/limits.html?gi-language=c
+const SQLITE_MAX_VARIABLE_NUMBER = 999;
+const PARAMS_PER_RECORD = 3;
+// We need to batch the records to avoid hitting the SQLITE_MAX_VARIABLE_NUMBER limit. Each record has 3 parameters
+const BATCH_SIZE = Math.floor(SQLITE_MAX_VARIABLE_NUMBER / PARAMS_PER_RECORD);
+class SqlitePrimingStore {
+    constructor(getLuvio, store) {
+        this.getLuvio = getLuvio;
+        this.store = store;
+    }
+    async writeRecords(records) {
+        const batches = batchArray(records);
+        const writeResult = { written: [], conflicted: [], errors: [] };
+        return (await Promise.all(batches.map((batch) => this.writeBatch(batch)))).reduce((acc, curr) => {
+            acc.written.push(...curr.written);
+            acc.conflicted.push(...curr.conflicted);
+            acc.errors.push(...curr.errors);
+            return acc;
+        }, writeResult);
+    }
+    async writeBatch(records) {
+        const idsToPrime = new Set();
+        const written = [];
+        const statement = `INSERT or IGNORE INTO lds_data (key, data, metadata) VALUES ${records
+            .map((_) => `(?,?,?)`)
+            .join(',')} returning key;`;
+        const params = [];
+        records.forEach(({ record, metadata }) => {
+            idsToPrime.add(record.id);
+            const key = keyBuilderRecord(this.getLuvio(), { recordId: record.id });
+            params.push(key);
+            params.push(JSON.stringify(record));
+            params.push(JSON.stringify(metadata));
+        });
+        try {
+            const result = await this.store.query(statement, params);
+            for (const row of result.rows) {
+                const id = extractRecordIdFromStoreKey(row[0]);
+                if (id) {
+                    written.push(id);
+                    idsToPrime.delete(id);
+                }
+            }
+            return { written, conflicted: Array.from(idsToPrime), errors: [] };
+        }
+        catch (e) {
+            return {
+                written: [],
+                conflicted: [],
+                errors: [{ ids: Array.from(idsToPrime), message: e }],
+            };
+        }
+    }
+}
+function batchArray(arr, batchSize = BATCH_SIZE) {
+    const batches = [];
+    // If the array length is less than or equal to the batch size, return the array as a single batch
+    if (arr.length <= batchSize) {
+        return [arr];
+    }
+    // Split the array into batches of size batchSize
+    for (let i = 0; i < arr.length; i += batchSize) {
+        batches.push(arr.slice(i, i + batchSize));
+    }
+    return batches;
+}
+
 function primingSessionFactory(config) {
     const { store, objectInfoService, getLuvio } = config;
     const networkAdapter = new NimbusPrimingNetworkAdapter();
     const recordLoader = new RecordLoaderGraphQL(networkAdapter);
-    const recordIngestor = new RecordIngestor(store, getLuvio);
+    const recordIngestor = new RecordIngestor(new SqlitePrimingStore(getLuvio, store), getLuvio);
     const session = new PrimingSession({
         recordLoader,
         recordIngestor,
@@ -15499,4 +15585,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.112.1-1a0875b1d
+// version: 1.113.0-a8af103c9

package/sfdc/mocks.d.ts

@@ -0,0 +1 @@
+export { MockNimbusBinaryStorePlugin, mockNimbusBinaryStorePlugin, } from './__tests__/MockNimbusBinaryStorePlugin.js';

package/sfdc/priming/SqlitePrimingStore.d.ts

@@ -0,0 +1,10 @@
+import type { PrimingStore, RecordWithMetadata, WriteResult } from '@salesforce/lds-priming';
+import type { Luvio } from '@luvio/engine';
+import type { SqliteStore } from '@salesforce/lds-store-sql';
+export declare class SqlitePrimingStore implements PrimingStore {
+    private readonly getLuvio;
+    private readonly store;
+    constructor(getLuvio: () => Luvio, store: SqliteStore);
+    writeRecords(records: RecordWithMetadata[]): Promise<WriteResult>;
+    private writeBatch;
+}