wlmaker 1.2.11 → 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,10 +1147,6 @@ 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);
@@ -1141,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) {
@@ -1162,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);
@@ -1192,15 +1240,13 @@ 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,
       modelType
     );
     injectMethod(bffPath, extractClassName(bffPath), method);
-    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}`));
   }
@@ -1208,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
     );
@@ -1220,22 +1266,20 @@ async function createEndpoint(options) {
   const repoIfacePath = path8.resolve(repositoryInterfaceFile);
   if (fs9.existsSync(repoIfacePath)) {
     const ifaceMethod = repositoryInterfaceMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       entityType,
       methodParamsForSignature
     );
     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("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,
@@ -1251,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(
@@ -1281,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.`));
 }
@@ -1324,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_]*$/;
@@ -1546,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(
@@ -1603,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");
@@ -1630,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 };
@@ -1655,14 +1794,29 @@ async function resolveEndpointProject() {
   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;
+    s.message(`Monorepo found at ${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;
+        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"))) {
@@ -1670,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();
@@ -1741,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 {
@@ -1750,7 +1950,9 @@ async function endpointFlow() {
       httpMethod,
       endpointPath,
       bffApiFile,
-      useCaseName
+      useCaseName,
+      diTarget,
+      diLazySingleton
     });
     genSpinner.stop("Endpoint generated");
     clack.outro(chalk5.green("Done!"));
@@ -1793,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.11",
+  "version": "1.2.13",
   "description": "Create Flutter BLoCs with Freezed sealed classes from the terminal",
   "keywords": [
     "flutter",