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

package/src/core/w3cCredential/DrizzleW3cCredentialRecordAdapter.ts

@@ -0,0 +1,95 @@
+import { JsonTransformer, W3cCredentialRecord } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleW3cCredentialAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['w3cCredential']>
+export class DrizzleW3cCredentialRecordAdapter extends BaseDrizzleRecordAdapter<
+  W3cCredentialRecord,
+  typeof postgres.w3cCredential,
+  typeof postgres,
+  typeof sqlite.w3cCredential,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.w3cCredential, sqlite: sqlite.w3cCredential }, 'W3cCredentialRecord')
+  }
+
+  public getValues(record: W3cCredentialRecord) {
+    const {
+      // Default Tags
+      issuerId,
+      subjectIds,
+      schemaIds,
+      contexts,
+      types,
+      givenId,
+      claimFormat,
+      proofTypes,
+      cryptosuites,
+      algs,
+
+      // Custom Tags
+      expandedTypes,
+      ...customTags
+    } = record.getTags()
+
+    return {
+      // JWT vc is string, JSON-LD vc is object
+      credential: record.credential.encoded,
+
+      // Tags
+      issuerId,
+      subjectIds,
+      schemaIds,
+      contexts,
+      types,
+      givenId,
+      claimFormat,
+      proofTypes,
+      cryptosuites,
+      algs,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleW3cCredentialAdapterValues): W3cCredentialRecord {
+    const {
+      // Tags
+      issuerId,
+      subjectIds,
+      schemaIds,
+      contexts,
+      types,
+      givenId,
+      claimFormat,
+      proofTypes,
+      cryptosuites,
+      algs,
+      expandedTypes,
+      customTags,
+      ...remainingValues
+    } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, W3cCredentialRecord)
+    record.setTags({
+      issuerId,
+      subjectIds,
+      schemaIds,
+      contexts,
+      types,
+      givenId: givenId ?? undefined,
+      claimFormat,
+      proofTypes: proofTypes ?? undefined,
+      cryptosuites: cryptosuites ?? undefined,
+      algs: algs ?? undefined,
+      expandedTypes: expandedTypes ?? undefined,
+      ...customTags,
+    })
+
+    return record
+  }
+}

package/src/core/w3cCredential/index.ts

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

package/src/core/w3cCredential/postgres.ts

