Alguém aqui sabe qual é a url usada pela CLI para linkar os aplicativos?

rafael.camargo · July 9, 2022, 3:08am

Oi! Alguém aqui sabe qual é a url usada pela CLI para linkar os aplicativos?

Estava dando uma olhada no projeto no GitHub, mas está meio confuso, e não consegui achar a url final, vou linkar algumas urls, e prints para ajudar, ou usar como dica para quem souber!

github.com

vtex/toolbelt/blob/main/src/api/conf.ts

import Configstore from 'configstore'
import { dirname } from 'path'

import { name as pkgName } from '../../package.json'

const conf = new Configstore(pkgName)

export const configDir = dirname(conf.path)

export enum Environment {
  Production = 'prod',
}

export const CLUSTER_DEFAULT_VALUE = ''

export const ENV_DEFAULT_VALUE = Environment.Production

export const saveEnvironment = (env: Environment) => conf.set('env', env)

export const saveStickyHost = (appName: string, stickyHost: string) =>

This file has been truncated. show original

Configs

github.com

vtex/toolbelt/blob/main/src/commands/link.ts

import { flags as oclifFlags } from '@oclif/command'

import { CustomCommand } from '../api/oclif/CustomCommand'
import { appLink } from '../modules/apps/link'

import { ColorifyConstants } from '../api/constants/Colors'

export default class Link extends CustomCommand {
  static description = `Syncs the app in the current directory with the ${ColorifyConstants.ID(
    'development workspace'
  )} in use.`

  static examples = [`${ColorifyConstants.COMMAND_OR_VTEX_REF('vtex link')} -a youraccount -w yourworkspace`]

