@dcl/sdk-commands 7.0.0-4293371227.commit-54082c6 → 7.0.0-4294380152.commit-0d08b10

package/src/components/analytics.ts

@@ -1,92 +0,0 @@
-import { v4 as uuidv4 } from 'uuid'
-import { Analytics } from '@segment/analytics-node'
-import future from 'fp-future'
-
-import { CliComponents } from '.'
-import { colors } from './log'
-
-export type IAnalyticsComponent = {
-  get(): Analytics
-  identify(): Promise<void>
-  track<T extends keyof Events>(eventName: T, eventProps: Events[T]): Promise<void>
-}
-
-type Events = {
-  'Scene created': {
-    projectType: string
-    url: string
-  }
-  'Preview started': {
-    projectHash: string
-    coords: { x: number; y: number }
-    isWorkspace: boolean
-  }
-  'Build scene': {
-    projectHash: string
-    coords: { x: number; y: number }
-    isWorkspace: boolean
-  }
-  'Export static': {
-    projectHash: string
-    coords: { x: number; y: number }
-  }
-}
-
-export async function createAnalyticsComponent({
-  dclInfoConfig
-}: Pick<CliComponents, 'dclInfoConfig'>): Promise<IAnalyticsComponent> {
-  const USER_ID = 'sdk-commands-user'
-  const config = await dclInfoConfig.get()
-  const analytics: Analytics = new Analytics({ writeKey: config.segmentKey ?? '' })
-  return {
-    get() {
-      return analytics
-    },
-    async identify() {
-      if (!config.userId) {
-        console.log(
-          `Decentraland CLI sends anonymous usage stats to improve their products, if you want to disable it change the configuration at ${colors.bold(
-            '~/.dclinfo'
-          )}\n`
-        )
-
-        const userId = uuidv4()
-        await dclInfoConfig.updateDCLInfo({ userId, trackStats: true })
-        analytics.identify({
-          userId: USER_ID,
-          traits: {
-            devId: userId,
-            createdAt: new Date()
-          }
-        })
-      }
-    },
-    async track<T extends keyof Events>(eventName: T, eventProps: Events[T]) {
-      const trackFuture = future<void>()
-      const { userId, trackStats } = await dclInfoConfig.get()
-      if (!trackStats) {
-        return trackFuture.resolve()
-      }
-      const trackInfo = {
-        userId: USER_ID,
-        event: eventName,
-        properties: {
-          ...eventProps,
-          os: process.platform,
-          nodeVersion: process.version,
-          cliVersion: await dclInfoConfig.getVersion(),
-          isCI: dclInfoConfig.isCI(),
-          isEditor: dclInfoConfig.isEditor(),
-          devId: userId
-        }
-      }
-      analytics.track(trackInfo, () => {
-        trackFuture.resolve()
-      })
-      if (!dclInfoConfig.isProduction()) {
-        console.log(trackInfo)
-      }
-      return trackFuture
-    }
-  }
-}

package/src/components/dcl-info-config.ts

@@ -1,63 +0,0 @@
-import path, { resolve } from 'path'
-import { CliComponents } from '.'
-import { DCLInfo, getDCLInfoConfig, getDclInfoPath, getEnvConfig } from '../logic/config'
-import { readJSON, writeJSON } from '../logic/fs'
-
-export type IDCLInfoConfigComponent = {
-  get(): Promise<DCLInfo>
-  updateDCLInfo(value: Partial<DCLInfo>): Promise<Partial<DCLInfo>>
-  getVersion(): Promise<string>
-  isCI(): boolean
-  isEditor(): boolean
-  isProduction(): boolean
-}
-
-export async function createDCLInfoConfigComponent({
-  fs
-}: Pick<CliComponents, 'fs'>): Promise<IDCLInfoConfigComponent> {
-  function isProduction() {
-    return process.env.NODE_ENV === 'production' || __filename.includes('node_modules')
-  }
-  const defaultConfig: Partial<DCLInfo> = {
-    userId: '',
-    trackStats: false,
-    segmentKey: isProduction() ? 'sFdziRVDJo0taOnGzTZwafEL9nLIANZ3' : 'mjCV5Dc4VAKXLJAH5g7LyHyW1jrIR3to'
-  }
-
-  return {
-    async get() {
-      const dclInfoConfig = await getDCLInfoConfig({ fs })
-      const envConfig = getEnvConfig()
-      const config = { ...defaultConfig, ...dclInfoConfig, ...envConfig }
-      return config
-    },
-    updateDCLInfo(value: Partial<DCLInfo>) {
-      return writeJSON({ fs }, getDclInfoPath(), value)
-    },
-    async getVersion() {
-      try {
-        /* istanbul ignore next */
-        const sdkPath = path.dirname(
-          require.resolve('@dcl/sdk/package.json', {
-            paths: [process.cwd()]
-          })
-        )
-        /* istanbul ignore next */
-        const packageJson = await readJSON<{ version: string }>({ fs }, resolve(sdkPath, 'package.json'))
-        /* istanbul ignore next */
-        return packageJson.version ?? 'unknown'
-      } catch (e) {
-        return 'unknown'
-      }
-    },
-    isEditor() {
-      return process.env.EDITOR === 'true'
-    },
-    isCI() {
-      return process.env.CI === 'true' || process.argv.includes('--ci') || process.argv.includes('--c')
-    },
-    isProduction() {
-      return isProduction()
-    }
-  }
-}

