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

package/src/commands/start/server/endpoints.ts

@@ -1,471 +0,0 @@
-import { Router } from '@well-known-components/http-server'
-import { PreviewComponents } from '../types'
-import * as path from 'path'
-import { WearableJson } from '@dcl/schemas/dist/sdk'
-import { Entity, EntityType, Locale, Wearable } from '@dcl/schemas'
-import fetch, { Headers } from 'node-fetch'
-import { fetchEntityByPointer } from '../../../logic/catalyst-requests'
-import { CliComponents } from '../../../components'
-import { b64HashingFunction, getProjectContentMappings } from '../../../logic/project-files'
-
-function getCatalystUrl(): URL {
-  return new URL('https://peer.decentraland.org')
-}
-
-function smartWearableNameToId(name: string) {
-  return name.toLocaleLowerCase().replace(/ /g, '-')
-}
-
-type LambdasWearable = Wearable & {
-  baseUrl: string
-}
-
-export function setupEcs6Endpoints(components: CliComponents, dir: string, router: Router<PreviewComponents>) {
-  const baseFolders = [dir]
-  // handle old preview scene.json
-  router.get('/scene.json', async () => {
-    return {
-      headers: { 'content-type': 'application/json' },
-      body: components.fs.createReadStream(path.join(dir, 'scene.json'))
-    }
-  })
-
-  router.get('/lambdas/explore/realms', async (ctx) => {
-    return {
-      body: [
-        {
-          serverName: 'localhost',
-          url: `http://${ctx.url.host}`,
-          layer: 'stub',
-          usersCount: 0,
-          maxUsers: 100,
-          userParcels: []
-        }
-      ]
-    }
-  })
-
-  router.get('/lambdas/contracts/servers', async (ctx) => {
-    return {
-      body: [
-        {
-          address: `http://${ctx.url.host}`,
-          owner: '0x0000000000000000000000000000000000000000',
-          id: '0x0000000000000000000000000000000000000000000000000000000000000000'
-        }
-      ]
-    }
-  })
-
-  router.get('/lambdas/profiles', async (ctx, next) => {
-    const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`
-
-    try {
-      const previewWearables = await getAllPreviewWearables(components, {
-        baseFolders,
-        baseUrl
-      })
-
-      if (previewWearables.length === 1) {
-        const catalystUrl = getCatalystUrl()
-
-        const u = new URL(ctx.url.toString())
-        u.host = catalystUrl.host
-        u.protocol = catalystUrl.protocol
-        u.port = catalystUrl.port
-        const req = await fetch(u.toString(), {
-          headers: {
-            connection: 'close'
-          },
-          method: ctx.request.method,
-          body: ctx.request.method === 'get' ? undefined : ctx.request.body
-        })
-
-        const deployedProfile = (await req.json()) as any[]
-
-        if (deployedProfile?.length === 1) {
-          deployedProfile[0].avatars[0].avatar.wearables.push(...previewWearables.map(($) => $.id))
-          return {
-            headers: {
-              'content-type': req.headers.get('content-type') || 'application/binary'
-            },
-            body: deployedProfile
-          }
-        }
-      }
-    } catch (err) {
-      console.warn(`Failed to catch profile and fill with preview wearables.`, err)
-    }
-
-    return next()
-  })
-
-  router.all('/lambdas/:path+', async (ctx) => {
-    const catalystUrl = getCatalystUrl()
-    const u = new URL(ctx.url.toString())
-    u.host = catalystUrl.host
-    u.protocol = catalystUrl.protocol
-    u.port = catalystUrl.port
-    const req = await fetch(u.toString(), {
-      headers: {
-        connection: 'close'
-      },
-      method: ctx.request.method,
-      body: ctx.request.method === 'get' ? undefined : ctx.request.body
-    })
-
-    return {
-      headers: {
-        'content-type': req.headers.get('content-type') || 'application/binary'
-      },
-      body: req.body
-    }
-  })
-
-  router.post('/content/entities', async (ctx) => {
-    const catalystUrl = getCatalystUrl()
-    const headers = new Headers()
-    console.log(ctx.request.headers)
-    const res = await fetch(`${catalystUrl.toString()}/content/entities`, {
-      method: 'post',
-      headers,
-      body: ctx.request.body
-    })
-
-    return res
-  })
-
-  serveStatic(components, dir, router)
-
-  // TODO: get workspace scenes & wearables...
-
-  serveFolders(components, router, baseFolders)
-}
-
-function serveFolders(components: Pick<CliComponents, 'fs'>, router: Router<PreviewComponents>, baseFolders: string[]) {
-  router.get('/content/contents/:hash', async (ctx: any, next: any) => {
-    if (ctx.params.hash && ctx.params.hash.startsWith('b64-')) {
-      const fullPath = path.resolve(Buffer.from(ctx.params.hash.replace(/^b64-/, ''), 'base64').toString('utf8'))
-
-      // only return files IF the file is within a baseFolder
-      if (!baseFolders.find((folder: string) => fullPath.startsWith(folder))) {
-        return next()
-      }
-
-      return {
-        headers: {
-          'x-timestamp': Date.now(),
-          'x-sent': true,
-          'cache-control': 'no-cache,private,max-age=1'
-        },
-        body: components.fs.createReadStream(fullPath)
-      }
-    }
-
-    return next()
-  })
-
-  async function pointerRequestHandler(pointers: string[]) {
-    if (!pointers || pointers.length === 0) {
-      return []
-    }
-
-    const requestedPointers = new Set<string>(
-      pointers && typeof pointers === 'string' ? [pointers as string] : (pointers as string[])
-    )
-
-    const resultEntities = await getSceneJson(components, baseFolders, Array.from(requestedPointers))
-    const catalystUrl = getCatalystUrl()
-    const remote = fetchEntityByPointer(
-      catalystUrl.toString(),
-      pointers.filter(($: string) => !$.match(/-?\d+,-?\d+/))
-    )
-
-    const serverEntities = Array.isArray(remote) ? remote : []
-
-    return [...resultEntities, ...serverEntities]
-  }
-
-  // REVIEW RESPONSE FORMAT
-  router.get('/content/entities/scene', async (ctx) => {
-    return {
-      body: await pointerRequestHandler(ctx.url.searchParams.getAll('pointer'))
-    }
-  })
-
-  // REVIEW RESPONSE FORMAT
-  router.post('/content/entities/active', async (ctx) => {
-    const body = await ctx.request.json()
-    return {
-      body: await pointerRequestHandler(body.pointers)
-    }
-  })
-
-  router.get('/preview-wearables/:id', async (ctx) => {
-    const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`
-    const wearables = await getAllPreviewWearables(components, {
-      baseUrl,
-      baseFolders
-    })
-    const wearableId = ctx.params.id
-    return {
-      body: {
-        ok: true,
-        data: wearables.filter((wearable) => smartWearableNameToId(wearable?.name) === wearableId)
-      }
-    }
-  })
-
-  router.get('/preview-wearables', async (ctx) => {
-    const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`
-    return {
-      body: {
-        ok: true,
-        data: await getAllPreviewWearables(components, { baseUrl, baseFolders })
-      }
-    }
-  })
-}
-
-async function getAllPreviewWearables(
-  components: Pick<CliComponents, 'fs'>,
-  { baseFolders, baseUrl }: { baseFolders: string[]; baseUrl: string }
-) {
-  const wearablePathArray: string[] = []
-  for (const wearableDir of baseFolders) {
-    const wearableJsonPath = path.resolve(wearableDir, 'wearable.json')
-    if (await components.fs.fileExists(wearableJsonPath)) {
-      wearablePathArray.push(wearableJsonPath)
-    }
-  }
-
-  const ret: LambdasWearable[] = []
-  for (const wearableJsonPath of wearablePathArray) {
-    try {
-      ret.push(await serveWearable(components, wearableJsonPath, baseUrl))
-    } catch (err) {
-      console.error(`Couldn't mock the wearable ${wearableJsonPath}. Please verify the correct format and scheme.`, err)
-    }
-  }
-  return ret
-}
-
-async function serveWearable(
-  components: Pick<CliComponents, 'fs'>,
-  wearableJsonPath: string,
-  baseUrl: string
-): Promise<LambdasWearable> {
-  const wearableDir = path.dirname(wearableJsonPath)
-  const wearableJson = JSON.parse((await components.fs.readFile(wearableJsonPath)).toString())
-
-  if (!WearableJson.validate(wearableJson)) {
-    const errors = (WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('')
-
-    console.error(`Unable to validate wearable.json properly, please check it.`, errors)
-    throw new Error(`Invalid wearable.json (${wearableJsonPath})`)
-  }
-
-  const hashedFiles = await getProjectContentMappings(components, wearableDir, b64HashingFunction)
-
-  const thumbnailFiltered = hashedFiles.filter(($) => $?.file === 'thumbnail.png')
-  const thumbnail =
-    thumbnailFiltered.length > 0 && thumbnailFiltered[0]?.hash && `${baseUrl}/${thumbnailFiltered[0].hash}`
-
-  const wearableId = 'urn:8dc2d7ad-97e3-44d0-ba89-e8305d795a6a'
-
-  const representations = wearableJson.data.representations.map((representation) => ({
-    ...representation,
-    mainFile: `male/${representation.mainFile}`,
-    contents: hashedFiles.map(($) => ({
-      key: `male/${$?.file}`,
-      url: `${baseUrl}/${$?.hash}`,
-      hash: $?.hash
-    }))
-  }))
-
-  return {
-    id: wearableId,
-    rarity: wearableJson.rarity,
-    i18n: [{ code: 'en' as Locale, text: wearableJson.name }],
-    description: wearableJson.description,
-    thumbnail: thumbnail || '',
-    image: thumbnail || '',
-    collectionAddress: '0x0',
-    baseUrl: `${baseUrl}/`,
-    name: wearableJson.name || '',
-    data: {
-      category: wearableJson.data.category,
-      replaces: [],
-      hides: [],
-      tags: [],
-      representations: representations as any
-      // scene: hashedFiles as any,
-    }
-  }
-}
-
-async function getSceneJson(
-  components: Pick<CliComponents, 'fs'>,
-  projectRoots: string[],
-  pointers: string[]
-): Promise<Entity[]> {
-  const requestedPointers = new Set<string>(pointers)
-  const resultEntities: Entity[] = []
-
-  const allDeployments = await Promise.all(
-    projectRoots.map(async (projectRoot) => fakeEntityV3FromFolder(components, projectRoot, b64HashingFunction))
-  )
-
-  for (const pointer of Array.from(requestedPointers)) {
-    // get deployment by pointer
-    const theDeployment = allDeployments.find(($) => $ && $.pointers.includes(pointer))
-    if (theDeployment) {
-      // remove all the required pointers from the requestedPointers set
-      // to prevent sending duplicated entities
-      theDeployment.pointers.forEach(($) => requestedPointers.delete($))
-
-      // add the deployment to the results
-      resultEntities.push(theDeployment)
-    }
-  }
-
-  return resultEntities
-}
-
-function serveStatic(components: Pick<CliComponents, 'fs'>, projectRoot: string, router: Router<PreviewComponents>) {
-  const sdkPath = path.dirname(
-    require.resolve('@dcl/sdk/package.json', {
-      paths: [projectRoot]
-    })
-  )
-  const dclExplorerJsonPath = path.dirname(
-    require.resolve('@dcl/explorer/package.json', {
-      paths: [projectRoot, sdkPath]
-    })
-  )
-
-  const dclKernelDefaultProfilePath = path.resolve(dclExplorerJsonPath, 'default-profile')
-  const dclKernelImagesDecentralandConnect = path.resolve(dclExplorerJsonPath, 'images', 'decentraland-connect')
-
-  const routes = [
-    {
-      route: '/',
-      path: path.resolve(dclExplorerJsonPath, 'preview.html'),
-      type: 'text/html'
-    },
-    {
-      route: '/favicon.ico',
-      path: path.resolve(dclExplorerJsonPath, 'favicon.ico'),
-      type: 'text/html'
-    },
-    {
-      route: '/@/explorer/index.js',
-      path: path.resolve(dclExplorerJsonPath, 'index.js'),
-      type: 'text/javascript'
-    }
-  ]
-
-  for (const route of routes) {
-    router.get(route.route, async (_ctx) => {
-      return {
-        headers: { 'Content-Type': route.type },
-        body: components.fs.createReadStream(route.path)
-      }
-    })
-  }
-
-  function createStaticRoutes(
-    components: Pick<CliComponents, 'fs'>,
-    route: string,
-    folder: string,
-    transform = (str: string) => str
-  ) {
-    router.get(route, async (ctx, next) => {
-      const file = ctx.params.path
-      const fullPath = path.resolve(folder, transform(file))
-
-      // only return files IF the file is within a baseFolder
-      if (!(await components.fs.fileExists(fullPath))) {
-        return next()
-      }
-
-      const headers: Record<string, any> = {
-        'x-timestamp': Date.now(),
-        'x-sent': true,
-        'cache-control': 'no-cache,private,max-age=1'
-      }
-
-      if (fullPath.endsWith('.wasm')) {
-        headers['content-type'] = 'application/wasm'
-      }
-
-      return {
-        headers,
-        body: components.fs.createReadStream(fullPath)
-      }
-    })
-  }
-
-  createStaticRoutes(components, '/images/decentraland-connect/:path+', dclKernelImagesDecentralandConnect)
-  createStaticRoutes(components, '/default-profile/:path+', dclKernelDefaultProfilePath)
-  createStaticRoutes(components, '/@/explorer/:path+', dclExplorerJsonPath, (filePath) => filePath.replace(/.br+$/, ''))
-
-  router.get('/feature-flags/:file', async (ctx) => {
-    const res = await fetch(`https://feature-flags.decentraland.zone/${ctx.params.file}`, {
-      headers: {
-        connection: 'close'
-      }
-    })
-    return {
-      body: await res.arrayBuffer()
-    }
-  })
-}
-
-async function fakeEntityV3FromFolder(
-  components: Pick<CliComponents, 'fs'>,
-  projectRoot: string,
-  hashingFunction: (filePath: string) => Promise<string>
-): Promise<Entity | null> {
-  const sceneJsonPath = path.resolve(projectRoot, 'scene.json')
-  let isParcelScene = true
-
-  const wearableJsonPath = path.resolve(projectRoot, 'wearable.json')
-  if (await components.fs.fileExists(wearableJsonPath)) {
-    try {
-      const wearableJson = JSON.parse(await components.fs.readFile(wearableJsonPath, 'utf-8'))
-      if (!WearableJson.validate(wearableJson)) {
-        const errors = (WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('')
-
-        console.error(`Unable to validate wearable.json properly, please check it.`, errors)
-        console.error(`Invalid wearable.json (${wearableJsonPath})`)
-      } else {
-        isParcelScene = false
-      }
-    } catch (err) {
-      console.error(`Unable to load wearable.json properly`, err)
-    }
-  }
-
-  if ((await components.fs.fileExists(sceneJsonPath)) && isParcelScene) {
-    const sceneJson = JSON.parse(await components.fs.readFile(sceneJsonPath, 'utf-8'))
-    const { base, parcels }: { base: string; parcels: string[] } = sceneJson.scene
-    const pointers = new Set<string>()
-    pointers.add(base)
-    parcels.forEach(($) => pointers.add($))
-
-    const mappedFiles = await getProjectContentMappings(components, projectRoot, hashingFunction)
-
-    return {
-      version: 'v3',
-      type: EntityType.SCENE,
-      id: await hashingFunction(projectRoot),
-      pointers: Array.from(pointers),
-      timestamp: Date.now(),
-      metadata: sceneJson,
-      content: mappedFiles
-    }
-  }
-
-  return null
-}

package/src/commands/start/server/file-watch-notifier.ts

@@ -1,45 +0,0 @@
-import { sdk } from '@dcl/schemas'
-import path from 'path'
-import { WebSocket } from 'ws'
-import chokidar from 'chokidar'
-import { getDCLIgnorePatterns } from '../../../logic/dcl-ignore'
-import { PreviewComponents } from '../types'
-
-/**
- * This function gets file modification events and sends them to all the connected
- * websockets, it is used to hot-reload assets of the scene.
- *
- * IMPORTANT: this is a legacy protocol and needs to be revisited for SDK7
- */
-export async function wireFileWatcherToWebSockets(
-  components: Pick<PreviewComponents, 'fs' | 'ws'>,
-  projectRoot: string
-) {
-  const { clients } = components.ws.ws
-  const ignored = await getDCLIgnorePatterns(components, projectRoot)
-
-  chokidar
-    .watch(path.resolve(projectRoot), {
-      ignored,
-      ignoreInitial: false,
-      cwd: projectRoot
-    })
-    .on('all', async (_, _file) => {
-      // TODO: accumulate changes in an array and debounce
-      return updateScene(projectRoot, clients)
-    })
-}
-
-function updateScene(dir: string, clients: Set<WebSocket>): void {
-  for (const client of clients) {
-    if (client.readyState === WebSocket.OPEN) {
-      const message: sdk.SceneUpdate = {
-        type: sdk.SCENE_UPDATE,
-        payload: { sceneId: 'b64-' + Buffer.from(dir).toString('base64'), sceneType: sdk.ProjectType.SCENE }
-      }
-
-      client.send(sdk.UPDATE)
-      client.send(JSON.stringify(message))
-    }
-  }
-}

package/src/commands/start/server/realm.ts

@@ -1,63 +0,0 @@
-import { handleSocketLinearProtocol } from '@dcl/mini-comms/dist/logic/handle-linear-protocol'
-import { PreviewComponents } from '../types'
-import { AboutResponse } from '@dcl/protocol/out-ts/decentraland/bff/http_endpoints.gen'
-import { Router } from '@well-known-components/http-server'
-import { upgradeWebSocketResponse } from '@well-known-components/http-server/dist/ws'
-
-/**
- * This module handles the BFF mock and communications server for the preview mode.
- * It runs using @dcl/mini-comms implementing RFC-5
- */
-
-export function setupRealmAndComms(components: PreviewComponents, router: Router<PreviewComponents>) {
-  router.get('/about', async (ctx) => {
-    const host = ctx.url.host
-
-    const body: AboutResponse = {
-      acceptingUsers: true,
-      bff: { healthy: false, publicUrl: host },
-      comms: {
-        healthy: true,
-        protocol: 'v3',
-        fixedAdapter: `ws-room:${ctx.url.protocol.replace(/^http/, 'ws')}//${host}/mini-comms/room-1`
-      },
-      configurations: {
-        networkId: 0,
-        globalScenesUrn: [],
-        scenesUrn: [],
-        realmName: 'LocalPreview'
-      },
-      content: {
-        healthy: true,
-        publicUrl: `${ctx.url.protocol}//${ctx.url.host}/content`
-      },
-      lambdas: {
-        healthy: true,
-        publicUrl: `${ctx.url.protocol}//${ctx.url.host}/lambdas`
-      },
-      healthy: true
-    }
-
-    return { body }
-  })
-
-  router.get('/mini-comms/:roomId', async (ctx) => {
-    return upgradeWebSocketResponse((ws: any) => {
-      if (ws.protocol === 'rfc5' || ws.protocol === 'rfc4') {
-        ws.on('error', (error: any) => {
-          console.error(error)
-          ws.close()
-        })
-
-        ws.on('close', () => {
-          console.debug('Websocket closed')
-        })
-
-        handleSocketLinearProtocol(components, ws, ctx.params.roomId).catch((err: any) => {
-          console.info(err)
-          ws.close()
-        })
-      }
-    })
-  })
-}

package/src/commands/start/server/routes.ts

@@ -1,36 +0,0 @@
-import { WebSocket } from 'ws'
-import { setupRealmAndComms } from './realm'
-import { Router } from '@well-known-components/http-server'
-import { setupEcs6Endpoints } from './endpoints'
-import { PreviewComponents } from '../types'
-import { upgradeWebSocketResponse } from '@well-known-components/http-server/dist/ws'
-
-export async function wireRouter(components: PreviewComponents, dir: string) {
-  const router = new Router<PreviewComponents>()
-
-  const sceneUpdateClients = new Set<WebSocket>()
-
-  router.get('/', async (ctx, next) => {
-    if (ctx.request.headers.get('upgrade') === 'websocket') {
-      return upgradeWebSocketResponse((ws) => initWsConnection(ws as any as WebSocket, sceneUpdateClients))
-    }
-
-    return next()
-  })
-
-  setupRealmAndComms(components, router)
-  setupEcs6Endpoints(components, dir, router)
-
-  components.server.setContext(components)
-  components.server.use(router.allowedMethods())
-  components.server.use(router.middleware())
-}
-
-const initWsConnection = (ws: WebSocket, clients: Set<WebSocket>) => {
-  if (ws.readyState === ws.OPEN) {
-    clients.add(ws)
-  } else {
-    ws.on('open', () => clients.add(ws))
-  }
-  ws.on('close', () => clients.delete(ws))
-}

package/src/commands/start/server/ws.ts

@@ -1,24 +0,0 @@
-import { WebSocketServer } from 'ws'
-import { PreviewComponents } from '../types'
-import { IBaseComponent } from '@well-known-components/interfaces'
-
-export type WebSocketComponent = IBaseComponent & {
-  ws: WebSocketServer
-}
-
-/**
- * Creates a ws-server component
- * @public
- */
-export async function createWsComponent(_: Pick<PreviewComponents, 'logs'>): Promise<WebSocketComponent> {
-  const ws = new WebSocketServer({ noServer: true })
-
-  async function stop() {
-    ws.close()
-  }
-
-  return {
-    stop,
-    ws
-  }
-}

package/src/commands/start/types.ts

@@ -1,26 +0,0 @@
-import {
-  ILoggerComponent,
-  IMetricsComponent,
-  IHttpServerComponent,
-  IConfigComponent
-} from '@well-known-components/interfaces'
-import { HTTPProvider } from 'eth-connect'
-import { RoomComponent } from '@dcl/mini-comms/dist/adapters/rooms'
-import { WebSocketComponent } from './server/ws'
-import { CliComponents } from '../../components'
-
-export type PreviewComponents = CliComponents & {
-  logs: ILoggerComponent
-  server: IHttpServerComponent<PreviewComponents>
-  config: IConfigComponent
-  metrics: IMetricsComponent<any>
-  ethereumProvider: HTTPProvider
-  rooms: RoomComponent
-  ws: WebSocketComponent
-  signaler: ISignalerComponent
-}
-
-export type ISignalerComponent = {
-  // programClosed resolves when the component is stopped
-  programClosed: Promise<void>
-}