@carecard/auth-util 3.17.0 → 3.18.0

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@carecard/auth-util",
-  "version": "3.17.0",
+  "version": "3.18.0",
   "repository": "https://github.com/CareCard-ca/pkg-auth-util.git",
   "description": "Auth utility functions",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "test": "npm run test:order && node test/index.test.js",
-    "test:order": "node --test scripts/testOrder/randomizeTestOrder.test.mjs scripts/testOrder/testOrderPolicy.test.mjs scripts/testParallel/runIndexedMochaTests.test.mjs scripts/testParallel/parallelTestPolicy.test.mjs",
-    "test:types": "npm run test:order && tsc --noEmit && mocha --require ./scripts/testOrder/randomizeTestOrder.cjs -r ts-node/register test/types.test.ts",
-    "test:coverage": "npm run test:order && tsc --noEmit && nyc node test/index.test.js",
-    "test:All": "npm run test && npm run test:types",
+    "test": "node scripts/runPackageTask.mjs test",
+    "test:order": "node --test scripts/testOrder/randomizeTestOrder.test.mjs scripts/testOrder/testOrderPolicy.test.mjs scripts/testParallel/runIndexedMochaTests.test.mjs scripts/testParallel/parallelTestPolicy.test.mjs scripts/packageTaskRunner.test.mjs",
+    "test:types": "node scripts/runPackageTask.mjs test:types",
+    "test:coverage": "node scripts/runPackageTask.mjs test:coverage",
+    "test:All": "node scripts/runPackageTask.mjs test:All",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "prepare": "husky",
@@ -42,8 +42,8 @@
     "typescript": "6.0.3"
   },
   "dependencies": {
-    "@carecard/common-util": "3.17.0",
-    "@carecard/validate": "3.17.0",
+    "@carecard/common-util": "3.18.0",
+    "@carecard/validate": "3.18.0",
     "@types/express": "5.0.6"
   },
   "overrides": {

package/scripts/packageTaskRunner.test.mjs

@@ -0,0 +1,86 @@
+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 = [];
+  const fixtureTasks = {
+    fixture: [{ command: 'first' }, { command: 'second' }, { command: 'third' }],
+  };
+
+  const exitCode = runPackageTask(
+    'fixture',
+    step => {
+      executedCommands.push(step.command);
+      return step.command === 'second' ? 7 : 0;
+    },
+    fixtureTasks,
+  );
+
+  assert.equal(exitCode, 7);
+  assert.deepEqual(executedCommands, ['first', 'second']);
+});
+
+test('runs conditional steps only when their required output is missing', async () => {
+  const { runPackageTask } = await loadPackageTaskRunner();
+  const executedCommands = [];
+  const fixtureTasks = {
+    fixture: [{ command: 'build', whenMissing: 'dist/runtime.js' }, { command: 'execute' }],
+  };
+
+  const exitCode = runPackageTask(
+    'fixture',
+    step => {
+      executedCommands.push(step.command);
+      return 0;
+    },
+    fixtureTasks,
+    () => true,
+  );
+
+  assert.equal(exitCode, 0);
+  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);
+
+  assert.deepEqual(environment, {
+    NODE_ENV: 'production',
+    PATH: '/bin',
+    DB_ENV: 'privileged',
+  });
+  assert.deepEqual(inheritedEnvironment, { NODE_ENV: 'test', PATH: '/bin' });
+});

package/scripts/runPackageTask.mjs

@@ -0,0 +1,88 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const packageTasks = Object.freeze({
+  test: [
+    { command: 'npm', arguments: ['run', 'test:order'] },
+    { command: 'node', arguments: ['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'],
+    },
+  ],
+  'test:coverage': [
+    { 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'] },
+  ],
+});
+
+export function createTaskEnvironment(overrides = {}, inheritedEnvironment = process.env) {
+  return { ...inheritedEnvironment, ...overrides };
+}
+
+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;
+  return 1;
+}
+
+export function executeTaskStep(taskStep) {
+  if (taskStep.removePath) {
+    rmSync(taskStep.removePath, { recursive: true, force: true });
+    return 0;
+  }
+
+  const result = spawnSync(taskStep.command, taskStep.arguments ?? [], {
+    env: createTaskEnvironment(taskStep.environment),
+    shell: false,
+    stdio: 'inherit',
+  });
+  return getTaskExitCode(result);
+}
+
+function shouldRunTaskStep(taskStep, pathExists) {
+  return !taskStep.whenMissing || !pathExists(taskStep.whenMissing);
+}
+
+export function runPackageTask(taskName, executeTask = executeTaskStep, taskDefinitions = packageTasks, pathExists = existsSync) {
+  const taskSteps = taskDefinitions[taskName];
+  if (!Array.isArray(taskSteps)) throw new Error('Unknown package task.');
+
+  for (const taskStep of taskSteps) {
+    if (!shouldRunTaskStep(taskStep, pathExists)) continue;
+    const exitCode = executeTask(taskStep);
+    if (exitCode !== 0) return exitCode;
+  }
+  return 0;
+}
+
+function isDirectExecution() {
+  if (!process.argv[1]) return false;
+  return resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+
+function runCommandLineTask() {
+  const taskName = process.argv[2];
+  if (!taskName || !packageTasks[taskName]) {
+    process.stderr.write('[PACKAGE_TASK_CONFIG] Unknown package task.\n');
+    process.exitCode = 2;
+    return;
+  }
+
+  process.exitCode = runPackageTask(taskName);
+}
+
+if (isDirectExecution()) runCommandLineTask();

package/scripts/testParallel/parallelTestPolicy.test.mjs

@@ -7,6 +7,7 @@ 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 testIndexSource = readFileSync(new URL('../../test/index.test.js', import.meta.url), 'utf8');
 const { parallelTestFiles } = require('../../test/index.test.js');
 
@@ -22,8 +23,11 @@ function listRuntimeTestFiles(directoryPath) {
 }
 
 test('keeps runtime test selection in the index and package scripts short', () => {
-  assert.equal(packageJson.scripts.test, 'npm run test:order && node test/index.test.js');
-  assert.match(packageJson.scripts['test:coverage'], /nyc node test\/index\.test\.js$/);
+  assert.equal(packageJson.scripts.test, 'node scripts/runPackageTask.mjs test');
+  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, /command: 'nyc'/);
   assert.match(testIndexSource, /parallelTestFiles/);
   assert.match(testIndexSource, /runIndexedMochaTests/);
   assert.match(testIndexSource, /if \(require\.main === module\)/);