@sprucelabs/spruce-cli 18.1.5 → 18.1.6

package/src/__tests__/behavioral/WatchingSkillViews.test.ts

@@ -1,7 +1,4 @@
-import { SettingsService } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test-utils'
-import ps from 'ps-node'
-import BootAction from '../../features/skill/actions/BootAction'
 import WatchAction from '../../features/view/actions/WatchAction'
 import CommandService from '../../services/CommandService'
 import AbstractSkillTest from '../../tests/AbstractSkillTest'
@@ -9,245 +6,35 @@ import AbstractSkillTest from '../../tests/AbstractSkillTest'
 export default class WatchingSkillViewsTest extends AbstractSkillTest {
 	protected static skillCacheKey = 'views'
 	protected static oldBootExecute: any
-
-	protected static async beforeAll() {
-		await super.beforeAll()
-		this.oldBootExecute = BootAction.prototype.execute
-	}
+	private static action: WatchAction
 
 	protected static async beforeEach() {
 		await super.beforeEach()
-		this.featureInstaller.isInstalled = async () => true
-		SettingsService.prototype.isMarkedAsInstalled = () => true
-		BootAction.prototype.execute = this.oldBootExecute
+		this.action = this.Action('view', 'watch')
 	}
 
 	@test()
 	protected static async hasWatchSkillViewsEvent() {
-		assert.isFunction(this.Action('view', 'watch').execute)
+		assert.isFunction(this.action.execute)
 	}
 
 	@test()
 	protected static async shouldCallBoot() {
 		let wasHit = false
+		CommandService.fakeCommand(
+			'ENABLED_SKILL_FEATURES=view,event SHOULD_REGISTER_EVENTS_AND_LISTENERS=false SHOULD_WATCH_VIEWS=true MAXIMUM_LOG_PREFIXES_LENGTH=0 yarn boot',
+			{
+				code: 200,
+				callback: () => {
+					wasHit = true
+				},
+			}
+		)
 
-		CommandService.fakeCommand(/yarn boot/gis, {
-			code: 0,
-			callback: () => {
-				wasHit = true
-			},
-		})
-
-		const watchAction = this.Action('view', 'watch') as WatchAction
-		void watchAction.execute({})
-		await this.wait(10)
-		assert.isTrue(wasHit)
-
-		await watchAction.kill()
-	}
-
-	@test()
-	protected static async shouldCallBootAgainOnFileChange() {
-		let hitCount = 0
-		CommandService.fakeCommand(/yarn boot/gis, {
-			code: 0,
-			callback: () => {
-				hitCount++
-			},
-		})
-
-		const watchAction = this.Action('view', 'watch') as WatchAction
-
-		void watchAction.execute({})
+		void this.action.execute()
 
 		await this.wait(10)
 
-		assert.isEqual(hitCount, 1)
-
-		await this.emitFileChangeEvent()
-
-		assert.isEqual(hitCount, 2)
-		await watchAction.kill()
-	}
-
-	@test()
-	protected static async changesDuringBootOfSkillKillSkill() {
-		CommandService.fakeCommand(/yarn boot/gis, {
-			code: 0,
-		})
-
-		const watchAction = this.Action('view', 'watch') as WatchAction
-
-		let passedOptions: any = null
-
-		//@ts-ignore
-		BootAction.prototype.execute = (options: any) => {
-			passedOptions = options
-		}
-
-		void watchAction.execute()
-
-		await this.wait(100)
-
-		assert.isTrue(passedOptions.shouldReturnImmediately)
-
-		await watchAction.kill()
-	}
-
-	@test()
-	protected static async holdsOnAction() {
-		CommandService.fakeCommand(/yarn boot/gis, {
-			code: 0,
-		})
-
-		const watchAction = this.Action('view', 'watch') as WatchAction
-		const actionPromise = watchAction.execute()
-		let didWait = false
-		const waitPromise = new Promise((resolve) => {
-			setTimeout(async () => {
-				didWait = true
-				await watchAction.kill()
-				resolve(null)
-			}, 1000)
-		})
-
-		await actionPromise
-		await waitPromise
-
-		assert.isTrue(didWait)
-
-		await watchAction.kill()
-	}
-
-	@test()
-	protected static async canKillAction() {
-		CommandService.fakeCommand(/yarn boot/gis, {
-			code: 0,
-		})
-
-		const watchAction = this.Action('view', 'watch') as WatchAction
-		const actionPromise = watchAction.execute()
-
-		let didWait = false
-		const waitPromise = new Promise((resolve) => {
-			setTimeout(() => {
-				didWait = true
-				resolve(null)
-			}, 1000)
-		})
-
-		await this.wait(100)
-
-		await watchAction.kill()
-
-		await actionPromise
-
-		assert.isFalse(didWait)
-
-		await waitPromise
-
-		await watchAction.kill()
-	}
-
-	@test()
-	protected static async makeSureWatcherIsStartedAndStopped() {
-		CommandService.fakeCommand(/yarn boot/gis, {
-			code: 0,
-		})
-
-		const watchFeature = this.featureInstaller.getFeature('watch')
-		let wasStarted = false
-		let wasStopped = false
-
-		watchFeature.startWatching = async () => {
-			wasStarted = true
-		}
-
-		watchFeature.stopWatching = async () => {
-			wasStopped = true
-		}
-
-		const watchAction = this.Action('view', 'watch') as WatchAction
-		void watchAction.execute()
-
-		await this.wait(100)
-
-		assert.isTrue(wasStarted)
-		assert.isFalse(wasStopped)
-
-		await watchAction.kill()
-		await this.wait(100)
-
-		assert.isTrue(wasStarted)
-		assert.isTrue(wasStopped)
-	}
-
-	@test()
-	protected static async killingActionKillsProcess() {
-		await this.FeatureFixture().installCachedFeatures('events')
-		await this.getSkillFixture().registerCurrentSkill({
-			name: `Watching skill views`,
-		})
-
-		await this.getViewFixture().createViewController({
-			nameKebab: 'root',
-			namePascal: 'Root',
-		})
-
-		await this.Action('view', 'sync').execute({})
-
-		await this.Service('build').build()
-
-		const watchAction = this.Action('view', 'watch') as WatchAction
-		const results = await watchAction.execute({ shouldReturnImmediately: true })
-
-		assert.isFalsy(results.errors)
-
-		let pid = watchAction.getPid()
-
-		while (!pid) {
-			await this.wait(100)
-			pid = watchAction.getPid()
-		}
-
-		await results.meta?.bootPromise
-
-		await this.assertProcessRunning(pid)
-
-		await watchAction.kill()
-
-		await this.wait(500)
-
-		await assert.doesThrowAsync(() => this.assertProcessRunning(pid as number))
-	}
-
-	private static async assertProcessRunning(pid: number) {
-		await new Promise((resolve, reject) => {
-			ps.lookup({ pid }, (err: any, results: any) => {
-				if (err || results.length !== 1) {
-					reject('boot process not running')
-				}
-
-				resolve(results)
-			})
-		})
-	}
-
-	private static async emitFileChangeEvent() {
-		const emitter = this.emitter
-
-		await emitter.emit('watcher.did-detect-change', {
-			changes: [
-				{
-					schemaId: 'generatedFile',
-					version: 'v2020_07_22',
-					values: {
-						action: 'updated',
-						name: 'Cool name!',
-						path: '/',
-					},
-				},
-			],
-		})
+		assert.isTrue(wasHit)
 	}
 }

