@learncard/learn-cloud-service 2.5.35 → 2.5.37

package/src/config/serverlessFunctionEnv.test.ts

@@ -0,0 +1,81 @@
+import { createRequire } from 'node:module';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const require = createRequire(import.meta.url);
+const functions: {
+    provider: (context?: {
+        options: { stage: string; httpPort?: string };
+    }) => Record<string, unknown>;
+} = require('../../serverless.function-env.cjs');
+
+beforeEach(() => {
+    vi.stubEnv('RUNTIME_SECRETS_ID', '');
+    vi.stubEnv('LEARN_CLOUD_SEED', 'seed');
+    vi.stubEnv('LEARN_CLOUD_MONGO_URI', 'mongodb://localhost:27017');
+    // XAPI_ENDPOINT is a user-classified bundle secret, so populate a stale fallback value
+    // to prove it never leaks onto the provider once a runtime bundle is configured.
+    vi.stubEnv('XAPI_ENDPOINT', 'https://stale.xapi.example.com');
+});
+afterEach(() => vi.unstubAllEnvs());
+
+describe('learn-cloud-service serverless function environments', () => {
+    it('omits all credential fallbacks in bundle mode', () => {
+        vi.stubEnv('RUNTIME_SECRETS_ID', 'learn-cloud-service/dev/runtime-secrets');
+        expect(Object.keys(functions.provider()).sort()).toEqual([
+            'CONFIG_TENANT',
+            'LAMBDA_STAGE',
+            'PORT',
+            'REDIS_HOST',
+            'REDIS_PORT',
+            'RUNTIME_SECRETS_ID',
+        ]);
+    });
+
+    it('drops the XAPI_ENDPOINT bundle secret in bundle mode even when a stale fallback is set', () => {
+        vi.stubEnv('RUNTIME_SECRETS_ID', 'learn-cloud-service/dev/runtime-secrets');
+        expect(functions.provider()).not.toHaveProperty('XAPI_ENDPOINT');
+    });
+
+    it('retains the existing provider credentials only in fallback mode', () => {
+        const provider = functions.provider();
+        expect(provider.LEARN_CLOUD_SEED).toBe('seed');
+        expect(provider.LEARN_CLOUD_MONGO_URI).toBe('mongodb://localhost:27017');
+        expect(provider.XAPI_ENDPOINT).toBe('https://stale.xapi.example.com');
+        expect(provider.RUNTIME_SECRETS_ID).toBeUndefined();
+    });
+
+    it('preserves the CloudFormation Redis intrinsics and CLI options', () => {
+        const provider = functions.provider({ options: { stage: 'production', httpPort: '5100' } });
+        expect(provider.LAMBDA_STAGE).toBe('production');
+        expect(provider.PORT).toBe('5100');
+        expect(provider.REDIS_HOST).toEqual({
+            'Fn::GetAtt': ['ElasticCacheCluster', 'RedisEndpoint.Address'],
+        });
+        expect(provider.REDIS_PORT).toEqual({
+            'Fn::GetAtt': ['ElasticCacheCluster', 'RedisEndpoint.Port'],
+        });
+    });
+
+    it.each(['', 'bundle'])(
+        'resolves the full provider environment through Serverless v3 (%s)',
+        async bundle => {
+            const source = require('serverless/lib/configuration/variables/sources/file');
+            vi.stubEnv('RUNTIME_SECRETS_ID', bundle);
+            const options = { stage: 'production', httpPort: '5100' };
+            const result = await source.resolve({
+                serviceDir: new URL('../../', import.meta.url).pathname,
+                params: [new URL('../../serverless.function-env.cjs', import.meta.url).pathname],
+                address: 'provider',
+                options,
+                resolveConfigurationProperty: vi.fn(),
+                resolveVariable: vi.fn(),
+            });
+            expect(result.value).toEqual(functions.provider({ options }));
+            expect(result.value.LAMBDA_STAGE).toBe('production');
+            expect(result.value.PORT).toBe('5100');
+            expect(result.value.REDIS_HOST).toEqual({
+                'Fn::GetAtt': ['ElasticCacheCluster', 'RedisEndpoint.Address'],
+            });
+        }
+    );
+});

