@powersync/capacitor 0.1.1 → 0.1.3

package/src/plugin/PowerSyncCore.ts

@@ -0,0 +1,6 @@
+import { registerPlugin } from '@capacitor/core';
+import { PowerSyncPlugin } from './PowerSyncPlugin';
+
+export const PowerSyncCore = registerPlugin<PowerSyncPlugin>('PowerSync', {
+  web: () => import('./web').then((m) => new m.PowerSyncWeb())
+});

package/src/plugin/PowerSyncPlugin.ts

@@ -0,0 +1,22 @@
+export type RegistrationResponse = {
+  /**
+   * Zero for successful registration, non-zero for failure.
+   */
+  responseCode: number;
+};
+
+export const messageForErrorCode = (code: number): string => {
+  switch (code) {
+    case 0:
+      return 'Success';
+    default:
+      return `Extension registration failed with SQLite error code: ${code}`;
+  }
+};
+
+export interface PowerSyncPlugin {
+  /**
+   * Registers the PowerSync core extension with the SQLite library.
+   */
+  registerCore(): Promise<RegistrationResponse>;
+}

package/src/plugin/web.ts

@@ -0,0 +1,9 @@
+import { WebPlugin } from '@capacitor/core';
+
+import type { PowerSyncPlugin, RegistrationResponse } from './PowerSyncPlugin';
+
+export class PowerSyncWeb extends WebPlugin implements PowerSyncPlugin {
+  async registerCore(): Promise<RegistrationResponse> {
+    throw new Error('This code path is not supported on web.');
+  }
+}

package/src/sync/CapacitorSyncImplementation.ts

@@ -0,0 +1,16 @@
+import { AbstractStreamingSyncImplementation, LockOptions } from '@powersync/web';
+import Lock from 'async-lock';
+
+export class CapacitorStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
+  static GLOBAL_LOCK = new Lock();
+
+  async obtainLock<T>(lockOptions: LockOptions<T>): Promise<T> {
+    const identifier = `streaming-sync-${lockOptions.type}-${this.options.identifier}`;
+    return CapacitorStreamingSyncImplementation.GLOBAL_LOCK.acquire(identifier, async () => {
+      if (lockOptions.signal?.aborted) {
+        throw new Error('Aborted');
+      }
+      return await lockOptions.callback();
+    });
+  }
+}