@fabasoad/sarif-to-slack 1.3.5 → 1.4.0

package/src/representations/TableGroupBySarifRepresentation.ts

@@ -1,25 +1,25 @@
-import type { SarifModel } from '../types'
-import type Finding from '../model/Finding'
-import TableGroupRepresentation from './TableGroupRepresentation'
+import type { SarifModel } from '../types';
+import type Finding from '../model/Finding';
+import TableGroupRepresentation from './TableGroupRepresentation';
 
 export default abstract class TableGroupBySarifRepresentation<
   KPer extends keyof Pick<Finding, 'level' | 'severity'>
 > extends TableGroupRepresentation<'sarifPath', KPer> {
-  private readonly _fileToNumberMap = new Map<string, number>()
+  private readonly _fileToNumberMap = new Map<string, number>();
 
   protected constructor(
     keyPer: KPer,
     values: string[],
-    model: SarifModel
+    model: SarifModel,
   ) {
-    super('sarifPath', keyPer, values, model)
+    super('sarifPath', keyPer, values, model);
   }
 
   protected override keyByToString(key: Finding['sarifPath']): string {
-    const keyStr: string = key.toString()
+    const keyStr: string = key.toString();
     if (!this._fileToNumberMap.has(keyStr)) {
-      this._fileToNumberMap.set(keyStr, this._fileToNumberMap.size + 1)
+      this._fileToNumberMap.set(keyStr, this._fileToNumberMap.size + 1);
     }
-    return this._fileToNumberMap.get(keyStr)?.toString() as string
+    return this._fileToNumberMap.get(keyStr)?.toString() as string;
   }
 }

package/src/representations/TableGroupByToolNamePerLevelRepresentation.ts

@@ -1,10 +1,10 @@
-import { type SarifModel, SecurityLevelValues } from '../types'
+import { type SarifModel, SecurityLevelValues } from '../types';
 import TableGroupByToolNameRepresentation
-  from './TableGroupByToolNameRepresentation'
+  from './TableGroupByToolNameRepresentation';
 
 export default class TableGroupByToolNamePerLevelRepresentation extends TableGroupByToolNameRepresentation<'level'> {
 
   public constructor(model: SarifModel) {
-    super('level', SecurityLevelValues, model)
+    super('level', SecurityLevelValues, model);
   }
 }

package/src/representations/TableGroupByToolNamePerSeverityRepresentation.ts

@@ -1,10 +1,10 @@
-import { type SarifModel, SecuritySeverityValues } from '../types'
+import { type SarifModel, SecuritySeverityValues } from '../types';
 import TableGroupByToolNameRepresentation
-  from './TableGroupByToolNameRepresentation'
+  from './TableGroupByToolNameRepresentation';
 
 export default class TableGroupByToolNamePerSeverityRepresentation extends TableGroupByToolNameRepresentation<'severity'> {
 
   public constructor(model: SarifModel) {
-    super('severity', SecuritySeverityValues, model)
+    super('severity', SecuritySeverityValues, model);
   }
 }

package/src/representations/TableGroupByToolNameRepresentation.ts

@@ -1,5 +1,5 @@
-import type { SarifModel } from '../types'
-import type Finding from '../model/Finding'
+import type { SarifModel } from '../types';
+import type Finding from '../model/Finding';
 import TableGroupRepresentation from './TableGroupRepresentation';
 
 export default abstract class TableGroupByToolNameRepresentation<
@@ -8,8 +8,8 @@ export default abstract class TableGroupByToolNameRepresentation<
   protected constructor(
     keyPer: KPer,
     values: string[],
-    model: SarifModel
+    model: SarifModel,
   ) {
-    super('toolName', keyPer, values, model)
+    super('toolName', keyPer, values, model);
   }
 }

package/src/representations/TableGroupRepresentation.ts

