supastash 0.1.0

package/dist/hooks/syncEngine/index.js

@@ -0,0 +1,66 @@
+import { useRef } from "react";
+import { AppState } from "react-native";
+import { getSupastashConfig } from "../../core/config";
+import { isOnline } from "../../utils/connection";
+import log from "../../utils/logs";
+import { pullFromRemote } from "./pullFromRemote";
+import { pushLocalData } from "./pushLocal";
+let isSyncing = false;
+let lastFullSync = 0;
+const syncPollingInterval = getSupastashConfig().pollingInterval?.push || 30000;
+/**
+ * Syncs the local data to the remote database
+ */
+export async function syncEngine(force = false) {
+    if (isSyncing)
+        return;
+    if (!(await isOnline()))
+        return;
+    try {
+        isSyncing = true;
+        await pushLocalData();
+        if (!getSupastashConfig().syncEngine?.pull)
+            return;
+        const now = Date.now();
+        const shouldPull = force ||
+            now - lastFullSync >
+                (getSupastashConfig().pollingInterval?.pull || 30000);
+        if (shouldPull) {
+            await pullFromRemote();
+            lastFullSync = now;
+        }
+    }
+    catch (error) {
+        log(`[Supastash] Error syncing: ${error}`);
+    }
+    finally {
+        isSyncing = false;
+    }
+}
+export function useSyncEngine() {
+    const isSyncingRef = useRef(false);
+    const intervalRef = useRef(null);
+    const appStateRef = useRef(null);
+    function startSync() {
+        if (isSyncingRef.current)
+            return;
+        isSyncingRef.current = true;
+        const config = getSupastashConfig();
+        const syncPollingInterval = config.pollingInterval?.push ?? 30000;
+        intervalRef.current = setInterval(() => {
+            syncEngine();
+        }, syncPollingInterval);
+        appStateRef.current = AppState.addEventListener("change", (state) => {
+            if (state === "active") {
+                syncEngine(true);
+            }
+        });
+    }
+    function stopSync() {
+        if (intervalRef.current)
+            clearInterval(intervalRef.current);
+        appStateRef.current?.remove?.();
+        isSyncingRef.current = false;
+    }
+    return { startSync, stopSync };
+}

