@sprucelabs/spruce-cli 18.2.0 → 18.3.1

package/src/features/event/stores/EventStore.ts

@@ -22,43 +22,6 @@ import AbstractStore from '../../../stores/AbstractStore'
 import { InternalUpdateHandler } from '../../../types/cli.types'
 import { eventContractCleanerUtil } from '../../../utilities/eventContractCleaner.utility'
 
-export interface EventStoreFetchEventContractsResponse {
-	errors: SpruceError[]
-	contracts: EventContract[]
-}
-
-type Options = Omit<
-	EventSignature,
-	| 'responsePayloadSchema'
-	| 'emitPayloadSchema'
-	| 'listenPermissionContract'
-	| 'emitPermissionContract'
->
-
-interface EventImport {
-	options?: Options
-	emitPayload?: Schema
-	emitTarget?: Schema
-	responsePayload?: Schema
-	emitPermissions?: PermissionContract
-	listenPermissions?: PermissionContract
-}
-
-const eventFileNamesImportKeyMap = {
-	'event.options.ts': { key: 'options', isSchema: false },
-	'emitPayload.builder.ts': { key: 'emitPayload', isSchema: true },
-	'emitTarget.builder.ts': { key: 'emitTarget', isSchema: true },
-	'responsePayload.builder.ts': { key: 'responsePayload', isSchema: true },
-	'emitPermissions.builder.ts': { key: 'emitPermissions', isSchema: false },
-	'listenPermissions.builder.ts': { key: 'listenPermissions', isSchema: false },
-}
-
-export interface FetchContractsOptions {
-	localNamespace?: string
-	namespaces?: string[]
-	didUpdateHandler?: InternalUpdateHandler
-}
-
 export default class EventStore extends AbstractStore {
 	public name = 'event'
 	protected static contractCache: Record<string, any> = {}
@@ -314,3 +277,40 @@ export default class EventStore extends AbstractStore {
 		EventStore.contractCache = {}
 	}
 }
+
+export interface EventStoreFetchEventContractsResponse {
+	errors: SpruceError[]
+	contracts: EventContract[]
+}
+
+type Options = Omit<
+	EventSignature,
+	| 'responsePayloadSchema'
+	| 'emitPayloadSchema'
+	| 'listenPermissionContract'
+	| 'emitPermissionContract'
+>
+
+interface EventImport {
+	options?: Options
+	emitPayload?: Schema
+	emitTarget?: Schema
+	responsePayload?: Schema
+	emitPermissions?: PermissionContract
+	listenPermissions?: PermissionContract
+}
+
+const eventFileNamesImportKeyMap = {
+	'event.options.ts': { key: 'options', isSchema: false },
+	'emitPayload.builder.ts': { key: 'emitPayload', isSchema: true },
+	'emitTarget.builder.ts': { key: 'emitTarget', isSchema: true },
+	'responsePayload.builder.ts': { key: 'responsePayload', isSchema: true },
+	'emitPermissions.builder.ts': { key: 'emitPermissions', isSchema: false },
+	'listenPermissions.builder.ts': { key: 'listenPermissions', isSchema: false },
+}
+
+export interface FetchContractsOptions {
+	localNamespace?: string
+	namespaces?: string[]
+	didUpdateHandler?: InternalUpdateHandler
+}

package/src/features/eventContract/EventContractFeature.ts

