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

package/dist/index.js

@@ -690,7 +690,8 @@ var BLOCK_SIGNATURES = {
   "error-handler": "lib/errors.ts",
   logger: "lib/logger.ts",
   auth: "lib/auth.ts",
-  mailer: "lib/mailer.ts"
+  mailer: "lib/mailer.ts",
+  docs: "lib/openapi.ts"
 };
 var resolveDependencies = async (moduleDependencies, cwd) => {
   if (!moduleDependencies || moduleDependencies.length === 0) {
@@ -841,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)) {
@@ -878,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)) {
@@ -940,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) {
@@ -1044,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) {
@@ -1069,6 +1246,7 @@ var add = async (moduleName) => {
   let customSmtpVars;
   let usedDefaultSmtp = false;
   let mailerProvider = "smtp";
+  let shouldInstallDocsForAuth = false;
   if (resolvedModuleName === "database") {
     const variantResponse = await (0, import_prompts2.default)({
       type: "select",
@@ -1226,6 +1404,26 @@ var add = async (moduleName) => {
       }
     }
   }
+  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";
@@ -1308,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...");
@@ -1318,6 +1526,25 @@ var add = async (moduleName) => {
         spinner.warn("Could not find app.ts - error handler needs manual setup");
       }
     }
+    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";
@@ -1382,6 +1609,14 @@ var add = async (moduleName) => {
         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);
@@ -1396,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