@boxyhq/saml-jackson 1.1.5 → 1.2.1

package/dist/directory-sync/DirectoryGroups.js

@@ -0,0 +1,254 @@
+"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.DirectoryGroups = void 0;
+const utils_1 = require("./utils");
+const events_1 = require("./events");
+class DirectoryGroups {
+    constructor({ directories, users, groups, }) {
+        this.directories = directories;
+        this.users = users;
+        this.groups = groups;
+    }
+    create(directory, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { displayName, members } = body;
+            const { data: group } = yield this.groups.create({
+                name: displayName,
+                raw: body,
+            });
+            yield (0, events_1.sendEvent)('group.created', { directory, group }, this.callback);
+            return {
+                status: 201,
+                data: {
+                    schemas: ['urn:ietf:params:scim:schemas:core:2.0:Group'],
+                    id: group === null || group === void 0 ? void 0 : group.id,
+                    displayName: group === null || group === void 0 ? void 0 : group.name,
+                    members: members !== null && members !== void 0 ? members : [],
+                },
+            };
+        });
+    }
+    get(group) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                status: 200,
+                data: {
+                    schemas: ['urn:ietf:params:scim:schemas:core:2.0:Group'],
+                    id: group.id,
+                    displayName: group.name,
+                    members: (0, utils_1.toGroupMembers)(yield this.groups.getAllUsers(group.id)),
+                },
+            };
+        });
+    }
+    delete(directory, group) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.groups.removeAllUsers(group.id);
+            yield this.groups.delete(group.id);
+            yield (0, events_1.sendEvent)('group.deleted', { directory, group }, this.callback);
+            return {
+                status: 200,
+                data: {},
+            };
+        });
+    }
+    getAll(queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { filter } = queryParams;
+            let groups = [];
+            if (filter) {
+                // Filter by group displayName
+                // filter: displayName eq "Developer"
+                const { data } = yield this.groups.search(filter.split('eq ')[1].replace(/['"]+/g, ''));
+                groups = data;
+            }
+            else {
+                // Fetch all the existing group
+                const { data } = yield this.groups.list({ pageOffset: undefined, pageLimit: undefined });
+                groups = data;
+            }
+            return {
+                status: 200,
+                data: {
+                    schemas: ['urn:ietf:params:scim:api:messages:2.0:ListResponse'],
+                    totalResults: groups ? groups.length : 0,
+                    itemsPerPage: groups ? groups.length : 0,
+                    startIndex: 1,
+                    Resources: groups ? groups.map((group) => group.raw) : [],
+                },
+            };
+        });
+    }
+    // Update group displayName
+    updateDisplayName(directory, group, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { displayName } = body;
+            const { data: updatedGroup, error } = yield this.groups.update(group.id, {
+                name: displayName,
+                raw: Object.assign(Object.assign({}, group.raw), body),
+            });
+            if (error || !updatedGroup) {
+                throw error;
+            }
+            yield (0, events_1.sendEvent)('group.updated', { directory, group: updatedGroup }, this.callback);
+            return updatedGroup;
+        });
+    }
+    patch(directory, group, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { Operations } = body;
+            const operation = (0, utils_1.parseGroupOperations)(Operations);
+            // Add group members
+            if (operation.action === 'addGroupMember') {
+                yield this.addGroupMembers(directory, group, operation.members);
+            }
+            // Remove group members
+            if (operation.action === 'removeGroupMember') {
+                yield this.removeGroupMembers(directory, group, operation.members);
+            }
+            // Update group name
+            if (operation.action === 'updateGroupName') {
+                yield this.updateDisplayName(directory, group, {
+                    displayName: operation.displayName,
+                });
+            }
+            const { data: updatedGroup } = yield this.groups.get(group.id);
+            return {
+                status: 200,
+                data: {
+                    schemas: ['urn:ietf:params:scim:schemas:core:2.0:Group'],
+                    id: updatedGroup === null || updatedGroup === void 0 ? void 0 : updatedGroup.id,
+                    displayName: updatedGroup === null || updatedGroup === void 0 ? void 0 : updatedGroup.name,
+                    members: (0, utils_1.toGroupMembers)(yield this.groups.getAllUsers(group.id)),
+                },
+            };
+        });
+    }
+    update(directory, group, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { displayName, members } = body;
+            // Update group name
+            const updatedGroup = yield this.updateDisplayName(directory, group, {
+                displayName,
+            });
+            // Update group members
+            if (members) {
+                yield this.addOrRemoveGroupMembers(directory, group, members);
+            }
+            return {
+                status: 200,
+                data: {
+                    schemas: ['urn:ietf:params:scim:schemas:core:2.0:Group'],
+                    id: group.id,
+                    displayName: updatedGroup.name,
+                    members: (0, utils_1.toGroupMembers)(yield this.groups.getAllUsers(group.id)),
+                },
+            };
+        });
+    }
+    addGroupMembers(directory, group, members, sendWebhookEvent = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (members === undefined || (members && members.length === 0)) {
+                return;
+            }
+            for (const member of members) {
+                if (yield this.groups.isUserInGroup(group.id, member.value)) {
+                    continue;
+                }
+                yield this.groups.addUserToGroup(group.id, member.value);
+                const { data: user } = yield this.users.get(member.value);
+                if (sendWebhookEvent && user) {
+                    yield (0, events_1.sendEvent)('group.user_added', { directory, group, user }, this.callback);
+                }
+            }
+        });
+    }
+    removeGroupMembers(directory, group, members, sendWebhookEvent = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (members.length === 0) {
+                return;
+            }
+            for (const member of members) {
+                yield this.groups.removeUserFromGroup(group.id, member.value);
+                const { data: user } = yield this.users.get(member.value);
+                // User may not exist in the directory, so we need to check if the user exists
+                if (sendWebhookEvent && user) {
+                    yield (0, events_1.sendEvent)('group.user_removed', { directory, group, user }, this.callback);
+                }
+            }
+        });
+    }
+    // Add or remove users from a group
+    addOrRemoveGroupMembers(directory, group, members) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const users = (0, utils_1.toGroupMembers)(yield this.groups.getAllUsers(group.id));
+            const usersToAdd = members.filter((member) => !users.some((user) => user.value === member.value));
+            const usersToRemove = users
+                .filter((user) => !members.some((member) => member.value === user.value))
+                .map((user) => ({ value: user.value }));
+            yield this.addGroupMembers(directory, group, usersToAdd, false);
+            yield this.removeGroupMembers(directory, group, usersToRemove, false);
+        });
+    }
+    respondWithError(error) {
+        return {
+            status: error ? error.code : 500,
+            data: null,
+        };
+    }
+    // Handle the request from the Identity Provider and route it to the appropriate method
+    handleRequest(request, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { body, query, resourceId: groupId, directoryId, apiSecret } = request;
+            const method = request.method.toUpperCase();
+            // Get the directory
+            const { data: directory, error } = yield this.directories.get(directoryId);
+            if (error || !directory) {
+                return this.respondWithError(error);
+            }
+            // Validate the request
+            if (directory.scim.secret != apiSecret) {
+                return this.respondWithError({ code: 401, message: 'Unauthorized' });
+            }
+            this.callback = callback;
+            this.users.setTenantAndProduct(directory.tenant, directory.product);
+            this.groups.setTenantAndProduct(directory.tenant, directory.product);
+            // Get the group
+            const { data: group } = groupId ? yield this.groups.get(groupId) : { data: null };
+            if (group) {
+                switch (method) {
+                    case 'GET':
+                        return yield this.get(group);
+                    case 'PUT':
+                        return yield this.update(directory, group, body);
+                    case 'PATCH':
+                        return yield this.patch(directory, group, body);
+                    case 'DELETE':
+                        return yield this.delete(directory, group);
+                }
+            }
+            switch (method) {
+                case 'POST':
+                    return yield this.create(directory, body);
+                case 'GET':
+                    return yield this.getAll({
+                        filter: query.filter,
+                    });
+            }
+            return {
+                status: 404,
+                data: {},
+            };
+        });
+    }
+}
+exports.DirectoryGroups = DirectoryGroups;

