@fonoster/identity 0.6.1-alpha.0

package/dist/workspaces/getWorkspace.d.ts

@@ -0,0 +1,16 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { Prisma } from "../db";
+type GetWorkspaceRequest = {
+    ref: string;
+};
+type Workspace = {
+    ref: string;
+    name: string;
+    ownerRef: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+declare function getWorkspace(prisma: Prisma): (call: {
+    request: GetWorkspaceRequest;
+}, callback: (error: GrpcErrorMessage, response?: Workspace) => void) => Promise<void>;
+export { getWorkspace };

package/dist/workspaces/getWorkspace.js

@@ -0,0 +1,65 @@
+"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.getWorkspace = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const grpc_js_1 = require("@grpc/grpc-js");
+const getTokenFromCall_1 = require("../utils/getTokenFromCall");
+const getUserRefFromToken_1 = require("../utils/getUserRefFromToken");
+const logger = (0, logger_1.getLogger)({ service: "identity", filePath: __filename });
+function getWorkspace(prisma) {
+    return (call, callback) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { ref } = call.request;
+            const token = (0, getTokenFromCall_1.getTokenFromCall)(call);
+            const ownerRef = (0, getUserRefFromToken_1.getUserRefFromToken)(token);
+            logger.verbose("getting workspace by id", { ref, ownerRef });
+            const workspace = yield prisma.workspace.findUnique({
+                where: {
+                    ref,
+                    ownerRef
+                }
+            });
+            if (!workspace) {
+                callback({
+                    code: grpc_js_1.status.NOT_FOUND,
+                    message: "Workspace not found"
+                });
+                return;
+            }
+            const response = (0, common_1.datesMapper)(workspace);
+            callback(null, response);
+        }
+        catch (error) {
+            (0, common_1.handleError)(error, callback);
+        }
+    });
+}
+exports.getWorkspace = getWorkspace;

package/dist/workspaces/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./createWorkspace";
+export * from "./deleteWorkspace";
+export * from "./getWorkspace";
+export * from "./updateWorkspace";
+export * from "./listWorkspaces";
+export * from "./inviteUserToWorkspace";
+export * from "./removeUserFromWorkspace";
+export * from "./resendWorkspaceMembershipInvitation";
+export * from "./WorkspaceRoleEnum";

package/dist/workspaces/index.js

@@ -0,0 +1,43 @@
+"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 });
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./createWorkspace"), exports);
+__exportStar(require("./deleteWorkspace"), exports);
+__exportStar(require("./getWorkspace"), exports);
+__exportStar(require("./updateWorkspace"), exports);
+__exportStar(require("./listWorkspaces"), exports);
+__exportStar(require("./inviteUserToWorkspace"), exports);
+__exportStar(require("./removeUserFromWorkspace"), exports);
+__exportStar(require("./resendWorkspaceMembershipInvitation"), exports);
+__exportStar(require("./WorkspaceRoleEnum"), exports);

package/dist/workspaces/inviteUserToWorkspace.d.ts

@@ -0,0 +1,31 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { z } from "zod";
+import { WorkspaceRoleEnum } from "./WorkspaceRoleEnum";
+import { Prisma } from "../db";
+import { IdentityConfig } from "../exchanges/types";
+import { SendInvite } from "../invites/sendInvite";
+declare const InviteUserToWorkspaceRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    name: z.ZodString;
+    role: z.ZodEnum<[WorkspaceRoleEnum.ADMIN, WorkspaceRoleEnum.USER]>;
+    password: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    email?: string;
+    password?: string;
+    role?: WorkspaceRoleEnum.ADMIN | WorkspaceRoleEnum.USER;
+}, {
+    name?: string;
+    email?: string;
+    password?: string;
+    role?: WorkspaceRoleEnum.ADMIN | WorkspaceRoleEnum.USER;
+}>;
+type InviteUserToWorkspaceRequest = z.infer<typeof InviteUserToWorkspaceRequestSchema>;
+type CreateWorkspaceResponse = {
+    workspaceRef: string;
+    userRef: string;
+};
+declare function inviteUserToWorkspace(prisma: Prisma, identityConfig: IdentityConfig, sendInvite: SendInvite): (call: {
+    request: InviteUserToWorkspaceRequest;
+}, callback: (error: GrpcErrorMessage, response?: CreateWorkspaceResponse) => void) => Promise<void>;
+export { inviteUserToWorkspace };

package/dist/workspaces/inviteUserToWorkspace.js

