payload 1.13.0 → 1.13.2

package/dist/database/getLocalizedPaths.js

@@ -1,122 +1,122 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLocalizedPaths = void 0;
-const types_1 = require("../fields/config/types");
-const flattenTopLevelFields_1 = __importDefault(require("../utilities/flattenTopLevelFields"));
-async function getLocalizedPaths({ payload, locale, collectionSlug, globalSlug, fields, incomingPath, overrideAccess = false, }) {
-    const pathSegments = incomingPath.split('.');
-    const localizationConfig = payload.config.localization;
-    let paths = [
-        {
-            path: '',
-            complete: false,
-            field: undefined,
-            fields: (0, flattenTopLevelFields_1.default)(fields, false),
-            collectionSlug,
-            globalSlug,
-            invalid: false,
-        },
-    ];
-    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;
-            const matchedField = lastIncompletePath.fields.find((field) => (0, types_1.fieldAffectsData)(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 (matchedField) {
-                if ('hidden' in matchedField && matchedField.hidden && !overrideAccess) {
-                    lastIncompletePath.invalid = true;
-                }
-                const nextSegment = pathSegments[i + 1];
-                const nextSegmentIsLocale = localizationConfig && localizationConfig.locales.includes(nextSegment);
-                if (nextSegmentIsLocale) {
-                    // Skip the next iteration, because it's a locale
-                    i += 1;
-                    currentPath = `${currentPath}.${nextSegment}`;
-                }
-                else if (localizationConfig && 'localized' in matchedField && matchedField.localized) {
-                    currentPath = `${currentPath}.${locale}`;
-                }
-                switch (matchedField.type) {
-                    case 'blocks':
-                    case 'richText':
-                    case 'json': {
-                        const upcomingSegments = pathSegments.slice(i + 1).join('.');
-                        lastIncompletePath.complete = true;
-                        lastIncompletePath.path = upcomingSegments ? `${currentPath}.${upcomingSegments}` : currentPath;
-                        return paths;
-                    }
-                    case 'relationship':
-                    case 'upload': {
-                        // If this is a polymorphic relation,
-                        // We only support querying directly (no nested querying)
-                        if (typeof matchedField.relationTo !== 'string') {
-                            const lastSegmentIsValid = ['value', 'relationTo'].includes(pathSegments[pathSegments.length - 1]);
-                            if (lastSegmentIsValid) {
-                                lastIncompletePath.complete = true;
-                                lastIncompletePath.path = pathSegments.join('.');
-                            }
-                            else {
-                                lastIncompletePath.invalid = true;
-                                return paths;
-                            }
-                        }
-                        else {
-                            lastIncompletePath.complete = true;
-                            lastIncompletePath.path = currentPath;
-                            const nestedPathToQuery = pathSegments.slice(nextSegmentIsLocale ? i + 2 : i + 1).join('.');
-                            if (nestedPathToQuery) {
-                                const relatedCollection = payload.collections[matchedField.relationTo].config;
-                                // eslint-disable-next-line no-await-in-loop
-                                const remainingPaths = await getLocalizedPaths({
-                                    payload,
-                                    locale,
-                                    globalSlug,
-                                    collectionSlug: relatedCollection.slug,
-                                    fields: relatedCollection.fields,
-                                    incomingPath: nestedPathToQuery,
-                                });
-                                paths = [
-                                    ...paths,
-                                    ...remainingPaths,
-                                ];
-                            }
-                            return paths;
-                        }
-                        break;
-                    }
-                    default: {
-                        if ('fields' in lastIncompletePath.field) {
-                            lastIncompletePath.fields = (0, flattenTopLevelFields_1.default)(lastIncompletePath.field.fields, false);
-                        }
-                        if (i + 1 === pathSegments.length)
-                            lastIncompletePath.complete = true;
-                        lastIncompletePath.path = currentPath;
-                    }
-                }
-            }
-            else {
-                lastIncompletePath.invalid = true;
-                lastIncompletePath.path = currentPath;
-                return paths;
-            }
-        }
-    }
-    return paths;
-}
-exports.getLocalizedPaths = getLocalizedPaths;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalizedPaths = void 0;
+const types_1 = require("../fields/config/types");
+const flattenTopLevelFields_1 = __importDefault(require("../utilities/flattenTopLevelFields"));
+async function getLocalizedPaths({ payload, locale, collectionSlug, globalSlug, fields, incomingPath, overrideAccess = false, }) {
+    const pathSegments = incomingPath.split('.');
+    const localizationConfig = payload.config.localization;
+    let paths = [
+        {
+            path: '',
+            complete: false,
+            field: undefined,
+            fields: (0, flattenTopLevelFields_1.default)(fields, false),
+            collectionSlug,
+            globalSlug,
+            invalid: false,
+        },
+    ];
+    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;
+            const matchedField = lastIncompletePath.fields.find((field) => (0, types_1.fieldAffectsData)(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 (matchedField) {
+                if ('hidden' in matchedField && matchedField.hidden && !overrideAccess) {
+                    lastIncompletePath.invalid = true;
+                }
+                const nextSegment = pathSegments[i + 1];
+                const nextSegmentIsLocale = localizationConfig && localizationConfig.locales.includes(nextSegment);
+                if (nextSegmentIsLocale) {
+                    // Skip the next iteration, because it's a locale
+                    i += 1;
+                    currentPath = `${currentPath}.${nextSegment}`;
+                }
+                else if (localizationConfig && 'localized' in matchedField && matchedField.localized) {
+                    currentPath = `${currentPath}.${locale}`;
+                }
+                switch (matchedField.type) {
+                    case 'blocks':
+                    case 'richText':
+                    case 'json': {
+                        const upcomingSegments = pathSegments.slice(i + 1).join('.');
+                        lastIncompletePath.complete = true;
+                        lastIncompletePath.path = upcomingSegments ? `${currentPath}.${upcomingSegments}` : currentPath;
+                        return paths;
+                    }
+                    case 'relationship':
+                    case 'upload': {
+                        // If this is a polymorphic relation,
+                        // We only support querying directly (no nested querying)
+                        if (typeof matchedField.relationTo !== 'string') {
+                            const lastSegmentIsValid = ['value', 'relationTo'].includes(pathSegments[pathSegments.length - 1]);
+                            if (lastSegmentIsValid) {
+                                lastIncompletePath.complete = true;
+                                lastIncompletePath.path = pathSegments.join('.');
+                            }
+                            else {
+                                lastIncompletePath.invalid = true;
+                                return paths;
+                            }
+                        }
+                        else {
+                            lastIncompletePath.complete = true;
+                            lastIncompletePath.path = currentPath;
+                            const nestedPathToQuery = pathSegments.slice(nextSegmentIsLocale ? i + 2 : i + 1).join('.');
+                            if (nestedPathToQuery) {
+                                const relatedCollection = payload.collections[matchedField.relationTo].config;
+                                // eslint-disable-next-line no-await-in-loop
+                                const remainingPaths = await getLocalizedPaths({
+                                    payload,
+                                    locale,
+                                    globalSlug,
+                                    collectionSlug: relatedCollection.slug,
+                                    fields: relatedCollection.fields,
+                                    incomingPath: nestedPathToQuery,
+                                });
+                                paths = [
+                                    ...paths,
+                                    ...remainingPaths,
+                                ];
+                            }
+                            return paths;
+                        }
+                        break;
+                    }
+                    default: {
+                        if ('fields' in lastIncompletePath.field) {
+                            lastIncompletePath.fields = (0, flattenTopLevelFields_1.default)(lastIncompletePath.field.fields, false);
+                        }
+                        if (i + 1 === pathSegments.length)
+                            lastIncompletePath.complete = true;
+                        lastIncompletePath.path = currentPath;
+                    }
+                }
+            }
+            else {
+                lastIncompletePath.invalid = true;
+                lastIncompletePath.path = currentPath;
+                return paths;
+            }
+        }
+    }
+    return paths;
+}
+exports.getLocalizedPaths = getLocalizedPaths;
 //# sourceMappingURL=getLocalizedPaths.js.map

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

