@friggframework/devtools 2.0.0--canary.653.8213092.0 → 2.0.0--canary.654.be44e66.0

package/frigg-cli/init-command/backend-first-handler.js

@@ -678,7 +678,7 @@ To integrate Frigg into your production application:
                         credentials: true
                     }
                 },
-                logging: { level: 'info' },
+                logging: { level: 'info', retentionInDays: 30 },
                 custom: {
                     appName: 'My Frigg Application',
                     version: '1.0.0',

package/frigg-cli/package.json

@@ -26,7 +26,7 @@
     "lodash": "4.18.1",
     "node-cache": "^5.1.2",
     "open": "^8.4.2",
-    "osls": "^3.40.1",
+    "osls": "^3.58.0",
     "semver": "^7.6.0",
     "validate-npm-package-name": "^5.0.0"
   },

package/infrastructure/domains/integration/integration-builder.js

@@ -32,10 +32,6 @@ const {
 const {
     nestedNodeModulesExcludes,
 } = require('../shared/utilities/nested-node-modules');
-const {
-    INTEGRATION_QUEUE_MAX_RECEIVE_COUNT,
-    QUEUE_MAX_RECEIVE_COUNT_ENV,
-} = require('@friggframework/core/queues/queue-delivery');
 
 class IntegrationBuilder extends InfrastructureBuilder {
     constructor() {
@@ -573,7 +569,7 @@ class IntegrationBuilder extends InfrastructureBuilder {
                 MessageRetentionPeriod: 345600, // 4 days (SQS default)
                 VisibilityTimeout: 1800,
                 RedrivePolicy: {
-                    maxReceiveCount: INTEGRATION_QUEUE_MAX_RECEIVE_COUNT,
+                    maxReceiveCount: 3,
                     deadLetterTargetArn: {
                         'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
                     },
@@ -581,14 +577,6 @@ class IntegrationBuilder extends InfrastructureBuilder {
             },
         };
 
-        const queueWorker = result.functions[`${integrationName}QueueWorker`];
-        queueWorker.environment = {
-            ...queueWorker.environment,
-            [QUEUE_MAX_RECEIVE_COUNT_ENV]: String(
-                INTEGRATION_QUEUE_MAX_RECEIVE_COUNT
-            ),
-        };
-
         // Add queue URL to environment
         this.setQueueUrlEnvironment(
             integrationName,

package/infrastructure/domains/integration/integration-builder.test.js

@@ -4,10 +4,6 @@
  * Tests integration-specific Lambda functions and SQS queues
  */
 
-const {
-    INTEGRATION_QUEUE_MAX_RECEIVE_COUNT,
-    QUEUE_MAX_RECEIVE_COUNT_ENV,
-} = require('@friggframework/core/queues/queue-delivery');
 const { IntegrationBuilder } = require('./integration-builder');
 const { ValidationResult } = require('../shared/base-builder');
 
@@ -211,54 +207,6 @@ describe('IntegrationBuilder', () => {
             });
         });
 
-        it('takes the redrive max receive count from the core runtime contract', async () => {
-            const result = await integrationBuilder.build(
-                { integrations: [{ Definition: { name: 'test' } }] },
-                {}
-            );
-
-            expect(
-                result.resources.TestQueue.Properties.RedrivePolicy
-                    .maxReceiveCount
-            ).toBe(INTEGRATION_QUEUE_MAX_RECEIVE_COUNT);
-        });
-
-        it('tells the queue worker the max receive count of the queue it owns', async () => {
-            const result = await integrationBuilder.build(
-                { integrations: [{ Definition: { name: 'test' } }] },
-                {}
-            );
-
-            expect(
-                result.functions.testQueueWorker.environment[
-                    QUEUE_MAX_RECEIVE_COUNT_ENV
-                ]
-            ).toBe('3');
-        });
-
-        it('leaves the max receive count unset for an external queue', async () => {
-            const result = await integrationBuilder.build(
-                {
-                    integrations: [
-                        {
-                            Definition: { name: 'test' },
-                            ownership: { queue: 'external' },
-                            queue: {
-                                url: 'https://sqs.us-east-1.amazonaws.com/123456789012/test-queue',
-                            },
-                        },
-                    ],
-                },
-                {}
-            );
-
-            expect(
-                result.functions.testQueueWorker.environment?.[
-                    QUEUE_MAX_RECEIVE_COUNT_ENV
-                ]
-            ).toBeUndefined();
-        });
-
         it('should create queue worker function', async () => {
             const appDefinition = {
                 integrations: [

package/infrastructure/domains/parameters/offload-utils.js

@@ -53,6 +53,13 @@ const FRAMEWORK_ENV_BLOCKLIST = new Set([
     'FRIGG_SSM_OFFLOADED_KEYS',
     'FRIGG_SSM_CACHE_TTL',
     'WORKER_FUNCTION_NAME',
+    // Read by the logger, telemetry flush and Prisma at INIT, before SSM loads
+    'FRIGG_LOG_LEVEL',
+    'AWS_LAMBDA_LOG_LEVEL',
+    'AWS_LAMBDA_LOG_FORMAT',
+    'OTEL_FLUSH_TIMEOUT_MS',
+    'DEBUG_VERBOSE',
+    'PRISMA_LOG_LEVEL',
     // Reserved AWS Lambda runtime variables
     '_HANDLER',
     '_X_AMZN_TRACE_ID',

package/infrastructure/domains/parameters/offload-utils.test.js

@@ -190,4 +190,17 @@ describe('offload-utils', () => {
             expect(FRAMEWORK_ENV_BLOCKLIST.has(key)).toBe(true);
         }
     });
+
+    it('blocklist covers the logger keys read at INIT (ADR-048)', () => {
+        for (const key of [
+            'FRIGG_LOG_LEVEL',
+            'AWS_LAMBDA_LOG_LEVEL',
+            'AWS_LAMBDA_LOG_FORMAT',
+            'OTEL_FLUSH_TIMEOUT_MS',
+            'DEBUG_VERBOSE',
+            'PRISMA_LOG_LEVEL',
+        ]) {
+            expect(FRAMEWORK_ENV_BLOCKLIST.has(key)).toBe(true);
+        }
+    });
 });

package/infrastructure/domains/security/iam-generator.js

@@ -467,6 +467,7 @@ function generateIAMCloudFormation(options = {}) {
                 'logs:FilterLogEvents',
                 'logs:PutLogEvents',
                 'logs:PutRetentionPolicy',
+                'logs:DeleteRetentionPolicy',
             ],
             Resource: [
                 {

package/infrastructure/domains/security/iam-generator.test.js

@@ -1,4 +1,11 @@
-const { generateIAMCloudFormation, getFeatureSummary } = require('./iam-generator');
+const fs = require('fs');
+const path = require('path');
+const {
+    generateIAMCloudFormation,
+    getFeatureSummary,
+    generateBasicIAMPolicy,
+    generateFullIAMPolicy,
+} = require('./iam-generator');
 
 describe('IAM Generator', () => {
     describe('getFeatureSummary', () => {
@@ -250,6 +257,28 @@ describe('IAM Generator', () => {
             expect(yaml).toContain('iam:ListPolicyVersions');
         });
 
+        it('should grant logs:DeleteRetentionPolicy so logging.retentionInDays can be removed', () => {
+            const yaml = generateIAMCloudFormation({
+                appName: 'test-app',
+                features: getFeatureSummary({ name: 'test-app' }).features,
+            });
+
+            expect(yaml).toContain('logs:PutRetentionPolicy');
+            expect(yaml).toContain('logs:DeleteRetentionPolicy');
+        });
+
+        it('should grant logs:DeleteRetentionPolicy in the static policy templates', () => {
+            for (const policy of [generateBasicIAMPolicy(), generateFullIAMPolicy()]) {
+                const actions = policy.Statement.flatMap((statement) => statement.Action);
+                expect(actions).toContain('logs:DeleteRetentionPolicy');
+            }
+            const stackYaml = fs.readFileSync(
+                path.join(__dirname, 'templates/frigg-deployment-iam-stack.yaml'),
+                'utf8'
+            );
+            expect(stackYaml).toContain("'logs:DeleteRetentionPolicy'");
+        });
+
         it('should include internal-error-queue pattern in SQS resources', () => {
             const appDefinition = {
                 name: 'test-app',

package/infrastructure/domains/security/templates/frigg-deployment-iam-stack.yaml

@@ -238,6 +238,7 @@ Resources:
               - 'logs:FilterLogEvents'
               - 'logs:PutLogEvents'
               - 'logs:PutRetentionPolicy'
+              - 'logs:DeleteRetentionPolicy'
             Resource:
               - !Sub 'arn:aws:logs:*:${AWS::AccountId}:log-group:/aws/lambda/*frigg*'
               - !Sub 'arn:aws:logs:*:${AWS::AccountId}:log-group:/aws/lambda/*frigg*:*'

package/infrastructure/domains/security/templates/iam-policy-basic.json

@@ -183,7 +183,8 @@
         "logs:DescribeLogStreams",
         "logs:FilterLogEvents",
         "logs:PutLogEvents",
-        "logs:PutRetentionPolicy"
+        "logs:PutRetentionPolicy",
+        "logs:DeleteRetentionPolicy"
       ],
       "Resource": [
         "arn:aws:logs:*:*:log-group:/aws/lambda/*frigg*",

package/infrastructure/domains/security/templates/iam-policy-full.json

@@ -183,7 +183,8 @@
         "logs:DescribeLogStreams",
         "logs:FilterLogEvents",
         "logs:PutLogEvents",
-        "logs:PutRetentionPolicy"
+        "logs:PutRetentionPolicy",
+        "logs:DeleteRetentionPolicy"
       ],
       "Resource": [
         "arn:aws:logs:*:*:log-group:/aws/lambda/*frigg*",

package/infrastructure/domains/shared/environment-builder.js

@@ -13,6 +13,7 @@ const {
     isSsmOffloadActive,
     getOffloadedKeys,
 } = require('../parameters/offload-utils');
+const { normalizeLogLevel } = require('./utilities/logging-config');
 
 // OTLP-family exporters read their endpoint/headers from these standard env
 // vars (ADR-011). When such an exporter is configured we auto-register them as
@@ -44,6 +45,20 @@ function addTelemetryEnvPassthrough(appDefinition, envVars) {
     }
 }
 
+// ADR-048 §12: logging.level wins over an `environment` passthrough. INFO is
+// the core default, so it emits no env var.
+function addLoggingEnv(appDefinition, envVars) {
+    const level = appDefinition?.logging?.level;
+    if (level === undefined) return;
+
+    const normalized = normalizeLogLevel(level);
+    if (normalized === 'INFO') {
+        delete envVars.FRIGG_LOG_LEVEL;
+        return;
+    }
+    envVars.FRIGG_LOG_LEVEL = normalized;
+}
+
 /**
  * Get environment variables from AppDefinition
  *
@@ -120,6 +135,8 @@ function getAppEnvironmentVars(appDefinition) {
         envKeys.push(key);
     }
 
+    addLoggingEnv(appDefinition, envVars);
+
     if (envKeys.length > 0) {
         console.log(
             `   Found ${envKeys.length} environment variables: ${envKeys.join(

package/infrastructure/domains/shared/environment-builder.test.js

@@ -147,6 +147,67 @@ describe('Environment Builder', () => {
         });
     });
 
+    describe('logging env (ADR-048)', () => {
+        it.each(['debug', 'WARN', 'Error'])(
+            'emits literal upper-case FRIGG_LOG_LEVEL for level "%s"',
+            (level) => {
+                const result = getAppEnvironmentVars({ logging: { level } });
+
+                expect(result.FRIGG_LOG_LEVEL).toBe(level.toUpperCase());
+            }
+        );
+
+        it.each(['info', 'INFO'])(
+            'emits nothing for the default level "%s"',
+            (level) => {
+                const result = getAppEnvironmentVars({ logging: { level } });
+
+                expect(result).not.toHaveProperty('FRIGG_LOG_LEVEL');
+            }
+        );
+
+        it('emits nothing when logging or logging.level is absent', () => {
+            expect(getAppEnvironmentVars({})).not.toHaveProperty(
+                'FRIGG_LOG_LEVEL'
+            );
+            expect(
+                getAppEnvironmentVars({ logging: { retentionInDays: 30 } })
+            ).not.toHaveProperty('FRIGG_LOG_LEVEL');
+        });
+
+        it('lets logging.level win over an environment passthrough', () => {
+            const result = getAppEnvironmentVars({
+                environment: { FRIGG_LOG_LEVEL: true },
+                logging: { level: 'error' },
+            });
+
+            expect(result.FRIGG_LOG_LEVEL).toBe('ERROR');
+        });
+
+        it('drops an environment passthrough when logging.level is INFO', () => {
+            const result = getAppEnvironmentVars({
+                environment: { FRIGG_LOG_LEVEL: true },
+                logging: { level: 'info' },
+            });
+
+            expect(result).not.toHaveProperty('FRIGG_LOG_LEVEL');
+        });
+
+        it('keeps an environment passthrough when logging.level is absent', () => {
+            const result = getAppEnvironmentVars({
+                environment: { FRIGG_LOG_LEVEL: true },
+            });
+
+            expect(result.FRIGG_LOG_LEVEL).toBe("${env:FRIGG_LOG_LEVEL, ''}");
+        });
+
+        it('throws on an unknown level', () => {
+            expect(() =>
+                getAppEnvironmentVars({ logging: { level: 'verbose' } })
+            ).toThrow(/logging\.level/);
+        });
+    });
+
     describe("getAppEnvironmentVars() - 'ssm' offload", () => {
         const originalSkipDiscovery = process.env.FRIGG_SKIP_AWS_DISCOVERY;
 

package/infrastructure/domains/shared/utilities/base-definition-factory.js

@@ -9,6 +9,7 @@
 
 const { buildEnvironment } = require('../environment-builder');
 const { nestedNodeModulesExcludes } = require('./nested-node-modules');
+const { buildLoggingProviderConfig } = require('./logging-config');
 
 /**
  * Create base serverless definition with core functions and resources
@@ -33,6 +34,7 @@ function createBaseDefinition(
     usePrismaLayer = true
 ) {
     const region = process.env.AWS_REGION || 'us-east-1';
+    const loggingConfig = buildLoggingProviderConfig(AppDefinition.logging);
 
     // Package config for handlers that skip esbuild (need node_modules dependencies)
     // Include backend src/ and index.js since handlers load the app definition
@@ -164,7 +166,7 @@ function createBaseDefinition(
     };
 
     return {
-        frameworkVersion: '>=3.17.0',
+        frameworkVersion: loggingConfig.frameworkVersion || '>=3.17.0',
         service: AppDefinition.name || 'create-frigg-app',
         package: {
             individually: true,
@@ -218,6 +220,7 @@ function createBaseDefinition(
                 name: '${opt:stage, "dev"}-${self:service}',
                 disableDefaultEndpoint: false,
             },
+            ...loggingConfig.provider,
         },
         plugins: [
             'serverless-esbuild',

package/infrastructure/domains/shared/utilities/base-definition-factory.test.js

@@ -317,3 +317,73 @@ describe('nested node_modules (lambda.keepNestedNodeModules)', () => {
         }
     });
 });
+
+describe('logging (ADR-048)', () => {
+    const build = (logging) =>
+        createBaseDefinition({ name: 'test-app', ...(logging && { logging }) }, {}, {});
+
+    it('emits no logs, logRetentionInDays or frameworkVersion change when logging is absent', () => {
+        const result = build();
+
+        expect(result.provider.logs).toBeUndefined();
+        expect(result.provider.logRetentionInDays).toBeUndefined();
+        expect(result.frameworkVersion).toBe('>=3.17.0');
+    });
+
+    it('maps logging.level to provider.logs.lambda and sets frameworkVersion >=3.58.0', () => {
+        const result = build({ level: 'warn' });
+
+        expect(result.provider.logs).toEqual({
+            lambda: {
+                logFormat: 'JSON',
+                applicationLogLevel: 'WARN',
+                systemLogLevel: 'INFO',
+            },
+        });
+        expect(result.provider.logRetentionInDays).toBeUndefined();
+        expect(result.frameworkVersion).toBe('>=3.58.0');
+    });
+
+    it.each(['info', 'INFO', 'Info', 'fatal', 'TRACE'])(
+        'accepts level "%s" in any case',
+        (level) => {
+            const result = build({ level });
+
+            expect(result.provider.logs.lambda.applicationLogLevel).toBe(
+                level.toUpperCase()
+            );
+        }
+    );
+
+    it.each(['verbose', 'warning', '', 3])('throws on unknown level %p', (level) => {
+        expect(() => build({ level })).toThrow(/logging\.level/);
+    });
+
+    it('maps retentionInDays to provider.logRetentionInDays without a logs block', () => {
+        const result = build({ retentionInDays: 30 });
+
+        expect(result.provider.logRetentionInDays).toBe(30);
+        expect(result.provider.logs).toBeUndefined();
+        expect(result.frameworkVersion).toBe('>=3.17.0');
+    });
+
+    it('accepts 1096, which CloudWatch allows but the osls schema omits', () => {
+        expect(build({ retentionInDays: 1096 }).provider.logRetentionInDays).toBe(1096);
+    });
+
+    it.each([10, 0, -1, 30.5, '30'])(
+        'throws on retentionInDays %p, which CloudWatch rejects',
+        (retentionInDays) => {
+            expect(() => build({ retentionInDays })).toThrow(
+                /logging\.retentionInDays/
+            );
+        }
+    );
+
+    it('sets both level and retention together', () => {
+        const result = build({ level: 'debug', retentionInDays: 14 });
+
+        expect(result.provider.logs.lambda.applicationLogLevel).toBe('DEBUG');
+        expect(result.provider.logRetentionInDays).toBe(14);
+    });
+});

package/infrastructure/domains/shared/utilities/logging-config.js

@@ -0,0 +1,77 @@
+const LOG_LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'];
+
+// CloudWatch Logs PutRetentionPolicy values. The osls schema copy lacks 1096.
+const RETENTION_DAYS = [
+    1, 3, 5, 7, 14, 30, 60, 90, 120, 150, 180, 365, 400, 545, 731, 1096, 1827,
+    2192, 2557, 2922, 3288, 3653,
+];
+
+// First osls version that compiles provider.logs.lambda into LoggingConfig.
+const LOGGING_CONFIG_FRAMEWORK_VERSION = '>=3.58.0';
+
+// ADR-048 Open question 3 (Phase 0 spike). Set to false to leave Lambda on
+// its default Text format; FRIGG_LOG_LEVEL then filters in process alone.
+const EMIT_LAMBDA_JSON_LOGGING_CONFIG = true;
+
+function normalizeLogLevel(level) {
+    const normalized = typeof level === 'string' ? level.toUpperCase() : level;
+    if (!LOG_LEVELS.includes(normalized)) {
+        throw new Error(
+            `Invalid logging.level ${JSON.stringify(level)}. Use one of: ${LOG_LEVELS.join(', ')} (any case).`
+        );
+    }
+    return normalized;
+}
+
+function validateRetentionInDays(retentionInDays) {
+    if (!RETENTION_DAYS.includes(retentionInDays)) {
+        throw new Error(
+            `Invalid logging.retentionInDays ${JSON.stringify(retentionInDays)}. CloudWatch accepts: ${RETENTION_DAYS.join(', ')}.`
+        );
+    }
+    return retentionInDays;
+}
+
+/**
+ * Map appDefinition.logging to provider-level serverless settings.
+ * Returns an empty object when logging is absent (ADR-048 §12: no change).
+ *
+ * @param {Object} [logging] - appDefinition.logging
+ * @returns {{ frameworkVersion?: string, provider?: Object }}
+ */
+function buildLoggingProviderConfig(logging) {
+    if (!logging) return {};
+
+    const provider = {};
+    const result = {};
+
+    if (logging.level !== undefined) {
+        const level = normalizeLogLevel(logging.level);
+        result.frameworkVersion = LOGGING_CONFIG_FRAMEWORK_VERSION;
+        if (EMIT_LAMBDA_JSON_LOGGING_CONFIG) {
+            provider.logs = {
+                lambda: {
+                    logFormat: 'JSON',
+                    applicationLogLevel: level,
+                    systemLogLevel: 'INFO',
+                },
+            };
+        }
+    }
+
+    if (logging.retentionInDays !== undefined) {
+        provider.logRetentionInDays = validateRetentionInDays(
+            logging.retentionInDays
+        );
+    }
+
+    if (Object.keys(provider).length > 0) result.provider = provider;
+    return result;
+}
+
+module.exports = {
+    LOG_LEVELS,
+    RETENTION_DAYS,
+    normalizeLogLevel,
+    buildLoggingProviderConfig,
+};

package/infrastructure/infrastructure-composer.test.js

@@ -150,7 +150,7 @@ describe('composeServerlessDefinition', () => {
 
             expect(result.service).toBe('test-app');
             expect(result.provider.name).toBe('aws');
-            expect(result.provider.runtime).toBe('nodejs20.x');
+            expect(result.provider.runtime).toBe('nodejs22.x');
             expect(result.provider.region).toBe('us-east-1');
             expect(result.provider.stage).toBe('${opt:stage}');
             expect(result.frameworkVersion).toBe('>=3.17.0');
@@ -238,6 +238,54 @@ describe('composeServerlessDefinition', () => {
         });
     });
 
+    describe('Logging (ADR-048)', () => {
+        it('carries logging into provider.logs, FRIGG_LOG_LEVEL and logRetentionInDays', async () => {
+            const result = await composeServerlessDefinition({
+                integrations: [mockIntegration],
+                logging: { level: 'debug', retentionInDays: 30 },
+            });
+
+            expect(result.frameworkVersion).toBe('>=3.58.0');
+            expect(result.provider.logs.lambda).toEqual({
+                logFormat: 'JSON',
+                applicationLogLevel: 'DEBUG',
+                systemLogLevel: 'INFO',
+            });
+            expect(result.provider.logRetentionInDays).toBe(30);
+            expect(result.provider.environment.FRIGG_LOG_LEVEL).toBe('DEBUG');
+        });
+
+        it('sets no function-level logs, which would replace the provider block', async () => {
+            const result = await composeServerlessDefinition({
+                integrations: [mockIntegration],
+                logging: { level: 'warn' },
+            });
+
+            const functions = Object.values(result.functions);
+            expect(functions.length).toBeGreaterThan(0);
+            expect(functions.every((fn) => fn.logs === undefined)).toBe(true);
+        });
+
+        it('lets logging.level win over environment: { FRIGG_LOG_LEVEL: true }', async () => {
+            const result = await composeServerlessDefinition({
+                integrations: [],
+                environment: { FRIGG_LOG_LEVEL: true },
+                logging: { level: 'error' },
+            });
+
+            expect(result.provider.environment.FRIGG_LOG_LEVEL).toBe('ERROR');
+        });
+
+        it('changes nothing when logging is absent', async () => {
+            const result = await composeServerlessDefinition({ integrations: [] });
+
+            expect(result.frameworkVersion).toBe('>=3.17.0');
+            expect(result.provider.logs).toBeUndefined();
+            expect(result.provider.logRetentionInDays).toBeUndefined();
+            expect(result.provider.environment).not.toHaveProperty('FRIGG_LOG_LEVEL');
+        });
+    });
+
     describe('VPC Configuration', () => {
         it('should add VPC configuration when vpc.enable is true with discover mode', async () => {
             const appDefinition = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.653.8213092.0",
+  "version": "2.0.0--canary.654.be44e66.0",
   "bin": {
     "frigg": "./frigg-cli/index.js"
   },
@@ -26,9 +26,9 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0--canary.653.8213092.0",
-    "@friggframework/schemas": "2.0.0--canary.653.8213092.0",
-    "@friggframework/test": "2.0.0--canary.653.8213092.0",
+    "@friggframework/core": "2.0.0--canary.654.be44e66.0",
+    "@friggframework/schemas": "2.0.0--canary.654.be44e66.0",
+    "@friggframework/test": "2.0.0--canary.654.be44e66.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.18.0",
@@ -56,12 +56,12 @@
     "validate-npm-package-name": "^5.0.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.653.8213092.0",
-    "@friggframework/prettier-config": "2.0.0--canary.653.8213092.0",
+    "@friggframework/eslint-config": "2.0.0--canary.654.be44e66.0",
+    "@friggframework/prettier-config": "2.0.0--canary.654.be44e66.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
-    "osls": "^3.40.1",
+    "osls": "^3.58.0",
     "prettier": "^2.7.1",
     "serverless-dotenv-plugin": "^6.0.0",
     "serverless-esbuild": "^1.54.3",
@@ -89,5 +89,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "82130925554847233af5021a9cbed628446c45f7"
+  "gitHead": "be44e66226ec1db051c264a5f8cf02998f3aa14c"
 }

package/infrastructure/domains/shared/utilities/base-definition-factory.js.bak

@@ -1,338 +0,0 @@
-/**
- * Base Serverless Definition Factory
- * 
- * Utility Layer - Hexagonal Architecture
- * 
- * Creates the base serverless.yml configuration with core functions,
- * resources, plugins, and provider settings.
- */
-
-const { buildEnvironment } = require('../environment-builder');
-
-/**
- * Create base serverless definition with core functions and resources
- * 
- * This creates the foundation serverless configuration that all
- * Frigg applications need, including:
- * - Core Lambda functions (auth, user, health, dbMigrate)
- * - Error handling infrastructure (SQS, SNS, CloudWatch)
- * - Prisma Lambda Layer
- * - Base plugins and esbuild configuration
- * 
- * @param {Object} AppDefinition - Application definition
- * @param {Object} appEnvironmentVars - Environment variables from app definition
- * @param {Object} discoveredResources - AWS resources discovered during build
- * @returns {Object} Base serverless definition
- */
-function createBaseDefinition(
-    AppDefinition,
-    appEnvironmentVars,
-    discoveredResources
-) {
-    const region = process.env.AWS_REGION || 'us-east-1';
-
-    // Function-level package config to exclude Prisma and AWS SDK
-    const functionPackageConfig = {
-        exclude: [
-            // Exclude AWS SDK (already in Lambda runtime or externalized by esbuild)
-            'node_modules/aws-sdk/**',
-            'node_modules/@aws-sdk/**',
-
-            // Exclude Prisma (provided via Lambda Layer)
-            'node_modules/@prisma/**',
-            'node_modules/.prisma/**',
-            'node_modules/prisma/**',
-            'node_modules/@friggframework/core/generated/**',
-
-            // Exclude nested node_modules from symlinked frigg packages (for npm link development)
-            'node_modules/@friggframework/core/node_modules/**',
-            'node_modules/@friggframework/devtools/node_modules/**',
-
-            // Exclude development/test files from backend project
-            'coverage/**',
-            'test/**',
-            'src/**',
-            'layers/**',
-            '**/*.test.js',
-            '**/*.spec.js',
-            '.git/**',
-            '.github/**',
-        ],
-    };
-
-    return {
-        frameworkVersion: '>=3.17.0',
-        service: AppDefinition.name || 'create-frigg-app',
-        package: {
-            individually: true,
-        },
-        useDotenv: true,
-        provider: {
-            name: AppDefinition.provider || 'aws',
-            ...(process.env.AWS_PROFILE && { profile: process.env.AWS_PROFILE }),
-            runtime: 'nodejs22.x',  // Node.js 22.x (latest Lambda runtime with AWS SDK v3)
-            timeout: 29,  // Set to 29s to give buffer before API Gateway's 30s timeout
-            region,
-            stage: '${opt:stage}',
-            environment: buildEnvironment(appEnvironmentVars, discoveredResources),
-            iamRoleStatements: [
-                {
-                    Effect: 'Allow',
-                    Action: ['sns:Publish'],
-                    Resource: { Ref: 'InternalErrorBridgeTopic' },
-                },
-                {
-                    Effect: 'Allow',
-                    Action: [
-                        'sqs:SendMessage',
-                        'sqs:SendMessageBatch',
-                        'sqs:GetQueueUrl',
-                        'sqs:GetQueueAttributes',
-                    ],
-                    Resource: [
-                        { 'Fn::GetAtt': ['InternalErrorQueue', 'Arn'] },
-                        {
-                            'Fn::Join': [
-                                ':',
-                                [
-                                    'arn:aws:sqs:${self:provider.region}:*:${self:service}--${self:provider.stage}-*Queue',
-                                ],
-                            ],
-                        },
-                    ],
-                },
-            ],
-            httpApi: {
-                payload: '2.0',
-                cors: {
-                    allowedOrigins: ['*'],
-                    allowedHeaders: ['*'],
-                    allowedMethods: ['*'],
-                    allowCredentials: false,
-                },
-                name: '${opt:stage, "dev"}-${self:service}',
-                disableDefaultEndpoint: false,
-            },
-        },
-        plugins: [
-            'serverless-esbuild',
-            'serverless-dotenv-plugin',
-            'serverless-offline-sqs',
-            'serverless-offline',
-            '@friggframework/serverless-plugin',
-        ],
-        custom: {
-            esbuild: {
-                bundle: true,
-                minify: true,
-                sourcemap: true,
-                target: 'node22',
-                platform: 'node',
-                format: 'cjs',
-                external: [
-                    '@aws-sdk/*',
-                    'aws-sdk',
-                    '@prisma/client',
-                    'prisma',
-                    '.prisma/*',
-                ],
-                packager: 'npm',
-                keepNames: true,
-                keepOutputDirectory: false,  // Clean up .esbuild directory after packaging
-                exclude: [
-                    'aws-sdk',
-                    '@aws-sdk/*',
-                    '@prisma/client',
-                    'prisma',
-                ],
-            },
-            'serverless-offline': {
-                httpPort: 3001,
-                lambdaPort: 4001,
-                websocketPort: 3002,
-                location: '.',  // Set base directory for handler resolution to current directory
-                skipCacheInvalidation: false,
-            },
-            'serverless-offline-sqs': {
-                autoCreate: false,
-                apiVersion: '2012-11-05',
-                endpoint: 'http://localhost:4566',
-                region,
-                accessKeyId: 'root',
-                secretAccessKey: 'root',
-                skipCacheInvalidation: false,
-            },
-        },
-        functions: {
-            auth: {
-                handler: 'node_modules/@friggframework/core/handlers/routers/auth.handler',
-                layers: [{ Ref: 'PrismaLambdaLayer' }],
-                skipEsbuild: true,  // Handlers in node_modules don't need bundling
-                package: functionPackageConfig,
-                events: [
-                    { httpApi: { path: '/api/integrations', method: 'ANY' } },
-                    {
-                        httpApi: {
-                            path: '/api/integrations/{proxy+}',
-                            method: 'ANY',
-                        },
-                    },
-                    { httpApi: { path: '/api/authorize', method: 'ANY' } },
-                ],
-            },
-            user: {
-                handler: 'node_modules/@friggframework/core/handlers/routers/user.handler',
-                layers: [{ Ref: 'PrismaLambdaLayer' }],
-                skipEsbuild: true,  // Handlers in node_modules don't need bundling
-                package: functionPackageConfig,
-                events: [{ httpApi: { path: '/user/{proxy+}', method: 'ANY' } }],
-            },
-            health: {
-                handler: 'node_modules/@friggframework/core/handlers/routers/health.handler',
-                layers: [{ Ref: 'PrismaLambdaLayer' }],
-                skipEsbuild: true,  // Handlers in node_modules don't need bundling
-                package: functionPackageConfig,
-                events: [
-                    { httpApi: { path: '/health', method: 'GET' } },
-                    { httpApi: { path: '/health/{proxy+}', method: 'GET' } },
-                ],
-            },
-            dbMigrate: {
-                handler: 'node_modules/@friggframework/core/handlers/database-migration-handler.handler',
-                // DO NOT use Prisma layer - this function includes Prisma CLI separately
-                skipEsbuild: true,  // Handlers in node_modules don't need bundling
-                timeout: 300,  // 5 minutes for long-running migrations
-                memorySize: 1024,  // Extra memory for Prisma CLI and migration operations
-                reservedConcurrency: 1,  // Prevent concurrent migrations (CRITICAL for data safety)
-                description: 'Runs database migrations via Prisma CLI (invoke manually from CI/CD or triggers). Prisma CLI bundled separately.',
-                package: {
-                    individually: true,
-                    patterns: [
-                        // Include handler
-                        'node_modules/@friggframework/core/handlers/database-migration-handler.js',
-
-                        // Include ONLY PostgreSQL Prisma client (exclude MongoDB)
-                        'node_modules/@friggframework/core/generated/prisma-postgresql/**',
-                        '!node_modules/@friggframework/core/generated/prisma-mongodb/**',  // Exclude MongoDB client entirely
-
-                        // Include Prisma runtime
-                        'node_modules/@prisma/client/**',
-                        'node_modules/.prisma/**',
-                        'node_modules/prisma/**',  // Prisma CLI
-
-                        // Exclude unnecessary engines and files
-                        '!node_modules/prisma/node_modules/**',
-                        '!**/query-engine-darwin*',  // Exclude macOS binaries (keep rhel for Lambda)
-                        '!**/runtime/*.wasm',  // WASM engines
-                        '!**/*.md',
-                        '!**/*.map',
-                        '!**/LICENSE*',
-                        '!**/*.d.ts',
-                        '!**/*.d.mts',
-                    ],
-                },
-                maximumEventAge: 60,
-                maximumRetryAttempts: 0,
-                tags: {
-                    Purpose: 'DatabaseMigration',
-                    ManagedBy: 'Frigg',
-                },
-                environment: {
-                    CI: '1',
-                    PRISMA_HIDE_UPDATE_MESSAGE: '1',
-                    PRISMA_MIGRATE_SKIP_SEED: '1',
-                },
-            },
-        },
-        layers: {
-            prisma: {
-                path: 'layers/prisma',
-                name: '${self:service}-prisma-${sls:stage}',
-                description: 'Prisma runtime client only (NO CLI) with rhel-openssl-3.0.x binaries (~10-15MB). CLI packaged separately in dbMigrate function.',
-                compatibleRuntimes: ['nodejs20.x', 'nodejs22.x'],
-                retain: false,
-            },
-        },
-        resources: {
-            Resources: {
-                InternalErrorQueue: {
-                    Type: 'AWS::SQS::Queue',
-                    Properties: {
-                        QueueName:
-                            '${self:service}-internal-error-queue-${self:provider.stage}',
-                        MessageRetentionPeriod: 300,
-                    },
-                },
-                InternalErrorBridgeTopic: {
-                    Type: 'AWS::SNS::Topic',
-                    Properties: {
-                        Subscription: [
-                            {
-                                Protocol: 'sqs',
-                                Endpoint: {
-                                    'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
-                                },
-                            },
-                        ],
-                    },
-                },
-                InternalErrorBridgePolicy: {
-                    Type: 'AWS::SQS::QueuePolicy',
-                    Properties: {
-                        Queues: [{ Ref: 'InternalErrorQueue' }],
-                        PolicyDocument: {
-                            Version: '2012-10-17',
-                            Statement: [
-                                {
-                                    Sid: 'Allow Dead Letter SNS to publish to SQS',
-                                    Effect: 'Allow',
-                                    Principal: { Service: 'sns.amazonaws.com' },
-                                    Resource: {
-                                        'Fn::GetAtt': [
-                                            'InternalErrorQueue',
-                                            'Arn',
-                                        ],
-                                    },
-                                    Action: [
-                                        'SQS:SendMessage',
-                                        'SQS:SendMessageBatch',
-                                    ],
-                                    Condition: {
-                                        ArnEquals: {
-                                            'aws:SourceArn': {
-                                                Ref: 'InternalErrorBridgeTopic',
-                                            },
-                                        },
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                ApiGatewayAlarm5xx: {
-                    Type: 'AWS::CloudWatch::Alarm',
-                    Properties: {
-                        AlarmDescription: 'API Gateway 5xx Errors',
-                        Namespace: 'AWS/ApiGateway',
-                        MetricName: '5XXError',
-                        Statistic: 'Sum',
-                        Threshold: 0,
-                        ComparisonOperator: 'GreaterThanThreshold',
-                        EvaluationPeriods: 1,
-                        Period: 60,
-                        AlarmActions: [{ Ref: 'InternalErrorBridgeTopic' }],
-                        Dimensions: [
-                            { Name: 'ApiId', Value: { Ref: 'HttpApi' } },
-                            { Name: 'Stage', Value: '${self:provider.stage}' },
-                        ],
-                    },
-                },
-            },
-        },
-    };
-}
-
-module.exports = {
-    createBaseDefinition,
-};
-