@raisenow/tamaro-cli 1.1.7 → 1.1.9

package/src/commands/dev.ts

@@ -1,88 +0,0 @@
-import {getPortPromise} from 'portfinder'
-import {halt, runCommandSync} from 'lib/command'
-import {applyEnv, assertEnvValid} from 'lib/env'
-import {assertCrtExists} from 'lib/https'
-import {logCommand, logTitle} from 'lib/logging'
-import {getIfCoreFns, resolveBin, resolveOwn} from 'lib/resolve'
-
-///////////////////////////////////////////////////////////////////////////////
-
-export type DevOptions = {
-  localCore: boolean
-  https: boolean
-  port: string
-  env?: string
-  nolint: boolean
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const dev = async (options: DevOptions): Promise<void> => {
-  const {env} = options
-
-  applyEnv(env)
-  assertOptionsValid(options)
-
-  const flags = await prepareFlags(options)
-  const {ifCore} = getIfCoreFns()
-  const title = ifCore(
-    'Running dev web-server for Tamaro Core …',
-    'Running dev web-server for customer configuration …',
-  )
-  const wpBin = resolveBin('webpack')
-  const wpConfig = resolveOwn('dist/webpack.config.js')
-  const cmd = `
-    ${wpBin} serve
-      --config ${wpConfig}
-      ${flags}
-  `
-
-  logTitle(title)
-  logCommand(cmd)
-  runCommandSync(cmd, {stdio: 'inherit'})
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-const assertOptionsValid = (options: DevOptions) => {
-  const {localCore, https, port, env} = options
-  const {ifCore} = getIfCoreFns()
-
-  if (ifCore() && localCore) {
-    halt('Flag "--local-core" is redundant if running in Tamaro Core context.')
-  }
-
-  if (isNaN(Number(port))) {
-    halt('Flag "--port" should be a number.')
-  }
-
-  if (https) {
-    assertCrtExists()
-  }
-
-  assertEnvValid(env)
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-const prepareFlags = async (options: DevOptions) => {
-  const flags: string[] = []
-  const {localCore, port: defaultPort, https, nolint} = options
-  const port = await getPortPromise({port: Number(defaultPort)})
-
-  if (localCore) {
-    flags.push('--env localCore')
-  }
-
-  flags.push(`--port ${port}`)
-
-  if (https) {
-    flags.push('--env https')
-  }
-
-  if (nolint) {
-    flags.push('--env nolint')
-  }
-
-  return flags.join(' ')
-}

package/src/commands/list-deployed.ts

@@ -1,117 +0,0 @@
-import {
-  assertProfilesPresent,
-  assertProfileValid,
-  awsAuthenticate,
-  type AwsOptions,
-  prepareFlags,
-  promptProfile,
-} from 'lib/aws'
-import {halt, runCommandSync} from 'lib/command'
-import {AWS_S3_BUCKET_TAMARO, CORE_CONFIG_NAME} from 'lib/constants'
-import {logCommand, logTitle} from 'lib/logging'
-import {getIfCoreFns, getWidgetUuid} from 'lib/resolve'
-
-///////////////////////////////////////////////////////////////////////////////
-
-export type ListDeployedOptions = AwsOptions & {
-  config?: string
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const listDeployed = async (
-  options: ListDeployedOptions,
-): Promise<void> => {
-  if (!options.profile && !options.ci) {
-    assertProfilesPresent()
-    options.profile = await promptProfile()
-  }
-
-  assertOptionsValid(options)
-  awsAuthenticate(options)
-
-  const flags = prepareFlags(options)
-  const {config} = options
-  const {ifCore} = getIfCoreFns()
-  const configName = config ?? ifCore(CORE_CONFIG_NAME, getWidgetUuid())
-  const title =
-    !config && ifCore()
-      ? `Listing deployments of Tamaro Core …`
-      : `Listing deployments of "${configName}" customer configuration …`
-
-  const deployUrl = `s3://${AWS_S3_BUCKET_TAMARO}/${configName}/`
-  const cmd = `aws s3 ls ${deployUrl} ${flags}`
-  let out = ''
-
-  logTitle(title)
-  logCommand(cmd)
-
-  // If customer configuration folder does not exist on AWS S3,
-  // command fails with blank stderr, so we need to handle this case.
-  try {
-    const result = runCommandSync(cmd)
-    out = result.stdout as string
-  } catch (error: any) {
-    out = error.stdout as string
-
-    if (error.stderr) {
-      halt(error.stderr)
-    }
-  }
-
-  const lines = out.split('\n')
-  const tags = parseTags(lines)
-  let text = ''
-
-  if (tags.length === 0) {
-    text = 'No deployments found.'
-  } else {
-    text = tags
-      .map((tag, idx) => {
-        // prettier-ignore
-        return `${idx + 1}. https://${AWS_S3_BUCKET_TAMARO}/${configName}/${tag}/index.html`
-      })
-      .join('\n')
-  }
-
-  // eslint-disable-next-line no-console
-  console.log(`${text}\n`)
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-const assertOptionsValid = (options: ListDeployedOptions) => {
-  const {config, profile} = options
-
-  assertConfigValid(config)
-
-  if (profile) {
-    assertProfileValid(profile)
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-const assertConfigValid = (config: string | undefined) => {
-  if (!config) {
-    return
-  }
-
-  const regex = /^[a-zA-Z0-9-_]+$/
-
-  if (!regex.test(config)) {
-    halt(
-      `Flag "--config" has forbidden format. Allowed format: ${regex.toString()}.`,
-    )
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-const parseTags = (lines: string[]): string[] => {
-  const regex = /^\s*PRE\s*/
-
-  return lines
-    .filter((line) => regex.test(line))
-    .map((line) => line.replace(regex, '').replace(/\/$/, ''))
-}

package/src/commands/serve.ts

@@ -1,69 +0,0 @@
-import {resolve} from 'path'
-import {getPortPromise} from 'portfinder'
-import {halt, runCommandSync} from 'lib/command'
-import {HTTPS_CRT_FILE, HTTPS_KEY_FILE} from 'lib/constants'
-import {assertCrtExists} from 'lib/https'
-import {logCommand, logTitle} from 'lib/logging'
-import {getIfCoreFns, getPaths} from 'lib/resolve'
-
-///////////////////////////////////////////////////////////////////////////////
-
-export type ServeOptions = {
-  port: string
-  https: boolean
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const serve = async (options: ServeOptions): Promise<void> => {
-  assertOptionsValid(options)
-
-  const flags = await prepareFlags(options)
-  const {ifCore} = getIfCoreFns()
-  const paths = getPaths(ifCore)
-  const cmd = `
-    npx -y serve ${paths.appDist}
-      --cors
-      ${flags}
-  `
-
-  logTitle(`Running web-server for pre-built bundle …`)
-  logCommand(cmd)
-  runCommandSync(cmd, {stdio: 'inherit'})
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-const assertOptionsValid = (options: ServeOptions) => {
-  const {port, https} = options
-
-  if (isNaN(Number(port))) {
-    halt('Flag "--port" should be a number.')
-  }
-
-  if (https) {
-    assertCrtExists()
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-const prepareFlags = async (options: ServeOptions) => {
-  const flags: string[] = []
-  const {port: defaultPort, https} = options
-  const port = await getPortPromise({port: Number(defaultPort)})
-
-  flags.push(`-p ${port}`)
-
-  if (https) {
-    const {ifCore} = getIfCoreFns()
-    const paths = getPaths(ifCore)
-    const certFile = resolve(paths.root, HTTPS_CRT_FILE)
-    const keyFile = resolve(paths.root, HTTPS_KEY_FILE)
-
-    flags.push(`--ssl-cert ${certFile}`)
-    flags.push(`--ssl-key ${keyFile}`)
-  }
-
-  return flags.join(' ')
-}

package/src/lib/InterpolateHtmlPlugin.ts

@@ -1,47 +0,0 @@
-import escapeStringRegexp from 'escape-string-regexp'
-import HtmlWebpackPlugin from 'html-webpack-plugin'
-import {type Compiler} from 'webpack'
-
-///////////////////////////////////////////////////////////////////////////////
-
-export type Replacements = Record<string, string | undefined>
-
-///////////////////////////////////////////////////////////////////////////////
-
-const PLUGIN_NAME = 'InterpolateHtmlPlugin'
-
-///////////////////////////////////////////////////////////////////////////////
-
-export class InterpolateHtmlPlugin {
-  replacements: Replacements
-
-  constructor(replacements: Replacements) {
-    this.replacements = {...replacements}
-  }
-
-  apply(compiler: Compiler): void {
-    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-      const hooks = HtmlWebpackPlugin.getHooks(compilation)
-
-      hooks.alterAssetTagGroups.tap(PLUGIN_NAME, (assets) => {
-        const publicUrl = this.replacements.PUBLIC_URL ?? ''
-        const entry = assets.headTags[0].attributes.src as string
-        this.replacements.ENTRY = `${publicUrl}${entry}`
-
-        return assets
-      })
-
-      hooks.afterTemplateExecution.tap(PLUGIN_NAME, (data) => {
-        // Run HTML through a series of user-specified string replacements.
-        Object.entries(this.replacements).forEach(([key, value]) => {
-          data.html = data.html.replace(
-            new RegExp(`%${escapeStringRegexp(key)}%`, 'g'),
-            value ?? '',
-          )
-        })
-
-        return data
-      })
-    })
-  }
-}

package/src/lib/aws.ts

@@ -1,138 +0,0 @@
-import {execaCommandSync} from 'execa'
-// eslint-disable-next-line import/no-named-as-default
-import prompts from 'prompts'
-import stripIndent from 'strip-indent'
-import {halt} from 'lib/command'
-
-///////////////////////////////////////////////////////////////////////////////
-
-export type AwsOptions = {
-  profile?: string
-  ci?: boolean
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const awsAuthenticate = (options: AwsOptions) => {
-  if (options.ci) {
-    /**
-     * Don't try to authenticate the user.
-     * This is done when CLI is running within an automated system like pipeline,
-     * In this case "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY" are used instead of "AWS_PROFILE".
-     */
-    return
-  }
-
-  try {
-    checkIdentity(options)
-  } catch (error) {
-    login(options)
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const assertProfilesPresent = () => {
-  const profiles = getAvailableProfiles()
-
-  if (profiles.length === 0) {
-    halt(
-      stripIndent(`
-        No AWS profiles found.
-        Run "aws configure sso" to set up SSO-enabled profile.
-        Check the wiki for more information:
-        https://raisenow.atlassian.net/wiki/x/lIrWvg
-      `),
-    )
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const getAvailableProfiles = (): string[] => {
-  const {stdout} = execaCommandSync('aws configure list-profiles')
-
-  return stdout.split('\n')
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * Returns caller identity data (output is ignored here).
- * Fails in case of expired SSO session.
- */
-const checkIdentity = (options: AwsOptions) => {
-  const flags = prepareFlags(options)
-
-  execaCommandSync(`aws sts get-caller-identity ${flags}`)
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * Opens SSO authentication page in the browser.
- * Fails if user canceled authentication process.
- */
-const login = (options: AwsOptions) => {
-  const flags = prepareFlags(options)
-
-  try {
-    execaCommandSync(`aws sso login ${flags}`, {stdio: 'inherit'})
-    // eslint-disable-next-line no-console
-    console.log('')
-  } catch (error) {
-    halt('Login failed.')
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const prepareFlags = (options: AwsOptions) => {
-  const flags: string[] = []
-  const {profile} = options
-
-  if (profile) {
-    flags.push(`--profile ${profile}`)
-  }
-
-  return flags.join(' ')
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const assertProfileValid = (profile: string) => {
-  const profiles = getAvailableProfiles()
-
-  if (!profiles.includes(profile)) {
-    halt(
-      stripIndent(`
-        AWS profile "${profile}" is not found.
-        Available profiles are: ${profiles.map((v) => `"${v}"`).join(', ')}.
-      `),
-    )
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const promptProfile = async (): Promise<string | undefined> => {
-  const profiles = getAvailableProfiles()
-    .filter((v) => !!v)
-    .map((v) => ({title: v, value: v}))
-
-  const {profile} = await prompts(
-    [
-      {
-        type: 'select',
-        name: 'profile',
-        message: 'Select AWS profile',
-        choices: profiles,
-      },
-    ],
-    {
-      onCancel: () => halt(),
-    },
-  )
-
-  return profile
-}

package/src/lib/command.ts

@@ -1,27 +0,0 @@
-import {execaCommandSync, type SyncOptions, type SyncResult} from 'execa'
-import {logError} from 'lib/logging'
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const halt = (message?: string) => {
-  logError(message)
-  process.exit(1)
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const prepareCommand = (cmd: string): string => {
-  return cmd
-    .replace(/\n/gm, ' ')
-    .replace(/[ \t]{2,}/gm, ' ')
-    .trim()
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const runCommandSync = (
-  cmd: string,
-  options?: SyncOptions,
-): SyncResult => {
-  return execaCommandSync(prepareCommand(cmd), options)
-}

package/src/lib/constants.ts

@@ -1,9 +0,0 @@
-export const DEFAULT_TAG = 'latest'
-export const DEFAULT_PORT = 1234
-export const AWS_S3_BUCKET_TAMARO = 'tamaro.raisenow.com'
-export const AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_STAGE = 'rnw-stage-email-service'
-export const AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_PROD = 'rnw-email-service'
-export const CORE_CONFIG_NAME = 'tamaro-core'
-export const AWS_CLOUDFRONT_DISTRIBUTION_ID = 'EHJ1OM458YQ0I'
-export const HTTPS_CRT_FILE = 'localhost.crt'
-export const HTTPS_KEY_FILE = 'localhost.key'

package/src/lib/env.ts

@@ -1,176 +0,0 @@
-import {createRequire} from 'module'
-import {basename} from 'path'
-import {config as dotenvConfig} from 'dotenv'
-import {expand as dotenvExpand} from 'dotenv-expand'
-import {globSync} from 'glob'
-import stripIndent from 'strip-indent'
-import type {IfUtilsFn} from 'webpack-config-utils'
-import {halt} from 'lib/command'
-import {getIfCoreFns, getPaths, getWidgetUuid, resolveApp} from 'lib/resolve'
-
-///////////////////////////////////////////////////////////////////////////////
-
-export type EnvVars = Record<string, string | undefined>
-
-///////////////////////////////////////////////////////////////////////////////
-
-const require = createRequire(import.meta.url)
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const getEnvVars = (
-  files: string[],
-  ifMin: IfUtilsFn,
-  ifCore: IfUtilsFn,
-  ifLocalCore: IfUtilsFn,
-  ifHttps: IfUtilsFn,
-) => {
-  const filePath = files.find((file) => basename(file) === '.env')
-
-  if (filePath) {
-    dotenvExpand(dotenvConfig({path: filePath}))
-  }
-
-  process.env.NODE_ENV ??= ifMin('production', 'development')
-  process.env.BABEL_ENV ??= ifMin('production', 'development')
-  process.env.EXPOSE_VAR ??= ifCore('rnw.tamaroCore', 'rnw.tamaro')
-  process.env.ELEMENT_ATTRIBUTE_DATA_WIDGET ??= ifCore(
-    'rnw-tamaro-core',
-    'rnw-tamaro',
-  )
-  process.env.WEBPACK_UNIQUE_NAME ??= ifCore('RnwTamaroCore', 'RnwTamaro')
-  process.env.BUILD_DATE = new Date().toISOString()
-  process.env.PUBLIC_URL ??= ''
-  process.env.HMR_ENABLED ??= ifMin('false', 'true')
-
-  if (ifCore()) {
-    process.env.PRODUCT_NAME = 'tamaro'
-
-    const corePkgPath = resolveApp('package.json')
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const {version} = require(corePkgPath)
-
-    process.env.PRODUCT_VERSION = version
-  }
-
-  if (!ifCore()) {
-    process.env.WIDGET_UUID = getWidgetUuid()
-
-    if (ifLocalCore()) {
-      const protocol = ifHttps() ? 'https' : 'http'
-      process.env.CORE_URL = `${protocol}://localhost:1234/index.js`
-    } else {
-      let version = process.env.CORE_VERSION
-      version = version ? `@${version}` : ''
-
-      // process.env.CORE_URL ??= `https://cdn.jsdelivr.net/npm/@raisenow/tamaro-core${version}/dist/index.js`
-      process.env.CORE_URL ??= `https://fastly.jsdelivr.net/npm/@raisenow/tamaro-core${version}/dist/index.js`
-    }
-  }
-
-  // var names which will be exposed along with "PUBLIC_*" var names
-  const varNames = [
-    // common
-    'NODE_ENV',
-    'BABEL_ENV',
-    'EXPOSE_VAR',
-    'ELEMENT_ATTRIBUTE_DATA_WIDGET',
-    'WEBPACK_UNIQUE_NAME',
-    'BUILD_DATE',
-    'PUBLIC_URL',
-
-    // core
-    'PRODUCT_NAME',
-    'PRODUCT_VERSION',
-
-    // config
-    'WIDGET_UUID',
-    'CORE_URL',
-    'CORE_VERSION', // should be explicitly specified in each config
-
-    // epik (obsolete since Tamaro v2.5.0)
-    'EPP_API_KEY_DEFAULT',
-    'EPP_API_URL_STAGE',
-    'EPP_API_URL_PROD',
-    'EPMS_API_URL_STAGE',
-    'EPMS_API_URL_PROD',
-    'EPP_PROXY_URL_STAGE',
-    'EPP_PROXY_URL_PROD',
-    'EPMS_PROXY_URL_STAGE',
-    'EPMS_PROXY_URL_PROD',
-    'EPMS_TWINT_CHECKOUT_URL_STAGE',
-    'EPMS_TWINT_CHECKOUT_URL_PROD',
-  ]
-
-  // Collect all vars which names start from "PUBLIC_" or present in "varNames" array
-  const raw = Object.keys(process.env)
-    .filter((key) => key.startsWith('PUBLIC_') || varNames.includes(key))
-    .reduce<EnvVars>((env, key) => {
-      env[key] = process.env[key]
-
-      return env
-    }, {})
-
-  // Stringify all values so we can feed into webpack DefinePlugin
-  const stringified = {
-    'process.env': Object.keys(raw).reduce<EnvVars>((env, key) => {
-      env[key] = JSON.stringify(raw[key])
-
-      return env
-    }, {}),
-  }
-
-  return {raw, stringified}
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-export const assertEnvValid = (env?: string) => {
-  const {ifCore} = getIfCoreFns()
-  const paths = getPaths(ifCore)
-  const files = globSync(paths.appEnv)
-  const envs = files
-    .map((file) => basename(file).replace(/^\.env\./, ''))
-    .map((file) => basename(file).replace(/^\.env$/, ''))
-    .filter((v) => !!v)
-
-  if (envs.length === 0) {
-    if (env) {
-      // There are no ".env.<env>" files, so we must ignore "--env" flag
-      // eslint-disable-next-line no-console
-      console.log('Flag "--env" is ignored.')
-    }
-  }
-
-  if (envs.length !== 0) {
-    if (!env) {
-      // There are some ".env.<env>" files, but no "--env" flag is specified, so we must require it
-      halt('Flag "--env" is required.')
-    }
-
-    if (env && !envs.includes(env)) {
-      // There are some ".env.<env>" files, but specified "--env" flag is incorrect
-      halt(
-        stripIndent(`
-          Flag "--env" has wrong value.
-          Available values are: ${envs.map((v) => `"${v}"`).join(', ')}.
-        `),
-      )
-    }
-  }
-}
-
-export const applyEnv = (env?: string) => {
-  if (!env) {
-    return
-  }
-
-  const {ifCore} = getIfCoreFns()
-  const paths = getPaths(ifCore)
-  const files = globSync(paths.appEnv)
-  const filePath = files.find((file) => basename(file) === `.env.${env}`)
-
-  if (filePath) {
-    dotenvExpand(dotenvConfig({path: filePath}))
-  }
-}