@powersync/web 0.0.0-dev-20240506092851

package/lib/src/worker/db/SharedWASQLiteDB.worker.js

@@ -0,0 +1,57 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import '@journeyapps/wa-sqlite';
+import * as Comlink from 'comlink';
+import { v4 as uuid } from 'uuid';
+import { _openDB } from './open-db';
+const _self = self;
+const DBMap = new Map();
+const OPEN_DB_LOCK = 'open-wasqlite-db';
+const openDB = (dbFileName) => __awaiter(void 0, void 0, void 0, function* () {
+    // Prevent multiple simultaneous opens from causing race conditions
+    return navigator.locks.request(OPEN_DB_LOCK, () => __awaiter(void 0, void 0, void 0, function* () {
+        const clientId = uuid();
+        if (!DBMap.has(dbFileName)) {
+            const clientIds = new Set();
+            const connection = yield _openDB(dbFileName);
+            DBMap.set(dbFileName, {
+                clientIds,
+                db: connection
+            });
+        }
+        const dbEntry = DBMap.get(dbFileName);
+        dbEntry.clientIds.add(clientId);
+        const { db } = dbEntry;
+        const wrappedConnection = Object.assign(Object.assign({}, db), { close: Comlink.proxy(() => {
+                var _a;
+                const { clientIds } = dbEntry;
+                clientIds.delete(clientId);
+                if (clientIds.size == 0) {
+                    console.debug(`Closing connection to ${dbFileName}.`);
+                    DBMap.delete(dbFileName);
+                    return (_a = db.close) === null || _a === void 0 ? void 0 : _a.call(db);
+                }
+                console.debug(`Connection to ${dbFileName} not closed yet due to active clients.`);
+            }) });
+        return Comlink.proxy(wrappedConnection);
+    }));
+});
+_self.onconnect = function (event) {
+    const port = event.ports[0];
+    console.debug('Exposing db on port', port);
+    Comlink.expose(openDB, port);
+};
+addEventListener('unload', () => {
+    Array.from(DBMap.values()).forEach((dbConnection) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const db = yield dbConnection.db;
+        (_a = db.close) === null || _a === void 0 ? void 0 : _a.call(db);
+    }));
+});

package/lib/src/worker/db/WASQLiteDB.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -0,0 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as Comlink from 'comlink';
+import { _openDB } from './open-db';
+Comlink.expose((dbFileName) => __awaiter(void 0, void 0, void 0, function* () { return Comlink.proxy(yield _openDB(dbFileName)); }));

package/lib/src/worker/db/open-db.d.ts

@@ -0,0 +1,20 @@
+import '@journeyapps/wa-sqlite';
+import { QueryResult } from '@powersync/common';
+export type WASQLExecuteResult = Omit<QueryResult, 'rows'> & {
+    rows: {
+        _array: any[];
+        length: number;
+    };
+};
+export type DBWorkerInterface = {
+    close?: () => void;
+    execute: WASQLiteExecuteMethod;
+    executeBatch: WASQLiteExecuteBatchMethod;
+    registerOnTableChange: (callback: OnTableChangeCallback) => void;
+};
+export type WASQLiteExecuteMethod = (sql: string, params?: any[]) => Promise<WASQLExecuteResult>;
+export type WASQLiteExecuteBatchMethod = (sql: string, params?: any[]) => Promise<WASQLExecuteResult>;
+export type OnTableChangeCallback = (opType: number, tableName: string, rowId: number) => void;
+export type OpenDB = (dbFileName: string) => DBWorkerInterface;
+export type SQLBatchTuple = [string] | [string, Array<any> | Array<Array<any>>];
+export declare function _openDB(dbFileName: string): Promise<DBWorkerInterface>;

package/lib/src/worker/db/open-db.js

