wlmaker 1.2.9 → 1.2.11

package/dist/cli.mjs

@@ -968,139 +968,49 @@ import * as path8 from "path";
 import chalk4 from "chalk";
 import { pascalCase as pascalCase4, camelCase } from "change-case";
 
-// src/core/json-to-dart.ts
-function jsonToFields(jsonStr) {
-  const parsed = JSON.parse(jsonStr);
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error("Expected a JSON object at the top level");
-  }
-  return objectToFields(parsed);
-}
-function objectToFields(obj) {
-  const fields = [];
-  for (const [key, value] of Object.entries(obj)) {
-    fields.push({
-      name: key,
-      dartType: dartTypeOf(value, key),
-      isNullable: value === null
-    });
-  }
-  return fields;
-}
-function dartTypeOf(value, nameHint) {
-  if (value === null) return "dynamic";
-  if (typeof value === "string") return "String";
-  if (typeof value === "boolean") return "bool";
-  if (typeof value === "number") {
-    return Number.isInteger(value) ? "int" : "double";
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "List<dynamic>";
-    const elementType = dartTypeOf(value[0], nameHint);
-    return `List<${elementType}>`;
-  }
-  if (typeof value === "object") {
-    return "Map<String, dynamic>";
-  }
-  return "dynamic";
-}
-function fieldsToConstructorParams(fields, indent = "    ") {
-  return fields.map((f) => {
-    const nullable = f.isNullable ? "?" : "";
-    return `${indent}required ${f.dartType}${nullable} ${f.name},`;
-  }).join("\n");
-}
-function fieldsToFromJson(fields, modelName) {
-  const entries = fields.map((f) => {
-    if (f.dartType.startsWith("List<")) {
-      return `      ${f.name}: (${_jsonFieldName(f)} as List<dynamic>).map((e) => e as ${_extractGenericType(f.dartType)}).toList(),`;
-    }
-    return `      ${f.name}: ${_jsonFieldName(f)} as ${f.dartType}${f.isNullable ? "?" : ""},`;
-  }).join("\n");
-  return `factory ${modelName}.fromJson(Map<String, dynamic> json) => ${modelName}(
-${entries}
-    );`;
-}
-function fieldsToJson(fields, modelName) {
-  const entries = fields.map((f) => `      '${f.name}': ${f.name},`).join("\n");
-  return `Map<String, dynamic> toJson() => {
-${entries}
-    };`;
-}
-function _jsonFieldName(f) {
-  return `json['${f.name}']`;
-}
-function _extractGenericType(listType) {
-  const match = listType.match(/^List<(.+)>$/);
-  return match ? match[1] : "dynamic";
-}
-
 // src/core/endpoint-templates.ts