@@ -1,78 +1,78 @@
-import type { SarifModel } from '../types'
-import type Finding from '../model/Finding'
-import Representation from './Representation'
-import Table from './table/Table'
-import Logger from '../Logger'
+import type { SarifModel } from '../types';
+import type Finding from '../model/Finding';
+import Representation from './Representation';
+import Table from './table/Table';
+import Logger from '../Logger';
 
 export default abstract class TableGroupRepresentation<
   KBy extends keyof Pick<Finding, 'toolName' | 'runId' | 'sarifPath'>,
   KPer extends keyof Pick<Finding, 'level' | 'severity'>
 > extends Representation {
-  private readonly _logger = new Logger('TableGroupRepresentation');
 
   protected constructor(
     private readonly _keyBy: KBy,
     private readonly _keyPer: KPer,
     private readonly _values: string[],
-    model: SarifModel
+    model: SarifModel,
   ) {
-    super(model, 'toolName')
+    super(model, 'toolName');
   }
 
   private groupFindingsPer(findings: Finding[]): Finding[][] {
     return findings.reduce(
       (grouped: Finding[][], f: Finding): Finding[][] => {
-        grouped[f[this._keyPer]].push(f)
-        return grouped
+        grouped[f[this._keyPer]].push(f);
+        return grouped;
       },
-      Array.from({ length: this._values.length }, (): Finding[] => [] as Finding[])
-    )
+      Array.from({ length: this._values.length }, (): Finding[] => [] as Finding[]),
+    );
   }
 
   protected keyByToString(key: Finding[KBy]): string {
-    return key.toString()
+    return key.toString();
   }
 
   private groupFindingsBy(findings: Finding[]): Map<string, Finding[]> {
     return findings.reduce(
       (grouped: Map<string, Finding[]>, f: Finding): Map<string, Finding[]> => {
-        const key: string = this.keyByToString(f[this._keyBy])
+        const key: string = this.keyByToString(f[this._keyBy]);
         if (!grouped.has(key)) {
-          grouped.set(key, [])
+          grouped.set(key, []);
         }
-        grouped.get(key)?.push(f)
-        return grouped
+        grouped.get(key)?.push(f);
+        return grouped;
       },
-      new Map<string, Finding[]>()
-    )
+      new Map<string, Finding[]>(),
+    );
   }
 
   private get title(): string {
     switch (this._keyBy) {
-      case 'toolName': return 'Tool'
-      case 'runId': return 'Run #'
-      case 'sarifPath': return 'File #'
-      default: return ''
+      case 'toolName': return 'Tool';
+      case 'runId': return 'Run #';
+      case 'sarifPath': return 'File #';
+      default: return '';
     }
   }
 
   public override compose(): string {
-    const groupedBy: Map<string, Finding[]> = this.groupFindingsBy(this._model.findings)
+    const logger = new Logger();
+    const groupedBy: Map<string, Finding[]> = this.groupFindingsBy(this._model.findings);
     const table = new Table({
       main: this.title,
       rows: Array.from(groupedBy.keys()),
       columns: this._values,
-    })
-    let i = 0
+    });
+    let i: number = 0;
     for (const findings of groupedBy.values()) {
-      const grouped: Finding[][] = this.groupFindingsPer(findings)
+      const grouped: Finding[][] = this.groupFindingsPer(findings);
       for (let j = 0; j < grouped.length; j++) {
-        table.set(i, j, grouped[j].length)
+        table.set(i, j, grouped[j].length);
       }
-      i++
+      i++;
     }
-    const result: string = this.codeBlock(table.toString())
-    this._logger.trace(result)
-    return result
+    const result: string = this.codeBlock(table.toString());
+    logger.trace(result);
+    return result;
   }
 }

package/src/representations/table/Cell.ts

