@sprucelabs/spruce-cli 22.1.13 → 22.3.0

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

@@ -1,30 +1,32 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const testFailedSchema: SpruceErrors.SpruceCli.TestFailedSchema = {
-    id: 'testFailed',
-    namespace: 'SpruceCli',
-    name: 'Test failed',
-    fields: {
-        /** . */
-        fileName: {
-            type: 'text',
-            isRequired: true,
-            options: undefined,
-        },
-        /** . */
-        testName: {
-            type: 'text',
-            isRequired: true,
-            options: undefined,
-        },
-        /** . */
-        errorMessage: {
-            type: 'text',
-            isRequired: true,
-            options: undefined,
-        },
-    },
+
+
+const testFailedSchema: SpruceErrors.SpruceCli.TestFailedSchema  = {
+	id: 'testFailed',
+	namespace: 'SpruceCli',
+	name: 'Test failed',
+	    fields: {
+	            /** . */
+	            'fileName': {
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	            /** . */
+	            'testName': {
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	            /** . */
+	            'errorMessage': {
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	    }
 }
 
 SchemaRegistry.getInstance().trackSchema(testFailedSchema)

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

@@ -1,11 +1,14 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const themeExistsSchema: SpruceErrors.SpruceCli.ThemeExistsSchema = {
-    id: 'themeExists',
-    namespace: 'SpruceCli',
-    name: 'Theme exists',
-    fields: {},
+
+
+const themeExistsSchema: SpruceErrors.SpruceCli.ThemeExistsSchema  = {
+	id: 'themeExists',
+	namespace: 'SpruceCli',
+	name: 'Theme exists',
+	    fields: {
+	    }
 }
 
 SchemaRegistry.getInstance().trackSchema(themeExistsSchema)

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

@@ -1,21 +1,22 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const transportAlreadyExistsSchema: SpruceErrors.SpruceCli.TransportAlreadyExistsSchema =
-    {
-        id: 'transportAlreadyExists',
-        namespace: 'SpruceCli',
-        name: 'transport already exists',
-        fields: {
-            /** Transport name. */
-            name: {
-                label: 'Transport name',
-                type: 'text',
-                isRequired: true,
-                options: undefined,
-            },
-        },
-    }
+
+
+const transportAlreadyExistsSchema: SpruceErrors.SpruceCli.TransportAlreadyExistsSchema  = {
+	id: 'transportAlreadyExists',
+	namespace: 'SpruceCli',
+	name: 'transport already exists',
+	    fields: {
+	            /** Transport name. */
+	            'name': {
+	                label: 'Transport name',
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	    }
+}
 
 SchemaRegistry.getInstance().trackSchema(transportAlreadyExistsSchema)
 

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

@@ -1,20 +1,21 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const viewPluginAlreadyExistsSchema: SpruceErrors.SpruceCli.ViewPluginAlreadyExistsSchema =
-    {
-        id: 'viewPluginAlreadyExists',
-        namespace: 'SpruceCli',
-        name: 'View plugin already exists',
-        fields: {
-            /** . */
-            name: {
-                type: 'text',
-                isRequired: true,
-                options: undefined,
-            },
-        },
-    }
+
+
+const viewPluginAlreadyExistsSchema: SpruceErrors.SpruceCli.ViewPluginAlreadyExistsSchema  = {
+	id: 'viewPluginAlreadyExists',
+	namespace: 'SpruceCli',
+	name: 'View plugin already exists',
+	    fields: {
+	            /** . */
+	            'name': {
+	                type: 'text',
+	                isRequired: true,
+	                options: undefined
+	            },
+	    }
+}
 
 SchemaRegistry.getInstance().trackSchema(viewPluginAlreadyExistsSchema)
 

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

@@ -1,13 +1,15 @@
 import { SchemaRegistry } from '@sprucelabs/schema'
 import { SpruceErrors } from '../errors.types'
 
-const vscodeNotInstalledSchema: SpruceErrors.SpruceCli.VscodeNotInstalledSchema =
-    {
-        id: 'vscodeNotInstalled',
-        namespace: 'SpruceCli',
-        name: 'vscode not installed',
-        fields: {},
-    }
+
+
+const vscodeNotInstalledSchema: SpruceErrors.SpruceCli.VscodeNotInstalledSchema  = {
+	id: 'vscodeNotInstalled',
+	namespace: 'SpruceCli',
+	name: 'vscode not installed',
+	    fields: {
+	    }
+}
 
 SchemaRegistry.getInstance().trackSchema(vscodeNotInstalledSchema)
 

package/src/GlobalEmitter.ts

@@ -39,7 +39,6 @@ export const globalContract = buildEventContract({
             }),
         },
         'skill.register-dashboard-widgets': {},
-
         'test.register-abstract-test-classes': {
             responsePayloadSchema: buildSchema({
                 id: 'registerAbstractTestClassResponsePayload',

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

@@ -0,0 +1,149 @@
+import { SelectChoice } from '@sprucelabs/spruce-core-schemas'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
+import { InstallFeatureOptions } from '../../../features/features.types'
+import InstallFeatureAction, {
+    InstallFeatureActionOptions,
+} from '../../../features/skill/actions/InstallFeatureAction'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+
+export default class InstallingFeaturesDirectlyTest extends AbstractSkillTest {
+    private static action: InstallFeatureAction
+    protected static skillCacheKey = 'skills'
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+        this.action = this.Action('skill', 'installFeature')
+    }
+
+    protected static async afterEach() {
+        this.ui.reset()
+        await super.afterEach()
+    }
+
+    @test()
+    protected static async hasExpectedAliases() {
+        assert.isEqualDeep(this.action.commandAliases, ['install.feature'])
+    }
+
+    @test()
+    protected static async promptsForWhichFeatureToInstall() {
+        await this.executeAndWaitForPrompt()
+
+        const features = {
+            error: 'Errors',
+            event: 'Events',
+            schema: 'Schemas',
+            store: 'Stores (including database support)',
+            test: 'Tests',
+            view: 'Views',
+        }
+
+        const choices: SelectChoice[] = Object.keys(features).map((key) => ({
+            label: features[key as keyof typeof features],
+            value: key,
+        }))
+
+        const last = this.ui.getLastInvocation()
+        assert.isEqual(last.command, 'prompt')
+        assert.isEqualDeep(last.options, {
+            type: 'select',
+            label: 'Which feature do you want to install?',
+            isRequired: true,
+            options: {
+                choices,
+            },
+        })
+    }
+
+    @test('can install store feature', 'store')
+    @test('can install view feature', 'view')
+    @test('can install test feature', 'test')
+    protected static async selectingAFeatureTriesToInstallIt(featureCode: any) {
+        let passedOption: InstallFeatureOptions | undefined
+
+        this.featureInstaller.install = async (options) => {
+            passedOption = options
+            return {}
+        }
+        await this.executeAndWaitForPrompt()
+        await this.sendInput(featureCode)
+
+        assert.isEqualDeep(passedOption, { features: [{ code: featureCode }] })
+    }
+
+    @test()
+    protected static async returnsResultsFromFeatureInstall() {
+        const results = {
+            [generateId()]: generateId(),
+            [generateId()]: generateId(),
+        }
+
+        this.featureInstaller.install = async () => results
+
+        const { promise } = await this.executeAndWaitForPrompt()
+
+        await this.sendInput('store')
+
+        const actual = await promise
+
+        assert.isEqualDeep(actual, results)
+    }
+
+    @test('skips view feature if already installed', 'view')
+    @test('skips store feature if already installed', 'store')
+    @test('skips test feature if already installed', 'test')
+    protected static async doesNotShowOptionForInstalledFeature(code: string) {
+        this.featureInstaller.install = async () => ({})
+        const installed = ['skill', code]
+        this.featureInstaller.isInstalled = async (code) =>
+            installed.includes(code)
+        await this.executeAndWaitForPrompt()
+        const { options } = this.ui.getLastInvocation()
+        const choices = options.options.choices as SelectChoice[]
+        assert.doesNotInclude(
+            choices.map((c) => c.value),
+            code
+        )
+    }
+
+    @test()
+    protected static async ifThereAreNoFeaturesToInstallDonNotPrompt() {
+        this.featureInstaller.isInstalled = async () => true
+        const results = await this.execute()
+        assert.isEqualDeep(results, {
+            summaryLines: [
+                'Nothing to install, you have already installed everything!',
+            ],
+        })
+    }
+
+    @test('should install directly view', 'view')
+    @test('should install directly store', 'store')
+    @test('should install directly test', 'test')
+    protected static async passingFeatureCodeToActionSkipsPrompt(code: any) {
+        let passedOption: InstallFeatureOptions | undefined
+        this.featureInstaller.install = async (options) => {
+            passedOption = options
+            return {}
+        }
+
+        this.ui.prompt = async () => assert.fail('Should not prompt')
+
+        await this.execute({ code })
+        assert.isEqualDeep(passedOption, { features: [{ code }] })
+    }
+
+    private static async sendInput(featureCode: string) {
+        await this.ui.sendInput(featureCode)
+    }
+
+    private static async executeAndWaitForPrompt() {
+        const promise = this.execute()
+        await this.ui.waitForInput()
+        return { promise }
+    }
+
+    private static execute(options?: InstallFeatureActionOptions) {
+        return this.action.execute(options ?? {})
+    }
+}

package/src/__tests__/behavioral/tests/SelectingAnAbstractTestClass.test.ts

@@ -131,8 +131,8 @@ export default class SelectingAnAbstractTestClassTest extends AbstractTestTest {
         for (const feat of featuresWithRegisteredTests) {
             await this.featureInstaller.install({
                 features: [
+                    //@ts-ignore
                     {
-                        //@ts-ignore
                         code: feat.featureCode,
                     },
                 ],

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

@@ -0,0 +1,158 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert, errorAssert, generateId } from '@sprucelabs/test-utils'
+import CreateAppAction from '../../../features/view/actions/CreateAppAction'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import testUtil from '../../../tests/utilities/test.utility'
+
+export default class CreatingAnAppViewControllerTest extends AbstractSkillTest {
+    protected static skillCacheKey = 'views'
+    private static avcPath: string
+
+    private static action: CreateAppAction
+    private static lastExecution: {
+        actionCode: string
+        featureCode: string
+    }[] = []
+
+    protected static async beforeAll(): Promise<void> {
+        await super.beforeAll()
+        this.avcPath = this.resolvePath('src/App.avc.ts')
+    }
+
+    protected static async beforeEach(): Promise<void> {
+        await super.beforeEach()
+
+        this.action = this.Action('view', 'createApp')
+        await this.cli.on('feature.will-execute', (payload) => {
+            this.lastExecution.push(payload)
+        })
+    }
+
+    @test()
+    protected static async generatesExpectedFile() {
+        const results = await this.execute()
+        assert.isFalsy(results.errors)
+
+        testUtil.assertFileByPathInGeneratedFiles(this.avcPath, results.files)
+
+        assert.doesInclude(results.files, {
+            action: 'generated',
+            name: 'App.avc.ts',
+            path: this.avcPath,
+        })
+
+        assert.doesInclude(results.files, {
+            action: 'generated',
+            name: 'views.ts',
+            path: this.combinedViewsPath,
+        })
+    }
+
+    @test()
+    protected static async syncsViewsOnCreation() {
+        debugger
+        assert.doesInclude(this.lastExecution, {
+            actionCode: 'sync',
+            featureCode: 'view',
+        })
+        assert.isEqual(this.lastExecution[1].actionCode, 'sync')
+        assert.isTrue(
+            diskUtil.doesFileExist(this.combinedViewsPath),
+            'views.ts does not exist'
+        )
+    }
+
+    @test()
+    protected static async throwsIfAppAlreadyExists() {
+        await this.executeAndAssertThrowsAvcExists()
+    }
+
+    @test()
+    protected static async avcIncludesExpectedContents() {
+        const contents = diskUtil.readFile(this.avcPath)
+        assert.doesInclude(
+            contents,
+            'export default class AppViewControllerImpl extends AbstractAppViewController'
+        )
+
+        assert.doesInclude(
+            contents,
+            'public async (_options: AppViewControllerLoadOptions)'
+        )
+    }
+
+    @test()
+    protected static async generatedFilesAreValid() {
+        await this.Service('typeChecker').check(this.avcPath)
+        await this.assertCombinedViewsFileIsValid()
+    }
+
+    @test()
+    protected static async doesNotDropAppIntoSkillViewTypes() {
+        const expected = `interface ViewControllerMap {}`
+        this.assertCombinedViewsContains(expected)
+    }
+
+    @test()
+    protected static async callsHeartwoodImportFunctionAsExpected() {
+        this.assertCombinedViewsContains(
+            'heartwood({ vcs, pluginsByName, App: AppViewControllerImpl })'
+        )
+    }
+
+    @test()
+    protected static async throwsEvenIfAppAvcMoves() {
+        const destination = this.resolvePath(`src/${generateId()}/App.avc.ts`)
+        diskUtil.moveFile(this.avcPath, destination)
+
+        await this.executeAndAssertThrowsAvcExists()
+        this.avcPath = destination
+    }
+
+    @test()
+    protected static async canRenameAppAvcAndItUpdatesCombinedViews() {
+        const contents = diskUtil.readFile(this.avcPath)
+        const updatedContents = contents.replace(
+            'AppViewControllerImpl',
+            'NewAppViewControllerImpl'
+        )
+        diskUtil.writeFile(this.avcPath, updatedContents)
+        await this.Action('view', 'sync').execute({})
+
+        this.assertCombinedViewsContains(
+            'heartwood({ vcs, pluginsByName, App: NewAppViewControllerImpl })'
+        )
+
+        await this.assertCombinedViewsFileIsValid()
+    }
+
+    private static async assertCombinedViewsFileIsValid() {
+        await this.Service('typeChecker').check(this.combinedViewsPath)
+    }
+
+    private static assertCombinedViewsContains(expected: string) {
+        const contents = diskUtil.readFile(this.combinedViewsPath)
+        assert.doesInclude(
+            contents.replace(/\s/g, ''),
+            expected.replace(/\s/g, ''),
+            `The combined views file does not include the expected contents.`
+        )
+    }
+
+    private static get combinedViewsPath() {
+        return this.resolveHashSprucePath('views', 'views.ts')
+    }
+
+    private static async executeAndAssertThrowsAvcExists() {
+        const results = await this.execute()
+        assert.isTruthy(results.errors)
+        errorAssert.assertError(
+            results.errors[0],
+            'APP_VIEW_CONTROLLER_ALREADY_EXISTS'
+        )
+    }
+
+    private static async execute() {
+        return await this.action.execute()
+    }
+}

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

@@ -20,7 +20,7 @@ export default class KeepingViewsInSyncTest extends AbstractSkillTest {
 
     @test()
     protected static async syncingWithNoViewsGeneratesNothing() {
-        const results = await this.action.execute({})
+        const results = await this.action.execute()
         assert.isFalsy(results.errors)
         assert.isFalsy(results.files)
     }

package/src/__tests__/behavioral/views/plugins/CreatingAViewPlugin.test.ts

@@ -92,7 +92,7 @@ export default class CreatingAViewPluginTest extends AbstractSkillTest {
 `
 
         this.assertCombinedFileIncludes(expected)
-        this.assertCombinedFileIncludes('heartwood(vcs, pluginsByName)')
+        this.assertCombinedFileIncludes('heartwood({ vcs, pluginsByName })')
     }
 
     @test()

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

@@ -1,4 +1,8 @@
-import AbstractSpruceTest, { test, assert } from '@sprucelabs/test-utils'
+import AbstractSpruceTest, {
+    test,
+    assert,
+    errorAssert,
+} from '@sprucelabs/test-utils'
 import TerminalInterface from '../../interfaces/TerminalInterface'
 
 export default class TerminalInterfaceTest extends AbstractSpruceTest {
@@ -33,6 +37,15 @@ export default class TerminalInterfaceTest extends AbstractSpruceTest {
         assert.isTrue(this.wasOraHit)
     }
 
+    @test()
+    protected static async askingToPromptThrowsIfInCi() {
+        process.env.CIRCLECI = 'true'
+        const err = await assert.doesThrowAsync(() =>
+            this.ui.prompt({ type: 'text' })
+        )
+        errorAssert.assertError(err, 'CANNOT_PROMPT_IN_CI')
+    }
+
     private static async startLoading() {
         await this.ui.startLoading()
     }

package/src/cli/Cli.ts

@@ -223,8 +223,7 @@ export default class Cli implements CliInterface {
             actionFactory,
             ui,
             emitter,
-            //@ts-ignore
-            featureInstallerFactory: () => featureInstaller,
+            featureInstallerFactory: () => featureInstaller!,
         })
 
         featureInstaller =

package/src/errors/SpruceError.ts

@@ -269,6 +269,14 @@ export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
                 message = `A view plugin by the name ${options.name} already exists!`
                 break
 
+            case 'CANNOT_PROMPT_IN_CI':
+                message = 'A cannot prompt in ci just happened!'
+                break
+
+            case 'APP_VIEW_CONTROLLER_ALREADY_EXISTS':
+                message = `You already have an AppViewController! Run \`spruce sync.views\` if you are having issues.`
+                break
+
             default:
                 message = super.friendlyMessage()
         }

package/src/errors/appViewControllerAlreadyExists.builder.ts

@@ -0,0 +1,7 @@
+import { buildErrorSchema } from '@sprucelabs/schema'
+
+export default buildErrorSchema({
+    id: 'appViewControllerAlreadyExists',
+    name: 'App view controller already exists',
+    fields: {},
+})

package/src/errors/cannotPromptInCi.builder.ts

@@ -0,0 +1,7 @@
+import { buildErrorSchema } from '@sprucelabs/schema'
+
+export default buildErrorSchema({
+    id: 'cannotPromptInCi',
+    name: 'cannot prompt in ci',
+    fields: {},
+})

package/src/features/cache/CacheFeature.ts

@@ -2,12 +2,6 @@ import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import AbstractFeature from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        cache: CacheFeature
-    }
-}
-
 export default class CacheFeature extends AbstractFeature {
     public description = 'Caching for all things Sprucebot.'
     public code: FeatureCode = 'cache'
@@ -18,3 +12,13 @@ export default class CacheFeature extends AbstractFeature {
         return true
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        cache: CacheFeature
+    }
+
+    interface FeatureOptionsMap {
+        cache: undefined
+    }
+}

package/src/features/conversation/ConversationFeature.ts

@@ -7,12 +7,6 @@ import AbstractFeature, {
 } from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        conversation: ConversationFeature
-    }
-}
-
 export default class ConversationFeature extends AbstractFeature {
     public nameReadable = 'Conversation'
     public code: FeatureCode = 'conversation'
@@ -68,3 +62,13 @@ export default class ConversationFeature extends AbstractFeature {
         return this.Writer('conversation').writePlugin(this.cwd)
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        conversation: ConversationFeature
+    }
+
+    interface FeatureOptionsMap {
+        conversation: undefined
+    }
+}

package/src/features/dependencies/DependencyFeature.ts

@@ -2,12 +2,6 @@ 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'
@@ -25,3 +19,13 @@ export default class DependencyFeature extends AbstractFeature {
         return this.features.isInstalled('skill')
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        dependency: DependencyFeature
+    }
+
+    interface FeatureOptionsMap {
+        dependency: undefined
+    }
+}