@modern-admin/system-prisma 0.1.0

package/src/stores/cache-store.ts

@@ -0,0 +1,79 @@
+import type { CacheEntry, ICacheStore } from '@modern-admin/core'
+import type { PrismaDelegate } from '../types.js'
+
+interface CacheRow {
+  key: string
+  value: unknown
+  tags: unknown
+  expiresAt: Date | null
+  createdAt: Date
+  updatedAt: Date
+}
+
+const rowToEntry = (row: CacheRow): CacheEntry => ({
+  key: row.key,
+  value: row.value,
+  tags: Array.isArray(row.tags) ? (row.tags as string[]) : [],
+  expiresAt: row.expiresAt ? row.expiresAt.toISOString() : null,
+  createdAt: row.createdAt.toISOString(),
+  updatedAt: row.updatedAt.toISOString(),
+})
+
+export class PrismaCacheStore implements ICacheStore {
+  constructor(private readonly delegate: PrismaDelegate<CacheRow>) {}
+
+  async get(key: string): Promise<CacheEntry | null> {
+    const row = await this.delegate.findUnique({ where: { key } })
+    if (!row) return null
+    if (row.expiresAt && row.expiresAt.getTime() < Date.now()) {
+      await this.delegate.delete({ where: { key } }).catch(() => undefined)
+      return null
+    }
+    return rowToEntry(row)
+  }
+
+  async set(
+    key: string,
+    value: unknown,
+    options: { ttlMs?: number; tags?: string[] } = {},
+  ): Promise<void> {
+    const expiresAt = options.ttlMs ? new Date(Date.now() + options.ttlMs) : null
+    const tags = options.tags ?? []
+    await this.delegate.upsert({
+      where: { key },
+      create: { key, value: value ?? null, tags, expiresAt },
+      update: { value: value ?? null, tags, expiresAt },
+    })
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.delegate.delete({ where: { key } }).catch(() => undefined)
+  }
+
+  /**
+   * Tag invalidation walks the table because Prisma's portable `Json` field
+   * doesn't support array-contains across all DB engines. For high-volume
+   * caches use a Postgres-specific implementation (`tags String[]`) or
+   * Redis. Here correctness > throughput by design.
+   */
+  async invalidateTags(tags: string[]): Promise<number> {
+    if (!tags.length) return 0
+    const set = new Set(tags)
+    const rows = await this.delegate.findMany({})
+    const targets = rows.filter((r) =>
+      Array.isArray(r.tags) && (r.tags as string[]).some((t) => set.has(t)),
+    )
+    if (!targets.length) return 0
+    const result = await this.delegate.deleteMany({
+      where: { key: { in: targets.map((r) => r.key) } },
+    })
+    return result.count
+  }
+
+  async prune(): Promise<number> {
+    const result = await this.delegate.deleteMany({
+      where: { expiresAt: { lt: new Date() } },
+    })
+    return result.count
+  }
+}

package/src/stores/config-store.ts

