supastash 0.1.0

package/dist/types/rnNitroSqlite.types.d.ts

@@ -0,0 +1,101 @@
+export interface RNNitroSQLiteDatabase {
+  transaction(fn: (tx: Transaction) => Promise<void> | void): Promise<void>;
+  execute: ExecuteQuery;
+  executeAsync: ExecuteAsyncQuery;
+}
+
+enum ColumnType {
+  BOOLEAN,
+  NUMBER,
+  INT64,
+  TEXT,
+  ARRAY_BUFFER,
+  NULL_VALUE,
+}
+
+// Passing null/undefined in array types is not possible, so we us a special struct as a workaround.
+type SQLiteNullValue = {
+  isNitroSQLiteNull: true;
+};
+type SQLiteValue = boolean | number | string | ArrayBuffer | SQLiteNullValue;
+
+/** Used internally to transform the query params into a native format without nullish values */
+type NativeSQLiteQueryParams = SQLiteValue[];
+
+/**
+ * Represents a value that can be stored in a SQLite database
+ */
+type SQLiteQueryParamItem = SQLiteValue | null | undefined;
+type SQLiteQueryParams = SQLiteQueryParamItem[];
+
+type QueryResultRowItem = SQLiteValue | undefined;
+type QueryResultRow = Record<string, QueryResultRowItem>;
+interface QueryResult<Row extends QueryResultRow = QueryResultRow> {
+  readonly insertId?: number;
+  readonly rowsAffected: number;
+
+  readonly rows?: {
+    /** Raw array with all dataset */
+    _array: Row[];
+    /** The lengh of the dataset */
+    length: number;
+    /** A convenience function to acess the index based the row object
+     * @param idx the row index
+     * @returns the row structure identified by column names
+     */
+    item: (idx: number) => Row | undefined;
+  };
+}
+
+type ExecuteQuery = <Row extends QueryResultRow = QueryResultRow>(
+  query: string,
+  params?: SQLiteQueryParams
+) => QueryResult<Row>;
+
+type ExecuteAsyncQuery = <Row extends QueryResultRow = QueryResultRow>(
+  query: string,
+  params?: SQLiteQueryParams
+) => Promise<QueryResult<Row>>;
+
+interface Transaction {
+  commit(): QueryResult;
+  rollback(): QueryResult;
+  execute: ExecuteQuery;
+  executeAsync: ExecuteAsyncQuery;
+}
+
+/**
+ * Allows the execution of bulk of sql commands
+ * inside a transaction
+ * If a single query must be executed many times with different arguments, its preferred
+ * to declare it a single time, and use an array of array parameters.
+ */
+interface BatchQueryCommand {
+  query: string;
+  params?: SQLiteQueryParams | SQLiteQueryParams[];
+}
+
+/**
+ * Used internally to transform the batch query commands into a native format without nullish values
+ */
+interface NativeBatchQueryCommand {
+  query: string;
+  params?: NativeSQLiteQueryParams | NativeSQLiteQueryParams[];
+}
+
+/**
+ * status: 0 or undefined for correct execution, 1 for error
+ * message: if status === 1, here you will find error description
+ * rowsAffected: Number of affected rows if status == 0
+ */
+interface BatchQueryResult {
+  rowsAffected?: number;
+}
+
+/**
+ * Result of loading a file and executing every line as a SQL command
+ * Similar to BatchQueryResult
+ */
+interface FileLoadResult extends BatchQueryResult {
+  commands?: number;
+}

package/dist/types/rnSqliteStorage.types.d.ts

