@sprucelabs/spruce-cli 28.2.3 → 29.0.0

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

@@ -14,9 +14,6 @@ import { FeatureActionResponse } from '../../features.types'
 import schemaDiskUtil from '../utilities/schemaDisk.utility'
 import ValueTypeBuilder from '../ValueTypeBuilder'
 
-type OptionsSchema =
-    SpruceSchemas.SpruceCli.v2020_07_22.SyncSchemasOptionsSchema
-type Options = SpruceSchemas.SpruceCli.v2020_07_22.SyncSchemasOptions
 export default class SyncAction extends AbstractAction<OptionsSchema> {
     public optionsSchema = syncSchemasActionSchema
     public commandAliases = ['sync.schemas']
@@ -24,12 +21,10 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 
     private readonly schemaWriter = this.Writer('schema')
     private readonly schemaStore = this.Store('schema')
+    private readonly skillStore = this.Store('skill')
 
     public async execute(options: Options): Promise<FeatureActionResponse> {
         const normalizedOptions = this.validateAndNormalizeOptions(options)
-        const isInCoreSchemasModule =
-            this.Service('pkg').get('name') ===
-            '@sprucelabs/spruce-core-schemas'
 
         let {
             schemaTypesDestinationDirOrFile,
@@ -39,7 +34,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
             shouldEnableVersioning,
             globalSchemaNamespace,
             shouldFetchRemoteSchemas,
-            shouldGenerateCoreSchemaTypes = isInCoreSchemasModule,
+            shouldGenerateCoreSchemaTypes,
             shouldFetchLocalSchemas,
             generateFieldTypes,
             generateStandaloneTypesFile,
@@ -54,8 +49,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 
         this.ui.startLoading('Loading details about your skill... 🧐')
 
-        let localNamespace =
-            await this.Store('skill').loadCurrentSkillsNamespace()
+        let localNamespace = await this.skillStore.loadCurrentSkillsNamespace()
         let shouldImportCoreSchemas = true
 
         if (shouldGenerateCoreSchemaTypes) {
@@ -79,6 +73,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
             generateStandaloneTypesFile,
             schemaTypesDestinationDirOrFile,
             fieldTypesDestinationDir,
+            language: this.getProjectLanguage(),
         })
 
         this.ui.startLoading('Generating field types...')
@@ -125,7 +120,6 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 
             if (deleteOrphanedSchemas) {
                 this.ui.startLoading('Identifying orphaned schemas...')
-
                 await schemaDiskUtil.deleteOrphanedSchemas(
                     resolvedSchemaTypesDestinationDirOrFile,
                     schemaTemplateItems
@@ -140,20 +134,30 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
             let valueTypes: ValueTypes | undefined
 
             try {
-                valueTypes = await this.generateValueTypes({
-                    resolvedDestination: resolvedFieldTypesDestination,
-                    fieldTemplateItems,
-                    schemaTemplateItems,
-                    globalSchemaNamespace: globalSchemaNamespace ?? undefined,
-                })
+                valueTypes = this.isInGoProject()
+                    ? undefined
+                    : await this.generateValueTypes({
+                          resolvedDestination: resolvedFieldTypesDestination,
+                          fieldTemplateItems,
+                          schemaTemplateItems,
+                          globalSchemaNamespace:
+                              globalSchemaNamespace ?? undefined,
+                      })
             } catch (err: any) {
                 schemaErrors.push(err)
             }
 
-            if (valueTypes) {
+            if (valueTypes || this.isInGoProject()) {
                 try {
                     this.ui.startLoading('Determining what changed... ⚡️')
 
+                    let goModuleNameAndPath: string | undefined = undefined
+                    if (this.isInGoProject()) {
+                        goModuleNameAndPath = this.skillStore.getGoModuleName({
+                            shouldIncludePathFromCwd: true,
+                        })
+                    }
+
                     typeResults = await this.schemaWriter.writeSchemasAndTypes(
                         resolvedSchemaTypesDestination,
                         {
@@ -162,11 +166,13 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
                             schemaTemplateItems,
                             shouldImportCoreSchemas,
                             valueTypes,
+                            goModuleNameAndPath,
+                            language: this.getProjectLanguage(),
                             globalSchemaNamespace:
                                 globalSchemaNamespace ?? undefined,
-                            typesTemplate: generateStandaloneTypesFile
-                                ? 'schema/core.schemas.types.ts.hbs'
-                                : undefined,
+                            typesTemplate: this.resolveTypesTemplate(
+                                generateStandaloneTypesFile
+                            ),
                         }
                     )
                 } catch (err: any) {
@@ -176,7 +182,10 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         }
 
         const p = resolvedSchemaTypesDestination
-        diskUtil.deleteEmptyDirs(diskUtil.isDir(p) ? p : pathUtil.dirname(p))
+        const dir = diskUtil.isDir(p) ? p : pathUtil.dirname(p)
+        if (diskUtil.doesDirExist(dir)) {
+            diskUtil.deleteEmptyDirs(dir)
+        }
 
         this.ui.stopLoading()
 
@@ -192,6 +201,18 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         })
     }
 
+    private resolveTypesTemplate(
+        generateStandaloneTypesFile: boolean
+    ): string | undefined {
+        if (this.isInGoProject()) {
+            return 'schema/schemas.go.hbs'
+        }
+
+        return generateStandaloneTypesFile
+            ? 'schema/core.schemas.types.ts.hbs'
+            : undefined
+    }
+
     private async optionallyInstallRemoteModules(
         schemaTemplateItems: SchemaTemplateItem[],
         forceInstall?: boolean
@@ -202,6 +223,10 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
                 .filter((i) => !!i)
         ) as string[]
 
+        if (this.isInGoProject()) {
+            return
+        }
+
         const notInstalled: string[] = []
 
         const pkg = this.Service('pkg')
@@ -287,11 +312,12 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
                 },
             })
 