@@ -0,0 +1,152 @@
+"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.inviteUserToWorkspace = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const grpc_js_1 = require("@grpc/grpc-js");
+const nanoid_1 = require("nanoid");
+const zod_1 = require("zod");
+const createSendEmail_1 = require("./createSendEmail");
+const isAdminMember_1 = require("./isAdminMember");
+const isWorkspaceMember_1 = require("./isWorkspaceMember");
+const WorkspaceRoleEnum_1 = require("./WorkspaceRoleEnum");
+const utils_1 = require("../utils");
+const getTokenFromCall_1 = require("../utils/getTokenFromCall");
+const getUserRefFromToken_1 = require("../utils/getUserRefFromToken");
+const logger = (0, logger_1.getLogger)({ service: "identity", filePath: __filename });
+const InviteUserToWorkspaceRequestSchema = zod_1.z.object({
+    email: zod_1.z.string().email(),
+    name: zod_1.z.string().min(3, "Name must contain at least 3 characters").max(50),
+    role: zod_1.z.enum([WorkspaceRoleEnum_1.WorkspaceRoleEnum.ADMIN, WorkspaceRoleEnum_1.WorkspaceRoleEnum.USER]),
+    password: zod_1.z
+        .string()
+        .min(6, "Password must contain at least 8 characters")
+        .or(zod_1.z.undefined())
+});
+const userIsMemberError = {
+    code: grpc_js_1.status.ALREADY_EXISTS,
+    message: "User is already a member of this workspace"
+};
+const inviterIsNotAdminError = {
+    code: grpc_js_1.status.PERMISSION_DENIED,
+    message: "Only admins or owners can invite users to a workspace"
+};
+const findUserByEmail = (prisma, email) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield prisma.user.findUnique({
+        where: {
+            email
+        }
+    });
+});
+const createUser = (prisma) => {
+    return (request) => __awaiter(void 0, void 0, void 0, function* () {
+        const { name, email, password } = request;
+        return yield prisma.user.create({
+            data: {
+                name,
+                email,
+                accessKeyId: (0, utils_1.generateAccessKeyId)(utils_1.AccessKeyIdType.USER),
+                password
+            }
+        });
+    });
+};
+var WorkspaceMemberStatus;
+(function (WorkspaceMemberStatus) {
+    WorkspaceMemberStatus["PENDING"] = "PENDING";
+    WorkspaceMemberStatus["ACTIVE"] = "ACTIVE";
+})(WorkspaceMemberStatus || (WorkspaceMemberStatus = {}));
+function inviteUserToWorkspace(prisma, identityConfig, sendInvite) {
+    return (call, callback) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const token = (0, getTokenFromCall_1.getTokenFromCall)(call);
+            const adminRef = (0, getUserRefFromToken_1.getUserRefFromToken)(token);
+            const accessKeyId = (0, utils_1.getAccessKeyIdFromCall)(call);
+            const workspace = yield prisma.workspace.findUnique({
+                where: {
+                    accessKeyId
+                }
+            });
+            const workspaceRef = workspace.ref;
+            const { email, name, role } = InviteUserToWorkspaceRequestSchema.parse(call.request);
+            logger.verbose("inviting user to workspace", {
+                workspaceRef,
+                email,
+                role
+            });
+            const isAdmin = yield (0, isAdminMember_1.isAdminMember)(prisma)(workspaceRef, adminRef);
+            if (!isAdmin) {
+                return callback(inviterIsNotAdminError);
+            }
+            let user = yield findUserByEmail(prisma, email);
+            const isMember = yield (0, isWorkspaceMember_1.isWorkspaceMember)(prisma)(workspaceRef, user === null || user === void 0 ? void 0 : user.ref);
+            if (isMember) {
+                return callback(userIsMemberError);
+            }
+            const oneTimePassword = (0, nanoid_1.customAlphabet)("1234567890abcdef", 10)();
+            let isExistingUser = true;
+            if (!user) {
+                isExistingUser = false;
+                user = yield createUser(prisma)({
+                    name,
+                    email,
+                    password: oneTimePassword
+                });
+            }
+            const newMember = yield prisma.workspaceMember.create({
+                data: {
+                    userRef: user.ref,
+                    workspaceRef,
+                    role: role,
+                    status: WorkspaceMemberStatus.PENDING
+                },
+                include: {
+                    workspace: true
+                }
+            });
+            yield sendInvite((0, createSendEmail_1.createSendEmail)(identityConfig), {
+                recipient: email,
+                oneTimePassword,
+                workspaceName: newMember.workspace.name,
+                isExistingUser,
+                // TODO: Create inviteUrl with invite token
+                inviteUrl: "https://placehold.it?token=jwt"
+            });
+            callback(null, {
+                userRef: user === null || user === void 0 ? void 0 : user.ref,
+                workspaceRef
+            });
+        }
+        catch (error) {
+            (0, common_1.handleError)(error, callback);
+        }
+    });
+}
+exports.inviteUserToWorkspace = inviteUserToWorkspace;

