@dcl/sdk-commands 7.0.0-4293371227.commit-54082c6 → 7.0.0-4295573637.commit-6d503ad

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

package/src/logic/dcl-ignore.ts

@@ -1,50 +0,0 @@
-/* istanbul ignore file */
-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,76 +0,0 @@
-import extractZip from 'extract-zip'
-import { resolve } from 'path'
-import { IFileSystemComponent } from '../components/fs'
-import { IFetchComponent } from '../components/fetch'
-import { CliComponents } from '../components'
-
-/**
- * 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
-}
-
-/**
- * Reads a file and parses it's JSON content
- * @param path The path to the subject json file
- */
-export async function readJSON<T>(components: Pick<CliComponents, 'fs'>, path: string): Promise<T> {
-  const content = await components.fs.readFile(path, 'utf-8')
-  return JSON.parse(content) as T
-}
-
-/**
- * Merges the provided content with a json file
- * @param path The path to the subject json file
- * @param content The content to be applied (as a plain object)
- */
-export async function writeJSON<T = unknown>(
-  components: Pick<CliComponents, 'fs'>,
-  path: string,
-  content: Partial<T>
-): Promise<Partial<T>> {
-  let currentFile
-
-  try {
-    currentFile = await readJSON<T>(components, path)
-  } catch (e) {
-    currentFile = {}
-  }
-
-  const newJson = { ...currentFile, ...content }
-  const strContent = JSON.stringify(newJson, null, 2)
-
-  await components.fs.writeFile(path, strContent)
-  return newJson
-}

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,92 +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'
-import { getSceneFilePath } from './scene-validations'
-import { Scene } from '@dcl/schemas'
-
-/**
- * Returns an array of the publishable files for a given folder.
- *
- */
-/* istanbul ignore next */
-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
- *
- */
-/* istanbul ignore next */
-export function normalizeDecentralandFilename(filename: string) {
-  return filename.replace(/(\\)/g, '/').toLowerCase()
-}
-
-/**
- * Returns the content mappings for a specific project folder.
- */
-/* istanbul ignore next */
-export async function getProjectContentMappings(
-  components: Pick<CliComponents, 'fs'>,
-  projectRoot: string,
-  /* istanbul ignore next */
-  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
-}
-
-export async function getSceneJson(components: Pick<CliComponents, 'fs'>, projectRoot: string): Promise<Scene> {
-  const sceneJsonContent = await components.fs.readFile(getSceneFilePath(projectRoot), 'utf8')
-  const sceneJson = JSON.parse(sceneJsonContent) as Scene
-  return sceneJson
-}
-
-export const b64HashingFunction = async (str: string) => 'b64-' + Buffer.from(str).toString('base64')

package/src/logic/project-validations.ts

@@ -1,61 +0,0 @@
-import { Scene } from '@dcl/schemas'
-import { resolve } from 'path'
-import { CliComponents } from '../components'
-import { CliError } from './error'
-import { exec } from './exec'
-import { validateSceneJson } from './scene-validations'
-
-/**
- * Asserts that the projectRoot is a valid project
- */
-export async function assertValidProjectFolder(
-  components: Pick<CliComponents, 'fs' | 'logger'>,
-  projectRoot: string
-): Promise<{ scene: Scene }> {
-  // no validations for now, only check that it exists
-  if (!(await components.fs.fileExists(resolve(projectRoot, 'package.json'))))
-    throw new CliError(`The project root doesn't have a package.json file`)
-
-  // now we will iterate over different file to evaluate the project kind
-  switch (true) {
-    // case wearable
-    case await components.fs.fileExists(resolve(projectRoot, 'scene.json')): {
-      return { scene: await validateSceneJson(components, projectRoot) }
-    }
-    default: {
-      throw new CliError(`UnknownProjectKind: the kind of project of the folder ${projectRoot} cannot be identified`)
-    }
-  }
-}
-
-/*
- * Returns true if the project contains an empty node_modules folder
- */
-export async function needsDependencies(components: Pick<CliComponents, 'fs'>, dir: string): Promise<boolean> {
-  const nodeModulesPath = resolve(dir, 'node_modules')
-  const hasNodeModulesFolder = await components.fs.directoryExists(nodeModulesPath)
-  const isNodeModulesEmpty = hasNodeModulesFolder && (await components.fs.readdir(nodeModulesPath)).length === 0
-
-  return !hasNodeModulesFolder || isNodeModulesEmpty
-}
-
-/* istanbul ignore next */
-export const npm = /^win/.test(process.platform) ? 'npm.cmd' : 'npm'
-
-/*
- * Runs "npm install" for desired project
- */
-export async function installDependencies(components: Pick<CliComponents, 'logger'>, directory: string): Promise<void> {
-  components.logger.info('Installing dependencies...')
-  // TODO: test in windows
-  await exec(directory, npm, ['install'])
-  components.logger.log('Installing dependencies... ✅')
-}
-
-/**
- * Run NPM commands
- */
-export async function npmRun(cwd: string, command: string, ...args: string[]): Promise<void> {
-  // TODO: test in windows
-  await exec(cwd, npm, ['run', command, '--silent', '--', ...args], { env: process.env as any })
-}

