@nerdfolio/ba-guest-list 0.0.1

package/README.md

@@ -0,0 +1,96 @@
+# Better Auth Guest List
+Plugin to provide fixed guest list functionality. Intended use is for development testing and possibly demos with
+know login names, e.g. login as "Alice" or "Bob".
+
+You can use it for logging in by just typing a single-word name or binding that name to a UI button.
+
+The fixed guest list can be defined on the server-side with roles so this plugin
+can also be used for testing roles.
+
+As this plugin is only intended to be a temporary aid to development and demo, it does not add any field to the schema. Internally, the guest name is transformed into an email via a fixed template, e.g. `tom.onguestlist@emaildomain` and that is the way that user will be looked up.
+
+# Installation
+
+```console
+
+pnpm add @nerdfolio/ba-guest-list
+
+```
+
+# Usage
+
+## Server-side setup
+
+```typescript
+// auth.ts
+import { betterAuth } from "better-auth"
+import { guestList } from "@nerdfolio/ba-guest-list"
+
+export const auth = betterAuth({
+	...otherConfigs,
+	plugins: [
+		...otherPlugins,
+		guestList({
+			allowGuests: [
+				// can be array of names or array of {name: string, role?: comma-separated-string}
+				{ name: "Alice", role: "admin" },
+				{ name: "Bob", role: "user" },
+				{ name: "Charlie", role: "user" },
+			],
+			revealNames: true // whether the client can see this list (useful for demos)
+		})
+	],
+})
+
+```
+
+Options:
+
+ `allowGuests`: can be an array of names or array of `{name: string, role?: string}`. role uses better-auth convention as a comma-separated string of actual roles.
+
+ `revealNames`: is a boolean. When enabled, the client will be able to retrieve the guest names via `client.signIn.guestList.reveal()`. Names may also be returned in api errors during logins. When undefined or disabled, the `reveal()` endpoint will just return `null` and names will not be sent in error messages.
+
+ `emailDomainName`: optional. Internally this plugin generates a fake email based on the guest name. It detects the app's domain and use that for email generation. You can override that with this option.
+
+
+## Client-side setup
+
+```typescript
+
+import { guestListClient } from "@nerdfolio/ba-guest-list/client"
+
+export const authClient = createAuthClient({
+	plugins: [
+		guestListClient()
+	],
+})
+
+```
+
+## Signin
+
+```typescript
+
+// authClient is the better-auth client as defined in client-side setup
+// GUEST_NAME has to be in the list of names defined in server-side setup, otherwise login will fail
+authClient.signIn.guestList({
+	name: GUEST_NAME
+})
+```
+
+If you have enabled `revealNames` in your server-side setup, you can retrieve that list of names on the client side. This may be useful for creating demos with a fixed list of login names. The plugin will
+call a special fetch endpoint and returns either `null` or an array of name strings. When `revealNames` is undefined or false, it returns `null`.
+
+```typescript
+// just an async so you'll need to use it according to the way your frontend framework andles async
+
+const guestNames = await authClient.signIn.guestList.reveal()
+  .then(({ data, error: _e }) => data?.join(", "))
+)
+
+// for example, in Solidstart, you can retrieve this via createAsync
+const guestList = createAsync(async () =>
+	authClient.signIn.guestList.reveal().then(({ data, error: _e }) => data?.join(", "))
+)
+
+```

package/dist/client.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  guestListClient: () => guestListClient
+});
+module.exports = __toCommonJS(client_exports);
+var guestListClient = () => {
+  return {
+    id: "guest-list",
+    $InferServerPlugin: {}
+    // pathMethods: {
+    // 	"/sign-in/guest-list": "POST",
+    // },
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  guestListClient
+});

package/dist/client.d.cts

