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

package/src/sqlite/baseRecord.ts

@@ -0,0 +1,38 @@
+import { SQLiteColumn, foreignKey, integer, primaryKey, text } from 'drizzle-orm/sqlite-core'
+import { context } from '../core/context/sqlite'
+
+export const getSqliteBaseRecordTable = () =>
+  ({
+    contextCorrelationId: text('context_correlation_id').notNull(),
+
+    id: text().notNull(),
+
+    // createdAt is set in credo, to avoid having to query the
+    // value from the database after creation
+    createdAt: integer('created_at', { mode: 'timestamp_ms' }).notNull(),
+
+    // updatedAt is updated in credo, to avoid having to query the updated
+    // value from the database after an update
+    updatedAt: integer('updated_at', { mode: 'timestamp_ms' }).notNull(),
+
+    metadata: text({ mode: 'json' }).$type<Record<string, Record<string, unknown> | undefined>>(),
+    customTags: text('custom_tags', { mode: 'json' }).$type<
+      Record<string, string | number | undefined | boolean | null | string[]>
+    >(),
+  }) as const
+
+// Define common base indexes that all tables should have
+export const sqliteBaseRecordIndexes = <
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  Table extends { contextCorrelationId: SQLiteColumn<any>; id: SQLiteColumn<any> },
+>(
+  table: Table,
+  tableName: string
+) => [
+  primaryKey({ columns: [table.contextCorrelationId, table.id], name: `${tableName}_pk` }),
+  foreignKey({
+    columns: [table.contextCorrelationId],
+    foreignColumns: [context.contextCorrelationId],
+    name: `${tableName}_fk_context`,
+  }).onDelete('cascade'),
+]

package/src/sqlite/index.ts

