pulse-rn 1.0.0

package/README.md

@@ -0,0 +1,235 @@
+# pulse-rn
+
+![NPM Version](https://img.shields.io/npm/v/pulse-rn)
+![License](https://img.shields.io/npm/l/pulse-rn)
+
+A lightweight offline-first synchronization engine for React Native/Expo applications. Provides real-time data synchronization between local SQLite database and remote server through WebSocket connections with conflict resolution and delta sync capabilities. It needs a backend server with the django-pulse library to work with. If this is library is well received, I will add more features to it and others backends support.
+
+## Features
+
+- **Offline-first architecture**: Local SQLite database with automatic sync when online
+- **Real-time synchronization**: WebSocket-based bidirectional sync
+- **Conflict resolution**: Version-based conflict handling with server authority
+- **Delta sync**: Only sync changes since last sync to minimize bandwidth
+- **Batch operations**: Efficient batching of local changes
+- **TypeScript support**: Full TypeScript implementation with type safety
+- **React Query integration**: Seamless integration with TanStack Query
+
+## Installation
+
+```bash
+npm install pulse-rn expo-sqlite expo-crypto @tanstack/react-query
+```
+
+## Configuration
+
+### PulseProvider Setup
+
+```tsx
+import { PulseProvider } from 'pulse-rn';
+
+function App() {
+  return (
+    <PulseProvider
+      config={{
+        baseUrl: 'localhost:8000',
+        userId: 1,
+        tablesConfig: {
+          items: ['id', 'name', 'description', 'version', 'is_deleted'],
+          users: ['id', 'name', 'email', 'version', 'is_deleted']
+        }
+      }}
+    >
+      {/* Your app components */}
+    </PulseProvider>
+  );
+}
+```
+
+#### Configuration Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `baseUrl` | string | WebSocket server base URL |
+| `userId` | number | Current user identifier |
+| `tablesConfig` | Record<string, string[]> | Table schema definitions |
+
+## API Reference
+
+### Hooks
+
+#### useSyncTable
+
+React hook for querying synchronized table data.
+
+```tsx
+import { useSyncTable } from 'pulse-rn';
+
+function ItemsList() {
+  const { data: items, isLoading, error } = useSyncTable('items');
+  
+  if (isLoading) return <Text>Loading...</Text>;
+  if (error) return <Text>Error: {error.message}</Text>;
+  
+  return (
+    <FlatList
+      data={items}
+      renderItem={({ item }) => <Text>{item.name}</Text>}
+    />
+  );
+}
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tableName` | string | Name of the table to query |
+
+**Returns**: Query object with `data`, `isLoading`, `error` properties filtered by `is_deleted = 0`
+
+### Functions
+
+#### createItem
+
+Creates a new record with automatic sync ID generation.
+
+```tsx
+import { createItem } from 'pulse-rn';
+import { useQueryClient } from '@tanstack/react-query';
+
+function CreateItemForm() {
+  const queryClient = useQueryClient();
+  
+  const handleCreate = () => {
+    createItem('items', {
+      name: 'New Item',
+      description: 'Item description'
+    }, queryClient);
+  };
+  
+  return <Button title="Create Item" onPress={handleCreate} />;
+}
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tableName` | string | Target table name |
+| `data` | object | Record data to insert |
+| `queryClient` | QueryClient | TanStack Query client instance |
+
+**Behavior**: Generates UUID `sync_id`, sets `version = 0`, marks `is_local_only = 1`
+
+#### updateItem
+
+Updates an existing record and queues for synchronization.
+
+```tsx
+import { updateItem } from 'pulse-rn';
+
+function UpdateItem({ item }) {
+  const queryClient = useQueryClient();
+  
+  const handleUpdate = () => {
+    updateItem('items', item.sync_id, {
+      name: 'Updated Name',
+      description: 'Updated description'
+    }, queryClient);
+  };
+  
+  return <Button title="Update" onPress={handleUpdate} />;
+}
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tableName` | string | Target table name |
+| `sync_id` | string | Record synchronization identifier |
+| `data` | object | Fields to update |
+| `queryClient` | QueryClient | TanStack Query client instance |
+
+**Behavior**: Updates specific fields, marks `is_local_only = 1`, resets `sync_error`
+
+#### deleteItem
+
+Performs logical deletion of a record.
+
+```tsx
+import { deleteItem } from 'pulse-rn';
+
+function DeleteItem({ item }) {
+  const queryClient = useQueryClient();
+  
+  const handleDelete = () => {
+    deleteItem('items', item.sync_id, queryClient);
+  };
+  
+  return <Button title="Delete" onPress={handleDelete} />;
+}
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tableName` | string | Target table name |
+| `sync_id` | string | Record synchronization identifier |
+| `queryClient` | QueryClient | TanStack Query client instance |
+
+**Behavior**: Sets `is_deleted = 1` (logical deletion)
+
+## Synchronization Logic
+
+### Batching System
+
+Local changes are batched and sent to the server every 2 seconds to optimize network usage:
+
+- Accumulates create/update/delete operations
+- Sends batches of up to 50 records per request
+- Automatic retry on connection failure
+
+### Delta Sync
+
+When connecting to the server, pulse-rn requests only changes since the last synchronization:
+
+```typescript
+{
+  type: 'SYNC_REQUEST_DELTA',
+  table: 'items',
+  last_version: 42
+}
+```
+
+- Tracks maximum local version per table
+- Only requests records with version > max_local_version
+- Minimizes bandwidth usage
+
+### Conflict Resolution
+
+Version-based conflict resolution with server authority:
+
+1. Client operations increment version numbers
+2. Server validates and applies changes with final authority
+3. Conflicts resolved by server version precedence
+4. Failed operations marked with `sync_error` field
+
+### Connection Management
+
+- Automatic reconnection with 3-second backoff
+- WebSocket connection state management
+- Graceful handling of network interruptions
+
+## WebSocket Protocol
+
+### Message Types
+
+| Type | Description |
+|-------|-------------|
+| `SYNC_BATCH_UPLOAD` | Batch of local changes |
+| `SYNC_REQUEST_DELTA` | Request changes since version |
+| `BATCH_ACK` | Batch processing acknowledgment |
+| `SYNC_ACK_INDIVIDUAL` | Individual operation result |
+| `SYNC_UPDATE` | Real-time data updates |
+
+## Error Handling
+
+- Network errors trigger automatic reconnection
+- Failed operations stored with error messages
+- Sync queue preserved across app restarts
+- Graceful degradation when offline

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './src/database';
+export * from './src/sync-engine';
+export * from './src/operations';
+export * from './src/context';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/database"), exports);
+__exportStar(require("./src/sync-engine"), exports);
+__exportStar(require("./src/operations"), exports);
+__exportStar(require("./src/context"), exports);

package/dist/src/context.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface PulseConfig {
+    baseUrl: string;
+    userId: number;
+    tablesConfig: Record<string, string[]>;
+}
+export declare const PulseProvider: ({ config, children }: {
+    config: PulseConfig;
+    children: React.ReactNode;
+}) => React.JSX.Element;
+export declare const usePulseConfig: () => PulseConfig;
+export {};

package/dist/src/context.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePulseConfig = exports.PulseProvider = void 0;
+const react_1 = __importStar(require("react"));
+const database_1 = require("./database");
+const sync_engine_1 = require("./sync-engine");
+const PulseContext = (0, react_1.createContext)(null);
+const PulseProvider = ({ config, children }) => {
+    (0, react_1.useEffect)(() => {
+        (0, database_1.initializeDB)(config.tablesConfig);
+    }, []);
+    const tableNames = Object.keys(config.tablesConfig);
+    (0, sync_engine_1.usePulseSync)(config.userId, config.baseUrl, tableNames);
+    return (<PulseContext.Provider value={config}>
+      {children}
+    </PulseContext.Provider>);
+};
+exports.PulseProvider = PulseProvider;
+const usePulseConfig = () => {
+    const context = (0, react_1.useContext)(PulseContext);
+    if (!context) {
+        throw new Error("usePulseConfig must be used within a PulseProvider");
+    }
+    return context;
+};
+exports.usePulseConfig = usePulseConfig;

package/dist/src/database.d.ts

@@ -0,0 +1,3 @@
+import * as SQLite from 'expo-sqlite';
+export declare const db: SQLite.SQLiteDatabase;
+export declare const initializeDB: (schema: Record<string, string[]>) => void;

package/dist/src/database.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeDB = exports.db = void 0;
+const SQLite = __importStar(require("expo-sqlite"));
+exports.db = SQLite.openDatabaseSync('djangopulse_v2.db');
+const initializeDB = (schema) => {
+    Object.entries(schema).forEach(([tableName, columns]) => {
+        const baseFields = ['user_id'];
+        const allExpectedColumns = [...baseFields, ...columns];
+        exports.db.execSync(`
+      CREATE TABLE IF NOT EXISTS ${tableName} (
+        sync_id TEXT PRIMARY KEY NOT NULL,
+        version INTEGER DEFAULT 0,
+        is_local_only INTEGER DEFAULT 0,
+        is_deleted INTEGER DEFAULT 0,
+        sync_error TEXT DEFAULT NULL
+      );
+    `);
+        const tableInfo = exports.db.getAllSync(`PRAGMA table_info(${tableName})`);
+        const existingColumns = tableInfo.map((col) => col.name);
+        allExpectedColumns.forEach(colName => {
+            if (!existingColumns.includes(colName)) {
+                try {
+                    exports.db.execSync(`ALTER TABLE ${tableName} ADD COLUMN ${colName} TEXT;`);
+                }
+                catch (e) {
+                    console.error(`Error migrating ${colName}:`, e);
+                }
+            }
+        });
+    });
+};
+exports.initializeDB = initializeDB;

package/dist/src/operations.d.ts

@@ -0,0 +1,3 @@
+export declare const useSyncTable: (tableName: string) => import("@tanstack/react-query").UseQueryResult<any[], Error>;
+export declare const createItem: (tableName: string, data: any, queryClient: any) => void;
+export declare const updateItem: (tableName: string, sync_id: string, data: any, queryClient: any) => void;

package/dist/src/operations.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateItem = exports.createItem = exports.useSyncTable = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const Crypto = __importStar(require("expo-crypto"));
+const sync_engine_1 = require("./sync-engine");
+const database_1 = require("./database");
+let syncBuffer = {};
+let syncTimeout = null;
+const sendBuffer = (tableName, socket) => {
+    const payloads = syncBuffer[tableName];
+    if (!payloads || payloads.length === 0)
+        return;
+    socket.send(JSON.stringify({ type: 'SYNC_BATCH_UPLOAD', table: tableName, payloads }));
+    syncBuffer[tableName] = [];
+};
+const useSyncTable = (tableName) => {
+    return (0, react_query_1.useQuery)({
+        queryKey: [tableName],
+        queryFn: async () => database_1.db.getAllSync(`SELECT * FROM ${tableName} WHERE is_deleted = 0`),
+    });
+};
+exports.useSyncTable = useSyncTable;
+const createItem = (tableName, data, queryClient) => {
+    const sync_id = Crypto.randomUUID();
+    const keys = Object.keys(data);
+    const columns = ['sync_id', 'version', 'is_local_only', 'is_deleted', ...keys].join(', ');
+    const placeholders = new Array(keys.length + 4).fill('?').join(', ');
+    const values = [sync_id, 0, 1, 0, ...Object.values(data)];
+    database_1.db.runSync(`INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`, values);
+    queryClient.invalidateQueries({ queryKey: [tableName] });
+    const socket = (0, sync_engine_1.getConnectedSocket)();
+    if (socket) {
+        if (!syncBuffer[tableName])
+            syncBuffer[tableName] = [];
+        syncBuffer[tableName].push({ sync_id, ...data, is_local_only: 1, is_deleted: 0 });
+        if (syncTimeout)
+            clearTimeout(syncTimeout);
+        syncTimeout = setTimeout(() => sendBuffer(tableName, socket), 2000);
+    }
+};
+exports.createItem = createItem;
+const updateItem = (tableName, sync_id, data, queryClient) => {
+    const keys = Object.keys(data);
+    const setClause = keys.map(key => `${key} = ?`).join(', ');
+    const values = [...Object.values(data), sync_id];
+    database_1.db.runSync(`UPDATE ${tableName} SET ${setClause}, is_local_only = 1, sync_error = NULL WHERE sync_id = ?`, values);
+    queryClient.invalidateQueries({ queryKey: [tableName] });
+    const socket = (0, sync_engine_1.getConnectedSocket)();
+    if (socket) {
+        if (!syncBuffer[tableName])
+            syncBuffer[tableName] = [];
+        syncBuffer[tableName].push({ sync_id, ...data, is_local_only: 1 });
+        if (syncTimeout)
+            clearTimeout(syncTimeout);
+        syncTimeout = setTimeout(() => sendBuffer(tableName, socket), 2000);
+    }
+};
+exports.updateItem = updateItem;

package/dist/src/sync-engine.d.ts

@@ -0,0 +1,2 @@
+export declare const getConnectedSocket: () => WebSocket | null;
+export declare const usePulseSync: (userId: number, baseUrl: string, tables: string[]) => void;

package/dist/src/sync-engine.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePulseSync = exports.getConnectedSocket = void 0;
+const react_1 = require("react");
+const react_query_1 = require("@tanstack/react-query");
+const database_1 = require("./database");
+const CHUNK_SIZE = 50;
+let activeSocket = null;
+const getConnectedSocket = () => {
+    if (activeSocket && activeSocket.readyState === WebSocket.OPEN)
+        return activeSocket;
+    return null;
+};
+exports.getConnectedSocket = getConnectedSocket;
+const handleGenericIncomingData = async (tableName, payload, queryClient) => {
+    const { sync_id, version, data } = payload;
+    const { id, ...cleanData } = data;
+    try {
+        const tableInfo = database_1.db.getAllSync(`PRAGMA table_info(${tableName})`);
+        const existingColumns = tableInfo.map((col) => col.name);
+        const finalData = {};
+        Object.keys(cleanData).forEach(key => {
+            if (existingColumns.includes(key))
+                finalData[key] = cleanData[key];
+        });
+        if (cleanData.is_deleted === 1 || cleanData.is_deleted === true) {
+            database_1.db.runSync(`UPDATE ${tableName} SET is_deleted = 1, version = ? WHERE sync_id = ?`, [version, sync_id]);
+            queryClient.invalidateQueries({ queryKey: [tableName] });
+            return;
+        }
+        const columns = Object.keys(finalData);
+        if (columns.length === 0)
+            return;
+        const placeholders = columns.map(() => '?').join(', ');
+        const values = columns.map(col => finalData[col]);
+        database_1.db.runSync(`INSERT OR REPLACE INTO ${tableName} (sync_id, version, is_local_only, sync_error, ${columns.join(', ')}) 
+             VALUES (?, ?, 0, NULL, ${placeholders})`, [sync_id, version, ...values]);
+        queryClient.invalidateQueries({ queryKey: [tableName] });
+    }
+    catch (error) {
+        console.error("SQLite Sync Error:", error);
+    }
+};
+const usePulseSync = (userId, baseUrl, tables) => {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    (0, react_1.useEffect)(() => {
+        let ws;
+        let reconnectTimeout;
+        const connect = () => {
+            ws = new WebSocket(`ws://${baseUrl}/ws/sync/`);
+            activeSocket = ws;
+            ws.onopen = () => {
+                tables.forEach((tableName) => {
+                    const pending = database_1.db.getAllSync(`SELECT * FROM ${tableName} WHERE is_local_only = 1`);
+                    if (pending.length > 0) {
+                        for (let i = 0; i < pending.length; i += CHUNK_SIZE) {
+                            const chunk = pending.slice(i, i + CHUNK_SIZE);
+                            ws.send(JSON.stringify({ type: 'SYNC_BATCH_UPLOAD', table: tableName, payloads: chunk }));
+                        }
+                    }
+                    const res = database_1.db.getFirstSync(`SELECT MAX(version) as max_v FROM ${tableName}`);
+                    ws.send(JSON.stringify({ type: 'SYNC_REQUEST_DELTA', table: tableName, last_version: res?.max_v || 0 }));
+                });
+            };
+            ws.onmessage = async (e) => {
+                const message = JSON.parse(e.data);
+                if (message.type === 'BATCH_ACK') {
+                    const { table, synced_ids, errors } = message;
+                    if (synced_ids.length > 0) {
+                        const placeholders = synced_ids.map(() => '?').join(',');
+                        database_1.db.runSync(`UPDATE ${table} SET is_local_only = 0, sync_error = NULL WHERE sync_id IN (${placeholders})`, synced_ids);
+                    }
+                    if (errors?.length > 0) {
+                        errors.forEach((err) => {
+                            database_1.db.runSync(`UPDATE ${table} SET sync_error = ? WHERE sync_id = ?`, [err.msg, err.id]);
+                        });
+                    }
+                    queryClient.invalidateQueries({ queryKey: [table] });
+                }
+                if (message.type === 'SYNC_ACK_INDIVIDUAL') {
+                    const { table, sync_id, status, error } = message;
+                    if (status === 'SUCCESS') {
+                        database_1.db.runSync(`UPDATE ${table} SET is_local_only = 0, sync_error = NULL WHERE sync_id = ?`, [sync_id]);
+                    }
+                    else {
+                        database_1.db.runSync(`UPDATE ${table} SET sync_error = ? WHERE sync_id = ?`, [error, sync_id]);
+                    }
+                    queryClient.invalidateQueries({ queryKey: [table] });
+                }
+                if (message.type === 'SYNC_UPDATE') {
+                    handleGenericIncomingData(message.data.model.toLowerCase(), message.data, queryClient);
+                }
+            };
+            ws.onclose = () => { reconnectTimeout = setTimeout(connect, 3000); activeSocket = null; };
+            ws.onerror = () => ws.close();
+        };
+        connect();
+        return () => { clearTimeout(reconnectTimeout); ws?.close(); activeSocket = null; };
+    }, [baseUrl]);
+};
+exports.usePulseSync = usePulseSync;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "pulse-rn",
+  "version": "1.0.0",
+  "description": "Powerful offline-first sync engine for React Native. Compatible with Django Pulse and future Node.js pulse-core.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": ["react-native", "expo", "sync", "offline-first", "sqlite", "pulse"],
+  "author": "Jesus M.",
+  "license": "MIT",
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.0.0",
+    "expo-crypto": "*",
+    "expo-sqlite": "*",
+    "react": "*"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/react-native": "^0.72.8",
+    "typescript": "^5.0.0"
+  }
+}