@@ -0,0 +1,67 @@
+interface ResultSet {
+  insertId: number;
+  rowsAffected: number;
+  rows: ResultSetRowList;
+}
+
+interface ResultSetRowList {
+  length: number;
+  raw(): any[];
+  item(index: number): any;
+}
+
+enum SQLErrors {
+  UNKNOWN_ERR = 0,
+  DATABASE_ERR = 1,
+  VERSION_ERR = 2,
+  TOO_LARGE_ERR = 3,
+  QUOTA_ERR = 4,
+  SYNTAX_ERR = 5,
+  CONSTRAINT_ERR = 6,
+  TIMEOUT_ERR = 7,
+}
+
+interface SQLError {
+  code: number;
+  message: string;
+}
+
+type StatementCallback = (
+  transaction: Transaction,
+  resultSet: ResultSet
+) => void;
+type StatementErrorCallback = (
+  transaction: Transaction,
+  error: SQLError
+) => void;
+interface Transaction {
+  executeSql(
+    sqlStatement: string,
+    arguments?: any[]
+  ): Promise<[Transaction, ResultSet]>;
+  executeSql(
+    sqlStatement: string,
+    arguments?: any[],
+    callback?: StatementCallback,
+    errorCallback?: StatementErrorCallback
+  ): void;
+}
+
+type TransactionCallback = (transaction: Transaction) => void;
+type TransactionErrorCallback = (error: SQLError) => void;
+
+export interface RNStorageSQLiteDatabase {
+  transaction(scope: (tx: Transaction) => void): Promise<Transaction>;
+  transaction(
+    scope: (tx: Transaction) => void,
+    error?: TransactionErrorCallback,
+    success?: TransactionCallback
+  ): void;
+  executeSql(statement: string, params?: any[]): Promise<[ResultSet]>;
+  executeSql(
+    statement: string,
+    params?: any[],
+    success?: StatementCallback,
+    error?: StatementErrorCallback
+  ): void;
+}

package/dist/types/schemaManager.types.d.ts

@@ -0,0 +1,44 @@
+type SqlPrimitive =
+  | "TEXT"
+  | "INTEGER"
+  | "REAL"
+  | "BLOB"
+  | "NUMERIC"
+  | `NUMERIC(${number},${number})`
+  | string;
+
+type SqlModifier =
+  | "PRIMARY KEY"
+  | "NOT NULL"
+  | "UNIQUE"
+  | "DEFAULT"
+  | "CHECK"
+  | "COLLATE"
+  | "REFERENCES"
+  | "AUTOINCREMENT"
+  | "ON CONFLICT"
+  | "GENERATED ALWAYS"
+  | "AS"
+  | "STORED"
+  | "VIRTUAL"
+  | "NULL"
+  | "CURRENT_TIMESTAMP"
+  | "CURRENT_DATE"
+  | "CURRENT_TIME"
+  | "IF NOT EXISTS"
+  | "WITHOUT ROWID"
+  | string;
+
+type ColumnDefinition = `${SqlPrimitive}${
+  | ""
+  | ` ${SqlModifier}`
+  | ` ${SqlModifier} ${SqlModifier}`
+  | ` ${SqlModifier} ${SqlModifier} ${SqlModifier}`}`;
+
+type LocalSchemaDefinition = Record<string, ColumnDefinition>;
+
+export type DefineLocalSchema = (
+  tableName: string,
+  schema: LocalSchemaDefinition,
+  deletePreviousSchema?: boolean
+) => void;

package/dist/types/supastashConfig.types.d.ts

@@ -0,0 +1,72 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { SQLiteOpenOptions } from "expo-sqlite";
+import { ExpoSQLiteDatabase } from "./expoSqlite.types";
+import { RNNitroSQLiteDatabase } from "./rnNitroSqlite.types";
+import { RNStorageSQLiteDatabase } from "./rnSqliteStorage.types";
+
+export type SupastashSQLiteClientTypes =
+  | "expo"
+  | "rn-storage"
+  | "rn-nitro"
+  | null;
+
+export type SupastashConfig<T extends SupastashSQLiteClientTypes> = {
+  dbName: string;
+  supabaseClient: SupabaseClient<any, "public", any> | null;
+  sqliteClient: T extends "expo"
+    ? ExpoSQLiteClient
+    : T extends "rn-storage"
+    ? RNStorageSQLiteClient
+    : T extends "rn-nitro"
+    ? RNSqliteNitroClient
+    : null;
+  sqliteClientType: T;
+  excludeTables?: { pull?: string[]; push?: string[] };
+  pollingInterval?: {
+    pull?: number;
+    push?: number;
+  };
+  listeners?: number;
+  onSchemaInit?: () => void;
+  debugMode?: boolean;
+};
+
+interface SupastashSQLiteDatabase {
+  runAsync(sql: string, params?: any[]): Promise<void>;
+  getAllAsync<T = any>(sql: string, params?: any[]): Promise<T[]>;
+  getFirstAsync<T = any>(sql: string, params?: any[]): Promise<T | null>;
+  execAsync(statements: string): Promise<void>;
+}
+
+export interface SupastashSQLiteAdapter {
+  openDatabaseAsync(
+    name: string,
+    sqliteClient: ExpoSQLiteClient | RNStorageSQLiteClient | RNSqliteNitroClient
+  ): Promise<SupastashSQLiteDatabase>;
+}
+
+export interface ExpoSQLiteClient {
+  openDatabaseAsync: (
+    databaseName: string,
+    options?: SQLiteOpenOptions | undefined,
+    directory?: string | undefined
+  ) => Promise<ExpoSQLiteDatabase>;
+}
+
+export interface RNStorageSQLiteClient {
+  openDatabase: ({
+    name,
+  }: {
+    name: string;
+  }) => Promise<RNStorageSQLiteDatabase>;
+}
+
+export interface RNSqliteNitroClient {
+  open: (options: { name: string; location?: string }) => RNNitroSQLiteDatabase;
+}
+
+export interface SupastashHookReturn {
+  dbReady: boolean;
+  startSync: () => void;
+  stopSync: () => void;
+}

