@panoptic-it-solutions/coolify-setup 1.1.15 → 1.1.17

package/dist/detector.d.ts

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

package/dist/detector.js

@@ -19,18 +19,32 @@ export async function detectProject() {
     const hasYarnLock = exists('yarn.lock');
     const hasDockerfile = exists('Dockerfile');
     const hasDockerCompose = exists('docker-compose.yml');
-    const hasSrcApp = exists('src/app'); // Detect src/ directory structure
     let packageManager = 'npm';
     if (hasPnpmLock)
         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',
-        usesSrcDirectory: hasSrcApp,
+        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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync, readdirSync, rmSync } from 'fs';
 import { join, dirname } from 'path';
 import { execSync } from 'child_process';
 import { generateDockerfile, generateDockerCompose, generateDockerComposeBuild, generateWorkflow, generateEntrypoint, generateMigrateScript, generateClaudeRules, } from './templates/index.js';
@@ -13,11 +13,11 @@ function writeFile(relativePath, content) {
     ensureDir(fullPath);
     writeFileSync(fullPath, content, 'utf-8');
 }
-function detectSrcDirectory() {
-    // Check if project uses src/ directory structure
-    const srcPath = join(process.cwd(), 'src');
+// 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(srcPath) && existsSync(srcAppPath);
+    return existsSync(srcAppPath) ? 'src/lib/db' : 'lib/db';
 }
 function addEsbuildToPackageJson(packageManager) {
     const packageJsonPath = join(process.cwd(), 'package.json');
@@ -53,34 +53,43 @@ function addEsbuildToPackageJson(packageManager) {
         return false;
     }
 }
-function copyMigrationsToLibDb(usesSrcDirectory) {
+function cleanupOldMigrationFiles(currentDbPath) {
     const cwd = process.cwd();
-    // Use src/lib/db for projects with src/ directory, otherwise lib/db
-    const libDbPath = usesSrcDirectory ? 'src/lib/db' : 'lib/db';
-    const destPath = join(cwd, libDbPath, '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 destination 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 → ${libDbPath}/migrations`);
-            return true;
+    // 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 ${libDbPath}/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');
@@ -92,13 +101,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);
@@ -106,15 +128,15 @@ function excludeMigrateFromTsConfig(migratePath) {
     }
 }
 export async function generateFiles(options) {
-    const { projectName, projectType, packageManager, includePostgres, includeRedis, includeMinio, } = options;
-    // Detect if project uses src/ directory structure
-    const usesSrcDirectory = projectType === 'nextjs' && detectSrcDirectory();
+    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,
-        usesSrcDirectory,
+        dbPath,
     });
     writeFile('Dockerfile', dockerfile);
     // Generate docker-compose.yml
@@ -139,7 +161,7 @@ export async function generateFiles(options) {
     const entrypoint = generateEntrypoint({
         projectType,
         includePostgres,
-        usesSrcDirectory,
+        dbPath,
     });
     writeFile('entrypoint.sh', entrypoint);
     // Generate Claude rules
@@ -147,31 +169,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, usesSrcDirectory });
         // 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)');
             }
-            // Use src/lib/db for projects with src/ directory, otherwise lib/db
-            const libDbPath = usesSrcDirectory ? 'src/lib/db' : 'lib/db';
-            // Copy migrations to lib/db/ for Docker build (don't move - preserve source imports)
-            copyMigrationsToLibDb(usesSrcDirectory);
-            // Write migrate.ts to lib/db/ for Next.js projects (will be bundled at build time)
-            const migratePath = `${libDbPath}/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 ${migratePath} 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,13 +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') {
-            // Use src/lib/db for projects with src/ directory, otherwise lib/db
-            const libDbPath = project.usesSrcDirectory ? 'src/lib/db' : 'lib/db';
-            generatedFiles.push(`${libDbPath}/migrate.ts`);
-            generatedFiles.push(`${libDbPath}/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 {
@@ -106,8 +106,8 @@ async function main() {
     console.log(chalk.green('  ✓ entrypoint.sh'));
     if (response.includePostgres) {
         if (project.type === 'nextjs') {
-            const libDbPath = project.usesSrcDirectory ? 'src/lib/db' : 'lib/db';
-            console.log(chalk.green(`  ✓ ${libDbPath}/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,6 +2,6 @@ export interface DockerfileOptions {
     projectType: 'nextjs' | 'node';
     packageManager: 'pnpm' | 'npm' | 'yarn';
     includePostgres: boolean;
-    usesSrcDirectory?: boolean;
+    dbPath: string;
 }
 export declare function generateDockerfile(options: DockerfileOptions): string;

package/dist/templates/dockerfile.js

@@ -5,9 +5,7 @@ export function generateDockerfile(options) {
     return generateNodeDockerfile(options);
 }
 function generateNextjsDockerfile(options) {
-    const { packageManager, includePostgres, usesSrcDirectory } = options;
-    // Use src/lib/db for projects with src/ directory structure
-    const libDbPath = usesSrcDirectory ? 'src/lib/db' : 'lib/db';
+    const { packageManager, includePostgres, dbPath } = options;
     const installCmd = packageManager === 'pnpm'
         ? 'pnpm install --frozen-lockfile'
         : packageManager === 'yarn'
@@ -41,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} ${libDbPath}/migrate.ts --bundle --platform=node --target=node22 --outfile=${libDbPath}/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/${libDbPath}/migrations ./${libDbPath}/migrations
-COPY --from=builder --chown=nextjs:nodejs /app/${libDbPath}/migrate.bundle.js ./${libDbPath}/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` : '';
@@ -137,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'
@@ -155,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,6 +1,6 @@
 export interface EntrypointOptions {
     projectType: 'nextjs' | 'node';
     includePostgres: boolean;
-    usesSrcDirectory?: boolean;
+    dbPath: string;
 }
 export declare function generateEntrypoint(options: EntrypointOptions): string;

package/dist/templates/entrypoint.js

@@ -1,7 +1,5 @@
 export function generateEntrypoint(options) {
-    const { projectType, includePostgres, usesSrcDirectory } = options;
-    // Use src/lib/db for projects with src/ directory, otherwise lib/db
-    const libDbPath = usesSrcDirectory ? 'src/lib/db' : 'lib/db';
+    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
@@ -9,7 +7,7 @@ export function generateEntrypoint(options) {
             ? `
 # Run database migrations (bundled JS with all deps baked in)
 echo "⏳ Running database migrations..."
-node ${libDbPath}/migrate.bundle.js
+node ${dbPath}/migrate.bundle.js
 `
             : `
 # Run database migrations

package/dist/templates/migrate.d.ts

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

package/dist/templates/migrate.js

@@ -1,10 +1,9 @@
 export function generateMigrateScript(options) {
-    const projectType = options?.projectType ?? 'nextjs';
-    const usesSrcDirectory = options?.usesSrcDirectory ?? false;
-    // For Next.js, migrations are in lib/db/migrations (or src/lib/db/migrations for src/ projects)
-    // 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'
-        ? (usesSrcDirectory ? './src/lib/db/migrations' : './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.15",
+  "version": "1.1.17",
   "description": "CLI tool for setting up Coolify deployment on Panoptic projects",
   "type": "module",
   "main": "dist/index.js",