@@ -0,0 +1,192 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import * as SQLite from '@journeyapps/wa-sqlite';
+import '@journeyapps/wa-sqlite';
+import * as Comlink from 'comlink';
+import { v4 as uuid } from 'uuid';
+export function _openDB(dbFileName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { default: moduleFactory } = yield import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
+        const module = yield moduleFactory();
+        const sqlite3 = SQLite.Factory(module);
+        const { IDBBatchAtomicVFS } = yield import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
+        const vfs = new IDBBatchAtomicVFS(dbFileName);
+        sqlite3.vfs_register(vfs, true);
+        const db = yield sqlite3.open_v2(dbFileName);
+        /**
+         * Listeners are exclusive to the DB connection.
+         */
+        const listeners = new Map();
+        sqlite3.register_table_onchange_hook(db, (opType, tableName, rowId) => {
+            Array.from(listeners.values()).forEach((l) => l(opType, tableName, rowId));
+        });
+        const registerOnTableChange = (callback) => {
+            const id = uuid();
+            listeners.set(id, callback);
+            return Comlink.proxy(() => {
+                listeners.delete(id);
+            });
+        };
+        /**
+         * This executes single SQL statements inside a requested lock.
+         */
+        const execute = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
+            // Running multiple statements on the same connection concurrently should not be allowed
+            return _acquireExecuteLock(() => __awaiter(this, void 0, void 0, function* () {
+                return executeSingleStatement(sql, bindings);
+            }));
+        });
+        /**
+         * This requests a lock for executing statements.
+         * Should only be used interanlly.
+         */
+        const _acquireExecuteLock = (callback) => {
+            return navigator.locks.request(`db-execute-${dbFileName}`, callback);
+        };
+        /**
+         * This executes a single statement using SQLite3.
+         */
+        const executeSingleStatement = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const results = [];
+            try {
+                for (var _d = true, _e = __asyncValues(sqlite3.statements(db, sql)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const stmt = _c;
+                    let columns;
+                    const wrappedBindings = bindings ? [bindings] : [[]];
+                    for (const binding of wrappedBindings) {
+                        // TODO not sure why this is needed currently, but booleans break
+                        binding.forEach((b, index, arr) => {
+                            if (typeof b == 'boolean') {
+                                arr[index] = b ? 1 : 0;
+                            }
+                        });
+                        sqlite3.reset(stmt);
+                        if (bindings) {
+                            sqlite3.bind_collection(stmt, binding);
+                        }
+                        const rows = [];
+                        while ((yield sqlite3.step(stmt)) === SQLite.SQLITE_ROW) {
+                            const row = sqlite3.row(stmt);
+                            rows.push(row);
+                        }
+                        columns = columns !== null && columns !== void 0 ? columns : sqlite3.column_names(stmt);
+                        if (columns.length) {
+                            results.push({ columns, rows });
+                        }
+                    }
+                    // When binding parameters, only a single statement is executed.
+                    if (bindings) {
+                        break;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            const rows = [];
+            for (const resultset of results) {
+                for (const row of resultset.rows) {
+                    const outRow = {};
+                    resultset.columns.forEach((key, index) => {
+                        outRow[key] = row[index];
+                    });
+                    rows.push(outRow);
+                }
+            }
+            const result = {
+                insertId: sqlite3.last_insert_id(db),
+                rowsAffected: sqlite3.changes(db),
+                rows: {
+                    _array: rows,
+                    length: rows.length
+                }
+            };
+            return result;
+        });
+        /**
+         * This executes SQL statements in a batch.
+         */
+        const executeBatch = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
+            return _acquireExecuteLock(() => __awaiter(this, void 0, void 0, function* () {
+                let affectedRows = 0;
+                const str = sqlite3.str_new(db, sql);
+                const query = sqlite3.str_value(str);
+                try {
+                    yield executeSingleStatement('BEGIN TRANSACTION');
+                    //Prepare statement once
+                    const prepared = yield sqlite3.prepare_v2(db, query);
+                    if (prepared === null) {
+                        return {
+                            rowsAffected: 0
+                        };
+                    }
+                    const wrappedBindings = bindings ? bindings : [];
+                    for (const binding of wrappedBindings) {
+                        // TODO not sure why this is needed currently, but booleans break
+                        for (let i = 0; i < binding.length; i++) {
+                            const b = binding[i];
+                            if (typeof b == 'boolean') {
+                                binding[i] = b ? 1 : 0;
+                            }
+                        }
+                        //Reset bindings
+                        sqlite3.reset(prepared.stmt);
+                        if (bindings) {
+                            sqlite3.bind_collection(prepared.stmt, binding);
+                        }
+                        const result = yield sqlite3.step(prepared.stmt);
+                        if (result === SQLite.SQLITE_DONE) {
+                            //The value returned by sqlite3_changes() immediately after an INSERT, UPDATE or DELETE statement run on a view is always zero.
+                            affectedRows += sqlite3.changes(db);
+                        }
+                    }
+                    //Finalize prepared statement
+                    yield sqlite3.finalize(prepared.stmt);
+                    yield executeSingleStatement('COMMIT');
+                }
+                catch (err) {
+                    yield executeSingleStatement('ROLLBACK');
+                    return {
+                        rowsAffected: 0
+                    };
+                }
+                finally {
+                    sqlite3.str_finish(str);
+                }
+                const result = {
+                    rowsAffected: affectedRows
+                };
+                return result;
+            }));
+        });
+        return {
+            execute: Comlink.proxy(execute),
+            executeBatch: Comlink.proxy(executeBatch),
+            registerOnTableChange: Comlink.proxy(registerOnTableChange),
+            close: Comlink.proxy(() => {
+                sqlite3.close(db);
+            })
+        };
+    });
+}

