@gesslar/bedoc 1.10.0 → 2.0.0

package/src/core/ActionManager.js

@@ -1,147 +0,0 @@
-import {HookPoints} from "./HookManager.js"
-
-export default class ActionManager {
-  #action = null
-  #hookManager = null
-  #contract
-  #log
-  #debug
-  #file
-  #variables
-
-  constructor({actionDefinition, logger, variables}) {
-    this.#log = logger
-    this.#debug = this.#log.newDebug()
-    this.#variables = variables
-
-    this.#initialize(actionDefinition)
-  }
-
-  #initialize(actionDefinition) {
-    const debug = this.#debug
-
-    debug("Setting up action", 2)
-
-    const {action, file, contract} = actionDefinition
-
-    if(!action)
-      throw new Error("Action is required")
-
-    if(!contract)
-      throw new Error("Contract is required")
-
-    this.#action = action
-    this.#contract = contract
-    this.#file = file
-
-    debug("Action setup complete", 2)
-  }
-
-  get action() {
-    return this.#action
-  }
-
-  get hookManager() {
-    return this.#hookManager
-  }
-
-  set hookManager(hookManager) {
-    if(this.hookManager)
-      throw new Error("Hooks already set")
-
-    this.action.hook = hookManager.on.bind(this.action)
-    this.action.HOOKS = HookPoints
-    this.#hookManager = hookManager
-    this.action.hooks = hookManager.hooks
-  }
-
-  get contract() {
-    return this.#contract
-  }
-
-  get meta() {
-    return this.#action.meta
-  }
-
-  get log() {
-    return this.#log
-  }
-
-  get variables() {
-    return this.#variables
-  }
-
-  async #setupAction() {
-    const setup = this.action?.setup
-
-    if(!setup)
-      return
-
-    await this.action.setup.call(this.action, {log: this.#log})
-  }
-
-  async #cleanupAction() {
-    const cleanup = this.action?.cleanup
-
-    if(!cleanup)
-      return
-
-    await this.action.cleanup.call(this.action)
-  }
-
-  async #setupHooks() {
-    const setup = this.hookManager?.setup
-
-    if(!setup)
-      return
-
-    await this.hookManager.setup.call(
-      this.hookManager.hooks, {
-        action: this.action,
-        variables: this.#variables,
-        log: this.#log
-      }
-    )
-  }
-
-  async #cleanupHooks() {
-    const cleanup = this.hookManager?.cleanup
-
-    if(!cleanup)
-      return
-
-    await this.hookManager.cleanup.call(this.hookManager.hooks)
-  }
-
-  async setupAction() {
-    this.#debug("Setting up action for %s", 2, this.meta.action)
-
-    await this.#setupHooks()
-    await this.#setupAction()
-  }
-
-  async runAction({file,content}) {
-    const func = this.action.run
-
-    if(!func)
-      throw new Error(`No \`run\` function found for action \`${this.meta.action}\``)
-
-    const actionResult = await func.call(
-      this.action, {file, moduleContent: content}
-    )
-
-    return actionResult
-  }
-
-  async cleanupAction() {
-    this.#debug("Post action", 2)
-    this.#debug("Cleaning up action for %s", 2, this.meta.action)
-
-    await this.#cleanupHooks()
-    await this.#cleanupAction()
-  }
-
-  toString() {
-    return `${this.#file?.module || "UNDEFINED"} (${this.meta?.action || "UNDEFINED"})`
-  }
-}

package/src/core/ContractManager.js

