@sprucelabs/spruce-cli 18.2.0 → 18.3.0

package/src/features/permission/PermissionFeature.ts

@@ -1,24 +1,79 @@
-import { diskUtil } from '@sprucelabs/spruce-skill-utils'
-import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
+import { diskUtil, NpmPackage } from '@sprucelabs/spruce-skill-utils'
+import AbstractFeature, {
+	FeatureDependency,
+	FeatureOptions,
+	InstallResults,
+} from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
+import PermissionWriter from './writers/PermissionWriter'
 
 export default class PermissionFeature extends AbstractFeature {
 	public code: FeatureCode = 'permission'
 	public nameReadable = 'permission'
 	public description = 'Manage permissions for your skill'
-	public dependencies: FeatureDependency[] = [
-		{
-			code: 'skill',
-			isRequired: true,
-		},
+	public dependencies: FeatureDependency[] = []
+	public actionsDir = diskUtil.resolvePath(__dirname, 'actions')
+	public packageDependencies: NpmPackage[] = [
 		{
-			code: 'event',
-			isRequired: true,
+			name: '@sprucelabs/spruce-permission-plugin@latest',
 		},
 	]
-	public packageDependencies = []
+	private writer: PermissionWriter
 
-	public actionsDir = diskUtil.resolvePath(__dirname, 'actions')
+	public constructor(options: FeatureOptions) {
+		super(options)
+		this.writer = this.Writer('permission')
+
+		void this.emitter.on(
+			'feature.did-execute',
+			this.handleDidExecuteAction.bind(this)
+		)
+	}
+
+	public async handleDidExecuteAction({
+		featureCode,
+		actionCode,
+	}: {
+		featureCode: string
+		actionCode: string
+	}) {
+		const isInstalled = await this.features.isInstalled('permission')
+		const isSkillInstalled = await this.features.isInstalled('skill')
+
+		if (
+			isSkillInstalled &&
+			isInstalled &&
+			featureCode === 'node' &&
+			actionCode === 'upgrade'
+		) {
+			const combinedFile = await this.writePlugin()
+			const results = await this.Action('permission', 'sync').execute({})
+
+			results.files = [...(results.files ?? []), ...combinedFile]
+			return results
+		}
+
+		return {}
+	}
+
+	public async afterPackageInstall(): Promise<InstallResults> {
+		const files = await this.writePlugin()
+		const combinedFile = await this.writeTypesFile()
+
+		return {
+			files: [...files, ...combinedFile],
+		}
+	}
+
+	private async writeTypesFile() {
+		return await this.writer.writeTypesFile(this.cwd, {
+			contracts: [],
+		})
+	}
+
+	private async writePlugin() {
+		return this.writer.writePlugin(this.cwd)
+	}
 }
 
 declare module '../../features/features.types' {

package/src/features/permission/actions/CreateAction.ts

@@ -26,6 +26,8 @@ export default class CreateAction extends AbstractAction<OptionsSchema> {
 			description,
 		})
 
+		await this.Action('permission', 'sync').execute({})
+
 		return {
 			files,
 		}

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

@@ -1,16 +1,35 @@
 import { buildSchema } from '@sprucelabs/schema'
 import AbstractAction from '../../AbstractAction'
-import { FeatureActionResponse } from '../../features.types'
+import { ActionOptions, FeatureActionResponse } from '../../features.types'
+import PermissionStore from '../stores/PermissionStore'
+import PermissionWriter from '../writers/PermissionWriter'
 
 export default class SyncAction extends AbstractAction<OptionsSchema> {
 	public invocationMessage = 'Syncing permissions... 🛡'
 	public optionsSchema = schema
+	public readonly commandAliases: string[] = ['sync.permissions']
+
+	private permissions: PermissionStore
+	private writer: PermissionWriter
+
+	public constructor(options: ActionOptions) {
+		super(options)
+		this.permissions = this.Store('permission')
+		this.writer = this.Writer('permission')
+	}
 
 	public async execute(): Promise<FeatureActionResponse> {
-		const files = await this.Writer('permission').writeTypesFile(this.cwd)
+		const map = await this.permissions.fetchContracts()
+		const typesFiles = await this.writer.writeTypesFile(this.cwd, map)
+
+		const local = await this.permissions.loadLocalPermissions()
+		const combinedFiles = await this.writer.writeCombinedFile(this.cwd, {
+			contracts: local,
+		})
 
 		return {
-			files,
+			files: [...typesFiles, ...combinedFiles],
+			summaryLines: ['Permissions synced'],
 		}
 	}
 }

package/src/features/permission/stores/PermissionStore.ts

@@ -9,28 +9,43 @@ import AbstractStore from '../../../stores/AbstractStore'
 export default class PermissionStore extends AbstractStore {
 	public name = 'permission'
 
-	private async loadLocalPermissions() {
+	public async loadLocalPermissions() {
 		const matches = await globby('**/*.permissions.ts', {
 			cwd: this.cwd,
 		})
 
-		const map: PermissionContractMap = {}
+		const namespace = this.Service('pkg').getSkillNamespace()
+		const imported: ImportedPermission[] = []
 
 		for (const file of matches) {
+			const path = diskUtil.resolvePath(this.cwd, file)
 			const contract = (await this.Service('import').importDefault(
-				diskUtil.resolvePath(this.cwd, file)
+				path
 			)) as PermissionContract
 
-			map[contract.id] = contract.permissions.map((p) => p.id)
+			imported.push({
+				id: `${namespace}.${contract.id}`,
+				permissions: contract.permissions.map((p) => p.id),
+				path,
+			})
 		}
 
-		return map
+		return imported
 	}
 
 	public async fetchContracts() {
-		const client = await this.connectToApi()
+		const client = await this.connectToApi({ shouldAuthAsCurrentSkill: true })
 		const deps = this.Service('dependency').get()
 
+		const local = await this.loadLocalPermissions()
+		const map: PermissionContractMap = local.reduce<PermissionContractMap>(
+			(map, local) => {
+				map[local.id] = local.permissions
+				return map
+			},
+			{}
+		)
+
 		const [{ permissionContracts }] = await client.emitAndFlattenResponses(
 			'list-permission-contracts::v2020_12_25',
 			{
@@ -40,8 +55,6 @@ export default class PermissionStore extends AbstractStore {
 			}
 		)
 
-		const map: PermissionContractMap = await this.loadLocalPermissions()
-
 		for (const result of permissionContracts) {
 			map[result.contract.id] = result.contract.permissions.map((p) => p.id)
 		}
@@ -49,3 +62,9 @@ export default class PermissionStore extends AbstractStore {
 		return map
 	}
 }
+
+export interface ImportedPermission {
+	id: string
+	permissions: string[]
+	path: string
+}

package/src/features/permission/writers/PermissionWriter.ts

@@ -1,23 +1,66 @@
-import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { PermissionContractMap } from '@sprucelabs/mercury-types'
+import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
 import AbstractWriter from '../../../writers/AbstractWriter'
+import { ImportedPermission } from '../stores/PermissionStore'
 
 export default class PermissionWriter extends AbstractWriter {
-	public async writeTypesFile(destinationDir: string) {
+	public async writeTypesFile(
+		destinationDir: string,
+		map: PermissionContractMap
+	) {
 		const destination = diskUtil.resolveHashSprucePath(
 			destinationDir,
 			'permissions',
 			'permissions.types.ts'
 		)
 
+		const contents = this.templates.permissionTypes({ contracts: map })
+
 		const files = await this.writeFileIfChangedMixinResults(
 			destination,
-			'',
+			contents,
 			'Types file for any permission contracts you created or depend on.'
 		)
 
 		return files
 	}
 
+	public async writeCombinedFile(
+		destinationDir: string,
+		options: {
+			contracts: ImportedPermission[]
+		}
+	) {
+		const { contracts } = options
+
+		const destinationPath = diskUtil.resolveHashSprucePath(
+			destinationDir,
+			'permissions'
+		)
+		const destinationFile = diskUtil.resolvePath(
+			destinationPath,
+			'permissions.ts'
+		)
+
+		const local = contracts.map((c) => ({
+			nameCamel: namesUtil.toCamel(c.id),
+			path: diskUtil.resolveRelativePath(
+				destinationPath,
+				c.path.replace('.ts', '')
+			),
+		}))
+
+		const content = this.templates.permissions({ contracts: local })
+
+		const files = await this.writeFileIfChangedMixinResults(
+			destinationFile,
+			content,
+			'Import of all permission contracts for loading on boot!'
+		)
+
+		return files
+	}
+
 	public async writeContract(
 		destinationDir: string,
 		options: {
@@ -51,4 +94,22 @@ export default class PermissionWriter extends AbstractWriter {
 
 		return files
 	}
+
+	public writePlugin(cwd: string) {
+		const destination = diskUtil.resolveHashSprucePath(
+			cwd,
+			'features',
+			'permission.plugin.ts'
+		)
+
+		const pluginContents = this.templates.permissionPlugin()
+
+		const results = this.writeFileIfChangedMixinResults(
+			destination,
+			pluginContents,
+			'Enable permission support in your skill.'
+		)
+
+		return results
+	}
 }

package/src/features/person/PersonFeature.ts

@@ -17,7 +17,7 @@ export default class PersonFeature extends AbstractFeature {
 	public actionsDir = diskUtil.resolvePath(__dirname, 'actions')
 
 	public isInstalled = () => {
-		return this.featureInstaller.isInstalled('skill')
+		return this.features.isInstalled('skill')
 	}
 }
 

package/src/features/sandbox/SandboxFeature.ts

@@ -27,9 +27,7 @@ export default class SandboxFeature extends AbstractFeature {
 		super(options)
 
 		void this.emitter.on('feature.will-execute', async (payload) => {
-			const isSkillInstalled = await this.featureInstaller.isInstalled(
-				'sandbox'
-			)
+			const isSkillInstalled = await this.features.isInstalled('sandbox')
 			if (
 				isSkillInstalled &&
 				payload.featureCode === 'node' &&

package/src/features/schema/SchemaFeature.ts

@@ -7,16 +7,6 @@ import AbstractFeature, {
 } from '../AbstractFeature'
 import { FeatureCode } from '../features.types'
 
-declare module '../../features/features.types' {
-	interface FeatureMap {
-		schema: SchemaFeature
-	}
-
-	interface FeatureOptionsMap {
-		schema: undefined
-	}
-}
-
 export default class SchemaFeature extends AbstractFeature {
 	public nameReadable = 'Schema'
 	public description = 'Define, validate, and normalize everything.'
@@ -59,8 +49,8 @@ export default class SchemaFeature extends AbstractFeature {
 		actionCode: string
 		featureCode: string
 	}) {
-		const isInstalled = await this.featureInstaller.isInstalled('schema')
-		const isSkillInstalled = await this.featureInstaller.isInstalled('skill')
+		const isInstalled = await this.features.isInstalled('schema')
+		const isSkillInstalled = await this.features.isInstalled('skill')
 
 		if (
 			payload.featureCode === 'node' &&
@@ -79,7 +69,7 @@ export default class SchemaFeature extends AbstractFeature {
 		actionCode: string
 		featureCode: string
 	}) {
-		const isInstalled = await this.featureInstaller.isInstalled('schema')
+		const isInstalled = await this.features.isInstalled('schema')
 
 		if (
 			payload.featureCode === 'node' &&
@@ -98,7 +88,7 @@ export default class SchemaFeature extends AbstractFeature {
 	}
 
 	public async afterPackageInstall(): Promise<InstallResults> {
-		const isSkillInstalled = await this.featureInstaller.isInstalled('skill')
+		const isSkillInstalled = await this.features.isInstalled('skill')
 
 		if (!isSkillInstalled) {
 			return {}
@@ -115,3 +105,13 @@ export default class SchemaFeature extends AbstractFeature {
 		return this.Writer('schema').writePlugin(this.cwd)
 	}
 }
+
+declare module '../../features/features.types' {
+	interface FeatureMap {
+		schema: SchemaFeature
+	}
+
+	interface FeatureOptionsMap {
+		schema: undefined
+	}
+}

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

@@ -15,21 +15,6 @@ import SpruceError from '../../../errors/SpruceError'
 import AbstractWriter, { WriteResults } from '../../../writers/AbstractWriter'
 import schemaDiskUtil from '../utilities/schemaDisk.utility'
 
-interface WriteFieldTypesOptions {
-	fieldTemplateItems: FieldTemplateItem[]
-}
-
-// eslint-disable-next-line no-redeclare
-export interface GenerateSchemaTypesOptions {
-	fieldTemplateItems: FieldTemplateItem[]
-	schemaTemplateItems: SchemaTemplateItem[]
-	valueTypes: ValueTypes
-	globalSchemaNamespace?: string
-	typesTemplate?: string
-	registerBuiltSchemas?: boolean
-	shouldImportCoreSchemas: boolean
-}
-
 export default class SchemaWriter extends AbstractWriter {
 	private readonly fieldTemplates: {
 		filename: string
@@ -289,3 +274,17 @@ export default class SchemaWriter extends AbstractWriter {
 		return results
 	}
 }
+
+interface WriteFieldTypesOptions {
+	fieldTemplateItems: FieldTemplateItem[]
+}
+
+export interface GenerateSchemaTypesOptions {
+	fieldTemplateItems: FieldTemplateItem[]
+	schemaTemplateItems: SchemaTemplateItem[]
+	valueTypes: ValueTypes
+	globalSchemaNamespace?: string
+	typesTemplate?: string
+	registerBuiltSchemas?: boolean
+	shouldImportCoreSchemas: boolean
+}

package/src/features/skill/SkillFeature.ts

@@ -11,22 +11,6 @@ import universalFileDescriptions from '../universalFileDescriptions'
 import universalScripts from '../universalScripts'
 import Updater from './updaters/Updater'
 
-type SkillFeatureOptionsSchema =
-	SpruceSchemas.SpruceCli.v2020_07_22.SkillFeatureSchema
-type SkillFeatureOptions = SpruceSchemas.SpruceCli.v2020_07_22.SkillFeature
-
-declare module '../../features/features.types' {
-	interface FeatureMap {
-		skill: SkillFeature
-	}
-
-	interface FeatureOptionsMap {
-		skill: SchemaValues<SkillFeatureOptionsSchema>
-	}
-}
-
-type UpgradeOptions = SpruceSchemas.SpruceCli.v2020_07_22.UpgradeSkillOptions
-
 export default class SkillFeature<
 	S extends SkillFeatureOptionsSchema = SkillFeatureOptionsSchema
 > extends AbstractFeature<S> {
@@ -120,7 +104,7 @@ export default class SkillFeature<
 					name: 'AbstractSpruceFixtureTest',
 					label: 'AbstractSpruceFixtureTest',
 					import: '@sprucelabs/spruce-test-fixtures',
-					featureCode: 'skill',
+					featureCode: 'node',
 				},
 			],
 		}
@@ -191,7 +175,7 @@ export default class SkillFeature<
 		options?: UpgradeOptions
 	}) {
 		const { featureCode, actionCode, options: upgradeOptions } = options
-		const isInstalled = await this.featureInstaller.isInstalled('skill')
+		const isInstalled = await this.features.isInstalled('skill')
 
 		if (isInstalled && featureCode === 'node' && actionCode === 'upgrade') {
 			const updater = new Updater(this, this.emitter)
@@ -204,3 +188,19 @@ export default class SkillFeature<
 		return {}
 	}
 }
+
+type SkillFeatureOptionsSchema =
+	SpruceSchemas.SpruceCli.v2020_07_22.SkillFeatureSchema
+type SkillFeatureOptions = SpruceSchemas.SpruceCli.v2020_07_22.SkillFeature
+
+declare module '../../features/features.types' {
+	interface FeatureMap {
+		skill: SkillFeature
+	}
+
+	interface FeatureOptionsMap {
+		skill: SchemaValues<SkillFeatureOptionsSchema>
+	}
+}
+
+type UpgradeOptions = SpruceSchemas.SpruceCli.v2020_07_22.UpgradeSkillOptions

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

@@ -43,7 +43,7 @@ export default class RebuildAction extends AbstractAction<OptionsSchema> {
 					InFlightEntertainment?.writeStatus(data)
 				},
 			})
-		} catch (err) {
+		} catch (err: any) {
 			this.resetUi()
 
 			return {

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

@@ -67,7 +67,7 @@ export default class RegisterAction extends AbstractAction<OptionsSchema> {
 					skill,
 				},
 			}
-		} catch (err) {
+		} catch (err: any) {
 			return {
 				hints: [
 					`If you've already registered your skill, try 'spruce login.skill'!`,

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

@@ -99,8 +99,7 @@ export default class SkillStore extends AbstractStore {
 	}
 
 	private getNamespaceFromPkg() {
-		const pkg = this.Service('pkg')
-		const nameFromPackage = pkg.get('skill.namespace')
+		const nameFromPackage = this.Service('pkg').getSkillNamespace()
 		if (!nameFromPackage) {
 			throw new Error(
 				'You need need to set skill.namespace in the package.json'

package/src/features/store/StoreFeature.ts

@@ -59,7 +59,7 @@ export default class StoreFeature extends AbstractFeature {
 		featureCode: string
 		actionCode: string
 	}) {
-		const isInstalled = await this.featureInstaller.isInstalled('store')
+		const isInstalled = await this.features.isInstalled('store')
 
 		const isUpgrade =
 			isInstalled &&

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

@@ -40,7 +40,7 @@ export default class SyncAction extends AbstractAction<OptionsSchema> {
 			return {
 				files,
 			}
-		} catch (err) {
+		} catch (err: any) {
 			return {
 				errors: [err],
 			}

package/src/features/test/TestFeature.ts

@@ -123,7 +123,7 @@ export default class TestFeature extends AbstractFeature {
 				const a = { ...ac, isDefaultExport: false }
 
 				if (ac.featureCode) {
-					const isInstalled = await this.featureInstaller.isInstalled(
+					const isInstalled = await this.features.isInstalled(
 						ac.featureCode as any
 					)
 

package/src/features/view/ViewFeature.ts

@@ -48,7 +48,7 @@ export default class ViewFeature extends AbstractFeature {
 
 		void this.emitter.on('feature.did-execute', async (payload) => {
 			const { featureCode, actionCode } = payload
-			const isInstalled = await this.featureInstaller.isInstalled('view')
+			const isInstalled = await this.features.isInstalled('view')
 
 			if (isInstalled && featureCode === 'node' && actionCode === 'upgrade') {
 				const files = await this.Writer('view').writePlugin(this.cwd)

package/src/schemas/v2020_07_22/actionResponse.builder.ts

@@ -0,0 +1,62 @@
+import { buildSchema } from '@sprucelabs/schema'
+import generatedFileBuilder from './generatedFile.builder'
+
+export default buildSchema({
+	id: 'actionResponse',
+	name: 'Action response',
+	importsWhenLocal: [`import AbstractSpruceError from '@sprucelabs/error'`],
+	fields: {
+		files: {
+			type: 'schema',
+			isArray: true,
+			options: {
+				schema: generatedFileBuilder,
+			},
+		},
+		headline: {
+			type: 'text',
+		},
+		hints: {
+			type: 'text',
+			isArray: true,
+		},
+		summaryLines: {
+			type: 'text',
+			isArray: true,
+		},
+		errors: {
+			type: 'raw',
+			isArray: true,
+			options: {
+				valueType: 'AbstractSpruceError<any>',
+			},
+		},
+		meta: {
+			type: 'raw',
+			options: {
+				valueType: 'Record<string, any>',
+			},
+		},
+		packagesInstalled: {
+			type: 'schema',
+			isArray: true,
+			options: {
+				schema: buildSchema({
+					id: 'npmPackage',
+					fields: {
+						name: {
+							type: 'text',
+							isRequired: true,
+						},
+						version: {
+							type: 'text',
+						},
+						isDev: {
+							type: 'boolean',
+						},
+					},
+				}),
+			},
+		},
+	},
+})

package/src/schemas/v2020_07_22/generatedFile.builder.ts

@@ -0,0 +1,44 @@
+import { buildSchema } from '@sprucelabs/schema'
+
+const generatedFileBuilder = buildSchema({
+	id: 'generatedFile',
+	fields: {
+		name: {
+			type: 'text',
+			isRequired: true,
+		},
+		path: {
+			type: 'text',
+			isRequired: true,
+		},
+		description: {
+			type: 'text',
+		},
+		action: {
+			type: 'select',
+			isRequired: true,
+			options: {
+				choices: [
+					{
+						label: 'Skipped',
+						value: 'skipped',
+					},
+					{
+						label: 'Generated',
+						value: 'generated',
+					},
+					{
+						label: 'Updated',
+						value: 'updated',
+					},
+					{
+						label: 'Deleted',
+						value: 'deleted',
+					},
+				],
+			},
+		},
+	},
+})
+
+export default generatedFileBuilder