@wavemaker-ai/react-runtime 1.0.0-rc.309

package/variables/crud-variable.js

@@ -0,0 +1,227 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _variables = require("@wavemaker-ai/variables");
+var _baseVariable = require("./base-variable");
+var _lodashEs = require("lodash-es");
+var _useHttp = _interopRequireDefault(require("@wavemaker-ai/react-runtime/hooks/useHttp"));
+var _util = require("@wavemaker-ai/react-runtime/core/util");
+var _formatters = _interopRequireDefault(require("@wavemaker-ai/react-runtime/core/formatters"));
+var _eventNotifier = _interopRequireDefault(require("@wavemaker-ai/react-runtime/core/event-notifier"));
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = (0, _get2["default"])((0, _getPrototypeOf2["default"])(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; } // @ts-nocheck
+var CrudVariable = /*#__PURE__*/function (_ref) {
+  function CrudVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, CrudVariable);
+    // Store context in httpService for global access
+    if (config._context) {
+      _useHttp["default"].setContext(config._context);
+    }
+    var 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: _useHttp["default"],
+      httpService: _useHttp["default"],
+      maxResults: config.maxResults || 10,
+      _id: config._id,
+      crudOperationId: config.crudOperationId,
+      controller: config.controller,
+      _context: config._context || {
+        prefabname: config.name
+      },
+      onSuccess: function onSuccess(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.SUCCESS, [args.variable, args.data, args.options]);
+        return config.onSuccess && config.onSuccess(args.variable, args.data, args.options);
+      },
+      onCanUpdate: function onCanUpdate(context, args) {
+        return config.onCanUpdate && config.onCanUpdate(args.variable, args.data, args.options);
+      },
+      onBeforeUpdate: function onBeforeUpdate(context, args) {
+        return config.onBeforeUpdate && config.onBeforeUpdate(args.variable, args.dataFilter || args.inputData, args.options);
+      },
+      onResult: function onResult(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        return config.onResult && config.onResult(args.variable, args.data, args.options);
+      },
+      onBeforeDatasetReady: function onBeforeDatasetReady(context, args) {
+        return config.onBeforeDatasetReady && config.onBeforeDatasetReady(args.variable, args.data, args.options);
+      },
+      onError: function onError(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.ERROR, [args.variable, args.data, args.options]);
+        if (args.data.includes("Violation")) {
+          _eventNotifier["default"].ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
+        }
+        return config.onError && config.onError(args.variable, args.data, args.options);
+      }
+    };
+    _this = _callSuper(this, CrudVariable, [variableConfig]);
+    _this.config = config;
+    (0, _defineProperty2["default"])(_this, "params", {});
+    (0, _defineProperty2["default"])(_this, "filters", {});
+    _this.dateFormatter = _formatters["default"].get("toDate");
+    _this.init();
+    return _this;
+  }
+  (0, _inherits2["default"])(CrudVariable, _ref);
+  return (0, _createClass2["default"])(CrudVariable, [{
+    key: "setFilterExpValue",
+    value: function setFilterExpValue(filter) {
+      var _this$filterExpressio;
+      (_this$filterExpressio = this.filterExpressions) === null || _this$filterExpressio === void 0 || _this$filterExpressio.rules.forEach(function (r) {
+        r.value = filter[r.target];
+      });
+    }
+  }, {
+    key: "invokeOnParamChange",
+    value: function invokeOnParamChange() {
+      var _this2 = this;
+      var isStatic = (0, _baseVariable.isStaticParamVariable)(this.config, this);
+      if (isStatic) return isStatic;
+      var last = this.params;
+      var latest = this.config.paramProvider();
+      if (this.config.operation === "read") {
+        var lastFilter = this.filters;
+        var latestFilter = this.config.filterProvider && this.config.filterProvider();
+        if (!(0, _lodashEs.isEqual)(lastFilter, latestFilter)) {
+          this.setFilterExpValue(latestFilter);
+          if (this.autoUpdate && !(0, _lodashEs.isEmpty)(latestFilter) && (0, _lodashEs.isFunction)(this.update)) {
+            this.filters = latestFilter;
+            this.invoke();
+          }
+        }
+      }
+      if (!(0, _lodashEs.isEqual)(last, latest)) {
+        if (this.config.operation === "read") {
+          (0, _lodashEs.forEach)(latest, function (val, key) {
+            _this2.filterFields[key] = {
+              value: val
+            };
+          });
+        } else {
+          this.inputFields = latest;
+        }
+        /* if auto-update set for the variable with read operation only, get its data */
+        // @ts-ignore
+        if (this.autoUpdate && !(0, _lodashEs.isUndefined)(latest) && (0, _lodashEs.isFunction)(this[this.config.operation + "Record"])) {
+          this.invoke();
+        }
+      }
+      return Promise.resolve(this);
+    }
+  }, {
+    key: "listRecords",
+    value: function listRecords(options, onSuccess, onError) {
+      this.processBinding(this);
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      this.filters = this.config.filterProvider && this.config.filterProvider();
+      if (options) {
+        this.filters = (0, _util.deepCopy)({}, this.filters, options.filterFields ? options.filterFields : options);
+      }
+      options = options || {};
+      options.filterFields = this.filters;
+      this.setFilterExpValue(this.filters);
+      return _superPropGet(CrudVariable, "listRecords", this, 3)([options, onSuccess, onError]);
+    }
+  }, {
+    key: "updateRecord",
+    value: function updateRecord(options, success, error) {
+      this.processBinding(this);
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      return _superPropGet(CrudVariable, "updateRecord", this, 3)([options, success, error]);
+    }
+  }, {
+    key: "insertRecord",
+    value: function insertRecord(options, success, error) {
+      this.processBinding(this);
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      return _superPropGet(CrudVariable, "insertRecord", this, 3)([options, success, error]);
+    }
+  }, {
+    key: "deleteRecord",
+    value: function deleteRecord(options, success, error) {
+      this.processBinding(this);
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      return _superPropGet(CrudVariable, "deleteRecord", this, 3)([options, success, error]);
+    }
+  }, {
+    key: "processBindExp",
+    value: function processBindExp(d, variable) {
+      var root = (0, _variables.getTarget)(variable),
+        targetNodeKey = (0, _variables.getTargetNodeKey)(d.target),
+        runMode = true;
+      var v = (0, _lodashEs.isArray)(d.value) ? d.value[0] : d.value;
+      if (v && !(0, _lodashEs.isUndefined)(d.value)) {
+        (0, _variables.setValueToNode)(d.target, d, root, variable, d.value, true);
+        if (runMode && root !== targetNodeKey) {
+          if (!_variables.internalBoundNodeMap.has(variable)) {
+            _variables.internalBoundNodeMap.set(variable, {});
+          }
+          (0, _lodashEs.set)(_variables.internalBoundNodeMap.get(variable), [variable.name, root, d.target], d.value);
+        }
+      }
+      return {
+        name: d.target,
+        value: v
+      };
+    }
+  }, {
+    key: "processBinding",
+    value: function processBinding(variable) {
+      var _this3 = this;
+      var fn = variable.config.dataBinding;
+      var bindMap = (0, _lodashEs.isFunction)(fn) ? fn() : fn;
+      if ((0, _lodashEs.isEmpty)(bindMap)) {
+        return;
+      }
+      var flattenedBindInfo = [];
+      (0, _lodashEs.forEach)(bindMap, function (bindNodes, operationType) {
+        bindNodes = bindNodes || [];
+        bindNodes.forEach(function (bindNode) {
+          bindNode.target = operationType + "." + bindNode.target;
+          flattenedBindInfo.push(bindNode);
+        });
+      });
+      bindMap = flattenedBindInfo;
+      variable["_binddataBinding"] = bindMap;
+      if (!bindMap || !(0, _lodashEs.isArray)(bindMap)) {
+        return;
+      }
+      flattenedBindInfo.forEach(function (node) {
+        /* for static variable change the binding with target 'dataBinding' to 'dataSet', as the results have to reflect directly in the dataSet */
+        if (variable.category === "wm.Variable" && node.target === "dataBinding") {
+          node.target = "dataSet";
+        }
+        _this3.processBindExp(node, variable);
+      });
+    }
+  }, {
+    key: "invoke",
+    value: function invoke(options, onSuccess, onError) {
+      this.processBinding(this);
+      return _superPropGet(CrudVariable, "invoke", this, 3)([options, onSuccess, onError]);
+    }
+  }]);
+}(_variables.CrudVariable);
+var _default = exports["default"] = CrudVariable;