package/src/features/AbstractAction.ts

@@ -39,7 +39,7 @@ export default abstract class AbstractAction<S extends Schema = Schema>
 	public abstract invocationMessage: string
 
 	protected parent: AbstractFeature
-	protected featureInstaller: FeatureInstaller
+	protected features: FeatureInstaller
 	protected cwd: string
 	protected templates: Templates
 	protected ui: GraphicsInterface
@@ -57,7 +57,7 @@ export default abstract class AbstractAction<S extends Schema = Schema>
 		this.parent = options.parent
 		this.storeFactory = options.storeFactory
 		this.serviceFactory = options.serviceFactory
-		this.featureInstaller = options.featureInstaller
+		this.features = options.featureInstaller
 		this.ui = options.ui
 		this.writerFactory = options.writerFactory
 		this.apiClientFactory = options.apiClientFactory
@@ -96,11 +96,11 @@ export default abstract class AbstractAction<S extends Schema = Schema>
 	}
 
 	protected getFeature<C extends FeatureCode>(code: C) {
-		return this.featureInstaller.getFeature(code)
+		return this.features.getFeature(code)
 	}
 
 	protected getFeatureCodes(): FeatureCode[] {
-		return this.featureInstaller.getAllCodes()
+		return this.features.getAllCodes()
 	}
 
 	protected validateAndNormalizeOptions(options: SchemaPartialValues<S>) {

package/src/features/dependencies/actions/AddAction.ts

@@ -64,7 +64,7 @@ export default class DeployAction extends AbstractAction<OptionsSchema> {
 		})
 
 		const summaryLines = [`Added "${skill.name}" as a dependency!`]
