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

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

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

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

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

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

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

package/src/anoncreds/link-secret/DrizzleAnonCredsLinkSecretRecordAdapter.ts

@@ -0,0 +1,45 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { AnonCredsLinkSecretRecord } from '@credo-ts/anoncreds'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleAnonCredsLinkSecretAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['anonCredsLinkSecret']>
+export class DrizzleAnonCredsLinkSecretRecordAdapter extends BaseDrizzleRecordAdapter<
+  AnonCredsLinkSecretRecord,
+  typeof postgres.anonCredsLinkSecret,
+  typeof postgres,
+  typeof sqlite.anonCredsLinkSecret,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.anonCredsLinkSecret, sqlite: sqlite.anonCredsLinkSecret },
+      'AnonCredsLinkSecretRecord'
+    )
+  }
+
+  public getValues(record: AnonCredsLinkSecretRecord) {
+    const { linkSecretId, isDefault, ...customTags } = record.getTags()
+
+    return {
+      linkSecretId,
+      isDefault,
+      value: record.value,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleAnonCredsLinkSecretAdapterValues): AnonCredsLinkSecretRecord {
+    const { customTags, isDefault, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, AnonCredsLinkSecretRecord)
+    record.setTags({ ...customTags, isDefault: isDefault ?? undefined } as TagsBase)
+
+    return record
+  }
+}

package/src/anoncreds/link-secret/index.ts

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

package/src/anoncreds/link-secret/postgres.ts

@@ -0,0 +1,18 @@
+import { boolean, pgTable, text, uniqueIndex } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const anonCredsLinkSecret = pgTable(
+  'AnonCredsLinkSecret',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    linkSecretId: text('link_secret_id').notNull(),
+    isDefault: boolean('is_default').notNull().default(false),
+
+    value: text('value'),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'anonCredsLinkSecret'),
+    uniqueIndex('link_secret_id_context_correlation_id_unique').on(table.linkSecretId, table.contextCorrelationId),
+  ]
+)

package/src/anoncreds/link-secret/sqlite.ts

@@ -0,0 +1,18 @@
+import { integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const anonCredsLinkSecret = sqliteTable(
+  'AnonCredsLinkSecret',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    linkSecretId: text('link_secret_id').notNull(),
+    isDefault: integer('is_default', { mode: 'boolean' }).notNull().default(false),
+
+    value: text('value'),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'anonCredsLinkSecret'),
+    uniqueIndex('link_secret_id_context_correlation_id_unique').on(table.linkSecretId, table.contextCorrelationId),
+  ]
+)

package/src/anoncreds/postgres.ts

@@ -0,0 +1,8 @@
+export * from './credential/postgres'
+export * from './credential-definition/postgres'
+export * from './credential-definition-private/postgres'
+export * from './key-correctness-proof/postgres'
+export * from './link-secret/postgres'
+export * from './revocation-registry-definition/postgres'
+export * from './revocation-registry-definition-private/postgres'
+export * from './schema/postgres'

package/src/anoncreds/revocation-registry-definition/DrizzleAnonCredsRevocationRegistryDefinitionRecordAdapter.ts

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

package/src/anoncreds/revocation-registry-definition/index.ts

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

package/src/anoncreds/revocation-registry-definition/postgres.ts

@@ -0,0 +1,18 @@
+import type { AnonCredsRevocationRegistryDefinition } from '@credo-ts/anoncreds'
+import { jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const anonCredsRevocationRegistryDefinition = pgTable(
+  'AnonCredsRevocationRegistryDefinition',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    revocationRegistryDefinitionId: text('revocation_registry_definition_id').notNull().unique(),
+    credentialDefinitionId: text('credential_definition_id').notNull(),
+
+    revocationRegistryDefinition: jsonb('revocation_registry_definition')
+      .$type<AnonCredsRevocationRegistryDefinition>()
+      .notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'anonCredsRevocationRegistryDefinition')
+)

package/src/anoncreds/revocation-registry-definition/sqlite.ts

@@ -0,0 +1,20 @@
+import type { AnonCredsRevocationRegistryDefinition } from '@credo-ts/anoncreds'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const anonCredsRevocationRegistryDefinition = sqliteTable(
+  'AnonCredsRevocationRegistryDefinition',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    revocationRegistryDefinitionId: text('revocation_registry_definition_id').notNull().unique(),
+    revocationRegistryDefinition: text('revocation_registry_definition', { mode: 'json' })
+      .$type<AnonCredsRevocationRegistryDefinition>()
+      .notNull(),
+
+    // This is duplicated from the revocation registry definition. Might want to
+    // dedupe by omitting that key from the json
+    credentialDefinitionId: text('credential_definition_id').notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'anonCredsRevocationRegistryDefinition')
+)

