@maxzima/wa-communicator 0.0.17 → 1.0.2

package/README.md

@@ -3,70 +3,119 @@
 Import all 
 ```javascript
 import {
-   CommunicatorReceiver,
-   CommunicatorSender,
-   CommunicatorTargetEnum,
-   CommunicatorActionEnum,
-} from '@maxzima/wa-communicator';
+  Communicator,
+  AccountTracker,
+  CommunicatorUpdateChallengeCustomErrorCodeEnum,
+  CommunicatorVerifyChallengeCustomErrorCodeEnum,
+  CommunicatorEmailCustomErrorCodeEnum,
+  TChallenge,
+  TCreateSessionResponse,
+  TResponse,
+  TSetupChallengeResponse,
+  TSignInByMobileResponse,
+  TVerifyChallengeResponse,
+  TGetCurrentUserProfileResponseUser
+} from "@maxzima/wa-communicator/dist";
 ```
 
-Import only sender
+Import only Communicator
 ```javascript
 import {
-   CommunicatorSender,
-   CommunicatorTargetEnum,
-   CommunicatorActionEnum,
-} from '@maxzima/wa-communicator/dit/sender';
+  Communicator,
+  CommunicatorUpdateChallengeCustomErrorCodeEnum,
+  CommunicatorVerifyChallengeCustomErrorCodeEnum,
+  CommunicatorEmailCustomErrorCodeEnum,
+  TChallenge,
+  TCreateSessionResponse,
+  TResponse,
+  TSetupChallengeResponse,
+  TSignInByMobileResponse,
+  TVerifyChallengeResponse,
+  TGetCurrentUserProfileResponseUser
+} from '@maxzima/wa-communicator/dist';
 ```
 
-Import only receiver
+Import only AccountTracker
 ```javascript
 import {
-   CommunicatorReceiver,
-   CommunicatorTargetEnum,
-   CommunicatorActionEnum,
-} from '@maxzima/wa-communicator';
+  AccountTracker,
+} from '@maxzima/wa-communicator/dist';
 ```
 
 # Usage Sender
 
 ```javascript
-const communicator = new CommunicatorSender({
-  receiverOrigin: 'google.com',
-  otherWindow: window.parent,
+const communicator = new Communicator({
+  clientAuthApiBaseUrl: 'clients.google.com',
+  clientFAPIBaseUrl: 'clients.google.com',
 });
 
-communicator.sendMessage({
-  target: CommunicatorTargetEnum.SIGN_UP,
-  action: {
-    [CommunicatorActionEnum.CLOSE]: true,
-    [CommunicatorActionEnum.GOTO]: {
-      url: 'clients.google.com',
-      isTargetBlank: true
-    },
-  }
-});
+communicator.signIn({
+  phoneNumber: '+18004397566',
+})
+  .then((response) => callback(response));
+
+communicator.setupChallenge({
+  type: 'email_otp',
+  authToken: 'some_auth_token...',
+})
+  .then((response) => callback(response));
+
+communicator.verifyChallenge({
+  type: 'email_otp',
+  code: '123456',
+  authToken: 'some_auth_token...',
+})
+  .then((response) => callback(response));
+
+communicator.emailUpdate({
+  email: 'exampleEmail.gmail.com',
+  authToken: 'some_auth_token...',
+})
+  .then((response) => callback(response));
+
+communicator.createSession({
+  authToken: 'some_auth_token...',
+})
+  .then((response) => callback(response));
+
+communicator.signUp({
+  locale: 'en',
+  phoneNumber: '+18004397566',
+  timezoneName: 'Asia/Qatar',
+})
+  .then((response) => callback(response));
+
+communicator.registration({
+  authToken: 'some_auth_token...',
+  name: 'companyName',
+  hash: 'some_tracking_hash...',
+  deviceType: 'mobile',
+  gaId: 'gaId_cookie_value',
+  origin: 'business',
+})
+  .then((response) => callback(response));
+
+communicator.getCurrentUserProfile()
+  .then((response) => callback(response))
 ```
 