package/lib/src/worker/db/open-worker-database.d.ts

@@ -0,0 +1,11 @@
+import * as Comlink from 'comlink';
+import { OpenDB } from './open-db';
+/**
+ * Opens a shared or dedicated worker which exposes opening of database connections
+ */
+export declare function openWorkerDatabasePort(workerIdentifier: string, multipleTabs?: boolean): MessagePort | Worker;
+/**
+ * @returns A function which allows for opening database connections inside
+ * a worker.
+ */
+export declare function getWorkerDatabaseOpener(workerIdentifier: string, multipleTabs?: boolean): Comlink.Remote<OpenDB>;

package/lib/src/worker/db/open-worker-database.js

@@ -0,0 +1,30 @@
+import * as Comlink from 'comlink';
+/**
+ * Opens a shared or dedicated worker which exposes opening of database connections
+ */
+export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true) {
+    /**
+     *  Webpack V5 can bundle the worker automatically if the full Worker constructor syntax is used
+     *  https://webpack.js.org/guides/web-workers/
+     *  This enables multi tab support by default, but falls back if SharedWorker is not available
+     *  (in the case of Android)
+     */
+    return multipleTabs
+        ? new SharedWorker(new URL('./SharedWASQLiteDB.worker.js', import.meta.url), {
+            /* @vite-ignore */
+            name: `shared-DB-worker-${workerIdentifier}`,
+            type: 'module'
+        }).port
+        : new Worker(new URL('./WASQLiteDB.worker.js', import.meta.url), {
+            /* @vite-ignore */
+            name: `DB-worker-${workerIdentifier}`,
+            type: 'module'
+        });
+}
+/**
+ * @returns A function which allows for opening database connections inside
+ * a worker.
+ */
+export function getWorkerDatabaseOpener(workerIdentifier, multipleTabs = true) {
+    return Comlink.wrap(openWorkerDatabasePort(workerIdentifier, multipleTabs));
+}

package/lib/src/worker/sync/AbstractSharedSyncClientProvider.d.ts