package/dist/directory-sync/DirectoryUsers.d.ts

@@ -0,0 +1,22 @@
+import type { DirectoryConfig, Directory, DirectorySyncResponse, DirectorySyncRequest, User, Users, IDirectoryUsers, EventCallback } from '../typings';
+export declare class DirectoryUsers implements IDirectoryUsers {
+    private directories;
+    private users;
+    private callback;
+    constructor({ directories, users }: {
+        directories: DirectoryConfig;
+        users: Users;
+    });
+    create(directory: Directory, body: any): Promise<DirectorySyncResponse>;
+    get(user: User): Promise<DirectorySyncResponse>;
+    update(directory: Directory, user: User, body: any): Promise<DirectorySyncResponse>;
+    patch(directory: Directory, user: User, body: any): Promise<DirectorySyncResponse>;
+    delete(directory: Directory, user: User): Promise<DirectorySyncResponse>;
+    getAll(queryParams: {
+        count: number;
+        startIndex: number;
+        filter?: string;
+    }): Promise<DirectorySyncResponse>;
+    private respondWithError;
+    handleRequest(request: DirectorySyncRequest, callback?: EventCallback): Promise<DirectorySyncResponse>;
+}

package/dist/directory-sync/DirectoryUsers.js

@@ -0,0 +1,175 @@
+"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.DirectoryUsers = void 0;
+const utils_1 = require("./utils");
+const events_1 = require("./events");
+class DirectoryUsers {
+    constructor({ directories, users }) {
+        this.directories = directories;
+        this.users = users;
+    }
+    create(directory, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { name, emails } = body;
+            const { data: user } = yield this.users.create({
+                first_name: name && 'givenName' in name ? name.givenName : '',
+                last_name: name && 'familyName' in name ? name.familyName : '',
+                email: emails[0].value,
+                active: true,
+                raw: body,
+            });
+            yield (0, events_1.sendEvent)('user.created', { directory, user }, this.callback);
+            return {
+                status: 201,
+                data: user === null || user === void 0 ? void 0 : user.raw,
+            };
+        });
+    }
+    get(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                status: 200,
+                data: user.raw,
+            };
+        });
+    }
+    update(directory, user, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { name, emails, active } = body;
+            const { data: updatedUser } = yield this.users.update(user.id, {
+                first_name: name.givenName,
+                last_name: name.familyName,
+                email: emails[0].value,
+                active,
+                raw: body,
+            });
+            yield (0, events_1.sendEvent)('user.updated', { directory, user: updatedUser }, this.callback);
+            return {
+                status: 200,
+                data: updatedUser === null || updatedUser === void 0 ? void 0 : updatedUser.raw,
+            };
+        });
+    }
+    patch(directory, user, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { Operations } = body;
+            const operation = (0, utils_1.parseUserOperations)(Operations);
+            if (operation.action === 'updateUser') {
+                const { data: updatedUser } = yield this.users.update(user.id, Object.assign(Object.assign(Object.assign({}, user), operation.attributes), { raw: Object.assign(Object.assign({}, user.raw), operation.raw) }));
+                yield (0, events_1.sendEvent)('user.updated', { directory, user: updatedUser }, this.callback);
+                return {
+                    status: 200,
+                    data: updatedUser === null || updatedUser === void 0 ? void 0 : updatedUser.raw,
+                };
+            }
+            return {
+                status: 200,
+                data: null,
+            };
+        });
+    }
+    delete(directory, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.users.delete(user.id);
+            yield (0, events_1.sendEvent)('user.deleted', { directory, user }, this.callback);
+            return {
+                status: 200,
+                data: user.raw,
+            };
+        });
+    }
+    getAll(queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { startIndex, filter, count } = queryParams;
+            let users = [];
+            let totalResults = 0;
+            if (filter) {
+                // Search users by userName
+                // filter: userName eq "john@example.com"
+                const { data } = yield this.users.search(filter.split('eq ')[1].replace(/['"]+/g, ''));
+                users = data;
+                totalResults = users ? users.length : 0;
+            }
+            else {
+                // Fetch all the existing Users (Paginated)
+                // At this moment, we don't have method to count the database records.
+                const { data: allUsers } = yield this.users.list({});
+                const { data } = yield this.users.list({ pageOffset: startIndex - 1, pageLimit: count });
+                users = data;
+                totalResults = allUsers ? allUsers.length : 0;
+            }
+            return {
+                status: 200,
+                data: {
+                    schemas: ['urn:ietf:params:scim:api:messages:2.0:ListResponse'],
+                    startIndex: startIndex ? startIndex : 1,
+                    totalResults: totalResults ? totalResults : 0,
+                    itemsPerPage: count ? count : 0,
+                    Resources: users ? users.map((user) => user.raw) : [],
+                },
+            };
+        });
+    }
+    respondWithError(error) {
+        return {
+            status: error ? error.code : 500,
+            data: null,
+        };
+    }
+    // Handle the request from the Identity Provider and route it to the appropriate method
+    handleRequest(request, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { body, query, resourceId: userId, directoryId, apiSecret } = request;
+            const method = request.method.toUpperCase();
+            // Get the directory
+            const { data: directory, error } = yield this.directories.get(directoryId);
+            if (error || !directory) {
+                return this.respondWithError(error);
+            }
+            // Validate the request
+            if (directory.scim.secret != apiSecret) {
+                return this.respondWithError({ code: 401, message: 'Unauthorized' });
+            }
+            this.callback = callback;
+            this.users.setTenantAndProduct(directory.tenant, directory.product);
+            // Get the user
+            const { data: user } = userId ? yield this.users.get(userId) : { data: null };
+            if (user) {
+                switch (method) {
+                    case 'GET':
+                        return yield this.get(user);
+                    case 'PATCH':
+                        return yield this.patch(directory, user, body);
+                    case 'PUT':
+                        return yield this.update(directory, user, body);
+                    case 'DELETE':
+                        return yield this.delete(directory, user);
+                }
+            }
+            switch (method) {
+                case 'POST':
+                    return yield this.create(directory, body);
+                case 'GET':
+                    return yield this.getAll({
+                        count: query.count,
+                        startIndex: query.startIndex,
+                        filter: query.filter,
+                    });
+            }
+            return {
+                status: 404,
+                data: {},
+            };
+        });
+    }
+}
+exports.DirectoryUsers = DirectoryUsers;

