@pol-studios/powersync 1.0.25 → 1.0.32

package/dist/types-BhAEsJj-.d.ts

@@ -0,0 +1,330 @@
+import { Schema } from '@powersync/react-native';
+import { h as UploadErrorMiddleware } from './types-DqJnP50o.js';
+import { A as AttachmentSource } from './types-JCEhw2Lf.js';
+
+/**
+ * Unified Configuration Types for @pol-studios/powersync
+ *
+ * This module defines the types for the `definePolConfig` API which provides
+ * a streamlined way to configure PowerSync with automatic schema generation.
+ */
+
+interface MinimalPowerSyncDatabase {
+    watch(sql: string, params: unknown[], callbacks: {
+        onResult: (results: {
+            rows?: {
+                _array?: unknown[];
+            };
+        }) => void;
+        onError?: (error: Error) => void;
+    }, options?: {
+        signal?: AbortSignal;
+        tables?: string[];
+        throttleMs?: number;
+    }): void;
+}
+/**
+ * Table specification for PowerSync sync.
+ *
+ * Can be either:
+ * - A string for public schema tables (e.g., "Project")
+ * - An object for custom schemas or additional options
+ *
+ * @example
+ * ```typescript
+ * // Simple - public schema
+ * powersync: ["Project", "Task"]
+ *
+ * // Custom schema
+ * powersync: [
+ *   "Project",
+ *   { table: "Profile", schema: "core" },
+ *   { table: "Comment", schema: "core", trackMetadata: true }
+ * ]
+ * ```
+ */
+type TableSpec = string | {
+    /** Table name */
+    table: string;
+    /** Schema name (default: "public") */
+    schema?: string;
+    /** Track sync metadata for this table (default: false) */
+    trackMetadata?: boolean;
+};
+
+/**
+ * Configuration for attachment sync.
+ *
+ * @example
+ * ```typescript
+ * attachments: {
+ *   source: { type: 'supabase-bucket', bucket: 'photos', signed: true },
+ *   watchPaths: (db, supabase, onUpdate) => {
+ *     const abort = new AbortController();
+ *     db.watch(
+ *       // Filter directly in the query - only emit paths you want to download
+ *       `SELECT storagePath FROM photos
+ *        WHERE storagePath IS NOT NULL
+ *        AND storagePath NOT LIKE '%.mp4'`,
+ *       [],
+ *       { onResult: (r) => onUpdate(r.rows._array.map(row => row.storagePath)) },
+ *       { signal: abort.signal }
+ *     );
+ *     return () => abort.abort();
+ *   },
+ * }
+ * ```
+ */
+interface PolConfigAttachments {
+    /**
+     * Attachment storage source configuration.
+     * Supports Supabase Storage buckets or custom backends.
+     */
+    source?: AttachmentSource;
+    /**
+     * Reactive source of attachment paths.
+     *
+     * Called once during initialization. Should set up a reactive subscription
+     * that calls `onUpdate` whenever the set of attachment paths changes.
+     *
+     * Filtering should happen in this callback - only emit paths you want to download.
+     *
+     * @param db - PowerSync database instance
+     * @param supabase - Supabase client for additional queries if needed
+     * @param onUpdate - Callback to emit current set of attachment paths
+     * @returns Optional cleanup function
+     *
+     * @example
+     * ```typescript
+     * watchPaths: (db, supabase, onUpdate) => {
+     *   const abort = new AbortController();
+     *   db.watch(
+     *     // Filter out videos directly in the query
+     *     `SELECT storagePath FROM photos
+     *      WHERE storagePath IS NOT NULL
+     *      AND storagePath NOT LIKE '%.mp4'`,
+     *     [],
+     *     { onResult: (r) => onUpdate(r.rows._array.map(row => row.storagePath)) },
+     *     { signal: abort.signal }
+     *   );
+     *   return () => abort.abort();
+     * }
+     * ```
+     */
+    watchPaths?: (db: MinimalPowerSyncDatabase, supabase: unknown, onUpdate: (paths: string[]) => void) => (() => void) | void;
+}
+/**
+ * Connector configuration for CRUD upload handling.
+ */
+interface PolConfigConnector {
+    /**
+     * Enable version-based conflict detection.
+     * @default false
+     */
+    conflictDetection?: boolean;
+    /**
+     * Middleware chain for classifying upload errors.
+     *
+     * @example
+     * ```typescript
+     * uploadErrorMiddleware: [
+     *   idempotentTables(['ReadReceipt', 'Like']),
+     *   discardOrphaned(),
+     * ]
+     * ```
+     */
+    uploadErrorMiddleware?: UploadErrorMiddleware[];
+}
+/**
+ * Sync behavior configuration.
+ */
+interface PolConfigSync {
+    /**
+     * Automatically connect when the provider mounts.
+     * @default true
+     */
+    autoConnect?: boolean;
+    /**
+     * Background sync configuration.
+     */
+    backgroundSync?: {
+        /** Enable background sync */
+        enabled: boolean;
+        /** Minimum interval between background syncs in minutes */
+        minimumInterval?: number;
+    };
+    /**
+     * Enable health monitoring.
+     * @default true
+     */
+    enableHealthMonitoring?: boolean;
+    /**
+     * Enable metrics collection.
+     * @default true
+     */
+    enableMetrics?: boolean;
+}
+/**
+ * Unified configuration for @pol-studios/powersync.
+ *
+ * This configuration is processed by `definePolConfig` to generate:
+ * - PowerSync Schema from the database schema
+ * - Table strategies for DataLayer routing
+ * - Attachment queue configuration
+ *
+ * @example
+ * ```typescript
+ * import { definePolConfig } from '@pol-studios/powersync/config';
+ * import { databaseSchema } from './databaseSchema';
+ *
+ * export const polConfig = definePolConfig({
+ *   powerSyncUrl: process.env.EXPO_PUBLIC_POWERSYNC_URL,
+ *   databaseSchema,
+ *
+ *   // Tables to sync via PowerSync
+ *   powersync: [
+ *     "Project",
+ *     "Task",
+ *     { table: "Profile", schema: "core" },
+ *   ],
+ *
+ *   attachments: {
+ *     source: { type: 'supabase-bucket', bucket: 'photos' },
+ *     watchPaths: (db, supabase, onUpdate) => {
+ *       const abort = new AbortController();
+ *       db.watch('SELECT storagePath FROM photos WHERE storagePath IS NOT NULL', [], {
+ *         onResult: (r) => onUpdate(r.rows._array.map(x => x.storagePath)),
+ *       }, { signal: abort.signal });
+ *       return () => abort.abort();
+ *     },
+ *   },
+ * });
+ * ```
+ */
+interface PolConfig {
+    /**
+     * PowerSync service URL.
+     * If not provided, runs in online-only mode (Supabase direct).
+     *
+     * @example "https://your-instance.powersync.journeyapps.com"
+     */
+    powerSyncUrl?: string;
+    /**
+     * The database schema object (from generated types).
+     * Used to auto-generate the PowerSync schema at runtime.
+     *
+     * This is the schema object exported from your generated databaseSchema.ts,
+     * which contains table definitions with columns and types.
+     */
+    databaseSchema: DatabaseSchemaObject;
+    /**
+     * Tables to sync via PowerSync (offline-first).
+     *
+     * Tables listed here will be synced to the local SQLite database.
+     * Tables NOT listed here will query Supabase directly (online-only).
+     */
+    powersync: TableSpec[];
+    /**
+     * Connector configuration for CRUD upload handling.
+     */
+    connector?: PolConfigConnector;
+    /**
+     * Attachment configuration for offline file caching.
+     */
+    attachments?: PolConfigAttachments;
+    /**
+     * Sync behavior configuration.
+     */
+    sync?: PolConfigSync;
+    /**
+     * Database filename for the local SQLite database.
+     * @default "powersync.db"
+     */
+    dbFilename?: string;
+}
+/**
+ * Table strategy for routing queries.
+ */
+type TableStrategyType = 'powersync' | 'supabase';
+/**
+ * Processed table strategy info.
+ */
+interface ProcessedTableStrategy {
+    /** Which backend to use */
+    strategy: TableStrategyType;
+    /** Original schema name */
+    schema: string;
+    /** Table name */
+    table: string;
+    /** PowerSync SQLite alias (e.g., CoreUserGroup for core.UserGroup) */
+    alias: string;
+}
+/**
+ * Processed configuration returned by `definePolConfig`.
+ *
+ * Contains the original config plus generated artifacts:
+ * - `__generatedSchema`: PowerSync Schema ready to use
+ * - `__tableStrategies`: Lookup map for table routing
+ * - `__schemaRouter`: Function to resolve table schema
+ */
+interface ProcessedPolConfig extends PolConfig {
+    /**
+     * Generated PowerSync Schema.
+     * Pass this to PowerSyncProvider or OfflineDataProvider.
+     */
+    __generatedSchema: Schema;
+    /**
+     * Table strategy lookup map.
+     * Used by DataLayerProvider to route queries to the correct backend.
+     */
+    __tableStrategies: Record<string, ProcessedTableStrategy>;
+    /**
+     * Schema router function.
+     * Returns the Supabase schema for a given table name.
+     *
+     * @param table - Table name (may include schema prefix like "core.Profile")
+     * @returns The schema name
+     */
+    __schemaRouter: (table: string) => string;
+    /**
+     * List of tables configured for PowerSync sync.
+     * Useful for deriving DataLayerConfig.
+     */
+    __powersyncTables: string[];
+}
+/**
+ * Column definition in the database schema.
+ */
+interface DatabaseColumnDef {
+    name: string;
+    /** Column type - accepts any string but common values are: 'string', 'number', 'boolean', 'date', 'enum', 'json' */
+    type: string;
+    isOptional: boolean;
+    isEnum?: boolean;
+    enumValues?: string[];
+}
+/**
+ * Table definition in the database schema.
+ */
+interface DatabaseTableDef {
+    name: string;
+    columns: DatabaseColumnDef[];
+    relationships?: Array<{
+        foreignKey: string;
+        referencedTable: string;
+        referencedColumn: string;
+    }>;
+}
+/**
+ * Schema definition structure (matches databaseSchema.ts export).
+ */
+interface DatabaseSchemaObject {
+    schemas: {
+        [schemaName: string]: {
+            tables: Record<string, DatabaseTableDef>;
+            views?: Record<string, DatabaseTableDef>;
+        };
+    };
+}
+
+export type { DatabaseSchemaObject as D, PolConfig as P, TableSpec as T, ProcessedPolConfig as a, ProcessedTableStrategy as b, PolConfigAttachments as c, PolConfigConnector as d, PolConfigSync as e, DatabaseTableDef as f, DatabaseColumnDef as g };