package/dist/types/syncEngine.types.d.ts

@@ -0,0 +1,12 @@
+export type SyncResult = {
+  success: string[]; // IDs that were successfully upserted
+  skipped: { id: string; reason: string }[]; // IDs that were skipped with reason
+};
+
+export type TableSchema = {
+  name: string;
+  type: string;
+  notnull: boolean;
+  dflt_value: string;
+  pk: number;
+};

package/dist/utils/connection.d.ts

@@ -0,0 +1,2 @@
+export declare function isOnline(): Promise<boolean>;
+//# sourceMappingURL=connection.d.ts.map

package/dist/utils/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../src/utils/connection.ts"],"names":[],"mappings":"AAEA,wBAAsB,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC,CAIjD"}

package/dist/utils/connection.js

@@ -0,0 +1,7 @@
+import NetInfo from "@react-native-community/netinfo";
+export async function isOnline() {
+    if (!NetInfo)
+        return true;
+    const networkState = await NetInfo.fetch();
+    return !!(networkState.isConnected && networkState.isInternetReachable);
+}

package/dist/utils/events/eventBus.d.ts

@@ -0,0 +1,3 @@
+import { EventEmitter } from "events";
+export declare const supastashEventBus: EventEmitter<[never]>;
+//# sourceMappingURL=eventBus.d.ts.map

package/dist/utils/events/eventBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventBus.d.ts","sourceRoot":"","sources":["../../../src/utils/events/eventBus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGtC,eAAO,MAAM,iBAAiB,uBAAqB,CAAC"}

package/dist/utils/events/eventBus.js

@@ -0,0 +1,4 @@
+import { EventEmitter } from "events";
+import { getSupastashConfig } from "../../core/config";
+export const supastashEventBus = new EventEmitter();
+supastashEventBus.setMaxListeners(getSupastashConfig()?.listeners || 250);

package/dist/utils/fetchData/buildFilter.d.ts

@@ -0,0 +1,7 @@
+import { FilterOperator } from "../../types/realtimeData.types";
+export declare function buildFilterString(filters: {
+    column: string;
+    operator: FilterOperator;
+    value: string | number | null | (string | number)[];
+} | undefined): string | undefined;
+//# sourceMappingURL=buildFilter.d.ts.map

package/dist/utils/fetchData/buildFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildFilter.d.ts","sourceRoot":"","sources":["../../../src/utils/fetchData/buildFilter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,wBAAgB,iBAAiB,CAC/B,OAAO,EACH;IACE,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,cAAc,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CACrD,GACD,SAAS,GACZ,MAAM,GAAG,SAAS,CAepB"}

package/dist/utils/fetchData/buildFilter.js

@@ -0,0 +1,13 @@
+export function buildFilterString(filters) {
+    if (!filters) {
+        return undefined;
+    }
+    const { column, operator, value } = filters;
+    if (value === null) {
+        return `${column}=${operator}.null`;
+    }
+    if (operator === "in" && Array.isArray(value)) {
+        return `${column}=in.(${value.join(",")})`;
+    }
+    return `${column}=${operator}.${value}`;
+}

package/dist/utils/fetchData/createTable.d.ts

