InviteOptions Type

import type { GenericEndpointContext } from "better-auth";
import type { InferOptionSchema, UserWithRole } from "better-auth/plugins";
import type { InviteSchema } from "./schema";

export type InviteOptions = {
  getDate?: () => Date;
  canCreateInvite?: ((data: {
    invitedUser: { email?: string; role: string; };
    inviterUser: UserWithRole;
    ctx: GenericEndpointContext;
  }) => Promise<boolean> | boolean) | boolean | Permissions;
  canAcceptInvite?: ((data: {
    invitedUser: UserWithRole;
    newAccount: boolean;
  }) => Promise<boolean> | boolean) | boolean | Permissions;
  canCancelInvite?: ((data: {
    inviterUser: UserWithRole;
    invitation: InviteTypeWithId;
    ctx: GenericEndpointContext;
  }) => Promise<boolean> | boolean) | boolean | Permissions;
  canRejectInvite?: ((data: {
    inviteeUser: UserWithRole;
    invitation: InviteTypeWithId;
    ctx: GenericEndpointContext;
  }) => Promise<boolean> | boolean) | boolean | Permissions;
  generateToken?: () => string;
  defaultTokenType?: TokensType;
  defaultRedirectToSignUp?: string;
  defaultRedirectToSignIn?: string;
  defaultRedirectAfterUpgrade?: string;
  defaultShareInviterName?: boolean;
  defaultMaxUses?: number;
  defaultSenderResponse?: "token" | "url";
  defaultSenderResponseRedirect?: "signUp" | "signIn";
  sendUserInvitation?: (data: {
    email: string;
    name?: string;
    role: string;
    url: string;
    token: string;
    newAccount: boolean;
  }, request?: Request) => Promise<void> | void;
  sendUserRoleUpgrade?: (data: {
    email: string;
    role: string;
    url: string;
    token: string;
  }, request?: Request) => Promise<void> | void;
  invitationTokenExpiresIn?: number;
  inviteCookieMaxAge?: number;
  cleanupInvitesOnDecision?: boolean;
  cleanupInvitesAfterMaxUses?: boolean;
  defaultCustomInviteUrl?: string;
  onInvitationUsed?: (data: {
    invitedUser: UserWithRole;
    newUser: UserWithRole;
    newAccount: boolean;
  }, request?: Request) => Promise<void> | void;
  schema?: InferOptionSchema<InviteSchema>;
  inviteHooks?: {
    beforeCreateInvite?: (data: { ctx: GenericEndpointContext; }) => Promise<void> | void;
    afterCreateInvite?: (data: { ctx: GenericEndpointContext; invitation: InviteTypeWithId; }) => Promise<void> | void;
    beforeAcceptInvite?: (data: { ctx: GenericEndpointContext; invitedUser: UserWithRole; }) => Promise<{ user?: UserWithRole }> | Promise<void> | { user?: UserWithRole } | void;
    afterAcceptInvite?: (data: { ctx: GenericEndpointContext; invitation: InviteTypeWithId; invitedUser: UserWithRole; }) => Promise<void> | void;
    beforeCancelInvite?: (data: { ctx: GenericEndpointContext; invitation: InviteTypeWithId; }) => Promise<void> | void;
    afterCancelInvite?: (data: { ctx: GenericEndpointContext; invitation: InviteTypeWithId; }) => Promise<void> | void;
    beforeRejectInvite?: (data: { ctx: GenericEndpointContext; invitation: InviteTypeWithId; }) => Promise<void> | void;
    afterRejectInvite?: (data: { ctx: GenericEndpointContext; invitation: InviteTypeWithId; }) => Promise<void> | void;
  };
};

type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

export type NewInviteOptions = MakeRequired<
  InviteOptions,
  | "getDate"
  | "invitationTokenExpiresIn"
  | "defaultShareInviterName"
  | "defaultSenderResponse"
  | "defaultSenderResponseRedirect"
  | "defaultTokenType"
  | "defaultRedirectToSignIn"
  | "defaultRedirectToSignUp"
  | "canCreateInvite"
  | "canAcceptInvite"
  | "canCancelInvite"
  | "canRejectInvite"
>;

import { invite } from "better-auth-invite-plugin";
import type { InviteOptions } from "better-auth-invite-plugin";

const inviteOptions: InviteOptions = {
  sendUserInvitation: async (data) => {
    await sendEmail({
      to: data.email,
      subject: "You've been invited!",
      body: `Click here: ${data.url}`,
    });
  },
};

const auth = betterAuth({
  plugins: [invite(inviteOptions)],
});

import type { InviteOptions } from "better-auth-invite-plugin";

const createInviteConfig = (): InviteOptions => {
  return {
    canCreateInvite: async ({ inviterUser }) => {
      return inviterUser.role === "admin";
    },
    defaultTokenType: "code",
    invitationTokenExpiresIn: 86400, // 24 hours
    sendUserInvitation: async (data, request) => {
      // Type-safe email data
      const { email, name, role, url, token, newAccount } = data;
      await emailService.send({ /* ... */ });
    },
  };
};

import type { InviteOptions } from "better-auth-invite-plugin";
import type { InferOptionSchema } from "better-auth/plugins";

const inviteOptions: InviteOptions = {
  schema: {
    invite: {
      fields: {
        customField: {
          type: "string",
          required: false,
        },
        metadata: {
          type: "json",
          required: false,
        },
      },
    },
  },
  sendUserInvitation: async (data) => {
    // Implementation
  },
};