-        const hashSpruceDestination =
-            resolvedSchemaTypesDestinationDirOrFile.replace(
-                diskUtil.resolveHashSprucePath(this.cwd),
-                '#spruce'
-            )
+        const hashSpruceDestination = this.isInGoProject()
+            ? this.cwd
+            : resolvedSchemaTypesDestinationDirOrFile.replace(
+                  diskUtil.resolveHashSprucePath(this.cwd),
+                  '#spruce'
+              )
 
         let total = 0
         let totalNamespaces = 0
@@ -317,11 +343,23 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         return { schemaTemplateItems, schemaErrors }
     }
 
+    private isInGoProject() {
+        return this.getProjectLanguage() === 'go'
+    }
+
     private async generateFieldTemplateItems(options: {
         addonsLookupDir: string
         shouldGenerateFieldTypes: boolean
         resolvedFieldTypesDestination: string
     }) {
+        if (this.isInGoProject()) {
+            return {
+                generateFieldFiles: [],
+                fieldTemplateItems: [],
+                fieldErrors: [],
+            }
+        }
+
         const {
             addonsLookupDir,
             shouldGenerateFieldTypes: generateFieldTypes,
@@ -358,3 +396,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
         return builder.generateValueTypes(options)
     }
 }
+
+type OptionsSchema =
+    SpruceSchemas.SpruceCli.v2020_07_22.SyncSchemasOptionsSchema
+type Options = SpruceSchemas.SpruceCli.v2020_07_22.SyncSchemasOptions

package/src/features/schema/utilities/schemaDisk.utility.ts

@@ -1,6 +1,10 @@
 import pathUtil from 'path'
 import { Schema, SchemaError, SchemaTemplateItem } from '@sprucelabs/schema'
