@sprucelabs/spruce-cli 14.29.30 → 14.29.31

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

@@ -23,6 +23,8 @@ import AbstractAction from '../../AbstractAction'
 import { FeatureActionResponse } from '../../features.types'
 
 const SKILL_EVENT_NAMESPACE = 'skill'
+const CORE_EVENT_NAMESPACE = 'mercury'
+
 type OptionsSchema =
 	SpruceSchemas.SpruceCli.v2020_07_22.ListenEventOptionsSchema
 export default class ListenAction extends AbstractAction<OptionsSchema> {
@@ -44,28 +46,11 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				eventName,
 				namespace,
 				schemaTypesLookupDir,
-				contractDestinationDir,
 			} = normalizedOptions
 
 			this.ui.startLoading('Loading event contracts...')
 
-			const eventStore = this.Store('event')
-
-			const skill = await this.Store('skill').loadCurrentSkill()
-
-			const namespacesForFetch =
-				namespace && namespace !== 'skill' ? [namespace] : undefined
-
-			const { contracts } = skill.slug
-				? await eventStore.fetchEventContracts({
-						localNamespace: skill.slug,
-						namespaces: namespacesForFetch,
-						didUpdateHandler: (msg: string) => this.ui.startLoading(msg),
-				  })
-				: await eventStore.fetchEventContracts({
-						namespaces: namespacesForFetch,
-						didUpdateHandler: (msg: string) => this.ui.startLoading(msg),
-				  })
+			const contracts = await this.fetchEventContracts(namespace)
 
 			this.ui.stopLoading()
 
@@ -90,6 +75,11 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				eventName = await this.collectEvent(contracts, namespace)
 			}
 
