@sprucelabs/spruce-templates 24.1.32 → 25.0.0

package/build/dist/templates/typescript/event/events.contract.ts.hbs

@@ -0,0 +1,24 @@
+{{#if shouldImportCoreEvents}}import { coreEventContracts } from '@sprucelabs/mercury-core-events'{{/if}}
+
+{{#each contracts}}
+import {{namespaceCamel}}{{namePascal}}EventContract_{{version}}, { {{namePascal}}EventContract as {{namespacePascal}}{{namePascal}}EventContract_{{version}}  } from '#spruce/events/{{ namespaceCamel }}/{{ nameCamel }}.{{ version }}.contract'
+{{/each}}
+
+export default [
+    {{#each contracts}}
+    {{namespaceCamel}}{{namePascal}}EventContract_{{version}},
+    {{/each}}
+    {{#if shouldImportCoreEvents}}...coreEventContracts,{{/if}}
+]
+
+declare module '{{skillEventContractTypesFile}}' {
+    interface SkillEventSignatures {
+    {{#each contracts}}
+    
+    {{#each eventSignatures}}
+    '{{@key}}': {{../namespacePascal}}{{../namePascal}}EventContract_{{../version}}['eventSignatures']['{{@key}}'],
+    {{/each}}
+    
+    {{/each}}
+    }
+}

package/build/dist/templates/typescript/event/listener.ts.hbs

@@ -0,0 +1,23 @@
+import SpruceError from '#spruce/../errors/SpruceError'
+import { SpruceEvent, SpruceEventResponse } from '@sprucelabs/spruce-event-utils'
+{{#if emitPayloadSchemaTemplateItem}}import { SkillEventContract } from '@sprucelabs/mercury-types'{{/if}}
+{{#if shouldImportGlobalSchema}}import { {{globalSchemaNamespace}} } from '{{schemaTypesFile}}'{{/if}}
+
+export default async (event: SpruceEvent{{#if emitPayloadSchemaTemplateItem}}<SkillEventContract, EmitPayload>{{/if}}): SpruceEventResponse{{#if responsePayloadSchemaTemplateItem}}<ResponsePayload>{{/if}} => {
+	console.log(event)
+
+	throw new SpruceError({
+		//@ts-ignore
+		code: 'LISTENER_NOT_IMPLEMENTED',
+		//@ts-ignore
+		fullyQualifiedEventName: '{{fullyQualifiedEventName}}'
+	})
+
+	//return {}
+}
+
+{{#if emitPayloadSchemaTemplateItem}}
+type EmitPayload = {{{ schemaNamespacePath schemaTemplateItem=emitPayloadSchemaTemplateItem }}}
+{{/if}}{{#if responsePayloadSchemaTemplateItem}}
+type ResponsePayload = {{{ schemaNamespacePath schemaTemplateItem=responsePayloadSchemaTemplateItem }}}
+{{/if}}

package/build/dist/templates/typescript/event/listeners.ts.hbs

@@ -0,0 +1,15 @@
+import { EventFeatureListener } from '@sprucelabs/spruce-event-utils'
+
+const listeners: EventFeatureListener[] = [
+    {{#each listeners}}
+    {
+        eventName: '{{eventName}}',
+        eventNamespace: '{{eventNamespace}}',
+        version: '{{version}}',
+        callback: require('{{path}}').default,
+        isGlobal: require('{{path}}').isGlobal,
+    },
+    {{/each}}
+]
+
+export default listeners

package/build/dist/templates/typescript/event/payload.builder.ts.hbs

@@ -0,0 +1,15 @@
+import {
+	buildSchema
+} from '@sprucelabs/schema'
+
+const {{nameCamel}}{{actionCamel}}Builder = buildSchema({
+    id: '{{nameCamel}}{{actionCamel}}',
+    fields: {
+        aTextField: {
+            type: 'text',
+            label: 'Update me',
+        }
+    }
+})
+
+export default {{nameCamel}}{{actionCamel}}Builder

package/build/dist/templates/typescript/log/transport.plugin.ts.hbs

@@ -0,0 +1,14 @@
+import { Level, LogTransport } from '@sprucelabs/spruce-skill-utils'
+
+export default function (): {
+	levels: Level[]
+	transport: LogTransport
+} | null {
+	return {
+		levels: [],
+		transport: (...messageParts: string[]) => {
+			const message = messageParts.join(' ')
+			console.log(message)
+		},
+	}
+}

package/build/dist/templates/typescript/permissions/contract.builder.ts.hbs

@@ -0,0 +1,36 @@
+import {
+    buildPermissionContract
+} from '@sprucelabs/mercury-types'
+
+const {{ nameCamel }}Permissions = buildPermissionContract({
+    id: '{{nameKebab}}',
+    name: '{{{escape nameReadable}}}',
+    description: '{{{escape description}}}',
+    requireAllPermissions: false,
+    permissions: [
+        {
+            id: 'can-high-five',
+            name: 'Can give high five',
+            description: 'Will this person be allowed to high five?',
+            
+            defaults: {
+                /** 
+                  Uncomment this comment to set which roles will pass by default. Keep
+                  in mind this is overridden by the people who install your skill.
+
+                guest: { onPrem: true },
+                owner: { onPrem: true },
+                groupManager: { onPrem: true },
+                manager: { onPrem: true },
+                teammate: { onPrem: true },
+                anonymous: { default: false },
+
+                **/
+               skill: false,
+            },
+            requireAllStatuses: false,
+        }
+    ]
+})
+
+export default {{ nameCamel }}Permissions

package/build/dist/templates/typescript/permissions/permission.plugin.ts.hbs

@@ -0,0 +1 @@
+export { plugin as default } from '@sprucelabs/spruce-permission-plugin'

package/build/dist/templates/typescript/permissions/permissions.ts.hbs

@@ -0,0 +1,13 @@
+import { PermissionContract } from "@sprucelabs/mercury-types"
+{{#each contracts}}
+import {{nameCamel}}PermissionContract from '{{path}}'
+{{/each}}
+
+const contracts: PermissionContract[] = [
+    {{#each contracts}}
+    {{nameCamel}}PermissionContract,
+    {{/each}}
+]
+
+
+export default contracts

package/build/dist/templates/typescript/permissions/permissions.types.ts.hbs

@@ -0,0 +1,14 @@
+import '@sprucelabs/mercury-types'
+
+declare module '@sprucelabs/mercury-types/build/types/mercury.types' {
+	interface PermissionContractMap {
+        {{#each contracts}}
+		'{{@key}}': [
+			{{#each this}}'{{this}}',{{/each}}
+		]
+        {{/each}}
+	}
+}
+
+
+export interface PermissionContractMap {}

package/build/dist/templates/typescript/polish/polish.ts.hbs

@@ -0,0 +1,67 @@
+import { PolishStep } from '@sprucelabs/heartwood-polish'
+
+// Documentation: https://developer.spruce.ai/#/polish/index
+
+const script: PolishStep[] = [
+	/**{
+		redirect: {
+			id: 'heartwood.root',
+		},
+	},
+	{
+		typeText: {
+			target: [['Field', 'phone']],
+			text: '5555555555',
+		},
+	},
+	{
+		assert: {
+			target: [['Field', 'phone']],
+			inputValue: {
+				equals: '+1 555-555-5555',
+			},
+		},
+	},
+	{
+		click: {
+			target: [['Button', 'primary']],
+		},
+	},
+	{
+		typeText: {
+			target: [['Field', 'code']],
+			text: '5555',
+		},
+	},
+	{
+		click: {
+			target: [['NavMenu', 'settings']],
+		},
+	},
+	{
+		click: {
+			target: [['NavLink', 'logout']],
+		},
+	},
+	{
+		click: {
+			target: [['Dialog', 'primary']],
+		},
+	},
+	{
+		typeText: {
+			target: [['Field', 'phone']],
+			text: '555-555-2323',
+		},
+	},
+	{
+		assert: {
+			target: [['Field', 'phone']],
+			inputValue: {
+				equals: '+1 555-555-2323',
+			},
+		},
+	},**/
+]
+
+export default script

package/build/dist/templates/typescript/sandbox/will-boot.listener.ts.hbs

@@ -0,0 +1,172 @@
+import { MercuryClient } from '@sprucelabs/mercury-client'
+import { SchemaError } from '@sprucelabs/schema'
+import { EventFeature } from '@sprucelabs/spruce-event-plugin'
+import {
+    SpruceEvent,
+    SpruceEventResponse,
+    eventResponseUtil,
+} from '@sprucelabs/spruce-event-utils'
+import { EnvService, PkgService } from '@sprucelabs/spruce-skill-utils'
+
+export default async (event: SpruceEvent): SpruceEventResponse => {
+    const sandboxNumber = process.env.SANDBOX_DEMO_NUMBER
+
+    if (sandboxNumber && process.env.SKILL_ID) {
+        const log = event.log.buildLog('Sandbox')
+
+        log.info('Demo sandbox number detected. Checking skill status.')
+
+        const events = event.skill.getFeatureByCode('event') as EventFeature
+
+        const env = new EnvService(event.skill.rootDir)
+        const pkg = new PkgService(event.skill.rootDir)
+
+        process.env.SKILL_ID = (env.get('SKILL_ID') ??
+            process.env.SKILL_ID) as string
+        process.env.SKILL_API_KEY = (env.get('SKILL_API_KEY') ??
+            process.env.SKILL_API_KEY) as string
+
+        try {
+            await events.connectToApi({ shouldWaitForWillBoot: false })
+            return
+        } catch {}
+
+        log.warn('It looks like sandbox was reset. Re-registering.')
+
+        const name = process.env.SKILL_NAME as string
+        const slug = pkg.get(['skill', 'namespace']) as string
+
+        assertRequiredParams(name, slug)
+
+        delete process.env.SKILL_ID
+        delete process.env.SKILL_API_KEY
+
+        const client = (await events.connectToApi({
+            shouldWaitForWillBoot: false,
+        })) as any
+
+        await login(client, sandboxNumber)
+
+        const skill = await registerOrLoginSkill(client, name, slug)
+        await client.emit(`logout::v2020_12_25`)
+
+        await client.authenticate({
+            skillId: skill.id,
+            apiKey: skill.apiKey,
+        })
+
+        env.set('SKILL_ID', skill.id)
+        env.set('SKILL_API_KEY', skill.apiKey)
+    }
+
+    return
+}
+
+async function login(client: any, sandboxNumber: string) {
+    const requestResults = await client.emit('request-pin::v2020_12_25', {
+        payload: {
+            phone: sandboxNumber,
+        },
+    })
+
+    const { challenge } =
+        eventResponseUtil.getFirstResponseOrThrow(requestResults)
+
+    const confirmResults = await client.emit('confirm-pin::v2020_12_25', {
+        payload: {
+            challenge,
+            pin: sandboxNumber.substr(-4),
+        },
+    })
+
+    eventResponseUtil.getFirstResponseOrThrow(confirmResults)
+}
+
+function assertRequiredParams(
+    name: string | undefined,
+    slug: string | undefined
+) {
+    const missing: string[] = []
+
+    if (!name) {
+        missing.push('env.SKILL_NAME')
+    }
+
+    if (!slug) {
+        missing.push('env.SKILL_SLUG')
+    }
+
+    if (missing.length > 0) {
+        throw new SchemaError({
+            code: 'MISSING_PARAMETERS',
+            parameters: missing,
+        })
+    }
+}
+
+async function registerOrLoginSkill(
+    client: MercuryClient,
+    name: string,
+    slug: string
+) {
+    let skill: any
+    try {
+        skill = await registerSkill(client, name, slug)
+    } catch (err: any) {
+        skill = await loginSkill(client, slug)
+    }
+    process.env.SKILL_ID = skill.id
+    process.env.SKILL_API_KEY = skill.apiKey
+
+    return skill
+}
+
+async function registerSkill(
+    client: MercuryClient,
+    name: string,
+    slug: string
+) {
+    const [{ skill }] = await client.emitAndFlattenResponses(
+        'register-skill::v2020_12_25',
+        {
+            payload: {
+                name,
+                description: 'Auto-generate for sandbox',
+                slug,
+            },
+        }
+    )
+
+    return skill
+}
+
+async function loginSkill(client: MercuryClient, slug: string) {
+    const [{ skills }] = await client.emitAndFlattenResponses(
+        'list-skills::v2020_12_25',
+        {
+            payload: {
+                shouldOnlyShowMine: true,
+            },
+        }
+    )
+
+    const match = skills.find((s: any) => s.slug === slug)
+
+	if (!match) {
+		throw new Error(`Could not find skill with slug ${slug}`)
+	}
+
+    const [{ skill }] = await client.emitAndFlattenResponses(
+        'get-skill::v2020_12_25',
+        {
+            target: {
+                skillId: match.id,
+            },
+            payload: {
+                shouldIncludeApiKey: true,
+            },
+        }
+    )
+
+    return skill
+}

package/build/dist/templates/typescript/schema/builder.ts.hbs

@@ -0,0 +1,24 @@
+import  { {{builderFunction}} } from '@sprucelabs/schema'
+
+
+export default {{builderFunction}}({
+	id: '{{nameCamel}}',
+	name: '{{{escape nameReadable}}}',{{#if description}}
+    description: '{{{escape description}}}',{{/if}}{{#if moduleToImportFromWhenRemote}}
+	moduleToImportFromWhenRemote: '{{{escape moduleToImportFromWhenRemote}}}',{{/if}}
+	fields: {
+		fieldName1: {
+			type: 'text',
+			label: 'First Field',
+			isRequired: true
+		},
+		fieldName2: {
+			type: 'number',
+			label: 'Second Field',
+			isRequired: true,
+			hint:
+				'A hint'
+		}
+	}
+})
+

package/build/dist/templates/typescript/schema/core.schemas.types.ts.hbs

@@ -0,0 +1,34 @@
+import { default as SchemaEntity } from '@sprucelabs/schema'
+{{#each imports}}
+import * as {{importAs}} from '{{package}}'
+{{/each}}
+{{#each schemaTemplateItems}}
+
+{{#each imports}}
+{{{this}}}
+{{/each}}
+{{/each}}
+
+
+
+{{#each schemaTemplateItems}}
+
+export declare namespace {{../globalSchemaNamespace}}.{{namespace}}{{#if (isDefined schema.version)}}.{{schema.version}}{{/if}} {
+
+	{{#if schema.description}}/** {{schema.description}} */{{/if}}
+	export interface {{namePascal}} {
+		{{> schemaValues schema=schema renderAs="type" }}
+	}
+
+	export interface {{namePascal}}Schema extends SpruceSchema.Schema {
+		{{> schemaBody namespace=namespace schema=schema renderAs="type" }}
+	}
+
+	export type {{namePascal}}Entity = SchemaEntity<{{../globalSchemaNamespace}}.{{namespace}}{{#if (isDefined schema.version)}}.{{schema.version}}{{/if}}.{{namePascal}}Schema>
+
+}
+
+{{/each}}
+
+
+

package/build/dist/templates/typescript/schema/example.ts.hbs

@@ -0,0 +1,20 @@
+// Importing your schema
+import {{nameCamel}}Schema from '#spruce/schemas/v2020_07_22/{{nameCamel}}.schema'
+
+// Importing interfaces
+import { {{namePascal}}, {{namePascal}}Entity } from '#spruce/schemas/v2020_07_22/{{nameCamel}}.types'
+
+// Create an entity instance based on a schema
+import Entity from '@sprucelabs/schema'
+const {{nameCamel}} = new Entity({{nameCamel}}Schema, values)
+
+// Set a value
+{{nameCamel}}.set('fieldName', newValue);
+
+// Get some values
+{{#each schema.fields}}
+const {{@key}} = {{../nameCamel}}.get('{{@key}}');
+{{/each}}
+
+// ensure it validates
+{{nameCamel}}.validate() // throws SchemaFieldValidationError

package/build/dist/templates/typescript/schema/fields/fieldClassMap.ts.hbs

@@ -0,0 +1,16 @@
+import { fieldClassMap } from '@sprucelabs/schema'
+
+{{#each fieldTemplateItems}}
+{{#if isLocal}}
+import {{className}} from '{{package}}'
+{{/if}}
+{{/each}}
+
+
+{{#each fieldTemplateItems}}
+{{#if isLocal}}
+fieldClassMap.{{camelType}} = {{className}}
+{{/if}}
+{{/each}}
+
+export default fieldClassMap

package/build/dist/templates/typescript/schema/fields/fields.types.ts.hbs

@@ -0,0 +1 @@
+export { FieldDefinitions, FieldDefinitionMap, FieldValueTypeGeneratorMap, FieldMap } from '@sprucelabs/schema'

package/build/dist/templates/typescript/schema/imported.schema.ts.hbs

@@ -0,0 +1 @@
+export { {{nameCamel}}Schema as default } from '{{importFrom}}'

package/build/dist/templates/typescript/schema/partials/fieldDefinitionBody.ts.hbs

@@ -0,0 +1,12 @@
+{{#if field.label}}label: '{{{escape field.label}}}',
+{{/if}}type: {{{fieldTypeEnum field}}}{{#if field.keyName}},
+keyName: '{{{escape field.keyName}}}'{{/if}}{{#if field.isPrivate}},
+isPrivate: true{{/if}}{{#if field.isRequired}},
+isRequired: true{{/if}}{{#if field.hint}},
+hint: '{{{escape field.hint}}}'{{/if}}{{#if (isDefined field.value)}},
+value: {{{json field.value}}}{{/if}}{{#if (isDefined field.defaultValue)}},
+defaultValue: {{{json field.defaultValue}}}{{/if}}{{#if field.isArray}},
+isArray: true{{/if}}{{#if (isDefined field.minArrayLength)}},
+minArrayLength: {{field.minArrayLength}}{{/if}}{{#if field.description}},
+description: '{{{escape field.description}}}'{{/if}},
+options: {{{fieldDefinitionOptions namespace schemaNameCamel schema.version fieldName field renderAs}}}

package/build/dist/templates/typescript/schema/partials/schemaBody.ts.hbs

@@ -0,0 +1,20 @@
+id: '{{{escape schema.id}}}',{{#if schema.version}}
+version: '{{{escape schema.version}}}',{{/if}}{{#if namespace}}
+namespace: '{{{escape namespace}}}',{{/if}}
+name: '{{{escape schema.name}}}',{{#if schema.importsWhenRemote}}
+importsWhenRemote: [{{#each schema.importsWhenRemote}}'{{{escape this}}}',{{/each}}],{{/if}}{{#if schema.moduleToImportFromWhenRemote}}
+moduleToImportFromWhenRemote: '{{{escape schema.moduleToImportFromWhenRemote}}}',{{/if}}{{#if schema.description}}
+description: '{{{escape schema.description}}}',{{/if}}{{#if schema.typeSuffix}}
+typeSuffix: '{{{escape schema.typeSuffix}}}',{{/if}}{{#if schema.dynamicFieldSignature}}
+dynamicFieldSignature: { 
+    {{> fieldDefinitionBody namespace=namespace schemaNameCamel=nameCamel schema=schema fieldName="__dynamicFieldSignature" field=schema.dynamicFieldSignature renderAs=renderAs}} 
+},{{/if}}{{#if schema.fields}}
+    fields: {
+        {{#each schema.fields}}
+            /** {{{label}}}.{{#if hint}} {{{hint}}}{{/if}} */
+            '{{@key}}': {
+                {{> fieldDefinitionBody namespace=../namespace schemaNameCamel=../nameCamel schema=../schema fieldName=@key field=this renderAs=../renderAs  }}
+            },
+        {{/each}}
+    }
+{{/if}}

package/build/dist/templates/typescript/schema/partials/schemaValues.ts.hbs

@@ -0,0 +1,7 @@
+{{#if schema.dynamicFieldSignature }}
+	/** {{schema.dynamicFieldSignature.label}}.{{#if schema.dynamicFieldSignature.hint}} {{schema.dynamicFieldSignature.hint}}{{/if}} */
+	[{{schema.dynamicFieldSignature.keyName}}:string]: {{{valueTypeLiteral namespace nameCamel schema.version "__dynamicFieldSignature" renderAs }}}{{#unless schema.dynamicFieldSignature.isRequired}}| undefined | null{{/unless}}{{/if}}
+{{#each schema.fields}}
+	{{#if (or label hint) }}/** {{{label}}}.{{#if hint}} {{{hint}}}{{/if}} */{{/if}}
+	'{{@key}}'{{#unless isRequired}}?{{/unless}}: {{{valueTypeLiteral ../namespace ../nameCamel ../schema.version @key ../renderAs }}}{{#unless isRequired}} | undefined | null{{/unless}}
+{{/each}}

package/build/dist/templates/typescript/schema/schema.plugin.ts.hbs

@@ -0,0 +1,101 @@
+import fs from 'fs'
+import pathUtil from 'path'
+import globby from '@sprucelabs/globby'
+import { SchemaError } from '@sprucelabs/schema'
+import {
+    SchemaHealthCheckItem,
+    SkillFeature,
+    Skill,
+    diskUtil,
+    HASH_SPRUCE_DIR_NAME,
+    BootCallback,
+} from '@sprucelabs/spruce-skill-utils'
+
+class SchemaFeature implements SkillFeature {
+    private skill: Skill
+    private _isBooted = false
+    private bootHandler?: BootCallback
+
+    public constructor(skill: Skill) {
+        this.skill = skill
+    }
+
+    public onBoot(cb: BootCallback) {
+        this.bootHandler = cb
+    }
+
+    public execute = async () => {
+        if (process.env.SHOULD_VALIDATE_SCHEMAS_ON_BOOT !== 'false') {
+            await this.loadSchemas()
+        }
+        this._isBooted = true
+        void this.bootHandler?.()
+    }
+
+    public checkHealth = async () => {
+        const schemas = await this.loadSchemas()
+
+        const health: SchemaHealthCheckItem = {
+            status: 'passed',
+            schemas,
+        }
+
+        return health
+    }
+
+    public async destroy() {
+        this._isBooted = false
+    }
+
+    public isInstalled = async () => {
+        const schemaPath = pathUtil.join(
+            this.skill.rootDir,
+            'node_modules',
+            '@sprucelabs/schema'
+        )
+
+        const isSchemaInstalled = fs.existsSync(schemaPath)
+
+        return isSchemaInstalled
+    }
+
+    public isBooted() {
+        return this._isBooted
+    }
+
+    private async loadSchemas() {
+        const schemaFiles = await globby(
+            diskUtil.resolvePath(
+                this.skill.activeDir,
+                HASH_SPRUCE_DIR_NAME,
+                'schemas',
+                '**/*.schema.[t|j]s'
+            )
+        )
+
+        return schemaFiles.map((file) => {
+            try {
+                const schema = require(file).default
+                return {
+                    id: schema.id,
+                    name: schema.name,
+                    version: schema.version,
+                    namespace: schema.namespace ?? '***MISSING***',
+                    description: schema.description,
+                }
+            } catch (err: any) {
+                throw new SchemaError({
+                    //@ts-ignore
+                    code: 'FAILED_LOADING_SCHEMA',
+                    originalError: err,
+                    friendlyMessage: `Error importing schema from: ${file}.`,
+                })
+            }
+        })
+    }
+}
+
+export default (skill: Skill) => {
+    const feature = new SchemaFeature(skill)
+    skill.registerFeature('schema', feature)
+}

package/build/dist/templates/typescript/schema/schema.ts.hbs

@@ -0,0 +1,12 @@
+{{#if registerBuiltSchemas}}import { SchemaRegistry } from '@sprucelabs/schema'{{/if}}
+import { {{globalSchemaNamespace}} } from '{{typesFile}}'
+
+{{{ importRelatedSchemas schema }}}
+
+const {{nameCamel}}Schema: {{globalSchemaNamespace}}.{{namespace}}{{#if schema.version}}.{{schema.version}}{{/if}}.{{namePascal}}Schema  = {
+	{{> schemaBody nameCamel=nameCamel namespace=namespace schema=schema renderAs="value" }}
+}
+
+{{#if registerBuiltSchemas}}SchemaRegistry.getInstance().trackSchema({{nameCamel}}Schema){{/if}}
+
+export default {{nameCamel}}Schema