@wavemaker-ai/react-runtime 1.0.0-rc.647684 → 12.0.0-rc.335

package/variables/crud-variable.js

@@ -9,7 +9,9 @@ import {
   internalBoundNodeMap
 } from "@wavemaker-ai/variables";
 import { VariableEvents, isStaticParamVariable } from "./base-variable";
-import { isEqual, isUndefined, isFunction, forEach, isEmpty, isArray, set } from "lodash-es";
+import { isEqual, isUndefined, isFunction, forEach, isEmpty, isArray, set, merge } from "lodash-es";
+import { metadataService } from "./metadata.service";
+import { resolveOperationParams } from "./operation-params";
 import httpService from "../hooks/useHttp";
 import { deepCopy } from "../core/util";
 import Formatters from "../core/formatters";
@@ -63,12 +65,26 @@ class CrudVariable extends _CrudVariable {
           EventNotifier.ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
         }
         return config.onError && config.onError(args.variable, args.data, args.options);
-      }
+      },
+      // Outside preview mode useHttp's send() calls variable.invokeHttp — without this the
+      // generated glue is dropped here and every CRUD call throws "invokeHttp is not a function".
+      invokeHttp: (config == null ? void 0 : config.invokeHttp) || void 0
     };
     super(variableConfig);
     this.config = config;
     __publicField(this, "params", {});
     __publicField(this, "filters", {});
+    /**
+     * The by-name params a generated invokeHttp receives. Same field name ServiceVariable uses, so
+     * useHttp's call site needs no per-kind chain. NOT `lastInvokedParams`: that name is
+     * ServiceVariable's RAW provider snapshot (compared against by invokeOnParamChange), and it is
+     * private there — reading it cross-object would also be reading a different thing.
+     */
+    __publicField(this, "resolvedParams");
+    // Which CRUD operation this call is for. A CrudVariable maps to a SET of operations
+    // (list/create/update/delete) resolved per call, so a generated invokeHttp has to be told which
+    // one to dispatch to — unlike a ServiceVariable, which is always one fixed operation.
+    __publicField(this, "lastInvokedOperation");
     this.dateFormatter = Formatters.get("toDate");
     this.init();
   }
@@ -79,6 +95,36 @@ class CrudVariable extends _CrudVariable {
       r.value = filter[r.target];
     });
   }
