wlmaker 1.2.10 → 1.2.12

package/dist/cli.mjs

@@ -977,20 +977,26 @@ function entityBoilerplate(pascal) {
 }
 `;
 }
-function modelBoilerplate(name, pascal) {
-  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() : super();
+@JsonSerializable(createToJson: true)
+class ${pascal}Model {
+  // TODO: Define constructor parameters and fields
+
+  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);
 }
 `;
@@ -1000,11 +1006,11 @@ function requestModelBoilerplate(name, pascal) {
 
 part '${name}_request_model.g.dart';
 
-@JsonSerializable()
+@JsonSerializable(createToJson: true)
 class ${pascal}RequestModel {
-  // TODO: Define fields
+  // TODO: Define constructor parameters and fields
 
-  ${pascal}RequestModel();
+  const ${pascal}RequestModel();
 
   factory ${pascal}RequestModel.fromJson(Map<String, dynamic> json) =>
       _$${pascal}RequestModelFromJson(json);
@@ -1060,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();
   }`;
 }
 
@@ -1105,22 +1112,6 @@ function injectMethod(filePath, className, methodCode) {
   const newContent = content.slice(0, classEnd) + "\n" + indentedMethod + "\n" + content.slice(classEnd);
   fs8.writeFileSync(filePath, newContent);
 }
-function injectImport(filePath, importLine) {
-  const content = fs8.readFileSync(filePath, "utf8");
-  if (content.includes(importLine.trim())) {
-    return;
-  }
-  const importRegex = /^import\s+[^;]+;/gm;
-  const imports = [...content.matchAll(importRegex)];
-  if (imports.length > 0) {
-    const lastImport = imports[imports.length - 1];
-    const insertPos = lastImport.index + lastImport[0].length;
-    const newContent = content.slice(0, insertPos) + "\n" + importLine + content.slice(insertPos);
-    fs8.writeFileSync(filePath, newContent);
-  } else {
-    fs8.writeFileSync(filePath, importLine + "\n\n" + content);
-  }
-}
 function injectExport(filePath, exportLine) {
   let content = "";
   if (fs8.existsSync(filePath)) {
@@ -1153,26 +1144,27 @@ async function createEndpoint(options) {
   const pathParams = extractPathParams(options.endpointPath);
   const methodParams = buildMethodParams(options, pathParams, needsBody);
   const methodParamsForSignature = methodParams.map((p) => ({ name: p.name, type: p.type }));
-  const returnType = `${pascal}Entity`;
+  const modelType = `${pascal}Model`;
+  const entityType = `${pascal}Entity`;
   const repositoryInterfaceSnake = path8.basename(repositoryInterfaceFile, ".dart");
   const spinner2 = (msg) => console.log(chalk4.cyan(`  \u2192 ${msg}`));
   spinner2("Generating entity");
-  const entityDir = path8.join(lib, "domain", "entities", feature, useCaseSnake);
+  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, useCaseSnake);
+  const modelDir = path8.join(lib, "data", "models", feature);
   fs9.mkdirSync(modelDir, { recursive: true });
   fs9.writeFileSync(
     path8.join(modelDir, `${useCaseSnake}_model.dart`),
-    modelBoilerplate(useCaseSnake, pascal)
+    modelBoilerplate(useCaseSnake, pascal, options.projectName)
   );
   if (needsBody) {
     spinner2("Generating request model");
-    const reqModelDir = path8.join(lib, "data", "models", feature, useCaseSnake);
+    const reqModelDir = path8.join(lib, "data", "models", feature);
     fs9.mkdirSync(reqModelDir, { recursive: true });
     fs9.writeFileSync(
       path8.join(reqModelDir, `${useCaseSnake}_request_model.dart`),
@@ -1183,17 +1175,14 @@ async function createEndpoint(options) {
   const bffPath = path8.resolve(options.bffApiFile);
   if (fs9.existsSync(bffPath)) {
     const retrofitParams = buildRetrofitParams(options, pathParams, needsBody);
-    const retrofitReturnType = `${pascal}Model`;
     const method = retrofitMethod(
       camelCase(options.useCaseName),
       options.endpointPath,
       options.httpMethod,
       retrofitParams,
-      retrofitReturnType
+      modelType
     );
     injectMethod(bffPath, extractClassName(bffPath), method);
-    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}`));
   }