  static flags = {
    ...CustomCommand.globalFlags,
    account: oclifFlags.string({
      char: 'a',
      description: `Starts a development session in the specified ${ColorifyConstants.ID(
        'account'

This file has been truncated. show original

Link command

github.com

vtex/toolbelt/blob/main/src/modules/apps/link.ts

import { Builder } from '../../api/clients/IOClients/apps/Builder'
import {
  ChangeSizeLimitError,
  ChangeToSend,
  ProjectSizeLimitError,
  ProjectUploader,
} from '../../api/modules/apps/ProjectUploader'
import {
  checkBuilderHubMessage,
  showBuilderHubMessage,
  continueAfterReactTermsAndConditions,
  validateAppAction,
} from '../../api/modules/utils'
import { createFlowIssueError } from '../../api/error/utils'
import { concat, isEmpty, map, pipe, prop } from 'ramda'
import { createInterface } from 'readline'
import { createPathToFileObject } from '../../api/files/ProjectFilesManager'
import { default as setup } from '../setup'
import { fixPinnedDependencies, PinnedDeps } from '../../api/pinnedDependencies'
import { formatNano, runYarnIfPathExists } from '../utils'

This file has been truncated. show original

Link App

github.com

vtex/toolbelt/blob/main/src/api/modules/apps/ProjectUploader.ts

import { Builder, RequestParams } from '../../clients/IOClients/apps/Builder'
import { getSavedOrMostAvailableHost } from '../../../host'
import { Readable } from 'stream'
import { ZlibOptions } from 'zlib'
import archiver from 'archiver'
import chalk from 'chalk'
import getStream from 'get-stream'
import logger from '../../logger'

const MB = 1000000

export interface FileToSend {
  path: string
  content: string | Readable | Buffer | NodeJS.ReadableStream
  byteSize: number
}

export type ChangeToSend = FileToSend

interface PrepareRequest {

This file has been truncated. show original

Uploader

E também:

github.com

vtex/toolbelt/blob/b21307d94a59abe12933d867a996a2036ccd9787/src/api/clients/IOClients/apps/Builder.ts#L111


      
          
          public testApp = (
            app: string,
            zipFile: Buffer,
            stickyOptions: StickyOptions = { sticky: true },
            params: RequestParams = {}
          ) => {
            return this.sendZipFile(routes.test(app), app, zipFile, stickyOptions, params)
          }
          
          public linkApp = (
            app: string,
            linkID: string,
            zipFile: Buffer,
            stickyOptions: StickyOptions = { sticky: true },
            params: RequestParams = {}
          ) => {
            return this.sendZipFile(routes.link(app), app, zipFile, stickyOptions, params, { [Headers.VTEX_LINK_ID]: linkID })
          }
          
          public relinkApp = async (app: string, changes: ChangeToSend[], linkID: string, params: RequestParams = {}) => {

linkApp function

georgebrindeiro · July 10, 2022, 7:14pm

O que exatamente você está querendo descobrir? Para onde é enviado o bundle do app?

rafael.camargo · July 10, 2022, 7:39pm

Basicamente é isso, já consegui identificar como é feito o processo de link e diff de arquivos, mas fiquei em duvida sobre a url usada, pelos arquivos e alguns trechos de código, chutaria que é https://{workspace}--{account}.myvtex.com/_v/builder/0/link/${app}, no arquivo do Builder ele descreve as rotas, porém a baseUrl que é a parte mais “complicada”, aparentemente ela vem herdada do builder, que por sua vez, vem do node-vtex-api.

Mas se a url seguir o padrão que já é observado no resto da plataforma, e por ser relativo as workspaces, essa url que citei faria sentido. Agora resta descobrir os headers que são obrigatórios para o processo de link das aplicações… skskk

georgebrindeiro · July 11, 2022, 2:34pm

Acho que é isso aí mesmo, mas que problema isso te ajuda a resolver? Você está só querendo entender melhor como as coisas funcionam por trás dos panos?

rafael.camargo · July 11, 2022, 3:33pm

No geral é isso mesmo, a forma como funciona a plataforma sempre me deixou curioso, estou entendendo melhor e testando algumas coisas com isso. Acho que pode ajudar com soluções para a plataforma no futuro.
Porém algumas coisas não ficam claras com tantos anos de código para ler , e um insight de quem tem mais contato com isso sempre ajuda!

Agora, outra coisa que me deixou curioso, existe alguma documentação, ou trecho de código que mostre ou explique sobre autenticação dentro das apis e etc? Temos os clássicos headers de api-key e token, mas passando pelos repositórios vi que são, utilizados diversos outros pelos builders, e etc…

Ex:

github.com

vtex/node-vtex-api/blob/6e539dbe5ce2af2ac1dce0d24513c47fc91fadfe/src/HttpClient/HttpClient.ts#L77


      
            exponentialTimeoutCoefficient,
            initialBackoffDelay,
            exponentialBackoffCoefficient,
            httpsAgent,
            tracer,
            logger,
          } = opts
          this.name = name || baseURL || 'unknown'
          
          const limit = concurrency && concurrency > 0 && pLimit(concurrency) || undefined
          const headers: Record<string, string> = {
            ...defaultHeaders,
            'Accept-Encoding': 'gzip',
            'User-Agent': userAgent,
            ...host ? { [FORWARDED_HOST_HEADER]: host } : null,
            ...tenant ? { [TENANT_HEADER]: formatTenantHeaderValue(tenant) } : null,
            ...binding ? { [BINDING_HEADER]: formatBindingHeaderValue(binding) } : null,
            ...locale ? { [LOCALE_HEADER]: locale } : null,
            ...operationId ? { 'x-vtex-operation-id': operationId } : null,
            ...product ? { [PRODUCT_HEADER]: product } : null,
            ...segmentToken ? { [SEGMENT_HEADER]: segmentToken } : null,

HttpClient

github.com

vtex/node-vtex-api/blob/6e539dbe5ce2af2ac1dce0d24513c47fc91fadfe/src/constants.ts#L10


      
          import { versionToMajor } from './utils/app'
          // tslint:disable-next-line
          const pkg = require('../package.json')
          
          export const NODE_VTEX_API_VERSION = pkg.version
          export const DEFAULT_WORKSPACE = 'master'
          export const IS_IO = process.env.VTEX_IO
          export const PID = process.pid
          
          export const CACHE_CONTROL_HEADER = 'cache-control'
          export const SEGMENT_HEADER = 'x-vtex-segment'
          export const SESSION_HEADER = 'x-vtex-session'
          export const PRODUCT_HEADER = 'x-vtex-product'
          export const LOCALE_HEADER = 'x-vtex-locale'
          export const FORWARDED_HOST_HEADER = 'x-forwarded-host'
          export const TENANT_HEADER = 'x-vtex-tenant'
          export const BINDING_HEADER = 'x-vtex-binding'
          export const META_HEADER = 'x-vtex-meta'
          export const META_HEADER_BUCKET = 'x-vtex-meta-bucket'
          export const ETAG_HEADER = 'etag'

constants

georgebrindeiro · July 12, 2022, 7:12pm

Acho que a seção Authentication do guia Connecting to VTEX Core Commerce APIs dá uma luz inicial nesse tema. Basicamente, apps rodando no VTEX IO conseguem obter:

App tokens com ctx.authToken
Store user tokens com ctx.vtex.storeUserAuthToken
Admin user tokens com ctx.vtex.adminUserAuthToken

Estes tokens devem ser passados pelo header VtexIdclientAutCookie para o request ser autenticado por eles. As permissões vinculadas serão aquelas descritas pelas policies do app ou pelo perfil de acesso do usuário.

Se você quiser fazer um request para uma API REST da sua máquina, usando o Postman por exemplo, você pode rodar vtex local token na VTEX IO CLI e usar esse mesmo header. Só deve lembrar que, ao contrário de app key e app token padrão, esses tokens expiram após um tempo.

system · July 13, 2022, 7:12pm

This topic was automatically closed 24 hours after the last reply. New replies are no longer allowed.