@@ -0,0 +1 @@
+export { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from './baseRecord'

package/src/storage/DrizzleStorageService.ts

@@ -0,0 +1,87 @@
+import type {
+  AgentContext,
+  BaseRecord,
+  BaseRecordConstructor,
+  Query,
+  QueryOptions,
+  StorageService,
+} from '@credo-ts/core'
+import { injectable } from '@credo-ts/core'
+import { DrizzleStorageModuleConfig } from '../DrizzleStorageModuleConfig'
+import { BaseDrizzleRecordAdapter } from '../adapter/BaseDrizzleRecordAdapter'
+import { CredoDrizzleStorageError } from '../error/CredoDrizzleStorageError'
+
+@injectable()
+export class DrizzleStorageService<T extends BaseRecord> implements StorageService<T> {
+  public constructor(public config: DrizzleStorageModuleConfig) {}
+
+  private getAdapterForRecordType(recordType: string) {
+    const adapter = this.config.adapters.find((adapter) => adapter.recordType === recordType)
+    if (!adapter) {
+      throw new CredoDrizzleStorageError(
+        `Could not find a registered drizzle adapter for record type '${recordType}'. Make sure to register the record type in the DrizzleStorageModule.`
+      )
+    }
+
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    return adapter as BaseDrizzleRecordAdapter<T, any, any, any, any>
+  }
+
+  public async save(agentContext: AgentContext, record: T): Promise<void> {
+    record.createdAt = record.createdAt ?? new Date()
+    record.updatedAt = record.createdAt
+
+    const adapter = this.getAdapterForRecordType(record.type)
+
+    // TOOD: duplicate
+    await adapter.insert(agentContext, record)
+  }
+
+  public async update(agentContext: AgentContext, record: T): Promise<void> {
+    record.updatedAt = new Date()
+
+    const adapter = this.getAdapterForRecordType(record.type)
+    await adapter.update(agentContext, record)
+  }
+
+  public async delete(agentContext: AgentContext, record: T): Promise<void> {
+    const adapter = this.getAdapterForRecordType(record.type)
+    await adapter.delete(agentContext, record.id)
+  }
+
+  public async deleteById(
+    agentContext: AgentContext,
+    recordClass: BaseRecordConstructor<T>,
+    id: string
+  ): Promise<void> {
+    const adapter = this.getAdapterForRecordType(recordClass.type)
+
+    await adapter.delete(agentContext, id)
+  }
+
+  public async getById(agentContext: AgentContext, recordClass: BaseRecordConstructor<T>, id: string): Promise<T> {
+    const adapter = this.getAdapterForRecordType(recordClass.type)
+
+    const record = await adapter.getById(agentContext, id)
+    return record
+  }
+
+  public async getAll(agentContext: AgentContext, recordClass: BaseRecordConstructor<T>): Promise<T[]> {
+    const adapter = this.getAdapterForRecordType(recordClass.type)
+
+    const records = await adapter.query(agentContext)
+    return records
+  }
+
+  public async findByQuery(
+    agentContext: AgentContext,
+    recordClass: BaseRecordConstructor<T>,
+    query: Query<T>,
+    queryOptions?: QueryOptions
+  ): Promise<T[]> {
+    const adapter = this.getAdapterForRecordType(recordClass.type)
+
+    const records = await adapter.query(agentContext, query, queryOptions)
+    return records
+  }
+}

package/src/storage/index.ts

@@ -0,0 +1 @@
+export * from './DrizzleStorageService'

package/src/tenants/bundle.ts

@@ -0,0 +1,19 @@
+import { DrizzleRecordBundle } from '../DrizzleRecord'
+import { tenantDrizzleRecord } from './tenant'
+import { tenantRoutingDrizzleRecord } from './tenant-routing'
+
+export default {
+  name: 'tenants',
+  records: [tenantDrizzleRecord, tenantRoutingDrizzleRecord],
+
+  migrations: {
+    postgres: {
+      schemaModule: '@credo-ts/drizzle-storage/tenants/postgres',
+      migrationsPath: '../../migrations/tenants/postgres',
+    },
+    sqlite: {
+      schemaModule: '@credo-ts/drizzle-storage/tenants/sqlite',
+      migrationsPath: '../../migrations/tenants/sqlite',
+    },
+  },
+} as const satisfies DrizzleRecordBundle

package/src/tenants/postgres.ts

@@ -0,0 +1,2 @@
+export * from './tenant/postgres'
+export * from './tenant-routing/postgres'

package/src/tenants/sqlite.ts

@@ -0,0 +1,2 @@
+export * from './tenant/sqlite'
+export * from './tenant-routing/sqlite'

package/src/tenants/tenant/DrizzleTenantRecordAdapter.ts

@@ -0,0 +1,45 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { TenantRecord } from '@credo-ts/tenants'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleTenantAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['tenant']>
+export class DrizzleTenantRecordAdapter extends BaseDrizzleRecordAdapter<
+  TenantRecord,
+  typeof postgres.tenant,
+  typeof postgres,
+  typeof sqlite.tenant,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.tenant, sqlite: sqlite.tenant }, 'TenantRecord')
+  }
+
+  public getValues(record: TenantRecord): DrizzleAdapterValues<(typeof sqlite)['tenant']> {
+    const { label, storageVersion, ...customTags } = record.getTags()
+
+    return {
+      label,
+      storageVersion,
+      config: record.config,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleTenantAdapterValues): TenantRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, TenantRecord)
+    if (customTags) record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/tenants/tenant/index.ts

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

package/src/tenants/tenant/postgres.ts

@@ -0,0 +1,16 @@
+import { VersionString } from '@credo-ts/core'
+import { TenantRecord } from '@credo-ts/tenants'
+import { jsonb, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+
+export const tenant = pgTable(
+  'Tenant',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    storageVersion: text('storage_version').$type<VersionString>(),
+    config: jsonb().$type<TenantRecord['config']>().notNull(),
+    label: text().notNull(),
+  },
+  (table) => postgresBaseRecordIndexes(table, 'tenant')
+)

package/src/tenants/tenant/sqlite.ts

@@ -0,0 +1,16 @@
+import { VersionString } from '@credo-ts/core'
+import { TenantRecord } from '@credo-ts/tenants'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+
+export const tenant = sqliteTable(
+  'Tenant',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    storageVersion: text('storage_version').$type<VersionString>(),
+    config: text({ mode: 'json' }).$type<TenantRecord['config']>().notNull(),
+    label: text().notNull(),
+  },
+  (table) => sqliteBaseRecordIndexes(table, 'tenant')
+)

