@depup/payload 3.79.1-depup.0

package/dist/database/getLocalizedPaths.js

@@ -0,0 +1,186 @@
+import { fieldShouldBeLocalized } from '../fields/config/types.js';
+import { APIError } from '../index.js';
+import { SAFE_FIELD_PATH_REGEX } from '../types/constants.js';
+export function getLocalizedPaths({ collectionSlug, fields, globalSlug, incomingPath, locale, overrideAccess = false, parentIsLocalized, payload }) {
+    const pathSegments = incomingPath.split('.');
+    const localizationConfig = payload.config.localization;
+    let paths = [
+        {
+            collectionSlug,
+            complete: false,
+            // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+            field: undefined,
+            fields,
+            globalSlug,
+            invalid: false,
+            parentIsLocalized: parentIsLocalized,
+            path: ''
+        }
+    ];
+    for(let i = 0; i < pathSegments.length; i += 1){
+        const segment = pathSegments[i];
+        const lastIncompletePath = paths.find(({ complete })=>!complete);
+        if (lastIncompletePath) {
+            const { path } = lastIncompletePath;
+            let currentPath = path ? `${path}.${segment}` : segment;
+            let fieldsToSearch;
+            let _parentIsLocalized = parentIsLocalized;
+            let matchedField;
+            if (lastIncompletePath?.field?.type === 'blocks') {
+                if (segment === 'blockType') {
+                    matchedField = {
+                        name: 'blockType',
+                        type: 'text'
+                    };
+                } else {
+                    for (const _block of lastIncompletePath.field.blockReferences ?? lastIncompletePath.field.blocks){
+                        let block;
+                        if (typeof _block === 'string') {
+                            block = payload.blocks[_block];
+                        } else {
+                            block = _block;
+                        }
+                        matchedField = block.flattenedFields.find((field)=>field.name === segment);
+                        if (matchedField) {
+                            break;
+                        }
+                    }
+                }
+            } else {
+                if (lastIncompletePath?.field && 'flattenedFields' in lastIncompletePath.field) {
+                    fieldsToSearch = lastIncompletePath.field.flattenedFields;
+                } else {
+                    fieldsToSearch = lastIncompletePath.fields;
+                }
+                _parentIsLocalized = parentIsLocalized || lastIncompletePath.field?.localized;
+                matchedField = fieldsToSearch.find((field)=>field.name === segment);
+            }
+            lastIncompletePath.field = matchedField;
+            if (currentPath === 'globalType' && globalSlug) {
+                lastIncompletePath.path = currentPath;
+                lastIncompletePath.complete = true;
+                lastIncompletePath.field = {
+                    name: 'globalType',
+                    type: 'text'
+                };
+                return paths;
+            }
+            if (currentPath === 'relationTo') {
+                lastIncompletePath.path = currentPath;
+                lastIncompletePath.complete = true;
+                lastIncompletePath.field = {
+                    name: 'relationTo',
+                    type: 'select',
+                    options: Object.keys(payload.collections)
+                };
+                return paths;
+            }
+            if (!matchedField && currentPath === 'id' && i === pathSegments.length - 1) {
+                lastIncompletePath.path = currentPath;
+                const idField = {
+                    name: 'id',
+                    type: payload.db.defaultIDType
+                };
+                lastIncompletePath.field = idField;
+                lastIncompletePath.complete = true;
+                return paths;
+            }
+            if (matchedField) {
+                if ('hidden' in matchedField && matchedField.hidden && !overrideAccess) {
+                    lastIncompletePath.invalid = true;
+                }
+                const nextSegment = pathSegments[i + 1];
+                const currentFieldIsLocalized = fieldShouldBeLocalized({
+                    field: matchedField,
+                    parentIsLocalized: _parentIsLocalized
+                });
+                const nextSegmentIsLocale = localizationConfig && localizationConfig.localeCodes.includes(nextSegment) && currentFieldIsLocalized;
+                if (nextSegmentIsLocale) {
+                    // Skip the next iteration, because it's a locale
+                    i += 1;
+                    currentPath = `${currentPath}.${nextSegment}`;
+                } else if (localizationConfig && currentFieldIsLocalized) {
+                    currentPath = `${currentPath}.${locale}`;
+                }
+                switch(matchedField.type){
+                    case 'join':
+                    case 'relationship':
+                    case 'upload':
+                        {
+                            // If this is a polymorphic relation,
+                            // We only support querying directly (no nested querying)
+                            if (matchedField.type !== 'join' && typeof matchedField.relationTo !== 'string') {
+                                lastIncompletePath.path = pathSegments.join('.');
+                                if (![
+                                    matchedField.name,
+                                    'relationTo',
+                                    'value'
+                                ].includes(pathSegments.at(-1))) {
+                                    lastIncompletePath.invalid = true;
+                                } else {
+                                    lastIncompletePath.complete = true;
+                                }
+                            } else {
+                                lastIncompletePath.complete = true;
+                                lastIncompletePath.path = currentPath;
+                                const nestedPathToQuery = pathSegments.slice(nextSegmentIsLocale ? i + 2 : i + 1).join('.');
+                                if (nestedPathToQuery) {
+                                    let relatedCollection;
+                                    if (matchedField.type === 'join') {
+                                        if (Array.isArray(matchedField.collection)) {
+                                            throw new APIError('Not supported');
+                                        }
+                                        relatedCollection = payload.collections[matchedField.collection].config;
+                                    } else {
+                                        relatedCollection = payload.collections[matchedField.relationTo].config;
+                                    }
+                                    const remainingPaths = getLocalizedPaths({
+                                        collectionSlug: relatedCollection.slug,
+                                        fields: relatedCollection.flattenedFields,
+                                        globalSlug,
+                                        incomingPath: nestedPathToQuery,
+                                        locale,
+                                        parentIsLocalized: false,
+                                        payload
+                                    });
+                                    paths = [
+                                        ...paths,
+                                        ...remainingPaths
+                                    ];
+                                }
+                                return paths;
+                            }
+                            break;
+                        }
+                    case 'json':
+                    case 'richText':
+                        {
+                            const upcomingSegments = pathSegments.slice(i + 1).join('.');
+                            pathSegments.forEach((path)=>{
+                                if (!SAFE_FIELD_PATH_REGEX.test(path)) {
+                                    lastIncompletePath.invalid = true;
+                                }
+                            });
+                            lastIncompletePath.complete = true;
+                            lastIncompletePath.path = upcomingSegments ? `${currentPath}.${upcomingSegments}` : currentPath;
+                            return paths;
+                        }
+                    default:
+                        {
+                            if (i + 1 === pathSegments.length) {
+                                lastIncompletePath.complete = true;
+                            }
+                            lastIncompletePath.path = currentPath;
+                        }
+                }
+            } else {
+                lastIncompletePath.invalid = true;
+                lastIncompletePath.path = currentPath;
+                return paths;
+            }
+        }
+    }
+    return paths;
+}
+
+//# sourceMappingURL=getLocalizedPaths.js.map

