wlmaker 1.2.12 → 1.2.13

package/dist/cli.mjs

@@ -966,14 +966,20 @@ import chalk5 from "chalk";
 import * as fs9 from "fs";
 import * as path8 from "path";
 import chalk4 from "chalk";
-import { pascalCase as pascalCase4, camelCase } from "change-case";
+import { pascalCase as pascalCase4, camelCase as camelCase2 } from "change-case";
 
 // src/core/endpoint-templates.ts
+import { camelCase } from "change-case";
 function entityBoilerplate(pascal) {
-  return `class ${pascal}Entity {
+  return `import 'package:equatable/equatable.dart';
+
+class ${pascal}Entity extends Equatable {
   // TODO: Define fields
 
   const ${pascal}Entity();
+
+  @override
+  List<Object?> get props => [];
 }
 `;
 }
@@ -1019,27 +1025,26 @@ class ${pascal}RequestModel {
 }
 `;
 }
-function useCaseTemplate2(name, pascal, method, params, returnType, repositoryInterface) {
+function useCaseTemplate2(pascal, method, params, returnType, repositoryInterface, projectName) {
   const hasParams = params.length > 0;
   const paramsClass = hasParams ? `
   class Params {
-${params.map((p) => `    final ${p.type} ${p.name};`).join("\n")}
     const Params({${params.map((p) => `required this.${p.name}`).join(", ")}});
+${params.map((p) => `    final ${p.type} ${p.name};`).join("\n")}
   }
 ` : "";
   const callParams = hasParams ? "Params params" : "";
   const callReturn = `Future<${returnType}>`;
   const args = hasParams ? params.map((p) => `params.${p.name}`).join(", ") : "";
-  return `import 'package:dartz/dartz.dart';
-import '../../repositories/${repositoryInterface}.dart';
+  return `import 'package:${projectName}/core.dart';
 
 class ${pascal}UseCase {
-  final ${repositoryInterface} _repository;
-
   ${pascal}UseCase(this._repository);
+
+  final ${repositoryInterface} _repository;
 ${paramsClass}
   ${callReturn} call(${callParams}) async {
-    return await _repository.${method}(${args});
+    return _repository.${method}(${args});
   }
 }
 `;
@@ -1066,20 +1071,58 @@ function repositoryInterfaceMethod(methodName, returnType, params) {
   const paramList = params.map((p) => `${p.type} ${p.name}`).join(", ");
   return `Future<${returnType}> ${methodName}(${paramList});`;
 }
-function repositoryImplMethod(methodName, returnType, modelType, 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 {
-    final model = await ${datasourceName}.${methodName}(${args});
-    return model.toEntity();
+  Future<${returnType}> ${methodName}(${paramList}) {
+    // TODO: implement ${methodName}
+    throw UnimplementedError();
   }`;
 }
+function datasourceModuleRegistration(domainPascal, lazy = true) {
+  const dsClass = `${domainPascal}RestDataSource`;
+  const dsCamel = camelCase(dsClass);
+  const apiClass = `Bff${domainPascal}Api`;
+  const annotation = lazy ? "@lazySingleton\n" : "";
+  return `//============================================================================
+// ${domainPascal}
+//============================================================================
+${annotation}${dsClass} ${dsCamel}(${apiClass} api) =>
+    ${dsClass}(api: api);`;
+}
+function repositoryModuleRegistration(domainPascal, lazy = true) {
+  const repoInterface = `${domainPascal}Repository`;
+  const repoCamel = camelCase(repoInterface);
+  const repoImpl = `${domainPascal}RepositoryData`;
+  const dsClass = `${domainPascal}RestDataSource`;
+  const annotation = lazy ? "@lazySingleton\n" : "";
+  return `//============================================================================
+// ${domainPascal}
+//============================================================================
+${annotation}${repoInterface} ${repoCamel}(
+  ${dsClass} restDataSource,
+) => ${repoImpl}(restDataSource: restDataSource);`;
+}
+function useCaseModuleRegistration(useCasePascal, domainPascal, lazy = true) {
+  const useCaseClass = `${useCasePascal}UseCase`;
+  const useCaseCamel = camelCase(useCaseClass);
+  const repoInterface = `${domainPascal}Repository`;
+  const annotation = lazy ? "@lazySingleton\n" : "";
+  return `//============================================================================
+// ${domainPascal}
+//============================================================================
+${annotation}${useCaseClass} ${useCaseCamel}(${repoInterface} repository) =>
+    ${useCaseClass}(repository);`;
+}
 
 // src/core/dart-injector.ts
 import * as fs8 from "fs";
-function injectMethod(filePath, className, methodCode) {
+function injectMethod(filePath, className, methodCode, dedupKey) {
   const content = fs8.readFileSync(filePath, "utf8");
+  const dedup = dedupKey ?? findSignature(methodCode);
+  if (dedup && content.includes(dedup)) {
+    return;
+  }
   const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
   const classMatch = content.match(classRegex);
   if (!classMatch) {
@@ -1104,14 +1147,26 @@ function injectMethod(filePath, className, methodCode) {
   if (classEnd === -1) {
     throw new Error(`Could not find closing brace for class "${className}" in ${filePath}`);
   }
-  const methodSignature = methodCode.trim().split("\n")[0].trim();
-  if (content.includes(methodSignature)) {
-    return;
-  }
   const indentedMethod = methodCode.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
   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)) {
@@ -1125,6 +1180,16 @@ function injectExport(filePath, exportLine) {
   lines.sort();
   fs8.writeFileSync(filePath, lines.join("\n") + "\n");
 }
+function findSignature(methodCode) {
+  const lines = methodCode.trim().split("\n");
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped && !stripped.startsWith("@")) {
+      return stripped;
+    }
+  }
+  return null;
+}
 
 // src/core/create-endpoint.ts
 async function createEndpoint(options) {
@@ -1146,7 +1211,6 @@ async function createEndpoint(options) {
   const methodParamsForSignature = methodParams.map((p) => ({ name: p.name, type: p.type }));
   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);
@@ -1176,7 +1240,7 @@ async function createEndpoint(options) {
   if (fs9.existsSync(bffPath)) {
     const retrofitParams = buildRetrofitParams(options, pathParams, needsBody);
     const method = retrofitMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       options.endpointPath,
       options.httpMethod,
       retrofitParams,
@@ -1190,7 +1254,7 @@ async function createEndpoint(options) {
   const dsPath = path8.resolve(datasourceFile);
   if (fs9.existsSync(dsPath)) {
     const dsMethod = datasourceMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       modelType,
       methodParamsForSignature
     );
@@ -1202,7 +1266,7 @@ async function createEndpoint(options) {
   const repoIfacePath = path8.resolve(repositoryInterfaceFile);
   if (fs9.existsSync(repoIfacePath)) {
     const ifaceMethod = repositoryInterfaceMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       entityType,
       methodParamsForSignature
     );
@@ -1213,9 +1277,9 @@ async function createEndpoint(options) {
   spinner2("Injecting repository implementation method");
   const repoImplPath = path8.resolve(repositoryImplFile);
   if (fs9.existsSync(repoImplPath)) {
-    const dsVarName = camelCase(datasourceClassName);
+    const dsVarName = camelCase2(datasourceClassName);
     const implMethod = repositoryImplMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       entityType,
       modelType,
       methodParamsForSignature,
@@ -1231,15 +1295,20 @@ async function createEndpoint(options) {
   fs9.writeFileSync(
     path8.join(useCaseDir, `${useCaseSnake}_usecase.dart`),
     useCaseTemplate2(
-      useCaseSnake,
       useCasePascal,
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       methodParamsForSignature,
       entityType,
-      repositoryInterfaceSnake
+      repositoryInterfaceName,
+      options.projectName
     )
   );
   spinner2("Updating barrel files");
+  const dsFileName = path8.basename(datasourceFile);
+  injectExport(
+    path8.join(lib, "data", "datasources", "datasources.dart"),
+    `export '${dsFileName}';`
+  );
   const entityBarrel = path8.join(lib, "domain", "entities", feature, `${feature}.dart`);
   injectExport(entityBarrel, `export '${useCaseSnake}_entity.dart';`);
   injectExport(
@@ -1261,6 +1330,44 @@ async function createEndpoint(options) {
     path8.join(lib, "domain", "usecases", "usecases.dart"),
     `export '${feature}/${feature}.dart';`
   );
+  if (options.diTarget && options.diTarget !== "none") {
+    spinner2("Registering in DI modules");
+    const appBaseDir = findAppBasePackageDir(options.projectRoot, options.diTarget);
+    if (appBaseDir) {
+      const domainPascal = pascalCase4(domain);
+      const lazy = options.diLazySingleton !== false;
+      const dsModuleFile = path8.join(appBaseDir, "datasources_module.dart");
+      const dsRegistration = datasourceModuleRegistration(domainPascal, lazy);
+      injectModuleRegistration(
+        dsModuleFile,
+        "DataSourceModule",
+        dsRegistration,
+        `${domainPascal}RestDataSource`
+      );
+      const repoModuleFile = path8.join(appBaseDir, "repositories_module.dart");
+      const repoRegistration = repositoryModuleRegistration(domainPascal, lazy);
+      injectModuleRegistration(
+        repoModuleFile,
+        "RepositoriesModule",
+        repoRegistration,
+        `${domainPascal}RepositoryData`
+      );
+      const ucModuleFile = path8.join(appBaseDir, "usecases_module.dart");
+      const ucRegistration = useCaseModuleRegistration(useCasePascal, domainPascal, lazy);
+      injectModuleRegistration(
+        ucModuleFile,
+        "UseCasesModule",
+        ucRegistration,
+        `${useCasePascal}UseCase`
+      );
+      const coreImport = `import 'package:${options.projectName}/core.dart';`;
+      injectImport(dsModuleFile, coreImport);
+      injectImport(repoModuleFile, coreImport);
+      injectImport(ucModuleFile, coreImport);
+    } else {
+      console.log(chalk4.yellow(`  \u26A0 Package "${options.diTarget}" not found in monorepo`));
+    }
+  }
   console.log(chalk4.green(`
 \u2713 Endpoint "${options.useCaseName}" generated successfully.`));
 }
@@ -1304,6 +1411,58 @@ function extractClassName(filePath) {
   if (!match) throw new Error(`No class found in ${filePath}`);
   return match[1];
 }
+function findAppBasePackageDir(projectRoot, packageName) {
+  let dir = path8.resolve(projectRoot);
+  for (let i = 0; i < 10; i++) {
+    const candidate = path8.join(dir, "packages", packageName, "lib", "dependencies");
+    if (fs9.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path8.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function injectModuleRegistration(filePath, className, registrationCode, dedupKey) {
+  if (!fs9.existsSync(filePath)) {
+    console.log(chalk4.yellow(`  \u26A0 Module file not found: ${filePath}`));
+    return;
+  }
+  const content = fs9.readFileSync(filePath, "utf8");
+  if (content.includes(dedupKey)) {
+    return;
+  }
+  const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
+  const classMatch = content.match(classRegex);
+  if (!classMatch) {
+    console.log(chalk4.yellow(`  \u26A0 Class "${className}" not found in ${filePath}`));
+    return;
+  }
+  const classStart = content.indexOf(classMatch[0]);
+  let braceCount = 0;
+  let classEnd = -1;
+  let foundOpen = false;
+  for (let i = classStart; i < content.length; i++) {
+    if (content[i] === "{") {
+      braceCount++;
+      foundOpen = true;
+    } else if (content[i] === "}") {
+      braceCount--;
+      if (foundOpen && braceCount === 0) {
+        classEnd = i;
+        break;
+      }
+    }
+  }
+  if (classEnd === -1) {
+    console.log(chalk4.yellow(`  \u26A0 Could not find closing brace for "${className}" in ${filePath}`));
+    return;
+  }
+  const indentedCode = registrationCode.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
+  const newContent = content.slice(0, classEnd) + "\n" + indentedCode + "\n" + content.slice(classEnd);
+  fs9.writeFileSync(filePath, newContent);
+}
 
 // src/interactive.ts
 var SNAKE_CASE_REGEX4 = /^[a-z][a-z0-9_]*$/;
@@ -1526,8 +1685,8 @@ async function widgetFlow() {
     clack.outro(chalk5.red(`Error: ${error}`));
   }
 }
-async function useCaseFlow(project) {
-  const ds = detectDesignSystem(project.projectRoot);
+async function useCaseFlow() {
+  const ds = detectDesignSystem(process.cwd());
   if (!ds) {
     clack.outro(
       chalk5.red(
@@ -1583,7 +1742,7 @@ async function useCaseFlow(project) {
   genSpinner.start("Generating use-case file...");
   try {
     await createUseCase(name, tier, {
-      projectRoot: project.projectRoot,
+      projectRoot: process.cwd(),
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("Use-case generated");
@@ -1610,7 +1769,7 @@ function findBffFiles(dir) {
 function inferBffFile(bffFiles, endpointPath) {
   const firstSegment = endpointPath.replace(/^\//, "").split("/")[0].toLowerCase();
   if (!firstSegment) return null;
-  const withDomains = bffFiles.map((f) => {
+  const withDomains = bffFiles.filter((f) => /^bff_.+_api\.dart$/.test(path9.basename(f))).map((f) => {
     const base = path9.basename(f, ".dart");
     const domain = base.replace(/^bff_/, "").replace(/_api$/, "");
     return { file: f, domain };
@@ -1635,6 +1794,7 @@ async function resolveEndpointProject() {
   s.start("Finding BFF package...");
   const monorepoRoot = findMonorepoRoot(process.cwd());
   if (monorepoRoot) {
+    s.message(`Monorepo found at ${monorepoRoot}`);
     const packageBases = ["packages", "packages/features"];
     for (const base of packageBases) {
       const baseDir = path9.join(monorepoRoot, base);
@@ -1644,15 +1804,19 @@ async function resolveEndpointProject() {
         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 bffPath = path9.join(candidate, "lib", "data", "api", "bff");
+        s.message(`Checking ${candidate} \u2192 bff exists: ${fs10.existsSync(bffPath)}`);
+        if (fs10.existsSync(bffPath)) {
+          const project2 = analyzeProject(candidate);
+          if (project2) {
+            s.stop(`Using ${chalk5.green(project2.projectName)}`);
+            return project2;
           }
         }
       }
     }
+  } else {
+    s.message("No monorepo root found");
   }
   const cwdProject = analyzeProject(process.cwd());
   if (cwdProject && fs10.existsSync(path9.join(cwdProject.projectRoot, "lib", "data", "api", "bff"))) {
@@ -1660,8 +1824,29 @@ async function resolveEndpointProject() {
     return cwdProject;
   }
   s.stop("No BFF package found");
-  clack.outro(chalk5.red("Could not find a package with lib/data/api/bff/."));
-  return null;
+  const manualPath = await clack.text({
+    message: "Enter the path to the package (must contain lib/data/api/bff/):",
+    placeholder: "e.g. /path/to/my-package or ./packages/core",
+    validate: (v) => {
+      if (!v.trim()) return "Path is required";
+      const resolved2 = path9.resolve(v.trim());
+      if (!fs10.existsSync(resolved2)) return "Path does not exist";
+      if (!fs10.existsSync(path9.join(resolved2, "pubspec.yaml"))) return "No pubspec.yaml found at this path";
+      if (!fs10.existsSync(path9.join(resolved2, "lib", "data", "api", "bff"))) return "No lib/data/api/bff/ found at this path";
+    }
+  });
+  if (clack.isCancel(manualPath)) {
+    clack.cancel("Cancelled");
+    return null;
+  }
+  const resolved = path9.resolve(manualPath);
+  const project = analyzeProject(resolved);
+  if (!project) {
+    clack.outro(chalk5.red(`Could not analyze project at ${resolved}`));
+    return null;
+  }
+  clack.log.info(`Using ${chalk5.green(project.projectName)}`);
+  return project;
 }
 async function endpointFlow() {
   const project = await resolveEndpointProject();
@@ -1731,6 +1916,31 @@ async function endpointFlow() {
     clack.cancel("Cancelled");
     return;
   }
+  const diTarget = await clack.select({
+    message: "Where to register DI modules?",
+    options: [
+      { value: "app_base", label: "app_base" },
+      { value: "app_base_loyalty", label: "app_base_loyalty" },
+      { value: "none", label: "Skip (no DI registration)" }
+    ],
+    initialValue: "app_base"
+  });
+  if (clack.isCancel(diTarget)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  let diLazySingleton = true;
+  if (diTarget !== "none") {
+    const lazyAnswer = await clack.confirm({
+      message: "Use @lazySingleton annotation?",
+      initialValue: true
+    });
+    if (clack.isCancel(lazyAnswer)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    diLazySingleton = lazyAnswer;
+  }
   const genSpinner = clack.spinner();
   genSpinner.start("Generating endpoint stack...");
   try {
@@ -1740,7 +1950,9 @@ async function endpointFlow() {
       httpMethod,
       endpointPath,
       bffApiFile,
-      useCaseName
+      useCaseName,
+      diTarget,
+      diLazySingleton
     });
     genSpinner.stop("Endpoint generated");
     clack.outro(chalk5.green("Done!"));
@@ -1783,12 +1995,9 @@ async function interactiveMode() {
     case "widget":
       await widgetFlow();
       break;
-    case "usecase": {
-      const project = await resolveProject();
-      if (!project) return;
-      await useCaseFlow(project);
+    case "usecase":
+      await useCaseFlow();
       break;
-    }
     case "endpoint":
       await endpointFlow();
       break;

package/package.json

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