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

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

@@ -0,0 +1,45 @@
+import { JsonObject } from '@credo-ts/core'
+import { AutoAcceptCredential, CredentialRecordBinding, CredentialRole, CredentialState } from '@credo-ts/didcomm'
+import { jsonb, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const didcommCredentialExchangeStateEnum = pgEnum('DidcommCredentialExchangeState', CredentialState)
+export const didcommCredentialExchangeRoleEnum = pgEnum('DidcommCredentialExchangeRole', CredentialRole)
+export const didcommCredentialExchangeAutoAcceptEnum = pgEnum(
+  'DidcommCredentialExchangeAutoAccept',
+  AutoAcceptCredential
+)
+
+export const didcommCredentialExchange = pgTable(
+  'DidcommCredentialExchange',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    connectionId: text('connection_id'),
+    threadId: text('thread_id').notNull(),
+    parentThreadId: text('parent_thread_id'),
+
+    state: didcommCredentialExchangeStateEnum().notNull(),
+    role: didcommCredentialExchangeRoleEnum().notNull(),
+    autoAcceptCredential: didcommCredentialExchangeAutoAcceptEnum('auto_accept_credential'),
+    revocationNotification: jsonb('revocation_notification').$type<JsonObject>(),
+    errorMessage: text('error_message'),
+    protocolVersion: text('protocol_version'),
+
+    credentials: jsonb().$type<CredentialRecordBinding[]>(),
+    credentialIds: text('credential_ids').array(), // same as credentials, but queryable
+
+    credentialAttributes: jsonb('credential_attributes').$type<JsonObject[]>(),
+    linkedAttachments: jsonb('linked_attachments').$type<JsonObject[]>(),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'didcommCredentialExchange'),
+    // TODO: we only want to set the `connectionId` to null on delete of
+    // the associated connection, but that's not possible with composite foreign keys
+    // so we need to add a custom trigger for that.
+    // foreignKey({
+    //   columns: [table.connectionId, table.contextCorrelationId],
+    //   foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    // }).onDelete('cascade'),
+  ]
+)

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

@@ -0,0 +1,39 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+import { JsonObject } from '@credo-ts/core'
+import { AutoAcceptCredential, CredentialRecordBinding, CredentialRole, CredentialState } from '@credo-ts/didcomm'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const didcommCredentialExchange = sqliteTable(
+  'DidcommCredentialExchange',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    connectionId: text('connection_id'),
+    threadId: text('thread_id').notNull(),
+    parentThreadId: text('parent_thread_id'),
+
+    state: text().$type<CredentialState>().notNull(),
+    role: text().$type<CredentialRole>().notNull(),
+    autoAcceptCredential: text('auto_accept_credential').$type<AutoAcceptCredential>(),
+    revocationNotification: text('revocation_notification', { mode: 'json' }).$type<JsonObject>(),
+    errorMessage: text('error_message'),
+    protocolVersion: text('protocol_version'),
+
+    credentials: text({ mode: 'json' }).$type<CredentialRecordBinding[]>(),
+    credentialIds: text('credential_ids', { mode: 'json' }).$type<string[]>(), // same as credentials, but queryable
+
+    credentialAttributes: text('credential_attributes', { mode: 'json' }).$type<JsonObject[]>(),
+    linkedAttachments: text('linked_attachments', { mode: 'json' }).$type<JsonObject[]>(),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'didcommCredentialExchange'),
+    // TODO: we only want to set the `connectionId` to null on delete of
+    // the associated connection, but that's not possible with composite foreign keys
+    // so we need to add a custom trigger for that.
+    // foreignKey({
+    //   columns: [table.connectionId, table.contextCorrelationId],
+    //   foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    // }).onDelete('cascade'),
+  ]
+)

package/src/didcomm/didcomm-message/DrizzleDidcommMessageRecordAdapter.ts

