@credo-ts/drizzle-storage 0.6.0-pr-2324-20250708122805 → 0.6.0-pr-2324-20250709075226

package/src/didcomm/out-of-band/postgres.ts

@@ -0,0 +1,46 @@
+import { OutOfBandInlineServiceKey, OutOfBandRole, OutOfBandState, PlaintextMessage } from '@credo-ts/didcomm'
+import { boolean, jsonb, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const didcommOutOfBandRoleEnum = pgEnum('DidcommOutOfBandRole', OutOfBandRole)
+export const didcommOutOfBandStateEnum = pgEnum('DidcommOutOfBandState', OutOfBandState)
+
+export const didcommOutOfBand = pgTable(
+  'DidcommOutOfBand',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    outOfBandInvitation: jsonb('out_of_band_invitation').$type<PlaintextMessage>().notNull(),
+    role: didcommOutOfBandRoleEnum().notNull(),
+    state: didcommOutOfBandStateEnum().notNull(),
+    alias: text(),
+    reusable: boolean().notNull(),
+    autoAcceptConnection: boolean('auto_accept_connection'),
+    mediatorId: text('mediator_id'),
+    reuseConnectionId: text('reuse_connection_id'),
+    invitationInlineServiceKeys: jsonb('invitation_inline_service_keys').$type<OutOfBandInlineServiceKey[]>(),
+
+    // Tags not on record
+    threadId: text('thread_id').notNull(),
+    invitationRequestsThreadIds: text('invitation_requests_thread_ids').array(),
+
+    // Custom tags
+    recipientKeyFingerprints: text('recipient_key_fingerprints').array(),
+    recipientRoutingKeyFingerprint: text('recipient_routing_key_fingerprint'),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'didcommOutOfBand'),
+    // foreignKey({
+    //   columns: [table.reuseConnectionId, table.contextCorrelationId],
+    //   foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    // }).onDelete('set default'),
+
+    // Do we want to delete connections when the mediator is removed?
+    // Or do we want to restrict it, and first require all connections
+    // to be removed?
+    // foreignKey({
+    //   columns: [table.mediatorId, table.contextCorrelationId],
+    //   foreignColumns: [didcommMediator.id, didcommMediator.contextCorrelationId],
+    // }).onDelete('cascade'),
+  ]
+)

package/src/didcomm/out-of-band/sqlite.ts

@@ -0,0 +1,46 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+import { OutOfBandInlineServiceKey, OutOfBandRole, OutOfBandState, PlaintextMessage } from '@credo-ts/didcomm'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const didcommOutOfBand = sqliteTable(
+  'DidcommOutOfBand',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    outOfBandInvitation: text('out_of_band_invitation', { mode: 'json' }).$type<PlaintextMessage>().notNull(),
+    role: text().$type<OutOfBandRole>().notNull(),
+    state: text().$type<OutOfBandState>().notNull(),
+    alias: text(),
+    reusable: integer({ mode: 'boolean' }).notNull(),
+    autoAcceptConnection: integer('auto_accept_connection', { mode: 'boolean' }),
+    mediatorId: text('mediator_id'),
+    reuseConnectionId: text('reuse_connection_id'),
+    invitationInlineServiceKeys: text('invitation_inline_service_keys', { mode: 'json' }).$type<
+      OutOfBandInlineServiceKey[]
+    >(),
+
+    // Tags not in record
+    threadId: text('thread_id').notNull(),
+    invitationRequestsThreadIds: text('invitation_requests_thread_ids', { mode: 'json' }).$type<string[]>(),
+
+    // Custom tags
+    recipientKeyFingerprints: text('recipient_key_fingerprints', { mode: 'json' }).$type<string[]>(),
+    recipientRoutingKeyFingerprint: text('recipient_routing_key_fingerprint'),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'didcommOutOfBand'),
+    // foreignKey({
+    //   columns: [table.reuseConnectionId, table.contextCorrelationId],
+    //   foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    // }).onDelete('set default'),
+
+    // Do we want to delete connections when the mediator is removed?
+    // Or do we want to restrict it, and first require all connections
+    // to be removed?
+    // foreignKey({
+    //   columns: [table.mediatorId, table.contextCorrelationId],
+    //   foreignColumns: [didcommMediator.id, didcommMediator.contextCorrelationId],
+    // }).onDelete('cascade'),
+  ]
+)

package/src/didcomm/postgres.ts

@@ -0,0 +1,8 @@
+export * from './basic-message/postgres'
+export * from './connection/postgres'
+export * from './credential-exchange/postgres'
+export * from './didcomm-message/postgres'
+export * from './mediation/postgres'
+export * from './mediator-routing/postgres'
+export * from './out-of-band/postgres'
+export * from './proof-exchange/postgres'