package/src/logic/realm.ts

@@ -1,28 +0,0 @@
-import { AboutResponse } from '@dcl/protocol/out-js/decentraland/bff/http_endpoints.gen'
-
-export function createStaticRealm(): AboutResponse {
-  return {
-    acceptingUsers: true,
-    bff: { healthy: false, publicUrl: `https://peer.decentraland.org/bff` },
-    comms: {
-      healthy: true,
-      protocol: 'v3',
-      fixedAdapter: `offline:offline`
-    },
-    configurations: {
-      networkId: 0,
-      globalScenesUrn: [],
-      scenesUrn: [],
-      realmName: 'SdkStaticExport'
-    },
-    content: {
-      healthy: true,
-      publicUrl: `https://peer.decentraland.org/content`
-    },
-    lambdas: {
-      healthy: true,
-      publicUrl: `https://peer.decentraland.org/lambdas`
-    },
-    healthy: true
-  }
-}

package/src/logic/scene-validations.ts

@@ -1,81 +0,0 @@
-import { resolve } from 'path'
-import { Scene } from '@dcl/schemas'
-import { CliError } from './error'
-import { getObject, inBounds, getBounds, areConnected } from './coordinates'
-import { CliComponents } from '../components'
-import { getSceneJson } from './project-files'
-
-export const SCENE_FILE = 'scene.json'
-
-/**
- * Composes the path to the `scene.json` file based on the provided path.
- * @param projectRoot The path to the directory containing the scene file.
- */
-export function getSceneFilePath(projectRoot: string): string {
-  return resolve(projectRoot, SCENE_FILE)
-}
-
-export function assertValidScene(scene: Scene) {
-  if (!Scene.validate(scene)) {
-    const errors: string[] = []
-    if (Scene.validate.errors) {
-      for (const error of Scene.validate.errors) {
-        errors.push(`Error validating scene.json: ${error.message}`)
-      }
-    }
-    throw new CliError('Invalid scene.json file:\n' + errors.join('\n'))
-  }
-
-  const parcelSet = new Set(scene.scene?.parcels)
-
-  if (parcelSet.size < scene.scene?.parcels?.length) {
-    throw new CliError(`There are duplicated parcels at scene.json.`)
-  }
-
-  if (!parcelSet.has(scene.scene?.base)) {
-    throw new CliError(`Your base parcel ${scene.scene?.base} should be included on parcels attribute at scene.json`)
-  }
-
-  const objParcels = scene.scene?.parcels?.map(getObject)
-  objParcels.forEach(({ x, y }) => {
-    if (inBounds(x, y)) {
-      return
-    }
-    const { minX, maxX } = getBounds()
-    throw new CliError(`Coordinates ${x},${y} are outside of allowed limits (from ${minX} to ${maxX})`)
-  })
-
-  if (!areConnected(objParcels)) {
-    throw new CliError('Parcels described on scene.json are not connected. They should be one next to each other')
-  }
-
-  if (!scene.main?.endsWith('.js')) {
-    throw new CliError(`Main scene format file (${scene.main}) is not a supported format`)
-  }
-
-  return scene
-}
-
-/**
- * Fails the execution if one of the parcel data is invalid
- */
-export async function validateSceneJson(
-  components: Pick<CliComponents, 'fs' | 'logger'>,
-  projectRoot: string
-): Promise<Scene> {
-  try {
-    const sceneJson = await getSceneJson(components, projectRoot)
-
-    return assertValidScene(sceneJson)
-  } catch (err: any) {
-    throw new CliError(`Error reading the scene.json file: ${err.message}`)
-  }
-}
-
-export function getBaseCoords(scene: Scene): { x: number; y: number } {
-  const [x, y] = scene.scene.base
-    .replace(/\ /g, '')
-    .split(',')
-    .map((a) => parseInt(a))
-  return { x, y }
-}

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "declaration": true,
-    "noUnusedLocals": true,
-    "stripInternal": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "allowJs": true,
-    "resolveJsonModule": true,
-    "strict": true,
-    "types": [
-      "node",
-    ],
-    "lib": [
-      "es2020"
-    ],
-    "outDir": "./dist"
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "dist"
-  ]
-}