@sprucelabs/spruce-cli/src/features/permission/writers/PermissionWriter.ts

Command line interface for building Spruce skills.

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(cwd: string, map: PermissionContractMap) {
        const destination = diskUtil.resolveHashSprucePath(
            cwd,
            'permissions',
            'permissions.types.ts'
        )

        const keys = Object.keys(map)
        keys.sort()
        const sorted: Partial<PermissionContractMap> = {}
        for (const key of keys) {
            map[key].sort((a, b) => a.localeCompare(b))
            sorted[key] = map[key]
        }

        const contents = this.templates.permissionTypes({
            contracts: sorted as PermissionContractMap,
        })

        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: {
            nameReadable: string
            nameKebab: string
            nameCamel: string
            description?: string
        }
    ) {
        const { nameReadable, nameKebab, nameCamel, description } = options

        const destination = diskUtil.resolvePath(
            destinationDir,
            `${nameKebab}.permissions.ts`
        )

        const content = this.templates.permissionContractBuilder({
            nameCamel,
            nameKebab,
            description,
            nameReadable,
        })

        const files = await this.writeFileIfChangedMixinResults(
            destination,
            content,
            'Your brand new permissions contract!'
        )

        return files
    }

    public writePlugin(cwd: string) {
        debugger
        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
    }
}