package/dist/database/getLocalizedPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/database/getLocalizedPaths.ts"],"sourcesContent":["import type { PathToQuery } from './queryValidation/types.js'\n\nimport {\n  type Field,\n  fieldShouldBeLocalized,\n  type FlattenedBlock,\n  type FlattenedField,\n} from '../fields/config/types.js'\nimport { APIError, type Payload, type SanitizedCollectionConfig } from '../index.js'\nimport { SAFE_FIELD_PATH_REGEX } from '../types/constants.js'\n\nexport function getLocalizedPaths({\n  collectionSlug,\n  fields,\n  globalSlug,\n  incomingPath,\n  locale,\n  overrideAccess = false,\n  parentIsLocalized,\n  payload,\n}: {\n  collectionSlug?: string\n  fields: FlattenedField[]\n  globalSlug?: string\n  incomingPath: string\n  locale?: string\n  overrideAccess?: boolean\n  /**\n   * @todo make required in v4.0. Usually, you'd wanna pass this through\n   */\n  parentIsLocalized?: boolean\n  payload: Payload\n}): PathToQuery[] {\n  const pathSegments = incomingPath.split('.')\n  const localizationConfig = payload.config.localization\n\n  let paths: PathToQuery[] = [\n    {\n      collectionSlug,\n      complete: false,\n      // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n      field: undefined,\n      fields,\n      globalSlug,\n      invalid: false,\n      parentIsLocalized: parentIsLocalized!,\n      path: '',\n    },\n  ]\n\n  for (let i = 0; i < pathSegments.length; i += 1) {\n    const segment = pathSegments[i]\n\n    const lastIncompletePath = paths.find(({ complete }) => !complete)\n\n    if (lastIncompletePath) {\n      const { path } = lastIncompletePath\n      let currentPath = path ? `${path}.${segment}` : segment\n\n      let fieldsToSearch: FlattenedField[]\n      let _parentIsLocalized = parentIsLocalized\n\n      let matchedField!: FlattenedField\n\n      if (lastIncompletePath?.field?.type === 'blocks') {\n        if (segment === 'blockType') {\n          matchedField = {\n            name: 'blockType',\n            type: 'text',\n          }\n        } else {\n          for (const _block of lastIncompletePath.field.blockReferences ??\n            lastIncompletePath.field.blocks) {\n            let block: FlattenedBlock\n            if (typeof _block === 'string') {\n              block = payload.blocks[_block]!\n            } else {\n              block = _block\n            }\n\n            matchedField = block.flattenedFields.find((field) => field.name === segment)!\n            if (matchedField) {\n              break\n            }\n          }\n        }\n      } else {\n        if (lastIncompletePath?.field && 'flattenedFields' in lastIncompletePath.field) {\n          fieldsToSearch = lastIncompletePath.field.flattenedFields\n        } else {\n          fieldsToSearch = lastIncompletePath.fields!\n        }\n        _parentIsLocalized = parentIsLocalized || lastIncompletePath.field?.localized\n\n        matchedField = fieldsToSearch.find((field) => field.name === segment)!\n      }\n\n      lastIncompletePath.field = matchedField!\n\n      if (currentPath === 'globalType' && globalSlug) {\n        lastIncompletePath.path = currentPath\n        lastIncompletePath.complete = true\n        lastIncompletePath.field = {\n          name: 'globalType',\n          type: 'text',\n        }\n\n        return paths\n      }\n\n      if (currentPath === 'relationTo') {\n        lastIncompletePath.path = currentPath\n        lastIncompletePath.complete = true\n        lastIncompletePath.field = {\n          name: 'relationTo',\n          type: 'select',\n          options: Object.keys(payload.collections),\n        }\n\n        return paths\n      }\n\n      if (!matchedField && currentPath === 'id' && i === pathSegments.length - 1) {\n        lastIncompletePath.path = currentPath\n        const idField: Field = {\n          name: 'id',\n          type: payload.db.defaultIDType as 'text',\n        }\n        lastIncompletePath.field = idField\n        lastIncompletePath.complete = true\n        return paths\n      }\n\n      if (matchedField) {\n        if ('hidden' in matchedField && matchedField.hidden && !overrideAccess) {\n          lastIncompletePath.invalid = true\n        }\n\n        const nextSegment = pathSegments[i + 1]!\n        const currentFieldIsLocalized = fieldShouldBeLocalized({\n          field: matchedField,\n          parentIsLocalized: _parentIsLocalized!,\n        })\n\n        const nextSegmentIsLocale =\n          localizationConfig &&\n          localizationConfig.localeCodes.includes(nextSegment) &&\n          currentFieldIsLocalized\n\n        if (nextSegmentIsLocale) {\n          // Skip the next iteration, because it's a locale\n          i += 1\n          currentPath = `${currentPath}.${nextSegment}`\n        } else if (localizationConfig && currentFieldIsLocalized) {\n          currentPath = `${currentPath}.${locale}`\n        }\n\n        switch (matchedField.type) {\n          case 'join':\n          case 'relationship':\n          case 'upload': {\n            // If this is a polymorphic relation,\n            // We only support querying directly (no nested querying)\n            if (matchedField.type !== 'join' && typeof matchedField.relationTo !== 'string') {\n              lastIncompletePath.path = pathSegments.join('.')\n              if (![matchedField.name, 'relationTo', 'value'].includes(pathSegments.at(-1)!)) {\n                lastIncompletePath.invalid = true\n              } else {\n                lastIncompletePath.complete = true\n              }\n            } else {\n              lastIncompletePath.complete = true\n              lastIncompletePath.path = currentPath!\n\n              const nestedPathToQuery = pathSegments\n                .slice(nextSegmentIsLocale ? i + 2 : i + 1)\n                .join('.')\n\n              if (nestedPathToQuery) {\n                let relatedCollection: SanitizedCollectionConfig\n                if (matchedField.type === 'join') {\n                  if (Array.isArray(matchedField.collection)) {\n                    throw new APIError('Not supported')\n                  }\n\n                  relatedCollection = payload.collections[matchedField.collection]!.config\n                } else {\n                  relatedCollection = payload.collections[matchedField.relationTo as string]!.config\n                }\n\n                const remainingPaths = getLocalizedPaths({\n                  collectionSlug: relatedCollection.slug,\n                  fields: relatedCollection.flattenedFields,\n                  globalSlug,\n                  incomingPath: nestedPathToQuery,\n                  locale,\n                  parentIsLocalized: false,\n                  payload,\n                })\n\n                paths = [...paths, ...remainingPaths]\n              }\n\n              return paths\n            }\n\n            break\n          }\n          case 'json':\n          case 'richText': {\n            const upcomingSegments = pathSegments.slice(i + 1).join('.')\n            pathSegments.forEach((path) => {\n              if (!SAFE_FIELD_PATH_REGEX.test(path)) {\n                lastIncompletePath.invalid = true\n              }\n            })\n            lastIncompletePath.complete = true\n            lastIncompletePath.path = upcomingSegments\n              ? `${currentPath}.${upcomingSegments}`\n              : currentPath!\n            return paths\n          }\n\n          default: {\n            if (i + 1 === pathSegments.length) {\n              lastIncompletePath.complete = true\n            }\n            lastIncompletePath.path = currentPath!\n          }\n        }\n      } else {\n        lastIncompletePath.invalid = true\n        lastIncompletePath.path = currentPath!\n        return paths\n      }\n    }\n  }\n\n  return paths\n}\n"],"names":["fieldShouldBeLocalized","APIError","SAFE_FIELD_PATH_REGEX","getLocalizedPaths","collectionSlug","fields","globalSlug","incomingPath","locale","overrideAccess","parentIsLocalized","payload","pathSegments","split","localizationConfig","config","localization","paths","complete","field","undefined","invalid","path","i","length","segment","lastIncompletePath","find","currentPath","fieldsToSearch","_parentIsLocalized","matchedField","type","name","_block","blockReferences","blocks","block","flattenedFields","localized","options","Object","keys","collections","idField","db","defaultIDType","hidden","nextSegment","currentFieldIsLocalized","nextSegmentIsLocale","localeCodes","includes","relationTo","join","at","nestedPathToQuery","slice","relatedCollection","Array","isArray","collection","remainingPaths","slug","upcomingSegments","forEach","test"],"mappings":"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"}

package/dist/database/migrations/createMigration.d.ts

@@ -0,0 +1,3 @@
+import type { CreateMigration } from '../types.js';
+export declare const createMigration: CreateMigration;
+//# sourceMappingURL=createMigration.d.ts.map

package/dist/database/migrations/createMigration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMigration.d.ts","sourceRoot":"","sources":["../../../src/database/migrations/createMigration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAKlD,eAAO,MAAM,eAAe,EAAE,eAuB7B,CAAA"}

package/dist/database/migrations/createMigration.js

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import { writeMigrationIndex } from '../../index.js';
+import { migrationTemplate } from './migrationTemplate.js';
+export const createMigration = function createMigration({ migrationName, payload }) {
+    const dir = payload.db.migrationDir;
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir);
+    }
+    const [yyymmdd, hhmmss] = new Date().toISOString().split('T');
+    const formattedDate = yyymmdd.replace(/\D/g, '');
+    const formattedTime = hhmmss.split('.')[0].replace(/\D/g, '');
+    const timestamp = `${formattedDate}_${formattedTime}`;
+    const formattedName = migrationName.replace(/\W/g, '_');
+    const fileName = `${timestamp}_${formattedName}.ts`;
+    const filePath = `${dir}/${fileName}`;
+    fs.writeFileSync(filePath, migrationTemplate);
+    writeMigrationIndex({
+        migrationsDir: payload.db.migrationDir
+    });
+    payload.logger.info({
+        msg: `Migration created at ${filePath}`
+    });
+};
+
+//# sourceMappingURL=createMigration.js.map

package/dist/database/migrations/createMigration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/database/migrations/createMigration.ts"],"sourcesContent":["import fs from 'fs'\n\nimport type { CreateMigration } from '../types.js'\n\nimport { writeMigrationIndex } from '../../index.js'\nimport { migrationTemplate } from './migrationTemplate.js'\n\nexport const createMigration: CreateMigration = function createMigration({\n  migrationName,\n  payload,\n}) {\n  const dir = payload.db.migrationDir\n  if (!fs.existsSync(dir)) {\n    fs.mkdirSync(dir)\n  }\n\n  const [yyymmdd, hhmmss] = new Date().toISOString().split('T')\n  const formattedDate = yyymmdd!.replace(/\\D/g, '')\n  const formattedTime = hhmmss!.split('.')[0]!.replace(/\\D/g, '')\n\n  const timestamp = `${formattedDate}_${formattedTime}`\n\n  const formattedName = migrationName!.replace(/\\W/g, '_')\n  const fileName = `${timestamp}_${formattedName}.ts`\n  const filePath = `${dir}/${fileName}`\n  fs.writeFileSync(filePath, migrationTemplate)\n\n  writeMigrationIndex({ migrationsDir: payload.db.migrationDir })\n\n  payload.logger.info({ msg: `Migration created at ${filePath}` })\n}\n"],"names":["fs","writeMigrationIndex","migrationTemplate","createMigration","migrationName","payload","dir","db","migrationDir","existsSync","mkdirSync","yyymmdd","hhmmss","Date","toISOString","split","formattedDate","replace","formattedTime","timestamp","formattedName","fileName","filePath","writeFileSync","migrationsDir","logger","info","msg"],"mappings":"AAAA,OAAOA,QAAQ,KAAI;AAInB,SAASC,mBAAmB,QAAQ,iBAAgB;AACpD,SAASC,iBAAiB,QAAQ,yBAAwB;AAE1D,OAAO,MAAMC,kBAAmC,SAASA,gBAAgB,EACvEC,aAAa,EACbC,OAAO,EACR;IACC,MAAMC,MAAMD,QAAQE,EAAE,CAACC,YAAY;IACnC,IAAI,CAACR,GAAGS,UAAU,CAACH,MAAM;QACvBN,GAAGU,SAAS,CAACJ;IACf;IAEA,MAAM,CAACK,SAASC,OAAO,GAAG,IAAIC,OAAOC,WAAW,GAAGC,KAAK,CAAC;IACzD,MAAMC,gBAAgBL,QAASM,OAAO,CAAC,OAAO;IAC9C,MAAMC,gBAAgBN,OAAQG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAEE,OAAO,CAAC,OAAO;IAE5D,MAAME,YAAY,GAAGH,cAAc,CAAC,EAAEE,eAAe;IAErD,MAAME,gBAAgBhB,cAAea,OAAO,CAAC,OAAO;IACpD,MAAMI,WAAW,GAAGF,UAAU,CAAC,EAAEC,cAAc,GAAG,CAAC;IACnD,MAAME,WAAW,GAAGhB,IAAI,CAAC,EAAEe,UAAU;IACrCrB,GAAGuB,aAAa,CAACD,UAAUpB;IAE3BD,oBAAoB;QAAEuB,eAAenB,QAAQE,EAAE,CAACC,YAAY;IAAC;IAE7DH,QAAQoB,MAAM,CAACC,IAAI,CAAC;QAAEC,KAAK,CAAC,qBAAqB,EAAEL,UAAU;IAAC;AAChE,EAAC"}

package/dist/database/migrations/findMigrationDir.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Attempt to find migrations directory.
+ *
+ * Checks for the following directories in order:
+ * - `migrationDir` argument from Payload config
+ * - `src/migrations`
+ * - `dist/migrations`
+ * - `migrations`
+ *
+ * @param migrationDir
+ * @default src/migrations`, if the src folder does not exists - migrations.
+ * @returns
+ */
+export declare const findMigrationDir: (migrationDir?: string) => string;
+//# sourceMappingURL=findMigrationDir.d.ts.map

package/dist/database/migrations/findMigrationDir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findMigrationDir.d.ts","sourceRoot":"","sources":["../../../src/database/migrations/findMigrationDir.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,kBAAmB,MAAM,KAAG,MA8BxD,CAAA"}

package/dist/database/migrations/findMigrationDir.js

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Attempt to find migrations directory.
+ *
+ * Checks for the following directories in order:
+ * - `migrationDir` argument from Payload config
+ * - `src/migrations`
+ * - `dist/migrations`
+ * - `migrations`
+ *
+ * @param migrationDir
+ * @default src/migrations`, if the src folder does not exists - migrations.
+ * @returns
+ */ export const findMigrationDir = (migrationDir)=>{
+    const cwd = process.cwd();
+    const srcMigrationsDir = path.resolve(cwd, 'src/migrations');
+    const distMigrationsDir = 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(srcMigrationsDir)) {
+        return srcMigrationsDir;
+    }
+    if (fs.existsSync(distMigrationsDir)) {
+        return distMigrationsDir;
+    }
+    if (fs.existsSync(relativeMigrations)) {
+        return relativeMigrations;
+    }
+    if (fs.existsSync(path.resolve(cwd, 'src'))) {
+        return srcMigrationsDir;
+    }
+    return relativeMigrations;
+};
+
+//# sourceMappingURL=findMigrationDir.js.map

