wlmaker 1.2.9 → 1.2.10

package/dist/cli.mjs

@@ -968,97 +968,16 @@ 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`);
+function modelBoilerplate(name, pascal) {
   return `import 'package:json_annotation/json_annotation.dart';
 import '../../domain/entities/${name}/${name}_entity.dart';
 
@@ -1066,15 +985,7 @@ 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")}
-  );
-
-  ${fromJson}
-
-  ${toJson}
+  const ${pascal}Model() : super();
 
   factory ${pascal}Model.fromJson(Map<String, dynamic> json) =>
       _$${pascal}ModelFromJson(json);
@@ -1084,23 +995,16 @@ ${fields.map((f) => `      ${f.name}: ${f.name},`).join("\n")}
 }
 `;
 }
-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()
 class ${pascal}RequestModel {
-${props}
+  // TODO: Define fields
 
-  ${pascal}RequestModel({
-${params}
-  });
+  ${pascal}RequestModel();
 
   factory ${pascal}RequestModel.fromJson(Map<String, dynamic> json) =>
       _$${pascal}RequestModelFromJson(json);
@@ -1234,46 +1138,51 @@ 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 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, useCaseSnake);
+  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, useCaseSnake);
+  fs9.mkdirSync(modelDir, { recursive: true });
+  fs9.writeFileSync(
+    path8.join(modelDir, `${useCaseSnake}_model.dart`),
+    modelBoilerplate(useCaseSnake, pascal)
+  );
+  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, useCaseSnake);
     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 retrofitParams = buildRetrofitParams(options, pathParams, needsBody);
     const retrofitReturnType = `${pascal}Model`;
     const method = retrofitMethod(
       camelCase(options.useCaseName),
@@ -1283,53 +1192,53 @@ async function createEndpoint(options) {
       retrofitReturnType
     );
     injectMethod(bffPath, extractClassName(bffPath), method);
-    const modelImport = `import 'package:${options.feature}/data/models/${options.responseModelName}/${options.responseModelName}_model.dart';`;
+    const modelImport = `import 'package:${feature}/data/models/${useCaseSnake}/${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,
       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,
       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:${feature}/domain/entities/${useCaseSnake}/${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,
       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`),
@@ -1339,26 +1248,22 @@ async function createEndpoint(options) {
       camelCase(options.useCaseName),
       methodParamsForSignature,
       returnType,
-      repositoryInterfaceName
+      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)."));
-    }
-  }
   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 +1275,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 +1286,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 +1300,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();
@@ -1700,7 +1604,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";
@@ -1717,34 +1621,16 @@ async function endpointFlow(project) {
     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..." }
-        ]
+        options: dartFiles.map((f) => ({
+          value: path9.join(bffDir, f),
+          label: f
+        }))
       });
       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;
-      }
+      bffApiFile = selected;
     } else {
       const customPath = await clack.text({
         message: "BFF API file path (no .dart files found in bff/)",
@@ -1773,128 +1659,9 @@ async function endpointFlow(project) {
     }
     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);
-  } 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";
-      }
-    });
-    if (clack.isCancel(modelName)) {
-      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;
-    }
-  }
+  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,96 +1675,6 @@ 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 {
@@ -2006,19 +1683,7 @@ async function endpointFlow(project) {
       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!"));

package/package.json

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