@komaci/esm-generator 242.0.0 → 242.1.0

package/build/__tests__/functionAstGeneration.spec.js

@@ -0,0 +1,412 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const path_1 = require("path");
+const fs_1 = require("fs");
+const common_shared_1 = require("@komaci/common-shared");
+const types_1 = require("@babel/types");
+const functionAstGeneration_1 = require("../functionAstGeneration");
+const generator_1 = __importDefault(require("@babel/generator"));
+const badImportRef_1 = require("./fixtures-source-code/badImportRef");
+describe('hoistLocalFunction', () => {
+    const baseFilesPath = (0, path_1.join)(__dirname, 'general-komaci-docs/assorted-template-strings');
+    const src = (0, fs_1.readFileSync)((0, path_1.join)(baseFilesPath, 'source.js'), {
+        encoding: 'utf-8',
+    });
+    const ast = (0, common_shared_1.generateAstFromSrcCode)(src);
+    const { templateStrings } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+    const firstTemplateStringFunc = {
+        generatedName: 't0',
+        type: common_shared_1.FunctionTypes.TEMPLATE_STRING,
+        componentAstNode: templateStrings[0],
+        requiredProperties: [],
+    };
+    const secondTemplateStringFunc = {
+        generatedName: 't1',
+        type: common_shared_1.FunctionTypes.TEMPLATE_STRING,
+        componentAstNode: templateStrings[1],
+        requiredProperties: [],
+    };
+    const imports = new Map();
+    imports.set('gql', {
+        generatorAlias: 'i1',
+        resourceName: 'lightning/graphql',
+        isFromInternalNamespace: true,
+        isFromSupportedLibrary: true,
+        name: 'gql',
+        komaciDocImportRef: '1/names/0',
+        usedInPriming: true,
+        staticallyAnalyzable: false,
+    });
+    imports.set('sneaky', {
+        generatorAlias: 'i2',
+        resourceName: 'snoop',
+        isFromInternalNamespace: true,
+        isFromSupportedLibrary: true,
+        name: 'sneaky',
+        komaciDocImportRef: '2/names/0',
+        usedInPriming: true,
+        staticallyAnalyzable: false,
+    });
+    const hoistedFirstFunc = (0, functionAstGeneration_1.hoistLocalFunction)(firstTemplateStringFunc, imports);
+    const hoistedSecondFunc = (0, functionAstGeneration_1.hoistLocalFunction)(secondTemplateStringFunc, imports);
+    it('can compose a template string for a public api prop', () => {
+        expect(hoistedFirstFunc).not.toBeUndefined();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        expect(hoistedFirstFunc.type).toBe('FunctionDeclaration');
+        expect(hoistedFirstFunc.id.name).toBe('t0');
+        expect(hoistedFirstFunc.body.body).toHaveLength(1);
+        expect(hoistedFirstFunc.body.body[0].type).toBe('ReturnStatement');
+        expect(hoistedFirstFunc.body.body[0]
+            .argument?.type).toBe('TemplateLiteral');
+        expect(hoistedFirstFunc.body
+            .body[0].argument.expressions).toHaveLength(2);
+        expect(hoistedFirstFunc.body
+            .body[0].argument.expressions[0].type).toBe('MemberExpression');
+        expect(hoistedFirstFunc.body
+            .body[0].argument.expressions[0].object.name).toBe('props');
+        expect(hoistedFirstFunc.body
+            .body[0].argument.expressions[0].property.name).toBe('basicInit');
+        expect(hoistedFirstFunc.body
+            .body[0].argument.expressions[1].type).toBe('Identifier');
+        expect(hoistedFirstFunc.body
+            .body[0].argument.expressions[1].name).toBe('i2');
+    });
+    it('can compose a template string for an internal prop', () => {
+        expect(hoistedSecondFunc).not.toBeUndefined();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        expect(hoistedSecondFunc.type).toBe('FunctionDeclaration');
+        expect(hoistedSecondFunc.id.name).toBe('t1');
+        expect(hoistedSecondFunc.body.body).toHaveLength(1);
+        expect(hoistedSecondFunc.body.body[0].type).toBe('ReturnStatement');
+        expect(hoistedSecondFunc.body.body[0]
+            .argument?.type).toBe('TaggedTemplateExpression');
+        expect(hoistedSecondFunc.body
+            .body[0].argument.quasi.expressions).toHaveLength(1);
+        expect(hoistedSecondFunc.body
+            .body[0].argument.tag.name).toBe('i1');
+    });
+});
+describe('sanitizeFunction', () => {
+    const ast = (0, common_shared_1.generateAstFromSrcCode)(badImportRef_1.sourceClass);
+    const { getters } = (0, common_shared_1.getPropertyMetadataFromAst)(ast);
+    const imports = new Map();
+    imports.set('test', {
+        name: 'test',
+        resourceName: 'force/shared',
+        staticallyAnalyzable: false,
+        usedInPriming: true,
+        isFromInternalNamespace: true,
+        isFromSupportedLibrary: true,
+        generatorAlias: 'i0',
+        komaciDocImportRef: '0/names/0',
+    });
+    imports.set('bad', {
+        name: 'test',
+        resourceName: 'invalid/import',
+        isFromInternalNamespace: true,
+        isFromSupportedLibrary: false,
+        staticallyAnalyzable: false,
+        usedInPriming: true,
+        generatorAlias: 'i1',
+        komaciDocImportRef: '1/names/0',
+    });
+    it('should be able to clean up and hoist a function with valid import references', () => {
+        (0, functionAstGeneration_1.sanitizeFunction)(getters[0], imports);
+        const hoisted = (0, types_1.functionDeclaration)((0, types_1.identifier)('g0'), [(0, types_1.identifier)('props')], // make 'props' an input parameter to the hoisted getter
+        getters[0].node.body);
+        const generatedFunction = (0, generator_1.default)((0, types_1.file)((0, types_1.program)([hoisted])));
+        expect(generatedFunction.code).toBe(badImportRef_1.expectedGoodHoist);
+    });
+    it('should throw an error if we try to reference a bad input', () => {
+        expect(() => (0, functionAstGeneration_1.sanitizeFunction)(getters[1], imports)).toThrowError(new Error(`${common_shared_1.ERROR_PREFIX}: 'bad' does not map to valid import`));
+    });
+});
+describe('adgToExpression', () => {
+    it('returns valid adg function from komaci doc', () => {
+        const komaciDoc = {
+            adgs: [
+                {
+                    properties: {
+                        getter0: {
+                            isPublic: false,
+                            input: { type: 'ImportReference', value: '0/names/0' },
+                        },
+                        prop1: {
+                            isPublic: true,
+                            initial: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                                namespacedMember: 'p1',
+                            },
+                        },
+                        prop2: {
+                            isPublic: true,
+                            initial: {
+                                type: 'ImportReference',
+                                value: '1/names/0',
+                                namespacedMember: 'p2',
+                            },
+                        },
+                        record1: {
+                            isPublic: false,
+                            input: { type: 'FunctionReference', value: 0 },
+                        },
+                        record2: {
+                            isPublic: false,
+                            input: { type: 'FunctionReference', value: 1 },
+                        },
+                        record3: {
+                            isPublic: false,
+                            input: { type: 'FunctionReference', value: 2 },
+                        },
+                    },
+                    functions: [
+                        {
+                            type: 'WireFunction',
+                            reference: { type: 'ImportReference', value: '2/names/0' },
+                            input: [
+                                {
+                                    type: 'ObjectValue',
+                                    value: {
+                                        recordId: {
+                                            type: 'PropertyReference',
+                                            value: 'prop1',
+                                        },
+                                    },
+                                },
+                            ],
+                            location: {
+                                startLine: 19,
+                                startColumn: 5,
+                                endLine: 19,
+                                endColumn: 45,
+                            },
+                        },
+                        {
+                            type: 'WireFunction',
+                            reference: { type: 'ImportReference', value: '2/names/0' },
+                            input: [
+                                {
+                                    type: 'ObjectValue',
+                                    value: {
+                                        recordId: {
+                                            type: 'PropertyReference',
+                                            value: 'getter0',
+                                        },
+                                    },
+                                },
+                            ],
+                            location: {
+                                startLine: 23,
+                                startColumn: 5,
+                                endLine: 23,
+                                endColumn: 47,
+                            },
+                        },
+                        {
+                            type: 'WireFunction',
+                            reference: { type: 'ImportReference', value: '2/names/0' },
+                            input: [
+                                {
+                                    type: 'ObjectValue',
+                                    value: {
+                                        recordId: {
+                                            type: 'PropertyReference',
+                                            value: 'prop2',
+                                        },
+                                    },
+                                },
+                            ],
+                            location: {
+                                startLine: 27,
+                                startColumn: 5,
+                                endLine: 27,
+                                endColumn: 45,
+                            },
+                        },
+                    ],
+                },
+            ],
+            imports: [
+                { resourceName: 'force/shared', names: ['*'] },
+                { resourceName: 'laf/transformWire', names: ['*'] },
+                { resourceName: 'lightning/uiRecordApi', names: ['getRecord'] },
+            ],
+            exports: { default: { type: 'AdgReference', value: 0 } },
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(komaciDoc, moduleMetadata);
+        (0, common_shared_1.initalizeAdgMetadata)(0, komaciDoc, moduleMetadata, false, false);
+        const adgMetadata = moduleMetadata.adgs.get(0);
+        const result = (0, functionAstGeneration_1.adgToExpression)(adgMetadata, moduleMetadata);
+        expect(result).not.toBeUndefined();
+        expect(result.arguments).toHaveLength(5);
+        expect(result.arguments[0].type).toBe('Identifier');
+        expect(result.arguments[0].name).toBe('undefined');
+        expect(result.arguments[1].type).toBe('ObjectExpression');
+        expect(result.arguments[2].type).toBe('ArrayExpression');
+        expect(result.arguments[2].elements).toHaveLength(3);
+        expect(result.arguments[3].type).toBe('Identifier');
+        expect(result.arguments[3].name).toBe('comp1');
+        expect(result.arguments[4].type).toBe('ArrayExpression');
+    });
+    it('returns valid adg function from komaci doc with local parent', () => {
+        const komaciDoc = {
+            adgs: [
+                {
+                    properties: {
+                        parentProp: {
+                            isPublic: true,
+                        },
+                    },
+                },
+                {
+                    parentClass: {
+                        type: 'AdgReference',
+                        value: 0,
+                    },
+                    properties: {
+                        testProp: {
+                            isPublic: false,
+                            input: {
+                                type: 'FunctionReference',
+                                value: 0,
+                            },
+                        },
+                    },
+                    functions: [
+                        {
+                            type: 'WireFunction',
+                            reference: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                            },
+                            input: [
+                                {
+                                    type: 'ObjectValue',
+                                    value: {
+                                        id: {
+                                            type: 'PropertyReference',
+                                            value: 'parentProp',
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+            imports: [
+                {
+                    resourceName: 'lightning/uiRecordApi',
+                    names: ['getRecord'],
+                },
+            ],
+            exports: {
+                Foo: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+                default: {
+                    type: 'AdgReference',
+                    value: 1,
+                },
+            },
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(komaciDoc, moduleMetadata);
+        (0, common_shared_1.initalizeAdgMetadata)(1, komaciDoc, moduleMetadata, false, false);
+        const adgMetadata = moduleMetadata.adgs.get(1);
+        const result = (0, functionAstGeneration_1.adgToExpression)(adgMetadata, moduleMetadata);
+        expect(result).not.toBeUndefined();
+        expect(result).not.toBeUndefined();
+        expect(result.arguments).toHaveLength(5);
+        expect(result.arguments[0].type).toBe('CallExpression');
+        expect(result.arguments[0].callee.name).toBe('adg0');
+        expect(result.arguments[1].type).toBe('ObjectExpression');
+        expect(result.arguments[2].type).toBe('ArrayExpression');
+        expect(result.arguments[2].elements).toHaveLength(1);
+        expect(result.arguments[3].type).toBe('Identifier');
+        expect(result.arguments[3].name).toBe('comp1');
+        expect(result.arguments[4].type).toBe('ArrayExpression');
+    });
+    it('returns valid adg function from komaci doc with import parent', () => {
+        const komaciDoc = {
+            adgs: [
+                {
+                    properties: {
+                        getterProp: {
+                            isPublic: false,
+                            input: {
+                                type: 'ImportReference',
+                                value: '0/names/0',
+                            },
+                        },
+                    },
+                    parentClass: {
+                        type: 'ImportReference',
+                        value: '1/names/0',
+                    },
+                },
+            ],
+            imports: [
+                {
+                    resourceName: 'force/shared',
+                    names: ['default'],
+                },
+                {
+                    resourceName: '@salesforce/komaci/force__shared__shared.js',
+                    names: ['default'],
+                },
+            ],
+            exports: {
+                default: {
+                    type: 'AdgReference',
+                    value: 0,
+                },
+            },
+        };
+        const moduleMetadata = (0, common_shared_1.initModuleMetadataObject)();
+        (0, common_shared_1.initializeImportMetdataFromKomaciDocument)(komaciDoc, moduleMetadata);
+        (0, common_shared_1.initalizeAdgMetadata)(0, komaciDoc, moduleMetadata, false, false);
+        const adgMetadata = moduleMetadata.adgs.get(0);
+        const result = (0, functionAstGeneration_1.adgToExpression)(adgMetadata, moduleMetadata);
+        expect(result).not.toBeUndefined();
+        expect(result.arguments).toHaveLength(5);
+        expect(result.arguments[0].type).toBe('CallExpression');
+        expect(result.arguments[0].callee.name).toBe('i1');
+        expect(result.arguments[1].type).toBe('ObjectExpression');
+        expect(result.arguments[2].type).toBe('ArrayExpression');
+        expect(result.arguments[2].elements).toHaveLength(0);
+        expect(result.arguments[3].type).toBe('Identifier');
+        expect(result.arguments[3].name).toBe('comp1');
+        expect(result.arguments[4].type).toBe('ArrayExpression');
+    });
+});
+describe('produceErrorAdgFunction', () => {
+    it('should produce a resolvable module with an adg with only one node that shows what the error was', () => {
+        const expected = `export default function (fct, ctx) {
+  const {
+    adg
+  } = fct;
+  return adg(undefined, {}, [{
+    t: "ErrorFunction",
+    c: {
+      "error": "something bad happened",
+      "stack": "full stack normally"
+    }
+  }], (fct, ctx) => {
+    return [];
+  }, []);
+}`;
+        const testError = new Error('something bad happened');
+        testError.stack = 'full stack normally';
+        const res = (0, functionAstGeneration_1.produceErrorAdgFunction)((0, common_shared_1.initModuleMetadataObject)(), testError);
+        expect((0, generator_1.default)((0, types_1.file)(res)).code).toBe(expected);
+    });
+});
+//# sourceMappingURL=functionAstGeneration.spec.js.map

package/build/__tests__/general-komaci-docs/template-component/source.js

@@ -10,7 +10,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("force/shared");
-const record_1 = require("lightning/record");
+const uiRecordApi_1 = require("lightning/uiRecordApi");
 const crazycool_1 = __importDefault(require("@salesforce/label/crazycool"));
 const lightning_1 = require("lightning");
 const import_1 = __importDefault(require("bad/import"));
@@ -25,10 +25,10 @@ __decorate([
     lightning_1.api
 ], Component.prototype, "recordId", void 0);
 __decorate([
-    (0, lightning_1.wire)(record_1.getRecord, { id: '$contractId' })
+    (0, lightning_1.wire)(uiRecordApi_1.getRecord, { id: '$contractId' })
 ], Component.prototype, "contract", void 0);
 __decorate([
-    (0, lightning_1.wire)(record_1.getRecord, { id: '$malicious' })
+    (0, lightning_1.wire)(uiRecordApi_1.getRecord, { id: '$malicious' })
 ], Component.prototype, "account", void 0);
 exports.default = Component;
 //# sourceMappingURL=source.js.map

package/build/__tests__/genericAstGeneration.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=genericAstGeneration.spec.d.ts.map