@@ -0,0 +1,17 @@
+import { PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+/**
+ * The client side port should provide these methods.
+ */
+export declare abstract class AbstractSharedSyncClientProvider {
+    abstract fetchCredentials(): Promise<PowerSyncCredentials | null>;
+    abstract uploadCrud(): Promise<void>;
+    abstract statusChanged(status: SyncStatusOptions): void;
+    abstract trace(...x: any[]): void;
+    abstract debug(...x: any[]): void;
+    abstract info(...x: any[]): void;
+    abstract log(...x: any[]): void;
+    abstract warn(...x: any[]): void;
+    abstract error(...x: any[]): void;
+    abstract time(label: string): void;
+    abstract timeEnd(label: string): void;
+}

package/lib/src/worker/sync/AbstractSharedSyncClientProvider.js

@@ -0,0 +1,5 @@
+/**
+ * The client side port should provide these methods.
+ */
+export class AbstractSharedSyncClientProvider {
+}

package/lib/src/worker/sync/BroadcastLogger.d.ts

@@ -0,0 +1,37 @@
+import { ILogLevel, ILogger } from 'js-logger';
+import { type WrappedSyncPort } from './SharedSyncImplementation';
+/**
+ * Broadcasts logs to all clients
+ */
+export declare class BroadcastLogger implements ILogger {
+    protected clients: WrappedSyncPort[];
+    TRACE: ILogLevel;
+    DEBUG: ILogLevel;
+    INFO: ILogLevel;
+    TIME: ILogLevel;
+    WARN: ILogLevel;
+    ERROR: ILogLevel;
+    OFF: ILogLevel;
+    constructor(clients: WrappedSyncPort[]);
+    trace(...x: any[]): void;
+    debug(...x: any[]): void;
+    info(...x: any[]): void;
+    log(...x: any[]): void;
+    warn(...x: any[]): void;
+    error(...x: any[]): void;
+    time(label: string): void;
+    timeEnd(label: string): void;
+    setLevel(level: ILogLevel): void;
+    getLevel(): ILogLevel;
+    enabledFor(level: ILogLevel): boolean;
+    /**
+     * Iterates all clients, catches individual client exceptions
+     * and proceeds to execute for all clients.
+     */
+    protected iterateClients(callback: (client: WrappedSyncPort) => Promise<void>): Promise<void>;
+    /**
+     * Guards against any logging errors.
+     * We don't want a logging exception to cause further issues upstream
+     */
+    protected sanitizeArgs(x: any[]): any[];
+}

package/lib/src/worker/sync/BroadcastLogger.js

@@ -0,0 +1,107 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Logger from 'js-logger';
+/**
+ * Broadcasts logs to all clients
+ */
+export class BroadcastLogger {
+    constructor(clients) {
+        this.clients = clients;
+        this.TRACE = Logger.TRACE;
+        this.DEBUG = Logger.DEBUG;
+        this.INFO = Logger.INFO;
+        this.TIME = Logger.TIME;
+        this.WARN = Logger.WARN;
+        this.ERROR = Logger.ERROR;
+        this.OFF = Logger.OFF;
+    }
+    trace(...x) {
+        console.trace(...x);
+        const sanitized = this.sanitizeArgs(x);
+        this.iterateClients((client) => client.clientProvider.trace(...sanitized));
+    }
+    debug(...x) {
+        console.debug(...x);
+        const sanitized = this.sanitizeArgs(x);
+        this.iterateClients((client) => client.clientProvider.debug(...sanitized));
+    }
+    info(...x) {
+        console.info(...x);
+        const sanitized = this.sanitizeArgs(x);
+        this.iterateClients((client) => client.clientProvider.info(...sanitized));
+    }
+    log(...x) {
+        console.log(...x);
+        const sanitized = this.sanitizeArgs(x);
+        this.iterateClients((client) => client.clientProvider.log(...sanitized));
+    }
+    warn(...x) {
+        console.warn(...x);
+        const sanitized = this.sanitizeArgs(x);
+        this.iterateClients((client) => client.clientProvider.warn(...sanitized));
+    }
+    error(...x) {
+        console.error(...x);
+        const sanitized = this.sanitizeArgs(x);
+        this.iterateClients((client) => client.clientProvider.error(...sanitized));
+    }
+    time(label) {
+        console.time(label);
+        this.iterateClients((client) => client.clientProvider.time(label));
+    }
+    timeEnd(label) {
+        console.timeEnd(label);
+        this.iterateClients((client) => client.clientProvider.timeEnd(label));
+    }
+    setLevel(level) {
+        // Levels are not adjustable on this level.
+    }
+    getLevel() {
+        // Levels are not adjustable on this level.
+        return Logger.INFO;
+    }
+    enabledFor(level) {
+        // Levels are not adjustable on this level.
+        return true;
+    }
+    /**
+     * Iterates all clients, catches individual client exceptions
+     * and proceeds to execute for all clients.
+     */
+    iterateClients(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let client of this.clients) {
+                try {
+                    yield callback(client);
+                }
+                catch (ex) {
+                    console.error('Caught exception when iterating client', ex);
+                }
+            }
+        });
+    }
+    /**
+     * Guards against any logging errors.
+     * We don't want a logging exception to cause further issues upstream
+     */
+    sanitizeArgs(x) {
+        const sanitizedParams = x.map((param) => {
+            try {
+                // Try and clone here first. If it fails it won't be passable over a MessagePort
+                return structuredClone(param);
+            }
+            catch (ex) {
+                console.error(ex);
+                return 'Could not serialize log params. Check shared worker logs for more details.';
+            }
+        });
+        return sanitizedParams;
+    }
+}

