tapimo 0.1.0 → 0.3.0

package/src/db/tables/organizations.ts

@@ -1,8 +1,9 @@
 import type { Selectable } from 'kysely'
-import { nanoid } from 'nanoid'
 
+import * as Id from '../../internal/Id.js'
 import type * as Db from '../Db.js'
 import type * as db_Schema from '../Schema.js'
+import type * as Memberships from './memberships.js'
 
 /** Columns of the `organizations` table, derived from `Schema.Organization`. */
 export type Table = db_Schema.Organization
@@ -25,9 +26,10 @@ export function create(db: Db.Db, input: create.Input): Promise<Record> {
     .values({
       createdAt: now,
       createdBy: input.createdBy ?? null,
-      id: input.id ?? `org_${nanoid()}`,
+      id: input.id ?? Id.generate('org'),
       name: input.name,
       updatedAt: now,
+      userId: input.userId ?? null,
     })
     .returningAll()
     .executeTakeFirstOrThrow()
@@ -42,9 +44,84 @@ export declare namespace create {
     id?: string | undefined
     /** Human-readable organization name. */
     name: string
+    /** Owning user id (`usr_…`); null for organizations created by the super admin. */
+    userId?: string | undefined
   }
 }
 
+/**
+ * Inserts an organization owned by `userId` — the org row plus its `owner`
+ * membership, atomically.
+ *
+ * @param db - The database.
+ * @param input - The organization to insert.
+ * @returns The stored record.
+ */
+export function createOwned(db: Db.Db, input: createOwned.Input): Promise<Record> {
+  const now = new Date().toISOString()
+  return db.kysely.transaction().execute(async (trx) => {
+    const record = await trx
+      .insertInto('organizations')
+      .values({
+        createdAt: now,
+        createdBy: input.userId,
+        id: Id.generate('org'),
+        name: input.name,
+        updatedAt: now,
+        userId: input.userId,
+      })
+      .returningAll()
+      .executeTakeFirstOrThrow()
+    await trx
+      .insertInto('memberships')
+      .values({
+        createdAt: now,
+        orgId: record.id,
+        role: 'owner',
+        updatedAt: now,
+        userId: input.userId,
+      })
+      .execute()
+    return record
+  })
+}
+
+export declare namespace createOwned {
+  /** Fields accepted when inserting a user-owned organization. */
+  type Input = {
+    /** Human-readable organization name. */
+    name: string
+    /** Owning user id (`usr_…`), granted the `owner` membership. */
+    userId: string
+  }
+}
+
+/**
+ * Deletes an organization and its owned rows atomically.
+ *
+ * @param db - The database.
+ * @param id - The organization id (`org_…`).
+ * @returns Whether the organization existed and was deleted.
+ */
+export function deleteOrganization(db: Db.Db, id: string): Promise<boolean> {
+  return db.kysely.transaction().execute(async (trx) => {
+    await trx
+      .deleteFrom('webhook_subscriptions')
+      .where('ownerType', '=', 'api_key')
+      .where('ownerId', '=', id)
+      .execute()
+    await trx.deleteFrom('billing_settings').where('orgId', '=', id).execute()
+    await trx.deleteFrom('invitations').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()
+    await trx.deleteFrom('request_usage_meter_events').where('orgId', '=', id).execute()
+    await trx.deleteFrom('stripe_customers').where('orgId', '=', id).execute()
+    const result = await trx.deleteFrom('organizations').where('id', '=', id).executeTakeFirst()
+    return result.numDeletedRows > 0n
+  })
+}
+
 /**
  * Reads an organization by id.
  *
@@ -66,6 +143,44 @@ export function list(db: Db.Db): Promise<Record[]> {
   return db.kysely.selectFrom('organizations').selectAll().orderBy('createdAt', 'desc').execute()
 }
 
+/**
+ * Lists organizations owned by `userId`, newest first.
+ *
+ * @param db - The database.
+ * @param userId - The owning user id (`usr_…`).
+ * @returns The records.
+ */
+export function listByUser(db: Db.Db, userId: string): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('organizations')
+    .selectAll()
+    .where('userId', '=', userId)
+    .orderBy('createdAt', 'desc')
+    .execute()
+}
+
+/**
+ * Lists organizations `userId` is a member of (any role), newest first. Each
+ * row carries the caller's membership `role`.
+ *
+ * @param db - The database.
+ * @param userId - The member user id (`usr_…`).
+ * @returns The records.
+ */
+export function listByMember(
+  db: Db.Db,
+  userId: string,
+): Promise<(Record & { role: Memberships.Role })[]> {
+  return db.kysely
+    .selectFrom('organizations')
+    .innerJoin('memberships', 'memberships.orgId', 'organizations.id')
+    .where('memberships.userId', '=', userId)
+    .selectAll('organizations')
+    .select('memberships.role')
+    .orderBy('organizations.createdAt', 'desc')
+    .execute()
+}
+
 /**
  * Renames an organization, bumping `updatedAt`.
  *

package/src/db/tables/projects.ts

@@ -0,0 +1,107 @@
+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 `projects` table, derived from `Schema.Project`. */
+export type Table = db_Schema.Project
+
+/** A stored project row. */
+export type Record = Selectable<Table>
+
+/**
+ * Inserts a project and returns the stored record.
+ *
+ * @param db - The database.
+ * @param input - The project 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('projects')
+    .values({
+      createdAt: now,
+      id: Id.generate('prj'),
+      name: input.name,
+      orgId: input.orgId,
+      updatedAt: now,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow()
+}
+
+export declare namespace create {
+  /** Fields accepted when inserting a project. */
+  type Input = {
+    /** Human-readable project name. */
+    name: string
+    /** Owning organization id (`org_…`). */
+    orgId: string
+  }
+}
+
+/**
+ * Deletes a project.
+ *
+ * @param db - The database.
+ * @param id - The project id (`prj_…`).
+ * @returns Whether the project existed and was deleted.
+ */
+export async function deleteProject(db: Db.Db, id: string): Promise<boolean> {
+  const result = await db.kysely.deleteFrom('projects').where('id', '=', id).executeTakeFirst()
+  return result.numDeletedRows > 0n
+}
+
+/**
+ * Reads a project by id.
+ *
+ * @param db - The database.
+ * @param id - The project id (`prj_…`).
+ * @returns The record, or `undefined` when absent.
+ */
+export function get(db: Db.Db, id: string): Promise<Record | undefined> {
+  return db.kysely.selectFrom('projects').selectAll().where('id', '=', id).executeTakeFirst()
+}
+
+/**
+ * Lists an organization's projects, newest first.
+ *
+ * @param db - The database.
+ * @param orgId - The owning organization id (`org_…`).
+ * @returns The records.
+ */
+export function listByOrg(db: Db.Db, orgId: string): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('projects')
+    .selectAll()
+    .where('orgId', '=', orgId)
+    .orderBy('createdAt', 'desc')
+    .execute()
+}
+
+/**
+ * Renames a project, bumping `updatedAt`.
+ *
+ * @param db - The database.
+ * @param id - The project id (`prj_…`).
+ * @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('projects')
+    .set({ name: input.name, updatedAt: new Date().toISOString() })
+    .where('id', '=', id)
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace update {
+  /** Mutable project fields. */
+  type Input = {
+    /** New human-readable project name. */
+    name: string
+  }
+}

