zuro-cli 0.0.2-beta.11 → 0.0.2-beta.13

package/dist/index.js

@@ -357,6 +357,32 @@ var ENV_CONFIGS = {
       { name: "BETTER_AUTH_SECRET", schema: "z.string().min(32)" },
       { name: "BETTER_AUTH_URL", schema: "z.string().url()" }
     ]
+  },
+  mailer: {
+    envVars: {
+      SMTP_HOST: "smtp.example.com",
+      SMTP_PORT: "587",
+      SMTP_USER: "your-email@example.com",
+      SMTP_PASS: "your-password",
+      MAIL_FROM: "noreply@example.com"
+    },
+    schemaFields: [
+      { name: "SMTP_HOST", schema: "z.string().min(1)" },
+      { name: "SMTP_PORT", schema: "z.coerce.number().default(587)" },
+      { name: "SMTP_USER", schema: "z.string().min(1)" },
+      { name: "SMTP_PASS", schema: "z.string().min(1)" },
+      { name: "MAIL_FROM", schema: "z.string().email()" }
+    ]
+  },
+  "mailer-resend": {
+    envVars: {
+      RESEND_API_KEY: "re_your_api_key",
+      MAIL_FROM: "onboarding@resend.dev"
+    },
+    schemaFields: [
+      { name: "RESEND_API_KEY", schema: "z.string().min(1)" },
+      { name: "MAIL_FROM", schema: "z.string().min(1)" }
+    ]
   }
 };
 
