@friggframework/devtools 2.0.0--canary.666.81647c4.0 → 2.0.0--canary.668.8e53aa9.0

package/frigg-cli/__tests__/unit/commands/validate-wiring.test.js

@@ -1,92 +0,0 @@
-/**
- * build and deploy validate the app definition first and stop on errors;
- * start validates and only warns (ADR-051).
- */
-
-// child_process and node:child_process are one module to jest: one mock.
-const mockChildProcess = {
-    spawnSync: jest.fn(() => ({ status: 0 })),
-    spawn: jest.fn(),
-};
-jest.mock('child_process', () => mockChildProcess);
-jest.mock('node:child_process', () => mockChildProcess);
-jest.mock('../../../validate-command', () => ({
-    preflightValidation: jest.fn(),
-}));
-jest.mock('../../../doctor-command', () => ({ doctorCommand: jest.fn() }));
-jest.mock('../../../utils/database-validator', () => ({
-    validateDatabaseUrl: jest.fn(() => ({ valid: true })),
-    getDatabaseType: jest.fn(() => ({ dbType: 'postgresql' })),
-    checkPrismaClientGenerated: jest.fn(() => ({ generated: true })),
-}));
-jest.mock('dotenv', () => ({ config: jest.fn() }));
-
-const childProcess = mockChildProcess;
-const nodeChildProcess = mockChildProcess;
-const { preflightValidation } = require('../../../validate-command');
-const { buildCommand } = require('../../../build-command');
-const { deployCommand } = require('../../../deploy-command');
-const { startCommand } = require('../../../start-command');
-
-describe('validation before build, deploy and start', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.spyOn(console, 'log').mockImplementation(() => {});
-        jest.spyOn(console, 'warn').mockImplementation(() => {});
-        jest.spyOn(console, 'error').mockImplementation(() => {});
-        jest.spyOn(process, 'exit').mockImplementation(() => {});
-    });
-
-    afterEach(() => jest.restoreAllMocks());
-
-    it('build validates first and fails on errors', async () => {
-        preflightValidation.mockReturnValue(false);
-
-        await buildCommand({ stage: 'prod' });
-
-        expect(preflightValidation).toHaveBeenCalledWith({
-            command: 'build',
-            options: { stage: 'prod' },
-            failOnErrors: true,
-        });
-        expect(childProcess.spawnSync).not.toHaveBeenCalled();
-    });
-
-    it('build packages after a passing validation', async () => {
-        preflightValidation.mockReturnValue(true);
-
-        await buildCommand({ stage: 'prod' });
-
-        expect(childProcess.spawnSync).toHaveBeenCalled();
-    });
-
-    it('deploy validates first and fails on errors', async () => {
-        preflightValidation.mockReturnValue(false);
-
-        await deployCommand({ stage: 'prod', skipValidate: false });
-
-        expect(preflightValidation).toHaveBeenCalledWith({
-            command: 'deploy',
-            options: { stage: 'prod', skipValidate: false },
-            failOnErrors: true,
-        });
-        expect(childProcess.spawn).not.toHaveBeenCalled();
-    });
-
-    it('start validates and only warns', async () => {
-        preflightValidation.mockReturnValue(true);
-        nodeChildProcess.spawn.mockReturnValue({ on: jest.fn() });
-        const previous = process.env.DATABASE_URL;
-        process.env.DATABASE_URL = 'postgresql://localhost/frigg';
-
-        await startCommand({ stage: 'dev' });
-
-        process.env.DATABASE_URL = previous;
-        expect(preflightValidation).toHaveBeenCalledWith({
-            command: 'start',
-            options: { stage: 'dev' },
-            failOnErrors: false,
-        });
-        expect(nodeChildProcess.spawn).toHaveBeenCalled();
-    });
-});

package/frigg-cli/validate-command/__tests__/init-validation.test.js

