@sprucelabs/spruce-cli 14.28.5 → 14.29.0

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/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/cli.ts

@@ -45,7 +45,7 @@ import { argParserUtil } from './utilities/argParser.utility'
 import WriterFactory from './writers/WriterFactory'
 
 interface HealthOptions {
-	isRunningLocally?: boolean
+	shouldRunOnSourceFiles?: boolean
 }
 
 export interface CliInterface extends MercuryEventEmitter<GlobalEventContract> {
@@ -153,7 +153,7 @@ export default class Cli implements CliInterface {
 		try {
 			const commandService = this.serviceFactory.Service(this.cwd, 'command')
 			const command =
-				options?.isRunningLocally === false
+				options?.shouldRunOnSourceFiles === false
 					? 'yarn health'
 					: 'yarn health.local'
 			const results = await commandService.execute(command)

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
+	}
+}

package/src/features/event/writers/EventWriter.ts

@@ -9,6 +9,7 @@ import {
 import {
 	EventContractTemplateItem,
 	EventListenerOptions,
+	ListenerTemplateItem,
 } from '@sprucelabs/spruce-templates'
 import { GeneratedFile } from '../../../types/cli.types'
 import AbstractWriter from '../../../writers/AbstractWriter'
@@ -182,6 +183,24 @@ export default class EventWriter extends AbstractWriter {
 		return results
 	}
 
+	public async writeListenerMap(
+		destinationDir: string,
+		options: {
+			listeners: ListenerTemplateItem[]
+		}
+	) {
+		const destination = diskUtil.resolvePath(destinationDir, 'listeners.ts')
+		const contents = this.templates.listeners({ listeners: options.listeners })
+
+		const results = await this.writeFileIfChangedMixinResults(
+			destination,
+			contents,
+			'An object holding all your data stores for easy import!'
+		)
+
+		return results
+	}
+
 	public async writeEvent(
 		destinationDir: string,
 		options: {

package/src/features/node/NodeFeature.ts

@@ -64,9 +64,6 @@ export default class NodeFeature<
 			this.ui.startLoading('Cleaning build...')
 			await this.Service('command').execute('yarn clean.build')
 
-			this.ui.startLoading('Applying lint rules to all files...')
-			await this.Service('command').execute('yarn fix.lint')
-
 			this.ui.startLoading('Rebuilding...')
 			await this.Service('command').execute('yarn build.dev')
 

package/src/features/skill/SkillFeature.ts

@@ -196,7 +196,7 @@ export default class SkillFeature<
 
 		if (isInstalled && featureCode === 'node' && actionCode === 'upgrade') {
 			const updater = new Updater(this, this.emitter)
-			const files = await updater.updateFiles(upgradeOptions as any)
+			const files = await updater.updateFiles(upgradeOptions ?? {})
 			return {
 				files,
 			}

package/src/features/skill/stores/SkillStore.ts

@@ -71,6 +71,7 @@ export default class SkillStore extends AbstractStore {
 
 		if (currentSkill) {
 			const client = await this.connectToApi({ shouldAuthAsCurrentSkill: true })
+
 			const response = await client.emit('get-skill::v2020_12_25', {
 				target: {
 					skillId: currentSkill.id,
@@ -85,6 +86,7 @@ export default class SkillStore extends AbstractStore {
 				isRegistered: true,
 				apiKey: currentSkill.apiKey,
 			}
+
 			return SkillStore.currentSkill as CurrentSkill
 		}
 
@@ -133,12 +135,11 @@ export default class SkillStore extends AbstractStore {
 		if (isRegistered) {
 			throw new SpruceError({
 				code: 'GENERIC',
-				friendlyMessage: `You can't change the namespace of a skill that is registered.`,
+				friendlyMessage: `You can't set the namespace of a skill that is registered.`,
 			})
 		}
 
-		const pkg = this.Service('pkg')
-		pkg.set({ path: 'skill.namespace', value: namesUtil.toKebab(namespace) })
+		this.Service('auth').updateCurrentSkillNamespace(namespace)
 	}
 
 	private getEventNamespaceForNotRegistered() {

package/src/features/store/StoreFeature.ts

@@ -37,8 +37,8 @@ export default class StoreFeature extends AbstractFeature {
 			this.registerAbstractTestClassHandler.bind(this)
 		)
 		void this.emitter.on(
-			'feature.did-execute',
-			this.didExecuterHandler.bind(this)
+			'feature.will-execute',
+			this.handleWillExecute.bind(this)
 		)
 	}
 
@@ -55,7 +55,7 @@ export default class StoreFeature extends AbstractFeature {
 		}
 	}
 
-	private async didExecuterHandler(payload: {
+	private async handleWillExecute(payload: {
 		featureCode: string
 		actionCode: string
 	}) {

package/src/features/store/actions/SyncAction.ts

@@ -31,7 +31,8 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 				const builder = new StoreTemplateItemBuilder()
 				const templateItems = builder.buildTemplateItems(stores, destination)
 
-				files = await this.Writer('store').writeTypes(destination, {
+				const writer = this.Writer('store')
+				files = await writer.writeTypesAndMap(destination, {
 					stores: templateItems,
 				})
 			}

package/src/features/store/writers/StoreWriter.ts

@@ -59,6 +59,18 @@ export default class StoreWriter extends AbstractWriter {
 		return results
 	}
 
+	public async writeTypesAndMap(
+		destination: string,
+		options: { stores: StoreTemplateItem[] }
+	) {
+		const [types, map] = await Promise.all([
+			this.writeTypes(destination, options),
+			this.writeMap(destination, options),
+		])
+
+		return [...types, ...map]
+	}
+
 	public async writeTypes(
 		destination: string,
 		options: { stores: StoreTemplateItem[] }
@@ -77,4 +89,22 @@ export default class StoreWriter extends AbstractWriter {
 
 		return files
 	}
+
+	public async writeMap(
+		destination: string,
+		options: { stores: StoreTemplateItem[] }
+	) {
+		const file = diskUtil.resolvePath(destination, 'stores.ts')
+		const mapContent = this.templates.stores(options)
+
+		const files = this.writeFileIfChangedMixinResults(
+			file,
+			mapContent,
+			'A reference to all your data stores for easy inclusion.'
+		)
+
+		await this.lint(file)
+
+		return files
+	}
 }

package/src/services/AuthService.ts

@@ -1,7 +1,8 @@
 import { SpruceSchemas } from '@sprucelabs/mercury-types'
 import { normalizeSchemaValues, validateSchemaValues } from '@sprucelabs/schema'
-import { EnvService } from '@sprucelabs/spruce-skill-utils'
+import { EnvService, namesUtil } from '@sprucelabs/spruce-skill-utils'
 import personWithTokenSchema from '#spruce/schemas/spruceCli/v2020_07_22/personWithToken.schema'
+import PkgService from './PkgService'
 
 type PersonWithToken = SpruceSchemas.SpruceCli.v2020_07_22.PersonWithToken
 
@@ -16,9 +17,11 @@ const LOGGED_IN_PERSON_KEY = 'LOGGED_IN_PERSON'
 
 export default class AuthService {
 	private env: EnvService
+	private pkg: PkgService
 
-	public constructor(envService: EnvService) {
+	public constructor(envService: EnvService, pkgService: PkgService) {
 		this.env = envService
+		this.pkg = pkgService
 	}
 
 	public getLoggedInPerson(): PersonWithToken | null {
@@ -51,7 +54,7 @@ export default class AuthService {
 		const id = this.env.get('SKILL_ID') as string
 		const apiKey = this.env.get('SKILL_API_KEY') as string
 		const name = this.env.get('SKILL_NAME') as string
-		const slug = this.env.get('SKILL_SLUG') as string
+		const slug = this.pkg.get('skill.namespace') as string
 
 		if (id && apiKey) {
 			return {
@@ -69,13 +72,20 @@ export default class AuthService {
 		this.env.unset('SKILL_ID')
 		this.env.unset('SKILL_API_KEY')
 		this.env.unset('SKILL_NAME')
-		this.env.unset('SKILL_SLUG')
 	}
 
 	public updateCurrentSkill(skill: SkillAuth) {
 		this.env.set('SKILL_ID', skill.id)
 		this.env.set('SKILL_API_KEY', skill.apiKey)
 		this.env.set('SKILL_NAME', skill.name)
-		this.env.set('SKILL_SLUG', skill.slug)
+
+		this.updateCurrentSkillNamespace(skill.slug)
+	}
+
+	public updateCurrentSkillNamespace(namespace: string) {
+		this.pkg.set({
+			path: 'skill.namespace',
+			value: namesUtil.toKebab(namespace),
+		})
 	}
 }

package/src/services/LintService.ts

@@ -1,4 +1,5 @@
 import { SchemaError } from '@sprucelabs/schema'
+// import { ESLint } from 'eslint'
 import fs from 'fs-extra'
 import SpruceError from '../errors/SpruceError'
 import CommandService from './CommandService'
@@ -7,9 +8,19 @@ export default class LintService {
 	public cwd: string
 	private command: CommandService
 
-	public constructor(cwd: string, command: CommandService) {
+	private static isLintingEnabled = true
+
+	public static disableLinting() {
+		this.isLintingEnabled = false
+	}
+
+	public static enableLinting() {
+		this.isLintingEnabled = true
+	}
+
+	public constructor(cwd: string, commandService: CommandService) {
 		this.cwd = cwd
-		this.command = command
+		this.command = commandService
 	}
 
 	public fix = async (pattern: string): Promise<string[]> => {
@@ -20,9 +31,15 @@ export default class LintService {
 			})
 		}
 
+		if (!LintService.isLintingEnabled) {
+			return []
+		}
+
 		let fixedFiles: any = {}
 		const fixedPaths: string[] = []
 		try {
+			// const cli = new ESLint({ fix: true, cwd: this.cwd, cache: true })
+			// fixedFiles = await cli.lintFiles([pattern])
 			const script = `"(async function lint() { try { const { ESLint } = require('eslint'); const cli = new ESLint({ fix: true, cwd: '${this.cwd}', }); const result = await cli.lintFiles(['${pattern}']); console.log(JSON.stringify(result)); } catch (err) { console.log(err.toString()); }})()"`
 
 			const { stdout } = await this.command.execute('node', {

package/src/services/ServiceFactory.ts

@@ -39,7 +39,10 @@ export default class ServiceFactory {
 	public Service<S extends Service>(cwd: string, type: S): ServiceMap[S] {
 		switch (type) {
 			case 'auth':
-				return new AuthService(new EnvService(cwd)) as ServiceMap[S]
+				return new AuthService(
+					new EnvService(cwd),
+					new PkgService(cwd)
+				) as ServiceMap[S]
 			case 'pkg':
 				return new PkgService(cwd) as ServiceMap[S]
 			case 'env':
@@ -52,7 +55,10 @@ export default class ServiceFactory {
 					command: new CommandService(cwd),
 				}) as ServiceMap[S]
 			case 'lint':
-				return new LintService(cwd, new CommandService(cwd)) as ServiceMap[S]
+				return new LintService(
+					cwd,
+					this.Service(cwd, 'command')
+				) as ServiceMap[S]
 			case 'command': {
 				return new CommandService(cwd) as ServiceMap[S]
 			}
@@ -74,7 +80,7 @@ export default class ServiceFactory {
 				const commandService = new CommandService(cwd)
 				return new BuildService(
 					commandService,
-					new LintService(cwd, commandService)
+					new LintService(cwd, this.Service(cwd, 'command'))
 				) as ServiceMap[S]
 			}
 			case 'eventSettings':

package/src/stores/StoreFactory.ts

@@ -1,5 +1,6 @@
 import ConversationStore from '../features/conversation/stores/ConversationStore'
 import EventStore from '../features/event/stores/EventStore'
+import ListenerStore from '../features/event/stores/ListenerStore'
 import OnboardingStore from '../features/onboard/stores/OnboardingStore'
 import OrganizationStore from '../features/organization/stores/OrganizationStore'
 import SchemaStore from '../features/schema/stores/SchemaStore'
@@ -20,6 +21,7 @@ export interface StoreMap {
 	conversation: ConversationStore
 	store: StoreStore
 	view: ViewStore
+	listener: ListenerStore
 }
 
 export type StoreCode = keyof StoreMap
@@ -33,6 +35,7 @@ const storeMap = {
 	conversation: ConversationStore,
 	store: StoreStore,
 	view: ViewStore,
+	listener: ListenerStore,
 }
 
 export interface StoreFactoryMethodOptions {

package/src/tests/AbstractCliTest.ts

@@ -23,6 +23,7 @@ import CliGlobalEmitter, { GlobalEmitter } from '../GlobalEmitter'
 import SpyInterface from '../interfaces/SpyInterface'
 import CommandService from '../services/CommandService'
 import ImportService from '../services/ImportService'
+import LintService from '../services/LintService'
 import ServiceFactory, { Service, ServiceMap } from '../services/ServiceFactory'
 import StoreFactory, {
 	StoreCode,
@@ -32,7 +33,6 @@ import StoreFactory, {
 } from '../stores/StoreFactory'
 import { ApiClientFactoryOptions } from '../types/apiClient.types'
 import { OptionOverrides } from '../types/cli.types'
-import AbstractWriter from '../writers/AbstractWriter'
 import WriterFactory from '../writers/WriterFactory'
 import FeatureFixture, {
 	FeatureFixtureOptions,
@@ -66,7 +66,7 @@ export default abstract class AbstractCliTest extends AbstractSpruceTest {
 		await super.beforeAll()
 		await this.cleanTestDirsAndFiles()
 
-		AbstractWriter.disableLinting()
+		LintService.disableLinting()
 
 		ImportService.setCacheDir(diskUtil.createRandomTempDir())
 		ImportService.enableCaching()