@@ -0,0 +1,31 @@
+import { ClaimFormat, W3cVerifiableCredential } from '@credo-ts/core'
+import { jsonb, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const w3cCredentialClaimFormat = pgEnum('W3cClaimFormat', [ClaimFormat.LdpVc, ClaimFormat.JwtVc])
+
+export const w3cCredential = pgTable(
+  'W3cCredential',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    // JWT vc is string, JSON-LD vc is object
+    credential: jsonb().$type<W3cVerifiableCredential['encoded']>().notNull(),
+
+    // Default Tags
+    issuerId: text('issuer_id').notNull(),
+    subjectIds: text('subject_ids').array().notNull(),
+    schemaIds: text('schema_ids').array().notNull(),
+    contexts: text().array().notNull(),
+    types: text().array().notNull(),
+    givenId: text('given_id'),
+    claimFormat: w3cCredentialClaimFormat('claim_format').notNull(),
+    proofTypes: text('proof_types').array(),
+    cryptosuites: text('crypto_suites').array(),
+    algs: text().array(),
+
+    // Custom Tags
+    expandedTypes: text('expanded_types').array(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'w3cCredential')
+)

package/src/core/w3cCredential/sqlite.ts

@@ -0,0 +1,29 @@
+import { ClaimFormat, W3cVerifiableCredential } from '@credo-ts/core'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const w3cCredential = sqliteTable(
+  'W3cCredential',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    // JWT vc is string, JSON-LD vc is object
+    credential: text({ mode: 'json' }).$type<W3cVerifiableCredential['encoded']>().notNull(),
+
+    // Default Tags
+    issuerId: text('issuer_id').notNull(),
+    subjectIds: text('subject_ids', { mode: 'json' }).$type<string[]>().notNull(),
+    schemaIds: text('schema_ids', { mode: 'json' }).$type<string[]>().notNull(),
+    contexts: text({ mode: 'json' }).$type<string[]>().notNull(),
+    types: text({ mode: 'json' }).$type<string[]>().notNull(),
+    givenId: text('given_id'),
+    claimFormat: text('claim_format').$type<ClaimFormat.LdpVc | ClaimFormat.JwtVc>().notNull(),
+    proofTypes: text('proof_types', { mode: 'json' }).$type<string[]>(),
+    cryptosuites: text('crypto_suites', { mode: 'json' }).$type<string[]>(),
+    algs: text({ mode: 'json' }).$type<string[]>(),
+
+    // Custom Tags
+    expandedTypes: text('expanded_types', { mode: 'json' }).$type<string[]>(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'w3cCredential')
+)

package/src/didcomm/basic-message/DrizzleDidcommBasicMessageRecordAdapter.ts

@@ -0,0 +1,54 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { BasicMessageRecord } from '@credo-ts/didcomm'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommBasicMessageAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommBasicMessage']>
+export class DrizzleDidcommBasicMessageRecordAdapter extends BaseDrizzleRecordAdapter<
+  BasicMessageRecord,
+  typeof postgres.didcommBasicMessage,
+  typeof postgres,
+  typeof sqlite.didcommBasicMessage,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.didcommBasicMessage, sqlite: sqlite.didcommBasicMessage },
+      'BasicMessageRecord'
+    )
+  }
+
+  public getValues(record: BasicMessageRecord): DrizzleAdapterValues<(typeof sqlite)['didcommBasicMessage']> {
+    const { role, connectionId, parentThreadId, threadId, ...customTags } = record.getTags()
+
+    return {
+      content: record.content,
+      sentTime: record.sentTime,
+
+      connectionId,
+      role,
+      threadId,
+      parentThreadId,
+
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommBasicMessageAdapterValues): BasicMessageRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, BasicMessageRecord)
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

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

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

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