@@ -0,0 +1,75 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { DidCommMessageRecord } from '@credo-ts/didcomm'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommMessageAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommMessage']>
+export class DrizzleDidcommMessageRecordAdapter extends BaseDrizzleRecordAdapter<
+  DidCommMessageRecord,
+  typeof postgres.didcommMessage,
+  typeof postgres,
+  typeof sqlite.didcommMessage,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.didcommMessage, sqlite: sqlite.didcommMessage }, 'DidCommMessageRecord')
+  }
+
+  public tagKeyMapping = {
+    messageType: ['message', '@type'],
+    messageId: ['message', '@id'],
+  } as const
+
+  public getValues(record: DidCommMessageRecord): DrizzleAdapterValues<(typeof sqlite)['didcommMessage']> {
+    const {
+      role,
+      associatedRecordId,
+      messageId,
+      messageName,
+      messageType,
+      protocolMajorVersion,
+      protocolMinorVersion,
+      protocolName,
+      threadId,
+      ...customTags
+    } = record.getTags()
+
+    return {
+      message: record.message,
+      role,
+
+      associatedRecordId,
+
+      // These are access on message['@type'] and message['@id']
+      // messageType,
+      // messageId,
+
+      threadId,
+      protocolName,
+      messageName,
+
+      protocolMajorVersion,
+      protocolMinorVersion,
+
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommMessageAdapterValues): DidCommMessageRecord {
+    const { customTags, messageName, protocolMajorVersion, protocolMinorVersion, protocolName, ...remainingValues } =
+      values
+
+    const record = JsonTransformer.fromJSON(remainingValues, DidCommMessageRecord)
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/didcomm/didcomm-message/index.ts

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

package/src/didcomm/didcomm-message/postgres.ts

@@ -0,0 +1,27 @@
+import { DidCommMessageRole, PlaintextMessage } from '@credo-ts/didcomm'
+import { jsonb, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const didcommMessageRoleEnum = pgEnum('DidcommMessageRole', DidCommMessageRole)
+
+export const didcommMessage = pgTable(
+  'DidcommMessage',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    message: jsonb().$type<PlaintextMessage>().notNull(),
+    role: didcommMessageRoleEnum().notNull(),
+
+    // We can't really put a foreign key on this...
+    // in that case we need to create a separate column for each possible record
+    associatedRecordId: text('associated_record_id'),
+
+    // Tags we can't query directy
+    threadId: text('thread_id').notNull(),
+    protocolName: text('protocol_name').notNull(),
+    messageName: text('message_name').notNull(),
+    protocolMajorVersion: text('protocol_major_version').notNull(),
+    protocolMinorVersion: text('protocol_minor_version').notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'didcommMessage')
+)

package/src/didcomm/didcomm-message/sqlite.ts

@@ -0,0 +1,26 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+import { DidCommMessageRole, PlaintextMessage } from '@credo-ts/didcomm'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const didcommMessage = sqliteTable(
+  'DidcommMessage',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    message: text({ mode: 'json' }).$type<PlaintextMessage>().notNull(),
+    role: text().$type<DidCommMessageRole>().notNull(),
+
+    // We can't really put a foreign key on this...
+    // in that case we need to create a separate column for each possible record
+    associatedRecordId: text('associated_record_id'),
+
+    // Tags we can't query directy
+    threadId: text('thread_id').notNull(),
+    protocolName: text('protocol_name').notNull(),
+    messageName: text('message_name').notNull(),
+    protocolMajorVersion: text('protocol_major_version').notNull(),
+    protocolMinorVersion: text('protocol_minor_version').notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'didcommMessage')
+)

package/src/didcomm/mediation/DrizzleDidcommMediationRecordAdapter.ts

@@ -0,0 +1,51 @@
+import { JsonTransformer } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { MediationRecord } from '@credo-ts/didcomm'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommMediationAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommMediation']>
+export class DrizzleDidcommMediationRecordAdapter extends BaseDrizzleRecordAdapter<
+  MediationRecord,
+  typeof postgres.didcommMediation,
+  typeof postgres,
+  typeof sqlite.didcommMediation,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.didcommMediation, sqlite: sqlite.didcommMediation }, 'MediationRecord')
+  }
+
+  public getValues(record: MediationRecord): DrizzleAdapterValues<(typeof sqlite)['didcommMediation']> {
+    const { connectionId, recipientKeys, role, state, threadId, default: defaultTag, ...customTags } = record.getTags()
+
+    return {
+      connectionId,
+      recipientKeys,
+      role,
+      state,
+      threadId,
+      default: defaultTag,
+      routingKeys: record.routingKeys,
+      endpoint: record.endpoint,
+      pickupStrategy: record.pickupStrategy,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommMediationAdapterValues): MediationRecord {
+    const { customTags, default: defaultTag, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, MediationRecord)
+    record.setTags({ ...customTags, default: defaultTag ?? undefined })
+
+    return record
+  }
+}

