yantr-js 0.1.0-beta.2

package/dist/index.js

@@ -0,0 +1,1023 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import path4 from "path";
+import fs4 from "fs-extra";
+
+// src/lib/installer.ts
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "path";
+async function detectPackageManager(cwd) {
+  const lockFiles = {
+    "pnpm-lock.yaml": "pnpm",
+    "yarn.lock": "yarn",
+    "package-lock.json": "npm",
+    "bun.lockb": "bun"
+  };
+  for (const [lockFile, pm] of Object.entries(lockFiles)) {
+    if (await fs.pathExists(path.join(cwd, lockFile))) {
+      return pm;
+    }
+  }
+  return null;
+}
+async function runPackageManager(pm, args, cwd) {
+  await execa(pm, args, { cwd, stdio: "inherit" });
+}
+async function installDependencies(pm, packages, cwd, isDev = false) {
+  const args = [];
+  switch (pm) {
+    case "npm":
+      args.push("install", isDev ? "-D" : "", ...packages);
+      break;
+    case "pnpm":
+      args.push("add", isDev ? "-D" : "", ...packages);
+      break;
+    case "yarn":
+      args.push("add", isDev ? "-D" : "", ...packages);
+      break;
+    case "bun":
+      args.push("add", isDev ? "-d" : "", ...packages);
+      break;
+  }
+  const filteredArgs = args.filter(Boolean);
+  await runPackageManager(pm, filteredArgs, cwd);
+}
+
+// src/lib/config.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+import { z } from "zod";
+var SetuConfigSchema = z.object({
+  $schema: z.string().optional(),
+  projectName: z.string(),
+  srcDir: z.string().default("./src"),
+  packageManager: z.enum(["npm", "pnpm", "yarn", "bun"]),
+  installedComponents: z.array(z.string()).default([])
+});
+var CONFIG_FILE = "yantr.json";
+async function configExists(cwd) {
+  return fs2.pathExists(path2.join(cwd, CONFIG_FILE));
+}
+async function readConfig(cwd) {
+  const configPath = path2.join(cwd, CONFIG_FILE);
+  if (!await fs2.pathExists(configPath)) {
+    throw new Error('yantr.json not found. Run "setu init" first.');
+  }
+  const content = await fs2.readJson(configPath);
+  return SetuConfigSchema.parse(content);
+}
+async function writeConfig(cwd, config) {
+  const configPath = path2.join(cwd, CONFIG_FILE);
+  await fs2.writeJson(configPath, config, { spaces: 2 });
+}
+function createConfig(projectName, srcDir, packageManager) {
+  return {
+    $schema: "https://raw.githubusercontent.com/SibilSoren/setu-js/main/cli/schema.json",
+    projectName,
+    srcDir,
+    packageManager,
+    installedComponents: []
+  };
+}
+async function addInstalledComponent(cwd, component) {
+  const config = await readConfig(cwd);
+  if (!config.installedComponents.includes(component)) {
+    config.installedComponents.push(component);
+    await writeConfig(cwd, config);
+  }
+}
+async function isComponentInstalled(cwd, component) {
+  const config = await readConfig(cwd);
+  return config.installedComponents.includes(component);
+}
+
+// src/utils/fs.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+async function ensureDir(dirPath) {
+  await fs3.ensureDir(dirPath);
+}
+async function writeFile(filePath, content) {
+  await fs3.ensureDir(path3.dirname(filePath));
+  await fs3.writeFile(filePath, content, "utf-8");
+}
+async function fileExists(filePath) {
+  return fs3.pathExists(filePath);
+}
+async function isNodeProject(cwd) {
+  return fs3.pathExists(path3.join(cwd, "package.json"));
+}
+async function getProjectName(cwd) {
+  const pkgPath = path3.join(cwd, "package.json");
+  if (await fs3.pathExists(pkgPath)) {
+    const pkg = await fs3.readJson(pkgPath);
+    return pkg.name || null;
+  }
+  return null;
+}
+async function hasSrcDirectory(cwd) {
+  return fs3.pathExists(path3.join(cwd, "src"));
+}
+
+// src/commands/init.ts
+async function init(options) {
+  console.clear();
+  p.intro(chalk.bgCyan.black(" \u{1FA9B} yantr init "));
+  const cwd = process.cwd();
+  const isNode = await isNodeProject(cwd);
+  if (!isNode) {
+    p.log.error("No package.json found in current directory.");
+    p.log.info("Please run this command in an existing Node.js project, or run:");
+    p.log.info(chalk.cyan("  npm init -y"));
+    p.outro(chalk.red("Initialization cancelled."));
+    process.exit(1);
+  }
+  const hasConfig = await configExists(cwd);
+  if (hasConfig && !options.yes) {
+    const overwrite = await p.confirm({
+      message: "yantr.json already exists. Overwrite?",
+      initialValue: false
+    });
+    if (p.isCancel(overwrite) || !overwrite) {
+      p.outro(chalk.yellow("Initialization cancelled."));
+      process.exit(0);
+    }
+  }
+  let projectName;
+  let srcDir;
+  let packageManager;
+  if (options.yes) {
+    projectName = await getProjectName(cwd) || path4.basename(cwd);
+    srcDir = await hasSrcDirectory(cwd) ? "./src" : ".";
+    packageManager = await detectPackageManager(cwd) || "npm";
+  } else {
+    const detectedPm = await detectPackageManager(cwd);
+    const detectedName = await getProjectName(cwd) || path4.basename(cwd);
+    const hasSrc = await hasSrcDirectory(cwd);
+    const responses = await p.group(
+      {
+        projectName: () => p.text({
+          message: "Project name:",
+          defaultValue: detectedName,
+          placeholder: detectedName
+        }),
+        srcDir: () => p.select({
+          message: "Where should Yantr put generated files?",
+          initialValue: hasSrc ? "./src" : ".",
+          options: [
+            { value: "./src", label: "./src (recommended)" },
+            { value: ".", label: ". (project root)" },
+            { value: "./lib", label: "./lib" }
+          ]
+        }),
+        packageManager: () => p.select({
+          message: "Package manager:",
+          initialValue: detectedPm || "npm",
+          options: [
+            { value: "npm", label: "npm" },
+            { value: "pnpm", label: "pnpm" },
+            { value: "yarn", label: "yarn" },
+            { value: "bun", label: "bun" }
+          ]
+        })
+      },
+      {
+        onCancel: () => {
+          p.cancel("Initialization cancelled.");
+          process.exit(0);
+        }
+      }
+    );
+    projectName = responses.projectName;
+    srcDir = responses.srcDir;
+    packageManager = responses.packageManager;
+  }
+  const spinner4 = p.spinner();
+  spinner4.start("Creating configuration...");
+  const config = createConfig(projectName, srcDir, packageManager);
+  await writeConfig(cwd, config);
+  spinner4.stop("Created yantr.json");
+  spinner4.start("Setting up base templates...");
+  const templatesDir = path4.join(srcDir, "lib", "yantr");
+  await ensureDir(path4.join(cwd, templatesDir));
+  const cliDir = path4.dirname(new URL(import.meta.url).pathname);
+  const registryPath = path4.join(cliDir, "..", "..", "registry", "templates", "base");
+  const baseTemplatesPath = await fs4.pathExists(registryPath) ? registryPath : path4.join(cliDir, "registry", "templates", "base");
+  const errorHandlerContent = `import type { Request, Response, NextFunction } from 'express';
+
+/**
+ * Custom error class for application errors
+ */
+export class AppError extends Error {
+  public readonly statusCode: number;
+  public readonly isOperational: boolean;
+  public readonly code?: string;
+
+  constructor(
+    message: string,
+    statusCode: number = 500,
+    isOperational: boolean = true,
+    code?: string
+  ) {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    this.code = code;
+
+    Object.setPrototypeOf(this, AppError.prototype);
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Common HTTP error classes
+ */
+export class NotFoundError extends AppError {
+  constructor(message: string = 'Resource not found') {
+    super(message, 404, true, 'NOT_FOUND');
+  }
+}
+
+export class BadRequestError extends AppError {
+  constructor(message: string = 'Bad request') {
+    super(message, 400, true, 'BAD_REQUEST');
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor(message: string = 'Unauthorized') {
+    super(message, 401, true, 'UNAUTHORIZED');
+  }
+}
+
+export class ForbiddenError extends AppError {
+  constructor(message: string = 'Forbidden') {
+    super(message, 403, true, 'FORBIDDEN');
+  }
+}
+
+export class ConflictError extends AppError {
+  constructor(message: string = 'Conflict') {
+    super(message, 409, true, 'CONFLICT');
+  }
+}
+
+export class ValidationError extends AppError {
+  public readonly errors: Record<string, string[]>;
+
+  constructor(errors: Record<string, string[]>) {
+    super('Validation failed', 422, true, 'VALIDATION_ERROR');
+    this.errors = errors;
+  }
+}
+
+/**
+ * Global error handler middleware
+ */
+export function errorHandler(
+  err: Error,
+  _req: Request,
+  res: Response,
+  _next: NextFunction
+): void {
+  console.error('[Error]', err);
+
+  if (err instanceof AppError) {
+    const response: Record<string, unknown> = {
+      success: false,
+      error: {
+        message: err.message,
+        code: err.code,
+      },
+    };
+
+    if (err instanceof ValidationError) {
+      response.error = {
+        ...response.error as object,
+        details: err.errors,
+      };
+    }
+
+    res.status(err.statusCode).json(response);
+    return;
+  }
+
+  const statusCode = 500;
+  const message = process.env.NODE_ENV === 'production'
+    ? 'Internal server error'
+    : err.message;
+
+  res.status(statusCode).json({
+    success: false,
+    error: {
+      message,
+      code: 'INTERNAL_ERROR',
+    },
+  });
+}
+
+/**
+ * Async handler wrapper to catch errors in async route handlers
+ */
+export function asyncHandler(
+  fn: (req: Request, res: Response, next: NextFunction) => Promise<void>
+) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}
+`;
+  const zodMiddlewareContent = `import type { Request, Response, NextFunction } from 'express';
+import { z, ZodError, ZodSchema } from 'zod';
+import { ValidationError } from './error-handler';
+
+type RequestLocation = 'body' | 'query' | 'params';
+
+interface ValidateOptions {
+  body?: ZodSchema;
+  query?: ZodSchema;
+  params?: ZodSchema;
+}
+
+/**
+ * Format Zod errors into a readable format
+ */
+function formatZodErrors(error: ZodError): Record<string, string[]> {
+  const errors: Record<string, string[]> = {};
+
+  for (const issue of error.issues) {
+    const path = issue.path.join('.');
+    const key = path || 'root';
+
+    if (!errors[key]) {
+      errors[key] = [];
+    }
+
+    errors[key].push(issue.message);
+  }
+
+  return errors;
+}
+
+/**
+ * Validate request data against Zod schemas
+ */
+export function validate(schemas: ValidateOptions) {
+  return async (req: Request, _res: Response, next: NextFunction) => {
+    const allErrors: Record<string, string[]> = {};
+    const locations: RequestLocation[] = ['body', 'query', 'params'];
+
+    for (const location of locations) {
+      const schema = schemas[location];
+
+      if (schema) {
+        const result = await schema.safeParseAsync(req[location]);
+
+        if (!result.success) {
+          const errors = formatZodErrors(result.error);
+
+          for (const [key, messages] of Object.entries(errors)) {
+            const prefixedKey = \`\${location}.\${key}\`;
+            allErrors[prefixedKey] = messages;
+          }
+        } else {
+          req[location] = result.data;
+        }
+      }
+    }
+
+    if (Object.keys(allErrors).length > 0) {
+      return next(new ValidationError(allErrors));
+    }
+
+    next();
+  };
+}
+
+export function validateBody<T extends ZodSchema>(schema: T) {
+  return validate({ body: schema });
+}
+
+export function validateQuery<T extends ZodSchema>(schema: T) {
+  return validate({ query: schema });
+}
+
+export function validateParams<T extends ZodSchema>(schema: T) {
+  return validate({ params: schema });
+}
+
+export { z };
+`;
+  await writeFile(
+    path4.join(cwd, templatesDir, "error-handler.ts"),
+    errorHandlerContent
+  );
+  await writeFile(
+    path4.join(cwd, templatesDir, "zod-middleware.ts"),
+    zodMiddlewareContent
+  );
+  spinner4.stop("Base templates created");
+  spinner4.start("Installing dependencies...");
+  try {
+    await installDependencies(packageManager, ["zod"], cwd, false);
+    spinner4.stop("Dependencies installed");
+  } catch (error) {
+    spinner4.stop("Could not install dependencies automatically");
+    p.log.warning(`Please run: ${chalk.cyan(`${packageManager} add zod`)}`);
+  }
+  p.note(
+    `${chalk.green("\u2713")} yantr.json created
+${chalk.green("\u2713")} ${templatesDir}/error-handler.ts
+${chalk.green("\u2713")} ${templatesDir}/zod-middleware.ts`,
+    "Files created"
+  );
+  p.log.info("Next steps:");
+  p.log.step(1, `Add error handler to your Express app:`);
+  console.log(chalk.gray(`   import { errorHandler } from '${templatesDir}/error-handler';`));
+  console.log(chalk.gray(`   app.use(errorHandler);`));
+  p.log.step(2, `Add components: ${chalk.cyan("yantr add auth")}`);
+  p.log.step(3, `Generate routes: ${chalk.cyan("yantr generate route users")}`);
+  p.outro(chalk.green("Yantr initialized successfully! \u{1FA9B}"));
+}
+
+// src/commands/add.ts
+import * as p2 from "@clack/prompts";
+import chalk2 from "chalk";
+import path6 from "path";
+
+// src/lib/registry.ts
+import { z as z2 } from "zod";
+import fs5 from "fs-extra";
+import path5 from "path";
+import { fileURLToPath } from "url";
+var ComponentSchema = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  files: z2.array(z2.string()),
+  dependencies: z2.array(z2.string()).default([]),
+  devDependencies: z2.array(z2.string()).default([])
+});
+var RegistrySchema = z2.object({
+  version: z2.string(),
+  baseUrl: z2.string(),
+  components: z2.record(z2.string(), ComponentSchema)
+});
+var REGISTRY_URL = "https://raw.githubusercontent.com/SibilSoren/setu-js/main/cli/registry/registry.json";
+var CACHE_DIR = ".yantr-cache";
+var CACHE_TTL_MS = 1e3 * 60 * 60;
+function getCacheDir() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
+  return path5.join(homeDir, CACHE_DIR);
+}
+async function getCachedRegistry() {
+  const cacheDir = getCacheDir();
+  const cachePath = path5.join(cacheDir, "registry.json");
+  try {
+    if (!await fs5.pathExists(cachePath)) {
+      return null;
+    }
+    const stats = await fs5.stat(cachePath);
+    const age = Date.now() - stats.mtimeMs;
+    if (age > CACHE_TTL_MS) {
+      return null;
+    }
+    const content = await fs5.readJson(cachePath);
+    return RegistrySchema.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function cacheRegistry(registry) {
+  const cacheDir = getCacheDir();
+  const cachePath = path5.join(cacheDir, "registry.json");
+  try {
+    await fs5.ensureDir(cacheDir);
+    await fs5.writeJson(cachePath, registry);
+  } catch {
+  }
+}
+async function loadLocalRegistry() {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = path5.dirname(__filename2);
+  const possiblePaths = [
+    // From source: cli/src/lib -> cli/registry
+    path5.join(__dirname2, "..", "..", "registry", "registry.json"),
+    // From dist: cli/dist -> cli/registry  
+    path5.join(__dirname2, "..", "registry", "registry.json"),
+    // Direct path from built bundle
+    path5.resolve(__dirname2, "..", "registry", "registry.json")
+  ];
+  for (const registryPath of possiblePaths) {
+    if (await fs5.pathExists(registryPath)) {
+      const content = await fs5.readJson(registryPath);
+      return RegistrySchema.parse(content);
+    }
+  }
+  throw new Error(`Local registry not found. Tried: ${possiblePaths.join(", ")}`);
+}
+async function loadLocalTemplateFile(filePath) {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = path5.dirname(__filename2);
+  const possiblePaths = [
+    path5.join(__dirname2, "..", "..", "registry", "templates", filePath),
+    path5.join(__dirname2, "..", "registry", "templates", filePath)
+  ];
+  for (const templatePath of possiblePaths) {
+    if (await fs5.pathExists(templatePath)) {
+      return fs5.readFile(templatePath, "utf-8");
+    }
+  }
+  return null;
+}
+async function getRegistry() {
+  const cached = await getCachedRegistry();
+  if (cached) {
+    return cached;
+  }
+  try {
+    const local = await loadLocalRegistry();
+    return local;
+  } catch {
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(REGISTRY_URL, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const remote = RegistrySchema.parse(data);
+    await cacheRegistry(remote);
+    return remote;
+  } catch (error) {
+    throw new Error(`Failed to load registry: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getComponent(name) {
+  const registry = await getRegistry();
+  return registry.components[name] || null;
+}
+async function listComponents() {
+  const registry = await getRegistry();
+  return Object.keys(registry.components);
+}
+async function fetchTemplateFile(filePath) {
+  const local = await loadLocalTemplateFile(filePath);
+  if (local) {
+    return local;
+  }
+  const registry = await getRegistry();
+  const url = `${registry.baseUrl}/${filePath}`;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 5e3);
+  const response = await fetch(url, { signal: controller.signal });
+  clearTimeout(timeoutId);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch template: ${url} (${response.status})`);
+  }
+  return response.text();
+}
+async function fetchComponentFiles(componentName) {
+  const component = await getComponent(componentName);
+  if (!component) {
+    throw new Error(`Component not found: ${componentName}`);
+  }
+  const files = /* @__PURE__ */ new Map();
+  for (const filePath of component.files) {
+    const content = await fetchTemplateFile(filePath);
+    files.set(filePath, content);
+  }
+  return files;
+}
+
+// src/commands/add.ts
+async function add(componentName, options) {
+  console.clear();
+  p2.intro(chalk2.bgCyan.black(` \u{1FA9B} yantr add ${componentName} `));
+  try {
+    const cwd = process.cwd();
+    if (!await configExists(cwd)) {
+      p2.log.error("yantr.json not found.");
+      p2.log.info("Please run " + chalk2.cyan("yantr init") + " first.");
+      p2.outro(chalk2.red("Add cancelled."));
+      process.exit(1);
+    }
+    const config = await readConfig(cwd);
+    const spinner4 = p2.spinner();
+    spinner4.start("Fetching component registry...");
+    const availableComponents = await listComponents();
+    if (!availableComponents.includes(componentName)) {
+      spinner4.stop("Component not found");
+      p2.log.error(`Unknown component: ${chalk2.red(componentName)}`);
+      p2.log.info(`Available components: ${chalk2.cyan(availableComponents.join(", "))}`);
+      p2.outro(chalk2.red("Add cancelled."));
+      process.exit(1);
+    }
+    const alreadyInstalled = await isComponentInstalled(cwd, componentName);
+    if (alreadyInstalled && !options.overwrite) {
+      spinner4.stop("Component already installed");
+      const overwrite = await p2.confirm({
+        message: `${componentName} is already installed. Overwrite?`,
+        initialValue: false
+      });
+      if (p2.isCancel(overwrite) || !overwrite) {
+        p2.outro(chalk2.yellow("Add cancelled."));
+        process.exit(0);
+      }
+    }
+    spinner4.start(`Downloading ${componentName}...`);
+    const component = await getComponent(componentName);
+    if (!component) {
+      spinner4.stop("Failed to fetch component");
+      p2.log.error("Failed to get component metadata");
+      process.exit(1);
+    }
+    const files = await fetchComponentFiles(componentName);
+    spinner4.stop(`Downloaded ${files.size} files`);
+    spinner4.start("Installing files...");
+    const installedFiles = [];
+    const baseDir = path6.join(cwd, config.srcDir, "lib", "yantr");
+    for (const [filePath, content] of files) {
+      const fileName = path6.basename(filePath);
+      const targetPath = path6.join(baseDir, componentName, fileName);
+      if (await fileExists(targetPath) && !options.overwrite && !alreadyInstalled) {
+        const shouldOverwrite = await p2.confirm({
+          message: `File ${fileName} already exists. Overwrite?`,
+          initialValue: false
+        });
+        if (p2.isCancel(shouldOverwrite) || !shouldOverwrite) {
+          continue;
+        }
+      }
+      await writeFile(targetPath, content);
+      installedFiles.push(path6.relative(cwd, targetPath));
+    }
+    spinner4.stop("Files installed");
+    if (component.dependencies.length > 0 || component.devDependencies.length > 0) {
+      spinner4.start("Installing dependencies...");
+      try {
+        if (component.dependencies.length > 0) {
+          await installDependencies(
+            config.packageManager,
+            component.dependencies,
+            cwd,
+            false
+          );
+        }
+        if (component.devDependencies.length > 0) {
+          await installDependencies(
+            config.packageManager,
+            component.devDependencies,
+            cwd,
+            true
+          );
+        }
+        spinner4.stop("Dependencies installed");
+      } catch (error) {
+        spinner4.stop("Could not install dependencies automatically");
+        if (component.dependencies.length > 0) {
+          p2.log.warning(
+            `Please run: ${chalk2.cyan(`${config.packageManager} add ${component.dependencies.join(" ")}`)}`
+          );
+        }
+        if (component.devDependencies.length > 0) {
+          p2.log.warning(
+            `Please run: ${chalk2.cyan(`${config.packageManager} add -D ${component.devDependencies.join(" ")}`)}`
+          );
+        }
+      }
+    }
+    await addInstalledComponent(cwd, componentName);
+    const filesNote = installedFiles.map((f) => `${chalk2.green("\u2713")} ${f}`).join("\n");
+    p2.note(filesNote, "Files created");
+    if (component.dependencies.length > 0) {
+      p2.log.info(`Dependencies: ${chalk2.cyan(component.dependencies.join(", "))}`);
+    }
+    const usageHints = {
+      auth: [
+        `Import auth routes: ${chalk2.gray(`import authRoutes from '${config.srcDir}/lib/yantr/auth/auth.routes';`)}`,
+        `Add to app: ${chalk2.gray('app.use("/api/auth", authRoutes);')}`
+      ],
+      logger: [
+        `Import logger: ${chalk2.gray(`import { logger } from '${config.srcDir}/lib/yantr/logger/logger';`)}`,
+        `Use HTTP logging: ${chalk2.gray("app.use(httpLogger);")}`
+      ],
+      database: [
+        `Import prisma: ${chalk2.gray(`import { prisma } from '${config.srcDir}/lib/yantr/database/prisma';`)}`,
+        `Initialize: ${chalk2.gray("npx prisma init")}`
+      ],
+      security: [
+        `Import security: ${chalk2.gray(`import { rateLimiter, helmetConfig } from '${config.srcDir}/lib/yantr/security';`)}`,
+        `Add to app: ${chalk2.gray("app.use(helmetConfig); app.use(rateLimiter);")}`
+      ]
+    };
+    if (usageHints[componentName]) {
+      p2.log.info("Usage:");
+      usageHints[componentName].forEach((hint, i) => {
+        console.log(`  ${i + 1}. ${hint}`);
+      });
+    }
+    p2.outro(chalk2.green(`${component.name} added successfully! \u{1F309}`));
+  } catch (error) {
+    p2.log.error(`Failed: ${error instanceof Error ? error.message : String(error)}`);
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+import * as p3 from "@clack/prompts";
+import chalk3 from "chalk";
+import path7 from "path";
+async function generate(type, name, _options) {
+  console.clear();
+  p3.intro(chalk3.bgCyan.black(` \u{1FA9B} yantr generate ${type} ${name} `));
+  try {
+    const cwd = process.cwd();
+    if (!await configExists(cwd)) {
+      p3.log.error("yantr.json not found.");
+      p3.log.info("Please run " + chalk3.cyan("yantr init") + " first.");
+      p3.outro(chalk3.red("Generate cancelled."));
+      process.exit(1);
+    }
+    const config = await readConfig(cwd);
+    const validTypes = ["route"];
+    if (!validTypes.includes(type)) {
+      p3.log.error(`Unknown type: ${chalk3.red(type)}`);
+      p3.log.info(`Available types: ${chalk3.cyan(validTypes.join(", "))}`);
+      p3.outro(chalk3.red("Generate cancelled."));
+      process.exit(1);
+    }
+    if (type === "route") {
+      await generateRoute(cwd, config.srcDir, name);
+    }
+    p3.outro(chalk3.green(`Generated ${type} "${name}" successfully! \u{1FA9B}`));
+  } catch (error) {
+    p3.log.error(`Failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+async function generateRoute(cwd, srcDir, name) {
+  const spinner4 = p3.spinner();
+  const normalizedName = name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  const pascalName = toPascalCase(normalizedName);
+  const camelName = toCamelCase(normalizedName);
+  const baseDir = path7.join(cwd, srcDir);
+  const routesDir = path7.join(baseDir, "routes");
+  const controllersDir = path7.join(baseDir, "controllers");
+  const servicesDir = path7.join(baseDir, "services");
+  const files = {
+    route: path7.join(routesDir, `${normalizedName}.routes.ts`),
+    controller: path7.join(controllersDir, `${normalizedName}.controller.ts`),
+    service: path7.join(servicesDir, `${normalizedName}.service.ts`)
+  };
+  for (const [type, filePath] of Object.entries(files)) {
+    if (await fileExists(filePath)) {
+      const overwrite = await p3.confirm({
+        message: `${type} file already exists. Overwrite?`,
+        initialValue: false
+      });
+      if (p3.isCancel(overwrite) || !overwrite) {
+        p3.outro(chalk3.yellow("Generate cancelled."));
+        process.exit(0);
+      }
+    }
+  }
+  spinner4.start("Generating files...");
+  const serviceContent = generateServiceTemplate(pascalName, camelName);
+  await writeFile(files.service, serviceContent);
+  const controllerContent = generateControllerTemplate(pascalName, camelName, normalizedName);
+  await writeFile(files.controller, controllerContent);
+  const routeContent = generateRouteTemplate(pascalName, camelName, normalizedName);
+  await writeFile(files.route, routeContent);
+  spinner4.stop("Files generated");
+  const createdFiles = Object.values(files).map(
+    (f) => `${chalk3.green("\u2713")} ${path7.relative(cwd, f)}`
+  ).join("\n");
+  p3.note(createdFiles, "Files created");
+  p3.log.info("Add to your app:");
+  console.log(chalk3.gray(`  import ${camelName}Routes from './${srcDir}/routes/${normalizedName}.routes';`));
+  console.log(chalk3.gray(`  app.use('/api/${normalizedName}', ${camelName}Routes);`));
+}
+function generateServiceTemplate(pascalName, _camelName) {
+  return `/**
+ * ${pascalName} Service
+ * 
+ * Business logic for ${pascalName.toLowerCase()} operations.
+ */
+
+export interface ${pascalName} {
+  id: string;
+  // Add your fields here
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface Create${pascalName}Input {
+  // Add your input fields here
+}
+
+export interface Update${pascalName}Input {
+  // Add your update fields here
+}
+
+/**
+ * Get all ${pascalName.toLowerCase()}s
+ */
+export async function getAll(): Promise<${pascalName}[]> {
+  // TODO: Implement database query
+  // Example: return prisma.${_camelName}.findMany();
+  return [];
+}
+
+/**
+ * Get ${pascalName.toLowerCase()} by ID
+ */
+export async function getById(id: string): Promise<${pascalName} | null> {
+  // TODO: Implement database query
+  // Example: return prisma.${_camelName}.findUnique({ where: { id } });
+  return null;
+}
+
+/**
+ * Create a new ${pascalName.toLowerCase()}
+ */
+export async function create(input: Create${pascalName}Input): Promise<${pascalName}> {
+  // TODO: Implement database insert
+  // Example: return prisma.${_camelName}.create({ data: input });
+  throw new Error('Not implemented');
+}
+
+/**
+ * Update ${pascalName.toLowerCase()} by ID
+ */
+export async function update(id: string, input: Update${pascalName}Input): Promise<${pascalName}> {
+  // TODO: Implement database update
+  // Example: return prisma.${_camelName}.update({ where: { id }, data: input });
+  throw new Error('Not implemented');
+}
+
+/**
+ * Delete ${pascalName.toLowerCase()} by ID
+ */
+export async function remove(id: string): Promise<void> {
+  // TODO: Implement database delete
+  // Example: await prisma.${_camelName}.delete({ where: { id } });
+  throw new Error('Not implemented');
+}
+`;
+}
+function generateControllerTemplate(pascalName, camelName, normalizedName) {
+  return `import type { Request, Response } from 'express';
+import { z } from 'zod';
+import * as ${camelName}Service from '../services/${normalizedName}.service';
+import { asyncHandler } from '../lib/yantr/error-handler';
+import { NotFoundError } from '../lib/yantr/error-handler';
+
+/**
+ * ${pascalName} Controller
+ * 
+ * Request handlers for ${pascalName.toLowerCase()} endpoints.
+ */
+
+// Validation schemas
+export const create${pascalName}Schema = z.object({
+  // Add your validation rules here
+});
+
+export const update${pascalName}Schema = z.object({
+  // Add your validation rules here
+});
+
+/**
+ * GET /api/${normalizedName}
+ * Get all ${pascalName.toLowerCase()}s
+ */
+export const getAll = asyncHandler(async (_req: Request, res: Response) => {
+  const items = await ${camelName}Service.getAll();
+  
+  res.json({
+    success: true,
+    data: items,
+  });
+});
+
+/**
+ * GET /api/${normalizedName}/:id
+ * Get ${pascalName.toLowerCase()} by ID
+ */
+export const getById = asyncHandler(async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const item = await ${camelName}Service.getById(id);
+  
+  if (!item) {
+    throw new NotFoundError('${pascalName} not found');
+  }
+  
+  res.json({
+    success: true,
+    data: item,
+  });
+});
+
+/**
+ * POST /api/${normalizedName}
+ * Create a new ${pascalName.toLowerCase()}
+ */
+export const create = asyncHandler(async (req: Request, res: Response) => {
+  const input = create${pascalName}Schema.parse(req.body);
+  const item = await ${camelName}Service.create(input);
+  
+  res.status(201).json({
+    success: true,
+    data: item,
+    message: '${pascalName} created successfully',
+  });
+});
+
+/**
+ * PUT /api/${normalizedName}/:id
+ * Update ${pascalName.toLowerCase()} by ID
+ */
+export const update = asyncHandler(async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const input = update${pascalName}Schema.parse(req.body);
+  const item = await ${camelName}Service.update(id, input);
+  
+  res.json({
+    success: true,
+    data: item,
+    message: '${pascalName} updated successfully',
+  });
+});
+
+/**
+ * DELETE /api/${normalizedName}/:id
+ * Delete ${pascalName.toLowerCase()} by ID
+ */
+export const remove = asyncHandler(async (req: Request, res: Response) => {
+  const { id } = req.params;
+  await ${camelName}Service.remove(id);
+  
+  res.json({
+    success: true,
+    message: '${pascalName} deleted successfully',
+  });
+});
+`;
+}
+function generateRouteTemplate(pascalName, camelName, normalizedName) {
+  return `import { Router } from 'express';
+import * as ${camelName}Controller from '../controllers/${normalizedName}.controller';
+import { validateBody } from '../lib/yantr/zod-middleware';
+import { 
+  create${pascalName}Schema, 
+  update${pascalName}Schema 
+} from '../controllers/${normalizedName}.controller';
+
+const router = Router();
+
+/**
+ * ${pascalName} Routes
+ * 
+ * GET    /api/${normalizedName}      - Get all ${pascalName.toLowerCase()}s
+ * GET    /api/${normalizedName}/:id  - Get ${pascalName.toLowerCase()} by ID
+ * POST   /api/${normalizedName}      - Create ${pascalName.toLowerCase()}
+ * PUT    /api/${normalizedName}/:id  - Update ${pascalName.toLowerCase()}
+ * DELETE /api/${normalizedName}/:id  - Delete ${pascalName.toLowerCase()}
+ */
+
+router.get('/', ${camelName}Controller.getAll);
+router.get('/:id', ${camelName}Controller.getById);
+router.post('/', validateBody(create${pascalName}Schema), ${camelName}Controller.create);
+router.put('/:id', validateBody(update${pascalName}Schema), ${camelName}Controller.update);
+router.delete('/:id', ${camelName}Controller.remove);
+
+export default router;
+`;
+}
+function toPascalCase(str) {
+  return str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("yantr").description("A Shadcn for Backend - Production-grade backend scaffolding CLI").version("0.1.0-beta.2");
+program.command("init").description("Initialize Setu in your project").option("-y, --yes", "Skip prompts and use defaults").action(init);
+program.command("add").description("Add a component to your project").argument("<component>", "Component to add (auth, logger, database, security)").option("-o, --overwrite", "Overwrite existing files").action(add);
+program.command("generate").alias("g").description("Generate boilerplate code").argument("<type>", "Type of code to generate (route)").argument("<name>", "Name of the resource").action(generate);
+program.parse();
+//# sourceMappingURL=index.js.map