@sprucelabs/spruce-cli 14.22.8 → 14.23.1

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

@@ -0,0 +1,98 @@
+import { test, assert } from '@sprucelabs/test'
+import { errorAssertUtil } from '@sprucelabs/test-utils'
+import AbstractSkillTest from '../../tests/AbstractSkillTest'
+
+export default class ConfiguringDependenciesTest extends AbstractSkillTest {
+	protected static skillCacheKey = 'skills'
+
+	@test()
+	protected static async hasAddDependencyAction() {
+		assert.isFunction(this.Action('dependency', 'add').execute)
+	}
+
+	@test()
+	protected static async errorsWhenPassedBadSlug() {
+		await this.getSkillFixture().registerCurrentSkill({
+			name: 'current skill in adding deps',
+		})
+
+		const results = await this.Action('dependency', 'add').execute({
+			namespace: 'waka-waka',
+		})
+
+		assert.isTruthy(results.errors)
+
+		errorAssertUtil.assertError(results.errors[0], 'SKILL_NOT_FOUND')
+	}
+
+	@test()
+	protected static async succeedsWhenPassedGoodSlug() {
+		const otherSkill = await this.getSkillFixture().seedDemoSkill({
+			name: 'dependent skill',
+		})
+
+		const results = await this.Action('dependency', 'add').execute({
+			namespace: otherSkill.slug,
+		})
+
+		assert.isFalsy(results.errors)
+
+		const settings = this.Service('settings')
+		const dependencies = settings.get('dependencies')
+
+		assert.isEqualDeep(dependencies, [
+			{
+				id: otherSkill.id,
+				namespace: otherSkill.slug,
+			},
+		])
+	}
+
+	@test()
+	protected static async asksToSelectSkillWhenNoSlugPassed() {
+		const otherSkill = await this.getSkillFixture().seedDemoSkill({
+			name: 'dependent skill',
+		})
+
+		const promise = this.Action('dependency', 'add').execute({})
+
+		await this.waitForInput()
+
+		const last = this.ui.lastInvocation()
+
+		assert.doesInclude(last.options.options.choices, {
+			value: otherSkill.slug,
+			label: otherSkill.name,
+		})
+
+		await this.ui.sendInput(otherSkill.slug)
+
+		const results = await promise
+		assert.isFalsy(results.errors)
+
+		const settings = this.Service('settings')
+		const dependencies = settings.get('dependencies')
+
+		assert.isEqualDeep(dependencies[1], {
+			id: otherSkill.id,
+			namespace: otherSkill.slug,
+		})
+	}
+
+	@test()
+	protected static async canAddSkillThatWasCreatedBySomeoneElse() {
+		const skill = await this.getSkillFixture().seedDemoSkill({
+			name: 'global dependency skill',
+		})
+
+		await this.getPersonFixture().loginAsDemoPerson(
+			process.env.DEMO_NUMBER_GLOBAL_EVENTS
+		)
+
+		const results = await this.Action('dependency', 'add').execute({
+			namespace: skill.slug,
+		})
+
+		assert.isFalsy(results.errors)
+	}
+}

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