package/dist/directory-sync/Groups.d.ts

@@ -0,0 +1,47 @@
+import type { Group, DatabaseStore, ApiError } from '../typings';
+import { Base } from './Base';
+export declare class Groups extends Base {
+    constructor({ db }: {
+        db: DatabaseStore;
+    });
+    create(param: {
+        name: string;
+        raw: any;
+    }): Promise<{
+        data: Group | null;
+        error: ApiError | null;
+    }>;
+    get(id: string): Promise<{
+        data: Group | null;
+        error: ApiError | null;
+    }>;
+    update(id: string, param: {
+        name: string;
+        raw: any;
+    }): Promise<{
+        data: Group | null;
+        error: ApiError | null;
+    }>;
+    delete(id: string): Promise<{
+        data: null;
+        error: ApiError | null;
+    }>;
+    getAllUsers(groupId: string): Promise<{
+        user_id: string;
+    }[]>;
+    addUserToGroup(groupId: string, userId: string): Promise<void>;
+    removeUserFromGroup(groupId: string, userId: string): Promise<void>;
+    removeAllUsers(groupId: string): Promise<void>;
+    isUserInGroup(groupId: string, userId: string): Promise<boolean>;
+    search(displayName: string): Promise<{
+        data: Group[] | null;
+        error: ApiError | null;
+    }>;
+    list({ pageOffset, pageLimit, }: {
+        pageOffset?: number;
+        pageLimit?: number;
+    }): Promise<{
+        data: Group[] | null;
+        error: ApiError | null;
+    }>;
+}