@@ -1,63 +0,0 @@
-/**
- * `frigg init` validates the generated app with the same code path as
- * `frigg validate`, and never fails because of it (ADR-051).
- */
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-jest.mock('@inquirer/prompts', () => ({}));
-
-const BackendFirstHandler = require('../../init-command/backend-first-handler');
-
-function writeApp(source) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'frigg-init-'));
-    fs.writeFileSync(path.join(dir, 'package.json'), '{"name":"backend"}');
-    fs.writeFileSync(path.join(dir, 'index.js'), source);
-    return dir;
-}
-
-describe('frigg init validation', () => {
-    const dirs = [];
-    let log;
-
-    beforeEach(() => {
-        log = jest.spyOn(console, 'log').mockImplementation(() => {});
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-        for (const dir of dirs.splice(0))
-            fs.rmSync(dir, { recursive: true, force: true });
-    });
-
-    it('validates the real generated definition, not a stand-in', async () => {
-        const dir = writeApp(
-            "module.exports = { Definition: { integrations: [], database: { postgres: { enable: true, management: 'create-new' } } } };"
-        );
-        dirs.push(dir);
-        const handler = new BackendFirstHandler(dir, {});
-
-        const ok = await handler.validateGeneratedAppDefinition(
-            path.join(dir, 'index.js')
-        );
-
-        expect(ok).toBe(false);
-        expect(log.mock.calls.flat().join('\n')).toContain(
-            '/database/postgres/management'
-        );
-    });
-
-    it('stays quiet before npm install, when index.js cannot load its dependencies', async () => {
-        const dir = writeApp(
-            "require('@friggframework/api-module-does-not-exist');"
-        );
-        dirs.push(dir);
-        const handler = new BackendFirstHandler(dir, {});
-
-        await expect(
-            handler.validateGeneratedAppDefinition(path.join(dir, 'index.js'))
-        ).resolves.toBe(true);
-        expect(log).not.toHaveBeenCalled();
-    });
-});

package/frigg-cli/validate-command/__tests__/integrations-checks.test.js

@@ -1,133 +0,0 @@
-const { checkIntegrations } = require('../checks/integrations');
-
-class FakeApi {
-    static requesterType = 'oauth2';
-}
-
-const moduleDefinition = () => ({
-    moduleName: 'acme',
-    API: FakeApi,
-    requiredAuthMethods: {
-        getToken: async () => {},
-        getEntityDetails: async () => {},
-        getCredentialDetails: async () => {},
-        testAuthRequest: async () => {},
-        apiPropertiesToPersist: { credential: [], entity: [] },
-    },
-});
-
-function integrationClass(definition) {
-    return class Integration {
-        static Definition = definition;
-    };
-}
-
-const goodIntegration = () =>
-    integrationClass({
-        name: 'acme',
-        version: '1.0.0',
-        modules: { acme: { definition: moduleDefinition() } },
-    });
-
-const codes = (issues) =>
-    issues.map((i) => `${i.severity}:${i.code}:${i.pointer}`);
-
-describe('checkIntegrations', () => {
-    it('accepts a well-formed integration class', () => {
-        expect(
-            checkIntegrations({ integrations: [goodIntegration()] })
-        ).toEqual([]);
-    });
-
-    it('warns when the app lists no integrations', () => {
-        expect(codes(checkIntegrations({ integrations: [] }))).toEqual([
-            'warning:no-integrations:/integrations',
-        ]);
-    });
-
-    it('rejects an entry that is not a class', () => {
-        expect(
-            codes(
-                checkIntegrations({
-                    integrations: [{ Definition: { name: 'x' } }],
-                })
-            )
-        ).toEqual(['error:integration-not-a-class:/integrations/0']);
-    });
-
-    it('rejects a class without a static Definition', () => {
-        class Bare {}
-        expect(codes(checkIntegrations({ integrations: [Bare] }))).toEqual([
-            'error:integration-definition-missing:/integrations/0/Definition',
-        ]);
-    });
-
-    it('requires a valid name and modules, and warns on a missing version', () => {
-        const Cls = integrationClass({ name: '1 bad name' });
-        expect(codes(checkIntegrations({ integrations: [Cls] }))).toEqual([
-            'error:integration-name-invalid:/integrations/0/Definition/name',
-            'warning:integration-version-missing:/integrations/0/Definition/version',
-            'error:integration-modules-missing:/integrations/0/Definition/modules',
-        ]);
-    });
-
-    it('reports duplicate integration names', () => {
-        expect(
-            codes(
-                checkIntegrations({
-                    integrations: [goodIntegration(), goodIntegration()],
-                })
-            )
-        ).toEqual([
-            'error:integration-name-duplicate:/integrations/1/Definition/name',
-        ]);
-    });
-
-    it('checks module definitions the way Module.validateDefinition does', () => {
-        const definition = moduleDefinition();
-        delete definition.requiredAuthMethods.getToken;
-        delete definition.moduleName;
-        const Cls = integrationClass({
-            name: 'acme',
-            version: '1',
-            modules: { acme: { definition }, other: {} },
-        });
-
-        expect(codes(checkIntegrations({ integrations: [Cls] }))).toEqual([
-            'error:module-name-missing:/integrations/0/Definition/modules/acme/definition/moduleName',
-            'error:module-auth-method-missing:/integrations/0/Definition/modules/acme/definition/requiredAuthMethods/getToken',
-            'error:module-definition-missing:/integrations/0/Definition/modules/other/definition',
-        ]);
-    });
-
-    it('does not require getToken for non-OAuth2 modules', () => {
-        const definition = moduleDefinition();
-        definition.API = class {
-            static requesterType = 'apiKey';
-        };
-        delete definition.requiredAuthMethods.getToken;
-        const Cls = integrationClass({
-            name: 'acme',
-            version: '1',
-            modules: { acme: { definition } },
-        });
-
-        expect(checkIntegrations({ integrations: [Cls] })).toEqual([]);
-    });
-
-    it('warns that a module rateLimit is not applied', () => {
-        const definition = {
-            ...moduleDefinition(),
-            rateLimit: { requests: 10, period: 'second' },
-        };
-        const Cls = integrationClass({
-            name: 'acme',
-            version: '1',
-            modules: { acme: { definition } },
-        });
-
-        expect(codes(checkIntegrations({ integrations: [Cls] }))).toEqual([
-            'warning:module-rate-limit-ignored:/integrations/0/Definition/modules/acme/definition/rateLimit',
-        ]);
-    });
-});

