@sprucelabs/spruce-cli 28.2.3 → 29.0.1

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

@@ -0,0 +1,376 @@
+import globby from '@sprucelabs/globby'
+import { buildSchema, Schema, SchemaTypesRenderer } from '@sprucelabs/schema'
+import {
+    CORE_NAMESPACE,
+    diskUtil,
+    namesUtil,
+    randomUtil,
+    versionUtil,
+} from '@sprucelabs/spruce-skill-utils'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
+import CommandServiceImpl from '../../../services/CommandService'
+import LintService from '../../../services/LintService'
+import SchemaTemplateItemBuilder from '../../../templateItemBuilders/SchemaTemplateItemBuilder'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import testUtil from '../../../tests/utilities/test.utility'
+import { GeneratedFile } from '../../../types/cli.types'
+
+export default class SyncingSchemasInGoTest extends AbstractSkillTest {
+    protected static skillCacheKey = 'schemas'
+    private static goDir: string
+    private static builder1Name = 'aSchemaIBuilt'
+    private static builder2Name = 'anotherSchemaIBuilt'
+    private static renderer: SchemaTypesRenderer
+    private static goModuleName = randomUtil.rand([
+        'my-skill',
+        'awesome-skill',
+        'super-skill',
+    ])
+
+    private static version = versionUtil.generateVersion().constValue
+    private static skillNamespace: string = CORE_NAMESPACE
+    private static schemaTemplateItemBuilder: SchemaTemplateItemBuilder
+    private static goFullModuleName: string
+
+    protected static async beforeEach(): Promise<void> {
+        await super.beforeEach()
+
+        if (!this.goDir) {
+            this.goDir = this.resolvePath(this.skillDir, 'go-schemas')
+            diskUtil.createDir(this.goDir)
+        }
+
+        CommandServiceImpl.fakeCommand(/yarn.*?/, {
+            code: 1,
+        })
+
+        this.renderer = SchemaTypesRenderer.Renderer()
+        this.schemaTemplateItemBuilder = new SchemaTemplateItemBuilder(
+            CORE_NAMESPACE
+        )
+    }
+
+    @test()
+    protected static async canSyncCoreSchemasWithoutError() {
+        this.moveToGoDir()
+
+        this.goFullModuleName = await this.go.initGoProject(this.goModuleName)
+        await this.sync()
+
+        const tsFiles = await globby('**/*.ts', {
+            cwd: this.cwd,
+            ignore: ['go/pkg/**'],
+        })
+        assert.isLength(tsFiles, 0, 'Expected no .ts files to be generated.')
+    }
+
+    @test()
+    protected static async syncingGeneratesCoreGoFileIfSchemaDoesExist() {
+        await this.createSchema(this.builder1Name)
+
+        this.moveToGoDir()
+
+        const syncResults = await this.sync()
+        testUtil.assertFileByPathInGeneratedFiles(
+            this.coreSchemaGoFilepath,
+            syncResults.files
+        )
+
+        assert.isTrue(
+            diskUtil.doesFileExist(this.coreSchemaGoFilepath),
+            'Expected core_schemas.go file to exist.'
+        )
+    }
+
+    @test()
+    protected static async coreSchemasFileHasStructBasedOnSchema() {
+        await this.assertCoreFileIncludesSchema(this.builder1Name)
+    }
+
+    @test()
+    protected static async coreShowsDifferentSchema() {
+        await this.createSchema(this.builder2Name)
+        this.moveToGoDir()
+        await this.sync()
+        await this.assertCoreFileIncludesSchema(this.builder2Name)
+    }
+
+    @test()
+    protected static async doesNotIncludeSchemaIfDeleted() {
+        diskUtil.deleteFile(this.getBuilderFilepath(this.builder1Name))
+
+        this.moveToGoDir()
+        await this.sync()
+
+        const contents = this.loadCoreSchemasFile()
+        assert.doesNotInclude(
+            contents,
+            namesUtil.toPascal(this.builder1Name),
+            'Expected core_schemas.go to not include deleted schema.'
+        )
+    }
+
+    @test()
+    protected static async coreSchemasFileIncludesPackageDeclaration() {
+        this.assertCoreSchemaFileIncludes('package schemas')
+    }
+
+    @test()
+    protected static async goFileIsValid() {
+        this.moveToGoDir()
+        await this.go.exec('build', './...')
+    }
+
+    @test()
+    protected static async canRenderNestedSchemas() {
+        const schema2 = await this.importBuilder(this.builder2Name)
+        schema2.fields = {
+            ...schema2.fields,
+            hasNestedSchema: {
+                type: 'schema',
+                options: {
+                    schema: nestedSchema,
+                },
+            },
+            dateOfBirth: {
+                type: 'date',
+            },
+        }
+
+        diskUtil.writeFile(
+            this.getBuilderFilepath(this.builder2Name),
+            `import { buildSchema } from '@sprucelabs/schema'
+
+export default buildSchema(${JSON.stringify(schema2, null, 4)})`
+        )
+
+        await this.lintBuilders()
+
+        schema2.namespace = this.skillNamespace
+        const expected = this.renderSchemaAsStruct(schema2)
+
+        this.moveToGoDir()
+        await this.sync()
+
+        this.assertCoreSchemaFileIncludes(expected)
+    }
+
+    @test()
+    protected static async generatedFileShouldPassVet() {
+        this.moveToGoDir()
+        await this.go.vet()
+    }
+
+    @test()
+    protected static async writesSchemaFileForEachSchemaFound() {
+        this.moveToGoDir()
+        const results = await this.sync()
+        const generated = ['nestedSchema', 'anotherSchemaIBuilt']
+        for (const schema of generated) {
+            this.assertSchemaFileWrittenWithExpectedPackage(
+                schema,
+                results.files
+            )
+        }
+    }
+
+    @test()
+    protected static async canActuallyUseGeneratedSchemasInGoTest() {
+        this.moveToGoDir()
+        const testSrc = buildGoTest({
+            pwd: this.goFullModuleName,
+            name: generateId(),
+            age: Date.now() % 100,
+            version: this.version,
+        })
+
+        diskUtil.writeFile(
+            this.resolvePath(this.cwd, 'test_schema.go'),
+            testSrc
+        )
+
+        await this.go.exec('test', './...')
+    }
+
+    @test()
+    protected static async creatingSchemaWithDifferentVersionAlsoWorks() {
+        this.version = versionUtil.generateVersion('2020_01_01').constValue
+        await this.createSchema('versionedSchema')
+        this.moveToGoDir()
+        const results = await this.sync()
+        this.assertSchemaFileWrittenWithExpectedPackage(
+            'versionedSchema',
+            results.files
+        )
+    }
+
+    private static assertSchemaFileWrittenWithExpectedPackage(
+        schema: string,
+        files: GeneratedFile[] = []
+    ) {
+        assert.isAbove(files.length, 0, 'Expected at least one generated file.')
+
+        const path = testUtil.assertFileByPathInGeneratedFiles(
+            `schemas/${this.skillNamespace.toLowerCase()}/${this.version}/${namesUtil.toSnake(schema)}.go`,
+            files
+        )
+        const contents = diskUtil.readFile(path)
+        assert.doesInclude(
+            contents,
+            `package ${this.version}`,
+            'Did not include expected package declaration.'
+        )
+    }
+
+    private static async lintBuilders() {
+        LintService.enableLinting()
+        await this.Service('lint').fix(`**/*.builder.ts`)
+    }
+
+    private static async assertCoreFileIncludesSchema(name: string) {
+        const struct = await this.importStructForSchema(name)
+        this.assertCoreSchemaFileIncludes(struct)
+    }
+
+    private static assertCoreSchemaFileIncludes(needle: string) {
+        const contents = this.loadCoreSchemasFile()
+
+        assert.doesInclude(
+            contents,
+            needle,
+            'core_schemas.go missing expected content'
+        )
+    }
+
+    private static async importStructForSchema(name: string) {
+        const imported = await this.importBuilder(name)
+        imported.namespace = this.skillNamespace
+        const struct = this.renderSchemaAsStruct(imported)
+
+        return struct
+    }
+
+    private static loadCoreSchemasFile() {
+        return diskUtil.readFile(this.coreSchemaGoFilepath)
+    }
+
+    private static renderSchemaAsStruct(imported: Schema) {
+        const templateItems = this.schemaTemplateItemBuilder.buildTemplateItems(
+            {
+                [CORE_NAMESPACE]: [imported],
+            }
+        )
+
+        return this.renderer.render(imported, {
+            language: 'go',
+            schemaTemplateItems: templateItems,
+        })
+    }
+
+    private static async importBuilder(name: string) {
+        return (await this.Service('import').importDefault(
+            this.getBuilderFilepath(name)
+        )) as Schema
+    }
+
+    private static async createSchema(name: string) {
+        const results = await this.Action('schema', 'create').execute({
+            nameReadable: 'A schema i built!',
+            nameCamel: name,
+            version: this.version,
+        })
+
+        assert.isFalsy(
+            results.errors,
+            'Expected no errors when creating schema.'
+        )
+    }
+
+    private static getBuilderFilepath(name: string) {
+        return this.resolvePath(
+            this.skillDir,
+            'src',
+            'schemas',
+            versionUtil.generateVersion().dirValue,
+            `${name}.builder.ts`
+        )
+    }
+
+    private static get coreSchemaGoFilepath() {
+        return diskUtil.resolvePath(this.goDir, 'schemas/core_schemas.go')
+    }
+
+    private static async sync() {
+        const results = await this.Action('schema', 'sync', {
+            shouldAutoHandleDependencies: true,
+        }).execute({
+            shouldGenerateCoreSchemaTypes: true,
+            schemaLookupDir: this.resolvePath(this.skillDir, 'src'),
+        })
+
+        assert.isFalsy(
+            results.errors,
+            'Expected no errors when syncing core schemas in a go project.'
+        )
+
+        assert.isTruthy(
+            results.files,
+            'Expected some generated files when syncing core schemas in a go project.'
+        )
+
+        return results
+    }
+
+    private static moveToGoDir() {
+        this.cwd = this.goDir
+        this.setCwd(this.cwd)
+    }
+}
+
+const nestedSchema = buildSchema({
+    id: 'nestedSchema',
+    fields: {
+        name: {
+            type: 'text',
+        },
+        age: {
+            type: 'number',
+        },
+    },
+})
+
+const buildGoTest = (options: {
+    pwd: string
+    name: string
+    age: number
+    version: string
+}) => `
+package goschemas
+
+import (
+	"testing"
+	spruce "${options.pwd}/schemas/spruce/${options.version}"
+)
+
+func TestMakeASchemaIBuilt(t *testing.T) {
+	data := map[string]interface{}{
+		"name": "${options.name}",
+		"age":  ${options.age},
+	}
+
+	result, err := spruce.MakeNestedSchema(data)
+	if err != nil {
+		t.Fatalf("MakeNestedSchema failed: %v", err)
+	}
+
+	if result.Name != "${options.name}" {
+		t.Errorf("Expected Name to be '${options.name}', got '%s'",
+			result.Name)
+	}
+
+	if result.Age != ${options.age} {
+		t.Errorf("Expected Age to be ${options.age}, got %f",
+			result.Age)
+	}
+}
+`

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

