@empire-builder-kit/nx 1.0.0-beta.9 → 1.0.0-rc.2

package/src/generators/slice/built-in-plan-testing-files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"built-in-plan-testing-files.js","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/slice/built-in-plan-testing-files.ts"],"names":[],"mappings":"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"}

package/src/generators/slice/built-in-plan-verification-files.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export declare function renderProductVerificationFiles(name: string, pascalName: string): Readonly<Record<string, string>>;

package/src/generators/slice/built-in-plan-verification-files.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderProductVerificationFiles = renderProductVerificationFiles;
+/** @internal */
+function renderProductVerificationFiles(name, pascalName) {
+    return {
+        'vitest.config.ts': `import { configDefaults, defineConfig } from 'vitest/config';
+export default defineConfig({
+  test: {
+    environment: 'node',
+    env: { EBK_STAGE: 'development' },
+    exclude: [
+      ...configDefaults.exclude,
+      '**/dist/**',
+      'e2e/**',
+      'integration/**',
+    ],
+  },
+});
+`,
+        'e2e/product.spec.ts': `import { createHash } from 'node:crypto';
+import { writeFileSync } from 'node:fs';
+import { getSessionTokenCookieNames } from '@empire-builder-kit/runtime/auth-session';
+import { expect, test } from '@playwright/test';
+
+function requiredEnvironment(name: string): string {
+  const value = process.env[name]?.trim();
+  if (!value) throw new Error(name + ' is required for deployed smoke.');
+  return value;
+}
+
+function productEndpoint(productUrl: URL, path: string): string {
+  return new URL(
+    productUrl.pathname.replace(/\\/$/, '') + path,
+    productUrl.origin,
+  ).href;
+}
+
+function runRecordId(runScope: string): string {
+  const digest = createHash('sha256').update(runScope, 'utf8').digest('hex');
+  return [
+    digest.slice(0, 8),
+    digest.slice(8, 12),
+    '4' + digest.slice(13, 16),
+    '8' + digest.slice(17, 20),
+    digest.slice(20, 32),
+  ].join('-');
+}
+
+function writeDataCleanupOutcome(
+  path: string,
+  outcome: 'failed' | 'not-required' | 'passed' | 'pending',
+): void {
+  writeFileSync(
+    path,
+    JSON.stringify({ outcome, schemaVersion: 1 }) + '\\n',
+    { encoding: 'utf8', mode: 0o600 },
+  );
+}
+
+test('proves the deployed product, auth, database, and event journey', async ({
+  page,
+}) => {
+  const productUrl = new URL(requiredEnvironment('EBK_SMOKE_URL'));
+  const apiUrl = new URL(requiredEnvironment('EBK_SMOKE_API_URL'));
+  const email = requiredEnvironment('EBK_SMOKE_EMAIL');
+  const password = requiredEnvironment('EBK_SMOKE_PASSWORD');
+  const reviewerEmail = requiredEnvironment('EBK_SMOKE_REVIEWER_EMAIL');
+  const reviewerPassword = requiredEnvironment(
+    'EBK_SMOKE_REVIEWER_PASSWORD',
+  );
+  const runScope = requiredEnvironment('EBK_TEST_RUN_ID');
+  const expectedSourceCommit = requiredEnvironment('EBK_SOURCE_COMMIT');
+  const expectedStage = requiredEnvironment('EBK_STAGE');
+  const observationPath = requiredEnvironment('EBK_SMOKE_OBSERVATION_PATH');
+  const dataCleanupPath = requiredEnvironment(
+    'EBK_SMOKE_DATA_CLEANUP_PATH',
+  );
+  writeDataCleanupOutcome(dataCleanupPath, 'not-required');
+
+  const publicHealth = await page.request.get(new URL('/health', apiUrl).href);
+  expect(publicHealth.status()).toBe(200);
+  await expect(publicHealth.json()).resolves.toMatchObject({
+    data: {
+      service: '${name}',
+      sourceCommit: expectedSourceCommit,
+      stage: expectedStage,
+      status: 'ok',
+    },
+  });
+
+  const webHealth = await page.request.get(
+    productEndpoint(productUrl, '/api/health'),
+  );
+  expect(webHealth.status()).toBe(200);
+  await expect(webHealth.json()).resolves.toEqual({
+    service: '${name}-web',
+    sourceCommit: expectedSourceCommit,
+    stage: expectedStage,
+    status: 'ok',
+  });
+
+  await page.goto(productUrl.href);
+  await expect(
+    page.getByRole('heading', { name: '${pascalName}' }),
+  ).toBeVisible();
+  await page.getByRole('link', { name: 'Sign in' }).click();
+  await expect(page.getByRole('heading', { name: 'Sign in' })).toBeVisible();
+  await page.getByLabel('Email').fill(email);
+  await page.getByLabel('Password').fill(password);
+  await page.getByRole('button', { name: 'Sign in' }).click();
+  await expect(page.getByRole('status')).toHaveText('Signed in.');
+
+  const protectedUrl = productEndpoint(productUrl, '/api/protected');
+  const protectedResponse = await page.request.get(protectedUrl);
+  expect(protectedResponse.status()).toBe(200);
+  await expect(protectedResponse.json()).resolves.toMatchObject({
+    data: { message: 'Authenticated request accepted.' },
+  });
+
+  const refreshResponse = await page.request.post(
+    productEndpoint(productUrl, '/api/auth/refresh'),
+  );
+  expect(refreshResponse.status()).toBe(200);
+  await expect(refreshResponse.json()).resolves.toEqual({ ok: true });
+  expect((await page.request.get(protectedUrl)).status()).toBe(200);
+
+  const cookieNames = getSessionTokenCookieNames({
+    namespace: '${name}',
+    secure: true,
+  });
+  const accessToken = (await page.context().cookies(productUrl.href)).find(
+    ({ name }) => name === cookieNames.access,
+  )?.value;
+  expect(accessToken, 'The server-managed access cookie must exist.').toBeTruthy();
+  const authenticatedHeaders = {
+    authorization: 'Bearer ' + accessToken,
+    'content-type': 'application/json',
+    'x-correlation-id':
+      'synthetic-' +
+      createHash('sha256').update(runScope, 'utf8').digest('hex').slice(0, 32),
+  };
+
+  const databaseResponse = await page.request.get(
+    new URL('/database-health', apiUrl).href,
+    { headers: authenticatedHeaders },
+  );
+  expect(databaseResponse.status()).toBe(200);
+  await expect(databaseResponse.json()).resolves.toMatchObject({
+    data: { service: '${name}', status: 'ok' },
+  });
+
+  const recordId = runRecordId(runScope);
+  const recordUrl = new URL('/records/' + recordId, apiUrl).href;
+  const testExpiresAt = new Date(Date.now() + 24 * 60 * 60 * 1_000)
+    .toISOString();
+  let recordCleanupRequired = false;
+  let approvalRequestDigest: string | undefined;
+  let approvalRequestId: string | undefined;
+  let reviewerHeaders: Record<string, string> | undefined;
+  let journeyFailed = false;
+  let journeyFailure: unknown;
+  try {
+    recordCleanupRequired = true;
+    writeDataCleanupOutcome(dataCleanupPath, 'pending');
+    const putResponse = await page.request.put(recordUrl, {
+      data: { name: 'deployed-smoke', runScope, testExpiresAt },
+      headers: authenticatedHeaders,
+    });
+    expect(putResponse.status()).toBe(200);
+    await expect(putResponse.json()).resolves.toMatchObject({
+      data: { id: recordId, name: 'deployed-smoke', runScope },
+    });
+
+    const getResponse = await page.request.get(recordUrl, {
+      headers: authenticatedHeaders,
+    });
+    expect(getResponse.status()).toBe(200);
+    await expect(getResponse.json()).resolves.toMatchObject({
+      data: { id: recordId, name: 'deployed-smoke', runScope },
+    });
+
+    const requestDeletionResponse = await page.request.post(
+      recordUrl + '/deletion-requests',
+      {
+        data: { reasonCode: 'synthetic-smoke-cleanup' },
+        headers: authenticatedHeaders,
+      },
+    );
+    expect(requestDeletionResponse.status()).toBe(202);
+    const deletionRequest = await requestDeletionResponse.json() as {
+      data?: {
+        approvalRequestId?: unknown;
+        requestDigest?: unknown;
+        status?: unknown;
+      };
+    };
+    expect(deletionRequest).toMatchObject({
+      data: {
+        approvalRequestId: expect.stringMatching(/^[0-9a-f-]{36}$/i),
+        requestDigest: expect.stringMatching(/^[a-f0-9]{64}$/),
+        status: 'pending',
+      },
+    });
+    if (
+      typeof deletionRequest.data?.approvalRequestId !== 'string' ||
+      typeof deletionRequest.data.requestDigest !== 'string'
+    ) {
+      throw new Error('The deletion request omitted its safe approval identity.');
+    }
+    approvalRequestId = deletionRequest.data.approvalRequestId;
+    approvalRequestDigest = deletionRequest.data.requestDigest;
+
+    await page.request.post(
+      productEndpoint(productUrl, '/api/auth/sign-out'),
+    );
+    await page.goto(productUrl.href);
+    await page.getByRole('link', { name: 'Sign in' }).click();
+    await page.getByLabel('Email').fill(reviewerEmail);
+    await page.getByLabel('Password').fill(reviewerPassword);
+    await page.getByRole('button', { name: 'Sign in' }).click();
+    await expect(page.getByRole('status')).toHaveText('Signed in.');
+    const reviewerAccessToken = (
+      await page.context().cookies(productUrl.href)
+    ).find(({ name }) => name === cookieNames.access)?.value;
+    expect(
+      reviewerAccessToken,
+      'The reviewer access cookie must exist.',
+    ).toBeTruthy();
+    reviewerHeaders = {
+      ...authenticatedHeaders,
+      authorization: 'Bearer ' + reviewerAccessToken,
+    };
+    const approvalResponse = await page.request.post(
+      recordUrl +
+        '/deletion-requests/' +
+        approvalRequestId +
+        '/decision',
+      {
+        data: {
+          expectedRequestDigest: approvalRequestDigest,
+          outcome: 'approved',
+          reasonReference: 'synthetic-smoke-review',
+        },
+        headers: reviewerHeaders,
+      },
+    );
+    expect(approvalResponse.status()).toBe(200);
+    await expect(approvalResponse.json()).resolves.toMatchObject({
+      data: { approvalRequestId, status: 'approved' },
+    });
+
+    const eventResponse = await page.request.post(
+      new URL('/events/example', apiUrl).href,
+      { headers: authenticatedHeaders },
+    );
+    expect(eventResponse.status()).toBe(200);
+    const eventPayload = await eventResponse.json() as {
+      data?: { eventId?: unknown };
+    };
+    expect(eventPayload).toMatchObject({
+      data: { eventId: expect.stringMatching(/^[0-9a-f-]{36}$/i) },
+    });
+    const eventId = eventPayload.data?.eventId;
+    if (typeof eventId !== 'string') {
+      throw new Error('The event publisher did not return an event id.');
+    }
+    writeFileSync(
+      observationPath,
+      JSON.stringify({
+        correlationId: authenticatedHeaders['x-correlation-id'],
+        eventId,
+        schemaVersion: 1,
+      }) + '\\n',
+      { encoding: 'utf8', mode: 0o600 },
+    );
+
+    const deletionUrl = new URL(recordUrl);
+    deletionUrl.searchParams.set('approvalRequestId', approvalRequestId);
+    deletionUrl.searchParams.set(
+      'reasonCode',
+      'synthetic-smoke-cleanup',
+    );
+    const deleteResponse = await page.request.delete(deletionUrl.href, {
+      headers: authenticatedHeaders,
+    });
+    expect(deleteResponse.status()).toBe(200);
+    await expect(deleteResponse.json()).resolves.toMatchObject({
+      data: { deleted: true, id: recordId },
+    });
+    writeDataCleanupOutcome(dataCleanupPath, 'passed');
+    recordCleanupRequired = false;
+  } catch (error) {
+    journeyFailed = true;
+    journeyFailure = error;
+  }
+  let recordCleanupFailed = false;
+  if (
+    recordCleanupRequired &&
+    approvalRequestId &&
+    approvalRequestDigest &&
+    reviewerHeaders
+  ) {
+    try {
+      const cleanupUrl = new URL(recordUrl);
+      cleanupUrl.searchParams.set('approvalRequestId', approvalRequestId);
+      cleanupUrl.searchParams.set(
+        'reasonCode',
+        'synthetic-smoke-cleanup',
+      );
+      const cleanupResponse = await page.request.delete(cleanupUrl.href, {
+        headers: authenticatedHeaders,
+      });
+      if ([200, 404].includes(cleanupResponse.status())) {
+        writeDataCleanupOutcome(dataCleanupPath, 'passed');
+        recordCleanupRequired = false;
+      } else {
+        recordCleanupFailed = true;
+        writeDataCleanupOutcome(dataCleanupPath, 'failed');
+      }
+    } catch {
+      recordCleanupFailed = true;
+      try {
+        writeDataCleanupOutcome(dataCleanupPath, 'failed');
+      } catch {
+        // The runner treats a missing cleanup record as incomplete cleanup.
+      }
+    }
+  } else if (recordCleanupRequired) {
+    recordCleanupFailed = true;
+    writeDataCleanupOutcome(dataCleanupPath, 'failed');
+  }
+  if (journeyFailed) throw journeyFailure;
+  if (recordCleanupFailed) {
+    throw new Error(
+      'The deployed smoke record cleanup did not prove absence.',
+    );
+  }
+
+  const signOutResponse = await page.request.post(
+    productEndpoint(productUrl, '/api/auth/sign-out'),
+  );
+  expect(signOutResponse.status()).toBe(200);
+  await expect(signOutResponse.json()).resolves.toEqual({ ok: true });
+  expect((await page.request.get(protectedUrl)).status()).toBe(401);
+});
+`,
+        'playwright.config.ts': `import { defineConfig } from '@playwright/test';
+export default defineConfig({
+  forbidOnly: true,
+  retries: 0,
+  testDir: './e2e',
+  use: { trace: 'retain-on-failure' },
+});
+`,
+    };
+}
+//# sourceMappingURL=built-in-plan-verification-files.js.map

package/src/generators/slice/built-in-plan-verification-files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"built-in-plan-verification-files.js","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/slice/built-in-plan-verification-files.ts"],"names":[],"mappings":";;AACA,wEAmWC;AApWD,gBAAgB;AAChB,SAAgB,8BAA8B,CAC5C,IAAY,EACZ,UAAkB;IAElB,OAAO;QACL,kBAAkB,EAAE;;;;;;;;;;;;;CAavB;QACG,qBAAqB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgET,IAAI;;;;;;;;;;;;gBAYN,IAAI;;;;;;;;yCAQqB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;kBAwBjC,IAAI;;;;;;;;;;;;;;;;;;;;;wBAqBE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqM3B;QACG,sBAAsB,EAAE;;;;;;;CAO3B;KACE,CAAC;AACJ,CAAC"}

package/src/generators/slice/built-in-plan-web-files.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export declare function renderProductWebFiles(name: string, pascalName: string, workspace: string): Readonly<Record<string, string>>;