@payloadcms/db-postgres 0.1.0-beta.15 → 0.1.0-beta.16

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAmB,qBAAqB,EAAE,MAAM,SAAS,CAAA;AA+B3E,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE7D,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,qBAAqB,CAsDjE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAmB,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAmC3E,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE7D,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,qBAAqB,CA0DjE"}

package/dist/index.js

@@ -29,6 +29,10 @@ const _findOne = require("./findOne");
 const _findVersions = require("./findVersions");
 const _init = require("./init");
 const _migrate = require("./migrate");
+const _migrateDown = require("./migrateDown");
+const _migrateFresh = require("./migrateFresh");
+const _migrateRefresh = require("./migrateRefresh");
+const _migrateReset = require("./migrateReset");
 const _migrateStatus = require("./migrateStatus");
 const _queryDrafts = require("./queryDrafts");
 const _beginTransaction = require("./transactions/beginTransaction");
@@ -80,6 +84,10 @@ function postgresAdapter(args) {
             findVersions: _findVersions.findVersions,
             init: _init.init,
             migrate: _migrate.migrate,
+            migrateDown: _migrateDown.migrateDown,
+            migrateFresh: _migrateFresh.migrateFresh,
+            migrateRefresh: _migrateRefresh.migrateRefresh,
+            migrateReset: _migrateReset.migrateReset,
             migrateStatus: _migrateStatus.migrateStatus,
             migrationDir,
             payload,
@@ -94,4 +102,4 @@ function postgresAdapter(args) {
     return adapter;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/migrateDown.d.ts

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

package/dist/migrateDown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateDown.d.ts","sourceRoot":"","sources":["../src/migrateDown.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C,wBAAsB,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA2DtE"}

package/dist/migrateDown.js

@@ -0,0 +1,71 @@
+/* eslint-disable no-restricted-syntax, no-await-in-loop */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "migrateDown", {
+    enumerable: true,
+    get: function() {
+        return migrateDown;
+    }
+});
+const _database = require("payload/database");
+const _migrationTableExists = require("./utilities/migrationTableExists");
+async function migrateDown() {
+    const { payload } = this;
+    const migrationFiles = await (0, _database.readMigrationFiles)({
+        payload
+    });
+    const { existingMigrations, latestBatch } = await (0, _database.getMigrations)({
+        payload
+    });
+    const migrationsToRollback = existingMigrations.filter((migration)=>migration.batch === latestBatch && migration.batch !== -1);
+    if (!migrationsToRollback?.length) {
+        payload.logger.info({
+            msg: 'No migrations to rollback.'
+        });
+        return;
+    }
+    payload.logger.info({
+        msg: `Rolling back batch ${latestBatch} consisting of ${migrationsToRollback.length} migration(s).`
+    });
+    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 down: ${migrationFile.name}`
+            });
+            transactionID = await this.beginTransaction();
+            await migrationFile.down({
+                payload
+            });
+            payload.logger.info({
+                msg: `Migrated down:  ${migrationFile.name} (${Date.now() - start}ms)`
+            });
+            const tableExists = await (0, _migrationTableExists.migrationTableExists)(this.drizzle);
+            if (tableExists) {
+                await payload.delete({
+                    id: migration.id,
+                    collection: 'payload-migrations',
+                    req: {
+                        transactionID
+                    }
+                });
+            }
+            await this.commitTransaction(transactionID);
+        } catch (err) {
+            await this.rollbackTransaction(transactionID);
+            payload.logger.error({
+                err,
+                msg: `Error running migration ${migrationFile.name}`
+            });
+            throw err;
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9taWdyYXRlRG93bi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBuby1yZXN0cmljdGVkLXN5bnRheCwgbm8tYXdhaXQtaW4tbG9vcCAqL1xuaW1wb3J0IHR5cGUgeyBQYXlsb2FkUmVxdWVzdCB9IGZyb20gJ3BheWxvYWQvdHlwZXMnXG5cbmltcG9ydCB7IGdldE1pZ3JhdGlvbnMsIHJlYWRNaWdyYXRpb25GaWxlcyB9IGZyb20gJ3BheWxvYWQvZGF0YWJhc2UnXG5cbmltcG9ydCB0eXBlIHsgUG9zdGdyZXNBZGFwdGVyIH0gZnJvbSAnLi90eXBlcydcblxuaW1wb3J0IHsgbWlncmF0aW9uVGFibGVFeGlzdHMgfSBmcm9tICcuL3V0aWxpdGllcy9taWdyYXRpb25UYWJsZUV4aXN0cydcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIG1pZ3JhdGVEb3duKHRoaXM6IFBvc3RncmVzQWRhcHRlcik6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCB7IHBheWxvYWQgfSA9IHRoaXNcbiAgY29uc3QgbWlncmF0aW9uRmlsZXMgPSBhd2FpdCByZWFkTWlncmF0aW9uRmlsZXMoeyBwYXlsb2FkIH0pXG5cbiAgY29uc3QgeyBleGlzdGluZ01pZ3JhdGlvbnMsIGxhdGVzdEJhdGNoIH0gPSBhd2FpdCBnZXRNaWdyYXRpb25zKHtcbiAgICBwYXlsb2FkLFxuICB9KVxuXG4gIGNvbnN0IG1pZ3JhdGlvbnNUb1JvbGxiYWNrID0gZXhpc3RpbmdNaWdyYXRpb25zLmZpbHRlcihcbiAgICAobWlncmF0aW9uKSA9PiBtaWdyYXRpb24uYmF0Y2ggPT09IGxhdGVzdEJhdGNoICYmIG1pZ3JhdGlvbi5iYXRjaCAhPT0gLTEsXG4gIClcblxuICBpZiAoIW1pZ3JhdGlvbnNUb1JvbGxiYWNrPy5sZW5ndGgpIHtcbiAgICBwYXlsb2FkLmxvZ2dlci5pbmZvKHsgbXNnOiAnTm8gbWlncmF0aW9ucyB0byByb2xsYmFjay4nIH0pXG4gICAgcmV0dXJuXG4gIH1cblxuICBwYXlsb2FkLmxvZ2dlci5pbmZvKHtcbiAgICBtc2c6IGBSb2xsaW5nIGJhY2sgYmF0Y2ggJHtsYXRlc3RCYXRjaH0gY29uc2lzdGluZyBvZiAke21pZ3JhdGlvbnNUb1JvbGxiYWNrLmxlbmd0aH0gbWlncmF0aW9uKHMpLmAsXG4gIH0pXG5cbiAgZm9yIChjb25zdCBtaWdyYXRpb24gb2YgbWlncmF0aW9uc1RvUm9sbGJhY2spIHtcbiAgICBjb25zdCBtaWdyYXRpb25GaWxlID0gbWlncmF0aW9uRmlsZXMuZmluZCgobSkgPT4gbS5uYW1lID09PSBtaWdyYXRpb24ubmFtZSlcbiAgICBpZiAoIW1pZ3JhdGlvbkZpbGUpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihgTWlncmF0aW9uICR7bWlncmF0aW9uLm5hbWV9IG5vdCBmb3VuZCBsb2NhbGx5LmApXG4gICAgfVxuXG4gICAgY29uc3Qgc3RhcnQgPSBEYXRlLm5vdygpXG4gICAgbGV0IHRyYW5zYWN0aW9uSURcblxuICAgIHRyeSB7XG4gICAgICBwYXlsb2FkLmxvZ2dlci5pbmZvKHsgbXNnOiBgTWlncmF0aW5nIGRvd246ICR7bWlncmF0aW9uRmlsZS5uYW1lfWAgfSlcbiAgICAgIHRyYW5zYWN0aW9uSUQgPSBhd2FpdCB0aGlzLmJlZ2luVHJhbnNhY3Rpb24oKVxuICAgICAgYXdhaXQgbWlncmF0aW9uRmlsZS5kb3duKHsgcGF5bG9hZCB9KVxuICAgICAgcGF5bG9hZC5sb2dnZXIuaW5mbyh7XG4gICAgICAgIG1zZzogYE1pZ3JhdGVkIGRvd246ICAke21pZ3JhdGlvbkZpbGUubmFtZX0gKCR7RGF0ZS5ub3coKSAtIHN0YXJ0fW1zKWAsXG4gICAgICB9KVxuXG4gICAgICBjb25zdCB0YWJsZUV4aXN0cyA9IGF3YWl0IG1pZ3JhdGlvblRhYmxlRXhpc3RzKHRoaXMuZHJpenpsZSlcbiAgICAgIGlmICh0YWJsZUV4aXN0cykge1xuICAgICAgICBhd2FpdCBwYXlsb2FkLmRlbGV0ZSh7XG4gICAgICAgICAgaWQ6IG1pZ3JhdGlvbi5pZCxcbiAgICAgICAgICBjb2xsZWN0aW9uOiAncGF5bG9hZC1taWdyYXRpb25zJyxcbiAgICAgICAgICByZXE6IHtcbiAgICAgICAgICAgIHRyYW5zYWN0aW9uSUQsXG4gICAgICAgICAgfSBhcyBQYXlsb2FkUmVxdWVzdCxcbiAgICAgICAgfSlcbiAgICAgIH1cblxuICAgICAgYXdhaXQgdGhpcy5jb21taXRUcmFuc2FjdGlvbih0cmFuc2FjdGlvbklEKVxuICAgIH0gY2F0Y2ggKGVycjogdW5rbm93bikge1xuICAgICAgYXdhaXQgdGhpcy5yb2xsYmFja1RyYW5zYWN0aW9uKHRyYW5zYWN0aW9uSUQpXG4gICAgICBwYXlsb2FkLmxvZ2dlci5lcnJvcih7XG4gICAgICAgIGVycixcbiAgICAgICAgbXNnOiBgRXJyb3IgcnVubmluZyBtaWdyYXRpb24gJHttaWdyYXRpb25GaWxlLm5hbWV9YCxcbiAgICAgIH0pXG4gICAgICB0aHJvdyBlcnJcbiAgICB9XG4gIH1cbn1cbiJdLCJuYW1lcyI6WyJtaWdyYXRlRG93biIsInBheWxvYWQiLCJtaWdyYXRpb25GaWxlcyIsInJlYWRNaWdyYXRpb25GaWxlcyIsImV4aXN0aW5nTWlncmF0aW9ucyIsImxhdGVzdEJhdGNoIiwiZ2V0TWlncmF0aW9ucyIsIm1pZ3JhdGlvbnNUb1JvbGxiYWNrIiwiZmlsdGVyIiwibWlncmF0aW9uIiwiYmF0Y2giLCJsZW5ndGgiLCJsb2dnZXIiLCJpbmZvIiwibXNnIiwibWlncmF0aW9uRmlsZSIsImZpbmQiLCJtIiwibmFtZSIsIkVycm9yIiwic3RhcnQiLCJEYXRlIiwibm93IiwidHJhbnNhY3Rpb25JRCIsImJlZ2luVHJhbnNhY3Rpb24iLCJkb3duIiwidGFibGVFeGlzdHMiLCJtaWdyYXRpb25UYWJsZUV4aXN0cyIsImRyaXp6bGUiLCJkZWxldGUiLCJpZCIsImNvbGxlY3Rpb24iLCJyZXEiLCJjb21taXRUcmFuc2FjdGlvbiIsImVyciIsInJvbGxiYWNrVHJhbnNhY3Rpb24iLCJlcnJvciJdLCJtYXBwaW5ncyI6IkFBQUEseURBQXlEOzs7OytCQVNuQ0E7OztlQUFBQTs7OzBCQU40QjtzQ0FJYjtBQUU5QixlQUFlQTtJQUNwQixNQUFNLEVBQUVDLE9BQU8sRUFBRSxHQUFHLElBQUk7SUFDeEIsTUFBTUMsaUJBQWlCLE1BQU1DLElBQUFBLDRCQUFrQixFQUFDO1FBQUVGO0lBQVE7SUFFMUQsTUFBTSxFQUFFRyxrQkFBa0IsRUFBRUMsV0FBVyxFQUFFLEdBQUcsTUFBTUMsSUFBQUEsdUJBQWEsRUFBQztRQUM5REw7SUFDRjtJQUVBLE1BQU1NLHVCQUF1QkgsbUJBQW1CSSxNQUFNLENBQ3BELENBQUNDLFlBQWNBLFVBQVVDLEtBQUssS0FBS0wsZUFBZUksVUFBVUMsS0FBSyxLQUFLLENBQUM7SUFHekUsSUFBSSxDQUFDSCxzQkFBc0JJLFFBQVE7UUFDakNWLFFBQVFXLE1BQU0sQ0FBQ0MsSUFBSSxDQUFDO1lBQUVDLEtBQUs7UUFBNkI7UUFDeEQ7SUFDRjtJQUVBYixRQUFRVyxNQUFNLENBQUNDLElBQUksQ0FBQztRQUNsQkMsS0FBSyxDQUFDLG1CQUFtQixFQUFFVCxZQUFZLGVBQWUsRUFBRUUscUJBQXFCSSxNQUFNLENBQUMsY0FBYyxDQUFDO0lBQ3JHO0lBRUEsS0FBSyxNQUFNRixhQUFhRixxQkFBc0I7UUFDNUMsTUFBTVEsZ0JBQWdCYixlQUFlYyxJQUFJLENBQUMsQ0FBQ0MsSUFBTUEsRUFBRUMsSUFBSSxLQUFLVCxVQUFVUyxJQUFJO1FBQzFFLElBQUksQ0FBQ0gsZUFBZTtZQUNsQixNQUFNLElBQUlJLE1BQU0sQ0FBQyxVQUFVLEVBQUVWLFVBQVVTLElBQUksQ0FBQyxtQkFBbUIsQ0FBQztRQUNsRTtRQUVBLE1BQU1FLFFBQVFDLEtBQUtDLEdBQUc7UUFDdEIsSUFBSUM7UUFFSixJQUFJO1lBQ0Z0QixRQUFRVyxNQUFNLENBQUNDLElBQUksQ0FBQztnQkFBRUMsS0FBSyxDQUFDLGdCQUFnQixFQUFFQyxjQUFjRyxJQUFJLENBQUMsQ0FBQztZQUFDO1lBQ25FSyxnQkFBZ0IsTUFBTSxJQUFJLENBQUNDLGdCQUFnQjtZQUMzQyxNQUFNVCxjQUFjVSxJQUFJLENBQUM7Z0JBQUV4QjtZQUFRO1lBQ25DQSxRQUFRVyxNQUFNLENBQUNDLElBQUksQ0FBQztnQkFDbEJDLEtBQUssQ0FBQyxnQkFBZ0IsRUFBRUMsY0FBY0csSUFBSSxDQUFDLEVBQUUsRUFBRUcsS0FBS0MsR0FBRyxLQUFLRixNQUFNLEdBQUcsQ0FBQztZQUN4RTtZQUVBLE1BQU1NLGNBQWMsTUFBTUMsSUFBQUEsMENBQW9CLEVBQUMsSUFBSSxDQUFDQyxPQUFPO1lBQzNELElBQUlGLGFBQWE7Z0JBQ2YsTUFBTXpCLFFBQVE0QixNQUFNLENBQUM7b0JBQ25CQyxJQUFJckIsVUFBVXFCLEVBQUU7b0JBQ2hCQyxZQUFZO29CQUNaQyxLQUFLO3dCQUNIVDtvQkFDRjtnQkFDRjtZQUNGO1lBRUEsTUFBTSxJQUFJLENBQUNVLGlCQUFpQixDQUFDVjtRQUMvQixFQUFFLE9BQU9XLEtBQWM7WUFDckIsTUFBTSxJQUFJLENBQUNDLG1CQUFtQixDQUFDWjtZQUMvQnRCLFFBQVFXLE1BQU0sQ0FBQ3dCLEtBQUssQ0FBQztnQkFDbkJGO2dCQUNBcEIsS0FBSyxDQUFDLHdCQUF3QixFQUFFQyxjQUFjRyxJQUFJLENBQUMsQ0FBQztZQUN0RDtZQUNBLE1BQU1nQjtRQUNSO0lBQ0Y7QUFDRiJ9

package/dist/migrateFresh.d.ts

@@ -0,0 +1,6 @@
+import type { PostgresAdapter } from './types';
+/**
+ * Drop the current database and run all migrate up functions
+ */
+export declare function migrateFresh(this: PostgresAdapter): Promise<void>;
+//# sourceMappingURL=migrateFresh.d.ts.map

package/dist/migrateFresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateFresh.d.ts","sourceRoot":"","sources":["../src/migrateFresh.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C;;GAEG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA8DvE"}

package/dist/migrateFresh.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "migrateFresh", {
+    enumerable: true,
+    get: function() {
+        return migrateFresh;
+    }
+});
+const _drizzleorm = require("drizzle-orm");
+const _database = require("payload/database");
+const _prompts = /*#__PURE__*/ _interop_require_default(require("prompts"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function migrateFresh() {
+    const { payload } = this;
+    const { confirm: acceptWarning } = await (0, _prompts.default)({
+        name: 'confirm',
+        initial: false,
+        message: `WARNING: This will drop your database and run all migrations. Are you sure you want to proceed?`,
+        type: 'confirm'
+    }, {
+        onCancel: ()=>{
+            process.exit(0);
+        }
+    });
+    if (!acceptWarning) {
+        process.exit(0);
+    }
+    payload.logger.info({
+        msg: `Dropping database.`
+    });
+    await this.drizzle.execute((0, _drizzleorm.sql)`drop schema public cascade;\ncreate schema public;`);
+    const migrationFiles = await (0, _database.readMigrationFiles)({
+        payload
+    });
+    payload.logger.debug({
+        msg: `Found ${migrationFiles.length} migration files.`
+    });
+    let transactionID;
+    // Run all migrate up
+    for (const migration of migrationFiles){
+        payload.logger.info({
+            msg: `Migrating: ${migration.name}`
+        });
+        try {
+            const start = Date.now();
+            transactionID = await this.beginTransaction();
+            await migration.up({
+                payload
+            });
+            await payload.create({
+                collection: 'payload-migrations',
+                data: {
+                    name: migration.name,
+                    batch: 1
+                },
+                req: {
+                    transactionID
+                }
+            });
+            await this.commitTransaction(transactionID);
+            payload.logger.info({
+                msg: `Migrated:  ${migration.name} (${Date.now() - start}ms)`
+            });
+        } catch (err) {
+            await this.rollbackTransaction(transactionID);
+            payload.logger.error({
+                err,
+                msg: `Error running migration ${migration.name}. Rolling back.`
+            });
+            throw err;
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/migrateRefresh.d.ts

@@ -0,0 +1,6 @@
+import type { PostgresAdapter } from './types';
+/**
+ * Run all migration down functions before running up
+ */
+export declare function migrateRefresh(this: PostgresAdapter): Promise<void>;
+//# sourceMappingURL=migrateRefresh.d.ts.map

package/dist/migrateRefresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateRefresh.d.ts","sourceRoot":"","sources":["../src/migrateRefresh.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C;;GAEG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,eAAe,iBAkGzD"}

package/dist/migrateRefresh.js

@@ -0,0 +1,114 @@
+/* eslint-disable no-restricted-syntax, no-await-in-loop */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "migrateRefresh", {
+    enumerable: true,
+    get: function() {
+        return migrateRefresh;
+    }
+});
+const _database = require("payload/database");
+const _migrationTableExists = require("./utilities/migrationTableExists");
+async function migrateRefresh() {
+    const { payload } = this;
+    const migrationFiles = await (0, _database.readMigrationFiles)({
+        payload
+    });
+    const { existingMigrations, latestBatch } = await (0, _database.getMigrations)({
+        payload
+    });
+    const migrationsToRollback = existingMigrations.filter((migration)=>migration.batch === latestBatch && migration.batch !== -1);
+    if (!migrationsToRollback?.length) {
+        payload.logger.info({
+            msg: 'No migrations to rollback.'
+        });
+        return;
+    }
+    payload.logger.info({
+        msg: `Rolling back batch ${latestBatch} consisting of ${migrationsToRollback.length} migration(s).`
+    });
+    let transactionID;
+    // Reverse order of migrations to rollback
+    migrationsToRollback.reverse();
+    for (const migration of migrationsToRollback){
+        try {
+            const migrationFile = migrationFiles.find((m)=>m.name === migration.name);
+            if (!migrationFile) {
+                throw new Error(`Migration ${migration.name} not found locally.`);
+            }
+            payload.logger.info({
+                msg: `Migrating down: ${migration.name}`
+            });
+            const start = Date.now();
+            transactionID = await this.beginTransaction();
+            await migrationFile.down({
+                payload
+            });
+            payload.logger.info({
+                msg: `Migrated down:  ${migration.name} (${Date.now() - start}ms)`
+            });
+            const tableExists = await (0, _migrationTableExists.migrationTableExists)(this.drizzle);
+            if (tableExists) {
+                await payload.delete({
+                    collection: 'payload-migrations',
+                    req: {
+                        transactionID
+                    },
+                    where: {
+                        name: {
+                            equals: migration.name
+                        }
+                    }
+                });
+            }
+        } catch (err) {
+            await this.rollbackTransaction(transactionID);
+            let msg = `Error running migration ${migration.name}. Rolling back.`;
+            if (err instanceof Error) {
+                msg += ` ${err.message}`;
+            }
+            payload.logger.error({
+                err,
+                msg
+            });
+            throw err;
+        }
+    }
+    // Run all migrate up
+    for (const migration of migrationFiles){
+        payload.logger.info({
+            msg: `Migrating: ${migration.name}`
+        });
+        try {
+            const start = Date.now();
+            transactionID = await this.beginTransaction();
+            await migration.up({
+                payload
+            });
+            await payload.create({
+                collection: 'payload-migrations',
+                data: {
+                    name: migration.name,
+                    executed: true
+                },
+                req: {
+                    transactionID
+                }
+            });
+            await this.commitTransaction(transactionID);
+            payload.logger.info({
+                msg: `Migrated:  ${migration.name} (${Date.now() - start}ms)`
+            });
+        } catch (err) {
+            await this.rollbackTransaction(transactionID);
+            payload.logger.error({
+                err,
+                msg: `Error running migration ${migration.name}. Rolling back.`
+            });
+            throw err;
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/migrateRefresh.ts"],"sourcesContent":["/* eslint-disable no-restricted-syntax, no-await-in-loop */\nimport type { PayloadRequest } from 'payload/types'\n\nimport { getMigrations, readMigrationFiles } from 'payload/database'\n\nimport type { PostgresAdapter } from './types'\n\nimport { migrationTableExists } from './utilities/migrationTableExists'\n\n/**\n * Run all migration down functions before running up\n */\nexport async function migrateRefresh(this: PostgresAdapter) {\n  const { payload } = this\n  const migrationFiles = await readMigrationFiles({ payload })\n\n  const { existingMigrations, latestBatch } = await getMigrations({\n    payload,\n  })\n\n  const migrationsToRollback = existingMigrations.filter(\n    (migration) => migration.batch === latestBatch && migration.batch !== -1,\n  )\n\n  if (!migrationsToRollback?.length) {\n    payload.logger.info({ msg: 'No migrations to rollback.' })\n    return\n  }\n\n  payload.logger.info({\n    msg: `Rolling back batch ${latestBatch} consisting of ${migrationsToRollback.length} migration(s).`,\n  })\n\n  let transactionID\n\n  // Reverse order of migrations to rollback\n  migrationsToRollback.reverse()\n\n  for (const migration of migrationsToRollback) {\n    try {\n      const migrationFile = migrationFiles.find((m) => m.name === migration.name)\n      if (!migrationFile) {\n        throw new Error(`Migration ${migration.name} not found locally.`)\n      }\n\n      payload.logger.info({ msg: `Migrating down: ${migration.name}` })\n      const start = Date.now()\n      transactionID = await this.beginTransaction()\n      await migrationFile.down({ payload })\n      payload.logger.info({\n        msg: `Migrated down:  ${migration.name} (${Date.now() - start}ms)`,\n      })\n\n      const tableExists = await migrationTableExists(this.drizzle)\n      if (tableExists) {\n        await payload.delete({\n          collection: 'payload-migrations',\n          req: {\n            transactionID,\n          } as PayloadRequest,\n          where: {\n            name: {\n              equals: migration.name,\n            },\n          },\n        })\n      }\n    } catch (err: unknown) {\n      await this.rollbackTransaction(transactionID)\n      let msg = `Error running migration ${migration.name}. Rolling back.`\n      if (err instanceof Error) {\n        msg += ` ${err.message}`\n      }\n      payload.logger.error({\n        err,\n        msg,\n      })\n      throw err\n    }\n  }\n\n  // Run all migrate up\n  for (const migration of migrationFiles) {\n    payload.logger.info({ msg: `Migrating: ${migration.name}` })\n    try {\n      const start = Date.now()\n      transactionID = await this.beginTransaction()\n      await migration.up({ payload })\n      await payload.create({\n        collection: 'payload-migrations',\n        data: {\n          name: migration.name,\n          executed: true,\n        },\n        req: {\n          transactionID,\n        } as PayloadRequest,\n      })\n      await this.commitTransaction(transactionID)\n\n      payload.logger.info({ msg: `Migrated:  ${migration.name} (${Date.now() - start}ms)` })\n    } catch (err: unknown) {\n      await this.rollbackTransaction(transactionID)\n      payload.logger.error({\n        err,\n        msg: `Error running migration ${migration.name}. Rolling back.`,\n      })\n      throw err\n    }\n  }\n}\n"],"names":["migrateRefresh","payload","migrationFiles","readMigrationFiles","existingMigrations","latestBatch","getMigrations","migrationsToRollback","filter","migration","batch","length","logger","info","msg","transactionID","reverse","migrationFile","find","m","name","Error","start","Date","now","beginTransaction","down","tableExists","migrationTableExists","drizzle","delete","collection","req","where","equals","err","rollbackTransaction","message","error","up","create","data","executed","commitTransaction"],"mappings":"AAAA,yDAAyD;;;;+BAYnCA;;;eAAAA;;;0BAT4B;sCAIb;AAK9B,eAAeA;IACpB,MAAM,EAAEC,OAAO,EAAE,GAAG,IAAI;IACxB,MAAMC,iBAAiB,MAAMC,IAAAA,4BAAkB,EAAC;QAAEF;IAAQ;IAE1D,MAAM,EAAEG,kBAAkB,EAAEC,WAAW,EAAE,GAAG,MAAMC,IAAAA,uBAAa,EAAC;QAC9DL;IACF;IAEA,MAAMM,uBAAuBH,mBAAmBI,MAAM,CACpD,CAACC,YAAcA,UAAUC,KAAK,KAAKL,eAAeI,UAAUC,KAAK,KAAK,CAAC;IAGzE,IAAI,CAACH,sBAAsBI,QAAQ;QACjCV,QAAQW,MAAM,CAACC,IAAI,CAAC;YAAEC,KAAK;QAA6B;QACxD;IACF;IAEAb,QAAQW,MAAM,CAACC,IAAI,CAAC;QAClBC,KAAK,CAAC,mBAAmB,EAAET,YAAY,eAAe,EAAEE,qBAAqBI,MAAM,CAAC,cAAc,CAAC;IACrG;IAEA,IAAII;IAEJ,0CAA0C;IAC1CR,qBAAqBS,OAAO;IAE5B,KAAK,MAAMP,aAAaF,qBAAsB;QAC5C,IAAI;YACF,MAAMU,gBAAgBf,eAAegB,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKX,UAAUW,IAAI;YAC1E,IAAI,CAACH,eAAe;gBAClB,MAAM,IAAII,MAAM,CAAC,UAAU,EAAEZ,UAAUW,IAAI,CAAC,mBAAmB,CAAC;YAClE;YAEAnB,QAAQW,MAAM,CAACC,IAAI,CAAC;gBAAEC,KAAK,CAAC,gBAAgB,EAAEL,UAAUW,IAAI,CAAC,CAAC;YAAC;YAC/D,MAAME,QAAQC,KAAKC,GAAG;YACtBT,gBAAgB,MAAM,IAAI,CAACU,gBAAgB;YAC3C,MAAMR,cAAcS,IAAI,CAAC;gBAAEzB;YAAQ;YACnCA,QAAQW,MAAM,CAACC,IAAI,CAAC;gBAClBC,KAAK,CAAC,gBAAgB,EAAEL,UAAUW,IAAI,CAAC,EAAE,EAAEG,KAAKC,GAAG,KAAKF,MAAM,GAAG,CAAC;YACpE;YAEA,MAAMK,cAAc,MAAMC,IAAAA,0CAAoB,EAAC,IAAI,CAACC,OAAO;YAC3D,IAAIF,aAAa;gBACf,MAAM1B,QAAQ6B,MAAM,CAAC;oBACnBC,YAAY;oBACZC,KAAK;wBACHjB;oBACF;oBACAkB,OAAO;wBACLb,MAAM;4BACJc,QAAQzB,UAAUW,IAAI;wBACxB;oBACF;gBACF;YACF;QACF,EAAE,OAAOe,KAAc;YACrB,MAAM,IAAI,CAACC,mBAAmB,CAACrB;YAC/B,IAAID,MAAM,CAAC,wBAAwB,EAAEL,UAAUW,IAAI,CAAC,eAAe,CAAC;YACpE,IAAIe,eAAed,OAAO;gBACxBP,OAAO,CAAC,CAAC,EAAEqB,IAAIE,OAAO,CAAC,CAAC;YAC1B;YACApC,QAAQW,MAAM,CAAC0B,KAAK,CAAC;gBACnBH;gBACArB;YACF;YACA,MAAMqB;QACR;IACF;IAEA,qBAAqB;IACrB,KAAK,MAAM1B,aAAaP,eAAgB;QACtCD,QAAQW,MAAM,CAACC,IAAI,CAAC;YAAEC,KAAK,CAAC,WAAW,EAAEL,UAAUW,IAAI,CAAC,CAAC;QAAC;QAC1D,IAAI;YACF,MAAME,QAAQC,KAAKC,GAAG;YACtBT,gBAAgB,MAAM,IAAI,CAACU,gBAAgB;YAC3C,MAAMhB,UAAU8B,EAAE,CAAC;gBAAEtC;YAAQ;YAC7B,MAAMA,QAAQuC,MAAM,CAAC;gBACnBT,YAAY;gBACZU,MAAM;oBACJrB,MAAMX,UAAUW,IAAI;oBACpBsB,UAAU;gBACZ;gBACAV,KAAK;oBACHjB;gBACF;YACF;YACA,MAAM,IAAI,CAAC4B,iBAAiB,CAAC5B;YAE7Bd,QAAQW,MAAM,CAACC,IAAI,CAAC;gBAAEC,KAAK,CAAC,WAAW,EAAEL,UAAUW,IAAI,CAAC,EAAE,EAAEG,KAAKC,GAAG,KAAKF,MAAM,GAAG,CAAC;YAAC;QACtF,EAAE,OAAOa,KAAc;YACrB,MAAM,IAAI,CAACC,mBAAmB,CAACrB;YAC/Bd,QAAQW,MAAM,CAAC0B,KAAK,CAAC;gBACnBH;gBACArB,KAAK,CAAC,wBAAwB,EAAEL,UAAUW,IAAI,CAAC,eAAe,CAAC;YACjE;YACA,MAAMe;QACR;IACF;AACF"}

package/dist/migrateReset.d.ts

@@ -0,0 +1,6 @@
+import type { PostgresAdapter } from './types';
+/**
+ * Run all migrate down functions
+ */
+export declare function migrateReset(this: PostgresAdapter): Promise<void>;
+//# sourceMappingURL=migrateReset.d.ts.map

package/dist/migrateReset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateReset.d.ts","sourceRoot":"","sources":["../src/migrateReset.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C;;GAEG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAoEvE"}

package/dist/migrateReset.js

@@ -0,0 +1,87 @@
+/* eslint-disable no-restricted-syntax, no-await-in-loop */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "migrateReset", {
+    enumerable: true,
+    get: function() {
+        return migrateReset;
+    }
+});
+const _database = require("payload/database");
+const _migrationTableExists = require("./utilities/migrationTableExists");
+async function migrateReset() {
+    const { payload } = this;
+    const migrationFiles = await (0, _database.readMigrationFiles)({
+        payload
+    });
+    const { existingMigrations } = await (0, _database.getMigrations)({
+        payload
+    });
+    if (!existingMigrations?.length) {
+        payload.logger.info({
+            msg: 'No migrations to reset.'
+        });
+        return;
+    }
+    // Rollback all migrations in order
+    for (const migration of existingMigrations){
+        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 down: ${migrationFile.name}`
+            });
+            transactionID = await this.beginTransaction();
+            await migrationFile.down({
+                payload
+            });
+            payload.logger.info({
+                msg: `Migrated down:  ${migrationFile.name} (${Date.now() - start}ms)`
+            });
+            const tableExists = await (0, _migrationTableExists.migrationTableExists)(this.drizzle);
+            if (tableExists) {
+                await payload.delete({
+                    id: migration.id,
+                    collection: 'payload-migrations',
+                    req: {
+                        transactionID
+                    }
+                });
+            }
+            await this.commitTransaction(transactionID);
+        } catch (err) {
+            await this.rollbackTransaction(transactionID);
+            payload.logger.error({
+                err,
+                msg: `Error running migration ${migrationFile.name}`
+            });
+            throw err;
+        }
+    }
+    // Delete dev migration
+    const tableExists = await (0, _migrationTableExists.migrationTableExists)(this.drizzle);
+    if (tableExists) {
+        try {
+            await payload.delete({
+                collection: 'payload-migrations',
+                where: {
+                    batch: {
+                        equals: -1
+                    }
+                }
+            });
+        } catch (err) {
+            payload.logger.error({
+                error: err,
+                msg: 'Error deleting dev migration'
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/db-postgres",
-  "version": "0.1.0-beta.15",
+  "version": "0.1.0-beta.16",
   "description": "The officially supported Postgres database adapter for Payload",
   "repository": "https://github.com/payloadcms/payload",
   "license": "MIT",
@@ -24,8 +24,8 @@
   "devDependencies": {
     "@types/pg": "8.10.2",
     "@types/to-snake-case": "1.0.0",
-    "payload": "2.0.0-beta.19",
-    "@payloadcms/eslint-config": "0.0.1"
+    "@payloadcms/eslint-config": "0.0.1",
+    "payload": "2.0.0-beta.26"
   },
   "peerDependencies": {
     "better-sqlite3": "^8.5.0"

package/src/index.ts

@@ -24,6 +24,10 @@ import { findOne } from './findOne'
 import { findVersions } from './findVersions'
 import { init } from './init'
 import { migrate } from './migrate'
+import { migrateDown } from './migrateDown'
+import { migrateFresh } from './migrateFresh'
+import { migrateRefresh } from './migrateRefresh'
+import { migrateReset } from './migrateReset'
 import { migrateStatus } from './migrateStatus'
 import { queryDrafts } from './queryDrafts'
 import { beginTransaction } from './transactions/beginTransaction'
@@ -77,6 +81,10 @@ export function postgresAdapter(args: Args): PostgresAdapterResult {
       findVersions,
       init,
       migrate,
+      migrateDown,
+      migrateFresh,
+      migrateRefresh,
+      migrateReset,
       migrateStatus,
       migrationDir,
       payload,

package/dist/utilities/migrations.d.ts

@@ -1,15 +0,0 @@
-import type { Payload } from 'payload';
-import type { Migration } from 'payload/database';
-type RunMigrationArgs = {
-    batch: number;
-    migration: Migration;
-    payload: Payload;
-};
-export declare function runUp({ batch, migration, payload }: RunMigrationArgs): Promise<void>;
-type RunMigrationDownArgs = {
-    migration: Migration;
-    payload: Payload;
-};
-export declare function runDown({ migration, payload }: RunMigrationDownArgs): Promise<void>;
-export {};
-//# sourceMappingURL=migrations.d.ts.map

package/dist/utilities/migrations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../src/utilities/migrations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAKjD,KAAK,gBAAgB,GAAG;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,wBAAsB,KAAK,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,gBAAgB,iBA0B1E;AAED,KAAK,oBAAoB,GAAG;IAC1B,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,wBAAsB,OAAO,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,oBAAoB,iBA4BzE"}

package/dist/utilities/migrations.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    runUp: function() {
-        return runUp;
-    },
-    runDown: function() {
-        return runDown;
-    }
-});
-const _pg = require("pg");
-async function runUp({ batch, migration, payload }) {
-    const start = Date.now();
-    payload.logger.info({
-        msg: `Migrating: ${migration.name}`
-    });
-    try {
-        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
-            }
-        });
-    } catch (err) {
-        let msg = `Error running migration ${migration.name}`;
-        if (err instanceof _pg.DatabaseError) {
-            msg += `: ${err.message}`;
-            if (err.hint) msg += `. ${err.hint}`;
-        }
-        payload.logger.error({
-            err,
-            msg
-        });
-        throw err;
-    }
-}
-async function runDown({ migration, payload }) {
-    const start = Date.now();
-    let transactionID;
-    try {
-        payload.logger.info({
-            msg: `Migrating down: ${migration.name}`
-        });
-        transactionID = await this.beginTransaction();
-        await migration.down({
-            payload
-        });
-        payload.logger.info({
-            msg: `Migrated down:  ${migration.name} (${Date.now() - start}ms)`
-        });
-        // Waiting for implementation here
-        await payload.delete({
-            id: migration.id,
-            collection: 'payload-migrations',
-            req: {
-                transactionID
-            }
-        });
-        await this.commitTransaction(transactionID);
-    } catch (err) {
-        await this.rollbackTransaction(transactionID);
-        payload.logger.error({
-            err,
-            msg: `Error running migration ${migration.name}`
-        });
-        throw err;
-    }
-}
-
-//# sourceMappingURL=data:application/json;base64,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