@sprucelabs/spruce-cli 22.1.13 → 22.3.0

package/src/features/deploy/DeployFeature.ts

@@ -5,12 +5,6 @@ import AbstractFeature, {
 } from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        deploy: DeployFeature
-    }
-}
-
 export default class DeployFeature extends AbstractFeature {
     public description = 'Deploy your skill with ease.'
     public code: FeatureCode = 'deploy'
@@ -35,3 +29,13 @@ export default class DeployFeature extends AbstractFeature {
         }
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        deploy: DeployFeature
+    }
+
+    interface FeatureOptionsMap {
+        deploy: undefined
+    }
+}

package/src/features/error/ErrorFeature.ts

@@ -7,16 +7,6 @@ import AbstractFeature, {
 } from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        error: ErrorFeature
-    }
-
-    interface FeatureOptionsMap {
-        error: undefined
-    }
-}
-
 export default class ErrorFeature extends AbstractFeature {
     public nameReadable = 'error handling'
     public description =
@@ -102,3 +92,13 @@ export default class ErrorFeature extends AbstractFeature {
         return this.Writer('error').writePlugin(this.cwd)
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        error: ErrorFeature
+    }
+
+    interface FeatureOptionsMap {
+        error: undefined
+    }
+}

package/src/features/eventContract/EventContractFeature.ts

@@ -3,12 +3,6 @@ import { FileDescription } from '../../types/cli.types'
 import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        eventContract: EventContractFeature
-    }
-}
-
 export default class EventContractFeature extends AbstractFeature {
     public code: FeatureCode = 'eventContract'
     public nameReadable = 'Event Contract'
@@ -22,3 +16,13 @@ export default class EventContractFeature extends AbstractFeature {
 
     public isInstalled = async () => true
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        eventContract: EventContractFeature
+    }
+
+    interface FeatureOptionsMap {
+        eventContract: undefined
+    }
+}

package/src/features/onboard/OnboardFeature.ts

@@ -9,12 +9,6 @@ import { FeatureCode } from '../features.types'
 import ScriptLoader from './ScriptLoader'
 import OnboardingStore from './stores/OnboardingStore'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        onboard: OnboardFeature
-    }
-}
-
 export default class OnboardFeature extends AbstractFeature {
     public code: FeatureCode = 'onboard'
     public nameReadable = 'Onboard'
@@ -150,3 +144,13 @@ export default class OnboardFeature extends AbstractFeature {
         return isExpectedCommand
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        onboard: OnboardFeature
+    }
+
+    interface FeatureOptionsMap {
+        onboard: undefined
+    }
+}

package/src/features/organization/OrganizationFeature.ts

@@ -25,4 +25,8 @@ declare module '../../features/features.types' {
     interface FeatureMap {
         organization: OrganizationFeature
     }
+
+    interface FeatureOptionsMap {
+        organization: undefined
+    }
 }

package/src/features/permission/PermissionFeature.ts

@@ -81,4 +81,8 @@ declare module '../../features/features.types' {
     interface FeatureMap {
         permission: PermissionFeature
     }
+
+    interface FeatureOptionsMap {
+        permission: undefined
+    }
 }

package/src/features/person/PersonFeature.ts

@@ -20,4 +20,8 @@ declare module '../../features/features.types' {
     interface FeatureMap {
         person: PersonFeature
     }
+
+    interface FeatureOptionsMap {
+        person: undefined
+    }
 }

package/src/features/polish/PolishFeature.ts

@@ -30,4 +30,8 @@ declare module '../../features/features.types' {
     interface FeatureMap {
         polish: PolishFeature
     }
+
+    interface FeatureOptionsMap {
+        polish: undefined
+    }
 }

package/src/features/sandbox/SandboxFeature.ts

@@ -3,12 +3,6 @@ import uiUtil from '../../utilities/ui.utility'
 import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
 import { ActionOptions, FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        sandbox: SandboxFeature
-    }
-}
-
 export default class SandboxFeature extends AbstractFeature {
     public code: FeatureCode = 'sandbox'
     public nameReadable = 'Sandbox'
@@ -45,3 +39,13 @@ export default class SandboxFeature extends AbstractFeature {
         })
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        sandbox: SandboxFeature
+    }
+
+    interface FeatureOptionsMap {
+        sandbox: undefined
+    }
+}