@@ -0,0 +1,80 @@
+import { type ConfigEntry, type ConfigScope, type IConfigStore, uuidv7 } from '@modern-admin/core'
+import type { PrismaDelegate } from '../types.js'
+
+interface ConfigRow {
+  id: string
+  scope: string
+  scopeId: string
+  key: string
+  value: unknown
+  updatedAt: Date
+}
+
+const GLOBAL_SCOPE_ID = ''
+const encodeScopeId = (scopeId: string | null): string => scopeId ?? GLOBAL_SCOPE_ID
+const decodeScopeId = (scopeId: string): string | null => scopeId === GLOBAL_SCOPE_ID ? null : scopeId
+
+const rowToEntry = (row: ConfigRow): ConfigEntry => ({
+  scope: row.scope as ConfigScope,
+  scopeId: decodeScopeId(row.scopeId),
+  key: row.key,
+  value: row.value,
+  updatedAt: row.updatedAt.toISOString(),
+})
+
+export class PrismaConfigStore implements IConfigStore {
+  constructor(private readonly delegate: PrismaDelegate<ConfigRow>) {
+  }
+
+  async get(scope: ConfigScope, scopeId: string | null, key: string): Promise<unknown> {
+    // findFirst instead of findUnique: tolerates accidental duplicates and
+    // returns the most-recently-updated row rather than throwing.
+    const row = await this.delegate.findFirst({
+      where: { scope, scopeId: encodeScopeId(scopeId), key },
+      orderBy: { updatedAt: 'desc' },
+    })
+    return row?.value
+  }
+
+  async set(
+    scope: ConfigScope,
+    scopeId: string | null,
+    key: string,
+    value: unknown,
+  ): Promise<void> {
+    const encodedScopeId = encodeScopeId(scopeId)
+    // Use findFirst + update-by-id / create instead of upsert with a
+    // compound unique key.  Prisma 7 + PrismaPg adapter can misidentify
+    // compound-key upserts and issue a second INSERT rather than an UPDATE,
+    // which violates the unique constraint.  Anchoring the update on the
+    // surrogate id is always safe.
+    const existing = await this.delegate.findFirst({
+      where: { scope, scopeId: encodedScopeId, key },
+    })
+    if (existing) {
+      await this.delegate.update({
+        where: { id: existing.id },
+        data: { value: value ?? null },
+      })
+    } else {
+      await this.delegate.create({
+        data: { id: uuidv7(), scope, scopeId: encodedScopeId, key, value: value ?? null },
+      })
+    }
+  }
+
+  async delete(scope: ConfigScope, scopeId: string | null, key: string): Promise<void> {
+    // deleteMany avoids "record not found" and also cleans up any duplicates.
+    await this.delegate
+      .deleteMany({ where: { scope, scopeId: encodeScopeId(scopeId), key } })
+      .catch(() => undefined)
+  }
+
+  async list(scope: ConfigScope, scopeId: string | null): Promise<ConfigEntry[]> {
+    const rows = await this.delegate.findMany({
+      where: { scope, scopeId: encodeScopeId(scopeId) },
+      orderBy: { key: 'asc' },
+    })
+    return rows.map(rowToEntry)
+  }
+}

package/src/stores/history-store.ts

@@ -0,0 +1,84 @@
+import { uuidv7, type HistoryEntry, type HistoryOp, type IHistoryStore } from '@modern-admin/core'
+import type { PrismaDelegate } 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 PrismaHistoryStore implements IHistoryStore {
+  constructor(private readonly delegate: PrismaDelegate<HistoryRow>) {}
+
+  async append(input: {
+    resourceId: string
+    recordId: string
+    op: HistoryOp
+    userId?: string
+    snapshot: Record<string, unknown>
+    snapshotBefore?: Record<string, unknown>
+  }): Promise<HistoryEntry> {
+    const row = await this.delegate.create({
+      data: {
+        id: uuidv7(),
+        resourceId: input.resourceId,
+        recordId: input.recordId,
+        op: input.op,
+        userId: input.userId ?? null,
+        snapshot: input.snapshot,
+        snapshotBefore: input.snapshotBefore ?? null,
+      },
+    })
+    return rowToEntry(row)
+  }
+
+  async list(
+    resourceId: string,
+    recordId: string,
+    options: { limit?: number; offset?: number } = {},
+  ): Promise<HistoryEntry[]> {
+    const limit = options.limit ?? 50
+    const offset = options.offset ?? 0
+    const rows = await this.delegate.findMany({
+      where: { resourceId, recordId },
+      orderBy: { createdAt: 'desc' },
+      take: limit,
+      ...(offset > 0 ? { skip: offset } : {}),
+    })
+    return rows.map(rowToEntry)
+  }
+
+  async get(resourceId: string, recordId: string, revisionId: string): Promise<HistoryEntry | null> {
+    const row = await this.delegate.findFirst({
+      where: { id: revisionId, resourceId, recordId },
+    })
+    return row ? rowToEntry(row) : null
+  }
+
+  async latest(resourceId: string, recordId: string): Promise<HistoryEntry | null> {
+    const row = await this.delegate.findFirst({
+      where: { resourceId, recordId },
+      orderBy: { createdAt: 'desc' },
+    })
+    return row ? rowToEntry(row) : null
+  }
+}

