本番環境のCloud Firestoreにデータパッチを当てる

// functions/src/index.ts
export const runDatapatchScript = functionsOnTokyo
  .runWith({ timeoutSeconds:  540 })
  .https.onCall(async (data: DataPatchScriptParams, context) => {
    if (!context.auth) {
      throw new functions.https.HttpsError(
        'failed-precondition',
        'The function must be called while authenticated.'
      )
    }
    
    ...
    
    const patchScript = getDataPatchScript(data) // 対象のスクリプトを解決
    const result = await patchScript.exec()
    return result
  })

import * as firebaseAdmin from 'firebase-admin'
import * as functions from 'firebase-functions'

export type DataPatchScriptParams = {
  name: string
  dryrun: boolean
}

export abstract class DataPatchScript {
  protected readonly db
  protected readonly isDryrun: boolean
  constructor(params: DataPatchScriptParams) {
    this.db = firebaseAdmin.firestore()
    this.isDryrun = params.dryrun ?? true
  }

  private executionLogs = []
  private logging(...logs: string[]) {
    if (!this.isDryrun) {
      functions.logger.log(...logs)
    }
    Array.prototype.push.apply(this.executionLogs, logs)
  }

  /**
   * 更新対象のデータ（Doc）
   */
  abstract targetDocsQuery(): FirebaseFirestore.Query<FirebaseFirestore.DocumentData>
  private targetDocRefs: FirebaseFirestore.DocumentReference[] = []
  /**
   * データパッチしたい更新処理
   * @param transaction
   * @param snapshot
   */
  abstract updateFunction(
    transaction: FirebaseFirestore.Transaction,
    snapshot: FirebaseFirestore.QuerySnapshot<FirebaseFirestore.DocumentData>
  ): Promise<unknown>

  beforeLog(
    documentSnapshots: FirebaseFirestore.DocumentSnapshot<FirebaseFirestore.DocumentData>[]
  ): void {
    this.logSnapshot(documentSnapshots, 'before')
  }

  afterLog(
    documentSnapshots: FirebaseFirestore.DocumentSnapshot<FirebaseFirestore.DocumentData>[]
  ): void {
    // DELETEを行った場合、refに対してundefinedが返るので対象から外す。
    const snapshots = documentSnapshots.filter((doc) => !!doc.data())

    this.logSnapshot(snapshots, 'after')
  }

  private logSnapshot(
    documentSnapshots: FirebaseFirestore.DocumentSnapshot<FirebaseFirestore.DocumentData>[],
    step: 'before' | 'after'
  ): void {
    const log: string[] = [`${step} snapshot is below:`]
    documentSnapshots.forEach((doc) => {
      log.push(
        JSON.stringify({
          documentId: doc.id,
          data: doc.data(),
        })
      )
    })
    log.push(`total count: ${documentSnapshots.length}`)
    this.logging(...log)
  }

  async exec(): Promise<string> {
    this.logging(
      `start: ${this.constructor.name}${this.isDryrun ? ' as dryrun' : ''}`
    )

    const snapshot = await this.targetDocsQuery().get()
    this.targetDocRefs = snapshot.docs.map((doc) => doc.ref)
    this.beforeLog(snapshot.docs)

    if (!this.isDryrun) {
      await this.db.runTransaction(
        async (transaction) => await this.updateFunction(transaction, snapshot)
      )

      const afterSnapshot = await this.db.getAll(...this.targetDocRefs)
      this.afterLog(afterSnapshot)
    }

    this.logging(
      `finish: ${this.constructor.name}${this.isDryrun ? ' as dryrun' : ''}`
    )

    return this.executionLogs.join('\n')
  }
}

const execDatapatch = async () => {
    const runDatapatch = functions.httpsCallable('runDatapatchScript')
    runDatapatch({ name: datapatchName, dryrun: dryRun })
      .then((result) => {
        setDatapatchResult(result.data)
      })
      .catch((e) => {
        setDatapatchResult(e.message)
      })
  }

import { DataPatchScript } from './abstractDatapatchScript'
import * as firebaseAdmin from 'firebase-admin'
export class UpdateMyCollection_20210910 extends DataPatchScript {

  targetDocsQuery(): FirebaseFirestore.Query<FirebaseFirestore.DocumentData> {
    return this.db
      .collection('my_collection')
      .orderBy('old_field')
  }

  async updateFunction(
    transaction: FirebaseFirestore.Transaction,
    snapshot: FirebaseFirestore.QuerySnapshot<FirebaseFirestore.DocumentData>
  ): Promise<void> {
    snapshot.docs.forEach((doc) => {
      transaction.update(doc.ref, {
        old_field: firebaseAdmin.firestore.FieldValue.delete(),
      })
    })
  }
}

export const getDataPatchScript = (
  params: DataPatchScriptParams
): DataPatchScript | undefined => {
  switch (params.name) {
    case UpdateHogeHogeCollection.name:
      return new UpdateHogeHogeCollection(params)
    case UpdateMyCollection_20210910.name:
      return new UpdateMyCollection_20210910(params)
    // ...
    default:
      return
  }
}