@dcl/sdk-commands 7.0.0-4217957637.commit-a393ef7

package/src/components/fs.ts

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,90 @@
+#!/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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,49 @@
+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

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

package/src/logic/exec.ts

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,76 @@
+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
+}