@dcl/sdk-commands 7.0.0-4286109573.commit-baaf951 → 7.0.0-4294380152.commit-0d08b10

package/src/components/fs.ts

@@ -1,62 +0,0 @@
-import * as fs from 'fs'
-import * as fsPromises from 'fs/promises'
-
-/**
- * @public
- *
- * This may be moved to well-known-components in the future
- */
-export type IFileSystemComponent = Pick<typeof fs, 'createReadStream'> &
-  Pick<typeof fs, 'createWriteStream'> &
-  Pick<
-    typeof fsPromises,
-    'access' | 'opendir' | 'stat' | 'unlink' | 'mkdir' | 'readFile' | 'writeFile' | 'rename' | 'rmdir'
-  > & {
-    constants: Pick<typeof fs.constants, 'F_OK' | 'R_OK'>
-  } & {
-    fileExists(path: string): Promise<boolean>
-    directoryExists(path: string): Promise<boolean>
-    readdir(path: string): Promise<string[]>
-  }
-
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await fs.promises.access(path, fs.constants.F_OK | fs.constants.R_OK)
-    return true
-  } catch (error) {
-    return false
-  }
-}
-async function directoryExists(path: string): Promise<boolean> {
-  try {
-    return (await fs.promises.lstat(path)).isDirectory()
-  } catch (error) {
-    return false
-  }
-}
-
-/**
- * @public
- */
-export function createFsComponent(): IFileSystemComponent {
-  return {
-    createReadStream: fs.createReadStream,
-    createWriteStream: fs.createWriteStream,
-    access: fsPromises.access,
-    writeFile: fsPromises.writeFile,
-    opendir: fsPromises.opendir,
-    stat: fsPromises.stat,
-    unlink: fsPromises.unlink,
-    mkdir: fsPromises.mkdir,
-    rmdir: fsPromises.rmdir,
-    readdir: fsPromises.readdir,
-    readFile: fsPromises.readFile,
-    constants: {
-      F_OK: fs.constants.F_OK,
-      R_OK: fs.constants.R_OK
-    },
-    rename: fsPromises.rename,
-    fileExists,
-    directoryExists
-  }
-}

package/src/components/index.ts

@@ -1,18 +0,0 @@
-import { ILoggerComponent } from '@well-known-components/interfaces'
-import { createFetchComponent, IFetchComponent } from './fetch'
-import { createFsComponent, IFileSystemComponent } from './fs'
-import { createStdoutCliLogger } from './log'
-
-export type CliComponents = {
-  fs: IFileSystemComponent
-  fetch: IFetchComponent
-  logger: ILoggerComponent.ILogger
-}
-
-export function initComponents(): CliComponents {
-  return {
-    fs: createFsComponent(),
-    fetch: createFetchComponent(),
-    logger: createStdoutCliLogger()
-  }
-}

package/src/components/log.ts

@@ -1,48 +0,0 @@
-import { ILoggerComponent } from '@well-known-components/interfaces'
-import { createColors } from 'colorette'
-import { CliError } from '../logic/error'
-
-/**
- * This file imitates "cargo" logs. The words are aligned with the colon like this:
- *        V
- *   Error: some text provided as argumen
- *    Info: some text provided as argumen
- * Success: some text provided as argumen
- * Warning: some text provided as argumen
- *        ^
- */
-
-const stderr = (...parameters: readonly unknown[]) => {
-  process.stderr.write(`${parameters.filter(($) => $ !== undefined).join('')}\n`)
-}
-
-// @see https://no-color.org
-// @see https://www.npmjs.com/package/chalk
-export const colors = createColors({
-  useColor: process.env.FORCE_COLOR !== '0' && !process.env.NO_COLOR
-})
-
-export function createStdoutCliLogger(): ILoggerComponent.ILogger {
-  return {
-    log(message, extra) {
-      stderr(message, extra && JSON.stringify(extra))
-    },
-    debug(message, extra) {
-      stderr(colors.blueBright('debug: '), message, extra && JSON.stringify(extra))
-    },
-    error(error, extra) {
-      stderr(colors.redBright('error: '), error, extra && JSON.stringify(extra))
-      /* istanbul ignore next */
-      if (!(error instanceof CliError) || process.env.DEBUG) {
-        // print the stacktrace if it is not a CliError
-        console.error(error)
-      }
-    },
-    info(message, extra) {
-      stderr(colors.blueBright('info: '), message, extra && JSON.stringify(extra))
-    },
-    warn(message, extra) {
-      stderr(colors.yellow('warning: '), message, extra && JSON.stringify(extra))
-    }
-  }
-}