@@ -1,25 +1,25 @@
 export default class Cell {
-  private _width: number
+  private _width: number;
 
   public constructor(private _value: number = 0) {
-    this._width = _value.toString().length
+    this._width = _value.toString().length;
   }
 
   public setWidth(width: number): void {
-    this._width = width > this._width ? width : this._width
+    this._width = width > this._width ? width : this._width;
   }
 
   public getWidth(): number {
-    return this._width
+    return this._width;
   }
 
   public get value(): number {
-    return this._value
+    return this._value;
   }
 
   public toString(): string {
-    const str: string = this._value.toString()
-    const repeatCount: number = this._width - str.length
-    return `${str}${repeatCount > 0 ? ' '.repeat(repeatCount) : ''}`
+    const str: string = this._value.toString();
+    const repeatCount: number = this._width - str.length;
+    return `${str}${repeatCount > 0 ? ' '.repeat(repeatCount) : ''}`;
   }
 }

package/src/representations/table/Column.ts

@@ -1,39 +1,39 @@
-import type Cell from './Cell'
-import Logger from '../../Logger'
+import type Cell from './Cell';
+import Logger from '../../Logger';
 
 export default class Column {
-  private readonly _logger: Logger = new Logger('Column');
   private readonly _cells: Cell[];
 
   public constructor(
     public readonly header: string,
     cellsCount: number,
   ) {
-    this._cells = new Array<Cell>(cellsCount)
+    this._cells = new Array<Cell>(cellsCount);
   }
 
   public get total(): number {
     return this._cells
       .reduce((sum: number, c: Cell): number => {
-        sum += Number(c.value)
-        return sum
-      }, 0)
+        sum += Number(c.value);
+        return sum;
+      }, 0);
   }
 
   public get width(): number {
     return Math.max(
       ...this._cells.map((c: Cell): number => c.getWidth()),
-      this.total.toString().length
-    )
+      this.total.toString().length,
+    );
   }
 
   public setCell(index: number, value: Cell): void {
     if (index >= 0 && index < this._cells.length) {
-      this._cells[index] = value
-      const width: number = this.width
-      this._cells.forEach((c: Cell): void => c.setWidth(width))
+      this._cells[index] = value;
+      const width: number = this.width;
+      this._cells.forEach((c: Cell): void => c.setWidth(width));
     } else {
-      this._logger.warn(`Cell index out of range. Requested index: ${index}. Cells count: ${this._cells.length}.`)
+      const logger = new Logger();;
+      logger.warn(`Cell index out of range. Requested index: ${index}. Cells count: ${this._cells.length}.`);
     }
   }
 }

package/src/representations/table/Row.ts

@@ -1,8 +1,7 @@
-import Cell from './Cell'
-import Logger from '../../Logger'
+import Cell from './Cell';
+import Logger from '../../Logger';
 
 export default class Row {
-  private readonly _logger = new Logger('Row');
   private readonly _cells: Cell[];
   private _totalWidth: number;
 
@@ -11,40 +10,41 @@ export default class Row {
     public readonly headerWidth: number,
     cellsCount: number,
   ) {
-    this._cells = Array.from({ length: cellsCount }, (): Cell => new Cell())
-    this._totalWidth = 1
+    this._cells = Array.from({ length: cellsCount }, (): Cell => new Cell());
+    this._totalWidth = 1;
   }
 
   public get total(): number {
     return this._cells
       .reduce((sum: number, c: Cell): number => {
-        sum += Number(c.value)
-        return sum
-      }, 0)
+        sum += Number(c.value);
+        return sum;
+      }, 0);
   }
 
   public setCell(index: number, value: Cell): void {
     if (index >= 0 && index < this._cells.length) {
-      this._cells[index] = value
+      this._cells[index] = value;
     } else {
-      this._logger.warn(`Setting cell failed. Reason: index out of range. Requested index: ${index}. Cells count: ${this._cells.length}.`)
+      const logger = new Logger();
+      logger.warn(`Setting cell failed. Reason: index out of range. Requested index: ${index}. Cells count: ${this._cells.length}.`);
     }
   }
 
   public get totalWidth(): number {
-    return this._totalWidth
+    return this._totalWidth;
   }
 
   public setTotalWidth(value: number): void {
-    this._totalWidth = value
+    this._totalWidth = value;
   }
 
   public toString(): string {
-    const result: string[] = []
-    result.push(`${this._header}${this.headerWidth > this._header.length ? ' '.repeat(this.headerWidth - this._header.length) : ''}`)
-    this._cells.map((c: Cell): string => c.toString()).forEach((v: string): number => result.push(v))
+    const result: string[] = [];
+    result.push(`${this._header}${this.headerWidth > this._header.length ? ' '.repeat(this.headerWidth - this._header.length) : ''}`);
+    this._cells.map((c: Cell): string => c.toString()).forEach((v: string): number => result.push(v));
     const totalStr: string = this.total.toString();
-    result.push(`${totalStr}${this._totalWidth > totalStr.length ? ' '.repeat(this._totalWidth - totalStr.length) : ''}`)
-    return `|${result.join('|')}|`
+    result.push(`${totalStr}${this._totalWidth > totalStr.length ? ' '.repeat(this._totalWidth - totalStr.length) : ''}`);
+    return `|${result.join('|')}|`;
   }
 }

