@friggframework/devtools 2.0.0-next.6 → 2.0.0-next.61

package/frigg-cli/__tests__/unit/utils/error-messages.test.js

@@ -0,0 +1,345 @@
+const {
+    DATABASE_URL_EXAMPLES,
+    getDatabaseUrlMissingError,
+    getDatabaseTypeNotConfiguredError,
+    getDatabaseConnectionError,
+    getPrismaClientNotGeneratedError,
+    getPrismaCommandError,
+    getDatabaseSetupSuccess
+} = require('../../../utils/error-messages');
+
+describe('Error Messages Utility', () => {
+    describe('DATABASE_URL_EXAMPLES', () => {
+        it('should include MongoDB connection string example', () => {
+            expect(DATABASE_URL_EXAMPLES.mongodb).toBeDefined();
+            expect(DATABASE_URL_EXAMPLES.mongodb).toContain('mongodb://');
+            expect(DATABASE_URL_EXAMPLES.mongodb).toContain('replicaSet=rs0');
+        });
+
+        it('should include DocumentDB connection string example', () => {
+            expect(DATABASE_URL_EXAMPLES.documentdb).toBeDefined();
+            expect(DATABASE_URL_EXAMPLES.documentdb).toContain('docdb');
+            expect(DATABASE_URL_EXAMPLES.documentdb).toContain('retryWrites=false');
+        });
+
+        it('should include PostgreSQL connection string example', () => {
+            expect(DATABASE_URL_EXAMPLES.postgresql).toBeDefined();
+            expect(DATABASE_URL_EXAMPLES.postgresql).toContain('postgresql://');
+            expect(DATABASE_URL_EXAMPLES.postgresql).toContain('schema=public');
+        });
+    });
+
+    describe('getDatabaseUrlMissingError()', () => {
+        it('should return formatted error message', () => {
+            const message = getDatabaseUrlMissingError();
+
+            expect(message).toBeTruthy();
+            expect(typeof message).toBe('string');
+        });
+
+        it('should include all database type examples', () => {
+            const message = getDatabaseUrlMissingError();
+
+            expect(message).toContain('MongoDB');
+            expect(message).toContain('DocumentDB');
+            expect(message).toContain('PostgreSQL');
+        });
+
+        it('should include example connection strings', () => {
+            const message = getDatabaseUrlMissingError();
+
+            expect(message).toContain(DATABASE_URL_EXAMPLES.mongodb);
+            expect(message).toContain(DATABASE_URL_EXAMPLES.documentdb);
+            expect(message).toContain(DATABASE_URL_EXAMPLES.postgresql);
+        });
+
+        it('should suggest running frigg db:setup', () => {
+            const message = getDatabaseUrlMissingError();
+
+            expect(message).toContain('frigg db:setup');
+        });
+
+        it('should mention .env file', () => {
+            const message = getDatabaseUrlMissingError();
+
+            expect(message).toContain('.env');
+        });
+    });
+
+    describe('getDatabaseTypeNotConfiguredError()', () => {
+        it('should return formatted error message', () => {
+            const message = getDatabaseTypeNotConfiguredError();
+
+            expect(message).toBeTruthy();
+            expect(typeof message).toBe('string');
+        });
+
+        it('should include PostgreSQL configuration example', () => {
+            const message = getDatabaseTypeNotConfiguredError();
+
+            expect(message).toContain('postgres');
+            expect(message).toContain('enable: true');
+        });
+
+        it('should include MongoDB configuration example', () => {
+            const message = getDatabaseTypeNotConfiguredError();
+
+            expect(message).toContain('mongoDB');
+            expect(message).toContain('enable: true');
+        });
+
+        it('should include DocumentDB configuration example', () => {
+            const message = getDatabaseTypeNotConfiguredError();
+
+            expect(message).toContain('documentDB');
+            expect(message).toContain('enable: true');
+        });
+
+        it('should mention app definition location', () => {
+            const message = getDatabaseTypeNotConfiguredError();
+
+            expect(message).toContain('backend/index.js');
+            expect(message).toContain('index.js');
+        });
+    });
+
+    describe('getDatabaseConnectionError()', () => {
+        const mockError = 'Connection refused';
+
+        it('should include error message for MongoDB', () => {
+            const message = getDatabaseConnectionError(mockError, 'mongodb');
+
+            expect(message).toContain(mockError);
+        });
+
+        it('should include error message for PostgreSQL', () => {
+            const message = getDatabaseConnectionError(mockError, 'postgresql');
+
+            expect(message).toContain(mockError);
+        });
+
+        it('should include MongoDB-specific troubleshooting for MongoDB', () => {
+            const message = getDatabaseConnectionError(mockError, 'mongodb');
+
+            expect(message).toContain('replica set');
+            expect(message).toContain('rs.initiate');
+            expect(message).toContain('mongosh');
+            expect(message).toContain('27017');
+        });
+
+        it('should include DocumentDB-specific troubleshooting for DocumentDB', () => {
+            const message = getDatabaseConnectionError(mockError, 'documentdb');
+
+            expect(message).toContain('DocumentDB');
+            expect(message).toContain('retryWrites=false');
+            expect(message).toContain('global-bundle.pem');
+        });
+
+        it('should include PostgreSQL-specific troubleshooting for PostgreSQL', () => {
+            const message = getDatabaseConnectionError(mockError, 'postgresql');
+
+            expect(message).toContain('pg_hba.conf');
+            expect(message).toContain('pg_isready');
+            expect(message).toContain('psql');
+            expect(message).toContain('5432');
+        });
+
+        it('should not include PostgreSQL troubleshooting for MongoDB', () => {
+            const message = getDatabaseConnectionError(mockError, 'mongodb');
+
+            expect(message).not.toContain('pg_hba.conf');
+            expect(message).not.toContain('pg_isready');
+        });
+
+        it('should not include MongoDB troubleshooting for PostgreSQL', () => {
+            const message = getDatabaseConnectionError(mockError, 'postgresql');
+
+            expect(message).not.toContain('replica set');
+            expect(message).not.toContain('rs.initiate');
+        });
+
+        it('should include general troubleshooting steps', () => {
+            const messageMongo = getDatabaseConnectionError(mockError, 'mongodb');
+            const messagePostgres = getDatabaseConnectionError(mockError, 'postgresql');
+
+            expect(messageMongo).toContain('Troubleshooting');
+            expect(messagePostgres).toContain('Troubleshooting');
+        });
+
+        it('should display database name in the error output', () => {
+            const message = getDatabaseConnectionError(mockError, 'documentdb');
+
+            expect(message).toContain('AWS DocumentDB (MongoDB-compatible)');
+        });
+
+        it('should show DATABASE_URL when available', () => {
+            process.env.DATABASE_URL = 'mongodb://test';
+            const message = getDatabaseConnectionError(mockError, 'mongodb');
+
+            expect(message).toContain('mongodb://test');
+            delete process.env.DATABASE_URL;
+        });
+
+        it('should handle missing DATABASE_URL gracefully', () => {
+            delete process.env.DATABASE_URL;
+            const message = getDatabaseConnectionError(mockError, 'mongodb');
+
+            expect(message).toContain('not set');
+        });
+    });
+
+    describe('getPrismaClientNotGeneratedError()', () => {
+        it('should return error message for MongoDB', () => {
+            const message = getPrismaClientNotGeneratedError('mongodb');
+
+            expect(message).toBeTruthy();
+            expect(message).toContain('mongodb');
+        });
+
+        it('should return error message for PostgreSQL', () => {
+            const message = getPrismaClientNotGeneratedError('postgresql');
+
+            expect(message).toBeTruthy();
+            expect(message).toContain('postgresql');
+        });
+
+        it('should include correct client package name for MongoDB', () => {
+            const message = getPrismaClientNotGeneratedError('mongodb');
+
+            expect(message).toContain('@prisma-mongodb/client');
+        });
+
+        it('should mention Mongo client reuse for DocumentDB', () => {
+            const message = getPrismaClientNotGeneratedError('documentdb');
+
+            expect(message).toContain('@prisma-mongodb/client');
+            expect(message).toContain('DocumentDB reuses the MongoDB Prisma client');
+        });
+
+        it('should include correct client package name for PostgreSQL', () => {
+            const message = getPrismaClientNotGeneratedError('postgresql');
+
+            expect(message).toContain('@prisma-postgresql/client');
+        });
+
+        it('should suggest running frigg db:setup', () => {
+            const message = getPrismaClientNotGeneratedError('mongodb');
+
+            expect(message).toContain('frigg db:setup');
+        });
+
+        it('should explain what will happen when running db:setup', () => {
+            const message = getPrismaClientNotGeneratedError('mongodb');
+
+            expect(message).toContain('Generate the Prisma client');
+            expect(message).toContain('Set up database schema');
+        });
+    });
+
+    describe('getPrismaCommandError()', () => {
+        const mockCommand = 'generate';
+        const mockError = 'Schema validation failed';
+
+        it('should include command name', () => {
+            const message = getPrismaCommandError(mockCommand, mockError);
+
+            expect(message).toContain('generate');
+        });
+
+        it('should include error message', () => {
+            const message = getPrismaCommandError(mockCommand, mockError);
+
+            expect(message).toContain(mockError);
+        });
+
+        it('should list common causes', () => {
+            const message = getPrismaCommandError(mockCommand, mockError);
+
+            expect(message).toContain('Common causes');
+            expect(message).toContain('schema');
+        });
+
+        it('should suggest running frigg db:setup', () => {
+            const message = getPrismaCommandError(mockCommand, mockError);
+
+            expect(message).toContain('frigg db:setup');
+        });
+
+        it('should suggest checking DATABASE_URL', () => {
+            const message = getPrismaCommandError(mockCommand, mockError);
+
+            expect(message).toContain('DATABASE_URL');
+        });
+
+        it('should work with different command names', () => {
+            const migrateMessage = getPrismaCommandError('migrate', mockError);
+            const pushMessage = getPrismaCommandError('db push', mockError);
+
+            expect(migrateMessage).toContain('migrate');
+            expect(pushMessage).toContain('db push');
+        });
+    });
+
+    describe('getDatabaseSetupSuccess()', () => {
+        it('should include database type for MongoDB', () => {
+            const message = getDatabaseSetupSuccess('mongodb', 'development');
+
+            expect(message).toContain('MongoDB');
+        });
+
+        it('should include database type for PostgreSQL', () => {
+            const message = getDatabaseSetupSuccess('postgresql', 'production');
+
+            expect(message).toContain('PostgreSQL');
+        });
+
+        it('should include database type for DocumentDB', () => {
+            const message = getDatabaseSetupSuccess('documentdb', 'production');
+
+            expect(message).toContain('AWS DocumentDB (MongoDB-compatible)');
+        });
+
+        it('should include stage information', () => {
+            const devMessage = getDatabaseSetupSuccess('mongodb', 'development');
+            const prodMessage = getDatabaseSetupSuccess('postgresql', 'production');
+
+            expect(devMessage).toContain('development');
+            expect(prodMessage).toContain('production');
+        });
+
+        it('should mention different operations for MongoDB vs PostgreSQL', () => {
+            const mongoMessage = getDatabaseSetupSuccess('mongodb', 'development');
+            const postgresMessage = getDatabaseSetupSuccess('postgresql', 'development');
+
+            expect(mongoMessage).toContain('Schema pushed');
+            expect(postgresMessage).toContain('Migrations applied');
+        });
+
+        it('should mention DocumentDB-specific schema messaging', () => {
+            const message = getDatabaseSetupSuccess('documentdb', 'development');
+
+            expect(message).toContain('Schema pushed to DocumentDB');
+        });
+
+        it('should suggest next steps', () => {
+            const message = getDatabaseSetupSuccess('mongodb', 'development');
+
+            expect(message).toContain('frigg start');
+            expect(message).toContain('Next steps');
+        });
+
+        it('should confirm what happened during setup', () => {
+            const message = getDatabaseSetupSuccess('mongodb', 'development');
+
+            expect(message).toContain('Prisma client generated');
+            expect(message).toContain('Database connection verified');
+        });
+
+        it('should show success indicators', () => {
+            const message = getDatabaseSetupSuccess('mongodb', 'development');
+
+            expect(message).toContain('successfully');
+            expect(message).toContain('completed');
+        });
+    });
+});

