@workos-inc/node 2.20.0 → 3.0.0-alpha.2

package/lib/users/serializers/authenticate-user-with-password-options.serializer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeAuthenticateUserWithPasswordOptions = void 0;
+const serializeAuthenticateUserWithPasswordOptions = (options) => ({
+    grant_type: 'password',
+    client_id: options.clientId,
+    client_secret: options.clientSecret,
+    email: options.email,
+    password: options.password,
+    ip_address: options.ipAddress,
+    user_agent: options.userAgent,
+    expires_in: options.expiresIn,
+});
+exports.serializeAuthenticateUserWithPasswordOptions = serializeAuthenticateUserWithPasswordOptions;

package/lib/users/serializers/authenticate-user-with-token-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { AuthenticateUserWithTokenCredentials, AuthenticateUserWithTokenOptions, SerializedAuthenticateUserWithTokenOptions } from '../interfaces';
+export declare const serializeAuthenticateUserWithTokenOptions: (options: AuthenticateUserWithTokenOptions & AuthenticateUserWithTokenCredentials) => SerializedAuthenticateUserWithTokenOptions;

package/lib/users/serializers/authenticate-user-with-token-options.serializer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeAuthenticateUserWithTokenOptions = void 0;
+const serializeAuthenticateUserWithTokenOptions = (options) => ({
+    grant_type: 'authorization_code',
+    client_id: options.clientId,
+    client_secret: options.clientSecret,
+    code: options.code,
+    expires_in: options.expiresIn,
+});
+exports.serializeAuthenticateUserWithTokenOptions = serializeAuthenticateUserWithTokenOptions;

package/lib/users/serializers/authentication-response.serializer.d.ts

@@ -0,0 +1,2 @@
+import { AuthenticationResponse, AuthenticationResponseResponse } from '../interfaces';
+export declare const deserializeAuthenticationResponse: (authenticationResponse: AuthenticationResponseResponse) => AuthenticationResponse;

package/lib/users/serializers/authentication-response.serializer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeAuthenticationResponse = void 0;
+const session_serializer_1 = require("./session.serializer");
+const user_serializer_1 = require("./user.serializer");
+const deserializeAuthenticationResponse = (authenticationResponse) => ({
+    session: authenticationResponse.session
+        ? (0, session_serializer_1.deserializeSession)(authenticationResponse.session)
+        : undefined,
+    user: (0, user_serializer_1.deserializeUser)(authenticationResponse.user),
+});
+exports.deserializeAuthenticationResponse = deserializeAuthenticationResponse;

package/lib/users/serializers/complete-password-reset-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { CompletePasswordResetOptions, SerializedCompletePasswordResetOptions } from '../interfaces';
+export declare const serializeCompletePasswordResetOptions: (options: CompletePasswordResetOptions) => SerializedCompletePasswordResetOptions;

package/lib/users/serializers/complete-password-reset-options.serializer.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCompletePasswordResetOptions = void 0;
+const serializeCompletePasswordResetOptions = (options) => ({
+    token: options.token,
+    new_password: options.newPassword,
+});
+exports.serializeCompletePasswordResetOptions = serializeCompletePasswordResetOptions;

package/lib/users/serializers/create-email-verification-challenge.serializer.d.ts

@@ -0,0 +1,2 @@
+import { CreateEmailVerificationChallengeResponse, CreateEmailVerificationChallengeResponseResponse } from '../interfaces';
+export declare const deserializeCreateEmailVerificationChallengeResponse: (createEmailVerificationChallengeResponse: CreateEmailVerificationChallengeResponseResponse) => CreateEmailVerificationChallengeResponse;