package/src/representations/table/Table.ts

@@ -1,8 +1,8 @@
-import Column from './Column'
-import Row from './Row'
-import Cell from './Cell'
+import Column from './Column';
+import Row from './Row';
+import Cell from './Cell';
 
-const HEADER_TOTAL: string = 'Total'
+const HEADER_TOTAL: string = 'Total';
 
 export type TableHeaders = {
   main?: string,
@@ -11,47 +11,47 @@ export type TableHeaders = {
 }
 
 export default class Table {
-  private readonly header: string
-  private readonly columns: Column[]
-  private readonly rows: Row[]
+  private readonly header: string;
+  private readonly columns: Column[];
+  private readonly rows: Row[];
 
   public constructor(
     headers: TableHeaders,
   ) {
-    this.header = headers.main ?? ''
+    this.header = headers.main ?? '';
     this.columns = Array.from(
       { length: headers.columns.length },
-      (_: unknown, index: number): Column => new Column(headers.columns[index], headers.rows.length)
-    )
+      (_: unknown, index: number): Column => new Column(headers.columns[index], headers.rows.length),
+    );
     const headerWidth: number = Math.max(
       this.header.length,
       ...headers.rows.map((v: string): number => v.length),
       HEADER_TOTAL.length,
-    )
+    );
     this.rows = Array.from(
       { length: headers.rows.length },
-      (_: unknown, index: number): Row => new Row(headers.rows[index], headerWidth, headers.columns.length)
-    )
+      (_: unknown, index: number): Row => new Row(headers.rows[index], headerWidth, headers.columns.length),
+    );
   }
 
   public set(rowIndex: number, columnIndex: number, v: number): void {
     if (rowIndex >= 0 && rowIndex < this.rows.length && columnIndex >= 0 && columnIndex < this.columns.length) {
-      const cell = new Cell(v)
-      cell.setWidth(this.columns[columnIndex].header.length)
-      this.columns[columnIndex].setCell(rowIndex, cell)
-      this.rows[rowIndex].setCell(columnIndex, cell)
+      const cell = new Cell(v);
+      cell.setWidth(this.columns[columnIndex].header.length);
+      this.columns[columnIndex].setCell(rowIndex, cell);
+      this.rows[rowIndex].setCell(columnIndex, cell);
       // Update width of the last cell ("Total") of every row, so that it is shown
       // correctly in string representation
       const rowTotalWidth: number = Math.max(
         // Based on the sum of all total values
         this.rows.reduce((sum: number, r: Row): number => {
-          sum += r.total
-          return sum
+          sum += r.total;
+          return sum;
         }, 0).toString().length,
         // Based on the width of "Total" header
         HEADER_TOTAL.length,
-      )
-      this.rows.forEach((r: Row): void => r.setTotalWidth(rowTotalWidth))
+      );
+      this.rows.forEach((r: Row): void => r.setTotalWidth(rowTotalWidth));
     }
   }
 

