supastash 0.1.0

package/dist/utils/sync/pullFromRemote/getLastPulledInfo.js

@@ -0,0 +1,29 @@
+import { getSupastashDb } from "../../../db/dbInitializer";
+const DEFAULT_LAST_PULLED_AT = "2024-01-01T00:00:00Z";
+const SYNC_STATUS_TABLE = "supastash_sync_status";
+/**
+ * Gets the last synced timestamp for a given table
+ * @param table - The table to get the last synced timestamp for
+ * @returns The last synced timestamp
+ */
+export async function getLastPulledInfo(table) {
+    const db = await getSupastashDb();
+    // Add table name to supastash_sync_status if it doesn't exist
+    await db.runAsync(`INSERT OR IGNORE INTO supastash_sync_status (table_name, last_synced_at) VALUES (?, ?)`, [table, DEFAULT_LAST_PULLED_AT]);
+    // Get the latest sync timestamp for this table
+    const result = await db.getFirstAsync(`SELECT last_synced_at FROM ${SYNC_STATUS_TABLE} WHERE table_name = ?`, [table]);
+    const original = result?.last_synced_at || DEFAULT_LAST_PULLED_AT;
+    const timestamp = Date.parse(original);
+    const lastSyncedAt = new Date(timestamp + 1);
+    const lastSyncedAtISOString = lastSyncedAt.toISOString();
+    return lastSyncedAtISOString;
+}
+/**
+ * Updates the last synced timestamp for a given table
+ * @param table - The table to update the last synced timestamp for
+ * @param lastSyncedAt - The last synced timestamp
+ */
+export async function updateLastPulledInfo(table, lastSyncedAt) {
+    const db = await getSupastashDb();
+    await db.runAsync(`UPDATE ${SYNC_STATUS_TABLE} SET last_synced_at = ? WHERE table_name = ?`, [lastSyncedAt, table]);
+}

package/dist/utils/sync/pullFromRemote/pullData.d.ts

@@ -0,0 +1,9 @@
+import { PayloadData } from "../../../types/query.types";
+import { RealtimeFilter } from "../../../types/realtimeData.types";
+/**
+ * Pulls data from the remote database for a given table
+ * @param table - The table to pull data from
+ * @returns The data from the table
+ */
+export declare function pullData(table: string, filter?: RealtimeFilter): Promise<PayloadData[] | null>;
+//# sourceMappingURL=pullData.d.ts.map

package/dist/utils/sync/pullFromRemote/pullData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pullData.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pullFromRemote/pullData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAoBnE;;;;GAIG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,cAAc,GACtB,OAAO,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAsE/B"}

package/dist/utils/sync/pullFromRemote/pullData.js

@@ -0,0 +1,71 @@
+import { getSupastashConfig } from "../../../core/config";
+import log from "../../logs";
+import { supabaseClientErr } from "../../supabaseClientErr";
+import { getLastPulledInfo, updateLastPulledInfo } from "./getLastPulledInfo";
+const validOperators = new Set([
+    "eq",
+    "neq",
+    "gt",
+    "lt",
+    "gte",
+    "lte",
+    "like",
+    "ilike",
+    "is",
+    "in",
+]);
+let timesPushed = 0;
+let lastPushed = 0;
+/**
+ * Pulls data from the remote database for a given table
+ * @param table - The table to pull data from
+ * @returns The data from the table
+ */
+export async function pullData(table, filter) {
+    const lastSyncedAt = await getLastPulledInfo(table);
+    const supabase = getSupastashConfig().supabaseClient;
+    if (!supabase)
+        throw new Error(`No supabase client found: ${supabaseClientErr}`);
+    let filteredQuery = supabase
+        .from(table)
+        .select("*")
+        .gt("updated_at", lastSyncedAt)
+        .is("deleted_at", null)
+        .order("updated_at", { ascending: false, nullsFirst: false });
+    if (filter &&
+        (!filter.operator ||
+            !validOperators.has(filter.operator) ||
+            !filter.column ||
+            !filter.value)) {
+        throw new Error(`Invalid filter: ${JSON.stringify(filter)} for table ${table}`);
+    }
+    if (filter?.operator &&
+        validOperators.has(filter.operator) &&
+        filter.column &&
+        filter.value) {
+        filteredQuery = filteredQuery[filter.operator](filter.column, filter.value);
+    }
+    // Fetch records updated after the last sync
+    const { data, error } = await filteredQuery;
+    if (error) {
+        log(`[Supastash] Error fetching from ${table}:`, error.message);
+        return null;
+    }
+    if (!data || data.length === 0) {
+        timesPushed++;
+        if (timesPushed >= 30) {
+            const timeSinceLastPush = Date.now() - lastPushed;
+            lastPushed = Date.now();
+            log(`[Supastash] No updates for ${table} at ${lastSyncedAt} (times pushed: ${timesPushed}) in the last ${timeSinceLastPush}ms`);
+            timesPushed = 0;
+        }
+        return null;
+    }
+    log(`Received ${data.length} updates for ${table}`);
+    // Update the supastash_sync_status table with the lastest timestamp
+    const lastest = data.find((r) => r.updated_at)?.updated_at;
+    if (lastest) {
+        await updateLastPulledInfo(table, lastest);
+    }
+    return data;
+}

