Add v2 api support (#45)

* Update all endpoints to v2

* Create object types and module

* Update modules to support v2 endpoints

Main changes to support v2 compatibility:
- Resource modules now have a meta field that can store any type of attribute rather than specific fields (name, description, etc)
- List endpoints now consist of an array of results with an optional prevCursor or nextCursor used for pagination

* Update /v2/authorize endpoint to /v2/check

* Add tests for batch endpoints

* Clean up unused imports

* Export object and warrant modules

* Include request options in query calls

* Create ListResponse interface for list return type

* Pass request options in Tenant.create

* Add warrant query test

* Add query filter to list objects filters

* Return warrant token when creating/deleting warrants

* Refactor parseResponse to be clearer

* Return warrantToken for object deletes

* Remove return awaits outside try-catch block

* Update object methods to also accept WarrantObjects

* Update tests to support typescript

* Add params types for all methods where applicable

* Improve usage of get and update methods

* Add list warrants method

---------

Co-authored-by: Karan Kajla <kkajla12@gmail.com>

Author: stanleyphu

package-lock.json

@@ -12,7 +12,7 @@
         "build": "tsc",
         "build-local": "npm run build && npm pack",
         "prepare": "npm run build",
-        "test": "npm run build && mocha"
+        "test": "npm run build && mocha --require ts-node/register test/**/*.spec.ts"
     },
     "repository": {
         "type": "git",
@@ -35,8 +35,12 @@
         "node": ">=18.0.0"
     },
     "devDependencies": {
+        "@types/chai": "^4.3.9",
+        "@types/mocha": "^10.0.3",
         "@types/node": "^18.11.18",
+        "chai": "^4.3.10",
         "mocha": "^10.2.0",
+        "ts-node": "^10.9.1",
         "typescript": "^4.3.2"
     }
 }

package.json

