@sprucelabs/spruce-cli 14.19.3 → 14.21.0

package/src/.spruce/schemas/spruceCli/v2020_07_22/nodeFeatureOptions.schema.ts

@@ -0,0 +1,38 @@
+import { SchemaRegistry } from '@sprucelabs/schema'
+import { SpruceSchemas } from '../../schemas.types'
+
+
+
+const nodeFeatureOptionsSchema: SpruceSchemas.SpruceCli.v2020_07_22.NodeFeatureOptionsSchema  = {
+	id: 'nodeFeatureOptions',
+	version: 'v2020_07_22',
+	namespace: 'SpruceCli',
+	name: 'Create node module',
+	description: 'Create a new node module, to be written in typescript, ready to rock!',
+	    fields: {
+	            /** . */
+	            'destination': {
+	                type: 'text',
+	                defaultValue: ".",
+	                options: undefined
+	            },
+	            /** What's the name of your module?. */
+	            'name': {
+	                label: 'What\'s the name of your module?',
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	            /** How would you describe your module?. */
+	            'description': {
+	                label: 'How would you describe your module?',
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	    }
+}
+
+SchemaRegistry.getInstance().trackSchema(nodeFeatureOptionsSchema)
+
+export default nodeFeatureOptionsSchema

package/src/GlobalEmitter.ts

@@ -149,6 +149,17 @@ export const globalContract = buildEventContract({
 				},
 			}),
 		},
+		'skill.will-write-directory-template': {
+			responsePayloadSchema: buildSchema({
+				id: 'wilLWriteDirectoryTemplateResponsePayload',
+				fields: {
+					filesToSkip: {
+						type: 'text',
+						isArray: true,
+					},
+				},
+			}),
+		},
 	},
 })
 

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

@@ -26,16 +26,10 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
 	}
 
 	protected static async afterEach() {
-		await this.resetSkills()
-
+		await this.getSkillFixture().clearAllSkills()
 		await super.afterEach()
 	}
 
-	private static async resetSkills() {
-		const skillFixture = this.getSkillFixture()
-		await skillFixture.clearAllSkills()
-	}
-
 	@test()
 	protected static async hasSetupSandboxAction() {
 		assert.isFunction(this.Action('sandbox', 'setup').execute)
@@ -58,14 +52,15 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
 	protected static async throwsHelpfulErrorWhenMissingParams() {
 		await this.installAndSetupForSandbox()
 
-		await this.getSkillFixture().registerCurrentSkill({
+		const skill = await this.getSkillFixture().registerCurrentSkill({
 			name: 'My new skill',
 		})
 
-		await this.resetSkills()
+		await this.resetCurrentSkill()
 
 		const env = this.Service('env')
 
+		env.set('SKILL_ID', skill.id)
 		env.unset('SKILL_NAME')
 		env.unset('SKILL_SLUG')
 
@@ -79,21 +74,18 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
 	}
 
 	@test()
-	protected static async doesNotReRegisterIfNotRegisteredFirstTime() {
+	protected static async doesNotTryToRegisterIfNeverRegisteredBefore() {
 		const { client } = await this.installAndSetupForSandbox()
 
+		const expected = await this.getTotalSkills(client)
+
 		const boot = await this.Action('skill', 'boot').execute({ local: true })
 
 		boot.meta?.kill()
 
-		const results2 = await client.emit(`list-skills::v2020_12_25`, {
-			payload: { showMineOnly: true },
-		})
-
-		const { skills: skills2 } =
-			eventResponseUtil.getFirstResponseOrThrow(results2)
+		const actual = await this.getTotalSkills(client)
 
-		assert.isLength(skills2, 0)
+		assert.isEqual(expected, actual)
 	}
 
 	@test()
@@ -123,7 +115,12 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
 			name: 'My new skill',
 		})
 
-		await this.resetSkills()
+		await this.resetCurrentSkill()
+
+		const env = this.Service('env')
+		env.set('SKILL_ID', skill.id)
+		env.set('SKILL_NAME', skill.name)
+		env.set('SKILL_SLUG', skill.slug)
 
 		const boot = await this.Action('skill', 'boot').execute({ local: true })
 
@@ -145,7 +142,7 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
 			name: 'My new skill',
 		})
 