package/src/stores/log-store.ts

@@ -0,0 +1,77 @@
+import { uuidv7, type ActionLogEntry, type ILogStore, type IQueryableLogStore } from '@modern-admin/core'
+import type { PrismaDelegate } from '../types.js'
+
+interface LogRow {
+  id: string
+  resourceId: string
+  action: string
+  recordId: string | null
+  recordIds: unknown
+  userId: string | null
+  payload: unknown
+  result: unknown
+  at: bigint
+  createdAt: Date
+}
+
+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 PrismaLogStore implements IQueryableLogStore {
+  constructor(private readonly delegate: PrismaDelegate<LogRow>) {}
+
+  async record(entry: ActionLogEntry): Promise<void> {
+    await this.delegate.create({
+      data: {
+        // Prefer the writer-supplied id (UUID v7 from `actionLoggingPlugin`)
+        // so React lists keyed on `entry.id` line up with the persisted row.
+        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: BigInt(entry.at),
+      },
+    })
+  }
+
+  async list(filter: Parameters<IQueryableLogStore['list']>[0] = {}): Promise<ActionLogEntry[]> {
+    const where: Record<string, unknown> = {}
+    if (filter.resourceId) where['resourceId'] = filter.resourceId
+    if (filter.recordId) where['recordId'] = filter.recordId
+    if (filter.userId) where['userId'] = filter.userId
+    if (filter.actions?.length) where['action'] = { in: filter.actions }
+    if (filter.from || filter.to) {
+      const range: Record<string, bigint> = {}
+      if (filter.from) range['gte'] = BigInt(filter.from.getTime())
+      if (filter.to) range['lte'] = BigInt(filter.to.getTime())
+      where['at'] = range
+    }
+    const rows = await this.delegate.findMany({
+      where,
+      orderBy: { at: 'desc' },
+      ...(filter.limit !== undefined ? { take: filter.limit } : {}),
+      ...(filter.offset !== undefined ? { skip: filter.offset } : {}),
+    })
+    return rows.map(rowToEntry)
+  }
+}
+
+/** Narrow type-test: a pure `ILogStore` is enough where readback isn't needed. */
+export type { ILogStore }

package/src/stores/webhook-store.ts

@@ -0,0 +1,150 @@
+import {
+  uuidv7,
+  type IWebhookStore,
+  type Webhook,
+  type WebhookDelivery,
+  type WebhookDeliveryStatus,
+  type WebhookInput,
+} from '@modern-admin/core'
+import type { PrismaDelegate } 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 PrismaWebhookStore implements IWebhookStore {
+  constructor(
+    private readonly webhookDelegate: PrismaDelegate<WebhookRow>,
+    private readonly deliveryDelegate: PrismaDelegate<DeliveryRow>,
+  ) {}
+
+  async list(): Promise<Webhook[]> {
+    const rows = await this.webhookDelegate.findMany({ orderBy: { createdAt: 'desc' } })
+    return rows.map(rowToWebhook)
+  }
+
+  async get(id: string): Promise<Webhook | null> {
+    const row = await this.webhookDelegate.findUnique({ where: { id } })
+    return row ? rowToWebhook(row) : null
+  }
+
+  async create(input: WebhookInput): Promise<Webhook> {
+    const row = await this.webhookDelegate.create({
+      data: {
+        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 ?? [],
+      },
+    })
+    return rowToWebhook(row)
+  }
+
+  async update(id: string, patch: Partial<WebhookInput>): Promise<Webhook> {
+    const data: Record<string, unknown> = {}
+    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 row = await this.webhookDelegate.update({ where: { id }, data })
+    return rowToWebhook(row)
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.webhookDelegate.delete({ where: { id } })
+  }
+
+  async recordDelivery(
+    delivery: Omit<WebhookDelivery, 'id' | 'createdAt'>,
+  ): Promise<WebhookDelivery> {
+    const row = await this.deliveryDelegate.create({
+      data: {
+        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,
+      },
+    })
+    return rowToDelivery(row)
+  }
+
+  async listDeliveries(webhookId: string, limit = 50): Promise<WebhookDelivery[]> {
+    const rows = await this.deliveryDelegate.findMany({
+      where: { webhookId },
+      orderBy: { createdAt: 'desc' },
+      take: limit,
+    })
+    return rows.map(rowToDelivery)
+  }
+}