package/dist/directory-sync/Groups.js

@@ -0,0 +1,195 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.Groups = void 0;
+const dbutils = __importStar(require("../db/utils"));
+const error_1 = require("../controller/error");
+const Base_1 = require("./Base");
+class Groups extends Base_1.Base {
+    constructor({ db }) {
+        super({ db });
+    }
+    // Create a new group
+    create(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { name, raw } = param;
+                const id = this.createId();
+                raw['id'] = id;
+                const group = {
+                    id,
+                    name,
+                    raw,
+                };
+                yield this.store('groups').put(id, group, {
+                    name: 'displayName',
+                    value: name,
+                });
+                return { data: group, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Get a group by id
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const group = yield this.store('groups').get(id);
+                if (!group) {
+                    throw new error_1.JacksonError(`Group with id ${id} not found.`, 404);
+                }
+                return { data: group, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Update the group data
+    update(id, param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { name, raw } = param;
+                const group = {
+                    id,
+                    name,
+                    raw,
+                };
+                yield this.store('groups').put(id, group);
+                return { data: group, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Delete a group by id
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.get(id);
+                if (error || !data) {
+                    throw error;
+                }
+                yield this.store('groups').delete(id);
+                return { data: null, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Get all users in a group
+    getAllUsers(groupId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const users = yield this.store('members').getByIndex({
+                name: 'groupId',
+                value: groupId,
+            });
+            if (users.length === 0) {
+                return [];
+            }
+            return users;
+        });
+    }
+    // Add a user to a group
+    addUserToGroup(groupId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = dbutils.keyDigest(dbutils.keyFromParts(groupId, userId));
+            yield this.store('members').put(id, {
+                group_id: groupId,
+                user_id: userId,
+            }, {
+                name: 'groupId',
+                value: groupId,
+            });
+        });
+    }
+    // Remove a user from a group
+    removeUserFromGroup(groupId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = dbutils.keyDigest(dbutils.keyFromParts(groupId, userId));
+            yield this.store('members').delete(id);
+        });
+    }
+    // Remove all users from a group
+    removeAllUsers(groupId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const users = yield this.getAllUsers(groupId);
+            if (users.length === 0) {
+                return;
+            }
+            for (const user of users) {
+                yield this.removeUserFromGroup(groupId, user.user_id);
+            }
+        });
+    }
+    // Check if a user is a member of a group
+    isUserInGroup(groupId, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = dbutils.keyDigest(dbutils.keyFromParts(groupId, userId));
+            return !!(yield this.store('members').get(id));
+        });
+    }
+    // Search groups by displayName
+    search(displayName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const groups = (yield this.store('groups').getByIndex({
+                    name: 'displayName',
+                    value: displayName,
+                }));
+                return { data: groups, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+    // Get all groups in a directory
+    list({ pageOffset, pageLimit, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const groups = (yield this.store('groups').getAll(pageOffset, pageLimit));
+                return { data: groups, error: null };
+            }
+            catch (err) {
+                return (0, error_1.apiError)(err);
+            }
+        });
+    }
+}
+exports.Groups = Groups;