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

package/src/core/context/index.ts

@@ -0,0 +1,8 @@
+import { DrizzleRecord } from '../../DrizzleRecord'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+export const contextDrizzleRecord = {
+  postgres,
+  sqlite,
+} satisfies DrizzleRecord

package/src/core/context/postgres.ts

@@ -0,0 +1,5 @@
+import { pgTable, text } from 'drizzle-orm/pg-core'
+
+export const context = pgTable('Context', {
+  contextCorrelationId: text('context_correlation_id').primaryKey(),
+})

package/src/core/context/sqlite.ts

@@ -0,0 +1,5 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+export const context = sqliteTable('Context', {
+  contextCorrelationId: text('context_correlation_id').primaryKey(),
+})

package/src/core/did/DrizzleDidRecordAdapter.ts

@@ -0,0 +1,71 @@
+import { DidRecord, JsonTransformer } 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 DrizzleDidAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['did']>
+export class DrizzleDidRecordAdapter extends BaseDrizzleRecordAdapter<
+  DidRecord,
+  typeof postgres.did,
+  typeof postgres,
+  typeof sqlite.did,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.did, sqlite: sqlite.did }, 'DidRecord')
+  }
+
+  public getValues(record: DidRecord) {
+    const {
+      // Default Tags
+      recipientKeyFingerprints,
+      method,
+      methodSpecificIdentifier,
+      alternativeDids,
+      did,
+      legacyUnqualifiedDid,
+      role,
+      ...customTags
+    } = record.getTags()
+
+    return {
+      did: record.did,
+      role: role,
+      didDocument: record.didDocument,
+      keys: record.keys,
+
+      // Tags
+      recipientKeyFingerprints,
+      method,
+      methodSpecificIdentifier,
+      alternativeDids,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidAdapterValues): DidRecord {
+    const {
+      // Default Tags
+      recipientKeyFingerprints,
+      method,
+      methodSpecificIdentifier,
+      alternativeDids,
+      customTags,
+      ...remainingValues
+    } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, DidRecord)
+    record.setTags({
+      recipientKeyFingerprints: recipientKeyFingerprints ?? undefined,
+      method,
+      methodSpecificIdentifier,
+      alternativeDids: alternativeDids ?? undefined,
+      ...customTags,
+    })
+
+    return record
+  }
+}

package/src/core/did/index.ts

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

package/src/core/did/postgres.ts

@@ -0,0 +1,28 @@
+import { DidDocumentKey, DidDocumentRole } from '@credo-ts/core'
+import { jsonb, pgEnum, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const didRoleEnum = pgEnum('didRole', DidDocumentRole)
+
+export const did = pgTable(
+  'Did',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    did: text().notNull(),
+    role: didRoleEnum().notNull(),
+    didDocument: jsonb('did_document'),
+    keys: jsonb().$type<DidDocumentKey[]>(),
+
+    // Default Tags
+    recipientKeyFingerprints: jsonb('recipient_key_fingerprints'),
+    method: text().notNull(),
+    methodSpecificIdentifier: text('method_specific_identifier').notNull(),
+    // Not adding this here, since it's legacy
+    // legacyUnqualifiedDid
+
+    // Custom Tags
+    alternativeDids: text('alternative_dids').array(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'did')
+)

package/src/core/did/sqlite.ts

@@ -0,0 +1,26 @@
+import { DidDocumentKey, DidDocumentRole } from '@credo-ts/core'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const did = sqliteTable(
+  'Did',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    did: text().notNull(),
+    role: text().$type<DidDocumentRole.Created | DidDocumentRole.Received>().notNull(),
+    didDocument: text('did_document', { mode: 'json' }),
+    keys: text({ mode: 'json' }).$type<DidDocumentKey[]>(),
+
+    // Default Tags
+    recipientKeyFingerprints: text('recipient_key_fingerprints', { mode: 'json' }).$type<string[]>(),
+    method: text().notNull(),
+    methodSpecificIdentifier: text('method_specific_identifier').notNull(),
+    // Not adding this here, since it's legacy
+    // legacyUnqualifiedDid
+
+    // Custom Tags
+    alternativeDids: text('alternative_dids', { mode: 'json' }).$type<string[]>(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'did')
+)

package/src/core/genericRecord/DrizzleGenericRecordAdapter.ts

@@ -0,0 +1,36 @@
+import { GenericRecord, JsonTransformer, TagsBase } 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 DrizzleGenericRecordAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['genericRecord']>
+export class DrizzleGenericRecordAdapter extends BaseDrizzleRecordAdapter<
+  GenericRecord,
+  typeof postgres.genericRecord,
+  typeof postgres,
+  typeof sqlite.genericRecord,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.genericRecord, sqlite: sqlite.genericRecord }, 'GenericRecord')
+  }
+
+  public getValues(record: GenericRecord) {
+    return {
+      content: record.content,
+      customTags: record.getTags() as Record<string, string>,
+    }
+  }
+
+  public toRecord(values: DrizzleGenericRecordAdapterValues): GenericRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, GenericRecord)
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/core/genericRecord/index.ts

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