@@ -14,7 +14,12 @@ export default class EventContractFeature extends AbstractFeature {
 	public nameReadable = 'Event Contract'
 	public description =
 		'Pull core Mercury events down and write to single, portable, dependency-free, strongly typed contract.'
-	public dependencies: FeatureDependency[] = []
+	public dependencies: FeatureDependency[] = [
+		{
+			code: 'permission',
+			isRequired: true,
+		},
+	]
 	public packageDependencies = []
 
 	public actionsDir = diskUtil.resolvePath(__dirname, 'actions')

package/src/features/eventContract/actions/PullAction.ts

@@ -1,5 +1,6 @@
 import { buildSchema, SchemaValues } from '@sprucelabs/schema'
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import actionUtil from '../../../utilities/action.utility'
 import AbstractAction from '../../AbstractAction'
 import { FeatureActionResponse } from '../../features.types'
 
@@ -30,7 +31,8 @@ export default class PullAction extends AbstractAction<PullOptionsSchema> {
 		destination = diskUtil.resolvePath(this.cwd, destination, filename)
 
 		const { contracts } = await this.Store('event').fetchEventContracts()
-		let buildEventContractImport = `import { buildEventContract } from '@sprucelabs/mercury-types'`
+		let buildEventContractImport = `import { buildEventContract } from '@sprucelabs/mercury-types'
+import '${'#spruce'}/permissions/permissions.types'`
 
 		const contents = `${buildEventContractImport}
 const eventContracts = [${contracts
@@ -48,7 +50,9 @@ export type CoreEventContract = ${contracts
 
 		diskUtil.writeFile(destination, contents)
 
-		return {
+		const results = await this.Action('permission', 'sync').execute({})
+
+		return actionUtil.mergeActionResults(results, {
 			files: [
 				{
 					name: filename,
@@ -57,6 +61,6 @@ export type CoreEventContract = ${contracts
 					description: 'All your Mercury core events ready for testing!',
 				},
 			],
-		}
+		})
 	}
 }

package/src/features/features.types.ts

@@ -1,6 +1,6 @@
-import { buildSchema, Schema, SchemaValues } from '@sprucelabs/schema'
+import { SpruceSchemas } from '@sprucelabs/mercury-types'
+import { Schema, SchemaValues } from '@sprucelabs/schema'
 import { Templates } from '@sprucelabs/spruce-templates'
-import generatedFileSchema from '#spruce/schemas/spruceCli/v2020_07_22/generatedFile.schema'
 import { GlobalEmitter } from '../GlobalEmitter'
 import ServiceFactory from '../services/ServiceFactory'
 import StoreFactory from '../stores/StoreFactory'
@@ -58,50 +58,13 @@ export interface InstallFeatureOptions {
 	didUpdateHandler?: InternalUpdateHandler
 }
 
-export const actionResponseSchema = buildSchema({
-	id: 'actionResponse',
-	fields: {
-		files: {
-			type: 'schema',
-			isArray: true,
-			options: {
-				schema: generatedFileSchema,
-			},
-		},
-		headline: {
-			type: 'text',
-		},
-		hints: {
-			type: 'text',
-			isArray: true,
-		},
-		summaryLines: {
-			type: 'text',
-			isArray: true,
-		},
-		errors: {
-			type: 'raw',
-			isArray: true,
-			options: {
-				valueType: 'SpruceError<any>',
-			},
-		},
-		meta: {
-			type: 'raw',
-			options: {
-				valueType: 'Record<string, any>',
-			},
-		},
-	},
-})
-
 export interface FeatureInstallResponse {
 	files?: GeneratedFile[]
 	packagesInstalled?: NpmPackage[]
 }
 
-export type FeatureActionResponse = SchemaValues<typeof actionResponseSchema> &
-	FeatureInstallResponse
+export type FeatureActionResponse =
+	SpruceSchemas.SpruceCli.v2020_07_22.ActionResponse & FeatureInstallResponse
 
 export interface FeatureAction<S extends Schema = Schema> {
 	optionsSchema?: S

package/src/features/log/LogFeature.ts

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

package/src/features/node/NodeFeature.ts

@@ -78,7 +78,7 @@ export default class NodeFeature<
 					'Code rebuilt successfully.',
 				],
 			}
-		} catch (err) {
+		} catch (err: any) {
 			return {
 				errors: [err],
 			}

package/src/features/organization/actions/InstallAction.ts

@@ -68,7 +68,7 @@ export default class InstallAction extends AbstractAction<OptionsSchema> {
 			return {
 				summaryLines: ['Skill installed!'],
 			}
-		} catch (err) {
+		} catch (err: any) {
 			return {
 				errors: [err],
 			}

package/src/features/permission/PermissionFeature.ts

@@ -1,24 +1,81 @@
-import { diskUtil } from '@sprucelabs/spruce-skill-utils'
-import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
+import { PermissionContractMap } from '@sprucelabs/mercury-types'
+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,
+			{} as PermissionContractMap
+		)
+	}
+
+	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
+			},
+			{} as any
+		)
+
 		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,63 @@
-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(cwd: string, map: PermissionContractMap) {
 		const destination = diskUtil.resolveHashSprucePath(
-			destinationDir,
+			cwd,
 			'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 +91,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
+}