Script to double check user-social-login data

Author: jmgasper

README.md

@@ -128,6 +128,13 @@ The following table summarizes the environment variables used by the application
 | `JWT_SECRET`               | Secret key for signing/verifying internal JWTs (e.g., 2FA, one-time tokens).  | `just-a-random-string` (example)            |
 | `LEGACY_BLOWFISH_KEY`      | Base64 encoded Blowfish key for legacy password encryption/decryption.        | `dGhpc2lzRGVmYXVmZlZhbHVl` (example)        |
 
+### Migrating legacy social login data
+
+- Run `npx ts-node scripts/migrate-user-social-login.ts` to copy legacy `user_social_login` rows into `identity.user_social_login`.
+- Set `SOURCE_IDENTITY_PG_URL` (legacy) and `IDENTITY_DB_URL` (target) before running; `USER_SOCIAL_LOGIN_BATCH_SIZE` tunes pagination.
+- Flags available: `--dry-run` (log only), `--truncate` (clear target before load; ignored during dry-run), and `--insert-missing-only` (skip rows that already exist in the target).
+- Ensure `identity.social_login_provider` is migrated first so foreign keys resolve during import.
+
 
 **Downstream Usage**
 --------------------

scripts/migrate-user-social-login.ts

@@ -0,0 +1,148 @@
+import { PrismaClient as TargetIdentityClient } from '@prisma/client';
+import { PrismaClient as SourceIdentityClient } from '../legacy_migrate/generated/source-identity';
+
+const DEFAULT_BATCH_SIZE = 1000;
+
+const parseBoolFlag = (flag: string) => process.argv.includes(flag);
+
+const requiredEnv = (key: string) => {
+  const value = process.env[key];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${key}`);
+  }
+  return value;
+};
+
+async function migrateUserSocialLogin() {
+  const dryRun = parseBoolFlag('--dry-run');
+  const truncate = parseBoolFlag('--truncate');
+  const batchSize = Number(process.env.USER_SOCIAL_LOGIN_BATCH_SIZE ?? DEFAULT_BATCH_SIZE);
+  const insertMissingOnly = parseBoolFlag('--insert-missing-only');
+
+  if (Number.isNaN(batchSize) || batchSize <= 0) {
+    throw new Error(`Invalid USER_SOCIAL_LOGIN_BATCH_SIZE: ${process.env.USER_SOCIAL_LOGIN_BATCH_SIZE}`);
+  }
+
+  if (insertMissingOnly && truncate) {
+    throw new Error('Cannot use --insert-missing-only together with --truncate');
+  }
+
+  const sourceDbUrl = requiredEnv('SOURCE_IDENTITY_PG_URL');
+  const targetDbUrl = requiredEnv('IDENTITY_DB_URL');
+
+  const sourceDb = new SourceIdentityClient({
+    datasources: {
+      db: { url: sourceDbUrl },
+    },
+  });
+
+  const targetDb = new TargetIdentityClient({
+    datasources: {
+      db: { url: targetDbUrl },
+    },
+  });
+
+  console.log(
+    `Starting user_social_login migration (dryRun=${dryRun}, truncate=${truncate}, insertMissingOnly=${insertMissingOnly}, batchSize=${batchSize})`,
+  );
+
+  try {
+    const totalRows = await sourceDb.user_social_login.count();
+    if (!totalRows) {
+      console.log('No rows found in source user_social_login. Nothing to migrate.');
+      return;
+    }
+
+    console.log(`Found ${totalRows} rows to migrate from source user_social_login`);
+
+    if (truncate) {
+      if (dryRun) {
+        console.log('[Dry Run] Would truncate target identity.user_social_login');
+      } else {
+        console.log('Truncating target identity.user_social_login before import...');
+        await targetDb.$executeRaw`TRUNCATE TABLE identity.user_social_login RESTART IDENTITY CASCADE`;
+      }
+    }
+
+    for (let offset = 0; offset < totalRows; offset += batchSize) {
+      const batch = await sourceDb.user_social_login.findMany({
+        orderBy: [{ user_id: 'asc' }, { social_login_provider_id: 'asc' }],
+        skip: offset,
+        take: batchSize,
+      });
+
+      if (!batch.length) {
+        break;
+      }
+
+      if (dryRun) {
+        console.log(`[Dry Run] Would migrate ${batch.length} rows (offset ${offset})`);
+        continue;
+      }
+
+      const recordsToInsert = batch.map((record) => ({
+          social_user_id: record.social_user_id ?? null,
+          user_id: Number(record.user_id),
+          social_login_provider_id: Number(record.social_login_provider_id),
+          social_user_name: record.social_user_name,
+          social_email: record.social_email ?? null,
+          social_email_verified: record.social_email_verified ?? null,
+          create_date: record.create_date ?? undefined,
+          modify_date: record.modify_date ?? undefined,
+        }));
+
+      if (insertMissingOnly) {
+        const existing = await targetDb.user_social_login.findMany({
+          where: {
+            OR: recordsToInsert.map((rec) => ({
+              user_id: rec.user_id,
+              social_login_provider_id: rec.social_login_provider_id,
+            })),
+          },
+          select: {
+            user_id: true,
+            social_login_provider_id: true,
+          },
+        });
+
+        const existingKey = new Set(existing.map((row) => `${row.user_id}-${row.social_login_provider_id}`));
+        const missing = recordsToInsert.filter(
+          (rec) => !existingKey.has(`${rec.user_id}-${rec.social_login_provider_id}`),
+        );
+
+        if (!missing.length) {
+          console.log(`Batch at offset ${offset} skipped (all ${recordsToInsert.length} rows already present)`);
+          continue;
+        }
+
+        await targetDb.user_social_login.createMany({
+          data: missing,
+          skipDuplicates: true,
+        });
+
+        console.log(
+          `Migrated ${Math.min(offset + batch.length, totalRows)} / ${totalRows} rows (inserted ${missing.length}, skipped ${
+            recordsToInsert.length - missing.length
+          })`,
+        );
+        continue;
+      }
+
+      await targetDb.user_social_login.createMany({
+        data: recordsToInsert,
+        skipDuplicates: true,
+      });
+
+      console.log(`Migrated ${Math.min(offset + batch.length, totalRows)} / ${totalRows} rows`);
+    }
+
+    console.log('user_social_login migration completed');
+  } finally {
+    await Promise.allSettled([sourceDb.$disconnect(), targetDb.$disconnect()]);
+  }
+}
+
+migrateUserSocialLogin().catch((error) => {
+  console.error('user_social_login migration failed:', error);
+  process.exit(1);
+});