@ingenyus/swarm-wasp 0.1.0

package/dist/index.js

@@ -0,0 +1,2718 @@
+// 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 OPERATIONS = {
+  CREATE: "create",
+  UPDATE: "update",
+  DELETE: "delete",
+  GET: "get",
+  GETALL: "getAll",
+  GETFILTERED: "getFiltered"
+};
+var CRUD_OPERATIONS = {
+  CREATE: "create",
+  GET: "get",
+  GETALL: "getAll",
+  UPDATE: "update",
+  DELETE: "delete"
+};
+var ACTION_OPERATIONS = {
+  CREATE: "create",
+  UPDATE: "update",
+  DELETE: "delete"
+};
+var QUERY_OPERATIONS = {
+  GET: "get",
+  GETALL: "getAll",
+  GETFILTERED: "getFiltered"
+};
+var TYPE_DIRECTORIES = {
+  component: "client/components",
+  hook: "client/hooks",
+  layout: "client/layouts",
+  page: "client/pages",
+  util: "client/utils",
+  action: "server/actions",
+  query: "server/queries",
+  middleware: "server/middleware",
+  job: "server/jobs",
+  api: "server/apis",
+  crud: "server/cruds",
+  type: "types"
+};
+var CONFIG_TYPES = {
+  ROUTE: "Route",
+  QUERY: "Query",
+  ACTION: "Action",
+  JOB: "Job",
+  API: "Api",
+  API_NAMESPACE: "ApiNamespace",
+  CRUD: "Crud"
+};
+
+// src/common/filesystem.ts
+var realFileSystem = {
+  readFileSync: fs.readFileSync,
+  writeFileSync: fs.writeFileSync,
+  existsSync: fs.existsSync,
+  copyFileSync: fs.copyFileSync,
+  mkdirSync: fs.mkdirSync,
+  readdirSync: fs.readdirSync,
+  statSync: fs.statSync
+};
+function findWaspRoot(fileSystem, startDir = process.cwd()) {
+  const startDirPath = path.resolve(startDir);
+  let currentDirPath = startDirPath;
+  const root = path.parse(currentDirPath).root;
+  while (currentDirPath !== root) {
+    const waspRootPath = path.join(currentDirPath, ".wasproot");
+    if (fileSystem.existsSync(waspRootPath)) {
+      return currentDirPath;
+    }
+    currentDirPath = path.dirname(currentDirPath);
+  }
+  throw new Error(
+    `Couldn't find Wasp application root from ${startDirPath}. Make sure you are running this command from within a Wasp project directory.`
+  );
+}
+function copyDirectory(fileSystem, src, dest) {
+  if (!fileSystem.existsSync(dest)) {
+    fileSystem.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fileSystem.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(fileSystem, srcPath, destPath);
+    } else {
+      fileSystem.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function ensureDirectoryExists(fileSystem, dir) {
+  if (!fileSystem.existsSync(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 = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const previousSegment = normalisedSegments[normalisedSegments.length - 1];
+    if (previousSegment !== "features" && segment !== "features") {
+      normalisedSegments.push("features");
+    }
+    normalisedSegments.push(segment);
+  }
+  return normalisedSegments.join("/");
+}
+function getFeatureDir(fileSystem, featureName) {
+  const waspRoot = findWaspRoot(fileSystem);
+  const normalisedPath = normaliseFeaturePath(featureName);
+  return path.join(waspRoot, "src", normalisedPath);
+}
+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";
+async function getEntityMetadata(modelName) {
+  try {
+    const schemaPath = path3.join(process.cwd(), "schema.prisma");
+    const schemaContent = fs2.readFileSync(schemaPath, "utf8");
+    const schema9 = getSchema(schemaContent);
+    const model = schema9.list?.find(
+      (m) => m.type === "model" && m.name === modelName
+    );
+    if (!model || model.type !== "model") {
+      throw new Error(`Model ${modelName} not found in schema`);
+    }
+    const compositeIdAttr = (model.properties || []).find(
+      (item) => item.type === "attribute" && item.kind === "object" && item.name === "id"
+    );
+    let compositeIdFields = [];
+    if (compositeIdAttr?.args?.[0]) {
+      const arg = compositeIdAttr.args[0];
+      if (typeof arg.value === "object" && arg.value !== null && "type" in arg.value && arg.value.type === "array" && "args" in arg.value) {
+        compositeIdFields = arg.value.args;
+      }
+    }
+    const fields = (model.properties || []).filter(
+      (item) => item.type === "field" && !item.array && !item.attributes?.some((attr) => attr.name === "relation")
+    ).map((field) => {
+      const fieldType = typeof field.fieldType === "string" ? field.fieldType : field.fieldType.name;
+      const tsType = getPrismaToTsType(fieldType);
+      const isRequired = !field.optional;
+      const isId = field.attributes?.some((attr) => attr.name === "id") || compositeIdFields.includes(field.name);
+      const isUnique = field.attributes?.some((attr) => attr.name === "unique") || false;
+      const hasDefaultValue = field.attributes?.some((attr) => attr.name === "default") || false;
+      const isUpdatedAt = field.attributes?.some((attr) => attr.name === "updatedAt") || false;
+      const isGenerated = field.attributes?.some((attr) => attr.name === "map") || false;
+      return {
+        name: field.name,
+        type: fieldType,
+        tsType,
+        isRequired,
+        isId,
+        isUnique,
+        hasDefaultValue,
+        isGenerated,
+        isUpdatedAt
+      };
+    });
+    return {
+      name: modelName,
+      fields
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to get entity metadata for ${modelName}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function getIdFields(model) {
+  const idFields = model.fields.filter((f) => f.isId).map((f) => f.name);
+  if (idFields.length === 0) {
+    throw new Error(`No ID field found for model ${model.name}`);
+  }
+  return idFields;
+}
+function getRequiredFields(model) {
+  return model.fields.filter(
+    (f) => f.isRequired && !f.hasDefaultValue && !f.isGenerated && !f.isUpdatedAt
+  ).map((f) => f.name);
+}
+function getOptionalFields(model) {
+  return model.fields.filter(
+    (field) => (field.hasDefaultValue && field.type !== "DateTime" || !field.isRequired) && !field.isId && !field.isGenerated && !field.isUpdatedAt
+  ).map((field) => field.name);
+}
+function getJsonFields(model) {
+  return model.fields.filter((f) => f.type === "Json").map((f) => f.name);
+}
+function generateJsonTypeHandling(jsonFields) {
+  if (jsonFields.length === 0) return "";
+  const assignments = jsonFields.map(
+    (field) => `        ${field}: (data.${field} as Prisma.JsonValue) || Prisma.JsonNull`
+  ).join(",\n");
+  return `,
+${assignments}`;
+}
+function needsPrismaImport(model) {
+  return model.fields.some((f) => f.type === "Json" || f.type === "Decimal");
+}
+function generatePickType(modelName, fields, allFields) {
+  if (fields.length === 0) return "";
+  if (fields.length === allFields.length) return modelName;
+  const fieldUnion = fields.map((f) => `"${f}"`).join(" | ");
+  return `Pick<${modelName}, ${fieldUnion}>`;
+}
+function generateOmitType(modelName, fields, allFields) {
+  if (fields.length === 0) return modelName;
+  if (fields.length === allFields.length) return "";
+  const fieldUnion = fields.map((f) => `"${f}"`).join(" | ");
+  return `Omit<${modelName}, ${fieldUnion}>`;
+}
+function generatePartialType(typeString) {
+  if (!typeString) return "";
+  return `Partial<${typeString}>`;
+}
+function generateIntersectionType(type1, type2) {
+  if (!type1 && !type2) return "";
+  if (!type1) return type2;
+  if (!type2) return type1;
+  return `${type1} & ${type2}`;
+}
+function getPrismaToTsType(type) {
+  const typeMap = {
+    String: "string",
+    Int: "number",
+    Float: "number",
+    Boolean: "boolean",
+    DateTime: "Date",
+    Json: "Prisma.JsonValue",
+    BigInt: "bigint",
+    Decimal: "Prisma.Decimal",
+    Bytes: "Buffer"
+  };
+  return typeMap[type] || type;
+}
+
+// src/common/schemas.ts
+import { extend } 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",
+    shortName: "f",
+    examples: ["root", "auth", "dashboard/users"],
+    helpText: 'Can be nested as a logical or relative path, e.g. "dashboard/users" or "features/dashboard/features/users"'
+  }),
+  name: extend(z.string().min(1, "Name is required"), {
+    description: "The name of the generated resource",
+    friendlyName: "Name",
+    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",
+    shortName: "p",
+    examples: ["/api/users/:id", "/api/products"],
+    helpText: 'Supports Express-style placeholders, e.g. "/api/users/:id"'
+  }),
+  entities: extend(z.string().optional(), {
+    description: "The Wasp entities that this resource will have access to (optional)",
+    friendlyName: "Entities",
+    shortName: "e",
+    examples: ["User,Product"],
+    helpText: "A comma-separated list of Wasp entities"
+  }),
+  force: extend(z.boolean().optional(), {
+    description: "Force overwrite of existing files and configuration entries (optional)",
+    friendlyName: "Force",
+    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",
+    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";
+var TemplateUtility = class {
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  processTemplate(templatePath, replacements) {
+    const declarations = Object.keys(replacements).map((key) => `${key}=it.${key}`).join(", ");
+    const functionHeader = declarations ? `const ${declarations};` : void 0;
+    const templateDir = path4.dirname(templatePath);
+    const eta = new Eta({
+      autoTrim: false,
+      autoEscape: false,
+      views: templateDir,
+      functionHeader
+    });
+    const templateName = path4.basename(templatePath).replace(/\.eta$/, "");
+    if (this.fileSystem.existsSync(templatePath)) {
+      return eta.render(templateName, replacements);
+    } else {
+      const template = this.fileSystem.readFileSync(templatePath, "utf8");
+      return eta.renderString(template, replacements);
+    }
+  }
+  /**
+   * Helper method to resolve template paths for concrete generators
+   * @param relativePath - The relative path to the template file
+   * @param generatorName - The name of the generator (e.g., 'api', 'job')
+   * @param currentFileUrl - The import.meta.url from the concrete generator class
+   * @returns The full path to the template file
+   */
+  resolveTemplatePath(relativePath, generatorName, currentFileUrl) {
+    const generatorDirName = toKebabCase(generatorName);
+    const currentFilePath = new URL(currentFileUrl).pathname;
+    const currentFileDir = path4.dirname(currentFilePath);
+    const currentFileName = path4.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(
+      startDir,
+      "generators",
+      generatorDirName,
+      "templates",
+      relativePath
+    );
+  }
+};
+
+// 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";
+import path5 from "path";
+import {
+  App as WaspApp
+} from "wasp-config";
+var App = class _App extends WaspApp {
+  constructor(name, config) {
+    super(name, config);
+  }
+  /**
+   * 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;
+  }
+  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;
+  }
+  /**
+   * 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
+   */
+  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;
+  }
+  /**
+   * 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
+   */
+  addApi(featureName, name, options) {
+    const importPath = this.getFeatureImportPath(
+      featureName,
+      "server",
+      "apis",
+      name
+    );
+    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;
+  }
+  /**
+   * 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)
+      }
+    });
+    return this;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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
+    );
+    const config = this.getOperationConfig(
+      name,
+      importPath,
+      options.entities,
+      options.auth
+    );
+    super.query(name, config);
+    return this;
+  }
+  /**
+   * 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
+   */
+  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;
+  }
+  /**
+   * 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
+    );
+    super.apiNamespace(name, {
+      path: options.path,
+      middlewareConfigFn: {
+        import: name,
+        from: `@src/${importPath}`
+      }
+    });
+    return this;
+  }
+  /**
+   * 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}`;
+  }
+  /**
+   * 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";
+    }
+  }
+  /**
+   * Configures all feature modules by scanning the features directory
+   */
+  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;
+  }
+  /**
+   * 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)
+   */
+  getOperationConfig(name, importPath, entities, auth) {
+    return {
+      fn: {
+        import: name,
+        from: `@src/${importPath}`
+      },
+      entities,
+      auth: auth || false
+    };
+  }
+};
+
+// 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/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) {
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+    this.templateUtility = new TemplateUtility(fileSystem);
+  }
+  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) {
+    return this.templateUtility.resolveTemplatePath(
+      templateName,
+      "feature-directory",
+      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
+   */
+  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}`);
+      }
+      this.fileSystem.copyFileSync(templatePath, configFilePath);
+    }
+    let content = this.fileSystem.readFileSync(configFilePath, "utf8");
+    content = this.normaliseSemicolons(content);
+    const parsed = parseHelperMethodDefinition(declaration);
+    if (!parsed) {
+      handleFatalError(`Could not parse definition: ${declaration}`);
+      return content;
+    }
+    const { methodName } = parsed;
+    const hadExistingDefinitions = this.hasExistingDefinitions(
+      content,
+      methodName
+    );
+    content = this.removeExistingDefinition(content, declaration);
+    const hasExistingDefinitions = this.hasExistingDefinitions(
+      content,
+      methodName
+    );
+    const lines = content.split("\n");
+    const configureFunctionStart = lines.findIndex(
+      (line) => line.trim().startsWith("export default function")
+    );
+    if (configureFunctionStart === -1) {
+      handleFatalError("Could not find configure function in feature config");
+    }
+    const appLineIndex = lines.findIndex(
+      (line, index) => index > configureFunctionStart && line.trim() === "app"
+    );
+    if (appLineIndex === -1) {
+      const insertIndex = configureFunctionStart + 1;
+      const itemsToInsert = ["  app"];
+      const comment = this.getMethodComment(methodName);
+      itemsToInsert.push(`    ${comment}`);
+      itemsToInsert.push(declaration.trimEnd());
+      lines.splice(insertIndex, 0, ...itemsToInsert);
+    } else {
+      const { insertIndex, addComment } = this.findGroupInsertionPoint(
+        lines,
+        methodName,
+        declaration,
+        hadExistingDefinitions || hasExistingDefinitions
+      );
+      const newLines = this.insertWithSpacing(
+        lines,
+        declaration,
+        insertIndex,
+        methodName,
+        addComment
+      );
+      const normalisedContent2 = this.normaliseSemicolons(newLines.join("\n"));
+      this.fileSystem.writeFileSync(configFilePath, normalisedContent2);
+      return configFilePath;
+    }
+    const normalisedContent = this.normaliseSemicolons(lines.join("\n"));
+    this.fileSystem.writeFileSync(configFilePath, normalisedContent);
+    return configFilePath;
+  }
+  /**
+   * Determines the insertion index for a method name based on alphabetical ordering
+   * of existing groups in the configuration file.
+   * @param groups - Object containing existing method groups
+   * @param methodName - The method name to find insertion index for
+   * @returns The insertion index for the method name
+   */
+  getInsertionIndexForMethod(groups, methodName) {
+    const existingMethods = Object.keys(groups).filter(
+      (method) => groups[method].length > 0
+    );
+    const allMethods = [...existingMethods, methodName].sort();
+    return allMethods.indexOf(methodName);
+  }
+  /**
+   * Gets the comment text for a method type.
+   * @param methodName The method name (e.g., 'addApi')
+   * @returns The comment text for the method type
+   */
+  getMethodComment(methodName) {
+    const entityName = methodName.startsWith("add") ? methodName.slice(3) : methodName;
+    return `// ${entityName} definitions`;
+  }
+  /**
+   * Finds the correct insertion point for a new configuration item.
+   * @param lines - Array of file lines
+   * @param methodName - The method name (e.g., 'addApi')
+   * @param definition - The definition string to parse for item name
+   * @returns Object with insertion index and whether to add a comment
+   */
+  findGroupInsertionPoint(lines, methodName, definition, hasExistingDefinitionsOfType) {
+    const appLineIndex = lines.findIndex((line) => line.trim() === "app");
+    if (appLineIndex === -1) {
+      return { insertIndex: appLineIndex + 1, addComment: false };
+    }
+    const methodCalls = [];
+    for (let i = appLineIndex + 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith(".") && line.includes("(")) {
+        let methodCallContent = line;
+        let j = i;
+        let closingParenCount = 0;
+        let foundClosingParen = false;
+        for (let k = 0; k < methodCallContent.length; k++) {
+          if (methodCallContent[k] === "(") closingParenCount++;
+          if (methodCallContent[k] === ")") closingParenCount--;
+          if (closingParenCount === 0 && methodCallContent[k] === ")") {
+            foundClosingParen = true;
+            break;
+          }
+        }
+        while (!foundClosingParen && j < lines.length - 1) {
+          j++;
+          methodCallContent += " " + lines[j].trim();
+          for (let k = 0; k < lines[j].length; k++) {
+            if (lines[j][k] === "(") closingParenCount++;
+            if (lines[j][k] === ")") closingParenCount--;
+            if (closingParenCount === 0 && lines[j][k] === ")") {
+              foundClosingParen = true;
+              break;
+            }
+          }
+        }
+        const match = methodCallContent.match(
+          /\.(\w+)\([^,]+,\s*['"`]([^'"`]+)['"`]/
+        );
+        if (match) {
+          methodCalls.push({
+            lineIndex: i,
+            endLineIndex: j,
+            methodName: match[1],
+            itemName: match[2]
+          });
+        }
+      }
+    }
+    const groups = {};
+    methodCalls.forEach((call) => {
+      if (!groups[call.methodName]) {
+        groups[call.methodName] = [];
+      }
+      groups[call.methodName].push({
+        lineIndex: call.lineIndex,
+        endLineIndex: call.endLineIndex,
+        itemName: call.itemName
+      });
+    });
+    const targetGroup = groups[methodName] || [];
+    if (targetGroup.length === 0) {
+      const targetGroupIndex = this.getInsertionIndexForMethod(
+        groups,
+        methodName
+      );
+      const existingMethods = Object.keys(groups).filter((method) => groups[method].length > 0).sort();
+      for (let i = targetGroupIndex; i < existingMethods.length; i++) {
+        const groupMethod = existingMethods[i];
+        if (groups[groupMethod] && groups[groupMethod].length > 0) {
+          const firstItem = groups[groupMethod][0];
+          let insertIndex = firstItem.lineIndex;
+          for (let j = firstItem.lineIndex - 1; j > appLineIndex; j--) {
+            const line = lines[j].trim();
+            if (line.startsWith("//") && line.includes("definitions")) {
+              insertIndex = j;
+              break;
+            } else if (line.startsWith(".") || line === "") {
+              continue;
+            } else {
+              break;
+            }
+          }
+          return { insertIndex, addComment: !hasExistingDefinitionsOfType };
+        }
+      }
+      for (let i = targetGroupIndex - 1; i >= 0; i--) {
+        const groupMethod = existingMethods[i];
+        if (groups[groupMethod] && groups[groupMethod].length > 0) {
+          const lastItem2 = groups[groupMethod][groups[groupMethod].length - 1];
+          return {
+            insertIndex: lastItem2.endLineIndex + 1,
+            addComment: !hasExistingDefinitionsOfType
+          };
+        }
+      }
+      return {
+        insertIndex: appLineIndex + 1,
+        addComment: !hasExistingDefinitionsOfType
+      };
+    }
+    const parsed = parseHelperMethodDefinition(definition);
+    if (!parsed) {
+      return { insertIndex: appLineIndex + 1, addComment: false };
+    }
+    const { firstParam: itemName } = parsed;
+    for (let i = 0; i < targetGroup.length; i++) {
+      if (itemName.localeCompare(targetGroup[i].itemName) < 0) {
+        return { insertIndex: targetGroup[i].lineIndex, addComment: false };
+      }
+    }
+    const lastItem = targetGroup[targetGroup.length - 1];
+    return { insertIndex: lastItem.endLineIndex + 1, addComment: false };
+  }
+  /**
+   * Inserts a definition with optional comment header.
+   * @param lines - Array of file lines
+   * @param declaration - The declaration to insert
+   * @param insertIndex - The index where to insert
+   * @param methodName - The method name for comment generation
+   * @param addComment - Whether to add a comment before the declaration
+   * @returns The modified lines array
+   */
+  insertWithSpacing(lines, declaration, insertIndex, methodName, addComment = false) {
+    const newLines = [...lines];
+    if (addComment) {
+      const comment = this.getMethodComment(methodName);
+      newLines.splice(insertIndex, 0, `    ${comment}`);
+      insertIndex += 1;
+    }
+    newLines.splice(insertIndex, 0, declaration.trimEnd());
+    return newLines;
+  }
+  /**
+   * Checks if there are any existing definitions of a specific type in the content.
+   * @param content - The file content to search
+   * @param methodName - The method name to check for (e.g., 'addJob', 'addApi')
+   * @returns true if there are existing definitions of this type, false otherwise
+   */
+  hasExistingDefinitions(content, methodName) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.trim().startsWith(`.${methodName}(`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Removes an existing definition from the content by finding the helper method call
+   * and removing the entire method call block.
+   * @param content - The file content
+   * @param definition - The new definition to find the existing one from
+   * @returns The content with the existing definition removed
+   */
+  removeExistingDefinition(content, definition) {
+    const parsed = parseHelperMethodDefinition(definition);
+    if (!parsed) {
+      return content;
+    }
+    const { methodName, firstParam } = parsed;
+    let contentLines = content.split("\n");
+    let openingLineIndex = -1;
+    for (let i = 0; i < contentLines.length; i++) {
+      const line = contentLines[i];
+      if (line.trim().startsWith(`.${methodName}(`)) {
+        if (firstParam && line.includes(firstParam)) {
+          openingLineIndex = i;
+          break;
+        }
+      }
+    }
+    if (openingLineIndex === -1) {
+      return content;
+    }
+    let closingLineIndex = -1;
+    let parenCount = 0;
+    let braceCount = 0;
+    let foundOpening = false;
+    for (let i = openingLineIndex; i < contentLines.length; i++) {
+      const line = contentLines[i];
+      for (const char of line) {
+        if (char === "(") {
+          parenCount++;
+          foundOpening = true;
+        } else if (char === ")") {
+          parenCount--;
+          if (foundOpening && parenCount === 0 && braceCount === 0) {
+            closingLineIndex = i;
+            break;
+          }
+        } else if (char === "{") {
+          braceCount++;
+        } else if (char === "}") {
+          braceCount--;
+        }
+      }
+      if (closingLineIndex !== -1) {
+        break;
+      }
+    }
+    if (closingLineIndex === -1) {
+      this.logger.warn(
+        "Could not find closing parenthesis for existing definition"
+      );
+      return content;
+    }
+    contentLines.splice(
+      openingLineIndex,
+      closingLineIndex - openingLineIndex + 1
+    );
+    return contentLines.join("\n");
+  }
+  /**
+   * Adds a definition to the content by finding the appropriate place to insert it.
+   * @param content - The current file content
+   * @param definition - The definition to add
+   * @returns The updated content with the new definition
+   */
+  addDefinitionToContent(content, definition) {
+    const lines = content.split("\n");
+    const lastLineIndex = lines.length - 1;
+    let insertIndex = lastLineIndex;
+    for (let i = lastLineIndex; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (line && !line.startsWith("}")) {
+        insertIndex = i;
+        break;
+      }
+    }
+    lines.splice(insertIndex + 1, 0, `  ${definition}`);
+    return lines.join("\n");
+  }
+  /**
+   * Normalises semicolons in the config file by removing them from method chain calls
+   * while preserving them in other contexts (imports, declarations, etc.).
+   * @param content - The file content to normalise
+   * @returns The normalised content
+   */
+  normaliseSemicolons(content) {
+    const lines = content.split("\n");
+    const configureFunctionStart = lines.findIndex(
+      (line) => line.trim().startsWith("export default function")
+    );
+    if (configureFunctionStart === -1) {
+      return content;
+    }
+    const appLineIndex = lines.findIndex(
+      (line, index) => index > configureFunctionStart && line.trim().startsWith("app")
+    );
+    if (appLineIndex === -1) {
+      return content;
+    }
+    let braceCount = 0;
+    let functionEndIndex = lines.length - 1;
+    for (let i = configureFunctionStart; i < lines.length; i++) {
+      const line = lines[i];
+      for (const char of line) {
+        if (char === "{") braceCount++;
+        if (char === "}") {
+          braceCount--;
+          if (braceCount === 0) {
+            functionEndIndex = i;
+            break;
+          }
+        }
+      }
+      if (braceCount === 0 && i > configureFunctionStart) {
+        break;
+      }
+    }
+    let lastMethodCallIndex = -1;
+    for (let i = appLineIndex + 1; i < functionEndIndex; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if ((trimmed.endsWith(")") || trimmed.endsWith(");")) && !trimmed.startsWith("//")) {
+        lines[i] = line.replace(/;\s*$/, "");
+        lastMethodCallIndex = i;
+      }
+    }
+    if (lastMethodCallIndex !== -1 && !lines[lastMethodCallIndex].trim().endsWith(";")) {
+      lines[lastMethodCallIndex] = lines[lastMethodCallIndex] + ";";
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/generators/base/wasp-generator.base.ts
+var WaspGeneratorBase = class extends GeneratorBase {
+  constructor(fileSystem = realFileSystem, logger = 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;
+  }
+  /**
+   * Resolves template path with override support
+   */
+  async getTemplatePath(templateName) {
+    const defaultPath = this.getDefaultTemplatePath(templateName);
+    const customPath = await this.getCustomTemplateDir();
+    if (!customPath) {
+      return defaultPath;
+    }
+    const { path: resolvedPath, isCustom } = this.templateResolver.resolveTemplatePath(
+      this.pluginName,
+      this.name,
+      templateName,
+      defaultPath,
+      customPath
+    );
+    if (isCustom) {
+      this.logger.info(`Using custom template: ${resolvedPath}`);
+    }
+    return resolvedPath;
+  }
+  /**
+   * Processes a template and writes the result to a file
+   */
+  async renderTemplateToFile(templateName, replacements, outputPath, readableFileType, force) {
+    const templatePath = await this.getTemplatePath(templateName);
+    const fileExists = this.checkFileExists(
+      outputPath,
+      force,
+      readableFileType
+    );
+    const content = this.templateUtility.processTemplate(
+      templatePath,
+      replacements
+    );
+    this.writeFile(outputPath, content, readableFileType, fileExists);
+    return fileExists;
+  }
+  /**
+   * Generic existence check with force flag handling
+   * Consolidates the pattern used in both file and config checks
+   */
+  checkExistence(exists, itemDescription, force, errorMessage) {
+    if (exists && !force) {
+      this.logger.error(`${itemDescription}. Use --force to overwrite`);
+      throw new Error(errorMessage || itemDescription);
+    }
+    return exists;
+  }
+  /**
+   * Checks if a file exists and handles force flag logic
+   */
+  checkFileExists(filePath, force, fileType) {
+    const fileExists = this.fileSystem.existsSync(filePath);
+    return this.checkExistence(
+      fileExists,
+      `${fileType} already exists: ${filePath}`,
+      force,
+      `${fileType} already exists`
+    );
+  }
+  /**
+   * Safely writes a file with proper error handling and logging
+   */
+  writeFile(filePath, content, fileType, fileExists) {
+    this.fileSystem.writeFileSync(filePath, content);
+    this.logger.success(
+      `${fileExists ? "Overwrote" : "Generated"} ${fileType}: ${filePath}`
+    );
+  }
+};
+
+// src/generators/feature-directory/schema.ts
+import { z as z2 } from "zod";
+var schema = z2.object({
+  path: commonSchemas.path
+});
+
+// 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}`);
+  }
+};
+
+// 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());
+  }
+  /**
+   * 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;
+      }
+    }
+    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
+    );
+    return this.checkExistence(
+      configExists,
+      `${methodName} config already exists in ${configPath}`,
+      force,
+      `${methodName} config already exists`
+    );
+  }
+  /**
+   * Updates the feature config with a new definition
+   */
+  updateFeatureConfig(featurePath, definition, configPath, configExists, methodName) {
+    this.configGenerator.update(featurePath, definition);
+    this.logger.success(
+      `${configExists ? "Updated" : "Added"} ${methodName} config in: ${configPath}`
+    );
+  }
+  /**
+   * Consolidated helper for updating config files with existence check
+   * This replaces the duplicated updateConfigFile pattern in concrete generators
+   */
+  updateConfigWithCheck(configPath, methodName, entityName, definition, featurePath, force) {
+    const configExists = this.checkConfigExists(
+      configPath,
+      methodName,
+      entityName,
+      force
+    );
+    if (!configExists || force) {
+      this.updateFeatureConfig(
+        featurePath,
+        definition,
+        configPath,
+        configExists,
+        methodName
+      );
+    }
+  }
+  /**
+   * Gets the appropriate directory for a feature based on its path.
+   * @param fileSystem - The filesystem abstraction
+   * @param featurePath - The full feature path
+   * @param type - The type of file being generated
+   * @returns The target directory and import path
+   */
+  getFeatureTargetDir(fileSystem, featurePath, type) {
+    validateFeaturePath3(featurePath);
+    const normalisedPath = normaliseFeaturePath(featurePath);
+    const featureDir = getFeatureDir(fileSystem, normalisedPath);
+    const typeKey = type.toLowerCase();
+    const typeDirectory = TYPE_DIRECTORIES[typeKey];
+    const targetDirectory = path8.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.entityType || "")
+    };
+    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 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) {
+    const imports = [];
+    if (operation !== OPERATIONS.GETALL) {
+      if (needsPrismaImport(model)) {
+        imports.push('import { Prisma } from "@prisma/client";');
+      }
+      imports.push(`import { ${modelName} } from "wasp/entities";`);
+    }
+    imports.push('import { HttpError } from "wasp/server";');
+    imports.push(
+      `import type { ${this.getOperationTypeName(
+        operation,
+        modelName
+      )} } from "wasp/server/operations";`
+    );
+    return imports.join("\n");
+  }
+  /**
+   * Gets the operation type ("query" or "action") for a given operation.
+   */
+  getOperationType(operation) {
+    return operation === OPERATIONS.GETALL || operation === OPERATIONS.GET || operation === OPERATIONS.GETFILTERED ? "query" : "action";
+  }
+  /**
+   * Generates the operation components needed for file and config generation.
+   */
+  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
+    );
+    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;
+      }
+      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;
+    }
+    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 = "";
+      }
+    }
+    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);
+  }
+  /**
+   * 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"
+    );
+    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}`
+    );
+  }
+  /**
+   * Generates an operation 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
+    );
+    return this.templateUtility.processTemplate(templatePath, {
+      operationType: capitalise(operationType),
+      operationName,
+      featureDir,
+      directory,
+      entities: entities.map((e) => `"${e}"`).join(", "),
+      importPath,
+      auth: String(auth)
+    });
+  }
+};
+
+// 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"
+});
+var schema2 = z3.object({
+  feature: commonSchemas.feature,
+  operation: actionSchema,
+  dataType: dataTypeSchema,
+  name: extend2(commonSchemas.name.optional(), commonSchemas.name._metadata),
+  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;
+  }
+  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) : [];
+    if (dataType && !entities.includes(dataType)) {
+      entities.unshift(dataType);
+    }
+    const { operationCode, operationName } = await this.generateOperationComponents(
+      dataType,
+      operation,
+      flags.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
+    );
+  }
+  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/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 EntityGeneratorBase {
+  get entityType() {
+    return CONFIG_TYPES.API_NAMESPACE;
+  }
+  description = "Generate API namespaces for Wasp applications";
+  schema = schema4;
+  async generate(flags) {
+    const { name, path: apiPath, feature } = flags;
+    const namespaceName = toCamelCase3(name);
+    return this.handleGeneratorError(
+      this.entityType,
+      namespaceName,
+      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
+        );
+      }
+    );
+  }
+  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
+    );
+    this.updateConfigWithCheck(
+      configFilePath,
+      "addApiNamespace",
+      namespaceName,
+      definition,
+      feature,
+      force
+    );
+  }
+  /**
+   * Generates an apiNamespace definition for the feature configuration.
+   */
+  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
+    });
+  }
+};
+
+// 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/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;
+  }
+  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
+      );
+    });
+  }
+  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
+    );
+  }
+  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
+    );
+  }
+  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;
+      },
+      {}
+    );
+  }
+  /**
+   * Generates operation code for overridden CRUD operations and returns as a single string.
+   */
+  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("");
+  }
+  /**
+   * Generates a CRUD definition for the feature configuration.
+   */
+  getDefinition(crudName, dataType, operations) {
+    const templatePath = this.templateUtility.resolveTemplatePath(
+      "config/crud.eta",
+      "crud",
+      import.meta.url
+    );
+    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
+    });
+  }
+};
+
+// 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;
+      }
+    },
+    {
+      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);
+    });
+  }
+  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
+    );
+  }
+  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 || "{}"
+    );
+    this.updateConfigWithCheck(
+      configPath,
+      "job",
+      jobName,
+      definition,
+      featurePath,
+      flags.force || false
+    );
+  }
+  /**
+   * Generates a job definition for the feature configuration.
+   */
+  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
+    });
+  }
+};
+
+// 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,
+      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
+        );
+      }
+    );
+  }
+};
+
+// 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;
+  }
+  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);
+    });
+  }
+  async generatePageFile(targetFile, componentName, flags) {
+    const templatePath = "files/client/page.eta";
+    const replacements = {
+      componentName,
+      displayName: formatDisplayName(componentName)
+    };
+    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
+    );
+  }
+  /**
+   * Generates a route definition for the feature configuration.
+   */
+  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)
+    });
+  }
+};
+export {
+  ActionGenerator,
+  ApiGenerator,
+  ApiNamespaceGenerator,
+  App,
+  CrudGenerator,
+  FeatureDirectoryGenerator,
+  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
+};