@@ -8,6 +8,7 @@ import testUtil from '../../tests/utilities/test.utility'
 
 export default class CreatingDataStoresTest extends AbstractSkillTest {
 	protected static skillCacheKey = 'stores'
+
 	@test()
 	protected static async hasCreateStoreAction() {
 		assert.isFunction(this.Action('store', 'create').execute)
@@ -72,6 +73,7 @@ export default class CreatingDataStoresTest extends AbstractSkillTest {
 	@test()
 	protected static async getsSecondStoresBackFromHealthCheck() {
 		const health = await this.cli.checkHealth({ isRunningLocally: true })
+
 		assert.isTruthy(health.store)
 		assert.isFalsy(health.store.errors)
 		assert.isLength(health.store.stores, 2)

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

@@ -0,0 +1,115 @@
+import { test, assert } from '@sprucelabs/test'
+import AbstractSkillTest from '../../tests/AbstractSkillTest'
+
+export default class ManagingDependenciesTest extends AbstractSkillTest {
+	protected static skillCacheKey = 'skills'
+
+	@test()
+	protected static async hasAddDependencyAction() {
+		assert.isFunction(this.Action('dependency', 'manage').execute)
+	}
+
+	@test()
+	protected static async showsSkillsAsCheckboxes() {
+		const skill1 = await this.getSkillFixture().seedDemoSkill({
+			name: 'dependency manage 1',
+		})
+
+		const skill2 = await this.getSkillFixture().seedDemoSkill({
+			name: 'dependency manage 2',
+		})
+
+		void this.Action('dependency', 'manage').execute({})
+
+		await this.waitForInput()
+
+		const last = this.ui.lastInvocation()
+
+		assert.isEqual(last.options.type, 'select')
+
+		assert.doesInclude(last.options.options.choices, {
+			value: skill1.id,
+		})
+
+		assert.doesInclude(last.options.options.choices, {
+			value: skill2.id,
+		})
+
+		this.ui.reset()
+	}
+
+	@test()
+	protected static async selectsExistingDependencies() {
+		const skill1 = await this.getSkillFixture().seedDemoSkill({
+			name: 'dependency manage 3',
+		})
+
+		this.Service('dependency').set([
+			{
+				namespace: skill1.slug,
+				id: skill1.id,
+			},
+		])
+
+		void this.Action('dependency', 'manage').execute({})
+
+		await this.waitForInput()
+
+		const last = this.ui.lastInvocation()
+
+		assert.isEqualDeep(last.options.value, [skill1.id])
+
+		this.ui.reset()
+	}
+
+	@test()
+	protected static async canSelectANewDependencies() {
+		const skill1 = await this.getSkillFixture().seedDemoSkill({
+			name: 'dependency manage 4',
+		})
+
+		const skill2 = await this.getSkillFixture().seedDemoSkill({
+			name: 'dependency manage 5',
+		})
+
+		const promise = this.Action('dependency', 'manage').execute({})
+
+		await this.waitForInput()
+
+		await this.ui.sendInput([skill1.id, skill2.id])
+
+		const dependencies = this.Service('settings').get('dependencies')
+
+		assert.isEqualDeep(dependencies, [
+			{
+				id: skill1.id,
+				namespace: skill1.slug,
+			},
+			{
+				id: skill2.id,
+				namespace: skill2.slug,
+			},
+		])
+
+		await promise
+	}
+
+	@test()
+	protected static async doesNotShowCurrentSkill() {
+		const skill = await this.getSkillFixture().registerCurrentSkill({
+			name: 'current skill in managing deps',
+		})
+
+		void this.Action('dependency', 'manage').execute({})
+
+		await this.waitForInput()
+
+		const last = this.ui.lastInvocation()
+
+		assert.doesNotInclude(last.options.options.choices, {
+			value: skill.id,
+		})
+
+		this.ui.reset()
+	}
+}

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

@@ -0,0 +1,70 @@
+import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert } from '@sprucelabs/test'
+import fsUtil from 'fs-extra'
+import AbstractSkillTest from '../../tests/AbstractSkillTest'
+import { RegisteredSkill } from '../../types/cli.types'
+
+export default class SyncingEventsOnlyFromDependenciesTest extends AbstractSkillTest {
+	protected static skillCacheKey = 'events'
+
+	@test()
+	protected static async doesntSyncAnythingToStart() {
+		const skills = this.getSkillFixture()
+		await skills.registerCurrentSkill({
+			name: 'events in sync skill',
+		})
+		const { skill } = await this.registerGlobalEvent()
+
+		const results = await this.Action('event', 'sync', {}).execute({})
+		assert.isFalsy(results.errors)
+
+		const eventFolder = this.resolveEventFolder(skill)
+
+		assert.isFalse(diskUtil.doesDirExist(eventFolder))
+
+		const contents = fsUtil.readdirSync(this.resolveHashSprucePath('events'))
+
+		assert.isLength(contents, 1)
+	}
+
+	@test()
+	protected static async syncsEventsForSkillsWeveAddedAsDependencies() {
+		const { skill } = await this.registerGlobalEvent()
+
+		this.Service('dependency').add({
+			id: skill.id,
+			namespace: skill.slug,
+		})
+
+		const results = await this.Action('event', 'sync', {}).execute({})
+		assert.isFalsy(results.errors)
+
+		const eventFolder = this.resolveEventFolder(skill)
+
+		assert.isTrue(diskUtil.doesDirExist(eventFolder))
+
+		const contents = fsUtil.readdirSync(this.resolveHashSprucePath('events'))
+
+		assert.isLength(contents, 2)
+	}
+
+	private static async registerGlobalEvent() {
+		const skills = this.getSkillFixture()
+
+		const skill = await skills.seedDemoSkill({ name: 'a temp skill' })
+
+		await skills.registerEventContract(skill, {
+			eventSignatures: {
+				'test-sync::v2021_01_01': {
+					isGlobal: true,
+				},
+			},
+		})
+
+		return { skill }
+	}
+
+	private static resolveEventFolder(skill: RegisteredSkill) {
+		return this.resolveHashSprucePath('events', namesUtil.toCamel(skill.slug))
+	}
+}

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

@@ -277,6 +277,11 @@ export default class CreatingAListenerTest extends AbstractEventTest {
 
 		await skillFixture.registerEventContract(skill2, eventContract)
 
+		this.Service('dependency').add({
+			id: skill2.id,
+			namespace: skill2.slug,
+		})
+
 		const results = await this.Action('event', 'listen').execute({
 			eventNamespace: skill2.slug,
 			eventName: `my-new-event`,

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

@@ -56,6 +56,11 @@ export default class KeepingEventsInSyncTest extends AbstractEventTest {
 
 		const skill2 = await skills.seedDemoSkill({ name: 'a temp skill' })
 
+		await this.Service('dependency').add({
+			id: skill2.id,
+			namespace: skill2.slug,
+		})
+
 		await skills.registerEventContract(skill2, {
 			eventSignatures: {
 				'test-sync::v2021_01_01': {
@@ -154,6 +159,7 @@ export default class KeepingEventsInSyncTest extends AbstractEventTest {
 		await this.syncCoreEventsPretendingToBeMercuryTypes()
 
 		const results = await this.Action('schema', 'sync').execute({})
+
 		await this.assertValidSyncSchemasResults(results, true)
 	}
 

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

@@ -52,6 +52,7 @@ export default class KeepingEventsInSyncTest extends AbstractEventTest {
 		const client = await this.getMercuryFixture().connectToApi({
 			shouldAuthAsCurrentSkill: true,
 		})
+
 		await client.disconnect()
 
 		EventStore.clearCache()
@@ -149,6 +150,11 @@ export default class KeepingEventsInSyncTest extends AbstractEventTest {
 			},
 		})
 
+		await this.Service('dependency').add({
+			id: skill2.id,
+			namespace: skill2.slug,
+		})
+
 		const results = await this.Action('event', 'sync').execute({})
 
 		const match = testUtil.assertFileByNameInGeneratedFiles(
@@ -224,6 +230,17 @@ export default class KeepingEventsInSyncTest extends AbstractEventTest {
 			},
 		})
 
+		await this.Service('dependency').set([
+			{
+				id: skill2.id,
+				namespace: skill2.slug,
+			},
+			{
+				id: skill3.id,
+				namespace: skill3.slug,
+			},
+		])
+
 		const results = await this.Action('event', 'sync').execute({})
 
 		const contract = testUtil.assertFileByNameInGeneratedFiles(
@@ -259,6 +276,11 @@ export default class KeepingEventsInSyncTest extends AbstractEventTest {
 			},
 		})
 
+		await this.Service('dependency').add({
+			id: skill2.id,
+			namespace: skill2.slug,
+		})
+
 		const results = await this.Action('event', 'sync').execute({})
 
 		const contract = testUtil.assertFileByNameInGeneratedFiles(
@@ -414,6 +436,11 @@ export function buildPermissionContract(..._: any[]):any { return _[0] }
 			},
 		})
 
+		await this.Service('dependency').add({
+			id: skill.id,
+			namespace: skill.slug,
+		})
+
 		const results = await this.Action('event', 'sync').execute({})
 
 		return { results, filename }

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

@@ -13,6 +13,10 @@ export default class CreatingAThemeTest extends AbstractSkillTest {
 
 	@test()
 	protected static async syncsEventsFirst() {
+		await this.getSkillFixture().registerCurrentSkill({
+			name: 'current skill in creating a theme',
+		})
+
 		const results = await this.Action('view', 'createTheme').execute({})
 		assert.isFalsy(results.errors)
 

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

@@ -8,4 +8,27 @@ export default class SettingUpViewsTest extends AbstractCliTest {
 		const feature = cli.getFeature('view')
 		assert.isTruthy(feature)
 	}
+
+	@test()
+	protected static async installingViewsAddsHeartwoodAsDependency() {
+		await this.FeatureFixture().installFeatures([
+			{
+				code: 'skill',
+				options: {
+					name: 'testing views',
+					description: 'this too, is a great test!',
+				},
+			},
+			{
+				code: 'view',
+			},
+		])
+
+		await this.getPersonFixture().loginAsDemoPerson()
+
+		const dependencies = this.Service('dependency').get()
+		assert.isLength(dependencies, 1)
+
+		assert.isEqual(dependencies[0].namespace, 'heartwood')
+	}
 }

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

@@ -102,7 +102,8 @@ export default class EventStoreTest extends AbstractEventTest {
 			localNamespace: 'my-skill',
 		})
 
-		assert.isTrue(contracts.length >= 2)
+		assert.isTrue(contracts.length > 2)
+
 		const skillContract = contracts[1]
 
 		const sig = eventContractUtil.getSignatureByName(
@@ -206,9 +207,11 @@ export default class EventStoreTest extends AbstractEventTest {
 
 		const { contracts } = await this.Store('event').fetchEventContracts({
 			localNamespace: skill.slug,
+			namespaces: ['core'],
 		})
 
-		assert.isTrue(contracts.length >= 2)
+		assert.isLength(contracts, 2)
+
 		const name = eventNameUtil.join({
 			eventName: EVENT_NAME,
 			eventNamespace: skill.slug,

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

@@ -314,9 +314,9 @@ export default class EventTemplateItemBuilderTest extends AbstractCliTest {
 		[contractWith2Signatures, contractWith2Signatures],
 		[
 			didBookTemplateItem,
-			willBookTemplateItem,
 			didBookTemplateItem,
 			willBookTemplateItem,
+			willBookTemplateItem,
 		]
 	)
 	@test(
@@ -360,4 +360,23 @@ export default class EventTemplateItemBuilderTest extends AbstractCliTest {
 		const match = schemaTemplateItems.find((item) => item.id === 'eventSource')
 		assert.isTruthy(match)
 	}
+
+	@test()
+	protected static sortsEventsAlphabetically() {
+		const { eventContractTemplateItems } = this.itemBuilder.buildTemplateItems({
+			contracts: [
+				{
+					eventSignatures: {
+						'zebra-cheeta': {},
+						'register-events':
+							coreEventContracts[0].eventSignatures['can-listen::v2020_12_25'],
+					},
+				},
+			],
+			localNamespace: 'testing',
+		})
+
+		assert.isEqual(eventContractTemplateItems[0].nameCamel, 'registerEvents')
+		assert.isEqual(eventContractTemplateItems[1].nameCamel, 'zebraCheeta')
+	}
 }

package/src/errors/SpruceError.ts

@@ -207,7 +207,7 @@ export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
 				break
 
 			case 'SKILL_NOT_FOUND':
-				message = `I couldn't find that skill!`
+				message = options.friendlyMessage ?? `I couldn't find that skill!`
 				break
 
 			case 'NO_SKILLS_REGISTERED':

package/src/features/FeatureInstallerFactory.ts

@@ -8,6 +8,7 @@ import { FeatureOptions } from './AbstractFeature'
 import ActionExecuter from './ActionExecuter'
 import CacheFeature from './cache/CacheFeature'
 import ConversationFeature from './conversation/ConversationFeature'
+import DependencyFeature from './dependencies/DependencyFeature'
 import DeployFeature from './deploy/DeployFeature'
 import ErrorFeature from './error/ErrorFeature'
 import EventFeature from './event/EventFeature'
@@ -48,6 +49,7 @@ export default class FeatureInstallerFactory {
 		ViewFeature,
 		CacheFeature,
 		LogFeature,
+		DependencyFeature,
 	]
 
 	public static readonly featureCodes: FeatureCode[] = [
@@ -70,6 +72,7 @@ export default class FeatureInstallerFactory {
 		'view',
 		'cache',
 		'log',
+		'dependency',
 	]
 
 	public static WithAllFeatures(options: {

package/src/features/dependencies/DependencyFeature.ts

@@ -0,0 +1,27 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
+import { FeatureCode } from '../features.types'
+
+declare module '../../features/features.types' {
+	interface FeatureMap {
+		dependency: DependencyFeature
+	}
+}
+
+export default class DependencyFeature extends AbstractFeature {
+	public description = 'Tell me which skills you depend on.'
+	public code: FeatureCode = 'dependency'
+	public nameReadable = 'Dependencies'
+	public actionsDir = diskUtil.resolvePath(__dirname, 'actions')
+	public dependencies: FeatureDependency[] = [
+		{
+			code: 'skill',
+			isRequired: true,
+		},
+	]
+	public packageDependencies = []
+
+	public async isInstalled() {
+		return this.featureInstaller.isInstalled('skill')
+	}
+}

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

@@ -0,0 +1,63 @@
+import { buildSchema, SchemaValues } from '@sprucelabs/schema'
+import SpruceError from '../../../errors/SpruceError'
+import AbstractAction from '../../AbstractAction'
+import { FeatureActionResponse } from '../../features.types'
+
+const optionsSchema = buildSchema({
+	id: 'addDepnedency',
+	description: 'Add a skill as a dependency.',
+	fields: {
+		namespace: {
+			type: 'id',
+			label: 'Namespace',
+			hint: 'The namespace of the skill you want to add as a dependency.',
+		},
+	},
+})
+
+type OptionsSchema = typeof optionsSchema
+type Options = SchemaValues<OptionsSchema>
+
+export default class DeployAction extends AbstractAction<OptionsSchema> {
+	public optionsSchema = optionsSchema
+	public commandAliases = ['add.dependency']
+	public invocationMessage = 'Adding a dependency... 🔗'
+
+	public async execute(options: Options): Promise<FeatureActionResponse> {
+		let { namespace } = this.validateAndNormalizeOptions(options)
+
+		const skills = await this.Store('skill').fetchAllSkills()
+
+		if (!namespace) {
+			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,
+					})),
+				},
+			})
+		}
+
+		const skill = skills.find((s) => s.slug === namespace)
+
+		if (!skill) {
+			throw new SpruceError({
+				code: 'SKILL_NOT_FOUND',
+				friendlyMessage: `I could not find a skill with the slug of ${namespace}.`,
+			})
+		}
+
+		this.Service('dependency').add({
+			id: skill.id,
+			namespace: skill.slug,
+		})
+
+		return {
+			summaryLines: [`Added "${skill.name}" as a dependency!`],
+		}
+	}
+}