@modern-admin/system-drizzle 0.1.0

package/src/stores/history-store.ts

@@ -0,0 +1,98 @@
+import { uuidv7, type HistoryEntry, type HistoryOp, type IHistoryStore } from '@modern-admin/core'
+import { and, desc, eq } from 'drizzle-orm'
+import type { DrizzleLike, SystemTables } from '../types.js'
+
+interface HistoryRow {
+  id: string
+  resourceId: string
+  recordId: string
+  op: string
+  userId: string | null
+  snapshot: unknown
+  snapshotBefore: unknown
+  diff: unknown
+  createdAt: Date
+}
+
+const rowToEntry = (row: HistoryRow): HistoryEntry => ({
+  id: row.id,
+  resourceId: row.resourceId,
+  recordId: row.recordId,
+  op: row.op as HistoryOp,
+  ...(row.userId !== null ? { userId: row.userId } : {}),
+  snapshot: (row.snapshot as Record<string, unknown>) ?? {},
+  ...(row.snapshotBefore !== null && row.snapshotBefore !== undefined
+    ? { snapshotBefore: row.snapshotBefore as Record<string, unknown> }
+    : {}),
+  createdAt: row.createdAt.toISOString(),
+})
+
+export class DrizzleHistoryStore implements IHistoryStore {
+  constructor(
+    private readonly db: DrizzleLike,
+    private readonly table: SystemTables['maHistory'],
+  ) {}
+
+  async append(input: {
+    resourceId: string
+    recordId: string
+    op: HistoryOp
+    userId?: string
+    snapshot: Record<string, unknown>
+    snapshotBefore?: Record<string, unknown>
+  }): Promise<HistoryEntry> {
+    const rows = (await this.db
+      .insert(this.table)
+      .values({
+        id: uuidv7(),
+        resourceId: input.resourceId,
+        recordId: input.recordId,
+        op: input.op,
+        userId: input.userId ?? null,
+        snapshot: input.snapshot,
+        snapshotBefore: input.snapshotBefore ?? null,
+      })
+      .returning()) as HistoryRow[]
+    return rowToEntry(rows[0]!)
+  }
+
+  async list(
+    resourceId: string,
+    recordId: string,
+    options: { limit?: number; offset?: number } = {},
+  ): Promise<HistoryEntry[]> {
+    const limit = options.limit ?? 50
+    const offset = options.offset ?? 0
+    let q = this.db
+      .select()
+      .from(this.table)
+      .where(
+        and(eq(this.table.resourceId, resourceId), eq(this.table.recordId, recordId)),
+      )
+      .orderBy(desc(this.table.createdAt))
+      .limit(limit)
+    if (offset > 0) q = q.offset(offset)
+    const rows = (await q) as HistoryRow[]
+    return rows.map(rowToEntry)
+  }
+
+  async get(resourceId: string, recordId: string, revisionId: string): Promise<HistoryEntry | null> {
+    const rows = (await this.db
+      .select()
+      .from(this.table)
+      .where(
+        and(
+          eq(this.table.id, revisionId),
+          eq(this.table.resourceId, resourceId),
+          eq(this.table.recordId, recordId),
+        ),
+      )
+      .limit(1)) as HistoryRow[]
+    return rows[0] ? rowToEntry(rows[0]) : null
+  }
+
+  async latest(resourceId: string, recordId: string): Promise<HistoryEntry | null> {
+    const rows = (await this.list(resourceId, recordId, { limit: 1 })) as HistoryEntry[]
+    return rows[0] ?? null
+  }
+}

package/src/stores/log-store.ts

