@cloud-copilot/iam-shrink 0.1.0

package/src/cli_utils.test.ts

@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { convertOptions, dashToCamelCase, extractActionsFromLineOfInput, parseStdIn } from "./cli_utils";
+import { readStdin } from './stdin';
+vi.mock('./stdin')
+
+beforeEach(() => {
+  vi.resetAllMocks()
+})
+
+const extractScenarios = [
+  {input: '  s3:Get*   ',                expected: ['s3:Get*']},
+  {input: '  s3:Get* s3:Put*  ',         expected: ['s3:Get*', 's3:Put*']},
+  {input: '  "s3:Get*", "s3:Put*"',      expected: ['s3:Get*', 's3:Put*']},
+  {input: '  `s3:Get*`, `s3:Put*`',      expected: ['s3:Get*', 's3:Put*']},
+  {input: `  's3:Get*', 's3:Put*'`,      expected: ['s3:Get*', 's3:Put*']},
+  {input: `  'resource-Groups:Get*'`,    expected: ['resource-Groups:Get*']},
+  {input: `s3:Get*, s3:Put*`,            expected: ['s3:Get*', 's3:Put*']},
+  {input: "s3:Put*",                     expected: ['s3:Put*']},
+  {input: ":s3:Put*",                    expected: []},
+  {input: 'arn:aws:apigateway:*::/apis', expected: []},
+  {input: 'hamburger',                   expected: []},
+]
+
+const dashToCamelCaseScenarios = [
+  {input: "--iterations", expected: "iterations"},
+  {input: "--show-data-version", expected: "showDataVersion"},
+]
+
+describe('cli_utils', () => {
+  describe('extractActionsFromLineOfInput', () => {
+    extractScenarios.forEach((scenario, index) => {
+      it(`should return for scenario ${index}: ${scenario.input} `, () => {
+        // Given the input
+        const input = scenario.input
+
+        // When the actions are extracted
+        const result = extractActionsFromLineOfInput(input)
+
+        // Then I should get the expected result
+        expect(result).toEqual(scenario.expected)
+      })
+    })
+  })
+
+  describe('dashToCamelCase', () => {
+    dashToCamelCaseScenarios.forEach((scenario, index) => {
+      it(`should return for scenario ${index}: ${scenario.input} `, () => {
+        // Given the input
+        const input = scenario.input
+
+        // When the input is converted
+        const result = dashToCamelCase(input)
+
+        // Then I should get the expected result
+        expect(result).toEqual(scenario.expected)
+      })
+    })
+  })
+
+  describe('convertOptions', () => {
+    it('should convert the options to keys on an object', () => {
+      // Given options as an array of strings
+      const optionArgs = ['--distinct', '--sort', '--something-cool', '--key-with-value=10']
+
+      // When the options are converted
+      const result = convertOptions(optionArgs)
+
+      // Then each option should be a key on the object
+      expect(result).toEqual({
+        distinct: true,
+        sort: true,
+        somethingCool: true,
+        keyWithValue: "10",
+      })
+    })
+  })
+
+  describe('parseStdIn', () => {
+    it('should return an empty object if no data is provided', async () => {
+      // Given no data is provided
+      vi.mocked(readStdin).mockResolvedValue('')
+
+      // When the actions are parsed
+      const result = await parseStdIn({})
+
+      // Then I should get an empty object
+      expect(result).toEqual({})
+    })
+
+    it('should return an array of actions from the data if it cannot be parsed', async () => {
+      // Given there is data with actions in multiple lines
+      vi.mocked(readStdin).mockResolvedValue('s3:GetObject\ns3:PutObject\ns3:DeleteObject\n')
+
+      // When the actions are parsed
+      const result = await parseStdIn({})
+
+      // Then I should get the expected actions
+      expect(result).toEqual({strings: ['s3:GetObject', 's3:PutObject', 's3:DeleteObject']})
+    })
+
+    it('should return an object if the data can be parsed', async () => {
+      // Given there is data that can be parsed
+      const dataValue = {
+        Action: ["s3:GetObject"],
+        Version: "2012-10-17"
+      }
+      vi.mocked(readStdin).mockResolvedValue(JSON.stringify(dataValue))
+
+      // When the actions are parsed
+      const result = await parseStdIn({})
+
+      // Then I should get the expected object
+      expect(result).toEqual({object: dataValue})
+    })
+  })
+})
+

package/src/cli_utils.ts

