@pol-studios/powersync 1.0.0 → 1.0.2

package/dist/chunk-C2RSTGDC.js

@@ -0,0 +1,726 @@
+import {
+  classifySupabaseError
+} from "./chunk-FPTDATY5.js";
+
+// src/connector/types.ts
+var defaultSchemaRouter = () => "public";
+
+// src/conflicts/detect.ts
+var TABLE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function validateTableName(table) {
+  if (!TABLE_NAME_REGEX.test(table)) {
+    throw new Error(`Invalid table name: ${table}`);
+  }
+}
+var DEFAULT_IGNORED_FIELDS = ["updatedAt", "createdAt", "_version", "id"];
+async function detectConflicts(table, recordId, localVersion, serverVersion, pendingChanges, supabase, config) {
+  const ignoredFields = /* @__PURE__ */ new Set([...DEFAULT_IGNORED_FIELDS, ...config?.ignoredFields ?? []]);
+  const filteredPendingChanges = {};
+  for (const [field, value] of Object.entries(pendingChanges)) {
+    if (!ignoredFields.has(field)) {
+      filteredPendingChanges[field] = value;
+    }
+  }
+  if (localVersion === serverVersion) {
+    return {
+      hasConflict: false,
+      conflicts: [],
+      nonConflictingChanges: Object.keys(filteredPendingChanges),
+      table,
+      recordId
+    };
+  }
+  const {
+    data: auditLogs,
+    error
+  } = await supabase.schema("core").from("AuditLog").select("oldRecord, newRecord, changeBy, changeAt").eq("tableName", table).eq("recordId_text", recordId).order("changeAt", {
+    ascending: false
+  }).limit(20);
+  if (error) {
+    console.warn("[detectConflicts] Failed to query AuditLog:", error);
+    return {
+      hasConflict: false,
+      conflicts: [],
+      nonConflictingChanges: Object.keys(filteredPendingChanges),
+      table,
+      recordId
+    };
+  }
+  const serverChanges = /* @__PURE__ */ new Map();
+  for (const log of auditLogs ?? []) {
+    const oldRec = log.oldRecord;
+    const newRec = log.newRecord;
+    if (!oldRec || !newRec) continue;
+    for (const [field, newValue] of Object.entries(newRec)) {
+      if (ignoredFields.has(field)) continue;
+      if (oldRec[field] !== newValue && !serverChanges.has(field)) {
+        serverChanges.set(field, {
+          newValue,
+          changedBy: log.changeBy,
+          changedAt: new Date(log.changeAt)
+        });
+      }
+    }
+  }
+  const conflicts = [];
+  const nonConflictingChanges = [];
+  for (const [field, localValue] of Object.entries(filteredPendingChanges)) {
+    if (serverChanges.has(field)) {
+      const serverChange = serverChanges.get(field);
+      conflicts.push({
+        field,
+        localValue,
+        serverValue: serverChange.newValue,
+        changedBy: serverChange.changedBy,
+        changedAt: serverChange.changedAt
+      });
+    } else {
+      nonConflictingChanges.push(field);
+    }
+  }
+  return {
+    hasConflict: conflicts.length > 0,
+    conflicts,
+    nonConflictingChanges,
+    table,
+    recordId
+  };
+}
+async function hasVersionColumn(table, db) {
+  try {
+    validateTableName(table);
+    const result = await db.getAll(`PRAGMA table_info("${table}")`);
+    return result.some((col) => col.name === "_version");
+  } catch {
+    return false;
+  }
+}
+async function fetchServerVersion(table, recordId, schema, supabase) {
+  const query = schema === "public" ? supabase.from(table) : supabase.schema(schema).from(table);
+  const {
+    data,
+    error
+  } = await query.select("_version").eq("id", recordId).single();
+  if (error || !data) {
+    return null;
+  }
+  return data._version ?? null;
+}
+async function getLocalVersion(table, recordId, db) {
+  validateTableName(table);
+  const result = await db.get(`SELECT _version FROM "${table}" WHERE id = ?`, [recordId]);
+  return result?._version ?? null;
+}
+
+// src/connector/supabase-connector.ts
+var SupabaseConnector = class {
+  supabase;
+  powerSyncUrl;
+  schemaRouter;
+  crudHandler;
+  logger;
+  onTransactionSuccess;
+  onTransactionFailure;
+  onTransactionComplete;
+  shouldUploadFn;
+  // Conflict detection configuration
+  conflictDetection;
+  conflictHandler;
+  conflictBus;
+  // Cache for version column existence checks (table -> hasVersionColumn)
+  versionColumnCache = /* @__PURE__ */ new Map();
+  // Active project IDs for scoped sync (optional feature)
+  activeProjectIds = [];
+  // Store resolutions for retry - when PowerSync retries, we apply stored resolutions
+  // instead of re-detecting conflicts that the user already resolved
+  resolvedConflicts = /* @__PURE__ */ new Map();
+  // Cleanup function for resolution listener subscription
+  unsubscribeResolution;
+  constructor(options) {
+    this.supabase = options.supabaseClient;
+    this.powerSyncUrl = options.powerSyncUrl;
+    this.schemaRouter = options.schemaRouter ?? defaultSchemaRouter;
+    this.crudHandler = options.crudHandler;
+    this.logger = options.logger;
+    this.onTransactionSuccess = options.onTransactionSuccess;
+    this.onTransactionFailure = options.onTransactionFailure;
+    this.onTransactionComplete = options.onTransactionComplete;
+    this.shouldUploadFn = options.shouldUpload;
+    this.conflictDetection = options.conflictDetection;
+    this.conflictHandler = options.conflictHandler;
+    this.conflictBus = options.conflictBus;
+    if (this.conflictBus) {
+      this.unsubscribeResolution = this.conflictBus.onResolution((table, recordId, resolution) => {
+        const key = `${table}:${recordId}`;
+        if (__DEV__) {
+          console.log("[Connector] Storing resolution for retry:", {
+            table,
+            recordId,
+            key,
+            resolution
+          });
+        }
+        this.resolvedConflicts.set(key, resolution);
+      });
+    }
+  }
+  /**
+   * Clean up resources (unsubscribe from event listeners).
+   * Call this when the connector is no longer needed.
+   */
+  destroy() {
+    if (this.unsubscribeResolution) {
+      this.unsubscribeResolution();
+      this.unsubscribeResolution = void 0;
+    }
+    this.resolvedConflicts.clear();
+  }
+  /**
+   * Set the active project IDs for scoped sync.
+   * Call this when user selects/opens projects.
+   */
+  setActiveProjectIds(projectIds) {
+    this.activeProjectIds = projectIds;
+  }
+  /**
+   * Get the current active project IDs.
+   */
+  getActiveProjectIds() {
+    return this.activeProjectIds;
+  }
+  /**
+   * Get credentials for PowerSync connection.
+   * Uses Supabase session token.
+   *
+   * Note: Token refresh is handled by Supabase's startAutoRefresh() which must be
+   * called on app initialization. getSession() returns the auto-refreshed token.
+   */
+  async fetchCredentials() {
+    this.logger?.debug("[Connector] Fetching credentials...");
+    const {
+      data: {
+        session
+      },
+      error
+    } = await this.supabase.auth.getSession();
+    if (error) {
+      this.logger?.error("[Connector] Auth error:", error);
+      throw new Error(`Failed to get Supabase session: ${error.message}`);
+    }
+    if (!session) {
+      this.logger?.error("[Connector] No active session");
+      throw new Error("No active Supabase session");
+    }
+    this.logger?.debug("[Connector] Credentials fetched, token expires at:", session.expires_at);
+    return {
+      endpoint: this.powerSyncUrl,
+      token: session.access_token,
+      expiresAt: session.expires_at ? new Date(session.expires_at * 1e3) : void 0
+    };
+  }
+  /**
+   * Upload local changes to Supabase.
+   * Called automatically by PowerSync when there are pending uploads.
+   *
+   * When conflict detection is enabled:
+   * 1. Checks if table has _version column (cached)
+   * 2. If yes, compares local vs server version
+   * 3. On version mismatch, queries AuditLog for field conflicts
+   * 4. If conflicts found, calls handler or publishes to conflict bus
+   * 5. Applies resolution or skips entry based on handler response
+   */
+  async uploadData(database) {
+    if (this.shouldUploadFn && !this.shouldUploadFn()) {
+      if (__DEV__) {
+        console.log("[Connector] Upload skipped - sync mode does not allow uploads");
+      }
+      this.logger?.debug("[Connector] Upload skipped - sync mode does not allow uploads");
+      return;
+    }
+    if (__DEV__) {
+      console.log("[Connector] uploadData called, fetching next CRUD transaction...");
+    }
+    const transaction = await database.getNextCrudTransaction();
+    if (!transaction) {
+      if (__DEV__) {
+        console.log("[Connector] No pending CRUD transaction found");
+      }
+      return;
+    }
+    if (__DEV__) {
+      console.log("[Connector] Transaction fetched:", {
+        crudCount: transaction.crud.length,
+        entries: transaction.crud.map((e) => ({
+          table: e.table,
+          op: e.op,
+          id: e.id,
+          opDataKeys: e.opData ? Object.keys(e.opData) : []
+        }))
+      });
+    }
+    const conflictDetectionEnabled = this.conflictDetection?.enabled !== false;
+    if (!conflictDetectionEnabled) {
+      await this.processTransaction(transaction, database);
+      return;
+    }
+    const {
+      crud
+    } = transaction;
+    const skipTables = new Set(this.conflictDetection?.skipTables ?? []);
+    const entriesToProcess = [];
+    const entriesQueuedForUI = [];
+    const entriesDiscarded = [];
+    const partialResolutions = [];
+    for (const entry of crud) {
+      if (entry.op === "DELETE") {
+        entriesToProcess.push(entry);
+        continue;
+      }
+      if (skipTables.has(entry.table)) {
+        entriesToProcess.push(entry);
+        continue;
+      }
+      const resolutionKey = `${entry.table}:${entry.id}`;
+      const existingResolution = this.resolvedConflicts.get(resolutionKey);
+      if (existingResolution) {
+        if (__DEV__) {
+          console.log("[Connector] Applying stored resolution for retry:", {
+            table: entry.table,
+            id: entry.id,
+            key: resolutionKey,
+            resolution: existingResolution
+          });
+        }
+        this.resolvedConflicts.delete(resolutionKey);
+        switch (existingResolution.action) {
+          case "overwrite":
+            entriesToProcess.push(entry);
+            break;
+          case "keep-server":
+            entriesDiscarded.push(entry);
+            break;
+          case "partial":
+            const partialEntry = {
+              ...entry,
+              opData: this.filterFields(entry.opData ?? {}, existingResolution.fields)
+            };
+            entriesToProcess.push(partialEntry);
+            break;
+        }
+        continue;
+      }
+      const hasVersion = await this.checkVersionColumn(entry.table, database);
+      if (!hasVersion) {
+        entriesToProcess.push(entry);
+        continue;
+      }
+      const localVersion = await getLocalVersion(entry.table, entry.id, database);
+      const schema = this.schemaRouter(entry.table);
+      const serverVersion = await fetchServerVersion(entry.table, entry.id, schema, this.supabase);
+      if (localVersion === null || serverVersion === null) {
+        entriesToProcess.push(entry);
+        continue;
+      }
+      const conflictResult = await detectConflicts(entry.table, entry.id, localVersion, serverVersion, entry.opData ?? {}, this.supabase, this.conflictDetection);
+      if (!conflictResult.hasConflict) {
+        entriesToProcess.push(entry);
+        continue;
+      }
+      this.conflictBus?.emitConflict(conflictResult);
+      if (this.conflictHandler) {
+        const resolution = await this.conflictHandler.onConflict(conflictResult);
+        if (resolution === null) {
+          entriesQueuedForUI.push(entry);
+          if (__DEV__) {
+            console.log("[Connector] Conflict queued for UI resolution:", {
+              table: entry.table,
+              id: entry.id,
+              conflicts: conflictResult.conflicts.map((c) => c.field)
+            });
+          }
+          continue;
+        }
+        switch (resolution.action) {
+          case "overwrite":
+            entriesToProcess.push(entry);
+            break;
+          case "keep-server":
+            entriesDiscarded.push(entry);
+            if (__DEV__) {
+              console.log("[Connector] Conflict resolved with keep-server, discarding local changes:", {
+                table: entry.table,
+                id: entry.id
+              });
+            }
+            break;
+          case "partial":
+            const partialEntry = {
+              ...entry,
+              opData: this.filterFields(entry.opData ?? {}, resolution.fields)
+            };
+            entriesToProcess.push(partialEntry);
+            partialResolutions.push({
+              originalConflict: conflictResult,
+              syncedFields: resolution.fields
+            });
+            break;
+        }
+      } else {
+        console.warn("[Connector] Conflict detected but no handler:", {
+          table: entry.table,
+          id: entry.id,
+          conflicts: conflictResult.conflicts
+        });
+        entriesToProcess.push(entry);
+      }
+    }
+    if (entriesQueuedForUI.length > 0) {
+      if (__DEV__) {
+        console.log("[Connector] Entries queued for UI resolution, leaving in queue:", {
+          queuedForUI: entriesQueuedForUI.length,
+          discarded: entriesDiscarded.length,
+          toProcess: entriesToProcess.length
+        });
+      }
+      this.onTransactionComplete?.(entriesQueuedForUI);
+      return;
+    }
+    if (entriesToProcess.length === 0 && entriesDiscarded.length > 0) {
+      if (__DEV__) {
+        console.log("[Connector] All entries resolved with keep-server, completing transaction to discard local changes");
+      }
+      try {
+        await transaction.complete();
+        this.onTransactionSuccess?.(entriesDiscarded);
+        this.onTransactionComplete?.(entriesDiscarded);
+      } catch (error) {
+        const classified = classifySupabaseError(error);
+        this.onTransactionFailure?.(entriesDiscarded, error instanceof Error ? error : new Error(String(error)), classified);
+        throw error;
+      }
+      return;
+    }
+    try {
+      for (const entry of entriesToProcess) {
+        if (__DEV__) {
+          console.log("[Connector] Processing CRUD entry:", {
+            table: entry.table,
+            op: entry.op,
+            id: entry.id,
+            opData: entry.opData
+          });
+        }
+        await this.processCrudEntry(entry);
+      }
+      if (__DEV__) {
+        console.log("[Connector] All CRUD entries processed, completing transaction...");
+      }
+      await transaction.complete();
+      if (__DEV__) {
+        console.log("[Connector] Transaction completed successfully:", {
+          entriesCount: entriesToProcess.length,
+          discardedCount: entriesDiscarded.length
+        });
+      }
+      if (this.conflictBus && partialResolutions.length > 0) {
+        for (const {
+          originalConflict,
+          syncedFields
+        } of partialResolutions) {
+          const syncedFieldSet = new Set(syncedFields);
+          const remainingConflicts = originalConflict.conflicts.filter((c) => !syncedFieldSet.has(c.field));
+          if (remainingConflicts.length > 0) {
+            if (__DEV__) {
+              console.log("[Connector] Re-emitting conflict for remaining fields:", {
+                table: originalConflict.table,
+                recordId: originalConflict.recordId,
+                syncedFields,
+                remainingConflictFields: remainingConflicts.map((c) => c.field)
+              });
+            }
+            this.conflictBus.emitConflict({
+              ...originalConflict,
+              conflicts: remainingConflicts,
+              // All remaining are conflicts now - clear nonConflictingChanges since
+              // the non-conflicting ones were already synced in the partial resolution
+              nonConflictingChanges: []
+            });
+          }
+        }
+      }
+      this.onTransactionSuccess?.(entriesToProcess);
+      this.onTransactionComplete?.(entriesToProcess);
+    } catch (error) {
+      const classified = classifySupabaseError(error);
+      console.error("[PowerSync Connector] Upload FAILED:", {
+        errorMessage: error instanceof Error ? error.message : String(error),
+        errorKeys: error && typeof error === "object" ? Object.keys(error) : [],
+        errorObject: JSON.stringify(error, null, 2),
+        classified,
+        isPermanent: classified.isPermanent,
+        entries: entriesToProcess.map((e) => ({
+          table: e.table,
+          op: e.op,
+          id: e.id
+        }))
+      });
+      this.logger?.error("[Connector] Upload error:", {
+        error,
+        classified,
+        entries: entriesToProcess.map((e) => ({
+          table: e.table,
+          op: e.op,
+          id: e.id
+        }))
+      });
+      this.onTransactionFailure?.(entriesToProcess, error instanceof Error ? error : new Error(String(error)), classified);
+      throw error;
+    }
+  }
+  /**
+   * Process a transaction without conflict detection.
+   * Used when conflict detection is disabled.
+   */
+  async processTransaction(transaction, _database) {
+    try {
+      for (const entry of transaction.crud) {
+        if (__DEV__) {
+          console.log("[Connector] Processing CRUD entry:", {
+            table: entry.table,
+            op: entry.op,
+            id: entry.id,
+            opData: entry.opData
+          });
+        }
+        await this.processCrudEntry(entry);
+      }
+      if (__DEV__) {
+        console.log("[Connector] All CRUD entries processed, completing transaction...");
+      }
+      await transaction.complete();
+      if (__DEV__) {
+        console.log("[Connector] Transaction completed successfully:", {
+          entriesCount: transaction.crud.length
+        });
+      }
+      this.onTransactionSuccess?.(transaction.crud);
+      this.onTransactionComplete?.(transaction.crud);
+    } catch (error) {
+      const classified = classifySupabaseError(error);
+      console.error("[PowerSync Connector] Upload FAILED:", {
+        errorMessage: error instanceof Error ? error.message : String(error),
+        errorKeys: error && typeof error === "object" ? Object.keys(error) : [],
+        errorObject: JSON.stringify(error, null, 2),
+        classified,
+        isPermanent: classified.isPermanent,
+        entries: transaction.crud.map((e) => ({
+          table: e.table,
+          op: e.op,
+          id: e.id
+        }))
+      });
+      this.logger?.error("[Connector] Upload error:", {
+        error,
+        classified,
+        entries: transaction.crud.map((e) => ({
+          table: e.table,
+          op: e.op,
+          id: e.id
+        }))
+      });
+      this.onTransactionFailure?.(transaction.crud, error instanceof Error ? error : new Error(String(error)), classified);
+      throw error;
+    }
+  }
+  /**
+   * Check if a table has a _version column (cached).
+   */
+  async checkVersionColumn(table, db) {
+    if (this.versionColumnCache.has(table)) {
+      return this.versionColumnCache.get(table);
+    }
+    const hasVersion = await hasVersionColumn(table, db);
+    this.versionColumnCache.set(table, hasVersion);
+    return hasVersion;
+  }
+  /**
+   * Filter opData to only include specified fields.
+   * Used for partial sync resolution.
+   */
+  filterFields(opData, fields) {
+    const fieldSet = new Set(fields);
+    const filtered = {};
+    for (const [key, value] of Object.entries(opData)) {
+      if (fieldSet.has(key)) {
+        filtered[key] = value;
+      }
+    }
+    return filtered;
+  }
+  /**
+   * Process a single CRUD operation.
+   *
+   * UUID-native tables (public schema, post-migration) use `id` as the UUID column.
+   * Core schema tables (Profile, Comment, CommentSection) still use a separate `uuid` column.
+   */
+  /**
+   * Process a single CRUD operation.
+   *
+   * All synced tables use `id` as their UUID primary key column.
+   */
+  async processCrudEntry(entry) {
+    const table = entry.table;
+    const id = entry.id;
+    const schema = this.schemaRouter(table);
+    if (this.crudHandler) {
+      let handled = false;
+      switch (entry.op) {
+        case "PUT" /* PUT */:
+          handled = await this.crudHandler.handlePut?.(entry, this.supabase, schema) ?? false;
+          break;
+        case "PATCH" /* PATCH */:
+          handled = await this.crudHandler.handlePatch?.(entry, this.supabase, schema) ?? false;
+          break;
+        case "DELETE" /* DELETE */:
+          handled = await this.crudHandler.handleDelete?.(entry, this.supabase, schema) ?? false;
+          break;
+      }
+      if (handled) {
+        this.logger?.debug(`[Connector] Custom handler processed ${entry.op} for ${schema}.${table}`);
+        return;
+      }
+    }
+    const query = schema === "public" ? this.supabase.from(table) : this.supabase.schema(schema).from(table);
+    switch (entry.op) {
+      case "PUT" /* PUT */:
+        if (__DEV__) {
+          console.log("[Connector] Executing PUT/UPSERT:", {
+            schema,
+            table,
+            id,
+            data: {
+              id,
+              ...entry.opData
+            }
+          });
+        }
+        const {
+          data: upsertData,
+          error: upsertError
+        } = await query.upsert({
+          id,
+          ...entry.opData
+        }, {
+          onConflict: "id"
+        }).select();
+        if (upsertError) {
+          if (__DEV__) {
+            console.error("[Connector] PUT/UPSERT FAILED:", {
+              schema,
+              table,
+              id,
+              error: upsertError,
+              errorMessage: upsertError.message,
+              errorCode: upsertError.code,
+              errorDetails: upsertError.details,
+              errorHint: upsertError.hint
+            });
+          }
+          throw new Error(`Upsert failed for ${schema}.${table}: ${upsertError.message}`);
+        }
+        if (__DEV__) {
+          console.log("[Connector] PUT/UPSERT SUCCESS:", {
+            schema,
+            table,
+            id,
+            responseData: upsertData
+          });
+        }
+        break;
+      case "PATCH" /* PATCH */:
+        if (__DEV__) {
+          console.log("[Connector] Executing PATCH/UPDATE:", {
+            schema,
+            table,
+            id,
+            opData: entry.opData
+          });
+        }
+        const {
+          data: updateData,
+          error: updateError
+        } = await query.update(entry.opData).eq("id", id).select();
+        if (updateError) {
+          if (__DEV__) {
+            console.error("[Connector] PATCH/UPDATE FAILED:", {
+              schema,
+              table,
+              id,
+              error: updateError,
+              errorMessage: updateError.message,
+              errorCode: updateError.code,
+              errorDetails: updateError.details,
+              errorHint: updateError.hint
+            });
+          }
+          throw new Error(`Update failed for ${schema}.${table}: ${updateError.message}`);
+        }
+        if (__DEV__) {
+          console.log("[Connector] PATCH/UPDATE SUCCESS:", {
+            schema,
+            table,
+            id,
+            responseData: updateData
+          });
+        }
+        break;
+      case "DELETE" /* DELETE */:
+        if (__DEV__) {
+          console.log("[Connector] Executing DELETE:", {
+            schema,
+            table,
+            id
+          });
+        }
+        const {
+          data: deleteData,
+          error: deleteError
+        } = await query.delete().eq("id", id).select();
+        if (deleteError) {
+          if (__DEV__) {
+            console.error("[Connector] DELETE FAILED:", {
+              schema,
+              table,
+              id,
+              error: deleteError,
+              errorMessage: deleteError.message,
+              errorCode: deleteError.code,
+              errorDetails: deleteError.details,
+              errorHint: deleteError.hint
+            });
+          }
+          throw new Error(`Delete failed for ${schema}.${table}: ${deleteError.message}`);
+        }
+        if (__DEV__) {
+          console.log("[Connector] DELETE SUCCESS:", {
+            schema,
+            table,
+            id,
+            responseData: deleteData
+          });
+        }
+        break;
+    }
+    this.logger?.debug(`[Connector] Processed ${entry.op} for ${schema}.${table} (id: ${id})`);
+  }
+};
+
+export {
+  defaultSchemaRouter,
+  detectConflicts,
+  hasVersionColumn,
+  fetchServerVersion,
+  getLocalVersion,
+  SupabaseConnector
+};
+//# sourceMappingURL=chunk-C2RSTGDC.js.map