package/src/index.ts

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-
-/* istanbul ignore file */
-
-import { getArgs } from './logic/args'
-import { CliError } from './logic/error'
-import { COMMANDS_PATH, getCommands } from './logic/commands'
-import { CliComponents, initComponents } from './components'
-import { printCommand } from './logic/beautiful-logs'
-import { colors } from './components/log'
-
-export interface Options {
-  args: ReturnType<typeof getArgs>
-  components: CliComponents
-}
-
-// leaving args as "any" since we don't know yet if we will use them
-type FileFn = (options: Options) => Promise<void>
-
-interface FileExports {
-  help?: FileFn
-  main?: FileFn
-  args?: ReturnType<typeof getArgs>
-}
-
-const listCommandsStr = (commands: string[]) => commands.map(($) => `\t *sdk-commands ${$} \n`).join('')
-
-const commandFnsAreValid = (fns: FileExports): fns is Required<FileExports> => {
-  const { help, main } = fns
-  if (!help || !main) {
-    throw new CliError(`Command does not follow implementation rules:
-      * Requires a "help" function
-      * Requires a "main" function
-    `)
-  }
-  return true
-}
-
-async function main() {
-  const helpMessage = (commands: string[]) => `Here is the list of commands:\n${listCommandsStr(commands)}`
-  const args = getArgs()
-  const command = process.argv[2]
-  const needsHelp = args['--help']
-  const components: CliComponents = initComponents()
-
-  const commands = await getCommands(components)
-
-  if (!commands.includes(command)) {
-    if (needsHelp) {
-      components.logger.info(helpMessage(commands))
-      return
-    }
-    throw new CliError(`Command ${command} is invalid. ${helpMessage(commands)}`)
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const cmd = require(`${COMMANDS_PATH}/${command}`)
-
-  if (commandFnsAreValid(cmd)) {
-    const options = { args: cmd.args, components }
-    if (needsHelp) {
-      await cmd.help(options)
-    } else {
-      printCommand(components.logger, command)
-
-      const ret = await cmd.main(options)
-      // print the result of the evaluation as json in the standard output
-      if (cmd.args['--json']) {
-        process.stdout.write(JSON.stringify(ret, null, 2))
-      }
-    }
-  }
-
-  // rollup watcher leaves many open FSWatcher even in build mode. we must call
-  // process.exit at this point to prevent the program halting forever
-  process.exit(process.exitCode || 0)
-}
-
-main().catch(function handleError(err: Error) {
-  if (err instanceof CliError) {
-    console.error(colors.redBright('Error: ') + err.message)
-  } else {
-    // log with console to show stacktrace and debug information
-    console.error(err)
-    console.warn(`Developer: All errors thrown must be an instance of "CliError"`)
-  }
-
-  // set an exit code but not finish the program immediately to close any pending work
-  process.exitCode = 1
-})

package/src/logic/args.ts

@@ -1,19 +0,0 @@
-import arg, { Result } from 'arg'
-
-export type Args = {
-  [key: string]: string | StringConstructor | NumberConstructor | BooleanConstructor
-}
-
-// updating to TS 4.9 will prevent losing types when
-// enforcing type to be "Args" by using "satisfies Args"
-export const DEFAULT_ARGS = {
-  '--help': Boolean,
-  '--json': Boolean,
-  '-h': '--help'
-}
-
-export function getArgs(): Result<typeof DEFAULT_ARGS>
-export function getArgs<T extends Args>(args: T): Result<typeof DEFAULT_ARGS & T>
-export function getArgs<T extends Args>(args?: T) {
-  return arg({ ...DEFAULT_ARGS, ...args }, { permissive: true })
-}

package/src/logic/beautiful-logs.ts

@@ -1,26 +0,0 @@
-import { ILoggerComponent } from '@well-known-components/interfaces'
-import { colors } from '../components/log'
-
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { name, version } = require('../../package.json')
-
-export function printProgressStep(logger: ILoggerComponent.ILogger, log: string, currentStep: number, maxStep: number) {
-  logger.log(colors.dim(`[${currentStep}/${maxStep}]`) + ' ' + log)
-}
-
-export function printProgressInfo(logger: ILoggerComponent.ILogger, log: string) {
-  logger.log(colors.dim(log))
-}
-
-export function printCommand(logger: ILoggerComponent.ILogger, commandName: string) {
-  logger.log(colors.bold(`${name} ${commandName} v${version}`))
-}
-
-export function printSuccess(logger: ILoggerComponent.ILogger, operationSuccessfulMessage: string, summary: string) {
-  // print a space before the success callout
-  logger.log('')
-  logger.log(colors.greenBright(operationSuccessfulMessage))
-  if (typeof summary === 'string') {
-    logger.log(summary)
-  }
-}

package/src/logic/catalyst-requests.ts

@@ -1,31 +0,0 @@
-import { Entity } from '@dcl/schemas'
-import { fetch } from 'undici'
-
-export async function fetchEntityByPointer(
-  baseUrl: string,
-  pointers: string[]
-): Promise<{
-  baseUrl: string
-  deployments: Entity[]
-}> {
-  if (pointers.length === 0)
-    return {
-      baseUrl,
-      deployments: []
-    }
-
-  const activeEntities = baseUrl + '/content/entities/active'
-
-  const response = await fetch(activeEntities, {
-    method: 'post',
-    headers: { 'content-type': 'application/json', connection: 'close' },
-    body: JSON.stringify({ pointers })
-  })
-
-  const deployments: Entity[] = response.ok ? ((await response.json()) as Entity[]) : []
-
-  return {
-    baseUrl,
-    deployments
-  }
-}

package/src/logic/commands.ts

@@ -1,28 +0,0 @@
-import { resolve } from 'path'
-import { CliComponents } from '../components'
-import { CliError } from './error'
-
-export const COMMANDS_PATH = resolve(__dirname, '../commands')
-
-export async function getCommands({ fs }: Pick<CliComponents, 'fs'>): Promise<string[]> {
-  const commandDirs = await fs.readdir(COMMANDS_PATH)
-
-  const commands = commandDirs.map(async (dir) => {
-    const path = resolve(COMMANDS_PATH, dir)
-
-    const statDir = await fs.stat(path)
-
-    if (!statDir.isDirectory()) {
-      throw new CliError('Developer: All commands must be inside a folder')
-    }
-
-    const statIndex = await fs.stat(`${path}/index.js`)
-    if (!statIndex.isFile()) {
-      throw new CliError('Developer: All commands must have an "index.js" file inside')
-    }
-
-    return dir
-  })
-
-  return Promise.all(commands)
-}

package/src/logic/coordinates.ts

@@ -1,95 +0,0 @@
-export interface IBounds {
-  minX: number
-  minY: number
-  maxX: number
-  maxY: number
-}
-
-export type Coords = {
-  x: number
-  y: number
-}
-
-/**
- * Returns metaverse coordinates bounds.
- * TODO: use functions from @dcl/schemas
- */
-export function getBounds(): IBounds {
-  return {
-    minX: -150,
-    minY: -150,
-    maxX: 165,
-    maxY: 165
-  }
-}
-
-/**
- * Parses a string-based set of coordinates.
- * - All spaces are removed
- * - Leading zeroes are removed
- * - `-0` is converted to `0`
- * @param coordinates An string containing coordinates in the `x,y; x,y; ...` format
- */
-export function parse(coordinates: string): string[] {
-  return coordinates.split(';').map((coord: string) => {
-    const [x, y] = coord.split(',').map(($) => {
-      return parseInt($, 10)
-        .toString() // removes spaces :)
-        .replace('-0', '0')
-        .replace(/undefined|NaN/g, '0')
-    })
-    return `${x},${y}`
-  })
-}
-
-/**
- * Converts a string-based set of coordinates to an object
- * @param coords A string containing a set of coordinates
- */
-export function getObject(coords: string): Coords {
-  const [x, y] = parse(coords)[0].split(',')
-  return { x: parseInt(x.toString(), 10), y: parseInt(y.toString(), 10) }
-}
-
-/**
- * Returns true if the given coordinates are in metaverse bounds
- */
-export function inBounds(x: number, y: number): boolean {
-  const { minX, minY, maxX, maxY } = getBounds()
-  return x >= minX && x <= maxX && y >= minY && y <= maxY
-}
-
-/**
- * Returns true if the given parcels array are connected
- */
-export function areConnected(parcels: Coords[]): boolean {
-  if (parcels.length === 0) {
-    return false
-  }
-  const visited = visitParcel(parcels[0], parcels)
-  return visited.length === parcels.length
-}
-
-function visitParcel(parcel: Coords, allParcels: Coords[], visited: Coords[] = []): Coords[] {
-  const isVisited = visited.some((visitedParcel) => isEqual(visitedParcel, parcel))
-  if (!isVisited) {
-    visited.push(parcel)
-    const neighbours = getNeighbours(parcel.x, parcel.y, allParcels)
-    neighbours.forEach((neighbours) => visitParcel(neighbours, allParcels, visited))
-  }
-  return visited
-}
-
-function getIsNeighbourMatcher(x: number, y: number) {
-  return (coords: Coords) =>
-    (coords.x === x && (coords.y + 1 === y || coords.y - 1 === y)) ||
-    (coords.y === y && (coords.x + 1 === x || coords.x - 1 === x))
-}
-
-function getNeighbours(x: number, y: number, parcels: Coords[]): Coords[] {
-  return parcels.filter(getIsNeighbourMatcher(x, y))
-}
-
-export function isEqual(p1: Coords, p2: Coords): boolean {
-  return p1.x === p2.x && p1.y === p2.y
-}

package/src/logic/dcl-ignore.ts

@@ -1,49 +0,0 @@
-import path from 'path'
-import { CliComponents } from '../components'
-
-export const defaultDclIgnore = [
-  '.*',
-  'package.json',
-  'package-lock.json',
-  'yarn-lock.json',
-  'build.json',
-  'export',
-  'tsconfig.json',
-  'tslint.json',
-  'node_modules',
-  '**/*.ts',
-  '**/*.tsx',
-  'Dockerfile',
-  'dist',
-  'README.md',
-  '*.blend',
-  '*.fbx',
-  '*.zip',
-  '*.rar'
-]
-
-export async function getDCLIgnoreFileContents(
-  components: Pick<CliComponents, 'fs'>,
-  dir: string
-): Promise<string | null> {
-  try {
-    return components.fs.readFile(path.resolve(dir, '.dclignore'), 'utf8')
-  } catch (e) {}
-
-  return null
-}
-
-/**
- * Returns the default .dclignore entries plus the ones provided by the user.
- * In case of .dclignore not existing, it returns a pre-defined list.
- */
-export async function getDCLIgnorePatterns(components: Pick<CliComponents, 'fs'>, dir: string): Promise<string[]> {
-  const ignoredContent = await getDCLIgnoreFileContents(components, dir)
-  const ignored = (ignoredContent?.split('\n') || defaultDclIgnore).filter(Boolean)
-  ignored.push(...defaultDclIgnore)
-
-  // by default many files need to be ignored
-  ignored.push('.*', 'node_modules', '**/*.ts', '**/*.tsx')
-
-  return Array.from(new Set(ignored))
-}

package/src/logic/error.ts

@@ -1 +0,0 @@
-export class CliError extends Error {}

package/src/logic/exec.ts

@@ -1,36 +0,0 @@
-import { spawn } from 'child_process'
-
-interface Options {
-  env: { [key: string]: string }
-  silent: boolean
-}
-
-export function exec(
-  cwd: string,
-  command: string,
-  args: string[],
-  { env, silent }: Partial<Options> = {}
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      shell: true,
-      cwd,
-      env: { ...process.env, NODE_ENV: '', ...env }
-    })
-
-    if (!silent) {
-      child.stdout.pipe(process.stdout)
-      child.stderr.pipe(process.stderr)
-    }
-
-    child.on('close', (code: number) => {
-      if (code !== 0) {
-        const _ = `${command} ${args.join(' ')}`
-        reject(new Error(`Command "${_}" exited with code ${code}. Please try running the command manually`))
-        return
-      }
-
-      resolve(undefined)
-    })
-  })
-}

