@ingenyus/swarm-wasp 0.1.0 → 0.2.1

package/dist/generators/base/component-generator.base.js

@@ -0,0 +1,931 @@
+// src/generators/base/component-generator.base.ts
+import {
+  hasHelperMethodCall,
+  logger as singletonLogger4,
+  toCamelCase,
+  toKebabCase as toKebabCase2,
+  validateFeaturePath as validateFeaturePath3
+} from "@ingenyus/swarm";
+import path6 from "path";
+
+// src/common/filesystem.ts
+import { toPascalCase, validateFeaturePath } from "@ingenyus/swarm";
+import fs from "fs";
+import path from "path";
+
+// src/types/constants.ts
+var PLUGIN_NAME = "wasp";
+var TYPE_DIRECTORIES = {
+  component: "client/components",
+  hook: "client/hooks",
+  layout: "client/layouts",
+  page: "client/pages",
+  util: "client/utils",
+  action: "server/actions",
+  query: "server/queries",
+  middleware: "server/middleware",
+  job: "server/jobs",
+  api: "server/apis",
+  crud: "server/cruds",
+  type: "types"
+};
+
+// src/common/filesystem.ts
+var realFileSystem = {
+  readFileSync: fs.readFileSync,
+  writeFileSync: fs.writeFileSync,
+  existsSync: fs.existsSync,
+  copyFileSync: fs.copyFileSync,
+  mkdirSync: fs.mkdirSync,
+  readdirSync: fs.readdirSync,
+  statSync: fs.statSync
+};
+function findWaspRoot(fileSystem, startDir = process.cwd()) {
+  const startDirPath = path.resolve(startDir);
+  let currentDirPath = startDirPath;
+  const root = path.parse(currentDirPath).root;
+  while (currentDirPath !== root) {
+    const waspRootPath = path.join(currentDirPath, ".wasproot");
+    if (fileSystem.existsSync(waspRootPath)) {
+      return currentDirPath;
+    }
+    currentDirPath = path.dirname(currentDirPath);
+  }
+  throw new Error(
+    `Couldn't find Wasp application root from ${startDirPath}. Make sure you are running this command from within a Wasp project directory.`
+  );
+}
+function ensureDirectoryExists(fileSystem, dir) {
+  if (!fileSystem.existsSync(dir)) {
+    fileSystem.mkdirSync(dir, { recursive: true });
+  }
+}
+function normaliseFeaturePath(featurePath) {
+  const segments = validateFeaturePath(featurePath);
+  const normalisedSegments = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const previousSegment = normalisedSegments[normalisedSegments.length - 1];
+    if (previousSegment !== "features" && segment !== "features") {
+      normalisedSegments.push("features");
+    }
+    normalisedSegments.push(segment);
+  }
+  return normalisedSegments.join("/");
+}
+function getFeatureDir(fileSystem, featureName) {
+  const waspRoot = findWaspRoot(fileSystem);
+  const normalisedPath = normaliseFeaturePath(featureName);
+  return path.join(waspRoot, "src", normalisedPath);
+}
+
+// src/common/prisma.ts
+import {
+  getSchema
+} from "@mrleebo/prisma-ast";
+import fs2 from "fs";
+import path2 from "path";
+
+// src/common/schemas.ts
+import { commandRegistry } from "@ingenyus/swarm";
+import { z } from "zod";
+var commonSchemas = {
+  feature: z.string().min(1, "Feature is required").meta({
+    description: "The feature directory this component will be generated in"
+  }).register(commandRegistry, {
+    shortName: "f",
+    examples: ["root", "auth", "dashboard/users"],
+    helpText: "Can be nested as a logical or relative path, e.g. 'dashboard/users' or 'features/dashboard/features/users'"
+  }),
+  name: z.string().min(1, "Name is required").meta({ description: "The name of the generated component" }).register(commandRegistry, {
+    shortName: "n",
+    examples: ["users", "task"],
+    helpText: "Will be used for generated files and configuration entries"
+  }),
+  target: z.string().min(1, "Target directory is required").meta({ description: "The target path of the generated directory" }).register(commandRegistry, {
+    shortName: "t",
+    examples: ["dashboard/users", "features/dashboard/features/users"],
+    helpText: "A logical or relative path, e.g. 'dashboard/users' or 'features/dashboard/features/users'"
+  }),
+  path: z.string().min(1, "Path is required").meta({ description: "The path that this component will be accessible at" }).register(commandRegistry, {
+    shortName: "p",
+    examples: ["/api/users/:id", "/api/products"],
+    helpText: "Supports Express-style placeholders, e.g. '/api/users/:id'"
+  }),
+  dataType: z.string().min(1, "Data type is required").meta({ description: "The data type/model name for this operation" }).register(commandRegistry, {
+    shortName: "d",
+    examples: ["User", "Product", "Task"],
+    helpText: "The Wasp entity or model name this operation will interact with"
+  }),
+  entities: z.array(z.string()).optional().meta({
+    description: "The Wasp entities that will be available to this component (optional)"
+  }).register(commandRegistry, {
+    shortName: "e",
+    examples: ["User", "User Task"],
+    helpText: "An array of Wasp entity names"
+  }),
+  force: z.boolean().optional().meta({
+    description: "Force overwrite of existing files and configuration entries (optional)"
+  }).register(commandRegistry, {
+    shortName: "F",
+    helpText: "CAUTION: Will overwrite existing files and configuration entries with current parameters"
+  }),
+  auth: z.boolean().optional().meta({
+    description: "Require authentication for this component (optional)"
+  }).register(commandRegistry, {
+    shortName: "a",
+    helpText: "Will generate authentication checks"
+  })
+};
+
+// src/common/templates.ts
+import { toKebabCase } from "@ingenyus/swarm";
+import { Eta } from "eta";
+import path3 from "path";
+var TemplateUtility = class {
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  processTemplate(templatePath, replacements) {
+    const declarations = Object.keys(replacements).map((key) => `${key}=it.${key}`).join(", ");
+    const functionHeader = declarations ? `const ${declarations};` : void 0;
+    const templateDir = path3.dirname(templatePath);
+    const eta = new Eta({
+      autoTrim: false,
+      autoEscape: false,
+      views: templateDir,
+      functionHeader
+    });
+    const templateName = path3.basename(templatePath).replace(/\.eta$/, "");
+    if (this.fileSystem.existsSync(templatePath)) {
+      return eta.render(templateName, replacements);
+    } else {
+      const template = this.fileSystem.readFileSync(templatePath, "utf8");
+      return eta.renderString(template, replacements);
+    }
+  }
+  /**
+   * Helper method to resolve template paths for concrete generators
+   * @param relativePath - The relative path to the template file
+   * @param generatorName - The name of the generator (e.g., 'api', 'job')
+   * @param currentFileUrl - The import.meta.url from the concrete generator class
+   * @returns The full path to the template file
+   */
+  resolveTemplatePath(relativePath, generatorName, currentFileUrl) {
+    const generatorDirName = toKebabCase(generatorName);
+    const currentFilePath = new URL(currentFileUrl).pathname;
+    const currentFileDir = path3.dirname(currentFilePath);
+    const currentFileName = path3.basename(currentFilePath);
+    const isInstalledPackage = currentFileDir.includes("node_modules") && currentFileDir.endsWith("/dist") && currentFileName === "index.js";
+    const startDir = isInstalledPackage ? currentFileDir : path3.dirname(path3.dirname(currentFileDir));
+    return path3.join(
+      startDir,
+      "generators",
+      generatorDirName,
+      "templates",
+      relativePath
+    );
+  }
+};
+
+// src/generators/feature/feature-generator.ts
+import {
+  handleFatalError as handleFatalError2,
+  logger as singletonLogger3,
+  validateFeaturePath as validateFeaturePath2
+} from "@ingenyus/swarm";
+import path5 from "path";
+
+// src/generators/base/wasp-generator.base.ts
+import {
+  GeneratorBase,
+  logger as singletonLogger2,
+  SwarmConfigManager,
+  TemplateResolver
+} from "@ingenyus/swarm";
+
+// src/generators/config/wasp-config-generator.ts
+import {
+  handleFatalError,
+  parseHelperMethodDefinition,
+  logger as singletonLogger
+} from "@ingenyus/swarm";
+import path4 from "path";
+var WaspConfigGenerator = class {
+  constructor(logger = singletonLogger, fileSystem = realFileSystem) {
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+    this.templateUtility = new TemplateUtility(fileSystem);
+  }
+  path = path4;
+  templateUtility;
+  /**
+   * Gets the template path for feature config templates.
+   * Feature config templates are located in the feature generator's templates directory.
+   * @param templateName - The name of the template file (e.g., 'feature.wasp.eta')
+   * @returns The full path to the template file
+   */
+  getTemplatePath(templateName) {
+    return this.templateUtility.resolveTemplatePath(
+      templateName,
+      "feature",
+      import.meta.url
+    );
+  }
+  /**
+   * Generate a TypeScript Wasp config file in a feature directory
+   * @param featurePath - The feature directory path
+   */
+  generate(featurePath) {
+    const featureDir = getFeatureDir(this.fileSystem, featurePath);
+    if (!this.fileSystem.existsSync(featureDir)) {
+      this.fileSystem.mkdirSync(featureDir, { recursive: true });
+    }
+    const templatePath = this.getTemplatePath("feature.wasp.eta");
+    if (!this.fileSystem.existsSync(templatePath)) {
+      this.logger.error(`Template not found: ${templatePath}`);
+      return;
+    }
+    const configFilePath = path4.join(featureDir, `feature.wasp.ts`);
+    if (this.fileSystem.existsSync(configFilePath)) {
+      this.logger.warn(`Feature config already exists: ${configFilePath}`);
+      return;
+    }
+    this.fileSystem.copyFileSync(templatePath, configFilePath);
+    this.logger.success(`Generated feature config: ${configFilePath}`);
+  }
+  /**
+   * Updates or creates a feature configuration file with a pre-built declaration.
+   * @param featurePath - The path to the feature
+   * @param declaration - The pre-built declaration string to add or update
+   * @returns The updated feature configuration file
+   */
+  update(featurePath, declaration) {
+    const configDir = getFeatureDir(this.fileSystem, featurePath);
+    const configFilePath = path4.join(configDir, `feature.wasp.ts`);
+    if (!this.fileSystem.existsSync(configFilePath)) {
+      const templatePath = this.getTemplatePath("feature.wasp.eta");
+      if (!this.fileSystem.existsSync(templatePath)) {
+        handleFatalError(`Feature config template not found: ${templatePath}`);
+      }
+      this.fileSystem.copyFileSync(templatePath, configFilePath);
+    }
+    let content = this.fileSystem.readFileSync(configFilePath, "utf8");
+    content = this.normaliseSemicolons(content);
+    const parsed = parseHelperMethodDefinition(declaration);
+    if (!parsed) {
+      handleFatalError(`Could not parse definition: ${declaration}`);
+      return content;
+    }
+    const { methodName } = parsed;
+    const hadExistingDefinitions = this.hasExistingDefinitions(
+      content,
+      methodName
+    );
+    content = this.removeExistingDefinition(content, declaration);
+    const hasExistingDefinitions = this.hasExistingDefinitions(
+      content,
+      methodName
+    );
+    const lines = content.split("\n");
+    const configureFunctionStart = lines.findIndex(
+      (line) => line.trim().startsWith("export default function")
+    );
+    if (configureFunctionStart === -1) {
+      handleFatalError("Could not find configure function in feature config");
+    }
+    const appLineIndex = lines.findIndex(
+      (line, index) => index > configureFunctionStart && line.trim() === "app"
+    );
+    if (appLineIndex === -1) {
+      const insertIndex = configureFunctionStart + 1;
+      const itemsToInsert = ["  app"];
+      const comment = this.getMethodComment(methodName);
+      itemsToInsert.push(`    ${comment}`);
+      itemsToInsert.push(declaration.trimEnd());
+      lines.splice(insertIndex, 0, ...itemsToInsert);
+    } else {
+      const { insertIndex, addComment } = this.findGroupInsertionPoint(
+        lines,
+        methodName,
+        declaration,
+        hadExistingDefinitions || hasExistingDefinitions
+      );
+      const newLines = this.insertWithSpacing(
+        lines,
+        declaration,
+        insertIndex,
+        methodName,
+        addComment
+      );
+      const normalisedContent2 = this.normaliseSemicolons(newLines.join("\n"));
+      this.fileSystem.writeFileSync(configFilePath, normalisedContent2);
+      return configFilePath;
+    }
+    const normalisedContent = this.normaliseSemicolons(lines.join("\n"));
+    this.fileSystem.writeFileSync(configFilePath, normalisedContent);
+    return configFilePath;
+  }
+  /**
+   * Determines the insertion index for a method name based on alphabetical ordering
+   * of existing groups in the configuration file.
+   * @param groups - Object containing existing method groups
+   * @param methodName - The method name to find insertion index for
+   * @returns The insertion index for the method name
+   */
+  getInsertionIndexForMethod(groups, methodName) {
+    const existingMethods = Object.keys(groups).filter(
+      (method) => groups[method].length > 0
+    );
+    const allMethods = [...existingMethods, methodName].sort();
+    return allMethods.indexOf(methodName);
+  }
+  /**
+   * Gets the comment text for a method type.
+   * @param methodName The method name (e.g., 'addApi')
+   * @returns The comment text for the method type
+   */
+  getMethodComment(methodName) {
+    const entityName = methodName.startsWith("add") ? methodName.slice(3) : methodName;
+    return `// ${entityName} definitions`;
+  }
+  /**
+   * Finds the correct insertion point for a new configuration item.
+   * @param lines - Array of file lines
+   * @param methodName - The method name (e.g., 'addApi')
+   * @param definition - The definition string to parse for item name
+   * @returns Object with insertion index and whether to add a comment
+   */
+  findGroupInsertionPoint(lines, methodName, definition, hasExistingDefinitionsOfType) {
+    const appLineIndex = lines.findIndex((line) => line.trim() === "app");
+    if (appLineIndex === -1) {
+      return { insertIndex: appLineIndex + 1, addComment: false };
+    }
+    const methodCalls = [];
+    for (let i = appLineIndex + 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith(".") && line.includes("(")) {
+        let methodCallContent = line;
+        let j = i;
+        let closingParenCount = 0;
+        let foundClosingParen = false;
+        for (let k = 0; k < methodCallContent.length; k++) {
+          if (methodCallContent[k] === "(") closingParenCount++;
+          if (methodCallContent[k] === ")") closingParenCount--;
+          if (closingParenCount === 0 && methodCallContent[k] === ")") {
+            foundClosingParen = true;
+            break;
+          }
+        }
+        while (!foundClosingParen && j < lines.length - 1) {
+          j++;
+          methodCallContent += " " + lines[j].trim();
+          for (let k = 0; k < lines[j].length; k++) {
+            if (lines[j][k] === "(") closingParenCount++;
+            if (lines[j][k] === ")") closingParenCount--;
+            if (closingParenCount === 0 && lines[j][k] === ")") {
+              foundClosingParen = true;
+              break;
+            }
+          }
+        }
+        const match = methodCallContent.match(
+          /\.(\w+)\([^,]+,\s*['"`]([^'"`]+)['"`]/
+        );
+        if (match) {
+          methodCalls.push({
+            lineIndex: i,
+            endLineIndex: j,
+            methodName: match[1],
+            itemName: match[2]
+          });
+        }
+      }
+    }
+    const groups = {};
+    methodCalls.forEach((call) => {
+      if (!groups[call.methodName]) {
+        groups[call.methodName] = [];
+      }
+      groups[call.methodName].push({
+        lineIndex: call.lineIndex,
+        endLineIndex: call.endLineIndex,
+        itemName: call.itemName
+      });
+    });
+    const targetGroup = groups[methodName] || [];
+    if (targetGroup.length === 0) {
+      const targetGroupIndex = this.getInsertionIndexForMethod(
+        groups,
+        methodName
+      );
+      const existingMethods = Object.keys(groups).filter((method) => groups[method].length > 0).sort();
+      for (let i = targetGroupIndex; i < existingMethods.length; i++) {
+        const groupMethod = existingMethods[i];
+        if (groups[groupMethod] && groups[groupMethod].length > 0) {
+          const firstItem = groups[groupMethod][0];
+          let insertIndex = firstItem.lineIndex;
+          for (let j = firstItem.lineIndex - 1; j > appLineIndex; j--) {
+            const line = lines[j].trim();
+            if (line.startsWith("//") && line.includes("definitions")) {
+              insertIndex = j;
+              break;
+            } else if (line.startsWith(".") || line === "") {
+              continue;
+            } else {
+              break;
+            }
+          }
+          return { insertIndex, addComment: !hasExistingDefinitionsOfType };
+        }
+      }
+      for (let i = targetGroupIndex - 1; i >= 0; i--) {
+        const groupMethod = existingMethods[i];
+        if (groups[groupMethod] && groups[groupMethod].length > 0) {
+          const lastItem2 = groups[groupMethod][groups[groupMethod].length - 1];
+          return {
+            insertIndex: lastItem2.endLineIndex + 1,
+            addComment: !hasExistingDefinitionsOfType
+          };
+        }
+      }
+      return {
+        insertIndex: appLineIndex + 1,
+        addComment: !hasExistingDefinitionsOfType
+      };
+    }
+    const parsed = parseHelperMethodDefinition(definition);
+    if (!parsed) {
+      return { insertIndex: appLineIndex + 1, addComment: false };
+    }
+    const { firstParam: itemName } = parsed;
+    for (let i = 0; i < targetGroup.length; i++) {
+      if (itemName.localeCompare(targetGroup[i].itemName) < 0) {
+        return { insertIndex: targetGroup[i].lineIndex, addComment: false };
+      }
+    }
+    const lastItem = targetGroup[targetGroup.length - 1];
+    return { insertIndex: lastItem.endLineIndex + 1, addComment: false };
+  }
+  /**
+   * Inserts a definition with optional comment header.
+   * @param lines - Array of file lines
+   * @param declaration - The declaration to insert
+   * @param insertIndex - The index where to insert
+   * @param methodName - The method name for comment generation
+   * @param addComment - Whether to add a comment before the declaration
+   * @returns The modified lines array
+   */
+  insertWithSpacing(lines, declaration, insertIndex, methodName, addComment = false) {
+    const newLines = [...lines];
+    if (addComment) {
+      const comment = this.getMethodComment(methodName);
+      newLines.splice(insertIndex, 0, `    ${comment}`);
+      insertIndex += 1;
+    }
+    newLines.splice(insertIndex, 0, declaration.trimEnd());
+    return newLines;
+  }
+  /**
+   * Checks if there are any existing definitions of a specific type in the content.
+   * @param content - The file content to search
+   * @param methodName - The method name to check for (e.g., 'addJob', 'addApi')
+   * @returns true if there are existing definitions of this type, false otherwise
+   */
+  hasExistingDefinitions(content, methodName) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.trim().startsWith(`.${methodName}(`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Removes an existing definition from the content by finding the helper method call
+   * and removing the entire method call block.
+   * @param content - The file content
+   * @param definition - The new definition to find the existing one from
+   * @returns The content with the existing definition removed
+   */
+  removeExistingDefinition(content, definition) {
+    const parsed = parseHelperMethodDefinition(definition);
+    if (!parsed) {
+      return content;
+    }
+    const { methodName, firstParam } = parsed;
+    let contentLines = content.split("\n");
+    let openingLineIndex = -1;
+    for (let i = 0; i < contentLines.length; i++) {
+      const line = contentLines[i];
+      if (line.trim().startsWith(`.${methodName}(`)) {
+        if (firstParam && line.includes(firstParam)) {
+          openingLineIndex = i;
+          break;
+        }
+      }
+    }
+    if (openingLineIndex === -1) {
+      return content;
+    }
+    let closingLineIndex = -1;
+    let parenCount = 0;
+    let braceCount = 0;
+    let foundOpening = false;
+    for (let i = openingLineIndex; i < contentLines.length; i++) {
+      const line = contentLines[i];
+      for (const char of line) {
+        if (char === "(") {
+          parenCount++;
+          foundOpening = true;
+        } else if (char === ")") {
+          parenCount--;
+          if (foundOpening && parenCount === 0 && braceCount === 0) {
+            closingLineIndex = i;
+            break;
+          }
+        } else if (char === "{") {
+          braceCount++;
+        } else if (char === "}") {
+          braceCount--;
+        }
+      }
+      if (closingLineIndex !== -1) {
+        break;
+      }
+    }
+    if (closingLineIndex === -1) {
+      this.logger.warn(
+        "Could not find closing parenthesis for existing definition"
+      );
+      return content;
+    }
+    contentLines.splice(
+      openingLineIndex,
+      closingLineIndex - openingLineIndex + 1
+    );
+    return contentLines.join("\n");
+  }
+  /**
+   * Adds a definition to the content by finding the appropriate place to insert it.
+   * @param content - The current file content
+   * @param definition - The definition to add
+   * @returns The updated content with the new definition
+   */
+  addDefinitionToContent(content, definition) {
+    const lines = content.split("\n");
+    const lastLineIndex = lines.length - 1;
+    let insertIndex = lastLineIndex;
+    for (let i = lastLineIndex; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (line && !line.startsWith("}")) {
+        insertIndex = i;
+        break;
+      }
+    }
+    lines.splice(insertIndex + 1, 0, `  ${definition}`);
+    return lines.join("\n");
+  }
+  /**
+   * Normalises semicolons in the config file by removing them from method chain calls
+   * while preserving them in other contexts (imports, declarations, etc.).
+   * @param content - The file content to normalise
+   * @returns The normalised content
+   */
+  normaliseSemicolons(content) {
+    const lines = content.split("\n");
+    const configureFunctionStart = lines.findIndex(
+      (line) => line.trim().startsWith("export default function")
+    );
+    if (configureFunctionStart === -1) {
+      return content;
+    }
+    const appLineIndex = lines.findIndex(
+      (line, index) => index > configureFunctionStart && line.trim().startsWith("app")
+    );
+    if (appLineIndex === -1) {
+      return content;
+    }
+    let braceCount = 0;
+    let functionEndIndex = lines.length - 1;
+    for (let i = configureFunctionStart; i < lines.length; i++) {
+      const line = lines[i];
+      for (const char of line) {
+        if (char === "{") braceCount++;
+        if (char === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            functionEndIndex = i;
+            break;
+          }
+        }
+      }
+      if (braceCount === 0 && i > configureFunctionStart) {
+        break;
+      }
+    }
+    let lastMethodCallIndex = -1;
+    for (let i = appLineIndex + 1; i < functionEndIndex; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if ((trimmed.endsWith(")") || trimmed.endsWith(");")) && !trimmed.startsWith("//")) {
+        lines[i] = line.replace(/;\s*$/, "");
+        lastMethodCallIndex = i;
+      }
+    }
+    if (lastMethodCallIndex !== -1 && !lines[lastMethodCallIndex].trim().endsWith(";")) {
+      lines[lastMethodCallIndex] = lines[lastMethodCallIndex] + ";";
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/generators/base/wasp-generator.base.ts
+var WaspGeneratorBase = class extends GeneratorBase {
+  constructor(fileSystem = realFileSystem, logger = singletonLogger2) {
+    super(fileSystem, logger);
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+    this.configGenerator = new WaspConfigGenerator(logger, fileSystem);
+    this.templateUtility = new TemplateUtility(fileSystem);
+    this.templateResolver = new TemplateResolver(fileSystem);
+  }
+  configGenerator;
+  templateUtility;
+  templateResolver;
+  swarmConfig;
+  configLoaded = false;
+  // Plugin name from swarm.config.json
+  pluginName = PLUGIN_NAME;
+  async loadSwarmConfig() {
+    if (this.configLoaded) return;
+    const configManager = new SwarmConfigManager();
+    this.swarmConfig = await configManager.loadConfig();
+    this.configLoaded = true;
+  }
+  async getCustomTemplateDir() {
+    await this.loadSwarmConfig();
+    return this.swarmConfig?.templateDirectory;
+  }
+  /**
+   * Resolves template path with override support
+   */
+  async getTemplatePath(templateName) {
+    const defaultPath = this.getDefaultTemplatePath(templateName);
+    const customPath = await this.getCustomTemplateDir();
+    if (!customPath) {
+      return defaultPath;
+    }
+    const { path: resolvedPath, isCustom } = this.templateResolver.resolveTemplatePath(
+      this.pluginName,
+      this.name,
+      templateName,
+      defaultPath,
+      customPath
+    );
+    if (isCustom) {
+      this.logger.info(`Using custom template: ${resolvedPath}`);
+    }
+    return resolvedPath;
+  }
+  /**
+   * Processes a template and writes the result to a file
+   */
+  async renderTemplateToFile(templateName, replacements, outputPath, readableFileType, force) {
+    const templatePath = await this.getTemplatePath(templateName);
+    const fileExists = this.checkFileExists(
+      outputPath,
+      force,
+      readableFileType
+    );
+    const content = this.templateUtility.processTemplate(
+      templatePath,
+      replacements
+    );
+    this.writeFile(outputPath, content, readableFileType, fileExists);
+    return fileExists;
+  }
+  /**
+   * Generic existence check with force flag handling
+   * Consolidates the pattern used in both file and config checks
+   */
+  checkExistence(exists, itemDescription, force, errorMessage) {
+    if (exists && !force) {
+      this.logger.error(`${itemDescription}. Use --force to overwrite`);
+      throw new Error(errorMessage || itemDescription);
+    }
+    return exists;
+  }
+  /**
+   * Checks if a file exists and handles force flag logic
+   */
+  checkFileExists(filePath, force, fileType) {
+    const fileExists = this.fileSystem.existsSync(filePath);
+    return this.checkExistence(
+      fileExists,
+      `${fileType} already exists: ${filePath}`,
+      force,
+      `${fileType} already exists`
+    );
+  }
+  /**
+   * Safely writes a file with proper error handling and logging
+   */
+  writeFile(filePath, content, fileType, fileExists) {
+    this.fileSystem.writeFileSync(filePath, content);
+    this.logger.success(
+      `${fileExists ? "Overwrote" : "Generated"} ${fileType}: ${filePath}`
+    );
+  }
+};
+
+// src/generators/feature/schema.ts
+import { z as z2 } from "zod";
+var schema = z2.object({
+  target: commonSchemas.target
+});
+
+// src/generators/feature/feature-generator.ts
+var FeatureGenerator = class extends WaspGeneratorBase {
+  constructor(logger = singletonLogger3, fileSystem = realFileSystem) {
+    super(fileSystem, logger);
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+    this.name = "feature";
+    this.description = "Generates a feature directory containing a Wasp configuration file";
+  }
+  name;
+  description;
+  schema = schema;
+  getDefaultTemplatePath(templateName) {
+    return this.templateUtility.resolveTemplatePath(
+      templateName,
+      this.name,
+      import.meta.url
+    );
+  }
+  /**
+   * Generates a feature directory containing a Wasp configuration file
+   * @param target - The target path of the generated directory
+   */
+  async generate(args) {
+    const { target } = args;
+    const segments = validateFeaturePath2(target);
+    const normalisedPath = normaliseFeaturePath(target);
+    const sourceRoot = path5.join(findWaspRoot(this.fileSystem), "src");
+    if (segments.length > 1) {
+      const parentPath = segments.slice(0, -1).join("/");
+      const parentNormalisedPath = normaliseFeaturePath(parentPath);
+      const parentFeatureDir = path5.join(sourceRoot, parentNormalisedPath);
+      if (!this.fileSystem.existsSync(parentFeatureDir)) {
+        handleFatalError2(
+          `Parent feature '${parentPath}' does not exist. Please create it first.`
+        );
+      }
+    }
+    const featureDir = path5.join(sourceRoot, normalisedPath);
+    this.fileSystem.mkdirSync(featureDir, { recursive: true });
+    this.configGenerator.generate(normalisedPath);
+    this.logger.success(`Generated feature: ${normalisedPath}`);
+  }
+};
+
+// src/generators/base/component-generator.base.ts
+var ComponentGeneratorBase = class extends WaspGeneratorBase {
+  constructor(logger = singletonLogger4, fileSystem = realFileSystem, featureDirectoryGenerator = new FeatureGenerator(logger, fileSystem)) {
+    super(fileSystem, logger);
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+    this.featureDirectoryGenerator = featureDirectoryGenerator;
+    this.featureDirectoryGenerator = featureDirectoryGenerator;
+  }
+  getDefaultTemplatePath(templateName) {
+    return this.templateUtility.resolveTemplatePath(
+      templateName,
+      this.name,
+      import.meta.url
+    );
+  }
+  get name() {
+    return toKebabCase2(this.componentType);
+  }
+  /**
+   * Validates that the feature config file exists in the target or ancestor directories
+   */
+  validateFeatureConfig(featurePath) {
+    const normalisedPath = normaliseFeaturePath(featurePath);
+    const segments = normalisedPath.split("/");
+    for (let i = segments.length; i > 0; i--) {
+      const pathSegments = segments.slice(0, i);
+      const currentPath = pathSegments.join("/");
+      const featureName = pathSegments[pathSegments.length - 1];
+      const featureDir = getFeatureDir(this.fileSystem, currentPath);
+      const configPath = path6.join(featureDir, `feature.wasp.ts`);
+      if (this.fileSystem.existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    this.logger.error(
+      `Feature config file not found in '${normalisedPath}' or any ancestor directories`
+    );
+    this.logger.error(
+      `Expected to find a feature.wasp.ts config file in one of the feature directories`
+    );
+    throw new Error("Feature config file not found");
+  }
+  /**
+   * Checks if a config item already exists in the feature config
+   */
+  checkConfigExists(configPath, methodName, itemName, force) {
+    const configContent = this.fileSystem.readFileSync(configPath, "utf8");
+    const configExists = hasHelperMethodCall(
+      configContent,
+      methodName,
+      itemName
+    );
+    return this.checkExistence(
+      configExists,
+      `${methodName} config already exists in ${configPath}`,
+      force,
+      `${methodName} config already exists`
+    );
+  }
+  /**
+   * Updates the feature config with a new definition
+   */
+  updateFeatureConfig(featurePath, definition, configPath, configExists, methodName) {
+    this.configGenerator.update(featurePath, definition);
+    this.logger.success(
+      `${configExists ? "Updated" : "Added"} ${methodName} config in: ${configPath}`
+    );
+  }
+  /**
+   * Consolidated helper for updating config files with existence check
+   * This replaces the duplicated updateConfigFile pattern in concrete generators
+   */
+  updateConfigWithCheck(configPath, methodName, entityName, definition, featurePath, force) {
+    const configExists = this.checkConfigExists(
+      configPath,
+      methodName,
+      entityName,
+      force
+    );
+    if (!configExists || force) {
+      this.updateFeatureConfig(
+        featurePath,
+        definition,
+        configPath,
+        configExists,
+        methodName
+      );
+    }
+  }
+  /**
+   * Gets the appropriate directory for a feature based on its path.
+   * @param fileSystem - The filesystem abstraction
+   * @param featurePath - The full feature path
+   * @param type - The type of file being generated
+   * @returns The target directory and import path
+   */
+  getFeatureTargetDir(fileSystem, featurePath, type) {
+    validateFeaturePath3(featurePath);
+    const normalisedPath = normaliseFeaturePath(featurePath);
+    const featureDir = getFeatureDir(fileSystem, normalisedPath);
+    const typeKey = type.toLowerCase();
+    const typeDirectory = TYPE_DIRECTORIES[typeKey];
+    const targetDirectory = path6.join(featureDir, typeDirectory);
+    const importDirectory = `@src/${normalisedPath}/${typeDirectory}`;
+    return { targetDirectory, importDirectory };
+  }
+  /**
+   * Ensures a target directory exists and returns its path
+   */
+  ensureTargetDirectory(featurePath, type) {
+    const { targetDirectory, importDirectory } = this.getFeatureTargetDir(
+      this.fileSystem,
+      featurePath,
+      type
+    );
+    ensureDirectoryExists(this.fileSystem, targetDirectory);
+    return { targetDirectory, importDirectory };
+  }
+  /**
+   * Generate middleware file for API or API namespace
+   */
+  async generateMiddlewareFile(targetFile, name, force) {
+    const replacements = {
+      name,
+      middlewareType: toCamelCase(this.componentType || "")
+    };
+    await this.renderTemplateToFile(
+      "middleware.eta",
+      replacements,
+      targetFile,
+      "Middleware file",
+      force
+    );
+  }
+};
+export {
+  ComponentGeneratorBase
+};