-function entityTemplate(name, pascal, fields) {
-  const params = fieldsToConstructorParams(fields);
-  const props = fields.map((f) => {
-    const nullable = f.isNullable ? "?" : "";
-    return `  final ${f.dartType}${nullable} ${f.name};`;
-  }).join("\n");
+function entityBoilerplate(pascal) {
   return `class ${pascal}Entity {
-${props}
+  // TODO: Define fields
 
-  const ${pascal}Entity({
-${params}
-  });
+  const ${pascal}Entity();
 }
 `;
 }
-function modelTemplate(name, pascal, fields) {
-  const params = fieldsToConstructorParams(fields);
-  const props = fields.map((f) => {
-    const nullable = f.isNullable ? "?" : "";
-    return `  final ${f.dartType}${nullable} ${f.name};`;
-  }).join("\n");
-  const fromJson = fieldsToFromJson(fields, `${pascal}Model`);
-  const toJson = fieldsToJson(fields, `${pascal}Model`);
-  return `import 'package:json_annotation/json_annotation.dart';
-import '../../domain/entities/${name}/${name}_entity.dart';
+function modelBoilerplate(name, pascal, projectName) {
+  return `import 'package:${projectName}/core.dart';
+import 'package:json_annotation/json_annotation.dart';
 
 part '${name}_model.g.dart';
 
-@JsonSerializable()
-class ${pascal}Model extends ${pascal}Entity {
-  const ${pascal}Model({
-${params}
-  }) : super(
-${fields.map((f) => `      ${f.name}: ${f.name},`).join("\n")}
-  );
+@JsonSerializable(createToJson: true)
+class ${pascal}Model {
+  // TODO: Define constructor parameters and fields
 
-  ${fromJson}
-
-  ${toJson}
+  const ${pascal}Model();
 
   factory ${pascal}Model.fromJson(Map<String, dynamic> json) =>
       _$${pascal}ModelFromJson(json);
 
-  @override
+  ${pascal}Entity toEntity() {
+    // TODO: Implement toEntity mapping
+    throw UnimplementedError();
+  }
+
   Map<String, dynamic> toJson() => _$${pascal}ModelToJson(this);
 }
 `;
 }
-function requestModelTemplate(name, pascal, fields) {
-  const params = fieldsToConstructorParams(fields);
-  const props = fields.map((f) => {
-    const nullable = f.isNullable ? "?" : "";
-    return `  final ${f.dartType}${nullable} ${f.name};`;
-  }).join("\n");
+function requestModelBoilerplate(name, pascal) {
   return `import 'package:json_annotation/json_annotation.dart';
 
 part '${name}_request_model.g.dart';
 
-@JsonSerializable()
+@JsonSerializable(createToJson: true)
 class ${pascal}RequestModel {
-${props}
+  // TODO: Define constructor parameters and fields
 
-  ${pascal}RequestModel({
-${params}
-  });
+  const ${pascal}RequestModel();
 
   factory ${pascal}RequestModel.fromJson(Map<String, dynamic> json) =>
       _$${pascal}RequestModelFromJson(json);
@@ -1156,12 +1066,13 @@ function repositoryInterfaceMethod(methodName, returnType, params) {
   const paramList = params.map((p) => `${p.type} ${p.name}`).join(", ");
   return `Future<${returnType}> ${methodName}(${paramList});`;
 }
-function repositoryImplMethod(methodName, returnType, params, datasourceName) {
+function repositoryImplMethod(methodName, returnType, modelType, params, datasourceName) {
   const paramList = params.map((p) => `${p.type} ${p.name}`).join(", ");
   const args = params.map((p) => p.name).join(", ");
   return `@override
   Future<${returnType}> ${methodName}(${paramList}) async {
-    return await ${datasourceName}.${methodName}(${args});
+    final model = await ${datasourceName}.${methodName}(${args});
+    return model.toEntity();
   }`;
 }
 
@@ -1234,102 +1145,108 @@ function injectExport(filePath, exportLine) {
 // src/core/create-endpoint.ts
 async function createEndpoint(options) {
   const lib = path8.join(options.projectRoot, "lib");
-  const pascal = pascalCase4(options.responseModelName);
+  const pascal = pascalCase4(options.useCaseName);
   const useCasePascal = pascalCase4(options.useCaseName);
   const useCaseSnake = options.useCaseName;
-  const hasRequestBody = ["POST", "PUT", "PATCH"].includes(options.httpMethod) && options.requestFields;
+  const needsBody = ["POST", "PUT", "PATCH"].includes(options.httpMethod);
+  const domain = extractDomain(options.bffApiFile);
+  const datasourceFile = path8.join(lib, "data", "datasources", `${domain}_rest_datasource.dart`);
+  const datasourceClassName = `${pascalCase4(domain)}RestDataSource`;
+  const repositoryInterfaceFile = path8.join(lib, "domain", "repositories", `${domain}_repository.dart`);
+  const repositoryInterfaceName = `${pascalCase4(domain)}Repository`;
+  const repositoryImplFile = path8.join(lib, "data", "repositories", `${domain}_repository_data.dart`);
+  const repositoryImplClassName = `${pascalCase4(domain)}RepositoryData`;
+  const feature = domain;
   const pathParams = extractPathParams(options.endpointPath);
-  const methodParams = buildMethodParams(options, pathParams, hasRequestBody);
+  const methodParams = buildMethodParams(options, pathParams, needsBody);
   const methodParamsForSignature = methodParams.map((p) => ({ name: p.name, type: p.type }));
-  const returnType = `${pascal}Entity`;
-  const repositoryInterfaceSnake = path8.basename(options.repositoryInterfaceFile, ".dart");
+  const modelType = `${pascal}Model`;
+  const entityType = `${pascal}Entity`;
+  const repositoryInterfaceSnake = path8.basename(repositoryInterfaceFile, ".dart");
   const spinner2 = (msg) => console.log(chalk4.cyan(`  \u2192 ${msg}`));
-  if (options.responseFields && options.responseFields.length > 0) {
-    spinner2("Generating entity");
-    const entityDir = path8.join(lib, "domain", "entities", options.feature);
-    fs9.mkdirSync(entityDir, { recursive: true });
-    fs9.writeFileSync(
-      path8.join(entityDir, `${options.responseModelName}_entity.dart`),
-      entityTemplate(options.responseModelName, pascal, options.responseFields)
-    );
-    spinner2("Generating model");
-    const modelDir = path8.join(lib, "data", "models", options.feature);
-    fs9.mkdirSync(modelDir, { recursive: true });
-    fs9.writeFileSync(
-      path8.join(modelDir, `${options.responseModelName}_model.dart`),
-      modelTemplate(options.responseModelName, pascal, options.responseFields)
-    );
-  }
-  if (hasRequestBody && options.requestFields && options.requestModelName) {
+  spinner2("Generating entity");
+  const entityDir = path8.join(lib, "domain", "entities", feature);
+  fs9.mkdirSync(entityDir, { recursive: true });
+  fs9.writeFileSync(
+    path8.join(entityDir, `${useCaseSnake}_entity.dart`),
+    entityBoilerplate(pascal)
+  );
+  spinner2("Generating model");
+  const modelDir = path8.join(lib, "data", "models", feature);
+  fs9.mkdirSync(modelDir, { recursive: true });
+  fs9.writeFileSync(
+    path8.join(modelDir, `${useCaseSnake}_model.dart`),
+    modelBoilerplate(useCaseSnake, pascal, options.projectName)
+  );
+  if (needsBody) {
     spinner2("Generating request model");
-    const reqPascal = pascalCase4(options.requestModelName);
-    const reqModelDir = path8.join(lib, "data", "models", options.feature);
+    const reqModelDir = path8.join(lib, "data", "models", feature);
     fs9.mkdirSync(reqModelDir, { recursive: true });
     fs9.writeFileSync(
-      path8.join(reqModelDir, `${options.requestModelName}_request_model.dart`),
-      requestModelTemplate(options.requestModelName, reqPascal, options.requestFields)
+      path8.join(reqModelDir, `${useCaseSnake}_request_model.dart`),
+      requestModelBoilerplate(useCaseSnake, pascal)
     );
   }
   spinner2("Injecting Retrofit method");
   const bffPath = path8.resolve(options.bffApiFile);
   if (fs9.existsSync(bffPath)) {
-    const retrofitParams = buildRetrofitParams(options, pathParams, hasRequestBody);
-    const retrofitReturnType = `${pascal}Model`;
+    const retrofitParams = buildRetrofitParams(options, pathParams, needsBody);
     const method = retrofitMethod(
       camelCase(options.useCaseName),
       options.endpointPath,
       options.httpMethod,
       retrofitParams,
-      retrofitReturnType
+      modelType
     );
     injectMethod(bffPath, extractClassName(bffPath), method);
-    const modelImport = `import 'package:${options.feature}/data/models/${options.responseModelName}/${options.responseModelName}_model.dart';`;
+    const modelImport = `import 'package:${options.projectName}/data/models/${feature}/${useCaseSnake}_model.dart';`;
     injectImport(bffPath, modelImport);
   } else {
     console.log(chalk4.yellow(`  \u26A0 BFF API file not found: ${bffPath}`));
   }
   spinner2("Injecting datasource method");
-  const dsPath = path8.resolve(options.datasourceFile);
+  const dsPath = path8.resolve(datasourceFile);
   if (fs9.existsSync(dsPath)) {
     const dsMethod = datasourceMethod(
       camelCase(options.useCaseName),
-      returnType,
+      modelType,
       methodParamsForSignature
     );
-    injectMethod(dsPath, options.datasourceClassName, dsMethod);
+    injectMethod(dsPath, datasourceClassName, dsMethod);
   } else {
     console.log(chalk4.yellow(`  \u26A0 Datasource file not found: ${dsPath}`));
   }
   spinner2("Injecting repository interface method");
-  const repoIfacePath = path8.resolve(options.repositoryInterfaceFile);
+  const repoIfacePath = path8.resolve(repositoryInterfaceFile);
   if (fs9.existsSync(repoIfacePath)) {
     const ifaceMethod = repositoryInterfaceMethod(
       camelCase(options.useCaseName),
-      returnType,
+      entityType,
       methodParamsForSignature
     );
-    injectMethod(repoIfacePath, options.repositoryInterfaceName, ifaceMethod);
-    const entityImport = `import 'package:${options.feature}/domain/entities/${options.responseModelName}/${options.responseModelName}_entity.dart';`;
+    injectMethod(repoIfacePath, repositoryInterfaceName, ifaceMethod);
+    const entityImport = `import 'package:${options.projectName}/domain/entities/${feature}/${useCaseSnake}_entity.dart';`;
     injectImport(repoIfacePath, entityImport);
   } else {
     console.log(chalk4.yellow(`  \u26A0 Repository interface not found: ${repoIfacePath}`));
   }
-  spinner2("Injectating repository implementation method");
-  const repoImplPath = path8.resolve(options.repositoryImplFile);
+  spinner2("Injecting repository implementation method");
+  const repoImplPath = path8.resolve(repositoryImplFile);
   if (fs9.existsSync(repoImplPath)) {
-    const dsVarName = camelCase(options.datasourceClassName);
+    const dsVarName = camelCase(datasourceClassName);
     const implMethod = repositoryImplMethod(
       camelCase(options.useCaseName),
-      returnType,
+      entityType,
+      modelType,
       methodParamsForSignature,
       dsVarName
     );
-    injectMethod(repoImplPath, options.repositoryImplClassName, implMethod);
+    injectMethod(repoImplPath, repositoryImplClassName, implMethod);
   } else {
     console.log(chalk4.yellow(`  \u26A0 Repository implementation not found: ${repoImplPath}`));
   }
   spinner2("Generating UseCase");
-  const useCaseDir = path8.join(lib, "domain", "usecases", options.feature);
+  const useCaseDir = path8.join(lib, "domain", "usecases", feature);
   fs9.mkdirSync(useCaseDir, { recursive: true });
   fs9.writeFileSync(
     path8.join(useCaseDir, `${useCaseSnake}_usecase.dart`),
@@ -1338,27 +1255,41 @@ async function createEndpoint(options) {
       useCasePascal,
       camelCase(options.useCaseName),
       methodParamsForSignature,
-      returnType,
-      repositoryInterfaceName
+      entityType,
+      repositoryInterfaceSnake
     )
   );
-  spinner2("Updating barrel file");
-  const barrelPath = path8.join(useCaseDir, "usecases.dart");
-  const exportLine = `export '${useCaseSnake}_usecase.dart';`;
-  injectExport(barrelPath, exportLine);
-  if (options.runBuildRunner) {
-    const projectRoot = findPubspecDir(options.projectRoot);
-    if (projectRoot && hasBuildRunner(projectRoot)) {
-      spinner2("Running build_runner...");
-      await runBuildRunner(projectRoot);
-      console.log(chalk4.green("  \u2713 build_runner completed."));
-    } else {
-      console.log(chalk4.yellow("  \u26A0 Skipping build_runner (not found)."));
-    }
+  spinner2("Updating barrel files");
+  const entityBarrel = path8.join(lib, "domain", "entities", feature, `${feature}.dart`);
+  injectExport(entityBarrel, `export '${useCaseSnake}_entity.dart';`);
+  injectExport(
+    path8.join(lib, "domain", "entities", "entities.dart"),
+    `export '${feature}/${feature}.dart';`
+  );
+  const modelBarrel = path8.join(lib, "data", "models", feature, `${feature}.dart`);
+  injectExport(modelBarrel, `export '${useCaseSnake}_model.dart';`);
+  if (needsBody) {
+    injectExport(modelBarrel, `export '${useCaseSnake}_request_model.dart';`);
   }
+  injectExport(
+    path8.join(lib, "data", "models", "models.dart"),
+    `export '${feature}/${feature}.dart';`
+  );
+  const useCaseBarrel = path8.join(useCaseDir, `${feature}.dart`);
+  injectExport(useCaseBarrel, `export '${useCaseSnake}_usecase.dart';`);
+  injectExport(
+    path8.join(lib, "domain", "usecases", "usecases.dart"),
+    `export '${feature}/${feature}.dart';`
+  );
   console.log(chalk4.green(`
 \u2713 Endpoint "${options.useCaseName}" generated successfully.`));
 }
+function extractDomain(bffApiFile) {
+  const baseName = path8.basename(bffApiFile);
+  const match = baseName.match(/^bff_(.+)_api\.dart$/);
+  if (match) return match[1];
+  return baseName.replace(/\.dart$/, "");
+}
 function extractPathParams(endpointPath) {
   const regex = /\{(\w+)\}/g;
   const params = [];
@@ -1370,8 +1301,8 @@ function extractPathParams(endpointPath) {
 }
 function buildMethodParams(options, pathParams, hasRequestBody) {
   const params = [...pathParams];
-  if (hasRequestBody && options.requestModelName) {
-    const reqPascal = pascalCase4(options.requestModelName);
+  if (hasRequestBody) {
+    const reqPascal = pascalCase4(options.useCaseName);
     params.push({ name: "body", type: `${reqPascal}RequestModel` });
   }
   return params;
@@ -1381,8 +1312,8 @@ function buildRetrofitParams(options, pathParams, hasRequestBody) {
   for (const pp of pathParams) {
     params.push({ ...pp, isPath: true });
   }
-  if (hasRequestBody && options.requestModelName) {
-    const reqPascal = pascalCase4(options.requestModelName);
+  if (hasRequestBody) {
+    const reqPascal = pascalCase4(options.useCaseName);
     params.push({ name: "body", type: `${reqPascal}RequestModel`, isBody: true });
   }
   return params;
@@ -1395,7 +1326,6 @@ function extractClassName(filePath) {
 }
 
 // src/interactive.ts
-import { pascalCase as pascalCase5 } from "change-case";
 var SNAKE_CASE_REGEX4 = /^[a-z][a-z0-9_]*$/;
 async function resolveProject() {
   const s = clack.spinner();
@@ -1683,8 +1613,76 @@ async function useCaseFlow(project) {
     clack.outro(chalk5.red(`Error: ${error}`));
   }
 }
-async function endpointFlow(project) {
+function findBffFiles(dir) {
+  const results = [];
+  if (!fs10.existsSync(dir)) return results;
+  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path9.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findBffFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".dart") && !entry.name.includes(".g.")) {
+      results.push(fullPath);
+    }
+  }
+  return results.sort();
+}
+function inferBffFile(bffFiles, endpointPath) {
+  const firstSegment = endpointPath.replace(/^\//, "").split("/")[0].toLowerCase();
+  if (!firstSegment) return null;
+  const withDomains = bffFiles.map((f) => {
+    const base = path9.basename(f, ".dart");
+    const domain = base.replace(/^bff_/, "").replace(/_api$/, "");
+    return { file: f, domain };
+  });
+  const exact = withDomains.filter((x) => x.domain === firstSegment);
+  if (exact.length === 1) return exact[0].file;
+  const singular = firstSegment.replace(/s$/, "");
+  const singularMatch = withDomains.filter((x) => x.domain === singular);
+  if (singularMatch.length === 1) return singularMatch[0].file;
+  const endsWith = withDomains.filter(
+    (x) => x.domain.endsWith(firstSegment) || x.domain.endsWith(singular)
+  );
+  if (endsWith.length === 1) return endsWith[0].file;
+  const contains = withDomains.filter(
+    (x) => firstSegment.includes(x.domain) || singular.includes(x.domain)
+  );
+  if (contains.length === 1) return contains[0].file;
+  return null;
+}
+async function resolveEndpointProject() {
+  const s = clack.spinner();
+  s.start("Finding BFF package...");
+  const monorepoRoot = findMonorepoRoot(process.cwd());
+  if (monorepoRoot) {
+    const packages = discoverPackages(monorepoRoot);
+    const bffPackage = packages.find(
+      (p) => fs10.existsSync(path9.join(p.projectRoot, "lib", "data", "api", "bff"))
+    );
+    if (bffPackage) {
+      s.stop(`Using ${chalk5.green(bffPackage.projectName)}`);
+      return bffPackage;
+    }
+  }
+  const cwdProject = analyzeProject(process.cwd());
+  if (cwdProject && fs10.existsSync(path9.join(cwdProject.projectRoot, "lib", "data", "api", "bff"))) {
+    s.stop(`Using ${chalk5.green(cwdProject.projectName)}`);
+    return cwdProject;
+  }
+  s.stop("No BFF package found");
+  clack.outro(chalk5.red("Could not find a package with lib/data/api/bff/."));
+  return null;
+}
+async function endpointFlow() {
+  const project = await resolveEndpointProject();
+  if (!project) return;
   const lib = path9.join(project.projectRoot, "lib");
+  const bffDir = path9.join(lib, "data", "api", "bff");
+  const bffFiles = findBffFiles(bffDir);
+  if (bffFiles.length === 0) {
+    clack.outro(chalk5.red("No BFF API files found. Ensure lib/data/api/bff/ exists with .dart files."));
+    return;
+  }
   const httpMethod = await clack.select({
     message: "HTTP Method",
     options: [
@@ -1700,7 +1698,7 @@ async function endpointFlow(project) {
     return;
   }
   const endpointPath = await clack.text({
-    message: "Endpoint path (e.g. /cp/{zipCode})",
+    message: "Endpoint path (e.g. /products/{id})",
     placeholder: "/api/users/{id}",
     validate: (v) => {
       if (!v.trim()) return "Path is required";
@@ -1710,191 +1708,26 @@ async function endpointFlow(project) {
     clack.cancel("Cancelled");
     return;
   }
-  const bffDir = path9.join(lib, "data", "api", "bff");
-  let bffApiFile = "";
-  if (fs10.existsSync(bffDir)) {
-    const dartFiles = fs10.readdirSync(bffDir).filter((f) => f.endsWith(".dart")).sort();
-    if (dartFiles.length > 0) {
-      const selected = await clack.select({
-        message: "Select BFF API file",
-        options: [
-          ...dartFiles.map((f) => ({
-            value: path9.join(bffDir, f),
-            label: f
-          })),
-          { value: "__custom__", label: "Custom path..." }
-        ]
-      });
-      if (clack.isCancel(selected)) {
-        clack.cancel("Cancelled");
-        return;
-      }
-      if (selected === "__custom__") {
-        const customPath = await clack.text({
-          message: "BFF API file path",
-          placeholder: "lib/data/api/bff/my_api.dart",
-          validate: (v) => {
-            if (!v.trim()) return "Path is required";
-          }
-        });
-        if (clack.isCancel(customPath)) {
-          clack.cancel("Cancelled");
-          return;
-        }
-        bffApiFile = path9.resolve(customPath);
-      } else {
-        bffApiFile = selected;
-      }
-    } else {
-      const customPath = await clack.text({
-        message: "BFF API file path (no .dart files found in bff/)",
-        placeholder: "lib/data/api/bff/my_api.dart",
-        validate: (v) => {
-          if (!v.trim()) return "Path is required";
-        }
-      });
-      if (clack.isCancel(customPath)) {
-        clack.cancel("Cancelled");
-        return;
-      }
-      bffApiFile = path9.resolve(customPath);
-    }
-  } else {
-    const customPath = await clack.text({
-      message: "BFF API file path (bff/ dir not found)",
-      placeholder: "lib/data/api/bff/my_api.dart",
-      validate: (v) => {
-        if (!v.trim()) return "Path is required";
-      }
-    });
-    if (clack.isCancel(customPath)) {
-      clack.cancel("Cancelled");
-      return;
-    }
-    bffApiFile = path9.resolve(customPath);
-  }
-  const responseChoice = await clack.select({
-    message: "Response model",
-    options: [
-      { value: "existing", label: "Use existing model", hint: "Reference an already created model" },
-      { value: "json", label: "Paste JSON", hint: "Generate entity + model from JSON" }
-    ]
-  });
-  if (clack.isCancel(responseChoice)) {
-    clack.cancel("Cancelled");
-    return;
-  }
-  let responseModelName = "";
-  let responseFields;
-  if (responseChoice === "json") {
-    const modelName = await clack.text({
-      message: "Response model name (snake_case)",
-      placeholder: "e.g. user_profile",
-      validate: (v) => {
-        if (!v.trim()) return "Name is required";
-        if (!SNAKE_CASE_REGEX4.test(v)) return "Must be snake_case";
-      }
-    });
-    if (clack.isCancel(modelName)) {
-      clack.cancel("Cancelled");
-      return;
-    }
-    responseModelName = modelName;
-    const jsonStr = await clack.text({
-      message: "Paste the JSON response",
-      placeholder: '{ "id": 1, "name": "John" }',
-      validate: (v) => {
-        if (!v.trim()) return "JSON is required";
-        try {
-          JSON.parse(v);
-        } catch {
-          return "Invalid JSON";
-        }
-      }
-    });
-    if (clack.isCancel(jsonStr)) {
-      clack.cancel("Cancelled");
-      return;
-    }
-    responseFields = jsonToFields(jsonStr);
+  let bffApiFile = inferBffFile(bffFiles, endpointPath);
+  if (bffApiFile) {
+    clack.log.info(`Auto-detected BFF file: ${chalk5.cyan(path9.basename(bffApiFile))}`);
   } else {
-    const modelName = await clack.text({
-      message: "Existing response model name (snake_case)",
-      placeholder: "e.g. user_profile",
-      validate: (v) => {
-        if (!v.trim()) return "Name is required";
-      }
+    const selected = await clack.select({
+      message: "Could not auto-detect BFF file. Select one:",
+      options: bffFiles.map((f) => ({
+        value: f,
+        label: path9.relative(bffDir, f)
+      }))
     });
-    if (clack.isCancel(modelName)) {
+    if (clack.isCancel(selected)) {
       clack.cancel("Cancelled");
       return;
     }
-    responseModelName = modelName;
-  }
-  let requestModelName;
-  let requestFields;
-  const needsBody = ["POST", "PUT", "PATCH"].includes(httpMethod);
-  if (needsBody) {
-    const requestChoice = await clack.select({
-      message: "Request body",
-      options: [
-        { value: "json", label: "Paste JSON", hint: "Generate request model from JSON" },
-        { value: "existing", label: "Use existing model", hint: "Reference an already created model" },
-        { value: "none", label: "No body", hint: "Just path/query params" }
-      ]
-    });
-    if (clack.isCancel(requestChoice)) {
-      clack.cancel("Cancelled");
-      return;
-    }
-    if (requestChoice === "json") {
-      const reqName = await clack.text({
-        message: "Request model name (snake_case)",
-        placeholder: `e.g. create_${responseModelName}`,
-        validate: (v) => {
-          if (!v.trim()) return "Name is required";
-          if (!SNAKE_CASE_REGEX4.test(v)) return "Must be snake_case";
-        }
-      });
-      if (clack.isCancel(reqName)) {
-        clack.cancel("Cancelled");
-        return;
-      }
-      requestModelName = reqName;
-      const reqJson = await clack.text({
-        message: "Paste the request JSON body",
-        placeholder: '{ "name": "John", "email": "john@example.com" }',
-        validate: (v) => {
-          if (!v.trim()) return "JSON is required";
-          try {
-            JSON.parse(v);
-          } catch {
-            return "Invalid JSON";
-          }
-        }
-      });
-      if (clack.isCancel(reqJson)) {
-        clack.cancel("Cancelled");
-        return;
-      }
-      requestFields = jsonToFields(reqJson);
-    } else if (requestChoice === "existing") {
-      const reqName = await clack.text({
-        message: "Existing request model name (snake_case)",
-        placeholder: `e.g. create_${responseModelName}`,
-        validate: (v) => {
-          if (!v.trim()) return "Name is required";
-        }
-      });
-      if (clack.isCancel(reqName)) {
-        clack.cancel("Cancelled");
-        return;
-      }
-      requestModelName = reqName;
-    }
+    bffApiFile = selected;
   }
+  const methodLower = httpMethod.toLowerCase();
   const pathSegments = endpointPath.replace(/^\//, "").split("/").filter((s) => !s.startsWith("{"));
-  const inferredName = pathSegments.length > 0 ? "get_" + pathSegments.join("_") : "get_data";
+  const inferredName = pathSegments.length > 0 ? `${methodLower}_${pathSegments.join("_")}` : `${methodLower}_data`;
   const useCaseName = await clack.text({
     message: "UseCase name (snake_case)",
     placeholder: inferredName,
@@ -1908,117 +1741,16 @@ async function endpointFlow(project) {
     clack.cancel("Cancelled");
     return;
   }
-  const datasourceFile = await clack.text({
-    message: "Datasource file path",
-    placeholder: `lib/data/datasources/${responseModelName}_datasource.dart`,
-    validate: (v) => {
-      if (!v.trim()) return "Path is required";
-    }
-  });
-  if (clack.isCancel(datasourceFile)) {
-    clack.cancel("Cancelled");
-    return;
-  }
-  const datasourceClassName = await clack.text({
-    message: "Datasource class name",
-    placeholder: `${pascalCase5(responseModelName)}Datasource`,
-    initialValue: `${pascalCase5(responseModelName)}Datasource`,
-    validate: (v) => {
-      if (!v.trim()) return "Class name is required";
-    }
-  });
-  if (clack.isCancel(datasourceClassName)) {
-    clack.cancel("Cancelled");
-    return;
-  }
-  const repositoryInterfaceFile = await clack.text({
-    message: "Repository interface file path",
-    placeholder: `lib/domain/repositories/${responseModelName}_repository.dart`,
-    validate: (v) => {
-      if (!v.trim()) return "Path is required";
-    }
-  });
-  if (clack.isCancel(repositoryInterfaceFile)) {
-    clack.cancel("Cancelled");
-    return;
-  }
-  const repositoryInterfaceName2 = await clack.text({
-    message: "Repository interface name",
-    placeholder: `${pascalCase5(responseModelName)}Repository`,
-    initialValue: `${pascalCase5(responseModelName)}Repository`,
-    validate: (v) => {
-      if (!v.trim()) return "Name is required";
-    }
-  });
-  if (clack.isCancel(repositoryInterfaceName2)) {
-    clack.cancel("Cancelled");
-    return;
-  }
-  const repositoryImplFile = await clack.text({
-    message: "Repository implementation file path",
-    placeholder: `lib/data/repositories/${responseModelName}_repository_impl.dart`,
-    validate: (v) => {
-      if (!v.trim()) return "Path is required";
-    }
-  });
-  if (clack.isCancel(repositoryImplFile)) {
-    clack.cancel("Cancelled");
-    return;
-  }
-  const repositoryImplClassName = await clack.text({
-    message: "Repository implementation class name",
-    placeholder: `${pascalCase5(responseModelName)}RepositoryImpl`,
-    initialValue: `${pascalCase5(responseModelName)}RepositoryImpl`,
-    validate: (v) => {
-      if (!v.trim()) return "Name is required";
-    }
-  });
-  if (clack.isCancel(repositoryImplClassName)) {
-    clack.cancel("Cancelled");
-    return;
-  }
-  const feature = await clack.text({
-    message: "Feature name (snake_case, for directory grouping)",
-    placeholder: responseModelName,
-    initialValue: responseModelName,
-    validate: (v) => {
-      if (!v.trim()) return "Feature name is required";
-      if (!SNAKE_CASE_REGEX4.test(v)) return "Must be snake_case";
-    }
-  });
-  if (clack.isCancel(feature)) {
-    clack.cancel("Cancelled");
-    return;
-  }
-  const runBuildRunner2 = await clack.confirm({
-    message: "Run build_runner after generation?",
-    initialValue: project.hasBuildRunner
-  });
-  if (clack.isCancel(runBuildRunner2)) {
-    clack.cancel("Cancelled");
-    return;
-  }
   const genSpinner = clack.spinner();
   genSpinner.start("Generating endpoint stack...");
   try {
     await createEndpoint({
       projectRoot: project.projectRoot,
+      projectName: project.projectName,
       httpMethod,
       endpointPath,
       bffApiFile,
-      responseModelName,
-      responseFields,
-      requestModelName,
-      requestFields,
-      useCaseName,
-      datasourceFile,
-      datasourceClassName,
-      repositoryInterfaceFile,
-      repositoryInterfaceName: repositoryInterfaceName2,
-      repositoryImplFile,
-      repositoryImplClassName,
-      feature,
-      runBuildRunner: runBuildRunner2
+      useCaseName
     });
     genSpinner.stop("Endpoint generated");
     clack.outro(chalk5.green("Done!"));
@@ -2067,12 +1799,9 @@ async function interactiveMode() {
       await useCaseFlow(project);
       break;
     }
-    case "endpoint": {
-      const project = await resolveProject();
-      if (!project) return;
-      await endpointFlow(project);
+    case "endpoint":
+      await endpointFlow();
       break;
-    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wlmaker",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "description": "Create Flutter BLoCs with Freezed sealed classes from the terminal",
   "keywords": [
     "flutter",