package/variables/live-variable.d.ts

@@ -0,0 +1,58 @@
+import { VariableConfig, VariableEvents } from "./base-variable";
+import { IPaginationMeta } from "../components/data/list/components/props";
+export interface LiveVariableConfig extends VariableConfig {
+    baseUrl: string;
+    maxResults: number;
+    _context: any;
+    onCanUpdate: any;
+    onBeforeUpdate: any;
+    onResult: any;
+    onBeforeDatasetReady: any;
+    inFlightBehavior: string;
+    type: string;
+    autoUpdate: boolean;
+    orderBy: string;
+    category: string;
+    liveSource: string;
+    propertiesMap: any;
+    properties: any;
+    tableName: string;
+    tableType: string;
+    relatedTables: any;
+    filterExpressions: any;
+    filterProvider: any;
+    pagination: IPaginationMeta;
+    loading: boolean;
+    _id: string;
+    execute: (operation: string, options?: any) => Promise<any>;
+    invoke: (options?: any) => Promise<any>;
+    inputFields: any;
+    filterFields: any;
+    update: (options?: any) => Promise<any>;
+    listRecords: (options?: any, onSuccess?: Function, onError?: Function) => Promise<any>;
+    updateRecord: (options?: any, success?: any, error?: any) => Promise<any>;
+    insertRecord: (options?: any, success?: any, error?: any) => Promise<any>;
+    deleteRecord: (options?: any, success?: any, error?: any) => Promise<any>;
+    notify: (event: VariableEvents, args: any) => void;
+}
+declare enum _LiveVariableEvents {
+    BEFORE_INVOKE = "beforeInvoke"
+}
+export type LiveVariableEvents = _LiveVariableEvents | VariableEvents;
+declare const LiveVariable_base: any;
+declare class LiveVariable extends LiveVariable_base {
+    config: LiveVariableConfig;
+    params: any;
+    private filters;
+    private filterValues;
+    private lastFilters;
+    constructor(config: LiveVariableConfig);
+    setFilterExpValue(filter: any): void;
+    setFilter(key: any, val?: any): this;
+    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;
+}
+export default LiveVariable;

