Add batch check method

Author: stanleyphu

src/modules/Authorization.ts

@@ -1,7 +1,10 @@
 import {
+    BatchCheckParams,
     Check,
+    CheckOp,
     CheckParams,
     CheckManyParams,
+    CheckResult,
     FeatureCheckParams,
     PermissionCheckParams,
     checkWarrantParamsToCheckWarrant,
@@ -39,6 +42,16 @@ export default class Authorization {
         return this.makeCheckRequest(check, options);
     }
 
+    public static async batchCheck(checkParams: BatchCheckParams, options: WarrantRequestOptions = {}): Promise<boolean[]> {
+        const check: Check = {
+            op: CheckOp.Batch,
+            warrants: checkParams.warrants.map((checkWarrantParams) => checkWarrantParamsToCheckWarrant(checkWarrantParams)),
+            debug: checkParams.debug
+        };
+
+        return this.makeBatchCheckRequest(check, options);
+    }
+
     public static async hasFeature(featureCheckParams: FeatureCheckParams, options: WarrantRequestOptions = {}): Promise<boolean> {
         return this.check({
             object: {
@@ -94,4 +107,14 @@ export default class Authorization {
             throw e;
         }
     }
+
+    private static async makeBatchCheckRequest(check: Check, options: WarrantRequestOptions = {}): Promise<boolean[]> {
+        const response = await WarrantClient.httpClient.post({
+            url: `/${API_VERSION}/check`,
+            data: check,
+            options,
+        });
+
+        return response.map((checkResult: CheckResult) => checkResult.code === 200);
+    } 
 }

src/types/Check.ts

@@ -12,6 +12,7 @@ import {
 export enum CheckOp {
     AllOf = "allOf",
     AnyOf = "anyOf",
+    Batch = "batch",
 }
 
 export interface CheckWarrantParams {
@@ -31,6 +32,11 @@ export interface CheckManyParams {
     debug?: boolean;
 }
 
+export interface BatchCheckParams {
+    warrants: CheckWarrantParams[];
+    debug?: boolean;
+}
+
 export interface FeatureCheckParams {
     featureId: string;
     subject: WarrantObject | Subject;
@@ -68,3 +74,9 @@ export function checkWarrantParamsToCheckWarrant(checkWarrantParams: CheckWarran
         context: checkWarrantParams.context
     }
 }
+
+export interface CheckResult {
+    code?: number;
+    result: string;
+    isImplicit: boolean;
+}

test/LiveTest.spec.ts

@@ -743,28 +743,29 @@ describe.skip('Live Test', function () {
         assert(warrantToken);
     });
 
-    it('batch create/delete warrants', async function () {
+    it('batch create/delete/check warrants', async function () {
         const newUser = await this.warrant.User.create();
         const permission1 = await this.warrant.Permission.create({ permissionId: "perm1", meta: { name: "Permission 1", description: "Permission 1" }});
         const permission2 = await this.warrant.Permission.create({ permissionId: "perm2", meta: { name: "Permission 2", description: "Permission 2" }});
 
-        let userHasPermission1 = await this.warrant.Authorization.check({
-            object: permission1,
-            relation: "member",
-            subject: newUser
+        let userHasPermissions = await this.warrant.Authorization.batchCheck({
+            warrants: [
+                {
+                    object: permission1,
+                    relation: "member",
+                    subject: newUser
+                },
+                {
+                    object: permission2,
+                    relation: "member",
+                    subject: newUser
+                }
+            ]
         }, {
             warrantToken: "latest"
         });
-        assert.strictEqual(userHasPermission1, false);
-
-        let userHasPermission2 = await this.warrant.Authorization.check({
-            object: permission2,
-            relation: "member",
-            subject: newUser
-        }, {
-            warrantToken: "latest"
-        });
-        assert.strictEqual(userHasPermission2, false);
+        assert.strictEqual(userHasPermissions[0], false);
+        assert.strictEqual(userHasPermissions[1], false);
 
         const warrants = await this.warrant.Warrant.batchCreate([
             {
@@ -783,23 +784,24 @@ describe.skip('Live Test', function () {
             assert(warrant.warrantToken);
         }
 
-        userHasPermission1 = await this.warrant.Authorization.check({
-            object: permission1,
-            relation: "member",
-            subject: newUser
-        }, {
-            warrantToken: "latest"
-        });
-        assert.strictEqual(userHasPermission1, true);
-
-        userHasPermission2 = await this.warrant.Authorization.check({
-            object: permission2,
-            relation: "member",
-            subject: newUser
+        userHasPermissions = await this.warrant.Authorization.batchCheck({
+            warrants: [
+                {
+                    object: permission1,
+                    relation: "member",
+                    subject: newUser
+                },
+                {
+                    object: permission2,
+                    relation: "member",
+                    subject: newUser
+                }
+            ]
         }, {
             warrantToken: "latest"
         });
-        assert.strictEqual(userHasPermission2, true);
+        assert.strictEqual(userHasPermissions[0], true);
+        assert.strictEqual(userHasPermissions[1], true);
 
         let warrantToken = await this.warrant.Warrant.batchDelete([
             {
@@ -820,6 +822,25 @@ describe.skip('Live Test', function () {
             { object: { objectType: "user", objectId: newUser.userId } },
         ]);
         assert(warrantToken);
+
+        userHasPermissions = await this.warrant.Authorization.batchCheck({
+            warrants: [
+                {
+                    object: permission1,
+                    relation: "member",
+                    subject: newUser
+                },
+                {
+                    object: permission2,
+                    relation: "member",
+                    subject: newUser
+                }
+            ]
+        }, {
+            warrantToken: "latest"
+        });
+        assert.strictEqual(userHasPermissions[0], false);
+        assert.strictEqual(userHasPermissions[1], false);
     });
 
     it('warrant with policy', async function () {