-# Usage Receiver
+# Usage AccountTracker
 
 ```javascript
-const communicator = new CommunicatorReceiver({
-  senderOrigin: 'clients.google.com'
+const tracker = new AccountTracker({
+  origin: 'business',
+  gtag: window.gtag, // gtag script width ga4_id 
+  lintrk: window.lintrk, // lintrk script with _linkedin_partner_id
+  ga4Id:'some_ga4_id',
 });
 
-// subscribe
-communicator.subscribe({
-  target: CommunicatorTargetEnum.SIGN_UP,
-  action: CommunicatorActionEnum.CLOSE,
-  callback: message => {
-    console.log('close', message);
-  },
-});
+/* tracking after sending phone number */
+tracker.sendPhoneVerifyEvent();
 
-// unsubscribe
-receiver.unsubscribe({
-  action: CommunicatorActionEnum.CLOSE
-});
+/* tracking after email verification */ 
+tracker.sendEmailVerifyEvent();
 
+/* tracking after registration */ 
+tracker.sendRegistrationSuccessEvent();
 ```

package/dist/engine/AccountTracker/Enums/AccountTrackerEnum.d.ts

@@ -0,0 +1,15 @@
+declare const enum GA4EventActionEnum {
+    VERIFY_CONTACT = "verify_contact"
+}
+declare const enum GA4EventContactEnum {
+    PHONE = "phone",
+    EMAIL = "email"
+}
+declare const enum LintrkActionTypeEnum {
+    TRACK = "track"
+}
+declare const enum LintrkEventIdEnum {
+    PHONE = 8612332,
+    EMAIL = 8612340,
+    REGISTRATION = 8612308
+}

package/dist/engine/AccountTracker/Enums/AccountTrackerEnum.js

@@ -0,0 +1 @@
+"use strict";

package/dist/engine/AccountTracker/Public/AccountTracker.d.ts

@@ -0,0 +1,9 @@
+export declare class AccountTracker {
+    private props;
+    constructor(props: TAccountTrackerProps);
+    sendPhoneVerifyEvent(): void;
+    sendEmailVerifyEvent(): void;
+    sendRegistrationSuccessEvent(): void;
+    private sendGA4Event;
+    private sendLinkedInEvent;
+}

package/dist/engine/AccountTracker/Public/AccountTracker.js

@@ -0,0 +1,35 @@
+export class AccountTracker {
+    constructor(props) {
+        this.sendGA4Event = (action, contact) => {
+            if (typeof this.props.gtag === 'undefined' || !this.props.ga4Id) {
+                return;
+            }
+            const params = {
+                contact: contact,
+                origin: this.props.origin || null,
+                send_to: this.props.ga4Id,
+            };
+            this.props.gtag('event', action, params);
+        };
+        this.sendLinkedInEvent = (id) => {
+            if (typeof this.props.lintrk === 'undefined') {
+                return;
+            }
+            this.props.lintrk("track", {
+                conversation_id: id,
+            });
+        };
+        this.props = props;
+    }
+    sendPhoneVerifyEvent() {
+        this.sendGA4Event("verify_contact", "phone");
+        this.sendLinkedInEvent(8612332);
+    }
+    sendEmailVerifyEvent() {
+        this.sendGA4Event("verify_contact", "email");
+        this.sendLinkedInEvent(8612340);
+    }
+    sendRegistrationSuccessEvent() {
+        this.sendLinkedInEvent(8612308);
+    }
+}

package/dist/engine/AccountTracker/Types/TAccountTracker.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="gtag.js" />
+declare type TLintrkOptions = {
+    conversation_id: LintrkEventIdEnum;
+};
+declare type TGA4Event = {
+    contact: GA4EventContactEnum;
+    send_to: TAccountTrackerProps['ga4Id'];
+    origin?: TAccountTrackerProps['origin'];
+};
+declare type TAccountTrackerProps = {
+    origin?: string;
+    gtag?: Gtag.Gtag;
+    lintrk?: (action: LintrkActionTypeEnum, options: TLintrkOptions) => void;
+    ga4Id?: string;
+};