package/lib/users/serializers/create-email-verification-challenge.serializer.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeCreateEmailVerificationChallengeResponse = void 0;
+const user_serializer_1 = require("./user.serializer");
+const deserializeCreateEmailVerificationChallengeResponse = (createEmailVerificationChallengeResponse) => ({
+    token: createEmailVerificationChallengeResponse.token,
+    user: (0, user_serializer_1.deserializeUser)(createEmailVerificationChallengeResponse.user),
+});
+exports.deserializeCreateEmailVerificationChallengeResponse = deserializeCreateEmailVerificationChallengeResponse;

package/lib/users/serializers/create-password-reset-challenge.serializer.d.ts

@@ -0,0 +1,3 @@
+import { CreatePasswordResetChallengeOptions, CreatePasswordResetChallengeResponse, CreatePasswordResetChallengeResponseResponse, SerializedCreatePasswordResetChallengeOptions } from '../interfaces';
+export declare const deserializeCreatePasswordResetChallengeResponse: (createPasswordResetChallengeResponse: CreatePasswordResetChallengeResponseResponse) => CreatePasswordResetChallengeResponse;
+export declare const serializeCreatePasswordResetChallengeOptions: (options: CreatePasswordResetChallengeOptions) => SerializedCreatePasswordResetChallengeOptions;

package/lib/users/serializers/create-password-reset-challenge.serializer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCreatePasswordResetChallengeOptions = exports.deserializeCreatePasswordResetChallengeResponse = void 0;
+const user_serializer_1 = require("./user.serializer");
+const deserializeCreatePasswordResetChallengeResponse = (createPasswordResetChallengeResponse) => ({
+    token: createPasswordResetChallengeResponse.token,
+    user: (0, user_serializer_1.deserializeUser)(createPasswordResetChallengeResponse.user),
+});
+exports.deserializeCreatePasswordResetChallengeResponse = deserializeCreatePasswordResetChallengeResponse;
+const serializeCreatePasswordResetChallengeOptions = (options) => ({
+    email: options.email,
+    password_reset_url: options.passwordResetUrl,
+});
+exports.serializeCreatePasswordResetChallengeOptions = serializeCreatePasswordResetChallengeOptions;

package/lib/users/serializers/create-user-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { CreateUserOptions, SerializedCreateUserOptions } from '../interfaces';
+export declare const serializeCreateUserOptions: (options: CreateUserOptions) => SerializedCreateUserOptions;

package/lib/users/serializers/create-user-options.serializer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCreateUserOptions = void 0;
+const serializeCreateUserOptions = (options) => ({
+    email: options.email,
+    password: options.password,
+    first_name: options.firstName,
+    last_name: options.lastName,
+    email_verified: options.emailVerified,
+});
+exports.serializeCreateUserOptions = serializeCreateUserOptions;

package/lib/users/serializers/index.d.ts

@@ -0,0 +1,13 @@
+export * from './authenticate-user-with-password-options.serializer';
+export * from './authenticate-user-with-token-options.serializer';
+export * from './authentication-response.serializer';
+export * from './complete-password-reset-options.serializer';
+export * from './create-email-verification-challenge.serializer';
+export * from './create-password-reset-challenge.serializer';
+export * from './create-user-options.serializer';
+export * from './revoke-session-options.serializer';
+export * from './session.serializer';
+export * from './update-user-password-options.serializer';
+export * from './update-user-options.serializer';
+export * from './user.serializer';
+export * from './verify-session.serializer';

package/lib/users/serializers/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./authenticate-user-with-password-options.serializer"), exports);
+__exportStar(require("./authenticate-user-with-token-options.serializer"), exports);
+__exportStar(require("./authentication-response.serializer"), exports);
+__exportStar(require("./complete-password-reset-options.serializer"), exports);
+__exportStar(require("./create-email-verification-challenge.serializer"), exports);
+__exportStar(require("./create-password-reset-challenge.serializer"), exports);
+__exportStar(require("./create-user-options.serializer"), exports);
+__exportStar(require("./revoke-session-options.serializer"), exports);
+__exportStar(require("./session.serializer"), exports);
+__exportStar(require("./update-user-password-options.serializer"), exports);
+__exportStar(require("./update-user-options.serializer"), exports);
+__exportStar(require("./user.serializer"), exports);
+__exportStar(require("./verify-session.serializer"), exports);

