@bemoje/cli 0.0.4 → 0.0.5

package/scripts/rollupUtils.ts

@@ -0,0 +1,184 @@
+import fs from 'fs-extra'
+import path from 'path'
+import walkdir from 'walkdir'
+import { readFileSafeSync } from '../src/util/fs/readFile/readFileSafeSync'
+import { Stats } from 'fs-extra'
+import type { WalkOptions } from 'walkdir'
+
+/**
+ * Extract all import statements from a given TypeScript source code string.
+ * @param code The TypeScript code as a string from which to extract import statements.
+ * @returns An array of objects, each representing an import statement. Each object includes the start and end line numbers (0-indexed) of the import statement in the original code, and the full text of the import statement.
+ */
+function tsExtractImports(code: string): ITsExtractImportsResult[] {
+  code = code.replace(/;/g, '')
+  const isFirstLine = /^import /
+  const isFirstLineInMulti = /\{\s*$/
+  const isLastLineInMulti = /^\} from '/
+  const result: ITsExtractImportsResult[] = []
+  let isMulti = false
+  let impLines = []
+  const lines = code.split(/\r?\n/)
+  for (let l = 0; l < lines.length; l++) {
+    const line = lines[l]
+    if (isFirstLine.test(line)) {
+      if (isFirstLineInMulti.test(line)) {
+        impLines.push(line)
+        isMulti = true
+      } else {
+        result.push({
+          start: l,
+          end: l,
+          match: line,
+        })
+      }
+    } else if (isMulti) {
+      impLines.push(line)
+      if (isLastLineInMulti.test(line)) {
+        result.push({
+          start: l - impLines.length + 1,
+          end: l,
+          match: impLines.join('\n'),
+        })
+        impLines = []
+        isMulti = false
+      }
+    }
+  }
+  return result
+}
+
+interface ITsExtractImportsResult {
+  /**
+   * The line index where the import statement starts.
+   */
+  start: number
+  /**
+   * The line index of the last line of the import statement.
+   */
+  end: number
+  /**
+   * The import statement.
+   */
+  match: string
+}
+
+export function walkTsFiles(
+  srcdir: string,
+  filter: (filepath: string, stat: Stats) => boolean = () => true,
+  options: WalkOptions = {}
+): string[] {
+  const result: string[] = []
+  walkdir.sync(srcdir, options, (filepath, stat) => {
+    if (!stat.isFile()) return
+    if (!/\.ts$/i.test(filepath)) return
+    // if (/\..+\.ts$/i.test(filepath)) return
+    if (!filter(filepath, stat)) return
+    result.push(filepath)
+  })
+  return result
+}
+
+const cliFilepaths = walkTsFiles('packages/cli/src')
+const imports = cliFilepaths
+  .map((filepath) => {
+    const src = readFileSafeSync(filepath)
+    // if(!src) return {filepath, imports: []}
+    const imps = tsExtractImports(src || '')
+      .map((imp) => {
+        const res = imp.match.replace(/\n/g, '').replace(/\s+/g, ' ')
+        if (!res.endsWith("from '@bemoje/util'")) return
+        return res
+          .replace(/^import( type)? \{/, '')
+          .replace("} from '@bemoje/util'", '')
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean)
+      })
+      .flat()
+      .map((s) => s?.trim())
+      .filter(Boolean)
+    return { filepath, imports: imps }
+  })
+  .filter((imp) => imp.imports.length)
+// console.dir(imports, { depth: null })
+const set = new Set(imports.map((imp) => imp.imports).flat())
+console.log(set)
+
+const utilFilepaths = walkTsFiles('packages/util/src')
+
+const filepaths = new Set<string>()
+
+for (const name of set) {
+  const filepath = utilFilepaths.find((filepath) => filepath.endsWith(`${name}.ts`))
+  if (!filepath) {
+    console.log({ fileNonExistent: name })
+    continue
+  }
+  filepaths.add(filepath)
+}
+// console.log(filepaths)
+
+function recurse(filepath: string) {
+  const src = readFileSafeSync(filepath)
+  for (const imp of tsExtractImports(src || '')) {
+    const res = imp.match.replace(/\n/g, '').replace(/\s+/g, ' ')
+    const regex = /from '\.\.?\//g
+    if (!regex.test(res)) continue
+    const relative = res.split(' from ')[1].replace(/['"]/g, '').trim()
+    if (!relative) continue
+    const resolved = path.resolve(path.dirname(filepath), relative + '.ts')
+    // console.log({ relative, resolved })
+    if (filepaths.has(resolved)) continue
+    filepaths.add(resolved)
+    recurse(resolved)
+  }
+}
+
+filepaths.forEach(recurse)
+
+for (const filepath of filepaths) {
+  const testFilepath = filepath.replace(/\.ts$/, '.test.ts')
+  if (fs.existsSync(testFilepath)) {
+    filepaths.add(testFilepath)
+  }
+}
+
+filepaths.forEach(recurse)
+
+filepaths.forEach((filepath) => {
+  filepath = filepath.replace(/\\+/g, '/')
+  const destFilepath = filepath.replace('packages/util/src', 'packages/cli/src/util')
+  // console.log({ filepath, destFilepath })
+  fs.ensureDirSync(path.dirname(destFilepath))
+  fs.copyFileSync(filepath, destFilepath)
+
+  // const src = readFileSafeSync(filepath)
+  // if (!src) {
+  //   console.log({ NO_SOURCE_AT: filepath })
+  //   return
+  // }
+  // for (const imp of tsExtractImports(src || '')) {
+  //   const res = imp.match.replace(/\n/g, '').replace(/\s+/g, ' ')
+  //   const regex = /from '\.\.?\//g
+  //   if (regex.test(res)) continue
+  //   externalImports.add(res)
+  // }
+  // source.push(tsStripImports(src))
+  // const testFilepath = filepath.replace(/\.ts$/, '.test.ts')
+  // if (fs.existsSync(testFilepath)) {
+  //   testsource.push(readFileSync(testFilepath, 'utf8').replace(/from '\..+$/gm, "from './util'"))
+  // }
+})
+
+// source.push([...externalImports].join('\n'))
+// source.reverse()
+// testsource.reverse()
+// const result = source.join('\n\n\n').replace(/^export .+ from .+$/gm, (s) => s.replace('export ', 'import ') + '\n' + s)
+// writeFileSafeSync('packages/cli/src/core/bemoje-util.ts', result)
+// const testresult = testsource.join('\n\n\n')
+// const testresultImports = [
+//   ...new Set(testresult.split('\n').filter((l) => l.startsWith('import ') && l.endsWith("'"))),
+// ].join('\n')
+// const testresultCode = tsStripImports(testresult)
+// writeFileSafeSync('packages/cli/src/core/bemoje-util.test.ts', testresultImports + '\n\n' + testresultCode)

package/src/arg/ArgumentBuilder.test.ts

@@ -0,0 +1,102 @@
+import { Argument } from '@commander-js/extra-typings'
+import { ArgumentBuilder } from './ArgumentBuilder'
+import { ArgumentParserSelector } from './ArgumentParserSelector'
+import { ArgumentReader } from './ArgumentReader'
+import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
+import { CommandBuilder } from '../cmd/CommandBuilder'
+
+describe(ArgumentBuilder.name, () => {
+  it('should add commander argument to commander command instance', () => {
+    new CommandBuilder('t', (c) => {
+      const spy = jest.spyOn(c.$, 'addArgument')
+      c.argument('[arg]', (a) => {
+        expect(spy).toBeCalledWith(a.$)
+      })
+    })
+  })
+
+  describe('constructor', () => {
+    it('$ should return an Argument instance', () => {
+      const o = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
+      expect(o.$).toBeInstanceOf(Argument)
+    })
+
+    it('get should return an ArgumentReader instance', () => {
+      const o = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
+      expect(o.get).toBeInstanceOf(ArgumentReader)
+    })
+
+    it('name', () => {
+      new CommandBuilder('t', (c) => {
+        c.argument('[arg]', (a) => {
+          expect(a.$.name()).toBe('arg')
+        })
+      })
+    })
+  })
+
+  describe('description', () => {
+    it('set inside callback', () => {
+      new CommandBuilder('t', (c) => {
+        c.argument('[arg]', (a) => {
+          expect(a.description('abc')).toBe(a)
+          expect(a.$.description).toBe('abc')
+        })
+        const arg = c.arguments[0]
+        expect(arg.description).toBe('abc')
+      })
+    })
+
+    it('set as second argument', () => {
+      new CommandBuilder('t', (c) => {
+        c.argument('[arg]', 'abc')
+        const arg = c.arguments[0]
+        expect(arg.description).toBe('abc')
+      })
+    })
+
+    it('allow no description', () => {
+      new CommandBuilder('t', (c) => {
+        expect(() => c.argument('[arg]')).not.toThrow()
+      })
+    })
+  })
+
+  describe('default', () => {
+    it('should call commander default method', () => {
+      new CommandBuilder('t', (c) => {
+        c.argument('[arg]', (a) => {
+          const spy = jest.spyOn(a.$, 'default')
+          expect(a.default('abc')).toBe(a)
+          expect(spy).toHaveBeenCalledTimes(1)
+        })
+      })
+    })
+  })
+
+  describe('choices', () => {
+    it('should call commander choices method', () => {
+      new CommandBuilder('t', (c) => {
+        c.argument('[arg]', (a) => {
+          const spy = jest.spyOn(a.$, 'choices')
+          expect(a.choices(['a', 'b'])).toBe(a)
+          expect(spy).toHaveBeenCalledWith(['a', 'b'])
+        })
+      })
+    })
+  })
+
+  describe('parser', () => {
+    it('should return a ArgumentParserSelector instance', () => {
+      const arg = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
+      expect(arg.parser).toBeInstanceOf(ArgumentParserSelector)
+    })
+  })
+
+  describe('validator', () => {
+    it('should return a ArgumentValidatorSelector instance', () => {
+      const arg = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
+      expect(arg.validator).toBeInstanceOf(ArgumentValidatorSelector)
+    })
+  })
+})

package/src/arg/ArgumentBuilder.ts

@@ -0,0 +1,47 @@
+import { Argument } from '@commander-js/extra-typings'
+import { ArgumentParserSelector } from './ArgumentParserSelector'
+import { ArgumentReader } from './ArgumentReader'
+import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
+import { CommandBuilder } from '../cmd/CommandBuilder'
+import { realizeLazyProperty } from '../util/object/realizeLazyProperty'
+
+/**
+ * Wrapper around the @see Argument class from 'commander'.
+ */
+export class ArgumentBuilder {
+  readonly $: Argument
+  readonly index: number
+
+  constructor(readonly cmd: CommandBuilder, name: string) {
+    this.$ = new Argument(name)
+    this.index = cmd.meta.argValidators.length
+    cmd.meta.argValidators[this.index] = []
+  }
+
+  description(string: string) {
+    this.$.description = string
+    return this
+  }
+
+  default(value: unknown, description?: string) {
+    this.$.default(value, description)
+    return this
+  }
+
+  choices(values: readonly string[]) {
+    this.$.choices(values)
+    return this
+  }
+
+  get parser() {
+    return new ArgumentParserSelector(this)
+  }
+
+  get validator() {
+    return new ArgumentValidatorSelector(this)
+  }
+
+  get get() {
+    return realizeLazyProperty(this, 'get', new ArgumentReader(this))
+  }
+}

package/src/arg/ArgumentParserSelector.test.ts

@@ -0,0 +1,53 @@
+import { ArgumentParserSelector } from './ArgumentParserSelector'
+import { CLI } from '../cmd/CLI'
+
+describe(ArgumentParserSelector.name, () => {
+  it('should parse string, number, integer', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<str>', (a) => a.parser.string())
+      c.argument('<num>', (a) => a.parser.number())
+      c.argument('<int>', (a) => a.parser.integer())
+      c.action((str, num, int) => {
+        expect(str).toBe('str')
+        expect(num).toBe(3.2)
+        expect(int).toBe(3)
+      })
+    })
+    run().parse(['str', '3.2', '3'], { from: 'user' })
+  })
+
+  it('should parse variadic argument', () => {
+    const init = CLI('t', (c) => {
+      c.argument('<str>', (o) => o.parser.string())
+      c.argument('<ints...>', (o) => o.parser.integer())
+      c.action((str, ints) => {
+        expect(ints).toEqual([3, 4, 5])
+      })
+    })
+    init().parse('abc 3 4 5'.split(' '), { from: 'user' })
+  })
+
+  it('should parse delimited string, number, integer', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<strs>', (a) => a.parser.delimitedStrings())
+      c.argument('<nums>', (a) => a.parser.delimitedNumbers())
+      c.argument('<ints>', (a) => a.parser.delimitedIntegers())
+      c.action((strs, nums, ints) => {
+        expect(strs).toEqual(['a', 'b'])
+        expect(nums).toEqual([3.1, 4.1])
+        expect(ints).toEqual([3, 4, 5])
+      })
+    })
+    run().parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })
+  })
+
+  it('should parse with custom parser', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<arg>', (a) => a.parser.custom((s) => s.split('')))
+      c.action((arg) => {
+        expect(arg).toEqual(['a', 'b', 'c'])
+      })
+    })
+    run().parse(['abc'], { from: 'user' })
+  })
+})