package/src/db/tables/requestUsage.ts

@@ -0,0 +1,231 @@
+import { type ColumnType, type Selectable, sql } from 'kysely'
+
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** A `bigint` count column: read as a string from pg, written as a number. */
+type Count = ColumnType<string, number, number>
+
+/** Environment a request-usage row attributes to. */
+export type Environment = db_Schema.RequestUsageBucket['environment']
+
+/** Exactly-once state of a meter event. */
+export type State = db_Schema.RequestUsageMeterEvent['state']
+
+/** Columns of the `request_usage_buckets` table (pg representation). */
+export type BucketTable = {
+  bucketStart: string
+  environment: Environment
+  orgId: string
+  reportedCount: Count
+  updatedAt: string
+}
+
+/** Columns of the `request_usage_meter_events` table (pg representation). */
+export type MeterEventTable = {
+  bucketStart: string
+  deltaCount: Count
+  environment: Environment
+  error: string | null
+  firstAttemptedAt: string
+  identifier: string
+  orgId: string
+  reason: string | null
+  reportedAt: string | null
+  sequence: number
+  state: State
+  stripeCustomerId: string
+}
+
+/** A stored per-hour request-count watermark. */
+export type Bucket = db_Schema.RequestUsageBucket
+
+/** A stored request-count meter event. */
+export type MeterEvent = db_Schema.RequestUsageMeterEvent
+
+/** Identifies one hourly bucket for an org in an environment. */
+export type BucketKey = {
+  /** UTC hour start (ISO 8601). */
+  bucketStart: string
+  /** Environment the requests were served under. */
+  environment: Environment
+  /** Organization id (`org_…`). */
+  orgId: string
+}
+
+/**
+ * Reads a bucket watermark.
+ *
+ * @param db - The database.
+ * @param key - The bucket key.
+ * @returns The watermark, or `undefined` when none has been reported yet.
+ */
+export async function getBucket(db: Db.Db, key: BucketKey): Promise<Bucket | undefined> {
+  const row = await db.kysely
+    .selectFrom('request_usage_buckets')
+    .selectAll()
+    .where('orgId', '=', key.orgId)
+    .where('environment', '=', key.environment)
+    .where('bucketStart', '=', key.bucketStart)
+    .executeTakeFirst()
+  return row ? toBucket(row) : undefined
+}
+
+/**
+ * Lists the meter events still awaiting a Stripe acknowledgement in an
+ * environment, oldest first — the reporter's crash-recovery drive.
+ *
+ * @param db - The database.
+ * @param environment - The environment to scan.
+ * @returns The pending meter events.
+ */
+export async function listPending(db: Db.Db, environment: Environment): Promise<MeterEvent[]> {
+  const rows = await db.kysely
+    .selectFrom('request_usage_meter_events')
+    .selectAll()
+    .where('environment', '=', environment)
+    .where('state', '=', 'pending')
+    .orderBy('firstAttemptedAt', 'asc')
+    .orderBy('identifier', 'asc')
+    .execute()
+  return rows.map(toMeterEvent)
+}
+
+/**
+ * Counts the meter events already reported for a bucket — the next delta's
+ * `sequence`, so a new seal never collides with a settled one.
+ *
+ * @param db - The database.
+ * @param key - The bucket key.
+ * @returns The count of reported events for the bucket.
+ */
+export async function countReported(db: Db.Db, key: BucketKey): Promise<number> {
+  const row = await db.kysely
+    .selectFrom('request_usage_meter_events')
+    .select((eb) => eb.fn.countAll<string>().as('count'))
+    .where('orgId', '=', key.orgId)
+    .where('environment', '=', key.environment)
+    .where('bucketStart', '=', key.bucketStart)
+    .where('state', '=', 'reported')
+    .executeTakeFirstOrThrow()
+  return Number(row.count)
+}
+
+/**
+ * Inserts a frozen `pending` meter event, claiming a delta. Idempotent on the
+ * deterministic `identifier`: a re-seal after a crash resolves to the existing
+ * row rather than duplicating the delta.
+ *
+ * @param db - The database.
+ * @param input - The event to insert.
+ * @returns Whether this call inserted the row.
+ */
+export async function insertPending(db: Db.Db, input: insertPending.Input): Promise<boolean> {
+  const now = new Date().toISOString()
+  const inserted = await db.kysely
+    .insertInto('request_usage_meter_events')
+    .values({
+      bucketStart: input.bucketStart,
+      deltaCount: input.deltaCount,
+      environment: input.environment,
+      error: null,
+      firstAttemptedAt: now,
+      identifier: input.identifier,
+      orgId: input.orgId,
+      reason: null,
+      reportedAt: null,
+      sequence: input.sequence,
+      state: 'pending',
+      stripeCustomerId: input.stripeCustomerId,
+    })
+    .onConflict((oc) => oc.doNothing())
+    .returning('identifier')
+    .executeTakeFirst()
+  return Boolean(inserted)
+}
+
+export declare namespace insertPending {
+  /** Fields accepted when sealing a pending meter event. */
+  type Input = {
+    /** UTC hour start the delta bills for (ISO 8601). */
+    bucketStart: string
+    /** Frozen request count this event bills (positive). */
+    deltaCount: number
+    /** Environment the requests were served under. */
+    environment: Environment
+    /** Deterministic id; also the Stripe identifier and idempotency key. */
+    identifier: string
+    /** Organization id (`org_…`). */
+    orgId: string
+    /** Delta sequence within the bucket. */
+    sequence: number
+    /** Stripe customer id the event bills against. */
+    stripeCustomerId: string
+  }
+}
+
+/**
+ * Marks a pending event reported and advances its bucket watermark by the
+ * event's frozen delta, atomically. A no-op once reported, so a retry after a
+ * crash between the Stripe ack and this write never double-advances.
+ *
+ * @param db - The database.
+ * @param identifier - The event identifier.
+ * @param at - When Stripe acknowledged the event (ISO 8601).
+ * @returns Whether this call settled the event (false when already reported).
+ */
+export function settle(db: Db.Db, identifier: string, at: string): Promise<boolean> {
+  return db.transaction(async (tx) => {
+    const updated = await tx.kysely
+      .updateTable('request_usage_meter_events')
+      .set({ error: null, reportedAt: at, state: 'reported' })
+      .where('identifier', '=', identifier)
+      .where('state', '=', 'pending')
+      .returningAll()
+      .executeTakeFirst()
+    if (!updated) return false
+    await tx.kysely
+      .insertInto('request_usage_buckets')
+      .values({
+        bucketStart: updated.bucketStart,
+        environment: updated.environment,
+        orgId: updated.orgId,
+        reportedCount: Number(updated.deltaCount),
+        updatedAt: at,
+      })
+      .onConflict((oc) =>
+        oc.columns(['orgId', 'environment', 'bucketStart']).doUpdateSet({
+          reportedCount: sql`request_usage_buckets.reported_count + ${updated.deltaCount}`,
+          updatedAt: at,
+        }),
+      )
+      .execute()
+    return true
+  })
+}
+
+/**
+ * Records a transient failure on a pending event; it stays pending for retry.
+ *
+ * @param db - The database.
+ * @param identifier - The event identifier.
+ * @param error - The failure detail.
+ */
+export async function markError(db: Db.Db, identifier: string, error: string): Promise<void> {
+  await db.kysely
+    .updateTable('request_usage_meter_events')
+    .set({ error: error.slice(0, 500) })
+    .where('identifier', '=', identifier)
+    .where('state', '=', 'pending')
+    .execute()
+}
+
+/** Maps a bucket row to its domain record. */
+function toBucket(row: Selectable<BucketTable>): Bucket {
+  return { ...row, reportedCount: Number(row.reportedCount) }
+}
+
+/** Maps a meter-event row to its domain record. */
+function toMeterEvent(row: Selectable<MeterEventTable>): MeterEvent {
+  return { ...row, deltaCount: Number(row.deltaCount) }
+}