zuro-cli 0.0.2-beta.14 → 0.0.2-beta.16

package/dist/index.js

@@ -67,8 +67,10 @@ __export(database_handler_exports, {
   databaseLabel: () => databaseLabel,
   detectInstalledDatabaseDialect: () => detectInstalledDatabaseDialect,
   ensureSchemaExport: () => ensureSchemaExport,
+  getDatabaseSelection: () => getDatabaseSelection,
   getDatabaseSetupHint: () => getDatabaseSetupHint,
   isDatabaseModule: () => isDatabaseModule,
+  isDrizzleDatabaseModule: () => isDrizzleDatabaseModule,
   parseDatabaseDialect: () => parseDatabaseDialect,
   printDatabaseHints: () => printDatabaseHints,
   promptDatabaseConfig: () => promptDatabaseConfig,
@@ -79,18 +81,57 @@ function parseDatabaseDialect(value) {
   if (!normalized) {
     return null;
   }
-  if (normalized === "pg" || normalized === "postgres" || normalized === "postgresql" || normalized === "database-pg") {
+  if (normalized === "pg" || normalized === "postgres" || normalized === "postgresql" || normalized === "database-pg" || normalized === "drizzle-pg" || normalized === "drizzle-postgres" || normalized === "database-drizzle-pg") {
     return "database-pg";
   }
-  if (normalized === "mysql" || normalized === "database-mysql") {
+  if (normalized === "mysql" || normalized === "database-mysql" || normalized === "drizzle-mysql" || normalized === "database-drizzle-mysql") {
     return "database-mysql";
   }
+  if (normalized === "database-prisma-pg" || normalized === "prisma-pg" || normalized === "prisma-postgres" || normalized === "prisma-postgresql" || normalized === "database-prisma") {
+    return "database-prisma-pg";
+  }
+  if (normalized === "database-prisma-mysql" || normalized === "prisma-mysql") {
+    return "database-prisma-mysql";
+  }
   return null;
 }
 function isDatabaseModule(moduleName) {
+  return moduleName === "database-pg" || moduleName === "database-mysql" || moduleName === "database-prisma-pg" || moduleName === "database-prisma-mysql";
+}
+function isDrizzleDatabaseModule(moduleName) {
   return moduleName === "database-pg" || moduleName === "database-mysql";
 }
+function getDatabaseSelection(moduleName) {
+  if (moduleName === "database-pg") {
+    return { orm: "drizzle", dialect: "postgresql" };
+  }
+  if (moduleName === "database-mysql") {
+    return { orm: "drizzle", dialect: "mysql" };
+  }
+  if (moduleName === "database-prisma-pg") {
+    return { orm: "prisma", dialect: "postgresql" };
+  }
+  return { orm: "prisma", dialect: "mysql" };
+}
+function getDatabaseModule(orm, dialect) {
+  return DATABASE_MODULE_MAP[orm][dialect];
+}
+function parsePrismaProvider(schemaContent) {
+  const match = schemaContent.match(/provider\s*=\s*"([^"]+)"/);
+  if (!match) {
+    return null;
+  }
+  const provider = match[1]?.trim().toLowerCase();
+  if (provider === "mysql") {
+    return "mysql";
+  }
+  if (provider === "postgresql" || provider === "postgres") {
+    return "postgresql";
+  }
+  return null;
+}
 function validateDatabaseUrl(rawUrl, moduleName) {
+  const { dialect } = getDatabaseSelection(moduleName);
   const dbUrl = rawUrl.trim();
   if (!dbUrl) {
     throw new Error("Database URL cannot be empty.");
@@ -102,25 +143,43 @@ function validateDatabaseUrl(rawUrl, moduleName) {
     throw new Error(`Invalid database URL: '${dbUrl}'.`);
   }
   const protocol = parsed.protocol.toLowerCase();
-  if (moduleName === "database-pg" && protocol !== "postgresql:" && protocol !== "postgres:") {
+  if (dialect === "postgresql" && protocol !== "postgresql:" && protocol !== "postgres:") {
     throw new Error("PostgreSQL URL must start with postgres:// or postgresql://");
   }
-  if (moduleName === "database-mysql" && protocol !== "mysql:") {
+  if (dialect === "mysql" && protocol !== "mysql:") {
     throw new Error("MySQL URL must start with mysql://");
   }
   return dbUrl;
 }
 async function detectInstalledDatabaseDialect(projectRoot, srcDir) {
   const dbIndexPath = import_path7.default.join(projectRoot, srcDir, "db", "index.ts");
-  if (!import_fs_extra6.default.existsSync(dbIndexPath)) {
-    return null;
-  }
-  const content = await import_fs_extra6.default.readFile(dbIndexPath, "utf-8");
-  if (content.includes("drizzle-orm/node-postgres") || content.includes(`from "pg"`)) {
-    return "database-pg";
+  const prismaSchemaPath = import_path7.default.join(projectRoot, "prisma", "schema.prisma");
+  if (import_fs_extra6.default.existsSync(dbIndexPath)) {
+    const content = await import_fs_extra6.default.readFile(dbIndexPath, "utf-8");
+    if (content.includes("drizzle-orm/node-postgres") || content.includes(`from "pg"`)) {
+      return "database-pg";
+    }
+    if (content.includes("drizzle-orm/mysql2") || content.includes(`from "mysql2`)) {
+      return "database-mysql";
+    }
+    if (content.includes(`from "@prisma/client"`)) {
+      if (import_fs_extra6.default.existsSync(prismaSchemaPath)) {
+        const schemaContent = await import_fs_extra6.default.readFile(prismaSchemaPath, "utf-8");
+        const dialect = parsePrismaProvider(schemaContent);
+        if (dialect === "mysql") {
+          return "database-prisma-mysql";
+        }
+      }
+      return "database-prisma-pg";
+    }
   }
-  if (content.includes("drizzle-orm/mysql2") || content.includes(`from "mysql2`)) {
-    return "database-mysql";
+  if (import_fs_extra6.default.existsSync(prismaSchemaPath)) {
+    const schemaContent = await import_fs_extra6.default.readFile(prismaSchemaPath, "utf-8");
+    const dialect = parsePrismaProvider(schemaContent);
+    if (dialect === "mysql") {
+      return "database-prisma-mysql";
+    }
+    return "database-prisma-pg";
   }
   return null;
 }
@@ -129,7 +188,8 @@ async function backupDatabaseFiles(projectRoot, srcDir) {
   const backupRoot = import_path7.default.join(projectRoot, ".zuro", "backups", `database-${timestamp}`);
   const candidates = [
     import_path7.default.join(projectRoot, srcDir, "db", "index.ts"),
-    import_path7.default.join(projectRoot, "drizzle.config.ts")
+    import_path7.default.join(projectRoot, "drizzle.config.ts"),
+    import_path7.default.join(projectRoot, "prisma", "schema.prisma")
   ];
   let copied = false;
   for (const filePath of candidates) {
@@ -145,7 +205,10 @@ async function backupDatabaseFiles(projectRoot, srcDir) {
   return copied ? backupRoot : null;
 }
 function databaseLabel(moduleName) {
-  return moduleName === "database-pg" ? "PostgreSQL" : "MySQL";
+  const selection = getDatabaseSelection(moduleName);
+  const ormLabel = selection.orm === "drizzle" ? "Drizzle" : "Prisma";
+  const dialectLabel = selection.dialect === "postgresql" ? "PostgreSQL" : "MySQL";
+  return `${ormLabel} (${dialectLabel})`;
 }
 function getDatabaseSetupHint(moduleName, dbUrl) {
   try {
@@ -185,23 +248,42 @@ async function ensureSchemaExport(projectRoot, srcDir, schemaFileName) {
 async function promptDatabaseConfig(initialModuleName, projectRoot, srcDir) {
   let resolvedModuleName;
   if (initialModuleName === "database") {
+    const ormResponse = await (0, import_prompts2.default)({
+      type: "select",
+      name: "orm",
+      message: "Which ORM?",
+      choices: [
+        { title: "Drizzle", value: "drizzle" },
+        { title: "Prisma", value: "prisma" }
+      ],
+      initial: 0
+    });
+    if (!ormResponse.orm) {
+      console.log(import_chalk4.default.yellow("Operation cancelled."));
+      return null;
+    }
     const variantResponse = await (0, import_prompts2.default)({
       type: "select",
-      name: "variant",
+      name: "dialect",
       message: "Which database dialect?",
       choices: [
-        { title: "PostgreSQL", value: "database-pg" },
-        { title: "MySQL", value: "database-mysql" }
+        { title: "PostgreSQL", value: "postgresql" },
+        { title: "MySQL", value: "mysql" }
       ]
     });
-    if (!variantResponse.variant) {
+    if (!variantResponse.dialect) {
       console.log(import_chalk4.default.yellow("Operation cancelled."));
       return null;
     }
-    resolvedModuleName = variantResponse.variant;
+    resolvedModuleName = getDatabaseModule(ormResponse.orm, variantResponse.dialect);
   } else {
-    resolvedModuleName = initialModuleName;
+    const parsed = parseDatabaseDialect(initialModuleName);
+    if (!parsed) {
+      throw new Error(`Unsupported database module '${initialModuleName}'.`);
+    }
+    resolvedModuleName = parsed;
   }
+  const { orm: selectedOrm, dialect: selectedDialect } = getDatabaseSelection(resolvedModuleName);
   let databaseBackupPath = null;
   const installedDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
   if (installedDialect && installedDialect !== resolvedModuleName) {
@@ -245,7 +327,14 @@ async function promptDatabaseConfig(initialModuleName, projectRoot, srcDir) {
   const enteredUrl = response.dbUrl?.trim() || "";
   const usedDefaultDbUrl = enteredUrl.length === 0;
   const customDbUrl = validateDatabaseUrl(enteredUrl || defaultUrl, resolvedModuleName);
-  return { resolvedModuleName, customDbUrl, usedDefaultDbUrl, databaseBackupPath };
+  return {
+    resolvedModuleName,
+    selectedOrm,
+    selectedDialect,
+    customDbUrl,
+    usedDefaultDbUrl,
+    databaseBackupPath
+  };
 }
 function printDatabaseHints(moduleName, customDbUrl, usedDefaultDbUrl, databaseBackupPath) {
   if (databaseBackupPath) {
@@ -260,9 +349,14 @@ function printDatabaseHints(moduleName, customDbUrl, usedDefaultDbUrl, databaseB
     customDbUrl || DEFAULT_DATABASE_URLS[moduleName]
   );
   console.log(import_chalk4.default.yellow(`\u2139 Ensure DB exists: ${setupHint}`));
-  console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+  if (isDrizzleDatabaseModule(moduleName)) {
+    console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx drizzle-kit generate && npx drizzle-kit migrate"));
+    return;
+  }
+  console.log(import_chalk4.default.yellow("\u2139 Run migrations: npx prisma migrate dev --name init"));
+  console.log(import_chalk4.default.yellow("\u2139 Generate client: npx prisma generate"));
 }
-var import_path7, import_fs_extra6, import_prompts2, import_chalk4, DEFAULT_DATABASE_URLS;
+var import_path7, import_fs_extra6, import_prompts2, import_chalk4, DATABASE_MODULE_MAP, DEFAULT_DATABASE_URLS;
 var init_database_handler = __esm({
   "src/handlers/database.handler.ts"() {
     "use strict";
@@ -271,9 +365,21 @@ var init_database_handler = __esm({
     import_prompts2 = __toESM(require("prompts"));
     import_chalk4 = __toESM(require("chalk"));
     init_code_inject();
+    DATABASE_MODULE_MAP = {
+      drizzle: {
+        postgresql: "database-pg",
+        mysql: "database-mysql"
+      },
+      prisma: {
+        postgresql: "database-prisma-pg",
+        mysql: "database-prisma-mysql"
+      }
+    };
     DEFAULT_DATABASE_URLS = {
       "database-pg": "postgresql://postgres@localhost:5432/mydb",
-      "database-mysql": "mysql://root@localhost:3306/mydb"
+      "database-mysql": "mysql://root@localhost:3306/mydb",
+      "database-prisma-pg": "postgresql://postgres@localhost:5432/mydb",
+      "database-prisma-mysql": "mysql://root@localhost:3306/mydb"
     };
   }
 });
@@ -353,9 +459,9 @@ app.use("/api/docs", docsRoutes);
   return true;
 }
 function printDocsHints() {
-  const chalk8 = require("chalk");
-  console.log(chalk8.yellow("\u2139 API docs available at: /api/docs"));
-  console.log(chalk8.yellow("\u2139 OpenAPI spec available at: /api/docs/openapi.json"));
+  const chalk9 = require("chalk");
+  console.log(chalk9.yellow("\u2139 API docs available at: /api/docs"));
+  console.log(chalk9.yellow("\u2139 OpenAPI spec available at: /api/docs/openapi.json"));
 }
 var import_path8, import_fs_extra7;
 var init_docs_handler = __esm({
@@ -693,6 +799,22 @@ var ENV_CONFIGS = {
       { name: "DATABASE_URL", schema: "z.string().url()" }
     ]
   },
+  "database-prisma-pg": {
+    envVars: {
+      DATABASE_URL: "postgresql://postgres@localhost:5432/mydb"
+    },
+    schemaFields: [
+      { name: "DATABASE_URL", schema: "z.string().url()" }
+    ]
+  },
+  "database-prisma-mysql": {
+    envVars: {
+      DATABASE_URL: "mysql://root@localhost:3306/mydb"
+    },
+    schemaFields: [
+      { name: "DATABASE_URL", schema: "z.string().url()" }
+    ]
+  },
   auth: {
     envVars: {
       BETTER_AUTH_SECRET: "your-secret-key-at-least-32-characters-long",
@@ -759,6 +881,19 @@ function sanitizeConfig(input) {
   if (typeof raw.srcDir === "string") {
     config.srcDir = raw.srcDir;
   }
+  if (raw.database && typeof raw.database === "object") {
+    const dbRaw = raw.database;
+    const database = {};
+    if (dbRaw.orm === "drizzle" || dbRaw.orm === "prisma") {
+      database.orm = dbRaw.orm;
+    }
+    if (dbRaw.dialect === "postgresql" || dbRaw.dialect === "mysql") {
+      database.dialect = dbRaw.dialect;
+    }
+    if (database.orm || database.dialect) {
+      config.database = database;
+    }
+  }
   return config;
 }
 function getConfigPath(cwd) {
@@ -1092,8 +1227,8 @@ ${import_chalk2.default.bold("Retry:")}`);
 
 // src/commands/add.ts
 var import_ora2 = __toESM(require("ora"));
-var import_path12 = __toESM(require("path"));
-var import_fs_extra11 = __toESM(require("fs-extra"));
+var import_path13 = __toESM(require("path"));
+var import_fs_extra12 = __toESM(require("fs-extra"));
 var import_node_crypto2 = require("crypto");
 
 // src/utils/dependency.ts
@@ -1120,9 +1255,17 @@ var resolveDependencies = async (moduleDependencies, cwd) => {
   const srcDir = config?.srcDir || "src";
   for (const dep of moduleDependencies) {
     if (dep === "database") {
+      const configuredOrm = config?.database?.orm;
+      const configuredDialect = config?.database?.dialect;
       const pgExists = import_fs_extra5.default.existsSync(import_path5.default.join(cwd, srcDir, BLOCK_SIGNATURES["database-pg"]));
       const mysqlExists = import_fs_extra5.default.existsSync(import_path5.default.join(cwd, srcDir, BLOCK_SIGNATURES["database-mysql"]));
-      if (pgExists || mysqlExists) {
+      const prismaSchemaExists = import_fs_extra5.default.existsSync(import_path5.default.join(cwd, "prisma", "schema.prisma"));
+      const hasDbFiles = pgExists || mysqlExists || prismaSchemaExists;
+      const hasDbConfig = Boolean(configuredOrm && configuredDialect);
+      if (hasDbConfig && hasDbFiles) {
+        continue;
+      }
+      if (!hasDbConfig && hasDbFiles) {
         continue;
       }
       console.log(import_chalk3.default.blue(`\u2139 Dependency '${dep}' is missing. Triggering install...`));
@@ -1154,7 +1297,7 @@ function resolveSafeTargetPath2(projectRoot, srcDir, file) {
 
 // src/commands/add.ts
 init_code_inject();
-var import_chalk7 = __toESM(require("chalk"));
+var import_chalk8 = __toESM(require("chalk"));
 init_database_handler();
 
 // src/handlers/auth.handler.ts
@@ -1624,15 +1767,514 @@ app.use(rateLimiter);` + content.slice(insertAt);
   return true;
 }
 
+// src/handlers/uploads.handler.ts
+var import_path12 = __toESM(require("path"));
+var import_fs_extra11 = __toESM(require("fs-extra"));
+var import_prompts5 = __toESM(require("prompts"));
+var import_chalk7 = __toESM(require("chalk"));
+init_code_inject();
+var UPLOAD_PRESETS = {
+  image: {
+    mimeTypes: ["image/jpeg", "image/png", "image/webp", "image/gif"],
+    maxFileSize: 5 * 1024 * 1024,
+    maxFiles: 1
+  },
+  document: {
+    mimeTypes: [
+      "application/pdf",
+      "text/plain",
+      "application/msword",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    ],
+    maxFileSize: 10 * 1024 * 1024,
+    maxFiles: 3
+  },
+  video: {
+    mimeTypes: ["video/mp4", "video/quicktime", "video/webm"],
+    maxFileSize: 100 * 1024 * 1024,
+    maxFiles: 1
+  }
+};
+function getUploadEnvSchemaFields(provider) {
+  const shared = [
+    { name: "UPLOAD_PROVIDER", schema: `z.enum(["s3", "r2", "cloudinary"])` },
+    { name: "UPLOAD_MODE", schema: `z.enum(["proxy", "direct", "large"])` },
+    { name: "UPLOAD_AUTH_MODE", schema: `z.enum(["required", "none"])` },
+    { name: "UPLOAD_FILE_ACCESS", schema: `z.enum(["private", "public"])` },
+    { name: "UPLOAD_FILE_PRESET", schema: `z.enum(["image", "document", "video"])` },
+    { name: "UPLOAD_KEY_PREFIX", schema: "z.string().min(1)" },
+    { name: "UPLOAD_ALLOWED_MIME", schema: "z.string().min(1)" },
+    { name: "UPLOAD_MAX_FILE_SIZE", schema: "z.coerce.number().positive()" },
+    { name: "UPLOAD_MAX_FILES", schema: "z.coerce.number().int().positive()" },
+    { name: "UPLOAD_DIRECT_URL_TTL_SECONDS", schema: "z.coerce.number().int().positive().default(900)" },
+    { name: "UPLOAD_ACCESS_URL_TTL_SECONDS", schema: "z.coerce.number().int().positive().default(300)" },
+    { name: "UPLOAD_MULTIPART_PART_SIZE", schema: "z.coerce.number().int().positive().default(5242880)" }
+  ];
+  if (provider === "cloudinary") {
+    return [
+      ...shared,
+      { name: "CLOUDINARY_CLOUD_NAME", schema: "z.string().min(1)" },
+      { name: "CLOUDINARY_API_KEY", schema: "z.string().min(1)" },
+      { name: "CLOUDINARY_API_SECRET", schema: "z.string().min(1)" },
+      { name: "CLOUDINARY_FOLDER", schema: 'z.string().min(1).default("uploads")' },
+      { name: "CLOUDINARY_UPLOAD_PRESET", schema: 'z.string().default("")' }
+    ];
+  }
+  return [
+    ...shared,
+    { name: "UPLOAD_BUCKET", schema: "z.string().min(1)" },
+    { name: "UPLOAD_REGION", schema: "z.string().min(1)" },
+    { name: "UPLOAD_ENDPOINT", schema: 'z.string().default("")' },
+    { name: "UPLOAD_ACCESS_KEY_ID", schema: "z.string().min(1)" },
+    { name: "UPLOAD_SECRET_ACCESS_KEY", schema: "z.string().min(1)" },
+    { name: "UPLOAD_PUBLIC_BASE_URL", schema: 'z.string().default("")' }
+  ];
+}
+async function isAuthInstalled(projectRoot, srcDir) {
+  return import_fs_extra11.default.pathExists(import_path12.default.join(projectRoot, srcDir, "lib", "auth.ts"));
+}
+function hasDrizzleDatabase(config) {
+  return config?.database?.orm === "drizzle";
+}
+function getProviderEnvDefaults(provider) {
+  if (provider === "cloudinary") {
+    return {
+      CLOUDINARY_CLOUD_NAME: "your-cloud-name",
+      CLOUDINARY_API_KEY: "your-api-key",
+      CLOUDINARY_API_SECRET: "your-api-secret",
+      CLOUDINARY_FOLDER: "uploads",
+      CLOUDINARY_UPLOAD_PRESET: ""
+    };
+  }
+  return {
+    UPLOAD_BUCKET: `your-${provider}-bucket`,
+    UPLOAD_REGION: provider === "r2" ? "auto" : "us-east-1",
+    UPLOAD_ENDPOINT: provider === "r2" ? "https://<account-id>.r2.cloudflarestorage.com" : "",
+    UPLOAD_ACCESS_KEY_ID: "your-access-key-id",
+    UPLOAD_SECRET_ACCESS_KEY: "your-secret-access-key",
+    UPLOAD_PUBLIC_BASE_URL: ""
+  };
+}
+function buildSharedEnvVars(provider, mode, authMode, access, preset, maxFileSize, maxFiles) {
+  return {
+    UPLOAD_PROVIDER: provider,
+    UPLOAD_MODE: mode,
+    UPLOAD_AUTH_MODE: authMode,
+    UPLOAD_FILE_ACCESS: access,
+    UPLOAD_FILE_PRESET: preset,
+    UPLOAD_KEY_PREFIX: "uploads",
+    UPLOAD_ALLOWED_MIME: UPLOAD_PRESETS[preset].mimeTypes.join(","),
+    UPLOAD_MAX_FILE_SIZE: String(maxFileSize),
+    UPLOAD_MAX_FILES: String(maxFiles),
+    UPLOAD_DIRECT_URL_TTL_SECONDS: "900",
+    UPLOAD_ACCESS_URL_TTL_SECONDS: "300",
+    UPLOAD_MULTIPART_PART_SIZE: "5242880"
+  };
+}
+async function promptUploadsConfig(projectRoot, srcDir) {
+  const projectConfig = await readZuroConfig(projectRoot);
+  const authInstalled = await isAuthInstalled(projectRoot, srcDir);
+  const drizzleInstalled = hasDrizzleDatabase(projectConfig);
+  const initial = await (0, import_prompts5.default)([
+    {
+      type: "select",
+      name: "provider",
+      message: "Which upload provider?",
+      choices: [
+        { title: "S3", value: "s3" },
+        { title: "R2", value: "r2" },
+        { title: "Cloudinary", value: "cloudinary" }
+      ],
+      initial: 0
+    },
+    {
+      type: "select",
+      name: "mode",
+      message: "Which upload mode?",
+      choices: [
+        { title: "Proxy", description: "API server receives the file and uploads it", value: "proxy" },
+        { title: "Direct", description: "Client uploads directly with signed params/URLs", value: "direct" },
+        { title: "Large", description: "Multipart upload flow for large files", value: "large" }
+      ],
+      initial: 1
+    },
+    {
+      type: "select",
+      name: "authMode",
+      message: "Who can upload?",
+      choices: [
+        { title: "Authenticated only", value: "required" },
+        { title: "Public", value: "none" }
+      ],
+      initial: authInstalled ? 0 : 1
+    },
+    {
+      type: "select",
+      name: "access",
+      message: "How should uploaded files be accessed?",
+      choices: [
+        { title: "Private", value: "private" },
+        { title: "Public", value: "public" }
+      ],
+      initial: 0
+    },
+    {
+      type: "select",
+      name: "preset",
+      message: "Which file preset?",
+      choices: [
+        { title: "Image", value: "image" },
+        { title: "Document", value: "document" },
+        { title: "Video", value: "video" }
+      ],
+      initial: 0
+    }
+  ]);
+  if (initial.provider === void 0) {
+    console.log(import_chalk7.default.yellow("Operation cancelled."));
+    return null;
+  }
+  const provider = initial.provider;
+  const mode = initial.mode;
+  const authMode = initial.authMode;
+  const access = initial.access;
+  const preset = initial.preset;
+  if (provider === "cloudinary" && mode === "large") {
+    console.log(import_chalk7.default.yellow("\nCloudinary large multipart scaffolding is not available in this module yet."));
+    console.log(import_chalk7.default.yellow("Use S3 or R2 for large uploads, or pick Proxy/Direct for Cloudinary.\n"));
+    return null;
+  }
+  if (provider === "cloudinary" && preset === "document") {
+    const warning = await (0, import_prompts5.default)({
+      type: "confirm",
+      name: "continue",
+      message: "Cloudinary is media-first. Continue with Cloudinary for non-media/general files?",
+      initial: false
+    });
+    if (!warning.continue) {
+      console.log(import_chalk7.default.yellow("Operation cancelled."));
+      return null;
+    }
+  }
+  const presetDefaults = UPLOAD_PRESETS[preset];
+  let useDatabaseMetadata = false;
+  let shouldInstallDatabase = false;
+  const metadataPrompt = await (0, import_prompts5.default)({
+    type: "confirm",
+    name: "metadata",
+    message: drizzleInstalled ? "Store upload metadata in your database?" : "Install database and store upload metadata?",
+    initial: true
+  });
+  if (metadataPrompt.metadata === void 0) {
+    console.log(import_chalk7.default.yellow("Operation cancelled."));
+    return null;
+  }
+  if (metadataPrompt.metadata === true) {
+    useDatabaseMetadata = true;
+    if (!projectConfig?.database) {
+      shouldInstallDatabase = true;
+    } else if (!drizzleInstalled) {
+      console.log(import_chalk7.default.yellow("\nUploads metadata currently supports Drizzle-based database setups only."));
+      console.log(import_chalk7.default.yellow("Install or switch to a Drizzle database, or continue without metadata.\n"));
+      return null;
+    }
+  }
+  if (access === "private" && !useDatabaseMetadata) {
+    const warning = await (0, import_prompts5.default)({
+      type: "confirm",
+      name: "continue",
+      message: "Private uploads work best with metadata. Continue without database tracking?",
+      initial: false
+    });
+    if (!warning.continue) {
+      console.log(import_chalk7.default.yellow("Operation cancelled."));
+      return null;
+    }
+  }
+  let shouldInstallAuth = false;
+  if (authMode !== "none" && !authInstalled) {
+    const authPrompt = await (0, import_prompts5.default)({
+      type: "confirm",
+      name: "installAuth",
+      message: "Uploads auth requires the auth module. Install auth now?",
+      initial: true
+    });
+    if (!authPrompt.installAuth) {
+      console.log(import_chalk7.default.yellow("Operation cancelled."));
+      return null;
+    }
+    shouldInstallAuth = true;
+  }
+  return {
+    provider,
+    mode,
+    authMode,
+    access,
+    preset,
+    useDatabaseMetadata,
+    shouldInstallAuth,
+    shouldInstallDatabase,
+    envVars: {
+      ...buildSharedEnvVars(provider, mode, authMode, access, preset, presetDefaults.maxFileSize, presetDefaults.maxFiles),
+      ...getProviderEnvDefaults(provider)
+    }
+  };
+}
+async function injectUploadsRoutes(projectRoot, srcDir) {
+  const routeIndexPath = import_path12.default.join(projectRoot, srcDir, "routes", "index.ts");
+  const routeImport = `import uploadsRoutes from "./uploads.routes";`;
+  const routeMountPattern = /rootRouter\.use\(\s*["']\/uploads["']\s*,\s*uploadsRoutes\s*\)/;
+  if (await import_fs_extra11.default.pathExists(routeIndexPath)) {
+    let routeContent = await import_fs_extra11.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 = `
+// Upload routes
+rootRouter.use("/uploads", uploadsRoutes);
+`;
+      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_extra11.default.writeFile(routeIndexPath, routeContent);
+    }
+    return true;
+  }
+  const appPath = import_path12.default.join(projectRoot, srcDir, "app.ts");
+  if (!await import_fs_extra11.default.pathExists(appPath)) {
+    return false;
+  }
+  let appContent = await import_fs_extra11.default.readFile(appPath, "utf-8");
+  let appModified = false;
+  const appImportResult = appendImport(appContent, `import uploadsRoutes from "./routes/uploads.routes";`);
+  if (!appImportResult.inserted) {
+    return false;
+  }
+  if (appImportResult.source !== appContent) {
+    appContent = appImportResult.source;
+    appModified = true;
+  }
+  const hasMount = /app\.use\(\s*["']\/api\/uploads["']\s*,\s*uploadsRoutes\s*\)/.test(appContent);
+  if (!hasMount) {
+    const setup = `
+// Upload routes
+app.use("/api/uploads", uploadsRoutes);
+`;
+    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_extra11.default.writeFile(appPath, appContent);
+  }
+  return true;
+}
+async function isUploadsModuleInstalled(projectRoot, srcDir) {
+  return import_fs_extra11.default.pathExists(import_path12.default.join(projectRoot, srcDir, "routes", "uploads.routes.ts"));
+}
+async function detectInstalledUploadsMode(projectRoot) {
+  const envPath = import_path12.default.join(projectRoot, ".env");
+  if (!await import_fs_extra11.default.pathExists(envPath)) {
+    return null;
+  }
+  const content = await import_fs_extra11.default.readFile(envPath, "utf-8");
+  const match = content.match(/^UPLOAD_MODE=(proxy|direct|large)$/m);
+  if (!match) {
+    return null;
+  }
+  return match[1];
+}
+async function injectUploadsDocs(projectRoot, srcDir, mode) {
+  const openApiPath = import_path12.default.join(projectRoot, srcDir, "lib", "openapi.ts");
+  if (!await import_fs_extra11.default.pathExists(openApiPath)) {
+    return false;
+  }
+  const marker = "// ZURO_UPLOADS_DOCS";
+  let content = await import_fs_extra11.default.readFile(openApiPath, "utf-8");
+  if (content.includes(marker)) {
+    return true;
+  }
+  const moduleDocsEndMarker = "// ZURO_DOCS_MODULES_END";
+  if (!content.includes(moduleDocsEndMarker)) {
+    return false;
+  }
+  const commonBlock = `
+const uploadAccessSchema = z.object({
+    key: z.string().openapi({ example: "uploads/users/user_123/2026/03/06/example.png" }),
+    resourceType: z.string().optional().openapi({ example: "image" }),
+    providerAssetId: z.string().optional().openapi({ example: "uploads/users/user_123/example" }),
+});
+
+`;
+  const directBlock = mode === "direct" ? `registry.registerPath({
+    method: "post",
+    path: "/api/uploads/presign",
+    tags: ["Uploads"],
+    summary: "Create a signed direct upload request",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.object({
+                        originalName: z.string().min(1),
+                        mimeType: z.string().min(1),
+                        bytes: z.number().positive(),
+                    }),
+                },
+            },
+        },
+    },
+    responses: {
+        200: { description: "Signed upload created" },
+    },
+});
+
+registry.registerPath({
+    method: "post",
+    path: "/api/uploads/complete",
+    tags: ["Uploads"],
+    summary: "Finalize a direct upload and persist metadata",
+    responses: {
+        201: { description: "Upload finalized" },
+    },
+});
+` : "";
+  const proxyBlock = mode === "proxy" ? `registry.registerPath({
+    method: "post",
+    path: "/api/uploads",
+    tags: ["Uploads"],
+    summary: "Upload a file through the API server",
+    responses: {
+        201: { description: "File uploaded" },
+    },
+});
+` : "";
+  const largeBlock = mode === "large" ? `registry.registerPath({
+    method: "post",
+    path: "/api/uploads/multipart/init",
+    tags: ["Uploads"],
+    summary: "Start a multipart upload session",
+    responses: {
+        200: { description: "Multipart upload initialized" },
+    },
+});
+
+registry.registerPath({
+    method: "post",
+    path: "/api/uploads/multipart/complete",
+    tags: ["Uploads"],
+    summary: "Complete a multipart upload",
+    responses: {
+        201: { description: "Multipart upload completed" },
+    },
+});
+
+registry.registerPath({
+    method: "post",
+    path: "/api/uploads/multipart/abort",
+    tags: ["Uploads"],
+    summary: "Abort a multipart upload",
+    responses: {
+        204: { description: "Multipart upload aborted" },
+    },
+});
+` : "";
+  const sharedOps = `registry.registerPath({
+    method: "post",
+    path: "/api/uploads/access-url",
+    tags: ["Uploads"],
+    summary: "Create an access URL for an uploaded file",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: uploadAccessSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        200: { description: "Access URL generated" },
+    },
+});
+
+registry.registerPath({
+    method: "delete",
+    path: "/api/uploads",
+    tags: ["Uploads"],
+    summary: "Delete an uploaded file",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: uploadAccessSchema,
+                },
+            },
+        },
+    },
+    responses: {
+        204: { description: "Upload deleted" },
+    },
+});
+`;
+  const block = `
+${commonBlock}${marker}
+${proxyBlock}${directBlock}${largeBlock}${sharedOps}`;
+  content = content.replace(moduleDocsEndMarker, `${block}
+${moduleDocsEndMarker}`);
+  const tagInsert = /(\{\s*name:\s*"Auth".+\},\s*\n\s*\],)/;
+  if (tagInsert.test(content) && !content.includes(`{ name: "Uploads", description: "File uploads and asset access" }`)) {
+    content = content.replace(
+      tagInsert,
+      `{ name: "Auth", description: "Authentication and session endpoints" },
+            { name: "Uploads", description: "File uploads and asset access" },
+        ],`
+    );
+  }
+  await import_fs_extra11.default.writeFile(openApiPath, content);
+  return true;
+}
+function printUploadHints(result) {
+  console.log(import_chalk7.default.yellow("\u2139 Upload routes are mounted at: /api/uploads"));
+  console.log(import_chalk7.default.yellow(`\u2139 Provider: ${result.provider} \xB7 Mode: ${result.mode} \xB7 Access: ${result.access}`));
+  console.log(import_chalk7.default.yellow("\u2139 Fill the generated upload env vars in .env before testing uploads."));
+  if (result.mode === "proxy") {
+    console.log(import_chalk7.default.yellow("\u2139 Reuse uploadSingle()/uploadArray() from src/lib/uploads/proxy.ts in your own form + file routes."));
+  }
+  if (result.provider === "r2") {
+    console.log(import_chalk7.default.yellow("\u2139 R2 presigned URLs use the R2 S3 API endpoint, not your custom domain."));
+  }
+  if (result.useDatabaseMetadata) {
+    console.log(import_chalk7.default.yellow("\u2139 Upload metadata is stored in db/schema/uploads.ts."));
+  } else {
+    console.log(import_chalk7.default.yellow("\u2139 No upload metadata table was added. Private file ownership checks fall back to key prefixes."));
+  }
+}
+
 // src/commands/add.ts
 function resolvePackageManager(projectRoot) {
-  if (import_fs_extra11.default.existsSync(import_path12.default.join(projectRoot, "pnpm-lock.yaml"))) {
+  if (import_fs_extra12.default.existsSync(import_path13.default.join(projectRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (import_fs_extra11.default.existsSync(import_path12.default.join(projectRoot, "bun.lockb")) || import_fs_extra11.default.existsSync(import_path12.default.join(projectRoot, "bun.lock"))) {
+  if (import_fs_extra12.default.existsSync(import_path13.default.join(projectRoot, "bun.lockb")) || import_fs_extra12.default.existsSync(import_path13.default.join(projectRoot, "bun.lock"))) {
     return "bun";
   }
-  if (import_fs_extra11.default.existsSync(import_path12.default.join(projectRoot, "yarn.lock"))) {
+  if (import_fs_extra12.default.existsSync(import_path13.default.join(projectRoot, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -1644,16 +2286,16 @@ function getModuleDocsPath(moduleName) {
   return moduleName;
 }
 async function hasEnvVariable(projectRoot, key) {
-  const envPath = import_path12.default.join(projectRoot, ".env");
-  if (!await import_fs_extra11.default.pathExists(envPath)) {
+  const envPath = import_path13.default.join(projectRoot, ".env");
+  if (!await import_fs_extra12.default.pathExists(envPath)) {
     return false;
   }
-  const content = await import_fs_extra11.default.readFile(envPath, "utf-8");
+  const content = await import_fs_extra12.default.readFile(envPath, "utf-8");
   const pattern = new RegExp(`^${escapeRegex(key)}=`, "m");
   return pattern.test(content);
 }
 async function isLikelyEmptyDirectory(cwd) {
-  const entries = await import_fs_extra11.default.readdir(cwd);
+  const entries = await import_fs_extra12.default.readdir(cwd);
   const ignored = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
   return entries.filter((entry) => !ignored.has(entry.toLowerCase())).length === 0;
 }
@@ -1677,16 +2319,22 @@ var add = async (moduleName, options = {}) => {
   let customDbUrl;
   let usedDefaultDbUrl = false;
   let databaseBackupPath = null;
+  let selectedDatabaseOrm = null;
+  let selectedDatabaseDialect = null;
   let generatedAuthSecret = false;
   let authDatabaseDialect = null;
   let customSmtpVars;
   let usedDefaultSmtp = false;
   let mailerProvider = "smtp";
   let shouldInstallDocsForAuth = false;
+  let uploadConfig = null;
+  let uploadDatabaseDialect = null;
   if (resolvedModuleName === "database" || isDatabaseModule(resolvedModuleName)) {
     const result = await promptDatabaseConfig(resolvedModuleName, projectRoot, srcDir);
     if (!result) return;
     resolvedModuleName = result.resolvedModuleName;
+    selectedDatabaseOrm = result.selectedOrm;
+    selectedDatabaseDialect = result.selectedDialect;
     customDbUrl = result.customDbUrl;
     usedDefaultDbUrl = result.usedDefaultDbUrl;
     databaseBackupPath = result.databaseBackupPath;
@@ -1704,6 +2352,10 @@ var add = async (moduleName, options = {}) => {
     shouldInstallDocsForAuth = result.shouldInstallDocsForAuth;
     authDatabaseDialect = result.authDatabaseDialect;
   }
+  if (resolvedModuleName === "uploads") {
+    uploadConfig = await promptUploadsConfig(projectRoot, srcDir);
+    if (!uploadConfig) return;
+  }
   const pm = resolvePackageManager(projectRoot);
   const spinner = (0, import_ora2.default)(`Checking registry for ${resolvedModuleName}...`).start();
   let currentStep = "package manager preflight";
@@ -1718,10 +2370,46 @@ var add = async (moduleName, options = {}) => {
       spinner.fail(`Module '${resolvedModuleName}' not found.`);
       return;
     }
-    spinner.succeed(`Found module: ${import_chalk7.default.cyan(resolvedModuleName)}`);
+    spinner.succeed(`Found module: ${import_chalk8.default.cyan(resolvedModuleName)}`);
     const moduleDeps = module2.moduleDependencies || [];
     currentStep = "module dependency resolution";
     await resolveDependencies(moduleDeps, projectRoot);
+    if (resolvedModuleName === "uploads" && uploadConfig) {
+      const errorHandlerInstalled = import_fs_extra12.default.existsSync(import_path13.default.join(projectRoot, srcDir, "lib", "errors.ts"));
+      if (!errorHandlerInstalled) {
+        console.log(import_chalk8.default.blue("\n\u2139 Uploads needs the error-handler module. Installing error-handler..."));
+        await add("error-handler");
+      }
+      if (uploadConfig.shouldInstallDatabase) {
+        console.log(import_chalk8.default.blue("\n\u2139 Upload metadata needs a Drizzle database. Installing database module..."));
+        await add("database");
+      }
+      if (uploadConfig.shouldInstallAuth) {
+        console.log(import_chalk8.default.blue("\n\u2139 Upload auth needs the auth module. Installing auth module..."));
+        await add("auth", { yes: true });
+      }
+      uploadDatabaseDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
+      if (uploadConfig.useDatabaseMetadata) {
+        if (uploadDatabaseDialect === "database-prisma-pg" || uploadDatabaseDialect === "database-prisma-mysql") {
+          spinner.fail("Uploads metadata currently supports Drizzle-based database setup only.");
+          console.log(import_chalk8.default.yellow("\u2139 Install a Drizzle database, or rerun uploads without metadata."));
+          return;
+        }
+        if (!uploadDatabaseDialect) {
+          spinner.fail("Could not detect a database setup for uploads metadata.");
+          console.log(import_chalk8.default.yellow("\u2139 Install the database module first, then rerun uploads."));
+          return;
+        }
+      }
+    }
+    if (resolvedModuleName === "auth") {
+      authDatabaseDialect = await detectInstalledDatabaseDialect(projectRoot, srcDir);
+      if (authDatabaseDialect === "database-prisma-pg" || authDatabaseDialect === "database-prisma-mysql") {
+        spinner.fail("Auth module currently supports Drizzle-based database setup only.");
+        console.log(import_chalk8.default.yellow("\u2139 Install auth after switching database ORM to Drizzle."));
+        return;
+      }
+    }
     currentStep = "dependency installation";
     spinner.start("Installing dependencies...");
     let runtimeDeps = module2.dependencies || [];
@@ -1735,6 +2423,15 @@ var add = async (moduleName, options = {}) => {
         devDeps = ["@types/nodemailer"];
       }
     }
+    if (resolvedModuleName === "uploads" && uploadConfig) {
+      runtimeDeps = ["multer"];
+      devDeps = ["@types/multer"];
+      if (uploadConfig.provider === "cloudinary") {
+        runtimeDeps.push("cloudinary");
+      } else {
+        runtimeDeps.push("@aws-sdk/client-s3", "@aws-sdk/s3-request-presigner");
+      }
+    }
     await installDependencies(pm, runtimeDeps, projectRoot);
     await installDependencies(pm, devDeps, projectRoot, { dev: true });
     spinner.succeed("Dependencies installed");
@@ -1754,12 +2451,37 @@ var add = async (moduleName, options = {}) => {
         expectedSha256 = void 0;
         expectedSize = void 0;
       }
+      if (resolvedModuleName === "uploads" && uploadConfig) {
+        if (file.target === "lib/uploads/provider.ts") {
+          fetchPath = uploadConfig.provider === "cloudinary" ? "express/lib/uploads/provider.cloudinary.ts" : "express/lib/uploads/provider.s3.ts";
+          expectedSha256 = void 0;
+          expectedSize = void 0;
+        }
+        if (file.target === "lib/uploads/metadata.ts") {
+          fetchPath = uploadConfig.useDatabaseMetadata ? "express/lib/uploads/metadata.db.ts" : "express/lib/uploads/metadata.noop.ts";
+          expectedSha256 = void 0;
+          expectedSize = void 0;
+        }
+        if (file.target === "middleware/upload-auth.ts") {
+          fetchPath = `express/middleware/upload-auth.${uploadConfig.authMode}.ts`;
+          expectedSha256 = void 0;
+          expectedSize = void 0;
+        }
+        if (file.target === "db/schema/uploads.ts") {
+          if (!uploadConfig.useDatabaseMetadata) {
+            continue;
+          }
+          fetchPath = uploadDatabaseDialect === "database-mysql" ? "express/db/schema/uploads.mysql.ts" : "express/db/schema/uploads.ts";
+          expectedSha256 = void 0;
+          expectedSize = void 0;
+        }
+      }
       let content = await fetchFile(fetchPath, {
         baseUrl: registryContext.fileBaseUrl,
         expectedSha256,
         expectedSize
       });
-      if (isDatabaseModule(resolvedModuleName) && file.target === "../drizzle.config.ts") {
+      if (isDrizzleDatabaseModule(resolvedModuleName) && file.target === "../drizzle.config.ts") {
         const normalizedSrcDir = srcDir.replace(/\\/g, "/");
         content = content.replace(
           /schema:\s*["'][^"']+["']/,
@@ -1767,10 +2489,10 @@ var add = async (moduleName, options = {}) => {
         );
       }
       const targetPath = resolveSafeTargetPath2(projectRoot, srcDir, file);
-      await import_fs_extra11.default.ensureDir(import_path12.default.dirname(targetPath));
-      await import_fs_extra11.default.writeFile(targetPath, content);
+      await import_fs_extra12.default.ensureDir(import_path13.default.dirname(targetPath));
+      await import_fs_extra12.default.writeFile(targetPath, content);
     }
-    const schemaExports = module2.files.map((file) => file.target.replace(/\\/g, "/")).filter((target) => /^db\/schema\/[^/]+\.ts$/.test(target)).map((target) => import_path12.default.posix.basename(target, ".ts")).filter((name) => name !== "index");
+    const schemaExports = module2.files.map((file) => file.target.replace(/\\/g, "/")).filter((target) => /^db\/schema\/[^/]+\.ts$/.test(target)).map((target) => import_path13.default.posix.basename(target, ".ts")).filter((name) => name !== "index");
     for (const schemaFileName of schemaExports) {
       await ensureSchemaExport(projectRoot, srcDir, schemaFileName);
     }
@@ -1830,6 +2552,38 @@ var add = async (moduleName, options = {}) => {
           spinner.warn("Could not update API docs automatically");
         }
       }
+      const uploadsInstalled = await isUploadsModuleInstalled(projectRoot, srcDir);
+      if (uploadsInstalled) {
+        const uploadMode = await detectInstalledUploadsMode(projectRoot);
+        if (uploadMode) {
+          spinner.start("Adding uploads endpoints to API docs...");
+          const uploadsDocsInjected = await injectUploadsDocs(projectRoot, srcDir, uploadMode);
+          if (uploadsDocsInjected) {
+            spinner.succeed("Uploads endpoints added to API docs");
+          } else {
+            spinner.warn("Could not update API docs automatically");
+          }
+        }
+      }
+    }
+    if (resolvedModuleName === "uploads" && uploadConfig) {
+      spinner.start("Configuring upload routes...");
+      const injected = await injectUploadsRoutes(projectRoot, srcDir);
+      if (injected) {
+        spinner.succeed("Upload routes configured");
+      } else {
+        spinner.warn("Could not configure upload routes automatically");
+      }
+      const docsInstalled = await isDocsModuleInstalled(projectRoot, srcDir);
+      if (docsInstalled) {
+        spinner.start("Adding uploads endpoints to API docs...");
+        const docsInjected = await injectUploadsDocs(projectRoot, srcDir, uploadConfig.mode);
+        if (docsInjected) {
+          spinner.succeed("Uploads endpoints added to API docs");
+        } else {
+          spinner.warn("Could not update API docs automatically");
+        }
+      }
     }
     let envConfigKey = resolvedModuleName;
     if (resolvedModuleName === "mailer" && mailerProvider === "resend") {
@@ -1859,12 +2613,34 @@ var add = async (moduleName, options = {}) => {
       await updateEnvSchema(projectRoot, srcDir, envConfig.schemaFields);
       spinner.succeed("Environment configured");
     }
-    console.log(import_chalk7.default.green(`
+    if (resolvedModuleName === "uploads" && uploadConfig) {
+      currentStep = "environment configuration";
+      spinner.start("Updating environment configuration...");
+      await updateEnvFile(projectRoot, uploadConfig.envVars, true);
+      await updateEnvSchema(projectRoot, srcDir, getUploadEnvSchemaFields(uploadConfig.provider));
+      spinner.succeed("Environment configured");
+    }
+    if (isDatabaseModule(resolvedModuleName)) {
+      const selected = getDatabaseSelection(resolvedModuleName);
+      const orm = selectedDatabaseOrm ?? selected.orm;
+      const dialect = selectedDatabaseDialect ?? selected.dialect;
+      const latestConfig = await readZuroConfig(projectRoot);
+      if (latestConfig) {
+        await writeZuroConfig(projectRoot, {
+          ...latestConfig,
+          database: {
+            orm,
+            dialect
+          }
+        });
+      }
+    }
+    console.log(import_chalk8.default.green(`
 \u2714 ${resolvedModuleName} added successfully!
 `));
     const docsPath = getModuleDocsPath(resolvedModuleName);
     const docsUrl = `https://zuro-cli.devbybriyan.com/docs/${docsPath}`;
-    console.log(import_chalk7.default.blue(`\u2139 Docs: ${docsUrl}`));
+    console.log(import_chalk8.default.blue(`\u2139 Docs: ${docsUrl}`));
     if (isDatabaseModule(resolvedModuleName)) {
       printDatabaseHints(resolvedModuleName, customDbUrl, usedDefaultDbUrl, databaseBackupPath);
     }
@@ -1877,17 +2653,20 @@ var add = async (moduleName, options = {}) => {
     if (resolvedModuleName === "docs") {
       printDocsHints();
     }
+    if (resolvedModuleName === "uploads" && uploadConfig) {
+      printUploadHints(uploadConfig);
+    }
     if (resolvedModuleName === "auth" && shouldInstallDocsForAuth) {
-      console.log(import_chalk7.default.blue("\n\u2139 Installing API docs module..."));
+      console.log(import_chalk8.default.blue("\n\u2139 Installing API docs module..."));
       await add("docs", { yes: true });
     }
   } catch (error) {
-    spinner.fail(import_chalk7.default.red(`Failed during ${currentStep}.`));
+    spinner.fail(import_chalk8.default.red(`Failed during ${currentStep}.`));
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(import_chalk7.default.red(errorMessage));
+    console.error(import_chalk8.default.red(errorMessage));
     console.log(`
-${import_chalk7.default.bold("Retry:")}`);
-    console.log(import_chalk7.default.cyan(`  npx zuro-cli add ${resolvedModuleName}`));
+${import_chalk8.default.bold("Retry:")}`);
+    console.log(import_chalk8.default.cyan(`  npx zuro-cli add ${resolvedModuleName}`));
   }
 };