package/src/didcomm/mediation/index.ts

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

package/src/didcomm/mediation/postgres.ts

@@ -0,0 +1,33 @@
+import { MediationRole, MediationState, MediatorPickupStrategy } from '@credo-ts/didcomm'
+import { boolean, foreignKey, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+import { didcommConnection } from '../postgres'
+
+export const didcommMediationStateEnum = pgEnum('DidcommMediationState', MediationState)
+export const didcommMediationRoleEnum = pgEnum('DidcommMediationRole', MediationRole)
+export const didcommMediationPickupStrategyEnum = pgEnum('DidcommMediationPickupStrategry', MediatorPickupStrategy)
+
+export const didcommMediation = pgTable(
+  'DidcommMediation',
+  {
+    ...getPostgresBaseRecordTable(),
+    state: didcommMediationStateEnum().notNull(),
+    role: didcommMediationRoleEnum().notNull(),
+    connectionId: text('connection_id').notNull(),
+    threadId: text('thread_id').notNull(),
+    endpoint: text(),
+
+    recipientKeys: text('recipient_keys').array().notNull(),
+    routingKeys: text('routing_keys').array().notNull(),
+    pickupStrategy: didcommMediationPickupStrategyEnum('pickup_strategy'),
+
+    default: boolean(),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'didcommMediation'),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/didcomm/mediation/sqlite.ts

@@ -0,0 +1,31 @@
+import { foreignKey, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+import { MediationRole, MediationState, MediatorPickupStrategy } from '@credo-ts/didcomm'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+import { didcommConnection } from '../sqlite'
+
+export const didcommMediation = sqliteTable(
+  'DidcommMediation',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    state: text().$type<MediationState>().notNull(),
+    role: text().$type<MediationRole>().notNull(),
+    connectionId: text('connection_id').notNull(),
+    threadId: text('thread_id').notNull(),
+    endpoint: text(),
+
+    recipientKeys: text('recipient_keys', { mode: 'json' }).$type<string[]>().notNull(),
+    routingKeys: text('routing_keys', { mode: 'json' }).$type<string[]>().notNull(),
+    pickupStrategy: text('pickup_strategy').$type<MediatorPickupStrategy>(),
+
+    default: integer({ mode: 'boolean' }),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'didcommMediation'),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/didcomm/mediator-routing/DrizzleDidcommMediatorRoutingRecordAdapter.ts

@@ -0,0 +1,49 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { MediatorRoutingRecord } from '@credo-ts/didcomm'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommMediatorRoutingAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommMediatorRouting']>
+export class DrizzleDidcommMediatorRoutingRecordAdapter extends BaseDrizzleRecordAdapter<
+  MediatorRoutingRecord,
+  typeof postgres.didcommMediatorRouting,
+  typeof postgres,
+  typeof sqlite.didcommMediatorRouting,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.didcommMediatorRouting, sqlite: sqlite.didcommMediatorRouting },
+      'MediatorRoutingRecord'
+    )
+  }
+
+  public getValues(record: MediatorRoutingRecord): DrizzleAdapterValues<(typeof sqlite)['didcommMediatorRouting']> {
+    const { routingKeyFingerprints, ...customTags } = record.getTags()
+
+    return {
+      routingKeyFingerprints,
+      routingKeys: record.routingKeys,
+
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommMediatorRoutingAdapterValues): MediatorRoutingRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, MediatorRoutingRecord)
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/didcomm/mediator-routing/index.ts

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