@@ -1,112 +0,0 @@
-import yaml from "yaml"
-import JSON5 from "json5"
-
-import * as FDUtil from "./util/FDUtil.js"
-import * as ContractUtil from "./util/ContractUtil.js"
-import * as DataUtil from "./util/DataUtil.js"
-
-const {resolveFilename, readFile} = FDUtil
-const {loadSchema, getValidator} = ContractUtil
-const {findClosestMatch} = DataUtil
-
-const refex = /^ref:\/\/(.*)$/
-
-export default class ContractManager {
-  static async newContract(actionType, terms) {
-    // Load and validate against the BeDoc contract schema
-    const schema = await loadSchema()
-    const validator = getValidator(schema)
-    const valid = validator(terms)
-
-    if(!valid) {
-      const error = ContractManager.reportValidationErrors(validator.errors)
-
-      throw new Error(`Invalid contract terms:\n${error}`)
-    }
-
-    const dataValidator = getValidator({
-      "$schema": "http://json-schema.org/draft-07/schema#",
-      "$id": `${actionType} Schema`,
-      title: `${actionType} Schema`,
-      type: "object",
-      properties: terms,
-    })
-
-    return new Contract(dataValidator)
-  }
-
-  static parse(contractData, directoryObject) {
-    if(typeof contractData === "string") {
-      const match = refex.exec(contractData)
-
-      if(match)
-        contractData = readFile(resolveFilename(match[1], directoryObject))
-
-      return yaml.parse(String(contractData))
-    }
-
-    throw new Error(`Invalid contract data: ${JSON5.stringify(contractData)}`)
-  }
-
-  static reportValidationErrors(errors) {
-    return errors.reduce((acc, error) => {
-      let msg = `- "${error.instancePath || "(root)"}" ${error.message}`
-
-      if(error.params) {
-        const details = []
-
-        if(error.params.type)
-          details.push(`  ➜ Expected type: ${error.params.type}`)
-
-        if(error.params.missingProperty)
-          details.push(`  ➜ Missing required field: ${error.params.missingProperty}`)
-
-        if(error.params.allowedValues) {
-          details.push(`  ➜ Allowed values: "${error.params.allowedValues.join('", "')}"`)
-          details.push(`  ➜ Received value: "${error.data}"`)
-          const closestMatch =
-            findClosestMatch(error.data, error.params.allowedValues)
-          if(closestMatch)
-            details.push(`  ➜ Did you mean: "${closestMatch}"?`)
-        }
-
-        if(error.params.pattern)
-          details.push(`  ➜ Expected pattern: ${error.params.pattern}`)
-
-        if(error.params.format)
-          details.push(`  ➜ Expected format: ${error.params.format}`)
-
-        if(error.params.additionalProperty)
-          details.push(`  ➜ Unexpected property: ${error.params.additionalProperty}`)
-
-        if(details.length)
-          msg += `\n${details.join("\n")}`
-      }
-
-      return acc ? `${acc}\n${msg}` : msg
-    }, "")
-  }
-}
-
-class Contract {
-  #validator = null
-
-  constructor(validator) {
-    this.#validator = validator
-  }
-
-  get validator() {
-    return this.#validator
-  }
-
-  validate(data) {
-    const validator = this.validator
-    const valid = validator(data)
-
-    if(!valid) {
-      const error = ContractManager.reportValidationErrors(validator.errors)
-
-      throw new Error(`This document violates the agreed upon contract:\n${error}`)
-    }
-  }
-}

package/src/core/Conveyor.js

