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

package/src/adapter/queryToDrizzleSqlite.ts

@@ -0,0 +1,213 @@
+import { BaseRecord, Query } from '@credo-ts/core'
+import { SQL, SQLWrapper, and, eq, not, or, sql } from 'drizzle-orm'
+import { sqliteTable } from 'drizzle-orm/sqlite-core'
+import type { AnySQLiteColumn, SQLiteColumn } from 'drizzle-orm/sqlite-core'
+import { CredoDrizzleStorageError } from '../error'
+import { getSqliteBaseRecordTable } from '../sqlite'
+import { DrizzleCustomTagKeyMapping } from './queryToDrizzlePostgres'
+
+/**
+ * Checks if an array column (stored as JSON text in SQLite) contains all values from the given array
+ * This ensures that the provided values array is a subset of the stored array
+ *
+ * @param column The column storing the JSON array
+ * @param values Array of values that should be contained in the column
+ * @returns SQL condition that checks if all values are in the array
+ */
+function arrayContainsAll<T extends AnySQLiteColumn>(column: T, values: unknown[]): SQL<unknown> {
+  if (values.length === 0) {
+    return sql`1=1` // Empty array always matches
+  }
+
+  return sql.join(
+    values.map((value) => sql`EXISTS (SELECT 1 FROM json_each(${column}) WHERE value = ${value})`),
+    sql` AND `
+  )
+}
+
+/**
+ * Checks if a JSON array within a JSON object contains all values from a given array
+ *
+ * @param column The column storing the JSON object
+ * @param path Path to the JSON array property
+ * @param values Array of values to check for containment
+ * @returns SQL condition that checks if all values are contained in the array
+ */
+function jsonArrayContainsAll<T extends AnySQLiteColumn>(column: T, tag: string, values: unknown[]): SQL<unknown> {
+  if (values.length === 0) {
+    return sql`1=1` // Empty array always matches
+  }
+
+  const jsonPath = `$."${tag}"`
+  return sql.join(
+    values.map(
+      (value) => sql`EXISTS (SELECT 1 FROM json_each(json_extract(${column}, ${jsonPath})) WHERE value = ${value})`
+    ),
+    sql` AND `
+  )
+}
+/**
+ * Converts a WQL object to Drizzle SQLite where conditions
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+export function queryToDrizzleSqlite<CredoRecord extends BaseRecord<any, any, any> = BaseRecord>(
+  query: Query<CredoRecord>,
+  table: ReturnType<typeof sqliteTable<string, ReturnType<typeof getSqliteBaseRecordTable>>>,
+  customTagKeyMapping?: DrizzleCustomTagKeyMapping
+): SQL {
+  // Handle empty WQL
+  if (!query || Object.keys(query).length === 0) {
+    return sql`1=1`
+  }
+
+  const conditions: Array<SQLWrapper> = []
+
+  // Process $or operator
+  if (query.$or && Array.isArray(query.$or) && query.$or.length > 0) {
+    const _$or = query.$or as Query<BaseRecord>[]
+
+    const orCondition = or(
+      ..._$or
+        .map((orItem) => queryToDrizzleSqlite(orItem, table, customTagKeyMapping))
+        .filter((sql) => sql !== undefined)
+    )
+    if (orCondition) {
+      conditions.push(orCondition)
+    }
+  }
+
+  // Process $and operator
+  if (query.$and && Array.isArray(query.$and) && query.$and.length > 0) {
+    const _$and = query.$and as Query<BaseRecord>[]
+
+    const andCondition = and(
+      ..._$and
+        .map((andItem) => queryToDrizzleSqlite(andItem, table, customTagKeyMapping))
+        .filter((sql) => sql !== undefined)
+    )
+    if (andCondition) {
+      conditions.push(andCondition)
+    }
+  }
+
+  // Process $not operator
+  if (query.$not) {
+    const notQuery = query.$not as Query<BaseRecord>
+    const notConditions: Array<SQLWrapper> = []
+
+    // Process $and within $not - all statements must be false
+    if (notQuery.$and && Array.isArray(notQuery.$and) && notQuery.$and.length > 0) {
+      const _$and = notQuery.$and as Query<BaseRecord>[]
+
+      // We need NOT(condition1 OR condition2 OR condition3)
+      // This is equivalent to NOT(condition1) AND NOT(condition2) AND NOT(condition3)
+      const andNotConditions = _$and
+        .map((andItem) => {
+          const condition = queryToDrizzleSqlite(andItem, table, customTagKeyMapping)
+          return condition ? not(condition) : undefined
+        })
+        .filter((condition) => condition !== undefined)
+
+      const andCondition = and(...andNotConditions)
+      if (andCondition) {
+        notConditions.push(andCondition)
+      }
+    }
+
+    // Process $or within $not - at least one statement must be false
+    if (notQuery.$or && Array.isArray(notQuery.$or) && notQuery.$or.length > 0) {
+      const _$or = notQuery.$or as Query<BaseRecord>[]
+
+      // We need at least one false, so NOT(condition1 AND condition2 AND condition3)
+      const orCondition = and(
+        ..._$or.map((orItem) => queryToDrizzleSqlite(orItem, table, customTagKeyMapping)).filter(Boolean)
+      )
+
+      if (orCondition) {
+        notConditions.push(not(orCondition))
+      }
+    }
+
+    // Process other fields in $not
+    for (const field in notQuery) {
+      if (field === '$not') {
+        throw new CredoDrizzleStorageError('Nested $not in $not is not supported')
+      }
+
+      if (field === '$or' || field === '$and') {
+        continue
+      }
+
+      const condition = queryToDrizzleSqlite(
+        { [field]: notQuery[field as keyof typeof notQuery] } as Query<BaseRecord>,
+        table,
+        customTagKeyMapping
+      )
+      if (condition) {
+        notConditions.push(not(condition))
+      }
+    }
+
+    // Combine all $not conditions with AND
+    const combinedNotCondition = notConditions.length === 1 ? notConditions[0] : and(...notConditions)
+    if (combinedNotCondition) {
+      conditions.push(combinedNotCondition)
+    }
+  }
+
+  // Process regular field conditions
+  for (const field in query) {
+    // Skip special operators we've already handled
+    if (field === '$or' || field === '$and' || field === '$not') {
+      continue
+    }
+
+    const value = query[field as keyof typeof query]
+
+    // Skip undefined values
+    if (value === undefined) continue
+
+    // Check if the field exists in the table
+    // In that case, query the column
+    if (field in table && table[field as keyof typeof table] instanceof Object) {
+      const column = table[field as keyof typeof table] as AnySQLiteColumn
+      if (Array.isArray(value)) {
+        conditions.push(arrayContainsAll(column, value))
+      } else {
+        conditions.push(eq(column, value))
+      }
+    } else {
+      // Check if field has a custom mapping
+      let targetField = field
+      let targetColumn: SQLiteColumn = table.customTags
+
+      if (customTagKeyMapping && field in customTagKeyMapping) {
+        const mapping = customTagKeyMapping[field]
+        const [columnName, fieldName] = mapping
+
+        if (columnName in table && table[columnName as keyof typeof table] instanceof Object) {
+          // Check if the mapped column exists in the table
+          targetColumn = table[columnName as keyof typeof table] as AnySQLiteColumn
+          targetField = fieldName
+        } else {
+          throw new CredoDrizzleStorageError(
+            `Query defined custom mapping from key '${field}' to column ${columnName}, but the column does not exist in the table.`
+          )
+        }
+      }
+
+      // Handle custom tag or mapped field
+      if (Array.isArray(value)) {
+        conditions.push(jsonArrayContainsAll(targetColumn, targetField, value))
+      } else {
+        const jsonPath = `$."${targetField}"`
+        // For scalar values, we need to extract and compare in SQLite syntax
+        conditions.push(eq(sql`json_extract(${targetColumn}, ${jsonPath})`, value))
+      }
+    }
+  }
+
+  // Combine all conditions with AND
+  return conditions.length === 1 ? conditions[0].getSQL() : (and(...conditions) ?? sql`1=1`)
+}

package/src/anoncreds/bundle.ts

@@ -0,0 +1,34 @@
+import type { DrizzleRecordBundle } from '../DrizzleRecord'
+import { anonCredsCredentialDrizzleRecord } from './credential'
+import { anonCredsCredentialDefinitionDrizzleRecord } from './credential-definition'
+import { anonCredsCredentialDefinitionPrivateDrizzleRecord } from './credential-definition-private'
+import { anonCredsKeyCorrectnessProofDrizzleRecord } from './key-correctness-proof'
+import { anonCredsLinkSecretDrizzleRecord } from './link-secret'
+import { anonCredsRevocationRegistryDefinitionDrizzleRecord } from './revocation-registry-definition'
+import { anonCredsRevocationRegistryDefinitionPrivateDrizzleRecord } from './revocation-registry-definition-private'
+import { anonCredsSchemaDrizzleRecord } from './schema'
+
+export default {
+  name: 'anoncreds',
+  records: [
+    anonCredsCredentialDrizzleRecord,
+    anonCredsCredentialDefinitionDrizzleRecord,
+    anonCredsCredentialDefinitionPrivateDrizzleRecord,
+    anonCredsKeyCorrectnessProofDrizzleRecord,
+    anonCredsLinkSecretDrizzleRecord,
+    anonCredsRevocationRegistryDefinitionDrizzleRecord,
+    anonCredsRevocationRegistryDefinitionPrivateDrizzleRecord,
+    anonCredsSchemaDrizzleRecord,
+  ],
+
+  migrations: {
+    postgres: {
+      schemaModule: '@credo-ts/drizzle-storage/anoncreds/postgres',
+      migrationsPath: '../../migrations/anoncreds/postgres',
+    },
+    sqlite: {
+      schemaModule: '@credo-ts/drizzle-storage/anoncreds/sqlite',
+      migrationsPath: '../../migrations/anoncreds/sqlite',
+    },
+  },
+} as const satisfies DrizzleRecordBundle

package/src/anoncreds/credential/DrizzleAnonCredsCredentialRecordAdapter.ts

@@ -0,0 +1,93 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { AnonCredsCredentialRecord } from '@credo-ts/anoncreds'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleAnonCredsCredentialAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['anonCredsCredential']>
+export class DrizzleAnonCredsCredentialRecordAdapter extends BaseDrizzleRecordAdapter<
+  AnonCredsCredentialRecord,
+  typeof postgres.anonCredsCredential,
+  typeof postgres,
+  typeof sqlite.anonCredsCredential,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.anonCredsCredential, sqlite: sqlite.anonCredsCredential },
+      'AnonCredsCredentialRecord'
+    )
+  }
+
+  public getValues(record: AnonCredsCredentialRecord) {
+    const {
+      credentialId,
+      linkSecretId,
+      credentialDefinitionId,
+      credentialRevocationId,
+      revocationRegistryId,
+      schemaId,
+      methodName,
+      schemaName,
+      schemaVersion,
+      schemaIssuerId,
+      issuerId,
+      ...customTags
+    } = record.getTags()
+
+    const { schema_id, cred_def_id, rev_reg_id, ...credentialRest } = record.credential
+
+    return {
+      credentialId,
+      credentialRevocationId,
+      linkSecretId,
+      methodName,
+
+      credential: credentialRest,
+      credentialDefinitionId,
+      revocationRegistryId,
+      schemaId,
+
+      schemaName,
+      schemaVersion,
+      schemaIssuerId,
+      issuerId,
+
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleAnonCredsCredentialAdapterValues): AnonCredsCredentialRecord {
+    const {
+      customTags,
+      schemaId,
+      revocationRegistryId,
+      credentialDefinitionId,
+      schemaName,
+      schemaVersion,
+      schemaIssuerId,
+      issuerId,
+      ...remainingValues
+    } = values
+
+    const record = JsonTransformer.fromJSON(
+      {
+        ...remainingValues,
+        credential: {
+          ...remainingValues.credential,
+          schema_id: schemaId,
+          cred_def_id: credentialDefinitionId,
+          rev_reg_id: revocationRegistryId,
+        },
+      },
+      AnonCredsCredentialRecord
+    )
+    record.setTags({ ...customTags, schemaName, schemaVersion, schemaIssuerId, issuerId } as TagsBase)
+
+    return record
+  }
+}

package/src/anoncreds/credential/index.ts

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

package/src/anoncreds/credential/postgres.ts

@@ -0,0 +1,27 @@
+import type { AnonCredsCredential } from '@credo-ts/anoncreds'
+import { jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const anonCredsCredential = pgTable(
+  'AnonCredsCredential',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    credentialId: text('credential_id').notNull().unique(),
+    credentialRevocationId: text('credential_revocation_id'),
+    linkSecretId: text('link_secret_id').notNull(),
+    credential: jsonb('credential')
+      .$type<Omit<AnonCredsCredential, 'schema_id' | 'cred_def_id' | 'rev_reg_id'>>()
+      .notNull(),
+    methodName: text('method_name').notNull(),
+
+    credentialDefinitionId: text('credential_definition_id').notNull(),
+    revocationRegistryId: text('revocation_registry_id'),
+    schemaId: text('schema_id').notNull(),
+    schemaName: text('schema_name').notNull(),
+    schemaVersion: text('schema_version').notNull(),
+    schemaIssuerId: text('schema_issuer_id').notNull(),
+    issuerId: text('issuer_id').notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'anonCredsCredential')
+)

package/src/anoncreds/credential/sqlite.ts

@@ -0,0 +1,27 @@
+import type { AnonCredsCredential } from '@credo-ts/anoncreds'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const anonCredsCredential = sqliteTable(
+  'AnonCredsCredential',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    credentialId: text('credential_id').notNull(),
+    credentialRevocationId: text('credential_revocation_id'),
+    linkSecretId: text('link_secret_id').notNull(),
+    credential: text('credential', { mode: 'json' })
+      .$type<Omit<AnonCredsCredential, 'schema_id' | 'cred_def_id' | 'rev_reg_id'>>()
+      .notNull(),
+    methodName: text('method_name').notNull(),
+
+    credentialDefinitionId: text('credential_definition_id').notNull(),
+    revocationRegistryId: text('revocation_registry_id'),
+    schemaId: text('schema_id').notNull(),
+    schemaName: text('schema_name').notNull(),
+    schemaVersion: text('schema_version').notNull(),
+    schemaIssuerId: text('schema_issuer_id').notNull(),
+    issuerId: text('issuer_id').notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'anonCredsCredential')
+)

package/src/anoncreds/credential-definition/DrizzleAnonCredsCredentialDefinitionRecordAdapter.ts

@@ -0,0 +1,72 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { AnonCredsCredentialDefinitionRecord } from '@credo-ts/anoncreds'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleAnonCredsCredentialDefinitionAdapterValues = DrizzleAdapterRecordValues<
+  (typeof sqlite)['anonCredsCredentialDefinition']
+>
+export class DrizzleAnonCredsCredentialDefinitionRecordAdapter extends BaseDrizzleRecordAdapter<
+  AnonCredsCredentialDefinitionRecord,
+  typeof postgres.anonCredsCredentialDefinition,
+  typeof postgres,
+  typeof sqlite.anonCredsCredentialDefinition,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.anonCredsCredentialDefinition, sqlite: sqlite.anonCredsCredentialDefinition },
+      'AnonCredsCredentialDefinitionRecord'
+    )
+  }
+
+  public getValues(record: AnonCredsCredentialDefinitionRecord) {
+    const {
+      schemaId: schemaIdTag,
+      credentialDefinitionId,
+      issuerId: issuerIdTag,
+      tag: tagTag,
+      methodName,
+      unqualifiedCredentialDefinitionId,
+      ...customTags
+    } = record.getTags()
+
+    const { issuerId, schemaId, tag, ...credentialDefinitionRest } = record.credentialDefinition
+
+    return {
+      credentialDefinitionId,
+      methodName,
+      unqualifiedCredentialDefinitionId,
+
+      schemaId,
+      issuerId,
+      tag,
+      credentialDefinition: credentialDefinitionRest,
+
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleAnonCredsCredentialDefinitionAdapterValues): AnonCredsCredentialDefinitionRecord {
+    const { customTags, unqualifiedCredentialDefinitionId, issuerId, schemaId, tag, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(
+      {
+        ...remainingValues,
+        credentialDefinition: { ...remainingValues.credentialDefinition, issuerId, schemaId, tag },
+      },
+      AnonCredsCredentialDefinitionRecord
+    )
+    record.setTags({
+      ...customTags,
+      unqualifiedCredentialDefinitionId: unqualifiedCredentialDefinitionId ?? undefined,
+    } as TagsBase)
+
+    return record
+  }
+}

package/src/anoncreds/credential-definition/index.ts

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

package/src/anoncreds/credential-definition/postgres.ts

@@ -0,0 +1,23 @@
+import type { AnonCredsCredentialDefinition } from '@credo-ts/anoncreds'
+import { jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const anonCredsCredentialDefinition = pgTable(
+  'AnonCredsCredentialDefinition',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    credentialDefinitionId: text('credential_definition_id').notNull().unique(),
+    credentialDefinition: jsonb('credential_definition')
+      .$type<Omit<AnonCredsCredentialDefinition, 'issuerId' | 'schemaId' | 'tag'>>()
+      .notNull(),
+    methodName: text('method_name').notNull(),
+
+    // These are extracted from the credential definition JSON object, to allow for easy querying based on tags
+    schemaId: text('schema_id').notNull(),
+    issuerId: text('issuer_id').notNull(),
+    tag: text('tag').notNull(),
+    unqualifiedCredentialDefinitionId: text('unqualified_credential_definition_id'),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'anonCredsCredentialDefinition')
+)

package/src/anoncreds/credential-definition/sqlite.ts

@@ -0,0 +1,23 @@
+import type { AnonCredsCredentialDefinition } from '@credo-ts/anoncreds'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const anonCredsCredentialDefinition = sqliteTable(
+  'AnonCredsCredentialDefinition',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    credentialDefinitionId: text('credential_definition_id').notNull().unique(),
+    credentialDefinition: text('credential_definition', { mode: 'json' })
+      .$type<Omit<AnonCredsCredentialDefinition, 'issuerId' | 'schemaId' | 'tag'>>()
+      .notNull(),
+    methodName: text('method_name').notNull(),
+
+    // These are extracted from the credential definition JSON object, to allow for easy querying based on tags
+    schemaId: text('schema_id').notNull(),
+    issuerId: text('issuer_id').notNull(),
+    tag: text('tag').notNull(),
+    unqualifiedCredentialDefinitionId: text('unqualified_credential_definition_id'),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'anonCredsCredentialDefinition')
+)

package/src/anoncreds/credential-definition-private/DrizzleAnonCredsCredentialDefinitionPrivateRecordAdapter.ts

@@ -0,0 +1,48 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { AnonCredsCredentialDefinitionPrivateRecord } from '@credo-ts/anoncreds'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleAnonCredsCredentialDefinitionPrivateAdapterValues = DrizzleAdapterRecordValues<
+  (typeof sqlite)['anonCredsCredentialDefinitionPrivate']
+>
+export class DrizzleAnonCredsCredentialDefinitionPrivateRecordAdapter extends BaseDrizzleRecordAdapter<
+  AnonCredsCredentialDefinitionPrivateRecord,
+  typeof postgres.anonCredsCredentialDefinitionPrivate,
+  typeof postgres,
+  typeof sqlite.anonCredsCredentialDefinitionPrivate,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.anonCredsCredentialDefinitionPrivate, sqlite: sqlite.anonCredsCredentialDefinitionPrivate },
+      'AnonCredsCredentialDefinitionPrivateRecord'
+    )
+  }
+
+  public getValues(record: AnonCredsCredentialDefinitionPrivateRecord) {
+    const { credentialDefinitionId, ...customTags } = record.getTags()
+
+    return {
+      credentialDefinitionId,
+      value: record.value,
+      customTags,
+    }
+  }
+
+  public toRecord(
+    values: DrizzleAnonCredsCredentialDefinitionPrivateAdapterValues
+  ): AnonCredsCredentialDefinitionPrivateRecord {
+    const { customTags, credentialDefinitionId, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, AnonCredsCredentialDefinitionPrivateRecord)
+    record.setTags({ ...customTags, credentialDefinitionId } as TagsBase)
+
+    return record
+  }
+}

package/src/anoncreds/credential-definition-private/index.ts

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

package/src/anoncreds/credential-definition-private/postgres.ts

@@ -0,0 +1,14 @@
+import { jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const anonCredsCredentialDefinitionPrivate = pgTable(
+  'AnonCredsCredentialDefinitionPrivate',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    credentialDefinitionId: text('credential_definition_id').notNull().unique(),
+
+    value: jsonb('value').$type<Record<string, unknown>>().notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'anonCredsCredentialDefinitionPrivate')
+)

package/src/anoncreds/credential-definition-private/sqlite.ts

@@ -0,0 +1,14 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const anonCredsCredentialDefinitionPrivate = sqliteTable(
+  'AnonCredsCredentialDefinitionPrivate',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    credentialDefinitionId: text('credential_definition_id').notNull().unique(),
+
+    value: text('value', { mode: 'json' }).$type<Record<string, unknown>>().notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'anonCredsCredentialDefinitionPrivate')
+)

package/src/anoncreds/key-correctness-proof/DrizzleAnonCredsKeyCorrectnessProofRecordAdapter.ts

@@ -0,0 +1,46 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { AnonCredsKeyCorrectnessProofRecord } from '@credo-ts/anoncreds'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleAnonCredsKeyCorrectnessProofAdapterValues = DrizzleAdapterRecordValues<
+  (typeof sqlite)['anonCredsKeyCorrectnessProof']
+>
+export class DrizzleAnonCredsKeyCorrectnessProofRecordAdapter extends BaseDrizzleRecordAdapter<
+  AnonCredsKeyCorrectnessProofRecord,
+  typeof postgres.anonCredsKeyCorrectnessProof,
+  typeof postgres,
+  typeof sqlite.anonCredsKeyCorrectnessProof,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.anonCredsKeyCorrectnessProof, sqlite: sqlite.anonCredsKeyCorrectnessProof },
+      'AnonCredsKeyCorrectnessProofRecord'
+    )
+  }
+
+  public getValues(record: AnonCredsKeyCorrectnessProofRecord) {
+    const { credentialDefinitionId, ...customTags } = record.getTags()
+
+    return {
+      credentialDefinitionId,
+      value: record.value,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleAnonCredsKeyCorrectnessProofAdapterValues): AnonCredsKeyCorrectnessProofRecord {
+    const { customTags, credentialDefinitionId, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, AnonCredsKeyCorrectnessProofRecord)
+    record.setTags({ ...customTags, credentialDefinitionId } as TagsBase)
+
+    return record
+  }
+}