package/dist/utils/sync/pullFromRemote/pullDeletedData.d.ts

@@ -0,0 +1,12 @@
+import { PayloadData } from "../../../types/query.types";
+import { RealtimeFilter } from "../../../types/realtimeData.types";
+/**
+ * Pulls deleted data from the remote database for a given table
+ * @param table - The table to pull deleted data from
+ * @returns The deleted data from the table as a map of id to record and the reordered data
+ */
+export declare function pullDeletedData(table: string, filter?: RealtimeFilter): Promise<{
+    deletedDataMap: Map<string, PayloadData>;
+    records: PayloadData[];
+} | null>;
+//# sourceMappingURL=pullDeletedData.d.ts.map

package/dist/utils/sync/pullFromRemote/pullDeletedData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pullDeletedData.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pullFromRemote/pullDeletedData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAwBnE;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,cAAc,GACtB,OAAO,CAAC;IACT,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACzC,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB,GAAG,IAAI,CAAC,CAqER"}

package/dist/utils/sync/pullFromRemote/pullDeletedData.js

@@ -0,0 +1,69 @@
+import { getSupastashConfig } from "../../../core/config";
+import log from "../../logs";
+import { supabaseClientErr } from "../../supabaseClientErr";
+import { getLastDeletedInfo, updateLastDeletedInfo, } from "./getLastDeletedInfo";
+const validOperators = new Set([
+    "eq",
+    "neq",
+    "gt",
+    "lt",
+    "gte",
+    "lte",
+    "like",
+    "ilike",
+    "is",
+    "in",
+]);
+let timesPushed = 0;
+let lastPushed = 0;
+/**
+ * Pulls deleted data from the remote database for a given table
+ * @param table - The table to pull deleted data from
+ * @returns The deleted data from the table as a map of id to record and the reordered data
+ */
+export async function pullDeletedData(table, filter) {
+    const lastDeletedAt = await getLastDeletedInfo(table);
+    const supabase = getSupastashConfig().supabaseClient;
+    if (!supabase)
+        throw new Error(`No supabase client found: ${supabaseClientErr}`);
+    let filteredQuery = supabase
+        .from(table)
+        .select("*")
+        .gt("deleted_at", lastDeletedAt)
+        .order("deleted_at", { ascending: false, nullsFirst: false });
+    if (filter &&
+        (!filter.operator ||
+            !validOperators.has(filter.operator) ||
+            !filter.column ||
+            !filter.value)) {
+        throw new Error(`Invalid filter: ${JSON.stringify(filter)} for table ${table}`);
+    }
+    if (filter?.operator &&
+        validOperators.has(filter.operator) &&
+        filter.column &&
+        filter.value) {
+        filteredQuery = filteredQuery[filter.operator](filter.column, filter.value);
+    }
+    // Fetch records deleted after the last sync
+    const { data, error } = await filteredQuery;
+    if (error) {
+        log(`[Supastash] Error fetching from ${table}:`, error.message);
+        return null;
+    }
+    if (!data || data.length === 0) {
+        timesPushed++;
+        if (timesPushed >= 30) {
+            const timeSinceLastPush = Date.now() - lastPushed;
+            lastPushed = Date.now();
+            log(`[Supastash] No deleted records for ${table} from ${lastDeletedAt} (times pushed: ${timesPushed}) in the last ${timeSinceLastPush}ms`);
+            timesPushed = 0;
+        }
+        return null;
+    }
+    log(`Received ${data.length} deleted records for ${table}`);
+    // Update the supastash_deleted_status table with the lastest timestamp
+    const lastest = data.find((r) => r.deleted_at)?.deleted_at;
+    await updateLastDeletedInfo(table, lastest);
+    const deletedDataMap = new Map(data.map((d) => [d.id, d]));
+    return { deletedDataMap, records: data };
+}