@@ -0,0 +1,8 @@
+import { PayloadData } from "../../types/query.types";
+/**
+ * Creates a table in the database
+ * @param table - The name of the table to create
+ * @param payload - The payload of the table
+ */
+export declare function createTable(table: string, payload?: PayloadData): Promise<void>;
+//# sourceMappingURL=createTable.d.ts.map

package/dist/utils/fetchData/createTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTable.d.ts","sourceRoot":"","sources":["../../../src/utils/fetchData/createTable.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAMtD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,iBA8CrE"}

package/dist/utils/fetchData/createTable.js

@@ -0,0 +1,48 @@
+import { getSupastashConfig } from "../../core/config";
+import { getSupastashDb } from "../../db/dbInitializer";
+import log from "../logs";
+import { checkIfTableExist } from "../tableValidator";
+import { getKeyType } from "./getKeyType";
+import { validatePayload } from "./validatePayload";
+/**
+ * Creates a table in the database
+ * @param table - The name of the table to create
+ * @param payload - The payload of the table
+ */
+export async function createTable(table, payload) {
+    const db = await getSupastashDb();
+    const config = getSupastashConfig();
+    let newPayload = payload;
+    const isTableExist = await checkIfTableExist(table);
+    if (isTableExist)
+        return;
+    if (!newPayload && config.supabaseClient) {
+        const { data, error } = await config.supabaseClient
+            .from(table)
+            .select("*")
+            .limit(1);
+        if (error) {
+            log("[Supastash] Error fetching data from supabase", error);
+            return;
+        }
+        newPayload = data?.[0];
+    }
+    if (!newPayload) {
+        log(`[Supastash] Can't create table ${table} because no data was found
+        Try creating the table manually using the 'defineLocalSchema()' function.
+      `);
+        return;
+    }
+    try {
+        validatePayload(newPayload);
+        const columns = Object.keys({ ...newPayload, synced_at: null }).map((key) => `${key} ${getKeyType(newPayload[key])}`);
+        log("Table to be created", columns);
+        // Create the table
+        await db.runAsync(`CREATE TABLE IF NOT EXISTS ${table} (${columns.join(", ")})`);
+    }
+    catch (error) {
+        throw new Error(`Failed to create table ${table}. 
+      Use the 'defineLocalSchema()' function to create the table manually.
+      Error: ${error}`);
+    }
+}

package/dist/utils/fetchData/deleteData.d.ts

@@ -0,0 +1,3 @@
+import { PayloadData } from "../../types/query.types";
+export declare function deleteData(payload: PayloadData, table: string, setDataMap: React.Dispatch<React.SetStateAction<Map<string, PayloadData>>>, setVersion: React.Dispatch<React.SetStateAction<string>>, dataMap: Map<string, PayloadData>, shouldFetch?: boolean): Promise<void>;
+//# sourceMappingURL=deleteData.d.ts.map

package/dist/utils/fetchData/deleteData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteData.d.ts","sourceRoot":"","sources":["../../../src/utils/fetchData/deleteData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAKtD,wBAAsB,UAAU,CAC9B,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAC1E,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EACxD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACjC,WAAW,GAAE,OAAc,iBAyB5B"}

package/dist/utils/fetchData/deleteData.js

@@ -0,0 +1,25 @@
+import { permanentlyDeleteData } from "../../utils/query/localDbQuery/delete";
+import { checkIfTableExist } from "../../utils/tableValidator";
+import { createTable } from "./createTable";
+export async function deleteData(payload, table, setDataMap, setVersion, dataMap, shouldFetch = true) {
+    if (!shouldFetch)
+        return;
+    try {
+        const exist = await checkIfTableExist(table);
+        if (!exist) {
+            await createTable(table, payload);
+        }
+        if (!payload?.id)
+            return;
+        // Delete the data
+        dataMap.delete(payload.id);
+        setDataMap(new Map(dataMap));
+        setVersion(`${table}-${Date.now()}`);
+        await permanentlyDeleteData(table, [
+            { column: "id", operator: "=", value: payload.id },
+        ]);
+    }
+    catch (error) {
+        console.error("[Supastash] Error receiving data:", error);
+    }
+}

package/dist/utils/fetchData/fetchLocalData.d.ts

