@contember/engine-content-api 1.1.0-alpha.4 → 1.1.0-alpha.7

package/dist/tests/cases/unit/permissionMerger.test.js

@@ -1,29 +1,9 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const schema_1 = require("@contember/schema");
 const acl_1 = require("../../../src/acl");
 const schema_definition_1 = require("@contember/schema-definition");
-const assert = __importStar(require("uvu/assert"));
-const uvu_1 = require("uvu");
+const vitest_1 = require("vitest");
 const execute = (test) => {
     const schema = new schema_definition_1.SchemaBuilder()
         .entity('Entity1', e => e.column('lorem').column('bar'))
@@ -31,518 +11,517 @@ const execute = (test) => {
         .buildSchema();
     const merger = new acl_1.PermissionFactory(schema);
     const result = merger.create(test.acl, test.roles);
-    assert.equal(result, test.result);
+    vitest_1.assert.deepStrictEqual(result, test.result);
 };
-const permissionMergerTest = (0, uvu_1.suite)('Permission merger');
-permissionMergerTest;
-permissionMergerTest('merge inheritance', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {},
-                            operations: {
-                                read: {
-                                    id: true,
+(0, vitest_1.describe)('Permission merger', () => {
+    (0, vitest_1.it)('merge inheritance', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {},
+                                operations: {
+                                    read: {
+                                        id: true,
+                                    },
                                 },
                             },
                         },
                     },
-                },
-                role2: {
-                    variables: {},
-                    inherits: ['role1'],
-                    stages: '*',
-                    entities: {
-                        Entity2: {
-                            predicates: {},
-                            operations: {
-                                read: {
-                                    id: true,
+                    role2: {
+                        variables: {},
+                        inherits: ['role1'],
+                        stages: '*',
+                        entities: {
+                            Entity2: {
+                                predicates: {},
+                                operations: {
+                                    read: {
+                                        id: true,
+                                    },
                                 },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role2'],
-        result: {
-            Entity1: {
-                predicates: {},
-                operations: {
-                    read: {
-                        id: true,
+            roles: ['role2'],
+            result: {
+                Entity1: {
+                    predicates: {},
+                    operations: {
+                        read: {
+                            id: true,
+                        },
                     },
                 },
-            },
-            Entity2: {
-                predicates: {},
-                operations: {
-                    read: {
-                        id: true,
+                Entity2: {
+                    predicates: {},
+                    operations: {
+                        read: {
+                            id: true,
+                        },
                     },
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('merge entity operations', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {},
-                            operations: {
-                                read: {
-                                    id: true,
+    (0, vitest_1.it)('merge entity operations', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {},
+                                operations: {
+                                    read: {
+                                        id: true,
+                                    },
                                 },
                             },
                         },
                     },
-                },
-                role2: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {},
-                            operations: {
-                                read: {
-                                    title: true,
+                    role2: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {},
+                                operations: {
+                                    read: {
+                                        title: true,
+                                    },
                                 },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role1', 'role2'],
-        result: {
-            Entity1: {
-                predicates: {},
-                operations: {
-                    read: {
-                        id: true,
-                        title: true,
+            roles: ['role1', 'role2'],
+            result: {
+                Entity1: {
+                    predicates: {},
+                    operations: {
+                        read: {
+                            id: true,
+                            title: true,
+                        },
                     },
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('merge entity operations with predicates', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {},
-                            operations: {
-                                read: {
-                                    id: true,
+    (0, vitest_1.it)('merge entity operations with predicates', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {},
+                                operations: {
+                                    read: {
+                                        id: true,
+                                    },
                                 },
                             },
                         },
                     },
-                },
-                role2: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                foo: { bar: { eq: 'abc' } },
-                            },
-                            operations: {
-                                read: {
-                                    title: 'foo',
+                    role2: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    foo: { bar: { eq: 'abc' } },
+                                },
+                                operations: {
+                                    read: {
+                                        title: 'foo',
+                                    },
                                 },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role1', 'role2'],
-        result: {
-            Entity1: {
-                predicates: {
-                    foo: { bar: { eq: 'abc' } },
-                },
-                operations: {
-                    read: {
-                        id: true,
-                        title: 'foo',
+            roles: ['role1', 'role2'],
+            result: {
+                Entity1: {
+                    predicates: {
+                        foo: { bar: { eq: 'abc' } },
+                    },
+                    operations: {
+                        read: {
+                            id: true,
+                            title: 'foo',
+                        },
                     },
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('merge entity operations and drops predicate', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {},
-                            operations: {
-                                read: {
-                                    id: true,
-                                    title: true,
+    (0, vitest_1.it)('merge entity operations and drops predicate', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {},
+                                operations: {
+                                    read: {
+                                        id: true,
+                                        title: true,
+                                    },
                                 },
                             },
                         },
                     },
-                },
-                role2: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                foo: { bar: { eq: 'abc' } },
-                            },
-                            operations: {
-                                read: {
-                                    title: 'foo',
+                    role2: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    foo: { bar: { eq: 'abc' } },
+                                },
+                                operations: {
+                                    read: {
+                                        title: 'foo',
+                                    },
                                 },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role1', 'role2'],
-        result: {
-            Entity1: {
-                predicates: {},
-                operations: {
-                    read: {
-                        id: true,
-                        title: true,
+            roles: ['role1', 'role2'],
+            result: {
+                Entity1: {
+                    predicates: {},
+                    operations: {
+                        read: {
+                            id: true,
+                            title: true,
+                        },
                     },
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('merge entity operations and merges predicates', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                bar: { lorem: { eq: 'ipsum' } },
-                            },
-                            operations: {
-                                read: {
-                                    id: true,
-                                    title: 'bar',
+    (0, vitest_1.it)('merge entity operations and merges predicates', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    bar: { lorem: { eq: 'ipsum' } },
+                                },
+                                operations: {
+                                    read: {
+                                        id: true,
+                                        title: 'bar',
+                                    },
                                 },
                             },
                         },
                     },
-                },
-                role2: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                foo: { bar: { eq: 'abc' } },
-                            },
-                            operations: {
-                                read: {
-                                    title: 'foo',
+                    role2: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    foo: { bar: { eq: 'abc' } },
+                                },
+                                operations: {
+                                    read: {
+                                        title: 'foo',
+                                    },
                                 },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role1', 'role2'],
-        result: {
-            Entity1: {
-                predicates: {
-                    __merge__bar__foo: {
-                        or: [{ lorem: { eq: 'ipsum' } }, { bar: { eq: 'abc' } }],
+            roles: ['role1', 'role2'],
+            result: {
+                Entity1: {
+                    predicates: {
+                        __merge__bar__foo: {
+                            or: [{ lorem: { eq: 'ipsum' } }, { bar: { eq: 'abc' } }],
+                        },
                     },
-                },
-                operations: {
-                    read: {
-                        id: true,
-                        title: '__merge__bar__foo',
+                    operations: {
+                        read: {
+                            id: true,
+                            title: '__merge__bar__foo',
+                        },
                     },
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('merge delete operation', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                bar: { lorem: { eq: 'ipsum' } },
-                            },
-                            operations: {
-                                delete: 'bar',
+    (0, vitest_1.it)('merge delete operation', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    bar: { lorem: { eq: 'ipsum' } },
+                                },
+                                operations: {
+                                    delete: 'bar',
+                                },
                             },
                         },
                     },
-                },
-                role2: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                foo: { bar: { eq: 'abc' } },
-                            },
-                            operations: {
-                                delete: 'foo',
+                    role2: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    foo: { bar: { eq: 'abc' } },
+                                },
+                                operations: {
+                                    delete: 'foo',
+                                },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role1', 'role2'],
-        result: {
-            Entity1: {
-                predicates: {
-                    __merge__bar__foo: {
-                        or: [{ lorem: { eq: 'ipsum' } }, { bar: { eq: 'abc' } }],
+            roles: ['role1', 'role2'],
+            result: {
+                Entity1: {
+                    predicates: {
+                        __merge__bar__foo: {
+                            or: [{ lorem: { eq: 'ipsum' } }, { bar: { eq: 'abc' } }],
+                        },
+                    },
+                    operations: {
+                        delete: '__merge__bar__foo',
                     },
-                },
-                operations: {
-                    delete: '__merge__bar__foo',
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('merge predicates and resolves conflicts', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                foo: { lorem: { eq: 'ipsum' } },
-                            },
-                            operations: {
-                                read: {
-                                    id: true,
-                                    title: 'foo',
+    (0, vitest_1.it)('merge predicates and resolves conflicts', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    foo: { lorem: { eq: 'ipsum' } },
+                                },
+                                operations: {
+                                    read: {
+                                        id: true,
+                                        title: 'foo',
+                                    },
                                 },
                             },
                         },
                     },
-                },
-                role2: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                foo: { bar: { eq: 'abc' } },
-                            },
-                            operations: {
-                                read: {
-                                    content: 'foo',
+                    role2: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    foo: { bar: { eq: 'abc' } },
+                                },
+                                operations: {
+                                    read: {
+                                        content: 'foo',
+                                    },
                                 },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role1', 'role2'],
-        result: {
-            Entity1: {
-                predicates: {
-                    foo: { lorem: { eq: 'ipsum' } },
-                    foo_: { bar: { eq: 'abc' } },
-                },
-                operations: {
-                    read: {
-                        id: true,
-                        title: 'foo',
-                        content: 'foo_',
+            roles: ['role1', 'role2'],
+            result: {
+                Entity1: {
+                    predicates: {
+                        foo: { lorem: { eq: 'ipsum' } },
+                        foo_: { bar: { eq: 'abc' } },
+                    },
+                    operations: {
+                        read: {
+                            id: true,
+                            title: 'foo',
+                            content: 'foo_',
+                        },
                     },
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('make primary predicate union of all other fields', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity1: {
-                            predicates: {
-                                foo: { lorem: { eq: 'ipsum' } },
-                                bar: { lorem: { eq: 'ipsum' } },
-                            },
-                            operations: {
-                                read: {
-                                    title: 'foo',
-                                    description: 'bar',
-                                    content: 'bar',
+    (0, vitest_1.it)('make primary predicate union of all other fields', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity1: {
+                                predicates: {
+                                    foo: { lorem: { eq: 'ipsum' } },
+                                    bar: { lorem: { eq: 'ipsum' } },
+                                },
+                                operations: {
+                                    read: {
+                                        title: 'foo',
+                                        description: 'bar',
+                                        content: 'bar',
+                                    },
                                 },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role1'],
-        result: {
-            Entity1: {
-                predicates: {
-                    foo: { lorem: { eq: 'ipsum' } },
-                    bar: { lorem: { eq: 'ipsum' } },
-                    __merge__foo__bar: {
-                        or: [{ lorem: { eq: 'ipsum' } }, { lorem: { eq: 'ipsum' } }],
+            roles: ['role1'],
+            result: {
+                Entity1: {
+                    predicates: {
+                        foo: { lorem: { eq: 'ipsum' } },
+                        bar: { lorem: { eq: 'ipsum' } },
+                        __merge__foo__bar: {
+                            or: [{ lorem: { eq: 'ipsum' } }, { lorem: { eq: 'ipsum' } }],
+                        },
                     },
-                },
-                operations: {
-                    read: {
-                        id: '__merge__foo__bar',
-                        title: 'foo',
-                        description: 'bar',
-                        content: 'bar',
+                    operations: {
+                        read: {
+                            id: '__merge__foo__bar',
+                            title: 'foo',
+                            description: 'bar',
+                            content: 'bar',
+                        },
                     },
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('prefix variables', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {},
-                    stages: '*',
-                    entities: {
-                        Entity2: {
-                            predicates: {
-                                foo: { xyz: { lorem: 'foo' } },
-                            },
-                            operations: {
-                                read: {
-                                    title: 'foo',
+    (0, vitest_1.it)('prefix variables', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {},
+                        stages: '*',
+                        entities: {
+                            Entity2: {
+                                predicates: {
+                                    foo: { xyz: { lorem: 'foo' } },
+                                },
+                                operations: {
+                                    read: {
+                                        title: 'foo',
+                                    },
                                 },
                             },
                         },
                     },
                 },
             },
-        },
-        roles: ['role1'],
-        result: {
-            Entity2: {
-                operations: {
-                    read: {
-                        title: 'foo',
-                        id: 'foo',
+            roles: ['role1'],
+            result: {
+                Entity2: {
+                    operations: {
+                        read: {
+                            title: 'foo',
+                            id: 'foo',
+                        },
                     },
-                },
-                predicates: {
-                    foo: {
-                        xyz: {
-                            lorem: 'role1__foo',
+                    predicates: {
+                        foo: {
+                            xyz: {
+                                lorem: 'role1__foo',
+                            },
                         },
                     },
                 },
             },
-        },
+        });
     });
-});
-permissionMergerTest('prefix inherited variables', () => {
-    execute({
-        acl: {
-            roles: {
-                role1: {
-                    variables: {
-                        foo: { entityName: 'Test', type: schema_1.Acl.VariableType.entity },
-                    },
-                    stages: '*',
-                    entities: {
-                        Entity2: {
-                            predicates: {
-                                foo: { xyz: { lorem: 'foo' } },
-                            },
-                            operations: {
-                                read: {
-                                    title: 'foo',
+    (0, vitest_1.it)('prefix inherited variables', () => {
+        execute({
+            acl: {
+                roles: {
+                    role1: {
+                        variables: {
+                            foo: { entityName: 'Test', type: schema_1.Acl.VariableType.entity },
+                        },
+                        stages: '*',
+                        entities: {
+                            Entity2: {
+                                predicates: {
+                                    foo: { xyz: { lorem: 'foo' } },
+                                },
+                                operations: {
+                                    read: {
+                                        title: 'foo',
+                                    },
                                 },
                             },
                         },
                     },
-                },
-                role2: {
-                    variables: {},
-                    entities: {},
-                    inherits: ['role1'],
-                    stages: '*',
+                    role2: {
+                        variables: {},
+                        entities: {},
+                        inherits: ['role1'],
+                        stages: '*',
+                    },
                 },
             },
-        },
-        roles: ['role2'],
-        result: {
-            Entity2: {
-                operations: {
-                    read: {
-                        title: 'foo',
-                        id: 'foo',
+            roles: ['role2'],
+            result: {
+                Entity2: {
+                    operations: {
+                        read: {
+                            title: 'foo',
+                            id: 'foo',
+                        },
                     },
-                },
-                predicates: {
-                    foo: {
-                        xyz: {
-                            lorem: 'role2__foo',
+                    predicates: {
+                        foo: {
+                            xyz: {
+                                lorem: 'role2__foo',
+                            },
                         },
                     },
                 },
             },
-        },
+        });
     });
 });
-permissionMergerTest.run();
 //# sourceMappingURL=permissionMerger.test.js.map