@maxzima/wa-communicator 0.0.17 → 1.0.2

package/dist/types/index.d.ts

@@ -1,60 +1 @@
-import { CommunicatorActionEnum } from "../enums/CommunicatorActionEnum";
-import { CommunicatorTargetEnum } from "../enums/CommunicatorTargetEnum";
-export declare type TSenderProps = {
-    receiverOrigin: string;
-    otherWindow: Window;
-};
-export declare type TReceiverProps = {
-    senderOrigin: string;
-};
-export declare type TReceiverCallback = (message: TCommunicatorMessage) => void;
-export declare type TCommunicatorActionTokenParams = {
-    name: string;
-    value: string;
-    domain: string;
-    expires?: number;
-};
-export declare type TCommunicatorActionResizeParams = {
-    width?: number;
-    height?: number;
-};
-export declare type TCommunicatorActionGotoParams = {
-    url: string;
-    isTargetBlank?: boolean;
-};
-export declare type TCommunicatorSenderActionMap = {
-    [CommunicatorActionEnum.LOADED]?: true;
-    [CommunicatorActionEnum.BLUR]?: true;
-    [CommunicatorActionEnum.TOKEN]?: TCommunicatorActionTokenParams;
-    [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams;
-    [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams;
-    [CommunicatorActionEnum.CLOSE]?: true;
-    [CommunicatorActionEnum.OPEN]?: CommunicatorTargetEnum;
-};
-export declare type TCommunicatorMessage = {
-    target: CommunicatorTargetEnum;
-    action: TCommunicatorSenderActionMap;
-};
-export declare type TReceiverSubscribeParams = {
-    code?: string;
-    target: CommunicatorTargetEnum;
-    action: CommunicatorActionEnum;
-    callback: TReceiverCallback;
-};
-export declare type TReceiverMessageQueue = TReceiverMessageQueueItem[];
-export declare type TReceiverMessageQueueItem = {
-    code?: string;
-    target: CommunicatorTargetEnum;
-    action: CommunicatorActionEnum;
-    params?: {
-        callback: TReceiverCallback;
-    };
-};
-export declare type TReceiverUnsubscribeMessageParams = {
-    code?: string;
-    target?: CommunicatorTargetEnum;
-    action?: CommunicatorActionEnum;
-};
-export declare type TReceiverTargetScenario = {
-    [key in CommunicatorTargetEnum]?: CommunicatorActionEnum[];
-};
+export * from "./TCommunicator";

package/dist/types/index.js

@@ -1 +1 @@
-import { CommunicatorActionEnum } from "../enums/CommunicatorActionEnum";
+export * from "./TCommunicator";

package/package.json

@@ -1,11 +1,11 @@
 {
-  "version": "0.0.17",
+  "version": "1.0.2",
   "name": "@maxzima/wa-communicator",
   "description": "",
   "author": "Noname",
   "license": "MIT",
   "main": "dist/index.js",
-  "types": "dist/index.d.js",
+  "types": "dist/index.d.ts",
   "engines": {
     "node": ">=14"
   },
@@ -20,14 +20,6 @@
     {
       "path": "dist/index.js",
       "limit": "10 KB"
-    },
-    {
-      "path": "dist/sender.js",
-      "limit": "10 KB"
-    },
-    {
-      "path": "dist/receiver.js",
-      "limit": "10 KB"
     }
   ],
   "scripts": {
@@ -43,21 +35,22 @@
     "size": "size-limit"
   },
   "devDependencies": {
-    "@size-limit/preset-small-lib": "^8.1.0",
-    "@types/jest": "^28.1.8",
-    "@typescript-eslint/eslint-plugin": "^5.35.1",
-    "@typescript-eslint/parser": "^5.35.1",
-    "eslint": "^8.22.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-editorconfig": "^4.0.2",
-    "eslint-plugin-eslint-comments": "^3.2.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "jest": "^28.1.3",
-    "npm-run-all": "^4.1.5",
-    "prettier": "^2.7.1",
-    "size-limit": "^8.1.0",
-    "ts-jest": "^28.0.8",
-    "typescript": "^4.7.4"
+    "@size-limit/preset-small-lib": "8.2.4",
+    "@types/jest": "28.1.8",
+    "@typescript-eslint/eslint-plugin": "5.59.5",
+    "@typescript-eslint/parser": "5.59.5",
+    "@types/gtag.js": "0.0.10",
+    "eslint": "8.40.0",
+    "eslint-config-prettier": "8.8.0",
+    "eslint-plugin-editorconfig": "4.0.3",
+    "eslint-plugin-eslint-comments": "3.2.0",
+    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-prettier": "4.2.1",
+    "jest": "28.1.3",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.8.8",
+    "size-limit": "8.2.4",
+    "ts-jest": "28.0.8",
+    "typescript": "4.7.4"
   }
 }

package/src/engine/AccountTracker/Enums/AccountTrackerEnum.ts

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

package/src/engine/AccountTracker/Public/AccountTracker.ts

@@ -0,0 +1,45 @@
+export class AccountTracker {
+  private props: TAccountTrackerProps;
+
+  constructor(props: TAccountTrackerProps) {
+    this.props = props;
+  }
+
+  public sendPhoneVerifyEvent () {
+    this.sendGA4Event(GA4EventActionEnum.VERIFY_CONTACT, GA4EventContactEnum.PHONE);
+    this.sendLinkedInEvent(LintrkEventIdEnum.PHONE);
+  }
+
+  public sendEmailVerifyEvent () {
+    this.sendGA4Event(GA4EventActionEnum.VERIFY_CONTACT, GA4EventContactEnum.EMAIL);
+    this.sendLinkedInEvent(LintrkEventIdEnum.EMAIL);
+  }
+
+  public sendRegistrationSuccessEvent () {
+    this.sendLinkedInEvent(LintrkEventIdEnum.REGISTRATION);
+  }
+
+  private sendGA4Event = (action: GA4EventActionEnum, contact: GA4EventContactEnum) => {
+    if (typeof this.props.gtag === 'undefined' || !this.props.ga4Id) {
+      return;
+    }
+
+    const params: TGA4Event = {
+      contact: contact,
+      origin: this.props.origin || null,
+      send_to: this.props.ga4Id,
+    };
+
+    this.props.gtag('event', action, params);
+  };
+
+  private sendLinkedInEvent = (id: LintrkEventIdEnum) => {
+    if (typeof this.props.lintrk === 'undefined') {
+      return;
+    }
+
+    this.props.lintrk(LintrkActionTypeEnum.TRACK, {
+      conversation_id: id,
+    });
+  };
+}

package/src/engine/AccountTracker/Types/TAccountTracker.ts

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

package/src/engine/AccountTracker/index.ts

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

package/src/engine/Communicator/Constants/Communicator.ts

@@ -0,0 +1,14 @@
+/* Immutable default values, which backend awaits */
+const CommunicatorDefaultRequestData: TDefaultRequestData = {
+  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/src/engine/Communicator/Enums/CommunicatorEnum.ts

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

package/src/engine/Communicator/Public/Communicator.ts

@@ -0,0 +1,195 @@
+import {
+  TAccountMeta,
+  TCreateSessionRequestData,
+  TEmailUpdateRequestData,
+  TRegistrationRequestData,
+  TRequestProps,
+  TRequestQueryParams,
+  TResponse,
+  TSetupChallengeRequestData,
+  TSignInByMobileRequestData,
+  TSignInStartRequestBody,
+  TSignUpByMobileRequestData,
+  TSignUpStartRequestBody,
+  TVerifyChallengeRequestBody,
+  TVerifyChallengeRequestData
+} from "@root/types";
+import {CommunicatorDefaultRequestData} from "./../Constants/Communicator";
+
+export class Communicator {
+  private props: TCommunicatorProps;
+
+  constructor(props: TCommunicatorProps) {
+    this.props = props;
+  }
+
+  public async signIn(data: TSignInByMobileRequestData) {
+    const meta = this.getMeta();
+    const body = JSON.stringify({
+      captcha_response: '_',
+      meta,
+      mobile: data.phoneNumber,
+    } as TSignInStartRequestBody);
+
+    return await this.send({
+      method: 'POST',
+      url: `${this.props.clientAuthApiBaseUrl}${CommunicatorAuthAPIEndpointEnum.SIGN_IN}`,
+      body,
+      headers: CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+    });
+  }
+
+  public async signUp(data: TSignUpByMobileRequestData) {
+    const body = JSON.stringify({
+      locale: data.locale,
+      mobile: data.phoneNumber,
+      timezone_name: data.timezoneName,
+    } as TSignUpStartRequestBody);
+
+    return await this.send({
+      method: 'POST',
+      url: `${this.props.clientAuthApiBaseUrl}${CommunicatorAuthAPIEndpointEnum.SIGN_UP}`,
+      body,
+      headers: CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+    });
+  }
+
+  public async setupChallenge(data: TSetupChallengeRequestData) {
+    return await this.send({
+      method: 'GET',
+      url: `${this.props.clientAuthApiBaseUrl}${CommunicatorAuthAPIEndpointEnum.CHALLENGE}`,
+      headers: {
+        'Authorization': `Bearer ${data.authToken}`,
+        ...CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+      },
+      queryParams: {
+        type: data.type,
+      },
+    });
+  }
+
+  public async verifyChallenge(data: TVerifyChallengeRequestData) {
+    const body = JSON.stringify({
+      type: data.type,
+      value: data.code,
+    } as TVerifyChallengeRequestBody);
+
+    return await this.send({
+      method: 'POST',
+      url: `${this.props.clientAuthApiBaseUrl}${CommunicatorAuthAPIEndpointEnum.CHALLENGE}`,
+      headers: {
+        'Authorization': `Bearer ${data.authToken}`,
+        ...CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+      },
+      body,
+    });
+  }
+
+  public async emailUpdate(data: TEmailUpdateRequestData) {
+    const body = JSON.stringify({
+      email: data.email,
+    });
+
+    return await this.send({
+      method: 'PATCH',
+      url: `${this.props.clientAuthApiBaseUrl}${CommunicatorAuthAPIEndpointEnum.EMAIL}`,
+      headers: {
+        'Authorization': `Bearer ${data.authToken}`,
+        ...CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+      },
+      body,
+    });
+  }
+
+  public async createSession(data: TCreateSessionRequestData) {
+    return await this.send({
+      method: 'POST',
+      url: `${this.props.clientAuthApiBaseUrl}${CommunicatorAuthAPIEndpointEnum.SESSION}`,
+      headers: {
+        'Authorization': `Bearer ${data.authToken}`,
+        ...CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+      },
+    });
+  }
+
+  public async getCurrentUserProfile() {
+    return await this.send({
+      method: 'GET',
+      url: `${this.props.clientFAPIBaseUrl}${CommunicatorFAPIEndpointEnum.USER}`,
+      headers: CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+    });
+  }
+
+  public async registration(data: TRegistrationRequestData) {
+    const body = JSON.stringify({
+      name: data.name,
+      source: {
+        hash: data.hash,
+        device_type: data.deviceType,
+        ga_id: data.gaId,
+        origin: data.origin,
+      }
+    });
+
+    return await this.send({
+      method: 'POST',
+      url: `${this.props.clientAuthApiBaseUrl}${CommunicatorFAPIEndpointEnum.REGISTRATION}`,
+      headers: {
+        'Authorization': `Bearer ${data.authToken}`,
+        ...CommunicatorDefaultRequestData.FETCH_HEADERS_INIT,
+      },
+      body,
+    });
+  }
+
+  private async send(requestInitProps: TRequestProps): Promise<TResponse> {
+    let url = requestInitProps.url;
+
+    if (requestInitProps.queryParams) {
+      url = `${url}?${this.processingQueryParams(requestInitProps.queryParams)}`;
+    }
+
+    return await 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,
+          })));
+      });
+  }
+
+  private getMeta = (): TAccountMeta => {
+    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,
+    };
+  };
+
+  private processingQueryParams = (queryParams: TRequestQueryParams):string => {
+    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;
+  };
+}

package/src/engine/Communicator/Types/TCommunicator.ts

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

package/src/engine/Communicator/index.ts

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

package/src/engine/index.ts

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

package/src/enums/CommunicatorErrorEnum.ts

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

package/src/enums/index.ts

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

package/src/index.ts

@@ -1,13 +1,20 @@
-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 {
+  Communicator,
+  AccountTracker
+} from "./engine";
+
+export {
+  CommunicatorUpdateChallengeCustomErrorCodeEnum,
+  CommunicatorVerifyChallengeCustomErrorCodeEnum,
+  CommunicatorEmailCustomErrorCodeEnum,
+} from "./enums";
 
 export {
-  CommunicatorReceiver,
-  CommunicatorSender,
-  CommunicatorTargetEnum,
-  CommunicatorActionEnum,
-  types,
-};
+  TChallenge,
+  TResponse,
+  TSignInByMobileResponse,
+  TSetupChallengeResponse,
+  TVerifyChallengeResponse,
+  TCreateSessionResponse,
+  TGetCurrentUserProfileResponseUser,
+} from "./types";