package/dist/{types-D0WcHrq6.d.ts → types-CGMibJKD.d.ts}

@@ -188,6 +188,14 @@ interface SupabaseClient {
                 } | null;
                 error: Error | null;
             }>;
+            getPublicUrl(path: string, options?: {
+                download?: string | boolean;
+                transform?: SupabaseTransformOptions;
+            }): {
+                data: {
+                    publicUrl: string;
+                };
+            };
             upload(path: string, file: Blob | ArrayBuffer | FormData, options?: {
                 contentType?: string;
                 upsert?: boolean;

package/dist/{types-DiBvmGEi.d.ts → types-DqJnP50o.d.ts}

@@ -1,5 +1,5 @@
 import { SupabaseClient } from '@supabase/supabase-js';
-import { C as CrudEntry, i as ClassifiedError } from './types-CDqWh56B.js';
+import { C as CrudEntry, i as ClassifiedError } from './types-B9MptP7E.js';
 import { LoggerAdapter } from './platform/index.js';
 
 /**
@@ -201,9 +201,9 @@ interface SupabaseConnectorOptions {
      */
     conflictBus?: ConflictBus;
     /**
-     * Optional: Configuration for retry behavior on upload failures.
-     * Allows customizing retry attempts, delays, and backoff for different error types.
-     * @default DEFAULT_RETRY_CONFIG
+     * @deprecated No longer used. The connector no longer has internal retry loops.
+     * PowerSync SDK handles all retries naturally via its uploadData() recall mechanism.
+     * Use `uploadErrorMiddleware` to classify errors as transient (retry) or permanent (fail).
      */
     retryConfig?: Partial<RetryConfig>;
     /**
@@ -215,15 +215,17 @@ interface SupabaseConnectorOptions {
     circuitBreaker?: ConnectorCircuitBreakerConfig;
     /**
      * Optional: Middleware chain for classifying upload errors.
-     * Allows customizing error handling for specific tables or error codes.
+     * This is the single source of truth for error handling decisions.
      *
      * Middleware functions are called in order until one returns a non-'continue' result:
-     * - 'success': Treat as successful (e.g., idempotent duplicate)
-     * - 'retry': Use the retry configuration to retry the operation
-     * - 'discard': Permanent failure, remove from queue without retry
-     * - 'continue': Pass to the next middleware in the chain
+     * - 'success': Treat as completed (e.g., idempotent duplicate already exists)
+     * - 'discard': Remove from queue silently (e.g., orphaned record)
+     * - 'retry': Transient error - throw to let PowerSync retry on next sync cycle
+     * - 'fail_transaction': Permanent error - record failure and surface to user
+     * - 'continue': Pass to next middleware (default: uses isPermanent from classifySupabaseError)
      *
-     * If all middleware return 'continue', the default classification is used.
+     * Architecture: No internal retry loops. PowerSync SDK handles all retries.
+     * This keeps error handling simple and predictable.
      *
      * @example
      * ```typescript
@@ -275,11 +277,14 @@ interface ConnectorConfig {
         refreshThresholdSeconds?: number;
     };
     /**
-     * Optional retry configuration for upload failures.
-     * Allows customizing retry attempts, delays, and backoff for different error types.
-     * @default DEFAULT_RETRY_CONFIG
+     * @deprecated No longer used. PowerSync SDK handles all retries.
      */
     retryConfig?: Partial<RetryConfig>;
+    /**
+     * Optional: Middleware chain for classifying upload errors.
+     * Passed to SupabaseConnector for error handling decisions.
+     */
+    uploadErrorMiddleware?: UploadErrorMiddleware[];
 }
 /**
  * Function that determines which Supabase schema a table belongs to.
@@ -360,18 +365,11 @@ interface RetryConfig {
     rls: RetryStrategyConfig;
 }
 /**
- * Default retry configuration
- *
- * Uses fast exponential backoff for transient errors (network issues):
- * - Transient: 1s → 2s → 4s
- *
- * RLS/permission errors (42501, row-level security violations) use extended delays
- * because parent data may need time to sync before child records can be inserted.
- * - RLS: 30s → 60s → 120s → 120s → 120s (5 retries over ~7.5 minutes)
+ * @deprecated No longer used. The connector no longer has internal retry loops.
+ * PowerSync SDK handles all retries via its uploadData() recall mechanism.
+ * Use `uploadErrorMiddleware` to classify errors as transient (retry) or permanent (fail).
  *
- * Other permanent errors (validation, constraints) get NO retries
- * because they will never succeed - fail fast and surface to user.
- * PowerSync's native retry mechanism will re-attempt on next sync cycle.
+ * Kept for backwards compatibility only.
  */
 declare const DEFAULT_RETRY_CONFIG: RetryConfig;
 /**