@learncard/learn-cloud-service 2.5.34 → 2.5.36

package/vitest.config.ts

@@ -6,6 +6,10 @@ export default createVitestConfig(nodePreset, {
             'test/uri-helpers.spec.ts',
             '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/vitest.share-content-config-unit.config.ts

@@ -0,0 +1,8 @@
+import tsconfigPaths from 'vite-tsconfig-paths';
+import { createVitestConfig, nodePreset } from '../../../vitest.shared';
+
+/** Configuration and boot-order checks without starting databases or services. */
+export default createVitestConfig(
+    { ...nodePreset, plugins: [tsconfigPaths({ root: '../../' })] },
+    { test: { include: ['test/share-content-config.spec.ts'] } }
+);

package/vitest.share-content-endpoint.config.ts

@@ -0,0 +1,21 @@
+import { createVitestConfig, serviceIntegrationPreset } from '../../../vitest.shared';
+
+/**
+ * Isolated LC-2187 endpoint suite.
+ *
+ * These specs exercise the real Fastify inject path, the real C1 verification
+ * module, a real ephemeral MongoDB and a real Redis container (global setup).
+ * They import no service `@mongo` singleton and touch no application database.
+ */
+export default createVitestConfig(serviceIntegrationPreset, {
+    test: {
+        globalSetup: './test/share-content-redis-setup.ts',
+        include: [
+            'test/share-content-config.spec.ts',
+            'test/share-content-endpoint.spec.ts',
+            'test/share-content-didkit.spec.ts',
+        ],
+        hookTimeout: 240_000,
+        testTimeout: 120_000,
+    },
+});

package/vitest.share-content.config.ts

@@ -0,0 +1,19 @@
+import { createVitestConfig, serviceIntegrationPreset } from '../../../vitest.shared';
+
+/**
+ * Isolated real-Mongo test config for the LC-2187 share-content repository and
+ * authorization module.
+ *
+ * These specs start their own `MongoMemoryServer` (or none at all) and never
+ * import the service `@mongo` singleton, so they do not need the shared
+ * integration global setup, Redis, the app router or any environment. The
+ * endpoint/transport suite lives in `vitest.share-content-endpoint.config.ts`
+ * and requires a real Redis container; it is deliberately excluded here so this
+ * repository-level config stays independent of Redis.
+ */
+export default createVitestConfig(serviceIntegrationPreset, {
+    test: {
+        include: ['test/share-content.spec.ts', 'test/share-content-auth.spec.ts'],
+        hookTimeout: 120_000,
+    },
+});

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))
+);