package/src/features/skill/actions/BootAction.ts

@@ -5,17 +5,6 @@ import CommandService from '../../../services/CommandService'
 import AbstractAction from '../../AbstractAction'
 import { FeatureActionResponse } from '../../features.types'
 
-type OptionsSchema = SpruceSchemas.SpruceCli.v2020_07_22.BootSkillOptionsSchema
-type Options = SpruceSchemas.SpruceCli.v2020_07_22.BootSkillOptions
-
-export interface BootMeta {
-    kill: () => void
-    pid: number
-    promise: Promise<void>
-    isBooted: boolean
-    bootPromise: Promise<void>
-}
-
 export default class BootAction extends AbstractAction<OptionsSchema> {
     public optionsSchema: OptionsSchema = bootSkillOptionsSchema
     public commandAliases = ['boot']
@@ -125,3 +114,14 @@ export default class BootAction extends AbstractAction<OptionsSchema> {
         return null
     }
 }
+
+type OptionsSchema = SpruceSchemas.SpruceCli.v2020_07_22.BootSkillOptionsSchema
+type Options = SpruceSchemas.SpruceCli.v2020_07_22.BootSkillOptions
+
+export interface BootMeta {
+    kill: () => void
+    pid: number
+    promise: Promise<void>
+    isBooted: boolean
+    bootPromise: Promise<void>
+}

package/src/features/skill/actions/InstallFeatureAction.ts

@@ -0,0 +1,93 @@
+import { buildSchema, SchemaValues } from '@sprucelabs/schema'
+import { SelectChoice } from '@sprucelabs/spruce-core-schemas'
+import AbstractAction from '../../AbstractAction'
+import { FeatureActionResponse, FeatureCode } from '../../features.types'
+
+export default class InstallFeatureAction extends AbstractAction<OptionsSchema> {
+    public optionsSchema = optionsSchema
+    public invocationMessage = 'Installing a feature... 🚀'
+    public commandAliases = ['install.feature']
+
+    public async execute(
+        options: InstallFeatureActionOptions
+    ): Promise<FeatureActionResponse> {
+        let { code } = options ?? {}
+
+        if (!code) {
+            const choices: SelectChoice[] = await this.buildFeatureChoices()
+
+            if (!choices.length) {
+                return {
+                    summaryLines: [
+                        'Nothing to install, you have already installed everything!',
+                    ],
+                }
+            }
+
+            code = await this.promptForFeature(choices)
+        }
+        const results = await this.features.install({
+            features: [{ code: code as any }],
+        })
+
+        return results
+    }
+
+    private async promptForFeature(choices: SelectChoice[]) {
+        return await this.ui.prompt({
+            type: 'select',
+            label: 'Which feature do you want to install?',
+            isRequired: true,
+            options: {
+                choices,
+            },
+        })
+    }
+
+    private async buildFeatureChoices() {
+        const choices: SelectChoice[] = []
+
+        for (const key in features) {
+            const isInstalled = await this.features.isInstalled(
+                key as FeatureCode
+            )
+            if (!isInstalled) {
+                choices.push({
+                    label: features[key as keyof typeof features],
+                    value: key,
+                })
+            }
+        }
+        return choices
+    }
+}
+
+const features = {
+    error: 'Errors',
+    event: 'Events',
+    schema: 'Schemas',
+    store: 'Stores (including database support)',
+    test: 'Tests',
+    view: 'Views',
+}
+
+const allFeatureChoices: SelectChoice[] = Object.keys(features).map((key) => ({
+    label: features[key as keyof typeof features],
+    value: key,
+}))
+
+const optionsSchema = buildSchema({
+    id: 'installFeature',
+    fields: {
+        code: {
+            type: 'select',
+            label: 'Feature to install',
+            options: {
+                choices: allFeatureChoices,
+            },
+        },
+    },
+})
+
+type OptionsSchema = typeof optionsSchema
+export type InstallFeatureActionOptions = SchemaValues<OptionsSchema>

package/src/features/store/StoreFeature.ts

