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

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@credo-ts/drizzle-storage",
-  "version": "0.6.0-pr-2324-20250708122805",
+  "version": "0.6.0-pr-2324-20250708123651",
   "files": [
     "build",
     "cli-build",
     "migrations",
     "tsconfig.json",
     "types",
-    "cli/drizzle.config.ts"
+    "cli/drizzle.config.ts",
+    "src"
   ],
   "license": "Apache-2.0",
   "description": "Credo storage service implementation based on Drizzle ORM, supporting PostgreSQL and SQLite",
@@ -21,12 +22,12 @@
       "default": "./build/index.js"
     },
     "./*/sqlite": {
-      "types": "./build/*/sqlite.d.ts",
-      "default": "./build/*/sqlite.ts"
+      "default": "./build/*/sqlite.js",
+      "types": "./build/*/sqlite.d.ts"
     },
     "./*/postgres": {
-      "types": "./build/*/postgres.d.ts",
-      "default": "./build/*/postgres.ts"
+      "default": "./build/*/postgres.js",
+      "types": "./build/*/postgres.d.ts"
     },
     "./*": {
       "default": "./build/*/bundle.js",
@@ -51,14 +52,14 @@
     "ts-node": "^10.9.2",
     "tsyringe": "^4.8.0",
     "zod": "^3.24.2",
-    "@credo-ts/action-menu": "0.6.0-pr-2324-20250708122805",
-    "@credo-ts/anoncreds": "0.6.0-pr-2324-20250708122805",
-    "@credo-ts/core": "0.6.0-pr-2324-20250708122805",
-    "@credo-ts/didcomm": "0.6.0-pr-2324-20250708122805",
-    "@credo-ts/drpc": "0.6.0-pr-2324-20250708122805",
-    "@credo-ts/openid4vc": "0.6.0-pr-2324-20250708122805",
-    "@credo-ts/question-answer": "0.6.0-pr-2324-20250708122805",
-    "@credo-ts/tenants": "0.6.0-pr-2324-20250708122805"
+    "@credo-ts/action-menu": "0.6.0-pr-2324-20250708123651",
+    "@credo-ts/anoncreds": "0.6.0-pr-2324-20250708123651",
+    "@credo-ts/core": "0.6.0-pr-2324-20250708123651",
+    "@credo-ts/didcomm": "0.6.0-pr-2324-20250708123651",
+    "@credo-ts/drpc": "0.6.0-pr-2324-20250708123651",
+    "@credo-ts/openid4vc": "0.6.0-pr-2324-20250708123651",
+    "@credo-ts/question-answer": "0.6.0-pr-2324-20250708123651",
+    "@credo-ts/tenants": "0.6.0-pr-2324-20250708123651"
   },
   "peerDependencies": {
     "drizzle-orm": "^0.44.2"

package/src/DrizzleDatabase.ts

@@ -0,0 +1,29 @@
+import { PgDatabase } from 'drizzle-orm/pg-core'
+import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core'
+
+export type DrizzleSqliteDatabase<Schema extends Record<string, unknown> = Record<string, unknown>> =
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  BaseSQLiteDatabase<'sync' | 'async', any, Schema>
+
+export type DrizzlePostgresDatabase<Schema extends Record<string, unknown> = Record<string, unknown>> = PgDatabase<
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  any,
+  Schema
+>
+
+export type DrizzleDatabase<
+  PostgresSchema extends Record<string, unknown> = Record<string, unknown>,
+  SqliteSchema extends Record<string, unknown> = Record<string, unknown>,
+> = DrizzlePostgresDatabase<PostgresSchema> | DrizzleSqliteDatabase<SqliteSchema>
+
+export function isDrizzlePostgresDatabase(database: DrizzleDatabase): database is DrizzlePostgresDatabase {
+  return database instanceof PgDatabase
+}
+
+export function isDrizzleSqliteDatabase(database: DrizzleDatabase): database is DrizzleSqliteDatabase {
+  return database instanceof BaseSQLiteDatabase
+}
+
+export function getDrizzleDatabaseType(database: DrizzleDatabase): 'sqlite' | 'postgres' {
+  return isDrizzlePostgresDatabase(database) ? 'postgres' : 'sqlite'
+}

package/src/DrizzleRecord.ts

@@ -0,0 +1,73 @@
+import { AnyDrizzleAdapter } from './adapter/BaseDrizzleRecordAdapter'
+
+export interface DrizzleRecordBundle {
+  /**
+   * The name of the drizzle record bundle. Ideally it should be simple but unique.
+   *
+   * E.g. `core` or `anoncreds` for internal modules. For custom modules we recommend
+   * prefixing a scope. E.g. `my-org-custom-protocol`
+   */
+  name: string
+
+  /**
+   * The drizzle records part of this bundle. This should stay consistent, as migrations are
+   * managed per drizzle record bundle. Removing migrations or records can result in data loss
+   * or locked databases.
+   */
+  records: DrizzleRecord[]
+
+  /**
+   * Information related to generationg and applying migrations
+   */
+  migrations: {
+    sqlite: {
+      /**
+       * A resolvable module that contains the drizzle SQLite schema definition for the complete bundle.
+       *
+       * NOTE: this MUST resolve to the TypeScript schema file, it cannot point to the built files. This
+       * file will only be resolved during generation of migrations, and thus it's not needed to publish
+       * the source files in your NPM package, as long as the module resolves during migration generation.
+       */
+      schemaModule: string
+
+      /**
+       * The migrations path where the migrations should be generated and retrieved. Note that the contents
+       * of this directory must be published with your NPM package so it can be used to apply migrations.
+       *
+       * The path should be relative to the resolved `schemaModule`. Note that if you use `publishConfig` to
+       * have different exports during development, this should still resolve to the generated migration files
+       * in the generated packages, so it's recommended to place your migrations outside of the src folder
+       */
+      migrationsPath: string
+    }
+    postgres: {
+      /**
+       * A resolvable module that contains the drizzle SQLite schema definition for the complete bundle.
+       *
+       * NOTE: this MUST resolve to the TypeScript schema file, it cannot point to the built files. This
+       * file will only be resolved during generation of migrations, and thus it's not needed to publish
+       * the source files in your NPM package, as long as the module resolves during migration generation.
+       */
+      schemaModule: string
+
+      /**
+       * The migrations path where the migrations should be generated and retrieved. Note that the contents
+       * of this directory must be published with your NPM package so it can be used to apply migrations.
+       *
+       * The path should be relative to the resolved `schemaModule`. Note that if you use `publishConfig` to
+       * have different exports during development, this should still resolve to the generated migration files
+       * in the generated packages, so it's recommended to place your migrations outside of the src folder
+       */
+      migrationsPath: string
+    }
+  }
+}
+
+export interface DrizzleRecord {
+  postgres: Record<string, unknown>
+  sqlite: Record<string, unknown>
+  adapter?: new (
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    database: any
+  ) => AnyDrizzleAdapter
+}

package/src/DrizzleStorageModule.ts

@@ -0,0 +1,112 @@
+import type { AgentContext, DependencyManager, Module } from '@credo-ts/core'
+import type { DrizzleStorageModuleConfigOptions } from './DrizzleStorageModuleConfig'
+
+import { CredoError, InjectionSymbols, StorageUpdateService } from '@credo-ts/core'
+
+import { eq } from 'drizzle-orm'
+import { isDrizzlePostgresDatabase, isDrizzleSqliteDatabase } from './DrizzleDatabase'
+import { DrizzleStorageModuleConfig } from './DrizzleStorageModuleConfig'
+import { context as postgresContext } from './core/postgres'
+import { context as sqliteContext } from './core/sqlite'
+import { CredoDrizzleStorageError } from './error'
+import { DrizzleStorageService } from './storage'
+
+export class DrizzleStorageModule implements Module {
+  public readonly config: DrizzleStorageModuleConfig
+
+  public constructor(config: DrizzleStorageModuleConfigOptions) {
+    this.config = new DrizzleStorageModuleConfig(config)
+  }
+
+  public register(dependencyManager: DependencyManager) {
+    dependencyManager.registerInstance(DrizzleStorageModuleConfig, this.config)
+
+    if (dependencyManager.isRegistered(InjectionSymbols.StorageService)) {
+      throw new CredoError(
+        'Unable to register DrizzleStorageService. There is an instance of StorageService already registered'
+      )
+    }
+    dependencyManager.registerSingleton(InjectionSymbols.StorageService, DrizzleStorageService)
+  }
+
+  public async onInitializeContext(agentContext: AgentContext): Promise<void> {
+    // For the root agent context we don't call provision, we should probably change that
+    // but this is because agent.initialize doesn't differantiate between create and open
+    // So we need to check basically when we start the agent if this is a new agent
+    // and if so, set the framework storage version. This is a bit inefficient, as we will
+    // again fetch the record after the module has been initialized, but probably something
+    // we can improve with caching.
+    if (agentContext.isRootAgentContext) {
+      const storageUpdateService = agentContext.resolve(StorageUpdateService)
+
+      // Previously if we didn't have a storage version record yet it meant we assumed you
+      // were on 0.1 before the record was added, but since this module is introduced in 0.6
+      // we can be sure that's not the case.
+      if (!(await storageUpdateService.hasStorageVersionRecord(agentContext))) {
+        await this.createNewContextInDatabase(agentContext)
+      }
+    }
+  }
+
+  public async onProvisionContext(agentContext: AgentContext): Promise<void> {
+    // This method is never called for root agent context
+    // but to be sure if that changesin the future
+    if (agentContext.isRootAgentContext) return
+
+    await this.createNewContextInDatabase(agentContext)
+  }
+
+  public async onDeleteContext(agentContext: AgentContext): Promise<void> {
+    // If it's the root agent context, we want to delete all the tenants as well
+    if (agentContext.isRootAgentContext) {
+      // Do we want to allow this? It can be quite impactfull
+      await this.deleteContextQuery()
+    } else {
+      await this.deleteContextQuery().where(eq(sqliteContext.contextCorrelationId, agentContext.contextCorrelationId))
+    }
+  }
+
+  private deleteContextQuery() {
+    // TODO: we could probably add some extra abstraction here.
+    if (isDrizzlePostgresDatabase(this.config.database)) {
+      return this.config.database.delete(postgresContext)
+    }
+
+    if (isDrizzleSqliteDatabase(this.config.database)) {
+      return this.config.database.delete(sqliteContext)
+    }
+
+    throw new CredoDrizzleStorageError(
+      'Unable to delete context. Database must be instance of postgres or sqlite database.'
+    )
+  }
+
+  private async createNewContextInDatabase(agentContext: AgentContext) {
+    // For new contexts, we need to set the storage version
+    const storageUpdateService = agentContext.resolve(StorageUpdateService)
+
+    if (isDrizzlePostgresDatabase(this.config.database)) {
+      // Create a new context record. This is mostly used to allow deleting a context and
+      // cascade delete all other records.
+      await this.config.database
+        .insert(postgresContext)
+        .values({
+          contextCorrelationId: agentContext.contextCorrelationId,
+        })
+        .onConflictDoNothing()
+    } else if (isDrizzleSqliteDatabase(this.config.database)) {
+      await this.config.database
+        .insert(sqliteContext)
+        .values({
+          contextCorrelationId: agentContext.contextCorrelationId,
+        })
+        .onConflictDoNothing()
+    } else {
+      throw new CredoDrizzleStorageError(
+        'Unable to provision context. Database must be instance of postgres or sqlite database.'
+      )
+    }
+
+    await storageUpdateService.setCurrentStorageVersion(agentContext, StorageUpdateService.frameworkStorageVersion)
+  }
+}

package/src/DrizzleStorageModuleConfig.ts

@@ -0,0 +1,48 @@
+import { DrizzleDatabase, getDrizzleDatabaseType } from './DrizzleDatabase'
+import { DrizzleRecord, DrizzleRecordBundle } from './DrizzleRecord'
+import { AnyDrizzleAdapter } from './adapter/BaseDrizzleRecordAdapter'
+import { getSchemaFromDrizzleRecords } from './combineSchemas'
+import coreDrizzleBundle from './core/bundle'
+
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+export type AnyDrizzleDatabase = DrizzleDatabase<any, any>
+
+export interface DrizzleStorageModuleConfigOptions<Database extends AnyDrizzleDatabase = AnyDrizzleDatabase> {
+  /**
+   * The drizzle database to use. To not depend on specific drivers and support different
+   * environments you need to configure the database yourself.
+   *
+   * See https://orm.drizzle.team/docs/get-started for available drivers.
+   * All SQLite and Postgres database are supported.
+   */
+  database: Database
+
+  /**
+   * The drizzle bundles to register. Each drizzle bundles consists of records, which need to contain both an
+   * sqlite and postgres definition, as well as an adapter.
+   */
+  bundles: DrizzleRecordBundle[]
+}
+
+/**
+ * @public
+ */
+export class DrizzleStorageModuleConfig {
+  public readonly database: AnyDrizzleDatabase
+  public readonly adapters: AnyDrizzleAdapter[]
+  public readonly schemas: Record<string, unknown>
+
+  public constructor(options: DrizzleStorageModuleConfigOptions) {
+    this.database = options.database
+
+    // core MUST always be registered
+    const allRecords: DrizzleRecord[] = Array.from(
+      new Set([...coreDrizzleBundle.records, ...options.bundles.flatMap((bundle) => bundle.records)])
+    )
+    this.adapters = allRecords
+      .map((record) => (record.adapter ? new record.adapter(this.database) : undefined))
+      .filter((adapter) => adapter !== undefined)
+
+    this.schemas = getSchemaFromDrizzleRecords(allRecords, getDrizzleDatabaseType(options.database))
+  }
+}

package/src/action-menu/action-menu/DrizzleDidcommActionMenuRecordAdapter.ts

@@ -0,0 +1,46 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import { BaseDrizzleRecordAdapter, DrizzleAdapterRecordValues } from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { ActionMenuOptions, ActionMenuRecord, ActionMenuSelectionOptions } from '@credo-ts/action-menu'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleDidcommActionMenuAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['didcommActionMenu']>
+export class DrizzleDidcommActionMenuRecordAdapter extends BaseDrizzleRecordAdapter<
+  ActionMenuRecord,
+  typeof postgres.didcommActionMenu,
+  typeof postgres,
+  typeof sqlite.didcommActionMenu,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.didcommActionMenu, sqlite: sqlite.didcommActionMenu }, 'ActionMenuRecord')
+  }
+
+  public getValues(record: ActionMenuRecord) {
+    const { role, connectionId, threadId, ...customTags } = record.getTags()
+
+    return {
+      role,
+      threadId,
+      connectionId,
+      state: record.state,
+      menu: record.menu ? (JsonTransformer.toJSON(record.menu) as ActionMenuOptions) : null,
+      performedAction: record.performedAction
+        ? (JsonTransformer.toJSON(record.performedAction) as ActionMenuSelectionOptions)
+        : null,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleDidcommActionMenuAdapterValues): ActionMenuRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, ActionMenuRecord)
+    if (customTags) record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/action-menu/action-menu/index.ts

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

