@unvired/react-native-wrapper-sdk 0.0.13 → 0.0.15

package/dist/lib/sync/SyncService.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncService = void 0;
+const unvired_ts_core_sdk_1 = require("@unvired/unvired-ts-core-sdk");
+/**
+ * Service for handling Synchronization with Unvired Server
+ */
+class SyncService {
+    /**
+     * Submit data to UMP server in sync mode (Foreground)
+     * @param reqType Request Type (RQST/PULL/PUSH/QUERY/REQ)
+     * @param header Header Data Structure
+     * @param customData Custom data string (optional)
+     * @param paFunction Process Agent Function Name
+     * @param autoSave Whether to auto-save data in DB
+     */
+    async syncForeground(reqType, header, customData = "", paFunction, autoSave) {
+        return unvired_ts_core_sdk_1.SyncEngine.syncForeground(reqType, header, customData, paFunction, autoSave);
+    }
+    /**
+     * Submit data to UMP server in async mode (Background)
+     * @param reqType Request Type
+     * @param header Header Data Structure
+     * @param customData Custom data string (optional)
+     * @param paFunction Process Agent Function Name
+     * @param beName Business Entity Name
+     */
+    async syncBackground(reqType, header, customData = "", paFunction, beName) {
+        return unvired_ts_core_sdk_1.SyncEngine.syncBackground(reqType, header, customData, paFunction, beName);
+    }
+    /**
+     * Sends request for initial data download
+     * @param functions List of functions to execute
+     */
+    async sendInitialDataDownloadRequest(functions = []) {
+        return unvired_ts_core_sdk_1.SettingsHelper.requestInitialDataDownload(functions);
+    }
+    /**
+     * Gets synchronization state
+     * @param callback Callback to receive state updates
+     */
+    getSynchronizationState(callback) {
+        unvired_ts_core_sdk_1.NotificationListenerHelper.synchronizationStateListener = callback;
+        // Initial state
+        callback("idle");
+    }
+    /**
+     * Starts Inbox Handler
+     */
+    startInboxHandler() {
+        // Correct usage of SyncEngine as per SDK definition
+        unvired_ts_core_sdk_1.SyncEngine.startInboxHandler();
+    }
+    /**
+     * Starts Data Sender (Outbox Handler)
+     */
+    startDataSender() {
+        unvired_ts_core_sdk_1.OutboxService.getInstance().start();
+    }
+    /**
+     * Request for downloading messages from server
+     */
+    getMessages() {
+        unvired_ts_core_sdk_1.SyncEngine.getMessages();
+    }
+    /**
+     * Register for Data Sender notifications
+     * @param callback Callback function
+     */
+    registerDataSenderListener(callback) {
+        unvired_ts_core_sdk_1.NotificationListenerHelper.dataSenderListener = callback;
+    }
+    /**
+     * Unregister Data Sender notifications
+     */
+    unRegisterDataSenderListener() {
+        unvired_ts_core_sdk_1.NotificationListenerHelper.dataSenderListener = null;
+    }
+    /**
+     * Register for Sync Items count updates
+     * @param callback Callback function
+     */
+    registerSyncItemsCountListener(callback) {
+        unvired_ts_core_sdk_1.NotificationListenerHelper.syncItemsCountListener = callback;
+    }
+    /**
+     * Check if a BE is in the Outbox queue
+     * @param beLid BE Header LID
+     */
+    async isInOutBox(beLid) {
+        return unvired_ts_core_sdk_1.SettingsHelper.isInOutBoxQueue(beLid);
+    }
+    /**
+     * Check if a BE is in Sent Items
+     * @param beLid BE Header LID
+     */
+    async isInSentItem(beLid) {
+        return unvired_ts_core_sdk_1.SettingsHelper.isInSentItems(beLid);
+    }
+    /**
+     * Get count of items in Outbox
+     */
+    async outBoxItemCount() {
+        return unvired_ts_core_sdk_1.SettingsHelper.getOutboxCount();
+    }
+    /**
+     * Get count of items in Sent Items
+     */
+    async sentItemCount() {
+        return unvired_ts_core_sdk_1.SettingsHelper.getSentItemsCount();
+    }
+    /**
+     * Get count of items in Inbox
+     */
+    async inBoxItemCount() {
+        return unvired_ts_core_sdk_1.SettingsHelper.getInboxCount();
+    }
+    /**
+     * Delete an entry from Outbox
+     * @param beLid BE Header LID
+     */
+    async deleteOutBoxEntry(beLid) {
+        return unvired_ts_core_sdk_1.SyncEngine.removeOutObjectBasedOnLid(beLid);
+    }
+    /**
+     * Lock Data Sender for a specific BE
+     * @param beLid BE LID
+     */
+    async lockDataSender(beLid) {
+        return unvired_ts_core_sdk_1.SyncEngine.lockDataSender(beLid);
+    }
+    /**
+     * Unlock Data Sender
+     */
+    async unlockDataSender() {
+        return unvired_ts_core_sdk_1.SyncEngine.unlockDataSender();
+    }
+}
+exports.SyncService = SyncService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-wrapper-sdk",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Unvired SDK for React Native - Enterprise mobile platform SDK with authentication, sync, and offline database",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,8 +27,8 @@
     "react-native": ">=0.60.0"
   },
   "dependencies": {
-    "@unvired/react-native-unvired-sdk": "^0.0.11",
-    "@unvired/unvired-ts-core-sdk": "^0.0.12",
+    "@unvired/react-native-unvired-sdk": "^0.0.15",
+    "@unvired/unvired-ts-core-sdk": "^0.0.15",
     "axios": "^1.6.5",
     "crypto-js": "^4.2.0",
     "uuid": "^9.0.1"

package/src/UnviredWrapper.ts

@@ -1,5 +1,11 @@
-import AuthBuilder from './lib/AuthBuilder';
-import { AuthenticationService, PlatformManager } from '@unvired/unvired-ts-core-sdk';
+import { AuthenticationService } from '@unvired/unvired-ts-core-sdk';
+import { AuthService } from './lib/auth/AuthService';
+import { DatabaseService } from './lib/database/DatabaseService';
+import { FileService } from './lib/file/FileService';
+import { NotificationService } from './lib/notification/NotificationService';
+import { SyncService } from './lib/sync/SyncService';
+import { SettingsService } from './lib/settings/SettingsService';
+import { LoggerService } from './lib/logger/LoggerService';
 
 /**
  * React Native Wrapper for Unvired Core SDK
@@ -11,78 +17,54 @@ export class UnviredWrapper {
   }
 
   /**
-   * Returns a builder for login method
-   * Can be awaited directly: await sdk.login().setAppName("my-app")
+   * Access Authentication operations
    */
-  login(): AuthBuilder {
-    return new AuthBuilder('login');
+  auth(): AuthService {
+    return new AuthService();
   }
 
   /**
-   * Returns a builder for authenticateAndActivate method
-   * Can be awaited directly: await sdk.authenticateAndActivate().setUsername("demo")
+   * Access Database operations
    */
-  authenticateAndActivate(): AuthBuilder {
-    return new AuthBuilder('authenticateAndActivate');
+  database(): DatabaseService {
+    return new DatabaseService();
   }
 
   /**
-   * Returns a builder for authenticateLocal method
-   * Can be awaited directly: await sdk.authenticateLocal().setUsername("demo")
+   * Access File/Attachment operations
    */
-  authenticateLocal(): AuthBuilder {
-    return new AuthBuilder('authenticateLocal');
+  file(): FileService {
+    return new FileService();
   }
 
   /**
-   * Logout method - Logs out the current user
+   * Access Notification operations
    */
-  async logout(): Promise<any> {
-    const authService = (AuthenticationService as any).instance;
-    return authService.logout();
+  notification(): NotificationService {
+    return new NotificationService();
   }
 
   /**
-   * Clear all data
+   * Access Synchronization operations
    */
-  async clearData(): Promise<any> {
-    const authService = (AuthenticationService as any).instance;
-    return authService.clearData();
+  sync(): SyncService {
+    return new SyncService();
   }
 
-  // Logging methods - delegating to PlatformManager's adapter
-  static logInfo(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logInfo(className, methodName, message);
-  }
-
-  static logError(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logError(className, methodName, message);
-  }
-
-  static logDebug(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logDebug(className, methodName, message);
-  }
-
-
-  static setLogLevel(level: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().setLogLevel(level);
-  }
-
-  static async getLogFileURL(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileURL();
-  }
-
-  static async getLogFileContent(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileContent();
+  /**
+   * Access Settings and Utility operations
+   */
+  settings(): SettingsService {
+    return new SettingsService();
   }
 
-  static async getBackupLogFileContent(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getBackupLogFileContent();
+  /**
+   * Access Logger operations
+   */
+  logger(): LoggerService {
+    return new LoggerService();
   }
 
-  static async clearLogFile(): Promise<void> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().clearLogFile();
-  }
 }
 
-export default UnviredWrapper;
+export default UnviredWrapper;

package/src/lib/auth/AuthService.ts

@@ -0,0 +1,45 @@
+import AuthBuilder from './AuthBuilder';
+import { AuthenticationService } from '@unvired/unvired-ts-core-sdk';
+
+/**
+ * Service for handling Authentication operations
+ */
+export class AuthService {
+
+    /**
+     * Returns a builder for login method
+     */
+    login(): AuthBuilder {
+        return new AuthBuilder('login');
+    }
+
+    /**
+     * Returns a builder for authenticateAndActivate method
+     */
+    authenticateAndActivate(): AuthBuilder {
+        return new AuthBuilder('authenticateAndActivate');
+    }
+
+    /**
+     * Returns a builder for authenticateLocal method
+     */
+    authenticateLocal(): AuthBuilder {
+        return new AuthBuilder('authenticateLocal');
+    }
+
+    /**
+     * Logout method - Logs out the current user
+     */
+    async logout(): Promise<any> {
+        const authService = (AuthenticationService as any).instance;
+        return authService.logout();
+    }
+
+    /**
+     * Clear all data
+     */
+    async clearData(): Promise<any> {
+        const authService = (AuthenticationService as any).instance;
+        return authService.clearData();
+    }
+}

package/src/lib/database/DatabaseService.ts

@@ -0,0 +1,148 @@
+import { AppDatabaseManager, DatabaseManager, SettingsHelper, FrameworkHelper, PlatformManager, DatabaseType } from '@unvired/unvired-ts-core-sdk';
+
+export class DatabaseService {
+    private db: AppDatabaseManager;
+
+    constructor() {
+        this.db = AppDatabaseManager.getInstance();
+    }
+
+    /**
+     * Selects data from the database
+     * @param tableName Name of the table
+     * @param whereClause Optional SQL where clause
+     */
+    async select(tableName: string, whereClause?: string): Promise<any> {
+        return this.db.select(tableName, whereClause);
+    }
+
+    /**
+     * Inserts data into the database
+     * @param tableName Name of the table
+     * @param structureObject Data object to insert
+     * @param isHeader Whether the data is a header or an item
+     */
+    async insert(tableName: string, structureObject: any, isHeader: boolean): Promise<any> {
+        return this.db.insert(tableName, structureObject, isHeader);
+    }
+
+    /**
+     * Inserts or updates data in the database
+     * @param tableName Name of the table
+     * @param structureObject Data object to insert or update
+     * @param isHeader Whether the data is a header or an item
+     */
+    async insertOrUpdate(tableName: string, structureObject: any, isHeader: boolean): Promise<any> {
+        return this.db.insertOrUpdate(tableName, structureObject, isHeader);
+    }
+
+    /**
+     * Deletes data from the database
+     * @param tableName Name of the table
+     * @param whereClause Optional SQL where clause
+     */
+    async delete(tableName: string, whereClause?: string): Promise<any> {
+        return this.db.delete(tableName, whereClause);
+    }
+
+    /**
+     * Updates data in the database
+     * @param tableName Name of the table
+     * @param updatedObject Object with updated values
+     * @param whereClause SQL where clause identifying rows to update
+     */
+    async update(tableName: string, updatedObject: any, whereClause: any): Promise<any> {
+        return this.db.update(tableName, updatedObject, whereClause);
+    }
+
+    /**
+     * Executes a raw SQL statement
+     * @param query SQL query
+     */
+    async executeStatement(query: string): Promise<any> {
+        return this.db.executeStatement(query);
+    }
+
+    /**
+     * Begins a transaction
+     */
+    async beginTransaction(): Promise<void> {
+        return this.db.beginTransaction();
+    }
+
+    /**
+     * Ends (commits) a transaction
+     */
+    async endTransaction(): Promise<void> {
+        return this.db.endTransaction();
+    }
+
+    /**
+     * Rolls back a transaction
+     */
+    async rollbackTransaction(): Promise<void> {
+        return this.db.rollbackTransaction();
+    }
+
+    /**
+     * Creates a save point
+     * @param savePoint Name of the save point
+     */
+    async createSavePoint(savePoint: string): Promise<void> {
+        return this.db.createSavePoint(savePoint);
+    }
+
+    /**
+     * Releases a save point
+     * @param savePoint Name of the save point
+     */
+    async releaseSavePoint(savePoint: string): Promise<void> {
+        return this.db.releaseSavePoint(savePoint);
+    }
+
+    /**
+     * Rolls back to a save point
+     * @param savePoint Name of the save point
+     */
+    async rollbackToSavePoint(savePoint: string): Promise<void> {
+        return this.db.rollbackToSavePoint(savePoint);
+    }
+
+    /**
+     * Saves Web Data (Browser only)
+     */
+    async saveWebData(): Promise<void> {
+        if (FrameworkHelper.getPlatform() === 'browser') {
+            return DatabaseManager.getInstance().saveWebData();
+        }
+    }
+
+    /**
+     * Exports Web Data
+     */
+    async exportWebData(): Promise<void> {
+        return DatabaseManager.getInstance().exportWebData();
+    }
+
+    /**
+     * Prepares database for export
+     */
+    async prepareDatabaseForExport(): Promise<void> {
+        return SettingsHelper.prepareDatabaseForExport();
+    }
+
+    /**
+     * Gets the database directory path
+     */
+    async getDatabasePath(): Promise<string> {
+        return new Promise((resolve, reject) => {
+            try {
+                const adapter = PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter();
+                // @ts-ignore - The type might be mismatch in d.ts but logical flow is correct
+                adapter.getDBFilePath({ dbType: DatabaseType.AppDb }, (path) => resolve(path));
+            } catch (e) {
+                reject(e);
+            }
+        });
+    }
+}

package/src/lib/file/FileService.ts

@@ -0,0 +1,149 @@
+import { AttachmentHelper, AttachmentQHelper, ServiceConstants, AppDatabaseManager } from '@unvired/unvired-ts-core-sdk';
+
+export class FileService {
+
+    // AttachmentService is not exported from the SDK, so we cannot expose start/stop here directly.
+    // If background sync control is needed, it might be via SyncEngine or other means.
+
+    /**
+     * Gets the directory used for storing attachments
+     */
+    async getAttachmentDirectory(): Promise<string> {
+        let dir = await AttachmentHelper.getAttachmentDirectory();
+        if (!dir.endsWith("/")) {
+            dir += "/";
+        }
+        return dir;
+    }
+
+    /**
+     * Adds an attachment
+     * @param attachmentName Name of the attachment
+     * @param attachmentData Data as ArrayBuffer
+     */
+    async addAttachment(attachmentName: string, attachmentData: ArrayBuffer): Promise<string> {
+        return AttachmentHelper.addAttachment(attachmentName, attachmentData);
+    }
+
+    /**
+     * Gets an attachment's data
+     * @param attachmentName Name of the attachment
+     */
+    async getAttachment(attachmentName: string): Promise<ArrayBuffer> {
+        return AttachmentHelper.getAttachment(attachmentName);
+    }
+
+    /**
+     * Deletes an attachment
+     * @param attachmentName Name of the attachment
+     */
+    async deleteAttachment(attachmentName: string): Promise<void> {
+        return AttachmentHelper.deleteAttachment(attachmentName);
+    }
+
+    /**
+     * Gets the file system path of an attachment
+     * @param attachmentName Name of the attachment
+     */
+    async getAttachmentPath(attachmentName: string): Promise<string> {
+        return AttachmentHelper.getAttachmentPath(attachmentName);
+    }
+
+    /**
+     * Reads a file from the filesystem as ArrayBuffer
+     * @param filePath Absolute path to the file
+     */
+    async readFileAsArrayBuffer(filePath: string): Promise<ArrayBuffer> {
+        return AttachmentHelper.readFileAsArrayBuffer(filePath);
+    }
+
+    /**
+     * Checks if a file exists
+     * @param filePath Absolute path to the file
+     */
+    async fileExists(filePath: string): Promise<boolean> {
+        return AttachmentHelper.fileExists(filePath);
+    }
+
+    /**
+     * Reads an external file
+     * @param filePath Absolute path to the file
+     */
+    async readExternalFile(filePath: string): Promise<ArrayBuffer> {
+        return AttachmentHelper.readExternalFile(filePath);
+    }
+
+    /**
+     * Writes data to an external file
+     * @param filePath Parent directory path
+     * @param fileName File name
+     * @param data Data to write
+     */
+    async writeExternalFile(filePath: string, fileName: string, data: ArrayBuffer): Promise<void> {
+        return AttachmentHelper.writeExternalFile(filePath, fileName, data);
+    }
+
+    /**
+     * Deletes an external file
+     * @param filePath Absolute path to the file
+     */
+    async deleteExternalFile(filePath: string): Promise<void> {
+        return AttachmentHelper.deleteExternalFile(filePath);
+    }
+
+    /**
+     * Create Attachment Item - Copies file to attachment folder and inserts record in DB
+     * @param tableName Table name for attachment
+     * @param structureObject Attachment item object
+     */
+    async createAttachmentItem(tableName: string, structureObject: any): Promise<any> {
+        if (!tableName) throw new Error("Table name is null or empty");
+        if (!structureObject) throw new Error("Structure object is null or empty");
+
+        const fileName = structureObject[ServiceConstants.AttachmentItemFieldFileName];
+        const localPath = structureObject[ServiceConstants.AttachmentItemFieldLocalPath];
+
+        if (!fileName) throw new Error("File Name is null or empty");
+        if (!localPath) throw new Error("Local Path is null or empty");
+
+        const arrayBuffer = await AttachmentHelper.readFileAsArrayBuffer(localPath);
+        if (!arrayBuffer) {
+            throw new Error(`Attachment file could not be read at the location: ${localPath}`);
+        }
+
+        let attachmentName = structureObject[ServiceConstants.AttachmentItemFieldUid];
+        if (fileName) {
+            attachmentName = fileName;
+        }
+
+        const attachmentPath = await AttachmentHelper.addAttachment(attachmentName, arrayBuffer);
+        structureObject[ServiceConstants.AttachmentItemFieldLocalPath] = attachmentPath;
+        structureObject[ServiceConstants.AttachmentItemFieldAttachmentStatus] = ServiceConstants.AttachmentStatusSavedForUpload;
+
+        await AppDatabaseManager.getInstance().insert(tableName, structureObject, false);
+        return structureObject;
+    }
+
+    /**
+     * Queues an attachment for download
+     * @param tableName Table name
+     * @param structureObject Structure object
+     */
+    async downloadAttachment(tableName: string, structureObject: any): Promise<any> {
+        await AttachmentQHelper.queueForDownload(tableName, structureObject, ServiceConstants.FwAttachmentForceDownloadPriority);
+        // Note: AttachmentService start is not exposed in SDK exports currently.
+        // If needed, SyncEngine might handle it or it should be auto-handled.
+        return structureObject;
+    }
+
+    /**
+    * Downloads an attachment synchronously (waits for completion)
+    * @param structureObject Structure object with UID and FileName
+    */
+    async downloadAttachmentSync(structureObject: any): Promise<any> {
+        const uid = structureObject[ServiceConstants.AttachmentItemFieldUid];
+        const fileName = structureObject[ServiceConstants.AttachmentItemFieldFileName];
+        const attachmentPath = await AttachmentQHelper.downloadAttachmentAndGetPath(uid, fileName);
+        return attachmentPath;
+    }
+}

package/src/lib/logger/LoggerService.ts

@@ -0,0 +1,70 @@
+import { PlatformManager } from '@unvired/unvired-ts-core-sdk';
+
+export class LoggerService {
+
+    /**
+     * Log Information
+     * @param className Class Name
+     * @param methodName Method Name
+     * @param message Message
+     */
+    info(className: string, methodName: string, message: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logInfo(className, methodName, message);
+    }
+
+    /**
+     * Log Error
+     * @param className Class Name
+     * @param methodName Method Name
+     * @param message Message
+     */
+    error(className: string, methodName: string, message: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logError(className, methodName, message);
+    }
+
+    /**
+     * Log Debug
+     * @param className Class Name
+     * @param methodName Method Name
+     * @param message Message
+     */
+    debug(className: string, methodName: string, message: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logDebug(className, methodName, message);
+    }
+
+    /**
+     * Set Log Level
+     * @param level Log Level
+     */
+    setLogLevel(level: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().setLogLevel(level);
+    }
+
+    /**
+     * Get Log File URL
+     */
+    async getLogFileURL(): Promise<string> {
+        return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileURL();
+    }
+
+    /**
+     * Get Log File Content
+     */
+    async getLogFileContent(): Promise<string> {
+        return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileContent();
+    }
+
+    /**
+     * Get Backup Log File Content
+     */
+    async getBackupLogFileContent(): Promise<string> {
+        return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getBackupLogFileContent();
+    }
+
+    /**
+     * Clear Log File
+     */
+    async clearLogFile(): Promise<void> {
+        return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().clearLogFile();
+    }
+}