@ingenyus/swarm-wasp 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,13 +1,13 @@
-// src/common/filesystem.ts
-import { toPascalCase, validateFeaturePath } from "@ingenyus/swarm";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
 // src/types/constants.ts
 var PLUGIN_NAME = "wasp";
 var OPERATION_TYPES = ["query", "action"];
-var HTTP_METHODS = ["ALL", "GET", "POST", "PUT", "DELETE"];
+var API_HTTP_METHODS = [
+  "ALL",
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE"
+];
 var OPERATIONS = {
   CREATE: "create",
   UPDATE: "update",
@@ -57,7 +57,20 @@ var CONFIG_TYPES = {
   CRUD: "Crud"
 };
 
+// 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";
 var realFileSystem = {
   readFileSync: fs.readFileSync,
   writeFileSync: fs.writeFileSync,
@@ -102,13 +115,6 @@ function ensureDirectoryExists(fileSystem, dir) {
     fileSystem.mkdirSync(dir, { recursive: true });
   }
 }
-function featureExists(fileSystem, featurePath) {
-  return fileSystem.existsSync(getFeatureDir(fileSystem, featurePath));
-}
-function getConfigDir(fileSystem) {
-  const waspRoot = findWaspRoot(fileSystem);
-  return path.join(waspRoot, "config");
-}
 function normaliseFeaturePath(featurePath) {
   const segments = validateFeaturePath(featurePath);
   const normalisedSegments = [];
@@ -131,81 +137,21 @@ function getFeatureImportPath(featurePath) {
   const segments = validateFeaturePath(featurePath);
   return segments.join("/");
 }
-function getFeatureTargetDir(fileSystem, featurePath, type) {
-  validateFeaturePath(featurePath);
-  const normalisedPath = normaliseFeaturePath(featurePath);
-  const featureDir = getFeatureDir(fileSystem, normalisedPath);
-  const typeKey = type.toLowerCase();
-  const typeDirectory = TYPE_DIRECTORIES[typeKey];
-  const targetDirectory = path.join(featureDir, typeDirectory);
-  const importDirectory = `@src/${normalisedPath}/${typeDirectory}`;
-  return { targetDirectory, importDirectory };
-}
 function getRouteNameFromPath(routePath) {
   const lastSegment = routePath.split("/").filter(Boolean).pop() || "index";
   const cleanSegment = lastSegment.replace(/[:*]/g, "");
   return `${toPascalCase(cleanSegment)}Page`;
 }
-function getAppRootDir(fileSystem) {
-  const currentFile = fileURLToPath(import.meta.url);
-  let currentDir = path.dirname(currentFile);
-  while (currentDir !== path.dirname(currentDir)) {
-    const dirName = path.basename(currentDir);
-    if (dirName === "src" || dirName === "dist") {
-      return currentDir;
-    }
-    const packageJsonPath = path.join(currentDir, "package.json");
-    if (fileSystem.existsSync(packageJsonPath)) {
-      const srcPath = path.join(currentDir, "src");
-      const distPath = path.join(currentDir, "dist");
-      if (fileSystem.existsSync(distPath)) {
-        return distPath;
-      } else if (fileSystem.existsSync(srcPath)) {
-        return srcPath;
-      }
-    }
-    currentDir = path.dirname(currentDir);
-  }
-  throw new Error("Could not determine application root directory");
-}
-function getTemplatesDir(fileSystem) {
-  const appRoot = getAppRootDir(fileSystem);
-  return path.join(appRoot, "templates");
-}
-
-// src/common/plugin.ts
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function getPluginVersion() {
-  const __dirname = path2.dirname(fileURLToPath2(import.meta.url));
-  let currentDir = __dirname;
-  while (currentDir !== path2.dirname(currentDir)) {
-    const packageJsonPath = path2.join(currentDir, "package.json");
-    if (realFileSystem.existsSync(packageJsonPath)) {
-      try {
-        const packageJson = JSON.parse(
-          realFileSystem.readFileSync(packageJsonPath, "utf8")
-        );
-        if (packageJson.name === "@ingenyus/swarm-wasp") {
-          return packageJson.version;
-        }
-      } catch (e) {
-      }
-    }
-    currentDir = path2.dirname(currentDir);
-  }
-  return "0.1.0";
-}
 
 // src/common/prisma.ts
 import {
   getSchema
 } from "@mrleebo/prisma-ast";
 import fs2 from "fs";
-import path3 from "path";
+import path2 from "path";
 async function getEntityMetadata(modelName) {
   try {
-    const schemaPath = path3.join(process.cwd(), "schema.prisma");
+    const schemaPath = path2.join(process.cwd(), "schema.prisma");
     const schemaContent = fs2.readFileSync(schemaPath, "utf8");
     const schema9 = getSchema(schemaContent);
     const model = schema9.list?.find(
@@ -326,97 +272,61 @@ function getPrismaToTsType(type) {
 }
 
 // src/common/schemas.ts
-import { extend } from "@ingenyus/swarm";
+import { commandRegistry } from "@ingenyus/swarm";
 import { z } from "zod";
 var commonSchemas = {
-  feature: extend(z.string().min(1, "Feature is required"), {
-    description: "The feature directory this resource will be generated in",
-    friendlyName: "Feature",
+  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"'
+    helpText: "Can be nested as a logical or relative path, e.g. 'dashboard/users' or 'features/dashboard/features/users'"
   }),
-  name: extend(z.string().min(1, "Name is required"), {
-    description: "The name of the generated resource",
-    friendlyName: "Name",
+  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"
   }),
-  path: extend(z.string().min(1, "Path is required"), {
-    description: "The path that this resource will be accessible at",
-    friendlyName: "Path",
+  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"'
+    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: extend(z.string().optional(), {
-    description: "The Wasp entities that this resource will have access to (optional)",
-    friendlyName: "Entities",
+  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,Product"],
-    helpText: "A comma-separated list of Wasp entities"
+    examples: ["User", "User Task"],
+    helpText: "An array of Wasp entity names"
   }),
-  force: extend(z.boolean().optional(), {
-    description: "Force overwrite of existing files and configuration entries (optional)",
-    friendlyName: "Force",
+  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: extend(z.boolean().optional(), {
-    description: "Require authentication for this resource (optional)",
-    friendlyName: "Auth",
+  auth: z.boolean().optional().meta({
+    description: "Require authentication for this component (optional)"
+  }).register(commandRegistry, {
     shortName: "a",
     helpText: "Will generate authentication checks"
   })
 };
-var getTypedArrayValidator = (validValues) => {
-  return (input) => {
-    if (!input) return true;
-    const values = input.split(",").map((s) => s.trim()).filter(Boolean);
-    const normalisedValues = validValues.map((value) => value.toLowerCase());
-    for (const value of values) {
-      const normalisedValue = value.toLowerCase();
-      if (!normalisedValues.includes(normalisedValue)) {
-        return false;
-      }
-    }
-    return true;
-  };
-};
-var getTypedArrayTransformer = (validValues) => {
-  return (input) => {
-    if (!input) return void 0;
-    return input.split(",").map((s) => s.trim()).filter(Boolean).map((value) => {
-      const normalisedValue = value.toLowerCase();
-      const validValue = validValues.find(
-        (val) => val.toLowerCase() === normalisedValue
-      );
-      return validValue;
-    });
-  };
-};
-var getTypedValueValidator = (validValues) => {
-  return (value) => {
-    const normalisedValue = value.toLowerCase();
-    const normalisedValidOps = validValues.map((val) => val.toLowerCase());
-    return normalisedValidOps.includes(normalisedValue);
-  };
-};
-var getTypedValueTransformer = (validValues) => {
-  return (value) => {
-    const normalisedValue = value.toLowerCase();
-    const validValue = validValues.find(
-      (val) => val.toLowerCase() === normalisedValue
-    );
-    return validValue;
-  };
-};
 
 // src/common/templates.ts
 import { toKebabCase } from "@ingenyus/swarm";
 import { Eta } from "eta";
-import path4 from "path";
+import path3 from "path";
 var TemplateUtility = class {
   constructor(fileSystem) {
     this.fileSystem = fileSystem;
@@ -424,14 +334,14 @@ var TemplateUtility = class {
   processTemplate(templatePath, replacements) {
     const declarations = Object.keys(replacements).map((key) => `${key}=it.${key}`).join(", ");
     const functionHeader = declarations ? `const ${declarations};` : void 0;
-    const templateDir = path4.dirname(templatePath);
+    const templateDir = path3.dirname(templatePath);
     const eta = new Eta({
       autoTrim: false,
       autoEscape: false,
       views: templateDir,
       functionHeader
     });
-    const templateName = path4.basename(templatePath).replace(/\.eta$/, "");
+    const templateName = path3.basename(templatePath).replace(/\.eta$/, "");
     if (this.fileSystem.existsSync(templatePath)) {
       return eta.render(templateName, replacements);
     } else {
@@ -449,11 +359,11 @@ var TemplateUtility = class {
   resolveTemplatePath(relativePath, generatorName, currentFileUrl) {
     const generatorDirName = toKebabCase(generatorName);
     const currentFilePath = new URL(currentFileUrl).pathname;
-    const currentFileDir = path4.dirname(currentFilePath);
-    const currentFileName = path4.basename(currentFilePath);
+    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 : path4.dirname(path4.dirname(currentFileDir));
-    return path4.join(
+    const startDir = isInstalledPackage ? currentFileDir : path3.dirname(path3.dirname(currentFileDir));
+    return path3.join(
       startDir,
       "generators",
       generatorDirName,
@@ -463,2212 +373,2199 @@ var TemplateUtility = class {
   }
 };
 
-// src/plugin.ts
-function createWaspPlugin() {
-  return {
-    name: PLUGIN_NAME,
-    version: getPluginVersion(),
-    description: "Wasp Plugin for Swarm",
-    swarmVersion: "0.1.0",
-    generators: [
-      new ActionGenerator(),
-      new ApiGenerator(),
-      new ApiNamespaceGenerator(),
-      new CrudGenerator(),
-      new FeatureDirectoryGenerator(),
-      new JobGenerator(),
-      new QueryGenerator(),
-      new RouteGenerator()
-    ]
-  };
-}
-var _apiPlugin = null;
-function getWaspPlugin() {
-  if (!_apiPlugin) {
-    _apiPlugin = createWaspPlugin();
-  }
-  return _apiPlugin;
-}
-var wasp = getWaspPlugin;
-
-// src/wasp-config/app.ts
-import fs3 from "fs";
+// 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 {
-  App as WaspApp
-} from "wasp-config";
-var App = class _App extends WaspApp {
-  constructor(name, config) {
-    super(name, config);
+  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;
   /**
-   * Static factory method that creates and initializes Swarm with configuration
-   * dynamically loaded from feature directories
-   *
-   * @param name The name of the application
-   * @param config The base configuration for the application
-   * @returns An initialized Swarm instance
+   * 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
    */
-  static async create(name, config) {
-    const app = new _App(name, config);
-    await app.configureFeatures();
-    return app;
-  }
-  // Chainable configuration methods
-  auth(authConfig) {
-    super.auth(authConfig);
-    return this;
-  }
-  client(clientConfig) {
-    super.client(clientConfig);
-    return this;
-  }
-  db(dbConfig) {
-    super.db(dbConfig);
-    return this;
-  }
-  emailSender(emailSenderConfig) {
-    super.emailSender(emailSenderConfig);
-    return this;
-  }
-  job(name, jobConfig) {
-    super.job(name, jobConfig);
-    return this;
-  }
-  query(name, queryConfig) {
-    super.query(name, queryConfig);
-    return this;
-  }
-  route(name, routeConfig) {
-    super.route(name, routeConfig);
-    return this;
-  }
-  api(name, apiConfig) {
-    super.api(name, apiConfig);
-    return this;
-  }
-  apiNamespace(name, apiNamespaceConfig) {
-    super.apiNamespace(name, apiNamespaceConfig);
-    return this;
-  }
-  crud(name, crudConfig) {
-    super.crud(name, crudConfig);
-    return this;
-  }
-  action(name, actionConfig) {
-    super.action(name, actionConfig);
-    return this;
+  getTemplatePath(templateName) {
+    return this.templateUtility.resolveTemplatePath(
+      templateName,
+      "feature",
+      import.meta.url
+    );
   }
   /**
-   * Helper method to add routes with simplified parameters
-   * @param featureName The name of the feature
-   * @param name Route name, e.g. "DashboardRoute"
-   * @param options Route configuration options
+   * Generate a TypeScript Wasp config file in a feature directory
+   * @param featurePath - The feature directory path
    */
-  addRoute(featureName, name, options) {
-    const componentName = name.charAt(0).toUpperCase() + name.slice(1);
-    const importPath = this.getFeatureImportPath(
-      featureName,
-      "client",
-      "pages",
-      componentName
-    );
-    const routeConfig = {
-      path: options.path,
-      to: this.page(componentName, {
-        authRequired: options.auth || false,
-        component: {
-          import: componentName,
-          from: `@src/${importPath}`
-        }
-      })
-    };
-    super.route(name, routeConfig);
-    return this;
+  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}`);
   }
   /**
-   * Helper method to add API endpoints with simplified parameters
-   * @param featureName The name of the feature
-   * @param name API endpoint name, e.g. "getTasksApi"
-   * @param options API configuration options
+   * 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
    */
-  addApi(featureName, name, options) {
-    const importPath = this.getFeatureImportPath(
-      featureName,
-      "server",
-      "apis",
-      name
+  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
     );
-    const middlewareImportPath = this.getFeatureImportPath(
-      featureName,
-      "server",
-      "middleware",
-      name
+    content = this.removeExistingDefinition(content, declaration);
+    const hasExistingDefinitions = this.hasExistingDefinitions(
+      content,
+      methodName
     );
-    super.api(name, {
-      fn: {
-        import: name,
-        from: `@src/${importPath}`
-      },
-      ...options.customMiddleware && {
-        import: name,
-        from: `@src/${middlewareImportPath}`
-      },
-      entities: options.entities,
-      httpRoute: { method: options.method, route: options.route },
-      auth: options.auth || false
-    });
-    return this;
-  }
-  /**
-   * Helper method to add CRUD operations with simplified parameters
-   * @param featureName The name of the feature
-   * @param name The CRUD name
-   * @param options CRUD configuration options
+    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
    */
-  addCrud(featureName, name, options) {
-    const processOperationOptions = (operationName, operationOptions) => {
-      if (!operationOptions) return void 0;
-      const processedOptions = { ...operationOptions };
-      if (operationOptions.override) {
-        const operationDataType = operationName === "getAll" ? this.getPlural(options.entity) : options.entity;
-        const operationComponent = `${operationName}${operationDataType}`;
-        const importPath = this.getFeatureImportPath(
-          featureName,
-          "server",
-          "cruds",
-          name.charAt(0).toLowerCase() + name.slice(1)
+  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*['"`]([^'"`]+)['"`]/
         );
-        processedOptions.overrideFn = {
-          import: operationComponent,
-          from: `@src/${importPath}`
-        };
-        delete processedOptions.override;
+        if (match) {
+          methodCalls.push({
+            lineIndex: i,
+            endLineIndex: j,
+            methodName: match[1],
+            itemName: match[2]
+          });
+        }
       }
-      return processedOptions;
-    };
-    super.crud(this.getPlural(options.entity), {
-      entity: options.entity,
-      operations: {
-        getAll: processOperationOptions("getAll", options.getAll),
-        get: processOperationOptions("get", options.get),
-        create: processOperationOptions("create", options.create),
-        update: processOperationOptions("update", options.update),
-        delete: processOperationOptions("delete", options.delete)
+    }
+    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
+      });
     });
-    return this;
+    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 };
   }
   /**
-   * Helper method to add actions with simplified parameters
-   * @param featureName The name of the feature
-   * @param name The action name
-   * @param options Action configuration options
+   * 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
    */
-  addAction(featureName, name, options) {
-    const importPath = this.getFeatureImportPath(
-      featureName,
-      "server",
-      "actions",
-      name
-    );
-    const config = this.getOperationConfig(
-      name,
-      importPath,
-      options.entities,
-      options.auth
-    );
-    super.action(name, config);
-    return this;
+  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;
   }
   /**
-   * Helper method to add queries with simplified parameters
-   * @param featureName The name of the feature
-   * @param name The query name
-   * @param options Query configuration options
+   * 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
    */
-  addQuery(featureName, name, options) {
-    const importPath = this.getFeatureImportPath(
-      featureName,
-      "server",
-      "queries",
-      name
-    );
-    const config = this.getOperationConfig(
-      name,
-      importPath,
-      options.entities,
-      options.auth
-    );
-    super.query(name, config);
-    return this;
+  hasExistingDefinitions(content, methodName) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.trim().startsWith(`.${methodName}(`)) {
+        return true;
+      }
+    }
+    return false;
   }
   /**
-   * Helper method to add background jobs with simplified parameters
-   * @param featureName The name of the feature
-   * @param name Job name
-   * @param options Job configuration options
+   * 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
    */
-  addJob(featureName, name, options) {
-    const importPath = this.getFeatureImportPath(
-      featureName,
-      "server",
-      "jobs",
-      name
-    );
-    super.job(name, {
-      executor: "PgBoss",
-      perform: {
-        fn: {
-          import: name,
-          from: `@src/${importPath}`
+  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;
         }
-      },
-      entities: options.entities,
-      ...options.cron && {
-        schedule: {
-          cron: options.cron,
-          args: options.args || {}
+      }
+    }
+    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--;
         }
       }
-    });
-    return this;
+      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");
   }
   /**
-   * Helper method to add API namespaces with simplified parameters
-   * @param featureName The name of the feature
-   * @param name Namespace name
-   * @param options API namespace configuration options
+   * 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
    */
-  addApiNamespace(featureName, name, options) {
-    const importPath = this.getFeatureImportPath(
-      featureName,
-      "server",
-      "middleware",
-      name
+  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")
     );
-    super.apiNamespace(name, {
-      path: options.path,
-      middlewareConfigFn: {
-        import: name,
-        from: `@src/${importPath}`
+    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;
+          }
+        }
       }
-    });
-    return this;
+      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;
   }
   /**
-   * Calculates the import path for a feature component
-   * @param featureName The name of the feature
-   * @param type The type of component (client, server, etc.)
-   * @param subPath The sub-path within the feature directory
-   * @param fileName The name of the file (optional, defaults to featureName)
-   * @returns The calculated import path
+   * 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
    */
-  getFeatureImportPath(featureName, type, subPath, fileName) {
-    const file = fileName || featureName;
-    return `features/${featureName}/${type}/${subPath}/${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;
   }
   /**
-   * Converts a singular word to its plural form
-   * @param word The singular word to pluralize
-   * @returns The plural form of the word
+   * Generic existence check with force flag handling
+   * Consolidates the pattern used in both file and config checks
    */
-  getPlural(word) {
-    if (word.endsWith("y")) {
-      return word.slice(0, -1) + "ies";
-    } else if (word.endsWith("s") || word.endsWith("sh") || word.endsWith("ch") || word.endsWith("x") || word.endsWith("z")) {
-      return word + "es";
-    } else {
-      return word + "s";
+  checkExistence(exists, itemDescription, force, errorMessage) {
+    if (exists && !force) {
+      this.logger.error(`${itemDescription}. Use --force to overwrite`);
+      throw new Error(errorMessage || itemDescription);
     }
+    return exists;
   }
   /**
-   * Configures all feature modules by scanning the features directory
+   * Checks if a file exists and handles force flag logic
    */
-  async configureFeatures() {
-    const featuresDir = path5.join(process.cwd(), "src", "features");
-    if (!fs3.existsSync(featuresDir)) {
-      console.warn(
-        "Features directory not found, skipping feature configuration"
-      );
-      return this;
-    }
-    const getAllFeatureFiles = (dir) => {
-      let results = [];
-      const list = fs3.readdirSync(dir, { withFileTypes: true });
-      for (const entry of list) {
-        const fullPath = path5.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          results = results.concat(getAllFeatureFiles(fullPath));
-        } else if (entry.isFile() && entry.name.endsWith(".wasp.ts")) {
-          results.push(path5.relative(featuresDir, fullPath));
-        }
-      }
-      return results;
-    };
-    const featureFiles = getAllFeatureFiles(featuresDir);
-    for (const file of featureFiles) {
-      try {
-        const featureName = path5.dirname(file);
-        const modulePath = path5.join(
-          process.cwd(),
-          ".wasp",
-          "src",
-          "features",
-          file.replace(".ts", ".js")
-        );
-        const module = await import(modulePath);
-        if (module.default) {
-          module.default(this, featureName);
-        }
-      } catch (error) {
-        console.error(`Failed to load feature module ${file}:`, error);
-      }
-    }
-    return this;
+  checkFileExists(filePath, force, fileType) {
+    const fileExists = this.fileSystem.existsSync(filePath);
+    return this.checkExistence(
+      fileExists,
+      `${fileType} already exists: ${filePath}`,
+      force,
+      `${fileType} already exists`
+    );
   }
   /**
-   * Helper method to get the configuration for an action or query
-   * @param name The operation name
-   * @param importPath Import path (excluding `@src/` prefix), e.g. "features/dashboard/server/queries/getTasks"
-   * @param entities Comma-separated list of entities (optional, defaults to datatype)
-   * @param auth Require authentication (optional)
+   * Safely writes a file with proper error handling and logging
    */
-  getOperationConfig(name, importPath, entities, auth) {
-    return {
-      fn: {
-        import: name,
-        from: `@src/${importPath}`
-      },
-      entities,
-      auth: auth || false
-    };
+  writeFile(filePath, content, fileType, fileExists) {
+    this.fileSystem.writeFileSync(filePath, content);
+    this.logger.success(
+      `${fileExists ? "Overwrote" : "Generated"} ${fileType}: ${filePath}`
+    );
   }
 };
 
-// src/generators/base/entity-generator.base.ts
-import {
-  hasHelperMethodCall,
-  SignaleLogger as SignaleLogger4,
-  toCamelCase,
-  toKebabCase as toKebabCase2,
-  validateFeaturePath as validateFeaturePath3
-} from "@ingenyus/swarm";
-import path8 from "path";
-
-// src/generators/feature-directory/feature-directory-generator.ts
-import {
-  handleFatalError as handleFatalError2,
-  SignaleLogger as SignaleLogger3,
-  validateFeaturePath as validateFeaturePath2
-} from "@ingenyus/swarm";
-import path7 from "path";
-
-// src/generators/base/wasp-generator.base.ts
-import {
-  GeneratorBase,
-  SignaleLogger as SignaleLogger2,
-  SwarmConfigManager,
-  TemplateResolver
-} from "@ingenyus/swarm";
+// src/generators/feature/schema.ts
+import { z as z2 } from "zod";
+var schema = z2.object({
+  target: commonSchemas.target
+});
 
-// src/generators/config/wasp-config-generator.ts
-import {
-  handleFatalError,
-  parseHelperMethodDefinition,
-  SignaleLogger
-} from "@ingenyus/swarm";
-import path6 from "path";
-var WaspConfigGenerator = class {
-  constructor(logger = new SignaleLogger(), fileSystem = realFileSystem) {
+// 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.templateUtility = new TemplateUtility(fileSystem);
+    this.name = "feature";
+    this.description = "Generates a feature directory containing a Wasp configuration file";
   }
-  path = path6;
-  templateUtility;
-  /**
-   * Gets the template path for feature config templates.
-   * Feature config templates are located in the feature-directory 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) {
+  name;
+  description;
+  schema = schema;
+  getDefaultTemplatePath(templateName) {
     return this.templateUtility.resolveTemplatePath(
       templateName,
-      "feature-directory",
+      this.name,
       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 configFilePrefix = featurePath.split("/").at(-1);
-    const configFilePath = path6.join(featureDir, `${configFilePrefix}.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
+   * Generates a feature directory containing a Wasp configuration file
+   * @param target - The target path of the generated directory
    */
-  update(featurePath, declaration) {
-    const configFilePrefix = featurePath.split("/").at(-1);
-    const configDir = getFeatureDir(this.fileSystem, featurePath);
-    const configFilePath = path6.join(configDir, `${configFilePrefix}.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}`);
+  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.`
+        );
       }
-      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"
+    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
     );
-    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;
+  }
+  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;
+      }
     }
-    const normalisedContent = this.normaliseSemicolons(lines.join("\n"));
-    this.fileSystem.writeFileSync(configFilePath, normalisedContent);
-    return configFilePath;
+    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");
   }
   /**
-   * 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
+   * Checks if a config item already exists in the feature config
    */
-  getInsertionIndexForMethod(groups, methodName) {
-    const existingMethods = Object.keys(groups).filter(
-      (method) => groups[method].length > 0
+  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`
     );
-    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
+   * Updates the feature config with a new definition
    */
-  getMethodComment(methodName) {
-    const entityName = methodName.startsWith("add") ? methodName.slice(3) : methodName;
-    return `// ${entityName} definitions`;
+  updateFeatureConfig(featurePath, definition, configPath, configExists, methodName) {
+    this.configGenerator.update(featurePath, definition);
+    this.logger.success(
+      `${configExists ? "Updated" : "Added"} ${methodName} config in: ${configPath}`
+    );
   }
   /**
-   * 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
+   * Consolidated helper for updating config files with existence check
+   * This replaces the duplicated updateConfigFile pattern in concrete generators
    */
-  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,
+  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
       );
-      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
+   * 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
    */
-  insertWithSpacing(lines, declaration, insertIndex, methodName, addComment = false) {
-    const newLines = [...lines];
-    if (addComment) {
-      const comment = this.getMethodComment(methodName);
-      newLines.splice(insertIndex, 0, `    ${comment}`);
-      insertIndex += 1;
+  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
+    );
+  }
+};
+
+// src/generators/base/operation-generator.base.ts
+import {
+  capitalise,
+  getPlural,
+  handleFatalError as handleFatalError3,
+  toPascalCase as toPascalCase2
+} from "@ingenyus/swarm";
+var OperationGeneratorBase = class extends ComponentGeneratorBase {
+  /**
+   * Gets the operation name based on operation type and model name.
+   */
+  getOperationName(operation, modelName, customName) {
+    if (customName) {
+      return customName;
+    }
+    switch (operation) {
+      case OPERATIONS.GETALL:
+        return `getAll${getPlural(modelName)}`;
+      case OPERATIONS.GETFILTERED:
+        return `getFiltered${getPlural(modelName)}`;
+      default:
+        return `${operation}${modelName}`;
     }
-    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
+   * Gets the template path for operation templates.
+   * This method resolves operation templates to the operation generator's directory
+   * instead of the current generator's directory.
    */
-  hasExistingDefinitions(content, methodName) {
-    const lines = content.split("\n");
-    for (const line of lines) {
-      if (line.trim().startsWith(`.${methodName}(`)) {
-        return true;
-      }
-    }
-    return false;
+  getOperationTemplatePath(templateName) {
+    return this.templateUtility.resolveTemplatePath(
+      templateName,
+      "operation",
+      import.meta.url
+    );
   }
   /**
-   * 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
+   * Gets the TypeScript type name for an operation.
    */
-  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;
+  getOperationTypeName(operation, modelName) {
+    return toPascalCase2(this.getOperationName(operation, modelName));
+  }
+  /**
+   * Generates import statements for an operation.
+   */
+  generateImports(model, modelName, operation) {
+    const imports = [];
+    if (operation !== OPERATIONS.GETALL) {
+      if (needsPrismaImport(model)) {
+        imports.push('import { Prisma } from "@prisma/client";');
       }
+      imports.push(`import { ${modelName} } from "wasp/entities";`);
     }
-    if (closingLineIndex === -1) {
-      this.logger.warn(
-        "Could not find closing parenthesis for existing definition"
-      );
-      return content;
-    }
-    contentLines.splice(
-      openingLineIndex,
-      closingLineIndex - openingLineIndex + 1
+    imports.push('import { HttpError } from "wasp/server";');
+    imports.push(
+      `import type { ${this.getOperationTypeName(
+        operation,
+        modelName
+      )} } from "wasp/server/operations";`
     );
-    return contentLines.join("\n");
+    return imports.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
+   * Gets the operation type ("query" or "action") for a given operation.
    */
-  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");
+  getOperationType(operation) {
+    return operation === OPERATIONS.GETALL || operation === OPERATIONS.GET || operation === OPERATIONS.GETFILTERED ? "query" : "action";
   }
   /**
-   * 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
+   * Generates the operation components needed for file and config generation.
    */
-  normaliseSemicolons(content) {
-    const lines = content.split("\n");
-    const configureFunctionStart = lines.findIndex(
-      (line) => line.trim().startsWith("export default function")
+  async generateOperationComponents(modelName, operation, auth = false, entities = [modelName], isCrudOverride = false, crudName = null, customName) {
+    const model = await getEntityMetadata(modelName);
+    const operationType = this.getOperationType(operation);
+    const operationName = this.getOperationName(
+      operation,
+      modelName,
+      customName
     );
-    if (configureFunctionStart === -1) {
-      return content;
-    }
-    const appLineIndex = lines.findIndex(
-      (line, index) => index > configureFunctionStart && line.trim().startsWith("app")
+    const operationCode = await this.generateOperationCode(
+      model,
+      operation,
+      auth,
+      isCrudOverride,
+      crudName
     );
-    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;
-          }
-        }
+    const configEntry = {
+      operationName,
+      entities,
+      authRequired: auth
+    };
+    return {
+      operationCode,
+      configEntry,
+      operationType,
+      operationName
+    };
+  }
+  /**
+   * Generates the code for an operation.
+   */
+  async generateOperationCode(model, operation, auth = false, isCrudOverride = false, crudName = null) {
+    const operationType = this.getOperationType(operation);
+    const templatePath = this.getOperationTemplatePath(`${operation}.eta`);
+    const allFieldNames = model.fields.map((f) => f.name);
+    const idFields = getIdFields(model);
+    const requiredFields = getRequiredFields(model);
+    const optionalFields = getOptionalFields(model);
+    const jsonFields = getJsonFields(model);
+    const pluralModelName = getPlural(model.name);
+    const pluralModelNameLower = pluralModelName.toLowerCase();
+    const modelNameLower = model.name.toLowerCase();
+    const operationName = this.getOperationName(operation, model.name);
+    const imports = isCrudOverride ? "" : this.generateImports(model, model.name, operation);
+    const jsonTypeHandling = generateJsonTypeHandling(jsonFields);
+    let typeParams = "";
+    switch (operation) {
+      case "create": {
+        const pickRequired = generatePickType(
+          model.name,
+          requiredFields,
+          allFieldNames
+        );
+        const partialOptional = generatePartialType(
+          generatePickType(model.name, optionalFields, allFieldNames)
+        );
+        typeParams = `<${generateIntersectionType(pickRequired, partialOptional)}>`;
+        break;
       }
-      if (braceCount === 0 && i > configureFunctionStart) {
+      case "update": {
+        const pickId = generatePickType(model.name, idFields, allFieldNames);
+        const omitId = generateOmitType(model.name, idFields, allFieldNames);
+        const partialRest = generatePartialType(omitId);
+        typeParams = `<${generateIntersectionType(pickId, partialRest)}>`;
         break;
       }
+      case "delete":
+      case "get":
+        typeParams = `<${generatePickType(model.name, idFields, allFieldNames)}>`;
+        break;
+      case "getAll":
+        typeParams = `<void>`;
+        break;
+      case "getFiltered":
+        typeParams = `<${generatePartialType(model.name)}>`;
+        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;
+    const authCheck = auth ? `  if (!context.user) {
+    throw new HttpError(401);
+  }
+
+` : "";
+    let typeAnnotation = "";
+    let satisfiesType = "";
+    if (isCrudOverride && crudName) {
+      const opCap = capitalise(operation);
+      if (operationType === "action") {
+        typeAnnotation = `: ${crudName}.${opCap}Action${typeParams}`;
+      } else {
+        typeAnnotation = "";
+      }
+      if (operationType === "query") {
+        satisfiesType = `satisfies ${crudName}.${opCap}Query${typeParams}`;
+      } else {
+        satisfiesType = "";
+      }
+    } else {
+      if (operationType === "action") {
+        typeAnnotation = `: ${this.getOperationTypeName(operation, model.name)}${typeParams}`;
+      } else {
+        typeAnnotation = "";
+      }
+      if (operationType === "query") {
+        satisfiesType = `satisfies ${this.getOperationTypeName(operation, model.name)}${typeParams}`;
+      } else {
+        satisfiesType = "";
       }
     }
-    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 = new SignaleLogger2()) {
-    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;
+    const isCompositeKey = idFields.length > 1;
+    const compositeKeyName = isCompositeKey ? idFields.join("_") : "";
+    const idFieldParams = isCompositeKey ? idFields.join(", ") : idFields[0];
+    const whereClause = isCompositeKey ? `${compositeKeyName}: { ${idFields.map((f) => `${f}`).join(", ")} }` : idFields[0];
+    const replacements = {
+      operationName,
+      modelName: model.name,
+      authCheck,
+      imports,
+      idField: idFields[0],
+      idFieldParams,
+      whereClause,
+      isCompositeKey: String(isCompositeKey),
+      compositeKeyName,
+      jsonTypeHandling,
+      typeAnnotation,
+      satisfiesType,
+      modelNameLower,
+      pluralModelNameLower
+    };
+    return this.templateUtility.processTemplate(templatePath, replacements);
   }
   /**
-   * Resolves template path with override support
+   * Generates an operation file for a given operation.
    */
-  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
+  generateOperationFile(operationsDir, operationName, operationCode, force = false) {
+    const operationFile = `${operationsDir}/${operationName}.ts`;
+    const fileExists = this.checkFileExists(
+      operationFile,
+      force,
+      "Operation file"
     );
-    if (isCustom) {
-      this.logger.info(`Using custom template: ${resolvedPath}`);
-    }
-    return resolvedPath;
+    this.writeFile(operationFile, operationCode, "operation file", fileExists);
   }
   /**
-   * Processes a template and writes the result to a file
+   * Copies a directory of operation templates to the target feature directory.
+   * @param templateDir - The source template directory
+   * @param targetDir - The target feature directory
    */
-  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
+  copyOperationTemplates(templateDir, targetDir) {
+    copyDirectory(this.fileSystem, templateDir, targetDir);
+    this.logger.debug(
+      `Copied operation templates from ${templateDir} to ${targetDir}`
     );
-    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
+   * Generates an operation definition for the feature configuration.
    */
-  checkExistence(exists, itemDescription, force, errorMessage) {
-    if (exists && !force) {
-      this.logger.error(`${itemDescription}. Use --force to overwrite`);
-      throw new Error(errorMessage || itemDescription);
+  getDefinition(operationName, featurePath, entities, operationType, importPath, auth = false) {
+    if (!OPERATION_TYPES.includes(operationType)) {
+      handleFatalError3(`Unknown operation type: ${operationType}`);
     }
-    return exists;
+    const directory = TYPE_DIRECTORIES[operationType];
+    const featureDir = getFeatureImportPath(featurePath);
+    const templatePath = this.templateUtility.resolveTemplatePath(
+      "operation.eta",
+      "config",
+      import.meta.url
+    );
+    return this.templateUtility.processTemplate(templatePath, {
+      operationType: capitalise(operationType),
+      operationName,
+      featureDir,
+      directory,
+      entities: entities.map((e) => `"${e}"`).join(", "),
+      importPath,
+      auth: String(auth)
+    });
   }
-  /**
-   * 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`
+};
+
+// src/generators/action/schema.ts
+import { SchemaManager, commandRegistry as commandRegistry2 } from "@ingenyus/swarm";
+import { z as z3 } from "zod";
+var validActions = Object.values(ACTION_OPERATIONS);
+var actionSchema = z3.string().min(1, "Action type is required").transform((val) => SchemaManager.findEnumValue(ACTION_OPERATIONS, val)).pipe(
+  z3.enum(ACTION_OPERATIONS, {
+    message: `Invalid action. Must be one of: ${validActions.join(", ")}`
+  })
+).meta({ description: "The action operation to generate" }).register(commandRegistry2, {
+  shortName: "o",
+  examples: validActions,
+  helpText: `Available actions: ${validActions.join(", ")}`
+});
+var schema2 = z3.object({
+  feature: commonSchemas.feature,
+  operation: actionSchema,
+  dataType: commonSchemas.dataType,
+  name: commonSchemas.name.optional().meta({
+    ...commonSchemas.name.meta() ?? {},
+    description: `${commonSchemas.name.meta()?.description ?? ""} (optional)`
+  }).register(commandRegistry2, commandRegistry2.get(commonSchemas.name) ?? {}),
+  entities: commonSchemas.entities,
+  force: commonSchemas.force,
+  auth: commonSchemas.auth
+});
+
+// src/generators/action/action-generator.ts
+var ActionGenerator = class extends OperationGeneratorBase {
+  get componentType() {
+    return CONFIG_TYPES.ACTION;
+  }
+  description = "Generates a Wasp Action";
+  schema = schema2;
+  async generate(args) {
+    const { dataType, feature, name } = args;
+    const operation = args.operation;
+    const operationType = "action";
+    const entities = args.entities ?? [];
+    if (dataType && !entities.includes(dataType)) {
+      entities.unshift(dataType);
+    }
+    const { operationCode, operationName } = await this.generateOperationComponents(
+      dataType,
+      operation,
+      args.auth,
+      entities,
+      false,
+      null,
+      name
+    );
+    return this.handleGeneratorError(
+      this.componentType,
+      operationName,
+      async () => {
+        const configPath = this.validateFeatureConfig(feature);
+        const { targetDirectory: operationsDir, importDirectory } = this.ensureTargetDirectory(feature, operationType);
+        const importPath = `${importDirectory}/${operationName}`;
+        this.generateOperationFile(
+          operationsDir,
+          operationName,
+          operationCode,
+          args.force || false
+        );
+        const definition = this.getDefinition(
+          operationName,
+          feature,
+          entities,
+          "action",
+          importPath,
+          args.auth
+        );
+        this.updateConfigWithCheck(
+          configPath,
+          "addAction",
+          operationName,
+          definition,
+          feature,
+          args.force || false
+        );
+      }
+    );
+  }
+};
+
+// src/generators/api/api-generator.ts
+import { toCamelCase as toCamelCase2, toPascalCase as toPascalCase3 } from "@ingenyus/swarm";
+
+// src/generators/api/schema.ts
+import { commandRegistry as commandRegistry3 } from "@ingenyus/swarm";
+import { z as z4 } from "zod";
+var validHttpMethods = API_HTTP_METHODS.map((method) => `${method}`);
+var schema3 = z4.object({
+  method: z4.string().min(1, "HTTP method is required").transform((val) => val.toUpperCase()).pipe(
+    z4.enum(API_HTTP_METHODS, {
+      message: `Invalid HTTP method. Must be one of: ${validHttpMethods.join(", ")}`
+    })
+  ).meta({ description: "The HTTP method used for this API Endpoint" }).register(commandRegistry3, {
+    shortName: "m",
+    examples: validHttpMethods,
+    helpText: `Must be one of: ${validHttpMethods.join(", ")}`
+  }),
+  feature: commonSchemas.feature,
+  name: commonSchemas.name,
+  path: commonSchemas.path,
+  entities: commonSchemas.entities,
+  auth: commonSchemas.auth,
+  force: commonSchemas.force,
+  customMiddleware: z4.boolean().meta({ description: "Enable custom middleware for this API Endpoint" }).optional().register(commandRegistry3, {
+    shortName: "c",
+    helpText: "Will generate custom middleware file"
+  })
+});
+
+// src/generators/api/api-generator.ts
+var ApiGenerator = class extends ComponentGeneratorBase {
+  get componentType() {
+    return CONFIG_TYPES.API;
+  }
+  description = "Generates a Wasp API Endpoint";
+  schema = schema3;
+  async generate(args) {
+    const apiName = toCamelCase2(args.name);
+    return this.handleGeneratorError(this.componentType, apiName, async () => {
+      const configPath = this.validateFeatureConfig(args.feature);
+      const {
+        targetDirectory: apiTargetDirectory,
+        importDirectory: apiImportDirectory
+      } = this.ensureTargetDirectory(args.feature, this.name);
+      const fileName = `${apiName}.ts`;
+      const targetFile = `${apiTargetDirectory}/${fileName}`;
+      await this.generateApiFile(targetFile, apiName, args);
+      if (args.customMiddleware) {
+        const { targetDirectory: middlewareTargetDirectory } = this.ensureTargetDirectory(args.feature, "middleware");
+        const middlewareFile = `${middlewareTargetDirectory}/${apiName}.ts`;
+        this.generateMiddlewareFile(
+          middlewareFile,
+          apiName,
+          args.force || false
+        );
+      }
+      await this.updateConfigFile(
+        apiName,
+        fileName,
+        apiImportDirectory,
+        args,
+        configPath
+      );
+    });
+  }
+  async generateApiFile(targetFile, apiName, { method, auth = false, force = false }) {
+    const replacements = this.buildTemplateData(apiName, method, auth);
+    await this.renderTemplateToFile(
+      "api.eta",
+      replacements,
+      targetFile,
+      "API Endpoint file",
+      force
     );
   }
-  /**
-   * 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}`
+  async updateConfigFile(apiName, apiFile, importDirectory, args, configFilePath) {
+    const {
+      feature,
+      force = false,
+      entities,
+      method,
+      path: path9,
+      auth,
+      customMiddleware
+    } = args;
+    const importPath = this.path.join(importDirectory, apiFile);
+    const definition = await this.getConfigDefinition(
+      apiName,
+      feature,
+      Array.isArray(entities) ? entities : entities ? [entities] : [],
+      method,
+      path9,
+      apiFile,
+      auth,
+      importPath,
+      customMiddleware || false
+    );
+    this.updateConfigWithCheck(
+      configFilePath,
+      "addApi",
+      apiName,
+      definition,
+      feature,
+      force
     );
   }
-};
+  async getConfigDefinition(apiName, featurePath, entities, method, route, apiFile, auth = false, importPath, customMiddleware = false) {
+    const featureDir = getFeatureImportPath(featurePath);
+    const configTemplatePath = await this.getTemplatePath("config/api.eta");
+    return this.templateUtility.processTemplate(configTemplatePath, {
+      apiName,
+      featureDir,
+      entities: entities.map((e) => `"${e}"`).join(", "),
+      method,
+      route,
+      apiFile,
+      auth: String(auth),
+      importPath,
+      customMiddleware: String(customMiddleware)
+    });
+  }
+  buildTemplateData(apiName, method, auth) {
+    const apiType = toPascalCase3(apiName);
+    const authCheck = auth ? `  if (!context.user) {
+  throw new HttpError(401);
+}
 
-// src/generators/feature-directory/schema.ts
-import { z as z2 } from "zod";
-var schema = z2.object({
-  path: commonSchemas.path
-});
+` : "";
+    const methodCheck = method !== "ALL" ? `  if (req.method !== '${method}') {
+  throw new HttpError(405);
+}
 
-// src/generators/feature-directory/feature-directory-generator.ts
-var FeatureDirectoryGenerator = class extends WaspGeneratorBase {
-  constructor(logger = new SignaleLogger3(), fileSystem = realFileSystem) {
-    super(fileSystem, logger);
-    this.logger = logger;
-    this.fileSystem = fileSystem;
-    this.name = "feature-directory";
-    this.description = "Generate feature directory structure";
-    this.schema = schema;
-  }
-  name;
-  description;
-  schema;
-  getDefaultTemplatePath(templateName) {
-    return this.templateUtility.resolveTemplatePath(
-      templateName,
-      this.name,
-      import.meta.url
-    );
-  }
-  /**
-   * Generate feature directory structure (main entry point)
-   * @param featurePath - The path to the feature
-   */
-  async generate(flags) {
-    const { path: featurePath } = flags;
-    console.log("generate feature directory:", featurePath);
-    const segments = validateFeaturePath2(featurePath);
-    const normalisedPath = normaliseFeaturePath(featurePath);
-    const sourceRoot = path7.join(findWaspRoot(this.fileSystem), "src");
-    if (segments.length > 1) {
-      const parentPath = segments.slice(0, -1).join("/");
-      const parentNormalisedPath = normaliseFeaturePath(parentPath);
-      const parentFeatureDir = path7.join(sourceRoot, parentNormalisedPath);
-      if (!this.fileSystem.existsSync(parentFeatureDir)) {
-        handleFatalError2(
-          `Parent feature '${parentPath}' does not exist. Please create it first.`
-        );
-      }
-    }
-    const featureDir = path7.join(sourceRoot, normalisedPath);
-    this.fileSystem.mkdirSync(featureDir, { recursive: true });
-    this.configGenerator.generate(normalisedPath);
-    this.logger.success(`Generated feature: ${normalisedPath}`);
+` : "";
+    const errorImport = auth || method !== "ALL" ? 'import { HttpError } from "wasp/server";\n' : "";
+    const imports = `${errorImport}import type { ${apiType} } from "wasp/server/api";`;
+    return {
+      imports,
+      apiType,
+      apiName,
+      methodCheck,
+      authCheck
+    };
   }
 };
 
-// src/generators/base/entity-generator.base.ts
-var EntityGeneratorBase = class extends WaspGeneratorBase {
-  constructor(logger = new SignaleLogger4(), fileSystem = realFileSystem, featureDirectoryGenerator = new FeatureDirectoryGenerator(
-    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.entityType.toString());
+// src/generators/api-namespace/api-namespace-generator.ts
+import { toCamelCase as toCamelCase3 } from "@ingenyus/swarm";
+import path7 from "path";
+
+// src/generators/api-namespace/schema.ts
+import { z as z5 } from "zod";
+var schema4 = z5.object({
+  feature: commonSchemas.feature,
+  name: commonSchemas.name,
+  path: commonSchemas.path,
+  force: commonSchemas.force
+});
+
+// src/generators/api-namespace/api-namespace-generator.ts
+var ApiNamespaceGenerator = class extends ComponentGeneratorBase {
+  get componentType() {
+    return CONFIG_TYPES.API_NAMESPACE;
   }
-  /**
-   * 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 = path8.join(featureDir, `${featureName}.wasp.ts`);
-      if (this.fileSystem.existsSync(configPath)) {
-        return configPath;
+  description = "Generates a Wasp API Namespace";
+  schema = schema4;
+  async generate(args) {
+    const { name, path: namespacePath, feature } = args;
+    const namespaceName = toCamelCase3(name);
+    return this.handleGeneratorError(
+      this.componentType,
+      namespaceName,
+      async () => {
+        const configPath = this.validateFeatureConfig(feature);
+        const { targetDirectory, importDirectory } = this.ensureTargetDirectory(
+          feature,
+          "middleware"
+        );
+        const targetFile = `${targetDirectory}/${namespaceName}.ts`;
+        await this.generateMiddlewareFile(
+          targetFile,
+          namespaceName,
+          args.force || false
+        );
+        await this.updateConfigFile(
+          namespaceName,
+          importDirectory,
+          namespacePath,
+          args,
+          configPath
+        );
       }
-    }
-    this.logger.error(
-      `Feature config file not found in '${normalisedPath}' or any ancestor directories`
-    );
-    this.logger.error(
-      `Expected to find a .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
+  async updateConfigFile(namespaceName, importDirectory, namespacePath, args, configFilePath) {
+    const { force = false } = args;
+    const importPath = path7.join(importDirectory, namespaceName);
+    const definition = await this.getDefinition(
+      namespaceName,
+      importPath,
+      namespacePath
     );
-    return this.checkExistence(
-      configExists,
-      `${methodName} config already exists in ${configPath}`,
-      force,
-      `${methodName} config already exists`
+    this.updateConfigWithCheck(
+      configFilePath,
+      "addApiNamespace",
+      namespaceName,
+      definition,
+      args.feature,
+      force
     );
   }
   /**
-   * Updates the feature config with a new definition
+   * Generates an apiNamespace definition for the feature configuration.
    */
-  updateFeatureConfig(featurePath, definition, configPath, configExists, methodName) {
-    this.configGenerator.update(featurePath, definition);
-    this.logger.success(
-      `${configExists ? "Updated" : "Added"} ${methodName} config in: ${configPath}`
+  async getDefinition(namespaceName, middlewareImportPath, pathValue) {
+    const templatePath = this.templateUtility.resolveTemplatePath(
+      "config/api-namespace.eta",
+      "api-namespace",
+      import.meta.url
     );
+    return this.templateUtility.processTemplate(templatePath, {
+      namespaceName,
+      middlewareImportPath,
+      pathValue
+    });
   }
-  /**
-   * 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
-      );
-    }
+};
+
+// src/generators/crud/crud-generator.ts
+import { getPlural as getPlural2, toCamelCase as toCamelCase4, toPascalCase as toPascalCase4 } from "@ingenyus/swarm";
+
+// src/generators/crud/schema.ts
+import { SchemaManager as SchemaManager2, commandRegistry as commandRegistry4 } from "@ingenyus/swarm";
+import { z as z6 } from "zod";
+var validCrudOperations = Object.values(CRUD_OPERATIONS);
+var publicOperations = getCrudOperationsArray();
+var overrideOperations = getCrudOperationsArray();
+var excludeOperations = getCrudOperationsArray();
+var schema5 = z6.object({
+  feature: commonSchemas.feature,
+  name: commonSchemas.name,
+  dataType: commonSchemas.dataType,
+  public: publicOperations.meta({
+    description: "Public CRUD operations (accessible without authentication)"
+  }).register(commandRegistry4, {
+    shortName: "b",
+    examples: ["'get'", "'get' 'getAll'"],
+    helpText: "Operations that can be accessed without authentication."
+  }),
+  override: overrideOperations.meta({ description: "Override existing CRUD operations" }).register(commandRegistry4, {
+    shortName: "v",
+    examples: ["'create'", "'create' 'update'"],
+    helpText: "Operations that will have overriden implementations"
+  }),
+  exclude: excludeOperations.meta({ description: "Exclude specific CRUD operations from generation" }).register(commandRegistry4, {
+    shortName: "x",
+    examples: ["'delete'", "'delete' 'update'"],
+    helpText: "Operations to exclude from generation"
+  }),
+  force: commonSchemas.force
+});
+function getCrudOperationsArray() {
+  return z6.array(
+    z6.string().transform((val) => {
+      return SchemaManager2.findEnumValue(CRUD_OPERATIONS, val);
+    }).pipe(
+      z6.enum(CRUD_OPERATIONS, {
+        message: `Must be one or more of: ${validCrudOperations.join(", ")}`
+      })
+    )
+  ).optional();
+}
+
+// src/generators/crud/crud-generator.ts
+var CRUD_OPERATIONS_LIST = [
+  "get",
+  "getAll",
+  "create",
+  "update",
+  "delete"
+];
+var CrudGenerator = class extends OperationGeneratorBase {
+  get componentType() {
+    return CONFIG_TYPES.CRUD;
   }
-  /**
-   * 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 = path8.join(featureDir, typeDirectory);
-    const importDirectory = `@src/${normalisedPath}/${typeDirectory}`;
-    return { targetDirectory, importDirectory };
+  description = "Generates a Wasp CRUD operation";
+  schema = schema5;
+  async generate(args) {
+    const { dataType, feature } = args;
+    const crudName = toCamelCase4(getPlural2(dataType));
+    const crudType = toPascalCase4(crudName);
+    return this.handleGeneratorError(this.componentType, crudName, async () => {
+      const configPath = this.validateFeatureConfig(feature);
+      const { targetDirectory } = this.ensureTargetDirectory(
+        feature,
+        this.componentType.toLowerCase()
+      );
+      if ((args.override?.length ?? 0) > 0) {
+        const targetFile = `${targetDirectory}/${crudName}.ts`;
+        const operations = await this.getOperationsCode(
+          dataType,
+          crudName,
+          args
+        );
+        await this.generateCrudFile(
+          targetFile,
+          dataType,
+          operations,
+          crudType,
+          args
+        );
+      }
+      await this.updateConfigFile(
+        feature,
+        crudName,
+        dataType,
+        args,
+        configPath
+      );
+    });
   }
-  /**
-   * Ensures a target directory exists and returns its path
-   */
-  ensureTargetDirectory(featurePath, type) {
-    const { targetDirectory, importDirectory } = this.getFeatureTargetDir(
-      this.fileSystem,
-      featurePath,
-      type
+  async generateCrudFile(targetFile, dataType, operations, crudName, args) {
+    const { override = [], force = false } = args;
+    const model = await getEntityMetadata(dataType);
+    const imports = this.generateCrudImports(
+      model,
+      dataType,
+      crudName,
+      override
     );
-    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.entityType || "")
+      imports,
+      operations
     };
     await this.renderTemplateToFile(
-      "middleware.eta",
+      "crud.eta",
       replacements,
       targetFile,
-      "Middleware file",
+      "CRUD file",
       force
     );
   }
-};
-
-// src/generators/base/operation-generator.base.ts
-import {
-  capitalise,
-  getPlural,
-  handleFatalError as handleFatalError3,
-  toPascalCase as toPascalCase2
-} from "@ingenyus/swarm";
-var OperationGeneratorBase = class extends EntityGeneratorBase {
-  /**
-   * Gets the operation name based on operation type and model name.
-   */
-  getOperationName(operation, modelName, customName) {
-    if (customName) {
-      return customName;
-    }
-    switch (operation) {
-      case OPERATIONS.GETALL:
-        return `getAll${getPlural(modelName)}`;
-      case OPERATIONS.GETFILTERED:
-        return `getFiltered${getPlural(modelName)}`;
-      default:
-        return `${operation}${modelName}`;
-    }
-  }
-  /**
-   * Gets the template path for operation templates.
-   * This method resolves operation templates to the operation generator's directory
-   * instead of the current generator's directory.
-   */
-  getOperationTemplatePath(templateName) {
-    return this.templateUtility.resolveTemplatePath(
-      templateName,
-      "operation",
-      import.meta.url
-    );
-  }
-  /**
-   * Gets the TypeScript type name for an operation.
-   */
-  getOperationTypeName(operation, modelName) {
-    return toPascalCase2(this.getOperationName(operation, modelName));
-  }
   /**
    * Generates import statements for an operation.
    */
-  generateImports(model, modelName, operation) {
+  generateCrudImports(model, modelName, crudName, operations) {
     const imports = [];
-    if (operation !== OPERATIONS.GETALL) {
+    if (operations.some((operation) => operation !== "getAll")) {
       if (needsPrismaImport(model)) {
         imports.push('import { Prisma } from "@prisma/client";');
       }
-      imports.push(`import { ${modelName} } from "wasp/entities";`);
+      imports.push(`import { type ${modelName} } from "wasp/entities";`);
     }
     imports.push('import { HttpError } from "wasp/server";');
-    imports.push(
-      `import type { ${this.getOperationTypeName(
-        operation,
-        modelName
-      )} } from "wasp/server/operations";`
-    );
+    imports.push(`import { type ${crudName} } from "wasp/server/crud";`);
     return imports.join("\n");
   }
+  async updateConfigFile(feature, crudName, dataType, args, configPath) {
+    const operations = this.buildOperations(args);
+    const definition = this.getDefinition(crudName, dataType, operations);
+    this.updateConfigWithCheck(
+      configPath,
+      "addCrud",
+      crudName,
+      definition,
+      feature,
+      args.force || false
+    );
+  }
+  buildOperations(args) {
+    const {
+      public: publicOps = [],
+      override: overrideOps = [],
+      exclude: excludeOps = []
+    } = args;
+    return CRUD_OPERATIONS_LIST.reduce(
+      (acc, operation) => {
+        if (excludeOps.includes(operation)) {
+          return acc;
+        }
+        const operationConfig = {};
+        if (publicOps.includes(operation)) {
+          operationConfig.isPublic = true;
+        }
+        if (overrideOps.includes(operation)) {
+          operationConfig.override = true;
+        }
+        acc[operation] = operationConfig;
+        return acc;
+      },
+      {}
+    );
+  }
   /**
-   * Gets the operation type ("query" or "action") for a given operation.
+   * Generates operation code for overridden CRUD operations and returns as a single string.
    */
-  getOperationType(operation) {
-    return operation === OPERATIONS.GETALL || operation === OPERATIONS.GET || operation === OPERATIONS.GETFILTERED ? "query" : "action";
+  async getOperationsCode(dataType, crudName, args) {
+    const { override = [], public: publicOps = [] } = args;
+    if (override.length === 0) {
+      return "";
+    }
+    const operationCodes = [];
+    for (const operation of override) {
+      const { operationCode } = await this.generateOperationComponents(
+        dataType,
+        operation,
+        !publicOps.includes(operation),
+        [dataType],
+        true,
+        toPascalCase4(crudName)
+      );
+      operationCodes.push(operationCode.replace(/^[\r\n]/, ""));
+    }
+    return operationCodes.join("");
   }
   /**
-   * Generates the operation components needed for file and config generation.
+   * Generates a CRUD definition for the feature configuration.
    */
-  async generateOperationComponents(modelName, operation, auth = false, entities = [modelName], isCrudOverride = false, crudName = null, customName) {
-    const model = await getEntityMetadata(modelName);
-    const operationType = this.getOperationType(operation);
-    const operationName = this.getOperationName(
-      operation,
-      modelName,
-      customName
-    );
-    const operationCode = await this.generateOperationCode(
-      model,
-      operation,
-      auth,
-      isCrudOverride,
-      crudName
+  getDefinition(crudName, dataType, operations) {
+    const templatePath = this.templateUtility.resolveTemplatePath(
+      "config/crud.eta",
+      "crud",
+      import.meta.url
     );
-    const configEntry = {
-      operationName,
-      entities,
-      authRequired: auth
-    };
-    return {
-      operationCode,
-      configEntry,
-      operationType,
-      operationName
-    };
+    const operationsStr = JSON.stringify(operations, null, 2).replace(/"([^"]+)":/g, "$1:").slice(1, -1).split("\n").filter((line) => line.trim() !== "").map((line, index) => index === 0 ? line.trimStart() : "    " + line).join("\n");
+    return this.templateUtility.processTemplate(templatePath, {
+      crudName: toPascalCase4(crudName),
+      dataType,
+      operations: operationsStr
+    });
   }
-  /**
-   * Generates the code for an operation.
-   */
-  async generateOperationCode(model, operation, auth = false, isCrudOverride = false, crudName = null) {
-    const operationType = this.getOperationType(operation);
-    const templatePath = this.getOperationTemplatePath(`${operation}.eta`);
-    const allFieldNames = model.fields.map((f) => f.name);
-    const idFields = getIdFields(model);
-    const requiredFields = getRequiredFields(model);
-    const optionalFields = getOptionalFields(model);
-    const jsonFields = getJsonFields(model);
-    const pluralModelName = getPlural(model.name);
-    const pluralModelNameLower = pluralModelName.toLowerCase();
-    const modelNameLower = model.name.toLowerCase();
-    const operationName = this.getOperationName(operation, model.name);
-    const imports = isCrudOverride ? "" : this.generateImports(model, model.name, operation);
-    const jsonTypeHandling = generateJsonTypeHandling(jsonFields);
-    let typeParams = "";
-    switch (operation) {
-      case "create": {
-        const pickRequired = generatePickType(
-          model.name,
-          requiredFields,
-          allFieldNames
-        );
-        const partialOptional = generatePartialType(
-          generatePickType(model.name, optionalFields, allFieldNames)
-        );
-        typeParams = `<${generateIntersectionType(pickRequired, partialOptional)}>`;
-        break;
-      }
-      case "update": {
-        const pickId = generatePickType(model.name, idFields, allFieldNames);
-        const omitId = generateOmitType(model.name, idFields, allFieldNames);
-        const partialRest = generatePartialType(omitId);
-        typeParams = `<${generateIntersectionType(pickId, partialRest)}>`;
-        break;
-      }
-      case "delete":
-      case "get":
-        typeParams = `<${generatePickType(model.name, idFields, allFieldNames)}>`;
-        break;
-      case "getAll":
-        typeParams = `<void>`;
-        break;
-      case "getFiltered":
-        typeParams = `<${generatePartialType(model.name)}>`;
-        break;
+};
+
+// src/generators/job/job-generator.ts
+import { capitalise as capitalise2, toCamelCase as toCamelCase5 } from "@ingenyus/swarm";
+
+// src/generators/job/schema.ts
+import { commandRegistry as commandRegistry5 } from "@ingenyus/swarm";
+import { z as z7 } from "zod";
+var cronSchema = z7.string().optional().refine(
+  (val) => {
+    if (!val) return true;
+    const parts = val.trim().split(/\s+/);
+    if (parts.length !== 5) return false;
+    const [minute, hour, day, month, weekday] = parts;
+    const validateCronField = (field, min, max) => {
+      if (field === "*") return true;
+      const rangeRegex = /^(\d+)(-(\d+))?(,(\d+)(-(\d+))?)*(\/(\d+))?$/;
+      if (!rangeRegex.test(field)) return false;
+      const items = field.split(",");
+      for (const item of items) {
+        if (item.includes("/")) {
+          const [base, step] = item.split("/");
+          const stepNum = parseInt(step, 10);
+          if (isNaN(stepNum) || stepNum <= 0) return false;
+          if (base === "*") continue;
+          const baseNum = parseInt(base, 10);
+          if (isNaN(baseNum) || baseNum < min || baseNum > max) return false;
+        } else if (item.includes("-")) {
+          const [start, end] = item.split("-");
+          const startNum = parseInt(start, 10);
+          const endNum = parseInt(end, 10);
+          if (isNaN(startNum) || isNaN(endNum) || startNum < min || endNum > max || startNum > endNum)
+            return false;
+        } else {
+          const num = parseInt(item, 10);
+          if (isNaN(num) || num < min || num > max) return false;
+        }
+      }
+      return true;
+    };
+    return validateCronField(minute, 0, 59) && validateCronField(hour, 0, 23) && validateCronField(day, 1, 31) && validateCronField(month, 1, 12) && validateCronField(weekday, 0, 6);
+  },
+  {
+    message: 'Cron expression must be a valid five-field format: (minute hour day month weekday), e.g. "0 9 * * *"'
+  }
+).meta({ description: "Cron schedule expression for the job" }).register(commandRegistry5, {
+  shortName: "c",
+  examples: ["0 9 * * *", "*/15 * * * *", "0 0 1 * *"],
+  helpText: "Five-field cron expression: minute hour day month weekday"
+});
+var argsSchema = z7.string().optional().refine(
+  (val) => {
+    if (!val) return true;
+    try {
+      const parsed = JSON.parse(val);
+      return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+    } catch {
+      return false;
     }
-    const authCheck = auth ? `  if (!context.user) {
-    throw new HttpError(401);
+  },
+  {
+    message: "Args must be a valid JSON object string"
   }
+).meta({ description: "Arguments to pass to the job function when executed" }).register(commandRegistry5, {
+  shortName: "a",
+  examples: ['{"userId": 123}', '{"type": "cleanup", "batchSize": 100}'],
+  helpText: "JSON object string that will be passed to the job function"
+});
+var schema6 = z7.object({
+  feature: commonSchemas.feature,
+  name: commonSchemas.name,
+  entities: commonSchemas.entities,
+  cron: cronSchema,
+  args: argsSchema,
+  force: commonSchemas.force
+});
 
-` : "";
-    let typeAnnotation = "";
-    let satisfiesType = "";
-    if (isCrudOverride && crudName) {
-      const opCap = capitalise(operation);
-      if (operationType === "action") {
-        typeAnnotation = `: ${crudName}.${opCap}Action${typeParams}`;
-      } else {
-        typeAnnotation = "";
-      }
-      if (operationType === "query") {
-        satisfiesType = `satisfies ${crudName}.${opCap}Query${typeParams}`;
-      } else {
-        satisfiesType = "";
-      }
-    } else {
-      if (operationType === "action") {
-        typeAnnotation = `: ${this.getOperationTypeName(operation, model.name)}${typeParams}`;
-      } else {
-        typeAnnotation = "";
-      }
-      if (operationType === "query") {
-        satisfiesType = `satisfies ${this.getOperationTypeName(operation, model.name)}${typeParams}`;
-      } else {
-        satisfiesType = "";
-      }
+// src/generators/job/job-generator.ts
+var JobGenerator = class extends ComponentGeneratorBase {
+  get componentType() {
+    return CONFIG_TYPES.JOB;
+  }
+  description = "Generates a Wasp Job";
+  schema = schema6;
+  async generate(args) {
+    const jobName = toCamelCase5(args.name);
+    return this.handleGeneratorError(this.componentType, jobName, async () => {
+      const configPath = this.validateFeatureConfig(args.feature);
+      const { targetDirectory } = this.ensureTargetDirectory(
+        args.feature,
+        this.componentType.toLowerCase()
+      );
+      const targetFile = `${targetDirectory}/${jobName}.ts`;
+      await this.generateJobFile(targetFile, jobName, args);
+      this.updateConfigFile(args.feature, jobName, args, configPath);
+    });
+  }
+  async generateJobFile(targetFile, jobName, args) {
+    const jobType = capitalise2(jobName);
+    const entities = args.entities ?? [];
+    let imports = `import type { ${jobType} } from 'wasp/server/jobs';
+`;
+    if (entities.length > 0) {
+      imports += `import { ${entities.join(", ")} } from 'wasp/entities';
+`;
     }
-    const isCompositeKey = idFields.length > 1;
-    const compositeKeyName = isCompositeKey ? idFields.join("_") : "";
-    const idFieldParams = isCompositeKey ? idFields.join(", ") : idFields[0];
-    const whereClause = isCompositeKey ? `${compositeKeyName}: { ${idFields.map((f) => `${f}`).join(", ")} }` : idFields[0];
     const replacements = {
-      operationName,
-      modelName: model.name,
-      authCheck,
       imports,
-      idField: idFields[0],
-      idFieldParams,
-      whereClause,
-      isCompositeKey: String(isCompositeKey),
-      compositeKeyName,
-      jsonTypeHandling,
-      typeAnnotation,
-      satisfiesType,
-      modelNameLower,
-      pluralModelNameLower
+      jobType,
+      jobName
     };
-    return this.templateUtility.processTemplate(templatePath, replacements);
-  }
-  /**
-   * Generates an operation file for a given operation.
-   */
-  generateOperationFile(operationsDir, operationName, operationCode, force = false) {
-    const operationFile = `${operationsDir}/${operationName}.ts`;
-    const fileExists = this.checkFileExists(
-      operationFile,
-      force,
-      "Operation file"
+    await this.renderTemplateToFile(
+      "job.eta",
+      replacements,
+      targetFile,
+      "job worker",
+      args.force || false
     );
-    this.writeFile(operationFile, operationCode, "operation file", fileExists);
   }
-  /**
-   * Copies a directory of operation templates to the target feature directory.
-   * @param templateDir - The source template directory
-   * @param targetDir - The target feature directory
-   */
-  copyOperationTemplates(templateDir, targetDir) {
-    copyDirectory(this.fileSystem, templateDir, targetDir);
-    this.logger.debug(
-      `Copied operation templates from ${templateDir} to ${targetDir}`
+  updateConfigFile(featurePath, jobName, args, configPath) {
+    const {
+      entities = [],
+      cron = "0 0 * * *",
+      args: executionArgs = "{}",
+      force = false
+    } = args;
+    const definition = this.getDefinition(
+      jobName,
+      entities,
+      cron,
+      executionArgs
+    );
+    this.updateConfigWithCheck(
+      configPath,
+      "job",
+      jobName,
+      definition,
+      featurePath,
+      force
     );
   }
   /**
-   * Generates an operation definition for the feature configuration.
+   * Generates a job definition for the feature configuration.
    */
-  getDefinition(operationName, featurePath, entities, operationType, importPath, auth = false) {
-    if (!OPERATION_TYPES.includes(operationType)) {
-      handleFatalError3(`Unknown operation type: ${operationType}`);
-    }
-    const directory = TYPE_DIRECTORIES[operationType];
-    const featureDir = getFeatureImportPath(featurePath);
-    const templatePath = this.templateUtility.resolveTemplatePath(
-      "operation.eta",
-      "config",
-      import.meta.url
-    );
+  getDefinition(jobName, entities, cron, args) {
+    const templatePath = this.getDefaultTemplatePath("config/job.eta");
     return this.templateUtility.processTemplate(templatePath, {
-      operationType: capitalise(operationType),
-      operationName,
-      featureDir,
-      directory,
+      jobName,
       entities: entities.map((e) => `"${e}"`).join(", "),
-      importPath,
-      auth: String(auth)
+      cron,
+      args
     });
   }
 };
 
-// src/generators/action/schema.ts
-import { extend as extend2 } from "@ingenyus/swarm";
-import { z as z3 } from "zod";
-var validActions = Object.values(ACTION_OPERATIONS);
-var actionSchema = extend2(
-  z3.string().min(1, "Action type is required").refine(getTypedValueValidator(validActions), {
-    message: `Invalid action. Must be one of: ${validActions.join(", ")}`
-  }).transform(getTypedValueTransformer(validActions)),
-  {
-    description: "The action operation to generate",
-    friendlyName: "Action Operation",
-    shortName: "o",
-    examples: validActions,
-    helpText: "Available actions: create, update, delete"
-  }
-);
-var dataTypeSchema = extend2(z3.string().min(1, "Data type is required"), {
-  description: "The data type/model name for this action",
-  friendlyName: "Data Type",
-  shortName: "d",
-  examples: ["User", "Product", "Task"],
-  helpText: "The Wasp entity or model name this action will work with"
+// src/generators/query/schema.ts
+import { SchemaManager as SchemaManager3, commandRegistry as commandRegistry6 } from "@ingenyus/swarm";
+import { z as z8 } from "zod";
+var validQueries = Object.values(QUERY_OPERATIONS);
+var querySchema = z8.string().min(1, "Query type is required").transform((val) => SchemaManager3.findEnumValue(QUERY_OPERATIONS, val)).pipe(
+  z8.enum(QUERY_OPERATIONS, {
+    message: `Invalid query. Must be one of: ${validQueries.join(", ")}`
+  })
+).meta({ description: "The query operation to generate" }).register(commandRegistry6, {
+  shortName: "o",
+  examples: validQueries,
+  helpText: `Available queries: ${validQueries.join(", ")}`
 });
-var schema2 = z3.object({
+var schema7 = z8.object({
   feature: commonSchemas.feature,
-  operation: actionSchema,
-  dataType: dataTypeSchema,
-  name: extend2(commonSchemas.name.optional(), commonSchemas.name._metadata),
+  operation: querySchema,
+  dataType: commonSchemas.dataType,
+  name: commonSchemas.name.optional().meta({
+    ...commonSchemas.name.meta() ?? {},
+    description: `${commonSchemas.name.meta()?.description ?? ""} (optional)`
+  }).register(commandRegistry6, commandRegistry6.get(commonSchemas.name) ?? {}),
   entities: commonSchemas.entities,
   force: commonSchemas.force,
   auth: commonSchemas.auth
 });
 
-// src/generators/action/action-generator.ts
-var ActionGenerator = class extends OperationGeneratorBase {
-  get entityType() {
-    return CONFIG_TYPES.ACTION;
+// src/generators/query/query-generator.ts
+var QueryGenerator = class extends OperationGeneratorBase {
+  get componentType() {
+    return CONFIG_TYPES.QUERY;
   }
-  description = "Generate actions (mutations) for Wasp applications";
-  schema = schema2;
-  async generate(flags) {
-    const { dataType, feature, name } = flags;
-    const operation = flags.operation;
-    const operationType = "action";
-    const entities = flags.entities ? Array.isArray(flags.entities) ? flags.entities : flags.entities.split(",").map((e) => e.trim()).filter(Boolean) : [];
+  description = "Generates a Wasp Query";
+  schema = schema7;
+  async generate(args) {
+    const { dataType, feature, name } = args;
+    const operation = args.operation;
+    const operationType = "query";
+    const entities = args.entities ?? [];
     if (dataType && !entities.includes(dataType)) {
       entities.unshift(dataType);
     }
     const { operationCode, operationName } = await this.generateOperationComponents(
       dataType,
       operation,
-      flags.auth,
+      args.auth,
       entities,
       false,
       null,
       name
     );
-    return this.handleGeneratorError(
-      this.entityType,
-      operationName,
-      async () => {
-        const configPath = this.validateFeatureConfig(feature);
-        const { targetDirectory: operationsDir, importDirectory } = this.ensureTargetDirectory(feature, operationType);
-        const importPath = `${importDirectory}/${operationName}`;
-        this.generateOperationFile(
-          operationsDir,
-          operationName,
-          operationCode,
-          flags.force || false
-        );
-        const definition = this.getDefinition(
-          operationName,
-          feature,
-          entities,
-          "action",
-          importPath,
-          flags.auth
-        );
-        this.updateConfigWithCheck(
-          configPath,
-          "addAction",
-          operationName,
-          definition,
-          feature,
-          flags.force || false
-        );
-      }
-    );
-  }
-};
-
-// src/generators/api/api-generator.ts
-import { toCamelCase as toCamelCase2, toPascalCase as toPascalCase3 } from "@ingenyus/swarm";
-
-// src/generators/api/schema.ts
-import { extend as extend3 } from "@ingenyus/swarm";
-import { z as z4 } from "zod";
-var validHttpMethods = Object.values(HTTP_METHODS);
-var schema3 = z4.object({
-  method: extend3(
-    z4.string().min(1, "HTTP method is required").refine(getTypedValueValidator(validHttpMethods), {
-      message: `Invalid HTTP method. Must be one of: ${validHttpMethods.join(", ")}`
-    }).transform(getTypedValueTransformer(validHttpMethods)),
-    {
-      description: "The HTTP method used for this API endpoint",
-      friendlyName: "HTTP Method",
-      shortName: "m",
-      examples: validHttpMethods
-    }
-  ),
-  feature: commonSchemas.feature,
-  name: commonSchemas.name,
-  path: commonSchemas.path,
-  entities: commonSchemas.entities,
-  auth: commonSchemas.auth,
-  force: commonSchemas.force,
-  customMiddleware: z4.boolean().optional()
-});
-
-// src/generators/api/api-generator.ts
-var ApiGenerator = class extends EntityGeneratorBase {
-  get entityType() {
-    return CONFIG_TYPES.API;
-  }
-  description = "Generate API endpoints for Wasp applications";
-  schema = schema3;
-  async generate(flags) {
-    const apiName = toCamelCase2(flags?.name);
-    return this.handleGeneratorError(this.entityType, apiName, async () => {
-      const configPath = this.validateFeatureConfig(flags.feature);
-      const {
-        targetDirectory: apiTargetDirectory,
-        importDirectory: apiImportDirectory
-      } = this.ensureTargetDirectory(flags.feature, this.name);
-      const fileName = `${apiName}.ts`;
-      const targetFile = `${apiTargetDirectory}/${fileName}`;
-      await this.generateApiFile(targetFile, apiName, flags);
-      if (flags.customMiddleware) {
-        const { targetDirectory: middlewareTargetDirectory } = this.ensureTargetDirectory(flags.feature, "middleware");
-        const middlewareFile = `${middlewareTargetDirectory}/${apiName}.ts`;
-        this.generateMiddlewareFile(
-          middlewareFile,
-          apiName,
-          flags.force || false
-        );
-      }
-      await this.updateConfigFile(
-        flags.feature,
-        apiName,
-        fileName,
-        apiImportDirectory,
-        flags,
-        configPath
-      );
-    });
-  }
-  async generateApiFile(targetFile, apiName, { method, auth = false, force = false }) {
-    const replacements = this.buildTemplateData(apiName, method, auth);
-    await this.renderTemplateToFile(
-      "api.eta",
-      replacements,
-      targetFile,
-      "API endpoint file",
-      force
-    );
-  }
-  async updateConfigFile(featurePath, apiName, apiFile, importDirectory, flags, configFilePath) {
-    const { force = false, entities, method, route, auth } = flags;
-    const importPath = this.path.join(importDirectory, apiFile);
-    const definition = await this.getConfigDefinition(
-      apiName,
-      featurePath,
-      Array.isArray(entities) ? entities : entities ? [entities] : [],
-      method,
-      route,
-      apiFile,
-      auth,
-      importPath,
-      flags.customMiddleware || false
-    );
-    this.updateConfigWithCheck(
-      configFilePath,
-      "addApi",
-      apiName,
-      definition,
-      featurePath,
-      force
+    return this.handleGeneratorError(
+      this.componentType,
+      operationName,
+      async () => {
+        const configPath = this.validateFeatureConfig(feature);
+        const { targetDirectory: operationsDir, importDirectory } = this.ensureTargetDirectory(feature, operationType);
+        const importPath = `${importDirectory}/${operationName}`;
+        this.generateOperationFile(
+          operationsDir,
+          operationName,
+          operationCode,
+          args.force || false
+        );
+        const definition = this.getDefinition(
+          operationName,
+          feature,
+          entities,
+          "query",
+          importPath,
+          args.auth
+        );
+        this.updateConfigWithCheck(
+          configPath,
+          "addQuery",
+          operationName,
+          definition,
+          feature,
+          args.force || false
+        );
+      }
     );
   }
-  async getConfigDefinition(apiName, featurePath, entities, method, route, apiFile, auth = false, importPath, customMiddleware = false) {
-    const featureDir = getFeatureImportPath(featurePath);
-    const configTemplatePath = await this.getTemplatePath("config/api.eta");
-    return this.templateUtility.processTemplate(configTemplatePath, {
-      apiName,
-      featureDir,
-      entities: entities.map((e) => `"${e}"`).join(", "),
-      method,
-      route,
-      apiFile,
-      auth: String(auth),
-      importPath,
-      customMiddleware: String(customMiddleware)
-    });
-  }
-  buildTemplateData(apiName, method, auth) {
-    const apiType = toPascalCase3(apiName);
-    const authCheck = auth ? `  if (!context.user) {
-  throw new HttpError(401);
-}
-
-` : "";
-    const methodCheck = method !== "ALL" ? `  if (req.method !== '${method}') {
-  throw new HttpError(405);
-}
-
-` : "";
-    const errorImport = auth || method !== "ALL" ? 'import { HttpError } from "wasp/server";\n' : "";
-    const imports = `${errorImport}import type { ${apiType} } from "wasp/server/api";`;
-    return {
-      imports,
-      apiType,
-      apiName,
-      methodCheck,
-      authCheck
-    };
-  }
 };
 
-// src/generators/api-namespace/api-namespace-generator.ts
-import { toCamelCase as toCamelCase3 } from "@ingenyus/swarm";
-import path9 from "path";
+// src/generators/route/route-generator.ts
+import {
+  formatDisplayName,
+  toCamelCase as toCamelCase6,
+  toPascalCase as toPascalCase5
+} from "@ingenyus/swarm";
 
-// src/generators/api-namespace/schema.ts
-import { z as z5 } from "zod";
-var schema4 = z5.object({
+// src/generators/route/schema.ts
+import { z as z9 } from "zod";
+var schema8 = z9.object({
   feature: commonSchemas.feature,
   name: commonSchemas.name,
   path: commonSchemas.path,
+  auth: commonSchemas.auth,
   force: commonSchemas.force
 });
 
-// src/generators/api-namespace/api-namespace-generator.ts
-var ApiNamespaceGenerator = class extends EntityGeneratorBase {
-  get entityType() {
-    return CONFIG_TYPES.API_NAMESPACE;
+// src/generators/route/route-generator.ts
+var RouteGenerator = class extends ComponentGeneratorBase {
+  get componentType() {
+    return CONFIG_TYPES.ROUTE;
   }
-  description = "Generate API namespaces for Wasp applications";
-  schema = schema4;
-  async generate(flags) {
-    const { name, path: apiPath, feature } = flags;
-    const namespaceName = toCamelCase3(name);
+  description = "Generates a Wasp Page and Route";
+  schema = schema8;
+  async generate(args) {
+    const { path: routePath, name, feature } = args;
+    const routeName = toCamelCase6(name || getRouteNameFromPath(routePath));
+    const componentName = toPascalCase5(routeName);
+    const fileName = `${componentName}.tsx`;
     return this.handleGeneratorError(
-      this.entityType,
-      namespaceName,
+      this.componentType,
+      routeName,
       async () => {
         const configPath = this.validateFeatureConfig(feature);
-        const { targetDirectory, importDirectory } = this.ensureTargetDirectory(
-          feature,
-          "middleware"
-        );
-        const targetFile = `${targetDirectory}/${namespaceName}.ts`;
-        await this.generateMiddlewareFile(
-          targetFile,
-          namespaceName,
-          flags.force || false
-        );
-        await this.updateConfigFile(
-          feature,
-          namespaceName,
-          importDirectory,
-          apiPath,
-          flags,
-          configPath
-        );
+        const { targetDirectory } = this.ensureTargetDirectory(feature, "page");
+        const targetFile = `${targetDirectory}/${fileName}`;
+        await this.generatePageFile(targetFile, componentName, args);
+        this.updateConfigFile(feature, routeName, routePath, args, configPath);
       }
     );
   }
-  async updateConfigFile(feature, namespaceName, importDirectory, apiPath, flags, configFilePath) {
-    const { force = false } = flags;
-    const importPath = path9.join(importDirectory, namespaceName);
-    const definition = await this.getDefinition(
-      namespaceName,
-      importPath,
-      apiPath
+  async generatePageFile(targetFile, componentName, args) {
+    const templatePath = "files/client/page.eta";
+    const replacements = {
+      componentName,
+      displayName: formatDisplayName(componentName)
+    };
+    await this.renderTemplateToFile(
+      "page.eta",
+      replacements,
+      targetFile,
+      "Page file",
+      args.force || false
+    );
+  }
+  updateConfigFile(featurePath, routeName, routePath, args, configPath) {
+    const definition = this.getDefinition(
+      routeName,
+      routePath,
+      featurePath,
+      args.auth
     );
     this.updateConfigWithCheck(
-      configFilePath,
-      "addApiNamespace",
-      namespaceName,
+      configPath,
+      "addRoute",
+      routeName,
       definition,
-      feature,
-      force
+      featurePath,
+      args.force || false
     );
   }
   /**
-   * Generates an apiNamespace definition for the feature configuration.
+   * Generates a route definition for the feature configuration.
    */
-  async getDefinition(namespaceName, middlewareImportPath, pathValue) {
-    const templatePath = this.templateUtility.resolveTemplatePath(
-      "config/api-namespace.eta",
-      "api-namespace",
-      import.meta.url
-    );
+  getDefinition(routeName, routePath, featurePath, auth = false) {
+    const templatePath = this.getDefaultTemplatePath("config/route.eta");
     return this.templateUtility.processTemplate(templatePath, {
-      namespaceName,
-      middlewareImportPath,
-      pathValue
+      featureName: featurePath.split("/").pop() || featurePath,
+      routeName,
+      routePath,
+      auth: String(auth)
     });
   }
 };
 
-// src/generators/crud/crud-generator.ts
-import { getPlural as getPlural2, toCamelCase as toCamelCase4, toPascalCase as toPascalCase4 } from "@ingenyus/swarm";
-
-// src/generators/crud/schema.ts
-import { extend as extend4 } from "@ingenyus/swarm";
-import { z as z6 } from "zod";
-var validCrudOperations = Object.values(CRUD_OPERATIONS);
-var publicOperations = getCrudOperationsArray();
-var overrideOperations = getCrudOperationsArray();
-var excludeOperations = getCrudOperationsArray();
-var schema5 = z6.object({
-  feature: commonSchemas.feature,
-  name: commonSchemas.name,
-  public: extend4(publicOperations, {
-    description: "Public CRUD operations (accessible without authentication)",
-    friendlyName: "Public Operations",
-    shortName: "b",
-    examples: ["get,getAll", "create,update"],
-    helpText: "Operations that can be accessed without authentication"
-  }),
-  override: extend4(overrideOperations, {
-    description: "Override existing CRUD operations",
-    friendlyName: "Override Operations",
-    shortName: "o",
-    examples: ["create,update"],
-    helpText: "Operations to override if they already exist"
-  }),
-  exclude: extend4(excludeOperations, {
-    description: "Exclude specific CRUD operations from generation",
-    friendlyName: "Exclude Operations",
-    shortName: "x",
-    examples: ["delete", "update,delete"],
-    helpText: "Operations to exclude from generation"
-  }),
-  force: commonSchemas.force
-});
-function getCrudOperationsArray() {
-  return z6.string().optional().refine(getTypedArrayValidator(validCrudOperations), {
-    message: `Must be one or more of: ${validCrudOperations.join(", ")}`
-  }).transform(getTypedArrayTransformer(validCrudOperations));
-}
+// src/plugins/wasp.ts
+var wasp = {
+  name: PLUGIN_NAME,
+  generators: [
+    new ActionGenerator(),
+    new ApiGenerator(),
+    new ApiNamespaceGenerator(),
+    new CrudGenerator(),
+    new FeatureGenerator(),
+    new JobGenerator(),
+    new QueryGenerator(),
+    new RouteGenerator()
+  ]
+};
 
-// src/generators/crud/crud-generator.ts
-var CRUD_OPERATIONS_LIST = [
-  "get",
-  "getAll",
-  "create",
-  "update",
-  "delete"
-];
-var CrudGenerator = class extends OperationGeneratorBase {
-  get entityType() {
-    return CONFIG_TYPES.CRUD;
+// src/wasp-config/app.ts
+import fs3 from "fs";
+import path8 from "path";
+import {
+  App as WaspApp
+} from "wasp-config";
+var App = class _App extends WaspApp {
+  constructor(name, config) {
+    super(name, config);
   }
-  description = "Generate CRUD operations for Wasp applications";
-  schema = schema5;
-  async generate(flags) {
-    const { dataType, feature } = flags;
-    const crudName = toCamelCase4(getPlural2(dataType));
-    return this.handleGeneratorError(this.entityType, crudName, async () => {
-      const configPath = this.validateFeatureConfig(feature);
-      const { targetDirectory } = this.ensureTargetDirectory(
-        feature,
-        this.entityType.toLowerCase()
-      );
-      const targetFile = `${targetDirectory}/${crudName}.ts`;
-      const fileExists = this.fileSystem.existsSync(targetFile);
-      if (!fileExists || flags.force) {
-        const operations = await this.getOperationsCode(
-          dataType,
-          crudName,
-          flags
-        );
-        await this.generateCrudFile(
-          targetFile,
-          crudName,
-          dataType,
-          operations,
-          flags.force || false
-        );
-      }
-      await this.updateConfigFile(
-        feature,
-        crudName,
-        dataType,
-        flags,
-        configPath
-      );
-    });
+  /**
+   * Static factory method that creates and initializes Swarm with configuration
+   * dynamically loaded from feature directories
+   *
+   * @param name The name of the application
+   * @param config The base configuration for the application
+   * @returns An initialized Swarm instance
+   */
+  static async create(name, config) {
+    const app = new _App(name, config);
+    await app.configureFeatures();
+    return app;
+  }
+  // Chainable configuration methods
+  auth(authConfig) {
+    super.auth(authConfig);
+    return this;
+  }
+  client(clientConfig) {
+    super.client(clientConfig);
+    return this;
+  }
+  db(dbConfig) {
+    super.db(dbConfig);
+    return this;
+  }
+  emailSender(emailSenderConfig) {
+    super.emailSender(emailSenderConfig);
+    return this;
+  }
+  job(name, jobConfig) {
+    super.job(name, jobConfig);
+    return this;
+  }
+  query(name, queryConfig) {
+    super.query(name, queryConfig);
+    return this;
   }
-  async generateCrudFile(targetFile, crudName, dataType, operations, force) {
-    const imports = `import { type ${toPascalCase4(dataType)} } from "wasp/entities";
-import { HttpError } from "wasp/server";
-import { type ${toPascalCase4(crudName)} } from "wasp/server/crud";`;
-    const replacements = {
-      imports,
-      operations
-    };
-    await this.renderTemplateToFile(
-      "crud.eta",
-      replacements,
-      targetFile,
-      "CRUD file",
-      force
-    );
+  route(name, routeConfig) {
+    super.route(name, routeConfig);
+    return this;
   }
-  async updateConfigFile(feature, crudName, dataType, flags, configPath) {
-    const operations = this.buildOperations(flags);
-    const definition = await this.getDefinition(crudName, dataType, operations);
-    this.updateConfigWithCheck(
-      configPath,
-      "addCrud",
-      crudName,
-      definition,
-      feature,
-      flags.force || false
-    );
+  api(name, apiConfig) {
+    super.api(name, apiConfig);
+    return this;
   }
-  buildOperations(flags) {
-    const {
-      public: publicOps = [],
-      override: overrideOps = [],
-      exclude: excludeOps = []
-    } = flags;
-    return CRUD_OPERATIONS_LIST.reduce(
-      (acc, operation) => {
-        if (excludeOps.includes(operation)) {
-          return acc;
-        }
-        const operationConfig = {};
-        if (publicOps.includes(operation)) {
-          operationConfig.isPublic = true;
-        }
-        if (overrideOps.includes(operation)) {
-          operationConfig.override = true;
-        }
-        acc[operation] = operationConfig;
-        return acc;
-      },
-      {}
-    );
+  apiNamespace(name, apiNamespaceConfig) {
+    super.apiNamespace(name, apiNamespaceConfig);
+    return this;
+  }
+  crud(name, crudConfig) {
+    super.crud(name, crudConfig);
+    return this;
+  }
+  action(name, actionConfig) {
+    super.action(name, actionConfig);
+    return this;
   }
   /**
-   * Generates operation code for overridden CRUD operations and returns as a single string.
+   * Helper method to add routes with simplified parameters
+   * @param featureName The name of the feature
+   * @param name Route name, e.g. "DashboardRoute"
+   * @param options Route configuration options
    */
-  async getOperationsCode(dataType, crudName, flags) {
-    if (!flags.override || flags.override.length === 0) {
-      return "";
-    }
-    const operationCodes = [];
-    for (const operation of flags.override) {
-      const { operationCode } = await this.generateOperationComponents(
-        dataType,
-        operation,
-        flags.auth || false,
-        [dataType],
-        true,
-        toPascalCase4(crudName)
-      );
-      operationCodes.push(operationCode.replace(/^[\r\n]/, ""));
-    }
-    return operationCodes.join("");
+  addRoute(featureName, name, options) {
+    const componentName = name.charAt(0).toUpperCase() + name.slice(1);
+    const importPath = this.getFeatureImportPath(
+      featureName,
+      "client",
+      "pages",
+      componentName
+    );
+    const routeConfig = {
+      path: options.path,
+      to: this.page(componentName, {
+        authRequired: options.auth || false,
+        component: {
+          import: componentName,
+          from: `@src/${importPath}`
+        }
+      })
+    };
+    super.route(name, routeConfig);
+    return this;
   }
   /**
-   * Generates a CRUD definition for the feature configuration.
+   * Helper method to add API endpoints with simplified parameters
+   * @param featureName The name of the feature
+   * @param name API endpoint name, e.g. "getTasksApi"
+   * @param options API configuration options
    */
-  getDefinition(crudName, dataType, operations) {
-    const templatePath = this.templateUtility.resolveTemplatePath(
-      "config/crud.eta",
-      "crud",
-      import.meta.url
+  addApi(featureName, name, options) {
+    const importPath = this.getFeatureImportPath(
+      featureName,
+      "server",
+      "apis",
+      name
     );
-    const operationsStr = JSON.stringify(operations, null, 2).replace(/"([^"]+)":/g, "$1:").slice(1, -1).split("\n").filter((line) => line.trim() !== "").map((line, index) => index === 0 ? line.trimStart() : "    " + line).join("\n");
-    return this.templateUtility.processTemplate(templatePath, {
-      crudName: toPascalCase4(crudName),
-      dataType,
-      operations: operationsStr
+    const middlewareImportPath = this.getFeatureImportPath(
+      featureName,
+      "server",
+      "middleware",
+      name
+    );
+    super.api(name, {
+      fn: {
+        import: name,
+        from: `@src/${importPath}`
+      },
+      ...options.customMiddleware && {
+        import: name,
+        from: `@src/${middlewareImportPath}`
+      },
+      entities: options.entities,
+      httpRoute: { method: options.method, route: options.route },
+      auth: options.auth || false
     });
+    return this;
   }
-};
-
-// src/generators/job/job-generator.ts
-import { capitalise as capitalise2, toCamelCase as toCamelCase5 } from "@ingenyus/swarm";
-
-// src/generators/job/schema.ts
-import { extend as extend5 } from "@ingenyus/swarm";
-import { z as z7 } from "zod";
-var cronSchema = extend5(
-  z7.string().optional().refine(
-    (val) => {
-      if (!val) return true;
-      const parts = val.trim().split(/\s+/);
-      if (parts.length !== 5) return false;
-      const [minute, hour, day, month, weekday] = parts;
-      const validateCronField = (field, min, max) => {
-        if (field === "*") return true;
-        const rangeRegex = /^(\d+)(-(\d+))?(,(\d+)(-(\d+))?)*(\/(\d+))?$/;
-        if (!rangeRegex.test(field)) return false;
-        const items = field.split(",");
-        for (const item of items) {
-          if (item.includes("/")) {
-            const [base, step] = item.split("/");
-            const stepNum = parseInt(step, 10);
-            if (isNaN(stepNum) || stepNum <= 0) return false;
-            if (base === "*") continue;
-            const baseNum = parseInt(base, 10);
-            if (isNaN(baseNum) || baseNum < min || baseNum > max)
-              return false;
-          } else if (item.includes("-")) {
-            const [start, end] = item.split("-");
-            const startNum = parseInt(start, 10);
-            const endNum = parseInt(end, 10);
-            if (isNaN(startNum) || isNaN(endNum) || startNum < min || endNum > max || startNum > endNum)
-              return false;
-          } else {
-            const num = parseInt(item, 10);
-            if (isNaN(num) || num < min || num > max) return false;
-          }
-        }
-        return true;
-      };
-      return validateCronField(minute, 0, 59) && validateCronField(hour, 0, 23) && validateCronField(day, 1, 31) && validateCronField(month, 1, 12) && validateCronField(weekday, 0, 6);
-    },
-    {
-      message: 'Cron expression must be a valid five-field format: (minute hour day month weekday), e.g. "0 9 * * *"'
-    }
-  ),
-  {
-    description: "Cron schedule expression for the job",
-    friendlyName: "Cron Schedule",
-    shortName: "c",
-    examples: ["0 9 * * *", "*/15 * * * *", "0 0 1 * *"],
-    helpText: "Five-field cron expression: minute hour day month weekday"
-  }
-);
-var argsSchema = extend5(
-  z7.string().optional().refine(
-    (val) => {
-      if (!val) return true;
-      try {
-        const parsed = JSON.parse(val);
-        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
-      } catch {
-        return false;
+  /**
+   * Helper method to add CRUD operations with simplified parameters
+   * @param featureName The name of the feature
+   * @param name The CRUD name
+   * @param options CRUD configuration options
+   */
+  addCrud(featureName, name, options) {
+    const processOperationOptions = (operationName, operationOptions) => {
+      if (!operationOptions) return void 0;
+      const processedOptions = { ...operationOptions };
+      if (operationOptions.override) {
+        const operationDataType = operationName === "getAll" ? this.getPlural(options.entity) : options.entity;
+        const operationComponent = `${operationName}${operationDataType}`;
+        const importPath = this.getFeatureImportPath(
+          featureName,
+          "server",
+          "cruds",
+          name.charAt(0).toLowerCase() + name.slice(1)
+        );
+        processedOptions.overrideFn = {
+          import: operationComponent,
+          from: `@src/${importPath}`
+        };
+        delete processedOptions.override;
+      }
+      return processedOptions;
+    };
+    super.crud(this.getPlural(options.entity), {
+      entity: options.entity,
+      operations: {
+        getAll: processOperationOptions("getAll", options.getAll),
+        get: processOperationOptions("get", options.get),
+        create: processOperationOptions("create", options.create),
+        update: processOperationOptions("update", options.update),
+        delete: processOperationOptions("delete", options.delete)
       }
-    },
-    {
-      message: "Args must be a valid JSON object string"
-    }
-  ),
-  {
-    description: "Arguments to pass to the job function when executed",
-    friendlyName: "Job Arguments",
-    shortName: "a",
-    examples: ['{"userId": 123}', '{"type": "cleanup", "batchSize": 100}'],
-    helpText: "JSON object string that will be passed to the job function"
-  }
-);
-var schema6 = z7.object({
-  feature: commonSchemas.feature,
-  name: commonSchemas.name,
-  entities: commonSchemas.entities,
-  cron: cronSchema,
-  args: argsSchema,
-  force: commonSchemas.force
-});
-
-// src/generators/job/job-generator.ts
-var JobGenerator = class extends EntityGeneratorBase {
-  get entityType() {
-    return CONFIG_TYPES.JOB;
-  }
-  description = "Generate job workers for Wasp applications";
-  schema = schema6;
-  async generate(flags) {
-    const jobName = toCamelCase5(flags.name);
-    return this.handleGeneratorError(this.entityType, jobName, async () => {
-      const configPath = this.validateFeatureConfig(flags.feature);
-      const { targetDirectory } = this.ensureTargetDirectory(
-        flags.feature,
-        this.entityType.toLowerCase()
-      );
-      const targetFile = `${targetDirectory}/${jobName}.ts`;
-      await this.generateJobFile(targetFile, jobName, flags);
-      this.updateConfigFile(flags.feature, jobName, flags, configPath);
     });
+    return this;
   }
-  async generateJobFile(targetFile, jobName, flags) {
-    const jobType = capitalise2(jobName);
-    const entities = Array.isArray(flags.entities) ? flags.entities : flags.entities ? [flags.entities] : [];
-    let imports = `import type { ${jobType} } from 'wasp/server/jobs';
-`;
-    if (entities.length > 0) {
-      imports += `import { ${entities.join(", ")} } from 'wasp/entities';
-`;
-    }
-    const replacements = {
-      imports,
-      jobType,
-      jobName
-    };
-    await this.renderTemplateToFile(
-      "job.eta",
-      replacements,
-      targetFile,
-      "job worker",
-      flags.force || false
+  /**
+   * Helper method to add actions with simplified parameters
+   * @param featureName The name of the feature
+   * @param name The action name
+   * @param options Action configuration options
+   */
+  addAction(featureName, name, options) {
+    const importPath = this.getFeatureImportPath(
+      featureName,
+      "server",
+      "actions",
+      name
+    );
+    const config = this.getOperationConfig(
+      name,
+      importPath,
+      options.entities,
+      options.auth
     );
+    super.action(name, config);
+    return this;
   }
-  updateConfigFile(featurePath, jobName, flags, configPath) {
-    const entities = Array.isArray(flags.entities) ? flags.entities : flags.entities ? [flags.entities] : [];
-    const cron = flags.cron || "0 0 * * *";
-    const args = flags.args || "{}";
-    const definition = this.getDefinition(
-      jobName,
-      entities,
-      cron,
-      args || "{}"
+  /**
+   * Helper method to add queries with simplified parameters
+   * @param featureName The name of the feature
+   * @param name The query name
+   * @param options Query configuration options
+   */
+  addQuery(featureName, name, options) {
+    const importPath = this.getFeatureImportPath(
+      featureName,
+      "server",
+      "queries",
+      name
     );
-    this.updateConfigWithCheck(
-      configPath,
-      "job",
-      jobName,
-      definition,
-      featurePath,
-      flags.force || false
+    const config = this.getOperationConfig(
+      name,
+      importPath,
+      options.entities,
+      options.auth
     );
+    super.query(name, config);
+    return this;
   }
   /**
-   * Generates a job definition for the feature configuration.
+   * Helper method to add background jobs with simplified parameters
+   * @param featureName The name of the feature
+   * @param name Job name
+   * @param options Job configuration options
    */
-  getDefinition(jobName, entities, cron, args) {
-    const templatePath = this.getDefaultTemplatePath("config/job.eta");
-    return this.templateUtility.processTemplate(templatePath, {
-      jobName,
-      entities: entities.map((e) => `"${e}"`).join(", "),
-      cron,
-      args
+  addJob(featureName, name, options) {
+    const importPath = this.getFeatureImportPath(
+      featureName,
+      "server",
+      "jobs",
+      name
+    );
+    super.job(name, {
+      executor: "PgBoss",
+      perform: {
+        fn: {
+          import: name,
+          from: `@src/${importPath}`
+        }
+      },
+      entities: options.entities,
+      ...options.cron && {
+        schedule: {
+          cron: options.cron,
+          args: options.args || {}
+        }
+      }
     });
+    return this;
   }
-};
-
-// src/generators/query/schema.ts
-import { extend as extend6 } from "@ingenyus/swarm";
-import { z as z8 } from "zod";
-var validQueries = Object.values(QUERY_OPERATIONS);
-var querySchema = extend6(
-  z8.string().min(1, "Query type is required").refine(getTypedValueValidator(validQueries), {
-    message: `Invalid query. Must be one of: ${validQueries.join(", ")}`
-  }).transform(getTypedValueTransformer(validQueries)),
-  {
-    description: "The query operation to generate",
-    friendlyName: "Query Operation",
-    shortName: "o",
-    examples: validQueries,
-    helpText: "Available queries: get, getAll, getFiltered"
-  }
-);
-var dataTypeSchema2 = extend6(z8.string().min(1, "Data type is required"), {
-  description: "The data type/model name for this query",
-  friendlyName: "Data Type",
-  shortName: "d",
-  examples: ["User", "Product", "Task"],
-  helpText: "The Wasp entity or model name this query will work with"
-});
-var schema7 = z8.object({
-  feature: commonSchemas.feature,
-  operation: querySchema,
-  dataType: dataTypeSchema2,
-  name: extend6(commonSchemas.name.optional(), commonSchemas.name._metadata),
-  entities: commonSchemas.entities,
-  force: commonSchemas.force,
-  auth: commonSchemas.auth
-});
-
-// src/generators/query/query-generator.ts
-var QueryGenerator = class extends OperationGeneratorBase {
-  get entityType() {
-    return CONFIG_TYPES.QUERY;
-  }
-  description = "Generate queries (data fetching) for Wasp applications";
-  schema = schema7;
-  async generate(flags) {
-    const { dataType, feature, name } = flags;
-    const operation = flags.operation;
-    const operationType = "query";
-    const entities = flags.entities ? Array.isArray(flags.entities) ? flags.entities : flags.entities.split(",").map((e) => e.trim()).filter(Boolean) : [];
-    if (dataType && !entities.includes(dataType)) {
-      entities.unshift(dataType);
-    }
-    const { operationCode, operationName } = await this.generateOperationComponents(
-      dataType,
-      operation,
-      flags.auth,
-      entities,
-      false,
-      null,
+  /**
+   * Helper method to add API namespaces with simplified parameters
+   * @param featureName The name of the feature
+   * @param name Namespace name
+   * @param options API namespace configuration options
+   */
+  addApiNamespace(featureName, name, options) {
+    const importPath = this.getFeatureImportPath(
+      featureName,
+      "server",
+      "middleware",
       name
     );
-    return this.handleGeneratorError(
-      this.entityType,
-      operationName,
-      async () => {
-        const configPath = this.validateFeatureConfig(feature);
-        const { targetDirectory: operationsDir, importDirectory } = this.ensureTargetDirectory(feature, operationType);
-        const importPath = `${importDirectory}/${operationName}`;
-        this.generateOperationFile(
-          operationsDir,
-          operationName,
-          operationCode,
-          flags.force || false
-        );
-        const definition = this.getDefinition(
-          operationName,
-          feature,
-          entities,
-          "query",
-          importPath,
-          flags.auth
-        );
-        this.updateConfigWithCheck(
-          configPath,
-          "addQuery",
-          operationName,
-          definition,
-          feature,
-          flags.force || false
-        );
+    super.apiNamespace(name, {
+      path: options.path,
+      middlewareConfigFn: {
+        import: name,
+        from: `@src/${importPath}`
       }
-    );
+    });
+    return this;
   }
-};
-
-// src/generators/route/route-generator.ts
-import { formatDisplayName, toCamelCase as toCamelCase6, toPascalCase as toPascalCase5 } from "@ingenyus/swarm";
-
-// src/generators/route/schema.ts
-import { z as z9 } from "zod";
-var schema8 = z9.object({
-  feature: commonSchemas.feature,
-  name: commonSchemas.name,
-  path: commonSchemas.path,
-  auth: commonSchemas.auth,
-  force: commonSchemas.force
-});
-
-// src/generators/route/route-generator.ts
-var RouteGenerator = class extends EntityGeneratorBase {
-  get entityType() {
-    return CONFIG_TYPES.ROUTE;
+  /**
+   * Calculates the import path for a feature component
+   * @param featureName The name of the feature
+   * @param type The type of component (client, server, etc.)
+   * @param subPath The sub-path within the feature directory
+   * @param fileName The name of the file (optional, defaults to featureName)
+   * @returns The calculated import path
+   */
+  getFeatureImportPath(featureName, type, subPath, fileName) {
+    const file = fileName || featureName;
+    return `features/${featureName}/${type}/${subPath}/${file}`;
   }
-  description = "Generate route handlers for Wasp applications";
-  schema = schema8;
-  async generate(flags) {
-    const { path: routePath, name, feature } = flags;
-    const routeName = toCamelCase6(name || getRouteNameFromPath(routePath));
-    const componentName = toPascalCase5(routeName);
-    const fileName = `${componentName}.tsx`;
-    return this.handleGeneratorError(this.entityType, routeName, async () => {
-      const configPath = this.validateFeatureConfig(feature);
-      const { targetDirectory } = this.ensureTargetDirectory(feature, "page");
-      const targetFile = `${targetDirectory}/${fileName}`;
-      await this.generatePageFile(targetFile, componentName, flags);
-      this.updateConfigFile(feature, routeName, routePath, flags, configPath);
-    });
+  /**
+   * Converts a singular word to its plural form
+   * @param word The singular word to pluralize
+   * @returns The plural form of the word
+   */
+  getPlural(word) {
+    if (word.endsWith("y")) {
+      return word.slice(0, -1) + "ies";
+    } else if (word.endsWith("s") || word.endsWith("sh") || word.endsWith("ch") || word.endsWith("x") || word.endsWith("z")) {
+      return word + "es";
+    } else {
+      return word + "s";
+    }
   }
-  async generatePageFile(targetFile, componentName, flags) {
-    const templatePath = "files/client/page.eta";
-    const replacements = {
-      componentName,
-      displayName: formatDisplayName(componentName)
+  /**
+   * Configures all feature modules by scanning the features directory
+   */
+  async configureFeatures() {
+    const featuresDir = path8.join(process.cwd(), "src", "features");
+    if (!fs3.existsSync(featuresDir)) {
+      console.warn(
+        "Features directory not found, skipping feature configuration"
+      );
+      return this;
+    }
+    const getAllFeatureFiles = (dir) => {
+      let results = [];
+      const list = fs3.readdirSync(dir, { withFileTypes: true });
+      for (const entry of list) {
+        const fullPath = path8.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          results = results.concat(getAllFeatureFiles(fullPath));
+        } else if (entry.isFile() && entry.name.endsWith(".wasp.ts")) {
+          results.push(path8.relative(featuresDir, fullPath));
+        }
+      }
+      return results;
     };
-    await this.renderTemplateToFile(
-      "page.eta",
-      replacements,
-      targetFile,
-      "Page file",
-      flags.force || false
-    );
-  }
-  updateConfigFile(featurePath, routeName, routePath, flags, configPath) {
-    const definition = this.getDefinition(
-      routeName,
-      routePath,
-      featurePath,
-      flags.auth
-    );
-    this.updateConfigWithCheck(
-      configPath,
-      "addRoute",
-      routeName,
-      definition,
-      featurePath,
-      flags.force || false
-    );
+    const featureFiles = getAllFeatureFiles(featuresDir);
+    for (const file of featureFiles) {
+      try {
+        const featureName = path8.dirname(file);
+        const modulePath = path8.join(
+          process.cwd(),
+          ".wasp",
+          "src",
+          "features",
+          file.replace(".ts", ".js")
+        );
+        const module = await import(modulePath);
+        if (module.default) {
+          module.default(this, featureName);
+        }
+      } catch (error) {
+        console.error(`Failed to load feature module ${file}:`, error);
+      }
+    }
+    return this;
   }
   /**
-   * Generates a route definition for the feature configuration.
+   * Helper method to get the configuration for an action or query
+   * @param name The operation name
+   * @param importPath Import path (excluding `@src/` prefix), e.g. "features/dashboard/server/queries/getTasks"
+   * @param entities Comma-separated list of entities (optional, defaults to datatype)
+   * @param auth Require authentication (optional)
    */
-  getDefinition(routeName, routePath, featurePath, auth = false) {
-    const templatePath = this.getDefaultTemplatePath("config/route.eta");
-    return this.templateUtility.processTemplate(templatePath, {
-      featureName: featurePath.split("/").pop() || featurePath,
-      routeName,
-      routePath,
-      auth: String(auth)
-    });
+  getOperationConfig(name, importPath, entities, auth) {
+    return {
+      fn: {
+        import: name,
+        from: `@src/${importPath}`
+      },
+      entities,
+      auth: auth || false
+    };
   }
 };
 export {
@@ -2677,42 +2574,10 @@ export {
   ApiNamespaceGenerator,
   App,
   CrudGenerator,
-  FeatureDirectoryGenerator,
+  FeatureGenerator,
   JobGenerator,
   QueryGenerator,
   RouteGenerator,
-  TemplateUtility,
   WaspConfigGenerator,
-  commonSchemas,
-  copyDirectory,
-  createWaspPlugin,
-  ensureDirectoryExists,
-  featureExists,
-  findWaspRoot,
-  generateIntersectionType,
-  generateJsonTypeHandling,
-  generateOmitType,
-  generatePartialType,
-  generatePickType,
-  getAppRootDir,
-  getConfigDir,
-  getEntityMetadata,
-  getFeatureDir,
-  getFeatureImportPath,
-  getFeatureTargetDir,
-  getIdFields,
-  getJsonFields,
-  getOptionalFields,
-  getPluginVersion,
-  getRequiredFields,
-  getRouteNameFromPath,
-  getTemplatesDir,
-  getTypedArrayTransformer,
-  getTypedArrayValidator,
-  getTypedValueTransformer,
-  getTypedValueValidator,
-  needsPrismaImport,
-  normaliseFeaturePath,
-  realFileSystem,
   wasp
 };