tapimo 0.0.2 → 0.1.0

package/src/db/tables/organizations.ts

@@ -0,0 +1,127 @@
+import type { Selectable } from 'kysely'
+import { nanoid } from 'nanoid'
+
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `organizations` table, derived from `Schema.Organization`. */
+export type Table = db_Schema.Organization
+
+/** A stored organization row. */
+export type Record = Selectable<Table>
+
+/**
+ * Inserts an organization and returns the stored record. The `id` defaults to
+ * a generated `org_…` handle when omitted.
+ *
+ * @param db - The database.
+ * @param input - The organization to insert.
+ * @returns The stored record.
+ */
+export function create(db: Db.Db, input: create.Input): Promise<Record> {
+  const now = new Date().toISOString()
+  return db.kysely
+    .insertInto('organizations')
+    .values({
+      createdAt: now,
+      createdBy: input.createdBy ?? null,
+      id: input.id ?? `org_${nanoid()}`,
+      name: input.name,
+      updatedAt: now,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow()
+}
+
+export declare namespace create {
+  /** Fields accepted when inserting an organization. */
+  type Input = {
+    /** Identity creating the organization (e.g. admin email), recorded for audit. */
+    createdBy?: string | undefined
+    /** Explicit id; a generated `org_…` handle is used when omitted. */
+    id?: string | undefined
+    /** Human-readable organization name. */
+    name: string
+  }
+}
+
+/**
+ * Reads an organization by id.
+ *
+ * @param db - The database.
+ * @param id - The organization id (`org_…`).
+ * @returns The record, or `undefined` when absent.
+ */
+export function get(db: Db.Db, id: string): Promise<Record | undefined> {
+  return db.kysely.selectFrom('organizations').selectAll().where('id', '=', id).executeTakeFirst()
+}
+
+/**
+ * Lists organizations, newest first.
+ *
+ * @param db - The database.
+ * @returns The records.
+ */
+export function list(db: Db.Db): Promise<Record[]> {
+  return db.kysely.selectFrom('organizations').selectAll().orderBy('createdAt', 'desc').execute()
+}
+
+/**
+ * Renames an organization, bumping `updatedAt`.
+ *
+ * @param db - The database.
+ * @param id - The organization id (`org_…`).
+ * @param input - The fields to update.
+ * @returns The updated record, or `undefined` when absent.
+ */
+export function update(db: Db.Db, id: string, input: update.Input): Promise<Record | undefined> {
+  return db.kysely
+    .updateTable('organizations')
+    .set({ name: input.name, updatedAt: new Date().toISOString() })
+    .where('id', '=', id)
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace update {
+  /** Mutable organization fields. */
+  type Input = {
+    /** New human-readable organization name. */
+    name: string
+  }
+}
+
+/**
+ * Inserts an organization when absent (`ON CONFLICT DO NOTHING`) — the
+ * mint/backfill path, where a key's `orgId` must resolve to a real row. The
+ * `name` defaults to the id for degenerate orgs created by the mint fallback.
+ *
+ * @param db - The database.
+ * @param input - The organization to ensure.
+ */
+export async function upsert(db: Db.Db, input: upsert.Input): Promise<void> {
+  const now = new Date().toISOString()
+  await db.kysely
+    .insertInto('organizations')
+    .values({
+      createdAt: now,
+      createdBy: input.createdBy ?? null,
+      id: input.id,
+      name: input.name ?? input.id,
+      updatedAt: now,
+    })
+    .onConflict((oc) => oc.column('id').doNothing())
+    .execute()
+}
+
+export declare namespace upsert {
+  /** Fields accepted when ensuring an organization exists. */
+  type Input = {
+    /** Identity creating the organization, recorded for audit. */
+    createdBy?: string | undefined
+    /** The organization id (`org_…`, or a mint-fallback key id). */
+    id: string
+    /** Human-readable organization name; defaults to the id. */
+    name?: string | undefined
+  }
+}

package/src/db/tables/verifiedTokens.ts

@@ -0,0 +1,111 @@
+import type { Selectable } from 'kysely'
+import type { Hex } from 'ox'
+
+import type * as VerifiedTokens from '../../internal/VerifiedTokens.js'
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `verified_tokens` table, derived from `Schema.VerifiedToken`. */
+export type Table = db_Schema.VerifiedToken
+
+/** Columns of the `verified_token_lists` table, derived from `Schema.VerifiedTokenList`. */
+export type ListTable = db_Schema.VerifiedTokenList
+
+/** A stored verified-token row. */
+export type Row = Selectable<Table>
+
+/** A chain's list-level metadata. */
+export type Meta = Selectable<ListTable>
+
+/**
+ * Reads a chain's list metadata — the "head" the soft-refresh cache compares
+ * versions against.
+ *
+ * @param db - The database.
+ * @param chainId - The chain id.
+ * @returns The metadata, or `undefined` when the chain has no list yet.
+ */
+export function head(db: Db.Db, chainId: number): Promise<Meta | undefined> {
+  return db.kysely
+    .selectFrom('verified_token_lists')
+    .selectAll()
+    .where('chainId', '=', chainId)
+    .executeTakeFirst()
+}
+
+/**
+ * Reads a chain's tokens in canonical list order.
+ *
+ * @param db - The database.
+ * @param chainId - The chain id.
+ * @returns The rows.
+ */
+export function list(db: Db.Db, chainId: number): Promise<Row[]> {
+  return db.kysely
+    .selectFrom('verified_tokens')
+    .selectAll()
+    .where('chainId', '=', chainId)
+    .orderBy('position')
+    .execute()
+}
+
+/**
+ * Publishes a chain's whole list: replaces its token rows (positions rewritten
+ * wholesale) and bumps the list metadata. Callers run this inside the
+ * per-chain publish lock/transaction, so the rewrite is atomic.
+ *
+ * @param db - The database (a transaction-scoped handle).
+ * @param chainId - The chain id.
+ * @param input - The validated list and its new version metadata.
+ */
+export async function publish(db: Db.Db, chainId: number, input: publish.Input): Promise<void> {
+  await db.kysely.deleteFrom('verified_tokens').where('chainId', '=', chainId).execute()
+  if (input.tokens.length > 0)
+    await db.kysely
+      .insertInto('verified_tokens')
+      .values(
+        input.tokens.map((token, position) => ({
+          address: token.address,
+          chainId,
+          currency: token.currency,
+          decimals: token.decimals,
+          logoUri: token.logoUri ?? null,
+          name: token.name,
+          position,
+          symbol: token.symbol,
+        })),
+      )
+      .execute()
+  await db.kysely
+    .insertInto('verified_token_lists')
+    .values({ chainId, updatedAt: input.updatedAt, version: input.version })
+    .onConflict((oc) =>
+      oc.column('chainId').doUpdateSet({ updatedAt: input.updatedAt, version: input.version }),
+    )
+    .execute()
+}
+
+export declare namespace publish {
+  /** A validated list to publish. */
+  type Input = {
+    /** Tokens in canonical order (addresses lowercased by the domain layer). */
+    tokens: readonly VerifiedTokens.Token[]
+    /** ISO timestamp of the publish. */
+    updatedAt: string
+    /** New opaque list version. */
+    version: string
+  }
+}
+
+/** Maps a stored row to the domain token (null `logoUri` → absent field). */
+export function toToken(row: Row): VerifiedTokens.Token {
+  return {
+    address: row.address as Hex.Hex,
+    currency: row.currency,
+    decimals: row.decimals,
+    id: row.address as Hex.Hex,
+    name: row.name,
+    symbol: row.symbol,
+    ...(row.logoUri === null ? {} : { logoUri: row.logoUri }),
+  }
+}

package/src/db/tables/webhookDeliveries.ts

@@ -0,0 +1,159 @@
+import type { Selectable } from 'kysely'
+
+import type * as Webhooks from '../../internal/Webhooks.js'
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `webhook_deliveries` table, derived from `Schema.WebhookDelivery`. */
+export type Table = db_Schema.WebhookDelivery
+
+/** A stored webhook-delivery row. */
+export type Record = Selectable<Table>
+
+/** Maps a stored row to the domain delivery (null columns → absent fields). */
+export function toDelivery(row: Record): Webhooks.Delivery {
+  return {
+    attempt: row.attempt,
+    createdAt: row.createdAt,
+    envelope: row.envelope,
+    ...(row.error === null ? {} : { error: row.error }),
+    eventId: row.eventId,
+    id: row.id,
+    requestUrl: row.requestUrl,
+    ...(row.responseMs === null ? {} : { responseMs: row.responseMs }),
+    ...(row.responseStatus === null ? {} : { responseStatus: row.responseStatus }),
+    status: row.status,
+    subscriptionId: row.subscriptionId,
+  }
+}
+
+/**
+ * Inserts a delivery row from its domain value.
+ *
+ * @param db - The database.
+ * @param delivery - The delivery to insert.
+ * @param expiresAt - Retention deadline (ISO); the row is invisible past it.
+ */
+export async function insert(
+  db: Db.Db,
+  delivery: Webhooks.Delivery,
+  expiresAt: string,
+): Promise<void> {
+  await db.kysely
+    .insertInto('webhook_deliveries')
+    .values({
+      attempt: delivery.attempt,
+      createdAt: delivery.createdAt,
+      envelope: delivery.envelope,
+      error: delivery.error ?? null,
+      eventId: delivery.eventId,
+      expiresAt,
+      id: delivery.id,
+      requestUrl: delivery.requestUrl,
+      responseMs: delivery.responseMs ?? null,
+      responseStatus: delivery.responseStatus ?? null,
+      status: delivery.status,
+      subscriptionId: delivery.subscriptionId,
+    })
+    .execute()
+}
+
+/**
+ * Lists a subscription's unexpired deliveries, newest first, with keyset
+ * paging (`id < cursor` — ids embed a zero-padded timestamp, so lexical order
+ * is chronological).
+ *
+ * @param db - The database.
+ * @param subscriptionId - The owning subscription id (`wh_…`).
+ * @param options - Paging options plus the retention timestamp.
+ * @returns The deliveries.
+ */
+export async function list(
+  db: Db.Db,
+  subscriptionId: string,
+  options: list.Options,
+): Promise<Webhooks.Delivery[]> {
+  let query = db.kysely
+    .selectFrom('webhook_deliveries')
+    .selectAll()
+    .where('subscriptionId', '=', subscriptionId)
+    .where('expiresAt', '>', options.now)
+    .orderBy('id', 'desc')
+  if (options.cursor) query = query.where('id', '<', options.cursor)
+  if (options.offset) query = query.offset(options.offset)
+  if (options.limit !== undefined) query = query.limit(options.limit)
+  return (await query.execute()).map(toDelivery)
+}
+
+export declare namespace list {
+  /** Options for {@link list}. */
+  type Options = {
+    /** Return deliveries whose id sorts before this one (older entries). */
+    cursor?: string | undefined
+    /** Maximum deliveries to return. */
+    limit?: number | undefined
+    /** ISO timestamp retention is evaluated against. */
+    now: string
+    /** Rows to skip from the head (positional pagination; exclusive with `cursor`). */
+    offset?: number | undefined
+  }
+}
+
+/**
+ * Counts a subscription's unexpired deliveries.
+ *
+ * @param db - The database.
+ * @param subscriptionId - The owning subscription id (`wh_…`).
+ * @param now - ISO timestamp retention is evaluated against.
+ * @returns The count.
+ */
+export async function count(db: Db.Db, subscriptionId: string, now: string): Promise<number> {
+  const row = await db.kysely
+    .selectFrom('webhook_deliveries')
+    .select((eb) => eb.fn.countAll().as('count'))
+    .where('subscriptionId', '=', subscriptionId)
+    .where('expiresAt', '>', now)
+    .executeTakeFirstOrThrow()
+  return Number(row.count)
+}
+
+/**
+ * Reads a single unexpired delivery scoped to its subscription.
+ *
+ * @param db - The database.
+ * @param subscriptionId - The owning subscription id (`wh_…`).
+ * @param deliveryId - The delivery id (`whd_…`).
+ * @param now - ISO timestamp retention is evaluated against.
+ * @returns The delivery, or `null` when absent.
+ */
+export async function get(
+  db: Db.Db,
+  subscriptionId: string,
+  deliveryId: string,
+  now: string,
+): Promise<Webhooks.Delivery | null> {
+  const row = await db.kysely
+    .selectFrom('webhook_deliveries')
+    .selectAll()
+    .where('subscriptionId', '=', subscriptionId)
+    .where('id', '=', deliveryId)
+    .where('expiresAt', '>', now)
+    .executeTakeFirst()
+  return row ? toDelivery(row) : null
+}
+
+/**
+ * Deletes deliveries past their retention deadline. Called best-effort from
+ * the poller tick.
+ *
+ * @param db - The database.
+ * @param now - ISO timestamp retention is evaluated against.
+ * @returns The number of rows deleted.
+ */
+export async function pruneExpired(db: Db.Db, now: string): Promise<number> {
+  const result = await db.kysely
+    .deleteFrom('webhook_deliveries')
+    .where('expiresAt', '<=', now)
+    .executeTakeFirst()
+  return Number(result.numDeletedRows)
+}