package/dist/utils/sync/pullFromRemote/stringifyFields.d.ts

@@ -0,0 +1,2 @@
+export declare function stringifyComplexFields(record: any): any;
+//# sourceMappingURL=stringifyFields.d.ts.map

package/dist/utils/sync/pullFromRemote/stringifyFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyFields.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pullFromRemote/stringifyFields.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,GAAG,OAUjD"}

package/dist/utils/sync/pullFromRemote/stringifyFields.js

@@ -0,0 +1,11 @@
+export function stringifyComplexFields(record) {
+    const result = {};
+    for (const key in record) {
+        const value = record[key];
+        result[key] =
+            typeof value === "object" && value !== null
+                ? JSON.stringify(value)
+                : value;
+    }
+    return result;
+}

package/dist/utils/sync/pullFromRemote/updateLocalDb.d.ts

@@ -0,0 +1,14 @@
+import { RealtimeFilter } from "../../../types/realtimeData.types";
+/**
+ * Updates the local database with the remote changes
+ * @param table - The table to update
+ */
+export declare function updateLocalDb(table: string, filters?: RealtimeFilter, onReceiveData?: (payload: any) => Promise<void>): Promise<void>;
+/**
+ * Upserts a record into the local database
+ * @param table - The table to upsert the record into
+ * @param record - The record to upsert
+ * @param exists - Whether the record already exists in the database
+ */
+export declare function upsertData(table: string, record: any, doesExist?: boolean): Promise<void>;
+//# sourceMappingURL=updateLocalDb.d.ts.map

package/dist/utils/sync/pullFromRemote/updateLocalDb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateLocalDb.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pullFromRemote/updateLocalDb.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAanE;;;GAGG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,cAAc,EACxB,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,iBAiDhD;AAID;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,GAAG,EACX,SAAS,CAAC,EAAE,OAAO,iBAkEpB"}

package/dist/utils/sync/pullFromRemote/updateLocalDb.js