package/variables/live-variable.js

@@ -0,0 +1,226 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _baseVariable = require("./base-variable");
+var _lodashEs = require("lodash-es");
+var _variables = require("@wavemaker-ai/variables");
+var _useHttp = _interopRequireDefault(require("@wavemaker-ai/react-runtime/hooks/useHttp"));
+var _util = require("@wavemaker-ai/react-runtime/core/util");
+var _formatters = _interopRequireDefault(require("@wavemaker-ai/react-runtime/core/formatters"));
+var _eventNotifier = _interopRequireDefault(require("@wavemaker-ai/react-runtime/core/event-notifier"));
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = (0, _get2["default"])((0, _getPrototypeOf2["default"])(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; } // @ts-ignore
+var _LiveVariableEvents = /*#__PURE__*/function (_LiveVariableEvents) {
+  _LiveVariableEvents["BEFORE_INVOKE"] = "beforeInvoke";
+  return _LiveVariableEvents;
+}(_LiveVariableEvents || {});
+var LiveVariable = /*#__PURE__*/function (_ref) {
+  function LiveVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, LiveVariable);
+    // Store context in httpService for global access
+    if (config._context) {
+      _useHttp["default"].setContext(config._context);
+    }
+    var variableConfig = {
+      name: config.name,
+      dataSet: config.paramProvider(),
+      inputFields: config.paramProvider(),
+      filterExpressions: config.filterExpressions,
+      filterFields: config.paramProvider(),
+      isList: config.isList,
+      maxResults: config.maxResults,
+      _context: config._context,
+      operation: config.operation,
+      type: config.type,
+      autoUpdate: config.autoUpdate,
+      liveSource: config.liveSource,
+      orderBy: config.orderBy,
+      category: config.category,
+      properties: config.properties,
+      propertiesMap: config.propertiesMap,
+      tableName: config.tableName,
+      tableType: config.tableType,
+      relatedTables: config.relatedTables,
+      httpClientService: _useHttp["default"],
+      httpService: _useHttp["default"],
+      inFlightBehavior: config.inFlightBehavior,
+      _id: config._id,
+      onSuccess: function onSuccess(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.SUCCESS, [args.variable, args.data, args.options]);
+        return config.onSuccess && config.onSuccess(args.variable, args.data, args.options);
+      },
+      onCanUpdate: function onCanUpdate(context, args) {
+        return config.onCanUpdate && config.onCanUpdate(args.variable, args.data, args.options);
+      },
+      onBeforeUpdate: function onBeforeUpdate(context, args) {
+        return config.onBeforeUpdate && config.onBeforeUpdate(args.variable, args.dataFilter || args.inputData, args.options);
+      },
+      onResult: function onResult(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        return config.onResult && config.onResult(args.variable, args.data, args.options);
+      },
+      onBeforeDatasetReady: function onBeforeDatasetReady(context, args) {
+        return config.onBeforeDatasetReady && config.onBeforeDatasetReady(args.variable, args.data, args.options);
+      },
+      onError: function onError(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.ERROR, [args.variable, args.data, args.options]);
+        if (args.data.includes("Violation")) {
+          _eventNotifier["default"].ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
+        }
+        return config.onError && config.onError(args.variable, args.data, args.options);
+      }
+    };
+    _this = _callSuper(this, LiveVariable, [variableConfig]);
+
+    // Fix: The upstream manager's updateDataset() uses Object.defineProperty
+    // without configurable:true on a shared module-level emptyArr singleton.
+    // On repeated error handling, this causes "Cannot redefine property: data".
+    // Intercept dataSet assignments so every set produces a fresh array copy,
+    // ensuring the shared emptyArr reference is never mutated.
+    _this.config = config;
+    (0, _defineProperty2["default"])(_this, "params", {});
+    (0, _defineProperty2["default"])(_this, "filters", {});
+    (0, _defineProperty2["default"])(_this, "filterValues", {});
+    (0, _defineProperty2["default"])(_this, "lastFilters", {});
+    var _dataSet = _this.dataSet;
+    Object.defineProperty(_this, "dataSet", {
+      get: function get() {
+        return _dataSet;
+      },
+      set: function set(val) {
+        _dataSet = Array.isArray(val) ? (0, _toConsumableArray2["default"])(val) : val;
+      },
+      configurable: true,
+      enumerable: true
+    });
+    _this.dateFormatter = _formatters["default"].get("toDate");
+    _this.init();
+    return _this;
+  }
+  (0, _inherits2["default"])(LiveVariable, _ref);
+  return (0, _createClass2["default"])(LiveVariable, [{
+    key: "setFilterExpValue",
+    value: function setFilterExpValue(filter) {
+      var _this$filterExpressio;
+      (_this$filterExpressio = this.filterExpressions) === null || _this$filterExpressio === void 0 || _this$filterExpressio.rules.forEach(function (r) {
+        r.value = filter[r.target];
+      });
+    }
+  }, {
+    key: "setFilter",
+    value: function setFilter(key, val) {
+      // Call parent to update filterExpressions.rules array
+      var filterExpressions = _superPropGet(LiveVariable, "setFilter", this, 3)([key, val]);
+
+      // Convert rules array to key-value object for API
+      var filterObj = {};
+      filterExpressions.rules.forEach(function (rule) {
+        if (rule.target && rule.value !== undefined && rule.value !== "") {
+          filterObj[rule.target] = rule.value;
+        }
+      });
+      this.filterValues = filterObj;
+      return this;
+    }
+  }, {
+    key: "invokeOnParamChange",
+    value: function invokeOnParamChange() {
+      var _this2 = this;
+      var isStatic = (0, _baseVariable.isStaticParamVariable)(this.config, this);
+      if (isStatic) return isStatic;
+      var last = this.params;
+      var latest = this.config.paramProvider();
+      if (this.config.operation === "read" && !(0, _lodashEs.isEqual)(last, latest)) {
+        var lastFilter = this.lastFilters;
+        var filterProviderResult = this.config.filterProvider && this.config.filterProvider();
+        var latestFilter = (0, _util.deepCopy)({}, this.filters || {}, this.filterValues || {}, filterProviderResult || {});
+        if (!(0, _lodashEs.isEqual)(lastFilter, latestFilter)) {
+          this.setFilterExpValue(latestFilter);
+          // Check if filter has any valid (non-undefined, non-null, non-empty-string) values
+          var hasValidFilterValues = Object.values(latestFilter).some(function (val) {
+            return val !== undefined && val !== null && val !== "";
+          });
+          if (this.autoUpdate && hasValidFilterValues && (0, _lodashEs.isFunction)(this.update)) {
+            this.filters = latestFilter;
+            this.lastFilters = latestFilter;
+            this.last = latest;
+            this.params = latest;
+            this.invoke();
+          }
+        }
+      }
+      if (!(0, _lodashEs.isEqual)(last, latest)) {
+        if (this.config.operation === "read") {
+          (0, _lodashEs.forEach)(latest, function (val, key) {
+            _this2.filterFields[key] = {
+              value: val
+            };
+          });
+        } else {
+          this.inputFields = latest;
+        }
+        /* if auto-update set for the variable with read operation only, get its data */
+        // @ts-ignore
+        if (this.autoUpdate && !(0, _lodashEs.isUndefined)(latest) && (0, _lodashEs.isFunction)(this[this.config.operation + "Record"])) {
+          this.last = latest;
+          this.invoke();
+        }
+        this.params = latest;
+      }
+      return Promise.resolve(this);
+    }
+  }, {
+    key: "listRecords",
+    value: function listRecords(options, onSuccess, onError) {
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      var providerFilters = this.config.filterProvider && this.config.filterProvider();
+      this.filters = (0, _util.deepCopy)({}, providerFilters || {}, this.filterValues || {});
+
+      // Merge with options if provided
+      if (options) {
+        this.filters = (0, _util.deepCopy)({}, this.filters, options.filterFields ? options.filterFields : options);
+      }
+      options = options || {};
+      options.filterFields = this.filters;
+      this.setFilterExpValue(this.filters);
+      this.lastFilters = this.filters;
+      return _superPropGet(LiveVariable, "listRecords", this, 3)([options, onSuccess, onError]);
+    }
+  }, {
+    key: "updateRecord",
+    value: function updateRecord(options, success, error) {
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      return _superPropGet(LiveVariable, "updateRecord", this, 3)([options, success, error]);
+    }
+  }, {
+    key: "insertRecord",
+    value: function insertRecord(options, success, error) {
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      return _superPropGet(LiveVariable, "insertRecord", this, 3)([options, success, error]);
+    }
+  }, {
+    key: "deleteRecord",
+    value: function deleteRecord(options, success, error) {
+      this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this]);
+      options.row = options.row || options || {};
+      return _superPropGet(LiveVariable, "deleteRecord", this, 3)([options, success, error]);
+    }
+  }]);
+}(_variables.LiveVariable);
+var _default = exports["default"] = LiveVariable;