-import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
+import {
+    diskUtil,
+    namesUtil,
+    ProjectLanguage,
+} from '@sprucelabs/spruce-skill-utils'
 import schemaGeneratorUtil from './schemaGenerator.utility'
 
 const schemaDiskUtil = {
@@ -8,25 +12,29 @@ const schemaDiskUtil = {
         destination: string
         schema: Schema
         shouldIncludeFileExtension?: boolean
+        language?: ProjectLanguage
     }) {
-        const {
-            destination,
-            schema,
-            shouldIncludeFileExtension: includeFileExtension,
-        } = options
+        const { destination, schema, shouldIncludeFileExtension, language } =
+            options
 
         if (!schema.namespace) {
             throw new SchemaError({
                 code: 'MISSING_PARAMETERS',
                 parameters: ['namespace'],
+                friendlyMessage: `Schema with id "${schema.id}" is missing a namespace so it can not be written to disk.`,
             })
         }
 
+        const name =
+            language == 'go'
+                ? `${namesUtil.toSnake(schema.id)}.go`
+                : `${schema.id}.schema${shouldIncludeFileExtension === false ? '' : '.ts'}`
+
         return pathUtil.join(
             destination,
             namesUtil.toCamel(schema.namespace),
             schema.version ?? '',
-            `${schema.id}.schema${includeFileExtension === false ? '' : '.ts'}`
+            name
         )
     },
 