@@ -0,0 +1,128 @@
+import { getSupastashConfig } from "../../../core/config";
+import { getSupastashDb } from "../../../db/dbInitializer";
+import { isOnline } from "../../connection";
+import { supastashEventBus } from "../../events/eventBus";
+import { getTableSchema } from "../../getTableSchema";
+import log from "../../logs";
+import { updateLocalSyncedAt } from "../../syncUpdate";
+import { pullData } from "./pullData";
+import { pullDeletedData } from "./pullDeletedData";
+import { stringifyComplexFields } from "./stringifyFields";
+let isInSync = new Map();
+const DEFAULT_DATE = "1970-01-01T00:00:00Z";
+/**
+ * Updates the local database with the remote changes
+ * @param table - The table to update
+ */
+export async function updateLocalDb(table, filters, onReceiveData) {
+    if (isInSync.get(table))
+        return;
+    isInSync.set(table, true);
+    try {
+        if (!(await isOnline()))
+            return;
+        const db = await getSupastashDb();
+        const deletedData = await pullDeletedData(table, filters);
+        const data = await pullData(table, filters);
+        const dataToUpdate = data?.filter((d) => !deletedData?.deletedDataMap.has(d.id));
+        const changes = !!deletedData || !!dataToUpdate;
+        // Delete records that are no longer in the remote data
+        if (deletedData) {
+            for (const record of deletedData.records) {
+                await db.runAsync(`DELETE FROM ${table} WHERE id = ?`, [record.id]);
+            }
+            supastashEventBus.emit(`push:${table}`, deletedData.records, "delete");
+        }
+        // Update local database with remote changes
+        if (dataToUpdate) {
+            for (const record of dataToUpdate) {
+                const { doesExist, newer } = await checkIfRecordExistsAndIsNewer(table, record);
+                if (newer) {
+                    if (onReceiveData) {
+                        await onReceiveData(record);
+                    }
+                    else {
+                        await upsertData(table, record, doesExist);
+                    }
+                }
+            }
+        }
+        if (changes)
+            supastashEventBus.emit(`push:${table}`, dataToUpdate, "update");
+    }
+    catch (error) {
+        console.error(`[Supastash] Error updating local db for ${table}`, error);
+    }
+    finally {
+        isInSync.delete(table);
+    }
+}
+const warned = new Map();
+/**
+ * Upserts a record into the local database
+ * @param table - The table to upsert the record into
+ * @param record - The record to upsert
+ * @param exists - Whether the record already exists in the database
+ */
+export async function upsertData(table, record, doesExist) {
+    if (!record?.id)
+        return;
+    let itemExists = !!doesExist;
+    if (doesExist === undefined) {
+        const { doesExist: exists } = await checkIfRecordExistsAndIsNewer(table, record);
+        itemExists = exists;
+    }
+    try {
+        const db = await getSupastashDb();
+        const columns = await getTableSchema(table);
+        const recordToSave = {
+            ...stringifyComplexFields(record),
+            synced_at: new Date().toISOString(),
+        };
+        if (__DEV__ && getSupastashConfig().debugMode) {
+            const unknownKeys = Object.keys(record).filter((key) => !columns.includes(key));
+            if (unknownKeys.length > 0 && !warned.get(table)) {
+                warned.set(table, true);
+                console.warn(`⚠️ [Supastash] ${table} record contains keys not in local schema: ${unknownKeys.join(", ")}. Data will still be stored`);
+            }
+        }
+        // Prep for upsert
+        const keys = columns;
+        const placeholders = keys.map(() => "?").join(", ");
+        const updateParts = keys
+            .filter((key) => key !== "id")
+            .map((key) => `${key} = ?`);
+        const updatePlaceholders = updateParts.join(", ");
+        const values = keys.map((key) => recordToSave[key]);
+        const updateValues = keys
+            .filter((key) => key !== "id")
+            .map((key) => recordToSave[key]);
+        if (itemExists) {
+            // Update existing record
+            await db.runAsync(`UPDATE ${table} SET ${updatePlaceholders} WHERE id = ?`, [...updateValues, record.id]);
+        }
+        else {
+            // Insert new record
+            await db.runAsync(`INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`, values);
+        }
+        await updateLocalSyncedAt(table, record.id);
+    }
+    catch (error) {
+        console.error(`[Supastash] Error upserting data for ${table}`, error);
+    }
+}
+async function checkIfRecordExistsAndIsNewer(table, item) {
+    if (!item?.id)
+        return { doesExist: false, newer: false };
+    const db = await getSupastashDb();
+    const record = await db.getFirstAsync(`SELECT * FROM ${table} WHERE id = ?`, [
+        item.id,
+    ]);
+    if (record &&
+        new Date(record.updated_at || DEFAULT_DATE) >=
+            new Date(item.updated_at || DEFAULT_DATE)) {
+        log(`Skipping ${table}:${record.id} - local is newer`);
+        return { doesExist: true, newer: false };
+    }
+    return { doesExist: !!record, newer: true };
+}

package/dist/utils/sync/pushLocal/deleteChunks.d.ts

@@ -0,0 +1,8 @@
+import { PayloadData } from "../../../types/query.types";
+/**
+ * Deletes a chunk of data from the remote database
+ * @param table - The table to delete from
+ * @param unsyncedRecords - The unsynced records to delete
+ */
+export declare function deleteData(table: string, unsyncedRecords: PayloadData[]): Promise<void>;
+//# sourceMappingURL=deleteChunks.d.ts.map

package/dist/utils/sync/pushLocal/deleteChunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteChunks.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/deleteChunks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAqDzD;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,EAAE,iBAU/B"}

package/dist/utils/sync/pushLocal/deleteChunks.js

@@ -0,0 +1,51 @@
+import { getSupastashConfig } from "../../../core/config";
+import { getSupastashDb } from "../../../db/dbInitializer";
+import log from "../../logs";
+import { parseStringifiedFields } from "./parseFields";
+const CHUNK_SIZE = 500;
+/**
+ * Permanently deletes a chunk of data from the local database
+ * @param table - The table to delete from
+ * @param chunk - The chunk of data to delete
+ */
+async function permanentlyDeleteChunkLocally(table, chunk) {
+    const db = await getSupastashDb();
+    for (const row of chunk) {
+        await db.runAsync(`DELETE FROM ${table} WHERE id = ${row.id}`);
+    }
+}
+/**
+ * Deletes a chunk of data from the remote database
+ * @param table - The table to delete from
+ * @param chunk - The chunk of data to delete
+ */
+async function deleteChunk(table, chunk) {
+    const config = getSupastashConfig();
+    const supabase = config.supabaseClient;
+    if (!supabase) {
+        throw new Error("No supabase client found");
+    }
+    let attempts = 0;
+    while (attempts < 3) {
+        const { error } = await supabase.from(table).upsert(chunk);
+        if (!error) {
+            await permanentlyDeleteChunkLocally(table, chunk);
+            break;
+        }
+        log(`Delete attempt ${attempts + 1} failed for a delete operation on table ${table}`, error);
+        await new Promise((res) => setTimeout(res, 1000 * Math.pow(2, attempts)));
+        attempts++;
+    }
+}
+/**
+ * Deletes a chunk of data from the remote database
+ * @param table - The table to delete from
+ * @param unsyncedRecords - The unsynced records to delete
+ */
+export async function deleteData(table, unsyncedRecords) {
+    const cleanRecords = unsyncedRecords.map(({ synced_at, deleted_at, ...rest }) => parseStringifiedFields(rest));
+    for (let i = 0; i < cleanRecords.length; i += CHUNK_SIZE) {
+        const chunk = cleanRecords.slice(i, i + CHUNK_SIZE);
+        await deleteChunk(table, chunk);
+    }
+}

