feat: extract line logic into new service (#90)

This commit ensures that if a line is marked as isEol true but the status is somehow not EOL, an error is thrown in the ui.

Additionally, this commit lays the groundwork for more robust parsing.

The eol scanner command (eol.ts), returns ScanResultComponent[] from an sbom.
Then, the eol.svc service transforms ScanResultComponents into Lines.

Something like zod would be useful to actually ensure that we are parsing ScanResultComponents into lines in a type-safe manner.

This commit starts us down that road by extracting Line-related logic into a new service.

Author: edezekiel

biome.json

@@ -31,7 +31,8 @@
       "lib/**",
       "node_modules/**",
       "test/snapshot/**",
-      "test/fixtures/**"
+      "test/fixtures/**",
+      "types/cdxgen.d.ts"
     ]
   }
 }

src/commands/scan/eol.ts

@@ -44,6 +44,7 @@ export default class ScanEol extends Command {
       throw new Error(`Scan failed to generate for dir: ${dir}`);
     }
 
+    // TODO: map scanResultComponents to Lines in a consolidated way
     const lines = await prepareRows(model, scan);
     if (lines?.length === 0) {
       this.log('No dependencies found');

src/service/eol/eol.svc.ts

@@ -1,5 +1,6 @@
 import { log } from '../../utils/log.util.ts';
 import { daysBetween } from '../../utils/misc.ts';
+import type { Line } from '../line.ts';
 import type { ScanResult, ScanResultComponent } from '../nes/modules/sbom.ts';
 import { NesApolloClient } from '../nes/nes.client.ts';
 import { createBomFromDir } from './cdx.svc.ts';
@@ -60,7 +61,7 @@ export async function submitScan(model: SbomModel): Promise<ScanResult> {
  * The idea being that each row can easily be used for
  * processing and/or rendering.
  */
-export async function prepareRows({ components, purls }: SbomModel, scan: ScanResult): Promise<ScanResultComponent[]> {
+export async function prepareRows({ components, purls }: SbomModel, scan: ScanResult): Promise<Line[]> {
   let lines = purls.map((purl) => {
     const { evidence } = components[purl];
     const occ = evidence?.occurrences?.map((o) => o.location).join('\n\t - ');
@@ -78,6 +79,7 @@ export async function prepareRows({ components, purls }: SbomModel, scan: ScanRe
     const daysEol = info.eolAt ? daysBetween(new Date(), info.eolAt) : undefined;
     let status: 'EOL' | 'LTS' | 'OK' = 'OK';
 
+    // TODO: extract this logic into the Line.ts file somehow, so that there is a unified Line model
     if (daysEol === undefined) {
       status = info.isEol ? 'EOL' : status;
     } else if (daysEol < 0) {

src/service/eol/eol.ui.ts

@@ -1,69 +1,6 @@
-import { ux } from '@oclif/core';
 import inquirer from 'inquirer';
 import type { Answers } from 'inquirer';
-
-import type { ScanResultComponent } from '../nes/modules/sbom.ts';
-
-interface Line {
-  daysEol?: number;
-  purl: ScanResultComponent['purl'];
-  info?: {
-    eolAt?: Date;
-    isEol: boolean;
-  };
-  status: ScanResultComponent['status'];
-}
-
-function daysBetween(date1: Date, date2: Date) {
-  const msPerDay = 1000 * 60 * 60 * 24 + 15; // milliseconds in a day plus 15 ms
-  return Math.round((date2.getTime() - date1.getTime()) / msPerDay);
-}
-
-function formatLine(l: Line, idx: number, ctx: { longest: number; total: number }) {
-  let { info, purl, status } = l;
-  let msg = '';
-  let stat: string;
-
-  info = info || { eolAt: new Date(), isEol: false };
-  const daysEol = info.eolAt ? daysBetween(new Date(), info.eolAt) : 0;
-
-  if (daysEol === 0) {
-    status = info.isEol ? 'EOL' : status;
-  } else if (daysEol < 0) {
-    status = 'EOL';
-  } else if (daysEol > 0) {
-    status = 'LTS';
-  }
-
-  switch (status) {
-    case 'EOL': {
-      stat = ux.colorize('red', 'EOL');
-      msg = `EOL'd ${ux.colorize('red', Math.abs(daysEol).toString())} days ago.`;
-      break;
-    }
-
-    case 'LTS': {
-      stat = ux.colorize('yellow', 'LTS');
-      msg = `Will go EOL in ${ux.colorize('yellow', Math.abs(daysEol).toString())} days.`;
-      break;
-    }
-
-    case 'OK': {
-      stat = ux.colorize('green', 'OK');
-      break;
-    }
-    default:
-      throw new Error(`Unknown status: ${status}`);
-  }
-
-  const padlen = ctx.total.toString().length;
-  const rownum = `${idx + 1}`.padStart(padlen, ' ');
-  const name = purl.padEnd(ctx.longest, ' ');
-  return {
-    name: `${rownum}. [${stat}] ${name} | ${msg}`,
-    value: l,
-  };
-}
+import { type Line, formatLine } from '../line.ts';
 
 export function promptComponentDetails(lines: Line[]): Promise<Answers> {
   const context = {

src/service/line.ts

@@ -0,0 +1,67 @@
+import { ux } from '@oclif/core';
+import type { ScanResultComponent } from './nes/modules/sbom.ts';
+
+export interface Line {
+  daysEol?: number;
+  purl: ScanResultComponent['purl'];
+  info?: {
+    eolAt?: Date;
+    isEol: boolean;
+  };
+  status: ScanResultComponent['status'];
+}
+
+export function daysBetween(date1: Date, date2: Date) {
+  const msPerDay = 1000 * 60 * 60 * 24 + 15; // milliseconds in a day plus 15 ms
+  return Math.round((date2.getTime() - date1.getTime()) / msPerDay);
+}
+
+export function getMessageAndStatus(status: string, eolAt?: Date) {
+  let msg = '';
+  let stat = '';
+
+  const stringifiedDaysEol = eolAt ? Math.abs(daysBetween(new Date(), eolAt)).toString() : 'unknown';
+
+  switch (status) {
+    case 'EOL': {
+      stat = ux.colorize('red', 'EOL');
+      msg = `EOL'd ${ux.colorize('red', stringifiedDaysEol)} days ago.`;
+      break;
+    }
+
+    case 'LTS': {
+      stat = ux.colorize('yellow', 'LTS');
+      msg = `Will go EOL in ${ux.colorize('yellow', stringifiedDaysEol)} days.`;
+      break;
+    }
+
+    case 'OK': {
+      stat = ux.colorize('green', 'OK');
+      break;
+    }
+    default:
+      throw new Error(`Unknown status: ${status}`);
+  }
+
+  return { stat, msg };
+}
+
+export function formatLine(l: Line, idx: number, ctx: { longest: number; total: number }) {
+  let { info, purl, status } = l;
+
+  info = info || { eolAt: new Date(), isEol: false };
+
+  if (info.isEol && status !== 'EOL') {
+    throw new Error(`isEol is true but status is not EOL: ${purl}`);
+  }
+
+  const { stat, msg } = getMessageAndStatus(status, info.eolAt);
+
+  const padlen = ctx.total.toString().length;
+  const rownum = `${idx + 1}`.padStart(padlen, ' ');
+  const name = purl.padEnd(ctx.longest, ' ');
+  return {
+    name: `${rownum}. [${stat}] ${name} | ${msg}`,
+    value: l,
+  };
+}

src/utils/log.util.ts

@@ -3,17 +3,17 @@
  * don't have the command instance handy
  */
 export const log = {
-  info: (_message?: any, ...args: any[]) => {
+  info: (_message?: unknown, ...args: unknown[]) => {
     console.log('[default_log]', ...args);
   },
-  warn: (_message?: any, ...args: any[]) => {
+  warn: (_message?: unknown, ...args: unknown[]) => {
     console.warn('[default_warn]', ...args);
   },
 };
 
 export const initOclifLog = (
-  info: (message?: any, ...args: any[]) => void,
-  warn: (message?: any, ...args: any[]) => void,
+  info: (message?: unknown, ...args: unknown[]) => void,
+  warn: (message?: unknown, ...args: unknown[]) => void,
 ) => {
   log.info = info;
   log.warn = warn;

test/hooks/prerun/CommandContextHook.test.ts

@@ -5,6 +5,6 @@ import { runHook } from '@oclif/test';
 describe('hooks', () => {
   it('shows a message', async () => {
     const { result } = await runHook('prerun', { id: 'report committers' });
-    ok((result as any).successes);
+    ok((result as unknown as { successes: unknown[] }).successes);
   });
 });

test/service/line.test.ts

@@ -0,0 +1,86 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { daysBetween, formatLine, getMessageAndStatus } from '../../src/service/line.ts';
+import type { Line } from '../../src/service/line.ts';
+
+describe('line', () => {
+  describe('daysBetween', () => {
+    it('should calculate days between dates', () => {
+      const date1 = new Date('2024-01-01');
+      const date2 = new Date('2024-01-31');
+      assert.equal(daysBetween(date1, date2), 30);
+    });
+
+    it('should handle negative differences', () => {
+      const date1 = new Date('2024-01-31');
+      const date2 = new Date('2024-01-01');
+      assert.equal(daysBetween(date1, date2), -30);
+    });
+  });
+
+  describe('getMessageAndStatus', () => {
+    it('should format EOL status', () => {
+      const eolAt = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
+      const { stat, msg } = getMessageAndStatus('EOL', eolAt);
+      assert(stat.includes('EOL'));
+      assert(msg.includes('days ago'));
+    });
+
+    it('should format LTS status', () => {
+      const eolAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000); // 30 days from now
+      const { stat, msg } = getMessageAndStatus('LTS', eolAt);
+      assert(stat.includes('LTS'));
+      assert(msg.includes('Will go EOL in'));
+    });
+
+    it('should format OK status', () => {
+      const { stat, msg } = getMessageAndStatus('OK');
+      assert(stat.includes('OK'));
+      assert.equal(msg, '');
+    });
+
+    it('should handle missing eolAt date', () => {
+      const { msg } = getMessageAndStatus('EOL');
+      assert(msg.includes('unknown') && msg.includes('days ago'));
+    });
+
+    it('should throw on unknown status', () => {
+      assert.throws(() => getMessageAndStatus('INVALID'), /Unknown status: INVALID/);
+    });
+  });
+
+  describe('formatLine', () => {
+    const context = { longest: 20, total: 3 };
+
+    it('should format line with EOL status', () => {
+      const line: Line = {
+        purl: 'pkg:npm/[email protected]',
+        status: 'EOL',
+        info: { isEol: true, eolAt: new Date() },
+      };
+      const result = formatLine(line, 0, context);
+      assert(result.name.includes('['));
+      assert(result.name.includes('EOL'));
+      assert(result.name.includes('pkg:npm/[email protected]'));
+      assert.equal(result.value, line);
+    });
+
+    it('should throw when isEol is true but status is not EOL', () => {
+      const line: Line = {
+        purl: 'pkg:npm/[email protected]',
+        status: 'OK',
+        info: { isEol: true },
+      };
+      assert.throws(() => formatLine(line, 0, context), /isEol is true but status is not EOL/);
+    });
+
+    it('should handle missing info', () => {
+      const line: Line = {
+        purl: 'pkg:npm/[email protected]',
+        status: 'OK',
+      };
+      const result = formatLine(line, 0, context);
+      assert(result.name.includes('OK'));
+    });
+  });
+});

test/utils/mocks/base.mock.ts

@@ -5,9 +5,9 @@ import { default as sinon } from 'sinon';
  * from a FIFO
  */
 export class BaseStackMock {
-  stack: any[] = [];
+  stack: unknown[] = [];
 
-  constructor(target: any, prop: string) {
+  constructor(target: Record<string, unknown>, prop: string) {
     sinon.stub(target, prop).callsFake(() => this.next());
   }
 
@@ -16,7 +16,7 @@ export class BaseStackMock {
     return Promise.resolve(this.stack.shift());
   }
 
-  public push(value: any) {
+  public push(value: unknown) {
     this.stack.push(value);
     return this;
   }

test/utils/mocks/fetch.mock.ts

@@ -5,12 +5,12 @@ import { BaseStackMock } from './base.mock.ts';
  * what Apollo uses to make GraphQL calls.
  */
 export class FetchMock extends BaseStackMock {
-  constructor(stack: any[] = []) {
+  constructor(stack: unknown[] = []) {
     super(globalThis, 'fetch');
     this.stack = stack;
   }
 
-  addGraphQL<D>(data?: D, errors: any[] = []) {
+  addGraphQL<D>(data?: D, errors: unknown[] = []) {
     this.stack.push({
       headers: {
         get: () => 'application/json; charset=utf-8',