+  captureLastInvokedParams(options, operation) {
+    var _a, _b;
+    this.lastInvokedOperation = (_a = operation != null ? operation : options == null ? void 0 : options.operation) != null ? _a : "list";
+    let inputFields = merge({}, this.config.paramProvider(), this.dataBinding, this.params);
+    if (options) {
+      const overrides = (_b = options.inputFields) != null ? _b : options;
+      inputFields = merge({}, inputFields, overrides);
+    }
+    this.resolvedParams = this.resolveParams(inputFields, options);
+  }
+  // CrudVariableManager calls httpCall(requestParams, variable) with NO third argument (unlike
+  // Live/ServiceVariable), so a generated invokeHttp never receives this call's values by name.
+  // The manager does resolve them — onto operationInfo.parameters[].sampleValue in
+  // getMethodInfoForCrud — but keeps that local. Rebuild the same flat map from the same
+  // servicedefs entry, using the resolver shared with ServiceVariable.
+  resolveParams(inputFields, options) {
+    var _a, _b, _c, _d;
+    const defs = (_c = (_a = metadataService) == null ? void 0 : _a.getByCrudId) == null ? void 0 : _c.call(
+      _a,
+      this.config.crudOperationId,
+      (_b = this.getPrefabName) == null ? void 0 : _b.call(this)
+    );
+    const def = (defs || []).find((d) => (d == null ? void 0 : d.operationType) === this.lastInvokedOperation);
+    return resolveOperationParams({
+      parameters: (_d = def == null ? void 0 : def.wmServiceOperationInfo) == null ? void 0 : _d.parameters,
+      inputFields,
+      options,
+      config: this.config
+    });
+  }
   invokeOnParamChange() {
     const isStatic = isStaticParamVariable(this.config, this);
     if (isStatic) return isStatic;
@@ -125,21 +171,25 @@ class CrudVariable extends _CrudVariable {
     options = options || {};
     options.filterFields = this.filters;
     this.setFilterExpValue(this.filters);
+    this.captureLastInvokedParams(options, "list");
     return super.listRecords(options, onSuccess, onError);
   }
   updateRecord(options, success, error) {
     this.processBinding(this);
     this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    this.captureLastInvokedParams(options, "update");
     return super.updateRecord(options, success, error);
   }
   insertRecord(options, success, error) {
     this.processBinding(this);
     this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    this.captureLastInvokedParams(options, "create");
     return super.insertRecord(options, success, error);
   }
   deleteRecord(options, success, error) {
     this.processBinding(this);
     this.notify(VariableEvents.BEFORE_INVOKE, [this]);
+    this.captureLastInvokedParams(options, "delete");
     return super.deleteRecord(options, success, error);
   }
   processBindExp(d, variable) {
@@ -187,6 +237,7 @@ class CrudVariable extends _CrudVariable {
   }
   invoke(options, onSuccess, onError) {
     this.processBinding(this);
+    this.captureLastInvokedParams(options);
     return super.invoke(options, onSuccess, onError);
   }
 }

package/variables/live-variable.d.ts

@@ -34,6 +34,7 @@ export interface LiveVariableConfig extends VariableConfig {
     insertRecord: (options?: any, success?: any, error?: any) => Promise<any>;
     deleteRecord: (options?: any, success?: any, error?: any) => Promise<any>;
     notify: (event: VariableEvents, args: any) => void;
+    invokeHttp?: Function;
 }
 declare enum _LiveVariableEvents {
     BEFORE_INVOKE = "beforeInvoke"

package/variables/live-variable.js

@@ -66,7 +66,8 @@ class LiveVariable extends _LiveVariable {
           EventNotifier.ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
         }
         return config.onError && config.onError(args.variable, args.data, args.options);
-      }
+      },
+      invokeHttp: (config == null ? void 0 : config.invokeHttp) || void 0
     };
     super(variableConfig);
     this.config = config;

package/variables/model-variable.d.ts

@@ -8,5 +8,7 @@ export declare class ModelVariable extends ModelVariable_base {
     constructor(config: VariableConfig);
     invoke(params?: any, onSuccess?: Function, onError?: Function): any;
     invokeOnParamChange(obj?: any, newVal?: any, oldVal?: any): Promise<this>;
+    addItem(value: any, options?: any): any;
+    removeItem(index: any, options?: any): any;
 }
 export {};

package/variables/model-variable.js

@@ -70,6 +70,20 @@ class ModelVariable extends _ModelVariable {
     }
     return Promise.resolve(this);
   }
