gio-miniprogram-sdk 4.0.0

package/src/core/uploader.ts

@@ -0,0 +1,219 @@
+import {
+  endsWith,
+  isArray,
+  isEmpty,
+  startsWith,
+  throttle,
+  toString,
+  unset
+} from '@@/utils/glodash';
+import { Event } from '@@/types/base';
+import { consoleText } from '@@/utils/tools';
+import { GrowingIOType } from '@@/types/growingIO';
+import { UploaderType } from '@@/types/uploader';
+
+class Uploader implements UploaderType {
+  // 因forceLogin配置积压的事件请求队列
+  public hoardingQueue: any[];
+  // 请求队列
+  public requestQueue: any[];
+  // 请求限制最大数
+  public requestLimit: number;
+  // 请求超时时间(ms)
+  public requestTimeout: number;
+  // 请求重试限制最大数
+  public retryLimit: number;
+  // 请求重试的原请求id
+  public retryIds: any;
+  // 请求中的请求数
+  public requestingNum: number;
+  // 请求地址
+  public requestURL: string;
+
+  constructor(public growingIO: GrowingIOType) {
+    this.hoardingQueue = [];
+    this.requestQueue = [];
+    this.requestLimit = 3;
+    this.requestTimeout = 5000;
+    this.retryLimit = 2;
+    this.retryIds = {};
+    this.requestingNum = 0;
+    this.requestURL = this.generateURL();
+  }
+
+  // 生成上报地址
+  generateURL = () => {
+    const { serverUrl, projectId } = this.growingIO.vdsConfig;
+    if (!startsWith(serverUrl, 'http')) {
+      return `https://${serverUrl}/v3/projects/${projectId}/collect`;
+    } else {
+      return `${serverUrl}/v3/projects/${projectId}/collect`;
+    }
+  };
+
+  // 提交请求（将请求按队列进行管理）
+  commitRequest = (reqData: Event) => {
+    const data: Event = { ...reqData };
+    const { vdsConfig } = this.growingIO;
+    // 如果开启forceLogin 则将请求推入积压队列，反之则进入请求队列
+    if (vdsConfig.forceLogin) {
+      this.hoardingQueue.push(data);
+    } else {
+      this.requestQueue.push(data);
+      this.initiateRequest();
+    }
+  };
+
+  // 发起请求
+  initiateRequest = (forceSend?: boolean) => {
+    const { plugins, vdsConfig } = this.growingIO;
+    // 同时请求数的限制，防止挤占小程序本身的业务请求
+    if (
+      [...this.hoardingQueue, ...this.requestQueue].length > 0 &&
+      this.requestingNum < this.requestLimit
+    ) {
+      // 淘宝云函数单发判断
+      if (vdsConfig?.tbConfig?.cloudFuncSend) {
+        plugins?.gioTaobaoAdapter?.singleInvoke();
+      } else if (forceSend) {
+        this.batchInvoke();
+      } else {
+        this.batchInvokeThrottle();
+      }
+    }
+  };
+
+  // 批量发送无延时(强制发送)
+  batchInvoke = () => {
+    const { vdsConfig, plugins, emitter } = this.growingIO;
+    let queues = [...this.hoardingQueue, ...this.requestQueue];
+    // 如果事件数大于50，剩下的切断放到下次请求
+    if (queues.length > 50) {
+      queues = queues.slice(0, 50);
+      // 如果积压队列超过50，只截取积压队列，剩下的下一次发
+      if (this.hoardingQueue.length > 50) {
+        this.hoardingQueue = this.hoardingQueue.slice(50);
+      } else {
+        // 如果积压队列小于50，正常的请求队列就只截取补满50后剩下的事件
+        this.hoardingQueue = [];
+        this.requestQueue = this.requestQueue.slice(
+          50 - this.hoardingQueue.length
+        );
+      }
+    } else {
+      this.hoardingQueue = [];
+      this.requestQueue = [];
+    }
+    // 过滤掉重试超过3次的请求(直接丢弃)
+    let eventsQueue: Event[] = queues.filter(
+      (o) => (this.retryIds[o.requestId] || 0) <= this.retryLimit
+    );
+    if (isEmpty(eventsQueue)) {
+      return;
+    }
+    // 生成新的请求事件（过滤事件中不能被上报的字段）
+    const requestData = eventsQueue.map((eData) => {
+      const rdata = { ...eData };
+      unset(rdata, 'requestId');
+      return rdata;
+    });
+    // 开启debug模式时，打印事件日志
+    if (vdsConfig.debug) {
+      console.log('[GrowingIO Debug]:', JSON.stringify(requestData, null, 2));
+    }
+    // 广播事件
+    emitter.emit('onSendBefore', { requestData });
+    if (vdsConfig?.tbConfig?.cloudAppId) {
+      plugins?.gioTaobaoAdapter?.tbCloudAppInvoke(requestData);
+    } else {
+      this.normalBatchInvoke(eventsQueue, requestData);
+    }
+  };
+
+  // 批量发送(1秒钟之内产生的请求只会组团发送一次)
+  batchInvokeThrottle = throttle(
+    this.batchInvoke,
+    this.growingIO.vdsConfig.uploadInterval,
+    false,
+    false
+  );
+
+  // 基础请求逻辑
+  normalBatchInvoke = (eventsQueue: any, requestData: any) => {
+    const { minipInstance, vdsConfig, emitter, plugins } = this.growingIO;
+    this.requestingNum += 1;
+    // 根据设置拼装最后请求数据
+    const header: any = {
+      // !!!京东小程序在7月4号的发版中，ios全匹配了application/json;导致我们的请求没法发出去，这里做一下兼容，等他们修复上线以后改回已注释的部分
+      // 'content-type': 'application/json;charset=UTF-8'
+      'content-type':
+        minipInstance.platform === 'jdp'
+          ? 'application/json'
+          : 'application/json;charset=UTF-8'
+    };
+    let compressData = [...requestData];
+    // 数据加密
+    const isCompress =
+      vdsConfig.compress && plugins?.gioCompress?.compressToUTF16;
+    if (isCompress) {
+      compressData = plugins.gioCompress.compressToUTF16(
+        JSON.stringify(requestData)
+      );
+      header['X-Compress-Codec'] = '1';
+    }
+    minipInstance.request({
+      url: `${this.requestURL}?stm=${Date.now()}&compress=${
+        isCompress ? '1' : '0'
+      }`,
+      header,
+      method: 'POST',
+      data: compressData,
+      timeout: this.requestTimeout,
+      fail: (result: any) => {
+        if (![200, 204].includes(result.code)) {
+          if (isArray(eventsQueue)) {
+            eventsQueue.forEach((o: any) => {
+              this.requestFailFn(o);
+            });
+          } else {
+            this.requestFailFn(eventsQueue);
+          }
+          consoleText(`请求失败!${JSON.stringify(result)}`, 'error');
+        }
+      },
+      complete: (args: any) => {
+        this.requestingNum -= 1;
+        emitter.emit('onSendAfter', { result: args });
+        this.initiateRequest();
+      }
+    });
+  };
+
+  // 请求失败的回调
+  requestFailFn = (eventsQueue: any) => {
+    // 把重试的请求进行计数，超过重试上限的会被丢弃
+    if (!this.retryIds[eventsQueue.requestId]) {
+      this.retryIds[eventsQueue.requestId] = 0;
+    }
+    this.retryIds[eventsQueue.requestId] += 1;
+    // 发送失败的事件会重新推入请求队列
+    const eventExist = this.requestQueue.some(
+      (o) => o.requestId === eventsQueue.requestId
+    );
+    if (!eventExist) {
+      // 延迟半秒后再推入请求队列，给网络一点恢复时间
+      let t = setTimeout(() => {
+        if (!isEmpty(this.requestQueue)) {
+          this.requestQueue.push(eventsQueue);
+        } else {
+          this.requestQueue.push(eventsQueue);
+          this.initiateRequest();
+        }
+        clearTimeout(t);
+        t = null;
+      }, 800);
+    }
+  };
+}
+
+export default Uploader;

