@sprucelabs/spruce-cli 28.2.3 → 29.0.1

package/src/.spruce/errors/errors.types.ts

@@ -48,6 +48,7 @@ import AbstractSpruceError from '@sprucelabs/error'
 
 
 
+
 
 
 export declare namespace SpruceErrors.SpruceCli {
@@ -291,7 +292,7 @@ export declare namespace SpruceErrors.SpruceCli {
 			
 			'fieldName': string
 			
-			'fieldOptions': (Record<string, any>)
+			'fieldOptions': Record<string, any>
 	}
 
 	export interface SchemaTemplateItemBuildingFailedSchema extends SpruceSchema.Schema {
@@ -551,7 +552,7 @@ export declare namespace SpruceErrors.SpruceCli {
 	export interface MercuryResponseError {
 		
 			
-			'responseErrors': (AbstractSpruceError<any>)[]
+			'responseErrors': AbstractSpruceError<any>[]
 	}
 
 	export interface MercuryResponseErrorSchema extends SpruceSchema.Schema {
@@ -949,6 +950,35 @@ export declare namespace SpruceErrors.SpruceCli {
 }
 
 
+export declare namespace SpruceErrors.SpruceCli {
+
+	
+	export interface DirectoryNotGoModule {
+		
+			/** Current Working Directory. */
+			'cwd': string
+	}
+
+	export interface DirectoryNotGoModuleSchema extends SpruceSchema.Schema {
+		id: 'directoryNotGoModule',
+		namespace: 'SpruceCli',
+		name: 'Directory not go module',
+		    fields: {
+		            /** Current Working Directory. */
+		            'cwd': {
+		                label: 'Current Working Directory',
+		                type: 'text',
+		                isRequired: true,
+		                options: undefined
+		            },
+		    }
+	}
+
+	export type DirectoryNotGoModuleEntity = SchemaEntity<SpruceErrors.SpruceCli.DirectoryNotGoModuleSchema>
+
+}
+
+
 export declare namespace SpruceErrors.SpruceCli {
 
 	

package/src/.spruce/errors/options.types.ts

@@ -91,6 +91,9 @@ export interface DockerNotStartedErrorOptions extends SpruceErrors.SpruceCli.Doc
 export interface DirectoryNotSkillErrorOptions extends SpruceErrors.SpruceCli.DirectoryNotSkill, ISpruceErrorOptions {
 	code: 'DIRECTORY_NOT_SKILL'
 }
+export interface DirectoryNotGoModuleErrorOptions extends SpruceErrors.SpruceCli.DirectoryNotGoModule, ISpruceErrorOptions {
+	code: 'DIRECTORY_NOT_GO_MODULE'
+}
 export interface DirectoryEmptyErrorOptions extends SpruceErrors.SpruceCli.DirectoryEmpty, ISpruceErrorOptions {
 	code: 'DIRECTORY_EMPTY'
 }
@@ -134,6 +137,6 @@ export interface ActionCancelledErrorOptions extends SpruceErrors.SpruceCli.Acti
 	code: 'ACTION_CANCELLED'
 }
 
-type ErrorOptions =  | VscodeNotInstalledErrorOptions  | ViewPluginAlreadyExistsErrorOptions  | TransportAlreadyExistsErrorOptions  | ThemeExistsErrorOptions  | TestFailedErrorOptions  | StoreExistsErrorOptions  | SkillViewExistsErrorOptions  | SkillNotRegisteredErrorOptions  | SkillNotFoundErrorOptions  | SchemaTemplateItemBuildingFailedErrorOptions  | SchemaFailedToImportErrorOptions  | SchemaExistsErrorOptions  | NotLoggedInErrorOptions  | NotImplementedErrorOptions  | NoSkillsRegisteredErrorOptions  | NoOrganizationsFoundErrorOptions  | MissingDependenciesErrorOptions  | MercuryResponseErrorErrorOptions  | LintFailedErrorOptions  | InvalidTestDirectoryErrorOptions  | InvalidFeatureCodeErrorOptions  | InvalidEventContractErrorOptions  | InvalidCommandErrorOptions  | GenericErrorOptions  | FileExistsErrorOptions  | FeatureNotInstalledErrorOptions  | FailedToImportErrorOptions  | ExecutingCommandFailedErrorOptions  | DockerNotStartedErrorOptions  | DirectoryNotSkillErrorOptions  | DirectoryEmptyErrorOptions  | DeployFailedErrorOptions  | DependencyExistsErrorOptions  | CreateAutoloaderFailedErrorOptions  | CommandNotImplementedErrorOptions  | CommandBlockedErrorOptions  | CommandAbortedErrorOptions  | CannotPromptInCiErrorOptions  | CacheNotEnabledErrorOptions  | BuildFailedErrorOptions  | BootErrorErrorOptions  | AppControllerAlreadyExistsErrorOptions  | AgentAlreadyRegisteredErrorOptions  | ActionCancelledErrorOptions 
+type ErrorOptions =  | VscodeNotInstalledErrorOptions  | ViewPluginAlreadyExistsErrorOptions  | TransportAlreadyExistsErrorOptions  | ThemeExistsErrorOptions  | TestFailedErrorOptions  | StoreExistsErrorOptions  | SkillViewExistsErrorOptions  | SkillNotRegisteredErrorOptions  | SkillNotFoundErrorOptions  | SchemaTemplateItemBuildingFailedErrorOptions  | SchemaFailedToImportErrorOptions  | SchemaExistsErrorOptions  | NotLoggedInErrorOptions  | NotImplementedErrorOptions  | NoSkillsRegisteredErrorOptions  | NoOrganizationsFoundErrorOptions  | MissingDependenciesErrorOptions  | MercuryResponseErrorErrorOptions  | LintFailedErrorOptions  | InvalidTestDirectoryErrorOptions  | InvalidFeatureCodeErrorOptions  | InvalidEventContractErrorOptions  | InvalidCommandErrorOptions  | GenericErrorOptions  | FileExistsErrorOptions  | FeatureNotInstalledErrorOptions  | FailedToImportErrorOptions  | ExecutingCommandFailedErrorOptions  | DockerNotStartedErrorOptions  | DirectoryNotSkillErrorOptions  | DirectoryNotGoModuleErrorOptions  | DirectoryEmptyErrorOptions  | DeployFailedErrorOptions  | DependencyExistsErrorOptions  | CreateAutoloaderFailedErrorOptions  | CommandNotImplementedErrorOptions  | CommandBlockedErrorOptions  | CommandAbortedErrorOptions  | CannotPromptInCiErrorOptions  | CacheNotEnabledErrorOptions  | BuildFailedErrorOptions  | BootErrorErrorOptions  | AppControllerAlreadyExistsErrorOptions  | AgentAlreadyRegisteredErrorOptions  | ActionCancelledErrorOptions 
 
 export default ErrorOptions

package/src/.spruce/errors/spruceCli/directoryNotGoModule.schema.ts

@@ -0,0 +1,23 @@
+import { SchemaRegistry } from '@sprucelabs/schema'
+import { SpruceErrors } from '../errors.types'
+
+
+
+const directoryNotGoModuleSchema: SpruceErrors.SpruceCli.DirectoryNotGoModuleSchema  = {
+	id: 'directoryNotGoModule',
+	namespace: 'SpruceCli',
+	name: 'Directory not go module',
+	    fields: {
+	            /** Current Working Directory. */
+	            'cwd': {
+	                label: 'Current Working Directory',
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	    }
+}
+
+SchemaRegistry.getInstance().trackSchema(directoryNotGoModuleSchema)
+
+export default directoryNotGoModuleSchema

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

@@ -5,10 +5,36 @@ import MockProgramFactory from '../../tests/MockProgramFactory'
 
 export default class OverridingCommandsInPackageJsonTest extends AbstractSkillTest {
     protected static skillCacheKey = 'schemas'
+    private static originalPackageJson: string
+    private static originalSettingsJson: string
 
-    @test()
-    protected static async runningCommandHonorsOverrides() {
-        this.overrideOptions()
+    protected static async beforeEach() {
+        await super.beforeEach()
+        if (!this.originalPackageJson) {
+            this.originalPackageJson = diskUtil.readFile(
+                this.resolvePath('package.json')
+            )
+            this.originalSettingsJson = diskUtil.readFile(
+                this.resolveHashSprucePath('settings.json')
+            )
+        } else {
+            diskUtil.writeFile(
+                this.resolvePath('package.json'),
+                this.originalPackageJson
+            )
+            diskUtil.writeFile(
+                this.resolveHashSprucePath('settings.json'),
+                this.originalSettingsJson
+            )
+        }
+    }
+
+    @test('running honors overrides in package.json', 'package.json')
+    @test('running honors overrides in settings.json', 'settings.json')
+    protected static async runningCommandHonorsOverrides(
+        override: OverrideFile
+    ) {
+        this.overrideOptions(override)
 
         const cli = await this.FeatureFixture().Cli({
             program: MockProgramFactory.Program(),
@@ -21,9 +47,18 @@ export default class OverridingCommandsInPackageJsonTest extends AbstractSkillTe
         this.assertCoreSchemasDidNotSync()
     }
 
-    @test()
-    protected static async runningCommandHonorsOverridesWhenCommandIsForwarded() {
-        this.overrideOptions()
+    @test(
+        'running honors overrides in package.json when command is forwarded',
+        'package.json'
+    )
+    @test(
+        'running honors overrides in settings.json when command is forwarded',
+        'settings.json'
+    )
+    protected static async runningCommandHonorsOverridesWhenCommandIsForwarded(
+        override: OverrideFile
+    ) {
+        this.overrideOptions(override)
 
         const cli = await this.FeatureFixture().Cli({
             program: MockProgramFactory.Program(),
@@ -49,14 +84,26 @@ export default class OverridingCommandsInPackageJsonTest extends AbstractSkillTe
             'person.schema.ts'
         )
 
-        assert.isFalse(diskUtil.doesFileExist(personPath))
+        assert.isFalse(
+            diskUtil.doesFileExist(personPath),
+            'did not expect to find person.schema.ts'
+        )
     }
 
-    private static overrideOptions() {
-        const pkg = this.Service('pkg')
-        pkg.set({
-            path: ['skill', 'commandOverrides', 'sync.schemas'],
-            value: '--shouldFetchCoreSchemas false',
-        })
+    private static overrideOptions(override: OverrideFile) {
+        if (override === 'settings.json') {
+            const settings = this.Service('settings')
+            settings.set('commandOverrides', {
+                'sync.schemas': '--shouldFetchCoreSchemas false',
+            })
+        } else {
+            const pkg = this.Service('pkg')
+            pkg.set({
+                path: ['skill', 'commandOverrides', 'sync.schemas'],
+                value: '--shouldFetchCoreSchemas false',
+            })
+        }
     }
 }
+
+type OverrideFile = 'package.json' | 'settings.json'

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

@@ -0,0 +1,134 @@
+import { SpruceSchemas } from '@sprucelabs/mercury-types'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import testUtil from '../../../tests/utilities/test.utility'
+import { RegisteredSkill } from '../../../types/cli.types'
+
+export default class EventsWithFeedTemplatesTest extends AbstractSkillTest {
+    protected static skillCacheKey = 'events'
+    private static eventOptionsFile: string
+    private static skill: RegisteredSkill
+
+    @test()
+    protected static async feedIsPassedToRegistration() {
+        this.skill = await this.registerSkill()
+
+        await this.createEvent()
+
+        const feedTemplate: FeedOptions = {
+            template: generateId(),
+        }
+        this.dropIntoEventOptions(`feed: ${JSON.stringify(feedTemplate)},`)
+
+        const signature = await this.syncAndFetchSignature()
+
+        assert.isEqualDeep(
+            signature.feed,
+            feedTemplate,
+            'Feed template should match.'
+        )
+    }
+
+    @test()
+    protected static async canHandleBackticksInAiInstructions() {
+        const aiInstructions = 'Here `there` be dragons'
+        this.dropIntoEventOptions(`aiInstructions: '${aiInstructions}',`)
+
+        const signature = await this.syncAndFetchSignature()
+
+        assert.isEqual(
+            signature.aiInstructions,
+            aiInstructions,
+            'AI instructions should match.'
+        )
+    }
+
+    @test()
+    protected static async canHandleBackticksInDescription() {
+        const description = 'This event `describes` something'
+        this.dropIntoEventOptions(`description: '${description}',`)
+
+        const signature = await this.syncAndFetchSignature()
+
+        assert.isEqual(
+            signature.description,
+            description,
+            'Description should match.'
+        )
+    }
+
+    private static async syncAndFetchSignature() {
+        await this.syncEvents()
+        await this.lintBuildAndBoot()
+        const signature = await this.fetchCreatedEventSignature()
+        return signature
+    }
+
+    private static dropIntoEventOptions(dropIn: string) {
+        const contents = diskUtil.readFile(this.eventOptionsFile)
+        const updated = contents.replace(
+            'isGlobal: false,',
+            `isGlobal: false, ${dropIn}`
+        )
+
+        diskUtil.writeFile(this.eventOptionsFile, updated)
+        return updated
+    }
+
+    private static async fetchCreatedEventSignature() {
+        const client = await this.connectToApi({
+            shouldAuthAsCurrentSkill: true,
+        })
+
+        const [{ contracts }] = await client.emitAndFlattenResponses(
+            'get-event-contracts::v2020_12_25',
+            {
+                target: {
+                    namespaces: [this.skill.slug],
+                },
+            }
+        )
+        const first = contracts[0]
+        const { eventSignatures } = first
+        const fqen = Object.keys(eventSignatures)[0]
+        const signature = eventSignatures[fqen]
+        return signature
+    }
+
+    private static async lintBuildAndBoot() {
+        await this.Service('command').execute('yarn fix.lint')
+        await this.Service('command').execute('yarn build.dev')
+        const boot = await this.Action('skill', 'boot').execute({})
+        assert.isFalsy(boot.errors, 'Should not have boot errors.')
+        boot.meta?.kill()
+    }
+
+    private static async createEvent() {
+        const results = await this.Action('event', 'create').execute({
+            nameReadable: 'a new event',
+            nameKebab: 'my-new-event',
+            nameCamel: 'myNewEvent',
+        })
+
+        assert.isFalsy(results.errors, 'Should not have errors.')
+
+        this.eventOptionsFile = testUtil.assertFileByNameInGeneratedFiles(
+            'event.options.ts',
+            results.files
+        )
+    }
+
+    private static async registerSkill() {
+        return await this.getSkillFixture().registerCurrentSkill({
+            name: 'current skill',
+        })
+    }
+
+    private static async syncEvents() {
+        const syncResults = await this.Action('event', 'sync').execute({})
+        assert.isFalsy(syncResults.errors, 'Should not have sync errors.')
+    }
+}
+
+type FeedOptions = SpruceSchemas.Mercury.v2020_12_25.FeedOptions

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

@@ -198,7 +198,6 @@ export function buildPermissionContract(..._: any[]):any { return _[0] }
 
     private static async assertGlobalEventsAreTyped(eventName: string) {
         const contents = diskUtil.readFile(this.eventContractPath)
-
         assert.doesInclude(contents, `'${eventName}':`)
     }
 

package/src/__tests__/behavioral/features/InstallFeaturesInGo.test.ts

@@ -0,0 +1,17 @@
+import { fake } from '@sprucelabs/spruce-test-fixtures'
+import { test, assert } from '@sprucelabs/test-utils'
+import AbstractCliTest from '../../../tests/AbstractCliTest'
+
+@fake.login()
+export default class InstallFeaturesInGoTest extends AbstractCliTest {
+    protected static async beforeEach(): Promise<void> {
+        await super.beforeEach()
+        await this.go.initGoProject()
+    }
+
+    @test()
+    protected static async schemaFeatureNotInstalledToStart() {
+        const isInstalled = await this.featureInstaller.isInstalled('schema')
+        assert.isFalse(isInstalled, 'Schema feature should not be installed')
+    }
+}

package/src/__tests__/behavioral/organization/CreatingAnOrg.test.ts

@@ -1,8 +1,30 @@
-import { eventResponseUtil } from '@sprucelabs/spruce-event-utils'
-import { test, assert } from '@sprucelabs/test-utils'
+import { MercuryClientFactory } from '@sprucelabs/mercury-client'
+import { Organization } from '@sprucelabs/spruce-core-schemas'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
 import AbstractCliTest from '../../../tests/AbstractCliTest'
+import { CreateOrganizationTargetAndPayload } from '../../support/EventFaker'
 
 export default class CreatingAnOrgTest extends AbstractCliTest {
+    private static organization: Organization
+    private static slug = generateId()
+    private static nameReadable = generateId()
+    private static lastCreateOrgTargetAndPayload: CreateOrganizationTargetAndPayload
+
+    protected static async beforeEach(): Promise<void> {
+        await super.beforeEach()
+
+        MercuryClientFactory.setIsTestMode(true)
+
+        this.organization = this.eventFaker.generateOrganizationValues()
+
+        await this.eventFaker.fakeRequestPin()
+        await this.eventFaker.fakeConfirmPin()
+        await this.eventFaker.fakeCreateOrganization((targetAndPayload) => {
+            this.lastCreateOrgTargetAndPayload = targetAndPayload
+            return this.organization
+        })
+    }
+
     @test()
     protected static async hasCreateAction() {
         await this.Cli()
@@ -11,33 +33,18 @@ export default class CreatingAnOrgTest extends AbstractCliTest {
 
     @test()
     protected static async createsAnOrg() {
-        const slug = `my-org-${new Date().getTime()}`
-
         await this.FeatureFixture().installCachedFeatures('organizations')
         await this.people.loginAsDemoPerson()
 
         const results = await this.Action('organization', 'create').execute({
-            nameReadable: 'My new org',
-            nameKebab: slug,
+            nameReadable: this.nameReadable,
+            nameKebab: this.slug,
         })
 
         assert.isFalsy(results.errors)
-
-        const { organization } = results.meta ?? {}
-
-        assert.isTruthy(organization)
-
-        const client = await this.connectToApi()
-
-        const orgResults = await client.emit('get-organization::v2020_12_25', {
-            target: {
-                organizationId: organization.id,
-            },
+        assert.isEqualDeep(this.lastCreateOrgTargetAndPayload.payload, {
+            name: this.nameReadable,
+            slug: this.slug,
         })
-
-        const { organization: getOrganization } =
-            eventResponseUtil.getFirstResponseOrThrow(orgResults)
-
-        assert.isEqual(getOrganization.slug, slug)
     }
 }

package/src/__tests__/behavioral/schemas/KeepingSchemasInSync.test.ts

@@ -156,7 +156,6 @@ export default class KeepsSchemasInSyncTest extends AbstractSchemaTest {
     @test()
     protected static async shouldGenerateCoreSchemaTypesGeneratesValidFiles() {
         await this.installSchemaFeature('schemas')
-
         await this.copyMockCoreSchemas()
 
         const results = await this.Action('schema', 'sync').execute(
@@ -192,18 +191,16 @@ export default class KeepsSchemasInSyncTest extends AbstractSchemaTest {
     }
 
     @test()
-    protected static async generateCoreSchemaInCoreSchemasModule() {
+    protected static async generateCoreSchemasWithShouldGenerateCoreSchemaTypes() {
         await this.installSchemaFeature('schemas')
-
-        const pkg = this.Service('pkg')
-        pkg.set({ path: 'name', value: '@sprucelabs/spruce-core-schemas' })
-
         await this.copyMockCoreSchemas()
 
-        const results = await this.Action('schema', 'sync').execute({})
+        const results = await this.Action('schema', 'sync').execute({
+            shouldGenerateCoreSchemaTypes: true,
+        })
 
-        assert.isFalsy(results.errors)
-        assert.isTruthy(results.files)
+        assert.isFalsy(results.errors, 'sync schemas had errors')
+        assert.isTruthy(results.files, 'sync should have generated files')
 
         const typesContents = diskUtil.readFile(this.coreSchemaTypesFile)