@verdocs/web-sdk 1.2.0 → 1.4.0

package/dist/components/Auth.js

@@ -0,0 +1,157 @@
+import { g as getEndpoint, d as decodeAccessTokenBody } from './Token.js';
+
+/**
+ * Authenticate to Verdocs via user/password authentication
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ * import {Transport} from '@verdocs/js-sdk/HTTP';
+ *
+ * const {accessToken} = await Auth.authenticateUser({ username: 'test@test.com', password: 'PASSWORD' });
+ * Transport.setAuthToken(accessToken);
+ * ```
+ */
+var authenticateUser = function (params) {
+    return getEndpoint()
+        .api.post('/authentication/login', params)
+        .then(function (r) { return r.data; });
+};
+/**
+ * Authenticate to Verdocs via client ID / Secret authentication. **NOTE: This is only suitable for
+ * NodeJS server-side applications. Never expose your Client Secret in a Web or Mobile app!** Also note
+ * that access tokens may be cached by server-side apps (and this is recommended) but do expire after 2
+ * hours. This expiration may change based on future security needs. Application developers are encouraged
+ * to check the `exp` expiration field in the response accessToken and renew tokens after they expire.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ * import {Transport} from '@verdocs/js-sdk/HTTP';
+ *
+ * const {accessToken} = await Auth.authenticateApp({ client_id: 'CLIENTID', client_secret: 'SECRET' });
+ * Transport.setAuthToken(accessToken);
+ * ```
+ */
+var authenticateApp = function (params) {
+    return getEndpoint()
+        .api.post('/authentication/login_client', {}, { headers: params })
+        .then(function (r) { return r.data; });
+};
+/**
+ * Validate a token. Only Verdocs tokens will be accepted. Most applications can decode tokens locally,
+ * because tokens will be validated when API calls are made anyway. However, high-security applications
+ * may use this endpoint to check if a token has been revoked.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ *
+ * const {valid} = await Auth.validateToken({ token });
+ * if (!valid) {
+ *   window.alert('Session invalid or expired. Please re-authenticate.');
+ * }
+ * ```
+ */
+var validateToken = function (params) {
+    return getEndpoint()
+        .api.post('/token/isValid', params)
+        .then(function (r) { return r.data; });
+};
+/**
+ * If called before the session expires, this will refresh the caller's session and tokens.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ * import {Transport} from '@verdocs/js-sdk/HTTP';
+ *
+ * const {accessToken} = await Auth.refreshTokens();
+ * Transport.setAuthToken(accessToken);
+ * ```
+ */
+var refreshTokens = function () {
+    return getEndpoint()
+        .api.get('/token')
+        .then(function (r) { return r.data; });
+};
+/**
+ * Update the caller's password. To help prevent CSRF attack vectors, the user's old password and email address are required.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ *
+ * const {status, message} = await Auth.updatePassword({ email, oldPassword, newPassword });
+ * if (status !== 'OK') {
+ *   window.alert(`Password reset error: ${message}`);
+ * }
+ * ```
+ */
+var updatePassword = function (params) {
+    return getEndpoint()
+        .api.put('/user/update_password', params)
+        .then(function (r) { return r.data; });
+};
+/**
+ * Update the caller's email address.
+ *
+ * ```typescript
+ * import {Auth} from '@verdocs/js-sdk/Auth';
+ *
+ * const {profiles} = await Auth.updateEmail({ email: newEmail });
+ * ```
+ */
+var updateEmail = function (params) {
+    return getEndpoint()
+        .api.put('/user/update_email', params)
+        .then(function (r) { return r.data; });
+};
+var clearSession = function (source, persist) {
+    getEndpoint().setAuthorization(null);
+    if (persist) {
+        localStorage.removeItem(source);
+    }
+    return null;
+};
+/**
+ * Parses and sets the active session, optionally persisting (brower-only, persists to localStorage).
+ */
+var setSession = function (source, token, persist) {
+    if (persist === void 0) { persist = false; }
+    if (token === null) {
+        return clearSession(source, persist);
+    }
+    var session = decodeAccessTokenBody(token || '');
+    if (session === null || (session.exp && session.exp * 1000 < new Date().getTime())) {
+        return clearSession(source, persist);
+    }
+    if (persist) {
+        localStorage.setItem(source, token);
+    }
+    getEndpoint().setAuthorization(token);
+    return session;
+};
+/**
+ * Load a session from localStorage
+ */
+var loadSession = function (source) {
+    var token = localStorage.getItem(source);
+    if (!token) {
+        return null;
+    }
+    var session = decodeAccessTokenBody(token);
+    if (!session) {
+        return null;
+    }
+    if (session.exp && session.exp * 1000 < new Date().getTime()) {
+        localStorage.removeItem(source);
+        return null;
+    }
+    getEndpoint().setAuthorization(token);
+    return session;
+};
+/**
+ * End the active session.
+ */
+var endSession = function (source, persist) {
+    if (persist === void 0) { persist = false; }
+    return clearSession(source, persist);
+};
+
+export { authenticateUser as a, loadSession as l, setSession as s };