package/dist/hooks/syncEngine/pullFromRemote/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pulls the data from the remote database to the local database
+ */
+export declare function pullFromRemote(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/syncEngine/pullFromRemote/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/syncEngine/pullFromRemote/index.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAsB,cAAc,kBAyBnC"}

package/dist/hooks/syncEngine/pullFromRemote/index.js

@@ -0,0 +1,28 @@
+import { getSupastashConfig } from "../../../core/config";
+import { tableFilters } from "../../../store/tableFilters";
+import log from "../../../utils/logs";
+import { getAllTables } from "../../../utils/sync/getAllTables";
+import { updateLocalDb } from "../../../utils/sync/pullFromRemote/updateLocalDb";
+/**
+ * Pulls the data from the remote database to the local database
+ */
+export async function pullFromRemote() {
+    const config = getSupastashConfig();
+    const { useFiltersFromStore = true } = config?.syncEngine || {};
+    const filter = (table) => useFiltersFromStore ? tableFilters.get(table) : undefined;
+    try {
+        const tables = await getAllTables();
+        if (!tables) {
+            log(`[Supastash] No tables found`);
+            return;
+        }
+        const excludeTables = getSupastashConfig()?.excludeTables?.pull || [];
+        const tablesToPull = tables.filter((table) => !excludeTables?.includes(table));
+        for (const table of tablesToPull) {
+            await updateLocalDb(table, filter(table));
+        }
+    }
+    catch (error) {
+        log(`[Supastash] Error pulling from remote: ${error}`);
+    }
+}

package/dist/hooks/syncEngine/pushLocal/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pushes the local data to the remote database
+ */
+export declare function pushLocalData(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/syncEngine/pushLocal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/syncEngine/pushLocal/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAsB,aAAa,kBAmClC"}

package/dist/hooks/syncEngine/pushLocal/index.js

@@ -0,0 +1,36 @@
+import { getSupastashConfig } from "../../../core/config";
+import log from "../../../utils/logs";
+import { getAllTables } from "../../../utils/sync/getAllTables";
+import { pushLocalDataToRemote } from "../../../utils/sync/pushLocal/sendUnsyncedToSupabase";
+let timesPushed = 0;
+let lastPushed = 0;
+/**
+ * Pushes the local data to the remote database
+ */
+export async function pushLocalData() {
+    try {
+        const tables = await getAllTables();
+        if (!tables) {
+            log("No tables found");
+            return;
+        }
+        const excludeTables = getSupastashConfig()?.excludeTables?.push || [];
+        const tablesToPush = tables.filter((table) => !excludeTables?.includes(table));
+        const noSync = [];
+        for (const table of tablesToPush) {
+            await pushLocalDataToRemote(table, undefined, noSync);
+        }
+        if (noSync.length > 0) {
+            timesPushed++;
+            if (timesPushed >= 30) {
+                const timeSinceLastPush = Date.now() - lastPushed;
+                lastPushed = Date.now();
+                log(`[Supastash] No sync data found for tables: ${noSync.join(", ")} (times pushed: ${timesPushed}) in the last ${timeSinceLastPush}ms`);
+                timesPushed = 0;
+            }
+        }
+    }
+    catch (error) {
+        log(`[Supastash] Error pushing local data to remote database: ${error}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { configureSupastash, getSupastashConfig } from "./core/config";
+export { defineLocalSchema } from "./core/schemaManager";
+export { getSupastashDb } from "./db/dbInitializer";
+export { useSupastashData } from "./hooks/supastashData";
+export { useSupastash } from "./hooks/supastashLogic";
+export { supastash } from "./utils/query/builder";
+export { wipeAllTables, wipeOldDataForAllTables, wipeOldDataForATable, wipeTable, } from "./utils/schema/wipeTables";
+export { getAllTables } from "./utils/sync/getAllTables";
+export { refreshAllTables, refreshTable } from "./utils/sync/refreshTables";
+export { clearAllLocalDeleteLog, clearAllLocalSyncLog, clearLocalDeleteLog, clearLocalSyncLog, getLocalDeleteLog, getLocalSyncLog, setLocalDeleteLog, setLocalSyncLog, } from "./utils/syncStatus";
+export type { CrudMethods } from "./types/query.types";
+export type { RealtimeOptions, SupastashDataResult, } from "./types/realtimeData.types";
+export type { SupastashConfig, SupastashHookReturn, SupastashSQLiteClientTypes, SupastashSQLiteDatabase, } from "./types/supastashConfig.types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,oBAAoB,EACpB,SAAS,GACV,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EACV,eAAe,EACf,mBAAmB,GACpB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,+BAA+B,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { configureSupastash, getSupastashConfig } from "./core/config";
+export { defineLocalSchema } from "./core/schemaManager";
+export { getSupastashDb } from "./db/dbInitializer";
+export { useSupastashData } from "./hooks/supastashData";
+export { useSupastash } from "./hooks/supastashLogic";
+export { supastash } from "./utils/query/builder";
+export { wipeAllTables, wipeOldDataForAllTables, wipeOldDataForATable, wipeTable, } from "./utils/schema/wipeTables";
+export { getAllTables } from "./utils/sync/getAllTables";
+export { refreshAllTables, refreshTable } from "./utils/sync/refreshTables";
+export { clearAllLocalDeleteLog, clearAllLocalSyncLog, clearLocalDeleteLog, clearLocalSyncLog, getLocalDeleteLog, getLocalSyncLog, setLocalDeleteLog, setLocalSyncLog, } from "./utils/syncStatus";

package/dist/store/tableFilters.d.ts

@@ -0,0 +1,3 @@
+import { RealtimeFilter } from "../types/realtimeData.types";
+export declare const tableFilters: Map<string, RealtimeFilter>;
+//# sourceMappingURL=tableFilters.d.ts.map

package/dist/store/tableFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableFilters.d.ts","sourceRoot":"","sources":["../../src/store/tableFilters.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,eAAO,MAAM,YAAY,6BAAoC,CAAC"}

package/dist/store/tableFilters.js

@@ -0,0 +1,2 @@
+// Store for table filters
+export const tableFilters = new Map();

package/dist/types/expoSqlite.types.d.ts

@@ -0,0 +1,57 @@
+export interface ExpoSQLiteDatabase {
+  runAsync<T = any>(
+    statement: string,
+    params: SQLiteBindParams
+  ): Promise<SQLiteRunResult>;
+  runAsync<T = any>(
+    statement: string,
+    ...params: SQLiteVariadicBindParams
+  ): Promise<SQLiteRunResult>;
+
+  getFirstAsync<T = any>(
+    statement: string,
+    params: SQLiteBindParams
+  ): Promise<T | null>;
+  getFirstAsync<T = any>(
+    statement: string,
+    ...params: SQLiteVariadicBindParams
+  ): Promise<T | null>;
+
+  getAllAsync<T = any>(
+    statement: string,
+    params: SQLiteBindParams
+  ): Promise<T[]>;
+  getAllAsync<T = any>(
+    statement: string,
+    ...params: SQLiteVariadicBindParams
+  ): Promise<T[]>;
+
+  execAsync(statement: string): Promise<void>;
+}
+
+export type SQLiteBindValue = string | number | null | boolean | Uint8Array;
+export type SQLiteBindParams =
+  | Record<string, SQLiteBindValue>
+  | SQLiteBindValue[];
+export type SQLiteVariadicBindParams = SQLiteBindValue[];
+
+export type SQLiteBindPrimitiveParams = Record<
+  string,
+  Exclude<SQLiteBindValue, Uint8Array>
+>;
+export type SQLiteBindBlobParams = Record<string, Uint8Array>;
+export type SQLiteColumnNames = string[];
+export type SQLiteColumnValues = any[];
+export type SQLiteAnyDatabase = any;
+
+export interface SQLiteRunResult {
+  /**
+   * The last inserted row ID. Returned from the [`sqlite3_last_insert_rowid()`](https://www.sqlite.org/c3ref/last_insert_rowid.html) function.
+   */
+  lastInsertRowId: number;
+
+  /**
+   * The number of rows affected. Returned from the [`sqlite3_changes()`](https://www.sqlite.org/c3ref/changes.html) function.
+   */
+  changes: number;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { SupastashQueryResult, SupastashResult } from "./query.types";
+export type { SupastashDataHook, SupastashDataResult, } from "./realtimeData.types";
+export type { SupastashConfig, SupastashSQLiteClientTypes, } from "./supastashConfig.types";
+export type { SyncResult, TableSchema } from "./syncEngine.types";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAC3E,YAAY,EACV,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,eAAe,EACf,0BAA0B,GAC3B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/types/index.js

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

package/dist/types/query.types.d.ts

@@ -0,0 +1,153 @@
+import { PostgrestError, PostgrestSingleResponse } from "@supabase/supabase-js";
+
+type SupabaseResult<T> = PostgrestSingleResponse<T>;
+export type PayloadData = any;
+
+export type SupabaseQueryReturn<U extends boolean, R> = U extends true
+  ? PostgrestSingleResponse<R>
+  : PostgrestSingleResponse<R[]>;
+
+type FilterOperations =
+  | "="
+  | "!="
+  | ">"
+  | "<"
+  | ">="
+  | "<="
+  | "LIKE"
+  | "IS"
+  | "IN";
+
+export type CrudMethods =
+  | "select"
+  | "insert"
+  | "update"
+  | "delete"
+  | "upsert"
+  | "none";
+
+export type FilterCalls = {
+  column: string;
+  operator: FilterOperations;
+  value: any;
+};
+
+export interface SupastashQuery<T extends CrudMethods, U extends boolean, R> {
+  id: string;
+  table: string;
+  method: T;
+  payload: R | R[] | null;
+  filters: FilterCalls[] | null;
+  limit: number | null;
+  select: string | null;
+  isSingle: U;
+  type: SyncMode;
+  runSelected: boolean;
+  viewRemoteResult: boolean;
+}
+
+export interface CrudReturnValue {
+  error;
+}
+
+export type SupastashResult<R> = {
+  data: R | null;
+  error: {
+    message: string;
+    name: string;
+    supabaseError?: PostgrestError;
+  } | null;
+};
+
+export type PayloadResult<R> = SupastashResult<R>;
+export type PayloadListResult<R> = SupastashResult<R[]>;
+export type SupatashDeleteResult<R> = {
+  data?: R[] | null;
+  error: {
+    message: string;
+    name: string;
+    supabaseError?: PostgrestError;
+  } | null;
+};
+
+export type MethodReturnTypeMap<U extends boolean, R> = {
+  select: U extends true ? SupastashResult<R> : SupastashResult<R[]>;
+  insert: U extends true ? SupastashResult<R> : SupastashResult<R[]>;
+  update: U extends true ? SupastashResult<R> : SupastashResult<R[]>;
+  delete: SupatashDeleteResult<R>;
+  upsert: U extends true ? SupastashResult<R> : SupastashResult<R[]>;
+  none: null;
+};
+
+export type HandlerMap<U extends boolean, R> = {
+  [K in CrudMethods]: () => Promise<MethodReturnTypeMap<U, R>[K]>;
+};
+
+export type SyncMode =
+  | "localFirst"
+  | "remoteFirst"
+  | "localOnly"
+  | "remoteOnly";
+
+export type SupastashQueryResult<
+  T extends CrudMethods,
+  U extends boolean,
+  V extends boolean,
+  R
+> = V extends true
+  ? Promise<{
+      remote: SupabaseQueryReturn<U, R> | null;
+      local: MethodReturnTypeMap<U, R>[T] | null;
+      success: boolean;
+    }>
+  : MethodReturnTypeMap<U, R>[T] extends { data: infer D; error: infer E }
+  ? Promise<{ data: D; error: E; success: boolean }>
+  : Promise<{
+      data: null;
+      error: { message: string } | null;
+      success: boolean;
+    }>;
+
+export type QueryBuilder<T extends CrudMethods, U extends boolean> = {
+  eq(column: string, value: any): QueryBuilder<T, U>;
+  neq(column: string, value: any): QueryBuilder<T, U>;
+  gt(column: string, value: any): QueryBuilder<T, U>;
+  lt(column: string, value: any): QueryBuilder<T, U>;
+  gte(column: string, value: any): QueryBuilder<T, U>;
+  lte(column: string, value: any): QueryBuilder<T, U>;
+  like(column: string, value: any): QueryBuilder<T, U>;
+  is(column: string, value: any): QueryBuilder<T, U>;
+  in(column: string, value: any[]): QueryBuilder<T, U>;
+  limit(n: number): QueryBuilder<T, U>;
+  syncMode(mode: SyncMode): QueryBuilder<T, U>;
+
+  // Transitions to U = true when called
+  single(): QueryBuilder<T, true>;
+
+  // Executes the query
+  execute(): SupastashQueryResult<T, U>;
+  run(): SupastashQueryResult<T, U>;
+  go(): SupastashQueryResult<T, U>;
+};
+
+export interface ExecuteOptions {
+  /**
+   * The number of times to retry the remote query if it fails
+   */
+  remoteRetry?: number;
+
+  /**
+   * Whether to view the remote result
+   */
+  viewRemoteResult?: boolean;
+
+  /**
+   * The delay between remote retries
+   */
+  remoteRetryDelay?: number;
+
+  /**
+   * Whether to enable debug logging
+   */
+  debug?: boolean;
+}

package/dist/types/realtimeData.types.d.ts

@@ -0,0 +1,186 @@
+export type FilterOperator =
+  | "eq"
+  | "neq"
+  | "gt"
+  | "lt"
+  | "gte"
+  | "lte"
+  | "in"
+  | "is";
+
+export type RealtimeFilter = {
+  column: string;
+  operator: FilterOperator;
+  value: string | number | null | (string | number)[];
+};
+
+export interface RealtimeOptions {
+  /**
+   * Whether to fetch local data automatically when the hook mounts.
+   * @default true
+   *
+   * @example
+   * const { user } = useAuth();
+   * const { data } = useSupastashData("messages", {
+   *   shouldFetch: !!user
+   * });
+   */
+  shouldFetch?: boolean;
+
+  /**
+   * Whether to use the filter while syncing.
+   * @default true
+   *
+   * @example
+   * useFilterWhileSyncing: true
+   */
+  useFilterWhileSyncing?: boolean;
+
+  /**
+   * Filter condition applied to the Supabase realtime subscription stream.
+   *
+   * @example
+   * filter: {
+   *   column: "user_id",
+   *   operator: "eq",
+   *   value: "123"
+   * }
+   */
+  filter?: RealtimeFilter;
+
+  /**
+   * Maximum number of records to fetch initially from the local database.
+   * @default 1000
+   *
+   * @example
+   * limit: 400
+   */
+  limit?: number;
+
+  /**
+   * Called when a new record is inserted into the table.
+   *
+   * @example
+   * onInsert: (payload) => {
+   *   console.log("Inserted", payload);
+   * }
+   */
+  onInsert?: (payload: any) => void;
+
+  /**
+   * Called when an existing record is updated.
+   *
+   * @example
+   * onUpdate: (payload) => {
+   *   console.log("Updated", payload);
+   * }
+   */
+  onUpdate?: (payload: any) => void;
+
+  /**
+   * Called when a record is deleted.
+   *
+   * @example
+   * onDelete: (payload) => {
+   *   console.log("Deleted", payload);
+   * }
+   */
+  onDelete?: (payload: any) => void;
+
+  /**
+   * Called on both insert and update events.
+   * Useful when insert/update are handled the same way.
+   *
+   * @example
+   * onInsertAndUpdate: async (payload) => {
+   *   const { data: localMessage } = await supastash
+   *     .from("messages")
+   *     .select("*")
+   *     .eq("id", payload.id)
+   *     .run();
+   *
+   *   if (!localMessage || localMessage.is_received) return;
+   *
+   *   await supastash
+   *     .from("messages")
+   *     .upsert({ ...localMessage, is_received: true })
+   *     .run();
+   * }
+   */
+  onInsertAndUpdate?: (payload: any) => Promise<void>;
+
+  /**
+   * Called to push unsynced local records to the remote database.
+   * Must return `true` if push was successful; otherwise, it will be retried later.
+   *
+   * @example
+   * onPushToRemote: async (payload) => {
+   *   const result = await supabase.from("messages").upsert(payload);
+   *   return !result.error;
+   * }
+   */
+  onPushToRemote?: (payload: any[]) => Promise<boolean>;
+
+  /**
+   * Whether to use realtime subscription.
+   * @default true
+   *
+   * @example
+   * realtime: true
+   */
+  realtime?: boolean;
+
+  /**
+   * If true, delays the initial fetch until `trigger()` is manually called.
+   *
+   * @example
+   * lazy: true
+   *
+   * const { data, trigger } = useSupastashData("messages", { lazy: true });
+   *
+   * useEffect(() => {
+   *   if (loaded) trigger();
+   * }, []);
+   */
+  lazy?: boolean;
+
+  /**
+   * Interval in milliseconds to batch UI updates for performance.
+   * @default 100
+   *
+   * @example
+   * flushIntervalMs: 200
+   */
+  flushIntervalMs?: number;
+}
+
+export type SupastashDataResult<R = any> = {
+  data: R[];
+  dataMap: Map<string, R>;
+  trigger: () => void;
+  cancel: () => void;
+  realtimeStatus: RealtimeStatus;
+};
+
+export type SupastashDataHook = (
+  table: string,
+  options: RealtimeOptions
+) => SupastashDataResult;
+
+// Realtime manager types
+export type EventHandler = (eventType: string, data: any) => void;
+export type SubscriptionKey = string;
+export type HookId = string;
+
+export interface TableSubscription {
+  table: string;
+  filterString?: string;
+  handlers: Map<HookId, EventHandler>;
+  isActive: boolean;
+}
+
+export interface RealtimeStatus {
+  status: "disconnected" | "connecting" | "connected" | "error";
+  error?: string;
+  isNetworkConnected: boolean;
+}