lazyconvex 0.0.0

package/src/server/test.ts

@@ -0,0 +1,554 @@
+/* eslint-disable no-await-in-loop, max-depth, max-statements, @typescript-eslint/no-unnecessary-condition */
+/** biome-ignore-all lint/performance/noAwaitInLoops: sequential deletes */
+import type { GenericDataModel, MutationBuilder, QueryBuilder } from 'convex/server'
+
+import { v } from 'convex/values'
+
+import type { DbLike, FilterLike, IndexLike, Rec } from './types'
+
+interface TestAuthConfig<DM extends GenericDataModel = GenericDataModel> {
+  getAuthUserId: (ctx: unknown) => Promise<null | string>
+  mutation: MutationBuilder<DM, 'public'>
+  query: QueryBuilder<DM, 'public'>
+}
+
+const TEST_EMAIL = 'test@playwright.local',
+  BATCH_SIZE = 50,
+  isTestMode = () => process.env.CONVEX_TEST_MODE === 'true',
+  generateToken = () => {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+    let token = ''
+    for (let i = 0; i < 32; i += 1) token += chars.charAt(Math.floor(Math.random() * chars.length))
+    return token
+  },
+  getOrgMembership = async (db: DbLike, orgId: string, userId: string) => {
+    const orgDoc = await db.get(orgId)
+    if (!orgDoc) return null
+    const isOwner = orgDoc.userId === userId,
+      member = await db
+        .query('orgMember')
+        .withIndex('by_org_user', ((q: IndexLike) => q.eq('orgId', orgId).eq('userId', userId)) as never)
+        .unique()
+    if (!(isOwner || member)) return null
+    return { isAdmin: isOwner || member?.isAdmin === true, isOwner, member, orgDoc }
+  },
+  makeTestAuth = <DM extends GenericDataModel>(config: TestAuthConfig<DM>) => {
+    const { mutation: rawMut, query: rawQry } = config,
+      mutation = rawMut as unknown as (opts: Rec) => Rec,
+      query = rawQry as unknown as (opts: Rec) => Rec,
+      getAuthUserIdOrTest = async (ctx: unknown): Promise<null | string> => {
+        if (!isTestMode()) return config.getAuthUserId(ctx)
+        const c = ctx as { auth: { getUserIdentity: () => Promise<unknown> }; db: DbLike },
+          identity = await c.auth.getUserIdentity()
+        if (identity === null) {
+          const u = await c.db
+            .query('users')
+            .filter(((q: FilterLike) => q.eq(q.field('email'), TEST_EMAIL)) as never)
+            .first()
+          return u?._id as null | string
+        }
+        return ((identity as Rec).subject as string).split('|')[0] ?? null
+      },
+      ensureTestUser = mutation({
+        args: {},
+        handler: async (ctx: { db: DbLike }) => {
+          if (!isTestMode()) return null
+          const u = await ctx.db
+            .query('users')
+            .filter(((q: FilterLike) => q.eq(q.field('email'), TEST_EMAIL)) as never)
+            .first()
+          if (u) return u._id
+          return ctx.db.insert('users', {
+            email: TEST_EMAIL,
+            emailVerificationTime: Date.now(),
+            name: 'Test User'
+          })
+        }
+      }),
+      getTestUser = query({
+        args: {},
+        handler: async (ctx: { db: DbLike }) => {
+          if (!isTestMode()) return null
+          const u = await ctx.db
+            .query('users')
+            .filter(((q: FilterLike) => q.eq(q.field('email'), TEST_EMAIL)) as never)
+            .first()
+          return u?._id ?? null
+        }
+      }),
+      createTestUser = mutation({
+        args: { email: v.string(), name: v.string() },
+        handler: async (ctx: { db: DbLike }, { email, name }: { email: string; name: string }) => {
+          if (!isTestMode()) return null
+          const existing = await ctx.db
+            .query('users')
+            .filter(((q: FilterLike) => q.eq(q.field('email'), email)) as never)
+            .first()
+          if (existing) return existing._id
+          return ctx.db.insert('users', { email, emailVerificationTime: Date.now(), name })
+        }
+      }),
+      getTestUserByEmail = query({
+        args: { email: v.string() },
+        handler: async (ctx: { db: DbLike }, { email }: { email: string }) => {
+          if (!isTestMode()) return null
+          const u = await ctx.db
+            .query('users')
+            .filter(((q: FilterLike) => q.eq(q.field('email'), email)) as never)
+            .first()
+          return u?._id ?? null
+        }
+      }),
+      addTestOrgMember = mutation({
+        args: { isAdmin: v.boolean(), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { isAdmin, orgId, userId }: { isAdmin: boolean; orgId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const existing = await ctx.db
+            .query('orgMember')
+            .withIndex('by_org_user', ((q: IndexLike) => q.eq('orgId', orgId).eq('userId', userId)) as never)
+            .unique()
+          if (existing) {
+            await ctx.db.patch(existing._id as string, { isAdmin, updatedAt: Date.now() })
+            return existing._id
+          }
+          return ctx.db.insert('orgMember', { isAdmin, orgId, updatedAt: Date.now(), userId })
+        }
+      }),
+      removeTestOrgMember = mutation({
+        args: { orgId: v.id('org'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { orgId, userId }: { orgId: string; userId: string }) => {
+          if (!isTestMode()) return false
+          const member = await ctx.db
+            .query('orgMember')
+            .withIndex('by_org_user', ((q: IndexLike) => q.eq('orgId', orgId).eq('userId', userId)) as never)
+            .unique()
+          if (member) {
+            await ctx.db.delete(member._id as string)
+            return true
+          }
+          return false
+        }
+      }),
+      cleanupTestUsers = mutation({
+        args: { emailPrefix: v.string() },
+        handler: async (ctx: { db: DbLike }, { emailPrefix }: { emailPrefix: string }) => {
+          if (!isTestMode()) return { count: 0 }
+          const users = await ctx.db.query('users').collect()
+          let count = 0
+          for (const u of users)
+            if ((u.email as string)?.startsWith(emailPrefix) && u.email !== TEST_EMAIL) {
+              await ctx.db.delete(u._id as string)
+              count += 1
+            }
+          return { count }
+        }
+      }),
+      cleanupOrgTestData = mutation({
+        args: { slugPrefix: v.string(), tables: v.optional(v.array(v.string())) },
+        handler: async (ctx: { db: DbLike }, { slugPrefix, tables }: { slugPrefix: string; tables?: string[] }) => {
+          if (!isTestMode()) return { count: 0, done: true }
+          const allOrgs = await ctx.db.query('org').collect(),
+            orgIds: string[] = []
+          for (const o of allOrgs) if ((o.slug as string).startsWith(slugPrefix)) orgIds.push(o._id as string)
+          if (orgIds.length === 0) return { count: 0, done: true }
+          let count = 0
+          for (const orgId of orgIds) {
+            if (tables)
+              for (const table of tables) {
+                const docs = await ctx.db.query(table).take(BATCH_SIZE * 2)
+                for (const d of docs)
+                  if (d.orgId === orgId) {
+                    await ctx.db.delete(d._id as string)
+                    count += 1
+                  }
+              }
+
+            const requests = await ctx.db
+              .query('orgJoinRequest')
+              .withIndex('by_org', ((q: IndexLike) => q.eq('orgId', orgId)) as never)
+              .collect()
+            for (const r of requests) {
+              await ctx.db.delete(r._id as string)
+              count += 1
+            }
+            const invites = await ctx.db
+              .query('orgInvite')
+              .withIndex('by_org', ((q: IndexLike) => q.eq('orgId', orgId)) as never)
+              .collect()
+            for (const i of invites) {
+              await ctx.db.delete(i._id as string)
+              count += 1
+            }
+            const members = await ctx.db
+              .query('orgMember')
+              .withIndex('by_org', ((q: IndexLike) => q.eq('orgId', orgId)) as never)
+              .collect()
+            for (const m of members) {
+              await ctx.db.delete(m._id as string)
+              count += 1
+            }
+            await ctx.db.delete(orgId)
+            count += 1
+          }
+          return { count, done: true }
+        }
+      }),
+      inviteAsUser = mutation({
+        args: { email: v.string(), isAdmin: v.boolean(), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { email, isAdmin, orgId, userId }: { email: string; isAdmin: boolean; orgId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const membership = await getOrgMembership(ctx.db, orgId, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (!membership.isAdmin) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          const token = generateToken(),
+            inviteId = await ctx.db.insert('orgInvite', {
+              email,
+              expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000,
+              isAdmin,
+              orgId,
+              token
+            })
+          return { inviteId, token }
+        }
+      }),
+      acceptInviteAsUser = mutation({
+        args: { token: v.string(), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { token, userId }: { token: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const inviteDoc = await ctx.db
+            .query('orgInvite')
+            .withIndex('by_token', ((q: IndexLike) => q.eq('token', token)) as never)
+            .unique()
+          if (!inviteDoc) return { code: 'INVALID_INVITE' }
+          if ((inviteDoc.expiresAt as number) < Date.now()) return { code: 'INVITE_EXPIRED' }
+          const orgDoc = await ctx.db.get(inviteDoc.orgId as string)
+          if (!orgDoc) return { code: 'NOT_FOUND' }
+          if (orgDoc.userId === userId) return { code: 'ALREADY_ORG_MEMBER' }
+          const existingMember = await ctx.db
+            .query('orgMember')
+            .withIndex('by_org_user', ((q: IndexLike) => q.eq('orgId', inviteDoc.orgId).eq('userId', userId)) as never)
+            .unique()
+          if (existingMember) return { code: 'ALREADY_ORG_MEMBER' }
+          const pendingRequest = await ctx.db
+            .query('orgJoinRequest')
+            .withIndex('by_org_status', ((q: IndexLike) =>
+              q.eq('orgId', inviteDoc.orgId).eq('status', 'pending')) as never)
+            .filter(((q: FilterLike) => q.eq(q.field('userId'), userId)) as never)
+            .unique()
+          if (pendingRequest) await ctx.db.patch(pendingRequest._id as string, { status: 'approved' as const })
+          await ctx.db.insert('orgMember', {
+            isAdmin: inviteDoc.isAdmin,
+            orgId: inviteDoc.orgId,
+            updatedAt: Date.now(),
+            userId
+          })
+          await ctx.db.delete(inviteDoc._id as string)
+          return { orgId: inviteDoc.orgId }
+        }
+      }),
+      setAdminAsUser = mutation({
+        args: { isAdmin: v.boolean(), memberId: v.id('orgMember'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { isAdmin, memberId, userId }: { isAdmin: boolean; memberId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const memberDoc = await ctx.db.get(memberId)
+          if (!memberDoc) return { code: 'NOT_FOUND' }
+          const orgDoc = await ctx.db.get(memberDoc.orgId as string)
+          if (!orgDoc) return { code: 'NOT_FOUND' }
+          if (orgDoc.userId !== userId) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          if (memberDoc.userId === orgDoc.userId) return { code: 'CANNOT_MODIFY_OWNER' }
+          await ctx.db.patch(memberId, { isAdmin, updatedAt: Date.now() })
+          return { success: true }
+        }
+      }),
+      removeMemberAsUser = mutation({
+        args: { memberId: v.id('orgMember'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { memberId, userId }: { memberId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const memberDoc = await ctx.db.get(memberId)
+          if (!memberDoc) return { code: 'NOT_FOUND' }
+          const membership = await getOrgMembership(ctx.db, memberDoc.orgId as string, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (memberDoc.userId === membership.orgDoc.userId) return { code: 'CANNOT_MODIFY_OWNER' }
+          if (!membership.isAdmin) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          if (!membership.isOwner && memberDoc.isAdmin) return { code: 'CANNOT_MODIFY_ADMIN' }
+          await ctx.db.delete(memberId)
+          return { success: true }
+        }
+      }),
+      transferOwnershipAsUser = mutation({
+        args: { newOwnerId: v.id('users'), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { newOwnerId, orgId, userId }: { newOwnerId: string; orgId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const orgDoc = await ctx.db.get(orgId)
+          if (!orgDoc) return { code: 'NOT_FOUND' }
+          if (orgDoc.userId !== userId) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          const targetMember = await ctx.db
+            .query('orgMember')
+            .withIndex('by_org_user', ((q: IndexLike) => q.eq('orgId', orgId).eq('userId', newOwnerId)) as never)
+            .unique()
+          if (!targetMember) return { code: 'NOT_ORG_MEMBER' }
+          if (!targetMember.isAdmin) return { code: 'TARGET_MUST_BE_ADMIN' }
+          await ctx.db.patch(orgId, { updatedAt: Date.now(), userId: newOwnerId })
+          await ctx.db.delete(targetMember._id as string)
+          await ctx.db.insert('orgMember', { isAdmin: true, orgId, updatedAt: Date.now(), userId })
+          return { success: true }
+        }
+      }),
+      updateOrgAsUser = mutation({
+        args: {
+          data: v.object({ name: v.optional(v.string()), slug: v.optional(v.string()) }),
+          orgId: v.id('org'),
+          userId: v.id('users')
+        },
+        handler: async (
+          ctx: { db: DbLike },
+          { data, orgId, userId }: { data: { name?: string; slug?: string }; orgId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const membership = await getOrgMembership(ctx.db, orgId, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (!membership.isAdmin) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          if (data.slug !== undefined) {
+            const existing = await ctx.db
+              .query('org')
+              .withIndex('by_slug', ((q: IndexLike) => q.eq('slug', data.slug)) as never)
+              .unique()
+            if (existing && existing._id !== orgId) return { code: 'ORG_SLUG_TAKEN' }
+          }
+          await ctx.db.patch(orgId, { ...data, updatedAt: Date.now() })
+          return { success: true }
+        }
+      }),
+      deleteOrgAsUser = mutation({
+        args: { cascadeTables: v.optional(v.array(v.string())), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { cascadeTables, orgId, userId }: { cascadeTables?: string[]; orgId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const orgDoc = await ctx.db.get(orgId)
+          if (!orgDoc) return { code: 'NOT_FOUND' }
+          if (orgDoc.userId !== userId) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          if (cascadeTables)
+            for (const table of cascadeTables) {
+              const docs = await ctx.db
+                .query(table)
+                .filter(((q: FilterLike) => q.eq(q.field('orgId'), orgId)) as never)
+                .collect()
+              for (const d of docs) await ctx.db.delete(d._id as string)
+            }
+
+          const requests = await ctx.db
+            .query('orgJoinRequest')
+            .withIndex('by_org', ((q: IndexLike) => q.eq('orgId', orgId)) as never)
+            .collect()
+          for (const r of requests) await ctx.db.delete(r._id as string)
+          const invites = await ctx.db
+            .query('orgInvite')
+            .withIndex('by_org', ((q: IndexLike) => q.eq('orgId', orgId)) as never)
+            .collect()
+          for (const i of invites) await ctx.db.delete(i._id as string)
+          const orgMembers = await ctx.db
+            .query('orgMember')
+            .withIndex('by_org', ((q: IndexLike) => q.eq('orgId', orgId)) as never)
+            .collect()
+          for (const m of orgMembers) await ctx.db.delete(m._id as string)
+          await ctx.db.delete(orgId)
+          return { success: true }
+        }
+      }),
+      leaveOrgAsUser = mutation({
+        args: { orgId: v.id('org'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { orgId, userId }: { orgId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const orgDoc = await ctx.db.get(orgId)
+          if (!orgDoc) return { code: 'NOT_FOUND' }
+          if (orgDoc.userId === userId) return { code: 'MUST_TRANSFER_OWNERSHIP' }
+          const member = await ctx.db
+            .query('orgMember')
+            .withIndex('by_org_user', ((q: IndexLike) => q.eq('orgId', orgId).eq('userId', userId)) as never)
+            .unique()
+          if (!member) return { code: 'NOT_ORG_MEMBER' }
+          await ctx.db.delete(member._id as string)
+          return { success: true }
+        }
+      }),
+      requestJoinAsUser = mutation({
+        args: { message: v.optional(v.string()), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { message, orgId, userId }: { message?: string; orgId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const orgDoc = await ctx.db.get(orgId)
+          if (!orgDoc) return { code: 'NOT_FOUND' }
+          if (orgDoc.userId === userId) return { code: 'ALREADY_ORG_MEMBER' }
+          const existingMember = await ctx.db
+            .query('orgMember')
+            .withIndex('by_org_user', ((q: IndexLike) => q.eq('orgId', orgId).eq('userId', userId)) as never)
+            .unique()
+          if (existingMember) return { code: 'ALREADY_ORG_MEMBER' }
+          const existingRequest = await ctx.db
+            .query('orgJoinRequest')
+            .withIndex('by_org_status', ((q: IndexLike) => q.eq('orgId', orgId).eq('status', 'pending')) as never)
+            .filter(((q: FilterLike) => q.eq(q.field('userId'), userId)) as never)
+            .unique()
+          if (existingRequest) return { code: 'JOIN_REQUEST_EXISTS' }
+          const requestId = await ctx.db.insert('orgJoinRequest', {
+            message,
+            orgId,
+            status: 'pending',
+            userId
+          })
+          return { requestId }
+        }
+      }),
+      approveJoinRequestAsUser = mutation({
+        args: { isAdmin: v.boolean(), requestId: v.id('orgJoinRequest'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { isAdmin, requestId, userId }: { isAdmin: boolean; requestId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const request = await ctx.db.get(requestId)
+          if (request?.status !== 'pending') return { code: 'NOT_FOUND' }
+          const membership = await getOrgMembership(ctx.db, request.orgId as string, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (!membership.isAdmin) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          const existingMember = await ctx.db
+            .query('orgMember')
+            .withIndex('by_org_user', ((q: IndexLike) =>
+              q.eq('orgId', request.orgId).eq('userId', request.userId)) as never)
+            .unique()
+          if (existingMember) return { code: 'ALREADY_ORG_MEMBER' }
+          await ctx.db.patch(requestId, { status: 'approved' })
+          await ctx.db.insert('orgMember', {
+            isAdmin,
+            orgId: request.orgId,
+            updatedAt: Date.now(),
+            userId: request.userId
+          })
+          return { success: true }
+        }
+      }),
+      rejectJoinRequestAsUser = mutation({
+        args: { requestId: v.id('orgJoinRequest'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { requestId, userId }: { requestId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const request = await ctx.db.get(requestId)
+          if (request?.status !== 'pending') return { code: 'NOT_FOUND' }
+          const membership = await getOrgMembership(ctx.db, request.orgId as string, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (!membership.isAdmin) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          await ctx.db.patch(requestId, { status: 'rejected' })
+          return { success: true }
+        }
+      }),
+      cancelJoinRequestAsUser = mutation({
+        args: { requestId: v.id('orgJoinRequest'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { requestId, userId }: { requestId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const requestDoc = await ctx.db.get(requestId)
+          if (!requestDoc) return { code: 'NOT_FOUND' }
+          if (requestDoc.userId !== userId) return { code: 'FORBIDDEN' }
+          if (requestDoc.status !== 'pending') return { code: 'NOT_FOUND' }
+          await ctx.db.delete(requestId)
+          return { success: true }
+        }
+      }),
+      pendingInvitesAsUser = query({
+        args: { orgId: v.id('org'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { orgId, userId }: { orgId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const membership = await getOrgMembership(ctx.db, orgId, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (!membership.isAdmin) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          return ctx.db
+            .query('orgInvite')
+            .withIndex('by_org', ((q: IndexLike) => q.eq('orgId', orgId)) as never)
+            .collect()
+        }
+      }),
+      pendingJoinRequestsAsUser = query({
+        args: { orgId: v.id('org'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { orgId, userId }: { orgId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const membership = await getOrgMembership(ctx.db, orgId, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (!membership.isAdmin) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          return ctx.db
+            .query('orgJoinRequest')
+            .withIndex('by_org_status', ((q: IndexLike) => q.eq('orgId', orgId).eq('status', 'pending')) as never)
+            .collect()
+        }
+      }),
+      createExpiredInvite = mutation({
+        args: { email: v.string(), isAdmin: v.boolean(), orgId: v.id('org') },
+        handler: async (
+          ctx: { db: DbLike },
+          { email, isAdmin, orgId }: { email: string; isAdmin: boolean; orgId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const token = generateToken(),
+            inviteId = await ctx.db.insert('orgInvite', {
+              email,
+              expiresAt: Date.now() - 1000,
+              isAdmin,
+              orgId,
+              token
+            })
+          return { inviteId, token }
+        }
+      }),
+      getJoinRequest = query({
+        args: { requestId: v.id('orgJoinRequest') },
+        handler: async (ctx: { db: DbLike }, { requestId }: { requestId: string }) => {
+          if (!isTestMode()) return null
+          return ctx.db.get(requestId)
+        }
+      })
+    return {
+      acceptInviteAsUser,
+      addTestOrgMember,
+      approveJoinRequestAsUser,
+      cancelJoinRequestAsUser,
+      cleanupOrgTestData,
+      cleanupTestUsers,
+      createExpiredInvite,
+      createTestUser,
+      deleteOrgAsUser,
+      ensureTestUser,
+      getAuthUserIdOrTest,
+      getJoinRequest,
+      getTestUser,
+      getTestUserByEmail,
+      inviteAsUser,
+      isTestMode,
+      leaveOrgAsUser,
+      pendingInvitesAsUser,
+      pendingJoinRequestsAsUser,
+      rejectJoinRequestAsUser,
+      removeMemberAsUser,
+      removeTestOrgMember,
+      requestJoinAsUser,
+      setAdminAsUser,
+      TEST_EMAIL,
+      transferOwnershipAsUser,
+      updateOrgAsUser
+    }
+  }
+
+export type { TestAuthConfig }
+export { isTestMode, makeTestAuth, TEST_EMAIL }