@sprucelabs/spruce-cli/build/templateItemBuilders/EventTemplateItemBuilder.js

Command line interface for building Spruce skills.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const schema_1 = require("@sprucelabs/schema");
const spruce_event_utils_1 = require("@sprucelabs/spruce-event-utils");
const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
const schemaDisk_utility_1 = __importDefault(require("../features/schema/utilities/schemaDisk.utility"));
const SchemaTemplateItemBuilder_1 = __importDefault(require("./SchemaTemplateItemBuilder"));
class EventTemplateItemBuilder {
    buildTemplateItems(options) {
        const { contracts, localNamespace, eventBuilderFile } = options;
        const eventContractTemplateItems = [];
        const schemaTemplateItems = [];
        for (const contract of contracts) {
            const { schemaTemplateItems: schemaItems, eventContractTemplateItems: contractItems, } = this.buildTemplateItemsForContract(contract, localNamespace, eventBuilderFile);
            eventContractTemplateItems.push(...contractItems);
            schemaTemplateItems.push(...schemaItems);
        }
        eventContractTemplateItems.sort((a, b) => {
            if (a.nameCamel > b.nameCamel) {
                return 1;
            }
            else if (a.nameCamel < b.nameCamel) {
                return -1;
            }
            return 0;
        });
        return { eventContractTemplateItems, schemaTemplateItems };
    }
    buildEventTemplateItemForName(contracts, fullyQualifiedEventName) {
        for (const contract of contracts) {
            const namedSignatures = spruce_event_utils_1.eventContractUtil.getNamedEventSignatures(contract);
            for (const namedSig of namedSignatures) {
                if (namedSig.fullyQualifiedEventName === fullyQualifiedEventName) {
                    const schemaTemplateItems = this.mapEventSigsToSchemaTemplateItems(namedSignatures);
                    const signatureTemplateItem = this.buildEventSigTemplateItem(namedSig, schemaTemplateItems);
                    return {
                        emitPayloadSchemaTemplateItem: signatureTemplateItem.emitPayloadSchema,
                        responsePayloadSchemaTemplateItem: signatureTemplateItem.responsePayloadSchema,
                    };
                }
            }
        }
        throw new schema_1.SchemaError({
            code: 'INVALID_PARAMETERS',
            parameters: ['fullyQualifiedEventName'],
            friendlyMessages: [
                `I could not find any events that match ${fullyQualifiedEventName}.`,
            ],
        });
    }
    buildTemplateItemsForContract(contract, localNamespace, eventBuilderFile) {
        const namedSignatures = spruce_event_utils_1.eventContractUtil.getNamedEventSignatures(contract);
        const schemaTemplateItems = this.mapEventSigsToSchemaTemplateItems(namedSignatures);
        const eventContractTemplateItems = [];
        for (const namedSig of namedSignatures) {
            const item = this.buildTemplateItemForEventSignature(namedSig, schemaTemplateItems, namedSig.eventNamespace === localNamespace, eventBuilderFile);
            eventContractTemplateItems.push(item);
        }
        return {
            eventContractTemplateItems,
            schemaTemplateItems,
        };
    }
    buildTemplateItemForEventSignature(namedSig, schemaTemplateItems, isLocal, eventBuilderFile) {
        const namespacePascal = this.sigToNamespacePascal(namedSig);
        const signatureTemplateItem = this.buildEventSigTemplateItem(namedSig, schemaTemplateItems);
        const item = {
            nameCamel: spruce_skill_utils_1.namesUtil.toCamel(namedSig.eventName),
            namePascal: spruce_skill_utils_1.namesUtil.toPascal(namedSig.eventName),
            version: namedSig.version ?? '***MISSING***',
            isLocal,
            namespace: spruce_skill_utils_1.namesUtil.toKebab(namedSig.eventNamespace ?? spruce_skill_utils_1.MERCURY_API_NAMESPACE),
            namespaceCamel: spruce_skill_utils_1.namesUtil.toCamel(namedSig.eventNamespace ?? spruce_skill_utils_1.MERCURY_API_NAMESPACE),
            imports: [
                signatureTemplateItem.emitPayloadSchema,
                signatureTemplateItem.responsePayloadSchema,
            ]
                .filter((i) => !!i)
                .map((item) => ({
                package: schemaDisk_utility_1.default.resolvePath({
                    destination: '#spruce/schemas',
                    schema: item.schema,
                    shouldIncludeFileExtension: false,
                }),
                importAs: `${item.nameCamel}Schema`,
            })),
            namespacePascal,
            eventSignatures: {
                [namedSig.fullyQualifiedEventName]: signatureTemplateItem,
            },
        };
        item.imports.push({
            importAs: '{ buildEventContract }',
            package: eventBuilderFile ?? '@sprucelabs/mercury-types',
        });
        if (namedSig.signature.listenPermissionContract ||
            namedSig.signature.emitPermissionContract) {
            item.imports.push({
                importAs: '{ buildPermissionContract }',
                package: eventBuilderFile ?? '@sprucelabs/mercury-types',
            });
        }
        return item;
    }
    buildEventSigTemplateItem(namedSig, schemaItems) {
        const { emitPayloadSchema, responsePayloadSchema, ...signature } = namedSig.signature;
        const signatureTemplateItem = {
            ...signature,
        };
        if (emitPayloadSchema) {
            signatureTemplateItem.emitPayloadSchema = schemaItems.find((i) => i.id === emitPayloadSchema.id &&
                (!emitPayloadSchema.namespace ||
                    i.namespace === emitPayloadSchema.namespace));
        }
        if (responsePayloadSchema) {
            signatureTemplateItem.responsePayloadSchema = schemaItems.find((i) => i.id === responsePayloadSchema.id &&
                (!responsePayloadSchema.namespace ||
                    i.namespace === responsePayloadSchema.namespace));
        }
        return signatureTemplateItem;
    }
    mapEventSigsToSchemaTemplateItems(namedSignatures) {
        const schemasByNamespace = this.mapEventSigsToSchemasByNamepace(namedSignatures);
        const schemaTemplateItemBuilder = new SchemaTemplateItemBuilder_1.default('Cli');
        const schemaItems = schemaTemplateItemBuilder.buildTemplateItems(schemasByNamespace, '#spruce/events');
        return schemaItems;
    }
    mapEventSigsToSchemasByNamepace(namedSignatures) {
        const schemasByNamespace = {};
        for (const namedSig of namedSignatures) {
            const namespacePascal = this.sigToNamespacePascal(namedSig);
            const { emitPayloadSchema, responsePayloadSchema } = namedSig.signature;
            if (!schemasByNamespace[namespacePascal]) {
                schemasByNamespace[namespacePascal] = [];
            }
            if (emitPayloadSchema) {
                schemasByNamespace[namespacePascal].push({
                    version: namedSig.version,
                    ...emitPayloadSchema,
                });
            }
            if (responsePayloadSchema) {
                schemasByNamespace[namespacePascal].push({
                    version: namedSig.version,
                    ...responsePayloadSchema,
                });
            }
        }
        return schemasByNamespace;
    }
    sigToNamespacePascal(namedSig) {
        return spruce_skill_utils_1.namesUtil.toPascal(namedSig.eventNamespace ?? spruce_skill_utils_1.MERCURY_API_NAMESPACE);
    }
}
exports.default = EventTemplateItemBuilder;
//# sourceMappingURL=EventTemplateItemBuilder.js.map