@pol-studios/db 1.0.58 → 1.0.59

package/dist/{useResolveFeedback-CuUkdHoR.d.ts → useResolveFeedback-thFi-4h8.d.ts}

@@ -1,17 +1,17 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { UseMutationResult, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import { QueryOptions, DataLayerConfig, TableStrategy, DatabaseSchema } from './core/index.js';
+import { T as TableDataAdapter, A as AdapterQueryResult, d as AdapterDependencies, g as AdapterAutoDetector, i as AutoDetectionResult, C as CapableDataAdapter, c as AdapterCapabilities } from './DataLayerContext-V5FotiSk.js';
 import { SupabaseClient, PostgrestSingleResponse as PostgrestSingleResponse$1, PostgrestError } from '@supabase/supabase-js';
-import { T as TableDataAdapter, C as CapableDataAdapter, c as AdapterCapabilities, A as AdapterQueryResult } from './DataLayerContext-BYZtDD0g.js';
-import { DatabaseSchema, QueryOptions } from './core/index.js';
 import { FunctionsResponse } from '@supabase/functions-js';
 import * as _supabase_postgrest_js from '@supabase/postgrest-js';
 import { PostgrestSingleResponse } from '@supabase/postgrest-js';
 import { G as GetResult } from './select-query-parser-BwyHum1L.js';
 import { G as GenericTable } from './types-CYr9JiUE.js';
 import { D as Database } from './useSupabase-DSZNeXnF.js';
-import { D as DbChangeLog, Q as QueryState } from './index-CFUuTzXO.js';
+import { D as DbChangeLog, Q as QueryState } from './index-vwVJ0BWj.js';
 import { U as UseDbQuerySingleReturn } from './useDbQuery-C-TL8jY1.js';
-import { J as UseDbUpsertResult } from './useDbCount-Ckb-FhZk.js';
+import { J as UseDbUpsertResult } from './useDbCount-dCkdaBpP.js';
 import { Moment } from 'moment';
 import * as react from 'react';
 import { ReactNode } from 'react';
@@ -39,6 +39,430 @@ declare function useMutationSuccess<TData, TError, TVariables>(mutation: UseMuta
  */
 declare function useMutationSuccessRN<TData, TError, TVariables>(mutation: UseMutationResult<TData, TError, TVariables>, options?: UseMutationSuccessOptions): UseMutationResult<TData, TError, TVariables>;
 
+/**
+ * Minimal interface for sync tracking callbacks.
+ * Intentionally decoupled from the full SyncControl to keep
+ * the adapter layer independent of React context types.
+ */
+interface SyncTracker {
+    addPendingMutation: (entry: {
+        id: string;
+        table: string;
+        op: string;
+        opData?: unknown;
+        createdAt?: Date;
+    }) => void;
+    removePendingMutation: (id: string) => void;
+}
+/**
+ * Decorator that wraps a TableDataAdapter and automatically
+ * tracks pending mutations via SyncTracker callbacks.
+ *
+ * Read operations (query, queryById, subscribe) are passed
+ * through without modification. Mutation operations (insert,
+ * update, upsert, delete) are wrapped with addPendingMutation
+ * before the write and removePendingMutation on error.
+ *
+ * NOTE: The syncTracker can be null/undefined during initialization
+ * due to React's useEffect timing. The adapter handles this gracefully
+ * by using optional chaining - mutations still work, just without tracking.
+ */
+declare class SyncTrackingAdapter implements TableDataAdapter {
+    private readonly inner;
+    private readonly syncTracker;
+    readonly name: string;
+    constructor(inner: TableDataAdapter, syncTracker: SyncTracker | null | undefined);
+    query<T>(table: string, options: QueryOptions): Promise<AdapterQueryResult<T>>;
+    queryById<T>(table: string, id: string, options?: Pick<QueryOptions, "select">): Promise<T | null>;
+    subscribe<T>(table: string, options: QueryOptions, callback: (data: T[]) => void): () => void;
+    insert<T>(table: string, data: Partial<T>): Promise<T>;
+    update<T>(table: string, id: string, data: Partial<T>): Promise<T>;
+    upsert<T>(table: string, data: Partial<T>): Promise<T>;
+    delete(table: string, id: string): Promise<void>;
+    /** Get the underlying unwrapped adapter */
+    getInnerAdapter(): TableDataAdapter;
+}
+
+/**
+ * V3 Data Layer Adapter Registry
+ *
+ * Factory that creates and manages adapter instances based on table configuration.
+ * Uses lazy initialization to create adapters on first access.
+ */
+
+/**
+ * Strip schema prefix from a table name.
+ *
+ * Examples:
+ * - "core.Profile" → "Profile"
+ * - "billing.Invoice" → "Invoice"
+ * - "Profile" → "Profile" (no schema, unchanged)
+ *
+ * @param tableName - Table name, optionally schema-qualified
+ * @returns Table name without schema prefix
+ */
+declare function stripSchemaPrefix(tableName: string): string;
+/**
+ * Generate a PowerSync alias from a schema-qualified table name.
+ * Use this when there are conflicting table names across schemas.
+ *
+ * Examples:
+ * - "core.Profile" → "CoreProfile"
+ * - "billing.Invoice" → "BillingInvoice"
+ * - "Profile" → "Profile" (no schema, unchanged)
+ *
+ * @param tableName - Table name, optionally schema-qualified
+ * @returns PascalCase alias suitable for PowerSync schema
+ */
+declare function generatePowerSyncAlias(tableName: string): string;
+/**
+ * Get the PowerSync alias for a table from its strategy config.
+ *
+ * Resolution order:
+ * 1. Explicit alias in strategy config → use it
+ * 2. Schema-qualified name → strip schema (e.g., "core.Profile" → "Profile")
+ * 3. Unqualified name → use as-is
+ *
+ * Note: If you have conflicting table names (e.g., both "core.Profile" and "public.Profile"),
+ * you MUST set an explicit `alias` in the config for at least one of them.
+ *
+ * @param tableName - Table name (may be schema-qualified)
+ * @param strategy - Table strategy config
+ * @returns The alias to use in PowerSync schema
+ */
+declare function getPowerSyncAlias(tableName: string, strategy: TableStrategy | undefined): string;
+/**
+ * Registry that manages and provides adapters based on table configuration.
+ *
+ * The registry:
+ * - Stores configuration for table strategies
+ * - Lazily creates adapters when first accessed
+ * - Caches created adapters for reuse
+ * - Provides default fallback for unconfigured tables
+ *
+ * Usage:
+ * ```typescript
+ * const registry = createAdapterRegistry(config);
+ *
+ * // Later, when providers initialize:
+ * registry.setPowerSyncAdapter(powerSyncAdapter);
+ * registry.setSupabaseAdapter(supabaseAdapter);
+ *
+ * // Get adapter for a table:
+ * const adapter = registry.getAdapter("Project");
+ * ```
+ */
+declare class AdapterRegistry {
+    private config;
+    /**
+     * Cache of created adapters by table name
+     */
+    private adapters;
+    /**
+     * PowerSync adapter instance (set during initialization or lazily via getter)
+     */
+    private powerSyncAdapter;
+    /**
+     * Getter function to retrieve PowerSync database instance.
+     * Used for lazy initialization when PowerSync becomes available after registry creation.
+     */
+    private powerSyncGetter;
+    /**
+     * Factory function to create PowerSync adapter from database instance.
+     * Set via setPowerSyncGetter along with the getter.
+     */
+    private powerSyncAdapterFactory;
+    /**
+     * Supabase adapter instance (set during initialization)
+     */
+    private supabaseAdapter;
+    /**
+     * Cached adapter instance (wraps Supabase with TanStack Query)
+     */
+    private cachedAdapter;
+    /**
+     * Dependencies for creating adapters
+     */
+    private deps;
+    /**
+     * Whether the registry has been initialized with adapters
+     */
+    private _isInitialized;
+    /**
+     * Auto-detector instance for automatic backend selection
+     */
+    private autoDetector;
+    /**
+     * Sync tracker for mutation tracking
+     */
+    private syncTracker;
+    /**
+     * Sync tracking adapter that wraps PowerSync adapter
+     */
+    private syncTrackingAdapter;
+    /**
+     * Listeners for backend change events
+     */
+    private backendChangeListeners;
+    /**
+     * Last auto-detection result for debugging and status
+     */
+    private lastDetectionResult;
+    /**
+     * Create a new adapter registry
+     *
+     * @param config - Data layer configuration with table strategies
+     */
+    constructor(config: DataLayerConfig);
+    /**
+     * Check if the registry has been initialized
+     */
+    get isInitialized(): boolean;
+    /**
+     * Initialize the registry with dependencies.
+     * Called by DataLayerProvider when PowerSync and Supabase are ready.
+     *
+     * @param deps - Dependencies needed to create adapters
+     */
+    initialize(deps: AdapterDependencies): void;
+    /**
+     * Set the PowerSync adapter instance
+     *
+     * @param adapter - PowerSync adapter implementation
+     */
+    setPowerSyncAdapter(adapter: TableDataAdapter): void;
+    /**
+     * Set a getter function for lazy PowerSync adapter initialization.
+     *
+     * This allows the registry to lazily create the PowerSync adapter when
+     * PowerSync becomes available, rather than requiring it at initialization time.
+     * Solves race conditions where queries/mutations run before PowerSync is ready.
+     *
+     * @param getter - Function that returns the PowerSync database instance (or null if not ready)
+     * @param factory - Function that creates a TableDataAdapter from the database instance
+     */
+    setPowerSyncGetter(getter: () => unknown, factory: (db: unknown) => TableDataAdapter): void;
+    /**
+     * Ensure PowerSync adapter is initialized if available.
+     *
+     * Checks the getter (if set) and lazily creates the adapter if PowerSync
+     * is now available. Also updates the auto-detector with the new reference.
+     *
+     * @returns true if PowerSync adapter is available, false otherwise
+     */
+    private ensurePowerSyncAdapter;
+    /**
+     * Set the sync tracker for mutation tracking.
+     * When set, write operations on PowerSync tables will
+     * automatically track pending mutations.
+     *
+     * NOTE: This also clears the adapter cache to ensure any
+     * previously cached adapters (which may have been created
+     * before the sync tracker was available) are recreated
+     * with the new sync tracker on next access.
+     */
+    setSyncTracker(tracker: SyncTracker): void;
+    /**
+     * Set the Supabase adapter instance
+     *
+     * @param adapter - Supabase adapter implementation
+     */
+    setSupabaseAdapter(adapter: TableDataAdapter): void;
+    /**
+     * Set the Cached adapter instance
+     *
+     * @param adapter - Cached adapter implementation
+     */
+    setCachedAdapter(adapter: TableDataAdapter): void;
+    /**
+     * Initialize auto-detection with a detector instance
+     *
+     * @param detector - The auto-detector to use
+     */
+    initializeAutoDetection(detector: AdapterAutoDetector): void;
+    /**
+     * Get the appropriate adapter for a table based on configuration.
+     *
+     * The adapter is selected based on the table's strategy in config.tables:
+     * - "powersync": Returns PowerSyncAdapter
+     * - "supabase": Returns SupabaseAdapter
+     * - "cached": Returns CachedAdapter (wrapping Supabase)
+     * - "hybrid": Returns HybridAdapter (combining PowerSync + Cached)
+     * - "auto": Uses auto-detection to select the best backend
+     *
+     * For tables not in config, defaults to auto-detection if available,
+     * otherwise falls back to SupabaseAdapter.
+     *
+     * Supports schema-qualified table names:
+     * - "core.Profile" looks up config["core.Profile"] first, then config["Profile"]
+     * - Auto-generates PowerSync alias as "CoreProfile" if not explicitly set
+     *
+     * @param table - The table name (may be schema-qualified like "core.Profile")
+     * @param operation - The operation type: 'read' uses fallback logic during init, 'write' always uses PowerSync for powersync tables
+     * @returns The appropriate adapter for the table
+     * @throws Error if adapters are not initialized
+     */
+    getAdapter(table: string, _operation?: 'read' | 'write'): TableDataAdapter;
+    /**
+     * Get the PowerSync adapter directly
+     *
+     * @returns PowerSync adapter or null if not initialized
+     */
+    getPowerSyncAdapter(): TableDataAdapter | null;
+    /**
+     * Get the Supabase adapter directly
+     *
+     * @returns Supabase adapter or null if not initialized
+     */
+    getSupabaseAdapter(): TableDataAdapter | null;
+    /**
+     * Get the Cached adapter directly
+     *
+     * @returns Cached adapter or null if not initialized
+     */
+    getCachedAdapter(): TableDataAdapter | null;
+    /**
+     * Get all configured table names
+     *
+     * @returns Array of table names with explicit strategy configuration
+     */
+    getConfiguredTables(): string[];
+    /**
+     * Get the strategy for a specific table
+     *
+     * @param table - The table name (may include schema prefix like "core.Profile")
+     * @returns The table strategy or undefined if not configured
+     */
+    getTableStrategy(table: string): TableStrategy | undefined;
+    /**
+     * Check if a table uses PowerSync strategy
+     *
+     * @param table - The table name (may include schema prefix like "core.Profile")
+     * @returns True if table uses PowerSync, Hybrid, or Auto strategy
+     */
+    usesPowerSync(table: string): boolean;
+    /**
+     * Get all table config keys that use PowerSync (may be schema-qualified)
+     *
+     * @returns Array of config keys using PowerSync, Hybrid, or Auto strategy
+     */
+    getPowerSyncTableKeys(): string[];
+    /**
+     * Get all tables that use PowerSync (returns aliases for PowerSync schema)
+     *
+     * @returns Array of PowerSync table aliases
+     */
+    getPowerSyncTables(): string[];
+    /**
+     * Get the PowerSync alias for a table.
+     * Uses explicit alias from config if set, otherwise auto-generates.
+     *
+     * @param table - Table name (may be schema-qualified)
+     * @returns The alias to use in PowerSync schema
+     */
+    getTableAlias(table: string): string;
+    /**
+     * Get adapter using auto-detection.
+     *
+     * Simple logic: PowerSync first, Supabase fallback.
+     * Once PowerSync is initialized, always use it for offline-first behavior.
+     */
+    private getAutoAdapter;
+    /**
+     * Subscribe to backend changes
+     *
+     * @param callback - Function called when recommended backend changes
+     * @returns Unsubscribe function
+     */
+    onBackendChange(callback: (backend: "powersync" | "supabase") => void): () => void;
+    /**
+     * Notify listeners of backend change
+     *
+     * @param backend - The new recommended backend
+     */
+    private notifyBackendChange;
+    /**
+     * Get the last auto-detection result
+     *
+     * @returns Last detection result or null if never detected
+     */
+    getLastDetectionResult(): AutoDetectionResult | null;
+    /**
+     * Get the auto-detector instance
+     *
+     * @returns Auto-detector instance or null if not initialized
+     */
+    getAutoDetector(): AdapterAutoDetector | null;
+    /**
+     * Create an adapter based on the strategy type
+     *
+     * @param strategy - The table strategy configuration
+     * @returns The created adapter
+     * @throws Error if the required base adapter is not initialized
+     */
+    private createAdapter;
+    /**
+     * Clear all cached adapters.
+     * Useful when configuration changes and adapters need to be recreated.
+     */
+    clearCache(): void;
+    /**
+     * Reset the registry to uninitialized state.
+     * Used during cleanup or testing.
+     */
+    reset(): void;
+    /**
+     * Dispose all adapters and clean up resources.
+     * Called when the DataLayerProvider unmounts.
+     */
+    dispose(): void;
+    /**
+     * Get debug information about the registry state
+     */
+    getDebugInfo(): {
+        isInitialized: boolean;
+        hasPowerSync: boolean;
+        hasSupabase: boolean;
+        hasCached: boolean;
+        cachedAdapterCount: number;
+        configuredTableCount: number;
+        powerSyncTables: string[];
+        hasAutoDetector: boolean;
+        lastDetectionResult: AutoDetectionResult | null;
+    };
+}
+/**
+ * Create a new adapter registry
+ *
+ * @param config - Data layer configuration
+ * @returns A new AdapterRegistry instance
+ *
+ * @example
+ * ```typescript
+ * const config: DataLayerConfig = {
+ *   schema: databaseSchema,
+ *   connections: { ... },
+ *   tables: {
+ *     Project: { strategy: "powersync", syncScope: "activeProject" },
+ *     AuditLog: { strategy: "supabase" },
+ *     Report: { strategy: "cached", cacheTime: 60000 },
+ *   },
+ *   scopes: { ... },
+ *   defaults: { syncMode: "live" },
+ * };
+ *
+ * const registry = createAdapterRegistry(config);
+ *
+ * // In provider:
+ * registry.setPowerSyncAdapter(new PowerSyncAdapter(db, schema));
+ * registry.setSupabaseAdapter(new SupabaseAdapter(supabase));
+ *
+ * // In hooks:
+ * const adapter = registry.getAdapter("Project"); // Returns PowerSyncAdapter
+ * ```
+ */
+declare function createAdapterRegistry(config: DataLayerConfig): AdapterRegistry;
+
 /**
  * V3 Data Layer - Supabase Adapter
  *
@@ -967,4 +1391,4 @@ declare function useResolveFeedback(): _tanstack_react_query.UseMutationResult<{
     }>;
 }, Error, number, unknown>;
 
-export { useUpsertChangelogMedia as $, type AttachmentQueueProvider as A, useAI as B, type ServerAvailabilityState as C, useServerAvailability as D, useSearchQuery as E, type UpdateOptions as F, executeAdvanceQuery as G, type CustomPageQueryResult as H, BUCKETS as I, type BucketName as J, createInCondition as K, DEFAULT_QUERY_TIMEOUT as L, isTimeoutError as M, type UseDbRealtimeQueryResult as N, convertFilterToRealtimeQuery as O, type AlertProps as P, LiveChangeContext as Q, LiveChangeContextProvider as R, StorageQueueProvider as S, TIMEOUT_ERROR_MESSAGE as T, type UseAutosaveOptions as U, useUpsertChangelog as V, useDeleteChangelog as W, useUpsertChangelogEntry as X, useMultiUpsertChangelogEntries as Y, useDeleteChangelogEntry as Z, useMultiDeleteChangelogEntries as _, useLatestOperationLog as a, useDeleteChangelogMedia as a0, useUploadChangelogMedia as a1, useChangelogs as a2, usePublishedChangelogs as a3, useChangelogById as a4, useChangelogBySlug as a5, useChangelogEntries as a6, useChangelogMedia as a7, useFeedbackList as a8, type FeedbackListItem as a9, type FeedbackListParams as aa, useSubmitFeedback as ab, type SubmitFeedbackParams as ac, useApplyFeedback as ad, useResolveFeedback as ae, type UseDbPartialQueryResult as af, useDbPartialQuery as ag, useAutosaveState as b, useAutosave as c, type UseAutosaveResult as d, useToastError as e, useStorageSource as f, getStorageUrl as g, type UseStorageSourceOptions as h, type UseStorageSourceResult as i, type StorageQueueProviderProps as j, StorageQueueContext as k, useStorageQueueContext as l, type StorageQueueContextValue as m, newTimeActivity as n, useDbRealtimeQuery as o, getSupabaseUrl as p, type UseMutationSuccessOptions as q, useMutationSuccess as r, setSupabaseUrl as s, useMutationSuccessRN as t, useLiveChangeTracking as u, SupabaseAdapter as v, createSupabaseAdapter as w, getErrorBody as x, type AIOptions as y, type AIResponse as z };
+export { LiveChangeContextProvider as $, type AttachmentQueueProvider as A, SupabaseAdapter as B, createSupabaseAdapter as C, SyncTrackingAdapter as D, type SyncTracker as E, getErrorBody as F, type AIOptions as G, type AIResponse as H, useAI as I, type ServerAvailabilityState as J, useServerAvailability as K, useSearchQuery as L, type UpdateOptions as M, executeAdvanceQuery as N, type CustomPageQueryResult as O, BUCKETS as P, type BucketName as Q, createInCondition as R, StorageQueueProvider as S, TIMEOUT_ERROR_MESSAGE as T, type UseAutosaveOptions as U, DEFAULT_QUERY_TIMEOUT as V, isTimeoutError as W, type UseDbRealtimeQueryResult as X, convertFilterToRealtimeQuery as Y, type AlertProps as Z, LiveChangeContext as _, useLatestOperationLog as a, useUpsertChangelog as a0, useDeleteChangelog as a1, useUpsertChangelogEntry as a2, useMultiUpsertChangelogEntries as a3, useDeleteChangelogEntry as a4, useMultiDeleteChangelogEntries as a5, useUpsertChangelogMedia as a6, useDeleteChangelogMedia as a7, useUploadChangelogMedia as a8, useChangelogs as a9, usePublishedChangelogs as aa, useChangelogById as ab, useChangelogBySlug as ac, useChangelogEntries as ad, useChangelogMedia as ae, useFeedbackList as af, type FeedbackListItem as ag, type FeedbackListParams as ah, useSubmitFeedback as ai, type SubmitFeedbackParams as aj, useApplyFeedback as ak, useResolveFeedback as al, type UseDbPartialQueryResult as am, useDbPartialQuery as an, useAutosaveState as b, useAutosave as c, type UseAutosaveResult as d, useToastError as e, useStorageSource as f, getStorageUrl as g, type UseStorageSourceOptions as h, type UseStorageSourceResult as i, type StorageQueueProviderProps as j, StorageQueueContext as k, useStorageQueueContext as l, type StorageQueueContextValue as m, newTimeActivity as n, useDbRealtimeQuery as o, getSupabaseUrl as p, type UseMutationSuccessOptions as q, useMutationSuccess as r, setSupabaseUrl as s, useMutationSuccessRN as t, useLiveChangeTracking as u, AdapterRegistry as v, createAdapterRegistry as w, stripSchemaPrefix as x, generatePowerSyncAlias as y, getPowerSyncAlias as z };

package/dist/with-auth/index.js

@@ -5,20 +5,20 @@ import {
   useUserMetadataState,
   useUserMetadataValue,
   userMetadataContext
-} from "../chunk-4EO55YV2.js";
+} from "../chunk-VSY6766U.js";
 import {
   useDbUpsert
-} from "../chunk-VYFAMTHI.js";
+} from "../chunk-WY6MNB6K.js";
 import "../chunk-SM73S2DY.js";
 import "../chunk-NSIAAYW3.js";
 import {
   useAuth,
   useSetupAuth
-} from "../chunk-MEBT5YHA.js";
+} from "../chunk-SNPZMRBC.js";
 import {
   useDbQuery
-} from "../chunk-6SDH7M7J.js";
-import "../chunk-GWYTROSD.js";
+} from "../chunk-ARALLEDJ.js";
+import "../chunk-L4DFVMTS.js";
 import "../chunk-RT4O5H2E.js";
 import {
   getSupabaseUrl

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pol-studios/db",
-  "version": "1.0.58",
+  "version": "1.0.59",
   "description": "Database layer for React applications with Supabase and PowerSync support",
   "license": "UNLICENSED",
   "type": "module",