@tachybase/plugin-data-source-common 0.23.8

package/dist/server/http/services/http-collection.js

@@ -0,0 +1,270 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_collection_exports = {};
+__export(http_collection_exports, {
+  HttpCollection: () => HttpCollection
+});
+module.exports = __toCommonJS(http_collection_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_utils = require("@tachybase/utils");
+var import_axios = __toESM(require("axios"));
+var import_lodash = __toESM(require("lodash"));
+var import_transform_response = require("./transform-response");
+var import_type_interface_map = require("./type-interface-map");
+var import_utils2 = require("./utils");
+function compileTemplate(template, context) {
+  return (0, import_utils.parse)(template)(context);
+}
+function mergeRequestOptions(options) {
+  const { baseRequestConfig, actionOptions, templateContext = {} } = options;
+  const rawConfig = {
+    method: actionOptions.method,
+    url: actionOptions.path,
+    baseURL: baseRequestConfig.baseUrl,
+    headers: {
+      ...baseRequestConfig.headers,
+      ...actionOptions.headers
+    },
+    params: actionOptions.params,
+    data: null
+  };
+  if (actionOptions.body) {
+    rawConfig.data = actionOptions.body;
+  }
+  if (actionOptions.contentType) {
+    rawConfig.headers["Content-Type"] = actionOptions.contentType;
+  }
+  if (actionOptions.contentType === "application/x-www-form-urlencoded") {
+    rawConfig.data = (0, import_utils2.normalizeRequestOptionsKey)(rawConfig.data);
+  }
+  const config = compileTemplate(rawConfig, templateContext);
+  if (templateContext.values && !rawConfig.data) {
+    config.data = templateContext.values;
+  }
+  if (actionOptions.contentType === "application/x-www-form-urlencoded") {
+    config.data = new URLSearchParams(config.data).toString();
+  }
+  return config;
+}
+function buildTemplateContext(options) {
+  const { dataSourceRequestConfig, templateContext, debugVars = {} } = options;
+  const variables = {
+    dataSourceVariables: dataSourceRequestConfig.variables || {}
+  };
+  for (const variableKey of Object.keys(variables)) {
+    templateContext[variableKey] = variables[variableKey];
+  }
+  for (const variableKey of Object.keys(debugVars)) {
+    if (variableKey === "body") {
+      import_lodash.default.set(templateContext, ["request", "body"], debugVars[variableKey]);
+    } else {
+      import_lodash.default.set(templateContext, ["request", "params", variableKey], debugVars[variableKey]);
+    }
+  }
+  if (templateContext.values && !import_lodash.default.get(templateContext, "request.body")) {
+    templateContext.body = templateContext.values;
+    import_lodash.default.set(templateContext, "request.body", templateContext.values);
+  }
+}
+function rawTypeToFieldType(rawType, exampleValue) {
+  const typeInfers = {
+    string: "string",
+    number: () => {
+      if (Number.isInteger(exampleValue)) {
+        return "integer";
+      }
+      return "float";
+    },
+    boolean: "boolean",
+    object: () => {
+      if (import_lodash.default.isNull(exampleValue)) {
+        return ["string", "integer", "float", "boolean", "json"];
+      }
+      return "json";
+    }
+  };
+  const inferType = typeInfers[rawType];
+  if (typeof inferType === "function") {
+    return inferType();
+  }
+  return inferType;
+}
+function getInterfaceOptionsByType(type) {
+  const interfaceConfig = import_type_interface_map.typeInterfaceMap[type];
+  if (typeof interfaceConfig === "function") {
+    return interfaceConfig();
+  } else {
+    return interfaceConfig;
+  }
+}
+function parseResponseToFieldsOptions(responseData) {
+  let objectItem = {};
+  if (Array.isArray(responseData)) {
+    objectItem = responseData[0];
+  }
+  if (import_lodash.default.isPlainObject(responseData)) {
+    objectItem = responseData;
+  }
+  return Object.keys(objectItem).map((key) => {
+    const rawType = typeof objectItem[key];
+    const inferredFieldType = rawTypeToFieldType(rawType, objectItem[key]);
+    let fieldOptions = {
+      name: key,
+      rawType,
+      title: key,
+      field: key
+    };
+    let fieldType = inferredFieldType;
+    if (Array.isArray(inferredFieldType)) {
+      fieldType = inferredFieldType[0];
+      fieldOptions["possibleTypes"] = inferredFieldType;
+    }
+    fieldOptions = {
+      ...fieldOptions,
+      type: fieldType,
+      ...getInterfaceOptionsByType(fieldType)
+    };
+    import_lodash.default.set(fieldOptions, "uiSchema.title", key);
+    return fieldOptions;
+  });
+}
+function guessFilterTargetKeyName(fields) {
+  const keyNames = ["id", "nodeId", "node_id"];
+  for (const keyName of keyNames) {
+    if (fields.find((field) => field.field === keyName)) {
+      return keyName;
+    }
+  }
+  return void 0;
+}
+class HttpCollection extends import_data_source.Collection {
+  availableActions() {
+    const allActionOptions = this.options.actions || {};
+    const actions = ["list", "get", "create", "update", "destroy"];
+    return actions.filter((action) => allActionOptions[action]);
+  }
+  // send http request to external server
+  static async runAction(options) {
+    const { dataSource, actionOptions, templateContext = {}, parseField, debugVars, runAsDebug } = options;
+    (0, import_utils2.normalizeRequestOptions)(actionOptions);
+    const dataSourceRequestConfig = dataSource.requestConfig();
+    buildTemplateContext({
+      dataSourceRequestConfig,
+      templateContext,
+      debugVars
+    });
+    const requestConfig = mergeRequestOptions({
+      baseRequestConfig: dataSourceRequestConfig,
+      actionOptions,
+      templateContext
+    });
+    if (runAsDebug) {
+      requestConfig.validateStatus = () => true;
+    }
+    const handleResponse = (response2) => {
+      if (parseField && response2.transformedResponse.data) {
+        response2.fields = parseResponseToFieldsOptions(response2.transformedResponse.data);
+        const filterTargetKeyName = guessFilterTargetKeyName(response2.fields);
+        if (filterTargetKeyName) {
+          response2.filterTargetKey = filterTargetKeyName;
+        }
+      }
+      if (options.runAsDebug && !response2.responseValidationErrorMessage) {
+        response2.debugBody = response2.transformedResponse;
+      }
+      return response2;
+    };
+    const response = await import_axios.default.request(requestConfig).catch((error) => {
+      throw new Error(`Failed to request external http datasource`, { cause: error });
+    });
+    const clientRequest = response.request;
+    const baseResponse = {
+      rawResponse: {
+        status: response.status,
+        headers: response.headers,
+        data: response.data,
+        body: response.data,
+        request: {
+          url: import_axios.default.getUri(requestConfig),
+          method: clientRequest.method,
+          headers: response.request.getHeaders()
+        }
+      },
+      data: null
+    };
+    const transformResponse = (baseResponse2, actionOptions2) => {
+      const transformer = actionOptions2.responseTransformer;
+      baseResponse2.transformedResponse = compileTemplate(transformer, {
+        rawResponse: baseResponse2.rawResponse
+      });
+      try {
+        (0, import_transform_response.transformResponseThroughMiddleware)({
+          transformedResponse: baseResponse2.transformedResponse,
+          actionOptions: actionOptions2,
+          templateContext
+        });
+      } catch (e) {
+        if (options.runAsDebug) {
+          baseResponse2.responseValidationErrorMessage = e.message;
+        } else {
+          throw e;
+        }
+      }
+    };
+    transformResponse(baseResponse, actionOptions);
+    dataSource.logger.debug({
+      actionOptions,
+      requestConfig,
+      baseResponse
+    });
+    return handleResponse(baseResponse);
+  }
+  getActionOptions(action) {
+    const allActionOptions = this.options.actions || {};
+    const actionOption = allActionOptions[action];
+    if (!actionOption) {
+      throw new Error(`request config of action "${action}" is not set`);
+    }
+    return actionOption;
+  }
+  runAction(action, templateContext) {
+    const actionOptions = this.getActionOptions(action);
+    return HttpCollection.runAction({
+      actionOptions: {
+        ...actionOptions,
+        type: action
+      },
+      dataSource: this.collectionManager.dataSource,
+      templateContext
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpCollection
+});

package/dist/server/http/services/http-data-source.d.ts

@@ -0,0 +1,10 @@
+import { DataSource } from '@tachybase/data-source';
+import { HttpCollectionManager } from './http-collection-manager';
+export declare class HttpDataSource extends DataSource {
+    load(options?: {
+        localData?: any;
+    }): Promise<void>;
+    createCollectionManager(options: any): HttpCollectionManager;
+    requestConfig(): Pick<any, string>;
+    publicOptions(): Pick<any, "variables" | "baseUrl">;
+}

package/dist/server/http/services/http-data-source.js

@@ -0,0 +1,67 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_data_source_exports = {};
+__export(http_data_source_exports, {
+  HttpDataSource: () => HttpDataSource
+});
+module.exports = __toCommonJS(http_data_source_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_lodash = __toESM(require("lodash"));
+var import_http_api_repository = require("./http-api-repository");
+var import_http_collection_manager = require("./http-collection-manager");
+var import_utils = require("./utils");
+class HttpDataSource extends import_data_source.DataSource {
+  async load(options = {}) {
+    const { localData } = options;
+    for (const collectionName of Object.keys(localData)) {
+      this.collectionManager.defineCollection(localData[collectionName]);
+    }
+  }
+  createCollectionManager(options) {
+    const collectionManager = new import_http_collection_manager.HttpCollectionManager({
+      dataSource: this
+    });
+    collectionManager.registerRepositories({
+      Repository: import_http_api_repository.HttpApiRepository
+    });
+    return collectionManager;
+  }
+  requestConfig() {
+    const configKeys = ["baseUrl", "headers", "variables", "timeout", "responseType"];
+    const config = import_lodash.default.pick(this.options, configKeys);
+    (0, import_utils.normalizeRequestOptions)(config);
+    return config;
+  }
+  publicOptions() {
+    return import_lodash.default.pick(this.options, ["baseUrl", "variables"]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpDataSource
+});

package/dist/server/http/services/http-request-builder.d.ts

@@ -0,0 +1,3 @@
+export declare class HttpRequestBuilder {
+    constructor(dataSource: any);
+}

package/dist/server/http/services/http-request-builder.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_request_builder_exports = {};
+__export(http_request_builder_exports, {
+  HttpRequestBuilder: () => HttpRequestBuilder
+});
+module.exports = __toCommonJS(http_request_builder_exports);
+class HttpRequestBuilder {
+  constructor(dataSource) {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpRequestBuilder
+});

package/dist/server/http/services/transform-response.d.ts

@@ -0,0 +1 @@
+export declare function transformResponseThroughMiddleware(options: any): void;

package/dist/server/http/services/transform-response.js

@@ -0,0 +1,185 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transform_response_exports = {};
+__export(transform_response_exports, {
+  transformResponseThroughMiddleware: () => transformResponseThroughMiddleware
+});
+module.exports = __toCommonJS(transform_response_exports);
+var import_database = require("@tachybase/database");
+var import_lodash = __toESM(require("lodash"));
+const middlewares = {
+  list: [
+    function validateListActionTransformedResponse(options) {
+      const { transformedResponse } = options;
+      const dataItem = import_lodash.default.get(transformedResponse, "data");
+      if (!Array.isArray(dataItem)) {
+        throw new Error(
+          `The transformed response for the list action should be an array. got ${getValueType(dataItem)}`
+        );
+      }
+      if (!dataItem.every((item) => import_lodash.default.isPlainObject(item))) {
+        throw new Error("Every item in the transformed response should be an object");
+      }
+    },
+    function handleFilter(options) {
+      if (checkVariablesAreUsed(options.actionOptions, ["request.params.filter"])) {
+        return;
+      }
+      const filter = import_lodash.default.get(options.templateContext, "request.params.filter") || {};
+      const { data } = options.transformedResponse;
+      options.transformedResponse.data = data.filter((item) => {
+        return (0, import_database.filterMatch)(item, filter);
+      });
+    },
+    function handleSort(options) {
+      if (checkVariablesAreUsed(options.actionOptions, ["request.params.sort"])) {
+        return;
+      }
+      const sort = import_lodash.default.get(options.templateContext, "request.params.sort") || [];
+      if (sort.length === 0) {
+        return;
+      }
+      const { data } = options.transformedResponse;
+      options.transformedResponse.data = data.sort((a, b) => {
+        for (const sortItem of sort) {
+          const isDesc = sortItem.startsWith("-");
+          const field = isDesc ? sortItem.slice(1) : sortItem;
+          if (a[field] > b[field]) {
+            return isDesc ? -1 : 1;
+          }
+          if (a[field] < b[field]) {
+            return isDesc ? 1 : -1;
+          }
+        }
+        return 0;
+      });
+    },
+    function handleFullList(options) {
+      if (checkVariablesAreUsed(options.actionOptions, ["request.params.page"])) {
+        return;
+      }
+      const page = parseInt(import_lodash.default.get(options.templateContext, "request.params.page", 1));
+      const pageSize = parseInt(import_lodash.default.get(options.templateContext, "request.params.pageSize", 20));
+      const { data } = options.transformedResponse;
+      const start = (page - 1) * pageSize;
+      const end = start + pageSize;
+      options.transformedResponse.data = data.slice(start, end);
+      import_lodash.default.set(options.transformedResponse, "meta.count", data.length);
+      import_lodash.default.set(options.transformedResponse, "meta.page", page);
+      import_lodash.default.set(options.transformedResponse, "meta.pageSize", pageSize);
+      import_lodash.default.set(options.transformedResponse, "meta.totalPage", Math.ceil(data.length / pageSize));
+    },
+    function handleFields(options) {
+      if (checkVariablesAreUsed(options.actionOptions, ["request.params.fields"])) {
+        return;
+      }
+      const fields = import_lodash.default.get(options.templateContext, "request.params.fields") || [];
+      if (fields.length === 0) {
+        return;
+      }
+      const { data } = options.transformedResponse;
+      options.transformedResponse.data = data.map((item) => {
+        return import_lodash.default.pick(item, fields);
+      });
+    },
+    function handleExpect(options) {
+      if (checkVariablesAreUsed(options.actionOptions, ["request.params.expect"])) {
+        return;
+      }
+      const expect = import_lodash.default.get(options.templateContext, "request.params.expect") || [];
+      if (expect.length === 0) {
+        return;
+      }
+      const { data } = options.transformedResponse;
+      options.transformedResponse.data = data.map((item) => {
+        return import_lodash.default.omit(item, expect);
+      });
+    }
+  ],
+  get: [
+    function validateGetActionTransformedResponse(options) {
+      const { transformedResponse } = options;
+      const dataItem = import_lodash.default.get(transformedResponse, "data");
+      if (!import_lodash.default.isPlainObject(dataItem)) {
+        throw new Error(
+          `The transformed response for the get action should be an object. got ${getValueType(dataItem)}`
+        );
+      }
+    },
+    function handleFields2(options) {
+      if (checkVariablesAreUsed(options.actionOptions, ["request.params.fields"])) {
+        return;
+      }
+      const fields = import_lodash.default.get(options.templateContext, "request.params.fields") || [];
+      if (fields.length === 0) {
+        return;
+      }
+      const { data } = options.transformedResponse;
+      options.transformedResponse.data = import_lodash.default.pick(data, fields);
+    },
+    function handleExpect2(options) {
+      if (checkVariablesAreUsed(options.actionOptions, ["request.params.expect"])) {
+        return;
+      }
+      const expect = import_lodash.default.get(options.templateContext, "request.params.expect") || [];
+      if (expect.length === 0) {
+        return;
+      }
+      const { data } = options.transformedResponse;
+      options.transformedResponse.data = import_lodash.default.omit(data, expect);
+    }
+  ],
+  create: [],
+  update: [],
+  destroy: []
+};
+function transformResponseThroughMiddleware(options) {
+  const { actionOptions } = options;
+  const { type } = actionOptions;
+  const actionMiddlewares = middlewares[type] || [];
+  actionMiddlewares.forEach((middleware) => {
+    middleware(options);
+  });
+}
+function checkVariablesAreUsed(options, variables) {
+  const template = JSON.stringify(options);
+  return variables.every((variable) => template.includes(`{{${variable}}}`));
+}
+function getValueType(value) {
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (import_lodash.default.isPlainObject(value)) {
+    return "object";
+  }
+  return typeof value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformResponseThroughMiddleware
+});