package/src/logic/fs.ts

@@ -1,41 +0,0 @@
-import extractZip from 'extract-zip'
-import { resolve } from 'path'
-import { IFileSystemComponent } from '../components/fs'
-import { IFetchComponent } from '../components/fetch'
-
-/**
- * Check's if directory is empty
- * @param dir Directory to check for emptyness
- */
-export async function isDirectoryEmpty(components: { fs: IFileSystemComponent }, dir: string): Promise<boolean> {
-  const files = await components.fs.readdir(dir)
-  return !files.length
-}
-
-/**
- * Download a file
- * @param url URL of the file
- * @param dest Path to where to save the file
- */
-export async function download(
-  components: { fs: IFileSystemComponent; fetch: IFetchComponent },
-  url: string,
-  dest: string
-): Promise<string> {
-  // we should remove this package and use the native "fetch" when Node
-  // releases it as stable: https://nodejs.org/docs/latest-v18.x/api/globals.html#fetch
-  const data = await (await components.fetch.fetch(url)).arrayBuffer()
-  await components.fs.writeFile(dest, Buffer.from(data))
-  return dest
-}
-
-/**
- * Extracts a .zip file
- * @param url Path of the zip file
- * @param dest Path to where to extract the zip file
- */
-export async function extract(path: string, dest: string): Promise<string> {
-  const destPath = resolve(dest)
-  await extractZip(resolve(path), { dir: destPath })
-  return destPath
-}