@@ -0,0 +1,46 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert } from '@sprucelabs/test-utils'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+import generateShortAlphaId from '../permissions/support/generateShortAlphaId'
+
+export default class SyncingSchemasInChildDirInGoTest extends AbstractSkillTest {
+    protected static skillCacheKey = 'schemas'
+    private static schemaNameCamel = generateShortAlphaId()
+
+    @test()
+    protected static async importsTheCorrectPath() {
+        await this.go.initGoProject()
+        await this.createSchema()
+
+        const dir = 'pgk'
+        diskUtil.createDir(this.resolvePath(dir))
+
+        this.cwd = this.resolvePath(dir)
+        this.setCwd(this.cwd)
+
+        const results = await this.Action('schema', 'sync', {
+            shouldAutoHandleDependencies: true,
+        }).execute({
+            schemaLookupDir: '../src/',
+        })
+
+        assert.isFalsy(
+            results.errors,
+            'Expected no errors when syncing schema.'
+        )
+
+        await this.go.vet()
+    }
+
+    private static async createSchema() {
+        const results = await this.Action('schema', 'create').execute({
+            nameReadable: 'A schema i built!',
+            nameCamel: this.schemaNameCamel,
+        })
+
+        assert.isFalsy(
+            results.errors,
+            'Expected no errors when creating schema.'
+        )
+    }
+}

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