package/src/arg/ArgumentParserSelector.ts

@@ -0,0 +1,14 @@
+import { ArgumentBuilder } from './ArgumentBuilder'
+import type { JsonValue } from '../util/types/JsonValue'
+import { ParserSelector } from '../core/ParserSelector'
+import type { TStringParser } from '../util/types/TStringParser'
+
+export class ArgumentParserSelector extends ParserSelector<ArgumentBuilder> {
+  constructor(builder: ArgumentBuilder) {
+    super(builder)
+  }
+  custom<T extends JsonValue>(parser: TStringParser<T>) {
+    this.builder.cmd.meta.argParsers[this.builder.index] = parser
+    return this.builder
+  }
+}

package/src/arg/ArgumentReader.test.ts

@@ -0,0 +1,60 @@
+import { ArgumentBuilder } from './ArgumentBuilder'
+import { ArgumentReader } from './ArgumentReader'
+import { CommandBuilder } from '../cmd/CommandBuilder'
+
+describe(ArgumentReader.name, () => {
+  it('should return an ArgumentReader instance', () => {
+    const a = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
+    expect(a.get).toBeInstanceOf(ArgumentReader)
+  })
+
+  describe('properties', () => {
+    let a = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
+
+    beforeEach(() => {
+      a = new ArgumentBuilder(new CommandBuilder('t'), '[arg]')
+    })
+
+    it('$', () => {
+      expect(a.get.$).toBe(a.$)
+    })
+
+    it('argument', () => {
+      expect(a.get.argument).toBe(a.$)
+    })
+
+    it('name', () => {
+      const spy = jest.spyOn(a.$, 'name')
+      expect(spy).not.toHaveBeenCalled()
+      a.get.name
+      expect(spy).toHaveBeenCalled()
+    })
+
+    it('choices', () => {
+      a.choices(['a'])
+      expect(a.get.choices).toEqual(a.$.argChoices)
+    })
+
+    it('default', () => {
+      a.default('a')
+      expect(a.get.default).toBe(a.$.defaultValue)
+    })
+
+    it('description', () => {
+      a.description('a')
+      expect(a.get.description).toBe(a.$.description)
+    })
+
+    it('variadic', () => {
+      expect(a.get.variadic).toBe(a.$.variadic)
+    })
+
+    it('required', () => {
+      expect(a.get.required).toBe(a.$.required)
+    })
+
+    it('optional', () => {
+      expect(a.get.optional).toBe(!a.$.required)
+    })
+  })
+})