-		const isEventInstalled = await this.featureInstaller.isInstalled('event')
+		const isEventInstalled = await this.features.isInstalled('event')
 		if (isEventInstalled) {
 			summaryLines.push(
 				'You will need to run `spruce sync.events` before accessing any new events.'

package/src/features/deploy/actions/HerokuAction.ts

@@ -295,7 +295,7 @@ export default class DeployAction extends AbstractAction<OptionsSchema> {
 	private async runTests() {
 		let results: FeatureActionResponse = {}
 
-		const isTestInstalled = await this.featureInstaller.isInstalled('test')
+		const isTestInstalled = await this.features.isInstalled('test')
 
 		if (isTestInstalled) {
 			try {
@@ -321,7 +321,7 @@ export default class DeployAction extends AbstractAction<OptionsSchema> {
 	private async buildAndLint() {
 		let results: FeatureActionResponse = {}
 
-		const isSkillInstalled = await this.featureInstaller.isInstalled('skill')
+		const isSkillInstalled = await this.features.isInstalled('skill')
 
 		if (isSkillInstalled) {
 			try {

package/src/features/node/actions/UpdateDependenciesAction.ts

@@ -52,7 +52,7 @@ export default class UpdateDependenciesAction extends AbstractAction<OptionsSche
 	}
 
 	private async installDependencies() {
-		const features = await this.featureInstaller.getInstalledFeatures()
+		const features = await this.features.getInstalledFeatures()
 
 		const pkg = this.Service('pkg')
 		const pkgContents = pkg.readPackage()

package/src/features/node/actions/UpgradeAction.ts

@@ -55,7 +55,7 @@ export default class UpgradeAction extends AbstractAction<OptionsSchema> {
 	}
 
 	private async updateScripts(options: { shouldConfirm: boolean }) {
-		const features = await this.featureInstaller.getInstalledFeatures()
+		const features = await this.features.getInstalledFeatures()
 
 		let scripts: Record<string, any> = {}
 

package/src/features/test/actions/CreateAction.ts

@@ -142,13 +142,11 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
 		match: ParentClassCandidate
 	) {
 		if (match.featureCode) {
-			const isInstalled = await this.featureInstaller.isInstalled(
-				match.featureCode
-			)
+			const isInstalled = await this.features.isInstalled(match.featureCode)
 
 			if (!isInstalled) {
 				this.ui.startLoading(`Installing ${match.name}...`)
-				await this.featureInstaller.install({
+				await this.features.install({
 					features: [{ code: match.featureCode as any }],
 				})
 				this.ui.stopLoading()

package/src/features/view/actions/WatchAction.ts

@@ -1,112 +1,58 @@
-import { buildSchema, SchemaValues } from '@sprucelabs/schema'
+import { buildSchema } from '@sprucelabs/schema'
 import { heartwoodRemoteUtil } from '@sprucelabs/spruce-event-utils'
-import { GraphicsTextEffect } from '@sprucelabs/spruce-skill-utils'
 import AbstractAction from '../../AbstractAction'
 import { FeatureActionResponse } from '../../features.types'
-import { BootMeta } from '../../skill/actions/BootAction'
-import WatchFeature from '../../watch/WatchFeature'
 
 const optionsSchema = buildSchema({
 	id: 'watchViewsOptions',
 	description: 'Watch for view changes and preview them in real time.',
-	fields: {
-		shouldReturnImmediately: {
-			type: 'boolean',
-			hint: "For testing so we don't wait until the process is killed to get the results.",
-		},
-	},
+	fields: {},
 })
 
 type OptionsSchema = typeof optionsSchema
-type Options = SchemaValues<OptionsSchema>
 
 export default class WatchAction extends AbstractAction<OptionsSchema> {
 	public commandAliases = ['watch.views']
 	public optionsSchema: OptionsSchema = optionsSchema
 	public invocationMessage = 'Watching views... 🤩'
-	private resolve?: () => void
-	private bootControls?: BootMeta
 	private skillName!: string
-	private bootMessage!: string
-	private watchFeature!: WatchFeature
-
-	public async execute(options?: Options): Promise<FeatureActionResponse> {
-		const { shouldReturnImmediately } = this.validateAndNormalizeOptions(
-			options ?? {}
-		)
-
-		this.watchFeature = this.featureInstaller.getFeature('watch')
-		await this.watchFeature.startWatching({ delay: 2000 })
 
+	public async execute(): Promise<FeatureActionResponse> {
 		const skill = await this.Store('skill').loadCurrentSkill()
-
 		this.skillName = skill.name
-		this.bootControls = await this.boot()
-
-		await this.emitter.on('watcher.did-detect-change', async () => {
-			this.bootControls?.kill()
-			this.bootControls = await this.boot(
-				'Changes detected, rebooting skill...'
-			)
-		})
-
-		if (!shouldReturnImmediately) {
-			await new Promise((resolve) => {
-				//@ts-ignore
-				this.resolve = resolve
-			})
 
-			await this.watchFeature.stopWatching()
-			this.bootControls?.kill()
-		}
+		this.resetUi()
+		const commands = this.Service('command')
+		await commands.execute(
+			'ENABLED_SKILL_FEATURES=view,event SHOULD_REGISTER_EVENTS_AND_LISTENERS=false SHOULD_WATCH_VIEWS=true MAXIMUM_LOG_PREFIXES_LENGTH=0 yarn boot',
+			{
+				onData: (data) => {
+					const line = this.popLastLine(data)
+					this.ui.startLoading(line)
+				},
+			}
+		)
 
 		return {
 			summaryLines: [`Done watching...`],
-			meta: {
-				bootPromise: this.bootControls.bootPromise,
-			},
 		}
 	}
 
+	private popLastLine(data: string) {
+		const line = data
+			.trim()
+			.split('\n')
+			.filter((s) => !!s)
+			.pop()
+
+		return line && line.length > 0 ? line.trim() : 'Waiting for changes'
+	}
+
 	private getPreviewUrl() {
 		const remote = this.Service('remote').getRemote() as any
 		return heartwoodRemoteUtil.buildUrl(remote) + '/#views/heartwood.watch'
 	}
 
-	private async boot(bootMessage = 'Booting skill...') {
-		this.bootMessage = bootMessage
-		this.resetUi()
-
-		const results = await this.Action('skill', 'boot').execute({
-			shouldReturnImmediately: true,
-			onData: (msg: string) => {
-				if (!msg.includes('node build/index') && !msg.includes('yarn run')) {
-					this.ui.stopLoading()
-					this.ui.renderLine(msg.trim())
-					this.ui.startLoading(this.bootMessage)
-				}
-			},
-			onError: (msg: string) => {
-				if (!msg.includes('No license field')) {
-					this.ui.stopLoading()
-					this.ui.renderLine(msg, [GraphicsTextEffect.Red])
-					this.ui.startLoading()
-				}
-			},
-		})
-
-		results.meta?.bootPromise?.then(() => {
-			this.bootMessage = 'Skill booted. Waiting for changes...'
-			this.ui.startLoading(this.bootMessage)
-		})
-
-		if (results.errors) {
-			throw results.errors[0]
-		}
-
-		return results.meta as BootMeta
-	}
-
 	private resetUi() {
 		this.ui.clear()
 		this.ui.renderHero('Heartwood')
@@ -119,16 +65,6 @@ export default class WatchAction extends AbstractAction<OptionsSchema> {
 		])
 		this.ui.renderDivider()
 		this.ui.renderLine('')
-		this.ui.startLoading(this.bootMessage)
-	}
-
-	public async kill() {
-		await this.watchFeature.stopWatching()
-		this.bootControls?.kill()
-		this.resolve?.()
-	}
-
-	public getPid() {
-		return this.bootControls?.pid
+		this.ui.startLoading('Watching for changes')
 	}
 }

package/src/services/CommandService.ts

@@ -9,13 +9,6 @@ import SpruceError from '../errors/SpruceError'
 
 process.setMaxListeners(100)
 
-interface MockResponse {
-	code: number
-	stdout?: string
-	stderr?: string
-	callback?: (executable: string, args: any[]) => void
-}
-
 export default class CommandService {
 	public cwd: string
 	private activeChildProcess: ChildProcess | undefined
@@ -195,3 +188,10 @@ export default class CommandService {
 		this.mockResponses = []
 	}
 }
+
+interface MockResponse {
+	code: number
+	stdout?: string
+	stderr?: string
+	callback?: (executable: string, args: any[]) => void
+}