+			const isCoreEvent = namespace === CORE_EVENT_NAMESPACE
+			if (isCoreEvent) {
+				namespace = undefined
+			}
+
 			const fqen = eventNameUtil.join({
 				eventName,
 				eventNamespace: namespace,
@@ -98,22 +88,13 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 
 			let { version } = eventNameUtil.split(fqen)
 
-			const isValidEvent = !!eventChoicesByNamespace[namespace].find(
-				(e) => e.value === eventName || e.value === fqen
+			this.assertIsValidChoice(
+				eventChoicesByNamespace,
+				namespace ?? 'mercury',
+				eventName,
+				fqen
 			)
 
-			if (!isValidEvent) {
-				throw new SchemaError({
-					code: 'INVALID_PARAMETERS',
-					friendlyMessage: `${eventName} is not a valid event . Try: \n\n${eventChoicesByNamespace[
-						namespace
-					]
-						.map((i) => i.value)
-						.join('\n')}`,
-					parameters: ['eventName'],
-				})
-			}
-
 			const resolvedDestination = diskUtil.resolvePath(
 				this.cwd,
 				listenerDestinationDir
@@ -124,11 +105,6 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				resolvedDestination
 			)
 
-			const resolvedSchemaTypesLookupDir = diskUtil.resolvePath(
-				this.cwd,
-				schemaTypesLookupDir
-			)
-
 			const isSkillEvent = namespace !== SKILL_EVENT_NAMESPACE
 
 			let emitPayloadSchemaTemplateItem: SchemaTemplateItem | undefined
@@ -139,7 +115,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				const templateItems = builder.buildEventTemplateItemForName(
 					contracts,
 					eventNameUtil.join({
-						eventNamespace: namespace,
+						eventNamespace: !isCoreEvent ? namespace : undefined,
 						eventName,
 						version: resolvedVersion,
 					})
@@ -151,21 +127,14 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 					templateItems.responsePayloadSchemaTemplateItem
 			}
 
-			const writer = this.Writer('event')
-			response.files = await writer.writeListener(resolvedDestination, {
-				...normalizedOptions,
+			response.files = await this.writeListener({
+				schemaTypesLookupDir,
+				resolvedDestination,
 				version: resolvedVersion,
 				eventName,
-				eventNamespace: namespace,
-				fullyQualifiedEventName: eventNameUtil.join({
-					eventName,
-					eventNamespace: namespace,
-					version: resolvedVersion,
-				}),
+				namespace,
 				emitPayloadSchemaTemplateItem,
-				contractDestinationDir,
 				responsePayloadSchemaTemplateItem,
-				schemaTypesLookupDir: resolvedSchemaTypesLookupDir,
 			})
 
 			const syncResults = await this.syncListeners()
@@ -173,15 +142,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 			response = actionUtil.mergeActionResults(syncResults, response)
 
 			if (isSkillEvent) {
-				const syncOptions = normalizeSchemaValues(
-					syncEventActionSchema,
-					options
-				)
-
-				const syncResults = await this.Action('event', 'sync').execute(
-					syncOptions
-				)
-
+				const syncResults = await this.syncEvents(options)
 				response = actionUtil.mergeActionResults(syncResults, response)
 			}
 
@@ -193,6 +154,98 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 		}
 	}
 
+	private async fetchEventContracts(namespace?: string) {
+		const eventStore = this.Store('event')
+		const skill = await this.Store('skill').loadCurrentSkill()
+
+		const namespacesForFetch =
+			namespace &&
+			namespace !== SKILL_EVENT_NAMESPACE &&
+			namespace !== CORE_EVENT_NAMESPACE
+				? [namespace]
+				: undefined
+
+		const { contracts } = skill.slug
+			? await eventStore.fetchEventContracts({
+					localNamespace: skill.slug,
+					namespaces: namespacesForFetch,
+					didUpdateHandler: (msg: string) => this.ui.startLoading(msg),
+			  })
+			: await eventStore.fetchEventContracts({
+					namespaces: namespacesForFetch,
+					didUpdateHandler: (msg: string) => this.ui.startLoading(msg),
+			  })
+
+		return contracts
+	}
+
+	private async syncEvents(
+		options: SpruceSchemas.SpruceCli.v2020_07_22.ListenEventOptions
+	) {
+		const syncOptions = normalizeSchemaValues(syncEventActionSchema, options)
+
+		const syncResults = await this.Action('event', 'sync').execute(syncOptions)
+		return syncResults
+	}
+
+	private async writeListener(options: {
+		resolvedDestination: string
+		schemaTypesLookupDir: string
+		namespace?: string | undefined
+		eventName: string
+		emitPayloadSchemaTemplateItem: SchemaTemplateItem | undefined
+		version: string
+		responsePayloadSchemaTemplateItem: SchemaTemplateItem | undefined
+	}) {
+		const {
+			resolvedDestination,
+			schemaTypesLookupDir,
+			namespace,
+			eventName,
+			version,
+		} = options
+
+		const resolvedSchemaTypesLookupDir = diskUtil.resolvePath(
+			this.cwd,
+			schemaTypesLookupDir
+		)
+		const writer = this.Writer('event')
+		const files = await writer.writeListener(resolvedDestination, {
+			...options,
+			fullyQualifiedEventName: eventNameUtil.join({
+				eventName,
+				eventNamespace: namespace,
+				version,
+			}),
+			schemaTypesLookupDir: resolvedSchemaTypesLookupDir,
+		})
+
+		return files
+	}
+
+	private assertIsValidChoice(
+		eventChoicesByNamespace: Record<string, SelectChoice[]>,
+		namespace: string,
+		eventName: string | undefined,
+		fqen: string
+	) {
+		const isValidEvent = !!eventChoicesByNamespace[namespace].find(
+			(e) => e.value === eventName || e.value === fqen
+		)
+
+		if (!isValidEvent) {
+			throw new SchemaError({
+				code: 'INVALID_PARAMETERS',
+				friendlyMessage: `${eventName} is not a valid event . Try: \n\n${eventChoicesByNamespace[
+					namespace
+				]
+					.map((i) => i.value)
+					.join('\n')}`,
+				parameters: ['eventName'],
+			})
+		}
+	}
+
 	private async syncListeners() {
 		return this.Action('event', 'sync.listeners').execute({})
 	}

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

@@ -1,9 +1,8 @@
 import pathUtil from 'path'
 import { SchemaTemplateItem } from '@sprucelabs/schema'
-import { eventDiskUtil } from '@sprucelabs/spruce-event-utils'
+import { eventDiskUtil, eventNameUtil } from '@sprucelabs/spruce-event-utils'
 import {
 	diskUtil,
-	namesUtil,
 	DEFAULT_SCHEMA_TYPES_FILENAME,
 } from '@sprucelabs/spruce-skill-utils'
 import {
@@ -129,53 +128,33 @@ export default class EventWriter extends AbstractWriter {
 
 	public async writeListener(
 		destinationDir: string,
-		options: Omit<
-			EventListenerOptions,
-			'nameConst' | 'schemaTypesFile' | 'contractsFile'
-		> & {
-			version: string
+		options: Omit<EventListenerOptions, 'schemaTypesFile'> & {
 			schemaTypesLookupDir: string
-			contractDestinationDir: string
 		}
 	) {
-		const {
-			eventName,
-			eventNamespace,
-			version,
-			schemaTypesLookupDir,
-			contractDestinationDir,
-		} = options
+		const { schemaTypesLookupDir, fullyQualifiedEventName } = options
 
+		const event = eventNameUtil.split(fullyQualifiedEventName)
 		const resolvedDestination = eventDiskUtil.resolveListenerPath(
 			destinationDir,
-			{
-				eventName,
-				eventNamespace,
-				version,
-			}
+			event as any
 		)
 
-		const relativeTypesFile = this.resolveSchemaTypesFile(
+		const relativeTypesFile = this.resolveSchemaTypesFile({
+			namespace: event.eventNamespace,
 			schemaTypesLookupDir,
-			resolvedDestination
-		)
-
-		const contractsFile = pathUtil.join(
-			contractDestinationDir,
-			CONTRACT_FILE_NAME.replace('.ts', '')
-		)
+			resolvedDestination,
+		})
 
 		const listenerContents = this.templates.listener({
 			...options,
-			nameConst: namesUtil.toConst(`${eventNamespace}_${eventName}`),
 			schemaTypesFile: relativeTypesFile,
-			contractsFile,
 		})
 
 		const results = await this.writeFileIfChangedMixinResults(
 			resolvedDestination,
 			listenerContents,
-			`Listener for ${eventNamespace}.${eventName}.`
+			`Listener for ${fullyQualifiedEventName}.`
 		)
 
 		await this.lint(resolvedDestination)
@@ -195,7 +174,7 @@ export default class EventWriter extends AbstractWriter {
 		const results = await this.writeFileIfChangedMixinResults(
 			destination,
 			contents,
-			'An object holding all your data stores for easy import!'
+			'All your listeners imported to one place for your skill to use when booting!'
 		)
 
 		return results
@@ -306,10 +285,17 @@ export default class EventWriter extends AbstractWriter {
 		return files
 	}
 
-	private resolveSchemaTypesFile(
-		schemaTypesLookupDir: string,
+	private resolveSchemaTypesFile(options: {
+		namespace?: string
+		schemaTypesLookupDir: string
 		resolvedDestination: string
-	) {
+	}) {
+		const { schemaTypesLookupDir, resolvedDestination, namespace } = options
+
+		if (!namespace) {
+			return '@sprucelabs/mercury-types'
+		}
+
 		const schemaTypesFile = pathUtil.join(
 			schemaTypesLookupDir,
 			DEFAULT_SCHEMA_TYPES_FILENAME

package/src/interfaces/SpyInterface.ts

@@ -245,7 +245,9 @@ export default class SpyInterface implements GraphicsInterface {
 					this.reset()
 
 					try {
-						assert.fail(`Timed out waiting for input: ${definition.label}`)
+						assert.fail(
+							`Timed out waiting for input with label: '${definition.label}'\n\nConsider passing what you need to Action().execute({ something })`
+						)
 					} catch (err: any) {
 						reject(err)
 					}

package/src/templateItemBuilders/EventTemplateItemBuilder.ts

@@ -88,6 +88,9 @@ export default class EventTemplateItemBuilder {
 		throw new SchemaError({
 			code: 'INVALID_PARAMETERS',
 			parameters: ['fullyQualifiedEventName'],
+			friendlyMessages: [
+				`I could not find any events that match ${fullyQualifiedEventName}.`,
+			],
 		})
 	}