package/src/core/genericRecord/postgres.ts

@@ -0,0 +1,12 @@
+import { jsonb, pgTable } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const genericRecord = pgTable(
+  'GenericRecord',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    content: jsonb().notNull().$type<Record<string, unknown>>(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'genericRecord')
+)

package/src/core/genericRecord/sqlite.ts

@@ -0,0 +1,12 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const genericRecord = sqliteTable(
+  'GenericRecord',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    content: text({ mode: 'json' }).notNull().$type<Record<string, unknown>>(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'genericRecord')
+)

package/src/core/mdoc/DrizzleMdocRecordAdapter.ts

@@ -0,0 +1,44 @@
+import { JsonTransformer, MdocRecord } 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 DrizzleMdocAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['mdoc']>
+export class DrizzleMdocRecordAdapter extends BaseDrizzleRecordAdapter<
+  MdocRecord,
+  typeof postgres.mdoc,
+  typeof postgres,
+  typeof sqlite.mdoc,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.mdoc, sqlite: sqlite.mdoc }, 'MdocRecord')
+  }
+
+  public getValues(record: MdocRecord) {
+    const { alg, docType, ...customTags } = record.getTags()
+
+    return {
+      alg,
+      docType,
+      base64Url: record.base64Url,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleMdocAdapterValues): MdocRecord {
+    const { alg, docType, customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, MdocRecord)
+    record.setTags({
+      alg,
+      docType,
+      ...customTags,
+    })
+
+    return record
+  }
+}

package/src/core/mdoc/index.ts

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

package/src/core/mdoc/postgres.ts

@@ -0,0 +1,15 @@
+import type { Kms } from '@credo-ts/core'
+import { pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const mdoc = pgTable(
+  'Mdoc',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    base64Url: text('base64_url').notNull(),
+    alg: text().$type<Kms.KnownJwaSignatureAlgorithm>().notNull(),
+    docType: text('doc_type').notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'mdoc')
+)

package/src/core/mdoc/sqlite.ts

@@ -0,0 +1,15 @@
+import type { Kms } from '@credo-ts/core'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const mdoc = sqliteTable(
+  'Mdoc',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    base64Url: text('base64_url').notNull(),
+    alg: text().$type<Kms.KnownJwaSignatureAlgorithm>().notNull(),
+    docType: text('doc_type').notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'mdoc')
+)

package/src/core/postgres.ts

@@ -0,0 +1,8 @@
+export * from './context/postgres'
+export * from './did/postgres'
+export * from './genericRecord/postgres'
+export * from './mdoc/postgres'
+export * from './sdJwtVc/postgres'
+export * from './singleContextLruCache/postgres'
+export * from './storageVersion/postgres'
+export * from './w3cCredential/postgres'

package/src/core/sdJwtVc/DrizzleSdJwtVcRecordAdapter.ts

@@ -0,0 +1,46 @@
+import { JsonTransformer, SdJwtVcRecord } 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 DrizzleSdJwtVcAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['sdJwtVc']>
+export class DrizzleSdJwtVcRecordAdapter extends BaseDrizzleRecordAdapter<
+  SdJwtVcRecord,
+  typeof postgres.sdJwtVc,
+  typeof postgres,
+  typeof sqlite.sdJwtVc,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.sdJwtVc, sqlite: sqlite.sdJwtVc }, 'SdJwtVcRecord')
+  }
+
+  public getValues(record: SdJwtVcRecord) {
+    const { alg, sdAlg, vct, ...customTags } = record.getTags()
+
+    return {
+      alg,
+      sdAlg,
+      vct,
+      compactSdJwtVc: record.compactSdJwtVc,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleSdJwtVcAdapterValues): SdJwtVcRecord {
+    const { sdAlg, alg, vct, customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, SdJwtVcRecord)
+    record.setTags({
+      alg,
+      vct,
+      sdAlg,
+      ...customTags,
+    })
+
+    return record
+  }
+}

package/src/core/sdJwtVc/index.ts

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

package/src/core/sdJwtVc/postgres.ts

@@ -0,0 +1,17 @@
+import type { Kms } from '@credo-ts/core'
+import { pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const sdJwtVc = pgTable(
+  'SdJwtVc',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    vct: text().notNull(),
+    alg: text().$type<Kms.KnownJwaSignatureAlgorithm>().notNull(),
+    sdAlg: text('sd_alg').$type<string>().notNull(),
+
+    compactSdJwtVc: text('compact_sd_jwt_vc').notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'sdJwtVc')
+)

