@ones-open/node-sdk 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -1,4 +1,540 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const ONES = "ONES";
-exports.ONES = ONES;
+const _defineProperty = require("@babel/runtime-corejs3/helpers/defineProperty");
+const lodashEs = require("lodash-es");
+const Fetch = require("axios");
+const _sortInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/sort");
+const getPlatformApiHost = () => {
+  return "platformApiHost";
+};
+const getPlatformAPIHost = getPlatformApiHost;
+const getInstanceId = () => {
+  return "instanceId";
+};
+const getApplicationId = () => {
+  return "applicationId";
+};
+const getAppId = getApplicationId;
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getAppId,
+  getApplicationId,
+  getInstanceId,
+  getPlatformAPIHost,
+  getPlatformApiHost
+}, Symbol.toStringTag, { value: "Module" }));
+var EntityWhereConditionEnum = /* @__PURE__ */ ((EntityWhereConditionEnum2) => {
+  EntityWhereConditionEnum2["beginsWith"] = "beginsWith";
+  EntityWhereConditionEnum2["between"] = "between";
+  EntityWhereConditionEnum2["equalTo"] = "equalTo";
+  EntityWhereConditionEnum2["greaterThan"] = "greaterThan";
+  EntityWhereConditionEnum2["lessThan"] = "lessThan";
+  EntityWhereConditionEnum2["greaterThanEqualTo"] = "greaterThanEqualTo";
+  EntityWhereConditionEnum2["lessThanEqualTo"] = "lessThanEqualTo";
+  EntityWhereConditionEnum2["containsAny"] = "containsAny";
+  return EntityWhereConditionEnum2;
+})(EntityWhereConditionEnum || {});
+const WhereConditions = {
+  /**
+   * @description beginsWith
+   * @returns EntityWhereCondition
+   */
+  [EntityWhereConditionEnum.beginsWith]: (value) => {
+    return {
+      [EntityWhereConditionEnum.beginsWith]: [value]
+    };
+  },
+  /**
+   * @description between
+   * @returns EntityWhereCondition
+   */
+  [EntityWhereConditionEnum.between]: (min, max) => {
+    return {
+      [EntityWhereConditionEnum.between]: [min, max]
+    };
+  },
+  /**
+   * @description equalTo
+   * @returns EntityWhereCondition
+   */
+  [EntityWhereConditionEnum.equalTo]: (value) => {
+    return {
+      [EntityWhereConditionEnum.equalTo]: [value]
+    };
+  },
+  /**
+   * @description greaterThan
+   * @returns EntityWhereCondition
+   */
+  [EntityWhereConditionEnum.greaterThan]: (value) => {
+    return {
+      [EntityWhereConditionEnum.greaterThan]: [value]
+    };
+  },
+  /**
+   * @description lessThan
+   * @returns EntityWhereCondition
+   */
+  [EntityWhereConditionEnum.lessThan]: (value) => {
+    return {
+      [EntityWhereConditionEnum.lessThan]: [value]
+    };
+  },
+  /**
+   * @description greaterThanEqualTo
+   * @returns EntityWhereCondition
+   */
+  [EntityWhereConditionEnum.greaterThanEqualTo]: (value) => {
+    return {
+      [EntityWhereConditionEnum.greaterThanEqualTo]: [value]
+    };
+  },
+  /**
+   * @description lessThanEqualTo
+   * @returns EntityWhereCondition
+   */
+  [EntityWhereConditionEnum.lessThanEqualTo]: (value) => {
+    return {
+      [EntityWhereConditionEnum.lessThanEqualTo]: [value]
+    };
+  },
+  /**
+   * @description containsAny
+   * @returns EntityWhereCondition
+   */
+  [EntityWhereConditionEnum.containsAny]: function() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return {
+      [EntityWhereConditionEnum.containsAny]: [...args]
+    };
+  }
+};
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["ServerError"] = "ServerError";
+  ErrorCode2["UnknownError"] = "UnknownError";
+  return ErrorCode2;
+})(ErrorCode || {});
+const createErrorResult = (code, message, error) => {
+  return Object.assign({}, {
+    code,
+    err_msg: `${message}`
+  }, error);
+};
+const fetch$1 = Fetch.create();
+const fetchBase$1 = (path, params, config) => {
+  return Promise.all([getPlatformAPIHost(), getInstanceId()]).then((_ref) => {
+    let [base, instance_id] = _ref;
+    if (base && instance_id) {
+      const url = `${base}${path}`;
+      const data = {
+        ...params,
+        instance_id
+      };
+      return fetch$1({
+        ...config,
+        url,
+        data
+      });
+    }
+    throw new Error(JSON.stringify({
+      base,
+      instance_id
+    }));
+  }).then((response) => {
+    return response.data;
+  }).catch((error) => {
+    if (error instanceof Fetch.AxiosError) {
+      const $error = error;
+      const data = $error.response.data;
+      if (data.code) {
+        return data;
+      }
+    }
+    const message = createErrorResult(ErrorCode.ServerError, error);
+    return message;
+  });
+};
+const fetchPost = (params) => {
+  return fetchBase$1("/plugin_ability_fetch/storage/entity_data", params, {
+    method: "post"
+  });
+};
+const fetchDelete$1 = (params) => {
+  return fetchBase$1("/plugin_ability_fetch/storage/entity_data", params, {
+    method: "delete"
+  });
+};
+const fetchQuery = (params) => {
+  return fetchBase$1("/plugin_ability_fetch/storage/entity_data/get_many", params, {
+    method: "post"
+  });
+};
+const fetchCount = (params) => {
+  return fetchBase$1("/plugin_ability_fetch/storage/entity_data/count", params, {
+    method: "post"
+  });
+};
+const defaultEntityQuery = {
+  cursor: Symbol("cursor"),
+  limit: Symbol("limit"),
+  sort: Symbol("sort"),
+  index: Symbol("index"),
+  where: Symbol("where")
+};
+const defaultEntityQueryCursor = defaultEntityQuery.cursor;
+const defaultEntityQueryLimit = defaultEntityQuery.limit;
+const defaultEntityQuerySort = _sortInstanceProperty(defaultEntityQuery);
+const defaultEntityQueryIndex = defaultEntityQuery.index;
+const defaultEntityQueryWhere = defaultEntityQuery.where;
+class EntityQueryClass {
+  constructor(name) {
+    _defineProperty(this, "_name", "");
+    _defineProperty(this, "_cursor", [defaultEntityQueryCursor]);
+    _defineProperty(this, "_limit", [defaultEntityQueryLimit]);
+    _defineProperty(this, "_sort", [defaultEntityQuerySort]);
+    _defineProperty(this, "_index", [defaultEntityQueryIndex]);
+    _defineProperty(this, "_where", [defaultEntityQueryWhere]);
+    this._name = name;
+  }
+  cursor(cursor) {
+    this._cursor = [cursor];
+    return this;
+  }
+  limit(limit) {
+    this._limit = [limit];
+    return this;
+  }
+  sort(sort) {
+    this._sort = [sort];
+    return this;
+  }
+  index(index2, partitions) {
+    if (typeof index2 === "string") {
+      if (partitions) {
+        this._index = [index2, partitions];
+        return this;
+      }
+    }
+    this._index = [index2];
+    return this;
+  }
+  where(where) {
+    this._where = [where];
+    return this;
+  }
+  _getParams() {
+    const data = {
+      index: {}
+    };
+    const array = [[this._cursor[0], "after_cursor"], [this._limit[0], "limit"], [this._sort[0], "sort"], [this._index[0], "index.name"], [this._index[1], "index.partition_values"], [this._where[0], "where"]];
+    array.forEach((item) => {
+      const [value, path] = item;
+      if (lodashEs.isNull(value) || lodashEs.isUndefined(value) || lodashEs.isSymbol(value))
+        ;
+      else {
+        lodashEs.set(data, path, value);
+      }
+    });
+    const result = {
+      entity_name: this._name,
+      data
+    };
+    return result;
+  }
+  async getOne() {
+    const params = this._getParams();
+    params.data.limit = 1;
+    const result = await fetchQuery(params);
+    const {
+      code,
+      data
+    } = result;
+    if (code === "OK") {
+      var _data$data;
+      return data === null || data === void 0 || (_data$data = data.data) === null || _data$data === void 0 ? void 0 : _data$data[0];
+    }
+    throw result;
+  }
+  async getMany() {
+    const params = this._getParams();
+    const result = await fetchQuery(params);
+    const {
+      code,
+      data
+    } = result;
+    if (code === "OK") {
+      if (data) {
+        return data;
+      }
+    }
+    throw result;
+  }
+  async count() {
+    const params = this._getParams();
+    const result = await fetchCount(params);
+    const {
+      code,
+      data
+    } = result;
+    if (code === "OK") {
+      const number = data === null || data === void 0 ? void 0 : data.count;
+      if (typeof number === "number") {
+        return number;
+      }
+    }
+    throw result;
+  }
+}
+class EntityClass {
+  constructor(name) {
+    _defineProperty(this, "_name", "");
+    this._name = name;
+  }
+  async get(key) {
+    const query = this.query();
+    return await query.index(defaultEntityQueryIndex).where(WhereConditions.equalTo(key)).getOne().then((data) => {
+      return data === null || data === void 0 ? void 0 : data.value;
+    });
+  }
+  async set(key, value) {
+    const item = {
+      key,
+      value
+    };
+    await this.batchSet([item]);
+  }
+  async delete(key) {
+    await this.batchDelete([key]);
+  }
+  query() {
+    return new EntityQueryClass(this._name);
+  }
+  async batchSet(items) {
+    const result = await fetchPost({
+      entity_name: this._name,
+      data: items
+    });
+    const {
+      code
+    } = result;
+    if (code !== "OK") {
+      throw result;
+    }
+  }
+  async batchDelete(keys) {
+    const result = await fetchDelete$1({
+      entity_name: this._name,
+      data: keys
+    });
+    const {
+      code
+    } = result;
+    if (code !== "OK") {
+      throw result;
+    }
+  }
+}
+var EntitySortEnum = /* @__PURE__ */ ((EntitySortEnum2) => {
+  EntitySortEnum2["ASC"] = "ASC";
+  EntitySortEnum2["DESC"] = "DESC";
+  return EntitySortEnum2;
+})(EntitySortEnum || {});
+var EntityErrorCode = /* @__PURE__ */ ((EntityErrorCode2) => {
+  EntityErrorCode2["EntityNameInvalid"] = "EntityNameInvalid";
+  EntityErrorCode2["EntityNotFound"] = "EntityNotFound";
+  EntityErrorCode2["EntityDataEmpty"] = "EntityDataEmpty";
+  EntityErrorCode2["EntityDataBatchLimit"] = "EntityDataBatchLimit";
+  EntityErrorCode2["EntityDataKeyInvalid"] = "EntityDataKeyInvalid";
+  EntityErrorCode2["EntityDataKeyDuplicate"] = "EntityDataKeyDuplicate";
+  EntityErrorCode2["EntityDataValueAttrInvalid"] = "EntityDataValueAttrInvalid";
+  EntityErrorCode2["EntityDataValueAttrNotFound"] = "EntityDataValueAttrNotFound";
+  EntityErrorCode2["EntityDataValueEmpty"] = "EntityDataValueEmpty";
+  EntityErrorCode2["EntityDataValueInvalid"] = "EntityDataValueInvalid";
+  EntityErrorCode2["EntityDataStringValueTooLong"] = "EntityDataStringValueTooLong";
+  EntityErrorCode2["EntityDataTextValueTooLong"] = "EntityDataTextValueTooLong";
+  EntityErrorCode2["EntityDataAttrRequired"] = "EntityDataAttrRequired";
+  EntityErrorCode2["EntityDataValueTypeInvalid"] = "EntityDataValueTypeInvalid";
+  EntityErrorCode2["EntityDataIndexEmpty"] = "EntityDataIndexEmpty";
+  EntityErrorCode2["EntityDataIndexNameInvalid"] = "EntityDataIndexNameInvalid";
+  EntityErrorCode2["EntityDataIndexNotFound"] = "EntityDataIndexNotFound";
+  EntityErrorCode2["EntityDataPartitionValueInvalid"] = "EntityDataPartitionValueInvalid";
+  EntityErrorCode2["EntityDataPartitionValueTypeInvalid"] = "EntityDataPartitionValueTypeInvalid";
+  EntityErrorCode2["EntityDataPartitionValueTooLong"] = "EntityDataPartitionValueTooLong";
+  EntityErrorCode2["EntityDataUniqueConstraintFailed"] = "EntityDataUniqueConstraintFailed";
+  EntityErrorCode2["EntityDataWhereConditionValueTypeInvalid"] = "EntityDataWhereConditionValueTypeInvalid";
+  EntityErrorCode2["EntityDataWhereConditionValueTooLong"] = "EntityDataWhereConditionValueTooLong";
+  EntityErrorCode2["EntityDataPageCursorInvalid"] = "EntityDataPageCursorInvalid";
+  EntityErrorCode2["EntityDataSortValueInvalid"] = "EntityDataSortValueInvalid";
+  EntityErrorCode2["EntityDataPageLimitNotInRange"] = "EntityDataPageLimitNotInRange";
+  EntityErrorCode2["EntityDataAPITimeOut"] = "EntityDataAPITimeOut";
+  EntityErrorCode2["MalformedJSON"] = "Malformed.JSON";
+  return EntityErrorCode2;
+})(EntityErrorCode || {});
+const entityStatic = {
+  Sort: EntitySortEnum,
+  EntityErrorCode,
+  WhereConditions,
+  defaultEntityQueryCursor,
+  defaultEntityQueryIndex,
+  defaultEntityQueryLimit,
+  defaultEntityQuerySort,
+  defaultEntityQueryWhere
+};
+function factory(entityName) {
+  return new EntityClass(entityName);
+}
+const entityFactory = factory;
+const entityDefault = Object.assign(entityFactory, entityStatic);
+const entity = entityDefault;
+var ObjectErrorCode = /* @__PURE__ */ ((ObjectErrorCode2) => {
+  ObjectErrorCode2["ObjectKeyInvalid"] = "ObjectKeyInvalid";
+  ObjectErrorCode2["ObjectKeyNotfound"] = "ObjectKeyNotfound";
+  ObjectErrorCode2["RequestTimeOut"] = "RequestTimeOut";
+  return ObjectErrorCode2;
+})(ObjectErrorCode || {});
+class ObjectError {
+  /**
+   * @description 错误载荷
+   */
+  constructor(result) {
+    _defineProperty(this, "err_msg", "");
+    this.code = result.code;
+    this.err_msg = result.err_msg;
+    this.err_values = result.err_values;
+  }
+}
+const fetch = Fetch.create();
+const fetchBase = (path, params) => {
+  return Promise.all([getPlatformAPIHost(), getInstanceId()]).then((_ref) => {
+    let [base, instance_id] = _ref;
+    if (base && instance_id) {
+      const url = `${base}${path}`;
+      const data = {
+        ...params,
+        instance_id
+      };
+      return fetch.post(url, data);
+    }
+    throw new Error(JSON.stringify({
+      base,
+      instance_id
+    }));
+  }).then((response) => {
+    return response.data;
+  }).catch((error) => {
+    if (error instanceof Fetch.AxiosError) {
+      const $error = error;
+      const data = $error.response.data;
+      if (data.code) {
+        return data;
+      }
+    }
+    const message = createErrorResult(ErrorCode.ServerError, error);
+    return message;
+  });
+};
+const fetchUpload = (params) => {
+  return fetchBase("/plugin_ability_fetch/storage/object/get_upload_policy_info", params);
+};
+const fetchDownload = (params) => {
+  return fetchBase("/plugin_ability_fetch/storage/object/get_download_pre_signed_url", params);
+};
+const fetchDelete = (params) => {
+  return fetchBase("/plugin_ability_fetch/storage/object/delete", params);
+};
+const fetchMetadata = (params) => {
+  return fetchBase("/plugin_ability_fetch/storage/object/get_metadata", params);
+};
+const object = {
+  ObjectError,
+  ObjectErrorCode,
+  upload: async (key) => {
+    const result = await fetchUpload({
+      object_key: key
+    });
+    if (result.code === "OK") {
+      if (result.data) {
+        const {
+          url,
+          fields
+        } = result.data;
+        const {
+          internal,
+          outbound
+        } = url;
+        if (internal && outbound) {
+          return {
+            getUrl: () => internal,
+            getWebUrl: () => outbound,
+            getFields: () => ({
+              ...fields
+            })
+          };
+        }
+      }
+      return new ObjectError(createErrorResult(ErrorCode.ServerError, "", {
+        err_values: result
+      }));
+    }
+    return new ObjectError(result);
+  },
+  download: async (key) => {
+    const result = await fetchDownload({
+      object_key: key
+    });
+    if (result.code === "OK") {
+      if (result.data) {
+        const {
+          url
+        } = result.data;
+        const {
+          internal,
+          outbound
+        } = url;
+        if (internal && outbound) {
+          return {
+            getUrl: () => internal,
+            getWebUrl: () => outbound
+          };
+        }
+      }
+      return new ObjectError(createErrorResult(ErrorCode.ServerError, "", {
+        err_values: result
+      }));
+    }
+    return new ObjectError(result);
+  },
+  delete: async (key) => {
+    const result = await fetchDelete({
+      object_key: key
+    });
+    if (result.code === "OK") {
+      return;
+    }
+    return new ObjectError(result);
+  },
+  metadata: async (key) => {
+    const result = await fetchMetadata({
+      object_key: key
+    });
+    if (result.code === "OK") {
+      if (result.data) {
+        return result.data;
+      }
+      return new ObjectError(createErrorResult(ErrorCode.ServerError, "", {
+        err_values: result
+      }));
+    }
+    return new ObjectError(result);
+  }
+};
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  entity,
+  object
+}, Symbol.toStringTag, { value: "Module" }));
+exports.ErrorCode = ErrorCode;
+exports.env = index$1;
+exports.storage = index;