package/src/didcomm/proof-exchange/DrizzleDidcommProofExchangeRecordAdapter.ts

@@ -0,0 +1,51 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { ProofExchangeRecord } from '@credo-ts/didcomm'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommProofExchangeAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommProofExchange']>
+export class DrizzleDidcommProofExchangeRecordAdapter extends BaseDrizzleRecordAdapter<
+  ProofExchangeRecord,
+  typeof postgres.didcommProofExchange,
+  typeof postgres,
+  typeof sqlite.didcommProofExchange,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.didcommProofExchange, sqlite: sqlite.didcommProofExchange }, 'ProofRecord')
+  }
+
+  public getValues(record: ProofExchangeRecord): DrizzleAdapterValues<(typeof sqlite)['didcommProofExchange']> {
+    const { role, connectionId, parentThreadId, threadId, state, ...customTags } = record.getTags()
+
+    return {
+      connectionId,
+      threadId,
+      protocolVersion: record.protocolVersion,
+      parentThreadId,
+      isVerified: record.isVerified,
+      state,
+      role,
+      autoAcceptProof: record.autoAcceptProof,
+      errorMessage: record.errorMessage,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommProofExchangeAdapterValues): ProofExchangeRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, ProofExchangeRecord)
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/didcomm/proof-exchange/index.ts

@@ -0,0 +1,10 @@
+import { DrizzleRecord } from '../../DrizzleRecord'
+import { DrizzleDidcommProofExchangeRecordAdapter } from './DrizzleDidcommProofExchangeRecordAdapter'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+export const didcommProofExchangeDrizzleRecord = {
+  adapter: DrizzleDidcommProofExchangeRecordAdapter,
+  postgres,
+  sqlite,
+} satisfies DrizzleRecord

package/src/didcomm/proof-exchange/postgres.ts

@@ -0,0 +1,33 @@
+import { AutoAcceptProof, ProofRole, ProofState } from '@credo-ts/didcomm'
+import { boolean, foreignKey, pgEnum, pgTable, text, unique } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+import { didcommConnection } from '../postgres'
+
+export const didcommProofExchangeRoleEnum = pgEnum('DidcommProofExchangeRole', ProofRole)
+export const didcommProofExchangeStateEnum = pgEnum('DidcommProofExchangeState', ProofState)
+export const didcommProofExchangeAutoAcceptEnum = pgEnum('DidcommProofExchangeAutoAccept', AutoAcceptProof)
+
+export const didcommProofExchange = pgTable(
+  'DidcommProofExchange',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    connectionId: text('connection_id'),
+    threadId: text('thread_id').notNull(),
+    protocolVersion: text('protocol_version').notNull(),
+    parentThreadId: text('parent_thread_id'),
+    isVerified: boolean('is_verified'),
+    state: didcommProofExchangeRoleEnum().notNull(),
+    role: didcommProofExchangeRoleEnum().notNull(),
+    autoAcceptProof: didcommProofExchangeAutoAcceptEnum('auto_accept_proof'),
+    errorMessage: text('error_message'),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'didcommProofExchange'),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+    unique().on(table.contextCorrelationId, table.threadId, table.role),
+  ]
+)

package/src/didcomm/proof-exchange/sqlite.ts