package/src/types.ts

@@ -0,0 +1,70 @@
+/**
+ * Structural Prisma typings used by the system stores.
+ *
+ * Prisma generates a fully-typed client per project, so we can't import a
+ * concrete `PrismaClient` here. Instead, every store consumes a minimal
+ * delegate shape — the same handful of methods Prisma always emits for a
+ * model. The host's actual generated client matches this surface
+ * structurally, no casts required.
+ */
+
+
+
+export interface PrismaDelegate<TRow = any> {
+  findMany(args?: any): Promise<TRow[]>
+  findUnique(args: { where: any }): Promise<TRow | null>
+  findFirst(args?: any): Promise<TRow | null>
+  create(args: { data: any }): Promise<TRow>
+  update(args: { where: any; data: any }): Promise<TRow>
+  upsert(args: { where: any; update: any; create: any }): Promise<TRow>
+  delete(args: { where: any }): Promise<TRow>
+  deleteMany(args?: { where?: any }): Promise<{ count: number }>
+  count(args?: any): Promise<number>
+}
+
+/**
+ * Whatever `prisma` instance the host injects. We index into it by model
+ * name (default: `maLog`, `maWebhook`, …); see `setupPrismaSystem`'s
+ * `models` option for renames.
+ *
+ * Uses `{ [K: string]: any }` (not `Record<string, PrismaDelegate>`) so that
+ * the generated `PrismaClient` — which carries utility methods like
+ * `$connect`, `$disconnect`, `$transaction` that are NOT `PrismaDelegate` —
+ * is directly assignable without a cast. TypeScript only waives the
+ * "missing index signature" check when the index value type is `any`; any
+ * other type (including `unknown`) still rejects `PrismaClient`. The shape
+ * of each delegate is validated at runtime in `resolveDelegate()`.
+ */
+
+export type PrismaLike = { [K: string]: any }
+
+export const DEFAULT_MODELS = {
+  log: 'maLog',
+  webhook: 'maWebhook',
+  webhookDelivery: 'maWebhookDelivery',
+  config: 'maConfig',
+  history: 'maHistory',
+  aiTask: 'maAiTask',
+  aiTaskEvent: 'maAiTaskEvent',
+  cache: 'maCache',
+} as const
+
+export type ModelKey = keyof typeof DEFAULT_MODELS
+export type ModelOverrides = Partial<Record<ModelKey, string>>
+
+export function resolveDelegate(
+  prisma: PrismaLike,
+  key: ModelKey,
+  overrides: ModelOverrides | undefined,
+): PrismaDelegate {
+  const name = overrides?.[key] ?? DEFAULT_MODELS[key]
+  const delegate = prisma[name] as PrismaDelegate | undefined
+  if (!delegate || typeof delegate.findMany !== 'function') {
+    throw new Error(
+      `[modern-admin/system-prisma] missing delegate "prisma.${name}". ` +
+      `Make sure the Modern Admin schema fragment is included in your schema.prisma ` +
+      `(see @modern-admin/system-prisma/schema), and that the Prisma client has been generated.`,
+    )
+  }
+  return delegate
+}