package/dist/utils/sync/pushLocal/getAllUnsyncedData.d.ts

@@ -0,0 +1,14 @@
+import { PayloadData } from "../../../types/query.types";
+/**
+ * Gets all unsynced data from a table
+ * @param table - The table to get the data from
+ * @returns The unsynced data
+ */
+export declare function getAllUnsyncedData(table: string): Promise<PayloadData[] | null>;
+/**
+ * Gets all deleted data from a table
+ * @param table - The table to get the data from
+ * @returns The deleted data
+ */
+export declare function getAllDeletedData(table: string): Promise<PayloadData[] | null>;
+//# sourceMappingURL=getAllUnsyncedData.d.ts.map

package/dist/utils/sync/pushLocal/getAllUnsyncedData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAllUnsyncedData.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/getAllUnsyncedData.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AA+DzD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAe/B;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,CAM/B"}

package/dist/utils/sync/pushLocal/getAllUnsyncedData.js

@@ -0,0 +1,70 @@
+import { getSupastashConfig } from "../../../core/config";
+import { getSupastashDb } from "../../../db/dbInitializer";
+import { getTableSchema } from "../../../utils/getTableSchema";
+import log from "../../../utils/logs";
+import { supabaseClientErr } from "../../supabaseClientErr";
+const numberOfErrors = new Map();
+const sharedKeysCache = new Map();
+async function getRemoteKeys(table) {
+    const config = getSupastashConfig();
+    const supabase = config?.supabaseClient;
+    if (!supabase) {
+        throw new Error(`Supabase client not found, ${supabaseClientErr}`);
+    }
+    if (sharedKeysCache.has(table)) {
+        return sharedKeysCache.get(table);
+    }
+    if (numberOfErrors.get(table) && (numberOfErrors.get(table) || 0) > 3) {
+        return null;
+    }
+    const { data, error } = await supabase.rpc("get_column_names", {
+        table_name: table,
+    });
+    if (error) {
+        log(`[Supastash] Error getting remote keys for table ${table} on public schema: ${error.message}`);
+        numberOfErrors.set(table, (numberOfErrors.get(table) || 0) + 1);
+        return null;
+    }
+    const keys = data?.map((item) => item.column_name);
+    const columns = await getTableSchema(table);
+    const sharedKeys = keys?.filter((key) => columns.includes(key));
+    const missingKeys = columns.filter((column) => !keys?.includes(column) && column !== "synced_at");
+    // Inform user of missing keys
+    if (missingKeys.length > 0) {
+        log(`[Supastash] Missing keys for table ${table} on public schema: ${missingKeys.join(", ")}`);
+    }
+    // Return shared keys if they exist
+    if (sharedKeys) {
+        sharedKeysCache.set(table, sharedKeys);
+        return sharedKeys;
+    }
+    return null;
+}
+/**
+ * Gets all unsynced data from a table
+ * @param table - The table to get the data from
+ * @returns The unsynced data
+ */
+export async function getAllUnsyncedData(table) {
+    const db = await getSupastashDb();
+    const remoteKeys = await getRemoteKeys(table);
+    if (!remoteKeys) {
+        const query = `SELECT * FROM ${table} WHERE synced_at IS NULL AND deleted_at IS NULL`;
+        const data = await db.getAllAsync(query);
+        return data ?? null;
+    }
+    const columns = remoteKeys.join(", ");
+    const query = `SELECT ${columns} FROM ${table} WHERE synced_at IS NULL AND deleted_at IS NULL`;
+    const data = await db.getAllAsync(query);
+    return data ?? null;
+}
+/**
+ * Gets all deleted data from a table
+ * @param table - The table to get the data from
+ * @returns The deleted data
+ */
+export async function getAllDeletedData(table) {
+    const db = await getSupastashDb();
+    const data = await db.getAllAsync(`SELECT deleted_at, id FROM ${table} WHERE deleted_at IS NOT NULL`);
+    return data ?? null;
+}