@@ -6,12 +6,6 @@ import AbstractFeature, {
 } from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        store: StoreFeature
-    }
-}
-
 export default class StoreFeature extends AbstractFeature {
     public nameReadable = 'Data Stores'
     public description = 'For working with remote places of storage.'
@@ -87,3 +81,13 @@ export default class StoreFeature extends AbstractFeature {
         }
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        store: StoreFeature
+    }
+
+    interface FeatureOptionsMap {
+        store: undefined
+    }
+}

package/src/features/test/TestFeature.ts

@@ -8,12 +8,6 @@ import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
 import ParentTestFinder from '../error/ParentTestFinder'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        test: TestFeature
-    }
-}
-
 export interface ParentClassCandidate {
     name: string
     label: string
@@ -149,3 +143,13 @@ export default class TestFeature extends AbstractFeature {
         return candidates
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        test: TestFeature
+    }
+
+    interface FeatureOptionsMap {
+        test: undefined
+    }
+}

package/src/features/view/ViewFeature.ts

@@ -3,16 +3,6 @@ import { NpmPackage } from '../../types/cli.types'
 import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
 import { ActionOptions, FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        view: ViewFeature
-    }
-
-    interface FeatureOptionsMap {
-        view: undefined
-    }
-}
-
 export default class ViewFeature extends AbstractFeature {
     public nameReadable = 'views'
     public description = 'Views: Create views using the Heartwood framework.'
@@ -98,3 +88,13 @@ export default class ViewFeature extends AbstractFeature {
         return { files }
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        view: ViewFeature
+    }
+
+    interface FeatureOptionsMap {
+        view: undefined
+    }
+}

package/src/features/view/actions/CreateAppAction.ts

@@ -0,0 +1,32 @@
+import { buildSchema } from '@sprucelabs/schema'
+import actionUtil from '../../../utilities/action.utility'
+import AbstractAction from '../../AbstractAction'
+import { FeatureActionResponse } from '../../features.types'
+
+export default class CreateAppAction extends AbstractAction<OptionsSchema> {
+    public optionsSchema = optionsSchema
+    public invocationMessage = 'Creating new app view controller... '
+    public readonly commandAliases = ['create.avc']
+
+    public async execute(): Promise<FeatureActionResponse> {
+        const writer = this.Writer('view', {})
+        const files = await writer.writeAppViewController(this.cwd)
+
+        const results = await this.Action('view', 'sync').execute({})
+        const merged = actionUtil.mergeActionResults(
+            {
+                files,
+            },
+            results
+        )
+
+        return merged
+    }
+}
+
+const optionsSchema = buildSchema({
+    id: 'createAppViewControllerOptions',
+    fields: {},
+})
+
+type OptionsSchema = typeof optionsSchema

package/src/features/view/actions/SyncAction.ts

@@ -1,5 +1,5 @@
 import globby from '@sprucelabs/globby'
