@sprucelabs/spruce-cli 14.28.6 → 14.29.1

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

@@ -1,5 +1,6 @@
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test'
+import LintService from '../../services/LintService'
 import AbstractSkillTest from '../../tests/AbstractSkillTest'
 import testUtil from '../../tests/utilities/test.utility'
 
@@ -32,6 +33,7 @@ export default class TestingDataStoresTest extends AbstractSkillTest {
 
 	@test()
 	protected static async letsYouSelectAbstractStoreTest() {
+		LintService.enableLinting()
 		this.cli.getFeature('store').isInstalled = async () => true
 
 		const promise = this.Action('test', 'create').execute({

package/src/__tests__/behavioral/eventContract/PullingMercuryEventContract.test.ts

@@ -11,6 +11,7 @@ export default class GeneratingMercuryEventContractTest extends AbstractCliTest
 	protected static async beforeEach() {
 		await super.beforeEach()
 		this.cli = await this.Cli()
+		diskUtil.writeFile(this.resolvePath('package.json'), '{}')
 	}
 
 	@test()

package/src/__tests__/behavioral/events/CreatingAListener.test.ts

@@ -52,18 +52,21 @@ export default class CreatingAListenerTest extends AbstractEventTest {
 	}
 
 	@test()
-	protected static async createsValidListener() {
-		const cli = await this.installEventFeature('events')
+	protected static async generatesMapFile() {
+		const { results } = await this.installEventsAndCreateListener()
 
-		const version = 'v2020_01_01'
+		const match = testUtil.assertFileByNameInGeneratedFiles(
+			`listeners.ts`,
+			results.files
+		)
 
-		const results = await this.Action('event', 'listen').execute({
-			namespace: 'skill',
-			eventName: 'will-boot',
-			version,
-		})
+		await this.Service('typeChecker').check(match)
+	}
 
-		assert.isFalsy(results.errors)
+	@test()
+	protected static async createsValidListener() {
+		const { version, results, cli } =
+			await this.installEventsAndCreateListener()
 
 		const match = testUtil.assertFileByNameInGeneratedFiles(
 			`will-boot.${version}.listener.ts`,
@@ -76,6 +79,7 @@ export default class CreatingAListenerTest extends AbstractEventTest {
 
 		const health = await cli.checkHealth()
 
+		assert.isFalsy(health?.event?.errors)
 		assert.isTruthy(health.skill)
 
 		assert.isUndefined(health.skill.errors)
@@ -261,6 +265,21 @@ export default class CreatingAListenerTest extends AbstractEventTest {
 		)
 	}
 
+	private static async installEventsAndCreateListener() {
+		const cli = await this.installEventFeature('events')
+
+		const version = 'v2020_01_01'
+
+		const results = await this.Action('event', 'listen').execute({
+			namespace: 'skill',
+			eventName: 'will-boot',
+			version,
+		})
+
+		assert.isFalsy(results.errors)
+		return { version, results, cli }
+	}
+
 	private static async setupSkillsInstallAtOrgRegisterEventContractAndGenerateListener(
 		eventSignature: EventSignature
 	) {

package/src/__tests__/behavioral/events/KeepingListenersInSync.test.ts

@@ -0,0 +1,47 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert } from '@sprucelabs/test'
+import { FeatureActionResponse } from '../../../features/features.types'
+import AbstractEventTest from '../../../tests/AbstractEventTest'
+import testUtil from '../../../tests/utilities/test.utility'
+
+export default class KeepingListenersInSyncTest extends AbstractEventTest {
+	@test()
+	protected static async hasSyncAction() {
+		assert.isFunction(this.Action('event', 'sync.listeners').execute)
+	}
+
+	@test()
+	protected static async deletingAListener() {
+		await this.FeatureFixture().installCachedFeatures('events')
+
+		await this.createBootListener('did-boot')
+		const results = await this.createBootListener('will-boot')
+
+		this.deleteLastFile(results)
+
+		const syncResults = await this.Action('event', 'sync.listeners').execute({})
+
+		const listenerMap = testUtil.assertFileByNameInGeneratedFiles(
+			'listeners.ts',
+			syncResults.files
+		)
+
+		await this.Service('typeChecker').check(listenerMap)
+	}
+
+	private static deleteLastFile(results: FeatureActionResponse) {
+		const path = results.files?.pop()?.path
+		assert.isString(path)
+
+		diskUtil.deleteFile(path)
+	}
+
+	private static async createBootListener(name: 'will-boot' | 'did-boot') {
+		const results = await this.Action('event', 'listen').execute({
+			namespace: 'skill',
+			eventName: name,
+		})
+		assert.isFalsy(results.errors)
+		return results
+	}
+}

package/src/__tests__/behavioral/events/SkillEmitsBootEvents.test.ts

@@ -1,8 +1,14 @@
 import { test, assert } from '@sprucelabs/test'
 import { errorAssertUtil } from '@sprucelabs/test-utils'
+import LintService from '../../../services/LintService'
 import AbstractEventTest from '../../../tests/AbstractEventTest'
 
 export default class SkillEmitsBootEventsTest extends AbstractEventTest {
+	protected static async beforeEach() {
+		await super.beforeEach()
+		LintService.enableLinting()
+	}
+
 	@test()
 	protected static async skillEmitsWillBootEvents() {
 		await this.installEventFeature('events')

package/src/__tests__/behavioral/skill/UpgradingWithListeners.test.ts

@@ -0,0 +1,59 @@
+import { eventResponseUtil } from '@sprucelabs/spruce-event-utils'
+import { test, assert } from '@sprucelabs/test'
+import SpruceError from '../../../errors/SpruceError'
+import { FeatureCode } from '../../../features/features.types'
+import CommandService from '../../../services/CommandService'
+import AbstractCliTest from '../../../tests/AbstractCliTest'
+
+export default class UpgradingWithListeners extends AbstractCliTest {
+	@test('should sync listeners when installed', 'events', true)
+	@test('should not sync listeners when not installed', 'skills', false)
+	@test(
+		'should not sync listeners when creating node when not installed',
+		'testsInNodeModule',
+		false,
+		'create'
+	)
+	@test(
+		'should not sync listeners when creating node when installed',
+		'events',
+		false,
+		'create'
+	)
+	protected static async upgradingSyncsListeners(
+		featureCode: FeatureCode,
+		shouldHit: boolean,
+		actionCode = 'upgrade'
+	) {
+		await this.FeatureFixture().installCachedFeatures(featureCode)
+
+		CommandService.setMockResponse(new RegExp(/yarn/), {
+			code: 0,
+		})
+
+		let wasHit = false
+
+		await this.getEmitter().on(
+			'feature.will-execute',
+			async ({ featureCode, actionCode }) => {
+				if (featureCode === 'event' && actionCode === 'sync.listeners') {
+					wasHit = true
+				}
+			}
+		)
+
+		const results = await this.getEmitter().emit('feature.will-execute', {
+			featureCode: 'node',
+			actionCode,
+		})
+
+		const { errors } = eventResponseUtil.getAllResponsePayloadsAndErrors(
+			results,
+			SpruceError
+		)
+
+		assert.isFalsy(errors)
+
+		assert.isEqual(wasHit, shouldHit)
+	}
+}

package/src/__tests__/behavioral/stores/CreatingADataStore.test.ts

@@ -47,6 +47,7 @@ export default class CreatingDataStoresTest extends AbstractSkillTest {
 	protected static async generatesAMapFile() {
 		const file = this.resolveHashSprucePath('stores', 'stores.ts')
 		assert.isTrue(diskUtil.doesFileExist(file))
+		await this.Service('typeChecker').check(file)
 	}
 
 	@test()

package/src/__tests__/behavioral/stores/KeepingDataStoresInSync.test.ts

@@ -1,6 +1,7 @@
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test'
 import { errorAssertUtil } from '@sprucelabs/test-utils'
+import { FeatureActionResponse } from '../../../features/features.types'
 import AbstractSkillTest from '../../../tests/AbstractSkillTest'
 import testUtil from '../../../tests/utilities/test.utility'
 
@@ -29,10 +30,6 @@ export default class KeepingDataStoresInSyncTest extends AbstractSkillTest {
 		assert.isLength(results.files, 0)
 	}
 
-	private static async syncStores() {
-		return this.Action('store', 'sync').execute({})
-	}
-
 	@test()
 	protected static async badFileReturnsError() {
 		diskUtil.writeFile(this.badStoreDest, 'throw new Error("Cheese!")')
@@ -48,19 +45,51 @@ export default class KeepingDataStoresInSyncTest extends AbstractSkillTest {
 
 	@test()
 	protected static async generatesValidTypeFile() {
-		await this.Action('store', 'create').execute({
+		const results = await this.Action('store', 'create').execute({
 			nameReadable: 'Bid',
 			nameReadablePlural: 'Bids',
 			namePascal: 'Bid',
 		})
 
+		await this.validateFiles(results)
+	}
+
+	@test()
+	protected static async fileIsValidAfterSync() {
 		const results = await this.syncStores()
 
+		await this.validateFiles(results)
+	}
+
+	@test()
+	protected static async canAddSecondStore() {
+		const results = await this.Action('store', 'create').execute({
+			nameReadable: 'Person',
+			nameReadablePlural: 'People',
+			namePascal: 'Person',
+		})
+
+		await this.validateFiles(results)
+	}
+
+	private static async validateFiles(results: FeatureActionResponse) {
 		const typesFile = testUtil.assertFileByNameInGeneratedFiles(
 			'stores.types.ts',
 			results.files
 		)
 
-		await this.Service('typeChecker').check(typesFile)
+		const mapFile = testUtil.assertFileByNameInGeneratedFiles(
+			'stores.ts',
+			results.files
+		)
+
+		await Promise.all([
+			this.Service('typeChecker').check(typesFile),
+			this.Service('typeChecker').check(mapFile),
+		])
+	}
+
+	private static async syncStores() {
+		return this.Action('store', 'sync').execute({})
 	}
 }

package/src/__tests__/behavioral/tests/CreatingATest.test.ts

@@ -1,4 +1,5 @@
 import { test, assert } from '@sprucelabs/test'
+import LintService from '../../../services/LintService'
 import AbstractTestTest from '../../../tests/AbstractTestTest'
 import testUtil from '../../../tests/utilities/test.utility'
 
@@ -30,6 +31,7 @@ export default class CreatingBehavioralTestsTest extends AbstractTestTest {
 		'AbstractStoreTest (requires install)'
 	)
 	protected static async canCreateBehavioralTest(testName: string) {
+		LintService.enableLinting()
 		await this.installTests()
 		const promise = this.Action('test', 'create').execute({
 			type: 'behavioral',

package/src/__tests__/behavioral/views/TestingViewControllers.test.ts

@@ -1,11 +1,17 @@
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test'
+import LintService from '../../../services/LintService'
 import AbstractSkillTest from '../../../tests/AbstractSkillTest'
 import testUtil from '../../../tests/utilities/test.utility'
 
 export default class TestingViewControllersTest extends AbstractSkillTest {
 	protected static skillCacheKey = 'viewsWithTests'
 
+	protected static async beforeEach() {
+		await super.beforeEach()
+		LintService.enableLinting()
+	}
+
 	@test()
 	protected static async showsNotInstalled() {
 		const viewFeature = this.cli.getFeature('view')

package/src/__tests__/implementation/AuthService.test.ts

@@ -70,11 +70,13 @@ export default class AuthServiceTest extends AbstractCliTest {
 
 	@test()
 	protected static getCurrentSkillReturnsNull() {
+		this.writePackageJson()
 		assert.isNull(this.auth.getCurrentSkill())
 	}
 
 	@test()
 	protected static canSetCurrentSkill() {
+		this.writePackageJson()
 		const skill = {
 			id: '123467aaoeuaoeu',
 			apiKey: 'taco',
@@ -86,4 +88,8 @@ export default class AuthServiceTest extends AbstractCliTest {
 
 		assert.isEqualDeep(this.auth.getCurrentSkill(), skill)
 	}
+
+	private static writePackageJson() {
+		diskUtil.writeFile(this.resolvePath('package.json'), '{}')
+	}
 }

package/src/__tests__/implementation/EventStore.test.ts

@@ -29,6 +29,7 @@ export default class EventStoreTest extends AbstractEventTest {
 	public static async beforeEach() {
 		await super.beforeEach()
 		this.createAction = this.Action<CreateAction>('event', 'create')
+		diskUtil.writeFile(this.resolvePath('package.json'), '{}')
 	}
 
 	@test()

package/src/__tests__/implementation/LintService.test.ts

@@ -0,0 +1,34 @@
+import { test, assert } from '@sprucelabs/test'
+import CommandService from '../../services/CommandService'
+import LintService from '../../services/LintService'
+import AbstractCliTest from '../../tests/AbstractCliTest'
+
+export default class LintServiceTest extends AbstractCliTest {
+	@test()
+	protected static async throwsWhenLintReturnsMessage() {
+		LintService.enableLinting()
+
+		await this.FeatureFixture().installCachedFeatures('skills')
+
+		CommandService.setMockResponse(/node/, {
+			code: 0,
+			stdout: `[{"filePath":"/Users/taylorromero/Development/SpruceLabs/spruce-appointments-skill/src/.spruce/stores/stores.types.ts","messages":[{"fatal":false,"severity":1,"message":"File ignored by default.  Use a negated ignore pattern (like \\"--ignore-pattern '!<relative/path/to/filename>'\\") to override."}],"errorCount":1,"warningCount":0,"fixableErrorCount":0,"fixableWarningCount":0,"usedDeprecatedRules":[]}]\n`,
+		})
+
+		await assert.doesThrowAsync(() => this.Service('lint').fix('./go'))
+	}
+
+	@test()
+	protected static async worksWhenNoMessagesReturned() {
+		LintService.enableLinting()
+
+		await this.FeatureFixture().installCachedFeatures('skills')
+
+		CommandService.setMockResponse(/node/, {
+			code: 0,
+			stdout: `[{"filePath":"/Users/taylorromero/Development/SpruceLabs/spruce-appointments-skill/src/.spruce/stores/stores.types.ts","messages":[{"fatal":false,"severity":1,"message":"File ignored by default.  Use a negated ignore pattern (like \\"--ignore-pattern '!<relative/path/to/filename>'\\") to override."}],"errorCount":0,"warningCount":1,"fixableErrorCount":0,"fixableWarningCount":0,"usedDeprecatedRules":[]}]\n`,
+		})
+
+		await this.Service('lint').fix('./go')
+	}
+}

package/src/__tests__/implementation/StoreFeature.test.ts

@@ -0,0 +1,40 @@
+import { test, assert } from '@sprucelabs/test'
+import CommandService from '../../services/CommandService'
+import AbstractCliTest from '../../tests/AbstractCliTest'
+
+export default class StoreFeatureTest extends AbstractCliTest {
+	@test()
+	protected static async syncsOnWillExecute() {
+		await this.FeatureFixture().installCachedFeatures('stores')
+
+		CommandService.setMockResponse(/yarn/, {
+			code: 0,
+		})
+
+		let hitCount = 0
+		const emitter = this.getEmitter()
+		await emitter.on(
+			'feature.will-execute',
+			async ({ featureCode, actionCode }) => {
+				if (featureCode === 'store' && actionCode === 'sync') {
+					hitCount++
+				}
+			}
+		)
+
+		await emitter.emit('feature.will-execute', {
+			featureCode: 'node',
+			actionCode: 'upgrade',
+		})
+
+		assert.isEqual(hitCount, 1)
+
+		await emitter.emit('feature.did-execute', {
+			featureCode: 'node',
+			actionCode: 'upgrade',
+			results: {},
+		})
+
+		assert.isEqual(hitCount, 1)
+	}
+}

package/src/errors/SpruceError.ts

@@ -68,12 +68,16 @@ export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
 				break
 
 			case 'LINT_FAILED':
-				message = `Lint failed on pattern ${options.pattern}.`
+				message = options.friendlyMessage
 
-				if (options.originalError) {
-					message += `\n\nOriginal error:${
-						options.originalError.stack ?? options.originalError.message
-					}`
+				if (!message) {
+					message = `Lint failed on pattern ${options.pattern}.`
+
+					if (options.originalError) {
+						message += `\n\nOriginal error:${
+							options.originalError.stack ?? options.originalError.message
+						}`
+					}
 				}
 
 				break

package/src/features/event/EventFeature.ts

@@ -3,6 +3,7 @@ import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import syncEventActionSchema from '#spruce/schemas/spruceCli/v2020_07_22/syncEventOptions.schema'
 import TerminalInterface from '../../interfaces/TerminalInterface'
 import { FileDescription } from '../../types/cli.types'
+import actionUtil from '../../utilities/action.utility'
 import AbstractFeature, {
 	FeatureDependency,
 	FeatureOptions,
@@ -73,6 +74,11 @@ export default class EventFeature extends AbstractFeature {
 
 	public async afterPackageInstall() {
 		diskUtil.createDir(diskUtil.resolvePath(this.cwd, 'src', 'events'))
+		const isSkillInstalled = await this.featureInstaller.isInstalled('skill')
+		if (isSkillInstalled) {
+			return await this.Action('event', 'sync.listeners').execute({})
+		}
+
 		return {}
 	}
 
@@ -82,19 +88,21 @@ export default class EventFeature extends AbstractFeature {
 	}): Promise<FeatureActionResponse> {
 		const { featureCode, actionCode } = payload
 
+		let results: FeatureActionResponse = {}
+
 		if (!this.initiatingAction) {
 			EventStore.clearCache()
 			const combined = this.combineCodes(featureCode, actionCode)
 			this.initiatingAction = combined
 		}
 
-		const isInstalled = await this.featureInstaller.isInstalled('event')
-
 		if (featureCode === 'node' || featureCode === 'upgrade') {
 			const settings = this.Service('eventSettings')
 			settings.clearListenerCache()
 		}
 
+		const isInstalled = await this.featureInstaller.isInstalled('event')
+
 		if (
 			isInstalled &&
 			(featureCode === 'event' ||
@@ -102,10 +110,19 @@ export default class EventFeature extends AbstractFeature {
 				actionCode === 'login') &&
 			actionCode !== 'setRemote'
 		) {
-			return this.appendRemoteToResultsOrPrompt()
+			const remoteResults = await this.appendRemoteToResultsOrPrompt()
+
+			results = actionUtil.mergeActionResults(results, remoteResults)
 		}
 
-		return {}
+		if (featureCode === 'node' && actionCode === 'upgrade' && isInstalled) {
+			const syncResults = await this.Action('event', 'sync.listeners').execute(
+				{}
+			)
+			results = actionUtil.mergeActionResults(results, syncResults)
+		}
+
+		return results
 	}
 
 	private async handleDidExecute(payload: {

package/src/features/event/actions/ListenAction.ts

@@ -151,8 +151,8 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 					templateItems.responsePayloadSchemaTemplateItem
 			}
 
-			const generator = this.Writer('event')
-			const results = await generator.writeListener(resolvedDestination, {
+			const writer = this.Writer('event')
+			response.files = await writer.writeListener(resolvedDestination, {
 				...normalizedOptions,
 				version: resolvedVersion,
 				eventName,
@@ -168,7 +168,9 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				schemaTypesLookupDir: resolvedSchemaTypesLookupDir,
 			})
 
-			response.files = results
+			const syncResults = await this.syncListeners()
+
+			response = actionUtil.mergeActionResults(syncResults, response)
 
 			if (isSkillEvent) {
 				const syncOptions = normalizeSchemaValues(
@@ -191,6 +193,10 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 		}
 	}
 
+	private async syncListeners() {
+		return this.Action('event', 'sync.listeners').execute({})
+	}
+
 	private async collectEvent(
 		contracts: EventContract[],
 		namespace: string

package/src/features/event/actions/SyncListenersAction.ts

@@ -0,0 +1,38 @@
+import { buildSchema } from '@sprucelabs/schema'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import AbstractAction from '../../AbstractAction'
+import ListenerTemplateItemBuilder from '../builders/ListenerTemplateItemBuilder'
+
+const syncListenersOptionScheam = buildSchema({
+	id: 'syncListenersOptions',
+	fields: {},
+})
+
+type OptionsSchema = typeof syncListenersOptionScheam
+
+export default class SyncListenerAction extends AbstractAction<OptionsSchema> {
+	public optionsSchema: OptionsSchema = syncListenersOptionScheam
+	public invocationMessage = 'Syncing listeners... 🎧'
+	public commandAliases = ['sync.listeners']
+
+	public async execute() {
+		const listeners = await this.Store('listener').loadListeners()
+		const builder = new ListenerTemplateItemBuilder()
+
+		const templateItems = builder.buildTemplateItems({
+			listeners,
+			cwd: this.cwd,
+		})
+
+		const files = await this.Writer('event').writeListenerMap(
+			diskUtil.resolveHashSprucePath(this.cwd, 'events'),
+			{
+				listeners: templateItems,
+			}
+		)
+
+		return {
+			files,
+		}
+	}
+}

package/src/features/event/builders/ListenerTemplateItemBuilder.ts

@@ -0,0 +1,27 @@
+import pathUtil from 'path'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { ListenerTemplateItem } from '@sprucelabs/spruce-templates'
+import { Listener } from '../stores/ListenerStore'
+
+export default class ListenerTemplateItemBuilder {
+	public buildTemplateItems(options: { listeners: Listener[]; cwd: string }) {
+		const destination = diskUtil.resolveHashSprucePath(
+			options.cwd,
+			'events',
+			'listeners.ts'
+		)
+
+		const listeners: ListenerTemplateItem[] = []
+
+		for (const match of options.listeners) {
+			listeners.push({
+				...match,
+				path: pathUtil
+					.relative(pathUtil.dirname(destination), match.path)
+					.replace('.ts', ''),
+			})
+		}
+
+		return listeners
+	}
+}

package/src/features/event/stores/EventStore.ts

@@ -76,7 +76,7 @@ export default class EventStore extends AbstractStore {
 		try {
 			contracts = await this.fetchRemoteContracts(namespaces)
 		} catch (err: any) {
-			const error = err.options.responseErrors[0]
+			const error = err.options.responseErrors?.[0] ?? err
 			throw error
 		}
 

package/src/features/event/stores/ListenerStore.ts

@@ -0,0 +1,32 @@
+import { eventDiskUtil } from '@sprucelabs/spruce-event-utils'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { ListenerTemplateItem } from '@sprucelabs/spruce-templates'
+import globby from 'globby'
+import AbstractStore from '../../../stores/AbstractStore'
+
+export type Listener = ListenerTemplateItem & {
+	path: string
+}
+
+export default class ListenerStore extends AbstractStore {
+	public name = 'listener'
+
+	public async loadListeners() {
+		const matches = await globby(
+			diskUtil.resolvePath(this.cwd, 'src', 'listeners', '**/*.listener.ts')
+		)
+
+		const listeners: Listener[] = []
+
+		for (const match of matches) {
+			const listener = eventDiskUtil.splitPathToListener(match)
+
+			listeners.push({
+				...listener,
+				path: match,
+			})
+		}
+
+		return listeners
+	}
+}