lazyconvex 0.0.0

package/src/server/setup.ts

@@ -0,0 +1,138 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */
+import type { GenericDataModel, GenericMutationCtx, GenericQueryCtx } from 'convex/server'
+import type { ZodObject, ZodRawShape } from 'zod/v4'
+
+import { customCtx } from 'convex-helpers/server/customFunctions'
+import { zCustomMutation, zCustomQuery } from 'convex-helpers/server/zod4'
+
+import type { OrgCrudOptions } from './org-crud'
+import type { CrudOptions, DbLike, Mb, Qb, Rec, SetupConfig } from './types'
+
+import { makeCacheCrud } from './cache-crud'
+import { makeChildCrud } from './child'
+import { makeCrud } from './crud'
+import { dbInsert, dbPatch } from './db'
+import { err, getUser, ownGet, readCtx, time } from './helpers'
+import { makeOrg } from './org'
+import { makeOrgCrud } from './org-crud'
+import { makeUnique } from './unique'
+
+const setup = <DM extends GenericDataModel>(config: SetupConfig<DM>) => {
+  type QCtx = GenericQueryCtx<DM>
+  type MCtx = GenericMutationCtx<DM>
+  const { getAuthUserId } = config,
+    authId = async (c: unknown) => getAuthUserId(c as never),
+    asDb = (c: { db: unknown }) => c.db as never as DbLike,
+    pq = zCustomQuery(
+      config.query,
+      customCtx(async (c: QCtx) => {
+        const vid = await authId(c),
+          { withAuthor } = readCtx({ db: asDb(c), storage: c.storage as never, viewerId: vid })
+        return { viewerId: vid, withAuthor }
+      })
+    ),
+    q = zCustomQuery(
+      config.query,
+      customCtx(async (c: QCtx) => {
+        const db = asDb(c),
+          user = await getUser({ ctx: c as never, db, getAuthUserId }),
+          { viewerId, withAuthor } = readCtx({ db, storage: c.storage as never, viewerId: user._id })
+        return {
+          get: ownGet(db, user._id),
+          user,
+          viewerId,
+          withAuthor
+        }
+      })
+    ),
+    m = zCustomMutation(
+      config.mutation,
+      customCtx(async (c: MCtx) => {
+        const db = asDb(c),
+          now = time(),
+          user = await getUser({ ctx: c as never, db, getAuthUserId }),
+          get = ownGet(db, user._id)
+        return {
+          create: async (t: string, d: Rec) => dbInsert(db, t, { ...d, ...now, userId: user._id }),
+          delete: async (id: string) => {
+            const d = await get(id)
+            await db.delete(id)
+            return d
+          },
+          get,
+          patch: async (
+            id: string,
+            data: ((doc: Rec) => Partial<Rec> | Promise<Partial<Rec>>) | Partial<Rec>,
+            expectedUpdatedAt?: number
+          ) => {
+            const doc = await get(id)
+            if (expectedUpdatedAt !== undefined && doc.updatedAt !== expectedUpdatedAt) return err('CONFLICT')
+            const up = typeof data === 'function' ? await data(doc) : data
+            await dbPatch(db, id, { ...up, ...now })
+            return { ...doc, ...up, ...now }
+          },
+          user
+        }
+      })
+    ),
+    cq = zCustomQuery(
+      config.query,
+      customCtx(() => ({}))
+    ),
+    cm = zCustomMutation(
+      config.mutation,
+      customCtx(() => ({}))
+    ),
+    children = config.children ?? {},
+    crud = <S extends ZodRawShape>(table: string, schema: ZodObject<S>, opt?: CrudOptions<S>) =>
+      makeCrud({
+        builders: { children, cm, cq, m: m as never as Mb, pq: pq as never as Qb, q: q as never as Qb },
+        options: opt,
+        schema,
+        table
+      }),
+    childCrud = <S extends ZodRawShape>(
+      table: string,
+      meta: { foreignKey: string; index: string; parent: string; schema: ZodObject<S> }
+    ) => makeChildCrud({ builders: { m: m as never as Mb, q: q as never as Qb }, meta, table }),
+    orgCrud = <S extends ZodRawShape>(table: string, schema: ZodObject<S>, opt?: Rec) =>
+      makeOrgCrud({
+        builders: { m: m as never as Mb, q: q as never as Qb },
+        options: opt as OrgCrudOptions | undefined,
+        schema,
+        table
+      }),
+    cacheCrud = <S extends ZodRawShape, K extends keyof Rec>(opts: {
+      fetcher?: (c: unknown, key: unknown) => Promise<unknown>
+      key: K
+      schema: ZodObject<S>
+      table: string
+      ttl?: number
+    }) =>
+      makeCacheCrud({
+        ...opts,
+        builders: {
+          action: config.action,
+          cm,
+          cq,
+          internalMutation: config.internalMutation,
+          internalQuery: config.internalQuery,
+          mutation: config.mutation,
+          query: config.query
+        }
+      }),
+    uniqueCheck = (table: string, field: string) => makeUnique({ field, pq: pq as never as Qb, table }),
+    org = config.orgSchema
+      ? makeOrg({
+          cascadeTables: config.orgCascadeTables,
+          getAuthUserId: config.getAuthUserId,
+          mutation: config.mutation,
+          query: config.query,
+          schema: config.orgSchema
+        })
+      : undefined,
+    user = { me: q({ handler: (c: Rec) => c.user }) }
+  return { cacheCrud, childCrud, cm, cq, crud, m, org, orgCrud, pq, q, uniqueCheck, user }
+}
+
+export { setup }