@@ -0,0 +1,71 @@
+import { uuidv7, type ActionLogEntry, type IQueryableLogStore } from '@modern-admin/core'
+import { and, desc, eq, gte, inArray, lte, type SQL } from 'drizzle-orm'
+import type { DrizzleLike, SystemTables } from '../types.js'
+
+interface LogRow {
+  id: string
+  resourceId: string
+  action: string
+  recordId: string | null
+  recordIds: unknown
+  userId: string | null
+  payload: unknown
+  result: unknown
+  at: number
+}
+
+const rowToEntry = (row: LogRow): ActionLogEntry => ({
+  id: row.id,
+  resourceId: row.resourceId,
+  action: row.action,
+  ...(row.recordId !== null ? { recordId: row.recordId } : {}),
+  ...(Array.isArray(row.recordIds) ? { recordIds: row.recordIds as string[] } : {}),
+  ...(row.userId !== null ? { userId: row.userId } : {}),
+  ...(row.payload !== null && row.payload !== undefined
+    ? { payload: row.payload as Record<string, unknown> }
+    : {}),
+  ...(row.result !== null && row.result !== undefined
+    ? { result: row.result as Record<string, unknown> }
+    : {}),
+  at: Number(row.at),
+})
+
+export class DrizzleLogStore implements IQueryableLogStore {
+  constructor(
+    private readonly db: DrizzleLike,
+    private readonly table: SystemTables['maLog'],
+  ) {}
+
+  async record(entry: ActionLogEntry): Promise<void> {
+    await this.db.insert(this.table).values({
+      id: entry.id ?? uuidv7(),
+      resourceId: entry.resourceId,
+      action: entry.action,
+      recordId: entry.recordId ?? null,
+      recordIds: entry.recordIds ?? null,
+      userId: entry.userId ?? null,
+      payload: entry.payload ?? null,
+      result: entry.result ?? null,
+      at: entry.at,
+    })
+  }
+
+  async list(filter: Parameters<IQueryableLogStore['list']>[0] = {}): Promise<ActionLogEntry[]> {
+    const conds: SQL[] = []
+    if (filter.resourceId) conds.push(eq(this.table.resourceId, filter.resourceId))
+    if (filter.recordId) conds.push(eq(this.table.recordId, filter.recordId))
+    if (filter.userId) conds.push(eq(this.table.userId, filter.userId))
+    if (filter.actions?.length) conds.push(inArray(this.table.action, filter.actions))
+    if (filter.from) conds.push(gte(this.table.at, filter.from.getTime()))
+    if (filter.to) conds.push(lte(this.table.at, filter.to.getTime()))
+
+    let q = this.db.select().from(this.table)
+    if (conds.length) q = q.where(conds.length === 1 ? conds[0] : and(...conds))
+    q = q.orderBy(desc(this.table.at))
+    if (filter.limit !== undefined) q = q.limit(filter.limit)
+    if (filter.offset !== undefined) q = q.offset(filter.offset)
+
+    const rows = (await q) as LogRow[]
+    return rows.map(rowToEntry)
+  }
+}

package/src/stores/webhook-store.ts