-import { buildSchema, SchemaValues } from '@sprucelabs/schema'
+import { buildSchema } from '@sprucelabs/schema'
 import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
 import {
     VcTemplateItem,
@@ -16,12 +16,10 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
     public commandAliases = ['sync.views']
     public invocationMessage = 'Syncing view controller types... 🌲'
 
-    public async execute(
-        _options: SchemaValues<OptionsSchema>
-    ): Promise<FeatureActionResponse> {
+    public async execute(): Promise<FeatureActionResponse> {
         const targetDir = diskUtil.resolvePath(this.cwd, 'src')
         const matches = await globby(
-            ['**/*.svc.ts', '**/*.vc.ts', '**/*.view.plugin.ts'],
+            ['**/*.svc.ts', '**/*.vc.ts', '**/*.view.plugin.ts', '**/*.avc.ts'],
             {
                 cwd: targetDir,
             }
@@ -35,12 +33,13 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         const introspect = introspectionUtil.introspect(paths)
 
         const vcTemplateItems: VcTemplateItem[] = []
+        let appTemplateItem: VcTemplateItem | undefined
         const svcTemplateItems: VcTemplateItem[] = []
         const viewPluginItems: ViewControllerPluginItem[] = []
 
         introspect.forEach(({ classes }) => {
             for (const thisClass of classes) {
-                const { vc, svc, plugin } =
+                const { vc, svc, plugin, avc } =
                     this.mapIntrospectedClassToTemplateItem(thisClass)
 
                 if (vc) {
@@ -49,6 +48,8 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
                     viewPluginItems.push(plugin)
                 } else if (svc) {
                     svcTemplateItems.push(svc)
+                } else if (avc) {
+                    appTemplateItem = avc
                 } else {
                     throw new Error('Unexpected class type.')
                 }
@@ -63,6 +64,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
                 vcTemplateItems,
                 svcTemplateItems,
                 viewPluginItems,
+                appTemplateItem,
             }
         )
 
@@ -75,6 +77,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         vc?: VcTemplateItem
         svc?: VcTemplateItem
         plugin?: ViewControllerPluginItem
+        avc?: VcTemplateItem
     } {
         const item = {
             id: c.staticProperties.id,
@@ -84,10 +87,13 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 
         let vc: VcTemplateItem | undefined
         let svc: VcTemplateItem | undefined
+        let avc: VcTemplateItem | undefined
         let plugin: ViewControllerPluginItem | undefined
 
         if (c.classPath.endsWith('.svc.ts')) {
             svc = item
+        } else if (c.classPath.endsWith('avc.ts')) {
+            avc = item
         } else if (c.classPath.endsWith('view.plugin.ts')) {
             const nameCamel = c.classPath.match(/([^/]+).view.plugin.ts$/)![1]
             plugin = { ...item, nameCamel }
@@ -95,7 +101,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
             vc = item
         }
 
-        return { svc, vc, plugin }
+        return { svc, vc, plugin, avc }
     }
 }
 

package/src/features/view/writers/ViewWriter.ts

@@ -214,4 +214,23 @@ export default class ViewWriter extends AbstractWriter {
         )
         return { path, filename }
     }
+
+    public async writeAppViewController(cwd: string) {
+        const match = await globby(cwd + '/**/App.avc.ts')
+
+        if (match.length > 0) {
+            throw new SpruceError({
+                code: 'APP_VIEW_CONTROLLER_ALREADY_EXISTS',
+            })
+        }
+
+        const destination = diskUtil.resolvePath(cwd, 'src', 'App.avc.ts')
+        const contents = this.templates.appViewController()
+
+        return this.writeFileIfChangedMixinResults(
+            destination,
+            contents,
+            'Your new app view controller!'
+        )
+    }
 }

package/src/features/vscode/VsCodeFeature.ts

@@ -3,12 +3,6 @@ import { FileDescription } from '../../types/cli.types'
 import AbstractFeature from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-    interface FeatureMap {
-        vscode: VsCodeFeature
-    }
-}
-
 export default class VsCodeFeature extends AbstractFeature {
     public nameReadable = 'VSCode'
     public description = 'Create settings and install VSCode extensions'
@@ -52,3 +46,12 @@ export default class VsCodeFeature extends AbstractFeature {
         return true
     }
 }
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        vscode: VsCodeFeature
+    }
+    interface FeatureOptionsMap {
+        vscode: undefined
+    }
+}

package/src/interfaces/TerminalInterface.ts

@@ -414,6 +414,11 @@ export default class TerminalInterface implements GraphicsInterface {
         definition: T
     ): Promise<FieldDefinitionValueType<T>> {
         this.isPromptActive = true
+
+        if (isCi()) {
+            throw new SpruceError({ code: 'CANNOT_PROMPT_IN_CI' })
+        }
+
         const name = generateInquirerFieldName()
         const fieldDefinition: FieldDefinitions = definition
         const { defaultValue } = fieldDefinition

package/src/tests/fixtures/ViewFixture.ts

@@ -24,7 +24,7 @@ export default class ViewFixture {
             options
         )
 
-        await this.syncAction.execute({})
+        await this.syncAction.execute()
 
         return files[0]
     }

package/src/utilities/isCi.ts

@@ -1,6 +1,10 @@
 export default function isCi() {
     const env = process.env
 
+    if (process.env.IS_TESTING_SELF) {
+        return false
+    }
+
     if (
         [
             'TRAVIS',