@@ -132,11 +132,21 @@ export default class ApiClient implements HttpClient {
 
     private async parseResponse(response: any): Promise<string | Object> {
         const resJson = await response.text();
+        const warrantToken = response.headers.get("Warrant-Token");
         if (resJson) {
-            return JSON.parse(resJson);
+            const parsedRes = JSON.parse(resJson);
+            if (warrantToken != null) {
+                parsedRes.warrantToken = warrantToken;
+            }
+
+            return parsedRes;
         }
 
-        return resJson;
+        if (warrantToken != null) {
+            return {warrantToken: warrantToken};
+        } else {
+           return resJson;
+        }
     }
 
     private buildError(errorResponse: any): Error {

src/HttpClient.ts

@@ -2,6 +2,7 @@ import { API_URL_BASE } from "./constants";
 import ApiClient from "./HttpClient";
 import Authorization from "./modules/Authorization";
 import Feature from "./modules/Feature";
+import Object from "./modules/ObjectModule";
 import Permission from "./modules/Permission";
 import PricingTier from "./modules/PricingTier";
 import Role from "./modules/Role";
@@ -17,6 +18,7 @@ export default class WarrantClient {
 
     public Authorization: typeof Authorization = Authorization;
     public Feature: typeof Feature = Feature;
+    public Object: typeof Object = Object;
     public Permission: typeof Permission = Permission;
     public PricingTier: typeof PricingTier = PricingTier;
     public Role: typeof Role = Role;

src/WarrantClient.ts

@@ -1,2 +1,3 @@
 export const API_URL_BASE = "https://api.warrant.dev";
 export const SELF_SERVICE_DASH_URL_BASE = "https://self-serve.warrant.dev";
+export const API_VERSION = "v2";

src/constants.ts

@@ -1,8 +1,10 @@
 export * from "./types";
 export { default as Feature } from "./modules/Feature";
+export { default as Object } from "./modules/ObjectModule";
 export { default as Permission } from "./modules/Permission";
 export { default as PricingTier } from "./modules/PricingTier";
 export { default as Role } from "./modules/Role";
 export { default as Tenant } from "./modules/Tenant";
 export { default as User } from "./modules/User";
+export { default as Warrant } from "./modules/WarrantModule";
 export { default as WarrantClient } from "./WarrantClient";

src/index.ts

@@ -1,120 +1,96 @@
-import Feature from "./Feature";
-import Permission from "./Permission";
-import Check, { AccessCheckRequest, CheckMany, CheckWarrant, FeatureCheck, PermissionCheck } from "../types/Check";
+import {
+    Check,
+    CheckParams,
+    CheckManyParams,
+    FeatureCheckParams,
+    PermissionCheckParams,
+    checkWarrantParamsToCheckWarrant,
+} from "../types/Check";
+import { ObjectType } from "../types/ObjectType";
 import { WarrantRequestOptions } from "../types/WarrantRequestOptions";
-import Warrant, { isSubject, isWarrantObject } from "../types/Warrant";
 import WarrantClient from "../WarrantClient";
+import { API_VERSION } from "../constants";
 
 export default class Authorization {
-    public static async check(check: Check, options: WarrantRequestOptions = {}): Promise<boolean> {
-        const accessCheckRequest: AccessCheckRequest = {
-            warrants: [{
-                object: check.object,
-                relation: check.relation,
-                subject: check.subject,
-                context: check.context
-            }],
-            debug: check.debug
+    public static async check(checkParams: CheckParams, options: WarrantRequestOptions = {}): Promise<boolean> {
+        const check: Check = {
+            warrants: [checkWarrantParamsToCheckWarrant(checkParams)],
+            debug: checkParams.debug
         }
         if (WarrantClient.config.authorizeEndpoint) {
-            return this.edgeAuthorize(accessCheckRequest, options);
+            return this.makeEdgeCheckRequest(check, options);
         }
 
-        return this.authorize(accessCheckRequest, options);
+        return this.makeCheckRequest(check, options);
     }
 
-    public static async checkMany(check: CheckMany, options: WarrantRequestOptions = {}): Promise<boolean> {
-        let warrants: CheckWarrant[] = check.warrants.map((warrant) => {
-            return {
-                object: warrant.object,
-                relation: warrant.relation,
-                subject: warrant.subject,
-                context: warrant.context
-            }
-        })
-        const accessCheckRequest: AccessCheckRequest = {
-            op: check.op,
-            warrants: warrants,
-            debug: check.debug
-        }
+    public static async checkMany(checkParams: CheckManyParams, options: WarrantRequestOptions = {}): Promise<boolean> {
+        const check: Check = {
+            op: checkParams.op,
+            warrants: checkParams.warrants.map((checkWarrantParams) => checkWarrantParamsToCheckWarrant(checkWarrantParams)),
+            debug: checkParams.debug
+        };
 
         if (WarrantClient.config.authorizeEndpoint) {
-            return this.edgeAuthorize(accessCheckRequest, options);
+            return this.makeEdgeCheckRequest(check, options);
         }
 
-        return this.authorize(accessCheckRequest, options);
+        return this.makeCheckRequest(check, options);
     }
 
-    public static async hasFeature(featureCheck: FeatureCheck, options: WarrantRequestOptions = {}): Promise<boolean> {
+    public static async hasFeature(featureCheckParams: FeatureCheckParams, options: WarrantRequestOptions = {}): Promise<boolean> {
         return this.check({
-            object: new Feature(featureCheck.featureId),
+            object: {
+                objectType: ObjectType.Feature,
+                objectId: featureCheckParams.featureId,
+            },
             relation: "member",
-            subject: featureCheck.subject,
-            context: featureCheck.context,
-            debug: featureCheck.debug
+            subject: featureCheckParams.subject,
+            context: featureCheckParams.context,
+            debug: featureCheckParams.debug
         }, options)
     }
 
-    public static async hasPermission(permissionCheck: PermissionCheck, options: WarrantRequestOptions = {}): Promise<boolean> {
+    public static async hasPermission(permissionCheckParams: PermissionCheckParams, options: WarrantRequestOptions = {}): Promise<boolean> {
         return this.check({
-            object: new Permission(permissionCheck.permissionId),
+            object: {
+                objectType: ObjectType.Permission,
+                objectId: permissionCheckParams.permissionId,
+            },
             relation: "member",
-            subject: permissionCheck.subject,
-            context: permissionCheck.context,
-            debug: permissionCheck.debug
+            subject: permissionCheckParams.subject,
+            context: permissionCheckParams.context,
+            debug: permissionCheckParams.debug
         }, options)
     }
 
     // Private methods
-    private static async authorize(accessCheckRequest: AccessCheckRequest, options: WarrantRequestOptions = {}): Promise<boolean> {
-        try {
-
-            const response = await WarrantClient.httpClient.post({
-                url: "/v2/authorize",
-                data: {
-                    ...accessCheckRequest,
-                    warrants: this.mapWarrantsForRequest(accessCheckRequest.warrants),
-                },
-                options,
-            });
+    private static async makeCheckRequest(check: Check, options: WarrantRequestOptions = {}): Promise<boolean> {
+        const response = await WarrantClient.httpClient.post({
+            url: `/${API_VERSION}/check`,
+            data: check,
+            options,
+        });
 
-            return response.code === 200;
-        } catch (e) {
-            throw e;
-        }
+        return response.code === 200;
     }
 
-    private static async edgeAuthorize(accessCheckRequest: AccessCheckRequest, options: WarrantRequestOptions = {}): Promise<boolean> {
+    private static async makeEdgeCheckRequest(check: Check, options: WarrantRequestOptions = {}): Promise<boolean> {
         try {
             const response = await WarrantClient.httpClient.post({
                 baseUrl: WarrantClient.config.authorizeEndpoint,
-                url: "/v2/authorize",
-                data: {
-                    ...accessCheckRequest,
-                    warrants: this.mapWarrantsForRequest(accessCheckRequest.warrants),
-                },
+                url: `/${API_VERSION}/check`,
+                data: check,
                 options,
             });
 
             return response.code === 200;
         } catch (e) {
             if (e.code === "cache_not_ready") {
-                return this.authorize(accessCheckRequest);
+                return this.makeCheckRequest(check);
             }
 
             throw e;
         }
     }
-
-    private static mapWarrantsForRequest(warrants: CheckWarrant[]): any[] {
-        return warrants.map((warrant) => {
-            return {
-                objectType: isWarrantObject(warrant.object) ? warrant.object.getObjectType() : warrant.object.objectType,
-                objectId: isWarrantObject(warrant.object) ? warrant.object.getObjectId() : warrant.object.objectId,
-                relation: warrant.relation,
-                subject: isSubject(warrant.subject) ? warrant.subject : { objectType: warrant.subject.getObjectType(), objectId: warrant.subject.getObjectId() },
-                context: warrant.context
-            }
-        })
-    }
 }