@wavemaker-ai/react-runtime 1.0.0-next.27766

package/utils/widget-cleanup-util.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+function removeWidgetsFromContext(context, proxy, names) {
+  const widgets = context == null ? void 0 : context.Widgets;
+  if (!widgets) return context;
+  const hasChanges = names.some((name) => name in widgets);
+  if (!hasChanges) return context;
+  const registry = context == null ? void 0 : context.overriddenPropsRegistry;
+  names.forEach((name) => {
+    delete context.Widgets[name];
+    proxy.Widgets[name] = null;
+    if (registry) registry.destroy(name);
+  });
+  return context;
+}
+const createWidgetCleanup = (config) => {
+  const { setPageContext, proxyRef, debounceDelay = 100 } = config;
+  const cleanupRef = /* @__PURE__ */ new Set();
+  let timeoutId = null;
+  const performCleanup = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      if (cleanupRef.size === 0) return;
+      setPageContext((currentContext) => {
+        const newContext = __spreadValues({}, currentContext);
+        const widgetsToClean = [...cleanupRef];
+        widgetsToClean.forEach((name) => {
+          var _a;
+          if (newContext.Widgets && newContext.Widgets[name]) {
+            delete newContext.Widgets[name];
+            if ((_a = proxyRef == null ? void 0 : proxyRef.current) == null ? void 0 : _a.Widgets) {
+              delete proxyRef.current.Widgets[name];
+            }
+          }
+        });
+        cleanupRef.clear();
+        return newContext;
+      });
+      timeoutId = null;
+    }, debounceDelay);
+  };
+  const cleanup = (name) => {
+    cleanupRef.add(name);
+    performCleanup();
+  };
+  const cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return {
+    cleanup,
+    cleanupRef,
+    cancel
+  };
+};
+export {
+  createWidgetCleanup,
+  removeWidgetsFromContext
+};

package/utils/widgets.d.ts

@@ -0,0 +1,3 @@
+export declare const getObjValueByKey: (obj: any, strKey: string) => any;
+export declare const checkIsCustomPipeExpression: (exp: any) => any;
+export declare const getEvaluatedData: (dataObj: any, options: any, context?: any) => any;

package/utils/widgets.js

