tapimo 0.4.3 → 0.5.0

package/src/db/Schema.ts

@@ -81,6 +81,45 @@ export const Invitation = z.object({
 /** Columns of the `invitations` table. */
 export type Invitation = z.output<typeof Invitation>
 
+/** A reusable bearer link granting organization membership. */
+export const InviteLink = z.object({
+  createdAt: z.string().check(z.describe('When the link was created (ISO 8601).')),
+  createdBy: z.string().check(z.describe('User id that created the link, or `super_admin`.')),
+  deletedAt: z.nullable(z.string()).check(z.describe('When the link was soft deleted, or null.')),
+  enabled: z.boolean().check(z.describe('Whether the link is enabled.')),
+  expiresAt: z.nullable(z.string()).check(z.describe('When the link expires, or null.')),
+  id: z.string().check(z.describe('Opaque invite-link resource id (`iln_…`).')),
+  lastUsedAt: z
+    .nullable(z.string())
+    .check(z.describe('When the link last created a membership, or null.')),
+  maxUses: z
+    .nullable(z.number().check(z.int(), z.positive()))
+    .check(z.describe('Maximum redemptions, or null.')),
+  name: z.string().check(z.describe('Link name.')),
+  orgId: z.string().check(z.describe('Organization id (`org_…`).')),
+  role: z.literal('member').check(z.describe('Non-privileged role granted by the link.')),
+  token: z.string().check(z.describe('Opaque invite-link bearer token (`lnk_…`).')),
+  updatedAt: z.string().check(z.describe('When the link was last changed (ISO 8601).')),
+  useCount: z.number().check(z.int(), z.nonnegative(), z.describe('Successful redemption count.')),
+})
+
+/** Columns of the `invite_links` table. */
+export type InviteLink = z.output<typeof InviteLink>
+
+/** An audit record for one membership created through an invite link. */
+export const InviteLinkRedemption = z.object({
+  createdAt: z.string().check(z.describe('When the link was redeemed (ISO 8601).')),
+  email: z.string().check(z.describe('Verified email used for redemption.')),
+  id: z.string().check(z.describe('Opaque redemption id (`ilr_…`).')),
+  inviteLinkId: z.string().check(z.describe('Invite-link id.')),
+  inviteLinkName: z.string().check(z.describe('Invite-link name at redemption time.')),
+  orgId: z.string().check(z.describe('Organization id.')),
+  userId: z.string().check(z.describe('Redeeming user id.')),
+})
+
+/** Columns of the `invite_link_redemptions` table. */
+export type InviteLinkRedemption = z.output<typeof InviteLinkRedemption>
+
 /** A user's role within an organization. */
 export const Membership = z.object({
   createdAt: z.string().check(z.describe('When the membership was created (ISO 8601).')),

package/src/db/tables/inviteLinks.ts

@@ -0,0 +1,187 @@
+import type { Selectable } from 'kysely'
+
+import * as Id from '../../internal/Id.js'
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `invite_links` table. */
+export type Table = db_Schema.InviteLink
+/** Columns of the `invite_link_redemptions` table. */
+export type RedemptionTable = db_Schema.InviteLinkRedemption
+/** A stored invite link. */
+export type Record = Selectable<Table>
+/** A stored redemption. */
+export type Redemption = Selectable<RedemptionTable>
+/** Derived link availability. */
+export type Status = 'active' | 'deleted' | 'disabled' | 'exhausted' | 'expired'
+
+/** Derives current availability from persisted controls and count. */
+export function status(record: Record, now = new Date().toISOString()): Status {
+  if (record.deletedAt) return 'deleted'
+  if (!record.enabled) return 'disabled'
+  if (record.expiresAt && record.expiresAt <= now) return 'expired'
+  if (record.maxUses !== null && record.useCount >= record.maxUses) return 'exhausted'
+  return 'active'
+}
+
+/** Creates a reusable invite link. */
+export function create(
+  db: Db.Db,
+  input: {
+    createdBy: string
+    expiresAt: string | null
+    maxUses: number | null
+    name?: string | undefined
+    orgId: string
+    role: 'member'
+  },
+): Promise<Record> {
+  const now = new Date().toISOString()
+  return db.kysely
+    .insertInto('invite_links')
+    .values({
+      createdAt: now,
+      createdBy: input.createdBy,
+      deletedAt: null,
+      enabled: true,
+      expiresAt: input.expiresAt,
+      id: Id.generate('iln'),
+      lastUsedAt: null,
+      maxUses: input.maxUses,
+      name: input.name ?? 'Untitled link',
+      orgId: input.orgId,
+      role: input.role,
+      token: Id.generate('lnk'),
+      updatedAt: now,
+      useCount: 0,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow()
+}
+
+/** Lists non-deleted links in an organization. */
+export function list(db: Db.Db, orgId: string): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('invite_links')
+    .selectAll()
+    .where('orgId', '=', orgId)
+    .where('deletedAt', 'is', null)
+    .orderBy('createdAt', 'desc')
+    .execute()
+}
+
+/** Gets an invite link by its management id, including deleted links. */
+export function get(db: Db.Db, id: string): Promise<Record | undefined> {
+  return db.kysely.selectFrom('invite_links').selectAll().where('id', '=', id).executeTakeFirst()
+}
+
+/** Gets an invite link by its bearer token, including deleted links. */
+export function getByToken(db: Db.Db, token: string): Promise<Record | undefined> {
+  return db.kysely
+    .selectFrom('invite_links')
+    .selectAll()
+    .where('token', '=', token)
+    .executeTakeFirst()
+}
+
+/** Updates an org-scoped non-deleted link. */
+export function update(
+  db: Db.Db,
+  orgId: string,
+  id: string,
+  enabled: boolean,
+): Promise<Record | undefined> {
+  return db.kysely
+    .updateTable('invite_links')
+    .set({ enabled, updatedAt: new Date().toISOString() })
+    .where('id', '=', id)
+    .where('orgId', '=', orgId)
+    .where('deletedAt', 'is', null)
+    .returningAll()
+    .executeTakeFirst()
+}
+
+/** Soft deletes an org-scoped link. */
+export function remove(db: Db.Db, orgId: string, id: string): Promise<Record | undefined> {
+  const now = new Date().toISOString()
+  return db.kysely
+    .updateTable('invite_links')
+    .set({ deletedAt: now, updatedAt: now })
+    .where('id', '=', id)
+    .where('orgId', '=', orgId)
+    .where('deletedAt', 'is', null)
+    .returningAll()
+    .executeTakeFirst()
+}
+
+/** Lists redemption audit records, newest first. */
+export function listRedemptions(
+  db: Db.Db,
+  orgId: string,
+  inviteLinkId: string,
+): Promise<Redemption[]> {
+  return db.kysely
+    .selectFrom('invite_link_redemptions')
+    .selectAll()
+    .where('orgId', '=', orgId)
+    .where('inviteLinkId', '=', inviteLinkId)
+    .orderBy('createdAt', 'desc')
+    .execute()
+}
+
+/** Atomically joins through an active link, consuming only a newly inserted membership. */
+export function accept(
+  db: Db.Db,
+  token: string,
+  userId: string,
+  email: string,
+): Promise<{ link: Record; consumed: boolean } | undefined> {
+  return db.kysely.transaction().execute(async (trx) => {
+    const now = new Date().toISOString()
+    const link = await trx
+      .selectFrom('invite_links')
+      .selectAll()
+      .where('token', '=', token)
+      .forUpdate()
+      .executeTakeFirst()
+    if (!link) return undefined
+    // Existing membership is already the desired end state, so retries remain
+    // successful after the link becomes unavailable and never consume capacity.
+    const existing = await trx
+      .selectFrom('memberships')
+      .select('userId')
+      .where('orgId', '=', link.orgId)
+      .where('userId', '=', userId)
+      .executeTakeFirst()
+    if (existing) return { consumed: false, link }
+    if (status(link, now) !== 'active') return undefined
+    const inserted = await trx
+      .insertInto('memberships')
+      .values({ createdAt: now, orgId: link.orgId, role: 'member', updatedAt: now, userId })
+      .onConflict((oc) => oc.columns(['orgId', 'userId']).doNothing())
+      .returning('userId')
+      .executeTakeFirst()
+    if (!inserted) return { consumed: false, link }
+    await trx
+      .updateTable('invite_links')
+      .set({ lastUsedAt: now, updatedAt: now, useCount: link.useCount + 1 })
+      .where('id', '=', link.id)
+      .execute()
+    await trx
+      .insertInto('invite_link_redemptions')
+      .values({
+        createdAt: now,
+        email: email.toLowerCase(),
+        id: Id.generate('ilr'),
+        inviteLinkId: link.id,
+        inviteLinkName: link.name,
+        orgId: link.orgId,
+        userId,
+      })
+      .execute()
+    return {
+      consumed: true,
+      link: { ...link, lastUsedAt: now, updatedAt: now, useCount: link.useCount + 1 },
+    }
+  })
+}

package/src/db/tables/organizations.ts

@@ -112,6 +112,8 @@ export function deleteOrganization(db: Db.Db, id: string): Promise<boolean> {
       .execute()
     await trx.deleteFrom('billing_settings').where('orgId', '=', id).execute()
     await trx.deleteFrom('invitations').where('orgId', '=', id).execute()
+    await trx.deleteFrom('invite_link_redemptions').where('orgId', '=', id).execute()
+    await trx.deleteFrom('invite_links').where('orgId', '=', id).execute()
     await trx.deleteFrom('memberships').where('orgId', '=', id).execute()
     await trx.deleteFrom('projects').where('orgId', '=', id).execute()
     await trx.deleteFrom('request_usage_buckets').where('orgId', '=', id).execute()

package/src/handlers/relay.ts

@@ -116,15 +116,27 @@ export function relay(options: relay.Options = {}): Handler {
   ) {
     await onRequest?.(request)
 
-    // Resolve chainId from: 1) explicit option (URL path), 2) first param object, 3) default chain.
     const params = 'params' in request && Array.isArray(request.params) ? request.params : []
     const first =
       typeof params[0] === 'object' && params[0]
         ? (params[0] as Record<string, unknown>)
         : undefined
-    const chainId =
-      Utils.resolveChainId(first?.['chainId']) ?? options?.chainId ?? getClient().chain?.id
-    const client = getClient(chainId)
+    const chainId_body = Utils.resolveChainId(first?.['chainId'])
+    const chainId_path = options?.chainId
+    if (chainId_body !== undefined && chainId_path !== undefined && chainId_body !== chainId_path)
+      return Utils.rpcErrorJson(
+        request,
+        new RpcResponse.InvalidParamsError({ message: 'Conflicting chain ids.' }),
+      )
+
+    let chainId: number | undefined
+    let client: Client
+    try {
+      chainId = chainId_path ?? chainId_body ?? getClient().chain?.id
+      client = getClient(chainId)
+    } catch (error) {
+      return Utils.rpcErrorJson(request, error)
+    }
 
     switch (request.method) {
       case 'eth_fillTransaction': {