@@ -1,2 +1,2 @@
-import { CreateMigration } from '../types';
-export declare const createMigration: CreateMigration;
+import { CreateMigration } from '../types';
+export declare const createMigration: CreateMigration;

package/dist/database/migrations/createMigration.js

@@ -1,26 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMigration = void 0;
-/* eslint-disable no-restricted-syntax, no-await-in-loop */
-const fs_1 = __importDefault(require("fs"));
-const migrationTemplate_1 = require("./migrationTemplate");
-const createMigration = async function createMigration({ payload, migrationDir, migrationName, }) {
-    const dir = migrationDir || '.migrations'; // TODO: Verify path after linking
-    if (!fs_1.default.existsSync(dir)) {
-        fs_1.default.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_1.default.writeFileSync(filePath, migrationTemplate_1.migrationTemplate);
-    payload.logger.info({ msg: `Migration created at ${filePath}` });
-};
-exports.createMigration = createMigration;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMigration = void 0;
+/* eslint-disable no-restricted-syntax, no-await-in-loop */
+const fs_1 = __importDefault(require("fs"));
+const migrationTemplate_1 = require("./migrationTemplate");
+const createMigration = async function createMigration({ payload, migrationDir, migrationName, }) {
+    const dir = migrationDir || '.migrations'; // TODO: Verify path after linking
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.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_1.default.writeFileSync(filePath, migrationTemplate_1.migrationTemplate);
+    payload.logger.info({ msg: `Migration created at ${filePath}` });
+};
+exports.createMigration = createMigration;
 //# sourceMappingURL=createMigration.js.map

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

@@ -1,8 +1,8 @@
-import { Payload } from '../..';
-import { MigrationData } from '../types';
-export declare function getMigrations({ payload, }: {
-    payload: Payload;
-}): Promise<{
-    existingMigrations: MigrationData[];
-    latestBatch: number;
-}>;
+import { Payload } from '../..';
+import { MigrationData } from '../types';
+export declare function getMigrations({ payload, }: {
+    payload: Payload;
+}): Promise<{
+    existingMigrations: MigrationData[];
+    latestBatch: number;
+}>;

package/dist/database/migrations/getMigrations.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMigrations = void 0;
-async function getMigrations({ payload, }) {
-    var _a;
-    const migrationQuery = await payload.find({
-        collection: 'payload-migrations',
-        sort: '-name',
-    });
-    const existingMigrations = migrationQuery.docs;
-    // Get the highest batch number from existing migrations
-    const latestBatch = ((_a = existingMigrations === null || existingMigrations === void 0 ? void 0 : existingMigrations[0]) === null || _a === void 0 ? void 0 : _a.batch) || 0;
-    return {
-        existingMigrations,
-        latestBatch,
-    };
-}
-exports.getMigrations = getMigrations;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMigrations = void 0;
+async function getMigrations({ payload, }) {
+    var _a;
+    const migrationQuery = await payload.find({
+        collection: 'payload-migrations',
+        sort: '-name',
+    });
+    const existingMigrations = migrationQuery.docs;
+    // Get the highest batch number from existing migrations
+    const latestBatch = ((_a = existingMigrations === null || existingMigrations === void 0 ? void 0 : existingMigrations[0]) === null || _a === void 0 ? void 0 : _a.batch) || 0;
+    return {
+        existingMigrations,
+        latestBatch,
+    };
+}
+exports.getMigrations = getMigrations;
 //# sourceMappingURL=getMigrations.js.map

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

@@ -1,2 +1,2 @@
-import { DatabaseAdapter } from '../types';
-export declare function migrate(this: DatabaseAdapter): Promise<void>;
+import { DatabaseAdapter } from '../types';
+export declare function migrate(this: DatabaseAdapter): Promise<void>;

package/dist/database/migrations/migrate.js

@@ -1,45 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrate = void 0;
-const getMigrations_1 = require("./getMigrations");
-const readMigrationFiles_1 = require("./readMigrationFiles");
-async function migrate() {
-    const { payload } = this;
-    const migrationFiles = await (0, readMigrationFiles_1.readMigrationFiles)({ payload });
-    const { existingMigrations, latestBatch } = await (0, getMigrations_1.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; // eslint-disable-line no-continue
-        }
-        const start = Date.now();
-        let transactionID;
-        try {
-            payload.logger.info({ msg: `Migrating: ${migration.name}` });
-            transactionID = await this.beginTransaction();
-            await migration.up({ payload });
-            payload.logger.info({ msg: `Migrated:  ${migration.name} (${Date.now() - start}ms)` });
-            await payload.create({
-                collection: 'payload-migrations',
-                data: {
-                    name: migration.name,
-                    batch: newBatch,
-                },
-                req: {
-                    transactionID,
-                },
-            });
-            await this.commitTransaction(transactionID);
-        }
-        catch (err) {
-            await this.rollbackTransaction(transactionID);
-            payload.logger.error({ msg: `Error running migration ${migration.name}`, err });
-            throw err;
-        }
-    }
-}
-exports.migrate = migrate;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = void 0;
+const getMigrations_1 = require("./getMigrations");
+const readMigrationFiles_1 = require("./readMigrationFiles");
+async function migrate() {
+    const { payload } = this;
+    const migrationFiles = await (0, readMigrationFiles_1.readMigrationFiles)({ payload });
+    const { existingMigrations, latestBatch } = await (0, getMigrations_1.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; // eslint-disable-line no-continue
+        }
+        const start = Date.now();
+        let transactionID;
+        try {
+            payload.logger.info({ msg: `Migrating: ${migration.name}` });
+            transactionID = await this.beginTransaction();
+            await migration.up({ payload });
+            payload.logger.info({ msg: `Migrated:  ${migration.name} (${Date.now() - start}ms)` });
+            await payload.create({
+                collection: 'payload-migrations',
+                data: {
+                    name: migration.name,
+                    batch: newBatch,
+                },
+                req: {
+                    transactionID,
+                },
+            });
+            await this.commitTransaction(transactionID);
+        }
+        catch (err) {
+            await this.rollbackTransaction(transactionID);
+            payload.logger.error({ msg: `Error running migration ${migration.name}`, err });
+            throw err;
+        }
+    }
+}
+exports.migrate = migrate;
 //# sourceMappingURL=migrate.js.map

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