package/frigg-cli/validate-command/__tests__/validate-app-definition.test.js

@@ -1,326 +0,0 @@
-const { validateDefinition } = require('../validate-app-definition');
-
-class Api {
-    static requesterType = 'oauth2';
-}
-const auth = {
-    getToken: async () => {},
-    getEntityDetails: async () => {},
-    getCredentialDetails: async () => {},
-    testAuthRequest: async () => {},
-    apiPropertiesToPersist: { credential: [], entity: [] },
-};
-class AcmeIntegration {
-    static Definition = {
-        name: 'acme',
-        version: '1.0.0',
-        modules: {
-            acme: {
-                definition: {
-                    moduleName: 'acme',
-                    API: Api,
-                    requiredAuthMethods: auth,
-                },
-            },
-        },
-    };
-}
-
-/** The app `frigg init` scaffolds, with one integration installed. */
-const scaffold = (overrides = {}) => ({
-    name: 'frigg-app',
-    integrations: [AcmeIntegration],
-    user: {
-        usePassword: true,
-        primary: 'individual',
-        individualUserRequired: true,
-        organizationUserRequired: false,
-    },
-    encryption: { fieldLevelEncryptionMethod: 'kms' },
-    managementMode: 'managed',
-    vpcIsolation: 'isolated',
-    vpc: { enable: false },
-    database: {
-        postgres: {
-            enable: true,
-            management: 'use-existing',
-            endpoint: 'db.example.com',
-        },
-    },
-    environment: { DATABASE_URL: true },
-    logging: { retentionInDays: 14 },
-    ssm: { enable: false },
-    ...overrides,
-});
-
-const summary = ({ errors, warnings }) => ({
-    errors: errors.map((i) => `${i.code} ${i.pointer}`),
-    warnings: warnings.map((i) => `${i.code} ${i.pointer}`),
-});
-
-describe('validateDefinition', () => {
-    it('passes a scaffolded app with an integration class', () => {
-        expect(
-            summary(
-                validateDefinition({
-                    definition: scaffold(),
-                    stage: 'prod',
-                    env: {},
-                })
-            )
-        ).toEqual({
-            errors: [],
-            warnings: ['no-effect /database/postgres/management'],
-        });
-    });
-
-    it('reports schema errors with JSON pointers and fix hints', () => {
-        const result = validateDefinition({
-            definition: scaffold({
-                vpc: { enable: false, mangement: 'discover' },
-                logging: { level: 'loud' },
-            }),
-            env: {},
-        });
-
-        expect(result.errors).toEqual([
-            expect.objectContaining({
-                code: 'unknown-key',
-                pointer: '/vpc/mangement',
-                hint: 'Did you mean "management"?',
-            }),
-            expect.objectContaining({
-                code: 'invalid-value',
-                pointer: '/logging/level',
-                hint: expect.stringContaining('"debug"'),
-            }),
-        ]);
-    });
-
-    it("rejects database.postgres.management 'existing', which the Aurora builder rejects", () => {
-        const definition = scaffold({
-            managementMode: undefined,
-            database: { postgres: { enable: true, management: 'existing' } },
-            vpc: { enable: true },
-        });
-
-        expect(
-            summary(validateDefinition({ definition, env: {} })).errors
-        ).toEqual(['invalid-value /database/postgres/management']);
-    });
-
-    it('reports a broken integration class', () => {
-        class Broken {
-            static Definition = { name: 'broken' };
-        }
-        const result = validateDefinition({
-            definition: scaffold({ integrations: [Broken] }),
-            env: {},
-        });
-
-        expect(summary(result).errors).toEqual([
-            'integration-modules-missing /integrations/0/Definition/modules',
-        ]);
-    });
-
-    it('reports an integration that is not a class once', () => {
-        const result = validateDefinition({
-            definition: scaffold({ integrations: ['acme'] }),
-            env: {},
-        });
-
-        expect(summary(result).errors).toEqual([
-            'integration-not-a-class /integrations/0',
-        ]);
-    });
-
-    it('reports a missing database', () => {
-        const result = validateDefinition({
-            definition: scaffold({ database: undefined }),
-            env: {},
-        });
-
-        expect(summary(result).errors).toEqual(['no-database /database']);
-    });
-
-    it('a non-object definition is a schema error, not a crash', () => {
-        expect(
-            summary(validateDefinition({ definition: 'nope', env: {} })).errors
-        ).toEqual(['invalid-type ']);
-    });
-});
-
-describe('semantic checks', () => {
-    const run = (overrides, options = {}) =>
-        summary(
-            validateDefinition({
-                definition: scaffold(overrides),
-                env: {},
-                ...options,
-            })
-        );
-
-    describe('encryption', () => {
-        it("requires AES_KEY_ID and AES_KEY in environment for 'aes'", () => {
-            expect(
-                run({ encryption: { fieldLevelEncryptionMethod: 'aes' } })
-                    .errors
-            ).toEqual([
-                'missing-encryption-env /environment/AES_KEY_ID',
-                'missing-encryption-env /environment/AES_KEY',
-            ]);
-        });
-
-        it('warns when the AES values are missing from the deploying shell', () => {
-            const result = run(
-                {
-                    encryption: { fieldLevelEncryptionMethod: 'aes' },
-                    environment: {
-                        DATABASE_URL: true,
-                        AES_KEY_ID: true,
-                        AES_KEY: true,
-                    },
-                },
-                { stage: 'prod', env: { AES_KEY_ID: 'k1' } }
-            );
-            expect(result.errors).toEqual([]);
-            expect(result.warnings).toContain(
-                'missing-env-value /environment/AES_KEY'
-            );
-        });
-
-        it('warns that a deployed stage without a method stores plaintext', () => {
-            expect(
-                run({ encryption: undefined }, { stage: 'prod' }).warnings
-            ).toContain(
-                'no-field-encryption /encryption/fieldLevelEncryptionMethod'
-            );
-        });
-
-        it('warns that stage dev never encrypts', () => {
-            expect(run({}, { stage: 'dev' }).warnings).toContain(
-                'encryption-bypassed /encryption/fieldLevelEncryptionMethod'
-            );
-        });
-
-        it('warns about the KMS key fallback outside managed mode', () => {
-            expect(
-                run({ managementMode: undefined, vpcIsolation: undefined })
-                    .warnings
-            ).toContain('kms-key-source /encryption/createResourceIfNoneFound');
-        });
-    });
-
-    describe('user', () => {
-        it('rejects a user config with which login always fails', () => {
-            expect(
-                run({ user: { individualUserRequired: false } }).errors
-            ).toEqual(['no-login /user']);
-        });
-
-        it('warns an organization-only app that individualUserRequired now defaults to true', () => {
-            expect(
-                run({ user: { organizationUserRequired: true } }).warnings
-            ).toContain('default-changed /user/individualUserRequired');
-        });
-
-        it('rejects adopterJwt without a secret and an app with every auth mode off', () => {
-            expect(
-                run({
-                    user: {
-                        authModes: {
-                            friggToken: false,
-                            sharedSecret: false,
-                            adopterJwt: false,
-                        },
-                    },
-                }).errors
-            ).toEqual(['no-auth-mode /user/authModes']);
-            expect(
-                run({ user: { authModes: { adopterJwt: true } } }).errors
-            ).toEqual(['missing-key /user/jwtConfig/secret']);
-        });
-
-        it('warns that user.password is the old spelling of usePassword', () => {
-            expect(run({ user: { password: true } }).warnings).toContain(
-                'deprecated-alias /user/password'
-            );
-        });
-    });
-
-    describe('management and VPC', () => {
-        it("warns that 'managed' does not stop the VPC builder applying vpc.management", () => {
-            expect(
-                run({ vpc: { enable: true, management: 'discover' } }).warnings
-            ).toContain('conflicting-settings /vpc/management');
-        });
-
-        it("warns when 'managed' is used without vpcIsolation", () => {
-            expect(run({ vpcIsolation: undefined }).warnings).toContain(
-                'ambiguous-default /vpcIsolation'
-            );
-        });
-
-        it('warns about subnet and NAT values the VPC builder ignores', () => {
-            const result = run({
-                managementMode: undefined,
-                vpc: {
-                    enable: true,
-                    subnets: { management: 'create-new' },
-                    natGateway: { management: 'discover' },
-                },
-            });
-            expect(result.warnings).toEqual(
-                expect.arrayContaining([
-                    'no-effect /vpc/subnets/management',
-                    'no-effect /vpc/natGateway/management',
-                ])
-            );
-        });
-
-        it('requires the ids use-existing needs', () => {
-            const result = run({
-                managementMode: undefined,
-                vpc: {
-                    enable: true,
-                    management: 'use-existing',
-                    subnets: { management: 'use-existing' },
-                },
-                database: {
-                    postgres: { enable: true, management: 'use-existing' },
-                },
-            });
-            expect(result.errors).toEqual([
-                'missing-key /vpc/vpcId',
-                'missing-key /vpc/subnets/ids',
-                'missing-key /database/postgres/endpoint',
-            ]);
-        });
-
-        it('warns that a private Aurora cluster is unreachable from Lambdas outside a VPC', () => {
-            expect(
-                run({
-                    managementMode: undefined,
-                    database: {
-                        postgres: { enable: true, management: 'managed' },
-                    },
-                }).warnings
-            ).toContain('unreachable-database /vpc/enable');
-        });
-    });
-
-    it('warns about keys nothing reads', () => {
-        expect(
-            run({ custom: { appName: 'x' }, security: { cors: {} } }).warnings
-        ).toEqual(
-            expect.arrayContaining(['no-effect /security', 'no-effect /custom'])
-        );
-    });
-
-    it("warns that 'ssm' environment entries need ssm.enable", () => {
-        expect(
-            run({ environment: { DATABASE_URL: true, API_KEY: 'ssm' } })
-                .warnings
-        ).toContain('ssm-inactive /environment/API_KEY');
-    });
-});