#!/usr/bin/env node

/* eslint-env node, es6*/

const os = require('os')

const path = require('path')

const execa = require('execa')

const fg = require('fast-glob')

const fs = require('fs-extra')

const { hideBin } = require('yargs/helpers')

const yargs = require('yargs/yargs')

// This script sets up a blank RedwoodJS app into a directory.

// It uses the packages from the RedwoodJS framework (../packages).

// So, if you're making changes to the framework,

// you can use the e2e tests to verify your changes.

//

// The steps are composable, so that it can work for the GitHub Workflow, and

// us contributors.

//

const makeDirectory = () => {

console.log('mkdir', REDWOOD_PROJECT_DIRECTORY)

fs.mkdirSync(REDWOOD_PROJECT_DIRECTORY, { recursive: true })

return REDWOOD_PROJECT_DIRECTORY

}

const buildRedwoodFramework = () => {

try {

const files = fg.sync('packages/**/dist', {

onlyDirectories: true,

})

execa.sync(

[files.length && 'yarn build:clean', 'yarn build']

.filter(Boolean)

.join('&&'),

{

cwd: REDWOODJS_FRAMEWORK_PATH,

shell: true,

stdio: 'inherit',

}

)

} catch (e) {

if (e.signal !== 'SIGINT') {

console.error('Error: Could not build Redwood Framework')

console.error(e)

}

process.exit(1)

}

}

const createRedwoodJSApp = ({ typescript, bundler }) => {

try {

execa.sync(

'yarn node dist/create-redwood-app.js',

[

REDWOOD_PROJECT_DIRECTORY,

'--no-yarn-install',

`--typescript ${typescript}`,

'--no-telemetry',

'--no-git',

].filter(Boolean),

{

cwd: path.join(REDWOODJS_FRAMEWORK_PATH, 'packages/create-redwood-app'),

env: { REDWOOD_CI: '1' },

shell: true,

stdio: 'inherit',

}

)

// Add prisma resolutions

const packageJSONPath = path.join(REDWOOD_PROJECT_DIRECTORY, 'package.json')

const packageJSON = fs.readJSONSync(packageJSONPath)

const getVersionFrmRwPkg = (dep, pkg) => {

return fs.readJSONSync(

path.join(REDWOODJS_FRAMEWORK_PATH, 'packages', pkg, 'package.json')

).dependencies[dep]

}

packageJSON.resolutions = {

prisma: getVersionFrmRwPkg('prisma', 'cli'),

'@prisma/client': getVersionFrmRwPkg('@prisma/client', 'api'),

'@prisma/internals': getVersionFrmRwPkg('@prisma/internals', 'cli'),

'graphql-yoga': getVersionFrmRwPkg('graphql-yoga', 'graphql-server'),

graphql: getVersionFrmRwPkg('graphql', 'graphql-server'),

}

fs.writeFileSync(packageJSONPath, JSON.stringify(packageJSON, null, 2))

if (bundler === 'webpack') {

const redwoodTOMLPath = path.join(

REDWOOD_PROJECT_DIRECTORY,

'redwood.toml'

)

const redwoodTOML = fs.readFileSync(redwoodTOMLPath, 'utf-8')

fs.writeFileSync(

redwoodTOMLPath,

redwoodTOML.replace('[web]\n', '[web]\n bundler = "webpack"\n')

)

}

} catch (e) {

if (e.signal !== 'SIGINT') {

console.error('Error: Could not create Redwood Project')

console.error(e)

}

process.exit(1)

}

}

const addFrameworkDepsToProject = () => {

try {

execa.sync('yarn project:deps', {

cwd: REDWOODJS_FRAMEWORK_PATH,

shell: true,

stdio: 'inherit',

env: {

RWFW_PATH: REDWOODJS_FRAMEWORK_PATH,

RWJS_CWD: REDWOOD_PROJECT_DIRECTORY,

},

})

} catch (e) {

if (e.signal !== 'SIGINT') {

console.error(

'Error: Could not add Redwood Framework dependencies to project'

)

console.error(e)

}

process.exit(1)

}

}

const copyFrameworkPackages = () => {

try {

execa.sync('yarn project:copy', {

cwd: REDWOODJS_FRAMEWORK_PATH,

shell: true,

stdio: 'inherit',

env: {

RWFW_PATH: REDWOODJS_FRAMEWORK_PATH,

RWJS_CWD: REDWOOD_PROJECT_DIRECTORY,

},

})

} catch (e) {

if (e.signal !== 'SIGINT') {

console.error('Error: We could not copy Redwood Framework packages')

console.error(e)

}

process.exit(1)

}

}