@@ -0,0 +1,85 @@
+import { get } from "lodash-es";
+const getObjValueByKey = (obj, strKey) => {
+  if (!strKey || !obj) {
+    return obj;
+  }
+  return get(obj, strKey);
+};
+const checkIsCustomPipeExpression = function(exp) {
+  let customRegEx = /(custom(\s*:))/g;
+  let matches = exp.match(customRegEx);
+  return matches && matches.length;
+};
+const getEvaluatedData = (dataObj, options, context) => {
+  let displayExpr = options.expression;
+  if (displayExpr) {
+    if (typeof displayExpr !== "function") {
+      return dataObj[displayExpr];
+    }
+    return displayExpr(dataObj);
+  }
+  let expressionValue = "";
+  const field = options.field || "", expr = options.expression, bindExpr = options.bindExpression;
+  if (bindExpr) {
+    expressionValue = bindExpr.replace("bind:", "");
+    if (checkIsCustomPipeExpression(expressionValue)) {
+      expressionValue = expressionValue + ": __1";
+    }
+    expressionValue = getUpdatedExpr(expressionValue);
+  } else {
+    expressionValue = expr ? expr : field;
+  }
+  if (!bindExpr && !expr) {
+    if (typeof field === "function") {
+      return field(dataObj);
+    }
+    return get(dataObj, field);
+  }
+  return expressionValue;
+};
+const getUpdatedExpr = (expr) => {
+  let updated = "", ch, next, i, j, matchCh, matchCount, isQuotedStr, subStr, isQuotedStrEvaluated;
+  expr = expr.replace(/\$\[data\[\$i\]/g, "$[__1");
+  for (i = 0; i < expr.length; i++) {
+    ch = expr[i];
+    next = expr[i + 1];
+    if (ch === "$" && next === "[") {
+      matchCount = 1;
+      isQuotedStrEvaluated = false;
+      isQuotedStr = false;
+      for (j = i + 2; j < expr.length; j++) {
+        matchCh = expr[j];
+        if (matchCh === " ") {
+          continue;
+        }
+        if (!isQuotedStrEvaluated) {
+          isQuotedStr = expr[j] === '"' || expr[j] === "'";
+          isQuotedStrEvaluated = true;
+        }
+        if (matchCh === "[") {
+          matchCount++;
+        } else if (matchCh === "]") {
+          matchCount--;
+        }
+        if (!matchCount) {
+          subStr = expr.substring(i + 2, j);
+          if (isQuotedStr) {
+            updated += "__1[" + subStr + "]";
+          } else {
+            updated += subStr;
+          }
+          break;
+        }
+      }
+      i = j;
+    } else {
+      updated += ch;
+    }
+  }
+  return updated;
+};
+export {
+  checkIsCustomPipeExpression,
+  getEvaluatedData,
+  getObjValueByKey
+};

package/variables/base-variable.d.ts

@@ -0,0 +1,61 @@
+import EventNotifier from "@wavemaker-ai/react-runtime/core/event-notifier";
+export interface VariableConfig {
+    name: string;
+    paramProvider: Function;
+    onBefore: Function;
+    onComplete: Function;
+    onSuccess: Function;
+    onError: Function;
+    isList: boolean;
+    twoWayBinding: boolean;
+    service: any;
+    operation: string;
+    operationId: string;
+    operationType: string;
+    serviceType: string;
+    spinnerMessage?: string;
+    spinnerContext?: string;
+    _id: string | number;
+    _context?: any;
+    dataBinding?: any;
+    isStaticParams?: boolean;
+}
+/**
+ * Call at the top of every invokeOnParamChange implementation.
+ * Returns a resolved Promise (early exit) when all dataBinding entries are
+ * static literals so auto-invocation is skipped, or null to continue.
+ */
+export declare function isStaticParamVariable<T>(config: Pick<VariableConfig, "isStaticParams">, instance: T): Promise<T> | null;
+export declare enum VariableEvents {
+    BEFORE_INVOKE = "beforeInvoke",
+    SUCCESS = "success",
+    ERROR = "error",
+    AFTER_INVOKE = "afterInvoke"
+}
+export declare abstract class BaseVariable<T extends VariableConfig> extends EventNotifier {
+    config: T;
+    name: string;
+    params: any;
+    dataSet: any;
+    isList: boolean;
+    twoWayBinding: boolean;
+    isExecuting: boolean;
+    dataBinding: any;
+    constructor(config: T);
+    invoke(params?: {}, onSuccess?: Function, onError?: Function): Promise<BaseVariable<T>>;
+    doNext(): Promise<BaseVariable<T>>;
+    invokeOnParamChange(): Promise<BaseVariable<T>>;
+    getData(): any;
+    setData(dataSet: any): any;
+    getValue(key: string, index: number): any;
+    setValue(key: string, value: any): any;
+    getItem(index: number): any;
+    setItem(index: any, value: any, options?: any): any;
+    addItem(value: any, options?: any): any;
+    removeItem(index: any, options?: any): any;
+    clearData(): any;
+    getCount(): any;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+}

package/variables/base-variable.js

@@ -0,0 +1,131 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import DatasetUtil from "../utils/dataset-util";
+import EventNotifier from "../core/event-notifier";
+import { isNumber, isObject, isBoolean, get, isEqual } from "lodash-es";
+function isStaticParamVariable(config, instance) {
+  return config.isStaticParams ? Promise.resolve(instance) : null;
+}
+var VariableEvents = /* @__PURE__ */ ((VariableEvents2) => {
+  VariableEvents2["BEFORE_INVOKE"] = "beforeInvoke";
+  VariableEvents2["SUCCESS"] = "success";
+  VariableEvents2["ERROR"] = "error";
+  VariableEvents2["AFTER_INVOKE"] = "afterInvoke";
+  return VariableEvents2;
+})(VariableEvents || {});
+class BaseVariable extends EventNotifier {
+  constructor(config) {
+    super();
+    this.config = config;
+    __publicField(this, "name", "");
+    __publicField(this, "params", {});
+    __publicField(this, "dataSet", {});
+    __publicField(this, "isList");
+    __publicField(this, "twoWayBinding");
+    __publicField(this, "isExecuting", false);
+    __publicField(this, "dataBinding", {});
+    this.name = config.name;
+    this.isList = config.isList;
+    this.twoWayBinding = config.twoWayBinding;
+    this.dataSet = this.isList ? [] : this.dataSet;
+    this.subscribe("beforeInvoke" /* BEFORE_INVOKE */, () => {
+      this.isExecuting = true;
+      console.info(`Before Invoking variable ${this.name}`);
+    });
+    this.subscribe("afterInvoke" /* AFTER_INVOKE */, () => {
+      this.isExecuting = false;
+      console.info(`After Invoking variable ${this.name}`);
+    });
+  }
+  config;
+  invoke(params, onSuccess, onError) {
+    if (!params) {
+      this.params = this.config.paramProvider();
+    } else {
+      this.params = params;
+    }
+    return Promise.resolve(this);
+  }
+  doNext() {
+    return Promise.reject(this);
+  }
+  invokeOnParamChange() {
+    const last = this.params;
+    const latest = this.config.paramProvider();
+    if (!isEqual(last, latest)) {
+      return this.invoke(latest);
+    }
+    return Promise.resolve(this);
+  }
+  getData() {
+    return this.dataSet;
+  }
+  setData(dataSet) {
+    if (DatasetUtil.isValidDataset(dataSet, this.isList)) {
+      this.dataSet = dataSet;
+    }
+    return this.dataSet;
+  }
+  getValue(key, index) {
+    return DatasetUtil.getValue(this.dataSet, key, index, this.isList);
+  }
+  setValue(key, value) {
+    return DatasetUtil.setValue(this.dataSet, key, value, this.isList);
+  }
+  getItem(index) {
+    return DatasetUtil.getItem(this.dataSet, index, this.isList);
+  }
+  setItem(index, value, options) {
+    options = DatasetUtil.getChildDetails(this.dataSet, options, this.isList);
+    return DatasetUtil.setItem(this.dataSet, index, value, options);
+  }
+  addItem(value, options) {
+    let index;
+    if (isNumber(options)) {
+      index = options;
+    }
+    if (isObject(options)) {
+      index = options.index;
+    }
+    options = DatasetUtil.getChildDetails(this.dataSet, options, this.isList);
+    return DatasetUtil.addItem(this.dataSet, value, index, options);
+  }
+  removeItem(index, options) {
+    let exactMatch, parentIndex;
+    if (options) {
+      if (isBoolean(options)) {
+        exactMatch = options;
+      }
+      if (isObject(options)) {
+        exactMatch = options.exactMatch;
+        if (this.isList) {
+          parentIndex = options.parentIndex || 0;
+        }
+      }
+    }
+    return DatasetUtil.removeItem(this.dataSet, index, {
+      exactMatch,
+      path: get(options, "path"),
+      parentIndex
+    });
+  }
+  clearData() {
+    this.dataSet = DatasetUtil.getValidDataset(this.isList);
+    return this.dataSet;
+  }
+  getCount() {
+    return DatasetUtil.getCount(this.dataSet, this.isList);
+  }
+  pause() {
+  }
+  resume() {
+  }
+  destroy() {
+  }
+}
+export {
+  BaseVariable,
+  VariableEvents,
+  isStaticParamVariable
+};

package/variables/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const WS_CONSTANTS: {
+    NON_BODY_HTTP_METHODS: string[];
+    NON_DATA_AXIOS_METHODS: string[];
+    CONTENT_TYPES: {
+        FORM_URL_ENCODED: string;
+        MULTIPART_FORMDATA: string;
+        OCTET_STREAM: string;
+    };
+    REST_SERVICE: {
+        ERR_TYPE: {
+            METADATA_MISSING: string;
+            CRUD_OPERATION_MISSING: string;
+            USER_UNAUTHORISED: string;
+        };
+        ERR_MSG: {
+            METADATA_MISSING: string;
+            USER_UNAUTHORISED: string;
+            CRUD_OPERATION_MISSING: string;
+        };
+    };
+};

package/variables/constants.js

@@ -0,0 +1,24 @@
+const WS_CONSTANTS = {
+  NON_BODY_HTTP_METHODS: ["GET", "HEAD"],
+  NON_DATA_AXIOS_METHODS: ["GET", "DELETE", "HEAD", "OPTIONS"],
+  CONTENT_TYPES: {
+    FORM_URL_ENCODED: "application/x-www-form-urlencoded",
+    MULTIPART_FORMDATA: "multipart/form-data",
+    OCTET_STREAM: "application/octet-stream"
+  },
+  REST_SERVICE: {
+    ERR_TYPE: {
+      METADATA_MISSING: "metadata_missing",
+      CRUD_OPERATION_MISSING: "crud_operation_missing",
+      USER_UNAUTHORISED: "user_unauthorised"
+    },
+    ERR_MSG: {
+      METADATA_MISSING: 'Metadata missing for "$variable"',
+      USER_UNAUTHORISED: "Unauthorized User",
+      CRUD_OPERATION_MISSING: 'Operation "$operation" not allowed for "$variable"'
+    }
+  }
+};
+export {
+  WS_CONSTANTS
+};

package/variables/crud-variable.d.ts

@@ -0,0 +1,39 @@
+import { VariableConfig } from "./base-variable";
+export interface CrudVariableConfig extends VariableConfig {
+    name: string;
+    dataSet: any;
+    inputFields: any;
+    filterExpressions: any;
+    filterFields: any;
+    crudOperationId: string;
+    baseUrl: string;
+    maxResults: number;
+    onCanUpdate: any;
+    onBeforeUpdate: any;
+    onResult: any;
+    onBeforeDatasetReady: any;
+    onError: any;
+    controller: string;
+    dataBinding: Record<string, unknown>;
+    filterProvider?: Function;
+}
+declare const CrudVariable_base: any;
+declare class CrudVariable extends CrudVariable_base {
+    config: CrudVariableConfig;
+    params: any;
+    filters: any;
+    constructor(config: CrudVariableConfig);
+    setFilterExpValue(filter: any): void;
+    invokeOnParamChange(): Promise<this>;
+    listRecords(options?: any, onSuccess?: Function, onError?: Function): any;
+    updateRecord(options?: any, success?: any, error?: any): any;
+    insertRecord(options?: any, success?: any, error?: any): any;
+    deleteRecord(options?: any, success?: any, error?: any): any;
+    processBindExp(d: any, variable: CrudVariable): {
+        name: any;
+        value: any;
+    };
+    processBinding(variable: any): void;
+    invoke(options?: any, onSuccess?: Function, onError?: Function): any;
+}
+export default CrudVariable;

package/variables/crud-variable.js

@@ -0,0 +1,196 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import {
+  CrudVariable as _CrudVariable,
+  getTarget,
+  setValueToNode,
+  getTargetNodeKey,
+  internalBoundNodeMap
+} from "@wavemaker-ai/variables";
+import { VariableEvents, isStaticParamVariable } from "./base-variable";
+import { isEqual, isUndefined, isFunction, forEach, isEmpty, isArray, set } from "lodash-es";
+import httpService from "../hooks/useHttp";
+import { deepCopy } from "../core/util";
+import Formatters from "../core/formatters";
+import EventNotifier from "../core/event-notifier";
+class CrudVariable extends _CrudVariable {
+  constructor(config) {
+    if (config._context) {
+      httpService.setContext(config._context);
+    }
+    const variableConfig = {
+      category: "wm.CrudVariable",
+      name: config.name,
+      dataSet: config.paramProvider(),
+      dataBinding: config.dataBinding,
+      inputFields: config.paramProvider(),
+      filterExpressions: config.filterExpressions,
+      filterFields: config.paramProvider(),
+      isList: config.isList,
+      operation: config.operation,
+      httpClientService: httpService,
+      httpService,
+      maxResults: config.maxResults || 10,
+      _id: config._id,
+      crudOperationId: config.crudOperationId,
+      controller: config.controller,
+      _context: config._context || {
+        prefabname: config.name
+      },
+      onSuccess: (context, args) => {
+        this.notify(VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        this.notify(VariableEvents.SUCCESS, [args.variable, args.data, args.options]);
+        return config.onSuccess && config.onSuccess(args.variable, args.data, args.options);
+      },
+      onCanUpdate: (context, args) => {
+        return config.onCanUpdate && config.onCanUpdate(args.variable, args.data, args.options);
+      },
+      onBeforeUpdate: (context, args) => {
+        return config.onBeforeUpdate && config.onBeforeUpdate(args.variable, args.dataFilter || args.inputData, args.options);
+      },
+      onResult: (context, args) => {
+        this.notify(VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        return config.onResult && config.onResult(args.variable, args.data, args.options);
+      },
+      onBeforeDatasetReady: (context, args) => {
+        return config.onBeforeDatasetReady && config.onBeforeDatasetReady(args.variable, args.data, args.options);
+      },
+      onError: (context, args) => {
+        this.notify(VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        this.notify(VariableEvents.ERROR, [args.variable, args.data, args.options]);
+        if (args.data.includes("Violation")) {
+          EventNotifier.ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
+        }
+        return config.onError && config.onError(args.variable, args.data, args.options);
+      }
+    };
+    super(variableConfig);
+    this.config = config;
+    __publicField(this, "params", {});
+    __publicField(this, "filters", {});
+    this.dateFormatter = Formatters.get("toDate");
+    this.init();
+  }
+  config;
+  setFilterExpValue(filter) {
+    var _a;
+    (_a = this.filterExpressions) == null ? void 0 : _a.rules.forEach((r) => {
+      r.value = filter[r.target];
+    });
+  }
+  invokeOnParamChange() {
+    const isStatic = isStaticParamVariable(this.config, this);
+    if (isStatic) return isStatic;
+    const last = this.params;
+    const latest = this.config.paramProvider();
+    if (this.config.operation === "read") {
+      const lastFilter = this.filters;
+      const latestFilter = this.config.filterProvider && this.config.filterProvider();
+      if (!isEqual(lastFilter, latestFilter)) {
+        this.setFilterExpValue(latestFilter);
+        if (this.autoUpdate && !isEmpty(latestFilter) && isFunction(this.update)) {
+          this.filters = latestFilter;
+          this.invoke();
+        }
+      }
+    }
+    if (!isEqual(last, latest)) {
+      if (this.config.operation === "read") {
+        forEach(latest, (val, key) => {
+          this.filterFields[key] = {
+            value: val
+          };
+        });
+      } else {
+        this.inputFields = latest;
+      }
+      if (this.autoUpdate && !isUndefined(latest) && isFunction(this[this.config.operation + "Record"])) {
+        this.invoke();
+      }
+    }
+    return Promise.resolve(this);
+  }
+  listRecords(options, onSuccess, onError) {
+    this.processBinding(this);
+    this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    this.filters = this.config.filterProvider && this.config.filterProvider();
+    if (options) {
+      this.filters = deepCopy(
+        {},
+        this.filters,
+        options.filterFields ? options.filterFields : options
+      );
+    }
+    options = options || {};
+    options.filterFields = this.filters;
+    this.setFilterExpValue(this.filters);
+    return super.listRecords(options, onSuccess, onError);
+  }
+  updateRecord(options, success, error) {
+    this.processBinding(this);
+    this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    return super.updateRecord(options, success, error);
+  }
+  insertRecord(options, success, error) {
+    this.processBinding(this);
+    this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    return super.insertRecord(options, success, error);
+  }
+  deleteRecord(options, success, error) {
+    this.processBinding(this);
+    this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    return super.deleteRecord(options, success, error);
+  }
+  processBindExp(d, variable) {
+    const root = getTarget(variable), targetNodeKey = getTargetNodeKey(d.target), runMode = true;
+    let v = isArray(d.value) ? d.value[0] : d.value;
+    if (v && !isUndefined(d.value)) {
+      setValueToNode(d.target, d, root, variable, d.value, true);
+      if (runMode && root !== targetNodeKey) {
+        if (!internalBoundNodeMap.has(variable)) {
+          internalBoundNodeMap.set(variable, {});
+        }
+        set(internalBoundNodeMap.get(variable), [variable.name, root, d.target], d.value);
+      }
+    }
+    return {
+      name: d.target,
+      value: v
+    };
+  }
+  processBinding(variable) {
+    const fn = variable.config.dataBinding;
+    let bindMap = isFunction(fn) ? fn() : fn;
+    if (isEmpty(bindMap)) {
+      return;
+    }
+    const flattenedBindInfo = [];
+    forEach(bindMap, (bindNodes, operationType) => {
+      bindNodes = bindNodes || [];
+      bindNodes.forEach((bindNode) => {
+        bindNode.target = operationType + "." + bindNode.target;
+        flattenedBindInfo.push(bindNode);
+      });
+    });
+    bindMap = flattenedBindInfo;
+    variable["_binddataBinding"] = bindMap;
+    if (!bindMap || !isArray(bindMap)) {
+      return;
+    }
+    flattenedBindInfo.forEach((node) => {
+      if (variable.category === "wm.Variable" && node.target === "dataBinding") {
+        node.target = "dataSet";
+      }
+      this.processBindExp(node, variable);
+    });
+  }
+  invoke(options, onSuccess, onError) {
+    this.processBinding(this);
+    return super.invoke(options, onSuccess, onError);
+  }
+}
+var crud_variable_default = CrudVariable;
+export {
+  crud_variable_default as default
+};