package/src/anoncreds/revocation-registry-definition-private/DrizzleAnonCredsRevocationRegistryDefinitionPrivateRecordAdapter.ts

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

package/src/anoncreds/revocation-registry-definition-private/index.ts

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

package/src/anoncreds/revocation-registry-definition-private/postgres.ts

@@ -0,0 +1,22 @@
+import { AnonCredsRevocationRegistryState } from '@credo-ts/anoncreds'
+import { jsonb, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const anonCredsRevocationRegistryStateEnum = pgEnum(
+  'AnonCredsRevocationRegistryState',
+  AnonCredsRevocationRegistryState
+)
+
+export const anonCredsRevocationRegistryDefinitionPrivate = pgTable(
+  'AnonCredsRevocationRegistryDefinitionPrivate',
+  {
+    ...getPostgresBaseRecordTable(),
+    state: anonCredsRevocationRegistryStateEnum('state').notNull(),
+
+    revocationRegistryDefinitionId: text('revocation_registry_definition_id').notNull().unique(),
+    credentialDefinitionId: text('credential_definition_id').notNull(),
+
+    value: jsonb('value').$type<Record<string, unknown>>().notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'anonCredsRevocationRegistryDefinitionPrivate')
+)

package/src/anoncreds/revocation-registry-definition-private/sqlite.ts

@@ -0,0 +1,18 @@
+import { AnonCredsRevocationRegistryState } from '@credo-ts/anoncreds'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const anonCredsRevocationRegistryDefinitionPrivate = sqliteTable(
+  'AnonCredsRevocationRegistryDefinitionPrivate',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    state: text('state').$type<AnonCredsRevocationRegistryState>().notNull(),
+
+    revocationRegistryDefinitionId: text('revocation_registry_definition_id').notNull().unique(),
+    credentialDefinitionId: text('credential_definition_id').notNull(),
+
+    value: text('value', { mode: 'json' }).$type<Record<string, unknown>>().notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'anonCredsRevocationRegistryDefinitionPrivate')
+)

package/src/anoncreds/schema/DrizzleAnonCredsSchemaRecordAdapter.ts

