@kosdev-code/kos-codegen-core 3.0.18 → 3.0.20

package/index.js

@@ -514,7 +514,6 @@ function generateInit(codegenFs, options) {
     modelDirectory: "lib",
     appDirectory: "app",
     components: true,
-    dataServices: true,
     internal: false,
     singleton: false,
     unitTests: true
@@ -1053,6 +1052,93 @@ function ensureModuleConst(sourceFile, spec) {
   });
   return true;
 }
+function afterImports(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  return imports.length > 0 ? imports[imports.length - 1].getChildIndex() + 1 : 0;
+}
+function unquote$1(name) {
+  return name.replace(/^["']|["']$/g, "");
+}
+function getConstCatalogLiteral(sourceFile, name) {
+  const declaration = sourceFile.getVariableDeclaration(name);
+  if (!declaration) return null;
+  let initializer = declaration.getInitializer();
+  if (tsMorph.Node.isAsExpression(initializer)) {
+    initializer = initializer.getExpression();
+  }
+  if (!initializer || !tsMorph.Node.isObjectLiteralExpression(initializer)) {
+    throw new Error(
+      `"${name}" exists in ${sourceFile.getBaseName()} but is not an object literal.`
+    );
+  }
+  return initializer;
+}
+function ensureConstCatalogEntry(sourceFile, spec) {
+  const matches = spec.equals ?? ((existing, candidate) => existing === candidate);
+  let literal = getConstCatalogLiteral(sourceFile, spec.catalogName);
+  if (!literal) {
+    sourceFile.insertVariableStatement(afterImports(sourceFile), {
+      isExported: true,
+      declarationKind: tsMorph.VariableDeclarationKind.Const,
+      declarations: [{ name: spec.catalogName, initializer: "{} as const" }]
+    });
+    literal = getConstCatalogLiteral(sourceFile, spec.catalogName);
+    if (!literal) {
+      throw new Error(`Failed to create catalog "${spec.catalogName}".`);
+    }
+    literal.addPropertyAssignment({
+      name: spec.key,
+      initializer: spec.initializer
+    });
+    return { key: spec.key, created: true };
+  }
+  for (const property of literal.getProperties().filter(tsMorph.Node.isPropertyAssignment)) {
+    const existingKey = unquote$1(property.getName());
+    const existingInitializer = property.getInitializerOrThrow().getText();
+    if (matches(existingInitializer, spec.initializer)) {
+      return { key: existingKey, created: false };
+    }
+    if (existingKey === spec.key) {
+      throw new Error(
+        `"${spec.catalogName}.${spec.key}" already exists with a different value (${existingInitializer}). Use a different methodName, or reconcile the catalog by hand.`
+      );
+    }
+  }
+  literal.addPropertyAssignment({
+    name: spec.key,
+    initializer: spec.initializer
+  });
+  return { key: spec.key, created: true };
+}
+function ensureExportedTypeAlias(sourceFile, spec) {
+  if (sourceFile.getTypeAlias(spec.name)) return false;
+  sourceFile.addTypeAlias({
+    name: spec.name,
+    type: spec.type,
+    isExported: true
+  });
+  return true;
+}
+function ensureExportedMapper(sourceFile, spec) {
+  if (sourceFile.getVariableDeclaration(spec.name)) return false;
+  sourceFile.addVariableStatement({
+    isExported: true,
+    declarationKind: tsMorph.VariableDeclarationKind.Const,
+    declarations: [
+      {
+        name: spec.name,
+        initializer: `(raw: ${spec.rawType}): ${spec.dataType} => raw`
+      }
+    ]
+  });
+  return true;
+}
+function ensureBarrelExport(sourceFile, moduleSpecifier) {
+  const present = sourceFile.getExportDeclarations().some((d) => d.getModuleSpecifierValue() === moduleSpecifier);
+  if (present) return false;
+  sourceFile.addExportDeclaration({ moduleSpecifier });
+  return true;
+}
 function addDecoratedMethod(cls, spec) {
   if (cls.getMethod(spec.name)) return false;
   cls.addMethod({
@@ -1460,20 +1546,6 @@ function generateContainerModel(codegenFs, templateDir, options, cwd, projects)
       path__namespace.join(projectRoot, options.modelDirectory || "", modelNameDashCase),
       { ...normalized, internal }
     );
-    if (options.dataServices) {
-      logger.info(`Generating data services for ${modelNameDashCase}`);
-      generateFilesFromTemplates(
-        codegenFs,
-        path__namespace.join(templateDir, "services"),
-        path__namespace.join(
-          projectRoot,
-          options.modelDirectory,
-          modelNameDashCase,
-          "services"
-        ),
-        { ...normalized, internal }
-      );
-    }
     const modelIndex = path__namespace.join(projectRoot, "index.ts");
     const modelPath = normalized.modelDirectory ? `${normalized.modelDirectory}/${modelNameDashCase}` : modelNameDashCase;
     updateModelIndex(codegenFs, modelIndex, modelPath);
@@ -1574,19 +1646,6 @@ function generateModel(params) {
     path__namespace.join(projectRoot, options.modelDirectory, normalized.nameDashCase),
     { ...normalized, internal }
   );
-  if (normalized.dataServices) {
-    generateFilesFromTemplates(
-      codegenFs,
-      path__namespace.join(modelTemplateDir, "services"),
-      path__namespace.join(
-        projectRoot,
-        options.modelDirectory,
-        normalized.nameDashCase,
-        "services"
-      ),
-      { ...normalized, internal }
-    );
-  }
   const modelIndex = path__namespace.join(projectRoot, "index.ts");
   const modelPath = options.modelDirectory ? `${options.modelDirectory}/${normalized.nameDashCase}` : normalized.nameDashCase;
   updateModelIndex(codegenFs, modelIndex, modelPath);
@@ -1617,8 +1676,7 @@ function generateModel(params) {
         ...options,
         name: `${normalized.name}-container`,
         modelName: normalized.name,
-        singleton: normalized.isContainerSingleton,
-        dataServices: normalized.dataServices
+        singleton: normalized.isContainerSingleton
       },
       cwd,
       projects
@@ -1696,6 +1754,40 @@ Pass modelPath to pick one.`
   }
   return candidates[0];
 }
+function modelBaseName(modelFilePath, modelName) {
+  const base = path__namespace.basename(modelFilePath);
+  const match = base.match(/^(.*)-model\.ts$/);
+  return match ? match[1] : modelName;
+}
+function servicesFilePathFor(modelFilePath, modelBase) {
+  return path__namespace.join(
+    path__namespace.dirname(modelFilePath),
+    "services",
+    `${modelBase}-services.ts`
+  );
+}
+function header(modelBase) {
+  return `/**
+ * Service layer for the ${modelBase} model: the endpoints it calls and the
+ * types derived from them. Standalone service functions for callers outside a
+ * model context belong here too.
+ */
+`;
+}
+function ensureServicesModule(codegenFs, modelFilePath, modelBase) {
+  const servicesFilePath = servicesFilePathFor(modelFilePath, modelBase);
+  if (!codegenFs.exists(servicesFilePath)) {
+    codegenFs.write(servicesFilePath, header(modelBase));
+  }
+  const barrelPath = path__namespace.join(path__namespace.dirname(servicesFilePath), "index.ts");
+  if (!codegenFs.exists(barrelPath)) {
+    codegenFs.write(barrelPath, "");
+  }
+  transformSourceFile(codegenFs, barrelPath, (sf) => {
+    ensureBarrelExport(sf, `./${modelBase}-services`);
+  });
+  return servicesFilePath;
+}
 function normalizeAddFutureOptions(codegenFs, options, projects) {
   const projectConfiguration = findProjectByName(
     codegenFs.root,
@@ -1730,8 +1822,7 @@ function normalizeAddFutureOptions(codegenFs, options, projects) {
     projects
   );
   const modelDirectory = path__namespace.dirname(modelFilePath);
-  const servicesDirectory = path__namespace.join(modelDirectory, "services");
-  const servicesFilePath = codegenFs.exists(servicesDirectory) ? path__namespace.join(servicesDirectory, `${nameDashCase}-services.ts`) : void 0;
+  const servicesFilePath = servicesFilePathFor(modelFilePath, nameDashCase);
   const registrationFilePath = path__namespace.join(
     modelDirectory,
     `${nameDashCase}-registration.ts`
@@ -1941,6 +2032,7 @@ class ModelFileTransformer {
     });
   }
 }
+const SDK_MODULE = "@kosdev-code/kos-ui-sdk";
 class ServiceFileTransformer {
   constructor(codegenFs, options) {
     this.codegenFs = codegenFs;
@@ -1949,162 +2041,69 @@ class ServiceFileTransformer {
   codegenFs;
   options;
   transform() {
-    const { servicesFilePath } = this.options;
-    if (!servicesFilePath || !this.codegenFs.exists(servicesFilePath)) {
-      this.createServicesFile();
-      return;
-    }
-    let content = this.codegenFs.read(servicesFilePath);
-    content = this.addFutureImports(content);
-    content = this.addFutureService(content);
-    content = this.addProgressTypes(content);
-    this.codegenFs.write(servicesFilePath, content);
-  }
-  createServicesFile() {
-    const { servicesFilePath, nameProperCase, nameDashCase, nameLowerCase } = this.options;
-    if (!servicesFilePath) {
-      return;
-    }
-    const content = `import {
-  KosLog,
-  type ClientResponse,
-  type DeepRequired,
-  type ElementType,
-  type ServiceResponse,
-  type FutureResponse
-} from '@kosdev-code/kos-ui-sdk';
-
-import API, { type KosApi, type ApiPath } from '../../../utils/service';
-
-const log = KosLog.createLogger({name: "${nameDashCase}-service", group: "Services"});
-
-const SERVICE_PATH: ApiPath = "ENTER_SERVICE_PATH"
-export type ${nameProperCase}ClientResponse = ClientResponse<
-  KosApi,
-  typeof SERVICE_PATH,
-  'get'
->;
-export type ${nameProperCase}Response = DeepRequired<${nameProperCase}ClientResponse>;
-
-/**
- * @category Service
- * Retrieves the initial ${nameLowerCase} data.
- */
-export const get${nameProperCase} = async (): Promise<ServiceResponse<${nameProperCase}Response>> => {
-  log.debug('sending GET for ${nameLowerCase}');
-  return await API.get(SERVICE_PATH);
-};
-
-/**
- * @category Service - Future Operation
- * Placeholder for a long-running operation that returns a Future for progress tracking
- *
- * Replace this with your actual long-running service operation
- */
-export const perform${nameProperCase}Operation = async (): Promise<FutureResponse> => {
-  // TODO: Implement your long-running service operation here
-  // This should return a Future that can be tracked for progress
-
-  log.debug('starting long-running ${nameLowerCase} operation');
-
-  // Example pattern:
-  // return API.post(OPERATION_SERVICE_PATH, {
-  //   // operation parameters
-  // });
-
-  // Placeholder - replace with actual implementation
-  throw new Error('perform${nameProperCase}Operation not yet implemented');
-};
-
-// Additional Future-aware service types (add as needed)
-export type ${nameProperCase}OperationProgress = {
-  // Define your progress data structure here
-  stage: string;
-  percentComplete: number;
-  currentItem?: string;
-  totalItems?: number;
-};
-
-export type ${nameProperCase}OperationResult = {
-  // Define your operation result structure here
-  success: boolean;
-  message?: string;
-  data?: any;
-};
-`;
-    this.codegenFs.write(servicesFilePath, content);
-  }
-  addFutureImports(content) {
-    if (content.includes("FutureResponse")) {
-      return content;
-    }
-    const importRegex = /import {\s*([^}]*)\s*} from '@kosdev-code\/kos-ui-sdk';/;
-    const importMatch = content.match(importRegex);
-    if (importMatch) {
-      const existingImports = importMatch[1];
-      if (existingImports.includes("FutureResponse")) {
-        return content;
-      }
-      const cleanedImports = existingImports.trim().replace(/,\s*$/, "");
-      const newImports = cleanedImports ? `${cleanedImports},
-  type FutureResponse` : `type FutureResponse`;
-      const newImportStatement = `import {
-  ${newImports}
-} from '@kosdev-code/kos-ui-sdk';`;
-      return content.replace(importMatch[0], newImportStatement);
-    }
-    return content;
+    const { modelFilePath, nameDashCase } = this.options;
+    if (!modelFilePath) return;
+    const servicesFilePath = ensureServicesModule(
+      this.codegenFs,
+      modelFilePath,
+      nameDashCase
+    );
+    transformSourceFile(this.codegenFs, servicesFilePath, (sf) => {
+      ensureNamedImport(sf, SDK_MODULE, [
+        { name: "KosLog" },
+        { name: "FutureResponse", isTypeOnly: true }
+      ]);
+      ensureModuleConst(sf, {
+        name: "log",
+        initializer: `KosLog.createLogger({ name: "${nameDashCase}-service", group: "Services" })`
+      });
+      this.addFutureOperation(sf);
+      this.addProgressTypes(sf);
+    });
   }
-  addFutureService(content) {
+  addFutureOperation(sf) {
     const { nameProperCase, nameLowerCase } = this.options;
-    if (content.includes(`perform${nameProperCase}Operation`)) {
-      return content;
-    }
-    const futureService = `
-/**
- * @category Service - Future Operation
- * Placeholder for a long-running operation that returns a Future for progress tracking
- *
- * Replace this with your actual long-running service operation
- */
-export const perform${nameProperCase}Operation = async (): Promise<FutureResponse> => {
-  // TODO: Implement your long-running service operation here
-  // This should return a Future that can be tracked for progress
-
-  log.debug('starting long-running ${nameLowerCase} operation');
-
-  // Example pattern:
-  // return API.post(OPERATION_SERVICE_PATH, {
-  //   // operation parameters
-  // });
-
-  // Placeholder - replace with actual implementation
-  throw new Error('perform${nameProperCase}Operation not yet implemented');
-};`;
-    return content + "\n" + futureService;
+    const name = `perform${nameProperCase}Operation`;
+    if (sf.getVariableDeclaration(name)) return;
+    sf.addVariableStatement({
+      isExported: true,
+      declarationKind: tsMorph.VariableDeclarationKind.Const,
+      declarations: [
+        {
+          name,
+          initializer: `async (): Promise<FutureResponse> => {
+  log.debug("starting long-running ${nameLowerCase} operation");
+  throw new Error("${name} not yet implemented");
+}`
+        }
+      ],
+      docs: [
+        {
+          description: `@category Service - Future Operation
+A long-running operation returning a Future for progress tracking. Replace the body with the real service call.`
+        }
+      ]
+    });
   }
-  addProgressTypes(content) {
+  addProgressTypes(sf) {
     const { nameProperCase } = this.options;
-    if (content.includes(`${nameProperCase}OperationProgress`)) {
-      return content;
-    }
-    const progressTypes = `
-// Additional Future-aware service types (add as needed)
-export type ${nameProperCase}OperationProgress = {
-  // Define your progress data structure here
+    ensureExportedTypeAlias(sf, {
+      name: `${nameProperCase}OperationProgress`,
+      type: `{
   stage: string;
   percentComplete: number;
   currentItem?: string;
   totalItems?: number;
-};
-
-export type ${nameProperCase}OperationResult = {
-  // Define your operation result structure here
+}`
+    });
+    ensureExportedTypeAlias(sf, {
+      name: `${nameProperCase}OperationResult`,
+      type: `{
   success: boolean;
   message?: string;
-  data?: any;
-};`;
-    return content + "\n" + progressTypes;
+  data?: unknown;
+}`
+    });
   }
 }
 class RegistrationFileTransformer {
@@ -2547,6 +2546,32 @@ function toImportSpecifier(fromFile, toFileNoExt) {
   if (!rel.startsWith(".")) rel = `./${rel}`;
   return rel;
 }
+function fromImportSpecifier(fromFile, specifier) {
+  return path__namespace.join(path__namespace.dirname(fromFile), specifier);
+}
+function assertServiceModuleAcceptsTransform(codegenFs, serviceModuleFile, modelProject) {
+  const file = `${serviceModuleFile}.ts`;
+  if (!codegenFs.exists(file)) return;
+  const typeParams = readSourceFile(codegenFs, file, (sf) => {
+    const alias = sf.getTypeAlias("EndpointCtx");
+    return alias ? alias.getTypeParameters().length : null;
+  });
+  if (typeParams === null || typeParams >= 2) return;
+  throw new Error(
+    `${file} predates the transform-aware service layer (EndpointCtx takes ${typeParams} type parameter). Run \`kosui api:generate --project ${modelProject} --helpers-only\` to refresh the helper layer in place (no spec fetch, openapi.d.ts untouched), then add the service request.`
+  );
+}
+function sameEndpoint(existing, candidate) {
+  const args = (text) => {
+    const match = text.match(
+      /^endpoint\s*\(\s*(['"])(.*?)\1\s*,\s*(['"])(.*?)\3\s*,?\s*\)$/
+    );
+    return match ? [match[2], match[4].toLowerCase()] : null;
+  };
+  const a = args(existing.trim());
+  const b = args(candidate.trim());
+  return !!a && !!b && a[0] === b[0] && a[1] === b[1];
+}
 function addServiceRequestToModel(codegenFs, options, projects) {
   const logger = getCodegenLogger();
   const { modelFilePath, sourceRoot } = resolveModelFilePath(
@@ -2557,14 +2582,15 @@ function addServiceRequestToModel(codegenFs, options, projects) {
   if (!codegenFs.exists(modelFilePath)) {
     throw new Error(`Model file not found: ${modelFilePath}`);
   }
-  let serviceImport = options.serviceModule;
-  if (!serviceImport && options.serviceModulePath) {
-    serviceImport = toImportSpecifier(
+  let serviceModuleFile;
+  if (options.serviceModulePath) {
+    serviceModuleFile = options.serviceModulePath.replace(/\.ts$/, "");
+  } else if (options.serviceModule) {
+    serviceModuleFile = fromImportSpecifier(
       modelFilePath,
-      options.serviceModulePath.replace(/\.ts$/, "")
+      options.serviceModule
     );
-  }
-  if (!serviceImport) {
+  } else {
     if (!sourceRoot) {
       throw new Error(
         "Cannot auto-resolve the service module without a project source root. Pass serviceModule."
@@ -2576,42 +2602,91 @@ function addServiceRequestToModel(codegenFs, options, projects) {
         "No generated service module found. Run `kosui api:generate` for this project first."
       );
     }
-    const specifiers = modules.map(
-      (m) => toImportSpecifier(modelFilePath, m.replace(/\.ts$/, ""))
-    );
     if (modules.length > 1) {
+      const specifiers = modules.map(
+        (m) => toImportSpecifier(modelFilePath, m.replace(/\.ts$/, ""))
+      );
       throw new Error(
         `Multiple service modules found — pass serviceModule (one of): ${specifiers.join(
           ", "
         )}`
       );
     }
-    serviceImport = specifiers[0];
+    serviceModuleFile = modules[0].replace(/\.ts$/, "");
   }
-  const method = options.method || "get";
+  assertServiceModuleAcceptsTransform(
+    codegenFs,
+    serviceModuleFile,
+    options.modelProject
+  );
+  const modelBase = modelBaseName(modelFilePath, options.modelName);
+  const servicesFilePath = servicesFilePathFor(modelFilePath, modelBase);
+  const serviceImportFromModel = toImportSpecifier(
+    modelFilePath,
+    serviceModuleFile
+  );
+  const serviceImportFromServices = toImportSpecifier(
+    servicesFilePath,
+    serviceModuleFile
+  );
+  const method = (options.method || "get").toLowerCase();
   const mode = options.mode ?? (options.lifecycle ? "lifecycle" : "method");
   const lifecycle = options.lifecycle || "LOAD";
+  const catalogName = `${pascalCase(modelBase)}Endpoints`;
   logger.info(
     `Adding ${mode}-driven @kosServiceRequest "${options.methodName}" (${method} ${options.servicePath}) to ${options.modelName}`
   );
+  ensureServicesModule(codegenFs, modelFilePath, modelBase);
+  let endpointKey = options.methodName;
+  let endpointCreated = true;
+  let dataAlias = "";
+  let mapperName = "";
+  let ctxAlias = "";
+  transformSourceFile(codegenFs, servicesFilePath, (sf) => {
+    ensureNamedImport(sf, serviceImportFromServices, [{ name: "endpoint" }]);
+    const entry = ensureConstCatalogEntry(sf, {
+      catalogName,
+      key: options.methodName,
+      initializer: `endpoint(${JSON.stringify(
+        options.servicePath
+      )}, ${JSON.stringify(method)})`,
+      equals: sameEndpoint
+    });
+    endpointKey = entry.key;
+    endpointCreated = entry.created;
+    dataAlias = `${pascalCase(endpointKey)}Data`;
+    mapperName = `to${pascalCase(endpointKey)}Data`;
+    ctxAlias = `${pascalCase(endpointKey)}Ctx`;
+    const rawType = `EndpointResponse<typeof ${catalogName}.${endpointKey}>`;
+    ensureNamedImport(sf, serviceImportFromServices, [
+      { name: "EndpointResponse", isTypeOnly: true }
+    ]);
+    ensureExportedTypeAlias(sf, { name: dataAlias, type: rawType });
+    ensureExportedMapper(sf, {
+      name: mapperName,
+      rawType,
+      dataType: dataAlias
+    });
+    if (mode === "method") {
+      ensureNamedImport(sf, serviceImportFromServices, [
+        { name: "EndpointCtx", isTypeOnly: true }
+      ]);
+      ensureExportedTypeAlias(sf, {
+        name: ctxAlias,
+        type: `EndpointCtx<typeof ${catalogName}.${endpointKey}, ${dataAlias}>`
+      });
+    }
+  });
   transformSourceFile(codegenFs, modelFilePath, (sf) => {
-    const endpointConst = endpointConstName(options.methodName);
     const className = getModelClass(sf).getName();
     if (!className) throw new Error("Model class has no name.");
     const typeParams = getModelClass(sf).getTypeParameters().map((tp) => tp.getText());
-    ensureNamedImport(sf, serviceImport, [
-      { name: "endpoint" },
-      { name: "serviceRequest" }
-    ]);
-    ensureModuleConst(sf, {
-      name: endpointConst,
-      initializer: `endpoint(${JSON.stringify(
-        options.servicePath
-      )}, ${JSON.stringify(method)})`
-    });
+    ensureNamedImport(sf, serviceImportFromModel, [{ name: "serviceRequest" }]);
     if (mode === "lifecycle") {
-      ensureNamedImport(sf, serviceImport, [
-        { name: "EndpointResponse", isTypeOnly: true }
+      ensureNamedImport(sf, "./services", [
+        { name: catalogName },
+        { name: mapperName },
+        { name: dataAlias, isTypeOnly: true }
       ]);
       ensureNamedImport(sf, resolveSdkModuleSpecifier(sf), [
         { name: "DependencyLifecycle" }
@@ -2619,25 +2694,24 @@ function addServiceRequestToModel(codegenFs, options, projects) {
       addDecoratedMethod(getModelClass(sf), {
         name: options.methodName,
         decoratorName: "serviceRequest",
-        decoratorArgsText: `${endpointConst}, { lifecycle: DependencyLifecycle.${lifecycle} }`,
+        decoratorArgsText: `${catalogName}.${endpointKey}, { lifecycle: DependencyLifecycle.${lifecycle}, transform: ${mapperName} }`,
         // The manager invokes phase handlers error-first, passing (null, data)
         // on success. The `error` half is only ever reached because
         // `serviceRequest` supplies an errorHandler — the bare decorator
         // defaults to `throw`, which fails the phase instead of calling back.
         parameters: [
           { name: "error", type: "string | null" },
-          {
-            name: "data",
-            type: `EndpointResponse<typeof ${endpointConst}>`
-          }
+          { name: "data", type: dataAlias }
         ],
         returnType: "void",
         statements: "// TODO: apply `data` to the model"
       });
       return;
     }
-    ensureNamedImport(sf, serviceImport, [
-      { name: "EndpointCtx", isTypeOnly: true }
+    ensureNamedImport(sf, "./services", [
+      { name: catalogName },
+      { name: mapperName },
+      { name: ctxAlias, isTypeOnly: true }
     ]);
     ensureNamedImport(sf, resolveSdkModuleSpecifier(sf), [
       { name: "executeServiceRequest" },
@@ -2653,15 +2727,9 @@ function addServiceRequestToModel(codegenFs, options, projects) {
     addDecoratedMethod(getModelClass(sf), {
       name: options.methodName,
       decoratorName: "serviceRequest",
-      decoratorArgsText: endpointConst,
+      decoratorArgsText: `${catalogName}.${endpointKey}, { transform: ${mapperName} }`,
       // Optional: the framework appends the context, callers never pass it.
-      parameters: [
-        {
-          name: "$ctx",
-          type: `EndpointCtx<typeof ${endpointConst}>`,
-          optional: true
-        }
-      ],
+      parameters: [{ name: "$ctx", type: ctxAlias, optional: true }],
       isAsync: true,
       returnType: "Promise<void>",
       statements: [
@@ -2671,11 +2739,14 @@ function addServiceRequestToModel(codegenFs, options, projects) {
       ].join("\n")
     });
   });
-  return { modelFilePath, serviceModule: serviceImport, mode };
-}
-function endpointConstName(methodName) {
-  const snake = methodName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").toUpperCase();
-  return `ENDPOINT_${snake}`;
+  return {
+    modelFilePath,
+    servicesFilePath,
+    serviceModule: serviceImportFromModel,
+    mode,
+    endpointKey,
+    endpointCreated
+  };
 }
 function modelElementType(typeText) {
   let m;