package/frigg-cli/__tests__/unit/version-detection.test.js

@@ -0,0 +1,171 @@
+/**
+ * Version Detection Tests
+ *
+ * Tests for the CLI version detection wrapper that prefers local installations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const semver = require('semver');
+
+describe('Version Detection Logic', () => {
+    describe('semver comparison', () => {
+        test('should prefer local when local version is newer', () => {
+            const localVersion = '2.1.0';
+            const globalVersion = '2.0.0';
+
+            const comparison = semver.compare(localVersion, globalVersion);
+
+            expect(comparison).toBeGreaterThan(0);
+        });
+
+        test('should prefer local when versions are equal', () => {
+            const localVersion = '2.0.0';
+            const globalVersion = '2.0.0';
+
+            const comparison = semver.compare(localVersion, globalVersion);
+
+            expect(comparison).toBe(0);
+        });
+
+        test('should warn when global is newer than local', () => {
+            const localVersion = '2.0.0';
+            const globalVersion = '2.1.0';
+
+            const comparison = semver.compare(localVersion, globalVersion);
+
+            expect(comparison).toBeLessThan(0);
+        });
+
+        test('should handle prerelease versions correctly', () => {
+            const localVersion = '2.0.0-next.1';
+            const globalVersion = '2.0.0-next.0';
+
+            const comparison = semver.compare(localVersion, globalVersion);
+
+            expect(comparison).toBeGreaterThan(0);
+        });
+
+        test('should prefer release over prerelease', () => {
+            const localVersion = '2.0.0';
+            const globalVersion = '2.0.0-next.0';
+
+            const comparison = semver.compare(localVersion, globalVersion);
+
+            expect(comparison).toBeGreaterThan(0);
+        });
+    });
+
+    describe('local CLI detection', () => {
+        test('should find local installation in node_modules', () => {
+            const cwd = process.cwd();
+            const localCliPath = path.join(cwd, 'node_modules', '@friggframework', 'frigg-cli');
+
+            // This test validates the path construction logic
+            expect(localCliPath).toContain('node_modules');
+            expect(localCliPath).toContain('@friggframework');
+            expect(localCliPath).toContain('frigg-cli');
+        });
+
+        test('should construct correct paths for package.json and index.js', () => {
+            const cwd = process.cwd();
+            const localCliPath = path.join(cwd, 'node_modules', '@friggframework', 'frigg-cli');
+            const localCliPackageJson = path.join(localCliPath, 'package.json');
+            const localCliIndex = path.join(localCliPath, 'index.js');
+
+            expect(localCliPackageJson).toContain('package.json');
+            expect(localCliIndex).toContain('index.js');
+        });
+    });
+
+    describe('environment variable check', () => {
+        test('should skip version check when FRIGG_CLI_SKIP_VERSION_CHECK is true', () => {
+            const originalEnv = process.env.FRIGG_CLI_SKIP_VERSION_CHECK;
+
+            process.env.FRIGG_CLI_SKIP_VERSION_CHECK = 'true';
+            const shouldSkip = process.env.FRIGG_CLI_SKIP_VERSION_CHECK === 'true';
+            expect(shouldSkip).toBe(true);
+
+            // Restore
+            if (originalEnv !== undefined) {
+                process.env.FRIGG_CLI_SKIP_VERSION_CHECK = originalEnv;
+            } else {
+                delete process.env.FRIGG_CLI_SKIP_VERSION_CHECK;
+            }
+        });
+
+        test('should not skip when environment variable is not set', () => {
+            const originalEnv = process.env.FRIGG_CLI_SKIP_VERSION_CHECK;
+            delete process.env.FRIGG_CLI_SKIP_VERSION_CHECK;
+
+            const shouldSkip = process.env.FRIGG_CLI_SKIP_VERSION_CHECK === 'true';
+            expect(shouldSkip).toBe(false);
+
+            // Restore
+            if (originalEnv !== undefined) {
+                process.env.FRIGG_CLI_SKIP_VERSION_CHECK = originalEnv;
+            }
+        });
+    });
+
+    describe('version detection decision matrix', () => {
+        const scenarios = [
+            {
+                name: 'local newer than global',
+                local: '2.1.0',
+                global: '2.0.0',
+                expected: 'use_local',
+            },
+            {
+                name: 'local equal to global',
+                local: '2.0.0',
+                global: '2.0.0',
+                expected: 'use_local',
+            },
+            {
+                name: 'global newer than local',
+                local: '2.0.0',
+                global: '2.1.0',
+                expected: 'warn_and_use_global',
+            },
+            {
+                name: 'local prerelease newer',
+                local: '2.0.0-next.1',
+                global: '2.0.0-next.0',
+                expected: 'use_local',
+            },
+        ];
+
+        scenarios.forEach(({ name, local, global, expected }) => {
+            test(`should ${expected.replace('_', ' ')} when ${name}`, () => {
+                const comparison = semver.compare(local, global);
+
+                if (expected === 'use_local') {
+                    expect(comparison).toBeGreaterThanOrEqual(0);
+                } else if (expected === 'warn_and_use_global') {
+                    expect(comparison).toBeLessThan(0);
+                }
+            });
+        });
+    });
+
+    describe('argument forwarding', () => {
+        test('should extract arguments correctly from process.argv', () => {
+            // Simulate process.argv
+            const mockArgv = ['node', '/path/to/frigg', 'doctor', 'my-stack', '--region', 'us-east-1'];
+            const args = mockArgv.slice(2);
+
+            expect(args).toEqual(['doctor', 'my-stack', '--region', 'us-east-1']);
+        });
+
+        test('should forward all arguments to local CLI', () => {
+            const mockArgv = ['node', '/path/to/frigg', 'repair', 'my-stack', '--import', '--yes'];
+            const args = mockArgv.slice(2);
+
+            expect(args).toContain('repair');
+            expect(args).toContain('my-stack');
+            expect(args).toContain('--import');
+            expect(args).toContain('--yes');
+        });
+    });
+});