package/src/action-menu/action-menu/postgres.ts

@@ -0,0 +1,31 @@
+import { ActionMenuOptions, ActionMenuRole, ActionMenuSelectionOptions, ActionMenuState } from '@credo-ts/action-menu'
+import { foreignKey, jsonb, pgEnum, pgTable, text, unique } from 'drizzle-orm/pg-core'
+import { didcommConnection } from '../../didcomm/connection/postgres'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const didcommActionMenuStateEnum = pgEnum('DidcommActionMenuState', ActionMenuState)
+export const didcommActionMenuRoleEnum = pgEnum('DidcommActionMenuRole', ActionMenuRole)
+
+export const didcommActionMenu = pgTable(
+  'DidcommActionMenu',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    state: didcommActionMenuStateEnum().notNull(),
+    role: didcommActionMenuRoleEnum().notNull(),
+
+    connectionId: text('connection_id').notNull(),
+    threadId: text('thread_id').notNull(),
+
+    menu: jsonb('menu').$type<ActionMenuOptions>(),
+    performedAction: jsonb('performed_action').$type<ActionMenuSelectionOptions>(),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'didcommActionMenu'),
+    unique().on(table.contextCorrelationId, table.threadId),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/action-menu/action-menu/sqlite.ts

@@ -0,0 +1,34 @@
+import { foreignKey, sqliteTable, text, unique } from 'drizzle-orm/sqlite-core'
+
+import type {
+  ActionMenuOptions,
+  ActionMenuRole,
+  ActionMenuSelectionOptions,
+  ActionMenuState,
+} from '@credo-ts/action-menu'
+import { didcommConnection } from '../../didcomm/connection/sqlite'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const didcommActionMenu = sqliteTable(
+  'DidcommActionMenu',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    state: text('state').$type<ActionMenuState>().notNull(),
+    role: text('role').$type<ActionMenuRole>().notNull(),
+
+    connectionId: text('connection_id').notNull(),
+    threadId: text('thread_id').notNull(),
+
+    menu: text('menu', { mode: 'json' }).$type<ActionMenuOptions>(),
+    performedAction: text('performed_action', { mode: 'json' }).$type<ActionMenuSelectionOptions>(),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'didcommActionMenu'),
+    unique().on(table.contextCorrelationId, table.threadId),
+    foreignKey({
+      columns: [table.connectionId, table.contextCorrelationId],
+      foreignColumns: [didcommConnection.id, didcommConnection.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/action-menu/bundle.ts

@@ -0,0 +1,18 @@
+import { DrizzleRecordBundle } from '../DrizzleRecord'
+import { didcommActionMenuDrizzleRecord } from './action-menu'
+
+export default {
+  name: 'action-menu',
+  records: [didcommActionMenuDrizzleRecord],
+
+  migrations: {
+    postgres: {
+      schemaModule: '@credo-ts/drizzle-storage/action-menu/postgres',
+      migrationsPath: '../../migrations/action-menu/postgres',
+    },
+    sqlite: {
+      schemaModule: '@credo-ts/drizzle-storage/action-menu/sqlite',
+      migrationsPath: '../../migrations/action-menu/sqlite',
+    },
+  },
+} as const satisfies DrizzleRecordBundle

package/src/action-menu/postgres.ts

@@ -0,0 +1 @@
+export * from './action-menu/postgres'

package/src/action-menu/sqlite.ts

@@ -0,0 +1 @@
+export * from './action-menu/sqlite'