package/dist/database/migrations/findMigrationDir.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/database/migrations/findMigrationDir.ts"],"sourcesContent":["import fs from 'fs'\nimport path from 'path'\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 * @param migrationDir\n * @default src/migrations`, if the src folder does not exists - migrations.\n * @returns\n */\nexport const findMigrationDir = (migrationDir?: string): string => {\n  const cwd = process.cwd()\n\n  const srcMigrationsDir = path.resolve(cwd, 'src/migrations')\n  const distMigrationsDir = path.resolve(cwd, 'dist/migrations')\n  const relativeMigrations = path.resolve(cwd, 'migrations')\n\n  // Use arg if provided\n  if (migrationDir) {\n    return migrationDir\n  }\n\n  // Check other common locations\n  if (fs.existsSync(srcMigrationsDir)) {\n    return srcMigrationsDir\n  }\n\n  if (fs.existsSync(distMigrationsDir)) {\n    return distMigrationsDir\n  }\n\n  if (fs.existsSync(relativeMigrations)) {\n    return relativeMigrations\n  }\n\n  if (fs.existsSync(path.resolve(cwd, 'src'))) {\n    return srcMigrationsDir\n  }\n\n  return relativeMigrations\n}\n"],"names":["fs","path","findMigrationDir","migrationDir","cwd","process","srcMigrationsDir","resolve","distMigrationsDir","relativeMigrations","existsSync"],"mappings":"AAAA,OAAOA,QAAQ,KAAI;AACnB,OAAOC,UAAU,OAAM;AAEvB;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,mBAAmB,CAACC;IAC/B,MAAMC,MAAMC,QAAQD,GAAG;IAEvB,MAAME,mBAAmBL,KAAKM,OAAO,CAACH,KAAK;IAC3C,MAAMI,oBAAoBP,KAAKM,OAAO,CAACH,KAAK;IAC5C,MAAMK,qBAAqBR,KAAKM,OAAO,CAACH,KAAK;IAE7C,sBAAsB;IACtB,IAAID,cAAc;QAChB,OAAOA;IACT;IAEA,+BAA+B;IAC/B,IAAIH,GAAGU,UAAU,CAACJ,mBAAmB;QACnC,OAAOA;IACT;IAEA,IAAIN,GAAGU,UAAU,CAACF,oBAAoB;QACpC,OAAOA;IACT;IAEA,IAAIR,GAAGU,UAAU,CAACD,qBAAqB;QACrC,OAAOA;IACT;IAEA,IAAIT,GAAGU,UAAU,CAACT,KAAKM,OAAO,CAACH,KAAK,SAAS;QAC3C,OAAOE;IACT;IAEA,OAAOG;AACT,EAAC"}

package/dist/database/migrations/findMigrationDir.spec.js

@@ -0,0 +1,47 @@
+import { afterEach, beforeEach, describe, expect, it, vitest } from 'vitest';
+import { findMigrationDir } from './findMigrationDir';
+import fs from 'fs';
+import path from 'path';
+const workDir = path.resolve(import.meta.dirname, '_tmp');
+describe('findMigrationDir', ()=>{
+    beforeEach(()=>{
+        const cwdSpy = vitest.spyOn(process, 'cwd');
+        cwdSpy.mockReturnValue(workDir);
+        fs.mkdirSync(workDir, {
+            recursive: true
+        });
+    });
+    afterEach(()=>{
+        fs.rmSync(workDir, {
+            force: true,
+            recursive: true
+        });
+    });
+    it('should return the passed directory', ()=>{
+        const dir = path.resolve(workDir, 'custom_migrations');
+        expect(findMigrationDir(dir)).toBe(dir);
+    });
+    it('should return src/migrations because that folder exists', ()=>{
+        fs.mkdirSync(path.resolve(workDir, 'src/migrations'), {
+            recursive: true
+        });
+        expect(findMigrationDir()).toBe(path.resolve(workDir, 'src/migrations'));
+    });
+    it('should return dist/migrations because that folder exists', ()=>{
+        fs.mkdirSync(path.resolve(workDir, 'dist/migrations'), {
+            recursive: true
+        });
+        expect(findMigrationDir()).toBe(path.resolve(workDir, 'dist/migrations'));
+    });
+    it('should return src/migrations because src exists', ()=>{
+        fs.mkdirSync(path.resolve(workDir, 'src'), {
+            recursive: true
+        });
+        expect(findMigrationDir()).toBe(path.resolve(workDir, 'src/migrations'));
+    });
+    it('should return migrations because src does not exist', ()=>{
+        expect(findMigrationDir()).toBe(path.resolve(workDir, 'migrations'));
+    });
+});
+
+//# sourceMappingURL=findMigrationDir.spec.js.map

package/dist/database/migrations/findMigrationDir.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/database/migrations/findMigrationDir.spec.ts"],"sourcesContent":["import { afterEach, beforeEach, describe, expect, it, vitest } from 'vitest'\nimport { findMigrationDir } from './findMigrationDir'\nimport fs from 'fs'\nimport path from 'path'\n\nconst workDir = path.resolve(import.meta.dirname, '_tmp')\n\ndescribe('findMigrationDir', () => {\n  beforeEach(() => {\n    const cwdSpy = vitest.spyOn(process, 'cwd')\n    cwdSpy.mockReturnValue(workDir)\n    fs.mkdirSync(workDir, { recursive: true })\n  })\n\n  afterEach(() => {\n    fs.rmSync(workDir, { force: true, recursive: true })\n  })\n\n  it('should return the passed directory', () => {\n    const dir = path.resolve(workDir, 'custom_migrations')\n    expect(findMigrationDir(dir)).toBe(dir)\n  })\n\n  it('should return src/migrations because that folder exists', () => {\n    fs.mkdirSync(path.resolve(workDir, 'src/migrations'), { recursive: true })\n    expect(findMigrationDir()).toBe(path.resolve(workDir, 'src/migrations'))\n  })\n\n  it('should return dist/migrations because that folder exists', () => {\n    fs.mkdirSync(path.resolve(workDir, 'dist/migrations'), { recursive: true })\n    expect(findMigrationDir()).toBe(path.resolve(workDir, 'dist/migrations'))\n  })\n\n  it('should return src/migrations because src exists', () => {\n    fs.mkdirSync(path.resolve(workDir, 'src'), { recursive: true })\n    expect(findMigrationDir()).toBe(path.resolve(workDir, 'src/migrations'))\n  })\n\n  it('should return migrations because src does not exist', () => {\n    expect(findMigrationDir()).toBe(path.resolve(workDir, 'migrations'))\n  })\n})\n"],"names":["afterEach","beforeEach","describe","expect","it","vitest","findMigrationDir","fs","path","workDir","resolve","dirname","cwdSpy","spyOn","process","mockReturnValue","mkdirSync","recursive","rmSync","force","dir","toBe"],"mappings":"AAAA,SAASA,SAAS,EAAEC,UAAU,EAAEC,QAAQ,EAAEC,MAAM,EAAEC,EAAE,EAAEC,MAAM,QAAQ,SAAQ;AAC5E,SAASC,gBAAgB,QAAQ,qBAAoB;AACrD,OAAOC,QAAQ,KAAI;AACnB,OAAOC,UAAU,OAAM;AAEvB,MAAMC,UAAUD,KAAKE,OAAO,CAAC,YAAYC,OAAO,EAAE;AAElDT,SAAS,oBAAoB;IAC3BD,WAAW;QACT,MAAMW,SAASP,OAAOQ,KAAK,CAACC,SAAS;QACrCF,OAAOG,eAAe,CAACN;QACvBF,GAAGS,SAAS,CAACP,SAAS;YAAEQ,WAAW;QAAK;IAC1C;IAEAjB,UAAU;QACRO,GAAGW,MAAM,CAACT,SAAS;YAAEU,OAAO;YAAMF,WAAW;QAAK;IACpD;IAEAb,GAAG,sCAAsC;QACvC,MAAMgB,MAAMZ,KAAKE,OAAO,CAACD,SAAS;QAClCN,OAAOG,iBAAiBc,MAAMC,IAAI,CAACD;IACrC;IAEAhB,GAAG,2DAA2D;QAC5DG,GAAGS,SAAS,CAACR,KAAKE,OAAO,CAACD,SAAS,mBAAmB;YAAEQ,WAAW;QAAK;QACxEd,OAAOG,oBAAoBe,IAAI,CAACb,KAAKE,OAAO,CAACD,SAAS;IACxD;IAEAL,GAAG,4DAA4D;QAC7DG,GAAGS,SAAS,CAACR,KAAKE,OAAO,CAACD,SAAS,oBAAoB;YAAEQ,WAAW;QAAK;QACzEd,OAAOG,oBAAoBe,IAAI,CAACb,KAAKE,OAAO,CAACD,SAAS;IACxD;IAEAL,GAAG,mDAAmD;QACpDG,GAAGS,SAAS,CAACR,KAAKE,OAAO,CAACD,SAAS,QAAQ;YAAEQ,WAAW;QAAK;QAC7Dd,OAAOG,oBAAoBe,IAAI,CAACb,KAAKE,OAAO,CAACD,SAAS;IACxD;IAEAL,GAAG,uDAAuD;QACxDD,OAAOG,oBAAoBe,IAAI,CAACb,KAAKE,OAAO,CAACD,SAAS;IACxD;AACF"}

package/dist/database/migrations/getMigrations.d.ts

@@ -0,0 +1,12 @@
+import type { Payload } from '../../index.js';
+import type { MigrationData } from '../types.js';
+/**
+ * Gets all existing migrations from the database, excluding the dev migration
+ */
+export declare function getMigrations({ payload, }: {
+    payload: Payload;
+}): Promise<{
+    existingMigrations: MigrationData[];
+    latestBatch: number;
+}>;
+//# sourceMappingURL=getMigrations.d.ts.map

package/dist/database/migrations/getMigrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMigrations.d.ts","sourceRoot":"","sources":["../../../src/database/migrations/getMigrations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;GAEG;AACH,wBAAsB,aAAa,CAAC,EAClC,OAAO,GACR,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;CACjB,GAAG,OAAO,CAAC;IAAE,kBAAkB,EAAE,aAAa,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAqBxE"}

package/dist/database/migrations/getMigrations.js

@@ -0,0 +1,26 @@
+/**
+ * Gets all existing migrations from the database, excluding the dev migration
+ */ export async function getMigrations({ payload }) {
+    const migrationQuery = await payload.find({
+        collection: 'payload-migrations',
+        limit: 0,
+        sort: [
+            '-batch',
+            '-name'
+        ],
+        where: {
+            batch: {
+                not_equals: -1
+            }
+        }
+    });
+    const existingMigrations = migrationQuery.docs;
+    // Get the highest batch number from existing migrations
+    const latestBatch = Number(existingMigrations?.[0]?.batch) || 0;
+    return {
+        existingMigrations,
+        latestBatch
+    };
+}
+
+//# sourceMappingURL=getMigrations.js.map

package/dist/database/migrations/getMigrations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/database/migrations/getMigrations.ts"],"sourcesContent":["import type { Payload } from '../../index.js'\nimport type { MigrationData } from '../types.js'\n\n/**\n * Gets all existing migrations from the database, excluding the dev migration\n */\nexport async function getMigrations({\n  payload,\n}: {\n  payload: Payload\n}): Promise<{ existingMigrations: MigrationData[]; latestBatch: number }> {\n  const migrationQuery = await payload.find({\n    collection: 'payload-migrations',\n    limit: 0,\n    sort: ['-batch', '-name'],\n    where: {\n      batch: {\n        not_equals: -1,\n      },\n    },\n  })\n\n  const existingMigrations = migrationQuery.docs as unknown as MigrationData[]\n\n  // Get the highest batch number from existing migrations\n  const latestBatch = Number(existingMigrations?.[0]?.batch) || 0\n\n  return {\n    existingMigrations,\n    latestBatch,\n  }\n}\n"],"names":["getMigrations","payload","migrationQuery","find","collection","limit","sort","where","batch","not_equals","existingMigrations","docs","latestBatch","Number"],"mappings":"AAGA;;CAEC,GACD,OAAO,eAAeA,cAAc,EAClCC,OAAO,EAGR;IACC,MAAMC,iBAAiB,MAAMD,QAAQE,IAAI,CAAC;QACxCC,YAAY;QACZC,OAAO;QACPC,MAAM;YAAC;YAAU;SAAQ;QACzBC,OAAO;YACLC,OAAO;gBACLC,YAAY,CAAC;YACf;QACF;IACF;IAEA,MAAMC,qBAAqBR,eAAeS,IAAI;IAE9C,wDAAwD;IACxD,MAAMC,cAAcC,OAAOH,oBAAoB,CAAC,EAAE,EAAEF,UAAU;IAE9D,OAAO;QACLE;QACAE;IACF;AACF"}

package/dist/database/migrations/getPredefinedMigration.d.ts

@@ -0,0 +1,18 @@
+import type { Payload } from '../../index.js';
+import type { MigrationTemplateArgs } from '../types.js';
+/**
+ * Get predefined migration 'up', 'down' and 'imports'.
+ *
+ * Supports two import methods:
+ * 1. @payloadcms/db-* packages: Loads from adapter's predefinedMigrations folder directly (no package.json export needed)
+ *    Example: `--file @payloadcms/db-mongodb/relationships-v2-v3`
+ * 2. Any other package/path: Uses dynamic import via package.json exports or absolute file paths
+ *    Example: `--file @payloadcms/plugin-seo/someMigration` or `--file /absolute/path/to/migration.ts`
+ */
+export declare const getPredefinedMigration: ({ dirname, file, migrationName: migrationNameArg, payload, }: {
+    dirname: string;
+    file?: string;
+    migrationName?: string;
+    payload: Payload;
+}) => Promise<MigrationTemplateArgs>;
+//# sourceMappingURL=getPredefinedMigration.d.ts.map

package/dist/database/migrations/getPredefinedMigration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPredefinedMigration.d.ts","sourceRoot":"","sources":["../../../src/database/migrations/getPredefinedMigration.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAIxD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,iEAKhC;IACD,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,OAAO,EAAE,OAAO,CAAA;CACjB,KAAG,OAAO,CAAC,qBAAqB,CA4DhC,CAAA"}

package/dist/database/migrations/getPredefinedMigration.js

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+import { dynamicImport } from '../../utilities/dynamicImport.js';
+/**
+ * Get predefined migration 'up', 'down' and 'imports'.
+ *
+ * Supports two import methods:
+ * 1. @payloadcms/db-* packages: Loads from adapter's predefinedMigrations folder directly (no package.json export needed)
+ *    Example: `--file @payloadcms/db-mongodb/relationships-v2-v3`
+ * 2. Any other package/path: Uses dynamic import via package.json exports or absolute file paths
+ *    Example: `--file @payloadcms/plugin-seo/someMigration` or `--file /absolute/path/to/migration.ts`
+ */ export const getPredefinedMigration = async ({ dirname, file, migrationName: migrationNameArg, payload })=>{
+    const importPath = file ?? migrationNameArg;
+    // Path 1: @payloadcms/db-* adapters - load directly from predefinedMigrations folder
+    // These don't need package.json exports; files are resolved relative to adapter's dirname
+    if (importPath?.startsWith('@payloadcms/db-')) {
+        const migrationName = importPath.split('/').slice(2).join('/');
+        let cleanPath = path.join(dirname, `./predefinedMigrations/${migrationName}`);
+        if (fs.existsSync(`${cleanPath}.mjs`)) {
+            cleanPath = `${cleanPath}.mjs`;
+        } else if (fs.existsSync(`${cleanPath}.js`)) {
+            cleanPath = `${cleanPath}.js`;
+        } else if (fs.existsSync(`${cleanPath}.ts`)) {
+            // Support .ts in development when running from source
+            cleanPath = `${cleanPath}.ts`;
+        } else {
+            payload.logger.error({
+                msg: `Canned migration ${migrationName} not found.`
+            });
+            process.exit(1);
+        }
+        cleanPath = cleanPath.replaceAll('\\', '/');
+        try {
+            const { downSQL, dynamic, imports, upSQL } = await dynamicImport(cleanPath);
+            return {
+                downSQL,
+                dynamic,
+                imports,
+                upSQL
+            };
+        } catch (err) {
+            payload.logger.error({
+                err,
+                msg: `Error loading predefined migration ${migrationName}`
+            });
+            process.exit(1);
+        }
+    } else if (importPath) {
+        // Path 2: Any other package or file path - use dynamic import
+        // Supports: package.json exports (e.g. @payloadcms/plugin-seo/migration) or absolute file paths
+        try {
+            const { downSQL, dynamic, imports, upSQL } = await dynamicImport(importPath);
+            return {
+                downSQL,
+                dynamic,
+                imports,
+                upSQL
+            };
+        } catch (_err) {
+            if (importPath?.includes('/')) {
+                // We can assume that the intent was to import a file, thus we throw an error.
+                throw new Error(`Error importing migration file from ${importPath}`);
+            }
+            // Silently fail. If the migration cannot be imported, it will be created as a blank migration and the import path will be used as the migration name.
+            return {};
+        }
+    }
+    return {};
+};
+
+//# sourceMappingURL=getPredefinedMigration.js.map

package/dist/database/migrations/getPredefinedMigration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/database/migrations/getPredefinedMigration.ts"],"sourcesContent":["import fs from 'fs'\nimport path from 'path'\n\nimport type { Payload } from '../../index.js'\nimport type { MigrationTemplateArgs } from '../types.js'\n\nimport { dynamicImport } from '../../utilities/dynamicImport.js'\n\n/**\n * Get predefined migration 'up', 'down' and 'imports'.\n *\n * Supports two import methods:\n * 1. @payloadcms/db-* packages: Loads from adapter's predefinedMigrations folder directly (no package.json export needed)\n *    Example: `--file @payloadcms/db-mongodb/relationships-v2-v3`\n * 2. Any other package/path: Uses dynamic import via package.json exports or absolute file paths\n *    Example: `--file @payloadcms/plugin-seo/someMigration` or `--file /absolute/path/to/migration.ts`\n */\nexport const getPredefinedMigration = async ({\n  dirname,\n  file,\n  migrationName: migrationNameArg,\n  payload,\n}: {\n  dirname: string\n  file?: string\n  migrationName?: string\n  payload: Payload\n}): Promise<MigrationTemplateArgs> => {\n  const importPath = file ?? migrationNameArg\n\n  // Path 1: @payloadcms/db-* adapters - load directly from predefinedMigrations folder\n  // These don't need package.json exports; files are resolved relative to adapter's dirname\n  if (importPath?.startsWith('@payloadcms/db-')) {\n    const migrationName = importPath.split('/').slice(2).join('/')\n    let cleanPath = path.join(dirname, `./predefinedMigrations/${migrationName}`)\n    if (fs.existsSync(`${cleanPath}.mjs`)) {\n      cleanPath = `${cleanPath}.mjs`\n    } else if (fs.existsSync(`${cleanPath}.js`)) {\n      cleanPath = `${cleanPath}.js`\n    } else if (fs.existsSync(`${cleanPath}.ts`)) {\n      // Support .ts in development when running from source\n      cleanPath = `${cleanPath}.ts`\n    } else {\n      payload.logger.error({\n        msg: `Canned migration ${migrationName} not found.`,\n      })\n      process.exit(1)\n    }\n    cleanPath = cleanPath.replaceAll('\\\\', '/')\n    try {\n      const { downSQL, dynamic, imports, upSQL } =\n        await dynamicImport<MigrationTemplateArgs>(cleanPath)\n      return {\n        downSQL,\n        dynamic,\n        imports,\n        upSQL,\n      }\n    } catch (err) {\n      payload.logger.error({\n        err,\n        msg: `Error loading predefined migration ${migrationName}`,\n      })\n      process.exit(1)\n    }\n  } else if (importPath) {\n    // Path 2: Any other package or file path - use dynamic import\n    // Supports: package.json exports (e.g. @payloadcms/plugin-seo/migration) or absolute file paths\n    try {\n      const { downSQL, dynamic, imports, upSQL } =\n        await dynamicImport<MigrationTemplateArgs>(importPath)\n      return {\n        downSQL,\n        dynamic,\n        imports,\n        upSQL,\n      }\n    } catch (_err) {\n      if (importPath?.includes('/')) {\n        // We can assume that the intent was to import a file, thus we throw an error.\n        throw new Error(`Error importing migration file from ${importPath}`)\n      }\n      // Silently fail. If the migration cannot be imported, it will be created as a blank migration and the import path will be used as the migration name.\n      return {}\n    }\n  }\n  return {}\n}\n"],"names":["fs","path","dynamicImport","getPredefinedMigration","dirname","file","migrationName","migrationNameArg","payload","importPath","startsWith","split","slice","join","cleanPath","existsSync","logger","error","msg","process","exit","replaceAll","downSQL","dynamic","imports","upSQL","err","_err","includes","Error"],"mappings":"AAAA,OAAOA,QAAQ,KAAI;AACnB,OAAOC,UAAU,OAAM;AAKvB,SAASC,aAAa,QAAQ,mCAAkC;AAEhE;;;;;;;;CAQC,GACD,OAAO,MAAMC,yBAAyB,OAAO,EAC3CC,OAAO,EACPC,IAAI,EACJC,eAAeC,gBAAgB,EAC/BC,OAAO,EAMR;IACC,MAAMC,aAAaJ,QAAQE;IAE3B,qFAAqF;IACrF,0FAA0F;IAC1F,IAAIE,YAAYC,WAAW,oBAAoB;QAC7C,MAAMJ,gBAAgBG,WAAWE,KAAK,CAAC,KAAKC,KAAK,CAAC,GAAGC,IAAI,CAAC;QAC1D,IAAIC,YAAYb,KAAKY,IAAI,CAACT,SAAS,CAAC,uBAAuB,EAAEE,eAAe;QAC5E,IAAIN,GAAGe,UAAU,CAAC,GAAGD,UAAU,IAAI,CAAC,GAAG;YACrCA,YAAY,GAAGA,UAAU,IAAI,CAAC;QAChC,OAAO,IAAId,GAAGe,UAAU,CAAC,GAAGD,UAAU,GAAG,CAAC,GAAG;YAC3CA,YAAY,GAAGA,UAAU,GAAG,CAAC;QAC/B,OAAO,IAAId,GAAGe,UAAU,CAAC,GAAGD,UAAU,GAAG,CAAC,GAAG;YAC3C,sDAAsD;YACtDA,YAAY,GAAGA,UAAU,GAAG,CAAC;QAC/B,OAAO;YACLN,QAAQQ,MAAM,CAACC,KAAK,CAAC;gBACnBC,KAAK,CAAC,iBAAiB,EAAEZ,cAAc,WAAW,CAAC;YACrD;YACAa,QAAQC,IAAI,CAAC;QACf;QACAN,YAAYA,UAAUO,UAAU,CAAC,MAAM;QACvC,IAAI;YACF,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAEC,OAAO,EAAEC,KAAK,EAAE,GACxC,MAAMvB,cAAqCY;YAC7C,OAAO;gBACLQ;gBACAC;gBACAC;gBACAC;YACF;QACF,EAAE,OAAOC,KAAK;YACZlB,QAAQQ,MAAM,CAACC,KAAK,CAAC;gBACnBS;gBACAR,KAAK,CAAC,mCAAmC,EAAEZ,eAAe;YAC5D;YACAa,QAAQC,IAAI,CAAC;QACf;IACF,OAAO,IAAIX,YAAY;QACrB,8DAA8D;QAC9D,gGAAgG;QAChG,IAAI;YACF,MAAM,EAAEa,OAAO,EAAEC,OAAO,EAAEC,OAAO,EAAEC,KAAK,EAAE,GACxC,MAAMvB,cAAqCO;YAC7C,OAAO;gBACLa;gBACAC;gBACAC;gBACAC;YACF;QACF,EAAE,OAAOE,MAAM;YACb,IAAIlB,YAAYmB,SAAS,MAAM;gBAC7B,8EAA8E;gBAC9E,MAAM,IAAIC,MAAM,CAAC,oCAAoC,EAAEpB,YAAY;YACrE;YACA,sJAAsJ;YACtJ,OAAO,CAAC;QACV;IACF;IACA,OAAO,CAAC;AACV,EAAC"}

package/dist/database/migrations/migrate.d.ts

@@ -0,0 +1,3 @@
+import type { BaseDatabaseAdapter } from '../types.js';
+export declare const migrate: BaseDatabaseAdapter['migrate'];
+//# sourceMappingURL=migrate.d.ts.map

package/dist/database/migrations/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../../src/database/migrations/migrate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAStD,eAAO,MAAM,OAAO,EAAE,mBAAmB,CAAC,SAAS,CA8ClD,CAAA"}

package/dist/database/migrations/migrate.js

@@ -0,0 +1,59 @@
+import { commitTransaction } from '../../utilities/commitTransaction.js';
+import { createLocalReq } from '../../utilities/createLocalReq.js';
+import { initTransaction } from '../../utilities/initTransaction.js';
+import { killTransaction } from '../../utilities/killTransaction.js';
+import { getMigrations } from './getMigrations.js';
+import { readMigrationFiles } from './readMigrationFiles.js';
+export const migrate = async function migrate(args) {
+    const { payload } = this;
+    const migrationFiles = args?.migrations || await readMigrationFiles({
+        payload
+    });
+    const { existingMigrations, latestBatch } = await getMigrations({
+        payload
+    });
+    const newBatch = latestBatch + 1;
+    // Execute 'up' function for each migration sequentially
+    for (const migration of migrationFiles){
+        const existingMigration = existingMigrations.find((existing)=>existing.name === migration.name);
+        // Run migration if not found in database
+        if (existingMigration) {
+            continue;
+        }
+        const start = Date.now();
+        const req = await createLocalReq({}, payload);
+        payload.logger.info({
+            msg: `Migrating: ${migration.name}`
+        });
+        try {
+            await initTransaction(req);
+            const session = payload.db.sessions?.[await req.transactionID];
+            await migration.up({
+                payload,
+                req,
+                session
+            });
+            payload.logger.info({
+                msg: `Migrated:  ${migration.name} (${Date.now() - start}ms)`
+            });
+            await payload.create({
+                collection: 'payload-migrations',
+                data: {
+                    name: migration.name,
+                    batch: newBatch
+                },
+                req
+            });
+            await commitTransaction(req);
+        } catch (err) {
+            await killTransaction(req);
+            payload.logger.error({
+                err,
+                msg: `Error running migration ${migration.name}`
+            });
+            throw err;
+        }
+    }
+};
+
+//# sourceMappingURL=migrate.js.map

package/dist/database/migrations/migrate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/database/migrations/migrate.ts"],"sourcesContent":["import type { BaseDatabaseAdapter } from '../types.js'\n\nimport { commitTransaction } from '../../utilities/commitTransaction.js'\nimport { createLocalReq } from '../../utilities/createLocalReq.js'\nimport { initTransaction } from '../../utilities/initTransaction.js'\nimport { killTransaction } from '../../utilities/killTransaction.js'\nimport { getMigrations } from './getMigrations.js'\nimport { readMigrationFiles } from './readMigrationFiles.js'\n\nexport const migrate: BaseDatabaseAdapter['migrate'] = async function migrate(\n  this: BaseDatabaseAdapter,\n  args,\n): Promise<void> {\n  const { payload } = this\n  const migrationFiles = args?.migrations || (await readMigrationFiles({ payload }))\n  const { existingMigrations, latestBatch } = await getMigrations({ payload })\n\n  const newBatch = latestBatch + 1\n\n  // Execute 'up' function for each migration sequentially\n  for (const migration of migrationFiles) {\n    const existingMigration = existingMigrations.find(\n      (existing) => existing.name === migration.name,\n    )\n\n    // Run migration if not found in database\n    if (existingMigration) {\n      continue\n    }\n\n    const start = Date.now()\n    const req = await createLocalReq({}, payload)\n\n    payload.logger.info({ msg: `Migrating: ${migration.name}` })\n\n    try {\n      await initTransaction(req)\n      const session = payload.db.sessions?.[await req.transactionID!]\n      await migration.up({ payload, req, session })\n      payload.logger.info({ msg: `Migrated:  ${migration.name} (${Date.now() - start}ms)` })\n      await payload.create({\n        collection: 'payload-migrations',\n        data: {\n          name: migration.name,\n          batch: newBatch,\n        },\n        req,\n      })\n      await commitTransaction(req)\n    } catch (err: unknown) {\n      await killTransaction(req)\n      payload.logger.error({ err, msg: `Error running migration ${migration.name}` })\n      throw err\n    }\n  }\n}\n"],"names":["commitTransaction","createLocalReq","initTransaction","killTransaction","getMigrations","readMigrationFiles","migrate","args","payload","migrationFiles","migrations","existingMigrations","latestBatch","newBatch","migration","existingMigration","find","existing","name","start","Date","now","req","logger","info","msg","session","db","sessions","transactionID","up","create","collection","data","batch","err","error"],"mappings":"AAEA,SAASA,iBAAiB,QAAQ,uCAAsC;AACxE,SAASC,cAAc,QAAQ,oCAAmC;AAClE,SAASC,eAAe,QAAQ,qCAAoC;AACpE,SAASC,eAAe,QAAQ,qCAAoC;AACpE,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,kBAAkB,QAAQ,0BAAyB;AAE5D,OAAO,MAAMC,UAA0C,eAAeA,QAEpEC,IAAI;IAEJ,MAAM,EAAEC,OAAO,EAAE,GAAG,IAAI;IACxB,MAAMC,iBAAiBF,MAAMG,cAAe,MAAML,mBAAmB;QAAEG;IAAQ;IAC/E,MAAM,EAAEG,kBAAkB,EAAEC,WAAW,EAAE,GAAG,MAAMR,cAAc;QAAEI;IAAQ;IAE1E,MAAMK,WAAWD,cAAc;IAE/B,wDAAwD;IACxD,KAAK,MAAME,aAAaL,eAAgB;QACtC,MAAMM,oBAAoBJ,mBAAmBK,IAAI,CAC/C,CAACC,WAAaA,SAASC,IAAI,KAAKJ,UAAUI,IAAI;QAGhD,yCAAyC;QACzC,IAAIH,mBAAmB;YACrB;QACF;QAEA,MAAMI,QAAQC,KAAKC,GAAG;QACtB,MAAMC,MAAM,MAAMrB,eAAe,CAAC,GAAGO;QAErCA,QAAQe,MAAM,CAACC,IAAI,CAAC;YAAEC,KAAK,CAAC,WAAW,EAAEX,UAAUI,IAAI,EAAE;QAAC;QAE1D,IAAI;YACF,MAAMhB,gBAAgBoB;YACtB,MAAMI,UAAUlB,QAAQmB,EAAE,CAACC,QAAQ,EAAE,CAAC,MAAMN,IAAIO,aAAa,CAAE;YAC/D,MAAMf,UAAUgB,EAAE,CAAC;gBAAEtB;gBAASc;gBAAKI;YAAQ;YAC3ClB,QAAQe,MAAM,CAACC,IAAI,CAAC;gBAAEC,KAAK,CAAC,WAAW,EAAEX,UAAUI,IAAI,CAAC,EAAE,EAAEE,KAAKC,GAAG,KAAKF,MAAM,GAAG,CAAC;YAAC;YACpF,MAAMX,QAAQuB,MAAM,CAAC;gBACnBC,YAAY;gBACZC,MAAM;oBACJf,MAAMJ,UAAUI,IAAI;oBACpBgB,OAAOrB;gBACT;gBACAS;YACF;YACA,MAAMtB,kBAAkBsB;QAC1B,EAAE,OAAOa,KAAc;YACrB,MAAMhC,gBAAgBmB;YACtBd,QAAQe,MAAM,CAACa,KAAK,CAAC;gBAAED;gBAAKV,KAAK,CAAC,wBAAwB,EAAEX,UAAUI,IAAI,EAAE;YAAC;YAC7E,MAAMiB;QACR;IACF;AACF,EAAC"}

package/dist/database/migrations/migrateDown.d.ts

@@ -0,0 +1,3 @@
+import type { BaseDatabaseAdapter } from '../types.js';
+export declare function migrateDown(this: BaseDatabaseAdapter): Promise<void>;
+//# sourceMappingURL=migrateDown.d.ts.map

package/dist/database/migrations/migrateDown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateDown.d.ts","sourceRoot":"","sources":["../../../src/database/migrations/migrateDown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAStD,wBAAsB,WAAW,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqD1E"}