package/src/config/stageConfig.test.ts

@@ -0,0 +1,26 @@
+import { afterEach, expect, it, vi } from 'vitest';
+
+// Model a non-empty .env value arriving before the stage defaults are applied.
+vi.mock('dotenv/config', () => {
+    vi.stubEnv('SENTRY_ENV', 'self-hosted');
+    return {};
+});
+
+afterEach(() => vi.unstubAllEnvs());
+
+it('loads local env before applying statically imported stage defaults', async () => {
+    const { applyLearnCloudStageConfig, stages } = await import('./stageConfig');
+    for (const key of Object.keys(stages.dev)) {
+        if (key !== 'SENTRY_ENV') vi.stubEnv(key, '');
+    }
+    applyLearnCloudStageConfig('dev');
+    expect(process.env.SENTRY_ENV).toBe('self-hosted');
+    expect(process.env.SERVER_URL).toBe(stages.dev.SERVER_URL);
+});
+
+it('does not select a deployed stage for an unknown local stage', async () => {
+    const { applyLearnCloudStageConfig } = await import('./stageConfig');
+    vi.stubEnv('SERVER_URL', '');
+    applyLearnCloudStageConfig('unregistered-self-hosted-stage');
+    expect(process.env.SERVER_URL).toBe('');
+});

package/src/config/stageConfig.ts

@@ -0,0 +1,24 @@
+import 'dotenv/config';
+import { applyStageConfig } from '@learncard/service-config';
+
+import baseConfig from '../../config/config.json';
+import devConfig from '../../config/config.dev.json';
+import productionConfig from '../../config/config.production.json';
+import scoutsDevConfig from '../../config/config.scouts.dev.json';
+import scoutsProductionConfig from '../../config/config.scouts.production.json';
+
+export const base: Record<string, string> = baseConfig;
+
+export const stages = {
+    dev: devConfig,
+    production: productionConfig,
+    // ScoutPass deploys the same services and stage names; CONFIG_TENANT=scouts selects these.
+    'scouts.dev': scoutsDevConfig,
+    'scouts.production': scoutsProductionConfig,
+} satisfies Record<string, Record<string, string>>;
+
+// Must run before any module that reads configuration on import (e.g. @environment):
+// merges base + the selected stage into process.env; explicit non-empty env still wins.
+export const applyLearnCloudStageConfig = (stage: string | undefined): void => {
+    applyStageConfig({ base, stages, stage });
+};

package/src/docker-entry.ts

@@ -1,3 +1,5 @@
+import './config/applyDockerStageConfig';
+
 import { environment } from '@environment';
 import path from 'path';
 

package/vitest.config.ts

@@ -7,6 +7,9 @@ export default createVitestConfig(nodePreset, {
             'test/query.helpers.spec.ts',
             'test/xapi.helpers.spec.ts',
             'test/share-content-auth.spec.ts',
+            'src/config/stageConfig.test.ts',
+            'src/config/serverlessFunctionEnv.test.ts',
+            '*Lambda.test.ts',
         ],
     },
 });

package/xApiLambda.test.ts