package/dist/workspaces/isAdminMember.d.ts

@@ -0,0 +1,3 @@
+import { Prisma } from "../db";
+declare function isAdminMember(prisma: Prisma): (workspaceRef: string, adminRef: string) => Promise<boolean>;
+export { isAdminMember };

package/dist/workspaces/isAdminMember.js

@@ -0,0 +1,53 @@
+"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.isAdminMember = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const WorkspaceRoleEnum_1 = require("./WorkspaceRoleEnum");
+function isAdminMember(prisma) {
+    return (workspaceRef, adminRef) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!workspaceRef || !adminRef) {
+            return false;
+        }
+        const workspace = yield prisma.workspace.findUnique({
+            where: {
+                ref: workspaceRef
+            },
+            include: {
+                members: true
+            }
+        });
+        if ((workspace === null || workspace === void 0 ? void 0 : workspace.ownerRef) === adminRef) {
+            return true;
+        }
+        const role = (_a = workspace === null || workspace === void 0 ? void 0 : workspace.members.find((member) => member.ref === adminRef)) === null || _a === void 0 ? void 0 : _a.role;
+        return role === WorkspaceRoleEnum_1.WorkspaceRoleEnum.ADMIN || role === WorkspaceRoleEnum_1.WorkspaceRoleEnum.OWNER;
+    });
+}
+exports.isAdminMember = isAdminMember;

package/dist/workspaces/isWorkspaceMember.d.ts

@@ -0,0 +1,3 @@
+import { Prisma } from "../db";
+declare function isWorkspaceMember(prisma: Prisma): (workspaceRef: string, userRef: string) => Promise<boolean>;
+export { isWorkspaceMember };

package/dist/workspaces/isWorkspaceMember.js

@@ -0,0 +1,32 @@
+"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.isWorkspaceMember = void 0;
+function isWorkspaceMember(prisma) {
+    return (workspaceRef, userRef) => __awaiter(this, void 0, void 0, function* () {
+        const workspace = yield prisma.workspace.findUnique({
+            where: {
+                ref: workspaceRef
+            }
+        });
+        const isMember = yield prisma.workspaceMember.findFirst({
+            where: {
+                // Force userId to be an empty string to ensure that the query is not
+                // fillter by workspaceRef only
+                userRef: userRef || "",
+                workspaceRef
+            }
+        });
+        const isOwner = (workspace === null || workspace === void 0 ? void 0 : workspace.ownerRef) === userRef;
+        return !!(isMember || isOwner);
+    });
+}
+exports.isWorkspaceMember = isWorkspaceMember;

package/dist/workspaces/listWorkspaces.d.ts

@@ -0,0 +1,16 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { Prisma } from "../db";
+type Workspace = {
+    ref: string;
+    name: string;
+    ownerRef: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+type ListWorkspacesResponse = {
+    workspaces: Workspace[];
+};
+declare function listWorkspaces(prisma: Prisma): (call: {
+    request: unknown;
+}, callback: (error: GrpcErrorMessage, response?: ListWorkspacesResponse) => void) => Promise<any[]>;
+export { listWorkspaces };

package/dist/workspaces/listWorkspaces.js

@@ -0,0 +1,55 @@
+"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.listWorkspaces = void 0;
+const logger_1 = require("@fonoster/logger");
+const utils_1 = require("../utils");
+const getTokenFromCall_1 = require("../utils/getTokenFromCall");
+const getUserRefFromToken_1 = require("../utils/getUserRefFromToken");
+const logger = (0, logger_1.getLogger)({ service: "identity", filePath: __filename });
+function listWorkspaces(prisma) {
+    return (call, callback) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const token = (0, getTokenFromCall_1.getTokenFromCall)(call);
+        const userRef = (0, getUserRefFromToken_1.getUserRefFromToken)(token);
+        const access = (0, utils_1.decodeToken)(token);
+        const workspacesAccessKeyIds = (_a = access.access) === null || _a === void 0 ? void 0 : _a.map((a) => a.accessKeyId);
+        logger.verbose("list workspaces for user or apikey", {
+            userRef,
+            workspacesAccessKeyIds
+        });
+        const workspaces = yield prisma.workspace.findMany({
+            where: {
+                OR: [
+                    {
+                        accessKeyId: {
+                            in: workspacesAccessKeyIds
+                        }
+                    },
+                    {
+                        members: {
+                            some: {
+                                userRef
+                            }
+                        }
+                    },
+                    {
+                        ownerRef: userRef
+                    }
+                ]
+            }
+        });
+        if (!workspaces)
+            return [];
+        callback(null, { workspaces });
+    });
+}
+exports.listWorkspaces = listWorkspaces;

