@sprucelabs/spruce-cli 22.2.0 → 23.0.0

package/src/errors/{appViewControllerAlreadyExists.builder.ts → appControllerAlreadyExists.builder.ts}

@@ -1,7 +1,7 @@
 import { buildErrorSchema } from '@sprucelabs/schema'
 
 export default buildErrorSchema({
-    id: 'appViewControllerAlreadyExists',
+    id: 'appControllerAlreadyExists',
     name: 'App view controller already exists',
     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
+    }
+}

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,96 @@
+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)
+        }
+
+        this.ui.startLoading('Installing feature...')
+
+        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/validateAndNormalize.utility.ts

@@ -3,6 +3,7 @@ import {
     normalizeSchemaValues,
     Schema,
     SchemaPartialValues,
+    SchemaValues,
     SchemaValuesWithDefaults,
     validateSchemaValues,
 } from '@sprucelabs/schema'
@@ -19,7 +20,7 @@ const validateAndNormalizer = {
         const values = {
             ...defaultSchemaValues(schema),
             ...this.stripUndefined(options),
-        } as SchemaPartialValues<S, false>
+        } as SchemaValues<S>
 
         validateSchemaValues(schema, values, {})
 

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

@@ -6,10 +6,16 @@ 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', 'create.app']
 
     public async execute(): Promise<FeatureActionResponse> {
         const writer = this.Writer('view', {})
-        const files = await writer.writeAppViewController(this.cwd)
+        const id = await this.Store('skill').loadCurrentSkillsNamespace()
+        const files = await writer.writeAppController(
+            this.cwd,
+            id.toLocaleLowerCase(),
+            id
+        )
 
         const results = await this.Action('view', 'sync').execute({})
         const merged = actionUtil.mergeActionResults(
@@ -19,14 +25,12 @@ export default class CreateAppAction extends AbstractAction<OptionsSchema> {
             results
         )
 
-        debugger
-
         return merged
     }
 }
 
 const optionsSchema = buildSchema({
-    id: 'createAppViewControllerOptions',
+    id: 'createAppControllerOptions',
     fields: {},
 })
 

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

@@ -19,7 +19,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
     public async execute(): Promise<FeatureActionResponse> {
         const targetDir = diskUtil.resolvePath(this.cwd, 'src')
         const matches = await globby(
-            ['**/*.svc.ts', '**/*.vc.ts', '**/*.view.plugin.ts', '**/*.avc.ts'],
+            ['**/*.svc.ts', '**/*.vc.ts', '**/*.view.plugin.ts', '**/*.ac.ts'],
             {
                 cwd: targetDir,
             }
@@ -39,8 +39,12 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 
         introspect.forEach(({ classes }) => {
             for (const thisClass of classes) {
-                const { vc, svc, plugin, avc } =
-                    this.mapIntrospectedClassToTemplateItem(thisClass)
+                const {
+                    vc,
+                    svc,
+                    plugin,
+                    ac: avc,
+                } = this.mapIntrospectedClassToTemplateItem(thisClass)
 
                 if (vc) {
                     vcTemplateItems.push(vc)
@@ -77,7 +81,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         vc?: VcTemplateItem
         svc?: VcTemplateItem
         plugin?: ViewControllerPluginItem
-        avc?: VcTemplateItem
+        ac?: VcTemplateItem
     } {
         const item = {
             id: c.staticProperties.id,
@@ -87,13 +91,13 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 
         let vc: VcTemplateItem | undefined
         let svc: VcTemplateItem | undefined
-        let avc: VcTemplateItem | undefined
+        let ac: 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('ac.ts')) {
+            ac = item
         } else if (c.classPath.endsWith('view.plugin.ts')) {
             const nameCamel = c.classPath.match(/([^/]+).view.plugin.ts$/)![1]
             plugin = { ...item, nameCamel }
@@ -101,7 +105,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
             vc = item
         }
 
-        return { svc, vc, plugin, avc }
+        return { svc, vc, plugin, ac }
     }
 }
 

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

@@ -26,8 +26,13 @@ export default class ViewWriter extends AbstractWriter {
     }
 
     public async writeCombinedViewsFile(cwd: string, options: ViewsOptions) {
-        let { vcTemplateItems, svcTemplateItems, viewPluginItems, ...rest } =
-            options
+        let {
+            vcTemplateItems,
+            svcTemplateItems,
+            viewPluginItems,
+            appTemplateItem,
+            ...rest
+        } = options
 
         const destinationDir = diskUtil.resolveHashSprucePath(cwd, 'views')
         const destination = diskUtil.resolvePath(destinationDir, 'views.ts')
@@ -47,10 +52,18 @@ export default class ViewWriter extends AbstractWriter {
             destinationDir
         )
 
+        if (appTemplateItem) {
+            appTemplateItem = this.makePathRelative(
+                appTemplateItem,
+                destinationDir
+            )
+        }
+
         const contents = this.templates.views({
             vcTemplateItems,
             svcTemplateItems,
             viewPluginItems,
+            appTemplateItem,
             ...rest,
         })
 
@@ -66,12 +79,20 @@ export default class ViewWriter extends AbstractWriter {
     private removeFileExtensionsFromTemplateItems<
         T extends VcTemplateItem | ViewControllerPluginItem,
     >(vcTemplateItems: T[], destinationDir: string): T[] {
-        return vcTemplateItems.map((i) => ({
+        return vcTemplateItems.map((i) =>
+            this.makePathRelative<T>(i, destinationDir)
+        )
+    }
+
+    private makePathRelative<
+        T extends VcTemplateItem | ViewControllerPluginItem,
+    >(i: T, destinationDir: string): T & { path: string } {
+        return {
             ...i,
             path: diskUtil
                 .resolveRelativePath(destinationDir, i.path)
                 .replace('.ts', ''),
-        }))
+        }
     }
 
     public writeViewController(
@@ -215,17 +236,21 @@ export default class ViewWriter extends AbstractWriter {
         return { path, filename }
     }
 
-    public async writeAppViewController(cwd: string) {
-        const match = await globby(cwd + '/**/App.avc.ts')
+    public async writeAppController(
+        cwd: string,
+        id: string,
+        namespacePascal: string
+    ) {
+        const match = await globby(cwd + '/**/App.ac.ts')
 
         if (match.length > 0) {
             throw new SpruceError({
-                code: 'APP_VIEW_CONTROLLER_ALREADY_EXISTS',
+                code: 'APP_CONTROLLER_ALREADY_EXISTS',
             })
         }
 
-        const destination = diskUtil.resolvePath(cwd, 'src', 'App.avc.ts')
-        const contents = this.templates.appViewController()
+        const destination = diskUtil.resolvePath(cwd, 'src', 'App.ac.ts')
+        const contents = this.templates.appController({ id, namespacePascal })
 
         return this.writeFileIfChangedMixinResults(
             destination,