package/lib/users/serializers/revoke-session-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { RevokeSessionOptions, SerializedRevokeSessionOptions } from '../interfaces';
+export declare const serializeRevokeSessionOptions: (options: RevokeSessionOptions) => SerializedRevokeSessionOptions;

package/lib/users/serializers/revoke-session-options.serializer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeRevokeSessionOptions = void 0;
+const serializeRevokeSessionOptions = (options) => {
+    if ('sessionId' in options) {
+        return {
+            session_id: options.sessionId,
+        };
+    }
+    return {
+        session_token: options.sessionToken,
+    };
+};
+exports.serializeRevokeSessionOptions = serializeRevokeSessionOptions;

package/lib/users/serializers/session.serializer.d.ts

@@ -0,0 +1,2 @@
+import { Session, SessionResponse } from '../interfaces/session.interface';
+export declare const deserializeSession: (session: SessionResponse) => Session;

package/lib/users/serializers/session.serializer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeSession = void 0;
+const deserializeSession = (session) => ({
+    id: session.id,
+    createdAt: session.created_at,
+    expiresAt: session.expires_at,
+    token: session.token,
+});
+exports.deserializeSession = deserializeSession;

package/lib/users/serializers/update-user-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { SerializedUpdateUserOptions, UpdateUserOptions } from '../interfaces';
+export declare const serializeUpdateUserOptions: (options: UpdateUserOptions) => SerializedUpdateUserOptions;

package/lib/users/serializers/update-user-options.serializer.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeUpdateUserOptions = void 0;
+const serializeUpdateUserOptions = (options) => ({
+    first_name: options.firstName,
+    last_name: options.lastName,
+});
+exports.serializeUpdateUserOptions = serializeUpdateUserOptions;

package/lib/users/serializers/update-user-password-options.serializer.d.ts

@@ -0,0 +1,2 @@
+import { SerializedUpdateUserPasswordOptions, UpdateUserPasswordOptions } from '../interfaces';
+export declare const serializeUpdateUserPasswordOptions: (options: UpdateUserPasswordOptions) => SerializedUpdateUserPasswordOptions;

package/lib/users/serializers/update-user-password-options.serializer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeUpdateUserPasswordOptions = void 0;
+const serializeUpdateUserPasswordOptions = (options) => ({
+    password: options.password,
+});
+exports.serializeUpdateUserPasswordOptions = serializeUpdateUserPasswordOptions;

package/lib/users/serializers/user.serializer.d.ts

@@ -0,0 +1,2 @@
+import { User, UserResponse } from '../interfaces';
+export declare const deserializeUser: (user: UserResponse) => User;

package/lib/users/serializers/user.serializer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeUser = void 0;
+const exceptions_1 = require("../exceptions");
+const deserializeUser = (user) => {
+    const baseUser = {
+        object: user.object,
+        id: user.id,
+        email: user.email,
+        firstName: user.first_name,
+        lastName: user.last_name,
+        createdAt: user.created_at,
+        updatedAt: user.updated_at,
+    };
+    switch (user.user_type) {
+        case 'managed':
+            return Object.assign(Object.assign({}, baseUser), { userType: user.user_type, organizationMemberships: [
+                    deserializeOrganizationMembership(user.organization_memberships[0]),
+                ], ssoProfileId: user.sso_profile_id });
+        case 'unmanaged':
+            return Object.assign(Object.assign({}, baseUser), { userType: user.user_type, organizationMemberships: user.organization_memberships.map(deserializeOrganizationMembership), emailVerifiedAt: user.email_verified_at, googleOauthProfileId: user.google_oauth_profile_id, microsoftOauthProfileId: user.microsoft_oauth_profile_id });
+        default:
+            throw new exceptions_1.UnexpectedUserTypeException(user);
+    }
+};
+exports.deserializeUser = deserializeUser;
+const deserializeOrganizationMembership = (organizationMembership) => ({
+    organization: organizationMembership.organization,
+    createdAt: organizationMembership.created_at,
+    updatedAt: organizationMembership.updated_at,
+});

