@unvired/react-native-wrapper-sdk 0.0.7 → 0.0.9

package/dist/lib/AuthBuilder.js

@@ -1,30 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoginType = exports.LoginParameters = void 0;
-const unvired_ts_core_sdk_1 = require("@unvired/unvired-ts-core-sdk");
-/**
- * LoginParameters class - Local definition to avoid module resolution issues
- */
-class LoginParameters {
-}
-exports.LoginParameters = LoginParameters;
-/**
- * LoginType enum for different authentication types
- */
-var LoginType;
-(function (LoginType) {
-    LoginType["UNVIRED"] = "UNVIRED";
-    LoginType["LDAP"] = "LDAP";
-    LoginType["SSO"] = "SSO";
-})(LoginType || (exports.LoginType = LoginType = {}));
-/**
- * AuthBuilder - Fluent API for building authentication requests
- * Can be awaited directly without calling .execute()
- */
+const UnviredSDK_1 = require("./../core/UnviredSDK");
 class AuthBuilder {
-    constructor(method) {
+    constructor(sdk, method) {
+        this.sdk = sdk;
         this.method = method;
-        this.loginParameters = new LoginParameters();
+        this.loginParameters = new UnviredSDK_1.LoginParameters();
     }
     setAppName(appName) {
         this.loginParameters.appName = appName;
@@ -115,15 +96,13 @@ class AuthBuilder {
         return this;
     }
     execute() {
-        // Get the singleton instance and call the appropriate authentication method
-        const authService = unvired_ts_core_sdk_1.AuthenticationService.instance;
         switch (this.method) {
             case 'login':
-                return authService.login(this.loginParameters);
+                return this.sdk.login(this.loginParameters);
             case 'authenticateAndActivate':
-                return authService.authenticateAndActivate(this.loginParameters);
+                return this.sdk.authenticateAndActivate(this.loginParameters);
             case 'authenticateLocal':
-                return authService.authenticateLocal(this.loginParameters);
+                return this.sdk.authenticateLocal(this.loginParameters);
             default:
                 return Promise.reject(new Error(`Unknown method: ${this.method}`));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-wrapper-sdk",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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",

package/src/UnviredWrapper.ts

@@ -1,13 +1,19 @@
-import AuthBuilder from './lib/AuthBuilder';
-import { AuthenticationService, PlatformManager } from '@unvired/unvired-ts-core-sdk';
+import UnviredSDK from './core/UnviredSDK';
+import AuthBuilder from './lib/AuthBuilder';
+
+import PlatformInterface from '@unvired/unvired-ts-core-sdk/platform/PlatformManager';
+
 
-/**
- * React Native Wrapper for Unvired Core SDK
- * Provides a clean, fluent API for React Native applications
- */
 export class UnviredWrapper {
+  private unviredSDK: UnviredSDK;
+
   constructor() {
-    // AuthenticationService is a singleton, accessed via static instance getter
+    this.unviredSDK = new UnviredSDK();
+  }
+
+  private static get logger() {
+    console.log('PlatformInterface from core SDK', PlatformInterface);
+    return UnviredSDK.getPlatformManager().getPlatformAdapter();
   }
 
   /**
@@ -15,7 +21,7 @@ export class UnviredWrapper {
    * Can be awaited directly: await sdk.login().setAppName("my-app")
    */
   login(): AuthBuilder {
-    return new AuthBuilder('login');
+    return new AuthBuilder(this.unviredSDK, 'login');
   }
 
   /**
@@ -23,7 +29,7 @@ export class UnviredWrapper {
    * Can be awaited directly: await sdk.authenticateAndActivate().setUsername("demo")
    */
   authenticateAndActivate(): AuthBuilder {
-    return new AuthBuilder('authenticateAndActivate');
+    return new AuthBuilder(this.unviredSDK, 'authenticateAndActivate');
   }
 
   /**
@@ -31,57 +37,52 @@ export class UnviredWrapper {
    * Can be awaited directly: await sdk.authenticateLocal().setUsername("demo")
    */
   authenticateLocal(): AuthBuilder {
-    return new AuthBuilder('authenticateLocal');
+    return new AuthBuilder(this.unviredSDK, '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();
-  }
-
-  // Logging methods - delegating to PlatformManager's adapter
   static logInfo(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logInfo(className, methodName, message);
+
+    console.log('PlatformInterface from core SDK', PlatformInterface);
+    this.logger.logInfo(className, methodName, message);
   }
 
   static logError(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logError(className, methodName, message);
+    this.logger.logError(className, methodName, message);
   }
 
   static logDebug(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logDebug(className, methodName, message);
+    this.logger.logDebug(className, methodName, message);
   }
 
+  static logWarning(className: string, methodName: string, message: string) {
+    this.logger.logWarning(className, methodName, message);
+  }
 
   static setLogLevel(level: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().setLogLevel(level);
+    this.logger.setLogLevel(level);
   }
 
   static async getLogFileURL(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileURL();
+    return this.logger.getLogFileURL();
   }
 
   static async getLogFileContent(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileContent();
+    return this.logger.getLogFileContent();
   }
 
   static async getBackupLogFileContent(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getBackupLogFileContent();
+    return this.logger.getBackupLogFileContent();
   }
 
   static async clearLogFile(): Promise<void> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().clearLogFile();
+    return this.logger.clearLogFile();
+  }
+
+  /**
+   * Logout method - Calls CoreWebSDK
+   */
+  async logout(): Promise<boolean> {
+    return this.unviredSDK.logout();
   }
 }
 

package/src/core/UnviredSDK.ts

@@ -0,0 +1,126 @@
+import { PlatformManager } from './platform/PlatformManager';
+
+export declare enum LoginType {
+  unvired = 'UNVIRED_ID',
+}
+export declare class LoginParameters {
+  /**
+   * Set the application name as configured in UMP.
+   */
+  appName: string;
+  /**
+   * Company name as configured in UMP.
+   */
+  company: string;
+  /**
+   * Username of the user trying to login.
+   */
+  username: string;
+  /**
+   * Password of the user trying to login.
+   */
+  password: string;
+  /**
+   * UMP URL. For example: https://umpdev.unvired.io/UMP
+   */
+  url: string;
+  /**
+   * Domain name. Required only if the login type is ADS or SAP.
+   */
+  domain: string;
+  /**
+   * Set this value to one of the allowed login types for your app as configured in UMP.
+   */
+  loginType: LoginType;
+  /**
+   * FrontEndUserId: This id uniquely identifies the user across devices of same type. If the Unvired user has multiple front end ids for a device type, you need to set this value.
+   * If the Unvired user has only one front end id, leave this field blank.
+   */
+  feUserId: string;
+  /**
+   * Required only if the loginType is 'sap'. This sets the SAP Port Name.
+   */
+  port: string;
+  /**
+   * Required for Browser Platform.
+   * For iOS Platform include the metadata.xml file as part of App Bundle
+   * For Android Platform include the metadata.xml file in src > res > raw
+   */
+  metadataPath: string;
+  /**
+   * This is required for Android only. Setting this value would save the attachments as Base64 string for easy access.
+   */
+  isRequiredAttachmentBase64: boolean;
+  /**
+   * Set an interval in seconds at which the framework has to make an attempt to send data from outbox.
+   * If the data-sender fails for reason, then the framework does not restart even if there are outbox items.
+   * In those cases, you will have to set this value, so that the framework always makes an attempt to send from outbox.
+   * Example:
+   * loginParameters.autoSendTime = '5' // Make an attempt to send data every 5 seconds.
+   */
+  autoSendTime: string;
+  /**
+   * Set the number of seconds at which GetMessage should automatically run. When this value is set, GetMessage would run in a interval as long as there are entries in Sent Items.
+   * You may need to set this value if your app doesn't support Push Notifications.
+   * By default, the framework does not do GetMessage automatically.
+   * Example:
+   * loginParameters.autoSyncTime = '5' // Make an attempt to receive data (GetMessage) every 5 seconds.
+   */
+  autoSyncTime: string;
+  /**
+   * Specify the metadata as a JSON string. This will override metadata.xml set at platform level.
+   */
+  metadataJSON: string;
+  /**
+   * Specify the demo data xml string for demo mode.
+   */
+  demoData: string;
+  /**
+   * Set 'true' if the application supports demo mode otherwise set 'false'.
+   */
+  demoModeRequired: boolean;
+  persistWebDb: boolean;
+  jwtOptions: object;
+  /**
+   * Language code to be sent to UMP. Specify a two-letter language code.
+   * The default value of this is 'en'.
+   */
+  loginLanguage: string;
+  /**
+   * Applicable for browser only. Set this flag to indicate that saved data should be reloaded upon launch.
+   */
+  cacheWebData: boolean;
+  /**
+   * Set this value if you the login process requires client credentials to be set.
+   * You can pass the client credentials with the method: |unviredSDK.setClientCredentials(credentials)|
+   * The passed credentials will be used based on this flag.
+   */
+  requireClientCredentials: boolean;
+}
+
+class UnviredSDK {
+  static getPlatformManager(): PlatformManager {
+    return PlatformManager.getInstance();
+  }
+
+  async login(_loginParameters: LoginParameters): Promise<string> {
+    // Returns one of: auth_activation_required, app_requires_login, login_success, app_requires_current_account, login_demo
+    return 'auth_activation_required';
+  }
+
+  async logout(): Promise<boolean> {
+    return true;
+  }
+
+  async authenticateLocal(_loginParameters: LoginParameters): Promise<string> {
+    // Returns one of: login_success, login_error
+    return 'login_success';
+  }
+
+  async authenticateAndActivate(_loginParameters: LoginParameters): Promise<string> {
+    // Returns one of: auth_activation_success, auth_activation_error
+    return 'auth_activation_success';
+  }
+}
+
+export default UnviredSDK;

package/src/core/platform/CordovaPlatformAdapter.ts

@@ -0,0 +1,69 @@
+import { PlatformInterface } from './PlatformInterface';
+
+declare var Logger: any;
+
+export class CordovaPlatformAdapter implements PlatformInterface {
+
+    // Logger
+    logInfo(className: string, methodName: string, message: string): void {
+        Logger.logInfo(className, methodName, message);
+    }
+
+    logError(className: string, methodName: string, message: string): void {
+        Logger.logError(className, methodName, message);
+    }
+
+    logDebug(className: string, methodName: string, message: string): void {
+        Logger.logDebug(className, methodName, message);
+    }
+
+    logWarning(className: string, methodName: string, message: string): void {
+        Logger.logWarning(className, methodName, message);
+    }
+
+    setLogLevel(level: string): void {
+        Logger.setLogLevel(level);
+    }
+
+    async getLogFileURL(): Promise<string> {
+        return new Promise((resolve, reject) => {
+            try {
+                const url = Logger.getLogFileURL();
+                resolve(url);
+            } catch (e) {
+                reject(e);
+            }
+        });
+    }
+
+    async getLogFileContent(): Promise<string> {
+        return new Promise((resolve, reject) => {
+            Logger.getLogFileContent((content: string) => {
+                resolve(content);
+            }, (error: any) => {
+                reject(error);
+            });
+        });
+    }
+
+    async getBackupLogFileContent(): Promise<string> {
+        return new Promise((resolve, reject) => {
+            Logger.getBackupLogFileContent((content: string) => {
+                resolve(content);
+            }, (error: any) => {
+                reject(error);
+            });
+        });
+    }
+
+    async clearLogFile(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            try {
+                Logger.clearLogFile();
+                resolve();
+            } catch (e) {
+                reject(e);
+            }
+        });
+    }
+}

package/src/core/platform/PlatformInterface.ts

@@ -0,0 +1,12 @@
+export interface PlatformInterface {
+    // Logger
+    logInfo(className: string, methodName: string, message: string): void;
+    logError(className: string, methodName: string, message: string): void;
+    logDebug(className: string, methodName: string, message: string): void;
+    logWarning(className: string, methodName: string, message: string): void;
+    setLogLevel(level: string): void;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<string>;
+    clearLogFile(): Promise<void>;
+}

package/src/core/platform/PlatformManager.ts

@@ -0,0 +1,35 @@
+import { PlatformInterface } from './PlatformInterface';
+import { ReactNativePlatformAdapter } from './ReactNativePlatformAdapter';
+
+export class PlatformManager {
+    private static instance: PlatformManager;
+    private platformAdapter: PlatformInterface;
+
+    private constructor() {
+        // Default to Cordova for now, or detect environment
+        // In a real scenario, we might inject this or detect based on environment variables
+        this.platformAdapter = new ReactNativePlatformAdapter();
+    }
+
+    public static getInstance(): PlatformManager {
+        if (!PlatformManager.instance) {
+            PlatformManager.instance = new PlatformManager();
+        }
+        return PlatformManager.instance;
+    }
+
+    public getPlatformAdapter(): PlatformInterface {
+        return this.platformAdapter;
+    }
+
+    public setPlatformAdapter(adapter: PlatformInterface) {
+        this.platformAdapter = adapter;
+    }
+}
+
+// Usage:
+// import { PlatformManager } from './platform/PlatformManager';
+// import { ReactNativePlatformAdapter } from './platform/ReactNativePlatformAdapter';
+
+// // Initialize with React Native adapter
+// PlatformManager.getInstance().setPlatformAdapter(new ReactNativePlatformAdapter());

package/src/core/platform/ReactNativePlatformAdapter.ts

@@ -0,0 +1,57 @@
+import { PlatformInterface } from './PlatformInterface';
+import { logger, LogLevel } from '@unvired/react-native-unvired-sdk';
+
+export class ReactNativePlatformAdapter implements PlatformInterface {
+  // Logger
+  logInfo(className: string, methodName: string, message: string): void {
+    logger.logInfo(className, methodName, message);
+
+    console.log(`[INFO] ${className}.${methodName}: ${message}`);
+  }
+
+  logError(className: string, methodName: string, message: string): void {
+    logger.logError(className, methodName, message);
+
+    console.error(`[ERROR] ${className}.${methodName}: ${message}`);
+  }
+
+  logDebug(className: string, methodName: string, message: string): void {
+    logger.logDebug(className, methodName, message);
+
+    console.debug(`[DEBUG] ${className}.${methodName}: ${message}`);
+  }
+
+  logWarning(className: string, methodName: string, message: string): void {
+    // TODO: Update to logger.logWarning once available in react-native-wrapper-sdk
+    // Using logInfo as fallback for now
+    if (typeof (logger as any).logWarning === 'function') {
+      (logger as any).logWarning(className, methodName, message);
+    } else {
+      logger.logInfo(className, methodName, `[WARNING] ${message}`);
+    }
+
+    console.warn(`[WARNING] ${className}.${methodName}: ${message}`);
+  }
+
+  setLogLevel(level: string): void {
+    logger.setLogLevel(level.toUpperCase() as LogLevel);
+
+    console.log(`[setLogLevel] ${level}`);
+  }
+
+  async getLogFileURL(): Promise<string> {
+    return await logger.getLogFileURL();
+  }
+
+  async getLogFileContent(): Promise<string> {
+    return await logger.getLogFileContent();
+  }
+
+  async getBackupLogFileContent(): Promise<string> {
+    return await logger.getBackupLogFileContent();
+  }
+
+  async clearLogFile(): Promise<void> {
+    await logger.clearLogFile();
+  }
+}

package/src/index.ts

@@ -1,5 +1,10 @@
 // Export main SDK
 import UnviredWrapper from './UnviredWrapper';
+
+export { LoginParameters, LoginType } from './core/UnviredSDK';
+
 // Export the default SDK instance
 export default UnviredWrapper;
 
+import UMP from '@unvired/unvired-ts-core-sdk';
+export { UMP };

package/src/lib/AuthBuilder.ts

@@ -1,50 +1,15 @@
-import { AuthenticationService } from '@unvired/unvired-ts-core-sdk';
-
-/**
- * LoginParameters class - Local definition to avoid module resolution issues
- */
-export class LoginParameters {
-    appName?: string;
-    company?: string;
-    username?: string;
-    password?: string;
-    url?: string;
-    domain?: string;
-    loginType?: string;
-    feUserId?: string;
-    port?: string;
-    metadataPath?: string;
-    isRequiredAttachmentBase64?: boolean;
-    autoSendTime?: string;
-    autoSyncTime?: string;
-    metadataJSON?: string;
-    demoData?: string;
-    demoModeRequired?: boolean;
-    persistWebDb?: boolean;
-    jwtOptions?: object;
-    loginLanguage?: string;
-    cacheWebData?: boolean;
-    requireClientCredentials?: boolean;
-}
-
-/**
- * LoginType enum for different authentication types
- */
-export enum LoginType {
-    UNVIRED = 'UNVIRED',
-    LDAP = 'LDAP',
-    SSO = 'SSO'
-}
+import UnviredSDK, { LoginParameters, LoginType } from './../core/UnviredSDK';
 
-/**
- * AuthBuilder - Fluent API for building authentication requests
- * Can be awaited directly without calling .execute()
- */
-export default class AuthBuilder implements PromiseLike<any> {
+export default class AuthBuilder implements PromiseLike<string> {
+    private sdk: UnviredSDK;
     private method: 'login' | 'authenticateAndActivate' | 'authenticateLocal';
     private loginParameters: LoginParameters;
 
-    constructor(method: 'login' | 'authenticateAndActivate' | 'authenticateLocal') {
+    constructor(
+        sdk: UnviredSDK,
+        method: 'login' | 'authenticateAndActivate' | 'authenticateLocal'
+    ) {
+        this.sdk = sdk;
         this.method = method;
         this.loginParameters = new LoginParameters();
     }
@@ -80,7 +45,7 @@ export default class AuthBuilder implements PromiseLike<any> {
     }
 
     setLoginType(loginType: LoginType): AuthBuilder {
-        this.loginParameters.loginType = loginType as any;
+        this.loginParameters.loginType = loginType;
         return this;
     }
 
@@ -95,88 +60,85 @@ export default class AuthBuilder implements PromiseLike<any> {
     }
 
     setMetadataPath(metadataPath: string): AuthBuilder {
-        (this.loginParameters as any).metadataPath = metadataPath;
+        this.loginParameters.metadataPath = metadataPath;
         return this;
     }
 
     setIsRequiredAttachmentBase64(isRequiredAttachmentBase64: boolean): AuthBuilder {
-        (this.loginParameters as any).isRequiredAttachmentBase64 = isRequiredAttachmentBase64;
+        this.loginParameters.isRequiredAttachmentBase64 = isRequiredAttachmentBase64;
         return this;
     }
 
     setAutoSendTime(autoSendTime: string): AuthBuilder {
-        (this.loginParameters as any).autoSendTime = autoSendTime;
+        this.loginParameters.autoSendTime = autoSendTime;
         return this;
     }
 
     setAutoSyncTime(autoSyncTime: string): AuthBuilder {
-        (this.loginParameters as any).autoSyncTime = autoSyncTime;
+        this.loginParameters.autoSyncTime = autoSyncTime;
         return this;
     }
 
     setMetadataJSON(metadataJSON: string): AuthBuilder {
-        (this.loginParameters as any).metadataJSON = metadataJSON;
+        this.loginParameters.metadataJSON = metadataJSON;
         return this;
     }
 
     setDemoData(demoData: string): AuthBuilder {
-        (this.loginParameters as any).demoData = demoData;
+        this.loginParameters.demoData = demoData;
         return this;
     }
 
     setDemoModeRequired(demoModeRequired: boolean): AuthBuilder {
-        (this.loginParameters as any).demoModeRequired = demoModeRequired;
+        this.loginParameters.demoModeRequired = demoModeRequired;
         return this;
     }
 
     setPersistWebDb(persistWebDb: boolean): AuthBuilder {
-        (this.loginParameters as any).persistWebDb = persistWebDb;
+        this.loginParameters.persistWebDb = persistWebDb;
         return this;
     }
 
     setJwtOptions(jwtOptions: object): AuthBuilder {
-        (this.loginParameters as any).jwtOptions = jwtOptions;
+        this.loginParameters.jwtOptions = jwtOptions;
         return this;
     }
 
     setLoginLanguage(loginLanguage: string): AuthBuilder {
-        (this.loginParameters as any).loginLanguage = loginLanguage;
+        this.loginParameters.loginLanguage = loginLanguage;
         return this;
     }
 
     setCacheWebData(cacheWebData: boolean): AuthBuilder {
-        (this.loginParameters as any).cacheWebData = cacheWebData;
+        this.loginParameters.cacheWebData = cacheWebData;
         return this;
     }
 
     setRequireClientCredentials(requireClientCredentials: boolean): AuthBuilder {
-        (this.loginParameters as any).requireClientCredentials = requireClientCredentials;
+        this.loginParameters.requireClientCredentials = requireClientCredentials;
         return this;
     }
 
-    setItem(key: string, value: any): AuthBuilder {
+    setItem(key: keyof LoginParameters, value: any): AuthBuilder {
         (this.loginParameters as any)[key] = value;
         return this;
     }
 
-    private execute(): Promise<any> {
-        // Get the singleton instance and call the appropriate authentication method
-        const authService = (AuthenticationService as any).instance;
-
+    private execute(): Promise<string> {
         switch (this.method) {
             case 'login':
-                return authService.login(this.loginParameters);
+                return this.sdk.login(this.loginParameters);
             case 'authenticateAndActivate':
-                return authService.authenticateAndActivate(this.loginParameters);
+                return this.sdk.authenticateAndActivate(this.loginParameters);
             case 'authenticateLocal':
-                return authService.authenticateLocal(this.loginParameters);
+                return this.sdk.authenticateLocal(this.loginParameters);
             default:
                 return Promise.reject(new Error(`Unknown method: ${this.method}`));
         }
     }
 
-    then<TResult1 = any, TResult2 = never>(
-        onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+    then<TResult1 = string, TResult2 = never>(
+        onfulfilled?: ((value: string) => TResult1 | PromiseLike<TResult1>) | undefined | null,
         onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
     ): PromiseLike<TResult1 | TResult2> {
         return this.execute().then(onfulfilled, onrejected);