gap-nodejs-sdk 1.0.0

package/index.ts

@@ -0,0 +1,5 @@
+import Gap from "./src/index";
+
+(function test() {
+
+})();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "gap-nodejs-sdk",
+  "version": "1.0.0",
+  "description": "GCI App Platform Library for Node",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "lint": "eslint '**/*.{ts,tsx}' --max-warnings 0",
+    "clean": "rimraf ./dist tsconfig.tsbuildinfo"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.dtsmart.vn/gap/gap-nodejs-sdk.git"
+  },
+  "author": "TanNX",
+  "license": "ISC",
+  "devDependencies": {
+    "rimraf": "^3.0.2",
+    "typescript": "^4.7.2"
+  },
+  "dependencies": {
+    "tslib": "^2.4.0"
+  }
+}

package/src/android/android_bridge.ts

@@ -0,0 +1,33 @@
+import {
+    PlatformExecutor,
+    MiniAppBridge,
+    Callback,
+    mabMessageQueue,
+} from '../common_bridge';
+import { Platform } from '../types/platform';
+
+/* tslint:disable:no-any */
+let uniqueId = Math.random();
+
+class AndroidExecutor implements PlatformExecutor {
+    execEvents(event) {
+        (window as any).dispatchEvent(event);
+    }
+    exec(action, param, onSuccess, onError) {
+        const callback = {} as Callback;
+        callback.onSuccess = onSuccess;
+        callback.onError = onError;
+        callback.id = String(++uniqueId);
+        mabMessageQueue.unshift(callback);
+
+        (window as any).MiniAppAndroid.postMessage(
+            JSON.stringify({ action, param, id: callback.id })
+        );
+    }
+
+    getPlatform(): string {
+        return Platform.ANDROID;
+    }
+}
+
+(window as any).MiniAppBridge = new MiniAppBridge(new AndroidExecutor());

package/src/base/input_data_type.ts

@@ -0,0 +1,38 @@
+export declare type LoginInput = {
+    username: string,
+    password: string,
+};
+
+export declare type AppConfig = {
+    /**
+     * Title app.
+     */
+    title?: string;
+    /**
+     * 0: Default | 1: Sensor | 2: Force portrait | 3: Force landscape
+     */
+    orientation?: 'auto' | 'portrait' | 'landscape';
+    /**
+     * Color.
+     */
+    headerColor?: null | string;
+    /**
+     * Text Color.
+     */
+    textColor?: null | string;
+    /**
+     * Status bar Color.
+     */
+    statusBarColor?: null | string;
+    /**
+     * Left button.
+     */
+    leftButton?: 'none' | 'back' | 'home' | 'both';
+};
+
+export declare type CommonRequest = {
+    channel: string,
+    type: string,
+    method: string,
+    data?: string,
+}

package/src/base/response_data_type.ts

@@ -0,0 +1,36 @@
+import { GapError } from "src/error"
+
+export declare type ResponseSuccess = {
+    channel: string,
+    type: string,
+    method: string,
+    data: string
+}
+
+export declare type ResponseError = {
+    error: object | GapError | string,
+}
+
+export declare type SystemInfo = {
+    version: string,
+    apiVersion: string
+}
+
+export declare type BusinessInfo = {
+    name: string,
+    shortName: string,
+    phone: string,
+    address: string,
+    countryCode: string,
+    city: string,
+    stateCode: string,
+    postalCode: string,
+    description: string,
+    logoImage: string,
+    coverImage: string
+}
+
+export declare type BusinessConfig = {
+    setting: object | string,
+    appSetting: object | string,
+}

package/src/base_type.ts

@@ -0,0 +1,14 @@
+export enum GapApiVersion {
+    V1 = '1.0.0',
+}
+
+export enum GapHeader {
+    GClientId = 'G-ClientID'
+}
+
+export enum UserAgent {
+    IOS = 'IOS',
+    ANDROID = 'ANDROID',
+    CHROME = 'CHROME',
+    SAFARI = 'SAFARI',
+}

package/src/common_bridge.ts