@@ -0,0 +1,29 @@
+import { foreignKey, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+import { AutoAcceptProof, ProofRole, ProofState } from '@credo-ts/didcomm'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+import { didcommConnection } from '../sqlite'
+
+export const didcommProofExchange = sqliteTable(
+  'DidcommProofExchange',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    connectionId: text('connection_id'),
+    threadId: text('thread_id').notNull(),
+    protocolVersion: text('protocol_version').notNull(),
+    parentThreadId: text('parent_thread_id'),
+    isVerified: integer('is_verified', { mode: 'boolean' }),
+    state: text().$type<ProofState>().notNull(),
+    role: text().$type<ProofRole>().notNull(),
+    autoAcceptProof: text('auto_accept_proof').$type<AutoAcceptProof>(),
+    errorMessage: text('error_message'),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'didcommProofExchange'),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/didcomm/sqlite.ts

@@ -0,0 +1,8 @@
+export * from './basic-message/sqlite'
+export * from './connection/sqlite'
+export * from './credential-exchange/sqlite'
+export * from './didcomm-message/sqlite'
+export * from './mediation/sqlite'
+export * from './mediator-routing/sqlite'
+export * from './out-of-band/sqlite'
+export * from './proof-exchange/sqlite'

package/src/drpc/bundle.ts

@@ -0,0 +1,18 @@
+import { DrizzleRecordBundle } from '../DrizzleRecord'
+import { didcommDrpcDrizzleRecord } from './drpc'
+
+export default {
+  name: 'drpc',
+  records: [didcommDrpcDrizzleRecord],
+
+  migrations: {
+    postgres: {
+      schemaModule: '@credo-ts/drizzle-storage/drpc/postgres',
+      migrationsPath: '../../migrations/drpc/postgres',
+    },
+    sqlite: {
+      schemaModule: '@credo-ts/drizzle-storage/drpc/sqlite',
+      migrationsPath: '../../migrations/drpc/sqlite',
+    },
+  },
+} as const satisfies DrizzleRecordBundle

package/src/drpc/drpc/DrizzleDidcommDrpcRecordAdapter.ts

@@ -0,0 +1,44 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { DrpcRecord } from '@credo-ts/drpc'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommDrpcAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommDrpc']>
+export class DrizzleDidcommDrpcRecordAdapter extends BaseDrizzleRecordAdapter<
+  DrpcRecord,
+  typeof postgres.didcommDrpc,
+  typeof postgres,
+  typeof sqlite.didcommDrpc,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.didcommDrpc, sqlite: sqlite.didcommDrpc }, 'DrpcRecord')
+  }
+
+  public getValues(record: DrpcRecord) {
+    const { connectionId, threadId, ...customTags } = record.getTags()
+
+    return {
+      threadId,
+      connectionId,
+      state: record.state,
+      role: record.role,
+      request: record.request,
+      response: record.response,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommDrpcAdapterValues): DrpcRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, DrpcRecord)
+    if (customTags) record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/drpc/drpc/index.ts

@@ -0,0 +1,10 @@
+import { DrizzleRecord } from '../../DrizzleRecord'
+import { DrizzleDidcommDrpcRecordAdapter } from './DrizzleDidcommDrpcRecordAdapter'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+export const didcommDrpcDrizzleRecord = {
+  adapter: DrizzleDidcommDrpcRecordAdapter,
+  postgres,
+  sqlite,
+} satisfies DrizzleRecord

package/src/drpc/drpc/postgres.ts

@@ -0,0 +1,31 @@
+import { DrpcRequest, DrpcResponse, DrpcRole, DrpcState } from '@credo-ts/drpc'
+import { foreignKey, jsonb, pgEnum, pgTable, text, unique } from 'drizzle-orm/pg-core'
+import { didcommConnection } from '../../didcomm/connection/postgres'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const didcommDrpcStateEnum = pgEnum('DidcommDrpcState', DrpcState)
+export const didcommDrpcRoleEnum = pgEnum('DidcommDrpcRole', DrpcRole)
+
+export const didcommDrpc = pgTable(
+  'DidcommDrpc',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    request: jsonb().$type<DrpcRequest>(),
+    response: jsonb().$type<DrpcResponse>(),
+
+    state: didcommDrpcStateEnum().notNull(),
+    role: didcommDrpcRoleEnum().notNull(),
+
+    connectionId: text('connection_id').notNull(),
+    threadId: text('thread_id').notNull(),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'didcommDrpc'),
+    unique().on(table.contextCorrelationId, table.threadId),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/drpc/drpc/sqlite.ts

@@ -0,0 +1,29 @@
+import { foreignKey, sqliteTable, text, unique } from 'drizzle-orm/sqlite-core'
+
+import { DrpcRequest, DrpcResponse, DrpcRole, DrpcState } from '@credo-ts/drpc'
+import { didcommConnection } from '../../didcomm/connection/sqlite'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const didcommDrpc = sqliteTable(
+  'DidcommDrpc',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    request: text({ mode: 'json' }).$type<DrpcRequest>(),
+    response: text({ mode: 'json' }).$type<DrpcResponse>(),
+
+    state: text('state').$type<DrpcState>().notNull(),
+    role: text('role').$type<DrpcRole>().notNull(),
+
+    connectionId: text('connection_id').notNull(),
+    threadId: text('thread_id').notNull(),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'didcommDrpc'),
+    unique().on(table.contextCorrelationId, table.threadId),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/drpc/postgres.ts

@@ -0,0 +1 @@
+export * from './drpc/postgres'

package/src/drpc/sqlite.ts

@@ -0,0 +1 @@
+export * from './drpc/sqlite'

package/src/error/CredoDrizzleColumnDoesNotExistError.ts