@@ -0,0 +1,54 @@
+import { JsonTransformer } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { AnonCredsSchemaRecord } from '@credo-ts/anoncreds'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleAnonCredsSchemaAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['anonCredsSchema']>
+export class DrizzleAnonCredsSchemaRecordAdapter extends BaseDrizzleRecordAdapter<
+  AnonCredsSchemaRecord,
+  typeof postgres.anonCredsSchema,
+  typeof postgres,
+  typeof sqlite.anonCredsSchema,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.anonCredsSchema, sqlite: sqlite.anonCredsSchema }, 'AnonCredsSchemaRecord')
+  }
+
+  public getValues(record: AnonCredsSchemaRecord) {
+    const { schemaId, issuerId, schemaName, schemaVersion, methodName, unqualifiedSchemaId, ...customTags } =
+      record.getTags()
+
+    const { issuerId: _, name: __, version: ___, ...restSchema } = record.schema
+    return {
+      schemaId,
+      schema: restSchema,
+      issuerId,
+      schemaName,
+      schemaVersion,
+      methodName,
+      unqualifiedSchemaId,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleAnonCredsSchemaAdapterValues): AnonCredsSchemaRecord {
+    const { customTags, unqualifiedSchemaId, issuerId, schemaName, schemaVersion, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(
+      { ...remainingValues, schema: { ...remainingValues.schema, issuerId, name: schemaName, version: schemaVersion } },
+      AnonCredsSchemaRecord
+    )
+
+    record.setTags({
+      ...customTags,
+      unqualifiedSchemaId: unqualifiedSchemaId ?? undefined,
+    })
+
+    return record
+  }
+}

package/src/anoncreds/schema/__tests__/schema.drizzle.e2e.test.ts

@@ -0,0 +1,70 @@
+import { AnonCredsSchemaRecord, AnonCredsSchemaRepository } from '@credo-ts/anoncreds'
+import { JsonTransformer } from '@credo-ts/core'
+
+import { DrizzleRecordTest, setupDrizzleRecordTest } from '../../../../tests/testDatabase'
+import { anonCredsSchemaDrizzleRecord } from '../index'
+
+describe.each(['postgres', 'sqlite'] as const)('AnonCredsSchemaRecord with %s', (type) => {
+  let recordTest: DrizzleRecordTest
+
+  beforeAll(async () => {
+    recordTest = await setupDrizzleRecordTest(type, anonCredsSchemaDrizzleRecord)
+  })
+
+  afterAll(async () => {
+    await recordTest.teardown()
+  })
+
+  test('create, retrieve, update, query and delete schema record', async () => {
+    const schema = JsonTransformer.fromJSON(
+      {
+        id: '6e7fcaf3-ebb9-45ed-9261-7b893f732bc1',
+        schemaId: 'did:web:123/schemas/1',
+        schema: {
+          name: 'TestSchema',
+          version: '1.0.0',
+          issuerId: 'did:web:123',
+          attrNames: ['test'],
+        },
+        methodName: 'web',
+        createdAt: new Date(),
+        _tags: {},
+      },
+      AnonCredsSchemaRecord
+    )
+    const anoncredsSchemaRepository = recordTest.agent.context.resolve(AnonCredsSchemaRepository)
+
+    await anoncredsSchemaRepository.save(recordTest.agent.context, schema)
+
+    const schema2 = await anoncredsSchemaRepository.findById(recordTest.agent.context, schema.id)
+    expect(schema).toEqual(schema2)
+
+    schema.setTags({
+      myCustomTag: 'hello',
+      isMorning: false,
+    })
+    await anoncredsSchemaRepository.update(recordTest.agent.context, schema)
+
+    const [schema3] = await anoncredsSchemaRepository.findByQuery(recordTest.agent.context, {
+      // TODO: we should allow null values in the query
+      // unqualifiedSchemaId: null,
+      isMorning: false,
+      schemaName: 'TestSchema',
+      schemaVersion: '1.0.0',
+      issuerId: 'did:web:123',
+      methodName: 'web',
+      schemaId: 'did:web:123/schemas/1',
+    })
+    expect(schema3).toEqual(schema)
+
+    expect(
+      await anoncredsSchemaRepository.findByQuery(recordTest.agent.context, {
+        myCustomTag: 'not-hello',
+      })
+    ).toHaveLength(0)
+
+    await anoncredsSchemaRepository.deleteById(recordTest.agent.context, schema.id)
+
+    expect(await anoncredsSchemaRepository.findByQuery(recordTest.agent.context, {})).toHaveLength(0)
+  })
+})

package/src/anoncreds/schema/index.ts

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

package/src/anoncreds/schema/postgres.ts

@@ -0,0 +1,22 @@
+import type { AnonCredsSchema } from '@credo-ts/anoncreds'
+import { jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const anonCredsSchema = pgTable(
+  'AnonCredsSchema',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    schemaId: text('schema_id').notNull().unique(),
+    schema: jsonb('schema').$type<Omit<AnonCredsSchema, 'issuerId' | 'name' | 'version'>>().notNull(),
+
+    // These are extracted from the schema JSON object, to allow for easy querying based on tags
+    issuerId: text('issuer_id').notNull(),
+    schemaName: text('schema_name').notNull(),
+    schemaVersion: text('schema_version').notNull(),
+
+    methodName: text('method_name').notNull(),
+    unqualifiedSchemaId: text('unqualified_schema_id'),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'anonCredsSchema')
+)

package/src/anoncreds/schema/sqlite.ts

@@ -0,0 +1,22 @@
+import type { AnonCredsSchema } from '@credo-ts/anoncreds'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const anonCredsSchema = sqliteTable(
+  'AnonCredsSchema',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    schemaId: text('schema_id').notNull().unique(),
+    schema: text({ mode: 'json' }).$type<Omit<AnonCredsSchema, 'issuerId' | 'name' | 'version'>>().notNull(),
+
+    // These are extracted from the schema JSON object, to allow for easy querying based on tags
+    issuerId: text('issuer_id').notNull(),
+    schemaName: text('schema_name').notNull(),
+    schemaVersion: text('schema_version').notNull(),
+
+    methodName: text('method_name').notNull(),
+    unqualifiedSchemaId: text('unqualified_schema_id'),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'anonCredsSchema')
+)

package/src/anoncreds/sqlite.ts

@@ -0,0 +1,8 @@
+export * from './credential/sqlite'
+export * from './credential-definition/sqlite'
+export * from './credential-definition-private/sqlite'
+export * from './key-correctness-proof/sqlite'
+export * from './link-secret/sqlite'
+export * from './revocation-registry-definition/sqlite'
+export * from './revocation-registry-definition-private/sqlite'
+export * from './schema/sqlite'

