huly-platform/packages/platform-rig/bin/format.js

const { join, dirname, relative, extname, basename } = require('path')
const {
  readFileSync,
  writeFileSync,
  existsSync,
  readdirSync,
  lstatSync,
  copyFileSync,
  mkdirSync,
  rmSync,
  current
} = require('fs')
const { spawnSync, execSync } = require('child_process')
const crypto = require('crypto')

if (!existsSync('.format')) {
  mkdirSync('.format', { recursive: true })
}

let hash = {}

if (existsSync('.format/format.json')) {
  hash = JSON.parse(readFileSync('.format/format.json').toString())
}

let filesToCheck = []
let allFiles = []

let newHash = {}

function calcFileHash(sourceFile, msg, addCheck) {
  const hasher = crypto.createHash('md5')
  hasher.update(readFileSync(sourceFile))
  let digest = hasher.digest('hex')
  if (hash[sourceFile] !== digest) {
    if (addCheck) {
      filesToCheck.push(sourceFile)
    }
    console.log(msg, relative(process.cwd(), sourceFile))
  }
  newHash[sourceFile] = digest
  if (addCheck) {
    allFiles.push(sourceFile)
  }
}

function calcHash(source, msg, addCheck) {
  const files = readdirSync(source)
  for (const f of files) {
    const sourceFile = join(source, f)

    if (lstatSync(sourceFile).isDirectory()) {
      calcHash(sourceFile, msg, addCheck)
    } else {
      let ext = basename(sourceFile)
      if (!ext.endsWith('.ts') && !ext.endsWith('.js') && !ext.endsWith('.svelte')) {
        continue
      }
      if (sourceFile.endsWith('.d.ts')) {
        // Skip declaration files
        continue
      }
      calcFileHash(sourceFile, msg, addCheck)
    }
  }
}

for (const v of process.argv.slice(2)) {
  if (existsSync(v)) {
    console.info('checking:', join(process.cwd(), v))
    calcHash(join(process.cwd(), v), 'changed', true)
  }
}

// Add package.json,  .eslintrc.js and node_modules/@hcengineering/platform-rig/ as hash roots.
for (const f of ['package.json', '.eslintrc.js']) {
  const fFile = join(process.cwd(), f)
  if (existsSync(fFile)) {
    calcFileHash(fFile, 'changed', false)
  }
}

const rigPackage = 'node_modules/@hcengineering/platform-rig/'
if (existsSync(rigPackage)) {
  calcHash(join(process.cwd(), rigPackage), 'changed', false)
}

if (process.argv.includes('-f') || process.argv.includes('--force')) {
  console.log('force checking')
  filesToCheck = allFiles
}

if (filesToCheck.length > 0) {
  console.info(`running prettier ${filesToCheck.length}`)
  // Changes detected.
  const prettier = spawnSync(join(process.cwd(), 'node_modules/.bin/prettier'), ['--color', '--write', ...filesToCheck])
  if (prettier.stdout != null) {
    writeFileSync('.format/prettier.log', prettier.stdout)
    if (prettier.status === null || prettier.status === 0) {
      console.info(prettier.stdout.toString())
    } else {
      console.error(prettier.stdout.toString())
    }
  }
  if (prettier.stderr != null) {
    writeFileSync('.format/prettier.err', prettier.stderr)
    const data = prettier.stderr.toString()
    if (data.length > 0) {
      console.error(data)
    }
  }

  console.log(`running eslint ${filesToCheck.length}`)
  const eslint = spawnSync(join(process.cwd(), 'node_modules/.bin/eslint'), ['--color', '--fix', ...filesToCheck], {
    env: { ...process.env, NODE_ENV: '--max-old-space-size=4096' }
  })
  if (eslint.stdout != null) {
    writeFileSync('.format/eslint.log', eslint.stdout)
    if (prettier.status === null || prettier.status === 0) {
      console.info(eslint.stdout.toString())
    } else {
      console.error(eslint.stdout.toString())
    }
  }
  if (eslint.stderr != null) {
    writeFileSync('.format/eslint.err', eslint.stderr)
    const data = eslint.stderr.toString()
    if (data.length > 0) {
      console.error(data)
    }
  }
  console.log(eslint.error, prettier.error)
  if (prettier.status || eslint.status || eslint.error || prettier.error) {
    console.info('prettier or eslint failed', prettier.status, eslint.status, prettier.error, eslint.error)
    // Make file empty, to prevent false passing if called without -f or --force.
    writeFileSync('.format/format.json', JSON.stringify({}, undefined, 2))
    process.exit(1)
  }

  hash = newHash
  for (const v of process.argv.slice(2)) {
    if (existsSync(v)) {
      calcHash(join(process.cwd(), v), 'updated')
    }
  }
  writeFileSync('.format/format.json', JSON.stringify(newHash, undefined, 2))
} else {
  console.info('No changes detected.')
}

process.exit(0)