@@ -0,0 +1,21 @@
+import { CredoDrizzleStorageError } from './CredoDrizzleStorageError'
+
+export class CredoDrizzleColumnDoesNotExistError extends CredoDrizzleStorageError {
+  public databaseType: 'sqlite' | 'postgres'
+  public recordType: string
+  public column: string
+
+  public constructor({
+    cause,
+    databaseType,
+    column,
+    recordType,
+  }: { cause?: Error; databaseType: 'postgres' | 'sqlite'; column: string; recordType: string }) {
+    const message = `Column '${column}' does not exist for record '${recordType}' in ${databaseType} database`
+    super(message, { cause })
+
+    this.databaseType = databaseType
+    this.column = column
+    this.recordType = recordType
+  }
+}

package/src/error/CredoDrizzleStorageError.ts

@@ -0,0 +1,7 @@
+import { CredoError } from '@credo-ts/core'
+
+export class CredoDrizzleStorageError extends CredoError {
+  public constructor(message: string, { cause }: { cause?: Error } = {}) {
+    super(message, { cause })
+  }
+}

package/src/error/index.ts

@@ -0,0 +1,2 @@
+export { CredoDrizzleStorageError } from './CredoDrizzleStorageError'
+export { CredoDrizzleColumnDoesNotExistError } from './CredoDrizzleColumnDoesNotExistError'

package/src/index.ts

@@ -0,0 +1,29 @@
+// Adapter
+export {
+  BaseDrizzleRecordAdapter,
+  AnyDrizzleAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from './adapter'
+
+// Storage
+export { DrizzleStorageService } from './storage'
+
+// Module
+export { DrizzleStorageModule } from './DrizzleStorageModule'
+export { DrizzleStorageModuleConfig } from './DrizzleStorageModuleConfig'
+
+export { DrizzleDatabase } from './DrizzleDatabase'
+
+export { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from './postgres'
+export { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from './sqlite'
+
+export type { DrizzleRecord, DrizzleRecordBundle } from './DrizzleRecord'
+
+export { GetSchemaFromDrizzleRecords, getSchemaFromDrizzleRecords } from './combineSchemas'
+
+export {
+  ReactNativeDrizzleMigration,
+  ReactNativeDrizzleMigrationsOptions,
+  applyReactNativeMigrations,
+} from './applyReactNativeMigrations'

package/src/openid4vc/bundle.ts

@@ -0,0 +1,26 @@
+import { DrizzleRecordBundle } from '../DrizzleRecord'
+import { openId4VcIssuanceSessionDrizzleRecord } from './openid4vc-issuance-session'
+import { openid4vcIssuerDrizzleRecord } from './openid4vc-issuer'
+import { openId4VcVerificationSessionDrizzleRecord } from './openid4vc-verification-session'
+import { openid4vcVerifierDrizzleRecord } from './openid4vc-verifier'
+
+export default {
+  name: 'openid4vc',
+  records: [
+    openid4vcIssuerDrizzleRecord,
+    openId4VcIssuanceSessionDrizzleRecord,
+    openid4vcVerifierDrizzleRecord,
+    openId4VcVerificationSessionDrizzleRecord,
+  ],
+
+  migrations: {
+    postgres: {
+      schemaModule: '@credo-ts/drizzle-storage/openid4vc/postgres',
+      migrationsPath: '../../migrations/openid4vc/postgres',
+    },
+    sqlite: {
+      schemaModule: '@credo-ts/drizzle-storage/openid4vc/sqlite',
+      migrationsPath: '../../migrations/openid4vc/sqlite',
+    },
+  },
+} as const satisfies DrizzleRecordBundle

package/src/openid4vc/openid4vc-issuance-session/DrizzleOpenId4VcIssuanceSessionRecordAdapter.ts

@@ -0,0 +1,90 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { OpenId4VcIssuanceSessionRecord } from '@credo-ts/openid4vc'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleOpenId4VcIssuanceSessionMenuAdapterValues = DrizzleAdapterRecordValues<
+  (typeof sqlite)['openId4VcIssuanceSession']
+>
+export class DrizzleOpenId4VcIssuanceSessionRecordAdapter extends BaseDrizzleRecordAdapter<
+  OpenId4VcIssuanceSessionRecord,
+  typeof postgres.openId4VcIssuanceSession,
+  typeof postgres,
+  typeof sqlite.openId4VcIssuanceSession,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.openId4VcIssuanceSession, sqlite: sqlite.openId4VcIssuanceSession },
+      'OpenId4VcIssuanceSessionRecord'
+    )
+  }
+
+  public tagKeyMapping = {
+    issuerState: ['authorization', 'issuerState'],
+    authorizationCode: ['authorization', 'code'],
+    authorizationSubject: ['authorization', 'subject'],
+    presentationAuthSession: ['presentation', 'authSession'],
+  } as const
+
+  public getValues(
+    record: OpenId4VcIssuanceSessionRecord
+  ): DrizzleAdapterValues<(typeof sqlite)['openId4VcIssuanceSession']> {
+    const {
+      authorizationCode,
+      authorizationSubject,
+      credentialOfferId,
+      credentialOfferUri,
+      issuerId,
+      issuerState,
+      preAuthorizedCode,
+      presentationAuthSession,
+      state,
+      ...customTags
+    } = record.getTags()
+
+    return {
+      credentialOfferId,
+      credentialOfferUri,
+      issuerId,
+      preAuthorizedCode,
+      state,
+
+      credentialOfferPayload: record.credentialOfferPayload,
+      authorization: record.authorization
+        ? {
+            ...record.authorization,
+            codeExpiresAt: record.authorization.codeExpiresAt?.toISOString(),
+          }
+        : undefined,
+      clientId: record.clientId,
+      dpop: record.dpop,
+      errorMessage: record.errorMessage,
+      issuanceMetadata: record.issuanceMetadata,
+      issuedCredentials: record.issuedCredentials,
+      pkce: record.pkce,
+      presentation: record.presentation,
+      userPin: record.userPin,
+      walletAttestation: record.walletAttestation,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleOpenId4VcIssuanceSessionMenuAdapterValues): OpenId4VcIssuanceSessionRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, OpenId4VcIssuanceSessionRecord)
+    if (customTags) record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/openid4vc/openid4vc-issuance-session/index.ts