@@ -0,0 +1,9 @@
+import { PayloadData } from "../../types/query.types";
+/**
+ * Fetches the local data from the database
+ * @param table - The name of the table to fetch from
+ * @param setData - The function to set the data
+ * @param shouldFetch - Whether to fetch the data
+ */
+export declare function fetchLocalData(table: string, setDataMap: React.Dispatch<React.SetStateAction<Map<string, PayloadData>>>, setVersion: React.Dispatch<React.SetStateAction<string>>, shouldFetch?: boolean, limit?: number): Promise<void>;
+//# sourceMappingURL=fetchLocalData.d.ts.map

package/dist/utils/fetchData/fetchLocalData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchLocalData.d.ts","sourceRoot":"","sources":["../../../src/utils/fetchData/fetchLocalData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAuBtD;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EAC1E,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EACxD,WAAW,GAAE,OAAc,EAC3B,KAAK,GAAE,MAAY,iBAkCpB"}

package/dist/utils/fetchData/fetchLocalData.js

@@ -0,0 +1,51 @@
+import { getSupastashDb } from "../../db/dbInitializer";
+let isFetching = new Map();
+function parseJSONColumns(row) {
+    const parsedRow = { ...row };
+    for (const key in parsedRow) {
+        const value = parsedRow[key];
+        if (typeof value === "string" &&
+            (value.startsWith("{") || value.startsWith("["))) {
+            try {
+                parsedRow[key] = JSON.parse(value);
+            }
+            catch { }
+        }
+    }
+    return parsedRow;
+}
+/**
+ * Fetches the local data from the database
+ * @param table - The name of the table to fetch from
+ * @param setData - The function to set the data
+ * @param shouldFetch - Whether to fetch the data
+ */
+export async function fetchLocalData(table, setDataMap, setVersion, shouldFetch = true, limit = 200) {
+    if (!shouldFetch || isFetching.get(table))
+        return;
+    isFetching.set(table, true);
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+        throw new Error(`Invalid table name: ${table}`);
+    }
+    const limitClause = `LIMIT ${limit ?? 200}`;
+    try {
+        const db = await getSupastashDb();
+        const localData = await db.getAllAsync(`SELECT * FROM ${table} WHERE deleted_at IS NULL ${limitClause}`);
+        const dataMap = new Map(localData
+            ?.map((item) => {
+            if (!item.id)
+                return undefined;
+            return [item.id, parseJSONColumns(item)];
+        })
+            .filter((item) => item !== undefined) ??
+            []);
+        setDataMap(dataMap);
+        setVersion(`${table}-${Date.now()}`);
+    }
+    catch (error) {
+        console.error(`[Supastash] Error fetching local data for ${table}:`, error);
+    }
+    finally {
+        isFetching.delete(table);
+    }
+}

package/dist/utils/fetchData/getKeyType.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Gets the type of the key
+ * @param value - The value of the key
+ * @returns The type of the key
+ */
+export declare function getKeyType(value: any): "NULL" | "INTEGER" | "REAL" | "TEXT" | "BLOB";
+//# sourceMappingURL=getKeyType.d.ts.map

package/dist/utils/fetchData/getKeyType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getKeyType.d.ts","sourceRoot":"","sources":["../../../src/utils/fetchData/getKeyType.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,GAAG,GACT,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAuB/C"}

package/dist/utils/fetchData/getKeyType.js

@@ -0,0 +1,25 @@
+/**
+ * Gets the type of the key
+ * @param value - The value of the key
+ * @returns The type of the key
+ */
+export function getKeyType(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    const valueType = typeof value;
+    if (valueType === "number") {
+        return Number.isInteger(value) ? "INTEGER" : "REAL";
+    }
+    if (value instanceof Date)
+        return "TEXT";
+    if (value instanceof ArrayBuffer ||
+        value instanceof Uint8Array ||
+        (typeof Buffer !== "undefined" && Buffer.isBuffer(value))) {
+        return "BLOB";
+    }
+    if (valueType === "boolean")
+        return "INTEGER";
+    if (valueType === "string")
+        return "TEXT";
+    return "TEXT";
+}

package/dist/utils/fetchData/initialFetch.d.ts

