@panoptic-it-solutions/coolify-setup 1.1.14 → 1.1.16

package/dist/detector.d.ts

@@ -4,5 +4,6 @@ export interface ProjectInfo {
     hasDockerfile: boolean;
     hasDockerCompose: boolean;
     name: string;
+    dbPath: string | null;
 }
 export declare function detectProject(): Promise<ProjectInfo>;

package/dist/detector.js

@@ -24,11 +24,27 @@ export async function detectProject() {
         packageManager = 'pnpm';
     else if (hasYarnLock)
         packageManager = 'yarn';
+    // Detect where migrations are located (check in order of priority)
+    const possibleDbPaths = [
+        'src/lib/db', // Already in src/lib/db
+        'lib/db', // Already in lib/db
+        'src/db', // Common with src/ directory
+        'db', // Common without src/
+        'drizzle', // Alternative location
+    ];
+    let dbPath = null;
+    for (const path of possibleDbPaths) {
+        if (exists(`${path}/migrations`)) {
+            dbPath = path;
+            break;
+        }
+    }
     return {
         type: hasNextConfig ? 'nextjs' : 'node',
         packageManager,
         hasDockerfile,
         hasDockerCompose,
         name: hasPackageJson ? getProjectName() : 'my-project',
+        dbPath,
     };
 }

package/dist/generator.d.ts

@@ -5,5 +5,6 @@ export interface GenerateOptions {
     includePostgres: boolean;
     includeRedis: boolean;
     includeMinio: boolean;
+    dbPath: string | null;
 }
 export declare function generateFiles(options: GenerateOptions): Promise<void>;

package/dist/generator.js

@@ -13,6 +13,12 @@ function writeFile(relativePath, content) {
     ensureDir(fullPath);
     writeFileSync(fullPath, content, 'utf-8');
 }