package/src/arg/ArgumentReader.ts

@@ -0,0 +1,33 @@
+import { ArgumentBuilder } from './ArgumentBuilder'
+
+export class ArgumentReader {
+  constructor(protected readonly parent: ArgumentBuilder) {}
+
+  get $() {
+    return this.parent.$
+  }
+  get argument() {
+    return this.$
+  }
+  get name() {
+    return this.$.name()
+  }
+  get choices() {
+    return this.$.argChoices
+  }
+  get default() {
+    return this.$.defaultValue
+  }
+  get description() {
+    return this.$.description
+  }
+  get variadic() {
+    return this.$.variadic
+  }
+  get required() {
+    return this.$.required
+  }
+  get optional() {
+    return !this.$.required
+  }
+}

package/src/arg/ArgumentValidatorSelector.test.ts

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
+import { CLI } from '../cmd/CLI'
+
+describe(ArgumentValidatorSelector.name, () => {
+  jest.spyOn(process, 'exit').mockImplementation((code?: number) => {
+    throw new Error('process.exit(' + code ?? '' + ') was called')
+  })
+
+  it('should validate string, number, integer', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<str>', (a) => a.parser.string().validator.isString())
+      c.argument('<num>', (a) => a.parser.number().validator.isNumber())
+      c.argument('<int>', (a) => a.parser.integer().validator.isInteger())
+      c.action(() => {})
+    })
+    expect(() => run().parse(['str', '3.2', '3'], { from: 'user' })).not.toThrow()
+  })
+
+  it('should throw if invalid', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<int>', (a) => a.parser.number().validator.isInteger())
+      c.action(() => {})
+      c.throwInsteadOfProcessExit()
+    })
+    expect(() => run().parse(['3.2'], { from: 'user' })).toThrow()
+  })
+
+  it('should validate delimited string, number, integer', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<strs>', (a) => a.parser.delimitedStrings().validator.isStringArray())
+      c.argument('<nums>', (a) => a.parser.delimitedNumbers().validator.isNumberArray())
+      c.argument('<ints>', (a) => a.parser.delimitedIntegers().validator.isIntegerArray())
+      c.action(() => {})
+    })
+    expect(() => run().parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })).not.toThrow()
+  })
+
+  it('should validate variadic argument', () => {
+    const init = CLI('t', (c) => {
+      c.argument('<str>', (o) => o.validator.isString())
+      c.argument('<ints...>', (o) => o.parser.integer().validator.isIntegerArray())
+      c.action(() => {})
+    })
+    expect(() => init().parse('abc 3 4 5'.split(' '), { from: 'user' })).not.toThrow()
+  })
+
+  it('should throw if invalid', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<ints>', (a) => a.parser.delimitedIntegers().validator.isIntegerArray())
+      c.action(() => {})
+      c.throwInsteadOfProcessExit()
+    })
+    expect(() => run().parse(['3,q,7'], { from: 'user' })).toThrow()
+  })
+
+  it('should validate with custom validator', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<arg>', (a) => a.validator.custom((arg) => arg === 'abc'))
+      c.action(() => {})
+      c.throwInsteadOfProcessExit()
+    })
+    expect(() => run().parse(['ab'], { from: 'user' })).toThrow()
+  })
+
+  it('should validate with multiple validators', () => {
+    const run = CLI('t', (c) => {
+      c.argument('<arg>', (a) => {
+        a.validator.custom((arg: string) => arg !== 'abc')
+        a.validator.custom((arg: string) => arg.length >= 3)
+      })
+      c.action(() => {})
+      c.throwInsteadOfProcessExit()
+    })
+    expect(() => run().parse(['ab'], { from: 'user' })).toThrow()
+    expect(() => run().parse(['abc'], { from: 'user' })).toThrow()
+    expect(() => run().parse(['abcd'], { from: 'user' })).not.toThrow()
+  })
+})

