@igniter-js/cli 0.2.62 → 0.2.63

package/dist/index.js

@@ -19549,12 +19549,18 @@ var PrismaProvider = class {
         return null;
       }
       const fields = model.properties.filter((prop) => prop.type === "field").map((prop) => {
-        const isRelation = !/^[A-Z]/.test(prop.fieldType.toString()) && typeof prop.fieldType !== "string";
+        if (prop.type !== "field" || !("fieldType" in prop) || !("name" in prop)) {
+          throw new Error(`Invalid field property structure for ${prop}`);
+        }
+        const fieldType = prop.fieldType;
+        const fieldTypeStr = typeof fieldType === "string" ? fieldType : fieldType?.toString() || "string";
+        const isOptional = "optional" in prop ? prop.optional : false;
+        const isRelation = !/^[A-Z]/.test(fieldTypeStr) && typeof fieldType !== "string";
         return {
           name: prop.name,
-          type: mapPrismaTypeToTsType(prop.fieldType),
+          type: mapPrismaTypeToTsType(fieldTypeStr),
           isId: hasAttribute(prop, "id"),
-          isRequired: !(prop.optional || hasAttribute(prop, "default")),
+          isRequired: !(isOptional || hasAttribute(prop, "default")),
           isUnique: hasAttribute(prop, "unique"),
           isRelation,
           hasDefault: hasAttribute(prop, "default"),
@@ -19574,6 +19580,28 @@ var PrismaProvider = class {
       throw new Error(`Could not process Prisma schema. Make sure '${this.schemaPath}' exists and is valid.`);
     }
   }
+  /**
+   * Lists all available model names in the Prisma schema.
+   *
+   * @returns A promise that resolves to an array of model names.
+   */
+  async listModels() {
+    try {
+      const schemaContent = await fs4.readFile(this.schemaPath, "utf-8");
+      const ast = (0, import_prisma_ast.getSchema)(schemaContent);
+      const models = ast.list.filter((node) => node.type === "model").map((model) => model.name);
+      logger4.debug(`Found ${models.length} models in schema: ${models.join(", ")}`);
+      return models;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        logger4.error(`Prisma schema file not found at: ${this.schemaPath}`);
+        return [];
+      } else {
+        logger4.error("Failed to parse Prisma schema for model listing", { error });
+        throw new Error(`Could not process Prisma schema. Make sure '${this.schemaPath}' exists and is valid.`);
+      }
+    }
+  }
   /**
    * Determines if a field's value is automatically managed by the database.
    *
@@ -19599,6 +19627,29 @@ var PrismaProvider = class {
 
 // src/adapters/scaffold.ts
 var logger5 = createChildLogger({ component: "scaffold" });
+async function hasPrismaSchema() {
+  const possiblePaths = [
+    path6.join(process.cwd(), "prisma", "schema.prisma"),
+    path6.join(process.cwd(), "schema.prisma")
+  ];
+  for (const schemaPath of possiblePaths) {
+    try {
+      await fs5.access(schemaPath);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function getPrismaModels() {
+  try {
+    const provider = new PrismaProvider();
+    return await provider.listModels();
+  } catch (error) {
+    logger5.debug("Failed to get Prisma models", { error });
+    return [];
+  }
+}
 function toPascalCase(str) {
   return str.replace(/(^\w|-\w)/g, (g) => g.replace(/-/, "").toUpperCase());
 }
@@ -19811,8 +19862,7 @@ function generateEmptyIndexTemplate(featureName) {
 `;
 }
 async function scaffoldEmptyFeature(featureName, featureDir) {
-  const spinner = logger5.spinner(`Creating empty feature '${featureName}'...`);
-  spinner.start();
+  logger5.info(`Creating empty feature '${featureName}'...`);
   try {
     await fs5.mkdir(path6.join(featureDir, "controllers"), { recursive: true });
     await fs5.mkdir(path6.join(featureDir, "procedures"), { recursive: true });
@@ -19828,15 +19878,14 @@ async function scaffoldEmptyFeature(featureName, featureDir) {
       path6.join(featureDir, "index.ts"),
       generateEmptyIndexTemplate(featureName)
     );
-    spinner.success(`Scaffolded empty feature '${featureName}'`);
+    logger5.success(`Scaffolded empty feature '${featureName}'`);
   } catch (error) {
-    spinner.error(`Failed to create empty feature '${featureName}'`);
+    logger5.error(`Failed to create empty feature '${featureName}'`);
     throw error;
   }
 }
 async function scaffoldFeatureFromSchema(featureName, schemaString, featureDir) {
-  const spinner = logger5.spinner(`Scaffolding feature '${featureName}' from schema...`);
-  spinner.start();
+  logger5.info(`Scaffolding feature '${featureName}' from schema...`);
   try {
     const [providerName, modelName] = schemaString.split(":");
     if (!providerName || !modelName) {
@@ -19847,7 +19896,7 @@ async function scaffoldFeatureFromSchema(featureName, schemaString, featureDir)
     if (!model) {
       throw new Error(`Model '${modelName}' not found using provider '${providerName}'.`);
     }
-    spinner.update("Generating files from model schema...");
+    logger5.info("Generating files from model schema...");
     await fs5.mkdir(path6.join(featureDir, "controllers"), { recursive: true });
     await fs5.mkdir(path6.join(featureDir, "procedures"), { recursive: true });
     await writeFile2(
@@ -19866,15 +19915,64 @@ async function scaffoldFeatureFromSchema(featureName, schemaString, featureDir)
       path6.join(featureDir, "index.ts"),
       generateCrudIndexTemplate(featureName)
     );
-    spinner.success(`Successfully scaffolded feature '${featureName}' from '${modelName}' model.`);
+    logger5.success(`Successfully scaffolded feature '${featureName}' from '${modelName}' model.`);
     console.log(import_chalk5.default.cyan(`
 \u2705 Next step: Register the '${toCamelCase(featureName)}Controller' in 'src/igniter.router.ts'`));
   } catch (error) {
-    spinner.error(`Failed to scaffold feature from schema`);
+    logger5.error(`Failed to scaffold feature from schema`);
     throw error;
   }
 }
-async function handleGenerateFeature(featureName, options) {
+async function handleGenerateFeature(name, options = {}) {
+  let featureName = name;
+  if (!featureName) {
+    const prompts2 = await import("prompts");
+    const hasPrisma = await hasPrismaSchema();
+    const prismaModels = hasPrisma ? await getPrismaModels() : [];
+    const questions = [
+      {
+        type: "text",
+        name: "featureName",
+        message: "What is the name of your feature?",
+        validate: (input) => {
+          if (!input.trim()) {
+            return "Feature name is required";
+          }
+          if (!/^[a-zA-Z][a-zA-Z0-9-_]*$/.test(input)) {
+            return "Feature name must start with a letter and contain only letters, numbers, hyphens, and underscores";
+          }
+          return true;
+        }
+      }
+    ];
+    if (hasPrisma && prismaModels.length > 0) {
+      questions.push({
+        type: "select",
+        name: "useModel",
+        message: "Would you like to generate CRUD operations from a Prisma model?",
+        choices: [
+          { title: "No, create an empty feature", value: "none" },
+          { title: "Yes, select a Prisma model", value: "select" }
+        ],
+        initial: 0
+      });
+      questions.push({
+        type: (prev) => prev === "select" ? "select" : null,
+        name: "selectedModel",
+        message: "Which Prisma model would you like to use?",
+        choices: prismaModels.map((model) => ({ title: model, value: model }))
+      });
+    }
+    const response = await prompts2.default(questions);
+    if (!response.featureName) {
+      logger5.error("Feature name is required");
+      process.exit(1);
+    }
+    featureName = response.featureName;
+    if (response.useModel === "select" && response.selectedModel) {
+      options.schema = `prisma:${response.selectedModel}`;
+    }
+  }
   const normalizedName = featureName.toLowerCase();
   const featureDir = path6.join(process.cwd(), "src", "features", normalizedName);
   logger5.info(`Scaffolding feature: ${import_chalk5.default.cyan(normalizedName)}`);
@@ -20111,7 +20209,7 @@ generate.command("docs").description("Generate OpenAPI specification and/or inte
     process.exit(1);
   }
 });
-generate.command("feature").description("Scaffold a new feature module").argument("<name>", "The name of the feature (e.g., 'user', 'products')").option("--schema <value>", "Generate from a schema provider (e.g., 'prisma:User')").action(async (name, options) => {
+generate.command("feature").description("Scaffold a new feature module").argument("[name]", "The name of the feature (e.g., 'user', 'products')").option("--schema <value>", "Generate from a schema provider (e.g., 'prisma:User')").action(async (name, options) => {
   await handleGenerateFeature(name, options);
 });
 generate.command("controller").description("Scaffold a new controller within a feature").argument("<name>", "The name of the controller (e.g., 'profile')").option("-f, --feature <feature>", "The parent feature name", "").action(async (name, options) => {