package/dist/utils/sync/pushLocal/parseFields.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parses stringified fields in a record
+ * @param record - The record to parse
+ * @returns The parsed record
+ */
+export declare function parseStringifiedFields(record: any): any;
+//# sourceMappingURL=parseFields.d.ts.map

package/dist/utils/sync/pushLocal/parseFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFields.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/parseFields.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,GAAG,OAgBjD"}

package/dist/utils/sync/pushLocal/parseFields.js

@@ -0,0 +1,24 @@
+/**
+ * Parses stringified fields in a record
+ * @param record - The record to parse
+ * @returns The parsed record
+ */
+export function parseStringifiedFields(record) {
+    const parsed = {};
+    for (const key in record) {
+        const value = record[key];
+        if (typeof value === "string") {
+            try {
+                const maybeParsed = JSON.parse(value);
+                parsed[key] = maybeParsed;
+            }
+            catch {
+                parsed[key] = value;
+            }
+        }
+        else {
+            parsed[key] = value;
+        }
+    }
+    return parsed;
+}

package/dist/utils/sync/pushLocal/sendUnsyncedToSupabase.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sends unsynced data to the remote database for a given table
+ * @param table - The table to send the data to
+ */
+export declare function pushLocalDataToRemote(table: string, onPushToRemote?: (payload: any[]) => Promise<boolean>, noSync?: string[]): Promise<void>;
+//# sourceMappingURL=sendUnsyncedToSupabase.d.ts.map

package/dist/utils/sync/pushLocal/sendUnsyncedToSupabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendUnsyncedToSupabase.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/sendUnsyncedToSupabase.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACrD,MAAM,CAAC,EAAE,MAAM,EAAE,iBAsClB"}

package/dist/utils/sync/pushLocal/sendUnsyncedToSupabase.js

@@ -0,0 +1,43 @@
+import { isOnline } from "../../connection";
+import { supastashEventBus } from "../../events/eventBus";
+import { deleteData } from "./deleteChunks";
+import { getAllDeletedData, getAllUnsyncedData } from "./getAllUnsyncedData";
+import { uploadData } from "./uploadChunk";
+let isInSync = new Map();
+/**
+ * Sends unsynced data to the remote database for a given table
+ * @param table - The table to send the data to
+ */
+export async function pushLocalDataToRemote(table, onPushToRemote, noSync) {
+    if (isInSync.get(table))
+        return;
+    isInSync.set(table, true);
+    try {
+        if (!(await isOnline()))
+            return;
+        const data = await getAllUnsyncedData(table);
+        const deletedData = await getAllDeletedData(table);
+        if ((!data || data.length === 0) &&
+            (!deletedData || deletedData.length === 0)) {
+            noSync?.push(table);
+            return;
+        }
+        if (data && data.length > 0) {
+            await uploadData(table, data, onPushToRemote);
+            supastashEventBus.emit(`push:${table}`, data, "insert");
+        }
+        const payloadForDeletedData = deletedData?.map((item) => ({
+            id: item.id,
+            deleted_at: item.deleted_at,
+        }));
+        if (payloadForDeletedData && payloadForDeletedData.length > 0) {
+            await deleteData(table, payloadForDeletedData);
+        }
+    }
+    catch (error) {
+        console.error(`[Supastash] Error pushing local data to remote for ${table}`, error);
+    }
+    finally {
+        isInSync.delete(table);
+    }
+}

package/dist/utils/sync/pushLocal/uploadChunk.d.ts

@@ -0,0 +1,8 @@
+import { PayloadData } from "../../../types/query.types";
+/**
+ * Uploads a chunk of data to the remote database
+ * @param table - The table to upload to
+ * @param unsyncedRecords - The unsynced records to upload
+ */
+export declare function uploadData(table: string, unsyncedRecords: PayloadData[], onPushToRemote?: (payload: any[]) => Promise<boolean>): Promise<void>;
+//# sourceMappingURL=uploadChunk.d.ts.map

package/dist/utils/sync/pushLocal/uploadChunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../src/utils/sync/pushLocal/uploadChunk.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AA0IzD;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,EAAE,EAC9B,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,iBAUtD"}