@ingenyus/swarm-wasp 0.1.0 → 0.2.0

package/dist/generators/base/index.js

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