package/src/system.ts

@@ -8,10 +8,10 @@ import { version, sha, buildAt } from './metadata.json';
  * @internal
  */
 export function logMetadata(): void {
-  const logger = new Logger(logMetadata.name);
-  logger.info(`version: ${version}`);
-  logger.info(`sha: ${sha}`);
-  logger.info(`built at: ${buildAt}`);
+  const logger = new Logger();
+  logger.debug(`version: ${version}`);
+  logger.debug(`sha: ${sha}`);
+  logger.debug(`built at: ${buildAt}`);
 }
 
 /**
@@ -21,7 +21,7 @@ export function logMetadata(): void {
  */
 export function isDebug(): boolean {
   const parseResult: ZodSafeParseResult<boolean> = z.stringbool().safeParse(
-    process.env.ACTIONS_STEP_DEBUG
+    process.env.ACTIONS_STEP_DEBUG,
   );
   return parseResult.success && parseResult.data;
 }

package/src/types.ts

@@ -1,7 +1,7 @@
-import type { Run } from 'sarif'
-import type { ColorOptions } from './model/color/ColorOptions'
-import type FindingArray from './model/FindingArray'
-import type { SendIf } from './model/SendIf'
+import type { Run } from 'sarif';
+import type { ColorOptions } from './model/color/ColorOptions';
+import type FindingArray from './model/FindingArray';
+import type { SendIf } from './model/SendIf';
 
 /**
  * Type representing properties that indicate whether to include certain information
@@ -9,7 +9,7 @@ import type { SendIf } from './model/SendIf'
  * @public
  */
 export type IncludeAwareOptions = {
-  include: boolean
+  include: boolean,
 }
 
 /**
@@ -18,7 +18,7 @@ export type IncludeAwareOptions = {
  * @public
  */
 export type IncludeAwareWithValueOptions = IncludeAwareOptions & {
-  value?: string
+  value?: string,
 }
 
 /**
@@ -34,7 +34,7 @@ export enum FooterType {
    * Represents a footer with Markdown formatting. Text can include formatting
    * such as bold, italics, and links.
    */
-  Markdown = 'mrkdwn'
+  Markdown = 'mrkdwn',
 }
 
 /**
@@ -43,7 +43,7 @@ export enum FooterType {
  * @public
  */
 export type FooterOptions = IncludeAwareWithValueOptions & {
-  type?: FooterType
+  type?: FooterType,
 }
 
 /**
@@ -221,11 +221,16 @@ export enum RepresentationType {
   TableGroupBySarifPerSeverity = 13,
 }
 
+/**
+ * Valid SARIF file extensions.
+ * @public
+ */
+export const SarifFileExtensionItems = ['sarif', 'json'] as const;
 /**
  * SARIF file extension.
  * @public
  */