package/src/arg/ArgumentValidatorSelector.ts

@@ -0,0 +1,14 @@
+import { ArgumentBuilder } from './ArgumentBuilder'
+import { arrLast } from '../util/array/arrLast'
+import type { TValidator } from '../util/types/TValidator'
+import { ValidatorSelector } from '../core/ValidatorSelector'
+
+export class ArgumentValidatorSelector extends ValidatorSelector<ArgumentBuilder> {
+  constructor(builder: ArgumentBuilder) {
+    super(builder)
+  }
+  custom<T>(validator: TValidator<T>) {
+    arrLast(this.builder.cmd.meta.argValidators).push(validator)
+    return this.builder
+  }
+}

package/src/cmd/CLI.test.ts

@@ -0,0 +1,14 @@
+import { CLI } from './CLI'
+
+describe(CLI.name, () => {
+  it('should not initialize immediately', () => {
+    let hasRun = false
+    const init = CLI('test', () => {
+      hasRun = true
+    })
+    expect(typeof init).toBe('function')
+    expect(hasRun).toBe(false)
+    init()
+    expect(hasRun).toBe(true)
+  })
+})

package/src/cmd/CLI.ts

@@ -0,0 +1,13 @@
+import { CommandBuilder } from './CommandBuilder'
+
+export function CLI(name: string, callback: (this: CommandBuilder, cmd: CommandBuilder) => void) {
+  return () => new CommandBuilder(name, callback).commander
+}
+
+/*
+
+TODO: should return a class that offers:
+- command
+- main
+- action
+*/