@@ -1,2 +1,2 @@
-import { DatabaseAdapter } from '../types';
-export declare function migrateDown(this: DatabaseAdapter): Promise<void>;
+import { DatabaseAdapter } from '../types';
+export declare function migrateDown(this: DatabaseAdapter): Promise<void>;

package/dist/database/migrations/migrateDown.js

@@ -1,50 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrateDown = void 0;
-const getMigrations_1 = require("./getMigrations");
-const readMigrationFiles_1 = require("./readMigrationFiles");
-async function migrateDown() {
-    const { payload } = this;
-    const migrationFiles = await (0, readMigrationFiles_1.readMigrationFiles)({ payload });
-    const { existingMigrations, latestBatch, } = await (0, getMigrations_1.getMigrations)({
-        payload,
-    });
-    const migrationsToRollback = existingMigrations.filter((migration) => migration.batch === latestBatch);
-    if (!(migrationsToRollback === null || migrationsToRollback === void 0 ? void 0 : migrationsToRollback.length)) {
-        payload.logger.info({ msg: 'No migrations to rollback.' });
-        return;
-    }
-    payload.logger.info({ msg: `Rolling back batch ${latestBatch} consisting of ${migrationsToRollback.length} migrations.` });
-    for (const migration of migrationsToRollback) {
-        const migrationFile = migrationFiles.find((m) => m.name === migration.name);
-        if (!migrationFile) {
-            throw new Error(`Migration ${migration.name} not found locally.`);
-        }
-        const start = Date.now();
-        let transactionID;
-        try {
-            payload.logger.info({ msg: `Migrating: ${migrationFile.name}` });
-            transactionID = await this.beginTransaction();
-            await migrationFile.down({ payload });
-            payload.logger.info({ msg: `Migrated:  ${migrationFile.name} (${Date.now() - start}ms)` });
-            await payload.delete({
-                collection: 'payload-migrations',
-                id: migration.id,
-                req: {
-                    transactionID,
-                },
-            });
-            await this.commitTransaction(transactionID);
-        }
-        catch (err) {
-            await this.rollbackTransaction(transactionID);
-            payload.logger.error({
-                msg: `Error running migration ${migrationFile.name}`,
-                err,
-            });
-            throw err;
-        }
-    }
-}
-exports.migrateDown = migrateDown;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateDown = void 0;
+const getMigrations_1 = require("./getMigrations");
+const readMigrationFiles_1 = require("./readMigrationFiles");
+async function migrateDown() {
+    const { payload } = this;
+    const migrationFiles = await (0, readMigrationFiles_1.readMigrationFiles)({ payload });
+    const { existingMigrations, latestBatch, } = await (0, getMigrations_1.getMigrations)({
+        payload,
+    });
+    const migrationsToRollback = existingMigrations.filter((migration) => migration.batch === latestBatch);
+    if (!(migrationsToRollback === null || migrationsToRollback === void 0 ? void 0 : migrationsToRollback.length)) {
+        payload.logger.info({ msg: 'No migrations to rollback.' });
+        return;
+    }
+    payload.logger.info({ msg: `Rolling back batch ${latestBatch} consisting of ${migrationsToRollback.length} migrations.` });
+    for (const migration of migrationsToRollback) {
+        const migrationFile = migrationFiles.find((m) => m.name === migration.name);
+        if (!migrationFile) {
+            throw new Error(`Migration ${migration.name} not found locally.`);
+        }
+        const start = Date.now();
+        let transactionID;
+        try {
+            payload.logger.info({ msg: `Migrating: ${migrationFile.name}` });
+            transactionID = await this.beginTransaction();
+            await migrationFile.down({ payload });
+            payload.logger.info({ msg: `Migrated:  ${migrationFile.name} (${Date.now() - start}ms)` });
+            await payload.delete({
+                collection: 'payload-migrations',
+                id: migration.id,
+                req: {
+                    transactionID,
+                },
+            });
+            await this.commitTransaction(transactionID);
+        }
+        catch (err) {
+            await this.rollbackTransaction(transactionID);
+            payload.logger.error({
+                msg: `Error running migration ${migrationFile.name}`,
+                err,
+            });
+            throw err;
+        }
+    }
+}
+exports.migrateDown = migrateDown;
 //# sourceMappingURL=migrateDown.js.map

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

@@ -1,5 +1,5 @@
-import { DatabaseAdapter } from '../types';
-/**
- * Reset and re-run all migrations.
- */
-export declare function migrateRefresh(this: DatabaseAdapter): Promise<void>;
+import { DatabaseAdapter } from '../types';
+/**
+ * Reset and re-run all migrations.
+ */
+export declare function migrateRefresh(this: DatabaseAdapter): Promise<void>;