package/src/didcomm/mediator-routing/postgres.ts

@@ -0,0 +1,14 @@
+import { MediatorRoutingRecordRoutingKey } from '@credo-ts/didcomm'
+import { jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const didcommMediatorRouting = pgTable(
+  'DidcommMediatorRouting',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    routingKeys: jsonb('routing_keys').$type<Array<string | MediatorRoutingRecordRoutingKey>>().notNull(),
+    routingKeyFingerprints: text('routing_key_fingerprints').array().notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'didcommMediatorRouting')
+)

package/src/didcomm/mediator-routing/sqlite.ts

@@ -0,0 +1,17 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+import { MediatorRoutingRecordRoutingKey } from '@credo-ts/didcomm'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const didcommMediatorRouting = sqliteTable(
+  'DidcommMediatorRouting',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    routingKeys: text('routing_keys', { mode: 'json' })
+      .$type<Array<string | MediatorRoutingRecordRoutingKey>>()
+      .notNull(),
+    routingKeyFingerprints: text('routing_key_fingerprints', { mode: 'json' }).$type<string[]>().notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'didcommMediatorRouting')
+)

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

@@ -0,0 +1,85 @@
+import { JsonTransformer } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { OutOfBandRecord } from '@credo-ts/didcomm'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommOutOfBandAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommOutOfBand']>
+export class DrizzleDidcommOutOfBandRecordAdapter extends BaseDrizzleRecordAdapter<
+  OutOfBandRecord,
+  typeof postgres.didcommOutOfBand,
+  typeof postgres,
+  typeof sqlite.didcommOutOfBand,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.didcommOutOfBand, sqlite: sqlite.didcommOutOfBand }, 'OutOfBandRecord')
+  }
+
+  public tagKeyMapping = {
+    invitationId: ['outOfBandInvitation', '@id'],
+  } as const
+
+  public getValues(record: OutOfBandRecord): DrizzleAdapterValues<(typeof sqlite)['didcommOutOfBand']> {
+    const {
+      invitationRequestsThreadIds,
+      recipientKeyFingerprints,
+      role,
+      state,
+      threadId,
+      recipientRoutingKeyFingerprint,
+
+      // Queried based on `outOfBandInvitation.@id`
+      invitationId,
+
+      ...customTags
+    } = record.getTags()
+
+    return {
+      invitationRequestsThreadIds,
+      role,
+      state,
+      threadId,
+
+      recipientKeyFingerprints,
+      recipientRoutingKeyFingerprint,
+
+      outOfBandInvitation: record.outOfBandInvitation.toJSON(),
+      reusable: record.reusable,
+      alias: record.alias,
+      autoAcceptConnection: record.autoAcceptConnection,
+      invitationInlineServiceKeys: record.invitationInlineServiceKeys,
+      mediatorId: record.mediatorId,
+      reuseConnectionId: record.reuseConnectionId,
+
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommOutOfBandAdapterValues): OutOfBandRecord {
+    const {
+      customTags,
+      recipientKeyFingerprints,
+      recipientRoutingKeyFingerprint,
+      threadId,
+      invitationRequestsThreadIds,
+      ...remainingValues
+    } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, OutOfBandRecord)
+    record.setTags({
+      ...customTags,
+      recipientKeyFingerprints: recipientKeyFingerprints ?? undefined,
+      recipientRoutingKeyFingerprint: recipientRoutingKeyFingerprint ?? undefined,
+    })
+
+    return record
+  }
+}