@@ -0,0 +1,146 @@
+/** @internal */
+const mabMessageQueue: Callback[] = [];
+const mabCustomEventQueue: CustomEvent[] = [];
+const mabKeyboardEventQueue: CustomEvent[] = [];
+export { mabMessageQueue };
+export { mabCustomEventQueue };
+export { mabKeyboardEventQueue };
+
+/** @internal */
+export interface Callback {
+    id: string;
+    onSuccess: (value: string) => void;
+    onError: (error: string) => void;
+}
+
+/** @internal */
+export interface PlatformExecutor {
+    /**
+     * Method to call the native interface methods for respective platforms
+     * such as iOS & Android.
+     * @param  {[string]} action Action command/interface name that native side need to execute
+     * @param  {Object} param Object that contains request parameter values like permissions.
+     * For eg., {permission: 'location'}
+     * @param  {[Function]} onSuccess Success callback function
+     * @param  {[Function]} onError Error callback function
+     */
+    exec(
+        action: string,
+        param: object | null,
+        onSuccess: (value: string) => void,
+        onError: (error: string) => void
+    ): void;
+
+    execEvents(event: CustomEvent): void;
+
+    /**
+     * Get the platform which injects this bridge.
+     * @returns The platform name. It could be 'Android' or 'iOS'.
+     */
+    getPlatform(): string;
+}
+
+export class MiniAppBridge {
+    executor: PlatformExecutor;
+    platform: string;
+    // isSecureStorageReady = false;
+    // secureStorageLoadError: MiniAppError | null = null;
+
+    constructor(executor: PlatformExecutor) {
+        this.executor = executor;
+        this.platform = executor.getPlatform();
+
+        // window.addEventListener(
+        //     MiniAppSecureStorageEvents.onReady,
+        //     () => (this.isSecureStorageReady = true)
+        // );
+        // window.addEventListener(
+        //     MiniAppSecureStorageEvents.onLoadError,
+        //     (e: CustomEvent) =>
+        //         (this.secureStorageLoadError = parseMiniAppError(e.detail.message))
+        // );
+    }
+
+    /**
+     * Success Callback method that will be called from native side
+     * to this bridge. This method will send back the value to the
+     * mini apps that uses promises.
+     * @param  {[String]} messageId Message ID which will be used to get callback object from messageQueue
+     * @param  {[String]} value Response value sent from the native on invoking the action command
+     */
+    execSuccessCallback(messageId, value) {
+        const queueObj = mabMessageQueue.filter(
+            callback => callback.id === messageId
+        )[0];
+        if (value) {
+            queueObj.onSuccess(value);
+        } else {
+            queueObj.onError('Unknown Error');
+        }
+        removeFromMessageQueue(queueObj);
+    }
+
+    /**
+     * Error Callback method that will be called from native side
+     * to this bridge. This method will send back the error message to the
+     * mini apps that uses promises.
+     * @param  {[String]} messageId Message ID which will be used to get callback object from messageQueue
+     * @param  {[String]} errorMessage Error message sent from the native on invoking the action command
+     */
+    execErrorCallback(messageId, errorMessage) {
+        const queueObj = mabMessageQueue.filter(
+            callback => callback.id === messageId
+        )[0];
+        if (!errorMessage) {
+            errorMessage = 'Unknown Error';
+        }
+        queueObj.onError(errorMessage);
+        removeFromMessageQueue(queueObj);
+    }
+    /**
+     * Event Callback method that will be called from native side
+     * to this bridge. This method will send back the value to the
+     * mini app that listen to this eventType.
+     * @param  {[String]} eventType EventType which will be used to listen for the event
+     * @param  {[String]} value Additional message sent from the native on invoking for the eventType
+     */
+    execCustomEventsCallback(eventType: string, value: string) {
+        const event = new CustomEvent(eventType, {
+            detail: { message: value },
+        });
+        let queueObj = mabCustomEventQueue.filter(
+            customEvent => customEvent === event
+        )[0];
+        if (!queueObj) {
+            if (eventType === event.type) {
+                removeFromEventQueue(event);
+            }
+            queueObj = event;
+            mabCustomEventQueue.unshift(queueObj);
+        }
+        this.executor.execEvents(queueObj);
+    }
+}
+/**
+ * Method to remove the callback object from the message queue after successful/error communication
+ * with the native application
+ * @param  {[Object]} queueObj Queue Object that holds the references of callback information.
+ * @internal
+ */
+function removeFromMessageQueue(queueObj) {
+    const messageObjIndex = mabMessageQueue.indexOf(queueObj);
+    if (messageObjIndex !== -1) {
+        mabMessageQueue.splice(messageObjIndex, 1);
+    }
+}
+
+function removeFromEventQueue(queueObj) {
+    const eventObjIndex = mabCustomEventQueue.indexOf(
+        mabCustomEventQueue.filter(
+            customEvent => customEvent.type === queueObj.type
+        )[0]
+    );
+    if (eventObjIndex !== -1) {
+        mabCustomEventQueue.splice(eventObjIndex, 1);
+    }
+}