+// Default dbPath if none detected (for projects without existing migrations)
+function getDefaultDbPath() {
+    // If project has src/app, use src/lib/db, otherwise use lib/db
+    const srcAppPath = join(process.cwd(), 'src/app');
+    return existsSync(srcAppPath) ? 'src/lib/db' : 'lib/db';
+}
 function addEsbuildToPackageJson(packageManager) {
     const packageJsonPath = join(process.cwd(), 'package.json');
     if (!existsSync(packageJsonPath)) {
@@ -47,32 +53,44 @@ function addEsbuildToPackageJson(packageManager) {
         return false;
     }
 }
-function copyMigrationsToLibDb() {
+function cleanupOldMigrationFiles(currentDbPath) {
     const cwd = process.cwd();
-    const destPath = join(cwd, 'lib/db/migrations');
-    // Skip if destination already exists
-    if (existsSync(destPath)) {
-        return false;
-    }
-    // Source directories to check (in order of priority)
-    const sourceRoots = ['db', 'src/db'];
-    for (const sourceRoot of sourceRoots) {
-        const sourcePath = join(cwd, sourceRoot, 'migrations');
-        if (existsSync(sourcePath)) {
-            // Ensure lib/db directory exists
-            ensureDir(join(destPath, 'dummy'));
-            // Copy (not move) to preserve source imports
-            execSync(`cp -r "${sourcePath}/." "${destPath}"`, { stdio: 'pipe' });
-            console.log(`Copied ${sourceRoot}/migrations → lib/db/migrations`);
-            return true;
+    const { unlinkSync, readdirSync, rmSync } = require('fs');
+    // Possible locations where we might have created files in previous runs
+    const possibleOldPaths = [
+        'lib/db',
+        'src/lib/db',
+    ];
+    for (const oldPath of possibleOldPaths) {
+        // Skip if this is the current path
+        if (oldPath === currentDbPath)
+            continue;
+        const oldMigratePath = join(cwd, oldPath, 'migrate.ts');
+        const oldMigrationsPath = join(cwd, oldPath, 'migrations');
+        // Remove old migrate.ts if it exists
+        if (existsSync(oldMigratePath)) {
+            unlinkSync(oldMigratePath);
+            console.log(`Removed old ${oldPath}/migrate.ts`);
+        }
+        // Remove old migrations folder if it's a folder we created (check if parent only contains our files)
+        if (existsSync(oldMigrationsPath)) {
+            const parentPath = join(cwd, oldPath);
+            try {
+                const contents = readdirSync(parentPath);
+                // Only remove if directory only contains migrations and/or migrate.ts (our files)
+                const isOurFolder = contents.every((f) => f === 'migrations' || f === 'migrate.ts' || f === 'migrate.bundle.js');
+                if (isOurFolder) {
+                    rmSync(parentPath, { recursive: true, force: true });
+                    console.log(`Removed old ${oldPath}/ folder`);
+                }
+            }
+            catch {
+                // Ignore errors during cleanup
+            }
         }
     }
-    // No migrations found - create empty folder so Docker build doesn't fail
-    ensureDir(join(destPath, 'dummy'));
-    console.log('Created empty lib/db/migrations (no source migrations found)');
-    return true;
 }
-function excludeMigrateFromTsConfig(migratePath) {
+function updateTsConfigExcludes(newMigratePath) {
     const tsconfigPath = join(process.cwd(), 'tsconfig.json');
     if (!existsSync(tsconfigPath)) {
         console.log('Warning: tsconfig.json not found, skipping exclusion');
@@ -84,13 +102,26 @@ function excludeMigrateFromTsConfig(migratePath) {
         if (!tsconfig.exclude) {
             tsconfig.exclude = ['node_modules'];
         }
-        // Add migrate.ts to exclude if not already present
-        if (!tsconfig.exclude.includes(migratePath)) {
-            tsconfig.exclude.push(migratePath);
+        // Old paths to remove from previous runs
+        const oldPaths = ['lib/db/migrate.ts', 'src/lib/db/migrate.ts'];
+        let modified = false;
+        // Remove old paths that are no longer used
+        for (const oldPath of oldPaths) {
+            const index = tsconfig.exclude.indexOf(oldPath);
+            if (index !== -1 && oldPath !== newMigratePath) {
+                tsconfig.exclude.splice(index, 1);
+                modified = true;
+            }
+        }
+        // Add new path if not already present
+        if (!tsconfig.exclude.includes(newMigratePath)) {
+            tsconfig.exclude.push(newMigratePath);
+            modified = true;
+        }
+        if (modified) {
             writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + '\n', 'utf-8');
-            return true;
         }
-        return false;
+        return modified;
     }
     catch (error) {
         console.log('Warning: Failed to update tsconfig.json:', error);
@@ -98,12 +129,15 @@ function excludeMigrateFromTsConfig(migratePath) {
     }
 }
 export async function generateFiles(options) {
-    const { projectName, projectType, packageManager, includePostgres, includeRedis, includeMinio, } = options;
+    const { projectName, projectType, packageManager, includePostgres, includeRedis, includeMinio, dbPath: detectedDbPath, } = options;
+    // Use detected dbPath or fall back to default based on project structure
+    const dbPath = detectedDbPath ?? getDefaultDbPath();
     // Generate Dockerfile
     const dockerfile = generateDockerfile({
         projectType,
         packageManager,
         includePostgres,
+        dbPath,
     });
     writeFile('Dockerfile', dockerfile);
     // Generate docker-compose.yml
@@ -128,6 +162,7 @@ export async function generateFiles(options) {
     const entrypoint = generateEntrypoint({
         projectType,
         includePostgres,
+        dbPath,
     });
     writeFile('entrypoint.sh', entrypoint);
     // Generate Claude rules
@@ -135,29 +170,33 @@ export async function generateFiles(options) {
     writeFile('.claude/rules/coolify.md', claudeRules);
     // Generate migrate.ts if postgres is included
     if (includePostgres) {
-        const migrateScript = generateMigrateScript({ projectType });
         // For Next.js standalone projects, we need esbuild to bundle the migration script
         if (projectType === 'nextjs') {
             const added = addEsbuildToPackageJson(packageManager);
             if (added) {
                 console.log('Added esbuild to devDependencies (required for migration bundling)');
             }
-            // Copy migrations to lib/db/ for Docker build (don't move - preserve source imports)
-            copyMigrationsToLibDb();
-            // Write migrate.ts to lib/db/ for Next.js projects (will be bundled at build time)
-            const migratePath = 'lib/db/migrate.ts';
-            const existingMigratePath = join(process.cwd(), migratePath);
-            if (!existsSync(existingMigratePath)) {
-                writeFile(migratePath, migrateScript);
+            // Clean up old files from previous runs (if dbPath changed)
+            cleanupOldMigrationFiles(dbPath);
+            // Create empty migrations folder if none exists
+            const migrationsPath = join(process.cwd(), dbPath, 'migrations');
+            if (!existsSync(migrationsPath)) {
+                ensureDir(join(migrationsPath, 'dummy'));
+                console.log(`Created empty ${dbPath}/migrations folder`);
             }
-            // Exclude migrate.ts from TypeScript compilation (it's bundled separately by esbuild)
-            const excluded = excludeMigrateFromTsConfig(migratePath);
-            if (excluded) {
-                console.log('Added lib/db/migrate.ts to tsconfig.json exclude (bundled separately)');
+            // Always write migrate.ts (overwrites previous version to handle updates)
+            const migrateScript = generateMigrateScript({ projectType, dbPath });
+            const migratePath = `${dbPath}/migrate.ts`;
+            writeFile(migratePath, migrateScript);
+            // Update tsconfig.json excludes (removes old paths, adds new)
+            const updated = updateTsConfigExcludes(migratePath);
+            if (updated) {
+                console.log(`Updated tsconfig.json exclude for ${migratePath}`);
             }
         }
         else {
             // For Node.js projects, write to scripts/ directory
+            const migrateScript = generateMigrateScript({ projectType, dbPath });
             writeFile('scripts/migrate.ts', migrateScript);
         }
     }

package/dist/index.js

@@ -64,6 +64,7 @@ async function main() {
         includePostgres: response.includePostgres,
         includeRedis: response.includeRedis,
         includeMinio: response.includeMinio,
+        dbPath: project.dbPath,
     });
     // Track generated files for commit
     const generatedFiles = [
@@ -85,11 +86,12 @@ async function main() {
     else {
         generatedFiles.push('package-lock.json');
     }
-    // Add migrate script and db folder if postgres included
+    // Add migrate script if postgres included
     if (response.includePostgres) {
         if (project.type === 'nextjs') {
-            generatedFiles.push('lib/db/migrate.ts');
-            generatedFiles.push('lib/db/migrations/'); // Include copied migrations folder
+            // Use detected dbPath, or fall back to default based on project structure
+            const dbPath = project.dbPath ?? (project.type === 'nextjs' ? 'lib/db' : 'db');
+            generatedFiles.push(`${dbPath}/migrate.ts`);
             generatedFiles.push('tsconfig.json'); // May be modified with exclude
         }
         else {
@@ -104,7 +106,8 @@ async function main() {
     console.log(chalk.green('  ✓ entrypoint.sh'));
     if (response.includePostgres) {
         if (project.type === 'nextjs') {
-            console.log(chalk.green('  ✓ lib/db/migrate.ts'));
+            const dbPath = project.dbPath ?? 'lib/db';
+            console.log(chalk.green(`  ✓ ${dbPath}/migrate.ts`));
         }
         else {
             console.log(chalk.green('  ✓ scripts/migrate.ts'));

package/dist/templates/dockerfile.d.ts

@@ -2,5 +2,6 @@ export interface DockerfileOptions {
     projectType: 'nextjs' | 'node';
     packageManager: 'pnpm' | 'npm' | 'yarn';
     includePostgres: boolean;
+    dbPath: string;
 }
 export declare function generateDockerfile(options: DockerfileOptions): string;

package/dist/templates/dockerfile.js

@@ -5,7 +5,7 @@ export function generateDockerfile(options) {
     return generateNodeDockerfile(options);
 }
 function generateNextjsDockerfile(options) {
-    const { packageManager, includePostgres } = options;
+    const { packageManager, includePostgres, dbPath } = options;
     const installCmd = packageManager === 'pnpm'
         ? 'pnpm install --frozen-lockfile'
         : packageManager === 'yarn'
@@ -39,12 +39,12 @@ function generateNextjsDockerfile(options) {
 # Build the migration bundle (single JS file with all deps baked in)
 # This avoids module resolution issues in the standalone container
 # postgres is externalized and copied separately due to pnpm symlink resolution issues
-RUN ${esbuildCmd} lib/db/migrate.ts --bundle --platform=node --target=node22 --outfile=lib/db/migrate.bundle.js --external:dotenv --external:postgres` : '';
+RUN ${esbuildCmd} ${dbPath}/migrate.ts --bundle --platform=node --target=node22 --outfile=${dbPath}/migrate.bundle.js --external:dotenv --external:postgres` : '';
     const migrationCopy = includePostgres ? `
 
 # Copy database migrations and bundled migration script
-COPY --from=builder --chown=nextjs:nodejs /app/lib/db/migrations ./lib/db/migrations
-COPY --from=builder --chown=nextjs:nodejs /app/lib/db/migrate.bundle.js ./lib/db/migrate.bundle.js
+COPY --from=builder --chown=nextjs:nodejs /app/${dbPath}/migrations ./${dbPath}/migrations
+COPY --from=builder --chown=nextjs:nodejs /app/${dbPath}/migrate.bundle.js ./${dbPath}/migrate.bundle.js
 
 # Copy postgres module for migration script (externalized from bundle due to pnpm symlinks)
 COPY --from=builder --chown=nextjs:nodejs /app/node_modules/.pnpm/postgres@*/node_modules/postgres ./node_modules/postgres` : '';
@@ -135,7 +135,7 @@ CMD ["./entrypoint.sh"]
 `;
 }
 function generateNodeDockerfile(options) {
-    const { packageManager, includePostgres } = options;
+    const { packageManager, includePostgres, dbPath } = options;
     const installCmd = packageManager === 'pnpm'
         ? 'pnpm install --frozen-lockfile --prod'
         : packageManager === 'yarn'
@@ -153,8 +153,8 @@ function generateNodeDockerfile(options) {
             : '';
     const migrationCopy = includePostgres ? `
 # Copy migration files
-COPY --chown=node:node lib/db/migrations ./scripts/migrations
-COPY --chown=node:node lib/db/migrate.ts ./scripts/migrate.ts` : '';
+COPY --chown=node:node ${dbPath}/migrations ./scripts/migrations
+COPY --chown=node:node ${dbPath}/migrate.ts ./scripts/migrate.ts` : '';
     const tsxInstall = includePostgres ? `
 # Install tsx globally for running TypeScript migration scripts
 RUN npm install -g tsx` : '';

package/dist/templates/entrypoint.d.ts

@@ -1,5 +1,6 @@
 export interface EntrypointOptions {
     projectType: 'nextjs' | 'node';
     includePostgres: boolean;
+    dbPath: string;
 }
 export declare function generateEntrypoint(options: EntrypointOptions): string;

package/dist/templates/entrypoint.js

@@ -1,5 +1,5 @@
 export function generateEntrypoint(options) {
-    const { projectType, includePostgres } = options;
+    const { projectType, includePostgres, dbPath } = options;
     // For Next.js standalone, we run the bundled JS file (no tsx needed)
     // For Node.js, we use tsx since full node_modules is available
     const migrationStep = includePostgres
@@ -7,7 +7,7 @@ export function generateEntrypoint(options) {
             ? `
 # Run database migrations (bundled JS with all deps baked in)
 echo "⏳ Running database migrations..."
-node lib/db/migrate.bundle.js
+node ${dbPath}/migrate.bundle.js
 `
             : `
 # Run database migrations

package/dist/templates/migrate.d.ts

@@ -1,4 +1,5 @@
 export interface MigrateScriptOptions {
     projectType: 'nextjs' | 'node';
+    dbPath: string;
 }
-export declare function generateMigrateScript(options?: MigrateScriptOptions): string;
+export declare function generateMigrateScript(options: MigrateScriptOptions): string;

package/dist/templates/migrate.js

@@ -1,9 +1,9 @@
 export function generateMigrateScript(options) {
-    const projectType = options?.projectType ?? 'nextjs';
-    // For Next.js, migrations are in lib/db/migrations (bundled with esbuild)
-    // For Node.js, migrations are in scripts/migrations (run with tsx)
+    const { projectType, dbPath } = options;
+    // For Next.js, migrations are in the detected dbPath (e.g., src/db, lib/db, etc.)
+    // For Node.js, migrations are copied to scripts/migrations (run with tsx)
     const migrationsFolder = projectType === 'nextjs'
-        ? './lib/db/migrations'
+        ? `./${dbPath}/migrations`
         : './scripts/migrations';
     return `import { drizzle } from 'drizzle-orm/postgres-js';
 import { migrate } from 'drizzle-orm/postgres-js/migrator';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@panoptic-it-solutions/coolify-setup",
-  "version": "1.1.14",
+  "version": "1.1.16",
   "description": "CLI tool for setting up Coolify deployment on Panoptic projects",
   "type": "module",
   "main": "dist/index.js",