package/src/core/userStore.ts

@@ -0,0 +1,203 @@
+import { GrowingIOType } from '@@/types/growingIO';
+import { UserStoreType } from '@@/types/userStore';
+import { batchGetStorageSync, batchSetStorageSync, guid } from '@@/utils/tools';
+
+/**
+ * 代码中与3.0测量协议字段对应关系
+ * 代码定义    |  3.0测量协议定义  |  字段解释
+ * ---------------------------------------------------
+ * sessionId  |  sessionId      |  访问会话id
+ * uid        |  deviceId       |  访问用户id(持久化)
+ * userId     |  userId         |  登录用户id(持久化)
+ * gioId      |  gioId          |  上一个非空的登录用户id(持久化)
+ */
+
+class UserStore implements UserStoreType {
+  // 访问用户id在存储中的名称
+  public uidStorageName: string;
+  // 登录用户id在存储中的名称
+  public userIdStorageName: string;
+  // 登录用户key在存储中的名称
+  public userKeyStorageName: string;
+  // 最后一次登录用户id在存储中的名称
+  public gioIdStorageName: string;
+  // 用户访问会话id
+  public _sessionId: string;
+  // 访问用户id（系统设置持久性存储）
+  public _uid: string;
+  // 登录用户id（客户设置持久性存储）
+  public _userId: string;
+  // 登录用户key（客户设置持久性存储）
+  public _userKey: string;
+  // 最后一次登录用户id（持久性存储）
+  public _gioId: string;
+  constructor(public growingIO: GrowingIOType) {
+    const { inPlugin } = this.growingIO;
+    this.uidStorageName = inPlugin ? '_growing_plugin_uid_' : '_growing_uid_';
+    this.userIdStorageName = inPlugin
+      ? '_growing_plugin_userId_'
+      : '_growing_userId_';
+    this.userKeyStorageName = inPlugin
+      ? '_growing_plugin_userKey_'
+      : '_growing_userKey_';
+    this.gioIdStorageName = inPlugin
+      ? '_growing_plugin_gioId_'
+      : '_growing_gioId_';
+    this._sessionId = guid();
+    this._uid = undefined;
+    this._userId = undefined;
+    this._userKey = undefined;
+    this._gioId = undefined;
+    if (this.growingIO?.gioPlatform !== 'quickapp') {
+      this.initUserInfo();
+    }
+  }
+
+  // @ts-ignore
+  get sessionId() {
+    if (!this._sessionId) {
+      this._sessionId = guid();
+    }
+    return this._sessionId;
+  }
+
+  // @ts-ignore
+  set sessionId(id: string) {
+    const prevId = this._sessionId;
+    if (!id) {
+      this._sessionId = guid();
+    } else {
+      this._sessionId = id;
+    }
+    // 广播通知登录sessionId变更
+    if (prevId !== this._sessionId) {
+      this.growingIO.emitter.emit('SESSIONID_UPDATE', {
+        newSessionId: this._sessionId,
+        oldSessionId: prevId
+      });
+    }
+  }
+
+  // @ts-ignore
+  get uid() {
+    return this._uid;
+  }
+
+  // @ts-ignore
+  set uid(id: string) {
+    const prevId = this._uid;
+    this._uid = id;
+    if (prevId !== this._uid) {
+      this.growingIO.minipInstance.setStorage(this.uidStorageName, this._uid);
+      // 广播通知访问用户Id变更
+      this.growingIO.emitter.emit('UID_UPDATE', {
+        newUId: id,
+        oldUId: prevId
+      });
+    }
+  }
+
+  // @ts-ignore
+  get userId() {
+    return this._userId;
+  }
+
+  // @ts-ignore
+  set userId(id: string) {
+    const prevId = this._userId;
+    this._userId = id;
+    if (prevId !== this._userId) {
+      this.growingIO.minipInstance.setStorage(
+        this.userIdStorageName,
+        this._userId
+      );
+      // 广播通知登录用户Id变更
+      this.growingIO.emitter.emit('USERID_UPDATE', {
+        newUserId: id,
+        oldUserId: prevId
+      });
+    }
+    if (id) this.gioId = id;
+  }
+
+  // @ts-ignore
+  get userKey() {
+    return this._userKey;
+  }
+
+  // @ts-ignore
+  set userKey(key: string) {
+    const prevKey = this._userKey;
+    this._userKey = key;
+    if (prevKey !== this._userKey) {
+      this.growingIO.minipInstance.setStorage(
+        this.userKeyStorageName,
+        this._userKey
+      );
+      // 广播通知登录用户key变更
+      this.growingIO.emitter.emit('USERKEY_UPDATE', {
+        newUserKey: key,
+        oldUserKey: prevKey
+      });
+    }
+  }
+
+  // @ts-ignore
+  get gioId() {
+    return this._gioId;
+  }
+
+  // @ts-ignore
+  set gioId(gioId: string) {
+    const prevId = this._gioId;
+    this._gioId = gioId;
+    if (prevId !== this._gioId) {
+      this.growingIO.minipInstance.setStorage(
+        this.gioIdStorageName,
+        this._gioId
+      );
+      // 广播通知登录用户Id变更
+      this.growingIO.emitter.emit('GIOID_UPDATE', {
+        newGioId: gioId,
+        oldGioId: prevId
+      });
+    }
+  }
+
+  // 初始化用户信息
+  initUserInfo = () => {
+    const { minipInstance } = this.growingIO;
+    const storeKeys = [
+      this.uidStorageName,
+      this.userIdStorageName,
+      this.userKeyStorageName,
+      this.gioIdStorageName
+    ];
+    const memoryKeys = ['_uid', '_userId', '_userKey', '_gioId'];
+    // 批量获取的存储数据
+    const values = batchGetStorageSync(minipInstance, storeKeys) ?? [];
+    // 往存储中重设的key
+    memoryKeys.forEach((key: string, index: number) => {
+      // 往内存中赋值
+      this[key] = values[index];
+      // 如果uid没有值，则自动生成并赋值（这种情况是用户第一次进或者清了缓存）
+      if (key === '_uid' && !this[key]) {
+        // this.uid会自动给内存和存储都赋值
+        this.uid = guid();
+      }
+    });
+  };
+
+  // 退出小程序时在存储中同步用户信息
+  saveUserInfo = () => {
+    const { minipInstance } = this.growingIO;
+    batchSetStorageSync(minipInstance, [
+      { key: this.uidStorageName, value: this.uid },
+      { key: this.userIdStorageName, value: this.userId },
+      { key: this.userKeyStorageName, value: this.userKey },
+      { key: this.gioIdStorageName, value: this.gioId }
+    ]);
+  };
+}
+
+export default UserStore;