@@ -0,0 +1,167 @@
+import {
+  uuidv7,
+  type IWebhookStore,
+  type Webhook,
+  type WebhookDelivery,
+  type WebhookDeliveryStatus,
+  type WebhookInput,
+} from '@modern-admin/core'
+import { desc, eq } from 'drizzle-orm'
+import type { DrizzleLike, SystemTables } from '../types.js'
+
+interface WebhookRow {
+  id: string
+  name: string
+  url: string
+  events: unknown
+  resourceId: string | null
+  enabled: boolean
+  secret: string | null
+  headers: unknown
+  filters: unknown
+  payloadFields: unknown
+  createdAt: Date
+  updatedAt: Date
+}
+
+interface DeliveryRow {
+  id: string
+  webhookId: string
+  event: string
+  payload: unknown
+  status: string
+  responseStatus: number | null
+  responseBody: string | null
+  error: string | null
+  attempt: number
+  createdAt: Date
+  deliveredAt: Date | null
+}
+
+const rowToWebhook = (row: WebhookRow): Webhook => ({
+  id: row.id,
+  name: row.name,
+  url: row.url,
+  events: Array.isArray(row.events) ? (row.events as string[]) : [],
+  resourceId: row.resourceId,
+  enabled: row.enabled,
+  ...(row.secret !== null ? { secret: row.secret } : {}),
+  headers: (row.headers as Record<string, string>) ?? {},
+  filters: (row.filters as Record<string, string>) ?? {},
+  payloadFields: Array.isArray(row.payloadFields) ? (row.payloadFields as string[]) : [],
+  createdAt: row.createdAt.toISOString(),
+  updatedAt: row.updatedAt.toISOString(),
+})
+
+const rowToDelivery = (row: DeliveryRow): WebhookDelivery => ({
+  id: row.id,
+  webhookId: row.webhookId,
+  event: row.event,
+  payload: (row.payload as Record<string, unknown>) ?? {},
+  status: row.status as WebhookDeliveryStatus,
+  ...(row.responseStatus !== null ? { responseStatus: row.responseStatus } : {}),
+  ...(row.responseBody !== null ? { responseBody: row.responseBody } : {}),
+  ...(row.error !== null ? { error: row.error } : {}),
+  attempt: row.attempt,
+  createdAt: row.createdAt.toISOString(),
+  ...(row.deliveredAt !== null ? { deliveredAt: row.deliveredAt.toISOString() } : {}),
+})
+
+export class DrizzleWebhookStore implements IWebhookStore {
+  constructor(
+    private readonly db: DrizzleLike,
+    private readonly hookTable: SystemTables['maWebhook'],
+    private readonly deliveryTable: SystemTables['maWebhookDelivery'],
+  ) {}
+
+  async list(): Promise<Webhook[]> {
+    const rows = (await this.db
+      .select()
+      .from(this.hookTable)
+      .orderBy(desc(this.hookTable.createdAt))) as WebhookRow[]
+    return rows.map(rowToWebhook)
+  }
+
+  async get(id: string): Promise<Webhook | null> {
+    const rows = (await this.db
+      .select()
+      .from(this.hookTable)
+      .where(eq(this.hookTable.id, id))
+      .limit(1)) as WebhookRow[]
+    return rows[0] ? rowToWebhook(rows[0]) : null
+  }
+
+  async create(input: WebhookInput): Promise<Webhook> {
+    const rows = (await this.db
+      .insert(this.hookTable)
+      .values({
+        id: uuidv7(),
+        name: input.name,
+        url: input.url,
+        events: input.events,
+        resourceId: input.resourceId ?? null,
+        enabled: input.enabled ?? true,
+        secret: input.secret ?? null,
+        headers: input.headers ?? {},
+        filters: input.filters ?? {},
+        payloadFields: input.payloadFields ?? [],
+      })
+      .returning()) as WebhookRow[]
+    return rowToWebhook(rows[0]!)
+  }
+
+  async update(id: string, patch: Partial<WebhookInput>): Promise<Webhook> {
+    const data: Record<string, unknown> = { updatedAt: new Date() }
+    if (patch.name !== undefined) data['name'] = patch.name
+    if (patch.url !== undefined) data['url'] = patch.url
+    if (patch.events !== undefined) data['events'] = patch.events
+    if (patch.resourceId !== undefined) data['resourceId'] = patch.resourceId ?? null
+    if (patch.enabled !== undefined) data['enabled'] = patch.enabled
+    if (patch.secret !== undefined) data['secret'] = patch.secret
+    if (patch.headers !== undefined) data['headers'] = patch.headers
+    if (patch.filters !== undefined) data['filters'] = patch.filters
+    if (patch.payloadFields !== undefined) data['payloadFields'] = patch.payloadFields
+    const rows = (await this.db
+      .update(this.hookTable)
+      .set(data)
+      .where(eq(this.hookTable.id, id))
+      .returning()) as WebhookRow[]
+    if (!rows[0]) throw new Error(`Webhook not found: ${id}`)
+    return rowToWebhook(rows[0])
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.db.delete(this.hookTable).where(eq(this.hookTable.id, id))
+  }
+
+  async recordDelivery(
+    delivery: Omit<WebhookDelivery, 'id' | 'createdAt'>,
+  ): Promise<WebhookDelivery> {
+    const rows = (await this.db
+      .insert(this.deliveryTable)
+      .values({
+        id: uuidv7(),
+        webhookId: delivery.webhookId,
+        event: delivery.event,
+        payload: delivery.payload,
+        status: delivery.status,
+        responseStatus: delivery.responseStatus ?? null,
+        responseBody: delivery.responseBody ?? null,
+        error: delivery.error ?? null,
+        attempt: delivery.attempt,
+        deliveredAt: delivery.deliveredAt ? new Date(delivery.deliveredAt) : null,
+      })
+      .returning()) as DeliveryRow[]
+    return rowToDelivery(rows[0]!)
+  }
+
+  async listDeliveries(webhookId: string, limit = 50): Promise<WebhookDelivery[]> {
+    const rows = (await this.db
+      .select()
+      .from(this.deliveryTable)
+      .where(eq(this.deliveryTable.webhookId, webhookId))
+      .orderBy(desc(this.deliveryTable.createdAt))
+      .limit(limit)) as DeliveryRow[]
+    return rows.map(rowToDelivery)
+  }
+}

package/src/types.ts

@@ -0,0 +1,27 @@
+/**
+ * Structural Drizzle typings used by the system stores.
+ *
+ * Drizzle's typed `db` carries a heavy dialect-specific generic load
+ * (`PgDatabase`, `MySqlDatabase`, `BetterSQLite3Database`, …). To stay
+ * dialect-agnostic at the package boundary we accept a `DrizzleLike`
+ * surface — runtime calls go through a small handful of methods every
+ * builder exposes. Hosts pass their concrete `drizzle(...)` instance and
+ * it satisfies this shape structurally.
+ */
+
+
+
+import type { SystemTables } from './schema/pg.js'
+
+/**
+ * Loose Drizzle client surface. The real `drizzle(...)` instance has a
+ * much richer typed API; we only depend on the methods we actually call.
+ */
+export type DrizzleLike = {
+  insert: (table: any) => any
+  select: (fields?: any) => any
+  update: (table: any) => any
+  delete: (table: any) => any
+}
+
+export type { SystemTables }