@@ -0,0 +1,82 @@
+import { ShrinkOptions } from "./shrink.js";
+import { shrinkJsonDocument } from "./shrink_file.js";
+import { readStdin } from "./stdin.js";
+
+interface CliOptions extends ShrinkOptions {
+  showDataVersion: boolean
+  readWaitMs: string
+}
+
+/**
+ * Convert a dash-case string to camelCase
+ * @param str the string to convert
+ * @returns the camelCase string
+ */
+export function dashToCamelCase(str: string): string {
+  str = str.substring(2)
+  return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+}
+
+/**
+ * Convert an array of option strings to an object
+ *
+ * @param optionArgs the array of option strings to convert
+ * @returns the object representation of the options
+ */
+export function convertOptions(optionArgs: string[]): Partial<CliOptions> {
+  const options: Record<string, string | boolean | number> = {} ;
+
+  for(const option of optionArgs) {
+    let key: string = option
+    let value: boolean | string = true
+    if(option.includes('=')) {
+      [key,value] = option.split('=')
+    }
+
+    options[dashToCamelCase(key)] = value
+  }
+  if(options.iterations) {
+    const iterationNumber = parseInt(options.iterations as string)
+    if(isNaN(iterationNumber)) {
+      delete options.iterations
+    } else if(iterationNumber <= 0) {
+      options.iterations = Infinity
+    } else {
+      options.iterations = iterationNumber
+    }
+  }
+
+  return options
+}
+
+const actionPattern = /\:?([a-zA-Z0-9-]+:[a-zA-Z0-9*]+)/g;
+export function extractActionsFromLineOfInput(line: string): string[] {
+  const matches = line.matchAll(actionPattern)
+
+  return Array.from(matches)
+              .filter((match) => !match[0].startsWith('arn:') && !match[0].startsWith(':'))
+              .map((match) => match[1])
+}
+
+/**
+ * Parse the actions from stdin
+ *
+ * @returns an array of strings from stdin
+ */
+export async function parseStdIn(options: Partial<CliOptions>): Promise<{strings?: string[], object?: any}> {
+  const delay = options.readWaitMs ? parseInt(options.readWaitMs.replaceAll(/\D/g, '')) : undefined
+  const data = await readStdin(delay)
+  if(data.length === 0) {
+    return {}
+  }
+
+  try {
+    const object = await shrinkJsonDocument(options, JSON.parse(data))
+    return {object}
+  } catch (err: any) {}
+
+
+  const lines = data.split('\n')
+  const actions = lines.flatMap(line => extractActionsFromLineOfInput(line))
+  return {strings: actions}
+}

package/src/errors.ts

@@ -0,0 +1,52 @@
+const bugBaseUrl = 'https://github.com/cloud-copilot/iam-shrink/issues/new'
+
+/**
+ * The title of the bug report
+ * @param errorMatch The undesired match
+ * @returns the title of the bug report
+ */
+function bugTitle(errorMatch: string) {
+  return `Bug: ShrinkValidationError. ${errorMatch}`;
+}
+
+/**
+ * The body of the bug report
+ *
+ * @param errorMatch The undesired match
+ * @param desiredPatterns The desired patterns
+ * @param excludedPatterns The excluded patterns
+ * @returns the body of the bug report
+ */
+function bugBody(errorMatch: string, desiredPatterns: string[]) {
+  return `${errorMatch} while shrinking patterns ${JSON.stringify(desiredPatterns)}`;
+}
+
+/**
+ * Get the full url of the full bug report
+ *
+ * @param desiredPatterns The desired patterns
+ * @param excludedPatterns The excluded patterns
+ * @param errorMatch The undesired match that caused the bug
+ * @returns the full url to create a new bug report
+ */
+function bugUrl(desiredPatterns: string[], errorMatch: string) {
+  return `${bugBaseUrl}?labels=bug&title=${encodeURIComponent(bugTitle(errorMatch))}&body=${encodeURIComponent(bugBody(errorMatch, desiredPatterns))}`;
+}
+
+export class ShrinkValidationError extends Error {
+  /**
+   * Capture a validation error from a shrink operation
+   *
+   * @param desiredPatterns the patterns the user wanted to shrink
+   * @param excludedPatterns the patterns the user wanted to exclude
+   * @param errorMatch the undesired match that triggered the bug
+   */
+  constructor(public readonly desiredPatterns: string[], public readonly errorMatch: string) {
+    super([
+      `@cloud-copilot/iam-shrink has failed validation and this is a bug.`,
+      `Please file a bug at ${bugUrl(desiredPatterns, errorMatch)}`,
+    ].join("\n"));
+    this.name = "ShrinkValidationError"; // Set the name of the error
+  }
+}
+

package/src/index.ts

@@ -0,0 +1,3 @@
+export { shrink } from './shrink.js';
+export { shrinkJsonDocument } from './shrink_file.js';
+