const runYarnInstall = () => {

try {

execa.sync('yarn install', {

cwd: REDWOOD_PROJECT_DIRECTORY,

shell: true,

stdio: 'inherit',

})

} catch (e) {

if (e.signal !== 'SIGINT') {

console.error('Error: Could not run `yarn install`')

console.error(e)

}

process.exit(1)

}

}

const runDevServerInBackground = () => {

try {

console.log('Starting RedwoodJS dev server...')

execa('yarn rw dev --no-generate --fwd="--no-open"', {

cwd: REDWOOD_PROJECT_DIRECTORY,

shell: true,

stdio: 'inherit',

env: {

RWJS_DELAY_RESTART: '500',

REDWOOD_CI: '1',

},

})

} catch (e) {

if (e.signal !== 'SIGINT') {

console.error('There was an error with the RedwoodJS dev server:')

console.error(e)

}

process.exit(1)

}

}

const runCypress = () => {

try {

console.log('Starting Cypress...')

execa.sync(

// do not use Yarn to run Cypress; this avoids missing binary errors

'../../node_modules/.bin/cypress',

[

'open',

`--env RW_PATH=${REDWOOD_PROJECT_DIRECTORY}`,

'--e2e',

'--browser chrome',

],

{

cwd: path.join(REDWOODJS_FRAMEWORK_PATH, 'tasks/e2e'),

shell: true,

stdio: 'inherit',

}

)

} catch (e) {

if (e.signal !== 'SIGINT') {

console.error('There was an error with Cypress:')

console.error(e)

}

process.exit(1)

}

}

const initGit = () => {

try {

console.log('Initializing Git')

execa.sync('git init --initial-branch main && git add .', {

cwd: REDWOOD_PROJECT_DIRECTORY,

shell: true,

stdio: 'inherit',

})

execa.sync('git commit -a --message=init', {

cwd: REDWOOD_PROJECT_DIRECTORY,

shell: true,

stdio: 'inherit',

})

} catch (e) {

if (e.signal !== 'SIGINT') {

console.error(

'There was an error with the `git init` or `git commit` step:'

)

console.error(e)

}

process.exit(1)

}

}

const args = yargs(hideBin(process.argv))

.option('create-project', { default: true, type: 'boolean', alias: 'create' })

.option('build-framework', { default: true, type: 'boolean', alias: 'build' })

.option('copy-framework', { default: true, type: 'boolean', alias: 'copy' })

.option('typescript', { default: false, type: 'boolean', alias: 'ts' })

.option('auto-start', { default: true, type: 'boolean', alias: 'start' })

.option('clean-files', { default: true, type: 'boolean' })

.option('bundler', {

default: 'vite',

type: 'string',

choices: ['vite', 'webpack'],

})

.scriptName('run-e2e')

.example('run-e2e')

.example('run-e2e /tmp/redwood-app --ts')

.help()

.parse()

const REDWOODJS_FRAMEWORK_PATH = path.resolve(__dirname, '..')

let REDWOOD_PROJECT_DIRECTORY =

args._?.[0] ||

path.join(

os.tmpdir(),

'redwood-e2e',

// ":" is problematic with paths

new Date().toISOString().split(':').join('-')

)

console.log()

console.log('-'.repeat(80))

console.log()

makeDirectory(REDWOOD_PROJECT_DIRECTORY)

console.log()

console.log('-'.repeat(80))

let {

buildFramework,

copyFramework,

createProject,

typescript,

bundler,

autoStart,

cleanFiles,

} = args

const tasks = [

buildFramework && buildRedwoodFramework,

createProject && (() => createRedwoodJSApp({ typescript, bundler })),

copyFramework && addFrameworkDepsToProject,

copyFramework && runYarnInstall,

copyFramework && copyFrameworkPackages,

autoStart && runDevServerInBackground,

autoStart && initGit,

autoStart && runCypress,

].filter(Boolean)

process.on('SIGINT', () => {

process.exit(0)

})

process.on('exit', () => {

console.log('')

console.log('-'.repeat(80))

if (cleanFiles && autoStart) {

console.log('Cleaning up e2e resources...')

console.log(' - Cleaning up files (may take a few seconds)...')

fs.rmSync(REDWOOD_PROJECT_DIRECTORY, { recursive: true, force: true })

console.log('Clean up complete')

} else {

console.log(

`E2E files within "${REDWOOD_PROJECT_DIRECTORY}" have not been automatically cleaned up.`

)

}

})

for (const task of tasks) {

console.log()

task()

console.log()

console.log('-'.repeat(80))

}