@@ -1202,7 +1191,7 @@ async function createEndpoint(options) {
   if (fs9.existsSync(dsPath)) {
     const dsMethod = datasourceMethod(
       camelCase(options.useCaseName),
-      returnType,
+      modelType,
       methodParamsForSignature
     );
     injectMethod(dsPath, datasourceClassName, dsMethod);
@@ -1214,12 +1203,10 @@ async function createEndpoint(options) {
   if (fs9.existsSync(repoIfacePath)) {
     const ifaceMethod = repositoryInterfaceMethod(
       camelCase(options.useCaseName),
-      returnType,
+      entityType,
       methodParamsForSignature
     );
     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}`));
   }
@@ -1229,7 +1216,8 @@ async function createEndpoint(options) {
     const dsVarName = camelCase(datasourceClassName);
     const implMethod = repositoryImplMethod(
       camelCase(options.useCaseName),
-      returnType,
+      entityType,
+      modelType,
       methodParamsForSignature,
       dsVarName
     );
@@ -1247,14 +1235,32 @@ async function createEndpoint(options) {
       useCasePascal,
       camelCase(options.useCaseName),
       methodParamsForSignature,
-      returnType,
+      entityType,
       repositoryInterfaceSnake
     )
   );
-  spinner2("Updating barrel file");
-  const barrelPath = path8.join(useCaseDir, "usecases.dart");
-  const exportLine = `export '${useCaseSnake}_usecase.dart';`;
-  injectExport(barrelPath, exportLine);
+  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.`));
 }
@@ -1587,8 +1593,86 @@ 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 packageBases = ["packages", "packages/features"];
+    for (const base of packageBases) {
+      const baseDir = path9.join(monorepoRoot, base);
+      if (!fs10.existsSync(baseDir)) continue;
+      const entries = fs10.readdirSync(baseDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const candidate = path9.join(baseDir, entry.name);
+        if (!fs10.existsSync(path9.join(candidate, "pubspec.yaml"))) continue;
+        if (fs10.existsSync(path9.join(candidate, "lib", "data", "api", "bff"))) {
+          const project = analyzeProject(candidate);
+          if (project) {
+            s.stop(`Using ${chalk5.green(project.projectName)}`);
+            return project;
+          }
+        }
+      }
+    }
+  }
+  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: [
@@ -1614,50 +1698,22 @@ 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
-        }))
-      });
-      if (clack.isCancel(selected)) {
-        clack.cancel("Cancelled");
-        return;
-      }
-      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);
-    }
+  let bffApiFile = inferBffFile(bffFiles, endpointPath);
+  if (bffApiFile) {
+    clack.log.info(`Auto-detected BFF file: ${chalk5.cyan(path9.basename(bffApiFile))}`);
   } 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";
-      }
+    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(customPath)) {
+    if (clack.isCancel(selected)) {
       clack.cancel("Cancelled");
       return;
     }
-    bffApiFile = path9.resolve(customPath);
+    bffApiFile = selected;
   }
   const methodLower = httpMethod.toLowerCase();
   const pathSegments = endpointPath.replace(/^\//, "").split("/").filter((s) => !s.startsWith("{"));
@@ -1680,6 +1736,7 @@ async function endpointFlow(project) {
   try {
     await createEndpoint({
       projectRoot: project.projectRoot,
+      projectName: project.projectName,
       httpMethod,
       endpointPath,
       bffApiFile,
@@ -1732,12 +1789,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.10",
+  "version": "1.2.12",
   "description": "Create Flutter BLoCs with Freezed sealed classes from the terminal",
   "keywords": [
     "flutter",