@@ -0,0 +1,41 @@
+import type { APIGatewayProxyEventV2, Context } from 'aws-lambda';
+import { beforeEach, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({ bootstrap: vi.fn(), getApp: vi.fn(), handler: vi.fn() }));
+
+vi.mock('@learncard/service-config', () => ({ bootstrapLambda: mocks.bootstrap }));
+vi.mock('./src/config/stageConfig', () => ({ base: {}, stages: { dev: {}, production: {} } }));
+vi.mock('./xApiLambdaApp', () => ({ xApiHandler: mocks.handler }));
+
+beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    mocks.bootstrap.mockReturnValue(mocks.getApp);
+    mocks.getApp.mockResolvedValue({ xApiHandler: mocks.handler });
+    mocks.handler.mockResolvedValue({ statusCode: 200 });
+});
+
+it('bootstraps the xApi app with checked-in stage config and the deploy stage', async () => {
+    vi.stubEnv('AWS_LAMBDA_FUNCTION_NAME', 'learn-cloud-service-dev-xapi');
+    vi.stubEnv('LAMBDA_STAGE', 'dev');
+    await import('./xApiLambda');
+    expect(mocks.bootstrap).toHaveBeenCalledTimes(1);
+    expect(mocks.bootstrap).toHaveBeenCalledWith({
+        base: {},
+        stages: { dev: {}, production: {} },
+        stage: 'dev',
+        importApp: expect.any(Function),
+    });
+    vi.unstubAllEnvs();
+});
+
+it('resolves the app once per cold start and forwards every argument', async () => {
+    const { xApiHandler } = await import('./xApiLambda');
+    const event = {} as APIGatewayProxyEventV2;
+    const context = {} as Context;
+    const callback = vi.fn();
+    await xApiHandler(event, context, callback);
+    await xApiHandler(event, context, callback);
+    expect(mocks.getApp).toHaveBeenCalledTimes(2);
+    expect(mocks.handler).toHaveBeenLastCalledWith(event, context, callback);
+});

package/xApiLambda.ts

@@ -1,23 +1,17 @@
-import serverlessHttp from 'serverless-http';
-import * as Sentry from '@sentry/serverless';
+import { bootstrapLambda } from '@learncard/service-config';
 
-import xApiApp from './src/xapi';
-import { environment } from './src/config/environment';
-import { toServerlessApplication } from './src/helpers/serverlessApplication';
+import { base, stages } from './src/config/stageConfig';
 
-Sentry.AWSLambda.init({
-    dsn: environment.SENTRY_DSN,
-    environment: environment.SENTRY_ENV,
-    enabled: Boolean(environment.SENTRY_DSN),
-    tracesSampleRate: 1.0,
-    integrations: [
-        new Sentry.Integrations.Console(),
-        new Sentry.Integrations.Http(),
-        new Sentry.Integrations.ContextLines(),
-        new Sentry.Integrations.Mongo(),
-    ],
+type XApiApp = typeof import('./xApiLambdaApp');
+
+const getApplication = bootstrapLambda<XApiApp>({
+    base,
+    stages,
+    stage: process.env.AWS_LAMBDA_FUNCTION_NAME
+        ? process.env.LAMBDA_STAGE
+        : process.env.CONFIG_STAGE,
+    importApp: () => import('./xApiLambdaApp'),
 });
 
-export const xApiHandler = Sentry.AWSLambda.wrapHandler(
-    serverlessHttp(toServerlessApplication(xApiApp))
-);
+export const xApiHandler = async (...args: Parameters<XApiApp['xApiHandler']>) =>
+    (await getApplication()).xApiHandler(...args);

package/xApiLambdaApp.ts

@@ -0,0 +1,23 @@
+import serverlessHttp from 'serverless-http';
+import * as Sentry from '@sentry/serverless';
+
+import xApiApp from './src/xapi';
+import { environment } from './src/config/environment';
+import { toServerlessApplication } from './src/helpers/serverlessApplication';
+
+Sentry.AWSLambda.init({
+    dsn: environment.SENTRY_DSN,
+    environment: environment.SENTRY_ENV,
+    enabled: Boolean(environment.SENTRY_DSN),
+    tracesSampleRate: 1.0,
+    integrations: [
+        new Sentry.Integrations.Console(),
+        new Sentry.Integrations.Http(),
+        new Sentry.Integrations.ContextLines(),
+        new Sentry.Integrations.Mongo(),
+    ],
+});
+
+export const xApiHandler = Sentry.AWSLambda.wrapHandler(
+    serverlessHttp(toServerlessApplication(xApiApp))
+);