@@ -0,0 +1,10 @@
+import { DrizzleRecord } from '../../DrizzleRecord'
+import { DrizzleOpenId4VcIssuanceSessionRecordAdapter } from './DrizzleOpenId4VcIssuanceSessionRecordAdapter'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+export const openId4VcIssuanceSessionDrizzleRecord = {
+  adapter: DrizzleOpenId4VcIssuanceSessionRecordAdapter,
+  postgres,
+  sqlite,
+} satisfies DrizzleRecord

package/src/openid4vc/openid4vc-issuance-session/postgres.ts

@@ -0,0 +1,54 @@
+import {
+  OpenId4VcIssuanceSessionAuthorization,
+  OpenId4VcIssuanceSessionDpop,
+  OpenId4VcIssuanceSessionPkce,
+  OpenId4VcIssuanceSessionPresentation,
+  OpenId4VcIssuanceSessionState,
+  OpenId4VcIssuanceSessionWalletAttestation,
+  OpenId4VciCredentialOfferPayload,
+} from '@credo-ts/openid4vc'
+import { jsonb, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+import { openid4vcIssuer } from '../postgres'
+
+export const openId4VcIssuanceSessionStateEnum = pgEnum('OpenId4VcIssuanceSessionState', OpenId4VcIssuanceSessionState)
+
+export const openId4VcIssuanceSession = pgTable(
+  'OpenId4VcIssuanceSession',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    issuerId: text('issuer_id')
+      .notNull()
+      .references(() => openid4vcIssuer.issuerId, { onDelete: 'cascade' }),
+
+    state: openId4VcIssuanceSessionStateEnum().notNull(),
+    issuedCredentials: text('issued_credentials').array(),
+
+    // Pre-authorized flow
+    preAuthorizedCode: text('pre_authorized_code'),
+    userPin: text('user_pin'),
+
+    // Client and authentication
+    clientId: text('client_id'),
+
+    pkce: jsonb().$type<OpenId4VcIssuanceSessionPkce>(),
+    walletAttestation: jsonb('wallet_attestation').$type<OpenId4VcIssuanceSessionWalletAttestation>(),
+    dpop: jsonb().$type<OpenId4VcIssuanceSessionDpop>(),
+    authorization: jsonb().$type<
+      Omit<OpenId4VcIssuanceSessionAuthorization, 'codeExpiresAt'> & { codeExpiresAt?: string }
+    >(),
+    presentation: jsonb().$type<OpenId4VcIssuanceSessionPresentation>(),
+
+    // Metadata and error handling
+    issuanceMetadata: jsonb('issuance_metadata').$type<Record<string, unknown>>(),
+
+    // Credential offer
+    credentialOfferUri: text('credential_offer_uri'),
+    credentialOfferId: text('credential_offer_id'),
+    credentialOfferPayload: jsonb('credential_offer_payload').$type<OpenId4VciCredentialOfferPayload>().notNull(),
+
+    errorMessage: text('error_message'),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'openId4VcIssuanceSession')
+)