package/variables/metadata.service.d.ts

@@ -0,0 +1,24 @@
+interface ServiceDefinition {
+    [key: string]: any;
+}
+interface SecurityDefinitions {
+    [key: string]: any;
+    oauthProvider?: {
+        [key: string]: any;
+    };
+}
+export declare class MetadataService {
+    metadataMap: Map<string, ServiceDefinition>;
+    providerMap: Map<string, SecurityDefinitions>;
+    readonly CONTEXT_APP = "app";
+    constructor();
+    isLoaded(context?: string): boolean;
+    load(prefabName?: string, prefabBaseUrl?: string): Promise<ServiceDefinition>;
+    setMetadata(metadata: ServiceDefinition, context?: string): void;
+    getByOperationId(operationId: string, context?: string): any;
+    getByProviderId(providerId: string, context?: string): any;
+    getByCrudId(crudId: string, context?: string): any[];
+    getMessage(): void;
+}
+export declare const metadataService: MetadataService;
+export {};

package/variables/metadata.service.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.metadataService = exports.MetadataService = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _store = require("@wavemaker-ai/react-runtime/store");
+var _axios = _interopRequireDefault(require("axios"));
+var MetadataService = exports.MetadataService = /*#__PURE__*/function () {
+  function MetadataService() {
+    (0, _classCallCheck2["default"])(this, MetadataService);
+    (0, _defineProperty2["default"])(this, "metadataMap", new Map());
+    (0, _defineProperty2["default"])(this, "providerMap", new Map());
+    (0, _defineProperty2["default"])(this, "CONTEXT_APP", "app");
+  }
+  return (0, _createClass2["default"])(MetadataService, [{
+    key: "isLoaded",
+    value: function isLoaded(context) {
+      var ctx = context || this.CONTEXT_APP;
+      return this.metadataMap.has(ctx);
+    }
+  }, {
+    key: "load",
+    value: function () {
+      var _load = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(prefabName, prefabBaseUrl) {
+        var _state$info,
+          _ref,
+          _WM_APP_PROPERTIES,
+          _this = this;
+        var state, appConfig, baseUrl, isPreview, serviceDefSources, url, serviceDefFileName;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              state = _store.store.getState();
+              appConfig = ((_state$info = state.info) === null || _state$info === void 0 ? void 0 : _state$info.appConfig) || {};
+              baseUrl = (_ref = prefabBaseUrl !== null && prefabBaseUrl !== void 0 ? prefabBaseUrl : appConfig.url) !== null && _ref !== void 0 ? _ref : "";
+              isPreview = appConfig.isPreview || false;
+              serviceDefSources = ((_WM_APP_PROPERTIES = window._WM_APP_PROPERTIES) === null || _WM_APP_PROPERTIES === void 0 ? void 0 : _WM_APP_PROPERTIES.serviceDefSources) || "DYNAMIC";
+              serviceDefFileName = prefabName ? "".concat(prefabName, "-prefab-servicedefs.json") : "app-servicedefs.json";
+              if (isPreview || serviceDefSources === "DYNAMIC") {
+                url = prefabName && prefabName !== "__self__" ? "".concat(baseUrl, "/services/prefabs/").concat(prefabName, "/servicedefs") : "".concat(baseUrl, "/services/servicedefs");
+              } else {
+                url = "".concat(baseUrl, "/services/servicedefs/").concat(serviceDefFileName);
+              }
+              return _context.abrupt("return", new Promise(function (resolve, reject) {
+                _axios["default"].get(url, {
+                  withCredentials: true
+                }).then(function (response) {
+                  _this.metadataMap = _this.metadataMap || new Map();
+                  _this.providerMap = _this.providerMap || new Map();
+                  var responseBody = response.data || {};
+                  _this.metadataMap.set(prefabName || _this.CONTEXT_APP, responseBody.serviceDefs);
+                  if (responseBody.securityDefinitions) {
+                    _this.providerMap.set(prefabName || _this.CONTEXT_APP, responseBody.securityDefinitions);
+                  }
+                  resolve(responseBody.serviceDefs);
+                })["catch"](reject);
+              }));
+            case 8:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function load(_x, _x2) {
+        return _load.apply(this, arguments);
+      }
+      return load;
+    }()
+  }, {
+    key: "setMetadata",
+    value: function setMetadata(metadata, context) {
+      this.metadataMap.set(context || this.CONTEXT_APP, metadata);
+    }
+  }, {
+    key: "getByOperationId",
+    value: function getByOperationId(operationId, context) {
+      var ctx = context || this.CONTEXT_APP;
+      var map = this.metadataMap.get(ctx);
+      return map && map[operationId];
+    }
+  }, {
+    key: "getByProviderId",
+    value: function getByProviderId(providerId, context) {
+      var ctx = context || this.CONTEXT_APP;
+      var map = this.providerMap.get(ctx);
+      return map && map[providerId];
+    }
+  }, {
+    key: "getByCrudId",
+    value: function getByCrudId(crudId, context) {
+      var _store$getState$info;
+      var ctx = context || this.CONTEXT_APP;
+      var map = (_store$getState$info = _store.store.getState().info) === null || _store$getState$info === void 0 ? void 0 : _store$getState$info.serviceDefs;
+      if (ctx !== this.CONTEXT_APP) {
+        var _store$getState$info2;
+        map = (_store$getState$info2 = _store.store.getState().info) === null || _store$getState$info2 === void 0 || (_store$getState$info2 = _store$getState$info2.prefabs) === null || _store$getState$info2 === void 0 || (_store$getState$info2 = _store$getState$info2[ctx]) === null || _store$getState$info2 === void 0 ? void 0 : _store$getState$info2.serviceDefs;
+      }
+      var ops = [];
+      if (map) {
+        for (var _key2 in map) {
+          if (map[_key2] && map[_key2].crudOperationId === crudId) {
+            ops.push(map[_key2]);
+          }
+        }
+      }
+      return ops;
+    }
+  }, {
+    key: "getMessage",
+    value: function getMessage() {
+      // Placeholder method to match Angular interface
+    }
+  }]);
+}(); // Export singleton instance for easy usage
+var metadataService = exports.metadataService = new MetadataService();

package/variables/model-variable.d.ts

@@ -0,0 +1,12 @@
+import { VariableConfig } from "./base-variable";
+declare const ModelVariable_base: any;
+export declare class ModelVariable extends ModelVariable_base {
+    config: any;
+    lastParams: any;
+    dataSet: any;
+    private initialized;
+    constructor(config: VariableConfig);
+    invoke(params?: any, onSuccess?: Function, onError?: Function): any;
+    invokeOnParamChange(obj?: any, newVal?: any, oldVal?: any): Promise<this>;
+}
+export {};