package/src/core/sdJwtVc/sqlite.ts

@@ -0,0 +1,17 @@
+import { Kms } from '@credo-ts/core'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const sdJwtVc = sqliteTable(
+  'SdJwtVc',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    vct: text().notNull(),
+    alg: text().$type<Kms.KnownJwaSignatureAlgorithm>().notNull(),
+    sdAlg: text('sd_alg').$type<string>().notNull(),
+
+    compactSdJwtVc: text('compact_sd_jwt_vc').notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'sdJwtVc')
+)

package/src/core/singleContextLruCache/DrizzleSingleContextLruCacheRecordAdapter.ts

@@ -0,0 +1,43 @@
+import { JsonTransformer, SingleContextLruCacheRecord, TagsBase } 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 DrizzleSingleContextLruCacheAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['singleContextLruCache']>
+export class DrizzleSingleContextLruCacheRecordAdapter extends BaseDrizzleRecordAdapter<
+  SingleContextLruCacheRecord,
+  typeof postgres.singleContextLruCache,
+  typeof postgres,
+  typeof sqlite.singleContextLruCache,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(
+      database,
+      { postgres: postgres.singleContextLruCache, sqlite: sqlite.singleContextLruCache },
+      'SingleContextLruCacheRecord'
+    )
+  }
+
+  public getValues(record: SingleContextLruCacheRecord) {
+    return {
+      entries: Object.fromEntries(record.entries.entries()),
+      customTags: record.getTags(),
+    }
+  }
+
+  public toRecord(values: DrizzleSingleContextLruCacheAdapterValues): SingleContextLruCacheRecord {
+    const { entries, customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(
+      { entries: Object.entries(entries), ...remainingValues },
+      SingleContextLruCacheRecord
+    )
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/core/singleContextLruCache/index.ts

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

package/src/core/singleContextLruCache/postgres.ts

@@ -0,0 +1,12 @@
+import { SingleContextLruCacheItem } from '@credo-ts/core'
+import { jsonb, pgTable } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const singleContextLruCache = pgTable(
+  'SingleContextLruCache',
+  {
+    ...getPostgresBaseRecordTable(),
+    entries: jsonb().notNull().$type<Record<string, SingleContextLruCacheItem>>(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'singleContextLruCache')
+)

package/src/core/singleContextLruCache/sqlite.ts

@@ -0,0 +1,13 @@
+import { SingleContextLruCacheItem } from '@credo-ts/core'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const singleContextLruCache = sqliteTable(
+  'SingleContextLruCache',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    entries: text({ mode: 'json' }).notNull().$type<Record<string, SingleContextLruCacheItem>>(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'singleContextLruCache')
+)

package/src/core/sqlite.ts

@@ -0,0 +1,8 @@
+export * from './context/sqlite'
+export * from './did/sqlite'
+export * from './genericRecord/sqlite'
+export * from './mdoc/sqlite'
+export * from './sdJwtVc/sqlite'
+export * from './singleContextLruCache/sqlite'
+export * from './storageVersion/sqlite'
+export * from './w3cCredential/sqlite'

package/src/core/storageVersion/DrizzleStorageVersionRecordAdapter.ts

@@ -0,0 +1,36 @@
+import { JsonTransformer, StorageVersionRecord, TagsBase } 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 DrizzleStorageVersionRecordAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['storageVersion']>
+export class DrizzleStorageVersionRecordAdapter extends BaseDrizzleRecordAdapter<
+  StorageVersionRecord,
+  typeof postgres.storageVersion,
+  typeof postgres,
+  typeof sqlite.storageVersion,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.storageVersion, sqlite: sqlite.storageVersion }, 'StorageVersionRecord')
+  }
+
+  public getValues(record: StorageVersionRecord) {
+    return {
+      storageVersion: record.storageVersion,
+      customTags: record.getTags() as Record<string, string>,
+    }
+  }
+
+  public toRecord(values: DrizzleStorageVersionRecordAdapterValues): StorageVersionRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, StorageVersionRecord)
+    record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/core/storageVersion/index.ts

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

package/src/core/storageVersion/postgres.ts

@@ -0,0 +1,13 @@
+import type { VersionString } from '@credo-ts/core'
+import { pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const storageVersion = pgTable(
+  'StorageVersion',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    storageVersion: text('storage_version').notNull().$type<VersionString>(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'storageVersion')
+)

package/src/core/storageVersion/sqlite.ts

@@ -0,0 +1,13 @@
+import type { VersionString } from '@credo-ts/core'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const storageVersion = sqliteTable(
+  'StorageVersion',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    storageVersion: text('storage_version').notNull().$type<VersionString>(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'storageVersion')
+)