@@ -0,0 +1,23 @@
+import { assert, test } from '@sprucelabs/test-utils'
+import AbstractCliTest from '../../../tests/AbstractCliTest'
+
+export default class SyncingSchemasInGoTest extends AbstractCliTest {
+    @test()
+    protected static async canSyncWithoutError() {
+        await this.go.initGoProject()
+        await this.sync()
+    }
+
+    private static async sync() {
+        const results = await this.Action('schema', 'sync', {
+            shouldAutoHandleDependencies: true,
+        }).execute({})
+
+        assert.isFalsy(
+            results.errors,
+            'Expected no errors when syncing core schemas in a go project.'
+        )
+
+        return results
+    }
+}

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

@@ -204,7 +204,7 @@ export default class SelectingAnAbstractTestClassTest extends AbstractTestTest {
 
         await assert.doesThrowAsync(
             () => this.Service('command').execute('yarn test'),
-            /Expected: false/gis
+            /Expected: true/gis
         )
     }
 

package/src/__tests__/behavioral/upgrading/UpdatingDependencies2.test.ts

@@ -1,6 +1,8 @@
 import { test, assert } from '@sprucelabs/test-utils'
 import { random, uniq } from 'lodash'
+import FeatureInstallerFactory from '../../../features/FeatureInstallerFactory'
 import UpdateDependenciesAction from '../../../features/node/actions/UpdateDependenciesAction'