package/src/components/eth.ts

@@ -1,3 +0,0 @@
-import { HTTPProvider } from 'eth-connect'
-
-export const providerInstance = new HTTPProvider('https://rpc.decentraland.org/mainnet?project=sdk-commands')

package/src/components/fetch.ts

@@ -1,11 +0,0 @@
-import * as undici from 'undici'
-
-export type IFetchComponent = {
-  fetch(url: string, init?: undici.RequestInit): Promise<undici.Response>
-}
-
-export function createFetchComponent(): IFetchComponent {
-  return {
-    fetch: undici.fetch
-  }
-}

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,26 +0,0 @@
-import { ILoggerComponent } from '@well-known-components/interfaces'
-import { createAnalyticsComponent, IAnalyticsComponent } from './analytics'
-import { createDCLInfoConfigComponent, IDCLInfoConfigComponent } from './dcl-info-config'
-import { createFetchComponent, IFetchComponent } from './fetch'
-import { createFsComponent, IFileSystemComponent } from './fs'
-import { createStdoutCliLogger } from './log'
-
-export type CliComponents = {
-  fs: IFileSystemComponent
-  fetch: IFetchComponent
-  logger: ILoggerComponent.ILogger
-  dclInfoConfig: IDCLInfoConfigComponent
-  analytics: IAnalyticsComponent
-}
-
-export async function initComponents(): Promise<CliComponents> {
-  const fsComponent = createFsComponent()
-  const dclInfoConfig = await createDCLInfoConfigComponent({ fs: fsComponent })
-  return {
-    fs: fsComponent,
-    fetch: createFetchComponent(),
-    logger: createStdoutCliLogger(),
-    dclInfoConfig,
-    analytics: await createAnalyticsComponent({ dclInfoConfig })
-  }
-}

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 = await 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)) {
-    await components.analytics.identify()
-    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/config.ts

@@ -1,45 +0,0 @@
-import path from 'path'
-import { CliComponents } from '../components'
-
-export interface DCLInfo {
-  segmentKey?: string
-  userId?: string
-  trackStats?: boolean
-}
-
-/* istanbul ignore next */
-export const getDclInfoPath = () =>
-  path.resolve(process.env[process.platform === 'win32' ? 'USERPROFILE' : 'HOME'] ?? '', '.dclinfo')
-
-/**
- * Reads the contents of the `.dclinfo` file
- */
-export async function getDCLInfoConfig(components: Pick<CliComponents, 'fs'>): Promise<DCLInfo> {
-  try {
-    const content = await components.fs.readFile(getDclInfoPath(), 'utf8')
-    return JSON.parse(content) as DCLInfo
-  } catch (e) {
-    return {}
-  }
-}
-
-/**
- * Config that can be override via ENV variables
- */
-export function getEnvConfig(): Partial<DCLInfo> {
-  const { SEGMENT_KEY } = process.env
-
-  const envConfig = {
-    segmentKey: SEGMENT_KEY
-  }
-
-  return removeEmptyKeys(envConfig)
-}
-
-export function removeEmptyKeys(obj: Record<string, unknown>) {
-  const result: Record<string, unknown> = {}
-  Object.keys(obj)
-    .filter((k) => !!obj[k])
-    .forEach((k) => (result[k] = obj[k]))
-  return result
-}

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
-}