@anvia/memory-prisma API reference

The package exports the Prisma 7 memory store and its delegate contracts. The @anvia/memory-prisma/v8 entrypoint exports a Prisma 8 PostgreSQL store. The package also provides the anvia-memory-prisma executable used by npx @anvia/memory-prisma init; the CLI is not a JavaScript subpath export.

import {
  PrismaMemoryStore,
  type PrismaMemoryClientLike,
  type PrismaMemoryConventionalDelegates,
  type PrismaMemoryDelegates,
  type PrismaMemoryErrorDelegate,
  type PrismaMemoryErrorPolicy,
  type PrismaMemoryMessageDelegate,
  type PrismaMemoryMessageRow,
  type PrismaMemoryPositionRow,
  type PrismaMemorySessionDelegate,
  type PrismaMemorySessionRow,
  type PrismaMemoryStoreOptions,
  type PrismaMemoryTransactionOptions,
} from '@anvia/memory-prisma'

PrismaMemoryStore

class PrismaMemoryStore implements MemoryStore {
  readonly kind: 'prisma'
  readonly inspector: MemoryInspector | undefined
  readonly compaction: MemoryCompactionCapability | undefined

  constructor(options: PrismaMemoryStoreOptions)
  validate(): Promise<void>
  load(options: MemoryLoadOptions): Promise<Message[]>
  append(options: MemoryAppendOptions): Promise<void>
  clear(options: MemoryClearOptions): Promise<void>
  recordError(options: MemoryErrorOptions): Promise<void>
}

Pass either the conventional generated Prisma client or explicit delegates:

type PrismaMemoryStoreOptions = {
  scopeKey?: MemoryScopeKeyResolver
  errorPolicy?: PrismaMemoryErrorPolicy
  validateMessages?: boolean
  transaction?: PrismaMemoryTransactionOptions
} & (
  | { client: object; delegates?: never }
  | { delegates: PrismaMemoryDelegates; client?: never }
)

Delegate contracts

type PrismaMemorySessionRow = { id: string }
type PrismaMemoryMessageRow = { message: unknown }
type PrismaMemoryPositionRow = { position: number }

type PrismaMemorySessionDelegate = {
  upsert(args: unknown): Promise<PrismaMemorySessionRow>
  deleteMany(args: unknown): Promise<unknown>
  findMany?(args: unknown): Promise<unknown[]>
  findUnique?(args: unknown): Promise<unknown | null>
}

type PrismaMemoryMessageDelegate = {
  findMany(args: unknown): Promise<PrismaMemoryMessageRow[]>
  findFirst(args: unknown): Promise<PrismaMemoryPositionRow | null>
  createMany(args: unknown): Promise<unknown>
  deleteMany?(args: unknown): Promise<{ count: number }>
}

type PrismaMemoryErrorDelegate = {
  create(args: unknown): Promise<unknown>
}

type PrismaMemoryDelegates = {
  sessions: PrismaMemorySessionDelegate
  messages: PrismaMemoryMessageDelegate
  errors?: PrismaMemoryErrorDelegate
  transaction<T>(
    operation: (tx: PrismaMemoryDelegates) => Promise<T>,
    options?: PrismaMemoryTransactionOptions,
  ): Promise<T>
}

Conventional client

type PrismaMemoryConventionalDelegates = {
  agentMemorySession: PrismaMemorySessionDelegate
  agentMemoryMessage: PrismaMemoryMessageDelegate
  agentMemoryError?: PrismaMemoryErrorDelegate
}

type PrismaMemoryClientLike = PrismaMemoryConventionalDelegates & {
  $transaction<T>(
    operation: (tx: PrismaMemoryConventionalDelegates) => Promise<T>,
    options?: PrismaMemoryTransactionOptions,
  ): Promise<T>
}

Policies

type PrismaMemoryErrorPolicy = 'store' | 'ignore'

type PrismaMemoryTransactionOptions = {
  isolationLevel?: string
}

Inspection is available when the optional session lookup methods exist. Atomic compaction requires sessions.findUnique on the root delegate and on delegates supplied to the transaction callback. The optional messages.deleteMany member remains accepted for source compatibility but is not used by checkpoint-based compaction.

Prisma 8 entrypoint

import {
  PrismaMemoryStore,
  type PrismaMemoryModelNames,
  type PrismaMemoryStoreOptions,
} from '@anvia/memory-prisma/v8'

PrismaMemoryStoreOptions requires a caller-owned @prisma/orm-postgres client and accepts schema, custom models names, scopeKey, errorPolicy, message validation, and transaction options. Call validate() after construction and close the client from the application lifecycle.

Return to the package guide.