@sprucelabs/spruce-cli/build/__tests__/implementation/EventTemplateItemBuilder.test.js

Command line interface for building Spruce skills.

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const mercury_core_events_1 = require("@sprucelabs/mercury-core-events");
const schema_1 = require("@sprucelabs/schema");
const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
const test_utils_1 = require("@sprucelabs/test-utils");
const EventTemplateItemBuilder_1 = __importDefault(require("../../templateItemBuilders/EventTemplateItemBuilder"));
const AbstractCliTest_1 = __importDefault(require("../../tests/AbstractCliTest"));
const expectedVersion = spruce_skill_utils_1.versionUtil.generateVersion().dirValue;
const bookContract = {
    eventSignatures: {
        [`did-book::${expectedVersion}`]: {},
    },
};
const contractWith2Signatures = {
    eventSignatures: {
        [`did-book::${expectedVersion}`]: {},
        [`will-book::${expectedVersion}`]: {},
    },
};
const contractWith2NamespacedSignatures = {
    eventSignatures: {
        [`appointments.did-book::${expectedVersion}`]: {},
        [`appointments.will-book::${expectedVersion}`]: {},
    },
};
const didBookTemplateItem = {
    version: expectedVersion,
    namePascal: 'DidBook',
    nameCamel: 'didBook',
    isLocal: false,
    namespace: spruce_skill_utils_1.namesUtil.toKebab(spruce_skill_utils_1.MERCURY_API_NAMESPACE),
    namespaceCamel: spruce_skill_utils_1.namesUtil.toCamel(spruce_skill_utils_1.MERCURY_API_NAMESPACE),
    namespacePascal: spruce_skill_utils_1.namesUtil.toPascal(spruce_skill_utils_1.MERCURY_API_NAMESPACE),
    imports: [
        {
            importAs: '{ buildEventContract }',
            package: '@sprucelabs/mercury-types',
        },
    ],
    eventSignatures: {
        [`did-book::${expectedVersion}`]: {},
    },
};
const willBookTemplateItem = {
    version: expectedVersion,
    namePascal: 'WillBook',
    nameCamel: 'willBook',
    isLocal: false,
    namespace: spruce_skill_utils_1.namesUtil.toKebab(spruce_skill_utils_1.MERCURY_API_NAMESPACE),
    imports: [
        {
            importAs: '{ buildEventContract }',
            package: '@sprucelabs/mercury-types',
        },
    ],
    namespaceCamel: spruce_skill_utils_1.namesUtil.toCamel(spruce_skill_utils_1.MERCURY_API_NAMESPACE),
    namespacePascal: spruce_skill_utils_1.namesUtil.toPascal(spruce_skill_utils_1.MERCURY_API_NAMESPACE),
    eventSignatures: {
        [`will-book::${expectedVersion}`]: {},
    },
};
const didBookWithNamespaceTemplateItem = {
    version: expectedVersion,
    namePascal: 'DidBook',
    nameCamel: 'didBook',
    isLocal: true,
    namespace: 'appointments',
    namespaceCamel: 'appointments',
    namespacePascal: 'Appointments',
    imports: [
        {
            importAs: '{ buildEventContract }',
            package: '@sprucelabs/mercury-types',
        },
    ],
    eventSignatures: {
        [`appointments.did-book::${expectedVersion}`]: {},
    },
};
const willBookWithNamespaceTemplateItem = {
    version: expectedVersion,
    namePascal: 'WillBook',
    nameCamel: 'willBook',
    isLocal: true,
    namespace: 'appointments',
    namespaceCamel: 'appointments',
    namespacePascal: 'Appointments',
    imports: [
        {
            importAs: '{ buildEventContract }',
            package: '@sprucelabs/mercury-types',
        },
    ],
    eventSignatures: {
        [`appointments.will-book::${expectedVersion}`]: {},
    },
};
const relatedToRelatedToProximitySchema = (0, schema_1.buildSchema)({
    id: 'relatedToRelatedToProximitySchema',
    version: expectedVersion,
    fields: {
        onlyField: {
            type: 'text',
        },
    },
});
const relatedToRelatedToProximitySchemaTemplateItem = {
    namespace: 'proximity',
    id: relatedToRelatedToProximitySchema.id,
    nameCamel: 'relatedToRelatedToProximitySchema',
    namePascal: 'RelatedToRelatedToProximitySchema',
    nameReadable: 'relatedToRelatedToProximitySchema',
    schema: {
        ...relatedToRelatedToProximitySchema,
        namespace: 'proximity',
    },
    isNested: true,
    destinationDir: '#spruce/events',
};
const relatedToProximitySchema = (0, schema_1.buildSchema)({
    version: expectedVersion,
    id: 'relatedToProximitySchema',
    fields: {
        boolField: {
            type: 'boolean',
        },
        relatedToRelatedSchema: {
            type: 'schema',
            options: {
                schema: relatedToRelatedToProximitySchema,
            },
        },
    },
});
const relatedToProximitySchemaTemplateItem = {
    namespace: 'proximity',
    id: relatedToProximitySchema.id,
    nameCamel: 'relatedToProximitySchema',
    namePascal: 'RelatedToProximitySchema',
    nameReadable: 'relatedToProximitySchema',
    schema: {
        id: 'relatedToProximitySchema',
        namespace: 'proximity',
        version: expectedVersion,
        fields: {
            boolField: {
                type: 'boolean',
            },
            relatedToRelatedSchema: {
                type: 'schema',
                options: {
                    schemaIds: [
                        {
                            id: 'relatedToRelatedToProximitySchema',
                            namespace: 'proximity',
                            version: expectedVersion,
                        },
                    ],
                },
            },
        },
    },
    isNested: true,
    destinationDir: '#spruce/events',
};
const proximityEmitPayloadSchema = (0, schema_1.buildSchema)({
    version: expectedVersion,
    id: 'proximityEmitPayload',
    namespace: 'proximity',
    fields: {
        textField: {
            type: 'text',
        },
        relatedSchema: {
            type: 'schema',
            options: {
                schema: relatedToProximitySchema,
            },
        },
    },
});
const proximityEmitPayloadTemplateItem = {
    namespace: 'proximity',
    id: proximityEmitPayloadSchema.id,
    nameCamel: 'proximityEmitPayload',
    namePascal: 'ProximityEmitPayload',
    nameReadable: 'proximityEmitPayload',
    schema: {
        id: 'proximityEmitPayload',
        namespace: 'proximity',
        version: expectedVersion,
        fields: {
            textField: {
                type: 'text',
            },
            relatedSchema: {
                type: 'schema',
                options: {
                    schemaIds: [
                        {
                            id: 'relatedToProximitySchema',
                            namespace: 'proximity',
                            version: expectedVersion,
                        },
                    ],
                },
            },
        },
    },
    isNested: false,
    destinationDir: '#spruce/events',
};
const contractWithEmitPayload = {
    eventSignatures: {
        [`proximity.did-enter::${expectedVersion}`]: {
            emitPayloadSchema: proximityEmitPayloadSchema,
        },
    },
};
const expectedContractWithEmitPayloadTemplateItem = {
    namePascal: 'DidEnter',
    nameCamel: 'didEnter',
    namespace: 'proximity',
    isLocal: false,
    version: expectedVersion,
    namespaceCamel: 'proximity',
    namespacePascal: 'Proximity',
    imports: [
        {
            package: `#spruce/schemas/proximity/${expectedVersion}/proximityEmitPayload.schema`,
            importAs: 'proximityEmitPayloadSchema',
        },
        {
            importAs: '{ buildEventContract }',
            package: '@sprucelabs/mercury-types',
        },
    ],
    eventSignatures: {
        [`proximity.did-enter::${expectedVersion}`]: {
            emitPayloadSchema: {
                ...proximityEmitPayloadTemplateItem,
            },
        },
    },
};
class EventTemplateItemBuilderTest extends AbstractCliTest_1.default {
    static itemBuilder;
    static async beforeEach() {
        await super.beforeEach();
        this.itemBuilder = new EventTemplateItemBuilder_1.default();
    }
    static async canCreateNewItemBuilder() {
        test_utils_1.assert.isTruthy(this.itemBuilder);
    }
    static async hasGenerateFunction() {
        test_utils_1.assert.isFunction(this.itemBuilder.buildTemplateItems);
    }
    static turnsSingleContractIntoTemplateItem() {
        const { eventContractTemplateItems } = this.itemBuilder.buildTemplateItems({
            contracts: [bookContract],
            localNamespace: 'test-namespace',
        });
        const actual = eventContractTemplateItems[0];
        test_utils_1.assert.isEqualDeep(actual, didBookTemplateItem);
    }
    static generateItems(contracts, expectedEventContractTemplateItems, expectedSchemaTemplateItems = []) {
        const { eventContractTemplateItems, schemaTemplateItems } = this.itemBuilder.buildTemplateItems({
            contracts,
            localNamespace: 'appointments',
        });
        test_utils_1.assert.isEqualDeep(eventContractTemplateItems, expectedEventContractTemplateItems);
        test_utils_1.assert.isEqualDeep(schemaTemplateItems, expectedSchemaTemplateItems);
    }
    static canPullEventContractSchemaFromCoreEventContract() {
        const { schemaTemplateItems } = this.itemBuilder.buildTemplateItems({
            contracts: [
                {
                    eventSignatures: {
                        'register-events': mercury_core_events_1.coreEventContracts[0].eventSignatures['can-listen::v2020_12_25'],
                    },
                },
            ],
            localNamespace: 'testing',
        });
        const match = schemaTemplateItems.find((item) => item.id === 'eventSource');
        test_utils_1.assert.isTruthy(match);
    }
    static sortsEventsAlphabetically() {
        const { eventContractTemplateItems } = this.itemBuilder.buildTemplateItems({
            contracts: [
                {
                    eventSignatures: {
                        'zebra-cheeta': {},
                        'register-events': mercury_core_events_1.coreEventContracts[0].eventSignatures['can-listen::v2020_12_25'],
                    },
                },
            ],
            localNamespace: 'testing',
        });
        test_utils_1.assert.isEqual(eventContractTemplateItems[0].nameCamel, 'registerEvents');
        test_utils_1.assert.isEqual(eventContractTemplateItems[1].nameCamel, 'zebraCheeta');
    }
    static eventContractTemplateItemsHaveProperNamespacesImports() {
        const groupsExpectedImports = [
            {
                package: '#spruce/schemas/groups/v2021_12_01/listEmitTargetAndPayload.schema',
                importAs: 'listEmitTargetAndPayloadSchema',
            },
            {
                package: '#spruce/schemas/groups/v2021_12_01/listResponsePayload.schema',
                importAs: 'listResponsePayloadSchema',
            },
            {
                importAs: '{ buildEventContract }',
                package: '@sprucelabs/mercury-types',
            },
            {
                importAs: '{ buildPermissionContract }',
                package: '@sprucelabs/mercury-types',
            },
        ];
        const appointmentsExpectedImports = [
            {
                package: '#spruce/schemas/appointments/v2021_06_23/listEmitTargetAndPayload.schema',
                importAs: 'listEmitTargetAndPayloadSchema',
            },
            {
                package: '#spruce/schemas/appointments/v2021_06_23/listResponsePayload.schema',
                importAs: 'listResponsePayloadSchema',
            },
            {
                importAs: '{ buildEventContract }',
                package: '@sprucelabs/mercury-types',
            },
            {
                importAs: '{ buildPermissionContract }',
                package: '@sprucelabs/mercury-types',
            },
        ];
        const { eventContractTemplateItems } = this.itemBuilder.buildTemplateItems({
            contracts: [
                {
                    eventSignatures: {
                        'groups.list::v2021_12_01': {
                            emitPayloadSchema: {
                                id: 'listEmitTargetAndPayload',
                                version: 'v2021_12_01',
                                namespace: 'Groups',
                                name: '',
                                fields: {},
                            },
                            responsePayloadSchema: {
                                id: 'listResponsePayload',
                                version: 'v2021_12_01',
                                namespace: 'Groups',
                                name: '',
                                fields: {},
                            },
                            emitPermissionContract: {
                                id: 'listEmitPermissions',
                                name: 'list',
                                requireAllPermissions: false,
                                permissions: [],
                            },
                        },
                        'appointments.list::v2021_06_23': {
                            emitPayloadSchema: {
                                id: 'listEmitTargetAndPayload',
                                version: 'v2021_06_23',
                                namespace: 'Appointments',
                                name: '',
                                fields: {},
                            },
                            responsePayloadSchema: {
                                id: 'listResponsePayload',
                                version: 'v2021_06_23',
                                namespace: 'Appointments',
                                name: '',
                                fields: {},
                            },
                            emitPermissionContract: {
                                id: 'listEmitPermissions',
                                name: 'list appointments',
                                requireAllPermissions: false,
                                permissions: [],
                            },
                            listenPermissionContract: {
                                id: 'listListenPermissions',
                                name: 'list appointments',
                                requireAllPermissions: false,
                                permissions: [],
                            },
                        },
                    },
                },
            ],
            localNamespace: 'testing',
        });
        test_utils_1.assert.isEqualDeep(eventContractTemplateItems[0].imports, groupsExpectedImports);
        test_utils_1.assert.isEqualDeep(eventContractTemplateItems[1].imports, appointmentsExpectedImports);
    }
}
exports.default = EventTemplateItemBuilderTest;
__decorate([
    (0, test_utils_1.test)()
], EventTemplateItemBuilderTest, "canCreateNewItemBuilder", null);
__decorate([
    (0, test_utils_1.test)()
], EventTemplateItemBuilderTest, "hasGenerateFunction", null);
__decorate([
    (0, test_utils_1.test)()
], EventTemplateItemBuilderTest, "turnsSingleContractIntoTemplateItem", null);
__decorate([
    (0, test_utils_1.test)('builds emit payload schema into a template item', [contractWithEmitPayload], [expectedContractWithEmitPayloadTemplateItem], [
        relatedToRelatedToProximitySchemaTemplateItem,
        relatedToProximitySchemaTemplateItem,
        proximityEmitPayloadTemplateItem,
    ]),
    (0, test_utils_1.test)('turns 1 contract with 2 event signature into 2 template items', [contractWith2Signatures], [didBookTemplateItem, willBookTemplateItem]),
    (0, test_utils_1.test)('turns 2 contract with 2 event signature into 4 template items', [contractWith2Signatures, contractWith2Signatures], [
        didBookTemplateItem,
        didBookTemplateItem,
        willBookTemplateItem,
        willBookTemplateItem,
    ]),
    (0, test_utils_1.test)('turns 1 contract with 2 namespaced event signatures to 2 template items', [contractWith2NamespacedSignatures], [didBookWithNamespaceTemplateItem, willBookWithNamespaceTemplateItem])
], EventTemplateItemBuilderTest, "generateItems", null);
__decorate([
    (0, test_utils_1.test)()
], EventTemplateItemBuilderTest, "canPullEventContractSchemaFromCoreEventContract", null);
__decorate([
    (0, test_utils_1.test)()
], EventTemplateItemBuilderTest, "sortsEventsAlphabetically", null);
__decorate([
    (0, test_utils_1.test)()
], EventTemplateItemBuilderTest, "eventContractTemplateItemsHaveProperNamespacesImports", null);
//# sourceMappingURL=EventTemplateItemBuilder.test.js.map