package/dist/engine/AccountTracker/Types/TAccountTracker.js

@@ -0,0 +1 @@
+"use strict";

package/dist/engine/AccountTracker/index.d.ts

@@ -0,0 +1 @@
+export * from './Public/AccountTracker';

package/dist/engine/AccountTracker/index.js

@@ -0,0 +1 @@
+export * from './Public/AccountTracker';

package/dist/engine/Communicator/Constants/Communicator.d.ts

@@ -0,0 +1,2 @@
+declare const CommunicatorDefaultRequestData: TDefaultRequestData;
+export { CommunicatorDefaultRequestData, };

package/dist/engine/Communicator/Constants/Communicator.js

@@ -0,0 +1,10 @@
+const CommunicatorDefaultRequestData = {
+    IP: '127.0.0.1',
+    LANG: 'ENG',
+    AUDIT_SOURCE_TYPE: 'Backend',
+    FETCH_HEADERS_INIT: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json, text/plain, */*',
+    },
+};
+export { CommunicatorDefaultRequestData, };

package/dist/engine/Communicator/Enums/CommunicatorEnum.d.ts

@@ -0,0 +1,12 @@
+declare const enum CommunicatorFAPIEndpointEnum {
+    GEO_BY_IP = "geo-by-ip",
+    USER = "user",
+    REGISTRATION = "clients/registration"
+}
+declare const enum CommunicatorAuthAPIEndpointEnum {
+    SIGN_IN = "sign-in",
+    CHALLENGE = "sign-in/challenge",
+    EMAIL = "sign-in/email",
+    SIGN_UP = "sign-up",
+    SESSION = "sign-in/session"
+}

package/dist/engine/Communicator/Enums/CommunicatorEnum.js

@@ -0,0 +1 @@
+"use strict";

package/dist/engine/Communicator/Public/Communicator.d.ts

@@ -0,0 +1,16 @@
+import { TCreateSessionRequestData, TEmailUpdateRequestData, TRegistrationRequestData, TResponse, TSetupChallengeRequestData, TSignInByMobileRequestData, TSignUpByMobileRequestData, TVerifyChallengeRequestData } from "@root/types";
+export declare class Communicator {
+    private props;
+    constructor(props: TCommunicatorProps);
+    signIn(data: TSignInByMobileRequestData): Promise<TResponse>;
+    signUp(data: TSignUpByMobileRequestData): Promise<TResponse>;
+    setupChallenge(data: TSetupChallengeRequestData): Promise<TResponse>;
+    verifyChallenge(data: TVerifyChallengeRequestData): Promise<TResponse>;
+    emailUpdate(data: TEmailUpdateRequestData): Promise<TResponse>;
+    createSession(data: TCreateSessionRequestData): Promise<TResponse>;
+    getCurrentUserProfile(): Promise<TResponse>;
+    registration(data: TRegistrationRequestData): Promise<TResponse>;
+    private send;
+    private getMeta;
+    private processingQueryParams;
+}

package/dist/engine/Communicator/Public/Communicator.js

@@ -0,0 +1,158 @@
+import { __awaiter } from "tslib";
+import { CommunicatorDefaultRequestData } from "./../Constants/Communicator";
+export class Communicator {
+    constructor(props) {
+        this.getMeta = () => {
+            return {
+                audit_source_type: CommunicatorDefaultRequestData.AUDIT_SOURCE_TYPE,
+                browser_page_resolution: `${window.innerWidth}x${window.innerHeight}`,
+                cookies_enabled: window.navigator.cookieEnabled,
+                ip: CommunicatorDefaultRequestData.IP,
+                js_enabled: true,
+                language: CommunicatorDefaultRequestData.LANG,
+                user_agent: window.navigator.userAgent,
+            };
+        };
+        this.processingQueryParams = (queryParams) => {
+            let queryParamsString = '';
+            const queryParamsList = Object.entries(queryParams);
+            queryParamsList.forEach((queryParam, index) => {
+                let separator = '';
+                if (index > 0) {
+                    separator = '&';
+                }
+                queryParamsString = `${queryParamsString}${separator}${queryParam[0]}=${queryParam[1]}`;
+            });
+            return queryParamsString;
+        };
+        this.props = props;
+    }
+    signIn(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = this.getMeta();
+            const body = JSON.stringify({
+                captcha_response: '_',
+                meta,
+                mobile: data.phoneNumber,
+            });
+            return yield this.send({
+                method: 'POST',
+                url: `${this.props.clientAuthApiBaseUrl}${"sign-in"}`,
+                body,
+                headers: CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+            });
+        });
+    }
+    signUp(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = JSON.stringify({
+                locale: data.locale,
+                mobile: data.phoneNumber,
+                timezone_name: data.timezoneName,
+            });
+            return yield this.send({
+                method: 'POST',
+                url: `${this.props.clientAuthApiBaseUrl}${"sign-up"}`,
+                body,
+                headers: CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+            });
+        });
+    }
+    setupChallenge(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.send({
+                method: 'GET',
+                url: `${this.props.clientAuthApiBaseUrl}${"sign-in/challenge"}`,
+                headers: Object.assign({ 'Authorization': `Bearer ${data.authToken}` }, CommunicatorDefaultRequestData.FETCH_HEADERS_INIT),
+                queryParams: {
+                    type: data.type,
+                },
+            });
+        });
+    }
+    verifyChallenge(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = JSON.stringify({
+                type: data.type,
+                value: data.code,
+            });
+            return yield this.send({
+                method: 'POST',
+                url: `${this.props.clientAuthApiBaseUrl}${"sign-in/challenge"}`,
+                headers: Object.assign({ 'Authorization': `Bearer ${data.authToken}` }, CommunicatorDefaultRequestData.FETCH_HEADERS_INIT),
+                body,
+            });
+        });
+    }
+    emailUpdate(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = JSON.stringify({
+                email: data.email,
+            });
+            return yield this.send({
+                method: 'PATCH',
+                url: `${this.props.clientAuthApiBaseUrl}${"sign-in/email"}`,
+                headers: Object.assign({ 'Authorization': `Bearer ${data.authToken}` }, CommunicatorDefaultRequestData.FETCH_HEADERS_INIT),
+                body,
+            });
+        });
+    }
+    createSession(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.send({
+                method: 'POST',
+                url: `${this.props.clientAuthApiBaseUrl}${"sign-in/session"}`,
+                headers: Object.assign({ 'Authorization': `Bearer ${data.authToken}` }, CommunicatorDefaultRequestData.FETCH_HEADERS_INIT),
+            });
+        });
+    }
+    getCurrentUserProfile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.send({
+                method: 'GET',
+                url: `${this.props.clientFAPIBaseUrl}${"user"}`,
+                headers: CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+            });
+        });
+    }
+    registration(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = JSON.stringify({
+                name: data.name,
+                source: {
+                    hash: data.hash,
+                    device_type: data.deviceType,
+                    ga_id: data.gaId,
+                    origin: data.origin,
+                }
+            });
+            return yield this.send({
+                method: 'POST',
+                url: `${this.props.clientAuthApiBaseUrl}${"clients/registration"}`,
+                headers: Object.assign({ 'Authorization': `Bearer ${data.authToken}` }, CommunicatorDefaultRequestData.FETCH_HEADERS_INIT),
+                body,
+            });
+        });
+    }
+    send(requestInitProps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let url = requestInitProps.url;
+            if (requestInitProps.queryParams) {
+                url = `${url}?${this.processingQueryParams(requestInitProps.queryParams)}`;
+            }
+            return yield fetch(new URL(url), {
+                method: requestInitProps.method,
+                body: requestInitProps.body,
+                headers: requestInitProps.headers,
+            })
+                .then((response) => {
+                return new Promise((resolve) => response.json()
+                    .then((json) => resolve({
+                    status: response.status,
+                    ok: response.ok,
+                    json,
+                })));
+            });
+        });
+    }
+}

package/dist/engine/Communicator/Types/TCommunicator.d.ts

@@ -0,0 +1,10 @@
+declare type TDefaultRequestData = {
+    IP: string;
+    LANG: string;
+    FETCH_HEADERS_INIT: HeadersInit;
+    AUDIT_SOURCE_TYPE: import('@root/types').TAuditSource;
+};
+declare type TCommunicatorProps = {
+    clientAuthApiBaseUrl: string;
+    clientFAPIBaseUrl: string;
+};

package/dist/engine/Communicator/Types/TCommunicator.js

@@ -0,0 +1 @@
+"use strict";

package/dist/engine/Communicator/index.d.ts

@@ -0,0 +1 @@
+export * from './Public/Communicator';

package/dist/engine/Communicator/index.js

@@ -0,0 +1 @@
+export * from './Public/Communicator';

package/dist/engine/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./AccountTracker";
+export * from "./Communicator";

package/dist/engine/index.js

@@ -0,0 +1,2 @@
+export * from "./AccountTracker";
+export * from "./Communicator";

package/dist/enums/CommunicatorErrorEnum.d.ts

@@ -0,0 +1,15 @@
+declare const enum CommunicatorUpdateChallengeCustomErrorCodeEnum {
+    INVALID_AUTH_HEADER = 90793,
+    FREQUENT_REQUESTS = 90449,
+    REQUESTS_EXCEEDED = 90696,
+    MISSING_EMAIL = 90174,
+    UNEXPECTED_CHALLENGE_TYPE = 90767
+}
+declare const enum CommunicatorVerifyChallengeCustomErrorCodeEnum {
+    SESSION_EXPIRED = 90302
+}
+declare const enum CommunicatorEmailCustomErrorCodeEnum {
+    UNKNOWN_ERROR = 91044,
+    UNPROCESSABLE_ENTITY = 90768
+}
+export { CommunicatorUpdateChallengeCustomErrorCodeEnum, CommunicatorVerifyChallengeCustomErrorCodeEnum, CommunicatorEmailCustomErrorCodeEnum, };

package/dist/enums/CommunicatorErrorEnum.js

@@ -0,0 +1 @@
+export {};

package/dist/enums/index.d.ts

@@ -0,0 +1 @@
+export * from "./CommunicatorErrorEnum";

package/dist/enums/index.js

@@ -0,0 +1 @@
+export * from "./CommunicatorErrorEnum";

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-import { CommunicatorReceiver } from "./engine/CommunicatorReceiver";
-import { CommunicatorSender } from "./engine/CommunicatorSender";
-import { CommunicatorTargetEnum } from "./enums/CommunicatorTargetEnum";
-import { CommunicatorActionEnum } from "./enums/CommunicatorActionEnum";
-import * as types from "./types";
-export { CommunicatorReceiver, CommunicatorSender, CommunicatorTargetEnum, CommunicatorActionEnum, types, };
+export { Communicator, AccountTracker } from "./engine";
+export { CommunicatorUpdateChallengeCustomErrorCodeEnum, CommunicatorVerifyChallengeCustomErrorCodeEnum, CommunicatorEmailCustomErrorCodeEnum, } from "./enums";
+export { TChallenge, TResponse, TSignInByMobileResponse, TSetupChallengeResponse, TVerifyChallengeResponse, TCreateSessionResponse, TGetCurrentUserProfileResponseUser, } from "./types";

package/dist/index.js

@@ -1,6 +1 @@
-import { CommunicatorReceiver } from "./engine/CommunicatorReceiver";
-import { CommunicatorSender } from "./engine/CommunicatorSender";
-import { CommunicatorTargetEnum } from "./enums/CommunicatorTargetEnum";
-import { CommunicatorActionEnum } from "./enums/CommunicatorActionEnum";
-import * as types from "./types";
-export { CommunicatorReceiver, CommunicatorSender, CommunicatorTargetEnum, CommunicatorActionEnum, types, };
+export { Communicator, AccountTracker } from "./engine";

package/dist/types/TCommunicator.d.ts

@@ -0,0 +1,110 @@
+declare type TChallenge = 'email_otp' | 'mobile_otp' | 'pin';
+declare type TAuditSource = 'Backend' | 'SelfService';
+declare type TRegistrationRequestBodySourceDeviceType = 'mobile' | 'regular';
+declare type TRequestProps = {
+    url?: string;
+    method?: RequestInit['method'];
+    body?: any;
+    headers?: HeadersInit;
+    mode?: RequestMode;
+    queryParams?: TRequestQueryParams;
+};
+declare type TRequestQueryParams = {
+    [key: string]: string;
+};
+declare type TResponse = {
+    json: any;
+    status: number;
+    ok: boolean;
+};
+declare type TSignInStartRequestBody = {
+    captcha_response?: string;
+    meta: TAccountMeta;
+    mobile?: string;
+};
+declare type TAccountMeta = {
+    audit_source_type: TAuditSource;
+    browser_page_resolution: string;
+    cookies_enabled: boolean;
+    ip: string;
+    js_enabled: boolean;
+    language: string;
+    user_agent: string;
+};
+declare type TSignInByMobileRequestData = {
+    phoneNumber: string;
+};
+declare type TSignInByMobileResponse = {
+    auth_token: string;
+    challenges: TChallenge[];
+};
+declare type TSignUpStartRequestBody = {
+    locale: string;
+    mobile: string;
+    timezone_name: string;
+};
+declare type TSignUpByMobileRequestData = {
+    locale: string;
+    phoneNumber: string;
+    timezoneName: string;
+};
+declare type TSetupChallengeRequestData = {
+    type: TChallenge;
+    authToken: string;
+};
+declare type TSetupChallengeResponse = {
+    attempts_left: number;
+    masked_email: string;
+    masked_mobile: string;
+    next_attempt_after: number;
+};
+declare type TVerifyChallengeRequestBody = {
+    type: TChallenge;
+    value: string;
+};
+declare type TVerifyChallengeRequestData = {
+    authToken: string;
+    type: TChallenge;
+    code: string;
+};
+declare type TVerifyChallengeResponse = {
+    auth_token: string;
+    challenges: TChallenge[];
+};
+declare type TEmailUpdateRequestData = {
+    authToken: string;
+    email: string;
+};
+declare type TCreateSessionRequestData = {
+    authToken: string;
+};
+declare type TCreateSessionResponse = {
+    access_token: string;
+    refresh_token: string;
+};
+declare type TGetCurrentUserProfileResponseUser = {
+    profiles: (TGetCurrentUserProfileResponseUserProfiles & Record<string, unknown>)[];
+};
+declare type TGetCurrentUserProfileResponseUserProfiles = {
+    target_entity_name: string;
+    target_entity_id: string;
+};
+declare type TRegistrationRequestBodySource = {
+    hash: string;
+    device_type: TRegistrationRequestBodySourceDeviceType;
+    ga_id: string;
+    origin: string;
+};
+declare type TRegistrationRequestBody = {
+    name: string;
+    source: TRegistrationRequestBodySource;
+};
+declare type TRegistrationRequestData = {
+    authToken: string;
+    name: TRegistrationRequestBody['name'];
+    deviceType: TRegistrationRequestBodySource['device_type'];
+    hash: TRegistrationRequestBodySource['hash'];
+    gaId: TRegistrationRequestBodySource['ga_id'];
+    origin: TRegistrationRequestBodySource['origin'];
+};
+export { TChallenge, TAuditSource, TRequestProps, TRequestQueryParams, TResponse, TSignInStartRequestBody, TAccountMeta, TSignInByMobileRequestData, TSignInByMobileResponse, TSignUpStartRequestBody, TSignUpByMobileRequestData, TSetupChallengeRequestData, TSetupChallengeResponse, TVerifyChallengeRequestBody, TVerifyChallengeRequestData, TVerifyChallengeResponse, TEmailUpdateRequestData, TCreateSessionRequestData, TCreateSessionResponse, TGetCurrentUserProfileResponseUser, TRegistrationRequestData };

package/dist/types/TCommunicator.js

@@ -0,0 +1 @@
+export {};