@@ -1,185 +0,0 @@
-import {format} from "node:util"
-
-import * as FDUtil from "./util/FDUtil.js"
-
-const {readFile, writeFile, composeFilename} = FDUtil
-
-export default class Conveyor {
-  #succeeded = []
-  #warned = []
-  #errored = []
-
-  constructor(parse, print, logger, output) {
-    this.parse = parse
-    this.print = print
-    this.logger = logger
-    this.output = output
-  }
-
-  /**
-   * Processes files with a concurrency limit.
-   *
-   * @param {Array} files - List of files to process.
-   * @param {number} maxConcurrent - Maximum number of concurrent tasks.
-   * @returns {Promise<object>} - Resolves when all files are processed.
-   */
-  async convey(files, maxConcurrent = 10) {
-    const fileQueue = [...files]
-    const activePromises = []
-
-    await Promise.all([
-      this.parse.setupAction(),
-      this.print.setupAction()
-    ])
-
-    const processNextFile = file => {
-      return this.#processFile(file).then(processedResult => {
-        // Store result
-        if(processedResult.status === "success") {
-          this.#succeeded.push({input: file, output: processedResult.file})
-        } else if(processedResult.status === "warning") {
-          this.#warned.push({input: file, warning: processedResult.warning})
-        } else {
-          this.#errored.push({input: file, error: processedResult.error})
-        }
-
-        // Start next job if queue isn't empty
-        if(fileQueue.length > 0) {
-          const nextFile = fileQueue.shift()
-          return processNextFile(nextFile)
-        }
-      })
-    }
-
-    // Initial fill of the worker pool
-    while(activePromises.length < maxConcurrent && fileQueue.length > 0) {
-      const file = fileQueue.shift()
-      activePromises.push(processNextFile(file))
-    }
-
-    // Wait for all processing to complete
-    await Promise.all(activePromises)
-
-    await Promise.all([
-      this.parse.cleanupAction(),
-      this.print.cleanupAction()
-    ])
-
-    return {
-      succeeded: this.#succeeded,
-      errored: this.#errored,
-      warned: this.#warned
-    }
-  }
-
-  /**
-   * Processes a single file.
-   *
-   * @param {object} file - FileMap object representing a file.
-   * @returns {Promise<object>} - Resolves when the file is processed
-   */
-  async #processFile(file) {
-    const debug = this.logger.newDebug()
-    const {parse, print} = this
-
-    try {
-      debug("Processing file: %o", 2, file.path)
-
-      // Step 1: Read file
-      const fileContent = readFile(file)
-      debug("Read file content %o (%o bytes)", 2, file.path, fileContent.length)
-
-      // Step 2: Parse file
-      const parseResult = await parse.runAction({
-        file,
-        content: fileContent
-      })
-      if(parseResult.status === "error")
-        return parseResult
-
-      if(parseResult.status === "warning")
-        debug("Parsed file successfully, but with warnings: %o", 2, file.path)
-      else
-        debug("Parsed file successfully: %o", 2, file.path)
-
-      if(!parseResult.result) {
-        const mess = format("No content found in %o. No file written.", file.path)
-        return {status: "warning", file, warning: mess}
-      }
-
-      parse.contract.validate(parseResult)
-      print.contract.validate(parseResult)
-
-      // Step 3: Print file
-      const printResult = await print.runAction({
-        file,
-        content: parseResult.result,
-      })
-      if(printResult.status === "error")
-        return printResult
-
-      debug("Printed file successfully: %o", 2, file.path)
-
-      // Step 4: Write output
-      const {status: printStatus, destFile, destContent} = printResult
-      const isNullish = value => value == null // Checks null or undefined
-
-      switch(printStatus) {
-        case "warning":
-        case "error":
-          return printResult
-        case "success":
-          if(isNullish(destFile) || isNullish(destContent))
-            return {
-              status: "warning",
-              warning: format("No content or destination file for %o", file.path)
-            }
-
-          break
-        default:
-          throw new Error(`Invalid status received from printing ${file.module}`)
-      }
-
-      if(this.output) {
-        const writeResult = await this.#writeOutput(destFile, destContent)
-
-        if(writeResult.status === "success")
-          debug("Wrote output %o (%o bytes)", 2, writeResult.file.path, destContent.length)
-        else
-          debug("Error writing output for: `%s`", 2, file.path)
-
-        return writeResult
-      }
-
-      debug("Output not specified. Writing skipped.", 2)
-
-      return {status: "success"}
-
-    } catch(error) {
-      return {status: "error", file, error}
-    }
-  }
-
-  /**
-   * Writes the output to the destination.
-   *
-   * @param {string} destFile - Destination file path.
-   * @param {string} destContent - File content.
-   * @returns {Promise<object>} - Resolves when the file is written.
-   */
-  async #writeOutput(destFile, destContent) {
-    const debug = this.logger.newDebug()
-
-    const destFileMap = composeFilename(this.output.path, destFile)
-
-    debug("Writing output to %o => %o", 2, destFile, destFileMap.absolutePath)
-
-    try {
-      writeFile(destFileMap, destContent)
-
-      return {status: "success", file: destFileMap}
-    } catch(error) {
-      return {status: "error", output: destFileMap, error}
-    }
-  }
-}

package/src/core/Core.js