+  // addItem/removeItem (inherited from @wavemaker-ai/variables) mutate `dataSet` in place
+  // and return it, with no notification - that's precisely the bug being fixed here.
+  addItem(value, options) {
+    this.dataSet = Array.isArray(this.dataSet) ? [...this.dataSet] : __spreadValues({}, this.dataSet);
+    const result = super.addItem(value, options);
+    this.notify(VariableEvents.AFTER_INVOKE, [this, this.dataSet]);
+    return result;
+  }
+  removeItem(index, options) {
+    this.dataSet = Array.isArray(this.dataSet) ? [...this.dataSet] : __spreadValues({}, this.dataSet);
+    const result = super.removeItem(index, options);
+    this.notify(VariableEvents.AFTER_INVOKE, [this, this.dataSet]);
+    return result;
+  }
 }
 export {
   ModelVariable

package/variables/operation-params.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Port of getEvaluatedOrderBy (not exported from the package root): the options order wins, and a
+ * field ordered by both is kept only once.
+ */
+export declare function evaluatedOrderBy(varOrder: any, optionsOrder: any): any;
+export interface ResolveParamsInput {
+    /** The operation's declared parameters — `wmServiceOperationInfo.parameters`. */
+    parameters?: any[];
+    /** The values the variable already holds, keyed by param name. */
+    inputFields?: any;
+    /** The per-call options (`options.page`, `options.size`, `options.orderBy`). */
+    options?: any;
+    /** The variable's own config, for its defaults. */
+    config?: any;
+    /**
+     * ServiceVariableUtils' `isBodyTypeQueryOrProcedure` — `controller` in
+     * {QueryExecution, ProcedureExecution} and `operationType` in {put, post}. Its BODY branch
+     * assembles the body from the body param's declared children instead of reading the param's
+     * own value.
+     */
+    isBodyTypeQueryOrProcedure?: boolean;
+    /** `wmServiceOperationInfo.definitions` — keyed by a param's `type`, listing its children. */
+    definitions?: Record<string, any>;
+}
+/**
+ * Returns `inputFields` unchanged when the operation has no declared parameters — there is nothing
+ * to resolve against, so passing the raw fields through is strictly better than emptying them.
+ */
+export declare function resolveOperationParams({ parameters, inputFields, options, config, isBodyTypeQueryOrProcedure, definitions, }: ResolveParamsInput): any;

package/variables/operation-params.js

@@ -0,0 +1,69 @@
+import { includes, isEmpty, join, map, remove, split, trim } from "lodash-es";
+const PAGINATION_PARAMS = ["page", "size", "sort"];
+function evaluatedOrderBy(varOrder, optionsOrder) {
+  if (!optionsOrder || isEmpty(optionsOrder)) {
+    return varOrder;
+  }
+  if (!varOrder) {
+    return optionsOrder;
+  }
+  const varFields = split(varOrder, ",");
+  const optionFields = map(split(optionsOrder, ","), (order) => split(trim(order), " ")[0]);
+  remove(varFields, (orderBy) => includes(optionFields, split(trim(orderBy), " ")[0]));
+  return join(split(optionsOrder, ","), ",") + (varFields.length ? "," + join(varFields, ",") : "");
+}
+function buildQueryProcedureBody(param, inputFields, definitions) {
+  const children = definitions == null ? void 0 : definitions[param == null ? void 0 : param.type];
+  const wrapped = inputFields == null ? void 0 : inputFields[param == null ? void 0 : param.name];
+  const values = wrapped && typeof wrapped === "object" && !Array.isArray(wrapped) ? wrapped : inputFields;
+  const declared = (children == null ? void 0 : children.length) ? children.filter((child) => !(child == null ? void 0 : child.readOnly)) : Object.keys(values != null ? values : {}).map((name) => ({ name }));
+  const body = {};
+  for (const child of declared) {
+    const value = values == null ? void 0 : values[child.name];
+    if (value !== void 0 && value !== "" && value !== null) {
+      body[child.name] = value;
+    }
+  }
+  return body;
+}
+function resolveOperationParams({
+  parameters,
+  inputFields,
+  options,
+  config,
+  isBodyTypeQueryOrProcedure,
+  definitions
+}) {
+  var _a, _b;
+  if (!(parameters == null ? void 0 : parameters.length)) {
+    return inputFields;
+  }
+  if (isBodyTypeQueryOrProcedure) {
+    const bodyParam = parameters.find((p) => (p == null ? void 0 : p.parameterType) === "body");
+    if (bodyParam) {
+      return buildQueryProcedureBody(bodyParam, inputFields, definitions);
+    }
+  }
+  const resolved = {};
+  for (const param of parameters) {
+    if (param.readOnly) {
+      continue;
+    }
+    let value = inputFields == null ? void 0 : inputFields[param.name];
+    if (includes(PAGINATION_PARAMS, param.name)) {
+      if (param.name === "size") {
+        value = (options == null ? void 0 : options.size) || value || ((_b = (_a = config == null ? void 0 : config._paginationConfig) == null ? void 0 : _a.input) == null ? void 0 : _b.size) || parseInt(config == null ? void 0 : config.maxResults, 10);
+      } else if (param.name === "page") {
+        value = (options == null ? void 0 : options.page) || value || 1;
+      } else if (param.name === "sort") {
+        value = evaluatedOrderBy(config == null ? void 0 : config.orderBy, options == null ? void 0 : options.orderBy) || value || "";
+      }
+    }
+    resolved[param.name] = value;
+  }
+  return resolved;
+}
+export {
+  evaluatedOrderBy,
+  resolveOperationParams
+};

package/variables/service-variable.d.ts

@@ -11,6 +11,7 @@ export interface ServiceVariableConfig extends VariableConfig {
     inFlightBehavior: string;
     controller: string;
     getServiceInfo: Function;
+    invokeHttp?: Function;
 }
 declare enum _ServiceVariableEvents {
     BEFORE_INVOKE = "beforeInvoke"
@@ -24,6 +25,14 @@ export declare class ServiceVariable extends ServiceVariable_base {
     private initialized;
     params: any;
     private lastInvokedParams;
+    /**
+     * The by-name params a generated invokeHttp receives — resolved from the operation's declared
+     * parameters, so the pagination defaults the manager applies internally are present. Kept
+     * separate from lastInvokedParams, which invokeOnParamChange() compares against the RAW provider
+     * values: adding `page`/`size` to that snapshot would make every comparison unequal and
+     * re-invoke in a loop.
+     */
+    resolvedParams: any;
     private dateFormatter;
     private lastParams;
     private lastParamProviderValues;

package/variables/service-variable.js

@@ -2,6 +2,7 @@ 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 { resolveOperationParams } from "./operation-params";
 import { forEach, isEmpty, isEqual, isNumber, isObject, isString, merge } from "lodash-es";
 import { deepCopy } from "../core/util";
 import { ServiceVariable as _ServiceVariable } from "@wavemaker-ai/variables";
@@ -73,7 +74,8 @@ class ServiceVariable extends _ServiceVariable {
       },
       onBeforeDatasetReady: (context, args) => {
         return config.onBeforeDatasetReady && config.onBeforeDatasetReady(args.variable, args.data, args.options);
-      }
+      },
+      invokeHttp: (config == null ? void 0 : config.invokeHttp) || void 0
     };
     super(variableConfig);
     this.config = config;
@@ -82,6 +84,14 @@ class ServiceVariable extends _ServiceVariable {
     __publicField(this, "initialized", false);
     __publicField(this, "params");
     __publicField(this, "lastInvokedParams");
+    /**
+     * The by-name params a generated invokeHttp receives — resolved from the operation's declared
+     * parameters, so the pagination defaults the manager applies internally are present. Kept
+     * separate from lastInvokedParams, which invokeOnParamChange() compares against the RAW provider
+     * values: adding `page`/`size` to that snapshot would make every comparison unequal and
+     * re-invoke in a loop.
+     */
+    __publicField(this, "resolvedParams");
     __publicField(this, "dateFormatter");
     __publicField(this, "lastParams");
     __publicField(this, "lastParamProviderValues");
@@ -182,7 +192,7 @@ class ServiceVariable extends _ServiceVariable {
     console.log("called in onDataUpdated");
   }
   invoke(options, onSuccess, onError) {
-    var _a;
+    var _a, _b, _c;
     let inputFields = merge({}, this.config.paramProvider(), this.dataBinding, this.params);
     if (options) {
       const overrides = (_a = options.inputFields) != null ? _a : options;
@@ -204,6 +214,15 @@ class ServiceVariable extends _ServiceVariable {
     if (!this.serviceInfo) {
       console.error(`Service Info is missing for (${this.name}) variable.`);
     }
+    this.resolvedParams = resolveOperationParams({
+      parameters: (_b = this.serviceInfo) == null ? void 0 : _b.parameters,
+      inputFields,
+      options,
+      config: this.config,
+      // ServiceVariableUtils' isBodyTypeQueryOrProcedure
+      isBodyTypeQueryOrProcedure: ["QueryExecution", "ProcedureExecution"].includes(this.config.controller) && ["put", "post"].includes(this.config.operationType),
+      definitions: (_c = this.serviceInfo) == null ? void 0 : _c.definitions
+    });
     return super.invoke(options, onSuccess, onError);
   }
   setInput(key, val, options) {

package/components/data/table/utils/validation.d.ts

@@ -1,13 +0,0 @@
-import { WmTableColumnProps, FieldValidationState } from "../props";
-/**
- * Validates a single field and updates validation state
- */
-export declare const validateField: (rowId: string, fieldName: string, value: any, column: WmTableColumnProps | undefined, validationState: FieldValidationState) => boolean;
-/**
- * Resets validation state for specific context
- */
-export declare const resetValidationState: (context: "editing" | "new-row" | "all" | undefined, editingRowId: string | null, validationState: FieldValidationState) => void;
-/**
- * Updates validation errors for fields based on validation results
- */
-export declare const updateValidationErrors: (validationResult: any, relevantFieldRefs: Record<string, HTMLElement | null>, validationState: FieldValidationState) => void;

package/components/data/table/utils/validation.js

@@ -1,82 +0,0 @@
-import { forEach, entries, keys } from "lodash-es";
-const validateField = (rowId, fieldName, value, column, validationState) => {
-  var _a, _b, _c, _d, _e, _f;
-  const fieldKey = `${rowId}_${fieldName}`;
-  const { fieldRefs, fieldValidationErrors, cellUpdateCallbacks } = validationState;
-  if (!(column == null ? void 0 : column.required)) return true;
-  if ((column == null ? void 0 : column.required) && (value === void 0 || value === null || value === "")) {
-    fieldValidationErrors.current[fieldKey] = true;
-    (_b = (_a = cellUpdateCallbacks.current)[fieldKey]) == null ? void 0 : _b.call(_a);
-    return false;
-  }
-  const fieldElement = fieldRefs.current[fieldKey];
-  if (fieldElement) {
-    const input = fieldElement.querySelector("input, textarea, select");
-    if (input && !input.validity.valid) {
-      fieldValidationErrors.current[fieldKey] = true;
-      (_d = (_c = cellUpdateCallbacks.current)[fieldKey]) == null ? void 0 : _d.call(_c);
-      return false;
-    }
-  }
-  fieldValidationErrors.current[fieldKey] = false;
-  (_f = (_e = cellUpdateCallbacks.current)[fieldKey]) == null ? void 0 : _f.call(_e);
-  return true;
-};
-const resetValidationState = (context, editingRowId, validationState) => {
-  const { fieldRefs, fieldValidationErrors, cellUpdateCallbacks } = validationState;
-  if (context === "editing" && editingRowId) {
-    forEach(keys(fieldRefs.current), (key) => {
-      if (key.startsWith(`${editingRowId}_`)) {
-        delete fieldRefs.current[key];
-        delete fieldValidationErrors.current[key];
-        delete cellUpdateCallbacks.current[key];
-      }
-    });
-  } else if (context === "new-row") {
-    forEach(keys(fieldRefs.current), (key) => {
-      if (key.startsWith("new-row_")) {
-        delete fieldRefs.current[key];
-        delete fieldValidationErrors.current[key];
-        delete cellUpdateCallbacks.current[key];
-      }
-    });
-  } else {
-    forEach(keys(fieldRefs.current), (key) => {
-      delete fieldRefs.current[key];
-    });
-    fieldValidationErrors.current = {};
-    cellUpdateCallbacks.current = {};
-  }
-};
-const updateValidationErrors = (validationResult, relevantFieldRefs, validationState) => {
-  const { fieldValidationErrors, cellUpdateCallbacks } = validationState;
-  const errors = {};
-  forEach(keys(relevantFieldRefs), (fieldKey) => {
-    errors[fieldKey] = false;
-  });
-  if (validationResult.invalidFieldKeys && validationResult.invalidFieldKeys.length > 0) {
-    forEach(validationResult.invalidFieldKeys, (fieldKey) => {
-      errors[fieldKey] = true;
-    });
-  } else {
-    validationResult.invalidElements.forEach((invalidElement) => {
-      forEach(entries(relevantFieldRefs), ([fieldKey, fieldElement]) => {
-        if (fieldElement === invalidElement || (fieldElement == null ? void 0 : fieldElement.contains(invalidElement))) {
-          errors[fieldKey] = true;
-        }
-      });
-    });
-  }
-  forEach(entries(errors), ([fieldKey, hasError]) => {
-    var _a, _b;
-    if (fieldValidationErrors.current[fieldKey] !== hasError) {
-      fieldValidationErrors.current[fieldKey] = hasError;
-      (_b = (_a = cellUpdateCallbacks.current)[fieldKey]) == null ? void 0 : _b.call(_a);
-    }
-  });
-};
-export {
-  resetValidationState,
-  updateValidationErrors,
-  validateField
-};