+import SkillFeature from '../../../features/skill/SkillFeature'
 import CommandServiceImpl from '../../../services/CommandService'
 import AbstractCliTest from '../../../tests/AbstractCliTest'
 import { NpmPackage } from '../../../types/cli.types'
@@ -10,6 +12,7 @@ export default class UpdateDependencies2Test extends AbstractCliTest {
 
     protected static async beforeEach() {
         await super.beforeEach()
+        FeatureInstallerFactory.setFeature('skill', SpySkillFeature)
         this.action = this.Action('node', 'updateDependencies')
     }
 
@@ -19,8 +22,12 @@ export default class UpdateDependencies2Test extends AbstractCliTest {
 
         this.Service('pkg').set({ path: 'dependencies.axios', value: '0.0.1' })
 
-        const skill = this.featureInstaller.getFeature('skill')
-        skill.packageDependencies.push({
+        debugger
+        const skill = this.featureInstaller.getFeature(
+            'skill'
+        ) as SpySkillFeature
+
+        skill.addPackageDependency({
             name: 'axios',
             version: '0.21.3',
         })
@@ -141,3 +148,9 @@ export default class UpdateDependencies2Test extends AbstractCliTest {
         return name
     }
 }
+
+class SpySkillFeature extends SkillFeature {
+    public addPackageDependency(dependency: NpmPackage) {
+        this._packageDependencies.push(dependency)
+    }
+}

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

@@ -1,4 +1,5 @@
-import { test, assert } from '@sprucelabs/test-utils'
+import { diskUtil, namesUtil, randomUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert, generateId } from '@sprucelabs/test-utils'
 import { errorAssert } from '@sprucelabs/test-utils'
 import SkillStoreImpl from '../../features/skill/stores/SkillStore'
 import AbstractCliTest from '../../tests/AbstractCliTest'
@@ -115,6 +116,48 @@ export default class SkillStoreTest extends AbstractCliTest {
         assert.isEqual(namespace, slug)
     }
 
+    @test()
+    protected static async returnsExpectedModuleInGoProject() {
+        const name = await this.initRandomGoProject()
+        await this.assertCurrentNamespaceEquals(name)
+    }
+
+    @test()
+    protected static async canFindGoModuleInSubdirectory() {
+        const name = await this.initRandomGoProject()
+        const newCwd = this.resolvePath(this.cwd, generateId())
+        diskUtil.createDir(newCwd)
+        this.setCwd(newCwd)
+        this.store = this.SkillStore()
+        await this.assertCurrentNamespaceEquals(name)
+    }
+
+    @test()
+    protected static async throwsNotInGoModuleErrorIfNotInGoProject() {
+        const err = await assert.doesThrowAsync(() =>
+            this.store.getGoModuleName()
+        )
+        errorAssert.assertError(err, 'DIRECTORY_NOT_GO_MODULE', {
+            cwd: this.cwd,
+        })
+    }
+
+    private static async assertCurrentNamespaceEquals(name: string) {
+        const actual = await this.store.loadCurrentSkillsNamespace()
+
+        assert.isEqual(
+            actual,
+            namesUtil.toPascal(name),
+            'Expected namespace to match go module name'
+        )
+    }
+
+    private static async initRandomGoProject() {
+        const name = randomUtil.rand(['my-skill', 'superSkill', 'AwesomeSkill'])
+        await this.go.initGoProject(name)
+        return name
+    }
+
     private static SkillStore(): SkillStoreImpl {
         return this.Store('skill', {})
     }

package/src/__tests__/support/EventFaker.ts

@@ -1,9 +1,63 @@
 import { SpruceSchemas } from '@sprucelabs/mercury-types'
+import { Organization } from '@sprucelabs/spruce-core-schemas'
 import { eventFaker } from '@sprucelabs/spruce-test-fixtures'
 import { generateId } from '@sprucelabs/test-utils'
 import { ListPermContractsTargetAndPayload } from '../../features/permission/stores/PermissionStore'
 
 export default class EventFaker {
+    public async fakeSyncPermissionContracts() {
+        await eventFaker.on('sync-permission-contracts::v2020_12_25', () => {
+            return {
+                contractRecords: [],
+            }
+        })
+    }
+    public async fakeRegisterEvents(cb?: () => void) {
+        await eventFaker.on('register-events::v2020_12_25', () => {
+            cb?.()
+            return {
+                fqens: [],
+            }
+        })
+    }
+    public async fakeGetEventContracts() {
+        await eventFaker.on('get-event-contracts::v2020_12_25', () => {
+            return {
+                contracts: [
+                    {
+                        id: generateId(),
+                        eventSignatures: {},
+                    },
+                ],
+            }
+        })
+    }
+    public async fakeCreateOrganization(
+        cb?: (
+            targetAndPayload: CreateOrganizationTargetAndPayload
+        ) => void | Organization
+    ) {
+        await eventFaker.on(
+            'create-organization::v2020_12_25',
+            (targetAndPayload) => {
+                return {
+                    organization:
+                        cb?.(targetAndPayload) ??
+                        this.generateOrganizationValues(),
+                }
+            }
+        )
+    }
+
+    public generateOrganizationValues(): Organization {
+        return {
+            id: generateId(),
+            name: generateId(),
+            slug: generateId(),
+            dateCreated: Date.now(),
+        }
+    }
+
     public async fakeListSkills(cb?: () => void | ListSkill[]) {
         await eventFaker.on('list-skills::v2020_12_25', () => {
             return {
@@ -52,3 +106,5 @@ export default class EventFaker {
 }
 
 export type ListSkill = SpruceSchemas.Mercury.v2020_12_25.ListSkillsSkill
+export type CreateOrganizationTargetAndPayload =
+    SpruceSchemas.Mercury.v2020_12_25.CreateOrganizationEmitTargetAndPayload

package/src/cli/Cli.ts

@@ -7,6 +7,7 @@ import { SpruceSchemas } from '@sprucelabs/mercury-types'
 import {
     HealthCheckResults,
     HEALTH_DIVIDER,
+    SettingsService,
 } from '@sprucelabs/spruce-skill-utils'
 import { templates } from '@sprucelabs/spruce-templates'
 import { DEFAULT_HOST } from '../constants'
@@ -183,19 +184,19 @@ export default class Cli implements CliInterface {
             new TerminalInterface(cwd)) as GraphicsInterface
         let featureInstaller: FeatureInstaller | undefined
 
+        const settings = services.Service(cwd, 'settings')
+
         const writerFactory = new WriterFactory({
             templates,
             ui,
-            settings: services.Service(cwd, 'settings'),
+            settings,
             linter: services.Service(cwd, 'lint'),
         })
 
         const pkg = services.Service(cwd, 'pkg')
 
-        const optionOverrides = this.loadOptionOverrides(pkg)
-        const blockedCommands = this.loadCommandBlocks(
-            services.Service(cwd, 'pkg')
-        )
+        const optionOverrides = this.loadOptionOverrides(pkg, settings)
+        const blockedCommands = this.loadCommandBlocks(pkg)
 
         try {
             const s = pkg.getSkillNamespace()
@@ -287,17 +288,24 @@ export default class Cli implements CliInterface {
         return blocks
     }
 
-    private static loadOptionOverrides(pkg: PkgService): OptionOverrides {
+    private static loadOptionOverrides(
+        pkg: PkgService,
+        settings: SettingsService
+    ): OptionOverrides {
         const mapped: OptionOverrides = {}
+        let overrides: Record<string, string> = {}
 
         if (pkg.doesExist()) {
-            const overrides = pkg.get('skill.commandOverrides')
-
-            Object.keys(overrides ?? {}).forEach((command) => {
-                const options = argParserUtil.parse(overrides[command])
-                mapped[command] = options
-            })
+            overrides = pkg.get('skill.commandOverrides')
         }
+
+        overrides = { ...settings.get('commandOverrides'), ...overrides }
+
+        Object.keys(overrides ?? {}).forEach((command) => {
+            const options = argParserUtil.parse(overrides[command])
+            mapped[command] = options
+        })
+
         return mapped
     }
 

package/src/errors/SpruceError.ts

@@ -281,6 +281,10 @@ export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
                 message = `You already registerd an AI Agent at ${options.promptPath}. If you want to register a new one, delete that file first.`
                 break
 
+            case 'DIRECTORY_NOT_GO_MODULE':
+                message = 'A Directory not go module just happened!'
+                break
+
             default:
                 message = super.friendlyMessage()
         }