@lwc/sfdc-compiler-utils 2.19.0

package/src/__tests__/no-explicit-namespace.spec.ts

@@ -0,0 +1,350 @@
+import { containsExplicitNamespace } from '../namespace-utils';
+
+describe('disallow references with an explicit namespace', () => {
+    describe('negative cases', () => {
+        test('should throw when invocation is misconfigured', () => {
+            expect(() => containsExplicitNamespace(undefined as any, 'a', 'b')).toThrowError(
+                'Failed to check explicit namespace usage.' +
+                    'Expected string values for "value", "type", and "explicitNamespace" ' +
+                    'parameters, received "undefined," "a", "b".'
+            );
+        });
+
+        test('should throw on processing unsupported reference type', () => {
+            expect(() => containsExplicitNamespace('label', 'bar', 'nsC')).toThrowError(
+                'Unsupported reference type bar'
+            );
+        });
+    });
+
+    describe('reference types that do not have namespace', () => {
+        test('"client" type should return false', () => {
+            const actual = containsExplicitNamespace('formFactor', 'client', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('"cssvars" type should return false', () => {
+            const actual = containsExplicitNamespace('customProperties', 'cssvars', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('"i18n" type should return false', () => {
+            const actual = containsExplicitNamespace('id', 'i18n', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('"slds" type should return false', () => {
+            const actual = containsExplicitNamespace('index.css', 'slds', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('"user" type should return false', () => {
+            const actual = containsExplicitNamespace('id', 'user', 'c');
+            expect(actual).toBe(false);
+        });
+        test('"userPermission" type should return false', () => {
+            const actual = containsExplicitNamespace('ViewSetup', 'userPermission', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('"gate" type should return false', () => {
+            const actual = containsExplicitNamespace('foo.bar.gate.name', 'gate', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('"metric" type should return false', () => {
+            const actual = containsExplicitNamespace('foo.bar.metric.name', 'metric', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('"internal" type should return false', () => {
+            const actual = containsExplicitNamespace('id', 'internal', 'c');
+            expect(actual).toBe(false);
+        });
+    });
+
+    describe('explicit namespace in label', () => {
+        test('should return "false" when not using namespace and explicit value is "c"', () => {
+            const actual = containsExplicitNamespace('label', 'label', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "true" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace('nsC.label', 'label', 'nsC');
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when explicit parameter value is "c" and the reference is explicit ', () => {
+            const actual = containsExplicitNamespace('nsC.label', 'label', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when references value has default namespace', () => {
+            const actual = containsExplicitNamespace('c.label', 'label', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when not using namespace at all', () => {
+            const actual = containsExplicitNamespace('label', 'label', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when both explicit namespace and reference use "c"', () => {
+            const actual = containsExplicitNamespace('c.label', 'label', 'c');
+            expect(actual).toBe(false);
+        });
+    });
+
+    describe('explicit namespace in resourceUrl', () => {
+        test('should return "false" when not using namespace and explicit value is "c"', () => {
+            const actual = containsExplicitNamespace('resource', 'resourceUrl', 'c');
+            expect(actual).toBe(false);
+        });
+        test('should return "true" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace('nsC__resource', 'resourceUrl', 'nsC');
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when using default namespace in the reference', () => {
+            const actual = containsExplicitNamespace('c__resourceUrl', 'resourceUrl', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace('resource', 'resourceUrl', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when explicit parameter value is "c" but the reference is explicit ', () => {
+            const actual = containsExplicitNamespace('nsC__resourceUrl', 'resourceUrl', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when both explicit namespace and reference use "c"', () => {
+            const actual = containsExplicitNamespace('c__resourceUrl', 'resourceUrl', 'c');
+            expect(actual).toBe(false);
+        });
+    });
+
+    describe('explicit namespace in contentAssetUrl', () => {
+        test('should return "false" when not using namespace and explicit value is "c"', () => {
+            const actual = containsExplicitNamespace('asset', 'contentAssetUrl', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "true" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace('nsC__asset', 'contentAssetUrl', 'nsC');
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when using default namespace in the reference', () => {
+            const actual = containsExplicitNamespace('c__asset', 'contentAssetUrl', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace('asset', 'contentAssetUrl', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "true" when explicit parameter value is "c" but the reference is explicit ', () => {
+            const actual = containsExplicitNamespace('nsC__asset', 'contentAssetUrl', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when both explicit namespace and reference use "c"', () => {
+            const actual = containsExplicitNamespace('c__asset', 'contentAssetUrl', 'c');
+            expect(actual).toBe(false);
+        });
+    });
+
+    describe('explicit namespace in customPermission', () => {
+        test('should return "false" when not using namespace and explicit value is "c"', () => {
+            const actual = containsExplicitNamespace('perm', 'customPermission', 'c');
+            expect(actual).toBe(false);
+        });
+        test('should return "true" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace(
+                'nsC__customPermission',
+                'customPermission',
+                'nsC'
+            );
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when using default namespace in the reference', () => {
+            const actual = containsExplicitNamespace(
+                'c__customPermission',
+                'customPermission',
+                'nsC'
+            );
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace('perm', 'customPermission', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when explicit parameter value is "c" but the reference is explicit ', () => {
+            const actual = containsExplicitNamespace(
+                'nsC__customPermission',
+                'customPermission',
+                'c'
+            );
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when both explicit namespace and reference use "c"', () => {
+            const actual = containsExplicitNamespace(
+                'c__customPermission',
+                'customPermission',
+                'c'
+            );
+            expect(actual).toBe(false);
+        });
+    });
+
+    describe('explicit namespace in apexMethod', () => {
+        test('should return "false" when not using namespace and explicit value is "c"', () => {
+            const actual = containsExplicitNamespace('MyClass.methodA', 'apexMethod', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "true" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace('nsC.MyClass.methodA', 'apexMethod', 'nsC');
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when using default namespace in the reference', () => {
+            const actual = containsExplicitNamespace('c.MyClass.methodA', 'apexMethod', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when not using namespace at all', () => {
+            const actual = containsExplicitNamespace('MyClass.methodA', 'apexMethod', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when explicit parameter value is "c" but the reference is explicit ', () => {
+            const actual = containsExplicitNamespace('nsC.MyClass.methodA', 'apexMethod', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when both explicit namespace and reference use "c"', () => {
+            const actual = containsExplicitNamespace('c.MyClass.methodA', 'apexMethod', 'c');
+            expect(actual).toBe(false);
+        });
+    });
+
+    describe('explicit namespace in schema', () => {
+        test('should return "false" when not using namespace and explicit value is "c"', () => {
+            const actual = containsExplicitNamespace('CustomObject__c', 'schema', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "true" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace(
+                'nsC__CustomObject__c.nsC__parentContact__r.Account.Name',
+                'schema',
+                'nsC'
+            );
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when references value has default namespace', () => {
+            const actual = containsExplicitNamespace(
+                'c__CustomObject__c.c__parentContact__r.Account.Name',
+                'schema',
+                'nsC'
+            );
+            expect(actual).toBe(false);
+        });
+
+        test('should return "true" when using mixed resource contains explicit namespace', () => {
+            const actual = containsExplicitNamespace(
+                'c__CustomObject__c.nsC__parentContact__r.Account.Name',
+                'schema',
+                'nsC'
+            );
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when not using namespace at all', () => {
+            const actual = containsExplicitNamespace('MyClass.methodA', 'schema', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when explicit parameter value is "c" but the reference is explicit ', () => {
+            const actual = containsExplicitNamespace(
+                'nsC__CustomObject__c.nsC__parentContact__r.Account.Name',
+                'schema',
+                'c'
+            );
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when both explicit namespace and reference use "c"', () => {
+            const actual = containsExplicitNamespace(
+                'c__CustomObject__c.nsC__parentContact__r.Account.Name',
+                'schema',
+                'c'
+            );
+            expect(actual).toBe(false);
+        });
+    });
+
+    describe('explicit namespace in module', () => {
+        test('should return "true" when not using default namespace and reference is explicit', () => {
+            const actual = containsExplicitNamespace('nsC/utils', 'module', 'nsC');
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when references value has default namespace', () => {
+            const actual = containsExplicitNamespace('c/utils', 'module', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when explicit parameter value is "c" but the reference is explicit ', () => {
+            const actual = containsExplicitNamespace('nsC/utils', 'module', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when both explicit namespace and reference use "c"', () => {
+            const actual = containsExplicitNamespace('c/utils', 'module', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when module does not have namespace and explicit value is "c"', () => {
+            const actual = containsExplicitNamespace('lwc', 'module', 'c');
+            expect(actual).toBe(false);
+        });
+    });
+
+    describe('explicit namespace in component', () => {
+        test('should return "true" when using explicit namespace', () => {
+            const actual = containsExplicitNamespace('explicit-child-tag', 'component', 'explicit');
+            expect(actual).toBe(true);
+        });
+
+        test('should return "true" when using camel-cased namespace', () => {
+            const actual = containsExplicitNamespace('nsc-child-tag', 'component', 'nsC');
+            expect(actual).toBe(true);
+        });
+
+        test('should return "false" when using default namespace in the reference', () => {
+            const actual = containsExplicitNamespace('c-child-tag', 'component', 'nsC');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when explicit parameter value is "c" but the reference is explicit ', () => {
+            const actual = containsExplicitNamespace('explicit-child-tag', 'component', 'c');
+            expect(actual).toBe(false);
+        });
+
+        test('should return "false" when both explicit namespace and reference use "c"', () => {
+            const actual = containsExplicitNamespace('c-child-tag', 'component', 'c');
+            expect(actual).toBe(false);
+        });
+    });
+});

package/src/index.ts

@@ -0,0 +1,9 @@
+// Copyright (c) 2022, Salesforce, Inc.,
+// All rights reserved.
+// For full license text, see the LICENSE.txt file
+
+export {
+    containsExplicitNamespace,
+    getNamespacedIdForType,
+    getNamespacedIdForResource,
+} from './namespace-utils';