package/src/logic/get-free-port.ts

@@ -1,15 +0,0 @@
-import portfinder from 'portfinder'
-
-export async function previewPort() {
-  let resolvedPort = 0
-
-  if (!resolvedPort) {
-    try {
-      resolvedPort = await portfinder.getPortPromise()
-    } catch (e) {
-      resolvedPort = 2044
-    }
-  }
-
-  return resolvedPort
-}

package/src/logic/project-files.ts

@@ -1,76 +0,0 @@
-import { ContentMapping } from '@dcl/schemas/dist/misc/content-mapping'
-import { CliComponents } from '../components'
-import { getDCLIgnorePatterns } from './dcl-ignore'
-import { sync as globSync } from 'glob'
-import ignore from 'ignore'
-import path from 'path'
-import { CliError } from './error'
-
-/**
- * Returns an array of the publishable files for a given folder.
- */
-export async function getPublishableFiles(
-  components: Pick<CliComponents, 'fs'>,
-  projectRoot: string
-): Promise<Array<string>> {
-  const ignorePatterns = await getDCLIgnorePatterns(components, projectRoot)
-
-  const ig = ignore().add(ignorePatterns)
-
-  const allFiles = globSync('**/*', {
-    cwd: projectRoot,
-    absolute: false,
-    dot: false,
-    ignore: ignorePatterns,
-    nodir: true
-  })
-
-  return ig.filter(allFiles)
-}
-
-/**
- * This function converts paths to decentraland-compatible paths.
- * - From windows separators to unix separators.
- * - All to lowercase
- */
-export function normalizeDecentralandFilename(filename: string) {
-  return filename.replace(/(\\)/g, '/').toLowerCase()
-}
-
-/**
- * Returns the content mappings for a specific project folder.
- */
-export async function getProjectContentMappings(
-  components: Pick<CliComponents, 'fs'>,
-  projectRoot: string,
-  hashingFunction: (filePath: string) => Promise<string>
-): Promise<ContentMapping[]> {
-  const projectFiles = await getPublishableFiles(components, projectRoot)
-  const ret: ContentMapping[] = []
-
-  const usedFilenames = new Set<string>()
-
-  for (const file of projectFiles) {
-    const absolutePath = path.resolve(projectRoot, file)
-
-    /* istanbul ignore if */
-    if (!(await components.fs.fileExists(absolutePath))) continue
-
-    // remove heading '/'
-    const normalizedFile = normalizeDecentralandFilename(file).replace(/^\/+/, '')
-
-    /* istanbul ignore if */
-    if (usedFilenames.has(normalizedFile)) {
-      throw new CliError(
-        `DuplicatedFilenameError: the file ${file} exists with a different casing. Please manually remove one occurrence`
-      )
-    }
-
-    ret.push({
-      file: normalizedFile,
-      hash: await hashingFunction(absolutePath)
-    })
-  }
-
-  return ret
-}