@@ -663,7 +689,9 @@ var BLOCK_SIGNATURES = {
   validator: "middleware/validate.ts",
   "error-handler": "lib/errors.ts",
   logger: "lib/logger.ts",
-  auth: "lib/auth.ts"
+  auth: "lib/auth.ts",
+  mailer: "lib/mailer.ts",
+  docs: "lib/openapi.ts"
 };
 var resolveDependencies = async (moduleDependencies, cwd) => {
   if (!moduleDependencies || moduleDependencies.length === 0) {
@@ -814,6 +842,25 @@ function getModuleDocsPath(moduleName) {
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function appendImport(source, line) {
+  if (source.includes(line)) {
+    return { source, inserted: true };
+  }
+  const importRegex = /^import .+ from .+;?\s*$/gm;
+  let lastImportIndex = 0;
+  let match;
+  while ((match = importRegex.exec(source)) !== null) {
+    lastImportIndex = match.index + match[0].length;
+  }
+  if (lastImportIndex <= 0) {
+    return { source, inserted: false };
+  }
+  return {
+    source: source.slice(0, lastImportIndex) + `
+${line}` + source.slice(lastImportIndex),
+    inserted: true
+  };
+}
 async function hasEnvVariable(projectRoot, key) {
   const envPath = import_path6.default.join(projectRoot, ".env");
   if (!await import_fs_extra6.default.pathExists(envPath)) {
@@ -851,6 +898,12 @@ async function ensureSchemaExport(projectRoot, srcDir, schemaFileName) {
 `;
   await import_fs_extra6.default.writeFile(schemaIndexPath, next);
 }
+async function isDocsModuleInstalled(projectRoot, srcDir) {
+  return await import_fs_extra6.default.pathExists(import_path6.default.join(projectRoot, srcDir, "lib", "openapi.ts"));
+}
+async function isAuthModuleInstalled(projectRoot, srcDir) {
+  return await import_fs_extra6.default.pathExists(import_path6.default.join(projectRoot, srcDir, "lib", "auth.ts"));
+}
 async function injectErrorHandler(projectRoot, srcDir) {
   const appPath = import_path6.default.join(projectRoot, srcDir, "app.ts");
   if (!import_fs_extra6.default.existsSync(appPath)) {
@@ -913,25 +966,6 @@ async function injectAuthRoutes(projectRoot, srcDir) {
   const routeIndexUserImport = `import userRoutes from "./user.routes";`;
   const appUserImport = `import userRoutes from "./routes/user.routes";`;
   let appModified = false;
-  const appendImport = (source, line) => {
-    if (source.includes(line)) {
-      return { source, inserted: true };
-    }
-    const importRegex = /^import .+ from .+;?\s*$/gm;
-    let lastImportIndex = 0;
-    let match;
-    while ((match = importRegex.exec(source)) !== null) {
-      lastImportIndex = match.index + match[0].length;
-    }
-    if (lastImportIndex <= 0) {
-      return { source, inserted: false };
-    }
-    return {
-      source: source.slice(0, lastImportIndex) + `
-${line}` + source.slice(lastImportIndex),
-      inserted: true
-    };
-  };
   for (const importLine of [authHandlerImport, authImport]) {
     const next = appendImport(appContent, importLine);
     if (!next.inserted) {
@@ -1017,7 +1051,177 @@ app.use("/api/users", userRoutes);
   }
   return true;
 }
-var add = async (moduleName) => {
+async function injectDocsRoutes(projectRoot, srcDir) {
+  const routeIndexPath = import_path6.default.join(projectRoot, srcDir, "routes", "index.ts");
+  const routeImport = `import docsRoutes from "./docs.routes";`;
+  const routeMountPattern = /rootRouter\.use\(\s*["']\/docs["']\s*,\s*docsRoutes\s*\)/;
+  if (await import_fs_extra6.default.pathExists(routeIndexPath)) {
+    let routeContent = await import_fs_extra6.default.readFile(routeIndexPath, "utf-8");
+    let routeModified = false;
+    const importResult = appendImport(routeContent, routeImport);
+    if (!importResult.inserted) {
+      return false;
+    }
+    if (importResult.source !== routeContent) {
+      routeContent = importResult.source;
+      routeModified = true;
+    }
+    if (!routeMountPattern.test(routeContent)) {
+      const routeSetup = `
+// API docs
+rootRouter.use("/docs", docsRoutes);
+`;
+      const exportMatch = routeContent.match(/export default rootRouter;?\s*$/m);
+      if (!exportMatch || exportMatch.index === void 0) {
+        return false;
+      }
+      routeContent = routeContent.slice(0, exportMatch.index) + routeSetup + "\n" + routeContent.slice(exportMatch.index);
+      routeModified = true;
+    }
+    if (routeModified) {
+      await import_fs_extra6.default.writeFile(routeIndexPath, routeContent);
+    }
+    return true;
+  }
+  const appPath = import_path6.default.join(projectRoot, srcDir, "app.ts");
+  if (!await import_fs_extra6.default.pathExists(appPath)) {
+    return false;
+  }
+  let appContent = await import_fs_extra6.default.readFile(appPath, "utf-8");
+  let appModified = false;
+  const appImportResult = appendImport(appContent, `import docsRoutes from "./routes/docs.routes";`);
+  if (!appImportResult.inserted) {
+    return false;
+  }
+  if (appImportResult.source !== appContent) {
+    appContent = appImportResult.source;
+    appModified = true;
+  }
+  const hasMount = /app\.use\(\s*["']\/api\/docs["']\s*,\s*docsRoutes\s*\)/.test(appContent);
+  if (!hasMount) {
+    const setup = `
+// API docs
+app.use("/api/docs", docsRoutes);
+`;
+    const exportMatch = appContent.match(/export default app;?\s*$/m);
+    if (!exportMatch || exportMatch.index === void 0) {
+      return false;
+    }
+    appContent = appContent.slice(0, exportMatch.index) + setup + "\n" + appContent.slice(exportMatch.index);
+    appModified = true;
+  }
+  if (appModified) {
+    await import_fs_extra6.default.writeFile(appPath, appContent);
+  }
+  return true;
+}
+async function injectAuthDocs(projectRoot, srcDir) {
+  const openApiPath = import_path6.default.join(projectRoot, srcDir, "lib", "openapi.ts");
+  if (!await import_fs_extra6.default.pathExists(openApiPath)) {
+    return false;
+  }
+  const authMarker = "// ZURO_AUTH_DOCS";
+  let content = await import_fs_extra6.default.readFile(openApiPath, "utf-8");
+  if (content.includes(authMarker)) {
+    return true;
+  }
+  const moduleDocsEndMarker = "// ZURO_DOCS_MODULES_END";
+  if (!content.includes(moduleDocsEndMarker)) {
+    return false;
+  }
+  const authBlock = `
+const authSignUpSchema = z.object({
+    email: z.string().email().openapi({ example: "dev@company.com" }),
+    password: z.string().min(8).openapi({ example: "strong-password" }),
+    name: z.string().min(1).optional().openapi({ example: "Dev User" }),
+});
+
+const authSignInSchema = z.object({
+    email: z.string().email().openapi({ example: "dev@company.com" }),
+    password: z.string().min(8).openapi({ example: "strong-password" }),
+});
+
+const authUserSchema = z.object({
+    id: z.string().openapi({ example: "user_123" }),
+    email: z.string().email().openapi({ example: "dev@company.com" }),
+    name: z.string().nullable().openapi({ example: "Dev User" }),
+});
+
+${authMarker}
+registry.registerPath({
+    method: "post",
+    path: "/api/auth/sign-up/email",
+    tags: ["Auth"],
+    summary: "Register using email and password",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: authSignUpSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        200: { description: "Registration successful" },
+    },
+});
+
+registry.registerPath({
+    method: "post",
+    path: "/api/auth/sign-in/email",
+    tags: ["Auth"],
+    summary: "Sign in using email and password",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: authSignInSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        200: { description: "Sign in successful" },
+        401: { description: "Invalid credentials" },
+    },
+});
+
+registry.registerPath({
+    method: "post",
+    path: "/api/auth/sign-out",
+    tags: ["Auth"],
+    summary: "Sign out current user",
+    responses: {
+        200: { description: "Sign out successful" },
+    },
+});
+
+registry.registerPath({
+    method: "get",
+    path: "/api/users/me",
+    tags: ["Auth"],
+    summary: "Get current authenticated user",
+    security: [{ bearerAuth: [] }],
+    responses: {
+        200: {
+            description: "Current user",
+            content: {
+                "application/json": {
+                    schema: z.object({ user: authUserSchema }),
+                },
+            },
+        },
+        401: { description: "Not authenticated" },
+    },
+});
+`;
+  content = content.replace(moduleDocsEndMarker, `${authBlock}
+${moduleDocsEndMarker}`);
+  await import_fs_extra6.default.writeFile(openApiPath, content);
+  return true;
+}
+var add = async (moduleName, options = {}) => {
   const projectRoot = process.cwd();
   const projectConfig = await readZuroConfig(projectRoot);
   if (!projectConfig) {
@@ -1039,6 +1243,10 @@ var add = async (moduleName) => {
   let databaseBackupPath = null;
   let generatedAuthSecret = false;
   let authDatabaseDialect = null;
+  let customSmtpVars;
+  let usedDefaultSmtp = false;
+  let mailerProvider = "smtp";
+  let shouldInstallDocsForAuth = false;
   if (resolvedModuleName === "database") {
     const variantResponse = await (0, import_prompts2.default)({
       type: "select",
@@ -1099,6 +1307,123 @@ var add = async (moduleName) => {
     usedDefaultDbUrl = enteredUrl.length === 0;
     customDbUrl = validateDatabaseUrl(enteredUrl || defaultUrl, resolvedModuleName);
   }
+  if (resolvedModuleName === "mailer") {
+    const providerResponse = await (0, import_prompts2.default)({
+      type: "select",
+      name: "provider",
+      message: "Which email provider?",
+      choices: [
+        { title: "SMTP (Nodemailer)", description: "Gmail, Mailtrap, any SMTP server", value: "smtp" },
+        { title: "Resend", description: "API-based, easiest setup", value: "resend" }
+      ]
+    });
+    if (providerResponse.provider === void 0) {
+      console.log(import_chalk4.default.yellow("Operation cancelled."));
+      return;
+    }
+    mailerProvider = providerResponse.provider;
+    console.log(import_chalk4.default.dim("  Tip: Leave fields blank to use placeholder values and configure later\n"));
+    if (mailerProvider === "smtp") {
+      const smtpResponse = await (0, import_prompts2.default)([
+        {
+          type: "text",
+          name: "host",
+          message: "SMTP Host",
+          initial: ""
+        },
+        {
+          type: "text",
+          name: "port",
+          message: "SMTP Port",
+          initial: "587"
+        },
+        {
+          type: "text",
+          name: "user",
+          message: "SMTP User",
+          initial: ""
+        },
+        {
+          type: "password",
+          name: "pass",
+          message: "SMTP Password"
+        },
+        {
+          type: "text",
+          name: "from",
+          message: "Mail From address",
+          initial: ""
+        }
+      ]);
+      if (smtpResponse.host === void 0) {
+        console.log(import_chalk4.default.yellow("Operation cancelled."));
+        return;
+      }
+      const host = smtpResponse.host?.trim() || "";
+      const user = smtpResponse.user?.trim() || "";
+      const pass = smtpResponse.pass?.trim() || "";
+      const from = smtpResponse.from?.trim() || "";
+      const port = smtpResponse.port?.trim() || "587";
+      usedDefaultSmtp = !host && !user;
+      if (!usedDefaultSmtp) {
+        customSmtpVars = {
+          SMTP_HOST: host || "smtp.example.com",
+          SMTP_PORT: port,
+          SMTP_USER: user || "your-email@example.com",
+          SMTP_PASS: pass || "your-password",
+          MAIL_FROM: from || "noreply@example.com"
+        };
+      }
+    } else {
+      const resendResponse = await (0, import_prompts2.default)([
+        {
+          type: "text",
+          name: "apiKey",
+          message: "Resend API Key",
+          initial: ""
+        },
+        {
+          type: "text",
+          name: "from",
+          message: "Mail From address",
+          initial: ""
+        }
+      ]);
+      if (resendResponse.apiKey === void 0) {
+        console.log(import_chalk4.default.yellow("Operation cancelled."));
+        return;
+      }
+      const apiKey = resendResponse.apiKey?.trim() || "";
+      const from = resendResponse.from?.trim() || "";
+      usedDefaultSmtp = !apiKey;
+      if (!usedDefaultSmtp) {
+        customSmtpVars = {
+          RESEND_API_KEY: apiKey || "re_your_api_key",
+          MAIL_FROM: from || "onboarding@resend.dev"
+        };
+      }
+    }
+  }
+  if (resolvedModuleName === "auth") {
+    const docsInstalled = await isDocsModuleInstalled(projectRoot, srcDir);
+    if (!docsInstalled) {
+      if (options.yes) {
+        shouldInstallDocsForAuth = true;
+      } else {
+        const docsResponse = await (0, import_prompts2.default)({
+          type: "confirm",
+          name: "installDocs",
+          message: "Install API docs module (Scalar + OpenAPI) too?",
+          initial: true
+        });
+        if (docsResponse.installDocs === void 0) {
+          console.log(import_chalk4.default.yellow("Operation cancelled."));
+          return;
+        }
+        shouldInstallDocsForAuth = docsResponse.installDocs;
+      }
+    }
+  }
   const pm = resolvePackageManager(projectRoot);
   const spinner = (0, import_ora2.default)(`Checking registry for ${resolvedModuleName}...`).start();
   let currentStep = "package manager preflight";
@@ -1119,8 +1444,19 @@ var add = async (moduleName) => {
     await resolveDependencies(moduleDeps, projectRoot);
     currentStep = "dependency installation";
     spinner.start("Installing dependencies...");
-    await installDependencies(pm, module2.dependencies || [], projectRoot);
-    await installDependencies(pm, module2.devDependencies || [], projectRoot, { dev: true });
+    let runtimeDeps = module2.dependencies || [];
+    let devDeps = module2.devDependencies || [];
+    if (resolvedModuleName === "mailer") {
+      if (mailerProvider === "resend") {
+        runtimeDeps = ["resend"];
+        devDeps = [];
+      } else {
+        runtimeDeps = ["nodemailer"];
+        devDeps = ["@types/nodemailer"];
+      }
+    }
+    await installDependencies(pm, runtimeDeps, projectRoot);
+    await installDependencies(pm, devDeps, projectRoot, { dev: true });
     spinner.succeed("Dependencies installed");
     currentStep = "module scaffolding";
     spinner.start("Scaffolding files...");
@@ -1136,6 +1472,11 @@ var add = async (moduleName) => {
         expectedSha256 = void 0;
         expectedSize = void 0;
       }
+      if (resolvedModuleName === "mailer" && file.target === "lib/mailer.ts" && mailerProvider === "resend") {
+        fetchPath = "express/lib/mailer.resend.ts";
+        expectedSha256 = void 0;
+        expectedSize = void 0;
+      }
       let content = await fetchFile(fetchPath, {
         baseUrl: registryContext.fileBaseUrl,
         expectedSha256,
@@ -1165,6 +1506,16 @@ var add = async (moduleName) => {
       } else {
         spinner.warn("Could not configure routes automatically");
       }
+      const docsInstalled = await isDocsModuleInstalled(projectRoot, srcDir);
+      if (docsInstalled) {
+        spinner.start("Adding auth endpoints to API docs...");
+        const authDocsInjected = await injectAuthDocs(projectRoot, srcDir);
+        if (authDocsInjected) {
+          spinner.succeed("Auth endpoints added to API docs");
+        } else {
+          spinner.warn("Could not update API docs automatically");
+        }
+      }
     }
     if (resolvedModuleName === "error-handler") {
       spinner.start("Configuring error handler in app.ts...");
@@ -1175,7 +1526,30 @@ var add = async (moduleName) => {
         spinner.warn("Could not find app.ts - error handler needs manual setup");
       }
     }
-    const envConfig = ENV_CONFIGS[resolvedModuleName];
+    if (resolvedModuleName === "docs") {
+      spinner.start("Configuring docs routes...");
+      const injected = await injectDocsRoutes(projectRoot, srcDir);
+      if (injected) {
+        spinner.succeed("Docs routes configured");
+      } else {
+        spinner.warn("Could not configure docs routes automatically");
+      }
+      const authInstalled = await isAuthModuleInstalled(projectRoot, srcDir);
+      if (authInstalled) {
+        spinner.start("Adding auth endpoints to API docs...");
+        const authDocsInjected = await injectAuthDocs(projectRoot, srcDir);
+        if (authDocsInjected) {
+          spinner.succeed("Auth endpoints added to API docs");
+        } else {
+          spinner.warn("Could not update API docs automatically");
+        }
+      }
+    }
+    let envConfigKey = resolvedModuleName;
+    if (resolvedModuleName === "mailer" && mailerProvider === "resend") {
+      envConfigKey = "mailer-resend";
+    }
+    const envConfig = ENV_CONFIGS[envConfigKey];
     if (envConfig) {
       currentStep = "environment configuration";
       spinner.start("Updating environment configuration...");
@@ -1183,6 +1557,9 @@ var add = async (moduleName) => {
       if (customDbUrl && isDatabaseModule(resolvedModuleName)) {
         envVars.DATABASE_URL = customDbUrl;
       }
+      if (resolvedModuleName === "mailer" && customSmtpVars) {
+        Object.assign(envVars, customSmtpVars);
+      }
       if (resolvedModuleName === "auth") {
         const hasExistingSecret = await hasEnvVariable(projectRoot, "BETTER_AUTH_SECRET");
         if (!hasExistingSecret) {
@@ -1225,6 +1602,21 @@ var add = async (moduleName) => {
       }
       console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
     }
+    if (resolvedModuleName === "mailer") {
+      if (usedDefaultSmtp) {
+        console.log(import_chalk4.default.yellow("\u2139 Placeholder SMTP values added to .env \u2014 update them before sending emails."));
+      } else {
+        console.log(import_chalk4.default.yellow("\u2139 Review SMTP configuration in .env to ensure values are correct."));
+      }
+    }
+    if (resolvedModuleName === "docs") {
+      console.log(import_chalk4.default.yellow("\u2139 API docs available at: /api/docs"));
+      console.log(import_chalk4.default.yellow("\u2139 OpenAPI spec available at: /api/docs/openapi.json"));
+    }
+    if (resolvedModuleName === "auth" && shouldInstallDocsForAuth) {
+      console.log(import_chalk4.default.blue("\n\u2139 Installing API docs module..."));
+      await add("docs", { yes: true });
+    }
   } catch (error) {
     spinner.fail(import_chalk4.default.red(`Failed during ${currentStep}.`));
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1239,6 +1631,6 @@ ${import_chalk4.default.bold("Retry:")}`);
 var program = new import_commander.Command();
 program.name("zuro-cli").description("Zuro CLI tool").version("0.0.1");
 program.command("init").description("Initialize a new Zuro project").action(init);
-program.command("add <module>").description("Add a module to your project").action(add);
+program.command("add <module>").description("Add a module to your project").action((module2, options) => add(module2, options));
 program.parse(process.argv);
 //# sourceMappingURL=index.js.map