package/lib/users/serializers/verify-session.serializer.d.ts

@@ -0,0 +1,3 @@
+import { SerializedVerifySessionOptions, VerifySessionOptions, VerifySessionResponse, VerifySessionResponseResponse } from '../interfaces';
+export declare const deserializeVerifySessionResponse: (verifySessionResponse: VerifySessionResponseResponse) => VerifySessionResponse;
+export declare const serializeVerifySessionOptions: (options: VerifySessionOptions) => SerializedVerifySessionOptions;

package/lib/users/serializers/verify-session.serializer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeVerifySessionOptions = exports.deserializeVerifySessionResponse = void 0;
+const session_serializer_1 = require("./session.serializer");
+const user_serializer_1 = require("./user.serializer");
+const deserializeVerifySessionResponse = (verifySessionResponse) => ({
+    session: (0, session_serializer_1.deserializeSession)(verifySessionResponse.session),
+    user: (0, user_serializer_1.deserializeUser)(verifySessionResponse.user),
+});
+exports.deserializeVerifySessionResponse = deserializeVerifySessionResponse;
+const serializeVerifySessionOptions = (options) => ({
+    token: options.token,
+    client_id: options.clientId,
+});
+exports.serializeVerifySessionOptions = serializeVerifySessionOptions;

package/lib/users/users.d.ts

@@ -0,0 +1,23 @@
+import { WorkOS } from '../workos';
+import { AddUserToOrganizationOptions, AuthenticateUserWithPasswordOptions, AuthenticateUserWithTokenOptions, AuthenticationResponse, CompletePasswordResetOptions, CreateEmailVerificationChallengeOptions, CreateEmailVerificationChallengeResponse, CreatePasswordResetChallengeOptions, CreatePasswordResetChallengeResponse, CreateUserOptions, ListUsersOptions, RemoveUserFromOrganizationOptions, RevokeSessionOptions, UpdateUserOptions, UpdateUserPasswordOptions, User, VerifySessionOptions, VerifySessionResponse } from './interfaces';
+import { DeserializedList } from '../common/interfaces';
+export declare class Users {
+    private readonly workos;
+    constructor(workos: WorkOS);
+    getUser(userId: string): Promise<User>;
+    listUsers(options?: ListUsersOptions): Promise<DeserializedList<User>>;
+    createUser(payload: CreateUserOptions): Promise<User>;
+    authenticateUserWithPassword(payload: AuthenticateUserWithPasswordOptions): Promise<AuthenticationResponse>;
+    authenticateUserWithToken(payload: AuthenticateUserWithTokenOptions): Promise<AuthenticationResponse>;
+    verifySession(payload: VerifySessionOptions): Promise<VerifySessionResponse>;
+    revokeSession(payload: RevokeSessionOptions): Promise<boolean>;
+    revokeAllSessionsForUser(userId: string): Promise<boolean>;
+    createEmailVerificationChallenge({ userId, verificationUrl, }: CreateEmailVerificationChallengeOptions): Promise<CreateEmailVerificationChallengeResponse>;
+    completeEmailVerification(token: string): Promise<User>;
+    createPasswordResetChallenge(payload: CreatePasswordResetChallengeOptions): Promise<CreatePasswordResetChallengeResponse>;
+    completePasswordReset(payload: CompletePasswordResetOptions): Promise<User>;
+    addUserToOrganization({ userId, organizationId, }: AddUserToOrganizationOptions): Promise<User>;
+    removeUserFromOrganization({ userId, organizationId, }: RemoveUserFromOrganizationOptions): Promise<User>;
+    updateUser(payload: UpdateUserOptions): Promise<User>;
+    updateUserPassword(payload: UpdateUserPasswordOptions): Promise<User>;
+}