@@ -0,0 +1,30 @@
+import { BasicMessageRole } from '@credo-ts/didcomm'
+import { foreignKey, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+import { didcommConnection } from '../postgres'
+
+export const didcommBasicMessageRoleEnum = pgEnum('DidcommBasicMessageRole', BasicMessageRole)
+
+export const didcommBasicMessage = pgTable(
+  'DidcommBasicMessage',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    content: text().notNull(),
+
+    // Not stored as date in Credo?
+    sentTime: text('sent_time').notNull(),
+
+    role: didcommBasicMessageRoleEnum().notNull(),
+    connectionId: text('connection_id'),
+    threadId: text('thread_id'),
+    parentThreadId: text('parent_thread_id'),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'didcommBasicMessage'),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

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

@@ -0,0 +1,29 @@
+import { foreignKey, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+import { BasicMessageRole } from '@credo-ts/didcomm'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+import { didcommConnection } from '../sqlite'
+
+export const didcommBasicMessage = sqliteTable(
+  'DidcommBasicMessage',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    content: text().notNull(),
+
+    // Not stored as date in Credo?
+    sentTime: text('sent_time').notNull(),
+
+    connectionId: text('connection_id'),
+    role: text().$type<BasicMessageRole>().notNull(),
+    threadId: text('thread_id'),
+    parentThreadId: text('parent_thread_id'),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'didcommBasicMessage'),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/didcomm/bundle.ts

@@ -0,0 +1,34 @@
+import { DrizzleRecordBundle } from '../DrizzleRecord'
+import { didcommBasicMessageDrizzleRecord } from './basic-message'
+import { didcommConnectionDrizzleRecord } from './connection'
+import { didcommCredentialExchangeDrizzleRecord } from './credential-exchange'
+import { didcommMessageDrizzleRecord } from './didcomm-message'
+import { didcommMediationDrizzleRecord } from './mediation'
+import { didcommMediatorRoutingDrizzleRecord } from './mediator-routing'
+import { didcommOutOfBandDrizzleRecord } from './out-of-band'
+import { didcommProofExchangeDrizzleRecord } from './proof-exchange'
+
+export default {
+  name: 'didcomm',
+  records: [
+    didcommBasicMessageDrizzleRecord,
+    didcommConnectionDrizzleRecord,
+    didcommCredentialExchangeDrizzleRecord,
+    didcommMessageDrizzleRecord,
+    didcommMediationDrizzleRecord,
+    didcommMediatorRoutingDrizzleRecord,
+    didcommOutOfBandDrizzleRecord,
+    didcommProofExchangeDrizzleRecord,
+  ],
+
+  migrations: {
+    postgres: {
+      schemaModule: '@credo-ts/drizzle-storage/didcomm/postgres',
+      migrationsPath: '../../migrations/didcomm/postgres',
+    },
+    sqlite: {
+      schemaModule: '@credo-ts/drizzle-storage/didcomm/sqlite',
+      migrationsPath: '../../migrations/didcomm/sqlite',
+    },
+  },
+} as const satisfies DrizzleRecordBundle

package/src/didcomm/connection/DrizzleDidcommConnectionRecordAdapter.ts

@@ -0,0 +1,70 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { ConnectionRecord } from '@credo-ts/didcomm'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommConnectionAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommConnection']>
+export class DrizzleDidcommConnectionRecordAdapter extends BaseDrizzleRecordAdapter<
+  ConnectionRecord,
+  typeof postgres.didcommConnection,
+  typeof postgres,
+  typeof sqlite.didcommConnection,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.didcommConnection, sqlite: sqlite.didcommConnection }, 'ConnectionRecord')
+  }
+
+  public getValues(record: ConnectionRecord) {
+    const {
+      state,
+      role,
+      threadId,
+      mediatorId,
+      did,
+      theirDid,
+      outOfBandId,
+      invitationDid,
+      connectionTypes,
+      previousDids,
+      previousTheirDids,
+      ...customTags
+    } = record.getTags()
+
+    return {
+      state,
+      role,
+      threadId,
+      mediatorId,
+      did,
+      theirDid,
+      outOfBandId,
+      invitationDid,
+      connectionTypes,
+      previousDids,
+      previousTheirDids,
+      alias: record.alias,
+      autoAcceptConnection: record.autoAcceptConnection,
+      errorMessage: record.errorMessage,
+      imageUrl: record.imageUrl,
+      theirLabel: record.theirLabel,
+      protocol: record.protocol,
+      // TOOD: Fix types
+      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+      customTags: customTags as any,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommConnectionAdapterValues): ConnectionRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, ConnectionRecord)
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/didcomm/connection/index.ts

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

package/src/didcomm/connection/postgres.ts

@@ -0,0 +1,55 @@
+import { boolean, pgEnum, pgTable, text, unique } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const didcommConnectionStateEnum = pgEnum('DidcommConnectionState', [
+  'start',
+  'invitation-sent',
+  'invitation-received',
+  'request-sent',
+  'request-received',
+  'response-sent',
+  'response-received',
+  'abandoned',
+  'completed',
+])
+
+export const didcommConnectionRoleEnum = pgEnum('DidcommConnectionRole', ['requester', 'responder'])
+
+export const didcommConnectionHandshakeProtocolEnum = pgEnum('DidcommConnectionHandshakeProtocol', [
+  'https://didcomm.org/didexchange/1.x',
+  'https://didcomm.org/connections/1.x',
+])
+
+export const didcommConnection = pgTable(
+  'DidcommConnection',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    state: didcommConnectionStateEnum().notNull(),
+    role: didcommConnectionRoleEnum().notNull(),
+
+    did: text(),
+    theirDid: text('their_did'),
+    theirLabel: text('their_label'),
+    alias: text(),
+    autoAcceptConnection: boolean('auto_accept_connection'),
+    imageUrl: text('image_url'),
+    threadId: text('thread_id'),
+    invitationDid: text('invitation_did'),
+
+    // TODO: references mediator/oob record
+    mediatorId: text('mediator_id'),
+    outOfBandId: text('out_of_band_id'),
+
+    errorMessage: text('error_message'),
+    protocol: didcommConnectionHandshakeProtocolEnum(),
+    connectionTypes: text('connection_types').array(),
+
+    previousDids: text('previous_dids').array(),
+    previousTheirDids: text('previous_their_dids').array(),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'didcommConnection'),
+    unique().on(table.contextCorrelationId, table.threadId),
+  ]
+)