-export type SarifFileExtension = 'sarif' | 'json'
+export type SarifFileExtension = typeof SarifFileExtensionItems[number];
 
 /**
  * Represents options for the provided SARIF file(s), such as path, should files
@@ -238,6 +243,30 @@ export type SarifOptions = {
   extension?: SarifFileExtension,
 }
 
+/**
+ * Valid log levels for the Logger.
+ * @public
+ */
+export const LogLevelItems = ['silly', 'trace', 'debug', 'info', 'warning', 'error', 'fatal'] as const;
+/**
+ * Log levels for the Logger.
+ * @public
+ */
+export type LogLevel = typeof LogLevelItems[number];
+
+/**
+ * It is used to stored logging options in global state
+ * @public
+ */
+export type LoggerOptions = {
+  logFunctionName?: boolean,
+  logFunctionNameOnPosition?: number,
+  minLevel?: LogLevel,
+  name?: string,
+  stylePrettyLogs?: boolean,
+  prettyLogTemplate?: string,
+}
+
 /**
  * Options for the SarifToSlackClient.
  * @public
@@ -253,6 +282,7 @@ export type SarifToSlackClientOptions = {
   run?: IncludeAwareOptions,
   representation?: RepresentationType,
   sendIf?: SendIf,
+  loggerOptions?: LoggerOptions,
 }
 
 /**
@@ -273,8 +303,8 @@ export enum SecuritySeverity {
 
 export const SecuritySeverityValues: string[] =
   Object.values(SecuritySeverity).filter(
-    (v: string | SecuritySeverity): v is string => typeof v === 'string'
-  )
+    (v: string | SecuritySeverity): v is string => typeof v === 'string',
+  );
 
 /**
  * Enum of security level.
@@ -293,8 +323,8 @@ export enum SecurityLevel {
 
 export const SecurityLevelValues: string[] =
   Object.values(SecurityLevel).filter(
-    (v: string | SecurityLevel): v is string => typeof v === 'string'
-  )
+    (v: string | SecurityLevel): v is string => typeof v === 'string',
+  );
 
 /**
  * The data about run, such as {@link Run} itself, tool name of the run and ID

package/src/utils/Comparators.ts

@@ -1,4 +1,4 @@
-import type Finding from '../model/Finding'
+import type Finding from '../model/Finding';
 
 /**
  * This function returns a comparator function based on the property of the
@@ -9,11 +9,11 @@ import type Finding from '../model/Finding'
 export function findingsComparatorByKey<K extends keyof Finding>(key: K): (a: Finding, b: Finding) => number {
   return (a: Finding, b: Finding): number => {
     switch (key) {
-      case 'severity': return b.severity - a.severity
-      case 'level': return b.level - a.level
-      case 'runId': return a.runId - b.runId
-      case 'toolName': return a.toolName.toLowerCase().localeCompare(b.toolName.toLowerCase())
-      default: return 1
+      case 'severity': return b.severity - a.severity;
+      case 'level': return b.level - a.level;
+      case 'runId': return a.runId - b.runId;
+      case 'toolName': return a.toolName.toLowerCase().localeCompare(b.toolName.toLowerCase());
+      default: return 1;
     }
   }
 }

package/src/utils/ExtendedArray.ts

@@ -6,6 +6,6 @@
 export default class ExtendedArray<T> extends Array<T> {
 
   public findByProperty<K extends keyof T>(prop: K, value: T[K]): T | undefined {
-    return this.find((v: T): boolean => v[prop] === value)
+    return this.find((v: T): boolean => v[prop] === value);
   }
 }

package/src/utils/FileUtils.ts

@@ -16,7 +16,7 @@ function listFiles(
   dir: string,
   recursive: boolean,
   extension: SarifFileExtension,
-  fileList: string[] = []
+  fileList: string[] = [],
 ): string[] {
   if (fs.statSync(dir).isDirectory()) {
     const entries: string[] = fs.readdirSync(dir);
@@ -27,7 +27,7 @@ function listFiles(
       } else if (path.extname(fullPath).toLowerCase() === `.${extension}`) {
         fileList.push(fullPath);
       }
-    })
+    });
   }
   return fileList;
 }
@@ -39,11 +39,11 @@ function listFiles(
  * @internal
  */
 export function extractListOfFiles(opts: SarifOptions): string[] {
-  const logger = new Logger(extractListOfFiles.name);
   if (!fs.existsSync(opts.path)) {
     throw new Error(`Provided path does not exist: ${opts.path}`);
   }
 
+  const logger = new Logger();
   const stats: fs.Stats = fs.statSync(opts.path);
 
   if (stats.isDirectory()) {