package/src/tenants/tenant-routing/DrizzleTenantRoutingRecordAdapter.ts

@@ -0,0 +1,44 @@
+import { JsonTransformer, TagsBase } from '@credo-ts/core'
+
+import {
+  BaseDrizzleRecordAdapter,
+  DrizzleAdapterRecordValues,
+  DrizzleAdapterValues,
+} from '../../adapter/BaseDrizzleRecordAdapter'
+
+import { TenantRoutingRecord } from '@credo-ts/tenants'
+import { DrizzleDatabase } from '../../DrizzleDatabase'
+import * as postgres from './postgres'
+import * as sqlite from './sqlite'
+
+type DrizzleTenantRoutingAdapterValues = DrizzleAdapterRecordValues<(typeof sqlite)['tenantRouting']>
+export class DrizzleTenantRoutingRecordAdapter extends BaseDrizzleRecordAdapter<
+  TenantRoutingRecord,
+  typeof postgres.tenantRouting,
+  typeof postgres,
+  typeof sqlite.tenantRouting,
+  typeof sqlite
+> {
+  public constructor(database: DrizzleDatabase<typeof postgres, typeof sqlite>) {
+    super(database, { postgres: postgres.tenantRouting, sqlite: sqlite.tenantRouting }, 'TenantRoutingRecord')
+  }
+
+  public getValues(record: TenantRoutingRecord): DrizzleAdapterValues<(typeof sqlite)['tenantRouting']> {
+    const { recipientKeyFingerprint, tenantId, ...customTags } = record.getTags()
+
+    return {
+      recipientKeyFingerprint,
+      tenantId,
+      customTags,
+    }
+  }
+
+  public toRecord(values: DrizzleTenantRoutingAdapterValues): TenantRoutingRecord {
+    const { customTags, ...remainingValues } = values
+
+    const record = JsonTransformer.fromJSON(remainingValues, TenantRoutingRecord)
+    if (customTags) record.setTags(customTags as TagsBase)
+
+    return record
+  }
+}

package/src/tenants/tenant-routing/index.ts

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

package/src/tenants/tenant-routing/postgres.ts

@@ -0,0 +1,20 @@
+import { foreignKey, pgTable, text } from 'drizzle-orm/pg-core'
+import { getPostgresBaseRecordTable, postgresBaseRecordIndexes } from '../../postgres/baseRecord'
+import { tenant } from '../postgres'
+
+export const tenantRouting = pgTable(
+  'TenantRouting',
+  {
+    ...getPostgresBaseRecordTable(),
+
+    tenantId: text('tenant_id').notNull(),
+    recipientKeyFingerprint: text('recipient_key_fingerprint').notNull(),
+  },
+  (table) => [
+    ...postgresBaseRecordIndexes(table, 'tenantRouting'),
+    foreignKey({
+      columns: [table.tenantId, table.contextCorrelationId],
+      foreignColumns: [tenant.id, tenant.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)

package/src/tenants/tenant-routing/sqlite.ts

@@ -0,0 +1,20 @@
+import { foreignKey, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { getSqliteBaseRecordTable, sqliteBaseRecordIndexes } from '../../sqlite/baseRecord'
+import { tenant } from '../sqlite'
+
+export const tenantRouting = sqliteTable(
+  'TenantRouting',
+  {
+    ...getSqliteBaseRecordTable(),
+
+    tenantId: text('tenant_id').notNull(),
+    recipientKeyFingerprint: text('recipient_key_fingerprint').notNull(),
+  },
+  (table) => [
+    ...sqliteBaseRecordIndexes(table, 'tenantRouting'),
+    foreignKey({
+      columns: [table.tenantId, table.contextCorrelationId],
+      foreignColumns: [tenant.id, tenant.contextCorrelationId],
+    }).onDelete('cascade'),
+  ]
+)