@payloadcms/db-postgres 3.0.0-beta.11 → 3.0.0-beta.110

package/README.md

@@ -14,7 +14,7 @@ npm install @payloadcms/db-postgres
 ## Usage
 
 ```ts
-import { buildConfig } from 'payload/config'
+import { buildConfig } from 'payload'
 import { postgresAdapter } from '@payloadcms/db-postgres'
 
 export default buildConfig({

package/dist/connect.d.ts

@@ -1,3 +1,3 @@
-import type { Connect } from 'payload/database';
+import type { Connect } from 'payload';
 export declare const connect: Connect;
 //# sourceMappingURL=connect.d.ts.map

package/dist/connect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../src/connect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AA+C/C,eAAO,MAAM,OAAO,EAAE,OAgDrB,CAAA"}
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../src/connect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAW,MAAM,SAAS,CAAA;AA6C/C,eAAO,MAAM,OAAO,EAAE,OAuDrB,CAAA"}

package/dist/connect.js

@@ -1,7 +1,6 @@
-import { sql } from 'drizzle-orm';
+import { pushDevSchema } from '@payloadcms/drizzle';
 import { drizzle } from 'drizzle-orm/node-postgres';
 import pg from 'pg';
-import { pushDevSchema } from './utilities/pushDevSchema.js';
 const connectWithReconnect = async function({ adapter, payload, reconnect = false }) {
     let result;
     if (!reconnect) {
@@ -9,7 +8,7 @@ const connectWithReconnect = async function({ adapter, payload, reconnect = fals
     } else {
         try {
             result = await adapter.pool.connect();
-        } catch (err) {
+        } catch (ignore) {
             setTimeout(()=>{
                 payload.logger.info('Reconnecting to postgres');
                 void connectWithReconnect({
@@ -32,7 +31,7 @@ const connectWithReconnect = async function({ adapter, payload, reconnect = fals
                     reconnect: true
                 });
             }
-        } catch (err) {
+        } catch (ignore) {
         // swallow error
         }
     });
@@ -42,16 +41,19 @@ export const connect = async function connect(options = {
 }) {
     const { hotReload } = options;
     this.schema = {
+        pgSchema: this.pgSchema,
         ...this.tables,
         ...this.relations,
         ...this.enums
     };
     try {
-        this.pool = new pg.Pool(this.poolOptions);
-        await connectWithReconnect({
-            adapter: this,
-            payload: this.payload
-        });
+        if (!this.pool) {
+            this.pool = new pg.Pool(this.poolOptions);
+            await connectWithReconnect({
+                adapter: this,
+                payload: this.payload
+            });
+        }
         const logger = this.logger || false;
         this.drizzle = drizzle(this.pool, {
             logger,
@@ -60,20 +62,34 @@ export const connect = async function connect(options = {
         if (!hotReload) {
             if (process.env.PAYLOAD_DROP_DATABASE === 'true') {
                 this.payload.logger.info(`---- DROPPING TABLES SCHEMA(${this.schemaName || 'public'}) ----`);
-                await this.drizzle.execute(sql.raw(`
-          drop schema if exists ${this.schemaName || 'public'} cascade;
-          create schema ${this.schemaName || 'public'};
-        `));
+                await this.dropDatabase({
+                    adapter: this
+                });
                 this.payload.logger.info('---- DROPPED TABLES ----');
             }
         }
     } catch (err) {
-        this.payload.logger.error(`Error: cannot connect to Postgres. Details: ${err.message}`, err);
+        this.payload.logger.error({
+            err,
+            msg: `Error: cannot connect to Postgres: ${err.message}`
+        });
+        if (typeof this.rejectInitializing === 'function') {
+            this.rejectInitializing();
+        }
         process.exit(1);
     }
     // Only push schema if not in production
-    if (process.env.NODE_ENV === 'production' || process.env.PAYLOAD_MIGRATING === 'true' || this.push === false) return;
-    await pushDevSchema(this);
+    if (process.env.NODE_ENV !== 'production' && process.env.PAYLOAD_MIGRATING !== 'true' && this.push !== false) {
+        await pushDevSchema(this);
+    }
+    if (typeof this.resolveInitializing === 'function') {
+        this.resolveInitializing();
+    }
+    if (process.env.NODE_ENV === 'production' && this.prodMigrations) {
+        await this.migrate({
+            migrations: this.prodMigrations
+        });
+    }
 };
 
 //# sourceMappingURL=connect.js.map

package/dist/connect.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/connect.ts"],"sourcesContent":["import type { Payload } from 'payload'\nimport type { Connect } from 'payload/database'\n\nimport { sql } from 'drizzle-orm'\nimport { drizzle } from 'drizzle-orm/node-postgres'\nimport pg from 'pg'\n\nimport type { PostgresAdapter } from './types.js'\n\nimport { pushDevSchema } from './utilities/pushDevSchema.js'\n\nconst connectWithReconnect = async function ({\n  adapter,\n  payload,\n  reconnect = false,\n}: {\n  adapter: PostgresAdapter\n  payload: Payload\n  reconnect?: boolean\n}) {\n  let result\n\n  if (!reconnect) {\n    result = await adapter.pool.connect()\n  } else {\n    try {\n      result = await adapter.pool.connect()\n    } catch (err) {\n      setTimeout(() => {\n        payload.logger.info('Reconnecting to postgres')\n        void connectWithReconnect({ adapter, payload, reconnect: true })\n      }, 1000)\n    }\n  }\n  if (!result) {\n    return\n  }\n  result.prependListener('error', (err) => {\n    try {\n      if (err.code === 'ECONNRESET') {\n        void connectWithReconnect({ adapter, payload, reconnect: true })\n      }\n    } catch (err) {\n      // swallow error\n    }\n  })\n}\n\nexport const connect: Connect = async function connect(\n  this: PostgresAdapter,\n  options = {\n    hotReload: false,\n  },\n) {\n  const { hotReload } = options\n\n  this.schema = {\n    ...this.tables,\n    ...this.relations,\n    ...this.enums,\n  }\n\n  try {\n    this.pool = new pg.Pool(this.poolOptions)\n    await connectWithReconnect({ adapter: this, payload: this.payload })\n\n    const logger = this.logger || false\n\n    this.drizzle = drizzle(this.pool, { logger, schema: this.schema })\n\n    if (!hotReload) {\n      if (process.env.PAYLOAD_DROP_DATABASE === 'true') {\n        this.payload.logger.info(`---- DROPPING TABLES SCHEMA(${this.schemaName || 'public'}) ----`)\n        await this.drizzle.execute(\n          sql.raw(`\n          drop schema if exists ${this.schemaName || 'public'} cascade;\n          create schema ${this.schemaName || 'public'};\n        `),\n        )\n        this.payload.logger.info('---- DROPPED TABLES ----')\n      }\n    }\n  } catch (err) {\n    this.payload.logger.error(`Error: cannot connect to Postgres. Details: ${err.message}`, err)\n    process.exit(1)\n  }\n\n  // Only push schema if not in production\n  if (\n    process.env.NODE_ENV === 'production' ||\n    process.env.PAYLOAD_MIGRATING === 'true' ||\n    this.push === false\n  )\n    return\n\n  await pushDevSchema(this)\n}\n"],"names":["sql","drizzle","pg","pushDevSchema","connectWithReconnect","adapter","payload","reconnect","result","pool","connect","err","setTimeout","logger","info","prependListener","code","options","hotReload","schema","tables","relations","enums","Pool","poolOptions","process","env","PAYLOAD_DROP_DATABASE","schemaName","execute","raw","error","message","exit","NODE_ENV","PAYLOAD_MIGRATING","push"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,GAAG,QAAQ,cAAa;AACjC,SAASC,OAAO,QAAQ,4BAA2B;AACnD,OAAOC,QAAQ,KAAI;AAInB,SAASC,aAAa,QAAQ,+BAA8B;AAE5D,MAAMC,uBAAuB,eAAgB,EAC3CC,OAAO,EACPC,OAAO,EACPC,YAAY,KAAK,EAKlB;IACC,IAAIC;IAEJ,IAAI,CAACD,WAAW;QACdC,SAAS,MAAMH,QAAQI,IAAI,CAACC,OAAO;IACrC,OAAO;QACL,IAAI;YACFF,SAAS,MAAMH,QAAQI,IAAI,CAACC,OAAO;QACrC,EAAE,OAAOC,KAAK;YACZC,WAAW;gBACTN,QAAQO,MAAM,CAACC,IAAI,CAAC;gBACpB,KAAKV,qBAAqB;oBAAEC;oBAASC;oBAASC,WAAW;gBAAK;YAChE,GAAG;QACL;IACF;IACA,IAAI,CAACC,QAAQ;QACX;IACF;IACAA,OAAOO,eAAe,CAAC,SAAS,CAACJ;QAC/B,IAAI;YACF,IAAIA,IAAIK,IAAI,KAAK,cAAc;gBAC7B,KAAKZ,qBAAqB;oBAAEC;oBAASC;oBAASC,WAAW;gBAAK;YAChE;QACF,EAAE,OAAOI,KAAK;QACZ,gBAAgB;QAClB;IACF;AACF;AAEA,OAAO,MAAMD,UAAmB,eAAeA,QAE7CO,UAAU;IACRC,WAAW;AACb,CAAC;IAED,MAAM,EAAEA,SAAS,EAAE,GAAGD;IAEtB,IAAI,CAACE,MAAM,GAAG;QACZ,GAAG,IAAI,CAACC,MAAM;QACd,GAAG,IAAI,CAACC,SAAS;QACjB,GAAG,IAAI,CAACC,KAAK;IACf;IAEA,IAAI;QACF,IAAI,CAACb,IAAI,GAAG,IAAIP,GAAGqB,IAAI,CAAC,IAAI,CAACC,WAAW;QACxC,MAAMpB,qBAAqB;YAAEC,SAAS,IAAI;YAAEC,SAAS,IAAI,CAACA,OAAO;QAAC;QAElE,MAAMO,SAAS,IAAI,CAACA,MAAM,IAAI;QAE9B,IAAI,CAACZ,OAAO,GAAGA,QAAQ,IAAI,CAACQ,IAAI,EAAE;YAAEI;YAAQM,QAAQ,IAAI,CAACA,MAAM;QAAC;QAEhE,IAAI,CAACD,WAAW;YACd,IAAIO,QAAQC,GAAG,CAACC,qBAAqB,KAAK,QAAQ;gBAChD,IAAI,CAACrB,OAAO,CAACO,MAAM,CAACC,IAAI,CAAC,CAAC,4BAA4B,EAAE,IAAI,CAACc,UAAU,IAAI,SAAS,MAAM,CAAC;gBAC3F,MAAM,IAAI,CAAC3B,OAAO,CAAC4B,OAAO,CACxB7B,IAAI8B,GAAG,CAAC,CAAC;gCACa,EAAE,IAAI,CAACF,UAAU,IAAI,SAAS;wBACtC,EAAE,IAAI,CAACA,UAAU,IAAI,SAAS;QAC9C,CAAC;gBAED,IAAI,CAACtB,OAAO,CAACO,MAAM,CAACC,IAAI,CAAC;YAC3B;QACF;IACF,EAAE,OAAOH,KAAK;QACZ,IAAI,CAACL,OAAO,CAACO,MAAM,CAACkB,KAAK,CAAC,CAAC,4CAA4C,EAAEpB,IAAIqB,OAAO,CAAC,CAAC,EAAErB;QACxFc,QAAQQ,IAAI,CAAC;IACf;IAEA,wCAAwC;IACxC,IACER,QAAQC,GAAG,CAACQ,QAAQ,KAAK,gBACzBT,QAAQC,GAAG,CAACS,iBAAiB,KAAK,UAClC,IAAI,CAACC,IAAI,KAAK,OAEd;IAEF,MAAMjC,cAAc,IAAI;AAC1B,EAAC"}
+{"version":3,"sources":["../src/connect.ts"],"sourcesContent":["import type { DrizzleAdapter } from '@payloadcms/drizzle/types'\nimport type { Connect, Payload } from 'payload'\n\nimport { pushDevSchema } from '@payloadcms/drizzle'\nimport { drizzle } from 'drizzle-orm/node-postgres'\nimport pg from 'pg'\n\nimport type { PostgresAdapter } from './types.js'\n\nconst connectWithReconnect = async function ({\n  adapter,\n  payload,\n  reconnect = false,\n}: {\n  adapter: PostgresAdapter\n  payload: Payload\n  reconnect?: boolean\n}) {\n  let result\n\n  if (!reconnect) {\n    result = await adapter.pool.connect()\n  } else {\n    try {\n      result = await adapter.pool.connect()\n    } catch (ignore) {\n      setTimeout(() => {\n        payload.logger.info('Reconnecting to postgres')\n        void connectWithReconnect({ adapter, payload, reconnect: true })\n      }, 1000)\n    }\n  }\n  if (!result) {\n    return\n  }\n  result.prependListener('error', (err) => {\n    try {\n      if (err.code === 'ECONNRESET') {\n        void connectWithReconnect({ adapter, payload, reconnect: true })\n      }\n    } catch (ignore) {\n      // swallow error\n    }\n  })\n}\n\nexport const connect: Connect = async function connect(\n  this: PostgresAdapter,\n  options = {\n    hotReload: false,\n  },\n) {\n  const { hotReload } = options\n\n  this.schema = {\n    pgSchema: this.pgSchema,\n    ...this.tables,\n    ...this.relations,\n    ...this.enums,\n  }\n\n  try {\n    if (!this.pool) {\n      this.pool = new pg.Pool(this.poolOptions)\n      await connectWithReconnect({ adapter: this, payload: this.payload })\n    }\n\n    const logger = this.logger || false\n    this.drizzle = drizzle(this.pool, { logger, schema: this.schema })\n\n    if (!hotReload) {\n      if (process.env.PAYLOAD_DROP_DATABASE === 'true') {\n        this.payload.logger.info(`---- DROPPING TABLES SCHEMA(${this.schemaName || 'public'}) ----`)\n        await this.dropDatabase({ adapter: this })\n        this.payload.logger.info('---- DROPPED TABLES ----')\n      }\n    }\n  } catch (err) {\n    this.payload.logger.error({ err, msg: `Error: cannot connect to Postgres: ${err.message}` })\n    if (typeof this.rejectInitializing === 'function') {\n      this.rejectInitializing()\n    }\n    process.exit(1)\n  }\n\n  // Only push schema if not in production\n  if (\n    process.env.NODE_ENV !== 'production' &&\n    process.env.PAYLOAD_MIGRATING !== 'true' &&\n    this.push !== false\n  ) {\n    await pushDevSchema(this as unknown as DrizzleAdapter)\n  }\n\n  if (typeof this.resolveInitializing === 'function') {\n    this.resolveInitializing()\n  }\n\n  if (process.env.NODE_ENV === 'production' && this.prodMigrations) {\n    await this.migrate({ migrations: this.prodMigrations })\n  }\n}\n"],"names":["pushDevSchema","drizzle","pg","connectWithReconnect","adapter","payload","reconnect","result","pool","connect","ignore","setTimeout","logger","info","prependListener","err","code","options","hotReload","schema","pgSchema","tables","relations","enums","Pool","poolOptions","process","env","PAYLOAD_DROP_DATABASE","schemaName","dropDatabase","error","msg","message","rejectInitializing","exit","NODE_ENV","PAYLOAD_MIGRATING","push","resolveInitializing","prodMigrations","migrate","migrations"],"mappings":"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"}

package/dist/exports/migration-utils.d.ts

@@ -0,0 +1,2 @@
+export { migratePostgresV2toV3 } from '../predefinedMigrations/v2-v3/index.js';
+//# sourceMappingURL=migration-utils.d.ts.map

package/dist/exports/migration-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-utils.d.ts","sourceRoot":"","sources":["../../src/exports/migration-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAA"}

package/dist/exports/migration-utils.js

@@ -0,0 +1,3 @@
+export { migratePostgresV2toV3 } from '../predefinedMigrations/v2-v3/index.js';
+
+//# sourceMappingURL=migration-utils.js.map

package/dist/exports/migration-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/migration-utils.ts"],"sourcesContent":["export { migratePostgresV2toV3 } from '../predefinedMigrations/v2-v3/index.js'\n"],"names":["migratePostgresV2toV3"],"mappings":"AAAA,SAASA,qBAAqB,QAAQ,yCAAwC"}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import type { DatabaseAdapterObj } from 'payload/database';
+import type { DatabaseAdapterObj } from 'payload';
 import type { Args, PostgresAdapter } from './types.js';
-export type { MigrateDownArgs, MigrateUpArgs } from './types.js';
-export { sql } from 'drizzle-orm';
 export declare function postgresAdapter(args: Args): DatabaseAdapterObj<PostgresAdapter>;
+export type { MigrateDownArgs, MigrateUpArgs } from '@payloadcms/drizzle/postgres';
+export { sql } from 'drizzle-orm';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAM1D,OAAO,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAiCvD,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAEhE,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAEjC,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,kBAAkB,CAAC,eAAe,CAAC,CAuE/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAW,MAAM,SAAS,CAAA;AAmD1D,OAAO,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIvD,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,kBAAkB,CAAC,eAAe,CAAC,CA4G/E;AAED,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAClF,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA"}

package/dist/index.js

@@ -1,83 +1,87 @@
-import fs from 'fs';
-import path from 'path';
-import { createDatabaseAdapter } from 'payload/database';
+import { beginTransaction, commitTransaction, count, create, createGlobal, createGlobalVersion, createVersion, deleteMany, deleteOne, deleteVersions, destroy, find, findGlobal, findGlobalVersions, findMigrationDir, findOne, findVersions, migrate, migrateDown, migrateFresh, migrateRefresh, migrateReset, migrateStatus, operatorMap, queryDrafts, rollbackTransaction, updateGlobal, updateGlobalVersion, updateOne, updateVersion } from '@payloadcms/drizzle';
+import { convertPathToJSONTraversal, countDistinct, createJSONQuery, createMigration, defaultDrizzleSnapshot, deleteWhere, dropDatabase, execute, getMigrationTemplate, init, insert, requireDrizzleKit } from '@payloadcms/drizzle/postgres';
+import { pgEnum, pgSchema, pgTable } from 'drizzle-orm/pg-core';
+import { createDatabaseAdapter, defaultBeginTransaction } from 'payload';
 import { connect } from './connect.js';
-import { create } from './create.js';
-import { createGlobal } from './createGlobal.js';
-import { createGlobalVersion } from './createGlobalVersion.js';
-import { createMigration } from './createMigration.js';
-import { createVersion } from './createVersion.js';
-import { deleteMany } from './deleteMany.js';
-import { deleteOne } from './deleteOne.js';
-import { deleteVersions } from './deleteVersions.js';
-import { destroy } from './destroy.js';
-import { find } from './find.js';
-import { findGlobal } from './findGlobal.js';
-import { findGlobalVersions } from './findGlobalVersions.js';
-import { findOne } from './findOne.js';
-import { findVersions } from './findVersions.js';
-import { init } from './init.js';
-import { migrate } from './migrate.js';
-import { migrateDown } from './migrateDown.js';
-import { migrateFresh } from './migrateFresh.js';
-import { migrateRefresh } from './migrateRefresh.js';
-import { migrateReset } from './migrateReset.js';
-import { migrateStatus } from './migrateStatus.js';
-import { queryDrafts } from './queryDrafts.js';
-import { beginTransaction } from './transactions/beginTransaction.js';
-import { commitTransaction } from './transactions/commitTransaction.js';
-import { rollbackTransaction } from './transactions/rollbackTransaction.js';
-import { updateOne } from './update.js';
-import { updateGlobal } from './updateGlobal.js';
-import { updateGlobalVersion } from './updateGlobalVersion.js';
-import { updateVersion } from './updateVersion.js';
-export { sql } from 'drizzle-orm';
 export function postgresAdapter(args) {
     const postgresIDType = args.idType || 'serial';
-    const payloadIDType = postgresIDType ? 'number' : 'text';
+    const payloadIDType = postgresIDType === 'serial' ? 'number' : 'text';
     function adapter({ payload }) {
         const migrationDir = findMigrationDir(args.migrationDir);
+        let resolveInitializing;
+        let rejectInitializing;
+        let adapterSchema;
+        const initializing = new Promise((res, rej)=>{
+            resolveInitializing = res;
+            rejectInitializing = rej;
+        });
+        if (args.schemaName) {
+            adapterSchema = pgSchema(args.schemaName);
+        } else {
+            adapterSchema = {
+                enum: pgEnum,
+                table: pgTable
+            };
+        }
         return createDatabaseAdapter({
             name: 'postgres',
-            // Postgres-specific
-            blockTableNames: {},
+            afterSchemaInit: args.afterSchemaInit ?? [],
+            beforeSchemaInit: args.beforeSchemaInit ?? [],
+            defaultDrizzleSnapshot,
             drizzle: undefined,
             enums: {},
+            features: {
+                json: true
+            },
             fieldConstraints: {},
+            getMigrationTemplate,
             idType: postgresIDType,
+            initializing,
             localesSuffix: args.localesSuffix || '_locales',
             logger: args.logger,
-            pgSchema: undefined,
+            operators: operatorMap,
+            pgSchema: adapterSchema,
             pool: undefined,
             poolOptions: args.pool,
+            prodMigrations: args.prodMigrations,
             push: args.push,
             relations: {},
             relationshipsSuffix: args.relationshipsSuffix || '_rels',
             schema: {},
             schemaName: args.schemaName,
             sessions: {},
+            tableNameMap: new Map(),
             tables: {},
+            transactionOptions: args.transactionOptions || undefined,
             versionsSuffix: args.versionsSuffix || '_v',
             // DatabaseAdapter
-            beginTransaction,
+            beginTransaction: args.transactionOptions === false ? defaultBeginTransaction() : beginTransaction,
             commitTransaction,
             connect,
+            convertPathToJSONTraversal,
+            count,
+            countDistinct,
             create,
             createGlobal,
             createGlobalVersion,
+            createJSONQuery,
             createMigration,
             createVersion,
             defaultIDType: payloadIDType,
             deleteMany,
             deleteOne,
             deleteVersions,
+            deleteWhere,
             destroy,
+            dropDatabase,
+            execute,
             find,
             findGlobal,
             findGlobalVersions,
             findOne,
             findVersions,
             init,
+            insert,
             migrate,
             migrateDown,
             migrateFresh,
@@ -85,13 +89,18 @@ export function postgresAdapter(args) {
             migrateReset,
             migrateStatus,
             migrationDir,
+            packageName: '@payloadcms/db-postgres',
             payload,
             queryDrafts,
+            rejectInitializing,
+            requireDrizzleKit,
+            resolveInitializing,
             rollbackTransaction,
             updateGlobal,
             updateGlobalVersion,
             updateOne,
-            updateVersion
+            updateVersion,
+            upsert: updateOne
         });
     }
     return {
@@ -99,37 +108,6 @@ export function postgresAdapter(args) {
         init: adapter
     };
 }
-/**
- * Attempt to find migrations directory.
- *
- * Checks for the following directories in order:
- * - `migrationDir` argument from Payload config
- * - `src/migrations`
- * - `dist/migrations`
- * - `migrations`
- *
- * Defaults to `src/migrations`
- *
- * @param migrationDir
- * @returns
- */ function findMigrationDir(migrationDir) {
-    const cwd = process.cwd();
-    const srcDir = path.resolve(cwd, 'src/migrations');
-    const distDir = path.resolve(cwd, 'dist/migrations');
-    const relativeMigrations = path.resolve(cwd, 'migrations');
-    // Use arg if provided
-    if (migrationDir) return migrationDir;
-    // Check other common locations
-    if (fs.existsSync(srcDir)) {
-        return srcDir;
-    }
-    if (fs.existsSync(distDir)) {
-        return distDir;
-    }
-    if (fs.existsSync(relativeMigrations)) {
-        return relativeMigrations;
-    }
-    return srcDir;
-}
+export { sql } from 'drizzle-orm';
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { Payload } from 'payload'\nimport type { DatabaseAdapterObj } from 'payload/database'\n\nimport fs from 'fs'\nimport path from 'path'\nimport { createDatabaseAdapter } from 'payload/database'\n\nimport type { Args, PostgresAdapter } from './types.js'\n\nimport { connect } from './connect.js'\nimport { create } from './create.js'\nimport { createGlobal } from './createGlobal.js'\nimport { createGlobalVersion } from './createGlobalVersion.js'\nimport { createMigration } from './createMigration.js'\nimport { createVersion } from './createVersion.js'\nimport { deleteMany } from './deleteMany.js'\nimport { deleteOne } from './deleteOne.js'\nimport { deleteVersions } from './deleteVersions.js'\nimport { destroy } from './destroy.js'\nimport { find } from './find.js'\nimport { findGlobal } from './findGlobal.js'\nimport { findGlobalVersions } from './findGlobalVersions.js'\nimport { findOne } from './findOne.js'\nimport { findVersions } from './findVersions.js'\nimport { init } from './init.js'\nimport { migrate } from './migrate.js'\nimport { migrateDown } from './migrateDown.js'\nimport { migrateFresh } from './migrateFresh.js'\nimport { migrateRefresh } from './migrateRefresh.js'\nimport { migrateReset } from './migrateReset.js'\nimport { migrateStatus } from './migrateStatus.js'\nimport { queryDrafts } from './queryDrafts.js'\nimport { beginTransaction } from './transactions/beginTransaction.js'\nimport { commitTransaction } from './transactions/commitTransaction.js'\nimport { rollbackTransaction } from './transactions/rollbackTransaction.js'\nimport { updateOne } from './update.js'\nimport { updateGlobal } from './updateGlobal.js'\nimport { updateGlobalVersion } from './updateGlobalVersion.js'\nimport { updateVersion } from './updateVersion.js'\n\nexport type { MigrateDownArgs, MigrateUpArgs } from './types.js'\n\nexport { sql } from 'drizzle-orm'\n\nexport function postgresAdapter(args: Args): DatabaseAdapterObj<PostgresAdapter> {\n  const postgresIDType = args.idType || 'serial'\n  const payloadIDType = postgresIDType ? 'number' : 'text'\n\n  function adapter({ payload }: { payload: Payload }) {\n    const migrationDir = findMigrationDir(args.migrationDir)\n\n    return createDatabaseAdapter<PostgresAdapter>({\n      name: 'postgres',\n\n      // Postgres-specific\n      blockTableNames: {},\n      drizzle: undefined,\n      enums: {},\n      fieldConstraints: {},\n      idType: postgresIDType,\n      localesSuffix: args.localesSuffix || '_locales',\n      logger: args.logger,\n      pgSchema: undefined,\n      pool: undefined,\n      poolOptions: args.pool,\n      push: args.push,\n      relations: {},\n      relationshipsSuffix: args.relationshipsSuffix || '_rels',\n      schema: {},\n      schemaName: args.schemaName,\n      sessions: {},\n      tables: {},\n      versionsSuffix: args.versionsSuffix || '_v',\n\n      // DatabaseAdapter\n      beginTransaction,\n      commitTransaction,\n      connect,\n      create,\n      createGlobal,\n      createGlobalVersion,\n      createMigration,\n      createVersion,\n      defaultIDType: payloadIDType,\n      deleteMany,\n      deleteOne,\n      deleteVersions,\n      destroy,\n      find,\n      findGlobal,\n      findGlobalVersions,\n      findOne,\n      findVersions,\n      init,\n      migrate,\n      migrateDown,\n      migrateFresh,\n      migrateRefresh,\n      migrateReset,\n      migrateStatus,\n      migrationDir,\n      payload,\n      queryDrafts,\n      rollbackTransaction,\n      updateGlobal,\n      updateGlobalVersion,\n      updateOne,\n      updateVersion,\n    })\n  }\n\n  return {\n    defaultIDType: payloadIDType,\n    init: adapter,\n  }\n}\n\n/**\n * Attempt to find migrations directory.\n *\n * Checks for the following directories in order:\n * - `migrationDir` argument from Payload config\n * - `src/migrations`\n * - `dist/migrations`\n * - `migrations`\n *\n * Defaults to `src/migrations`\n *\n * @param migrationDir\n * @returns\n */\nfunction findMigrationDir(migrationDir?: string): string {\n  const cwd = process.cwd()\n  const srcDir = path.resolve(cwd, 'src/migrations')\n  const distDir = path.resolve(cwd, 'dist/migrations')\n  const relativeMigrations = path.resolve(cwd, 'migrations')\n\n  // Use arg if provided\n  if (migrationDir) return migrationDir\n\n  // Check other common locations\n  if (fs.existsSync(srcDir)) {\n    return srcDir\n  }\n\n  if (fs.existsSync(distDir)) {\n    return distDir\n  }\n\n  if (fs.existsSync(relativeMigrations)) {\n    return relativeMigrations\n  }\n\n  return srcDir\n}\n"],"names":["fs","path","createDatabaseAdapter","connect","create","createGlobal","createGlobalVersion","createMigration","createVersion","deleteMany","deleteOne","deleteVersions","destroy","find","findGlobal","findGlobalVersions","findOne","findVersions","init","migrate","migrateDown","migrateFresh","migrateRefresh","migrateReset","migrateStatus","queryDrafts","beginTransaction","commitTransaction","rollbackTransaction","updateOne","updateGlobal","updateGlobalVersion","updateVersion","sql","postgresAdapter","args","postgresIDType","idType","payloadIDType","adapter","payload","migrationDir","findMigrationDir","name","blockTableNames","drizzle","undefined","enums","fieldConstraints","localesSuffix","logger","pgSchema","pool","poolOptions","push","relations","relationshipsSuffix","schema","schemaName","sessions","tables","versionsSuffix","defaultIDType","cwd","process","srcDir","resolve","distDir","relativeMigrations","existsSync"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,OAAOA,QAAQ,KAAI;AACnB,OAAOC,UAAU,OAAM;AACvB,SAASC,qBAAqB,QAAQ,mBAAkB;AAIxD,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,MAAM,QAAQ,cAAa;AACpC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,eAAe,QAAQ,uBAAsB;AACtD,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,SAAS,QAAQ,iBAAgB;AAC1C,SAASC,cAAc,QAAQ,sBAAqB;AACpD,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,IAAI,QAAQ,YAAW;AAChC,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,kBAAkB,QAAQ,0BAAyB;AAC5D,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,IAAI,QAAQ,YAAW;AAChC,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,WAAW,QAAQ,mBAAkB;AAC9C,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,cAAc,QAAQ,sBAAqB;AACpD,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,WAAW,QAAQ,mBAAkB;AAC9C,SAASC,gBAAgB,QAAQ,qCAAoC;AACrE,SAASC,iBAAiB,QAAQ,sCAAqC;AACvE,SAASC,mBAAmB,QAAQ,wCAAuC;AAC3E,SAASC,SAAS,QAAQ,cAAa;AACvC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,SAASC,aAAa,QAAQ,qBAAoB;AAIlD,SAASC,GAAG,QAAQ,cAAa;AAEjC,OAAO,SAASC,gBAAgBC,IAAU;IACxC,MAAMC,iBAAiBD,KAAKE,MAAM,IAAI;IACtC,MAAMC,gBAAgBF,iBAAiB,WAAW;IAElD,SAASG,QAAQ,EAAEC,OAAO,EAAwB;QAChD,MAAMC,eAAeC,iBAAiBP,KAAKM,YAAY;QAEvD,OAAOvC,sBAAuC;YAC5CyC,MAAM;YAEN,oBAAoB;YACpBC,iBAAiB,CAAC;YAClBC,SAASC;YACTC,OAAO,CAAC;YACRC,kBAAkB,CAAC;YACnBX,QAAQD;YACRa,eAAed,KAAKc,aAAa,IAAI;YACrCC,QAAQf,KAAKe,MAAM;YACnBC,UAAUL;YACVM,MAAMN;YACNO,aAAalB,KAAKiB,IAAI;YACtBE,MAAMnB,KAAKmB,IAAI;YACfC,WAAW,CAAC;YACZC,qBAAqBrB,KAAKqB,mBAAmB,IAAI;YACjDC,QAAQ,CAAC;YACTC,YAAYvB,KAAKuB,UAAU;YAC3BC,UAAU,CAAC;YACXC,QAAQ,CAAC;YACTC,gBAAgB1B,KAAK0B,cAAc,IAAI;YAEvC,kBAAkB;YAClBnC;YACAC;YACAxB;YACAC;YACAC;YACAC;YACAC;YACAC;YACAsD,eAAexB;YACf7B;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAiB;YACAD;YACAf;YACAG;YACAE;YACAC;YACAF;YACAG;QACF;IACF;IAEA,OAAO;QACL8B,eAAexB;QACfpB,MAAMqB;IACR;AACF;AAEA;;;;;;;;;;;;;CAaC,GACD,SAASG,iBAAiBD,YAAqB;IAC7C,MAAMsB,MAAMC,QAAQD,GAAG;IACvB,MAAME,SAAShE,KAAKiE,OAAO,CAACH,KAAK;IACjC,MAAMI,UAAUlE,KAAKiE,OAAO,CAACH,KAAK;IAClC,MAAMK,qBAAqBnE,KAAKiE,OAAO,CAACH,KAAK;IAE7C,sBAAsB;IACtB,IAAItB,cAAc,OAAOA;IAEzB,+BAA+B;IAC/B,IAAIzC,GAAGqE,UAAU,CAACJ,SAAS;QACzB,OAAOA;IACT;IAEA,IAAIjE,GAAGqE,UAAU,CAACF,UAAU;QAC1B,OAAOA;IACT;IAEA,IAAInE,GAAGqE,UAAU,CAACD,qBAAqB;QACrC,OAAOA;IACT;IAEA,OAAOH;AACT"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { DatabaseAdapterObj, Payload } from 'payload'\n\nimport {\n  beginTransaction,\n  commitTransaction,\n  count,\n  create,\n  createGlobal,\n  createGlobalVersion,\n  createVersion,\n  deleteMany,\n  deleteOne,\n  deleteVersions,\n  destroy,\n  find,\n  findGlobal,\n  findGlobalVersions,\n  findMigrationDir,\n  findOne,\n  findVersions,\n  migrate,\n  migrateDown,\n  migrateFresh,\n  migrateRefresh,\n  migrateReset,\n  migrateStatus,\n  operatorMap,\n  queryDrafts,\n  rollbackTransaction,\n  updateGlobal,\n  updateGlobalVersion,\n  updateOne,\n  updateVersion,\n} from '@payloadcms/drizzle'\nimport {\n  convertPathToJSONTraversal,\n  countDistinct,\n  createJSONQuery,\n  createMigration,\n  defaultDrizzleSnapshot,\n  deleteWhere,\n  dropDatabase,\n  execute,\n  getMigrationTemplate,\n  init,\n  insert,\n  requireDrizzleKit,\n} from '@payloadcms/drizzle/postgres'\nimport { pgEnum, pgSchema, pgTable } from 'drizzle-orm/pg-core'\nimport { createDatabaseAdapter, defaultBeginTransaction } from 'payload'\n\nimport type { Args, PostgresAdapter } from './types.js'\n\nimport { connect } from './connect.js'\n\nexport function postgresAdapter(args: Args): DatabaseAdapterObj<PostgresAdapter> {\n  const postgresIDType = args.idType || 'serial'\n  const payloadIDType = postgresIDType === 'serial' ? 'number' : 'text'\n\n  function adapter({ payload }: { payload: Payload }) {\n    const migrationDir = findMigrationDir(args.migrationDir)\n    let resolveInitializing\n    let rejectInitializing\n    let adapterSchema: PostgresAdapter['pgSchema']\n\n    const initializing = new Promise<void>((res, rej) => {\n      resolveInitializing = res\n      rejectInitializing = rej\n    })\n\n    if (args.schemaName) {\n      adapterSchema = pgSchema(args.schemaName)\n    } else {\n      adapterSchema = { enum: pgEnum, table: pgTable }\n    }\n\n    return createDatabaseAdapter<PostgresAdapter>({\n      name: 'postgres',\n      afterSchemaInit: args.afterSchemaInit ?? [],\n      beforeSchemaInit: args.beforeSchemaInit ?? [],\n      defaultDrizzleSnapshot,\n      drizzle: undefined,\n      enums: {},\n      features: {\n        json: true,\n      },\n      fieldConstraints: {},\n      getMigrationTemplate,\n      idType: postgresIDType,\n      initializing,\n      localesSuffix: args.localesSuffix || '_locales',\n      logger: args.logger,\n      operators: operatorMap,\n      pgSchema: adapterSchema,\n      pool: undefined,\n      poolOptions: args.pool,\n      prodMigrations: args.prodMigrations,\n      push: args.push,\n      relations: {},\n      relationshipsSuffix: args.relationshipsSuffix || '_rels',\n      schema: {},\n      schemaName: args.schemaName,\n      sessions: {},\n      tableNameMap: new Map<string, string>(),\n      tables: {},\n      transactionOptions: args.transactionOptions || undefined,\n      versionsSuffix: args.versionsSuffix || '_v',\n\n      // DatabaseAdapter\n      beginTransaction:\n        args.transactionOptions === false ? defaultBeginTransaction() : beginTransaction,\n      commitTransaction,\n      connect,\n      convertPathToJSONTraversal,\n      count,\n      countDistinct,\n      create,\n      createGlobal,\n      createGlobalVersion,\n      createJSONQuery,\n      createMigration,\n      createVersion,\n      defaultIDType: payloadIDType,\n      deleteMany,\n      deleteOne,\n      deleteVersions,\n      deleteWhere,\n      destroy,\n      dropDatabase,\n      execute,\n      find,\n      findGlobal,\n      findGlobalVersions,\n      findOne,\n      findVersions,\n      init,\n      insert,\n      migrate,\n      migrateDown,\n      migrateFresh,\n      migrateRefresh,\n      migrateReset,\n      migrateStatus,\n      migrationDir,\n      packageName: '@payloadcms/db-postgres',\n      payload,\n      queryDrafts,\n      rejectInitializing,\n      requireDrizzleKit,\n      resolveInitializing,\n      rollbackTransaction,\n      updateGlobal,\n      updateGlobalVersion,\n      updateOne,\n      updateVersion,\n      upsert: updateOne,\n    })\n  }\n\n  return {\n    defaultIDType: payloadIDType,\n    init: adapter,\n  }\n}\n\nexport type { MigrateDownArgs, MigrateUpArgs } from '@payloadcms/drizzle/postgres'\nexport { sql } from 'drizzle-orm'\n"],"names":["beginTransaction","commitTransaction","count","create","createGlobal","createGlobalVersion","createVersion","deleteMany","deleteOne","deleteVersions","destroy","find","findGlobal","findGlobalVersions","findMigrationDir","findOne","findVersions","migrate","migrateDown","migrateFresh","migrateRefresh","migrateReset","migrateStatus","operatorMap","queryDrafts","rollbackTransaction","updateGlobal","updateGlobalVersion","updateOne","updateVersion","convertPathToJSONTraversal","countDistinct","createJSONQuery","createMigration","defaultDrizzleSnapshot","deleteWhere","dropDatabase","execute","getMigrationTemplate","init","insert","requireDrizzleKit","pgEnum","pgSchema","pgTable","createDatabaseAdapter","defaultBeginTransaction","connect","postgresAdapter","args","postgresIDType","idType","payloadIDType","adapter","payload","migrationDir","resolveInitializing","rejectInitializing","adapterSchema","initializing","Promise","res","rej","schemaName","enum","table","name","afterSchemaInit","beforeSchemaInit","drizzle","undefined","enums","features","json","fieldConstraints","localesSuffix","logger","operators","pool","poolOptions","prodMigrations","push","relations","relationshipsSuffix","schema","sessions","tableNameMap","Map","tables","transactionOptions","versionsSuffix","defaultIDType","packageName","upsert","sql"],"mappings":"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"}

package/dist/predefinedMigrations/relationships-v2-v3.d.ts

@@ -0,0 +1,4 @@
+declare const imports = "import { migratePostgresV2toV3 } from '@payloadcms/db-postgres/migration-utils'";
+declare const upSQL = "   await migratePostgresV2toV3({\n        // enables logging of changes that will be made to the database\n        debug: false,\n        payload,\n        req,\n        })\n";
+export { imports, upSQL };
+//# sourceMappingURL=relationships-v2-v3.d.ts.map

package/dist/predefinedMigrations/relationships-v2-v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationships-v2-v3.d.ts","sourceRoot":"","sources":["../../src/predefinedMigrations/relationships-v2-v3.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,OAAO,oFAAoF,CAAA;AACjG,QAAA,MAAM,KAAK,mLAMV,CAAA;AAED,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAA"}

package/dist/predefinedMigrations/relationships-v2-v3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/predefinedMigrations/relationships-v2-v3.ts"],"sourcesContent":["const imports = `import { migratePostgresV2toV3 } from '@payloadcms/db-postgres/migration-utils'`\nconst upSQL = `   await migratePostgresV2toV3({\n        // enables logging of changes that will be made to the database\n        debug: false,\n        payload,\n        req,\n        })\n`\n\nexport { imports, upSQL }\n"],"names":["imports","upSQL"],"mappings":"AAAA,MAAMA,UAAU,CAAC,+EAA+E,CAAC;AACjG,MAAMC,QAAQ,CAAC;;;;;;AAMf,CAAC;AAED,SAASD,OAAO,EAAEC,KAAK,GAAE"}

package/dist/predefinedMigrations/relationships-v2-v3.mjs

@@ -0,0 +1,11 @@
+const imports = `import { migratePostgresV2toV3 } from '@payloadcms/db-postgres/migration-utils'`;
+const upSQL = `   await migratePostgresV2toV3({
+        // enables logging of changes that will be made to the database
+        debug: false,
+        payload,
+        req,
+        })
+`;
+export { imports, upSQL };
+
+//# sourceMappingURL=relationships-v2-v3.js.map

package/dist/predefinedMigrations/v2-v3/fetchAndResave/index.d.ts

@@ -0,0 +1,20 @@
+import type { TransactionPg } from '@payloadcms/drizzle/types';
+import type { Field, Payload, PayloadRequest } from 'payload';
+import type { PostgresAdapter } from '../../../types.js';
+import type { DocsToResave } from '../types.js';
+type Args = {
+    adapter: PostgresAdapter;
+    collectionSlug?: string;
+    db: TransactionPg;
+    debug: boolean;
+    docsToResave: DocsToResave;
+    fields: Field[];
+    globalSlug?: string;
+    isVersions: boolean;
+    payload: Payload;
+    req: PayloadRequest;
+    tableName: string;
+};
+export declare const fetchAndResave: ({ adapter, collectionSlug, db, debug, docsToResave, fields, globalSlug, isVersions, payload, req, tableName, }: Args) => Promise<void>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/predefinedMigrations/v2-v3/fetchAndResave/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/predefinedMigrations/v2-v3/fetchAndResave/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,eAAe,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,EAAE,EAAE,aAAa,CAAA;IACjB,KAAK,EAAE,OAAO,CAAA;IACd,YAAY,EAAE,YAAY,CAAA;IAC1B,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,eAAO,MAAM,cAAc,mHAYxB,IAAI,kBAwMN,CAAA"}

package/dist/predefinedMigrations/v2-v3/fetchAndResave/index.js

@@ -0,0 +1,169 @@
+import { upsertRow } from '@payloadcms/drizzle';
+import { traverseFields } from './traverseFields.js';
+export const fetchAndResave = async ({ adapter, collectionSlug, db, debug, docsToResave, fields, globalSlug, isVersions, payload, req, tableName })=>{
+    for (const [id, rows] of Object.entries(docsToResave)){
+        if (collectionSlug) {
+            const collectionConfig = payload.collections[collectionSlug].config;
+            if (collectionConfig) {
+                if (isVersions) {
+                    const doc = await payload.findVersionByID({
+                        id,
+                        collection: collectionSlug,
+                        depth: 0,
+                        fallbackLocale: null,
+                        locale: 'all',
+                        req,
+                        showHiddenFields: true
+                    });
+                    if (debug) {
+                        payload.logger.info(`The collection "${collectionConfig.slug}" version with ID ${id} will be migrated`);
+                    }
+                    traverseFields({
+                        doc,
+                        fields,
+                        path: '',
+                        rows
+                    });
+                    try {
+                        await upsertRow({
+                            id: doc.id,
+                            adapter,
+                            data: doc,
+                            db,
+                            fields,
+                            ignoreResult: true,
+                            operation: 'update',
+                            req,
+                            tableName
+                        });
+                    } catch (err) {
+                        payload.logger.error(`"${collectionConfig.slug}" version with ID ${doc.id} FAILED TO MIGRATE`);
+                        throw err;
+                    }
+                    if (debug) {
+                        payload.logger.info(`"${collectionConfig.slug}" version with ID ${doc.id} migrated successfully!`);
+                    }
+                } else {
+                    const doc = await payload.findByID({
+                        id,
+                        collection: collectionSlug,
+                        depth: 0,
+                        fallbackLocale: null,
+                        locale: 'all',
+                        req,
+                        showHiddenFields: true
+                    });
+                    if (debug) {
+                        payload.logger.info(`The collection "${collectionConfig.slug}" with ID ${doc.id} will be migrated`);
+                    }
+                    traverseFields({
+                        doc,
+                        fields,
+                        path: '',
+                        rows
+                    });
+                    try {
+                        await upsertRow({
+                            id: doc.id,
+                            adapter,
+                            data: doc,
+                            db,
+                            fields,
+                            ignoreResult: true,
+                            operation: 'update',
+                            req,
+                            tableName
+                        });
+                    } catch (err) {
+                        payload.logger.error(`The collection "${collectionConfig.slug}" with ID ${doc.id} has FAILED TO MIGRATE`);
+                        throw err;
+                    }
+                    if (debug) {
+                        payload.logger.info(`The collection "${collectionConfig.slug}" with ID ${doc.id} has migrated successfully!`);
+                    }
+                }
+            }
+        }
+        if (globalSlug) {
+            const globalConfig = payload.config.globals?.find((global)=>global.slug === globalSlug);
+            if (globalConfig) {
+                if (isVersions) {
+                    const { docs } = await payload.findGlobalVersions({
+                        slug: globalSlug,
+                        depth: 0,
+                        fallbackLocale: null,
+                        limit: 0,
+                        locale: 'all',
+                        req,
+                        showHiddenFields: true
+                    });
+                    if (debug) {
+                        payload.logger.info(`${docs.length} global "${globalSlug}" versions will be migrated`);
+                    }
+                    for (const doc of docs){
+                        traverseFields({
+                            doc,
+                            fields,
+                            path: '',
+                            rows
+                        });
+                        try {
+                            await upsertRow({
+                                id: doc.id,
+                                adapter,
+                                data: doc,
+                                db,
+                                fields,
+                                ignoreResult: true,
+                                operation: 'update',
+                                req,
+                                tableName
+                            });
+                        } catch (err) {
+                            payload.logger.error(`"${globalSlug}" version with ID ${doc.id} FAILED TO MIGRATE`);
+                            throw err;
+                        }
+                        if (debug) {
+                            payload.logger.info(`"${globalSlug}" version with ID ${doc.id} migrated successfully!`);
+                        }
+                    }
+                } else {
+                    const doc = await payload.findGlobal({
+                        slug: globalSlug,
+                        depth: 0,
+                        fallbackLocale: null,
+                        locale: 'all',
+                        req,
+                        showHiddenFields: true
+                    });
+                    traverseFields({
+                        doc,
+                        fields,
+                        path: '',
+                        rows
+                    });
+                    try {
+                        await upsertRow({
+                            adapter,
+                            data: doc,
+                            db,
+                            fields,
+                            ignoreResult: true,
+                            operation: 'update',
+                            req,
+                            tableName
+                        });
+                    } catch (err) {
+                        payload.logger.error(`The global "${globalSlug}" has FAILED TO MIGRATE`);
+                        throw err;
+                    }
+                    if (debug) {
+                        payload.logger.info(`The global "${globalSlug}" has migrated successfully!`);
+                    }
+                }
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=index.js.map