package/src/index.ts

@@ -0,0 +1,68 @@
+import {
+  initPreCheck,
+  paramExtraCheck,
+  paramsBaseCheck,
+  paramsEmptyCheck
+} from '@@/utils/verifiers';
+import { consoleText, getGlobal, niceTry } from '@@/utils/tools';
+import { drop, isString, toString } from '@@/utils/glodash';
+import { HANDLERS, DEPRECATED_HANDLERS } from '@@/constants/config';
+import GrowingIO from './core/growingIO';
+
+const gioInstance: any = new GrowingIO();
+
+const gdp = function () {
+  const actionName = arguments[0];
+  // 判断指令为字符串且配置项中允许调用且实例中存在的方法
+  if (
+    isString(actionName) &&
+    HANDLERS.includes(actionName) &&
+    gioInstance[actionName]
+  ) {
+    const args = drop(Array.from(arguments));
+    // 初始化方法单独处理
+    if (actionName === 'init') {
+      const preCheckRes = initPreCheck(gioInstance);
+      const emptyCheckRes = paramsEmptyCheck(args);
+      const baseCheckRes = paramsBaseCheck(args);
+      const extraCheckRes = paramExtraCheck(args);
+      if (preCheckRes && emptyCheckRes && baseCheckRes && extraCheckRes) {
+        const { projectId } = baseCheckRes;
+        const { dataSourceId, appId, options } = extraCheckRes;
+        return gioInstance.init({
+          ...options,
+          projectId,
+          dataSourceId,
+          appId
+        });
+      }
+    } else if (actionName === 'registerPlugins') {
+      gioInstance.registerPlugins(args[0]);
+    } else if (gioInstance.gioSDKInitialized && gioInstance.vdsConfig) {
+      return gioInstance[actionName](...args);
+    } else {
+      consoleText('SDK未初始化!', 'error');
+    }
+  } else if (DEPRECATED_HANDLERS.includes(actionName)) {
+    consoleText(`方法 ${toString(actionName)} 已被弃用!`, 'warn');
+  } else {
+    consoleText(`不存在名为 ${toString(actionName)} 的方法调用!`, 'error');
+  }
+};
+
+getGlobal().gdp = gdp;
+getGlobal().gioSDKVersion = gioInstance.sdkVersion;
+
+export const GioApp = niceTry(
+  () => gioInstance.dataStore.eventHooks.growingApp ?? App
+);
+export const GioPage = niceTry(
+  () => gioInstance.dataStore.eventHooks.growingPage ?? Page
+);
+export const GioComponent = niceTry(
+  () => gioInstance.dataStore.eventHooks.growingComponent ?? Component
+);
+export const GioBehavior = niceTry(
+  () => gioInstance.dataStore.eventHooks.growingBehavior ?? Behavior
+);
+export default gdp;