@sprucelabs/spruce-cli 14.26.19 → 14.28.2

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

@@ -107,7 +107,7 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 
 		await this.waitForInput()
 
-		assert.doesNotInclude(this.ui.lastInvocation(), {
+		assert.doesNotInclude(this.ui.getLastInvocation(), {
 			command: 'prompt',
 			options: {
 				type: 'select',
@@ -158,7 +158,7 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 		await this.waitForInput()
 
 		this.ui.reset()
-		const lastQuestion = this.ui.lastInvocation()
+		const lastQuestion = this.ui.getLastInvocation()
 
 		assert.isEqual(lastQuestion.command, 'prompt')
 		assert.doesInclude(
@@ -227,7 +227,7 @@ export default class FeatureCommandExecuterContTest extends AbstractSchemaTest {
 		assert.doesInclude(message, /2 required/gi)
 		assert.doesInclude(message, /1 optional/gi)
 
-		assert.doesInclude(this.ui.lastInvocation(), {
+		assert.doesInclude(this.ui.getLastInvocation(), {
 			command: 'prompt',
 			options: {
 				type: 'select',

package/src/errors/SpruceError.ts

@@ -252,6 +252,10 @@ export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
 				message = `A transport named '${options.name}' already exists!`
 				break
 
+			case 'DEPENDENCY_EXISTS':
+				message = `You already have ${options.namespace} as a dependency!`
+				break
+
 			default:
 				message = super.friendlyMessage()
 		}

package/src/errors/dependencyExists.builder.ts

@@ -0,0 +1,12 @@
+import { buildErrorSchema } from '@sprucelabs/schema'
+
+export default buildErrorSchema({
+	id: 'dependencyExists',
+	name: 'Dependency exists',
+	fields: {
+		namespace: {
+			type: 'text',
+			isRequired: true,
+		},
+	},
+})

package/src/features/AbstractAction.ts

@@ -1,6 +1,5 @@
 import { Schema, SchemaValues, SchemaPartialValues } from '@sprucelabs/schema'
 import { versionUtil } from '@sprucelabs/spruce-skill-utils'
-import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { Templates } from '@sprucelabs/spruce-templates'
 import { GlobalEmitter } from '../GlobalEmitter'
 import ServiceFactory, {
@@ -132,9 +131,7 @@ export default abstract class AbstractAction<S extends Schema = Schema>
 		resolvedDestination: string,
 		fallbackVersion: string
 	) {
-		const versions = diskUtil.doesDirExist(resolvedDestination)
-			? versionUtil.getAllVersions(resolvedDestination)
-			: []
+		const versions = versionUtil.getAllVersions(resolvedDestination)
 		const todaysVersion = versionUtil.generateVersion()
 
 		let version = fallbackVersion

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

@@ -27,17 +27,24 @@ export default class DeployAction extends AbstractAction<OptionsSchema> {
 		let { namespace } = this.validateAndNormalizeOptions(options)
 
 		const skills = await this.Store('skill').fetchAllSkills()
+		const dependencyService = this.Service('dependency')
 
 		if (!namespace) {
+			const dependencies = dependencyService.get().map((d) => d.namespace)
+
+			const choices = skills
+				.filter((s) => dependencies.indexOf(s.slug) === -1)
+				.map((s) => ({
+					value: s.slug,
+					label: s.name,
+				}))
+
 			namespace = await this.ui.prompt({
 				type: 'select',
 				label: 'Which skill would you like to add as a dependency?',
 				isRequired: true,
 				options: {
-					choices: skills.map((s) => ({
-						value: s.slug,
-						label: s.name,
-					})),
+					choices,
 				},
 			})
 		}
@@ -51,7 +58,7 @@ export default class DeployAction extends AbstractAction<OptionsSchema> {
 			})
 		}
 
-		this.Service('dependency').add({
+		dependencyService.add({
 			id: skill.id,
 			namespace: skill.slug,
 		})

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

@@ -68,7 +68,10 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
 
 		try {
 			const destinationDir = diskUtil.resolvePath(this.cwd, 'src', 'events')
-			const resolvedVersion = await this.resolveVersion(version, destinationDir)
+			const resolvedVersion = await this.resolveVersion(
+				version,
+				diskUtil.resolvePath(destinationDir, '**', '*')
+			)
 
 			const files = await this.Writer('event').writeEvent(destinationDir, {
 				nameKebab,

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

@@ -42,7 +42,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				listenerDestinationDir,
 				version: versionOptions,
 				eventName,
-				eventNamespace,
+				namespace,
 				schemaTypesLookupDir,
 				contractDestinationDir,
 			} = normalizedOptions
@@ -53,42 +53,52 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 
 			const skill = await this.Store('skill').loadCurrentSkill()
 
+			const namespacesForFetch =
+				namespace && namespace !== 'skill' ? [namespace] : undefined
+
 			const { contracts } = skill.slug
-				? await eventStore.fetchEventContracts({ localNamespace: skill.slug })
-				: await eventStore.fetchEventContracts()
+				? 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),
+				  })
 
 			this.ui.stopLoading()
 
-			if (!eventNamespace) {
-				eventNamespace = await this.collectNamespace(contracts)
+			if (!namespace) {
+				namespace = await this.collectNamespace(contracts)
 			}
 
 			const { eventChoicesByNamespace } =
 				this.mapContractsToSelectChoices(contracts)
 
-			if (!eventChoicesByNamespace[eventNamespace]) {
+			if (!eventChoicesByNamespace[namespace]) {
 				throw new SchemaError({
 					code: 'INVALID_PARAMETERS',
-					friendlyMessage: `${eventNamespace} is not a valid event namespace. Try: \n\n${Object.keys(
+					friendlyMessage: `${namespace} is not a valid event namespace. Try: \n\n${Object.keys(
 						eventChoicesByNamespace
 					).join('\n')}`,
-					parameters: ['eventNamespace'],
+					parameters: ['namespace'],
 				})
 			}
 
 			if (!eventName) {
-				eventName = await this.collectEvent(contracts, eventNamespace)
+				eventName = await this.collectEvent(contracts, namespace)
 			}
 
 			const fqen = eventNameUtil.join({
 				eventName,
-				eventNamespace,
+				eventNamespace: namespace,
 				version: versionOptions,
 			})
 
 			let { version } = eventNameUtil.split(fqen)
 
-			const isValidEvent = !!eventChoicesByNamespace[eventNamespace].find(
+			const isValidEvent = !!eventChoicesByNamespace[namespace].find(
 				(e) => e.value === eventName || e.value === fqen
 			)
 
@@ -96,7 +106,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				throw new SchemaError({
 					code: 'INVALID_PARAMETERS',
 					friendlyMessage: `${eventName} is not a valid event . Try: \n\n${eventChoicesByNamespace[
-						eventNamespace
+						namespace
 					]
 						.map((i) => i.value)
 						.join('\n')}`,
@@ -119,7 +129,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				schemaTypesLookupDir
 			)
 
-			const isSkillEvent = eventNamespace !== SKILL_EVENT_NAMESPACE
+			const isSkillEvent = namespace !== SKILL_EVENT_NAMESPACE
 
 			let emitPayloadSchemaTemplateItem: SchemaTemplateItem | undefined
 			let responsePayloadSchemaTemplateItem: SchemaTemplateItem | undefined
@@ -129,7 +139,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				const templateItems = builder.buildEventTemplateItemForName(
 					contracts,
 					eventNameUtil.join({
-						eventNamespace,
+						eventNamespace: namespace,
 						eventName,
 						version: resolvedVersion,
 					})
@@ -146,10 +156,10 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 				...normalizedOptions,
 				version: resolvedVersion,
 				eventName,
-				eventNamespace,
+				eventNamespace: namespace,
 				fullyQualifiedEventName: eventNameUtil.join({
 					eventName,
-					eventNamespace,
+					eventNamespace: namespace,
 					version: resolvedVersion,
 				}),
 				emitPayloadSchemaTemplateItem,
@@ -183,11 +193,11 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 
 	private async collectEvent(
 		contracts: EventContract[],
-		eventNamespace: string
+		namespace: string
 	): Promise<string> {
 		const eventChoices: SelectChoice[] =
 			this.mapContractsToSelectChoices(contracts).eventChoicesByNamespace[
-				eventNamespace
+				namespace
 			]
 
 		const eventName = await this.ui.prompt({
@@ -205,7 +215,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 	private async collectNamespace(contracts: EventContract[]): Promise<string> {
 		const { namespaceChoices } = this.mapContractsToSelectChoices(contracts)
 
-		const eventNamespace = await this.ui.prompt({
+		const namespace = await this.ui.prompt({
 			type: 'select',
 			label: 'Select an event namespace',
 			isRequired: true,
@@ -214,7 +224,7 @@ export default class ListenAction extends AbstractAction<OptionsSchema> {
 			},
 		})
 
-		return eventNamespace
+		return namespace
 	}
 
 	private mapContractsToSelectChoices(contracts: EventContract[]) {

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

@@ -72,7 +72,13 @@ export default class EventStore extends AbstractStore {
 
 		didUpdateHandler?.('Pulling remote contracts...')
 
-		const contracts = await this.fetchRemoteContracts(namespaces)
+		let contracts
+		try {
+			contracts = await this.fetchRemoteContracts(namespaces)
+		} catch (err: any) {
+			const error = err.options.responseErrors[0]
+			throw error
+		}
 
 		const localContract =
 			localNamespace &&

package/src/features/node/NodeFeature.ts

@@ -5,7 +5,11 @@ import nodeFeatureOptionsSchema from '#spruce/schemas/spruceCli/v2020_07_22/node
 import { FileDescription, GeneratedFile } from '../../types/cli.types'
 import ScriptUpdater from '../../updaters/ScriptUpdater'
 import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
-import { ActionOptions, FeatureCode } from '../features.types'
+import {
+	ActionOptions,
+	FeatureActionResponse,
+	FeatureCode,
+} from '../features.types'
 import universalDevDependencies from '../universalDevDependencies'
 import universalFileDescriptions from '../universalFileDescriptions'
 import universalScripts from '../universalScripts'
@@ -49,33 +53,36 @@ export default class NodeFeature<
 
 		void this.emitter.on('feature.did-execute', async (payload) => {
 			if (payload.featureCode === 'node' && payload.actionCode === 'upgrade') {
-				try {
-					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')
-
-					return {
-						summaryLines: [
-							'Build cleared.',
-							'Lint rules applied to source.',
-							'Code rebuilt successfully.',
-						],
-					}
-				} catch (err) {
-					return {
-						errors: [err],
-					}
-				}
+				return this.handleUpgrade()
 			}
 
 			return {}
 		})
 	}
+	private async handleUpgrade(): Promise<FeatureActionResponse> {
+		try {
+			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')
+
+			return {
+				summaryLines: [
+					'Build cleared.',
+					'Lint rules applied to source.',
+					'Code rebuilt successfully.',
+				],
+			}
+		} catch (err) {
+			return {
+				errors: [err],
+			}
+		}
+	}
 
 	public async beforePackageInstall(options: Options) {
 		const destination = this.resolveDestination(options)
@@ -94,8 +101,7 @@ export default class NodeFeature<
 
 		await this.Service('command', destination).execute('yarn init -y')
 
-		const nodeWriter = this.Writer('node')
-		const written = await nodeWriter.writeNodeModule(destination)
+		const written = await this.Writer('node').writeNodeModule(destination)
 
 		files.push(...written)
 

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

@@ -24,6 +24,13 @@ export default class UpgradeAction extends AbstractAction<OptionsSchema> {
 		})
 
 		try {
+			const files = await this.Writer('node', {
+				upgradeMode: normalizedOptions.upgradeMode,
+			}).writeNodeModule(this.cwd, {
+				shouldConfirmBeforeWriting: true,
+				shouldWriteIndex: false,
+			})
+
 			InFlightEntertainment.start([
 				"Let's start the upgrade!",
 				'While things are going, see if you can beat 1k points!',
@@ -34,10 +41,10 @@ export default class UpgradeAction extends AbstractAction<OptionsSchema> {
 
 			return actionUtil.mergeActionResults(dependencyResults, {
 				headline: 'Upgrade',
+				files,
 			})
 		} finally {
 			InFlightEntertainment.stop()
-
 			this.ui.renderHero('Upgrade')
 		}
 	}

package/src/features/node/writers/NodeWriter.ts

@@ -1,35 +1,50 @@
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import { DirectoryTemplateCode } from '@sprucelabs/spruce-templates'
-import AbstractWriter, { WriteResults } from '../../../writers/AbstractWriter'
+import { GeneratedFile } from '../../../types/cli.types'
+import AbstractWriter, {
+	WriteDirectoryTemplateOptions,
+	WriteResults,
+} from '../../../writers/AbstractWriter'
 
+export const NODE_FILES_TO_UPGRADE = [
+	'tsconfig.json',
+	'.eslintrc.js',
+	'.eslintignore',
+	'.gitignore',
+	'.nvmrc',
+]
 export default class NodeWriter extends AbstractWriter {
-	public async writeNodeModule(destinationDir: string): Promise<WriteResults> {
-		const contents = '//exports go here\n'
-		const destination = diskUtil.resolvePath(destinationDir, 'src', 'index.ts')
-
-		diskUtil.writeFile(destination, contents)
+	public async writeNodeModule(
+		destinationDir: string,
+		options?: Partial<WriteDirectoryTemplateOptions> & {
+			shouldWriteIndex?: boolean
+		}
+	): Promise<WriteResults> {
+		let files: GeneratedFile[] = []
+		if (options?.shouldWriteIndex !== false) {
+			const contents = '//exports go here\n'
+			const destination = diskUtil.resolvePath(
+				destinationDir,
+				'src',
+				'index.ts'
+			)
+			diskUtil.writeFile(destination, contents)
+			files.push({
+				name: 'src/index.ts',
+				description: 'Placeholder entry file!',
+				action: 'generated',
+				path: destination,
+			})
+		}
 
-		const files = await this.writeDirectoryTemplate({
+		const directoryTemplateFiles = await this.writeDirectoryTemplate({
 			destinationDir,
 			code: DirectoryTemplateCode.Skill,
-			filesToWrite: [
-				'tsconfig.json',
-				'.eslintrc.js',
-				'.eslintignore',
-				'.gitignore',
-				'.nvmrc',
-			],
+			filesToWrite: NODE_FILES_TO_UPGRADE,
 			context: { name: 'ignored', description: 'ignored' },
+			...options,
 		})
 
-		return [
-			{
-				name: 'src/index.ts',
-				description: 'Placeholder entry file!',
-				action: 'generated',
-				path: destination,
-			},
-			...files,
-		]
+		return [...files, ...directoryTemplateFiles]
 	}
 }

package/src/features/sandbox/actions/SetupAction.ts

@@ -18,7 +18,7 @@ export default class SetupAction extends AbstractAction<OptionsSchema> {
 	public async execute(): Promise<FeatureActionResponse> {
 		const createListenerAction = this.Action('event', 'listen')
 		const results = await createListenerAction.execute({
-			eventNamespace: 'skill',
+			namespace: 'skill',
 			eventName: 'will-boot',
 		})
 

package/src/features/skill/updaters/Updater.ts

@@ -3,6 +3,7 @@ import { SpruceSchemas } from '#spruce/schemas/schemas.types'
 import SpruceError from '../../../errors/SpruceError'
 import { GlobalEmitter } from '../../../GlobalEmitter'
 import AbstractFeature from '../../AbstractFeature'
+import { NODE_FILES_TO_UPGRADE } from '../../node/writers/NodeWriter'
 
 type UpgradeOptions = SpruceSchemas.SpruceCli.v2020_07_22.UpgradeSkillOptions
 
@@ -35,7 +36,7 @@ export default class Updater {
 			SpruceError
 		)
 
-		const filesToSkip = ['package.json']
+		const filesToSkip = [...NODE_FILES_TO_UPGRADE, 'package.json']
 
 		for (const payload of payloads) {
 			if (payload.filesToSkip) {

package/src/interfaces/SpyInterface.ts

@@ -80,7 +80,7 @@ export default class SpyInterface implements GraphicsInterface {
 		clearTimeout(this.promptTimeout)
 	}
 
-	public lastInvocation() {
+	public getLastInvocation() {
 		return this.invocations[this.invocations.length - 1]
 	}
 

package/src/schemas/v2020_07_22/listenEventOptions.builder.ts

@@ -7,7 +7,7 @@ export default buildSchema({
 	description: 'Options for event.listen.',
 	fields: {
 		...syncEventOptionsBuilder.fields,
-		eventNamespace: {
+		namespace: {
 			type: 'text',
 			label: 'Namespace',
 		},

package/src/services/DependencyService.ts

@@ -1,4 +1,5 @@
 import { SettingsService } from '@sprucelabs/spruce-skill-utils'
+import SpruceError from '../errors/SpruceError'
 
 interface Dependency {
 	id: string
@@ -16,10 +17,23 @@ export default class DependencyService {
 	}
 
 	public add(dependency: Dependency) {
+		this.assertDependencyDoesNotExist(dependency.namespace)
+
 		const dependencies = this.settings.get('dependencies') ?? []
 		dependencies.push(dependency)
 		this.settings.set('dependencies', dependencies)
 	}
+	private assertDependencyDoesNotExist(namespace: string) {
+		const dependencies = this.get()
+		const match = dependencies.find((d) => d.namespace === namespace)
+
+		if (match) {
+			throw new SpruceError({
+				code: 'DEPENDENCY_EXISTS',
+				namespace,
+			})
+		}
+	}
 
 	public get(): Dependency[] {
 		return this.settings.get('dependencies') ?? []

package/src/tests/AbstractCliTest.ts

@@ -465,7 +465,7 @@ export default abstract class AbstractCliTest extends AbstractSpruceTest {
 	}
 
 	protected static selectOptionBasedOnLabel(label: string) {
-		const last = this.ui.lastInvocation()
+		const last = this.ui.getLastInvocation()
 		assert.doesInclude(last.options.options.choices, {
 			label,
 		})

package/src/tests/utilities/uiAssert.utility.ts

@@ -0,0 +1,45 @@
+import { assert } from '@sprucelabs/test'
+import SpyInterface from '../../interfaces/SpyInterface'
+
+const uiAssertUtil = {
+	async assertRendersSelect(ui: SpyInterface) {
+		await ui.waitForInput()
+
+		const last = ui.getLastInvocation()
+		assert.isTruthy(
+			last.options.options.choices,
+			`I expected a select, I did not find one!`
+		)
+	},
+
+	assertSelectDidNotRenderChoice(
+		ui: SpyInterface,
+		value: string,
+		label: string
+	) {
+		const last = ui.getLastInvocation()
+
+		assert.doesNotInclude(last.options.options.choices, {
+			value,
+			label,
+		})
+	},
+
+	async assertRendersConfirmWriteFile(ui: SpyInterface) {
+		await ui.waitForInput()
+
+		const last = ui.getLastInvocation()
+
+		assert.isEqual(last.options.type, 'select')
+		assert.isEqualDeep(last.options.options.choices, [
+			{
+				label: 'Overwrite',
+				value: 'overwrite',
+			},
+			{ value: 'skip', label: 'Skip' },
+			{ value: 'alwaysSkip', label: 'Always skip' },
+		])
+	},
+}
+
+export default uiAssertUtil

package/src/writers/AbstractWriter.ts

@@ -16,13 +16,22 @@ export type WriteResults = GeneratedFile[]
 export interface WriterOptions {
 	templates: Templates
 	term: GraphicsInterface
-	askBeforeUpdating?: boolean
 	upgradeMode?: UpgradeMode
 	fileDescriptions: FileDescription[]
 	linter?: LintService
 	settings: SettingsService
 }
 
+export interface WriteDirectoryTemplateOptions {
+	destinationDir: string
+	code: DirectoryTemplateCode
+	filesToWrite?: string[]
+	filesToSkip?: string[]
+	context: any
+	shouldConfirmBeforeWriting?: boolean
+	firstFileWriteMessage?: string
+}
+
 export default abstract class AbstractWriter {
 	protected templates: Templates
 	protected ui: GraphicsInterface
@@ -59,15 +68,9 @@ export default abstract class AbstractWriter {
 		this.isLintingEnabled = true
 	}
 
-	protected async writeDirectoryTemplate(options: {
-		destinationDir: string
-		code: DirectoryTemplateCode
-		filesToWrite?: string[]
-		filesToSkip?: string[]
-		context: any
-		shouldConfirmBeforeWriting?: boolean
-		firstFileWriteMessage?: string
-	}) {
+	protected async writeDirectoryTemplate(
+		options: WriteDirectoryTemplateOptions
+	) {
 		const {
 			context,
 			destinationDir,
@@ -93,6 +96,7 @@ export default abstract class AbstractWriter {
 				!filesToWrite || filesToWrite.indexOf(generated.filename) > -1
 			const shouldSkip =
 				filesToSkip && filesToSkip.indexOf(generated.filename) > -1
+
 			if (shouldWrite && !shouldSkip) {
 				results = await this.writeFileIfChangedMixinResults(
 					pathUtil.join(destinationDir, generated.relativePath),
@@ -128,6 +132,7 @@ export default abstract class AbstractWriter {
 
 		if (!diskUtil.doesFileExist(destination)) {
 			let write = true
+
 			if (
 				this.shouldConfirmBeforeWriting &&
 				fileDescription?.confirmPromptOnFirstWrite

package/build/.spruce/events/appointments/didBookAppointments.v2021_06_23.contract.d.ts

@@ -1,10 +0,0 @@
-declare const didBookAppointmentsEventContract: {
-    eventSignatures: {
-        'appointments.did-book-appointments::v2021_06_23': {
-            isGlobal: true;
-            emitPayloadSchema: import("@sprucelabs/mercury-types").SpruceSchemas.Appointments.v2021_06_23.DidBookAppointmentsEmitTargetAndPayloadSchema;
-        };
-    };
-};
-export default didBookAppointmentsEventContract;
-export declare type DidBookAppointmentsEventContract = typeof didBookAppointmentsEventContract;