@@ -1,166 +0,0 @@
-import {hrtime} from "node:process"
-
-import Discovery from "./Discovery.js"
-import HookManager from "./HookManager.js"
-import Logger from "./Logger.js"
-import ParseManager from "./action/ParseManager.js"
-import PrintManager from "./action/PrintManager.js"
-import Conveyor from "./Conveyor.js"
-import Configuration from "./Configuration.js"
-
-import * as ActionUtil from "./util/ActionUtil.js"
-import * as DataUtil from "./util/DataUtil.js"
-import * as FDUtil from "./util/FDUtil.js"
-
-const {loadPackageJson} = ActionUtil
-const {schemaCompare} = DataUtil
-const {getFiles} = FDUtil
-
-export const Environment = Object.freeze({
-  EXTENSION: "extension",
-  NPM: "npm",
-  ACTION: "action",
-  CLI: "cli",
-})
-
-export default class Core {
-  constructor(options) {
-    this.options = options
-    const {debug: debugMode, debugLevel} = options
-    this.logger = new Logger({name: "BeDoc", debugMode, debugLevel})
-    this.packageJson = loadPackageJson(options.basePath)?.bedoc ?? {}
-    this.debugOptions = this.logger.options
-  }
-
-  static async new({options, source}) {
-    const config = new Configuration()
-
-    const validConfig = await config.validate({options, source})
-    if(validConfig.status === "error")
-      throw new AggregateError(validConfig.errors,"BeDoc configuration failed")
-
-    const instance = new Core({...validConfig, name: "BeDoc"})
-    const debug = instance.logger.newDebug()
-
-    debug("Creating new BeDoc instance with options: `%o`", 3, validConfig)
-
-    const discovery = new Discovery(instance)
-    const actionDefs = await discovery.discoverActions({
-      print: validConfig.printer,
-      parse: validConfig.parser
-    })
-
-    const validCrit = discovery.satisfyCriteria(actionDefs, validConfig)
-
-    debug("Actions that met criteria: `%o`", 3, validCrit)
-
-    if(Object.values(validCrit).some(arr => arr.length === 0))
-      throw new Error("No found matching parser and printer")
-
-    const validSchemas = {print: [], parse: []}
-    let printers = validCrit.print.length
-    while(printers--) {
-      const printer = validCrit.print[printers]
-      const printerSchema = printer.contract
-      const satisfied = []
-
-      for(const parser of validCrit.parse) {
-        const parserSchema = parser.contract
-        const result = schemaCompare(parserSchema, printerSchema)
-        if(result.status === "success")
-          satisfied.push(parser)
-      }
-
-      if(satisfied.length > 0) {
-        validSchemas.print.push(printer)
-        validSchemas.parse.push(...satisfied)
-      }
-    }
-
-    const finalActions = {}
-    for(const [key, value] of Object.entries(validSchemas)) {
-      if(value.length === 0)
-        throw new Error(`No matching ${key} found`)
-
-      if(value.length > 1)
-        throw new Error(`Multiple matching ${key} found`)
-
-      finalActions[key] = validSchemas[key][0]
-    }
-
-    debug("Contracts satisfied between parser and printer", 2)
-
-    // Adding to instance
-    instance.actions = {}
-    const {variables} = validConfig
-    const managers = {print: PrintManager, parse: ParseManager}
-    for(const [, actionDefinition] of Object.entries(finalActions)) {
-      const {action: actionType} = actionDefinition.action.meta
-
-      debug("Attaching %o action to instance", 2, actionType)
-      instance.actions[actionType] =
-        new managers[actionType] ({
-          actionDefinition,
-          logger: instance.logger,
-          variables
-        })
-
-      if(validConfig.hooks) {
-        const hookManager = await HookManager.new({
-          action: actionType,
-          hooksFile: validConfig.hooks,
-          logger: new Logger(instance.debugOptions),
-          timeout: validConfig.hooksTimeout,
-        })
-
-        if(hookManager)
-          instance.actions[actionType].hookManager = hookManager
-      }
-    }
-
-    return instance
-  }
-
-  async processFiles(glob) {
-    const debug = this.logger.newDebug()
-
-    debug("Starting file processing with conveyor", 1)
-
-    const {output} = this.options
-
-    const input = await getFiles(glob)
-    if(!input?.length)
-      throw new Error("No input files specified")
-
-    // Instantiate the conveyor
-    const conveyor = new Conveyor(
-      this.actions.parse,
-      this.actions.print,
-      this.logger,
-      output,
-    )
-
-    const processStart = hrtime.bigint()
-
-    // Initiate the conveyor
-    const processResult = await conveyor.convey(
-      input, this.options.maxConcurrent
-    )
-
-    debug("Conveyor complete", 1)
-
-    const processEnd = hrtime.bigint()
-
-    const result = {
-      totalFiles: input.length,
-      succeeded: processResult.succeeded,
-      warned: processResult.warned,
-      errored: processResult.errored,
-      duration: ((Number(processEnd - processStart)) / 1_000_000).toFixed(2)
-    }
-
-    debug("File processing complete", 1)
-
-    return result
-  }
-}