package/src/applyReactNativeMigrations.ts

@@ -0,0 +1,24 @@
+import { AnyDrizzleDatabase } from './DrizzleStorageModuleConfig'
+
+export interface ReactNativeDrizzleMigration {
+  journal: {
+    entries: { idx: number; when: number; tag: string; breakpoints: boolean }[]
+  }
+  migrations: Record<string, string>
+}
+
+export interface ReactNativeDrizzleMigrationsOptions<Database extends AnyDrizzleDatabase = AnyDrizzleDatabase> {
+  db: Database
+  migrations: ReactNativeDrizzleMigration[]
+  migrate: (db: Database, migration: ReactNativeDrizzleMigration) => Promise<void>
+}
+
+export async function applyReactNativeMigrations<Database extends AnyDrizzleDatabase = AnyDrizzleDatabase>({
+  migrate,
+  migrations,
+  db,
+}: ReactNativeDrizzleMigrationsOptions<Database>) {
+  for (const migration of migrations) {
+    await migrate(db, migration)
+  }
+}

package/src/combineSchemas.ts

@@ -0,0 +1,44 @@
+import { UnionToIntersection } from '@credo-ts/core'
+import { DrizzleRecord } from './DrizzleRecord'
+
+/**
+ * Extracts and combines schema types from an array of DrizzleRecord objects for a specific database type
+ */
+export type GetSchemaFromDrizzleRecords<
+  Schemas extends readonly DrizzleRecord[],
+  DatabaseType extends 'postgres' | 'sqlite',
+> = UnionToIntersection<
+  {
+    [K in keyof Schemas]: Schemas[K][DatabaseType]
+  }[number]
+>
+
+/**
+ * Combines multiple Drizzle schema objects into a single unified schema
+ * @param schemas - Array of schema objects to combine
+ * @returns A single merged schema object
+ */
+export function getSchemaFromDrizzleRecords<
+  DrizzleRecords extends Array<DrizzleRecord> | ReadonlyArray<DrizzleRecord>,
+  DatabaseType extends 'postgres' | 'sqlite',
+>(
+  drizzleRecords: DrizzleRecords,
+  databaseType: DatabaseType
+): GetSchemaFromDrizzleRecords<DrizzleRecords, DatabaseType> {
+  // Create a new empty object to hold our combined schema
+  const combinedSchema = {} as GetSchemaFromDrizzleRecords<DrizzleRecords, DatabaseType>
+
+  // Iterate through each schema and merge its properties into the combined schema
+  for (const drizzleRecord of drizzleRecords) {
+    const schema = drizzleRecord[databaseType]
+
+    for (const key in schema) {
+      if (Object.prototype.hasOwnProperty.call(schema, key)) {
+        // Merge each property from the current schema into our combined schema
+        Object.assign(combinedSchema as object, { [key]: schema[key] })
+      }
+    }
+  }
+
+  return combinedSchema
+}

package/src/core/bundle.ts

@@ -0,0 +1,33 @@
+import { DrizzleRecordBundle } from '../DrizzleRecord'
+import { contextDrizzleRecord } from './context'
+import { didDrizzleRecord } from './did'
+import { genericRecordDrizzleRecord } from './genericRecord'
+import { mdocDrizzleRecord } from './mdoc'
+import { sdJwtVcDrizzleRecord } from './sdJwtVc'
+import { singleContextLruCacheDrizzleRecord } from './singleContextLruCache'
+import { storageVersionDrizzleRecord } from './storageVersion'
+import { w3cCredentialDrizzleRecord } from './w3cCredential'
+
+export default {
+  name: 'core',
+  records: [
+    contextDrizzleRecord,
+    sdJwtVcDrizzleRecord,
+    mdocDrizzleRecord,
+    storageVersionDrizzleRecord,
+    genericRecordDrizzleRecord,
+    didDrizzleRecord,
+    w3cCredentialDrizzleRecord,
+    singleContextLruCacheDrizzleRecord,
+  ],
+  migrations: {
+    postgres: {
+      schemaModule: '@credo-ts/drizzle-storage/core/postgres',
+      migrationsPath: '../../migrations/core/postgres',
+    },
+    sqlite: {
+      schemaModule: '@credo-ts/drizzle-storage/core/sqlite',
+      migrationsPath: '../../migrations/core/sqlite',
+    },
+  },
+} as const satisfies DrizzleRecordBundle