@oliasoft-open-source/node-json-migrator 3.0.0 → 3.1.0-beta-2

package/dist/index.mjs

@@ -804,10 +804,6 @@ var isArguments = baseIsArguments(/* @__PURE__ */ function() {
   return isObjectLike(value) && hasOwnProperty$8.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
 function stubFalse() {
   return false;
 }
@@ -2324,221 +2320,213 @@ const LoaderModule = { loadModuleFromString };
 
 const hash = (string) => createHash("sha256").update(string).digest("hex");
 
-var balancedMatch;
-var hasRequiredBalancedMatch;
-
-function requireBalancedMatch () {
-	if (hasRequiredBalancedMatch) return balancedMatch;
-	hasRequiredBalancedMatch = 1;
-	balancedMatch = balanced;
-	function balanced(a, b, str) {
-	  if (a instanceof RegExp) a = maybeMatch(a, str);
-	  if (b instanceof RegExp) b = maybeMatch(b, str);
-	  var r = range(a, b, str);
-	  return r && {
-	    start: r[0],
-	    end: r[1],
-	    pre: str.slice(0, r[0]),
-	    body: str.slice(r[0] + a.length, r[1]),
-	    post: str.slice(r[1] + b.length)
-	  };
-	}
-	function maybeMatch(reg, str) {
-	  var m = str.match(reg);
-	  return m ? m[0] : null;
-	}
-	balanced.range = range;
-	function range(a, b, str) {
-	  var begs, beg, left, right, result;
-	  var ai = str.indexOf(a);
-	  var bi = str.indexOf(b, ai + 1);
-	  var i = ai;
-	  if (ai >= 0 && bi > 0) {
-	    if (a === b) {
-	      return [ai, bi];
-	    }
-	    begs = [];
-	    left = str.length;
-	    while (i >= 0 && !result) {
-	      if (i == ai) {
-	        begs.push(i);
-	        ai = str.indexOf(a, i + 1);
-	      } else if (begs.length == 1) {
-	        result = [begs.pop(), bi];
-	      } else {
-	        beg = begs.pop();
-	        if (beg < left) {
-	          left = beg;
-	          right = bi;
-	        }
-	        bi = str.indexOf(b, i + 1);
-	      }
-	      i = ai < bi && ai >= 0 ? ai : bi;
-	    }
-	    if (begs.length) {
-	      result = [left, right];
-	    }
-	  }
-	  return result;
-	}
-	return balancedMatch;
-}
-
-var braceExpansion;
-var hasRequiredBraceExpansion;
-
-function requireBraceExpansion () {
-	if (hasRequiredBraceExpansion) return braceExpansion;
-	hasRequiredBraceExpansion = 1;
-	var balanced = requireBalancedMatch();
-	braceExpansion = expandTop;
-	var escSlash = "\0SLASH" + Math.random() + "\0";
-	var escOpen = "\0OPEN" + Math.random() + "\0";
-	var escClose = "\0CLOSE" + Math.random() + "\0";
-	var escComma = "\0COMMA" + Math.random() + "\0";
-	var escPeriod = "\0PERIOD" + Math.random() + "\0";
-	function numeric(str) {
-	  return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-	}
-	function escapeBraces(str) {
-	  return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
-	}
-	function unescapeBraces(str) {
-	  return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
-	}
-	function parseCommaParts(str) {
-	  if (!str)
-	    return [""];
-	  var parts = [];
-	  var m = balanced("{", "}", str);
-	  if (!m)
-	    return str.split(",");
-	  var pre = m.pre;
-	  var body = m.body;
-	  var post = m.post;
-	  var p = pre.split(",");
-	  p[p.length - 1] += "{" + body + "}";
-	  var postParts = parseCommaParts(post);
-	  if (post.length) {
-	    p[p.length - 1] += postParts.shift();
-	    p.push.apply(p, postParts);
-	  }
-	  parts.push.apply(parts, p);
-	  return parts;
-	}
-	function expandTop(str) {
-	  if (!str)
-	    return [];
-	  if (str.substr(0, 2) === "{}") {
-	    str = "\\{\\}" + str.substr(2);
-	  }
-	  return expand(escapeBraces(str), true).map(unescapeBraces);
-	}
-	function embrace(str) {
-	  return "{" + str + "}";
-	}
-	function isPadded(el) {
-	  return /^-?0\d/.test(el);
-	}
-	function lte(i, y) {
-	  return i <= y;
-	}
-	function gte(i, y) {
-	  return i >= y;
-	}
-	function expand(str, isTop) {
-	  var expansions = [];
-	  var m = balanced("{", "}", str);
-	  if (!m) return [str];
-	  var pre = m.pre;
-	  var post = m.post.length ? expand(m.post, false) : [""];
-	  if (/\$$/.test(m.pre)) {
-	    for (var k = 0; k < post.length; k++) {
-	      var expansion = pre + "{" + m.body + "}" + post[k];
-	      expansions.push(expansion);
-	    }
-	  } else {
-	    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-	    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-	    var isSequence = isNumericSequence || isAlphaSequence;
-	    var isOptions = m.body.indexOf(",") >= 0;
-	    if (!isSequence && !isOptions) {
-	      if (m.post.match(/,.*\}/)) {
-	        str = m.pre + "{" + m.body + escClose + m.post;
-	        return expand(str);
-	      }
-	      return [str];
-	    }
-	    var n;
-	    if (isSequence) {
-	      n = m.body.split(/\.\./);
-	    } else {
-	      n = parseCommaParts(m.body);
-	      if (n.length === 1) {
-	        n = expand(n[0], false).map(embrace);
-	        if (n.length === 1) {
-	          return post.map(function(p) {
-	            return m.pre + n[0] + p;
-	          });
-	        }
-	      }
-	    }
-	    var N;
-	    if (isSequence) {
-	      var x = numeric(n[0]);
-	      var y = numeric(n[1]);
-	      var width = Math.max(n[0].length, n[1].length);
-	      var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-	      var test = lte;
-	      var reverse = y < x;
-	      if (reverse) {
-	        incr *= -1;
-	        test = gte;
-	      }
-	      var pad = n.some(isPadded);
-	      N = [];
-	      for (var i = x; test(i, y); i += incr) {
-	        var c;
-	        if (isAlphaSequence) {
-	          c = String.fromCharCode(i);
-	          if (c === "\\")
-	            c = "";
-	        } else {
-	          c = String(i);
-	          if (pad) {
-	            var need = width - c.length;
-	            if (need > 0) {
-	              var z = new Array(need + 1).join("0");
-	              if (i < 0)
-	                c = "-" + z + c.slice(1);
-	              else
-	                c = z + c;
-	            }
-	          }
-	        }
-	        N.push(c);
-	      }
-	    } else {
-	      N = [];
-	      for (var j = 0; j < n.length; j++) {
-	        N.push.apply(N, expand(n[j], false));
-	      }
-	    }
-	    for (var j = 0; j < N.length; j++) {
-	      for (var k = 0; k < post.length; k++) {
-	        var expansion = pre + N[j] + post[k];
-	        if (!isTop || isSequence || expansion)
-	          expansions.push(expansion);
-	      }
-	    }
-	  }
-	  return expansions;
-	}
-	return braceExpansion;
-}
-
-var braceExpansionExports = requireBraceExpansion();
-var expand = /*@__PURE__*/getDefaultExportFromCjs(braceExpansionExports);
+const balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+};
+const maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+const range = (a, b, str) => {
+  let begs, beg, left, right = void 0, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== void 0)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== void 0 && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== void 0) {
+      result = [left, right];
+    }
+  }
+  return result;
+};
+
+const escSlash = "\0SLASH" + Math.random() + "\0";
+const escOpen = "\0OPEN" + Math.random() + "\0";
+const escClose = "\0CLOSE" + Math.random() + "\0";
+const escComma = "\0COMMA" + Math.random() + "\0";
+const escPeriod = "\0PERIOD" + Math.random() + "\0";
+const escSlashPattern = new RegExp(escSlash, "g");
+const escOpenPattern = new RegExp(escOpen, "g");
+const escClosePattern = new RegExp(escClose, "g");
+const escCommaPattern = new RegExp(escComma, "g");
+const escPeriodPattern = new RegExp(escPeriod, "g");
+const slashPattern = /\\\\/g;
+const openPattern = /\\{/g;
+const closePattern = /\\}/g;
+const commaPattern = /\\,/g;
+const periodPattern = /\\./g;
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
+}
+function expand(str) {
+  if (!str) {
+    return [];
+  }
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x; test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], false));
+      }
+    }
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
+}
 
 const MAX_PATTERN_LENGTH = 1024 * 64;
 const assertValidPattern = (pattern) => {
@@ -3058,7 +3046,7 @@ class AST {
       this.#hasMagic = void 0;
       return [s, unescape(this.toString()), false, false];
     }
-    let bodyDotAllowed = !repeated || allowDot || dot || false ? "" : this.#partsToRegExp(true);
+    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
     if (bodyDotAllowed === body) {
       bodyDotAllowed = "";
     }
@@ -6136,7 +6124,7 @@ const IFREG = 8;
 const IFLNK = 10;
 const IFSOCK = 12;
 const IFMT = 15;
-const IFMT_UNKNOWN = -16;
+const IFMT_UNKNOWN = ~IFMT;
 const READDIR_CALLED = 16;
 const LSTAT_CALLED = 32;
 const ENOTDIR = 64;
@@ -6398,7 +6386,7 @@ class PathBase {
     }
     const children = Object.assign([], { provisional: 0 });
     this.#children.set(this, children);
-    this.#type &= -17;
+    this.#type &= ~READDIR_CALLED;
     return children;
   }
   /**
@@ -8920,14 +8908,15 @@ const migrationTablesExist = (db, entity) => {
     SELECT EXISTS (
       SELECT FROM information_schema.tables
       WHERE table_schema = 'public'
-      AND table_name = '${entity}_migrations'
+      AND table_name = $(tableName)
     )
   `;
-  return db.any(query);
+  const params = { tableName: `${entity}_migrations` };
+  return db.one(query, params);
 };
 const createMigrationsTables = (db, entity) => {
   const query = `
-    CREATE TABLE IF NOT EXISTS ${entity}_migrations (
+    CREATE TABLE IF NOT EXISTS $(migrationsTable:name) (
       file_hash TEXT NOT NULL PRIMARY KEY,
       file_name TEXT NOT NULL,
       sequence TEXT NOT NULL,
@@ -8935,20 +8924,26 @@ const createMigrationsTables = (db, entity) => {
       UNIQUE (file_name),
       UNIQUE (sequence)
     );
-    CREATE TABLE IF NOT EXISTS ${entity}_versions (
+    CREATE TABLE IF NOT EXISTS $(versionsTable:name) (
       version TEXT NOT NULL PRIMARY KEY,
       plan TEXT NOT NULL,
       created_on TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
     );
   `;
-  return db.any(query);
+  const params = {
+    migrationsTable: `${entity}_migrations`,
+    versionsTable: `${entity}_versions`
+  };
+  return db.none(query, params);
 };
 const getMigrationRecords = (db, entity) => {
   const query = `
-    SELECT file_hash, file_name, sequence FROM ${entity}_migrations
+    SELECT file_hash, file_name, sequence
+    FROM $(migrationsTable:name)
     ORDER BY sequence
   `;
-  return db.manyOrNone(query).then(
+  const params = { migrationsTable: `${entity}_migrations` };
+  return db.manyOrNone(query, params).then(
     (data) => data.map((r) => ({
       fileHash: r.file_hash,
       fileName: r.file_name,
@@ -8966,7 +8961,7 @@ const insertMigrationsRecords = (db, pgpHelpers, entity, migrations) => {
     const cs = new pgpHelpers.ColumnSet(
       ["file_name", "file_hash", "sequence"],
       {
-        table: `${entity}_migrations`
+        table: new pgpHelpers.TableName({ table: `${entity}_migrations` })
       }
     );
     const onConflict = " ON CONFLICT(file_name) DO NOTHING";
@@ -8975,13 +8970,14 @@ const insertMigrationsRecords = (db, pgpHelpers, entity, migrations) => {
   }
 };
 const replaceMigrationsRecords = async (db, pgpHelpers, entity, migrations) => {
-  const truncate = `DELETE FROM ${entity}_migrations`;
-  await db.none(truncate);
+  const query = `DELETE FROM $(migrationsTableName:name)`;
+  const params = { migrationsTableName: `${entity}_migrations` };
+  await db.none(query, params);
   await insertMigrationsRecords(db, pgpHelpers, entity, migrations);
 };
 const insertVersions = (db, pgpHelpers, entity, records) => {
   const cs = new pgpHelpers.ColumnSet(["version", "plan"], {
-    table: `${entity}_versions`
+    table: new pgpHelpers.TableName({ table: `${entity}_versions` })
   });
   const onConflict = " ON CONFLICT(version) DO NOTHING";
   const query = pgpHelpers.insert(records, cs) + onConflict;
@@ -8989,19 +8985,97 @@ const insertVersions = (db, pgpHelpers, entity, records) => {
 };
 const getPlanFromVersion = (db, entity, version) => {
   const query = `
-    SELECT plan FROM ${entity}_versions
-    WHERE version=$1;
+    SELECT plan FROM $(versionsTable:name)
+    WHERE version=$(version);
   `;
-  return db.oneOrNone(query, [version], (r) => r?.plan || null);
+  const params = {
+    version,
+    versionsTable: `${entity}_versions`
+  };
+  return db.oneOrNone(query, params, (r) => r?.plan || null);
 };
 const getVersions = async (db, entity) => {
   const query = `
     SELECT
        version,
        plan
-    FROM ${entity}_versions ORDER BY created_on DESC
+    FROM $(versionsTable:name) ORDER BY created_on DESC
+  `;
+  const params = {
+    versionsTable: `${entity}_versions`
+  };
+  return db.any(query, params);
+};
+const getRecordList = async (db, entity, entityColumnNames, latestVersion, latestVersionPlanLength) => {
+  const query = `
+    SELECT
+      $(entityIdColumn:name) AS id,
+      name,
+      $(entityCreatedColumn:name) AS created,
+      version
+    FROM $(entityTable:name)
+    WHERE (
+      version IS NULL
+      OR (
+        version <> $(latestVersion)
+        AND (
+          SELECT
+            CASE
+              WHEN IS_JSON(plan) THEN JSON_ARRAY_LENGTH(plan::json)
+            ELSE 0
+            END AS length
+          FROM $(entityVersionsTable:name)
+          WHERE $(entityVersionsTable:name).version = version
+          LIMIT 1
+        )::integer <= $(latestVersionPlanLength)
+      )
+    )
+  `;
+  const params = {
+    entityTable: entity,
+    entityVersionsTable: `${entity}_versions`,
+    entityIdColumn: entityColumnNames.id,
+    entityCreatedColumn: entityColumnNames.created,
+    latestVersion,
+    latestVersionPlanLength
+  };
+  return db.any(query, params);
+};
+const getRecord = async (t, entity, entityColumnNames, entityId) => {
+  const query = `
+    SELECT *
+    FROM $(entityTable:name)
+    WHERE $(entityIdColumn:name) = $(entityId)
+  `;
+  const params = {
+    entityTable: entity,
+    entityId,
+    entityIdColumn: entityColumnNames.id
+  };
+  return t.one(query, params);
+};
+const updateRecord = async (t, entity, entityColumnNames, entityId, currentVersion, nextData, nextVersion, etag) => {
+  const useEtag = typeof etag === "number";
+  const query = `
+    UPDATE $(entityTable:name)
+    SET data = $(nextData),
+        version = $(nextVersion)
+        ${useEtag ? ", etag = etag + 1" : ""}
+    WHERE $(entityIdColumn:name) = $(entityId)
+      AND version = $(currentVersion)
+      ${useEtag ? "AND etag = $(etag)" : ""}
+    RETURNING *
   `;
-  return db.any(query);
+  const params = {
+    entityTable: entity,
+    entityId,
+    entityIdColumn: entityColumnNames.id,
+    currentVersion,
+    nextData,
+    nextVersion,
+    etag
+  };
+  return t.oneOrNone(query, params);
 };
 
 let cachedPlannedVersion = null;
@@ -9565,6 +9639,145 @@ const migrate = async ({
   };
 };
 
+const migrateRecord = async ({
+  record,
+  config,
+  beforeMigrateRecord,
+  afterMigrateRecord
+}) => {
+  const { dry } = config;
+  console.log(chalk.gray(` ${record.name}`));
+  try {
+    await config.database.tx(async (transaction) => {
+      const currentRecord = await getRecord(
+        transaction,
+        config.entity,
+        config.entityColumnNames,
+        record.id
+      );
+      const { data, etag, version: currentVersion } = currentRecord;
+      await beforeMigrateRecord({
+        currentRecord,
+        dry
+      });
+      const { nextPayload: nextData, nextVersion } = await migrate({
+        payload: data,
+        config: {
+          ...config,
+          version: currentVersion,
+          printPendingFileNames: true
+        }
+      });
+      if (!dry) {
+        const nextRecord = await updateRecord(
+          transaction,
+          config?.entity,
+          config.entityColumnNames,
+          record.id,
+          currentVersion,
+          nextData,
+          nextVersion,
+          etag
+        );
+        if (!nextRecord) {
+          throw new Error(
+            "Failed to patch record with newest migration - The record was probably updated while migrating..."
+          );
+        }
+        await afterMigrateRecord({
+          currentRecord,
+          nextRecord,
+          transaction,
+          dry
+        });
+      }
+    });
+    return null;
+  } catch (error) {
+    const migrationErrorPayload = {
+      id: record.id,
+      name: record.name,
+      created: record.created,
+      error,
+      stackTrace: error.stack
+    };
+    console.log(
+      chalk.red(
+        ` Dataset migration with id ${record.id} failed:
+ ${error.stack}`
+      )
+    );
+    return migrationErrorPayload;
+  }
+};
+const migrateRecords = async ({
+  recordList,
+  config,
+  beforeMigrateRecord,
+  afterMigrateRecord,
+  onMigrationErrors
+}) => {
+  const { dry } = config;
+  const migrationErrors = [];
+  if (recordList.length) {
+    console.log(chalk.gray("Executing record migration scripts..."));
+    for await (const record of recordList) {
+      const migrationErrorPayload = await migrateRecord({
+        record,
+        config,
+        beforeMigrateRecord,
+        afterMigrateRecord
+      });
+      if (migrationErrorPayload) {
+        migrationErrors.push(migrationErrorPayload);
+      }
+    }
+  }
+  if (migrationErrors.length) {
+    console.log(
+      chalk.yellow(
+        `Completed ${config?.entity ?? "entity"} migrations (some failed)${config?.dry ? " [dry-run, no output written]" : ""} \u2713`
+      )
+    );
+    await onMigrationErrors({
+      migrationErrors,
+      dry
+    });
+  } else {
+    console.log(
+      chalk.green(
+        `Completed ${config?.entity ?? "entity"} migrations (success)${config?.dry ? " [dry-run, no output written]" : ""} \u2713`
+      )
+    );
+  }
+};
+const migrateAll = async ({
+  config,
+  beforeMigrateRecord,
+  afterMigrateRecord,
+  onMigrationErrors
+}) => {
+  const plan = await getPlannedMigrations({
+    config
+  });
+  const latestVersion = plan.nextVersion;
+  const latestVersionPlanLength = plan.plannedMigrations.length;
+  const recordList = await getRecordList(
+    config?.database,
+    config?.entity,
+    config?.entityColumnNames,
+    latestVersion,
+    latestVersionPlanLength
+  );
+  await migrateRecords({
+    config,
+    recordList,
+    beforeMigrateRecord,
+    afterMigrateRecord,
+    onMigrationErrors
+  });
+};
+
 const parsePlan = (plan) => {
   return (() => {
     try {
@@ -9613,4 +9826,4 @@ const printVersionHistory = async ({ config }) => {
   }
 };
 
-export { createMigration, getPlannedMigrations, getPlannedVersion, getVersions, migrate, pipe, printVersionHistory };
+export { createMigration, getPlannedMigrations, getPlannedVersion, getVersions, migrate, migrateAll, pipe, printVersionHistory };