@spica-devkit/identity 0.13.1 → 0.18.1-pre2

package/dist/index.js

@@ -42,6 +42,7 @@ class Axios {
     }
     setBaseUrl(url) {
         this.instance.defaults.baseURL = url;
+        this.baseUrl = url;
     }
     setWriteDefaults(writeDefaults) {
         for (const [header, value] of Object.entries(writeDefaults.headers)) {
@@ -52,6 +53,9 @@ class Axios {
     setAuthorization(authorization) {
         this.instance.defaults.headers["Authorization"] = authorization;
     }
+    getAuthorization() {
+        return this.instance.defaults.headers["Authorization"].toString();
+    }
     get(url, config) {
         return this.instance.get(url, config);
     }
@@ -149,23 +153,28 @@ function initialize$1(options) {
     else if ("identity" in options) {
         authorization = `IDENTITY ${options.identity}`;
     }
-    checkInitialized(authorization);
+    else if ("user" in options) {
+        authorization = `USER ${options.user}`;
+    }
     const publicUrl = options.publicUrl || getPublicUrl();
     if (!publicUrl) {
         throw new Error("Public url must be provided.");
     }
     if (!service$1) {
-        service$1 = new Axios({ baseURL: publicUrl, headers: { Authorization: authorization } });
+        service$1 = new Axios({});
     }
-    else {
-        service$1.setBaseUrl(publicUrl);
+    service$1.setBaseUrl(publicUrl);
+    if (authorization) {
         service$1.setAuthorization(authorization);
     }
     return { authorization, publicUrl, service: service$1 };
 }
-function checkInitialized(authorization) {
-    if (!authorization) {
-        throw new Error("You should call initialize method with a valid apikey or identity token.");
+function checkInitialized(authorization, service, options = { skipAuthCheck: false }) {
+    if (!authorization && !options.skipAuthCheck) {
+        throw new Error("You should call initialize method with a valid credentials.");
+    }
+    if (!service) {
+        throw new Error("You should call initialize method with a valid publicUrl.");
     }
 }
 function getPublicUrl() {
@@ -175,6 +184,76 @@ function isPlatformBrowser() {
     return typeof window !== "undefined";
 }
 
+var Batch;
+(function (Batch) {
+    function prepareInsertRequest(resources, url, auth, headers) {
+        return {
+            requests: resources.map((resource, i) => {
+                headers = addAuthHeader(headers, auth);
+                return {
+                    id: i.toString(),
+                    body: resource,
+                    method: "POST",
+                    url: url,
+                    headers: headers
+                };
+            })
+        };
+    }
+    Batch.prepareInsertRequest = prepareInsertRequest;
+    function prepareRemoveRequest(ids, url, auth, headers) {
+        return {
+            requests: ids.map((id, i) => {
+                headers = addAuthHeader(headers, auth);
+                return {
+                    id: i.toString(),
+                    body: undefined,
+                    method: "DELETE",
+                    url: `${url}/${id}`,
+                    headers: headers
+                };
+            })
+        };
+    }
+    Batch.prepareRemoveRequest = prepareRemoveRequest;
+    function handleBatchResponse({ requests }, { responses }) {
+        const sortById = (a, b) => Number(a.id) - Number(b.id);
+        const successResponses = responses
+            .sort(sortById)
+            .filter(r => r.status >= 200 && r.status < 300);
+        const failureResponses = responses
+            .sort(sortById)
+            .filter(r => r.status >= 400 && r.status <= 500);
+        const successes = successResponses.map(sr => {
+            const req = requests.find(r => r.id == sr.id);
+            return {
+                request: (req.body || req.url),
+                response: sr.body
+            };
+        });
+        const failures = failureResponses.map(fr => {
+            const req = requests.find(r => r.id == fr.id);
+            return {
+                request: (req.body || req.url),
+                response: {
+                    error: fr.body["error"],
+                    message: fr.body["message"]
+                }
+            };
+        });
+        return {
+            successes,
+            failures
+        };
+    }
+    Batch.handleBatchResponse = handleBatchResponse;
+})(Batch || (Batch = {}));
+function addAuthHeader(headers, auth) {
+    headers = headers || {};
+    headers["Authorization"] = auth;
+    return headers;
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -746,22 +825,22 @@ function initialize(options) {
         }
     });
 }
-function verifyToken(token, baseUrl) {
+function verifyToken(token, baseUrl, headers = {}) {
     const _baseUrl = baseUrl ? baseUrl : service ? service.baseUrl : undefined;
     if (!_baseUrl) {
         throw new Error("You should pass the base url of the server or call the initialize method.");
     }
     const req = new Axios({ baseURL: _baseUrl });
-    return req.get(`${identitySegment}/verify`, { headers: { Authorization: token } });
+    return req.get(`${identitySegment}/verify`, { headers: { Authorization: token, ...headers } });
 }
-async function login(identifier, password, tokenLifeSpan) {
-    checkInitialized(authorization);
+async function login(identifier, password, tokenLifeSpan, headers) {
+    checkInitialized(authorization, service);
     return service
         .post("/passport/identify", {
         identifier,
         password,
         expires: tokenLifeSpan
-    })
+    }, { headers })
         .then(r => {
         if (isTokenScheme(r)) {
             return r.token;
@@ -777,7 +856,7 @@ function isChallenge(tokenOrChallenge) {
     return typeof tokenOrChallenge.show == "function" && typeof tokenOrChallenge.answer == "function";
 }
 async function loginWithStrategy(id) {
-    checkInitialized(authorization);
+    checkInitialized(authorization, service);
     const { url, state } = await service.get(`/passport/strategy/${id}/url`);
     const token = new Observable(observer => {
         service
@@ -803,71 +882,81 @@ async function loginWithStrategy(id) {
 }
 exports.authfactor = void 0;
 (function (authfactor) {
-    function list() {
-        return service.get("passport/identity/factors");
+    function list(headers) {
+        return service.get("passport/identity/factors", { headers });
     }
     authfactor.list = list;
-    async function register(identityId, factor) {
-        const response = await service.post(`passport/identity/${identityId}/start-factor-verification`, factor);
+    async function register(identityId, factor, headers) {
+        const response = await service.post(`passport/identity/${identityId}/start-factor-verification`, factor, { headers });
         const challenge = new _Challenge(response, response => response.message);
         return challenge;
     }
     authfactor.register = register;
-    function unregister(identityId) {
-        return service.delete(`passport/identity/${identityId}/factors`);
+    function unregister(identityId, headers) {
+        return service.delete(`passport/identity/${identityId}/factors`, { headers });
     }
     authfactor.unregister = unregister;
 })(exports.authfactor || (exports.authfactor = {}));
-function getStrategies() {
-    return service.get("/passport/strategies");
+function getStrategies(headers) {
+    return service.get("/passport/strategies", { headers });
 }
-function get(id) {
-    checkInitialized(authorization);
-    return service.get(`${identitySegment}/${id}`);
+function get(id, headers) {
+    checkInitialized(authorization, service);
+    return service.get(`${identitySegment}/${id}`, { headers });
 }
-function getAll(queryParams = {}) {
-    checkInitialized(authorization);
+function getAll(queryParams = {}, headers) {
+    checkInitialized(authorization, service);
     return service.get(identitySegment, {
-        params: queryParams
+        params: queryParams,
+        headers
     });
 }
-async function insert(identity) {
-    checkInitialized(authorization);
+async function insert(identity, headers) {
+    checkInitialized(authorization, service);
     identity = deepCopyJSON(identity);
     const desiredPolicies = identity.policies;
     delete identity.policies;
-    const insertedIdentity = await service.post(identitySegment, identity);
+    const insertedIdentity = await service.post(identitySegment, identity, { headers });
     return exports.policy.attach(insertedIdentity._id, desiredPolicies).then(policies => {
         insertedIdentity.policies = policies;
         return insertedIdentity;
     });
 }
-async function update(id, identity) {
-    checkInitialized(authorization);
+async function update(id, identity, headers) {
+    checkInitialized(authorization, service);
     const existingIdentity = await service.get(`${identitySegment}/${id}`);
     identity = deepCopyJSON(identity);
     const desiredPolicies = identity.policies;
     delete identity.policies;
     const { onlyInFirst: policiesForDetach, onlyInSecond: policiesForAttach } = getArrayDifferences(existingIdentity.policies, desiredPolicies);
-    const updatedIdentity = await service.put(`${identitySegment}/${id}`, identity);
+    const updatedIdentity = await service.put(`${identitySegment}/${id}`, identity, {
+        headers
+    });
     updatedIdentity.policies = desiredPolicies;
     await exports.policy.attach(id, policiesForAttach);
     await exports.policy.detach(id, policiesForDetach);
     return updatedIdentity;
 }
-function remove(id) {
-    checkInitialized(authorization);
-    return service.delete(`${identitySegment}/${id}`);
+function remove(id, headers) {
+    checkInitialized(authorization, service);
+    return service.delete(`${identitySegment}/${id}`, { headers });
+}
+function removeMany(ids, headers) {
+    checkInitialized(authorization, service);
+    const batchReqs = Batch.prepareRemoveRequest(ids, identitySegment, service.getAuthorization(), headers);
+    return service
+        .post("batch", batchReqs, { headers })
+        .then(response => Batch.handleBatchResponse(batchReqs, response));
 }
 exports.policy = void 0;
 (function (policy) {
-    function attach(identityId, policyIds = []) {
-        checkInitialized(authorization);
+    function attach(identityId, policyIds = [], headers) {
+        checkInitialized(authorization, service);
         const promises = [];
         const attachedPolicies = new Set();
         for (const policyId of policyIds) {
             const promise = service
-                .put(`${identitySegment}/${identityId}/policy/${policyId}`, {})
+                .put(`${identitySegment}/${identityId}/policy/${policyId}`, {}, { headers })
                 .then(() => attachedPolicies.add(policyId))
                 .catch(e => {
                 console.error(`Failed to attach policy with id ${policyId}: `, e);
@@ -878,13 +967,13 @@ exports.policy = void 0;
         return Promise.all(promises).then(() => Array.from(attachedPolicies));
     }
     policy.attach = attach;
-    function detach(identityId, policyIds = []) {
-        checkInitialized(authorization);
+    function detach(identityId, policyIds = [], headers) {
+        checkInitialized(authorization, service);
         const promises = [];
         const detachedPolicies = new Set();
         for (const policyId of policyIds) {
             const promise = service
-                .delete(`${identitySegment}/${identityId}/policy/${policyId}`)
+                .delete(`${identitySegment}/${identityId}/policy/${policyId}`, { headers })
                 .then(() => detachedPolicies.add(policyId))
                 .catch(e => {
                 console.error(`Failed to detach policy with id ${policyId}: `, e);
@@ -913,6 +1002,7 @@ exports.isChallenge = isChallenge;
 exports.login = login;
 exports.loginWithStrategy = loginWithStrategy;
 exports.remove = remove;
+exports.removeMany = removeMany;
 exports.update = update;
 exports.verifyToken = verifyToken;
 //# sourceMappingURL=index.js.map