package/src/server/test-crud.ts

@@ -0,0 +1,211 @@
+/* eslint-disable no-await-in-loop, max-depth, max-statements, @typescript-eslint/max-params, @typescript-eslint/prefer-nullish-coalescing */
+/** biome-ignore-all lint/performance/noAwaitInLoops: sequential deletes */
+import type { GenericDataModel, MutationBuilder, QueryBuilder } from 'convex/server'
+
+import { v } from 'convex/values'
+
+import type { DbLike, IndexLike, Rec } from './types'
+
+import { isTestMode } from './test'
+
+interface OrgTestCrudConfig<DM extends GenericDataModel = GenericDataModel> {
+  acl?: boolean
+  aclFrom?: { field: string; table: string }
+  cascade?: { foreignKey: string; table: string }[]
+  mutation: MutationBuilder<DM, 'public'>
+  query: QueryBuilder<DM, 'public'>
+  table: string
+}
+
+const 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 }
+  },
+  checkAclPermission = (doc: Rec, userId: string, membership: { isAdmin: boolean }) => {
+    const isCreator = doc.userId === userId,
+      editors = (doc.editors ?? []) as string[],
+      isEditor = editors.includes(userId)
+    return isCreator || membership.isAdmin || isEditor
+  },
+  checkChildAclPermission = async (
+    db: DbLike,
+    doc: Rec,
+    parentField: string,
+    userId: string,
+    membership: { isAdmin: boolean }
+  ) => {
+    const isCreator = doc.userId === userId
+    if (isCreator || membership.isAdmin) return true
+    const parentId = doc[parentField] as string,
+      parent = parentId ? await db.get(parentId) : null,
+      editors = parent ? ((parent.editors ?? []) as string[]) : []
+    return editors.some(eid => eid === userId)
+  },
+  addEditorToDoc = async (db: DbLike, itemId: string, editorId: string, orgId: string) => {
+    const doc = await db.get(itemId)
+    if (doc?.orgId !== orgId) return { code: 'NOT_FOUND' }
+    const editors = (doc.editors ?? []) as string[],
+      alreadyEditor = editors.some((id: string) => id === editorId)
+    if (alreadyEditor) return doc
+    await db.patch(itemId, { editors: [...editors, editorId], updatedAt: Date.now() })
+    return db.get(itemId)
+  },
+  removeEditorFromDoc = async (db: DbLike, itemId: string, editorId: string, orgId: string) => {
+    const doc = await db.get(itemId)
+    if (doc?.orgId !== orgId) return { code: 'NOT_FOUND' }
+    const editors = (doc.editors ?? []) as string[],
+      filtered: string[] = []
+    for (const id of editors) if (id !== editorId) filtered.push(id)
+    await db.patch(itemId, { editors: filtered, updatedAt: Date.now() })
+    return db.get(itemId)
+  },
+  makeOrgTestCrud = <DM extends GenericDataModel>(config: OrgTestCrudConfig<DM>) => {
+    const { acl, aclFrom, cascade, mutation: rawMut, query: rawQry, table } = config,
+      mutation = rawMut as unknown as (opts: Rec) => Rec,
+      query = rawQry as unknown as (opts: Rec) => Rec,
+      hasAcl = acl || Boolean(aclFrom),
+      createAsUser = mutation({
+        /** biome-ignore lint/suspicious/noExplicitAny: test generic */
+        args: { data: v.any(), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { data, orgId, userId }: { data: Rec; orgId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const membership = await getOrgMembership(ctx.db, orgId, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          return ctx.db.insert(table, { ...data, orgId, updatedAt: Date.now(), userId })
+        }
+      }),
+      updateAsUser = mutation({
+        /** biome-ignore lint/suspicious/noExplicitAny: test generic */
+        args: { data: v.any(), id: v.string(), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { data, id, orgId, userId }: { data: Rec; id: string; orgId: string; userId: string }
+        ) => {
+          if (!isTestMode()) return null
+          const doc = await ctx.db.get(id)
+          if (doc?.orgId !== orgId) return { code: 'NOT_FOUND' }
+          const membership = await getOrgMembership(ctx.db, orgId, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (hasAcl) {
+            const permitted = aclFrom
+              ? await checkChildAclPermission(ctx.db, doc, aclFrom.field, userId, membership)
+              : checkAclPermission(doc, userId, membership)
+            if (!permitted) return { code: 'FORBIDDEN' }
+          }
+          await ctx.db.patch(id, { ...data, updatedAt: Date.now() })
+          return { success: true }
+        }
+      }),
+      rmAsUser = mutation({
+        args: { id: v.string(), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { id, orgId, userId }: { id: string; orgId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const doc = await ctx.db.get(id)
+          if (doc?.orgId !== orgId) return { code: 'NOT_FOUND' }
+          const membership = await getOrgMembership(ctx.db, orgId, userId)
+          if (!membership) return { code: 'NOT_ORG_MEMBER' }
+          if (hasAcl) {
+            const permitted = aclFrom
+              ? await checkChildAclPermission(ctx.db, doc, aclFrom.field, userId, membership)
+              : checkAclPermission(doc, userId, membership)
+            if (!permitted) return { code: 'FORBIDDEN' }
+          }
+          if (cascade)
+            for (const { foreignKey, table: childTable } of cascade) {
+              const children = await ctx.db
+                .query(childTable)
+                .withIndex('by_parent', ((q: IndexLike) => q.eq(foreignKey, id)) as never)
+                .collect()
+              for (const c of children) await ctx.db.delete(c._id as string)
+            }
+
+          await ctx.db.delete(id)
+          return { success: true }
+        }
+      }),
+      bulkRmAsUser = mutation({
+        args: { ids: v.array(v.string()), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (ctx: { db: DbLike }, { ids, orgId, userId }: { ids: string[]; orgId: string; userId: string }) => {
+          if (!isTestMode()) return null
+          const orgDoc = await ctx.db.get(orgId)
+          if (!orgDoc) return { code: 'NOT_FOUND' }
+          const isOwner = orgDoc.userId === userId,
+            member = await ctx.db
+              .query('orgMember')
+              .withIndex('by_org_user', ((q: IndexLike) => q.eq('orgId', orgId).eq('userId', userId)) as never)
+              .unique()
+          if (!(isOwner || member)) return { code: 'NOT_ORG_MEMBER' }
+          if (!(isOwner || member?.isAdmin)) return { code: 'INSUFFICIENT_ORG_ROLE' }
+          let count = 0
+          for (const id of ids) {
+            const doc = await ctx.db.get(id)
+            if (doc?.orgId === orgId) {
+              if (cascade)
+                for (const { foreignKey, table: childTable } of cascade) {
+                  const children = await ctx.db
+                    .query(childTable)
+                    .withIndex('by_parent', ((q: IndexLike) => q.eq(foreignKey, id)) as never)
+                    .collect()
+                  for (const c of children) await ctx.db.delete(c._id as string)
+                }
+
+              await ctx.db.delete(id)
+              count += 1
+            }
+          }
+          return { count }
+        }
+      }),
+      listAsUser = 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' }
+          return ctx.db
+            .query(table)
+            .withIndex('by_org', ((q: IndexLike) => q.eq('orgId', orgId)) as never)
+            .collect()
+        }
+      }),
+      result: Rec = { bulkRmAsUser, createAsUser, listAsUser, rmAsUser, updateAsUser }
+    if (hasAcl) {
+      result.addEditorAsUser = mutation({
+        args: { editorId: v.id('users'), itemId: v.string(), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { editorId, itemId, orgId, userId }: { editorId: string; itemId: 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' }
+          return addEditorToDoc(ctx.db, itemId, editorId, orgId)
+        }
+      })
+      result.removeEditorAsUser = mutation({
+        args: { editorId: v.id('users'), itemId: v.string(), orgId: v.id('org'), userId: v.id('users') },
+        handler: async (
+          ctx: { db: DbLike },
+          { editorId, itemId, orgId, userId }: { editorId: string; itemId: 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' }
+          return removeEditorFromDoc(ctx.db, itemId, editorId, orgId)
+        }
+      })
+    }
+    return result
+  }
+
+export type { OrgTestCrudConfig }
+export { getOrgMembership, makeOrgTestCrud }