@@ -0,0 +1,10 @@
+import { guestList } from './index.cjs';
+import 'better-auth';
+import 'zod/v4-mini';
+
+declare const guestListClient: () => {
+    id: "guest-list";
+    $InferServerPlugin: ReturnType<typeof guestList>;
+};
+
+export { guestListClient };

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+import { guestList } from './index.js';
+import 'better-auth';
+import 'zod/v4-mini';
+
+declare const guestListClient: () => {
+    id: "guest-list";
+    $InferServerPlugin: ReturnType<typeof guestList>;
+};
+
+export { guestListClient };

package/dist/client.mjs

@@ -0,0 +1,13 @@
+// src/client.ts
+var guestListClient = () => {
+  return {
+    id: "guest-list",
+    $InferServerPlugin: {}
+    // pathMethods: {
+    // 	"/sign-in/guest-list": "POST",
+    // },
+  };
+};
+export {
+  guestListClient
+};

package/dist/index.cjs

@@ -0,0 +1,188 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  guestList: () => guestList
+});
+module.exports = __toCommonJS(index_exports);
+var import_api = require("better-auth/api");
+var import_cookies = require("better-auth/cookies");
+var import_lodash_es = require("lodash-es");
+var import_v4_mini = require("zod/v4-mini");
+
+// src/utils.ts
+function getOrigin(url) {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.origin;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// src/index.ts
+function formatName(name) {
+  return (0, import_lodash_es.capitalize)(name.replaceAll(/\s/g, ""));
+}
+var guestList = (options) => {
+  const ERROR_CODES = {
+    NAME_NOT_PROVIDED: "Guest name not provided",
+    NAME_NOT_ON_GUEST_LIST: "Your name is not on the guest list",
+    NAME_ONE_WORD_ONLY: "Please only use 1-word names",
+    FAILED_TO_CREATE_USER: "Failed to create user",
+    COULD_NOT_CREATE_SESSION: "Could not create session"
+  };
+  const guestLookup = Object.fromEntries(
+    (options?.allowGuests ?? []).map((entry) => typeof entry === "string" ? { name: entry, role: "" } : entry).filter((entry) => !!entry && entry.name).map(({ name, role }) => [formatName(name), {
+      name: formatName(name),
+      role: (role ?? "").split(",").map((s) => s.trim()).join(",")
+    }])
+  );
+  return {
+    id: "guest-list",
+    endpoints: {
+      signInGuest: (0, import_api.createAuthEndpoint)(
+        "/sign-in/guest-list",
+        {
+          method: "POST",
+          body: import_v4_mini.z.object({
+            name: import_v4_mini.z.string()
+          }),
+          metadata: {
+            openapi: {
+              description: "Sign in as a guest with name only",
+              responses: {
+                200: {
+                  description: "Sign in as a guest successful",
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object",
+                        properties: {
+                          user: {
+                            $ref: "#/components/schemas/User"
+                          },
+                          session: {
+                            $ref: "#/components/schemas/Session"
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        async (ctx) => {
+          const { name } = ctx.body;
+          if (!name) {
+            ctx.context.logger.error("Guest name not provided");
+            throw new import_api.APIError("UNAUTHORIZED", {
+              message: options?.revealNames ? `Guest name not provided. Try: ${JSON.stringify(Object.keys(guestLookup))}` : ERROR_CODES.NAME_NOT_PROVIDED
+            });
+          }
+          if (name.trim().split(/\s+/).length > 1) {
+            ctx.context.logger.error("For simplicity, only one word names are allowed");
+            throw new import_api.APIError("UNAUTHORIZED", {
+              message: ERROR_CODES.NAME_ONE_WORD_ONLY
+            });
+          }
+          const cleanedName = formatName(name);
+          if (!guestLookup[cleanedName]) {
+            throw new import_api.APIError("UNAUTHORIZED", {
+              message: options?.revealNames ? `Name not on list. Try: ${JSON.stringify(Object.keys(guestLookup))}` : ERROR_CODES.NAME_NOT_ON_GUEST_LIST
+            });
+          }
+          const { emailDomainName = getOrigin(ctx.context.baseURL) } = options ?? {};
+          const email = `${cleanedName.toLowerCase().replaceAll(/\s/g, "")}.onguestlist@${emailDomainName}`;
+          const found = await ctx.context.internalAdapter.findUserByEmail(email);
+          async function createNewUser() {
+            const newUser = await ctx.context.internalAdapter.createUser(
+              {
+                email,
+                emailVerified: false,
+                name: cleanedName,
+                role: guestLookup[cleanedName].role,
+                createdAt: /* @__PURE__ */ new Date(),
+                updatedAt: /* @__PURE__ */ new Date()
+              },
+              ctx
+            );
+            if (!newUser) {
+              throw ctx.error("INTERNAL_SERVER_ERROR", {
+                message: ERROR_CODES.FAILED_TO_CREATE_USER
+              });
+            }
+            return newUser;
+          }
+          const user = found ? found.user : await createNewUser();
+          const session = await ctx.context.internalAdapter.createSession(user.id, ctx, true);
+          if (!session) {
+            return ctx.json(null, {
+              status: 400,
+              body: {
+                message: ERROR_CODES.COULD_NOT_CREATE_SESSION
+              }
+            });
+          }
+          await (0, import_cookies.setSessionCookie)(ctx, { session, user });
+          return ctx.json({ token: session.token, user });
+        }
+      ),
+      revealGuestList: (0, import_api.createAuthEndpoint)(
+        "/sign-in/guest-list/reveal",
+        {
+          method: "GET",
+          metadata: {
+            openapi: {
+              description: "Reveal guest list if 'revealNames' is enabled. Empty array otherwise",
+              responses: {
+                200: {
+                  description: "List of allowed guest names or empty array",
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "array",
+                        items: {
+                          type: "string"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        async (ctx) => {
+          return ctx.json(options?.revealNames ? Object.keys(guestLookup) : []);
+        }
+      )
+    },
+    //schema: mergeSchema(schema, options?.schema),
+    $ERROR_CODES: ERROR_CODES
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  guestList
+});

package/dist/index.d.cts

@@ -0,0 +1,175 @@
+import * as better_auth from 'better-auth';
+import { z } from 'zod/v4-mini';
+
+type GuestWithRole = {
+    name: string;
+    role: string;
+};
+interface GuestListOptions {
+    /**
+     * List of accepted guest names
+     */
+    allowGuests: string[] | GuestWithRole[];
+    /**
+     * When true returns the list of guest names via the guestList.reveal() endpoint and via errors.
+     * When false returns nothing.
+     * @default false
+     */
+    revealNames?: boolean;
+    /**
+     * Configure the domain name of the temporary email
+     * address for the guest users in the database.
+     * @default "baseURL"
+     */
+    emailDomainName?: string;
+}
+declare const guestList: (options?: GuestListOptions) => {
+    id: "guest-list";
+    endpoints: {
+        signInGuest: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    name: string;
+                };
+            } & {
+                method?: "POST" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: better_auth.Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    token: string;
+                    user: {
+                        id: string;
+                        name: string;
+                        emailVerified: boolean;
+                        email: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        image?: string | null | undefined;
+                    };
+                } | null;
+            } : {
+                token: string;
+                user: {
+                    id: string;
+                    name: string;
+                    emailVerified: boolean;
+                    email: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | null | undefined;
+                };
+            } | null>;
+            options: {
+                method: "POST";
+                body: z.ZodMiniObject<{
+                    name: z.ZodMiniString<string>;
+                }, z.core.$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/sign-in/guest-list";
+        };
+        revealGuestList: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                body?: undefined;
+            } & {
+                method?: "GET" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: better_auth.Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: string[];
+            } : string[]>;
+            options: {
+                method: "GET";
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "array";
+                                            items: {
+                                                type: string;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/sign-in/guest-list/reveal";
+        };
+    };
+    $ERROR_CODES: {
+        readonly NAME_NOT_PROVIDED: "Guest name not provided";
+        readonly NAME_NOT_ON_GUEST_LIST: "Your name is not on the guest list";
+        readonly NAME_ONE_WORD_ONLY: "Please only use 1-word names";
+        readonly FAILED_TO_CREATE_USER: "Failed to create user";
+        readonly COULD_NOT_CREATE_SESSION: "Could not create session";
+    };
+};
+
+export { type GuestListOptions, guestList };

package/dist/index.d.ts

@@ -0,0 +1,175 @@
+import * as better_auth from 'better-auth';
+import { z } from 'zod/v4-mini';
+
+type GuestWithRole = {
+    name: string;
+    role: string;
+};
+interface GuestListOptions {
+    /**
+     * List of accepted guest names
+     */
+    allowGuests: string[] | GuestWithRole[];
+    /**
+     * When true returns the list of guest names via the guestList.reveal() endpoint and via errors.
+     * When false returns nothing.
+     * @default false
+     */
+    revealNames?: boolean;
+    /**
+     * Configure the domain name of the temporary email
+     * address for the guest users in the database.
+     * @default "baseURL"
+     */
+    emailDomainName?: string;
+}
+declare const guestList: (options?: GuestListOptions) => {
+    id: "guest-list";
+    endpoints: {
+        signInGuest: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    name: string;
+                };
+            } & {
+                method?: "POST" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: better_auth.Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    token: string;
+                    user: {
+                        id: string;
+                        name: string;
+                        emailVerified: boolean;
+                        email: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        image?: string | null | undefined;
+                    };
+                } | null;
+            } : {
+                token: string;
+                user: {
+                    id: string;
+                    name: string;
+                    emailVerified: boolean;
+                    email: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    image?: string | null | undefined;
+                };
+            } | null>;
+            options: {
+                method: "POST";
+                body: z.ZodMiniObject<{
+                    name: z.ZodMiniString<string>;
+                }, z.core.$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/sign-in/guest-list";
+        };
+        revealGuestList: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                body?: undefined;
+            } & {
+                method?: "GET" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: better_auth.Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: string[];
+            } : string[]>;
+            options: {
+                method: "GET";
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "array";
+                                            items: {
+                                                type: string;
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/sign-in/guest-list/reveal";
+        };
+    };
+    $ERROR_CODES: {
+        readonly NAME_NOT_PROVIDED: "Guest name not provided";
+        readonly NAME_NOT_ON_GUEST_LIST: "Your name is not on the guest list";
+        readonly NAME_ONE_WORD_ONLY: "Please only use 1-word names";
+        readonly FAILED_TO_CREATE_USER: "Failed to create user";
+        readonly COULD_NOT_CREATE_SESSION: "Could not create session";
+    };
+};
+
+export { type GuestListOptions, guestList };

package/dist/index.mjs

@@ -0,0 +1,163 @@
+// src/index.ts
+import { APIError, createAuthEndpoint } from "better-auth/api";
+import { setSessionCookie } from "better-auth/cookies";
+import { capitalize } from "lodash-es";
+import { z } from "zod/v4-mini";
+
+// src/utils.ts
+function getOrigin(url) {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.origin;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// src/index.ts
+function formatName(name) {
+  return capitalize(name.replaceAll(/\s/g, ""));
+}
+var guestList = (options) => {
+  const ERROR_CODES = {
+    NAME_NOT_PROVIDED: "Guest name not provided",
+    NAME_NOT_ON_GUEST_LIST: "Your name is not on the guest list",
+    NAME_ONE_WORD_ONLY: "Please only use 1-word names",
+    FAILED_TO_CREATE_USER: "Failed to create user",
+    COULD_NOT_CREATE_SESSION: "Could not create session"
+  };
+  const guestLookup = Object.fromEntries(
+    (options?.allowGuests ?? []).map((entry) => typeof entry === "string" ? { name: entry, role: "" } : entry).filter((entry) => !!entry && entry.name).map(({ name, role }) => [formatName(name), {
+      name: formatName(name),
+      role: (role ?? "").split(",").map((s) => s.trim()).join(",")
+    }])
+  );
+  return {
+    id: "guest-list",
+    endpoints: {
+      signInGuest: createAuthEndpoint(
+        "/sign-in/guest-list",
+        {
+          method: "POST",
+          body: z.object({
+            name: z.string()
+          }),
+          metadata: {
+            openapi: {
+              description: "Sign in as a guest with name only",
+              responses: {
+                200: {
+                  description: "Sign in as a guest successful",
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "object",
+                        properties: {
+                          user: {
+                            $ref: "#/components/schemas/User"
+                          },
+                          session: {
+                            $ref: "#/components/schemas/Session"
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        async (ctx) => {
+          const { name } = ctx.body;
+          if (!name) {
+            ctx.context.logger.error("Guest name not provided");
+            throw new APIError("UNAUTHORIZED", {
+              message: options?.revealNames ? `Guest name not provided. Try: ${JSON.stringify(Object.keys(guestLookup))}` : ERROR_CODES.NAME_NOT_PROVIDED
+            });
+          }
+          if (name.trim().split(/\s+/).length > 1) {
+            ctx.context.logger.error("For simplicity, only one word names are allowed");
+            throw new APIError("UNAUTHORIZED", {
+              message: ERROR_CODES.NAME_ONE_WORD_ONLY
+            });
+          }
+          const cleanedName = formatName(name);
+          if (!guestLookup[cleanedName]) {
+            throw new APIError("UNAUTHORIZED", {
+              message: options?.revealNames ? `Name not on list. Try: ${JSON.stringify(Object.keys(guestLookup))}` : ERROR_CODES.NAME_NOT_ON_GUEST_LIST
+            });
+          }
+          const { emailDomainName = getOrigin(ctx.context.baseURL) } = options ?? {};
+          const email = `${cleanedName.toLowerCase().replaceAll(/\s/g, "")}.onguestlist@${emailDomainName}`;
+          const found = await ctx.context.internalAdapter.findUserByEmail(email);
+          async function createNewUser() {
+            const newUser = await ctx.context.internalAdapter.createUser(
+              {
+                email,
+                emailVerified: false,
+                name: cleanedName,
+                role: guestLookup[cleanedName].role,
+                createdAt: /* @__PURE__ */ new Date(),
+                updatedAt: /* @__PURE__ */ new Date()
+              },
+              ctx
+            );
+            if (!newUser) {
+              throw ctx.error("INTERNAL_SERVER_ERROR", {
+                message: ERROR_CODES.FAILED_TO_CREATE_USER
+              });
+            }
+            return newUser;
+          }
+          const user = found ? found.user : await createNewUser();
+          const session = await ctx.context.internalAdapter.createSession(user.id, ctx, true);
+          if (!session) {
+            return ctx.json(null, {
+              status: 400,
+              body: {
+                message: ERROR_CODES.COULD_NOT_CREATE_SESSION
+              }
+            });
+          }
+          await setSessionCookie(ctx, { session, user });
+          return ctx.json({ token: session.token, user });
+        }
+      ),
+      revealGuestList: createAuthEndpoint(
+        "/sign-in/guest-list/reveal",
+        {
+          method: "GET",
+          metadata: {
+            openapi: {
+              description: "Reveal guest list if 'revealNames' is enabled. Empty array otherwise",
+              responses: {
+                200: {
+                  description: "List of allowed guest names or empty array",
+                  content: {
+                    "application/json": {
+                      schema: {
+                        type: "array",
+                        items: {
+                          type: "string"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        async (ctx) => {
+          return ctx.json(options?.revealNames ? Object.keys(guestLookup) : []);
+        }
+      )
+    },
+    //schema: mergeSchema(schema, options?.schema),
+    $ERROR_CODES: ERROR_CODES
+  };
+};
+export {
+  guestList
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@nerdfolio/ba-guest-list",
+  "version": "0.0.1",
+  "description": "Similar to anonymous, but with a name that must be on a guest list. Useful for testing or demo with fixed logins",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.mjs",
+      "require": "./dist/client.cjs"
+    }
+  },
+  "keywords": [
+    "better-auth",
+    "better-auth plugin",
+    "guest login",
+    "demo login"
+  ],
+  "author": "taivo@github",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "better-auth": "1.2.9"
+  },
+  "peerDependencies": {
+    "better-auth": "1.2.9"
+  },
+  "dependencies": {
+    "lodash-es": "^4.17.21",
+    "zod": "^3.25.67"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsup-node"
+  }
+}

package/src/client.ts

@@ -0,0 +1,12 @@
+import type { BetterAuthClientPlugin } from "better-auth"
+import type { guestList } from "."
+
+export const guestListClient = () => {
+	return {
+		id: "guest-list",
+		$InferServerPlugin: {} as ReturnType<typeof guestList>,
+		// pathMethods: {
+		// 	"/sign-in/guest-list": "POST",
+		// },
+	} satisfies BetterAuthClientPlugin
+}

package/src/index.ts

@@ -0,0 +1,205 @@
+import type { BetterAuthPlugin } from "better-auth"
+import { APIError, createAuthEndpoint } from "better-auth/api"
+import { setSessionCookie } from "better-auth/cookies"
+import { capitalize } from "lodash-es"
+import { z } from "zod/v4-mini"
+import { getOrigin } from "./utils"
+
+type GuestWithRole = {
+	name: string,
+	role: string //comma-separated string
+}
+
+export interface GuestListOptions {
+	/**
+	 * List of accepted guest names
+	 */
+	allowGuests: string[] | GuestWithRole[]
+
+	/**
+	 * When true returns the list of guest names via the guestList.reveal() endpoint and via errors.
+	 * When false returns nothing.
+	 * @default false
+	 */
+	revealNames?: boolean
+
+	/**
+	 * Configure the domain name of the temporary email
+	 * address for the guest users in the database.
+	 * @default "baseURL"
+	 */
+	emailDomainName?: string
+
+	/**
+	 * Custom schema for the anonymous plugin
+	 */
+	// schema?: InferOptionSchema<typeof schema>
+}
+
+function formatName(name: string) {
+	return capitalize(name.replaceAll(/\s/g, ""))
+}
+
+export const guestList = (options?: GuestListOptions) => {
+	const ERROR_CODES = {
+		NAME_NOT_PROVIDED: "Guest name not provided",
+		NAME_NOT_ON_GUEST_LIST: "Your name is not on the guest list",
+		NAME_ONE_WORD_ONLY: "Please only use 1-word names",
+		FAILED_TO_CREATE_USER: "Failed to create user",
+		COULD_NOT_CREATE_SESSION: "Could not create session",
+	} as const
+
+	const guestLookup = Object.fromEntries(
+		(options?.allowGuests ?? [])
+			.map((entry) => typeof entry === "string" ? { name: entry, role: "" } : entry)
+			.filter(entry => !!entry && entry.name)
+			.map(({ name, role }) => [formatName(name), {
+				name: formatName(name),
+				role: (role ?? "").split(",").map(s => s.trim()).join(",")
+			}])
+	)
+
+	return {
+		id: "guest-list",
+		endpoints: {
+			signInGuest: createAuthEndpoint(
+				"/sign-in/guest-list",
+				{
+					method: "POST",
+					body: z.object({
+						name: z.string(),
+					}),
+					metadata: {
+						openapi: {
+							description: "Sign in as a guest with name only",
+							responses: {
+								200: {
+									description: "Sign in as a guest successful",
+									content: {
+										"application/json": {
+											schema: {
+												type: "object",
+												properties: {
+													user: {
+														$ref: "#/components/schemas/User",
+													},
+													session: {
+														$ref: "#/components/schemas/Session",
+													},
+												},
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+				async (ctx) => {
+					const { name } = ctx.body
+
+					if (!name) {
+						ctx.context.logger.error("Guest name not provided")
+						throw new APIError("UNAUTHORIZED", {
+							message: options?.revealNames
+								? `Guest name not provided. Try: ${JSON.stringify(Object.keys(guestLookup))}` : ERROR_CODES.NAME_NOT_PROVIDED,
+						})
+					}
+
+					if (name.trim().split(/\s+/).length > 1) {
+						ctx.context.logger.error("For simplicity, only one word names are allowed")
+						throw new APIError("UNAUTHORIZED", {
+							message: ERROR_CODES.NAME_ONE_WORD_ONLY,
+						})
+					}
+
+					const cleanedName = formatName(name)
+
+					if (!guestLookup[cleanedName]) {
+						throw new APIError("UNAUTHORIZED", {
+							message: options?.revealNames
+								? `Name not on list. Try: ${JSON.stringify(Object.keys(guestLookup))}`
+								: ERROR_CODES.NAME_NOT_ON_GUEST_LIST,
+						})
+					}
+
+					// generate email based the input name
+					const { emailDomainName = getOrigin(ctx.context.baseURL) } = options ?? {}
+					const email = `${cleanedName.toLowerCase().replaceAll(/\s/g, "")}.onguestlist@${emailDomainName}`
+
+					const found = await ctx.context.internalAdapter.findUserByEmail(email)
+
+					async function createNewUser() {
+						const newUser = await ctx.context.internalAdapter.createUser(
+							{
+								email,
+								emailVerified: false,
+								name: cleanedName,
+								role: guestLookup[cleanedName].role,
+								createdAt: new Date(),
+								updatedAt: new Date(),
+							},
+							ctx
+						)
+						if (!newUser) {
+							throw ctx.error("INTERNAL_SERVER_ERROR", {
+								message: ERROR_CODES.FAILED_TO_CREATE_USER,
+							})
+						}
+
+						return newUser
+					}
+
+					const user = found ? found.user : await createNewUser()
+
+					const session = await ctx.context.internalAdapter.createSession(user.id, ctx, true)
+
+					if (!session) {
+						return ctx.json(null, {
+							status: 400,
+							body: {
+								message: ERROR_CODES.COULD_NOT_CREATE_SESSION,
+							},
+						})
+					}
+					await setSessionCookie(ctx, { session, user })
+
+					return ctx.json({ token: session.token, user })
+				}
+			),
+
+			revealGuestList: createAuthEndpoint(
+				"/sign-in/guest-list/reveal",
+				{
+					method: "GET",
+					metadata: {
+						openapi: {
+							description: "Reveal guest list if 'revealNames' is enabled. Empty array otherwise",
+							responses: {
+								200: {
+									description: "List of allowed guest names or empty array",
+									content: {
+										"application/json": {
+											schema: {
+												type: "array",
+												items: {
+													type: "string",
+												},
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+				async (ctx) => {
+					return ctx.json(options?.revealNames ? Object.keys(guestLookup) : [])
+				}
+			)
+		},
+
+		//schema: mergeSchema(schema, options?.schema),
+		$ERROR_CODES: ERROR_CODES,
+	} satisfies BetterAuthPlugin
+}

package/src/utils.ts

@@ -0,0 +1,8 @@
+export function getOrigin(url: string) {
+	try {
+		const parsedUrl = new URL(url)
+		return parsedUrl.origin
+	} catch (_error) {
+		return null
+	}
+}

package/tsup.config.ts

@@ -0,0 +1,15 @@
+import { type Options, defineConfig } from "tsup"
+
+const libCfg = {
+	entry: ["src/index.ts", "src/client.ts"],
+	splitting: false,
+	target: "node22",
+	format: ["esm", "cjs"],
+	dts: true,
+	clean: true,
+	outExtension({ format }) {
+		return { js: format === "esm" ? ".mjs" : format === "cjs" ? ".cjs" : ".js" }
+	},
+} satisfies Options
+
+export default defineConfig(libCfg)