package/src/didcomm/out-of-band/__tests__/outOfBand.test.ts

@@ -0,0 +1,84 @@
+import { Agent, JsonTransformer } from '@credo-ts/core'
+
+import { OutOfBandRecord, OutOfBandRepository } from '@credo-ts/didcomm'
+import { setupDrizzleRecordTest } from '../../../../tests/testDatabase'
+import { didcommOutOfBandDrizzleRecord } from '../index'
+
+describe.each(['postgres', 'sqlite'] as const)('OutOfBandRecord with %s', (type) => {
+  let agent: Agent
+
+  beforeAll(async () => {
+    agent = await setupDrizzleRecordTest(type, didcommOutOfBandDrizzleRecord)
+  })
+
+  test('create, retrieve, update, query and delete out of band record', async () => {
+    const outOfBand = JsonTransformer.fromJSON(
+      {
+        _tags: {},
+        metadata: {},
+        id: 'd565b4d8-3e5d-42da-a87c-4454fdfbaff0',
+        createdAt: '2022-06-02T18:35:06.374Z',
+        outOfBandInvitation: {
+          '@type': 'https://didcomm.org/out-of-band/1.1/invitation',
+          '@id': '5d57ca2d-80ed-432c-8def-c40c75e8ab09',
+          label: 'Faber College',
+          goalCode: 'p2p-messaging',
+          goal: 'To make a connection',
+          accept: ['didcomm/aip1', 'didcomm/aip2;env=rfc19'],
+          handshake_protocols: ['https://didcomm.org/didexchange/1.0', 'https://didcomm.org/connections/1.0'],
+          services: [
+            {
+              id: '#inline-0',
+              serviceEndpoint: 'rxjs:faber',
+              type: 'did-communication',
+              recipientKeys: ['did:key:z6MkhngxtGfzTvGVbFjVVqBHvniY1f2XrTMZLM5BZvPh31Dc'],
+              routingKeys: [],
+            },
+          ],
+        },
+        role: 'sender',
+        state: 'await-response',
+        autoAcceptConnection: true,
+        reusable: false,
+      },
+      OutOfBandRecord
+    )
+    const outOfBandRepository = agent.context.resolve(OutOfBandRepository)
+
+    await outOfBandRepository.save(agent.context, outOfBand)
+
+    const outOfBand2 = await outOfBandRepository.findById(agent.context, outOfBand.id)
+    expect(outOfBand.toJSON()).toEqual(outOfBand2?.toJSON())
+
+    outOfBand.setTags({
+      myCustomTag: 'hello',
+      isMorning: false,
+    })
+    await outOfBandRepository.update(agent.context, outOfBand)
+
+    const [outOfBand3] = await outOfBandRepository.findByQuery(agent.context, {
+      isMorning: false,
+
+      // Tests custom tag mapping (invitationId -> outOfBandInvitation[@id])
+      invitationId: '5d57ca2d-80ed-432c-8def-c40c75e8ab09',
+    })
+    expect(outOfBand3.toJSON()).toEqual(outOfBand.toJSON())
+
+    const [outOfBand4] = await outOfBandRepository.findByQuery(agent.context, {
+      isMorning: false,
+      // Id does not exist
+      invitationId: 'a0b7c554-0beb-4a4c-808a-fd4495241770',
+    })
+    expect(outOfBand4).toBeUndefined()
+
+    expect(
+      await outOfBandRepository.findByQuery(agent.context, {
+        myCustomTag: 'not-hello',
+      })
+    ).toHaveLength(0)
+
+    await outOfBandRepository.deleteById(agent.context, outOfBand.id)
+
+    expect(await outOfBandRepository.findByQuery(agent.context, {})).toHaveLength(0)
+  })
+})

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

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