lazyconvex 0.0.0

package/src/server/org.ts

@@ -0,0 +1,572 @@
+/* eslint-disable no-await-in-loop, max-statements, @typescript-eslint/no-unnecessary-condition */
+/** biome-ignore-all lint/performance/noAwaitInLoops: sequential deletes */
+import type { GenericDataModel, GenericMutationCtx, GenericQueryCtx, MutationBuilder, QueryBuilder } from 'convex/server'
+import type { GenericId } from 'convex/values'
+import type { ZodObject, ZodRawShape } from 'zod/v4'
+
+import { customCtx } from 'convex-helpers/server/customFunctions'
+import { zCustomMutation, zCustomQuery, zid } from 'convex-helpers/server/zod4'
+import { z } from 'zod/v4'
+
+import type { DbLike, FilterLike, IndexLike, Mb, OrgRole, Qb, Rec } from './types'
+
+import { err, getUser, time } from './helpers'
+import { getOrgMember, getOrgRole, requireOrgMember, requireOrgRole } from './org-helpers'
+
+interface InviteDocLike {
+  [k: string]: unknown
+  _creationTime: number
+  _id: GenericId<'orgInvite'>
+  email: string
+  expiresAt: number
+  isAdmin: boolean
+  orgId: GenericId<'org'>
+  token: string
+}
+
+interface JoinRequestItem {
+  request: {
+    [k: string]: unknown
+    _creationTime: number
+    _id: GenericId<'orgJoinRequest'>
+    message?: string
+    orgId: GenericId<'org'>
+    status: string
+    userId: GenericId<'users'>
+  }
+  user: null | OrgUserLike
+}
+
+interface OrgDocLike {
+  [k: string]: unknown
+  _creationTime: number
+  _id: GenericId<'org'>
+  avatarId?: GenericId<'_storage'>
+  name: string
+  slug: string
+  updatedAt: number
+  userId: GenericId<'users'>
+}
+
+interface OrgMemberItem {
+  memberId?: GenericId<'orgMember'>
+  role: OrgRole
+  user: null | OrgUserLike
+  userId: GenericId<'users'>
+}
+
+interface OrgUserLike {
+  [k: string]: unknown
+  _id: GenericId<'users'>
+  email?: string
+  image?: string
+  name?: string
+}
+
+const 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
+  },
+  SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000,
+  makeOrg = <DM extends GenericDataModel, S extends ZodRawShape>({
+    cascadeTables,
+    getAuthUserId,
+    mutation,
+    query,
+    schema: orgSchema
+  }: {
+    cascadeTables?: string[]
+    getAuthUserId: (ctx: never) => Promise<null | string>
+    mutation: MutationBuilder<DM, 'public'>
+    query: QueryBuilder<DM, 'public'>
+    schema: ZodObject<S>
+  }) => {
+    const mb = zCustomMutation(
+        mutation,
+        customCtx(async (c: GenericMutationCtx<DM>) => ({
+          user: await getUser({ ctx: c as never, db: c.db as never as DbLike, getAuthUserId })
+        }))
+      ) as never as Mb,
+      qb = zCustomQuery(
+        query,
+        customCtx(async (c: GenericQueryCtx<DM>) => ({
+          user: await getUser({ ctx: c as never, db: c.db as never as DbLike, getAuthUserId })
+        }))
+      ) as never as Qb,
+      pqb = zCustomQuery(
+        query,
+        customCtx(() => ({}))
+      ) as never as Qb,
+      m = mb,
+      q = qb,
+      pq = pqb,
+      create = m({
+        args: { data: orgSchema },
+        handler: async (c: Rec, { data }: { data: Rec }) => {
+          const existing = await (c.db as DbLike)
+            .query('org')
+            .withIndex('by_slug', ((o: IndexLike) => o.eq('slug', data.slug)) as never)
+            .unique()
+          if (existing) return err('ORG_SLUG_TAKEN')
+          const orgId = await (c.db as DbLike).insert('org', {
+            avatarId: (data.avatarId as string) ?? undefined,
+            name: data.name,
+            slug: data.slug,
+            userId: (c.user as Rec)._id,
+            ...time()
+          })
+          return { orgId } as { orgId: GenericId<'org'> }
+        }
+      }),
+      update = m({
+        args: { data: orgSchema.partial(), orgId: zid('org') },
+        handler: async (c: Rec, { data, orgId }: { data: Rec; orgId: string }) => {
+          await requireOrgRole({ db: c.db, minRole: 'admin', orgId, userId: (c.user as Rec)._id as string })
+          const newSlug = data.slug as string | undefined
+          if (newSlug !== undefined) {
+            const existing = await (c.db as DbLike)
+              .query('org')
+              .withIndex('by_slug', ((o: IndexLike) => o.eq('slug', newSlug)) as never)
+              .unique()
+            if (existing && existing._id !== orgId) return err('ORG_SLUG_TAKEN')
+          }
+          const patchData: Rec = {}
+          if (data.name !== undefined) patchData.name = data.name
+          if (newSlug !== undefined) patchData.slug = newSlug
+          if (data.avatarId !== undefined && data.avatarId !== null) patchData.avatarId = data.avatarId
+          await (c.db as DbLike).patch(orgId, { ...patchData, ...time() })
+        }
+      }),
+      get = q({
+        args: { orgId: zid('org') },
+        handler: async (c: Rec, { orgId }: { orgId: string }): Promise<null | OrgDocLike> => {
+          await requireOrgMember({ db: c.db, orgId, userId: (c.user as Rec)._id as string })
+          return (c.db as DbLike).get(orgId) as Promise<null | OrgDocLike>
+        }
+      }),
+      getBySlug = pq({
+        args: { slug: z.string() },
+        handler: async (c: Rec, { slug }: { slug: string }): Promise<null | OrgDocLike> =>
+          (c.db as DbLike)
+            .query('org')
+            .withIndex('by_slug', ((o: IndexLike) => o.eq('slug', slug)) as never)
+            .unique() as Promise<null | OrgDocLike>
+      }),
+      getPublic = pq({
+        args: { slug: z.string() },
+        handler: async (
+          c: Rec,
+          { slug }: { slug: string }
+        ): Promise<null | { _id: GenericId<'org'>; avatarId?: GenericId<'_storage'>; name: string; slug: string }> => {
+          const orgDoc = await (c.db as DbLike)
+            .query('org')
+            .withIndex('by_slug', ((o: IndexLike) => o.eq('slug', slug)) as never)
+            .unique()
+          if (!orgDoc) return null
+          return {
+            _id: orgDoc._id as GenericId<'org'>,
+            avatarId: orgDoc.avatarId as GenericId<'_storage'> | undefined,
+            name: orgDoc.name as string,
+            slug: orgDoc.slug as string
+          }
+        }
+      }),
+      myOrgs = q({
+        args: {},
+        handler: async (c: Rec): Promise<{ org: OrgDocLike; role: OrgRole }[]> => {
+          const uid = (c.user as Rec)._id as string,
+            db = c.db as DbLike,
+            ownedOrgs = await db
+              .query('org')
+              .withIndex('by_user', ((o: IndexLike) => o.eq('userId', uid)) as never)
+              .collect(),
+            memberships = await db
+              .query('orgMember')
+              .withIndex('by_user', ((o: IndexLike) => o.eq('userId', uid)) as never)
+              .collect(),
+            memberOrgIds = memberships.map((x: Rec) => x.orgId as string),
+            memberOrgResults = await Promise.all(memberOrgIds.map(async (id: string) => db.get(id))),
+            memberOrgs: Rec[] = []
+          for (const orgDoc of memberOrgResults) if (orgDoc) memberOrgs.push(orgDoc)
+          const ownedIds = new Set(ownedOrgs.map((o: Rec) => o._id as string)),
+            result: { org: OrgDocLike; role: OrgRole }[] = []
+          for (const o of ownedOrgs) result.push({ org: o as OrgDocLike, role: 'owner' })
+          for (const o of memberOrgs)
+            if (!ownedIds.has(o._id as string)) {
+              const member = memberships.find((x: Rec) => x.orgId === o._id),
+                role: OrgRole = member?.isAdmin ? 'admin' : 'member'
+              result.push({ org: o as OrgDocLike, role })
+            }
+          return result
+        }
+      }),
+      remove = m({
+        args: { orgId: zid('org') },
+
+        handler: async (c: Rec, { orgId }: { orgId: string }) => {
+          const db = c.db as DbLike,
+            orgDoc = await db.get(orgId)
+          if (!orgDoc) return err('NOT_FOUND')
+          if (orgDoc.userId !== (c.user as Rec)._id) return err('FORBIDDEN')
+          if (cascadeTables)
+            for (const table of cascadeTables) {
+              const docs = await db
+                .query(table)
+                .filter((o: FilterLike) => o.eq(o.field('orgId'), orgId))
+                .collect()
+              await Promise.all(docs.map(async (d: Rec) => db.delete(d._id as string)))
+            }
+
+          const joinRequests = await db
+            .query('orgJoinRequest')
+            .withIndex('by_org', ((o: IndexLike) => o.eq('orgId', orgId)) as never)
+            .collect()
+          await Promise.all(joinRequests.map(async (r: Rec) => db.delete(r._id as string)))
+          const invites = await db
+            .query('orgInvite')
+            .withIndex('by_org', ((o: IndexLike) => o.eq('orgId', orgId)) as never)
+            .collect()
+          await Promise.all(invites.map(async (i: Rec) => db.delete(i._id as string)))
+          const orgMembers = await db
+            .query('orgMember')
+            .withIndex('by_org', ((o: IndexLike) => o.eq('orgId', orgId)) as never)
+            .collect()
+          await Promise.all(orgMembers.map(async (x: Rec) => db.delete(x._id as string)))
+          await db.delete(orgId)
+        }
+      }),
+      isSlugAvailable = pq({
+        args: { slug: z.string() },
+        handler: async (c: Rec, { slug }: { slug: string }) => {
+          const existing = await (c.db as DbLike)
+            .query('org')
+            .withIndex('by_slug', ((o: IndexLike) => o.eq('slug', slug)) as never)
+            .unique()
+          return { available: !existing } as { available: boolean }
+        }
+      }),
+      membership = q({
+        args: { orgId: zid('org') },
+        handler: async (
+          c: Rec,
+          { orgId }: { orgId: string }
+        ): Promise<null | { memberId: GenericId<'orgMember'> | null; role: OrgRole }> => {
+          const db = c.db as DbLike,
+            orgDoc = await db.get(orgId)
+          if (!orgDoc) return err('NOT_FOUND')
+          const userId = (c.user as Rec)._id as string,
+            member = await getOrgMember({ db, orgId, userId }),
+            role = getOrgRole({ member, org: orgDoc, userId })
+          if (!role) return null
+          return { memberId: ((member as null | Rec)?._id as GenericId<'orgMember'>) ?? null, role }
+        }
+      }),
+      members = q({
+        args: { orgId: zid('org') },
+        handler: async (c: Rec, { orgId }: { orgId: string }): Promise<OrgMemberItem[]> => {
+          const db = c.db as DbLike,
+            userId = (c.user as Rec)._id as string
+          await requireOrgMember({ db, orgId, userId })
+          const orgDoc = await db.get(orgId)
+          if (!orgDoc) return err('NOT_FOUND')
+          const result: OrgMemberItem[] = [],
+            ownerUser = await db.get(orgDoc.userId as string)
+          result.push({
+            role: 'owner',
+            user: ownerUser as null | OrgUserLike,
+            userId: orgDoc.userId as GenericId<'users'>
+          })
+          const memberDocs = await db
+              .query('orgMember')
+              .withIndex('by_org', ((o: IndexLike) => o.eq('orgId', orgId)) as never)
+              .collect(),
+            userDocs = await Promise.all(memberDocs.map(async (x: Rec) => db.get(x.userId as string)))
+          for (let i = 0; i < memberDocs.length; i += 1) {
+            const memberDoc = memberDocs[i],
+              userDoc = userDocs[i]
+            if (memberDoc)
+              result.push({
+                memberId: memberDoc._id as GenericId<'orgMember'>,
+                role: memberDoc.isAdmin ? 'admin' : 'member',
+                user: (userDoc as null | OrgUserLike) ?? null,
+                userId: memberDoc.userId as GenericId<'users'>
+              })
+          }
+          return result
+        }
+      }),
+      setAdmin = m({
+        args: { isAdmin: z.boolean(), memberId: zid('orgMember') },
+        handler: async (c: Rec, { isAdmin, memberId }: { isAdmin: boolean; memberId: string }) => {
+          const db = c.db as DbLike,
+            memberDoc = await db.get(memberId)
+          if (!memberDoc) return err('NOT_FOUND')
+          const orgDoc = await db.get(memberDoc.orgId as string)
+          if (!orgDoc) return err('NOT_FOUND')
+          if (orgDoc.userId !== (c.user as Rec)._id) return err('FORBIDDEN')
+          if (memberDoc.userId === orgDoc.userId) return err('CANNOT_MODIFY_OWNER')
+          await db.patch(memberId, { isAdmin, ...time() })
+        }
+      }),
+      removeMember = m({
+        args: { memberId: zid('orgMember') },
+        handler: async (c: Rec, { memberId }: { memberId: string }) => {
+          const db = c.db as DbLike,
+            memberDoc = await db.get(memberId)
+          if (!memberDoc) return err('NOT_FOUND')
+          const orgDoc = await db.get(memberDoc.orgId as string)
+          if (!orgDoc) return err('NOT_FOUND')
+          if (memberDoc.userId === orgDoc.userId) return err('CANNOT_MODIFY_OWNER')
+          const { role } = await requireOrgRole({
+            db,
+            minRole: 'admin',
+            orgId: memberDoc.orgId as string,
+            userId: (c.user as Rec)._id as string
+          })
+          if (role === 'admin' && memberDoc.isAdmin) return err('CANNOT_MODIFY_ADMIN')
+          await db.delete(memberId)
+        }
+      }),
+      leave = m({
+        args: { orgId: zid('org') },
+        handler: async (c: Rec, { orgId }: { orgId: string }) => {
+          const db = c.db as DbLike,
+            orgDoc = await db.get(orgId)
+          if (!orgDoc) return err('NOT_FOUND')
+          const userId = (c.user as Rec)._id as string
+          if (orgDoc.userId === userId) return err('MUST_TRANSFER_OWNERSHIP')
+          const member = await getOrgMember({ db, orgId, userId })
+          if (!member) return err('NOT_ORG_MEMBER')
+          await db.delete((member as Rec)._id as string)
+        }
+      }),
+      transferOwnership = m({
+        args: { newOwnerId: zid('users'), orgId: zid('org') },
+        handler: async (c: Rec, { newOwnerId, orgId }: { newOwnerId: string; orgId: string }) => {
+          const db = c.db as DbLike,
+            orgDoc = await db.get(orgId)
+          if (!orgDoc) return err('NOT_FOUND')
+          if (orgDoc.userId !== (c.user as Rec)._id) return err('FORBIDDEN')
+          const targetMember = await getOrgMember({ db, orgId, userId: newOwnerId })
+          if (!targetMember) return err('NOT_ORG_MEMBER')
+          if (!(targetMember as Rec).isAdmin) return err('TARGET_MUST_BE_ADMIN')
+          await db.patch(orgId, { userId: newOwnerId, ...time() })
+          await db.delete((targetMember as Rec)._id as string)
+          await db.insert('orgMember', {
+            isAdmin: true,
+            orgId,
+            userId: (c.user as Rec)._id,
+            ...time()
+          })
+        }
+      }),
+      invite = m({
+        args: { email: z.email(), isAdmin: z.boolean(), orgId: zid('org') },
+        handler: async (c: Rec, { email, isAdmin, orgId }: { email: string; isAdmin: boolean; orgId: string }) => {
+          await requireOrgRole({ db: c.db, minRole: 'admin', orgId, userId: (c.user as Rec)._id as string })
+          const token = generateToken(),
+            expiresAt = Date.now() + SEVEN_DAYS_MS,
+            inviteId = await (c.db as DbLike).insert('orgInvite', {
+              email,
+              expiresAt,
+              isAdmin,
+              orgId,
+              token
+            })
+          return { inviteId, token } as { inviteId: GenericId<'orgInvite'>; token: string }
+        }
+      }),
+      acceptInvite = m({
+        args: { token: z.string() },
+        handler: async (c: Rec, { token }: { token: string }) => {
+          const db = c.db as DbLike,
+            userId = (c.user as Rec)._id as string,
+            inviteDoc = await db
+              .query('orgInvite')
+              .withIndex('by_token', ((o: IndexLike) => o.eq('token', token)) as never)
+              .unique()
+          if (!inviteDoc) return err('INVALID_INVITE')
+          if ((inviteDoc.expiresAt as number) < Date.now()) return err('INVITE_EXPIRED')
+          const existingMember = await getOrgMember({ db, orgId: inviteDoc.orgId as string, userId }),
+            orgDoc = await db.get(inviteDoc.orgId as string)
+          if (!orgDoc) return err('NOT_FOUND')
+          if (existingMember || orgDoc.userId === userId) return err('ALREADY_ORG_MEMBER')
+          const pendingRequest = await db
+            .query('orgJoinRequest')
+            .withIndex('by_org_status', ((o: IndexLike) =>
+              o.eq('orgId', inviteDoc.orgId).eq('status', 'pending')) as never)
+            .filter((o: FilterLike) => o.eq(o.field('userId'), userId))
+            .unique()
+          if (pendingRequest) await db.patch(pendingRequest._id as string, { status: 'approved', ...time() })
+          await db.insert('orgMember', {
+            isAdmin: inviteDoc.isAdmin,
+            orgId: inviteDoc.orgId,
+            userId,
+            ...time()
+          })
+          await db.delete(inviteDoc._id as string)
+          return { orgId: inviteDoc.orgId } as { orgId: GenericId<'org'> }
+        }
+      }),
+      revokeInvite = m({
+        args: { inviteId: zid('orgInvite') },
+        handler: async (c: Rec, { inviteId }: { inviteId: string }) => {
+          const db = c.db as DbLike,
+            inviteDoc = await db.get(inviteId)
+          if (!inviteDoc) return err('NOT_FOUND')
+          await requireOrgRole({
+            db,
+            minRole: 'admin',
+            orgId: inviteDoc.orgId as string,
+            userId: (c.user as Rec)._id as string
+          })
+          await db.delete(inviteId)
+        }
+      }),
+      pendingInvites = q({
+        args: { orgId: zid('org') },
+        handler: async (c: Rec, { orgId }: { orgId: string }): Promise<InviteDocLike[]> => {
+          await requireOrgRole({ db: c.db, minRole: 'admin', orgId, userId: (c.user as Rec)._id as string })
+          return (c.db as DbLike)
+            .query('orgInvite')
+            .withIndex('by_org', ((o: IndexLike) => o.eq('orgId', orgId)) as never)
+            .collect() as Promise<InviteDocLike[]>
+        }
+      }),
+      requestJoin = m({
+        args: { message: z.string().optional(), orgId: zid('org') },
+        handler: async (c: Rec, { message, orgId }: { message?: string; orgId: string }) => {
+          const db = c.db as DbLike,
+            userId = (c.user as Rec)._id as string,
+            orgDoc = await db.get(orgId)
+          if (!orgDoc) return err('NOT_FOUND')
+          const existingMember = await getOrgMember({ db, orgId, userId })
+          if (existingMember || orgDoc.userId === userId) return err('ALREADY_ORG_MEMBER')
+          const existingRequest = await db
+            .query('orgJoinRequest')
+            .withIndex('by_org_status', ((o: IndexLike) => o.eq('orgId', orgId).eq('status', 'pending')) as never)
+            .filter((o: FilterLike) => o.eq(o.field('userId'), userId))
+            .unique()
+          if (existingRequest) return err('JOIN_REQUEST_EXISTS')
+          const requestId = await db.insert('orgJoinRequest', {
+            message,
+            orgId,
+            status: 'pending',
+            userId
+          })
+          return { requestId } as { requestId: GenericId<'orgJoinRequest'> }
+        }
+      }),
+      approveJoinRequest = m({
+        args: { isAdmin: z.boolean().optional(), requestId: zid('orgJoinRequest') },
+        handler: async (c: Rec, { isAdmin, requestId }: { isAdmin?: boolean; requestId: string }) => {
+          const db = c.db as DbLike,
+            requestDoc = await db.get(requestId)
+          if (!requestDoc) return err('NOT_FOUND')
+          await requireOrgRole({
+            db,
+            minRole: 'admin',
+            orgId: requestDoc.orgId as string,
+            userId: (c.user as Rec)._id as string
+          })
+          await db.insert('orgMember', {
+            isAdmin: isAdmin ?? false,
+            orgId: requestDoc.orgId,
+            userId: requestDoc.userId,
+            ...time()
+          })
+          await db.patch(requestId, { status: 'approved' })
+        }
+      }),
+      rejectJoinRequest = m({
+        args: { requestId: zid('orgJoinRequest') },
+        handler: async (c: Rec, { requestId }: { requestId: string }) => {
+          const db = c.db as DbLike,
+            requestDoc = await db.get(requestId)
+          if (!requestDoc) return err('NOT_FOUND')
+          await requireOrgRole({
+            db,
+            minRole: 'admin',
+            orgId: requestDoc.orgId as string,
+            userId: (c.user as Rec)._id as string
+          })
+          await db.patch(requestId, { status: 'rejected' })
+        }
+      }),
+      cancelJoinRequest = m({
+        args: { requestId: zid('orgJoinRequest') },
+        handler: async (c: Rec, { requestId }: { requestId: string }) => {
+          const db = c.db as DbLike,
+            requestDoc = await db.get(requestId)
+          if (!requestDoc) return err('NOT_FOUND')
+          if (requestDoc.userId !== (c.user as Rec)._id) return err('FORBIDDEN')
+          if (requestDoc.status !== 'pending') return err('NOT_FOUND')
+          await db.delete(requestId)
+        }
+      }),
+      pendingJoinRequests = q({
+        args: { orgId: zid('org') },
+        handler: async (c: Rec, { orgId }: { orgId: string }): Promise<JoinRequestItem[]> => {
+          const db = c.db as DbLike
+          await requireOrgRole({ db, minRole: 'admin', orgId, userId: (c.user as Rec)._id as string })
+          const requests = await db
+              .query('orgJoinRequest')
+              .withIndex('by_org_status', ((o: IndexLike) => o.eq('orgId', orgId).eq('status', 'pending')) as never)
+              .collect(),
+            users = await Promise.all(requests.map(async (r: Rec) => db.get(r.userId as string))),
+            result: JoinRequestItem[] = []
+          for (let i = 0; i < requests.length; i += 1) {
+            const req = requests[i],
+              usr = users[i]
+            if (req) result.push({ request: req as JoinRequestItem['request'], user: (usr as null | OrgUserLike) ?? null })
+          }
+          return result
+        }
+      }),
+      myJoinRequest = q({
+        args: { orgId: zid('org') },
+        handler: async (c: Rec, { orgId }: { orgId: string }) =>
+          (c.db as DbLike)
+            .query('orgJoinRequest')
+            .withIndex('by_org_status', ((o: IndexLike) => o.eq('orgId', orgId).eq('status', 'pending')) as never)
+            .filter((o: FilterLike) => o.eq(o.field('userId'), (c.user as Rec)._id))
+            .unique() as Promise<null | {
+            _id: GenericId<'orgJoinRequest'>
+            message?: string
+            orgId: GenericId<'org'>
+            status: string
+            userId: GenericId<'users'>
+          }>
+      })
+    return {
+      acceptInvite,
+      approveJoinRequest,
+      cancelJoinRequest,
+      create,
+      get,
+      getBySlug,
+      getPublic,
+      invite,
+      isSlugAvailable,
+      leave,
+      members,
+      membership,
+      myJoinRequest,
+      myOrgs,
+      pendingInvites,
+      pendingJoinRequests,
+      rejectJoinRequest,
+      remove,
+      removeMember,
+      requestJoin,
+      revokeInvite,
+      setAdmin,
+      transferOwnership,
+      update
+    }
+  }
+
+export { makeOrg }
+export type { InviteDocLike, JoinRequestItem, OrgDocLike, OrgMemberItem, OrgUserLike }

