@carecard/jwt-read 3.18.0 → 3.19.0

package/scripts/canonicalTestCommand.test.mjs

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { runPackageTask } from './runPackageTask.mjs';
+
+test('the complete test command runs each validation category exactly once', () => {
+  const executedSteps = [];
+
+  const exitCode = runPackageTask('test', taskStep => {
+    executedSteps.push([taskStep.command, ...(taskStep.arguments ?? [])].join(' '));
+    return 0;
+  });
+
+  assert.equal(exitCode, 0);
+  assert.deepEqual(executedSteps, [
+    'npm run validate:audits',
+    'npm run test:order',
+    'tsc --noEmit',
+    'mocha --require ./scripts/testOrder/randomizeTestOrder.cjs -r ts-node/register test/types.test.ts',
+    'nyc node test/index.test.js',
+  ]);
+});
+
+test('the legacy aggregate command delegates to the complete test command once', () => {
+  const executedSteps = [];
+
+  runPackageTask('test:All', taskStep => {
+    executedSteps.push([taskStep.command, ...(taskStep.arguments ?? [])].join(' '));
+    return 0;
+  });
+
+  assert.deepEqual(executedSteps, ['npm test']);
+});

package/scripts/packageTaskRunner.audit.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+
+const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const composedCommandPattern = /&&|\|\||\bsh -c\b|\bnode -e\b/u;
+const runnerCommandPattern = /^node scripts\/runPackageTask\.mjs ([A-Za-z0-9:_-]+)$/u;
+
+async function loadPackageTaskRunner() {
+  return import(new URL('./runPackageTask.mjs', import.meta.url));
+}
+
+test('delegates composed package tasks to the repository runner', async () => {
+  const runnerCommands = Object.entries(packageJson.scripts ?? {}).filter(([, command]) =>
+    runnerCommandPattern.test(command),
+  );
+
+  for (const [scriptName, command] of Object.entries(packageJson.scripts ?? {})) {
+    assert.doesNotMatch(
+      command,
+      composedCommandPattern,
+      `${scriptName} must delegate composition to runPackageTask.mjs`,
+    );
+  }
+
+  assert.ok(runnerCommands.length > 0, 'at least one package task must use the runner');
+  const { packageTasks } = await loadPackageTaskRunner();
+  for (const [scriptName] of runnerCommands) {
+    assert.ok(packageTasks[scriptName], `${scriptName} must have a runner task`);
+  }
+});
+
+test('does not suppress command execution errors at the CLI boundary', () => {
+  const runnerSource = readFileSync(new URL('./runPackageTask.mjs', import.meta.url), 'utf8');
+
+  assert.doesNotMatch(runnerSource, /catch\s*\{/u);
+});

package/scripts/packageTaskRunner.test.mjs

@@ -1,29 +1,10 @@
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
 import test from 'node:test';
 
-const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-const composedCommandPattern = /&&|\|\||\bsh -c\b|\bnode -e\b/u;
-const runnerCommandPattern = /^node scripts\/runPackageTask\.mjs ([A-Za-z0-9:_-]+)$/u;
-
 async function loadPackageTaskRunner() {
   return import(new URL('./runPackageTask.mjs', import.meta.url));
 }
 
-test('delegates composed package tasks to the repository runner', async () => {
-  const runnerCommands = Object.entries(packageJson.scripts ?? {}).filter(([, command]) => runnerCommandPattern.test(command));
-
-  for (const [scriptName, command] of Object.entries(packageJson.scripts ?? {})) {
-    assert.doesNotMatch(command, composedCommandPattern, `${scriptName} must delegate composition to runPackageTask.mjs`);
-  }
-
-  assert.ok(runnerCommands.length > 0, 'at least one package task must use the runner');
-  const { packageTasks } = await loadPackageTaskRunner();
-  for (const [scriptName] of runnerCommands) {
-    assert.ok(packageTasks[scriptName], `${scriptName} must have a runner task`);
-  }
-});
-
 test('runs task steps in order and stops at the first failure', async () => {
   const { runPackageTask } = await loadPackageTaskRunner();
   const executedCommands = [];
@@ -65,17 +46,14 @@ test('runs conditional steps only when their required output is missing', async
   assert.deepEqual(executedCommands, ['execute']);
 });
 
-test('does not suppress command execution errors at the CLI boundary', () => {
-  const runnerSource = readFileSync(new URL('./runPackageTask.mjs', import.meta.url), 'utf8');
-
-  assert.doesNotMatch(runnerSource, /catch\s*\{/u);
-});
-
 test('merges task environment overrides without mutating inherited values', async () => {
   const { createTaskEnvironment } = await loadPackageTaskRunner();
   const inheritedEnvironment = { NODE_ENV: 'test', PATH: '/bin' };
 
-  const environment = createTaskEnvironment({ NODE_ENV: 'production', DB_ENV: 'privileged' }, inheritedEnvironment);
+  const environment = createTaskEnvironment(
+    { NODE_ENV: 'production', DB_ENV: 'privileged' },
+    inheritedEnvironment,
+  );
 
   assert.deepEqual(environment, {
     NODE_ENV: 'production',

package/scripts/runPackageTask.mjs

@@ -4,27 +4,53 @@ import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 export const packageTasks = Object.freeze({
+  'validate:audits': [
+    { command: 'node', arguments: ['scripts/packageTaskRunner.audit.mjs'] },
+    { command: 'node', arguments: ['scripts/testOrder/testOrderPolicy.audit.mjs'] },
+    { command: 'node', arguments: ['scripts/testParallel/parallelTestPolicy.audit.mjs'] },
+    { command: 'mocha', arguments: ['test/config/errorWarningSuppression.audit.js'] },
+    { command: 'mocha', arguments: ['test/config/repositoryIsolation.audit.js'] },
+    { command: 'mocha', arguments: ['test/config/serverAuthEmailVerificationDocs.audit.js'] },
+    { command: 'mocha', arguments: ['test/config/tddGuidanceDocs.audit.js'] },
+    { command: 'mocha', arguments: ['test/jwtLib.audit.js'] },
+  ],
   test: [
+    { command: 'npm', arguments: ['run', 'validate:audits'] },
     { command: 'npm', arguments: ['run', 'test:order'] },
-    { command: 'node', arguments: ['test/index.test.js'] },
+    { command: 'tsc', arguments: ['--noEmit'] },
+    {
+      command: 'mocha',
+      arguments: [
+        '--require',
+        './scripts/testOrder/randomizeTestOrder.cjs',
+        '-r',
+        'ts-node/register',
+        'test/types.test.ts',
+      ],
+    },
+    { command: 'nyc', arguments: ['node', 'test/index.test.js'] },
   ],
   'test:types': [
     { command: 'npm', arguments: ['run', 'test:order'] },
     { command: 'tsc', arguments: ['--noEmit'] },
     {
       command: 'mocha',
-      arguments: ['--require', './scripts/testOrder/randomizeTestOrder.cjs', '-r', 'ts-node/register', 'test/types.test.ts'],
+      arguments: [
+        '--require',
+        './scripts/testOrder/randomizeTestOrder.cjs',
+        '-r',
+        'ts-node/register',
+        'test/types.test.ts',
+      ],
     },
   ],
   'test:coverage': [
+    { command: 'npm', arguments: ['run', 'validate:audits'] },
     { command: 'npm', arguments: ['run', 'test:order'] },
     { command: 'tsc', arguments: ['--noEmit'] },
     { command: 'nyc', arguments: ['node', 'test/index.test.js'] },
   ],
-  'test:All': [
-    { command: 'npm', arguments: ['run', 'test'] },
-    { command: 'npm', arguments: ['run', 'test:types'] },
-  ],
+  'test:All': [{ command: 'npm', arguments: ['test'] }],
 });
 
 export function createTaskEnvironment(overrides = {}, inheritedEnvironment = process.env) {
@@ -32,10 +58,18 @@ export function createTaskEnvironment(overrides = {}, inheritedEnvironment = pro
 }
 
 function getTaskExitCode(result) {
-  if (result.error) throw result.error;
-  if (typeof result.status === 'number') return result.status;
-  if (result.signal === 'SIGINT') return 130;
-  if (result.signal === 'SIGTERM') return 143;
+  if (result.error) {
+    throw result.error;
+  }
+  if (typeof result.status === 'number') {
+    return result.status;
+  }
+  if (result.signal === 'SIGINT') {
+    return 130;
+  }
+  if (result.signal === 'SIGTERM') {
+    return 143;
+  }
   return 1;
 }
 
@@ -57,20 +91,33 @@ function shouldRunTaskStep(taskStep, pathExists) {
   return !taskStep.whenMissing || !pathExists(taskStep.whenMissing);
 }
 
-export function runPackageTask(taskName, executeTask = executeTaskStep, taskDefinitions = packageTasks, pathExists = existsSync) {
+export function runPackageTask(
+  taskName,
+  executeTask = executeTaskStep,
+  taskDefinitions = packageTasks,
+  pathExists = existsSync,
+) {
   const taskSteps = taskDefinitions[taskName];
-  if (!Array.isArray(taskSteps)) throw new Error('Unknown package task.');
+  if (!Array.isArray(taskSteps)) {
+    throw new Error('Unknown package task.');
+  }
 
   for (const taskStep of taskSteps) {
-    if (!shouldRunTaskStep(taskStep, pathExists)) continue;
+    if (!shouldRunTaskStep(taskStep, pathExists)) {
+      continue;
+    }
     const exitCode = executeTask(taskStep);
-    if (exitCode !== 0) return exitCode;
+    if (exitCode !== 0) {
+      return exitCode;
+    }
   }
   return 0;
 }
 
 function isDirectExecution() {
-  if (!process.argv[1]) return false;
+  if (!process.argv[1]) {
+    return false;
+  }
   return resolve(process.argv[1]) === fileURLToPath(import.meta.url);
 }
 
@@ -85,4 +132,6 @@ function runCommandLineTask() {
   process.exitCode = runPackageTask(taskName);
 }
 
-if (isDirectExecution()) runCommandLineTask();
+if (isDirectExecution()) {
+  runCommandLineTask();
+}

package/scripts/testOrder/randomizeTestOrder.cjs

@@ -3,10 +3,16 @@
 const MAX_TEST_ORDER_SEED = 2_147_483_647;
 
 function resolveTestOrderSeed(configuredSeed) {
-  if (configuredSeed === undefined) return undefined;
-  if (!/^[1-9]\d*$/.test(configuredSeed)) throw new Error('TEST_ORDER_SEED must be a positive 32-bit integer.');
+  if (configuredSeed === undefined) {
+    return undefined;
+  }
+  if (!/^[1-9]\d*$/.test(configuredSeed)) {
+    throw new Error('TEST_ORDER_SEED must be a positive 32-bit integer.');
+  }
   const seed = Number(configuredSeed);
-  if (!Number.isSafeInteger(seed) || seed > MAX_TEST_ORDER_SEED) throw new Error('TEST_ORDER_SEED must be a positive 32-bit integer.');
+  if (!Number.isSafeInteger(seed) || seed > MAX_TEST_ORDER_SEED) {
+    throw new Error('TEST_ORDER_SEED must be a positive 32-bit integer.');
+  }
   return seed;
 }
 function createSeededRandom(seed) {
@@ -25,14 +31,18 @@ function shuffleValues(values, random) {
   }
 }
 function shuffleSuiteTree(suite, random) {
-  for (const childSuite of suite.suites) shuffleSuiteTree(childSuite, random);
+  for (const childSuite of suite.suites) {
+    shuffleSuiteTree(childSuite, random);
+  }
   shuffleValues(suite.tests, random);
   shuffleValues(suite.suites, random);
 }
 const mochaHooks = {
   beforeAll() {
     const seed = resolveTestOrderSeed(process.env.TEST_ORDER_SEED);
-    if (seed === undefined) return;
+    if (seed === undefined) {
+      return;
+    }
     console.log(`Test order seed: ${seed} (reproduce with TEST_ORDER_SEED=${seed})`);
     shuffleSuiteTree(this.test.parent, createSeededRandom(seed));
   },

package/scripts/testOrder/{testOrderPolicy.test.mjs → testOrderPolicy.audit.mjs}

@@ -7,7 +7,9 @@ const TEST_ORDER_INVARIANCE_RULE =
   "Non-negotiable test order invariance rule: Every test must pass independently of which tests run before or after it, and the suite must pass in every execution order. Each test must establish the state it needs, isolate mutable state, and clean up state it owns; it must never rely on another test's setup, mutations, or cleanup. Default test, CI, and Husky commands must use the test framework's ordinary ordering and must not force randomized ordering. Random-order execution is an explicit diagnostic only, and every failure it exposes must be fixed at the root cause.";
 
 function listRepositoryFiles() {
-  return execFileSync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], { encoding: 'utf8' })
+  return execFileSync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], {
+    encoding: 'utf8',
+  })
     .trim()
     .split('\n')
     .filter(Boolean);
@@ -43,6 +45,10 @@ test('keeps default package scripts on the test framework ordinary ordering', ()
 
   for (const [scriptName, command] of Object.entries(packageJson.scripts ?? {})) {
     assert.equal(typeof command, 'string', `${scriptName} must be a string command.`);
-    assert.doesNotMatch(command, /--test-randomize|--test-random-seed/, `${scriptName} must not force randomized test ordering.`);
+    assert.doesNotMatch(
+      command,
+      /--test-randomize|--test-random-seed/,
+      `${scriptName} must not force randomized test ordering.`,
+    );
   }
 });

package/scripts/testParallel/{parallelTestPolicy.test.mjs → parallelTestPolicy.audit.mjs}

@@ -6,15 +6,22 @@ import test from 'node:test';
 
 const require = createRequire(import.meta.url);
 const repositoryRoot = resolve(import.meta.dirname, '../..');
-const packageJson = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
-const packageTaskRunnerSource = readFileSync(new URL('../runPackageTask.mjs', import.meta.url), 'utf8');
+const packageJson = JSON.parse(
+  readFileSync(new URL('../../package.json', import.meta.url), 'utf8'),
+);
+const packageTaskRunnerSource = readFileSync(
+  new URL('../runPackageTask.mjs', import.meta.url),
+  'utf8',
+);
 const testIndexSource = readFileSync(new URL('../../test/index.test.js', import.meta.url), 'utf8');
 const { parallelTestFiles } = require('../../test/index.test.js');
 
 function listRuntimeTestFiles(directoryPath) {
   return readdirSync(directoryPath, { withFileTypes: true }).flatMap(entry => {
     const entryPath = join(directoryPath, entry.name);
-    if (entry.isDirectory()) return listRuntimeTestFiles(entryPath);
+    if (entry.isDirectory()) {
+      return listRuntimeTestFiles(entryPath);
+    }
     if (!/\.test\.(?:js|mjs)$/.test(entry.name) || entry.name === 'index.test.js') {
       return [];
     }
@@ -24,20 +31,32 @@ function listRuntimeTestFiles(directoryPath) {
 
 test('keeps runtime test selection in the index and package scripts short', () => {
   assert.equal(packageJson.scripts.test, 'node scripts/runPackageTask.mjs test');
-  assert.equal(packageJson.scripts['test:coverage'], 'node scripts/runPackageTask.mjs test:coverage');
+  assert.equal(
+    packageJson.scripts['test:coverage'],
+    'node scripts/runPackageTask.mjs test:coverage',
+  );
   assert.match(packageTaskRunnerSource, /arguments: \['run', 'test:order'\]/);
-  assert.match(packageTaskRunnerSource, /arguments: \['test\/index\.test\.js'\]/);
+  assert.match(packageTaskRunnerSource, /arguments: \['node', 'test\/index\.test\.js'\]/);
   assert.match(packageTaskRunnerSource, /command: 'nyc'/);
   assert.match(testIndexSource, /parallelTestFiles/);
   assert.match(testIndexSource, /runIndexedMochaTests/);
   assert.match(testIndexSource, /if \(require\.main === module\)/);
 });
 
-test('runs the parallel execution contract in the test-order gate', () => {
-  assert.match(packageJson.scripts['test:order'], /scripts\/testParallel\/parallelTestPolicy\.test\.mjs/);
-  assert.match(packageJson.scripts['test:order'], /scripts\/testParallel\/runIndexedMochaTests\.test\.mjs/);
+test('keeps parallel behavior tests in the test-order gate and static policy checks in the audit gate', () => {
+  assert.match(
+    packageJson.scripts['test:order'],
+    /scripts\/testParallel\/runIndexedMochaTests\.test\.mjs/,
+  );
+  assert.equal(
+    packageJson.scripts['validate:audits'],
+    'node scripts/runPackageTask.mjs validate:audits',
+  );
 });
 
 test('selects every runtime test file exactly once', () => {
-  assert.deepEqual([...parallelTestFiles].sort(), listRuntimeTestFiles(resolve(repositoryRoot, 'test')).sort());
+  assert.deepEqual(
+    [...parallelTestFiles].sort(),
+    listRuntimeTestFiles(resolve(repositoryRoot, 'test')).sort(),
+  );
 });

package/scripts/testParallel/runIndexedMochaTests.cjs

@@ -15,7 +15,9 @@ function resolveParallelJobCount(
   availableJobCount = availableParallelism(),
 ) {
   const requestedJobCount =
-    configuredJobCount === undefined ? Math.min(availableJobCount, defaultMaximum) : Number.parseInt(configuredJobCount, 10);
+    configuredJobCount === undefined
+      ? Math.min(availableJobCount, defaultMaximum)
+      : Number.parseInt(configuredJobCount, 10);
 
   if (!Number.isInteger(requestedJobCount) || requestedJobCount < 1) {
     throw new Error('TEST_PARALLEL_JOBS must be a positive integer.');

package/scripts/testParallel/runIndexedMochaTests.test.mjs

@@ -12,10 +12,16 @@ test('uses bounded Mocha file workers without randomized default ordering', () =
   const argumentsList = buildMochaArguments(['test/example.test.js'], 2);
 
   assert.ok(argumentsList.includes('--parallel'));
-  assert.deepEqual(argumentsList.slice(argumentsList.indexOf('--jobs'), argumentsList.indexOf('--jobs') + 2), ['--jobs', '2']);
+  assert.deepEqual(
+    argumentsList.slice(argumentsList.indexOf('--jobs'), argumentsList.indexOf('--jobs') + 2),
+    ['--jobs', '2'],
+  );
   assert.ok(argumentsList.includes('test/example.test.js'));
 });
 
 test('rejects invalid worker configuration instead of changing execution silently', () => {
-  assert.throws(() => resolveParallelJobCount('0', 8, 4, 12), /TEST_PARALLEL_JOBS must be a positive integer/);
+  assert.throws(
+    () => resolveParallelJobCount('0', 8, 4, 12),
+    /TEST_PARALLEL_JOBS must be a positive integer/,
+  );
 });