better-auth-invite-plugin 0.1.0

package/dist/routes.d.ts

@@ -0,0 +1,168 @@
+import { type NewInviteOptions } from "./types";
+import * as z from "zod";
+export declare const createInvite: (options: NewInviteOptions) => import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/invite/create", {
+    method: "POST";
+    body: z.ZodObject<{
+        role: z.ZodString;
+        email: z.ZodOptional<z.ZodEmail>;
+        tokenType: z.ZodOptional<z.ZodEnum<{
+            token: "token";
+            code: "code";
+            custom: "custom";
+        }>>;
+        redirectToSignUp: z.ZodOptional<z.ZodString>;
+        redirectToSignIn: z.ZodOptional<z.ZodString>;
+        maxUses: z.ZodOptional<z.ZodNumber>;
+        expiresIn: z.ZodOptional<z.ZodNumber>;
+        redirectToAfterUpgrade: z.ZodOptional<z.ZodString>;
+        shareInviterName: z.ZodOptional<z.ZodBoolean>;
+        senderResponse: z.ZodOptional<z.ZodEnum<{
+            token: "token";
+            url: "url";
+        }>>;
+        senderResponseRedirect: z.ZodOptional<z.ZodEnum<{
+            signUp: "signUp";
+            signIn: "signIn";
+        }>>;
+    }, z.core.$strip>;
+    use: ((inputContext: import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareInputContext<import("better-auth", { with: { "resolution-mode": "import" } }).MiddlewareOptions>) => Promise<{
+        session: {
+            session: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                expiresAt: Date;
+                token: string;
+                ipAddress?: string | null | undefined;
+                userAgent?: string | null | undefined;
+            };
+            user: Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+            };
+        };
+    }>)[];
+    metadata: {
+        openapi: {
+            operationId: string;
+            description: string;
+            responses: {
+                "200": {
+                    description: string;
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object";
+                                properties: {
+                                    status: {
+                                        type: string;
+                                    };
+                                    message: {
+                                        type: string;
+                                    };
+                                    token: {
+                                        type: string;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    status: boolean;
+    message: string;
+}>;
+/**
+ * Can be used calling it form better auth
+ * Ex: auth.api.activateInvite()
+ */
+export declare const activateInvite: (options: NewInviteOptions) => import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/invite/activate", {
+    method: "POST";
+    body: z.ZodObject<{
+        callbackURL: z.ZodString;
+        token: z.ZodString;
+    }, z.core.$strip>;
+    metadata: {
+        openapi: {
+            operationId: string;
+            description: string;
+            parameters: {
+                name: string;
+                in: "path";
+                required: true;
+                description: string;
+                schema: {
+                    type: "string";
+                };
+            }[];
+            responses: {
+                "200": {
+                    description: string;
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object";
+                                properties: {
+                                    token: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, void>;
+/**
+ * Only used for invite links
+ */
+export declare const activateInviteCallback: (options: NewInviteOptions) => import("better-auth", { with: { "resolution-mode": "import" } }).StrictEndpoint<"/invite/:token", {
+    method: "GET";
+    query: z.ZodObject<{
+        callbackURL: z.ZodString;
+    }, z.core.$strip>;
+    metadata: {
+        openapi: {
+            operationId: string;
+            description: string;
+            parameters: {
+                name: string;
+                in: "path";
+                required: true;
+                description: string;
+                schema: {
+                    type: "string";
+                };
+            }[];
+            responses: {
+                "200": {
+                    description: string;
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object";
+                                properties: {
+                                    token: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, void>;

package/dist/routes.js

@@ -0,0 +1,324 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateInviteCallback = exports.activateInvite = exports.createInvite = void 0;
+const api_1 = require("better-auth/api");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const body_1 = require("./body");
+const z = __importStar(require("zod"));
+const createInvite = (options) => {
+    return (0, api_1.createAuthEndpoint)("/invite/create", {
+        method: "POST",
+        body: body_1.createInviteBodySchema,
+        use: [api_1.sessionMiddleware],
+        metadata: {
+            openapi: {
+                operationId: "createInvitation",
+                description: "Create an invitation",
+                responses: {
+                    "200": {
+                        description: "Success",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        status: {
+                                            type: "boolean",
+                                        },
+                                        message: {
+                                            type: "string",
+                                        },
+                                        token: {
+                                            type: "string",
+                                        },
+                                    },
+                                    required: ["status", "message"],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }, async (ctx) => {
+        const inviterUser = ctx.context.session.user;
+        const { email, role } = ctx.body;
+        const { tokenType, redirectToAfterUpgrade, redirectToSignUp, redirectToSignIn, maxUses, expiresIn, shareInviterName, senderResponse, senderResponseRedirect, } = (0, utils_1.resolveInvitePayload)(ctx.body, options);
+        if (!(0, utils_1.canUserCreateInvite)(options, inviterUser, { email, role })) {
+            throw ctx.error("BAD_REQUEST", {
+                message: types_1.ERROR_CODES.INSUFFICIENT_PERMISSIONS,
+            });
+        }
+        let generateToken = (0, utils_1.resolveTokenGenerator)(tokenType, options);
+        const invitedUser = email &&
+            (await ctx.context.internalAdapter.findUserByEmail(email, {
+                includeAccounts: true,
+            }));
+        // If the user already exists they should sign in, else they should sign up
+        const callbackURL = invitedUser ? redirectToSignIn : redirectToSignUp;
+        const token = generateToken();
+        const now = options.getDate();
+        const expiresAt = (0, utils_1.getDate)(expiresIn, "sec");
+        await ctx.context.adapter.create({
+            model: "invite",
+            data: {
+                token,
+                createdByUserId: inviterUser.id,
+                createdAt: now,
+                expiresAt,
+                maxUses,
+                redirectToAfterUpgrade,
+                shareInviterName,
+                email,
+                role,
+            },
+        });
+        const url = `${ctx.context.baseURL}/invite/${token}`;
+        const redirectURLEmail = `${url}?callbackURL=${callbackURL}?`;
+        // If an email is provided, send the invitation or role upgrade using the configured function
+        if (email) {
+            const sendFn = invitedUser
+                ? options.sendUserRoleUpgrade ?? options.sendUserInvitation
+                : options.sendUserInvitation;
+            if (!sendFn) {
+                throw ctx.error("INTERNAL_SERVER_ERROR", {
+                    message: "No invitation sending function configured",
+                });
+            }
+            await sendFn({
+                email,
+                role,
+                url: redirectURLEmail,
+                token,
+            }, ctx.request).catch((e) => {
+                ctx.context.logger.error("Error sending the invitation email", e);
+            });
+            return ctx.json({
+                status: true,
+                message: "The invitation was sent",
+            });
+        }
+        const redirectTo = senderResponseRedirect === "signUp"
+            ? redirectToSignUp
+            : redirectToSignIn;
+        const redirectURL = `${url}?callbackURL=${redirectTo}`;
+        const returnToken = senderResponse === "token" ? token : redirectURL;
+        return ctx.json({
+            status: true,
+            message: "The invitation token was generated",
+            token: returnToken,
+        });
+    });
+};
+exports.createInvite = createInvite;
+/**
+ * Can be used calling it form better auth
+ * Ex: auth.api.activateInvite()
+ */
+const activateInvite = (options) => {
+    return (0, api_1.createAuthEndpoint)("/invite/activate", {
+        method: "POST",
+        body: z.object({
+            /**
+             * Where to redirect the user after sing in/up
+             */
+            callbackURL: z
+                .string()
+                .describe("Where to redirect the user after sing in/up"),
+            /**
+             * The invite token.
+             */
+            token: z.string().describe("The invite token"),
+        }),
+        metadata: {
+            openapi: {
+                operationId: "activateInvite",
+                description: "Redirects the user to the callback URL with the token in a cookie",
+                parameters: [
+                    {
+                        name: "token",
+                        in: "path",
+                        required: true,
+                        description: "The invitation token",
+                        schema: {
+                            type: "string",
+                        },
+                    },
+                ],
+                responses: {
+                    "200": {
+                        description: "Success",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        token: {
+                                            type: "string",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }, async (ctx) => {
+        const { token, callbackURL } = ctx.body;
+        await activateInviteLogic({ ctx, options, token, callbackURL });
+    });
+};
+exports.activateInvite = activateInvite;
+/**
+ * Only used for invite links
+ */
+const activateInviteCallback = (options) => {
+    return (0, api_1.createAuthEndpoint)("/invite/:token", {
+        method: "GET",
+        query: z.object({
+            /**
+             * Where to redirect the user after sing in/up
+             */
+            callbackURL: z
+                .string()
+                .describe("Where to redirect the user after sing in/up"),
+        }),
+        metadata: {
+            openapi: {
+                operationId: "activateInviteCallback",
+                description: "Redirects the user to the callback URL with the token in a cookie",
+                parameters: [
+                    {
+                        name: "token",
+                        in: "path",
+                        required: true,
+                        description: "The invitation token",
+                        schema: {
+                            type: "string",
+                        },
+                    },
+                ],
+                responses: {
+                    "200": {
+                        description: "Success",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        token: {
+                                            type: "string",
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }, async (ctx) => {
+        const { token } = ctx.params;
+        const { callbackURL } = ctx.query;
+        await activateInviteLogic({ ctx, options, token, callbackURL });
+    });
+};
+exports.activateInviteCallback = activateInviteCallback;
+const activateInviteLogic = async ({ ctx, options, token, callbackURL, }) => {
+    if (!token) {
+        throw ctx.redirect((0, utils_1.redirectError)(ctx.context, callbackURL, { error: "INVALID_TOKEN" }));
+    }
+    const invite = (await ctx.context.adapter.findOne({
+        model: "invite",
+        where: [{ field: "token", value: token }],
+    }));
+    if (invite === null) {
+        throw ctx.redirect((0, utils_1.redirectError)(ctx.context, callbackURL, { error: "INVALID_TOKEN" }));
+    }
+    const timesUsed = await ctx.context.adapter.count({
+        model: "invite_use",
+        where: [{ field: "inviteId", value: invite.id }],
+    });
+    if (!(timesUsed < invite.maxUses)) {
+        throw ctx.redirect((0, utils_1.redirectError)(ctx.context, callbackURL, { error: "INVALID_TOKEN" }));
+    }
+    if (options.getDate() > invite.expiresAt) {
+        throw ctx.redirect((0, utils_1.redirectError)(ctx.context, callbackURL, { error: "INVALID_TOKEN" }));
+    }
+    const sessionObject = ctx.context.session;
+    const session = sessionObject?.session;
+    const userId = sessionObject?.user.id;
+    const user = userId
+        ? (await ctx.context.internalAdapter.findUserById(userId))
+        : undefined;
+    if (user) {
+        // Upgrade existing user's role instead of redirecting if user already exists
+        if (!session || !userId) {
+            throw ctx.redirect((0, utils_1.redirectError)(ctx.context, callbackURL, {
+                error: "INTERNAL_SERVER_ERROR",
+            }));
+        }
+        await (0, utils_1.consumeInvite)({
+            ctx,
+            invite,
+            user,
+            options,
+            userId,
+            timesUsed,
+            token,
+            session,
+            newAccount: false,
+        });
+        await (0, utils_1.redirectToAfterUpgrade)({
+            shareInviterName: invite.shareInviterName,
+            ctx,
+            invite,
+            signUp: true,
+        });
+    }
+    // If user doesn't already exist, we set a cookie and redirect them to the sign in/up page
+    // Get cookie name (customizable)
+    const cookie = (0, utils_1.getCookieName)({ ctx, options });
+    ctx.setCookie(cookie, token, {
+        httpOnly: true,
+        path: "/",
+        expires: invite.expiresAt,
+    });
+    // Redirects the user to sign in/up
+    throw ctx.redirect((0, utils_1.redirectCallback)(ctx.context, callbackURL));
+};

package/dist/schema.d.ts

@@ -0,0 +1,76 @@
+export declare const schema: {
+    invite: {
+        fields: {
+            token: {
+                type: "string";
+                unique: true;
+            };
+            createdAt: {
+                type: "date";
+            };
+            expiresAt: {
+                type: "date";
+                required: true;
+            };
+            maxUses: {
+                type: "number";
+                required: true;
+            };
+            createdByUserId: {
+                type: "string";
+                references: {
+                    model: string;
+                    field: string;
+                    onDelete: "set null";
+                };
+            };
+            callbackURL: {
+                type: "string";
+                required: true;
+            };
+            redirectToAfterUpgrade: {
+                type: "string";
+                required: true;
+            };
+            shareInviterName: {
+                type: "boolean";
+                required: true;
+            };
+            email: {
+                type: "string";
+                required: false;
+            };
+            role: {
+                type: "string";
+                required: true;
+            };
+        };
+    };
+    invite_use: {
+        fields: {
+            inviteId: {
+                type: "string";
+                required: true;
+                references: {
+                    model: string;
+                    field: string;
+                    onDelete: "set null";
+                };
+            };
+            usedAt: {
+                type: "date";
+                required: true;
+            };
+            usedByUserId: {
+                type: "string";
+                required: false;
+                references: {
+                    model: string;
+                    field: string;
+                    onDelete: "set null";
+                };
+            };
+        };
+    };
+};
+export type InviteSchema = typeof schema;

package/dist/schema.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+exports.schema = {
+    invite: {
+        fields: {
+            token: { type: "string", unique: true },
+            createdAt: { type: "date" },
+            expiresAt: { type: "date", required: true },
+            maxUses: { type: "number", required: true },
+            createdByUserId: {
+                type: "string",
+                references: { model: "user", field: "id", onDelete: "set null" },
+            },
+            callbackURL: { type: "string", required: true },
+            redirectToAfterUpgrade: { type: "string", required: true },
+            shareInviterName: { type: "boolean", required: true },
+            email: { type: "string", required: false },
+            role: { type: "string", required: true },
+        },
+    },
+    invite_use: {
+        fields: {
+            inviteId: {
+                type: "string",
+                required: true,
+                references: { model: "invite", field: "id", onDelete: "set null" },
+            },
+            usedAt: { type: "date", required: true },
+            usedByUserId: {
+                type: "string",
+                required: false,
+                references: { model: "user", field: "id", onDelete: "set null" },
+            },
+        },
+    },
+};

package/dist/schemas.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod";
+export declare const createInviteBodySchema: z.ZodObject<{
+    role: z.ZodString;
+    email: z.ZodOptional<z.ZodEmail>;
+    tokenType: z.ZodOptional<z.ZodEnum<{
+        token: "token";
+        code: "code";
+        custom: "custom";
+    }>>;
+    redirectToSignUp: z.ZodOptional<z.ZodString>;
+    redirectToSignIn: z.ZodOptional<z.ZodString>;
+    maxUses: z.ZodOptional<z.ZodNumber>;
+    expiresIn: z.ZodOptional<z.ZodNumber>;
+    redirectToAfterUpgrade: z.ZodOptional<z.ZodString>;
+    shareInviterName: z.ZodOptional<z.ZodBoolean>;
+    senderResponse: z.ZodOptional<z.ZodEnum<{
+        token: "token";
+        url: "url";
+    }>>;
+    senderResponseRedirect: z.ZodOptional<z.ZodEnum<{
+        signUp: "signUp";
+        signIn: "signIn";
+    }>>;
+}, z.core.$strip>;