@@ -0,0 +1,3 @@
+import { RealtimeFilter } from "../../types/realtimeData.types";
+export declare function initialFetch(table: string, filter?: RealtimeFilter, onReceiveData?: (payload: any) => Promise<void>, onPushToRemote?: (payload: any[]) => Promise<boolean>): Promise<void>;
+//# sourceMappingURL=initialFetch.d.ts.map

package/dist/utils/fetchData/initialFetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialFetch.d.ts","sourceRoot":"","sources":["../../../src/utils/fetchData/initialFetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAOhE,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,cAAc,EACvB,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EAC/C,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,iBAatD"}

package/dist/utils/fetchData/initialFetch.js

@@ -0,0 +1,20 @@
+import { updateLocalDb } from "../sync/pullFromRemote/updateLocalDb";
+import { pushLocalDataToRemote } from "../sync/pushLocal/sendUnsyncedToSupabase";
+import { createTable } from "./createTable";
+let isInSync = new Map();
+export async function initialFetch(table, filter, onReceiveData, onPushToRemote) {
+    if (isInSync.get(table))
+        return;
+    isInSync.set(table, true);
+    try {
+        await createTable(table);
+        await updateLocalDb(table, filter, onReceiveData);
+        await pushLocalDataToRemote(table, onPushToRemote);
+    }
+    catch (error) {
+        console.error(`[Supastash] Error on initial fetch for ${table}`, error);
+    }
+    finally {
+        isInSync.delete(table);
+    }
+}

package/dist/utils/fetchData/realTimeCall.d.ts

@@ -0,0 +1,5 @@
+import { PayloadData } from "../../types/query.types";
+import { RealtimeOptions } from "../../types/realtimeData.types";
+declare const useRealtimeData: (table: string, queueHandler: (eventType: string, data: PayloadData) => void, options: RealtimeOptions, initialized: boolean, realtime: boolean) => void;
+export default useRealtimeData;
+//# sourceMappingURL=realTimeCall.d.ts.map

package/dist/utils/fetchData/realTimeCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realTimeCall.d.ts","sourceRoot":"","sources":["../../../src/utils/fetchData/realTimeCall.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAMjE,QAAA,MAAM,eAAe,GACnB,OAAO,MAAM,EACb,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,KAAK,IAAI,EAC5D,SAAS,eAAe,EACxB,aAAa,OAAO,EACpB,UAAU,OAAO,SAmDlB,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/utils/fetchData/realTimeCall.js

@@ -0,0 +1,43 @@
+import { useEffect } from "react";
+import { getSupastashConfig } from "../../core/config";
+import { supabaseClientErr } from "../supabaseClientErr";
+import { buildFilterString } from "./buildFilter";
+const hasRegistered = new Map();
+const useRealtimeData = (table, queueHandler, options, initialized, realtime) => {
+    const { lazy, shouldFetch } = options;
+    useEffect(() => {
+        if (!realtime || (options.lazy && !initialized) || !shouldFetch) {
+            return;
+        }
+        const filterString = options.filter
+            ? buildFilterString(options.filter)
+            : undefined;
+        if (hasRegistered.get(`${table}:${filterString ?? ""}`))
+            return;
+        hasRegistered.set(`${table}:${filterString ?? ""}`, true);
+        const supabase = getSupastashConfig().supabaseClient;
+        if (!supabase) {
+            console.error("[Supastash] No supabase client found", supabaseClientErr);
+            return;
+        }
+        const subDetails = filterString
+            ? { event: "*", schema: "public", table, filter: filterString }
+            : { event: "*", schema: "public", table };
+        const subscription = supabase
+            .channel(`supastash:realtime:${table}:${filterString ? filterString : ""}`)
+            .on("postgres_changes", subDetails, (payload) => {
+            console.log("[Supastash] 🔥 GOT PAYLOAD:", payload?.new?.id
+                ? payload?.new?.id
+                : "No id found for this item", `on table ${table}`, `with event type ${payload.eventType}`);
+            queueHandler(payload.eventType, payload.new);
+        })
+            .subscribe((status, err) => {
+            if (err)
+                console.error(`[Supastash] 📡 STATUS: ${status} on table ${table}`, err);
+        });
+        return () => {
+            supabase.removeChannel(subscription);
+        };
+    }, [table, lazy, initialized, realtime, shouldFetch]);
+};
+export default useRealtimeData;