package/src/server/schema-helpers.ts

@@ -0,0 +1,107 @@
+import type { ZodObject, ZodRawShape } from 'zod/v4'
+
+import { zodOutputToConvexFields as z2c } from 'convex-helpers/server/zod4'
+import { defineTable } from 'convex/server'
+import { v } from 'convex/values'
+
+const baseTable = <T extends ZodRawShape>(s: ZodObject<T>) =>
+    defineTable({ ...z2c(s.shape), updatedAt: v.optional(v.number()) }),
+  ownedTable = <T extends ZodRawShape>(s: ZodObject<T>) =>
+    defineTable({ ...z2c(s.shape), updatedAt: v.number(), userId: v.id('users') }).index('by_user', ['userId' as never]),
+  orgTable = <T extends ZodRawShape>(s: ZodObject<T>) =>
+    defineTable({
+      ...z2c(s.shape),
+      orgId: v.id('org'),
+      updatedAt: v.number(),
+      userId: v.id('users')
+    })
+      .index('by_org', ['orgId' as never])
+      .index('by_org_user', ['orgId' as never, 'userId' as never]),
+  orgChildTable = <T extends ZodRawShape>(
+    s: ZodObject<T>,
+    parent: {
+      foreignKey: string
+      table: string
+    }
+  ) =>
+    defineTable({
+      ...z2c(s.shape),
+      orgId: v.id('org'),
+      updatedAt: v.number(),
+      userId: v.id('users')
+    })
+      .index('by_org', ['orgId' as never])
+      .index('by_parent', [parent.foreignKey as never]),
+  childTable = <T extends ZodRawShape>(s: ZodObject<T>, indexField: string, indexName?: string) =>
+    defineTable({
+      ...z2c(s.shape),
+      updatedAt: v.number()
+    }).index(indexName ?? `by_${indexField}`, [indexField as never]),
+  orgTables = () => ({
+    org: defineTable({
+      avatarId: v.optional(v.id('_storage')),
+      name: v.string(),
+      slug: v.string(),
+      updatedAt: v.number(),
+      userId: v.id('users')
+    })
+      .index('by_slug', ['slug'])
+      .index('by_user', ['userId']),
+    orgInvite: defineTable({
+      email: v.string(),
+      expiresAt: v.number(),
+      isAdmin: v.boolean(),
+      orgId: v.id('org'),
+      token: v.string()
+    })
+      .index('by_org', ['orgId'])
+      .index('by_token', ['token']),
+    orgJoinRequest: defineTable({
+      message: v.optional(v.string()),
+      orgId: v.id('org'),
+      status: v.union(v.literal('pending'), v.literal('approved'), v.literal('rejected')),
+      userId: v.id('users')
+    })
+      .index('by_org', ['orgId'])
+      .index('by_org_status', ['orgId', 'status'])
+      .index('by_user', ['userId']),
+    orgMember: defineTable({
+      isAdmin: v.boolean(),
+      orgId: v.id('org'),
+      updatedAt: v.number(),
+      userId: v.id('users')
+    })
+      .index('by_org', ['orgId'])
+      .index('by_org_user', ['orgId', 'userId'])
+      .index('by_user', ['userId'])
+  }),
+  uploadTables = () => ({
+    uploadChunk: defineTable({
+      chunkIndex: v.number(),
+      storageId: v.id('_storage'),
+      totalChunks: v.number(),
+      uploadId: v.string(),
+      userId: v.id('users')
+    })
+      .index('by_upload', ['uploadId'])
+      .index('by_user', ['userId']),
+    uploadRateLimit: defineTable({
+      timestamp: v.number(),
+      userId: v.id('users')
+    }).index('by_user', ['userId']),
+    uploadSession: defineTable({
+      completedChunks: v.number(),
+      contentType: v.string(),
+      fileName: v.string(),
+      finalStorageId: v.optional(v.id('_storage')),
+      status: v.union(v.literal('pending'), v.literal('assembling'), v.literal('completed'), v.literal('failed')),
+      totalChunks: v.number(),
+      totalSize: v.number(),
+      uploadId: v.string(),
+      userId: v.id('users')
+    })
+      .index('by_upload_id', ['uploadId'])
+      .index('by_user', ['userId'])
+  })
+
+export { baseTable, childTable, orgChildTable, orgTable, orgTables, ownedTable, uploadTables }