package/dist/workspaces/removeUserFromWorkspace.d.ts

@@ -0,0 +1,12 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { Prisma } from "../db";
+type RemoveUserFromWorkspaceRequest = {
+    userRef: string;
+};
+type RemoveUserFromWorkspaceResponse = {
+    userRef: string;
+};
+declare function removeUserFromWorkspace(prisma: Prisma): (call: {
+    request: RemoveUserFromWorkspaceRequest;
+}, callback: (error: GrpcErrorMessage, response?: RemoveUserFromWorkspaceResponse) => void) => Promise<void>;
+export { removeUserFromWorkspace };

package/dist/workspaces/removeUserFromWorkspace.js

@@ -0,0 +1,84 @@
+"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.removeUserFromWorkspace = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const grpc_js_1 = require("@grpc/grpc-js");
+const isAdminMember_1 = require("./isAdminMember");
+const utils_1 = require("../utils");
+const getTokenFromCall_1 = require("../utils/getTokenFromCall");
+const getUserRefFromToken_1 = require("../utils/getUserRefFromToken");
+const logger = (0, logger_1.getLogger)({ service: "identity", filePath: __filename });
+function removeUserFromWorkspace(prisma) {
+    return (call, callback) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { userRef } = call.request;
+            const token = (0, getTokenFromCall_1.getTokenFromCall)(call);
+            const accessKeyId = (0, utils_1.getAccessKeyIdFromCall)(call);
+            const adminRef = (0, getUserRefFromToken_1.getUserRefFromToken)(token);
+            const workspace = yield prisma.workspace.findUnique({
+                where: {
+                    accessKeyId
+                }
+            });
+            const workspaceRef = workspace === null || workspace === void 0 ? void 0 : workspace.ref;
+            logger.verbose("removing user from workspace", { workspaceRef, userRef });
+            const isAdmin = yield (0, isAdminMember_1.isAdminMember)(prisma)(workspaceRef, adminRef);
+            if (!isAdmin && adminRef !== userRef) {
+                return callback({
+                    code: grpc_js_1.status.PERMISSION_DENIED,
+                    message: "Only admins or owners can remove users from a workspace"
+                });
+            }
+            const memberRef = yield prisma.workspaceMember.findFirst({
+                where: {
+                    workspaceRef,
+                    userRef
+                }
+            });
+            if (!memberRef) {
+                return callback({
+                    code: grpc_js_1.status.NOT_FOUND,
+                    message: "User not found in workspace"
+                });
+            }
+            const response = yield prisma.workspaceMember.delete({
+                where: {
+                    ref: memberRef === null || memberRef === void 0 ? void 0 : memberRef.ref
+                }
+            });
+            callback(null, response);
+        }
+        catch (error) {
+            (0, common_1.handleError)(error, callback);
+        }
+    });
+}
+exports.removeUserFromWorkspace = removeUserFromWorkspace;

package/dist/workspaces/resendWorkspaceMembershipInvitation.d.ts

@@ -0,0 +1,14 @@
+import { GrpcErrorMessage } from "@fonoster/common";
+import { Prisma } from "../db";
+import { IdentityConfig } from "../exchanges/types";
+import { SendInvite } from "../invites/sendInvite";
+type ResendWorkspaceMembershipInvitationRequest = {
+    userRef: string;
+};
+type ResendWorkspaceMembershipInvitationResponse = {
+    userRef: string;
+};
+declare function resendWorkspaceMembershipInvitation(prisma: Prisma, identityConfig: IdentityConfig, sendInvite: SendInvite): (call: {
+    request: ResendWorkspaceMembershipInvitationRequest;
+}, callback: (error: GrpcErrorMessage, response?: ResendWorkspaceMembershipInvitationResponse) => void) => Promise<void>;
+export { resendWorkspaceMembershipInvitation };