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

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(): LiveVariableConfig | Promise<Awaited<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,192 @@
+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 { VariableEvents, isStaticParamVariable } from "./base-variable";
+import { isEqual, isUndefined, isFunction, forEach } from "lodash-es";
+import { LiveVariable as _LiveVariable } from "@wavemaker-ai/variables";
+import httpService from "../hooks/useHttp";
+import { deepCopy } from "../core/util";
+import Formatters from "../core/formatters";
+import EventNotifier from "../core/event-notifier";
+var _LiveVariableEvents = /* @__PURE__ */ ((_LiveVariableEvents2) => {
+  _LiveVariableEvents2["BEFORE_INVOKE"] = "beforeInvoke";
+  return _LiveVariableEvents2;
+})(_LiveVariableEvents || {});
+class LiveVariable extends _LiveVariable {
+  constructor(config) {
+    if (config._context) {
+      httpService.setContext(config._context);
+    }
+    const 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: httpService,
+      httpService,
+      inFlightBehavior: config.inFlightBehavior,
+      _id: config._id,
+      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", {});
+    __publicField(this, "filterValues", {});
+    __publicField(this, "lastFilters");
+    let _dataSet = this.dataSet;
+    Object.defineProperty(this, "dataSet", {
+      get: () => _dataSet,
+      set: (val) => {
+        _dataSet = Array.isArray(val) ? [...val] : val;
+      },
+      configurable: true,
+      enumerable: true
+    });
+    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];
+    });
+  }
+  setFilter(key, val) {
+    const filterExpressions = super.setFilter(key, val);
+    const filterObj = {};
+    filterExpressions.rules.forEach((rule) => {
+      if (rule.target && rule.value !== void 0 && rule.value !== "") {
+        filterObj[rule.target] = rule.value;
+      }
+    });
+    this.filterValues = filterObj;
+    return this;
+  }
+  invokeOnParamChange() {
+    const isStatic = isStaticParamVariable(this.config, this);
+    if (isStatic) return this.config;
+    const last = this.params;
+    const latest = this.config.paramProvider();
+    if (this.config.operation === "read") {
+      const lastFilter = this.lastFilters;
+      const filterProviderResult = this.config.filterProvider && this.config.filterProvider();
+      const latestFilter = deepCopy(
+        {},
+        this.filters || {},
+        this.filterValues || {},
+        filterProviderResult || {}
+      );
+      if (this.lastFilters === void 0) {
+        this.setFilterExpValue(latestFilter);
+        this.filters = latestFilter;
+        this.lastFilters = latestFilter;
+      } else if (!isEqual(lastFilter, latestFilter)) {
+        this.setFilterExpValue(latestFilter);
+        const hasValidFilterValues = Object.values(latestFilter).some(
+          (val) => val !== void 0 && val !== null && val !== ""
+        );
+        this.filters = latestFilter;
+        this.lastFilters = latestFilter;
+        if (this.autoUpdate && hasValidFilterValues && isFunction(this.update)) {
+          this.last = latest;
+          this.params = latest;
+          this.invoke();
+          return Promise.resolve(this);
+        }
+      }
+    }
+    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.last = latest;
+        this.invoke();
+      }
+      this.params = latest;
+    }
+    return Promise.resolve(this);
+  }
+  listRecords(options, onSuccess, onError) {
+    this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    const providerFilters = this.config.filterProvider && this.config.filterProvider();
+    this.filters = deepCopy({}, providerFilters || {}, this.filterValues || {});
+    if (options) {
+      this.filters = deepCopy(
+        {},
+        this.filters,
+        options.filterFields ? options.filterFields : options
+      );
+    }
+    options = options || {};
+    options.filterFields = this.filters;
+    this.setFilterExpValue(this.filters);
+    this.lastFilters = this.filters;
+    return super.listRecords(options, onSuccess, onError);
+  }
+  updateRecord(options, success, error) {
+    this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    return super.updateRecord(options, success, error);
+  }
+  insertRecord(options, success, error) {
+    this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    return super.insertRecord(options, success, error);
+  }
+  deleteRecord(options, success, error) {
+    this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    options.row = options.row || options || {};
+    return super.deleteRecord(options, success, error);
+  }
+}
+var live_variable_default = LiveVariable;
+export {
+  live_variable_default as default
+};

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,80 @@
+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 { store } from "../store";
+import axios from "axios";
+class MetadataService {
+  constructor() {
+    __publicField(this, "metadataMap", /* @__PURE__ */ new Map());
+    __publicField(this, "providerMap", /* @__PURE__ */ new Map());
+    __publicField(this, "CONTEXT_APP", "app");
+  }
+  isLoaded(context) {
+    const ctx = context || this.CONTEXT_APP;
+    return this.metadataMap.has(ctx);
+  }
+  async load(prefabName, prefabBaseUrl) {
+    var _a, _b, _c;
+    const state = store.getState();
+    const appConfig = ((_a = state.info) == null ? void 0 : _a.appConfig) || {};
+    const baseUrl = (_b = prefabBaseUrl != null ? prefabBaseUrl : appConfig.url) != null ? _b : "";
+    const isPreview = appConfig.isPreview || false;
+    const serviceDefSources = ((_c = window._WM_APP_PROPERTIES) == null ? void 0 : _c.serviceDefSources) || "DYNAMIC";
+    let url;
+    const serviceDefFileName = prefabName ? `${prefabName}-prefab-servicedefs.json` : "app-servicedefs.json";
+    if (isPreview || serviceDefSources === "DYNAMIC") {
+      url = prefabName && prefabName !== "__self__" ? `${baseUrl}/services/prefabs/${prefabName}/servicedefs` : `${baseUrl}/services/servicedefs`;
+    } else {
+      url = `${baseUrl}/services/servicedefs/${serviceDefFileName}`;
+    }
+    return new Promise((resolve, reject) => {
+      axios.get(url, { withCredentials: true }).then((response) => {
+        this.metadataMap = this.metadataMap || /* @__PURE__ */ new Map();
+        this.providerMap = this.providerMap || /* @__PURE__ */ new Map();
+        const 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);
+    });
+  }
+  setMetadata(metadata, context) {
+    this.metadataMap.set(context || this.CONTEXT_APP, metadata);
+  }
+  getByOperationId(operationId, context) {
+    const ctx = context || this.CONTEXT_APP;
+    const map = this.metadataMap.get(ctx);
+    return map && map[operationId];
+  }
+  getByProviderId(providerId, context) {
+    const ctx = context || this.CONTEXT_APP;
+    const map = this.providerMap.get(ctx);
+    return map && map[providerId];
+  }
+  getByCrudId(crudId, context) {
+    var _a, _b, _c, _d;
+    const ctx = context || this.CONTEXT_APP;
+    let map = (_a = store.getState().info) == null ? void 0 : _a.serviceDefs;
+    if (ctx !== this.CONTEXT_APP) {
+      map = (_d = (_c = (_b = store.getState().info) == null ? void 0 : _b.prefabs) == null ? void 0 : _c[ctx]) == null ? void 0 : _d.serviceDefs;
+    }
+    const ops = [];
+    if (map) {
+      for (const key in map) {
+        if (map[key] && map[key].crudOperationId === crudId) {
+          ops.push(map[key]);
+        }
+      }
+    }
+    return ops;
+  }
+  getMessage() {
+  }
+}
+const metadataService = new MetadataService();
+export {
+  MetadataService,
+  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 {};

package/variables/model-variable.js

@@ -0,0 +1,76 @@
+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;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { clone, isEqual } from "lodash-es";
+import { VariableEvents } from "./base-variable";
+import { ModelVariable as _ModelVariable } from "@wavemaker-ai/variables";
+class ModelVariable extends _ModelVariable {
+  constructor(config) {
+    const initialData = config.paramProvider();
+    const variable = {
+      name: config.name,
+      dataSet: initialData != null ? initialData : config.isList ? [] : { dataValue: "" },
+      isList: config.isList,
+      twoWayBinding: config.twoWayBinding
+    };
+    super(variable);
+    __publicField(this, "config");
+    __publicField(this, "lastParams");
+    __publicField(this, "dataSet");
+    __publicField(this, "initialized", false);
+    this.config = config;
+    this.invoke();
+  }
+  invoke(params, onSuccess, onError) {
+    let result;
+    try {
+      const provided = this.config.paramProvider();
+      if (Array.isArray(provided)) {
+        this.dataSet = provided;
+      } else if (this.dataSet && provided) {
+        this.dataSet = Array.isArray(this.dataSet) ? provided : __spreadValues(__spreadValues({}, this.dataSet), provided);
+      } else if (this.dataSet && Object.keys(this.dataSet).length !== 0) {
+        this.dataSet = Array.isArray(this.dataSet) ? [...this.dataSet] : __spreadValues({}, this.dataSet);
+      } else {
+        this.dataSet = provided;
+      }
+      this.notify(VariableEvents.BEFORE_INVOKE, [this, this.dataSet]);
+      result = super.execute(params, () => {
+      });
+      this.config.onSuccess && this.config.onSuccess(this, this.dataSet);
+      onSuccess && onSuccess(this, this.dataSet);
+      this.notify(VariableEvents.SUCCESS, [this, this.dataSet]);
+    } catch (error) {
+      this.config.onError && this.config.onError(this, this.dataSet);
+      onError && onError(this, this.dataSet);
+      this.notify(VariableEvents.ERROR, [this, this.dataSet]);
+    }
+    this.notify(VariableEvents.AFTER_INVOKE, [this, this.dataSet]);
+    return result;
+  }
+  invokeOnParamChange(obj, newVal, oldVal) {
+    const latest = this.config.paramProvider();
+    if (!isEqual(this.lastParams, latest)) {
+      this.invoke();
+      this.lastParams = clone(latest);
+    }
+    return Promise.resolve(this);
+  }
+}
+export {
+  ModelVariable
+};

package/variables/service-variable.d.ts

@@ -0,0 +1,41 @@
+import { VariableConfig, VariableEvents } from "./base-variable";
+export interface ServiceVariableConfig extends VariableConfig {
+    baseUrl: string;
+    maxResults: number;
+    _context: any;
+    serviceType: string;
+    onCanUpdate: any;
+    onBeforeUpdate: any;
+    onResult: any;
+    onBeforeDatasetReady: any;
+    inFlightBehavior: string;
+    controller: string;
+    getServiceInfo: Function;
+}
+declare enum _ServiceVariableEvents {
+    BEFORE_INVOKE = "beforeInvoke"
+}
+export type ServiceVariableEvents = _ServiceVariableEvents | VariableEvents;
+declare const ServiceVariable_base: any;
+export declare class ServiceVariable extends ServiceVariable_base {
+    config: ServiceVariableConfig;
+    pagination: any;
+    private cancelTokenSource;
+    private initialized;
+    params: any;
+    private lastInvokedParams;
+    private dateFormatter;
+    private lastParams;
+    private lastParamProviderValues;
+    private dataBindingRequestBody;
+    constructor(config: ServiceVariableConfig);
+    private updateFirstAndLastRecord;
+    private setupEventHandlers;
+    invokeOnParamChange(obj?: any, newVal?: any, oldVal?: any): Promise<this>;
+    doNext(): Promise<unknown>;
+    onDataUpdated(): void;
+    invoke(options?: any, onSuccess?: Function, onError?: Function): any;
+    setInput(key: any, val?: any, options?: any): any;
+}
+export declare const _setInput: (targetObj: any, key: any, val: any, options?: any) => any;
+export {};