@igniter-js/cli 0.2.62 → 0.2.64

package/dist/index.mjs

@@ -19553,12 +19553,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"),
@@ -19578,6 +19584,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 = 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.
    *
@@ -19603,6 +19631,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());
 }
@@ -19815,8 +19866,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 });
@@ -19832,15 +19882,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) {
@@ -19851,7 +19900,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(
@@ -19870,15 +19919,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(chalk5.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: ${chalk5.cyan(normalizedName)}`);
@@ -19902,6 +20000,74 @@ async function handleGenerateProcedure(name, feature) {
   logger5.warn(`'generate procedure' is not yet fully implemented. Use 'generate feature --schema' instead.`);
 }
 
+// src/lib/port-manager.ts
+init_logger();
+import { spawn as spawn3 } from "child_process";
+async function killProcessOnPort(port) {
+  const isWindows = process.platform === "win32";
+  const isMac = process.platform === "darwin";
+  const isLinux = process.platform === "linux";
+  try {
+    let command;
+    let args;
+    if (isWindows) {
+      command = "cmd";
+      args = ["/c", `netstat -ano | findstr :${port} | findstr LISTENING`];
+    } else if (isMac || isLinux) {
+      command = "lsof";
+      args = ["-ti", `:${port}`];
+    } else {
+      logger.warn(`Unsupported platform: ${process.platform}. Skipping port cleanup.`);
+      return;
+    }
+    const child = spawn3(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    await new Promise((resolve5) => {
+      child.on("close", async (code) => {
+        if (code === 0 && stdout.trim()) {
+          const pids = stdout.trim().split("\n").filter((line) => line.trim());
+          if (pids.length > 0) {
+            logger.info(`Found ${pids.length} process(es) using port ${port}. Killing...`);
+            for (const pid of pids) {
+              try {
+                if (isWindows) {
+                  const parts = pid.trim().split(/\s+/);
+                  const actualPid = parts[parts.length - 1];
+                  spawn3("taskkill", ["/PID", actualPid, "/F"], { stdio: "inherit" });
+                } else {
+                  process.kill(parseInt(pid.trim()), "SIGTERM");
+                  setTimeout(() => {
+                    try {
+                      process.kill(parseInt(pid.trim()), "SIGKILL");
+                    } catch (e) {
+                    }
+                  }, 2e3);
+                }
+              } catch (error) {
+                logger.warn(`Failed to kill process ${pid}:`, error);
+              }
+            }
+            await new Promise((resolve6) => setTimeout(resolve6, 1e3));
+            logger.info(`Port ${port} freed successfully.`);
+          }
+        } else if (code !== 0 && stderr) {
+          logger.debug(`Port check command failed (this is normal if no processes are using the port): ${stderr}`);
+        }
+        resolve5();
+      });
+    });
+  } catch (error) {
+    logger.warn(`Failed to check/kill processes on port ${port}:`, error);
+  }
+}
+
 // src/index.ts
 var program = new Command();
 program.name("igniter").description("CLI for Igniter.js type-safe client generation").version("1.0.0").option("--debug", "Enable debug mode for detailed logging", false).hook("preAction", (thisCommand) => {
@@ -19960,6 +20126,9 @@ program.command("init").description("Create a new Igniter.js project with intera
   }
 });
 program.command("dev").description("Start development mode with framework and Igniter (interactive dashboard and OpenAPI docs by default)").option("--framework <type>", `Framework type (${getFrameworkList()}, generic)`).option("--output <dir>", "Output directory for generated client files", "src/").option("--port <number>", "Port for the dev server", "3000").option("--cmd <command>", "Custom command to start dev server").option("--no-framework", "Disable framework dev server (Igniter only)").option("--no-interactive", "Disable interactive mode (use regular concurrent mode)").option("--docs-output <dir>", "Output directory for OpenAPI docs", "./src/docs").action(async (options) => {
+  const port = parseInt(options.port) || 3e3;
+  logger.info(`Checking and freeing port ${port}...`);
+  await killProcessOnPort(port);
   const detectedFramework = detectFramework();
   const framework = options.framework ? isFrameworkSupported(options.framework) ? options.framework : "generic" : detectedFramework;
   const useInteractive = options.interactive !== false;
@@ -19984,7 +20153,7 @@ program.command("dev").description("Start development mode with framework and Ig
         command: frameworkCommand,
         color: "green",
         cwd: process.cwd(),
-        env: { PORT: options.port.toString(), NODE_ENV: "development" }
+        env: { PORT: port.toString(), NODE_ENV: "development" }
       });
     }
   }
@@ -20115,7 +20284,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) => {