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

package/src/variables/variable.transformer.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const bind_ex_transformer_1 = __importDefault(require("../transpile/bind.ex.transformer"));
+const schema_to_ts_1 = require("../services/schema-to-ts");
+const doc_normalizer_1 = require("../services/doc-normalizer");
 const lodash_1 = require("lodash");
 function bindingValueIsStatic(value) {
     const v = Array.isArray(value) ? value[0] : value;
@@ -40,6 +42,42 @@ function isStaticParamsVariable(variable) {
     }
     return filterExpressionsAreStatic(variable.filterExpressions);
 }
+// Converts plural entity name to singular: Countries→Country, Addresses→Address, Users→User
+function simpleSingularize(plural) {
+    const lower = plural.toLowerCase();
+    if (lower.endsWith("ies"))
+        return plural.substring(0, plural.length - 3) + "y";
+    if (lower.endsWith("es"))
+        return plural.substring(0, plural.length - 2);
+    if (lower.endsWith("s"))
+        return plural.substring(0, plural.length - 1);
+    return plural;
+}
+// Converts singular entity name to plural following English morphology rules:
+// Employee→Employees, Country→Countries, Address→Addresses, Church→Churches, Day→Days
+function simplePluralize(singular) {
+    if (!singular)
+        return singular;
+    const last = singular[singular.length - 1].toLowerCase();
+    const prev = singular.length > 1 ? singular[singular.length - 2].toLowerCase() : null;
+    const vowels = "aeiouy";
+    if (last === "x" || last === "s") {
+        return singular + "es";
+    }
+    else if (last === "y") {
+        return prev !== null && vowels.includes(prev)
+            ? singular + "s" // Day → Days
+            : singular.slice(0, -1) + "ies"; // City → Cities
+    }
+    else if (last === "h") {
+        return prev !== null && (prev === "c" || prev === "s")
+            ? singular + "es" // Church→Churches, Dish→Dishes
+            : singular + "s";
+    }
+    else {
+        return singular + "s";
+    }
+}
 function parseStaticJsonValue(value) {
     const trimmedValue = value.trim();
     if (!trimmedValue.startsWith("{") && !trimmedValue.startsWith("[")) {
@@ -551,9 +589,350 @@ function transformModelVariable(variable, scope) {
     tv.isList = !!variable.isList;
     return tv;
 }
-function transformServiceVariable(variable, scope) {
+const capitalizeFirstLetter = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+/** Matches the singleton export name emitted by service.generator.ts for a given service class. */
+const getServiceInstanceName = (className) => className.charAt(0).toLowerCase() + className.slice(1);
+/**
+ * The name a generated `*.variables.ts` uses to refer to a service singleton.
+ *
+ * The singleton a service file exports is named after its own class (e.g. `departmentService` in
+ * `services/hrdb/DepartmentService.ts`) — the folder, not the name, says which backend service it
+ * belongs to. But one generated variables file can import singletons from SEVERAL services at
+ * once, and two services that share an entity name (an "Employee" in both hrdb and salesdb) would
+ * then export identically-named singletons. So the local name is qualified with the owning
+ * service id (`hrdbEmployeeService` / `salesdbEmployeeService`) and the import is aliased to it
+ * (see templates/variables.template) — keeping the generated file's own export clean while every
+ * import site stays unambiguous.
+ */
+function getServiceLocalName(serviceId, className) {
+    const instanceName = getServiceInstanceName(className);
+    if (!serviceId) {
+        return instanceName;
+    }
+    const prefix = (0, schema_to_ts_1.toPascalCase)(serviceId);
+    const core = prefix.endsWith("Service") ? prefix.slice(0, -"Service".length) : prefix;
+    // Already service-named (e.g. class SecurityService in service securityService) — the
+    // qualified form would just double the word.
+    if (className.startsWith(core)) {
+        return instanceName;
+    }
+    return getServiceInstanceName(`${core}${className}`);
+}
+/**
+ * Derives service class name from controller. Strip "Controller", separators, ensure PascalCase.
+ * Matches generated API files (apiNameSuffix=Service).
+ */
+function getServiceClassName(prefix) {
+    if (!prefix || typeof prefix !== "string")
+        return "Service";
+    // Strip separators including underscore — OpenAPI generator also removes underscores
+    // from tag names when computing class names (e.g. "Master_LOV" → "MasterLOV")
+    const base = prefix.replace(/[\s/\\\-_]+/g, "").trim();
+    if (!base)
+        return "Service";
+    let basePascal = capitalizeFirstLetter(base);
+    if (basePascal.endsWith("Controller")) {
+        basePascal = basePascal.slice(0, -"Controller".length);
+    }
+    if (!basePascal)
+        return "Service";
+    return basePascal.endsWith("Service") ? basePascal : basePascal + "Service";
+}
+/**
+ * Some operationIds are free text with spaces or other separators
+ * (e.g. "update Product Offer category", "create/update bulk rules") instead
+ * of a valid identifier. camelCase them to match the generated API method name
+ * (e.g. "updateProductOfferCategory"). Mirrors toCamelCaseIdentifier in
+ * scripts/swagger-builder.js, which sanitizes the same values before codegen.
+ */
+function toCamelCaseIdentifier(name) {
+    if (typeof name !== "string" || !/[^a-zA-Z0-9]/.test(name))
+        return name;
+    const words = name.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+    if (!words.length)
+        return name;
+    let result = words
+        .map((word, i) => (i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))
+        .join("");
+    if (/^[0-9]/.test(result))
+        result = "_" + result;
+    return result;
+}
+/**
+ * Mirrors doc-normalizer.ts's hasMultipleDistinctTags()-gated OpenAPIService behavior: a
+ * connector whose spec never tagged operations meaningfully (every operation shares one tag,
+ * often the generic placeholder "default") gets lumped into one class named after the service
+ * itself; a connector with real distinct per-entity tags (e.g. "Department"/"Employee") splits
+ * into one class per entity, same as any other service type. `variable.controller` already
+ * carries that same signal here — WM sets it to the literal "default" placeholder for the
+ * lumped case (mirroring the doc's own generic tag) and to the real entity name otherwise — so
+ * this can be decided without needing the underlying designtime doc at variable-transform time.
+ */
+function resolveServiceTag(serviceId, controller, serviceType) {
+    const isLumpedOpenApiService = serviceType === "OpenAPIService" && (!controller || controller.toLowerCase() === "default");
+    const base = isLumpedOpenApiService
+        ? serviceId.endsWith("Service")
+            ? serviceId.slice(0, -"Service".length)
+            : serviceId
+        : controller || serviceId;
+    // Real designtime tags (mirrored onto variable.controller) are often not valid identifiers
+    // as-is (e.g. "Manage - Category", "Query - Entity Lock" — spaces and hyphens straight from a
+    // human-authored Swagger tag). A bare capitalize-first-letter leaves those characters in
+    // place, producing an invalid JS/TS class/instance name for invokeHttp to call into. Must use
+    // the exact same toPascalCase() doc-normalizer.ts uses when it computes the SAME tag on the
+    // generation side, or the two computations disagree on the class name.
+    return base ? (0, schema_to_ts_1.toPascalCase)(base) : base;
+}
+/**
+ * Returns serviceFile and invokeFnName for both ServiceVariable and LiveVariable.
+ * - ServiceVariable: uses controller + operation (e.g. EmployeeService.countEmployees)
+ * - LiveVariable: uses type + operation mapping (read→filterDepartments, create→createDepartment, etc.)
+ */
+function formatServiceDetails(variable) {
+    if (variable.operationId) {
+        // Use variable.service as the authoritative service identifier so that service names
+        // containing underscores (e.g. "Master_LOV") are handled correctly.
+        // Fallback: split operationId on first "_" (legacy behaviour for variables without service field).
+        const serviceName = variable.service;
+        let prefix;
+        let invokeFnName;
+        if (serviceName) {
+            prefix = serviceName;
+            // Always rederive via the EXACT same deriveMethodName() doc-normalizer.ts uses on the
+            // generation side, with the same candidates (service id, and the operation's own
+            // controller/tag in both its raw "<Controller>Controller" and WM-cleaned forms) — this
+            // can never drift from what was actually generated, unlike trusting variable.operation
+            // (WM's own bare-action-name guess) or hand-rolling a narrower prefix-stripping rule here:
+            // - JavaService/SoapService operationIds carry a "<Controller>_" tag layer that must be
+            //   fully stripped (e.g. "GetLoggedInUserController_getUser" -> "getUser").
+            // - OpenAPIService operationIds can carry BOTH a service-id AND controller/tag layer that
+            //   must both be stripped (e.g. "hrdbSwagger_DepartmentController_getDepartment" ->
+            //   "getDepartment").
+            // - RestService single-operation connectors bake the service's own id in as their tag —
+            //   deriveMethodName() only collapses a DOUBLED prefix to one copy rather than stripping
+            //   it away (e.g. "swagger_swagger_invoke" -> "swaggerInvoke"), so two different
+            //   connectors don't collide on one generic action name; a genuinely single-prefixed one
+            //   (e.g. "CreateContractSpecification_invoke") still strips fully, to "invoke".
+            const controllerRaw = variable.controller ? `${variable.controller}Controller` : undefined;
+            const prefixCandidates = [serviceName, variable.controller, controllerRaw].filter(Boolean);
+            invokeFnName = (0, doc_normalizer_1.deriveMethodName)(variable.operationId, prefixCandidates);
+        }
+        else {
+            const sepIdx = variable.operationId.indexOf("_");
+            prefix = sepIdx >= 0 ? variable.operationId.substring(0, sepIdx) : variable.operationId;
+            invokeFnName =
+                sepIdx >= 0 ? variable.operationId.substring(sepIdx + 1) : variable.operationId;
+        }
+        // Some operationIds are free text with spaces or other separators
+        // (e.g. "update Product Offer category", "create/update bulk rules"),
+        // which isn't a valid JS identifier as-is. The generated API method name
+        // camelCases these (e.g. "updateProductOfferCategory"), so do the same
+        // here to keep the invoked method name in sync.
+        invokeFnName = toCamelCaseIdentifier(invokeFnName);
+        // variable.service is the backend service id (e.g. "hrdb", "hrdbSwagger") — the same value
+        // service.generator.ts's collected.serviceName carries. Prefer the (service, controller)
+        // pair when available (reliable, WM-Studio-provided, and required so two different backend
+        // services sharing a controller/entity name don't collide on one class) — fall back to the
+        // legacy operationId-derived `prefix` only for older variables with no `service` field.
+        const formattedServiceName = variable.service
+            ? (0, schema_to_ts_1.buildServiceClassName)(variable.service, resolveServiceTag(variable.service, variable.controller, variable.serviceType))
+            : getServiceClassName(prefix);
+        return {
+            formattedServiceName,
+            invokeFnName,
+        };
+    }
+    // LiveVariable: has type and operation, maps to API function names
+    if (variable.type && variable.operation) {
+        const entity = variable.type;
+        // Normalize to singular first (entity may arrive as singular or plural from WaveMaker).
+        // Then re-pluralize for read so the method name is always the correct plural form.
+        // e.g. "Employee" → singular="Employee" → plural="Employees" → filterEmployees
+        // e.g. "Addresses" → singular="Address" → plural="Addresses" → filterAddresses
+        const singular = simpleSingularize(entity);
+        const plural = simplePluralize(singular);
+        const operationMap = {
+            read: `filter${plural}`,
+            insert: `create${singular}`,
+            update: `edit${singular}`,
+            delete: `delete${singular}`,
+        };
+        const invokeFnName = operationMap[variable.operation];
+        if (!invokeFnName)
+            return null;
+        // variable.liveSource is the owning DataService's id (e.g. "hrdb", "salesdb") — same
+        // rationale as ServiceVariable above: prefix so two DataServices sharing an entity name
+        // (e.g. both have "Employee") don't collide on one generated class.
+        const formattedServiceName = variable.liveSource
+            ? (0, schema_to_ts_1.buildServiceClassName)(variable.liveSource, capitalizeFirstLetter(entity))
+            : capitalizeFirstLetter(entity + "Service");
+        return {
+            formattedServiceName,
+            invokeFnName,
+        };
+    }
+    return null;
+}
+/**
+ * A variable's backing service is only real if it was actually generated into
+ * services/apis/*.ts. validServiceClassNames is undefined when that hasn't been
+ * checked (e.g. direct unit tests) — in that case, skip validation entirely.
+ */
+function isServiceAvailable(className, validServiceClassNames) {
+    return !validServiceClassNames || !className || validServiceClassNames.has(className);
+}
+/**
+ * The key an argument's value actually arrives under in the params object the runtime hands
+ * `invokeHttp`.
+ *
+ * For a ServiceVariable that's the swagger parameter's own name — `inputFields` is keyed by
+ * exactly those. A LiveVariable never populates `inputFields` with its DB operation's fields:
+ * LiveVariableManager builds its own `dbOperationOptions` and that object is what reaches
+ * `invokeHttp`, keyed by the runtime's OWN names (see VARIABLE_URLS.DATABASE in
+ * @wavemaker-ai/variables' variables.constants.ts and getEntityData()'s dbOperationOptions):
+ *   - `page` / `size` / `sort` — same names, handled by the pageable branch above.
+ *   - `data` — the request payload. For a filter/search read this is the query fragment the
+ *     manager pre-builds as `"q=<query>"` (posted form-urlencoded, matching the backend's
+ *     `consumes = "application/x-www-form-urlencoded"`); for insert/update it's the entity.
+ *     Either way it is NEVER keyed by the swagger name (`q`, or the entity name for a body), so
+ *     reading the swagger name here would silently always yield `undefined` — dropping every
+ *     filter on a LiveVariable read.
+ *   - `id` — the primary key for update/delete by id.
+ */
+/**
+ * The expression the invokeHttp glue uses to source one positional argument from the runtime's
+ * flat `params` object. `page`/`size`/`sort` collapse into one `Pageable` literal; everything else
+ * reads its key. Values pass through as they arrive — base.service.ts's serializers strip any
+ * `<name>=` prefix @wavemaker-ai/variables baked in, since they already hold the wire name.
+ */
+function callArgExpression(arg, isLiveVariable, isBodyTypeQueryOrProcedure = false) {
+    // A query/procedure variable (controller QueryExecution|ProcedureExecution + post|put) does not
+    // put its body under the swagger param's name: ServiceVariableUtils calls processRequestBody(),
+    // which assembles the body from that param's CHILD fields — so inputFields is FLAT
+    // ({USERNAME, PASSWORD, ...}) with no `CreateUserRequest` key. Reading the swagger name there
+    // yields undefined and the request goes out with no body.
+    if (isBodyTypeQueryOrProcedure && arg.source.kind === "body") {
+        return "params";
+    }
+    if (arg.source.kind === "pageable") {
+        const props = arg.source.paramNames
+            .map(wireName => {
+            const prop = wireName === "sort" ? "sort" : wireName === "size" ? "pageSize" : "pageNumber";
+            return `${prop}: params?.[${JSON.stringify(wireName)}]`;
+        })
+            .join(", ");
+        return `{ ${props} }`;
+    }
+    return `params?.[${JSON.stringify(liveVariableParamKey(arg, isLiveVariable))}]`;
+}
+/**
+ * Sets the fields templates/variables.template's `invokeHttp` glue needs to call a generated
+ * service method whose signature mirrors the backend operation's own declared parameters (see
+ * src/services/method-emitter.ts): one positional argument per parameter, in declared order.
+ *
+ * `tv.callArgs` is a list of ready-to-emit JS expressions, each sourcing one argument from the
+ * flat params object the WM runtime hands `invokeHttp` — including reconstructing the single
+ * `pageable` object the backend binds page/size/sort into. `tv.serviceImportPath` is where the
+ * owning singleton lives, now that each service has its own folder and a class name alone no
+ * longer determines its path.
+ *
+ * Both come from the tables the generator itself wrote while emitting these exact methods, so a
+ * call site can never name an argument the generated method doesn't have. When the lookup isn't
+ * available (service generation didn't run — e.g. direct unit tests) `callArgs` stays undefined
+ * and the template falls back to passing the params object straight through.
+ */
+function applyServiceCallShape(tv, lookupKey, methodArgsByOperation, servicePathByOperation, isLiveVariable = false, isBodyTypeQueryOrProcedure = false) {
+    var _a;
+    const importPath = servicePathByOperation === null || servicePathByOperation === void 0 ? void 0 : servicePathByOperation.get(lookupKey);
+    if (importPath) {
+        tv.serviceImportPath = importPath;
+        // The path comes from the generator itself, so it is authoritative about WHICH class owns this
+        // operation — more so than the variable's own `controller`, which can be stale (a real case:
+        // a variable claims `controller: "Manage - Category"` for an operation the designtime doc
+        // actually tags "Manage - Product Offer Group Category"). Re-derive the class and its exported
+        // singleton from the resolved path so the import names always match the file being imported;
+        // otherwise we emit `import { manageCategoryService } from '.../ManageProductOfferGroupCategoryService'`
+        // — a module that has no such export.
+        const resolvedClassName = importPath.split("/").pop();
+        if (resolvedClassName && resolvedClassName !== tv.serviceFileClass) {
+            tv.serviceFile = resolvedClassName;
+            tv.serviceFileClass = resolvedClassName;
+            tv.serviceExportName = getServiceInstanceName(resolvedClassName);
+            tv.serviceInstanceName = getServiceLocalName((_a = tv.service) !== null && _a !== void 0 ? _a : tv.liveSource, resolvedClassName);
+        }
+    }
+    const args = methodArgsByOperation === null || methodArgsByOperation === void 0 ? void 0 : methodArgsByOperation.get(lookupKey);
+    if (!args) {
+        return;
+    }
+    // Handlebars treats an EMPTY array as falsy, so `{{#if callArgs}}` cannot distinguish "this
+    // operation takes no arguments" from "no lookup was available". A zero-arg method (e.g.
+    // `sample(ctx?)`) then fell through to the `(params, ctx)` fallback and was called with two
+    // arguments — a compile error. This flag records that the args ARE known, whatever their count.
+    tv.hasResolvedCallArgs = true;
+    // page/size/sort arrive under those exact names for BOTH variable kinds — LiveVariable's
+    // manager builds them into its dbOperationOptions, and a ServiceVariable's inputFields keys
+    // them by the swagger param names, which are also page/size/sort.
+    tv.callArgs = args.map(arg => callArgExpression(arg, isLiveVariable, isBodyTypeQueryOrProcedure));
+}
+function liveVariableParamKey(arg, isLiveVariable) {
+    const swaggerName = arg.source.paramName;
+    if (!isLiveVariable) {
+        return swaggerName;
+    }
+    switch (arg.source.kind) {
+        case "query":
+            // The only query param a LiveVariable operation declares besides the pageable trio is the
+            // filter query (`q`), which the manager delivers in `data`, already "q="-prefixed and
+            // unwrapped back to a bare value by the runtime's normalizeInvokeHttpParams().
+            return swaggerName === "q" ? "data" : swaggerName;
+        case "body":
+        case "formData":
+            return "data";
+        case "path":
+            // A LiveVariable's by-id operations receive the key as `id`, whatever the entity calls its
+            // primary key column (deptId, empId, ...).
+            return "id";
+        default:
+            return swaggerName;
+    }
+}
+function transformServiceVariable(variable, scope, validServiceClassNames, methodArgsByOperation, methodNameByOperation, servicePathByOperation) {
+    var _a;
+    // A variable whose service was never generated (no swagger definition, service removed, ...)
+    // is still emitted — just without an invokeHttp. useHttp's send() falls back to its own axios
+    // instance when `variable.invokeHttp == undefined`, so the call still goes out the pre-codegen
+    // way instead of the variable disappearing from the page.
+    const serviceDetails = formatServiceDetails(variable);
+    let skipInvokeHttp = false;
+    if (!isServiceAvailable(serviceDetails === null || serviceDetails === void 0 ? void 0 : serviceDetails.formattedServiceName, validServiceClassNames)) {
+        console.warn(`ServiceVariable "${variable.name}" references service "${variable.service}" ` +
+            `(${serviceDetails === null || serviceDetails === void 0 ? void 0 : serviceDetails.formattedServiceName}), which was not generated. Emitting the ` +
+            `variable without an invokeHttp — the runtime falls back to its own transport.`);
+        skipInvokeHttp = true;
+    }
+    // The service CLASS existing isn't enough — the specific OPERATION must exist too. A project's
+    // variable JSON can name an operationId the designtime doc no longer exposes (a real case: a
+    // variable kept an operationId for an endpoint since removed from the backend, while its
+    // service and controller are still perfectly valid). Generating for it produced a call to a
+    // method that doesn't exist AND, because the per-operation lookup missed, an import path with
+    // the service folder blank (`@/services//XService`) — a build break rather than a clear signal.
+    // When the lookup tables are available (they aren't in direct unit tests) and this operation
+    // isn't in them, treat it exactly like a missing service and skip the variable.
+    const operationKey = `${variable.service}::${variable.operationId}`;
+    if (servicePathByOperation && !servicePathByOperation.has(operationKey)) {
+        console.warn(`ServiceVariable "${variable.name}" references operation "${variable.operationId}" on ` +
+            `service "${variable.service}", which has no such operation. Emitting the variable ` +
+            `without an invokeHttp — the runtime falls back to its own transport.`);
+        skipInvokeHttp = true;
+    }
     const tv = transformVariable(variable, scope);
     tv.classname = "ServiceVariable";
+    // Gates the service import AND the invokeHttp block in the template: with no
+    // generated method to call, emitting either would not compile.
+    tv.hasInvokeHttp = !skipInvokeHttp;
     tv.operationId = variable.operationId;
     tv.isList = !!variable.isList;
     tv.inFlightBehavior = variable.inFlightBehavior;
@@ -567,6 +946,30 @@ function transformServiceVariable(variable, scope) {
     tv.autoUpdate = variable.autoUpdate;
     tv.orderBy = variable.orderBy;
     tv.isStaticParams = isStaticParamsVariable(variable);
+    tv.serviceFile = serviceDetails === null || serviceDetails === void 0 ? void 0 : serviceDetails.formattedServiceName;
+    tv.serviceFileClass = serviceDetails === null || serviceDetails === void 0 ? void 0 : serviceDetails.formattedServiceName;
+    // `serviceInstanceName` is the name used at the call site (and aliased to on import);
+    // `serviceExportName` is what the service file actually exports.
+    tv.serviceExportName =
+        serviceDetails && getServiceInstanceName(serviceDetails.formattedServiceName);
+    tv.serviceInstanceName =
+        serviceDetails && getServiceLocalName(variable.service, serviceDetails.formattedServiceName);
+    // Prefer the actual generated method name (looked up by the exact same key
+    // service.generator.ts built it with) over re-deriving it from variable.operationId via
+    // formatServiceDetails/deriveMethodName: WM doesn't always record a variable's operationId as
+    // the designtime doc's raw operationId verbatim (see NormalizedOperation.operationIdAliases),
+    // so blindly re-running the same stripping rules on a shorter/differently-prefixed alias can
+    // land on a name the generated class doesn't actually have (e.g. a doc-side "doubled prefix"
+    // operationId that collapses to "fooBar" on the generation side, but whose variable-side alias
+    // has only one prefix layer and over-strips down to bare "bar"). Falls back to the re-derived
+    // name only when the lookup can't help (service generation didn't run, e.g. direct unit tests).
+    const lookupKey = `${variable.service}::${variable.operationId}`;
+    tv.invokeFnName = (_a = methodNameByOperation === null || methodNameByOperation === void 0 ? void 0 : methodNameByOperation.get(lookupKey)) !== null && _a !== void 0 ? _a : serviceDetails === null || serviceDetails === void 0 ? void 0 : serviceDetails.invokeFnName;
+    // Mirrors ServiceVariableUtils' isBodyTypeQueryOrProcedure: a query/procedure variable's body
+    // is assembled from the body param's child fields, so its params object is flat.
+    const isBodyTypeQueryOrProcedure = ["QueryExecution", "ProcedureExecution"].includes(variable.controller) &&
+        ["put", "post"].includes(variable.operationType);
+    applyServiceCallShape(tv, lookupKey, methodArgsByOperation, servicePathByOperation, false, isBodyTypeQueryOrProcedure);
     return tv;
 }
 function transformNavigationAction(variable, scope) {
@@ -596,11 +999,13 @@ function transformNotificationAction(variable, scope, imports) {
     tv.classname = "NotificationAction";
     tv.group = "action";
     tv.operation = variable.operation;
-    const partialContent = Array.isArray(variable.dataBinding)
-        ? variable.dataBinding.filter((binding) => {
-            return binding.target === "page";
-        })[0]
-        : null;
+    const bindings = Array.isArray(variable.dataBinding) ? variable.dataBinding : [];
+    const getBinding = (target) => bindings.find((b) => b.target === target);
+    const contentBinding = getBinding("content");
+    const rendersPartial = contentBinding
+        ? contentBinding.value === "page"
+        : variable.operation !== "toast";
+    const partialContent = rendersPartial ? getBinding("page") : null;
     if (variable.onOk || variable.onClick) {
         tv.onOk = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onOk || variable.onClick, scope, "event"), ";");
     }
@@ -658,9 +1063,91 @@ function transformLogoutVariable(variable, scope) {
     tv.redirectTo = variable.redirectTo;
     return tv;
 }
-function transformLiveVariable(variable, scope) {
+/**
+ * The `${serviceName}::${operationIdAlias}` key of the operation whose GENERATED method is named
+ * `methodName` on service `serviceName`. LiveVariables identify their operation by that derived
+ * method name rather than by a doc operationId (they have none), so this reverses the
+ * methodNameByOperation table to reach the other per-operation lookups keyed the same way.
+ */
+function findOperationKeyByMethodName(serviceName, methodName, methodNameByOperation) {
+    if (!serviceName || !methodName || !methodNameByOperation) {
+        return undefined;
+    }
+    const prefix = `${serviceName}::`;
+    for (const [key, name] of methodNameByOperation) {
+        if (name === methodName && key.startsWith(prefix)) {
+            return key;
+        }
+    }
+    return undefined;
+}
+/**
+ * Fallback for when findOperationKeyByMethodName's guessed name (built via
+ * simpleSingularize/simplePluralize) doesn't match anything real: those are an English-stemming
+ * HEURISTIC, and WM entity names aren't always actual English plurals to begin with — an entity
+ * literally named "AllTypes" has no distinct singular in WM's own generated methods at all
+ * (`findAllTypes`, `createAllTypes`, `filterAllTypes`, `deleteAllTypes` all keep "AllTypes"
+ * unchanged), so the stemmer's round-trip ("AllTypes" -> "AllTyp" -> "AllTyps") produces a name
+ * nothing was ever generated as, and the reverse lookup silently misses.
+ *
+ * WM's own raw operationId for a Data Service entity operation is always
+ * `<entity>Controller_<verb><NameVariant>` — the verb always comes right after the tag,
+ * regardless of what spelling variant WM chose for NameVariant. Searching by that verb prefix
+ * against the RAW (un-derived) key finds the real operation without having to guess the spelling
+ * variant at all. Among ties (e.g. an association method like `findAssociatedEmployees` also
+ * starting with "find"), the shortest key wins — the plain CRUD operation, not one with an extra
+ * qualifier tacked on.
+ */
+function findLiveOperationKeyByVerb(liveSource, entity, verbTokens, methodNameByOperation) {
+    if (!liveSource || !entity || !methodNameByOperation) {
+        return undefined;
+    }
+    const tagPrefix = `${liveSource}::${entity}Controller_`;
+    let best;
+    for (const key of methodNameByOperation.keys()) {
+        if (!key.startsWith(tagPrefix))
+            continue;
+        const verbAndName = key.slice(tagPrefix.length);
+        if (!verbTokens.some(verb => verbAndName.startsWith(verb)))
+            continue;
+        if (!best || key.length < best.length) {
+            best = key;
+        }
+    }
+    return best;
+}
+/** WM's own verb token for each DataService action — the literal prefix its raw operationId's tail (after `<Entity>Controller_`) always starts with, independent of the entity's own singular/plural spelling. */
+const LIVE_OPERATION_VERBS = {
+    readTableData: ["find"],
+    searchTableDataWithQuery: ["filter"],
+    searchTableData: ["search"],
+    insertTableData: ["create"],
+    updateTableData: ["edit"],
+    deleteTableData: ["delete"],
+};
+/** Which DataService action formatServiceDetails' operationMap maps each `variable.operation` value to — mirrors that map's own verb choice (read -> filter/searchTableDataWithQuery, not find/readTableData) so the fallback resolves the SAME operation the guessed name was aiming for. */
+const LIVE_DEFAULT_ACTION_BY_OPERATION = {
+    read: "searchTableDataWithQuery",
+    insert: "insertTableData",
+    update: "updateTableData",
+    delete: "deleteTableData",
+};
+function transformLiveVariable(variable, scope, validServiceClassNames, methodArgsByOperation, methodNameByOperation, servicePathByOperation) {
+    var _a, _b;
+    const serviceDetails = formatServiceDetails(variable);
+    let skipInvokeHttp = false;
+    if (serviceDetails &&
+        !isServiceAvailable(serviceDetails.formattedServiceName, validServiceClassNames)) {
+        console.warn(`LiveVariable "${variable.name}" targets entity "${variable.type}" ` +
+            `(${serviceDetails.formattedServiceName}), which was not generated. Emitting the ` +
+            `variable without an invokeHttp — the runtime falls back to its own transport.`);
+        skipInvokeHttp = true;
+    }
     const tv = transformVariable(variable, scope);
     tv.classname = "LiveVariable";
+    // Gates the service import AND the invokeHttp block in the template: with no
+    // generated method to call, emitting either would not compile.
+    tv.hasInvokeHttp = !skipInvokeHttp;
     tv.isList = !!variable.isList;
     tv.inFlightBehavior = variable.inFlightBehavior;
     tv.maxResults = variable.maxResults;
@@ -677,9 +1164,132 @@ function transformLiveVariable(variable, scope) {
     tv.filterExpressions = variable.filterExpressions;
     tv._id = variable._id;
     tv.isStaticParams = isStaticParamsVariable(variable);
+    if (serviceDetails) {
+        tv.serviceFile = serviceDetails.formattedServiceName;
+        tv.serviceFileClass = serviceDetails.formattedServiceName;
+        tv.serviceExportName = getServiceInstanceName(serviceDetails.formattedServiceName);
+        tv.serviceInstanceName = getServiceLocalName(variable.liveSource, serviceDetails.formattedServiceName);
+        tv.invokeFnName = serviceDetails.invokeFnName;
+        // A LiveVariable has no raw `operationId` to key the sidecar lookups with — its method name
+        // is derived from its operation instead (read -> filterDepartments, insert ->
+        // createDepartment, ...). Resolve the same tables by that derived METHOD NAME, which the
+        // generator also indexes (see findOperationKeyByMethodName), so a LiveVariable's generated
+        // call gets the same correct positional arguments a ServiceVariable's does.
+        let lookupKey = findOperationKeyByMethodName(variable.liveSource, serviceDetails.invokeFnName, methodNameByOperation);
+        // The guessed name above is an English-stemming heuristic and can miss for entity names that
+        // aren't real English plurals (see findLiveOperationKeyByVerb) — fall back to a verb-prefix
+        // search against the raw operationId, which needs no such guess.
+        if (!lookupKey) {
+            lookupKey = findLiveOperationKeyByVerb(variable.liveSource, variable.type, (_a = LIVE_OPERATION_VERBS[LIVE_DEFAULT_ACTION_BY_OPERATION[variable.operation]]) !== null && _a !== void 0 ? _a : [], methodNameByOperation);
+        }
+        if (lookupKey) {
+            // The fallback resolves the operation independently of the guessed name, so the guess
+            // itself may still be wrong — realign tv.invokeFnName to the actual generated method name
+            // rather than leaving the mismatched guess in place (this is the value applyServiceCallShape
+            // uses at the top level when liveTargets ends up empty and the template falls back to it).
+            tv.invokeFnName = (_b = methodNameByOperation === null || methodNameByOperation === void 0 ? void 0 : methodNameByOperation.get(lookupKey)) !== null && _b !== void 0 ? _b : tv.invokeFnName;
+            applyServiceCallShape(tv, lookupKey, methodArgsByOperation, servicePathByOperation, true // LiveVariable — its params object is keyed by the runtime's own DB-operation names
+            );
+        }
+        // `variable.operation` is only the DEFAULT operation — the one `.invoke()` runs. Every
+        // LiveVariable carries all four record methods (see live-variable.ts's DataSource.Operation
+        // switch), and a table bound to it as `datasource` calls insert/update/delete on THAT
+        // variable, not on some other one. Emitting only the default meant a grid edit on a
+        // `read` variable ran filterX with the row data. So resolve all four and let the glue
+        // dispatch on the DB operation the manager passes in `params.operation`.
+        tv.liveTargets = buildLiveTargets(variable, methodArgsByOperation, methodNameByOperation, servicePathByOperation);
+    }
     return tv;
 }
-function transformCrudVariable(variable, scope) {
+/**
+ * A LiveVariable's invokeHttp targets, one per DB operation the runtime can ask it for.
+ *
+ * Keyed by the manager's own action names (`params.operation`, set in
+ * live-variable.manager.ts). Only the operations whose method actually generated are included, so
+ * a service missing (say) a delete endpoint simply has no `delete` case rather than a call to a
+ * method that does not exist.
+ */
+function buildLiveTargets(variable, methodArgsByOperation, methodNameByOperation, servicePathByOperation) {
+    var _a, _b, _c;
+    const entity = variable.type;
+    if (!entity) {
+        return undefined;
+    }
+    const singular = simpleSingularize(entity);
+    const plural = simplePluralize(singular);
+    // The manager's action -> the generated method for it. Each action is a DISTINCT backend
+    // endpoint with its own body shape, so they cannot share one method:
+    //   readTableData / searchTableDataWithQuery -> POST /<entity>/filter, body `q=<query string>`
+    //   searchTableData          -> POST /<entity>/search, body a QueryFilter[] ARRAY
+    // Collapsing any two of these sent the wrong body to the wrong route and silently matched
+    // nothing.
+    const byAction = [
+        // readTableData's template is `GET /<entity>?page=&size=&:sort` — the collection GET, which
+        // the generator names find<Plural>. filter<Plural> is the POST /filter twin and belongs only
+        // to the query-bearing actions.
+        ["readTableData", `find${plural}`],
+        ["searchTableDataWithQuery", `filter${plural}`],
+        ["searchTableData", `search${plural}ByQueryFilters`],
+        ["insertTableData", `create${singular}`],
+        ["updateTableData", `edit${singular}`],
+        ["deleteTableData", `delete${singular}`],
+    ];
+    // All four methods for one entity are emitted onto ONE class (the entity's own service), and a
+    // LiveVariable is pinned to a single liveSource — so every target shares the variable's own
+    // import and instance. Only the method name and its argument list differ per action.
+    const targets = [];
+    for (const [action, guessedMethodName] of byAction) {
+        let lookupKey = findOperationKeyByMethodName(variable.liveSource, guessedMethodName, methodNameByOperation);
+        // Same English-stemming-guess-can-miss situation as transformLiveVariable's default target
+        // above — fall back to a verb-prefix search that needs no singular/plural guess at all.
+        if (!lookupKey) {
+            lookupKey = findLiveOperationKeyByVerb(variable.liveSource, entity, (_a = LIVE_OPERATION_VERBS[action]) !== null && _a !== void 0 ? _a : [], methodNameByOperation);
+        }
+        if (!lookupKey || (servicePathByOperation && !servicePathByOperation.has(lookupKey))) {
+            continue; // that operation was not generated for this entity
+        }
+        // The fallback resolves independently of the guess, so use the actual generated method name
+        // (methodNameByOperation's own value for this key) rather than the possibly-wrong guess.
+        const methodName = (_b = methodNameByOperation === null || methodNameByOperation === void 0 ? void 0 : methodNameByOperation.get(lookupKey)) !== null && _b !== void 0 ? _b : guessedMethodName;
+        const shape = {};
+        applyServiceCallShape(shape, lookupKey, methodArgsByOperation, servicePathByOperation, true);
+        targets.push({
+            action,
+            invokeFnName: methodName,
+            callArgs: (_c = shape.callArgs) !== null && _c !== void 0 ? _c : [],
+            hasResolvedCallArgs: !!shape.hasResolvedCallArgs,
+        });
+    }
+    return targets.length ? targets : undefined;
+}
+/**
+ * A CrudVariable's invokeHttp targets, keyed by operationType.
+ *
+ * Unlike a ServiceVariable (one fixed operation), a CrudVariable names a GROUP whose member is
+ * chosen per call, so the glue dispatches on the operation the runtime records for that call.
+ * Each entry carries everything the call needs: the singleton to import, its local alias, the
+ * method, and how to source each positional argument.
+ */
+function buildCrudTargets(variable, crudOperationsById) {
+    const group = crudOperationsById === null || crudOperationsById === void 0 ? void 0 : crudOperationsById.get(variable.crudOperationId);
+    if (!group) {
+        return undefined;
+    }
+    const targets = Object.entries(group).map(([operationType, target]) => {
+        const className = target.importPath.split("/").pop();
+        return {
+            operationType,
+            importPath: target.importPath,
+            serviceExportName: getServiceInstanceName(className),
+            serviceInstanceName: getServiceLocalName(variable.service, className),
+            invokeFnName: target.methodName,
+            // A CrudVariable is never a LiveVariable, so params are keyed by the swagger names.
+            callArgs: target.args.map(arg => callArgExpression(arg, false)),
+        };
+    });
+    return targets.length ? targets : undefined;
+}
+function transformCrudVariable(variable, scope, crudOperationsById) {
     const tv = transformVariable(variable, scope);
     tv._id = variable._id;
     tv.name = variable.name;
@@ -705,15 +1315,16 @@ function transformCrudVariable(variable, scope) {
     tv.dataBinding = variable._transformedDataBinding || variable.dataBinding;
     tv.classname = "CrudVariable";
     tv.group = "variable";
+    tv.crudTargets = buildCrudTargets(variable, crudOperationsById);
     tv.isStaticParams = isStaticParamsVariable(variable);
     return tv;
 }
-exports.default = (variable, scope, appUrl, imports) => {
+exports.default = (variable, scope, appUrl, imports, validServiceClassNames, methodArgsByOperation, methodNameByOperation, servicePathByOperation, crudOperationsById) => {
     switch (variable.category) {
         case "wm.Variable":
             return transformModelVariable(variable, scope);
         case "wm.ServiceVariable":
-            return transformServiceVariable(variable, scope);
+            return transformServiceVariable(variable, scope, validServiceClassNames, methodArgsByOperation, methodNameByOperation, servicePathByOperation);
         case "wm.NavigationAction":
             return transformNavigationAction(variable, scope);
         case "wm.TimerAction":
@@ -727,9 +1338,9 @@ exports.default = (variable, scope, appUrl, imports) => {
         case "wm.LogoutAction":
             return transformLogoutVariable(variable, scope);
         case "wm.LiveVariable":
-            return transformLiveVariable(variable, scope);
+            return transformLiveVariable(variable, scope, validServiceClassNames, methodArgsByOperation, methodNameByOperation, servicePathByOperation);
         case "wm.CrudVariable":
-            return transformCrudVariable(variable, scope);
+            return transformCrudVariable(variable, scope, crudOperationsById);
     }
     return null;
 };