-		await this.resetSkills()
+		await this.resetCurrentSkill()
 
 		const boot = await this.Action('skill', 'boot').execute({ local: true })
 
@@ -164,7 +161,7 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
 			name: 'Conversation test',
 		})
 
-		await this.resetSkills()
+		await this.resetCurrentSkill()
 
 		await this.Action('conversation', 'create').execute({
 			nameReadable: 'book an appointment',
@@ -200,4 +197,34 @@ export default class DeployingToSandboxTest extends AbstractCliTest {
 
 		return skills
 	}
+
+	private static async resetCurrentSkill() {
+		const isInstalled = this.Service('settings').isMarkedAsInstalled('skill')
+		if (!isInstalled) {
+			return
+		}
+
+		const skills = this.Store('skill')
+		const isRegistered = await skills.isCurrentSkillRegistered()
+
+		if (isRegistered) {
+			const skill = await skills.loadCurrentSkill()
+
+			if (skill.id) {
+				await skills.unregisterSkill(skill.id)
+			}
+		}
+	}
+
+	private static async getTotalSkills(client: ApiClient) {
+		const results2 = await client.emit(`list-skills::v2020_12_25`, {
+			payload: { showMineOnly: true },
+		})
+
+		const { skills: skills2 } =
+			eventResponseUtil.getFirstResponseOrThrow(results2)
+
+		const total = skills2.length
+		return total
+	}
 }

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

@@ -64,86 +64,24 @@ export default class RegisteringEventsOnBootTest extends AbstractEventTest {
 		const namespace = namesUtil.toPascal(currentSkill.slug)
 		const sig = eventContractUtil.getSignatureByName(contracts[1], name)
 
-		assert.isEqualDeep(sig, {
+		assert.doesInclude(sig, {
 			emitPayloadSchema: {
 				id: 'didBookAppointmentEmitTargetAndPayload',
 				version,
 				namespace,
-				name: '',
-				fields: {
-					source: {
-						label: 'Source',
-						type: 'schema',
-						options: {
-							schema: {
-								id: 'eventSource',
-								version,
-								namespace,
-								name: '',
-								fields: { proxyToken: { label: 'Proxy token', type: 'id' } },
-							},
-						},
-					},
-					target: {
-						type: 'schema',
-						isRequired: true,
-						options: {
-							schema: {
-								id: 'myFantasticallyAmazingEventEmitTarget',
-								version,
-								namespace,
-								name: '',
-								fields: { tacoId: { type: 'id', isRequired: true } },
-							},
-						},
-					},
-					payload: {
-						type: 'schema',
-						isRequired: true,
-						options: {
-							schema: {
-								id: 'myFantasticallyAmazingEventEmitPayload',
-								version,
-								namespace,
-								name: '',
-								fields: { aRequiredField: { type: 'text', isRequired: true } },
-							},
-						},
-					},
-				},
 			},
 			responsePayloadSchema: {
 				id: 'myFantasticallyAmazingEventResponsePayload',
 				version,
 				namespace,
-				name: '',
-				fields: { anotherRequiredField: { type: 'text', isRequired: true } },
 			},
 			emitPermissionContract: {
 				id: 'myFantasticallyAmazingEventEmitPermissions',
 				name: 'my fantastically amazing event',
-				requireAllPermissions: false,
-				permissions: [
-					{
-						id: 'can-high-five',
-						name: 'Can give high five',
-						description: 'Will this person be allowed to high five?',
-						requireAllStatuses: false,
-					},
-				],
 			},
 			listenPermissionContract: {
 				id: 'myFantasticallyAmazingEventListenPermissions',
 				name: 'my fantastically amazing event',
-				requireAllPermissions: false,
-				permissions: [
-					{
-						id: 'can-high-five',
-						name: 'Can give high five',
-						description: 'Will this person be allowed to high five?',
-						requireAllStatuses: false,
-					},
-				],
 			},
 		})
 	}

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

@@ -20,10 +20,40 @@ const REMOTE_MODULE2 = '@sprucelabs/spruce-templates'
 export default class SettingUpSchemasForModuleDistributionTest extends AbstractSkillTest {
 	protected static skillCacheKey = 'schemas'
 	private static builder1: Schema
-	private static schema1: Schema
+	private static schema1: Schema = {
+		id: 'calendarEvent',
+		version: 'v2021_09_20',
+		namespace: 'TestingSchemas',
+		name: 'Schema imported as module',
+		moduleToImportFromWhenRemote: '@sprucelabs/spruce-calendar-utils',
+		fields: {
+			fieldName1: { label: 'First Field', type: 'text', isRequired: true },
+			fieldName2: {
+				label: 'Second Field',
+				type: 'number',
+				isRequired: true,
+				hint: 'A hint',
+			},
+		},
+	}
 	//@ts-ignore
 	private static schema1b: Schema
-	private static schema2: Schema
+	private static schema2: Schema = {
+		id: 'calendarEvent2',
+		version: 'v2021_09_20',
+		namespace: 'TestingSchemas',
+		name: 'Schema imported as module',
+		moduleToImportFromWhenRemote: '@sprucelabs/spruce-templates',
+		fields: {
+			fieldName1: { label: 'First Field', type: 'text', isRequired: true },
+			fieldName2: {
+				label: 'Second Field',
+				type: 'number',
+				isRequired: true,
+				hint: 'A hint',
+			},
+		},
+	}
 
 	@test(
 		'can specify importFromModuleWhenRemote 1',
@@ -186,7 +216,7 @@ export default class SettingUpSchemasForModuleDistributionTest extends AbstractS
 
 	@test('schemas are imported from one module', ['schema1'])
 	@test('schemas are imported from two modules', ['schema1', 'schema2'])
-	protected static async schemasAreImportedFromModuleWhenSyncedFormDifferentNamespace(
+	protected static async schemasAreImportedFromModuleWhenSyncedFromDifferentNamespace(
 		schemaNames: ('schema1' | 'schema2')[]
 	) {
 		await this.reInstallSkill()
@@ -209,6 +239,7 @@ export default class SettingUpSchemasForModuleDistributionTest extends AbstractS
 		})
 
 		await this.assertCalendarEventSchemaIsImported(results)
+
 		assert.doesThrow(() =>
 			testUtil.assertFileByNameInGeneratedFiles(
 				'schemas.types.ts',
@@ -269,7 +300,7 @@ export default class SettingUpSchemasForModuleDistributionTest extends AbstractS
 		assert.isEqualDeep(localSchema.importsWhenRemote, importsWhenRemote)
 
 		await this.assertCalendarEventSchemaIsImported(results)
-		await this.assertValidTypesFile(results)
+		await this.assertValidTypesFileWhenAddingRemoteImport(results)
 	}
 
 	@test()
@@ -360,6 +391,78 @@ export default class SettingUpSchemasForModuleDistributionTest extends AbstractS
 		)
 	}
 
+	@test()
+	protected static async importedSchemasDoNotShowUpInSchemaTypes() {
+		// await this.reInstallSkill()
+		await this.Store('skill').setCurrentSkillsNamespace('TestingTwo')
+
+		const schema1 = {
+			id: 'fullCompletedForm',
+			namespace: 'Heartwood',
+			version: versionUtil.generateVersion().dirValue,
+			moduleToImportFromWhenRemote: '@sprucelabs/heartwood-view-controllers',
+			importsWhenRemote: ['import * from bananarama'],
+			fields: {
+				id: {
+					type: 'id',
+					isRequired: true,
+				},
+				personId: {
+					type: 'id',
+					isRequired: true,
+				},
+				values: {
+					type: 'raw',
+					isArray: true,
+					options: {
+						valueType: 'Record<string, any>',
+					},
+				},
+			},
+		}
+
+		const schema2 = {
+			id: 'localCompleted',
+			version: versionUtil.generateVersion().dirValue,
+			fields: {
+				id: {
+					type: 'id',
+					isRequired: true,
+				},
+				personId: {
+					type: 'id',
+					isRequired: true,
+				},
+				values: {
+					type: 'raw',
+					isArray: true,
+					options: {
+						valueType: 'Record<string, any>',
+					},
+				},
+			},
+		}
+
+		await this.getEmitter().on('schema.did-fetch-schemas', async () => {
+			return {
+				schemas: [schema1, schema2],
+			}
+		})
+
+		const results = await this.SyncAction().execute({
+			shouldInstallMissingDependencies: true,
+		})
+
+		assert.isFalsy(results.errors)
+
+		const schemaTypesFile = testUtil.assertFileByNameInGeneratedFiles(
+			'schemas.types.ts',
+			results.files
+		)
+
+		await this.Service('typeChecker').check(schemaTypesFile)
+	}
+
 	private static SyncAction() {
 		return this.Action('schema', 'sync', {
 			optionOverrides: {
@@ -429,7 +532,9 @@ export default class SettingUpSchemasForModuleDistributionTest extends AbstractS
 		return templateItems as SchemaTemplateItem[]
 	}
 
-	private static async assertValidTypesFile(results: FeatureActionResponse) {
+	private static async assertValidTypesFileWhenAddingRemoteImport(
+		results: FeatureActionResponse
+	) {
 		const schemaTypesFile = testUtil.assertFileByNameInGeneratedFiles(
 			'schemas.types.ts',
 			results.files

package/src/__tests__/behavioral/errors/CreatingANewErrorBuilder.test.ts

@@ -8,11 +8,6 @@ export default class CreatingANewErrorBuilderTest extends AbstractErrorTest {
 		assert.isFunction(this.Action('error', 'create').execute)
 	}
 
-	protected static async installErrorsAndGetCreateAction() {
-		await this.installErrorFeature('errors')
-		return this.Action('error', 'create')
-	}
-
 	@test()
 	protected static async createsValidBuilder() {
 		const action = await this.installErrorsAndGetCreateAction()
@@ -71,4 +66,9 @@ export default class CreatingANewErrorBuilderTest extends AbstractErrorTest {
 		assert.isTruthy(health.schema?.schemas)
 		assert.isLength(health.schema.schemas, 0)
 	}
+
+	protected static async installErrorsAndGetCreateAction() {
+		await this.installErrorFeature('errors')
+		return this.Action('error', 'create')
+	}
 }

package/src/__tests__/behavioral/{CreatingAnEvent.test.ts → events/CreatingAnEvent.test.ts}

@@ -6,12 +6,12 @@ import {
 } from '@sprucelabs/spruce-skill-utils'
 import { test, assert } from '@sprucelabs/test'
 import { errorAssertUtil } from '@sprucelabs/test-utils'
-import { CliInterface } from '../../cli'
-import { FeatureActionResponse } from '../../features/features.types'
-import AbstractEventTest from '../../tests/AbstractEventTest'
-import testUtil from '../../tests/utilities/test.utility'
-import { RegisteredSkill } from '../../types/cli.types'
-import actionUtil from '../../utilities/action.utility'
+import { CliInterface } from '../../../cli'
+import { FeatureActionResponse } from '../../../features/features.types'
+import AbstractEventTest from '../../../tests/AbstractEventTest'
+import testUtil from '../../../tests/utilities/test.utility'
+import { RegisteredSkill } from '../../../types/cli.types'
+import actionUtil from '../../../utilities/action.utility'
 
 const EVENT_NAME_READABLE = 'my fantastically amazing event'
 const EVENT_NAME = 'my-fantastically-amazing-event'

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

@@ -1,7 +1,7 @@
 import pathUtil from 'path'
+import { coreEventContracts } from '@sprucelabs/mercury-core-events'
 import {
 	buildPermissionContract,
-	coreEventContracts,
 	EventContract,
 	EventSignature,
 	SpruceSchemas,
@@ -497,7 +497,6 @@ export function buildPermissionContract(..._: any[]):any { return _[0] }
 		await this.Service('pkg').uninstall([
 			'@sprucelabs/mercury-types',
 			'@sprucelabs/mercury-client',
-			'@sprucelabs/spruce-event-utils',
 			'@sprucelabs/spruce-event-plugin',
 		])
 		return results

package/src/__tests__/behavioral/node/CreatingANodeModule.test.ts

@@ -0,0 +1,47 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert } from '@sprucelabs/test'
+import CommandService from '../../../services/CommandService'
+import AbstractCliTest from '../../../tests/AbstractCliTest'
+import testUtil from '../../../tests/utilities/test.utility'
+
+export default class CreatingANodeModuleTest extends AbstractCliTest {
+	@test()
+	protected static async hasCreateAction() {
+		assert.isFunction(this.Action('node', 'create').execute)
+	}
+
+	@test()
+	protected static async canCreateAtDestination() {
+		CommandService.setMockResponse(new RegExp(/yarn add/gis), {
+			code: 0,
+		})
+		const promise = this.Action('node', 'create', {
+			shouldAutoHandleDependencies: true,
+		}).execute({ destination: 'new-module' })
+
+		await this.waitForInput()
+		await this.ui.sendInput('new module')
+		await this.ui.sendInput('such a good description!')
+
+		const results = await promise
+
+		testUtil.assertFileByPathInGeneratedFiles(
+			/new-module\/package\.json/gis,
+			results.files
+		)
+
+		assert.isFalse(diskUtil.doesFileExist(this.resolvePath('package.json')))
+	}
+
+	@test()
+	protected static async canBuildNodeModule() {
+		await this.Action('node', 'create', {
+			shouldAutoHandleDependencies: true,
+		}).execute({
+			name: 'build test',
+			description: 'yes!',
+		})
+
+		await this.Service('build').build()
+	}
+}

package/src/__tests__/behavioral/{CreatingASkill.test.ts → skill/CreatingASkill.test.ts}

@@ -1,7 +1,7 @@
 import { test, assert } from '@sprucelabs/test'
-import CommandService from '../../services/CommandService'
-import AbstractCliTest from '../../tests/AbstractCliTest'
-import testUtil from '../../tests/utilities/test.utility'
+import CommandService from '../../../services/CommandService'
+import AbstractCliTest from '../../../tests/AbstractCliTest'
+import testUtil from '../../../tests/utilities/test.utility'
 
 export default class CreatingASkillTest extends AbstractCliTest {
 	protected static async beforeEach() {

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

@@ -145,21 +145,64 @@ export default class UpgradingASkill2Test extends AbstractCliTest {
 			return {}
 		}
 
-		CommandService.setMockResponse('yarn clean.build', {
-			code: 0,
+		this.disableCleanBuildAndYarnAdd()
+
+		await this.Action('node', 'upgrade').execute({})
+
+		assert.isEqual(wasHit, isInstalled)
+	}
+
+	@test()
+	protected static async resetsErrorPluginInSkill() {
+		await this.FeatureFixture().installCachedFeatures('skills')
+
+		const { plugin, expectedContents } = this.destroyErrorPlugin()
+
+		await this.disableCleanBuildAndYarnAdd()
+
+		const promise = this.Action('node', 'upgrade').execute({
+			upgradeMode: 'askForChanged',
 		})
 
-		CommandService.setMockResponse('yarn build.dev', {
-			code: 0,
+		await this.waitForInput()
+		await this.ui.sendInput('overwrite')
+
+		await promise
+
+		const actualContents = diskUtil.readFile(plugin)
+
+		assert.isEqual(actualContents, expectedContents)
+	}
+
+	@test()
+	protected static async resetsErrorPluginWhenErrorInstalled() {
+		await this.FeatureFixture().installCachedFeatures('errors')
+
+		await this.Action('error', 'create').execute({
+			nameReadable: 'Test pass',
+			nameCamel: 'testPass',
 		})
 
-		CommandService.setMockResponse(/yarn.*?add/gis, {
-			code: 0,
+		const { plugin, expectedContents } = this.destroyErrorPlugin()
+
+		this.disableCleanAndBuild()
+
+		const results = await this.Action('node', 'upgrade').execute({
+			upgradeMode: 'askForChanged',
 		})
 
-		await this.Action('node', 'upgrade').execute({})
+		assert.isFalsy(results.errors)
+		const actualContents = diskUtil.readFile(plugin)
 
-		assert.isEqual(wasHit, isInstalled)
+		assert.isEqual(actualContents, expectedContents)
+	}
+
+	private static destroyErrorPlugin() {
+		const plugin = this.resolveHashSprucePath('errors', 'options.types.ts')
+		const expectedContents = diskUtil.readFile(plugin)
+
+		diskUtil.writeFile(plugin, 'waka')
+		return { plugin, expectedContents }
 	}
 
 	private static getViewsPluginPath() {
@@ -169,4 +212,22 @@ export default class UpgradingASkill2Test extends AbstractCliTest {
 	protected static assertViewPluginNotWritten() {
 		assert.isFalse(diskUtil.doesFileExist(this.getViewsPluginPath()))
 	}
+
+	private static disableCleanBuildAndYarnAdd() {
+		this.disableCleanAndBuild()
+
+		CommandService.setMockResponse(/yarn.*?add/gis, {
+			code: 0,
+		})
+	}
+
+	private static disableCleanAndBuild() {
+		CommandService.setMockResponse('yarn clean.build', {
+			code: 0,
+		})
+
+		CommandService.setMockResponse('yarn build.dev', {
+			code: 0,
+		})
+	}
 }

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

@@ -1,4 +1,4 @@
-import { coreEventContracts } from '@sprucelabs/mercury-types'
+import { coreEventContracts } from '@sprucelabs/mercury-core-events'
 import { buildEmitTargetAndPayloadSchema } from '@sprucelabs/spruce-event-utils'
 import AbstractSpruceTest, { test, assert } from '@sprucelabs/test'
 import { eventContractCleanerUtil } from '../../utilities/eventContractCleaner.utility'

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

@@ -1,3 +1,4 @@
+import { coreEventContracts } from '@sprucelabs/mercury-core-events'
 import { EventContract } from '@sprucelabs/mercury-types'
 import { buildSchema, SchemaTemplateItem } from '@sprucelabs/schema'
 import {
@@ -9,7 +10,6 @@ import { EventContractTemplateItem } from '@sprucelabs/spruce-templates'
 import { test, assert } from '@sprucelabs/test'
 import EventTemplateItemBuilder from '../../templateItemBuilders/EventTemplateItemBuilder'
 import AbstractCliTest from '../../tests/AbstractCliTest'
-import coreEventContract from '../support/coreEventContract'
 
 const expectedVersion = versionUtil.generateVersion().dirValue
 
@@ -350,16 +350,14 @@ export default class EventTemplateItemBuilderTest extends AbstractCliTest {
 				{
 					eventSignatures: {
 						'register-events':
-							coreEventContract.eventSignatures['register-events'],
+							coreEventContracts[0].eventSignatures['can-listen::v2020_12_25'],
 					},
 				},
 			],
 			localNamespace: 'testing',
 		})
 
-		const match = schemaTemplateItems.find(
-			(item) => item.id === 'eventContract'
-		)
+		const match = schemaTemplateItems.find((item) => item.id === 'eventSource')
 		assert.isTruthy(match)
 	}
 }