package/lib/src/worker/sync/SharedSyncImplementation.d.ts

@@ -0,0 +1,88 @@
+import * as Comlink from 'comlink';
+import { ILogger } from 'js-logger';
+import { AbstractStreamingSyncImplementation, StreamingSyncImplementation, BaseObserver, LockOptions, StreamingSyncImplementationListener, SyncStatus, SyncStatusOptions } from '@powersync/common';
+import { WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
+import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
+/**
+ * Manual message events for shared sync clients
+ */
+export declare enum SharedSyncClientEvent {
+    /**
+     * This client requests the shared sync manager should
+     * close it's connection to the client.
+     */
+    CLOSE_CLIENT = "close-client"
+}
+export type ManualSharedSyncPayload = {
+    event: SharedSyncClientEvent;
+    data: any;
+};
+export type SharedSyncInitOptions = {
+    dbName: string;
+    streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote'>;
+};
+export interface SharedSyncImplementationListener extends StreamingSyncImplementationListener {
+    initialized: () => void;
+}
+export type WrappedSyncPort = {
+    port: MessagePort;
+    clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
+};
+export type RemoteOperationAbortController = {
+    controller: AbortController;
+    activePort: WrappedSyncPort;
+};
+/**
+ * Shared sync implementation which runs inside a shared webworker
+ */
+export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> implements StreamingSyncImplementation {
+    protected ports: WrappedSyncPort[];
+    protected syncStreamClient?: AbstractStreamingSyncImplementation;
+    protected isInitialized: Promise<void>;
+    protected statusListener?: () => void;
+    protected fetchCredentialsController?: RemoteOperationAbortController;
+    protected uploadDataController?: RemoteOperationAbortController;
+    syncStatus: SyncStatus;
+    broadCastLogger: ILogger;
+    constructor();
+    waitForStatus(status: SyncStatusOptions): Promise<void>;
+    get lastSyncedAt(): Date | undefined;
+    get isConnected(): boolean;
+    waitForReady(): Promise<void>;
+    /**
+     * Configures the DBAdapter connection and a streaming sync client.
+     */
+    init(dbWorkerPort: MessagePort, params: SharedSyncInitOptions): Promise<void>;
+    dispose(): Promise<void | undefined>;
+    /**
+     * Connects to the PowerSync backend instance.
+     * Multiple tabs can safely call this in their initialization.
+     * The connection will simply be reconnected whenever a new tab
+     * connects.
+     */
+    connect(): Promise<any>;
+    disconnect(): Promise<any>;
+    /**
+     * Adds a new client tab's message port to the list of connected ports
+     */
+    addPort(port: MessagePort): void;
+    /**
+     * Removes a message port client from this manager's managed
+     * clients.
+     */
+    removePort(port: MessagePort): void;
+    triggerCrudUpload(): void;
+    obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
+    hasCompletedSync(): Promise<boolean>;
+    getWriteCheckpoint(): Promise<string>;
+    /**
+     * A method to update the all shared statuses for each
+     * client.
+     */
+    private updateAllStatuses;
+    /**
+     * A function only used for unit tests which updates the internal
+     * sync stream client and all tab client's sync status
+     */
+    private _testUpdateAllStatuses;
+}