@@ -35,23 +43,32 @@ const schemaDiskUtil = {
         generateStandaloneTypesFile: boolean
         schemaTypesDestinationDirOrFile: string
         fieldTypesDestinationDir: string
+        language: ProjectLanguage
     }) {
-        const {
+        let {
             cwd,
             generateStandaloneTypesFile,
             schemaTypesDestinationDirOrFile,
             fieldTypesDestinationDir,
+            language,
         } = options
 
+        if (
+            language === 'go' &&
+            !generateStandaloneTypesFile &&
+            schemaTypesDestinationDirOrFile === '#spruce/schemas'
+        ) {
+            schemaTypesDestinationDirOrFile = 'schemas/schemas.go'
+        }
+
         const resolvedSchemaTypesDestination = diskUtil.resolvePath(
             cwd,
             generateStandaloneTypesFile &&
                 diskUtil.isDirPath(schemaTypesDestinationDirOrFile)
-                ? diskUtil.resolvePath(
+                ? this.resolveStandaloneSchemaTypesFilePath({
                       cwd,
                       schemaTypesDestinationDirOrFile,
-                      'core.schemas.types.ts'
-                  )
+                  })
                 : schemaTypesDestinationDirOrFile
         )
 
@@ -73,6 +90,21 @@ const schemaDiskUtil = {
         }
     },
 
+    resolveStandaloneSchemaTypesFilePath(options: {
+        cwd: string
+        schemaTypesDestinationDirOrFile: string
+    }) {
+        const { cwd, schemaTypesDestinationDirOrFile } = options
+
+        return diskUtil.resolvePath(
+            cwd,
+            schemaTypesDestinationDirOrFile,
+            diskUtil.detectProjectLanguage(cwd) === 'go'
+                ? '../../schemas/core_schemas.go'
+                : 'core.schemas.types.ts'
+        )
+    },
+
     async deleteOrphanedSchemas(
         resolvedDestination: string,
         schemaTemplateItems: SchemaTemplateItem[]

package/src/features/schema/utilities/schemaGenerator.utility.ts

@@ -7,26 +7,27 @@ const schemaGeneratorUtil = {
         lookupDir: string,
         schemas: { id: string; namespace?: string; version?: string }[]
     ): Promise<string[]> {
-        const matches = await globby(
-            pathUtil.join(lookupDir, '/**/*.schema.[t|j]s')
-        )
+        const matches = await globby([
+            pathUtil.join(lookupDir, '/**/*.schema.[t|j]s'),
+            pathUtil.join(lookupDir, '/*/v*/*.go'),
+        ])
+
         const filtered = matches.filter((match) => {
             let found = false
 
             for (const schema of schemas) {
                 const { id, namespace, version } = schema
-                let regexString = `${pathUtil.sep}${id}.schema.[t|j]s`
 
-                if (version) {
-                    regexString = pathUtil.sep + version + regexString
-                }
+                const expectedPath = match.endsWith('.go')
+                    ? this.buildPath(
+                          namesUtil.toSnake(id),
+                          '.go',
+                          namespace,
+                          version
+                      )
+                    : this.buildPath(id, '.schema.', namespace, version)
 
-                if (namespace) {
-                    regexString = namesUtil.toCamel(namespace) + regexString
-                }
-
-                const idx = match.search(new RegExp(regexString))
-                if (idx > -1) {
+                if (match.includes(expectedPath)) {
                     found = true
                     break
                 }
@@ -36,6 +37,25 @@ const schemaGeneratorUtil = {
         })
         return filtered
     },
+
+    buildPath(
+        schemaId: string,
+        suffix: string,
+        namespace?: string,
+        version?: string
+    ): string {
+        let path = pathUtil.sep + schemaId + suffix
+
+        if (version) {
+            path = pathUtil.sep + version + path
+        }
+
+        if (namespace) {
+            path = namesUtil.toCamel(namespace) + path
+        }
+
+        return path
+    },
 }
 
 export default schemaGeneratorUtil

package/src/features/schema/writers/SchemaWriter.ts

@@ -1,7 +1,7 @@
 import path from 'path'
 import pathUtil from 'path'
 import { FieldTemplateItem, SchemaTemplateItem } from '@sprucelabs/schema'
-import { versionUtil } from '@sprucelabs/spruce-skill-utils'
+import { ProjectLanguage, versionUtil } from '@sprucelabs/spruce-skill-utils'
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import {
     LATEST_HANDLEBARS,
@@ -110,13 +110,17 @@ export default class SchemaWriter extends AbstractWriter {
 
     public async writeSchemasAndTypes(
         destinationDirOrFilename: string,
-        options: GenerateSchemaTypesOptions
+        options: Omit<GenerateSchemaTypesOptions, 'valueTypes'> & {
+            valueTypes?: ValueTypes
+            goModuleNameAndPath?: string
+        }
     ): Promise<WriteResults> {
         const {
             fieldTemplateItems,
             schemaTemplateItems,
             valueTypes,
             typesTemplate,
+            language,
         } = options
 
         this.isLintEnabled = false
@@ -132,7 +136,8 @@ export default class SchemaWriter extends AbstractWriter {
         const localItems = schemaTemplateItems.filter((i) => !i.importFrom)
 
         if (localItems.length > 0) {
-            const schemaTypesContents = this.templates.schemasTypes({
+            let schemaTypesContents = this.templates.schemasTypes({
+                language: language === 'go' ? 'go' : 'typescript',
                 schemaTemplateItems: localItems,
                 fieldTemplateItems,
                 valueTypes,
@@ -140,6 +145,17 @@ export default class SchemaWriter extends AbstractWriter {
                 typesTemplate,
             })
 
+            if (language === 'go') {
+                const referencesSchemaType =
+                    schemaTypesContents.split('SpruceSchema.')
+                if (referencesSchemaType.length === 1) {
+                    schemaTypesContents = schemaTypesContents.replace(
+                        'import SpruceSchema "github.com/sprucelabsai-community/spruce-schema/v32/pkg/fields"',
+                        ''
+                    )
+                }
+            }
+
             results = await this.writeFileIfChangedMixinResults(
                 resolvedTypesDestination,
                 schemaTypesContents,
@@ -154,7 +170,7 @@ export default class SchemaWriter extends AbstractWriter {
         const allSchemaResults = await this.writeAllSchemas(
             pathUtil.dirname(resolvedTypesDestination),
             {
-                ...options,
+                ...(options as GenerateSchemaTypesOptions),
                 typesFile: resolvedTypesDestination,
             }
         )
@@ -172,52 +188,61 @@ export default class SchemaWriter extends AbstractWriter {
         destinationDir: string,
         options: GenerateSchemaTypesOptions & { typesFile?: string }
     ): Promise<WriteResults> {
+        const { language } = options
         const results: WriteResults = []
 
         for (const item of options.schemaTemplateItems) {
-            const schemaResults = await this.writeSchema(destinationDir, {
-                ...options,
-                ...item,
-            })
-            results.push(...schemaResults)
+            if (language === 'ts' || (language === 'go' && !item.importFrom)) {
+                const schemaResults = await this.writeSchema(destinationDir, {
+                    ...options,
+                    ...item,
+                })
+                results.push(...schemaResults)
+            }
         }
 
         return results
     }
 
-    public async writeSchema(
+    private async writeSchema(
         destinationDir: string,
         options: {
             schemaTemplateItems: SchemaTemplateItem[]
             fieldTemplateItems: FieldTemplateItem[]
             valueTypes: ValueTypes
             typesFile?: string
+            language?: ProjectLanguage
             registerBuiltSchemas?: boolean
+            goModuleNameAndPath?: string
             shouldImportCoreSchemas: boolean
         } & SchemaTemplateItem
     ) {
-        const {
+        let {
             schemaTemplateItems,
             fieldTemplateItems,
             valueTypes,
             registerBuiltSchemas = true,
+            language,
+            schema,
+            typesFile,
             ...item
         } = options
 
         const resolvedDestination = schemaDiskUtil.resolvePath({
             destination: destinationDir,
-            schema: options.schema,
+            schema,
+            language,
         })
 
-        let typesFile = options.typesFile
-            ? diskUtil.resolveRelativePath(
-                  pathUtil.dirname(resolvedDestination),
-                  options.typesFile
-              )
-            : undefined
+        typesFile = this.resolveTypesFile(typesFile, resolvedDestination)
 
-        if (typesFile) {
-            typesFile = typesFile.replace(pathUtil.extname(typesFile), '')
+        let templateFile =
+            item.importFrom && options.shouldImportCoreSchemas
+                ? `schema/imported.schema.ts.hbs`
+                : undefined
+
+        if (language === 'go') {
+            templateFile = 'schema/schema.go.hbs'
         }
 
         const schemaContents = this.templates.schema({
@@ -227,23 +252,42 @@ export default class SchemaWriter extends AbstractWriter {
             fieldTemplateItems,
             valueTypes,
             typesFile,
-            schemaFile:
-                item.importFrom && options.shouldImportCoreSchemas
-                    ? `schema/imported.schema.ts.hbs`
-                    : undefined,
+            schema,
+            language: language === 'go' ? 'go' : 'typescript',
+            schemaFile: templateFile,
         })
 
         return this.writeFileIfChangedMixinResults(
             resolvedDestination,
             schemaContents,
             `${
-                item.schema.description ? `${item.schema.description} ` : ''
+                schema.description ? `${schema.description} ` : ''
             }This is the schema generated by ${
                 item.id
             }.builder.ts. AUTOGENERATED. DO NOT EDIT.`
         )
     }
 
+    private resolveTypesFile(
+        typesFile: string | undefined,
+        resolvedDestination: string
+    ) {
+        let resolvedType = typesFile
+            ? diskUtil.resolveRelativePath(
+                  pathUtil.dirname(resolvedDestination),
+                  typesFile
+              )
+            : undefined
+
+        if (resolvedType) {
+            resolvedType = resolvedType.replace(
+                pathUtil.extname(resolvedType),
+                ''
+            )
+        }
+        return resolvedType
+    }
+
     public async writeValueTypes(
         destinationDir: string,
         options: {
@@ -297,4 +341,6 @@ export interface GenerateSchemaTypesOptions {
     typesTemplate?: string
     registerBuiltSchemas?: boolean
     shouldImportCoreSchemas: boolean
+    language?: ProjectLanguage
+    goModuleNameAndPath?: string
 }

package/src/features/skill/SkillFeature.ts

@@ -19,7 +19,7 @@ export default class SkillFeature<
     public description = 'The scaffolding needed to run a Skill'
     public readonly installOrderWeight = 100
 
-    public packageDependencies: NpmPackage[] = [
+    protected _packageDependencies: NpmPackage[] = [
         { name: '@sprucelabs/error' },
         { name: '@sprucelabs/spruce-skill-utils' },
         { name: '@sprucelabs/spruce-skill-booter' },

package/src/features/skill/stores/SkillStore.ts

@@ -1,5 +1,6 @@
+import path from 'path'
 import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas'
-import { namesUtil } from '@sprucelabs/spruce-skill-utils'
+import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
 import SpruceError from '../../../errors/SpruceError'
 import AbstractStore, { StoreOptions } from '../../../stores/AbstractStore'
 import { CurrentSkill, RegisteredSkill } from '../../../types/cli.types'
@@ -130,25 +131,66 @@ export default class SkillStoreImpl
         return skill.isRegistered
     }
 
+    public getGoModuleName(options?: { shouldIncludePathFromCwd?: boolean }) {
+        const { shouldIncludePathFromCwd = false } = options || {}
+
+        let goModFile = diskUtil.resolvePath(this.cwd, 'go.mod')
+        if (!diskUtil.doesFileExist(goModFile)) {
+            goModFile = diskUtil.resolvePath(this.cwd, '../go.mod')
+        }
+
+        if (!diskUtil.doesFileExist(goModFile)) {
+            throw new SpruceError({
+                code: 'DIRECTORY_NOT_GO_MODULE',
+                friendlyMessage: `Couldn't find a go.mod file in the current directory or its parent. Are you in a Go module?`,
+                cwd: this.cwd,
+            })
+        }
+        const goModContents = diskUtil.readFile(goModFile)
+        const moduleLine = goModContents.match(/module\s+([^\s]+)/)
+        const goModuleName = moduleLine?.[1] as string
+
+        if (shouldIncludePathFromCwd) {
+            const goModDir = path.dirname(goModFile)
+            const relativePath = this.cwd.replace(goModDir, '')
+
+            if (relativePath) {
+                return `${goModuleName}${relativePath}`
+            }
+        }
+
+        return goModuleName
+    }
+
     private getNamespaceFromPkg() {
+        if (this.isGoModule()) {
+            const module = this.getGoModuleName()
+            const moduleParts = module.split('/') ?? []
+            return moduleParts.pop() as string
+        }
+
         const nameFromPackage = this.Service('pkg').getSkillNamespace()
         if (!nameFromPackage) {
             throw new Error(
                 'You need need to set skill.namespace in the package.json'
             )
         }
-        return nameFromPackage
+        return nameFromPackage as string
+    }
+
+    private isGoModule() {
+        return diskUtil.detectProjectLanguage(this.cwd) === 'go'
     }
 
     public async loadCurrentSkillsNamespace() {
-        const fallback = namesUtil.toPascal(this.getNamespaceFromPkg())
+        const fallback = this.getNamespaceFromPkg()
 
-        if (this.Service('auth').getCurrentSkill()) {
+        if (!this.isGoModule() && this.Service('auth').getCurrentSkill()) {
             const current = await this.loadCurrentSkill()
             return namesUtil.toPascal(current.slug ?? fallback)
         }
 
-        return fallback
+        return namesUtil.toPascal(fallback)
     }
 
     public async setCurrentSkillsNamespace(namespace: string) {

package/src/features/store/StoreFeature.ts

@@ -16,7 +16,7 @@ export default class StoreFeature extends AbstractFeature {
             isRequired: true,
         },
     ]
-    public packageDependencies = [
+    public _packageDependencies = [
         { name: '@sprucelabs/spruce-store-plugin@latest', isDev: false },
         { name: '@sprucelabs/data-stores@latest', isDev: false },
     ]

package/src/features/test/TestFeature.ts

@@ -25,7 +25,7 @@ export default class TestFeature extends AbstractFeature {
         { code: 'skill', isRequired: false },
         { code: 'node', isRequired: true },
     ]
-    public packageDependencies: NpmPackage[] = [
+    public _packageDependencies: NpmPackage[] = [
         { name: '@sprucelabs/test@latest', isDev: true },
         { name: '@sprucelabs/test-utils@latest', isDev: true },
         { name: '@sprucelabs/jest-json-reporter@latest', isDev: true },