@unvired/react-native-wrapper-sdk 0.0.2

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

@@ -0,0 +1,7 @@
+// Export main SDK
+import UnviredWrapper from './UnviredWrapper';
+
+export { LoginParameters, LoginType } from './core/UnviredSDK';
+
+// Export the default SDK instance
+export default UnviredWrapper;  

package/src/lib/AuthBuilder.ts

@@ -0,0 +1,146 @@
+import UnviredSDK, { LoginParameters, LoginType } from './../core/UnviredSDK';
+
+export default class AuthBuilder implements PromiseLike<string> {
+    private sdk: UnviredSDK;
+    private method: 'login' | 'authenticateAndActivate' | 'authenticateLocal';
+    private loginParameters: LoginParameters;
+
+    constructor(
+        sdk: UnviredSDK,
+        method: 'login' | 'authenticateAndActivate' | 'authenticateLocal'
+    ) {
+        this.sdk = sdk;
+        this.method = method;
+        this.loginParameters = new LoginParameters();
+    }
+
+    setAppName(appName: string): AuthBuilder {
+        this.loginParameters.appName = appName;
+        return this;
+    }
+
+    setCompany(company: string): AuthBuilder {
+        this.loginParameters.company = company;
+        return this;
+    }
+
+    setUsername(username: string): AuthBuilder {
+        this.loginParameters.username = username;
+        return this;
+    }
+
+    setPassword(password: string): AuthBuilder {
+        this.loginParameters.password = password;
+        return this;
+    }
+
+    setUrl(url: string): AuthBuilder {
+        this.loginParameters.url = url;
+        return this;
+    }
+
+    setDomain(domain: string): AuthBuilder {
+        this.loginParameters.domain = domain;
+        return this;
+    }
+
+    setLoginType(loginType: LoginType): AuthBuilder {
+        this.loginParameters.loginType = loginType;
+        return this;
+    }
+
+    setFeUserId(feUserId: string): AuthBuilder {
+        this.loginParameters.feUserId = feUserId;
+        return this;
+    }
+
+    setPort(port: string): AuthBuilder {
+        this.loginParameters.port = port;
+        return this;
+    }
+
+    setMetadataPath(metadataPath: string): AuthBuilder {
+        this.loginParameters.metadataPath = metadataPath;
+        return this;
+    }
+
+    setIsRequiredAttachmentBase64(isRequiredAttachmentBase64: boolean): AuthBuilder {
+        this.loginParameters.isRequiredAttachmentBase64 = isRequiredAttachmentBase64;
+        return this;
+    }
+
+    setAutoSendTime(autoSendTime: string): AuthBuilder {
+        this.loginParameters.autoSendTime = autoSendTime;
+        return this;
+    }
+
+    setAutoSyncTime(autoSyncTime: string): AuthBuilder {
+        this.loginParameters.autoSyncTime = autoSyncTime;
+        return this;
+    }
+
+    setMetadataJSON(metadataJSON: string): AuthBuilder {
+        this.loginParameters.metadataJSON = metadataJSON;
+        return this;
+    }
+
+    setDemoData(demoData: string): AuthBuilder {
+        this.loginParameters.demoData = demoData;
+        return this;
+    }
+
+    setDemoModeRequired(demoModeRequired: boolean): AuthBuilder {
+        this.loginParameters.demoModeRequired = demoModeRequired;
+        return this;
+    }
+
+    setPersistWebDb(persistWebDb: boolean): AuthBuilder {
+        this.loginParameters.persistWebDb = persistWebDb;
+        return this;
+    }
+
+    setJwtOptions(jwtOptions: object): AuthBuilder {
+        this.loginParameters.jwtOptions = jwtOptions;
+        return this;
+    }
+
+    setLoginLanguage(loginLanguage: string): AuthBuilder {
+        this.loginParameters.loginLanguage = loginLanguage;
+        return this;
+    }
+
+    setCacheWebData(cacheWebData: boolean): AuthBuilder {
+        this.loginParameters.cacheWebData = cacheWebData;
+        return this;
+    }
+
+    setRequireClientCredentials(requireClientCredentials: boolean): AuthBuilder {
+        this.loginParameters.requireClientCredentials = requireClientCredentials;
+        return this;
+    }
+
+    setItem(key: keyof LoginParameters, value: any): AuthBuilder {
+        (this.loginParameters as any)[key] = value;
+        return this;
+    }
+
+    private execute(): Promise<string> {
+        switch (this.method) {
+            case 'login':
+                return this.sdk.login(this.loginParameters);
+            case 'authenticateAndActivate':
+                return this.sdk.authenticateAndActivate(this.loginParameters);
+            case 'authenticateLocal':
+                return this.sdk.authenticateLocal(this.loginParameters);
+            default:
+                return Promise.reject(new Error(`Unknown method: ${this.method}`));
+        }
+    }
+
+    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);
+    }
+}