package/src/context.ts

@@ -0,0 +1,72 @@
+import { GapApiVersion } from "./base-type";
+import * as GapErrors from "./error";
+
+
+interface ContextInterface {
+    API_KEY: string;
+    API_SECRET_KEY: string;
+    G_CLIENTID: string;
+    API_VERSION: GapApiVersion;
+    USER_AGENT: string;
+    // HOST_NAME: string;
+    // HOST_SCHEME?: string;
+    // IS_EMBEDDED_APP: boolean;
+    // IS_PRIVATE_APP?: boolean;
+    LOG_FILE?: string;
+    USER_AGENT_PREFIX?: string;
+
+
+    /**
+     * Sets up the GAP API Library
+     *
+     * @param params Settings to update
+     */
+    initialize(params: ContextInterface): void;
+
+    /**
+     * Throws error if context has not been initialized.
+     */
+    throwIfUninitialized(): void | never;
+
+}
+
+const Context: ContextInterface = {
+    API_KEY: "",
+    API_SECRET_KEY: "",
+    G_CLIENTID: "",
+    USER_AGENT: "",
+    API_VERSION: GapApiVersion.V1,
+    initialize: function (params: ContextInterface): void {
+        // Make sure that the essential params actually have content in them
+        const missing: string[] = [];
+        if (!params.API_KEY.length) {
+            missing.push('API_KEY');
+        }
+        if (!params.API_SECRET_KEY.length) {
+            missing.push('API_SECRET_KEY');
+        }
+        if (!params.API_SECRET_KEY.length) {
+            missing.push('G_CLIENTID');
+        }
+        if (missing.length) {
+            throw new GapErrors.MissingDataContextError(
+                `Cannot initialize Shopify API Library. Missing values for: ${missing.join(
+                    ', '
+                )}`
+            );
+        }
+        this.API_KEY = params.API_KEY;
+        this.API_SECRET_KEY = params.API_SECRET_KEY;
+        this.G_CLIENTID = params.G_CLIENTID;
+        this.API_VERSION = params.API_VERSION;
+    },
+    throwIfUninitialized: function (): void {
+        if (!this.API_KEY || this.API_KEY.length === 0) {
+            throw new GapErrors.UninitializedContextError(
+                'Context has not been properly initialized. Please call the .initialize() method to setup your app context object.'
+            );
+        }
+    },
+}
+
+export { Context, ContextInterface };

package/src/error.ts