package/lib/users/users.js

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const serializers_1 = require("./serializers");
+const serializers_2 = require("../common/serializers");
+class Users {
+    constructor(workos) {
+        this.workos = workos;
+    }
+    getUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.get(`/users/${userId}`);
+            return (0, serializers_1.deserializeUser)(data);
+        });
+    }
+    listUsers(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.get('/users', {
+                query: options,
+            });
+            return (0, serializers_2.deserializeList)(data, serializers_1.deserializeUser);
+        });
+    }
+    createUser(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/users', (0, serializers_1.serializeCreateUserOptions)(payload));
+            return (0, serializers_1.deserializeUser)(data);
+        });
+    }
+    authenticateUserWithPassword(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/users/sessions/token', (0, serializers_1.serializeAuthenticateUserWithPasswordOptions)(Object.assign(Object.assign({}, payload), { clientSecret: this.workos.key })));
+            return (0, serializers_1.deserializeAuthenticationResponse)(data);
+        });
+    }
+    authenticateUserWithToken(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/users/sessions/token', (0, serializers_1.serializeAuthenticateUserWithTokenOptions)(Object.assign(Object.assign({}, payload), { clientSecret: this.workos.key })));
+            return (0, serializers_1.deserializeAuthenticationResponse)(data);
+        });
+    }
+    verifySession(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/users/sessions/verify', (0, serializers_1.serializeVerifySessionOptions)(payload));
+            return (0, serializers_1.deserializeVerifySessionResponse)(data);
+        });
+    }
+    revokeSession(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/users/sessions/revocations', (0, serializers_1.serializeRevokeSessionOptions)(payload));
+            return data;
+        });
+    }
+    revokeAllSessionsForUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.delete(`/users/${userId}/sessions`);
+            return data;
+        });
+    }
+    createEmailVerificationChallenge({ userId, verificationUrl, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post(`/users/${userId}/email_verification_challenge`, {
+                verification_url: verificationUrl,
+            });
+            return (0, serializers_1.deserializeCreateEmailVerificationChallengeResponse)(data);
+        });
+    }
+    completeEmailVerification(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/users/email_verification', {
+                token,
+            });
+            return (0, serializers_1.deserializeUser)(data);
+        });
+    }
+    createPasswordResetChallenge(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/users/password_reset_challenge', (0, serializers_1.serializeCreatePasswordResetChallengeOptions)(payload));
+            return (0, serializers_1.deserializeCreatePasswordResetChallengeResponse)(data);
+        });
+    }
+    completePasswordReset(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post('/users/password_reset', (0, serializers_1.serializeCompletePasswordResetOptions)(payload));
+            return (0, serializers_1.deserializeUser)(data);
+        });
+    }
+    addUserToOrganization({ userId, organizationId, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.post(`/users/${userId}/organizations`, {
+                organization_id: organizationId,
+            });
+            return (0, serializers_1.deserializeUser)(data);
+        });
+    }
+    removeUserFromOrganization({ userId, organizationId, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.delete(`/users/${userId}/organizations/${organizationId}`);
+            return (0, serializers_1.deserializeUser)(data);
+        });
+    }
+    updateUser(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.put(`/users/${payload.userId}`, (0, serializers_1.serializeUpdateUserOptions)(payload));
+            return (0, serializers_1.deserializeUser)(data);
+        });
+    }
+    updateUserPassword(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.workos.put(`/users/${payload.userId}/password`, (0, serializers_1.serializeUpdateUserPasswordOptions)(payload));
+            return (0, serializers_1.deserializeUser)(data);
+        });
+    }
+}
+exports.Users = Users;

package/lib/users/users.spec.d.ts

@@ -0,0 +1 @@
+export {};