package/src/didcomm/connection/sqlite.ts

@@ -0,0 +1,39 @@
+import { integer, sqliteTable, text, unique } from 'drizzle-orm/sqlite-core'
+
+import type { DidExchangeRole, DidExchangeState, HandshakeProtocol } from '@credo-ts/didcomm'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const didcommConnection = sqliteTable(
+  'DidcommConnection',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    state: text('state').$type<DidExchangeState>().notNull(),
+    role: text('role').$type<DidExchangeRole>().notNull(),
+
+    did: text('did'),
+    theirDid: text('their_did'),
+    theirLabel: text('their_label'),
+    alias: text('alias'),
+    autoAcceptConnection: integer('auto_accept_connection', { mode: 'boolean' }),
+    imageUrl: text('image_url'),
+    threadId: text('thread_id'),
+    invitationDid: text('invitation_did'),
+
+    // TODO: references mediator/oob record
+    mediatorId: text('mediator_id'),
+    outOfBandId: text('out_of_band_id'),
+
+    errorMessage: text('error_message'),
+    protocol: text('protocol').$type<HandshakeProtocol>(),
+
+    // Using JSON for array storage
+    connectionTypes: text('connection_types', { mode: 'json' }).$type<string[]>(),
+    previousDids: text('previous_dids', { mode: 'json' }).$type<string[]>(),
+    previousTheirDids: text('previous_their_dids', { mode: 'json' }).$type<string[]>(),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'didcommConnection'),
+    unique().on(table.contextCorrelationId, table.threadId),
+  ]
+)

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

