Skip to content

AI-native design editor. Open-source Figma alternative.

6.9 KB
Raw Blame
import type { Kysely } from 'kysely'
import { Migrator, type Migration, type MigrationProvider } from 'kysely/migration'

import * as foundation from './migrations/001_foundation'
import * as cleanupClaims from './migrations/002_upload_cleanup_claims'
import * as documentCleanupClaims from './migrations/003_document_cleanup_claims'
import * as documentSharing from './migrations/004_document_sharing'
import * as documentCollaborationEpoch from './migrations/005_document_collaboration_epoch'
import * as invitationContinuation from './migrations/006_invitation_continuation'
import * as collaborationState from './migrations/007_collaboration_state'
import * as storageReservations from './migrations/008_storage_reservations'
import * as workspaceEntitlements from './migrations/009_workspace_entitlements'
import * as uploadFinalization from './migrations/010_upload_finalization'
import * as uploadFinalizationLease from './migrations/011_upload_finalization_lease'
import * as transactionalEmail from './migrations/012_transactional_email'
import * as adminEnrollment from './migrations/013_admin_enrollment'
import * as enrollmentEmailKinds from './migrations/014_enrollment_email_kinds'
import * as cloudRateLimit from './migrations/015_cloud_rate_limit'
import * as authSchema from './migrations/016_auth_schema'
import * as authenticationEmailKinds from './migrations/017_authentication_email_kinds'
import * as authenticationMFA from './migrations/018_authentication_mfa'
import * as betterAuthAccountIssuer from './migrations/019_better_auth_account_issuer'
import * as workspaceInvitations from './migrations/020_workspace_invitations'
import * as documentVersions from './migrations/021_document_versions'
import * as entitlementExternalVersion from './migrations/022_entitlement_external_version'
import * as documentImages from './migrations/023_document_images'
import * as accountActivity from './migrations/024_account_activity'
import * as tableNames from './migrations/025_table_names'
import * as userPicture from './migrations/026_user_picture'
import * as documentKind from './migrations/027_document_kind'
import type { CloudDatabase } from './tables'

const migrations: Record<string, Migration> = {
  '001_foundation': foundation,
  '002_upload_cleanup_claims': cleanupClaims,
  '003_document_cleanup_claims': documentCleanupClaims,
  '004_document_sharing': documentSharing,
  '005_document_collaboration_epoch': documentCollaborationEpoch,
  '006_invitation_continuation': invitationContinuation,
  '007_collaboration_state': collaborationState,
  '008_storage_reservations': storageReservations,
  '009_workspace_entitlements': workspaceEntitlements,
  '010_upload_finalization': uploadFinalization,
  '011_upload_finalization_lease': uploadFinalizationLease,
  '012_transactional_email': transactionalEmail,
  '013_admin_enrollment': adminEnrollment,
  '014_enrollment_email_kinds': enrollmentEmailKinds,
  '015_cloud_rate_limit': cloudRateLimit,
  '016_auth_schema': authSchema,
  '017_authentication_email_kinds': authenticationEmailKinds,
  '018_authentication_mfa': authenticationMFA,
  '019_better_auth_account_issuer': betterAuthAccountIssuer,
  '020_workspace_invitations': workspaceInvitations,
  '021_document_versions': documentVersions,
  '022_entitlement_external_version': entitlementExternalVersion,
  '023_document_images': documentImages,
  '024_account_activity': accountActivity,
  '025_table_names': tableNames,
  '026_user_picture': userPicture,
  '027_document_kind': documentKind
}

class CloudMigrationProvider implements MigrationProvider {
  async getMigrations(): Promise<Record<string, Migration>> {
    return migrations
  }
}

export type CloudAuthMigration = {
  run(): Promise<void>
  schemaVersion: string
}

const REQUIRED_AUTH_SCHEMA: Record<string, string[]> = {
  user: [
    'id',
    'name',
    'email',
    'email_verified',
    'created_at',
    'updated_at',
    'role',
    'banned',
    'two_factor_enabled'
  ],
  session: ['id', 'expires_at', 'token', 'user_id', 'impersonated_by'],
  account: ['id', 'account_id', 'provider_id', 'user_id'],
  verification: ['id', 'identifier', 'value', 'expires_at'],
  device_code: ['id', 'device_code', 'user_code', 'status', 'client_id'],
  rate_limit: ['id', 'key', 'count', 'last_request'],
  two_factor: [
    'id',
    'secret',
    'backup_codes',
    'user_id',
    'verified',
    'failed_verification_count',
    'locked_until'
  ],
  passkey: ['id', 'public_key', 'user_id', 'credential_id', 'counter', 'device_type', 'backed_up']
}

async function existingAuthSchema(
  database: Kysely<CloudDatabase>
): Promise<Map<string, Set<string>>> {
  const tables = await database.introspection.getTables()
  return new Map(
    tables
      .filter((table) => Object.hasOwn(REQUIRED_AUTH_SCHEMA, table.name))
      .map((table) => [table.name, new Set(table.columns.map((column) => column.name))])
  )
}

async function migrateAuthSchema(
  database: Kysely<CloudDatabase>,
  migration: CloudAuthMigration
): Promise<void> {
  const recorded = await database
    .selectFrom('authSchemaVersion')
    .select('version')
    .where('id', '=', 'better-auth')
    .executeTakeFirst()
  if (recorded) {
    if (recorded.version !== migration.schemaVersion) {
      throw new Error(
        `Better Auth schema ${recorded.version} requires an explicit migration to ${migration.schemaVersion}`
      )
    }
    return
  }

  const existing = await existingAuthSchema(database)
  if (existing.size === 0) {
    await migration.run()
  } else {
    const missing = Object.entries(REQUIRED_AUTH_SCHEMA).flatMap(([table, requiredColumns]) => {
      const columns = existing.get(table)
      if (!columns) return [table]
      return requiredColumns
        .filter((column) => !columns.has(column))
        .map((column) => `${table}.${column}`)
    })
    if (missing.length > 0) {
      throw new Error(`Existing Better Auth schema is incomplete: ${missing.join(', ')}`)
    }
  }

  await database
    .insertInto('authSchemaVersion')
    .values({ id: 'better-auth', version: migration.schemaVersion, updatedAt: new Date() })
    .execute()
}

/** Runs a migrator to its latest migration, failing with every error it reports. */
export async function migrateToLatest(migrator: Migrator, failure: string): Promise<void> {
  const result = await migrator.migrateToLatest()
  const failed = result.results?.find((migration) => migration.status === 'Error')
  if (result.error || failed) {
    throw new AggregateError(
      [result.error, failed ? new Error(`Migration failed: ${failed.migrationName}`) : null].filter(
        (error): error is Error => error instanceof Error
      ),
      failure
    )
  }
}

export async function migrateCloudDatabase(
  database: Kysely<CloudDatabase>,
  authMigration?: CloudAuthMigration
): Promise<void> {
  await migrateToLatest(
    new Migrator({ db: database, provider: new CloudMigrationProvider() }),
    'OpenPencil Cloud database migration failed'
  )
  if (authMigration) await migrateAuthSchema(database, authMigration)
}