@@ -0,0 +1,39 @@
+export class GapError extends Error {
+    constructor(...args: any) {
+        super(...args);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+interface HttpResponseData {
+    code: number;
+    statusText: string;
+    body?: { [key: string]: unknown };
+    headers?: { [key: string]: unknown };
+}
+interface HttpResponseErrorParams extends HttpResponseData {
+    message: string;
+}
+export class HttpResponseError extends GapError {
+    readonly response: HttpResponseData;
+
+    public constructor({
+        message,
+        code,
+        statusText,
+        body,
+        headers,
+    }: HttpResponseErrorParams) {
+        super(message);
+        this.response = {
+            code,
+            statusText,
+            body,
+            headers,
+        };
+    }
+}
+
+//Detail of error for testing purpose
+export class UninitializedContextError extends GapError { };
+export class MissingDataContextError extends GapError { };

package/src/index.ts

@@ -0,0 +1,13 @@
+import { Context } from './context';
+import * as NativeApp from "./native_app/index";
+import * as ShopifyErrors from './error';
+
+export const Gap = {
+    Context,
+    NativeApp,
+    // GciClientApi,
+    Errors: ShopifyErrors,
+};
+
+export default Gap;
+export * from './types';

package/src/interface/invoke_event_interface.ts

@@ -0,0 +1,3 @@
+export interface InvokeEvent {
+    invokeEvent: () => string;
+}

package/src/interface/native_app_interface.ts

@@ -0,0 +1,13 @@
+import * as ResponseDataType from "src/base/response_data_type";
+import * as InputDataType from "src/base/input_data_type";
+
+export default interface NativeAppInterFace {
+    getAppId: () => string;
+    login: (data?: InputDataType.LoginInput) => Promise<string>;
+    getLoginStatus: () => boolean;
+    getAccessToken: () => Promise<string | null>;
+    getVersion: () => string;
+    getSystemInfo: () => ResponseDataType.SystemInfo;
+    getBusinessInfo: () => ResponseDataType.BusinessInfo;
+    getBusinessConfig: () => ResponseDataType.BusinessConfig;
+}

package/src/ios/ios_bridge.ts

@@ -0,0 +1,61 @@
+import {
+  PlatformExecutor,
+  MiniAppBridge,
+  Callback,
+  mabMessageQueue,
+} from '../common_bridge';
+import { Platform } from '../types/platform';
+
+/* tslint:disable:no-any */
+let uniqueId = Math.random();
+
+// tslint:disable-next-line: variable-name
+const GeolocationPositionError = {
+  PERMISSION_DENIED: 1,
+  POSITION_UNAVAILABLE: 2,
+  TIMEOUT: 3,
+};
+
+class IOSExecutor implements PlatformExecutor {
+  execEvents(event): void {
+    (window as any).dispatchEvent(event);
+  }
+  exec(action, param, onSuccess, onError) {
+    const callback = {} as Callback;
+    callback.onSuccess = onSuccess;
+    callback.onError = onError;
+    callback.id = String(++uniqueId);
+    mabMessageQueue.unshift(callback);
+
+    (window as any).webkit.messageHandlers.MiniAppiOS.postMessage(
+      JSON.stringify({ action, param, id: callback.id })
+    );
+  }
+
+  getPlatform(): string {
+    return Platform.IOS;
+  }
+}
+
+const iOSExecutor = new IOSExecutor();
+(window as any).MiniAppBridge = new MiniAppBridge(iOSExecutor);
+
+navigator.geolocation.getCurrentPosition = (success, error, options) => {
+  return iOSExecutor.exec(
+    'getCurrentPosition',
+    { locationOptions: options },
+    value => {
+      try {
+        const parsedData = JSON.parse(value);
+        success(parsedData);
+      } catch (error) {
+        error({
+          code: GeolocationPositionError.POSITION_UNAVAILABLE,
+          message:
+            'Failed to parse location object from MiniAppBridge: ' + error,
+        });
+      }
+    },
+    error => console.error(error)
+  );
+};

package/src/native_app/index.ts

@@ -0,0 +1,17 @@
+import * as ResponseDataType from "src/base/response_data_type";
+import NativeAppInterFace from "src/interface/native_app_interface";
+import * as InputDataType from "src/base/input_data_type";
+
+export class NativeApp implements NativeAppInterFace {
+    public getAppId() {
+        return "";
+    }
+    login: (data?: InputDataType.LoginInput | undefined) => Promise<string>;
+    getLoginStatus: () => boolean;
+    getAccessToken: () => Promise<string | null>;
+    getVersion: () => string;
+    getSystemInfo: () => ResponseDataType.SystemInfo;
+    getBusinessInfo: () => ResponseDataType.BusinessInfo;
+    getBusinessConfig: () => ResponseDataType.BusinessConfig;
+
+}

package/src/types/platform.ts

@@ -0,0 +1,8 @@
+/** @internal */
+
+/** Device platform. */
+export enum Platform {
+    ANDROID = 'Android',
+    IOS = 'iOS',
+    WEB = 'Web'
+}

package/src/types.ts

@@ -0,0 +1 @@
+export * from './base-type';

package/tsconfig.json

@@ -0,0 +1,50 @@
+{
+    "compileOnSave": false,
+    "compilerOptions": {
+        "composite": true,
+        "declaration": true,
+        "declarationMap": true,
+        "pretty": true,
+        "moduleResolution": "node",
+        "target": "es6",
+        "downlevelIteration": true,
+        "esModuleInterop": true,
+        "sourceMap": false,
+        "noEmitOnError": false,
+        "experimentalDecorators": true,
+        "noUnusedParameters": true,
+        "noUnusedLocals": true,
+        "importHelpers": true,
+        "strictNullChecks": true,
+        "noImplicitAny": false,
+        "noImplicitThis": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "lib": [
+            "dom",
+            "dom.iterable",
+            "es2015",
+            "es2016",
+            "es2017",
+            "es2018",
+            "es2019",
+            "es2020",
+            "esnext.asynciterable"
+        ],
+        "typeRoots": [
+            "./node_modules/@types"
+        ],
+        "outDir": "./dist",
+        "baseUrl": ".",
+        "rootDir": "src"
+    },
+    "include": [
+        "./src/**/*.ts",
+        "./src/**/*.tsx"
+    ],
+    "exclude": [
+        "**/*.test.ts",
+        "**/*.test.tsx",
+        "**/test/*"
+    ]
+}