@@ -0,0 +1,64 @@
+import { JsonObject, JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { CredentialExchangeRecord } from '@credo-ts/didcomm'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommCredentialExchangeAdapterValues = DrizzleAdapterRecordValues<
+  (typeof sqlite)['didcommCredentialExchange']
+>
+export class DrizzleDidcommCredentialExchangeRecordAdapter extends BaseDrizzleRecordAdapter<
+  CredentialExchangeRecord,
+  typeof postgres.didcommCredentialExchange,
+  typeof postgres,
+  typeof sqlite.didcommCredentialExchange,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.didcommCredentialExchange, sqlite: sqlite.didcommCredentialExchange },
+      'CredentialRecord'
+    )
+  }
+
+  public getValues(
+    record: CredentialExchangeRecord
+  ): DrizzleAdapterValues<(typeof sqlite)['didcommCredentialExchange']> {
+    const { connectionId, threadId, parentThreadId, state, role, credentialIds, ...customTags } = record.getTags()
+
+    return {
+      connectionId,
+      threadId,
+      parentThreadId,
+      state,
+      role,
+      autoAcceptCredential: record.autoAcceptCredential,
+      revocationNotification: JsonTransformer.toJSON(record.revocationNotification),
+      errorMessage: record.errorMessage,
+      protocolVersion: record.protocolVersion,
+      credentials: record.credentials,
+      credentialIds,
+      credentialAttributes: JsonTransformer.toJSON(record.credentialAttributes) as JsonObject[],
+      linkedAttachments: record.linkedAttachments?.map((a) => JsonTransformer.toJSON(a)),
+
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommCredentialExchangeAdapterValues): CredentialExchangeRecord {
+    const { customTags, credentialIds, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, CredentialExchangeRecord)
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/didcomm/credential-exchange/__tests__/credentialExchange.test.ts

@@ -0,0 +1,97 @@
+import { Agent, JsonTransformer } from '@credo-ts/core'
+
+import {
+  AutoAcceptCredential,
+  CredentialExchangeRecord,
+  CredentialRepository,
+  CredentialRole,
+  CredentialState,
+} from '@credo-ts/didcomm'
+import { setupDrizzleRecordTest } from '../../../../tests/testDatabase'
+import { didcommCredentialExchangeDrizzleRecord } from '../index'
+
+describe.each(['postgres', 'sqlite'] as const)('CredentialExchangeRecord with %s', (type) => {
+  let agent: Agent
+
+  beforeAll(async () => {
+    agent = await setupDrizzleRecordTest(type, didcommCredentialExchangeDrizzleRecord)
+  })
+
+  test('create, retrieve, update, query and delete credential exchange record', async () => {
+    const credentialExchange = JsonTransformer.fromJSON(
+      {
+        id: '6e7fcaf3-ebb9-45ed-9261-7b893f732bc1',
+        connectionId: '1eb24dc2-1d81-4249-baf9-783e03176fd3',
+        threadId: '1c92f4ff-e859-4086-bb09-ad979c63d6e5',
+        parentThreadId: '4b99cdca-847c-4083-8ea0-8880f2c410ff',
+        state: CredentialState.Abandoned,
+        role: CredentialRole.Holder,
+        autoAcceptCredential: AutoAcceptCredential.Always,
+        revocationNotification: {
+          revocationDate: new Date(),
+          comment: 'hello',
+        },
+        errorMessage: 'hello',
+        protocolVersion: '2',
+        credentials: [
+          {
+            credentialRecordType: 'w3c',
+            credentialRecordId: '8633f56d-abc9-4229-ba09-9ca6611ad8e4',
+          },
+        ],
+        credentialAttributes: [
+          {
+            name: 'hello',
+            'mime-type': 'application/json',
+            value: 'something',
+          },
+        ],
+        linkedAttachments: [
+          {
+            '@id': 'a402b029-6dfb-4840-97f3-b3b0f8e7ac49',
+            'mime-type': 'hello',
+            data: {
+              json: { some: 'key' },
+            },
+          },
+        ],
+      },
+      CredentialExchangeRecord
+    )
+    const credentialExchangeRepository = agent.context.resolve(CredentialRepository)
+
+    await credentialExchangeRepository.save(agent.context, credentialExchange)
+
+    const credentialExchange2 = await credentialExchangeRepository.findById(agent.context, credentialExchange.id)
+    expect(credentialExchange).toEqual(credentialExchange2)
+
+    credentialExchange.setTags({
+      myCustomTag: 'hello',
+      isMorning: false,
+    })
+    await credentialExchangeRepository.update(agent.context, credentialExchange)
+
+    const [credentialExchange3] = await credentialExchangeRepository.findByQuery(agent.context, {
+      isMorning: false,
+      credentialIds: ['8633f56d-abc9-4229-ba09-9ca6611ad8e4'],
+    })
+    expect(credentialExchange3).toEqual(credentialExchange)
+
+    const [credentialExchange4] = await credentialExchangeRepository.findByQuery(agent.context, {
+      isMorning: false,
+      // Id does not exist
+      credentialIds: ['a0b7c554-0beb-4a4c-808a-fd4495241770'],
+    })
+    expect(credentialExchange4).toBeUndefined()
+
+    expect(
+      await credentialExchangeRepository.findByQuery(agent.context, {
+        myCustomTag: 'not-hello',
+      })
+    ).toHaveLength(0)
+
+    await credentialExchangeRepository.deleteById(agent.context, credentialExchange.id)
+
+    expect(await credentialExchangeRepository.findByQuery(agent.context, {})).toHaveLength(0)
+  })
+})

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

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