drizzle-kit 0.13.0 → 0.14.1

package/index.js

@@ -2523,9 +2523,9 @@ var require_src = __commonJS({
   }
 });
 
-// node_modules/.pnpm/esbuild-register@3.4.1_esbuild@0.15.18/node_modules/esbuild-register/dist/node.js
+// node_modules/.pnpm/esbuild-register@3.4.2_esbuild@0.15.18/node_modules/esbuild-register/dist/node.js
 var require_node2 = __commonJS({
-  "node_modules/.pnpm/esbuild-register@3.4.1_esbuild@0.15.18/node_modules/esbuild-register/dist/node.js"(exports) {
+  "node_modules/.pnpm/esbuild-register@3.4.2_esbuild@0.15.18/node_modules/esbuild-register/dist/node.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     function _interopRequireDefault2(obj) {
@@ -7290,6 +7290,14 @@ var require_node2 = __commonJS({
         ...overrides
       } = esbuildOptions;
       const compile = function compile2(code, filename, format) {
+        const define2 = {
+          "import.meta.url": IMPORT_META_URL_VARIABLE_NAME,
+          ...overrides.define
+        };
+        const banner = `const ${IMPORT_META_URL_VARIABLE_NAME} = require('url').pathToFileURL(__filename).href;${overrides.banner || ""}`;
+        if (code.includes(banner)) {
+          return code;
+        }
         const dir = _path2.dirname.call(void 0, filename);
         const options = getOptions(dir);
         format = format != null ? format : inferPackageFormat(dir, filename);
@@ -7301,11 +7309,8 @@ var require_node2 = __commonJS({
           jsxFactory: options.jsxFactory,
           jsxFragment: options.jsxFragment,
           format,
-          define: {
-            "import.meta.url": IMPORT_META_URL_VARIABLE_NAME,
-            ...overrides.define
-          },
-          banner: `const ${IMPORT_META_URL_VARIABLE_NAME} = require('url').pathToFileURL(__filename).href;${overrides.banner || ""}`,
+          define: define2,
+          banner,
           ...overrides
         });
         const js = result.code;
@@ -7397,6 +7402,7 @@ var init_pgSerializer = __esm({
         (0, import_utils.getTableColumns)(table4).forEach((column4) => {
           const notNull = column4.notNull;
           const primaryKey = column4.primary;
+          const sqlTypeLowered = column4.getSQLType().toLowerCase();
           const columnToSet = {
             name: column4.name,
             type: column4.getSQLType(),
@@ -7412,7 +7418,15 @@ var init_pgSerializer = __esm({
                 throw new Error("Only strings are allowed in .default()");
               }).join();
             } else {
-              columnToSet.default = typeof column4.default === "string" ? `'${column4.default}'` : column4.default;
+              if (typeof column4.default === "string") {
+                columnToSet.default = `'${column4.default}'`;
+              } else {
+                if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
+                  columnToSet.default = `'${JSON.stringify(column4.default)}'::${sqlTypeLowered}`;
+                } else {
+                  columnToSet.default = column4.default;
+                }
+              }
             }
           }
           columnsObject[column4.name] = columnToSet;
@@ -7477,6 +7491,137 @@ var init_pgSerializer = __esm({
   }
 });
 
+// src/serializer/mysqlImports.ts
+var mysqlImports_exports = {};
+__export(mysqlImports_exports, {
+  prepareFromMySqlImports: () => prepareFromMySqlImports
+});
+var import_drizzle_orm_mysql, prepareFromMySqlImports;
+var init_mysqlImports = __esm({
+  "src/serializer/mysqlImports.ts"() {
+    import_drizzle_orm_mysql = require("drizzle-orm-mysql");
+    prepareFromMySqlImports = (imports) => {
+      const tables = [];
+      const enums = [];
+      imports.forEach((it) => {
+        const i0 = require(it);
+        const i0values = Object.values(i0);
+        i0values.forEach((t) => {
+          if (t instanceof import_drizzle_orm_mysql.MySqlTable) {
+            tables.push(
+              t
+            );
+          }
+        });
+      });
+      return { tables, enums };
+    };
+  }
+});
+
+// src/serializer/mysqlSerializer.ts
+var mysqlSerializer_exports = {};
+__export(mysqlSerializer_exports, {
+  generateMySqlSnapshot: () => generateMySqlSnapshot
+});
+var import_drizzle_orm_mysql2, import_table2, import_utils2, import_sql2, import_common, dialect5, generateMySqlSnapshot;
+var init_mysqlSerializer = __esm({
+  "src/serializer/mysqlSerializer.ts"() {
+    import_drizzle_orm_mysql2 = require("drizzle-orm-mysql");
+    import_table2 = require("drizzle-orm/table");
+    import_utils2 = require("drizzle-orm-mysql/utils");
+    import_sql2 = require("drizzle-orm/sql");
+    import_common = require("drizzle-orm-mysql/columns/common");
+    dialect5 = new import_drizzle_orm_mysql2.MySqlDialect();
+    generateMySqlSnapshot = (tables, enums) => {
+      const result = {};
+      for (const table4 of tables) {
+        const tableName = (0, import_table2.getTableName)(table4);
+        const columnsObject = {};
+        const indexesObject = {};
+        const foreignKeysObject = {};
+        (0, import_utils2.getTableColumns)(table4).forEach((column4) => {
+          const notNull = column4.notNull;
+          const primaryKey = column4.primary;
+          const columnToSet = {
+            name: column4.name,
+            type: column4.getSQLType(),
+            primaryKey,
+            notNull,
+            autoincrement: column4 instanceof import_common.MySqlColumnWithAutoIncrement ? column4.autoIncrement : false
+          };
+          if (column4.default !== void 0) {
+            if (column4.default instanceof import_sql2.SQL) {
+              columnToSet.default = column4.default.queryChunks.map((it) => {
+                if (typeof it === "string") {
+                  return `${it}`;
+                }
+                throw new Error();
+              }).join();
+            } else {
+              columnToSet.default = typeof column4.default === "string" ? `'${column4.default}'` : column4.default;
+            }
+            if (["blob", "text", "json"].includes(column4.getSQLType())) {
+              columnToSet.default = `(${columnToSet.default})`;
+            }
+          }
+          columnsObject[column4.name] = columnToSet;
+        });
+        const foreignKeys = (0, import_utils2.getTableForeignKeys)(table4).map((fk4) => {
+          const name = fk4.getName();
+          const tableFrom = tableName;
+          const onDelete = fk4.onDelete;
+          const onUpdate = fk4.onUpdate;
+          const reference = fk4.reference();
+          const referenceFT = reference.foreignTable;
+          const tableTo = (0, import_table2.getTableName)(referenceFT);
+          const columnsFrom = reference.columns.map((it) => it.name);
+          const columnsTo = reference.foreignColumns.map((it) => it.name);
+          return {
+            name,
+            tableFrom,
+            tableTo,
+            columnsFrom,
+            columnsTo,
+            onDelete,
+            onUpdate
+          };
+        });
+        foreignKeys.forEach((it) => {
+          foreignKeysObject[it.name] = it;
+        });
+        (0, import_utils2.getTableIndexes)(table4).forEach((value) => {
+          var _a;
+          const columns = value.config.columns;
+          const name = value.config.name;
+          let indexColumns = columns.map((it) => {
+            if (it instanceof import_sql2.SQL) {
+              return dialect5.sqlToQuery(it).sql;
+            } else {
+              return it.name;
+            }
+          });
+          indexesObject[name] = {
+            name,
+            columns: indexColumns,
+            isUnique: (_a = value.config.unique) != null ? _a : false,
+            using: value.config.using,
+            algorithm: value.config.algorythm,
+            lock: value.config.lock
+          };
+        });
+        result[tableName] = {
+          name: tableName,
+          columns: columnsObject,
+          indexes: indexesObject,
+          foreignKeys: foreignKeysObject
+        };
+      }
+      return { version: "3", dialect: "mysql", tables: result, enums: {} };
+    };
+  }
+});
+
 // src/serializer/sqliteImports.ts
 var sqliteImports_exports = {};
 __export(sqliteImports_exports, {
@@ -7508,22 +7653,22 @@ var sqliteSerializer_exports = {};
 __export(sqliteSerializer_exports, {
   generateSqliteSnapshot: () => generateSqliteSnapshot
 });
-var import_table2, import_sql2, import_drizzle_orm_sqlite2, import_utils2, dialect5, generateSqliteSnapshot;
+var import_table3, import_sql3, import_drizzle_orm_sqlite2, import_utils3, dialect6, generateSqliteSnapshot;
 var init_sqliteSerializer = __esm({
   "src/serializer/sqliteSerializer.ts"() {
-    import_table2 = require("drizzle-orm/table");
-    import_sql2 = require("drizzle-orm/sql");
+    import_table3 = require("drizzle-orm/table");
+    import_sql3 = require("drizzle-orm/sql");
     import_drizzle_orm_sqlite2 = require("drizzle-orm-sqlite");
-    import_utils2 = require("drizzle-orm-sqlite/utils");
-    dialect5 = new import_drizzle_orm_sqlite2.SQLiteSyncDialect();
+    import_utils3 = require("drizzle-orm-sqlite/utils");
+    dialect6 = new import_drizzle_orm_sqlite2.SQLiteSyncDialect();
     generateSqliteSnapshot = (tables, enums) => {
       const result = {};
       for (const table4 of tables) {
-        const tableName = (0, import_table2.getTableName)(table4);
+        const tableName = (0, import_table3.getTableName)(table4);
         const columnsObject = {};
         const indexesObject = {};
         const foreignKeysObject = {};
-        (0, import_utils2.getTableColumns)(table4).forEach((column4) => {
+        (0, import_utils3.getTableColumns)(table4).forEach((column4) => {
           const notNull = column4.notNull;
           const primaryKey = column4.primary;
           const columnToSet = {
@@ -7533,7 +7678,7 @@ var init_sqliteSerializer = __esm({
             notNull
           };
           if (column4.default !== void 0) {
-            if (column4.default instanceof import_sql2.SQL) {
+            if (column4.default instanceof import_sql3.SQL) {
               columnToSet.default = column4.default.queryChunks.map((it) => {
                 if (typeof it === "string") {
                   return `${it}`;
@@ -7549,14 +7694,14 @@ var init_sqliteSerializer = __esm({
           }
           columnsObject[column4.name] = columnToSet;
         });
-        const foreignKeys = (0, import_utils2.getTableForeignKeys)(table4).map((fk4) => {
+        const foreignKeys = (0, import_utils3.getTableForeignKeys)(table4).map((fk4) => {
           const name = fk4.getName();
           const tableFrom = tableName;
           const onDelete = fk4.onDelete;
           const onUpdate = fk4.onUpdate;
           const reference = fk4.reference();
           const referenceFT = reference.foreignTable;
-          const tableTo = (0, import_table2.getTableName)(referenceFT);
+          const tableTo = (0, import_table3.getTableName)(referenceFT);
           const columnsFrom = reference.columns.map((it) => it.name);
           const columnsTo = reference.foreignColumns.map((it) => it.name);
           return {
@@ -7572,21 +7717,21 @@ var init_sqliteSerializer = __esm({
         foreignKeys.forEach((it) => {
           foreignKeysObject[it.name] = it;
         });
-        (0, import_utils2.getTableIndexes)(table4).forEach((value) => {
+        (0, import_utils3.getTableIndexes)(table4).forEach((value) => {
           var _a;
           const columns = value.config.columns;
           const name = value.config.name;
           let indexColumns = columns.map((it) => {
-            if (it instanceof import_sql2.SQL) {
-              return dialect5.sqlToQuery(it).sql;
+            if (it instanceof import_sql3.SQL) {
+              return dialect6.sqlToQuery(it).sql;
             } else {
               return it.name;
             }
           });
           let where = void 0;
           if (value.config.where !== void 0) {
-            if (value.config.where instanceof import_sql2.SQL) {
-              where = dialect5.sqlToQuery(value.config.where).sql;
+            if (value.config.where instanceof import_sql3.SQL) {
+              where = dialect6.sqlToQuery(value.config.where).sql;
             }
           }
           indexesObject[name] = {
@@ -14188,7 +14333,7 @@ var import_fs3 = __toESM(require("fs"));
 // src/migrationPreparator.ts
 var import_fs2 = __toESM(require("fs"));
 
-// node_modules/.pnpm/zod@3.19.1/node_modules/zod/lib/index.mjs
+// node_modules/.pnpm/zod@3.20.2/node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
@@ -14284,6 +14429,8 @@ var getParsedType = (data) => {
       return ZodParsedType.function;
     case "bigint":
       return ZodParsedType.bigint;
+    case "symbol":
+      return ZodParsedType.symbol;
     case "object":
       if (Array.isArray(data)) {
         return ZodParsedType.array;
@@ -14323,7 +14470,8 @@ var ZodIssueCode = util.arrayToEnum([
   "too_small",
   "too_big",
   "invalid_intersection_types",
-  "not_multiple_of"
+  "not_multiple_of",
+  "not_finite"
 ]);
 var ZodError = class extends Error {
   constructor(issues) {
@@ -14464,25 +14612,25 @@ var errorMap = (issue, _ctx) => {
       break;
     case ZodIssueCode.too_small:
       if (issue.type === "array")
-        message = `Array must contain ${issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+        message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
       else if (issue.type === "string")
-        message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+        message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
       else if (issue.type === "number")
-        message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
+        message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
       else if (issue.type === "date")
-        message = `Date must be greater than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.minimum)}`;
+        message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(issue.minimum)}`;
       else
         message = "Invalid input";
       break;
     case ZodIssueCode.too_big:
       if (issue.type === "array")
-        message = `Array must contain ${issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+        message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
       else if (issue.type === "string")
-        message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+        message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
       else if (issue.type === "number")
-        message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
+        message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
       else if (issue.type === "date")
-        message = `Date must be smaller than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.maximum)}`;
+        message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(issue.maximum)}`;
       else
         message = "Invalid input";
       break;
@@ -14495,6 +14643,9 @@ var errorMap = (issue, _ctx) => {
     case ZodIssueCode.not_multiple_of:
       message = `Number must be a multiple of ${issue.multipleOf}`;
       break;
+    case ZodIssueCode.not_finite:
+      message = "Number must be finite";
+      break;
     default:
       message = _ctx.defaultError;
       util.assertNever(issue);
@@ -14592,6 +14743,7 @@ var ParseStatus = class {
 var INVALID = Object.freeze({
   status: "aborted"
 });
+var DIRTY = (value) => ({ status: "dirty", value });
 var OK = (value) => ({ status: "valid", value });
 var isAborted = (x) => x.status === "aborted";
 var isDirty = (x) => x.status === "dirty";
@@ -14646,7 +14798,6 @@ function processCreateParams(params) {
 var ZodType = class {
   constructor(def) {
     this.spa = this.safeParseAsync;
-    this.superRefine = this._refinement;
     this._def = def;
     this.parse = this.parse.bind(this);
     this.safeParse = this.safeParse.bind(this);
@@ -14664,8 +14815,11 @@ var ZodType = class {
     this.or = this.or.bind(this);
     this.and = this.and.bind(this);
     this.transform = this.transform.bind(this);
+    this.brand = this.brand.bind(this);
     this.default = this.default.bind(this);
+    this.catch = this.catch.bind(this);
     this.describe = this.describe.bind(this);
+    this.pipe = this.pipe.bind(this);
     this.isNullable = this.isNullable.bind(this);
     this.isOptional = this.isOptional.bind(this);
   }
@@ -14751,7 +14905,7 @@ var ZodType = class {
       data,
       parsedType: getParsedType(data)
     };
-    const maybeAsyncResult = this._parse({ data, path: [], parent: ctx });
+    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
     const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
     return handleResult(ctx, result);
   }
@@ -14806,6 +14960,9 @@ var ZodType = class {
       effect: { type: "refinement", refinement }
     });
   }
+  superRefine(refinement) {
+    return this._refinement(refinement);
+  }
   optional() {
     return ZodOptional.create(this);
   }
@@ -14849,6 +15006,14 @@ var ZodType = class {
       ...processCreateParams(void 0)
     });
   }
+  catch(def) {
+    const defaultValueFunc = typeof def === "function" ? def : () => def;
+    return new ZodCatch({
+      innerType: this,
+      defaultValue: defaultValueFunc,
+      typeName: ZodFirstPartyTypeKind.ZodCatch
+    });
+  }
   describe(description) {
     const This = this.constructor;
     return new This({
@@ -14856,6 +15021,9 @@ var ZodType = class {
       description
     });
   }
+  pipe(target) {
+    return ZodPipeline.create(this, target);
+  }
   isOptional() {
     return this.safeParse(void 0).success;
   }
@@ -14866,6 +15034,27 @@ var ZodType = class {
 var cuidRegex = /^c[^\s-]{8,}$/i;
 var uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
 var emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+var datetimeRegex = (args) => {
+  if (args.precision) {
+    if (args.offset) {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}:\\d{2})|Z)$`);
+    } else {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}Z$`);
+    }
+  } else if (args.precision === 0) {
+    if (args.offset) {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}:\\d{2})|Z)$`);
+    } else {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$`);
+    }
+  } else {
+    if (args.offset) {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}:\\d{2})|Z)$`);
+    } else {
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`);
+    }
+  }
+};
 var ZodString = class extends ZodType {
   constructor() {
     super(...arguments);
@@ -14881,6 +15070,9 @@ var ZodString = class extends ZodType {
     });
   }
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = String(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.string) {
       const ctx2 = this._getOrReturnCtx(input);
@@ -14905,6 +15097,7 @@ var ZodString = class extends ZodType {
             minimum: check.value,
             type: "string",
             inclusive: true,
+            exact: false,
             message: check.message
           });
           status.dirty();
@@ -14917,10 +15110,37 @@ var ZodString = class extends ZodType {
             maximum: check.value,
             type: "string",
             inclusive: true,
+            exact: false,
             message: check.message
           });
           status.dirty();
         }
+      } else if (check.kind === "length") {
+        const tooBig = input.data.length > check.value;
+        const tooSmall = input.data.length < check.value;
+        if (tooBig || tooSmall) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          if (tooBig) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.too_big,
+              maximum: check.value,
+              type: "string",
+              inclusive: true,
+              exact: true,
+              message: check.message
+            });
+          } else if (tooSmall) {
+            addIssueToContext(ctx, {
+              code: ZodIssueCode.too_small,
+              minimum: check.value,
+              type: "string",
+              inclusive: true,
+              exact: true,
+              message: check.message
+            });
+          }
+          status.dirty();
+        }
       } else if (check.kind === "email") {
         if (!emailRegex.test(input.data)) {
           ctx = this._getOrReturnCtx(input, ctx);
@@ -14997,6 +15217,17 @@ var ZodString = class extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "datetime") {
+        const regex = datetimeRegex(check);
+        if (!regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_string,
+            validation: "datetime",
+            message: check.message
+          });
+          status.dirty();
+        }
       } else {
         util.assertNever(check);
       }
@@ -15021,6 +15252,23 @@ var ZodString = class extends ZodType {
   cuid(message) {
     return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
   }
+  datetime(options) {
+    var _a;
+    if (typeof options === "string") {
+      return this._addCheck({
+        kind: "datetime",
+        precision: null,
+        offset: false,
+        message: options
+      });
+    }
+    return this._addCheck({
+      kind: "datetime",
+      precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
+      offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
+      ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)
+    });
+  }
   regex(regex, message) {
     return this._addCheck({
       kind: "regex",
@@ -15057,7 +15305,14 @@ var ZodString = class extends ZodType {
     });
   }
   length(len, message) {
-    return this.min(len, message).max(len, message);
+    return this._addCheck({
+      kind: "length",
+      value: len,
+      ...errorUtil.errToObj(message)
+    });
+  }
+  get isDatetime() {
+    return !!this._def.checks.find((ch) => ch.kind === "datetime");
   }
   get isEmail() {
     return !!this._def.checks.find((ch) => ch.kind === "email");
@@ -15093,9 +15348,11 @@ var ZodString = class extends ZodType {
   }
 };
 ZodString.create = (params) => {
+  var _a;
   return new ZodString({
     checks: [],
     typeName: ZodFirstPartyTypeKind.ZodString,
+    coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
     ...processCreateParams(params)
   });
 };
@@ -15115,6 +15372,9 @@ var ZodNumber = class extends ZodType {
     this.step = this.multipleOf;
   }
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = Number(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.number) {
       const ctx2 = this._getOrReturnCtx(input);
@@ -15148,6 +15408,7 @@ var ZodNumber = class extends ZodType {
             minimum: check.value,
             type: "number",
             inclusive: check.inclusive,
+            exact: false,
             message: check.message
           });
           status.dirty();
@@ -15161,6 +15422,7 @@ var ZodNumber = class extends ZodType {
             maximum: check.value,
             type: "number",
             inclusive: check.inclusive,
+            exact: false,
             message: check.message
           });
           status.dirty();
@@ -15175,6 +15437,15 @@ var ZodNumber = class extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "finite") {
+        if (!Number.isFinite(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.not_finite,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else {
         util.assertNever(check);
       }
@@ -15258,6 +15529,12 @@ var ZodNumber = class extends ZodType {
       message: errorUtil.toString(message)
     });
   }
+  finite(message) {
+    return this._addCheck({
+      kind: "finite",
+      message: errorUtil.toString(message)
+    });
+  }
   get minValue() {
     let min = null;
     for (const ch of this._def.checks) {
@@ -15286,11 +15563,15 @@ ZodNumber.create = (params) => {
   return new ZodNumber({
     checks: [],
     typeName: ZodFirstPartyTypeKind.ZodNumber,
+    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
     ...processCreateParams(params)
   });
 };
 var ZodBigInt = class extends ZodType {
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = BigInt(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.bigint) {
       const ctx = this._getOrReturnCtx(input);
@@ -15305,13 +15586,18 @@ var ZodBigInt = class extends ZodType {
   }
 };
 ZodBigInt.create = (params) => {
+  var _a;
   return new ZodBigInt({
     typeName: ZodFirstPartyTypeKind.ZodBigInt,
+    coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
     ...processCreateParams(params)
   });
 };
 var ZodBoolean = class extends ZodType {
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = Boolean(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.boolean) {
       const ctx = this._getOrReturnCtx(input);
@@ -15328,11 +15614,15 @@ var ZodBoolean = class extends ZodType {
 ZodBoolean.create = (params) => {
   return new ZodBoolean({
     typeName: ZodFirstPartyTypeKind.ZodBoolean,
+    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
     ...processCreateParams(params)
   });
 };
 var ZodDate = class extends ZodType {
   _parse(input) {
+    if (this._def.coerce) {
+      input.data = new Date(input.data);
+    }
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.date) {
       const ctx2 = this._getOrReturnCtx(input);
@@ -15360,6 +15650,7 @@ var ZodDate = class extends ZodType {
             code: ZodIssueCode.too_small,
             message: check.message,
             inclusive: true,
+            exact: false,
             minimum: check.value,
             type: "date"
           });
@@ -15372,6 +15663,7 @@ var ZodDate = class extends ZodType {
             code: ZodIssueCode.too_big,
             message: check.message,
             inclusive: true,
+            exact: false,
             maximum: check.value,
             type: "date"
           });
@@ -15430,10 +15722,32 @@ var ZodDate = class extends ZodType {
 ZodDate.create = (params) => {
   return new ZodDate({
     checks: [],
+    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
     typeName: ZodFirstPartyTypeKind.ZodDate,
     ...processCreateParams(params)
   });
 };
+var ZodSymbol = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.symbol) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.symbol,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+};
+ZodSymbol.create = (params) => {
+  return new ZodSymbol({
+    typeName: ZodFirstPartyTypeKind.ZodSymbol,
+    ...processCreateParams(params)
+  });
+};
 var ZodUndefined = class extends ZodType {
   _parse(input) {
     const parsedType = this._getType(input);
@@ -15556,6 +15870,22 @@ var ZodArray = class extends ZodType {
       });
       return INVALID;
     }
+    if (def.exactLength !== null) {
+      const tooBig = ctx.data.length > def.exactLength.value;
+      const tooSmall = ctx.data.length < def.exactLength.value;
+      if (tooBig || tooSmall) {
+        addIssueToContext(ctx, {
+          code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
+          minimum: tooSmall ? def.exactLength.value : void 0,
+          maximum: tooBig ? def.exactLength.value : void 0,
+          type: "array",
+          inclusive: true,
+          exact: true,
+          message: def.exactLength.message
+        });
+        status.dirty();
+      }
+    }
     if (def.minLength !== null) {
       if (ctx.data.length < def.minLength.value) {
         addIssueToContext(ctx, {
@@ -15563,6 +15893,7 @@ var ZodArray = class extends ZodType {
           minimum: def.minLength.value,
           type: "array",
           inclusive: true,
+          exact: false,
           message: def.minLength.message
         });
         status.dirty();
@@ -15575,6 +15906,7 @@ var ZodArray = class extends ZodType {
           maximum: def.maxLength.value,
           type: "array",
           inclusive: true,
+          exact: false,
           message: def.maxLength.message
         });
         status.dirty();
@@ -15608,7 +15940,10 @@ var ZodArray = class extends ZodType {
     });
   }
   length(len, message) {
-    return this.min(len, message).max(len, message);
+    return new ZodArray({
+      ...this._def,
+      exactLength: { value: len, message: errorUtil.toString(message) }
+    });
   }
   nonempty(message) {
     return this.min(1, message);
@@ -15619,6 +15954,7 @@ ZodArray.create = (schema5, params) => {
     type: schema5,
     minLength: null,
     maxLength: null,
+    exactLength: null,
     typeName: ZodFirstPartyTypeKind.ZodArray,
     ...processCreateParams(params)
   });
@@ -15868,15 +16204,30 @@ var ZodObject = class extends ZodType {
       shape: () => newShape
     });
   }
-  required() {
+  required(mask) {
     const newShape = {};
-    for (const key in this.shape) {
-      const fieldSchema = this.shape[key];
-      let newField = fieldSchema;
-      while (newField instanceof ZodOptional) {
-        newField = newField._def.innerType;
+    if (mask) {
+      util.objectKeys(this.shape).map((key) => {
+        if (util.objectKeys(mask).indexOf(key) === -1) {
+          newShape[key] = this.shape[key];
+        } else {
+          const fieldSchema = this.shape[key];
+          let newField = fieldSchema;
+          while (newField instanceof ZodOptional) {
+            newField = newField._def.innerType;
+          }
+          newShape[key] = newField;
+        }
+      });
+    } else {
+      for (const key in this.shape) {
+        const fieldSchema = this.shape[key];
+        let newField = fieldSchema;
+        while (newField instanceof ZodOptional) {
+          newField = newField._def.innerType;
+        }
+        newShape[key] = newField;
       }
-      newShape[key] = newField;
     }
     return new ZodObject({
       ...this._def,
@@ -16005,6 +16356,27 @@ ZodUnion.create = (types, params) => {
     ...processCreateParams(params)
   });
 };
+var getDiscriminator = (type) => {
+  if (type instanceof ZodLazy) {
+    return getDiscriminator(type.schema);
+  } else if (type instanceof ZodEffects) {
+    return getDiscriminator(type.innerType());
+  } else if (type instanceof ZodLiteral) {
+    return [type.value];
+  } else if (type instanceof ZodEnum) {
+    return type.options;
+  } else if (type instanceof ZodNativeEnum) {
+    return Object.keys(type.enum);
+  } else if (type instanceof ZodDefault) {
+    return getDiscriminator(type._def.innerType);
+  } else if (type instanceof ZodUndefined) {
+    return [void 0];
+  } else if (type instanceof ZodNull) {
+    return [null];
+  } else {
+    return null;
+  }
+};
 var ZodDiscriminatedUnion = class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
@@ -16018,11 +16390,11 @@ var ZodDiscriminatedUnion = class extends ZodType {
     }
     const discriminator = this.discriminator;
     const discriminatorValue = ctx.data[discriminator];
-    const option = this.options.get(discriminatorValue);
+    const option = this.optionsMap.get(discriminatorValue);
     if (!option) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union_discriminator,
-        options: this.validDiscriminatorValues,
+        options: Array.from(this.optionsMap.keys()),
         path: [discriminator]
       });
       return INVALID;
@@ -16044,29 +16416,31 @@ var ZodDiscriminatedUnion = class extends ZodType {
   get discriminator() {
     return this._def.discriminator;
   }
-  get validDiscriminatorValues() {
-    return Array.from(this.options.keys());
-  }
   get options() {
     return this._def.options;
   }
-  static create(discriminator, types, params) {
-    const options = /* @__PURE__ */ new Map();
-    try {
-      types.forEach((type) => {
-        const discriminatorValue = type.shape[discriminator].value;
-        options.set(discriminatorValue, type);
-      });
-    } catch (e) {
-      throw new Error("The discriminator value could not be extracted from all the provided schemas");
-    }
-    if (options.size !== types.length) {
-      throw new Error("Some of the discriminator values are not unique");
+  get optionsMap() {
+    return this._def.optionsMap;
+  }
+  static create(discriminator, options, params) {
+    const optionsMap = /* @__PURE__ */ new Map();
+    for (const type of options) {
+      const discriminatorValues = getDiscriminator(type.shape[discriminator]);
+      if (!discriminatorValues) {
+        throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
+      }
+      for (const value of discriminatorValues) {
+        if (optionsMap.has(value)) {
+          throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
+        }
+        optionsMap.set(value, type);
+      }
     }
     return new ZodDiscriminatedUnion({
       typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
       discriminator,
       options,
+      optionsMap,
       ...processCreateParams(params)
     });
   }
@@ -16178,6 +16552,7 @@ var ZodTuple = class extends ZodType {
         code: ZodIssueCode.too_small,
         minimum: this._def.items.length,
         inclusive: true,
+        exact: false,
         type: "array"
       });
       return INVALID;
@@ -16188,6 +16563,7 @@ var ZodTuple = class extends ZodType {
         code: ZodIssueCode.too_big,
         maximum: this._def.items.length,
         inclusive: true,
+        exact: false,
         type: "array"
       });
       status.dirty();
@@ -16358,6 +16734,7 @@ var ZodSet = class extends ZodType {
           minimum: def.minSize.value,
           type: "set",
           inclusive: true,
+          exact: false,
           message: def.minSize.message
         });
         status.dirty();
@@ -16370,6 +16747,7 @@ var ZodSet = class extends ZodType {
           maximum: def.maxSize.value,
           type: "set",
           inclusive: true,
+          exact: false,
           message: def.maxSize.message
         });
         status.dirty();
@@ -16698,6 +17076,9 @@ var ZodEffects = class extends ZodType {
   innerType() {
     return this._def.schema;
   }
+  sourceType() {
+    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
     const effect = this._def.effect || null;
@@ -16865,9 +17246,44 @@ var ZodDefault = class extends ZodType {
   }
 };
 ZodDefault.create = (type, params) => {
-  return new ZodOptional({
+  return new ZodDefault({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodOptional,
+    typeName: ZodFirstPartyTypeKind.ZodDefault,
+    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+    ...processCreateParams(params)
+  });
+};
+var ZodCatch = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const result = this._def.innerType._parse({
+      data: ctx.data,
+      path: ctx.path,
+      parent: ctx
+    });
+    if (isAsync(result)) {
+      return result.then((result2) => {
+        return {
+          status: "valid",
+          value: result2.status === "valid" ? result2.value : this._def.defaultValue()
+        };
+      });
+    } else {
+      return {
+        status: "valid",
+        value: result.status === "valid" ? result.value : this._def.defaultValue()
+      };
+    }
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+};
+ZodCatch.create = (type, params) => {
+  return new ZodCatch({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodCatch,
+    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
     ...processCreateParams(params)
   });
 };
@@ -16907,6 +17323,61 @@ var ZodBranded = class extends ZodType {
     return this._def.type;
   }
 };
+var ZodPipeline = class extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.common.async) {
+      const handleAsync = async () => {
+        const inResult = await this._def.in._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inResult.status === "aborted")
+          return INVALID;
+        if (inResult.status === "dirty") {
+          status.dirty();
+          return DIRTY(inResult.value);
+        } else {
+          return this._def.out._parseAsync({
+            data: inResult.value,
+            path: ctx.path,
+            parent: ctx
+          });
+        }
+      };
+      return handleAsync();
+    } else {
+      const inResult = this._def.in._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      });
+      if (inResult.status === "aborted")
+        return INVALID;
+      if (inResult.status === "dirty") {
+        status.dirty();
+        return {
+          status: "dirty",
+          value: inResult.value
+        };
+      } else {
+        return this._def.out._parseSync({
+          data: inResult.value,
+          path: ctx.path,
+          parent: ctx
+        });
+      }
+    }
+  }
+  static create(a, b) {
+    return new ZodPipeline({
+      in: a,
+      out: b,
+      typeName: ZodFirstPartyTypeKind.ZodPipeline
+    });
+  }
+};
 var late = {
   object: ZodObject.lazycreate
 };
@@ -16918,6 +17389,7 @@ var ZodFirstPartyTypeKind;
   ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
   ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
   ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
   ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
   ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
   ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
@@ -16942,8 +17414,10 @@ var ZodFirstPartyTypeKind;
   ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
   ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
   ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
   ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
   ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
 var stringType = ZodString.create;
 var numberType = ZodNumber.create;
@@ -16951,6 +17425,7 @@ var nanType = ZodNaN.create;
 var bigIntType = ZodBigInt.create;
 var booleanType = ZodBoolean.create;
 var dateType = ZodDate.create;
+var symbolType = ZodSymbol.create;
 var undefinedType = ZodUndefined.create;
 var nullType = ZodNull.create;
 var anyType = ZodAny.create;
@@ -16977,6 +17452,7 @@ var effectsType = ZodEffects.create;
 var optionalType = ZodOptional.create;
 var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
+var pipelineType = ZodPipeline.create;
 
 // src/serializer/mysqlSchema.ts
 var index = objectType({
@@ -17335,23 +17811,26 @@ var import_crypto = require("crypto");
 var import_fs = __toESM(require("fs"));
 var import_node = __toESM(require_node2());
 var import_path = __toESM(require("path"));
-var serialize = (path3, dialect6) => {
+var serialize = (path3, dialect7) => {
   const fileName = import_fs.default.lstatSync(path3).isDirectory() ? null : import_path.default.resolve(path3);
   const filenames = fileName ? [fileName] : import_fs.default.readdirSync(path3).map((it) => import_path.default.join(import_path.default.resolve(path3), it));
   const { unregister } = (0, import_node.register)({
     target: "node14",
     loader: "ts"
   });
-  if (dialect6 === "pg") {
+  if (dialect7 === "pg") {
     const { prepareFromPgImports: prepareFromPgImports2 } = (init_pgImports(), __toCommonJS(pgImports_exports));
     const { generatePgSnapshot: generatePgSnapshot2 } = (init_pgSerializer(), __toCommonJS(pgSerializer_exports));
     const { tables, enums } = prepareFromPgImports2(filenames);
     unregister();
     return generatePgSnapshot2(tables, enums);
-  } else if (dialect6 === "mysql") {
+  } else if (dialect7 === "mysql") {
+    const { prepareFromMySqlImports: prepareFromMySqlImports2 } = (init_mysqlImports(), __toCommonJS(mysqlImports_exports));
+    const { generateMySqlSnapshot: generateMySqlSnapshot2 } = (init_mysqlSerializer(), __toCommonJS(mysqlSerializer_exports));
+    const { tables, enums } = prepareFromMySqlImports2(filenames);
     unregister();
-    return {};
-  } else if (dialect6 === "sqlite") {
+    return generateMySqlSnapshot2(tables, enums);
+  } else if (dialect7 === "sqlite") {
     const { prepareFromSqliteImports: prepareFromSqliteImports2 } = (init_sqliteImports(), __toCommonJS(sqliteImports_exports));
     const { generateSqliteSnapshot: generateSqliteSnapshot2 } = (init_sqliteSerializer(), __toCommonJS(sqliteSerializer_exports));
     const { tables, enums } = prepareFromSqliteImports2(filenames);
@@ -17368,8 +17847,8 @@ var serializer_default = serialize;
 var Convertor = class {
 };
 var PgCreateTableConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "create_table" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "create_table" && dialect7 === "pg";
   }
   convert(st) {
     const { tableName, columns } = st;
@@ -17391,8 +17870,8 @@ var PgCreateTableConvertor = class extends Convertor {
   }
 };
 var MySqlCreateTableConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "create_table" && dialect6 === "mysql";
+  can(statement, dialect7) {
+    return statement.type === "create_table" && dialect7 === "mysql";
   }
   convert(st) {
     const { tableName, columns } = st;
@@ -17415,8 +17894,8 @@ var MySqlCreateTableConvertor = class extends Convertor {
   }
 };
 var SQLiteCreateTableConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "sqlite_create_table" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "sqlite_create_table" && dialect7 === "sqlite";
   }
   convert(st) {
     const { tableName, columns, referenceData } = st;
@@ -17497,8 +17976,8 @@ var DropTableConvertor = class extends Convertor {
   }
 };
 var PgRenameTableConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "rename_table" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "rename_table" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableNameFrom, tableNameTo } = statement;
@@ -17506,8 +17985,8 @@ var PgRenameTableConvertor = class extends Convertor {
   }
 };
 var SqliteRenameTableConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "rename_table" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "rename_table" && dialect7 === "sqlite";
   }
   convert(statement) {
     const { tableNameFrom, tableNameTo } = statement;
@@ -17515,8 +17994,8 @@ var SqliteRenameTableConvertor = class extends Convertor {
   }
 };
 var MySqlRenameTableConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "rename_table" && dialect6 === "mysql";
+  can(statement, dialect7) {
+    return statement.type === "rename_table" && dialect7 === "mysql";
   }
   convert(statement) {
     const { tableNameFrom, tableNameTo } = statement;
@@ -17524,8 +18003,8 @@ var MySqlRenameTableConvertor = class extends Convertor {
   }
 };
 var PgAlterTableRenameColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_rename_column" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_rename_column" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableName, oldColumnName, newColumnName } = statement;
@@ -17533,8 +18012,8 @@ var PgAlterTableRenameColumnConvertor = class extends Convertor {
   }
 };
 var MySqlAlterTableRenameColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_rename_column" && dialect6 === "mysql";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_rename_column" && dialect7 === "mysql";
   }
   convert(statement) {
     const { tableName, oldColumnName, newColumnName } = statement;
@@ -17542,8 +18021,8 @@ var MySqlAlterTableRenameColumnConvertor = class extends Convertor {
   }
 };
 var SQLiteAlterTableRenameColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_rename_column" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_rename_column" && dialect7 === "sqlite";
   }
   convert(statement) {
     const { tableName, oldColumnName, newColumnName } = statement;
@@ -17551,8 +18030,8 @@ var SQLiteAlterTableRenameColumnConvertor = class extends Convertor {
   }
 };
 var PgAlterTableDropColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_drop_column" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_drop_column" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableName, columnName } = statement;
@@ -17560,8 +18039,8 @@ var PgAlterTableDropColumnConvertor = class extends Convertor {
   }
 };
 var MySqlAlterTableDropColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_drop_column" && dialect6 === "mysql";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_drop_column" && dialect7 === "mysql";
   }
   convert(statement) {
     const { tableName, columnName } = statement;
@@ -17569,8 +18048,8 @@ var MySqlAlterTableDropColumnConvertor = class extends Convertor {
   }
 };
 var SQLiteAlterTableDropColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_drop_column" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_drop_column" && dialect7 === "sqlite";
   }
   convert(statement) {
     const { tableName, columnName } = statement;
@@ -17578,8 +18057,8 @@ var SQLiteAlterTableDropColumnConvertor = class extends Convertor {
   }
 };
 var PgAlterTableAddColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_add_column" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_add_column" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableName, column: column4 } = statement;
@@ -17590,8 +18069,8 @@ var PgAlterTableAddColumnConvertor = class extends Convertor {
   }
 };
 var MySqlAlterTableAddColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_add_column" && dialect6 === "mysql";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_add_column" && dialect7 === "mysql";
   }
   convert(statement) {
     const { tableName, column: column4 } = statement;
@@ -17604,8 +18083,8 @@ var MySqlAlterTableAddColumnConvertor = class extends Convertor {
   }
 };
 var SQLiteAlterTableAddColumnConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "sqlite_alter_table_add_column" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "sqlite_alter_table_add_column" && dialect7 === "sqlite";
   }
   convert(statement) {
     const { tableName, column: column4, referenceData } = statement;
@@ -17619,8 +18098,8 @@ var SQLiteAlterTableAddColumnConvertor = class extends Convertor {
   }
 };
 var PgAlterTableAlterColumnSetTypeConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_set_type" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_set_type" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableName, columnName, newDataType } = statement;
@@ -17628,8 +18107,8 @@ var PgAlterTableAlterColumnSetTypeConvertor = class extends Convertor {
   }
 };
 var SQLiteAlterTableAlterColumnSetTypeConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_set_type" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_set_type" && dialect7 === "sqlite";
   }
   convert(statement) {
     return `/*
@@ -17643,8 +18122,8 @@ var SQLiteAlterTableAlterColumnSetTypeConvertor = class extends Convertor {
   }
 };
 var PgAlterTableAlterColumnSetDefaultConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_set_default" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_set_default" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableName, columnName } = statement;
@@ -17652,8 +18131,8 @@ var PgAlterTableAlterColumnSetDefaultConvertor = class extends Convertor {
   }
 };
 var SqliteAlterTableAlterColumnSetDefaultConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_set_default" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_set_default" && dialect7 === "sqlite";
   }
   convert(statement) {
     return `/*
@@ -17667,8 +18146,8 @@ var SqliteAlterTableAlterColumnSetDefaultConvertor = class extends Convertor {
   }
 };
 var PgAlterTableAlterColumnDropDefaultConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_drop_default" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_drop_default" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableName, columnName } = statement;
@@ -17676,8 +18155,8 @@ var PgAlterTableAlterColumnDropDefaultConvertor = class extends Convertor {
   }
 };
 var SqliteAlterTableAlterColumnDropDefaultConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_drop_default" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_drop_default" && dialect7 === "sqlite";
   }
   convert(statement) {
     return `/*
@@ -17691,8 +18170,8 @@ var SqliteAlterTableAlterColumnDropDefaultConvertor = class extends Convertor {
   }
 };
 var PgAlterTableAlterColumnSetNotNullConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_set_notnull" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_set_notnull" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableName, columnName } = statement;
@@ -17700,8 +18179,8 @@ var PgAlterTableAlterColumnSetNotNullConvertor = class extends Convertor {
   }
 };
 var SqliteAlterTableAlterColumnSetNotNullConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_set_notnull" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_set_notnull" && dialect7 === "sqlite";
   }
   convert(statement) {
     return `/*
@@ -17715,8 +18194,8 @@ var SqliteAlterTableAlterColumnSetNotNullConvertor = class extends Convertor {
   }
 };
 var PgAlterTableAlterColumnDropNotNullConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_drop_notnull" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_drop_notnull" && dialect7 === "pg";
   }
   convert(statement) {
     const { tableName, columnName } = statement;
@@ -17724,8 +18203,8 @@ var PgAlterTableAlterColumnDropNotNullConvertor = class extends Convertor {
   }
 };
 var SqliteAlterTableAlterColumnDropNotNullConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_table_alter_column_drop_notnull" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "alter_table_alter_column_drop_notnull" && dialect7 === "sqlite";
   }
   convert(statement) {
     return `/*
@@ -17739,8 +18218,8 @@ var SqliteAlterTableAlterColumnDropNotNullConvertor = class extends Convertor {
   }
 };
 var PgCreateForeignKeyConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "create_reference" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "create_reference" && dialect7 === "pg";
   }
   convert(statement) {
     const {
@@ -17766,8 +18245,8 @@ var PgCreateForeignKeyConvertor = class extends Convertor {
   }
 };
 var SqliteCreateForeignKeyConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "create_reference" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "create_reference" && dialect7 === "sqlite";
   }
   convert(statement) {
     return `/*
@@ -17780,8 +18259,8 @@ var SqliteCreateForeignKeyConvertor = class extends Convertor {
   }
 };
 var MySqlCreateForeignKeyConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "create_reference" && dialect6 === "mysql";
+  can(statement, dialect7) {
+    return statement.type === "create_reference" && dialect7 === "mysql";
   }
   convert(statement) {
     const {
@@ -17809,8 +18288,8 @@ var AlterForeignKeyConvertor = class extends Convertor {
   }
 };
 var SqliteAlterForeignKeyConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "alter_reference" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "alter_reference" && dialect7 === "sqlite";
   }
   convert(statement) {
     return `/*
@@ -17823,8 +18302,8 @@ var SqliteAlterForeignKeyConvertor = class extends Convertor {
   }
 };
 var PgDeleteForeignKeyConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "delete_reference" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "delete_reference" && dialect7 === "pg";
   }
   convert(statement) {
     const tableFrom = statement.tableName;
@@ -17834,8 +18313,8 @@ var PgDeleteForeignKeyConvertor = class extends Convertor {
   }
 };
 var SqliteDeleteForeignKeyConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "delete_reference" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "delete_reference" && dialect7 === "sqlite";
   }
   convert(statement) {
     return `/*
@@ -17848,8 +18327,8 @@ var SqliteDeleteForeignKeyConvertor = class extends Convertor {
   }
 };
 var MySqlDeleteForeignKeyConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "delete_reference" && dialect6 === "mysql";
+  can(statement, dialect7) {
+    return statement.type === "delete_reference" && dialect7 === "mysql";
   }
   convert(statement) {
     const tableFrom = statement.tableName;
@@ -17859,8 +18338,8 @@ var MySqlDeleteForeignKeyConvertor = class extends Convertor {
   }
 };
 var CreatePgIndexConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "create_index" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "create_index" && dialect7 === "pg";
   }
   convert(statement) {
     const { name, columns, isUnique } = PgSquasher.unsquashIdx(statement.data);
@@ -17870,8 +18349,8 @@ var CreatePgIndexConvertor = class extends Convertor {
   }
 };
 var CreateMySqlIndexConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "create_index" && dialect6 === "mysql";
+  can(statement, dialect7) {
+    return statement.type === "create_index" && dialect7 === "mysql";
   }
   convert(statement) {
     const { name, columns, isUnique } = PgSquasher.unsquashIdx(statement.data);
@@ -17881,8 +18360,8 @@ var CreateMySqlIndexConvertor = class extends Convertor {
   }
 };
 var CreateSqliteIndexConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "create_index" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "create_index" && dialect7 === "sqlite";
   }
   convert(statement) {
     const { name, columns, isUnique, where } = SQLiteSquasher.unsquashIdx(
@@ -17895,8 +18374,8 @@ var CreateSqliteIndexConvertor = class extends Convertor {
   }
 };
 var PgDropIndexConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "drop_index" && dialect6 === "pg";
+  can(statement, dialect7) {
+    return statement.type === "drop_index" && dialect7 === "pg";
   }
   convert(statement) {
     const { name } = PgSquasher.unsquashIdx(statement.data);
@@ -17904,8 +18383,8 @@ var PgDropIndexConvertor = class extends Convertor {
   }
 };
 var SqliteDropIndexConvertor = class extends Convertor {
-  can(statement, dialect6) {
-    return statement.type === "drop_index" && dialect6 === "sqlite";
+  can(statement, dialect7) {
+    return statement.type === "drop_index" && dialect7 === "sqlite";
   }
   convert(statement) {
     const { name } = PgSquasher.unsquashIdx(statement.data);
@@ -17954,10 +18433,10 @@ convertors.push(new SqliteAlterTableAlterColumnSetNotNullConvertor());
 convertors.push(new SqliteAlterTableAlterColumnDropNotNullConvertor());
 convertors.push(new SqliteAlterTableAlterColumnSetDefaultConvertor());
 convertors.push(new SqliteAlterTableAlterColumnDropDefaultConvertor());
-var fromJson = (statements, dialect6) => {
+var fromJson = (statements, dialect7) => {
   const result = statements.map((statement) => {
     const filtered = convertors.filter((it) => {
-      return it.can(statement, dialect6);
+      return it.can(statement, dialect7);
     });
     const convertor = filtered.length === 1 ? filtered[0] : void 0;
     if (!convertor) {
@@ -18197,11 +18676,11 @@ var prepareRenameColumns = (tableName, pairs) => {
     };
   });
 };
-var prepareAlterTableColumnsJson = (tableName, deleted, added, altered, addedFk, dialect6) => {
+var prepareAlterTableColumnsJson = (tableName, deleted, added, altered, addedFk, dialect7) => {
   const statements = [];
   const dropColumns = _prepareDropColumns(tableName, deleted);
   const alterColumns = _prepareAlterColumns(tableName, altered);
-  if (dialect6 === "sqlite") {
+  if (dialect7 === "sqlite") {
     let jsonCreateFKStatements = Object.values(addedFk);
     const sqliteAddColumns = _prepareSQLiteAddColumns(
       tableName,
@@ -18390,13 +18869,13 @@ var mapValues = (obj, map) => {
   }, {});
   return result;
 };
-var squashIndexesAndFKs = (json, dialect6 = "pg") => {
+var squashIndexesAndFKs = (json, dialect7 = "pg") => {
   const mappedTables = Object.fromEntries(
     Object.entries(json.tables).map((it) => {
       const squashedIndexes = mapValues(it[1].indexes, (index4) => {
-        if (dialect6 === "mysql") {
+        if (dialect7 === "mysql") {
           return MySqlSquasher.squashIdx(index4);
-        } else if (dialect6 === "pg") {
+        } else if (dialect7 === "pg") {
           return PgSquasher.squashIdx(index4);
         } else {
           return SQLiteSquasher.squashIdx(index4);
@@ -18404,9 +18883,9 @@ var squashIndexesAndFKs = (json, dialect6 = "pg") => {
       });
       const squashedFKs = mapValues(it[1].foreignKeys, (fk4) => {
         {
-          if (dialect6 === "mysql") {
+          if (dialect7 === "mysql") {
             return MySqlSquasher.squashFK(fk4);
-          } else if (dialect6 === "pg") {
+          } else if (dialect7 === "pg") {
             return PgSquasher.squashFK(fk4);
           } else {
             return SQLiteSquasher.squashFK(fk4);
@@ -18513,11 +18992,11 @@ var diffResultScheme = objectType({
   deletedEnums: enumSchema2.array(),
   alteredEnums: changedEnumSchema.array()
 }).strict();
-var applySnapshotsDiff = async (json1, json2, tablesResolver, columnsResolver, dialect6) => {
+var applySnapshotsDiff = async (json1, json2, tablesResolver, columnsResolver, dialect7) => {
   var _a, _b, _c, _d;
   const diffResult = applyJsonDiff(
-    squashIndexesAndFKs(json1, dialect6),
-    squashIndexesAndFKs(json2, dialect6)
+    squashIndexesAndFKs(json1, dialect7),
+    squashIndexesAndFKs(json2, dialect7)
   );
   if (Object.keys(diffResult).length === 0) {
     return "";
@@ -18583,7 +19062,7 @@ var applySnapshotsDiff = async (json1, json2, tablesResolver, columnsResolver, d
       it.added,
       it.altered,
       it.addedForeignKeys,
-      dialect6
+      dialect7
     );
   }).flat();
   const jsonCreateIndexesForAllAlteredTables = allAltered.map((it) => {
@@ -18596,7 +19075,7 @@ var applySnapshotsDiff = async (json1, json2, tablesResolver, columnsResolver, d
     return prepareCreateReferencesJson(it.name, it.foreignKeys);
   }).flat();
   const jsonReferencesForAllAlteredTables = allAltered.map((it) => {
-    const forAdded = dialect6 !== "sqlite" ? prepareCreateReferencesJson(it.name, it.addedForeignKeys) : [];
+    const forAdded = dialect7 !== "sqlite" ? prepareCreateReferencesJson(it.name, it.addedForeignKeys) : [];
     const forAltered = prepareDropReferencesJson(
       it.name,
       it.deletedForeignKeys
@@ -18613,7 +19092,7 @@ var applySnapshotsDiff = async (json1, json2, tablesResolver, columnsResolver, d
   }).flat()) != null ? _d : [];
   jsonStatements.push(...createEnums);
   jsonStatements.push(...jsonAlterEnumsWithAddedValues);
-  if (dialect6 === "sqlite") {
+  if (dialect7 === "sqlite") {
     jsonStatements.push(...jsonSQLiteCreateTables);
   } else {
     jsonStatements.push(...jsonCreateTables);
@@ -18622,7 +19101,7 @@ var applySnapshotsDiff = async (json1, json2, tablesResolver, columnsResolver, d
   jsonStatements.push(...jsonRenameTables);
   jsonStatements.push(...jsonRenameColumnsStatements);
   jsonStatements.push(...jsonAlterTables);
-  if (dialect6 !== "sqlite")
+  if (dialect7 !== "sqlite")
     jsonStatements.push(...jsonCreateReferences);
   jsonStatements.push(...jsonAlterReferencesForAlteredTables);
   jsonStatements.push(...jsonCreateIndexesForCreatedTables);
@@ -18635,7 +19114,7 @@ var applySnapshotsDiff = async (json1, json2, tablesResolver, columnsResolver, d
 // src/migrationPreparator.ts
 var import_hanji2 = __toESM(require_hanji());
 
-// node_modules/.pnpm/chalk@5.1.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+// node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
 var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
@@ -18812,11 +19291,11 @@ function assembleStyles() {
 var ansiStyles = assembleStyles();
 var ansi_styles_default = ansiStyles;
 
-// node_modules/.pnpm/chalk@5.1.2/node_modules/chalk/source/vendor/supports-color/index.js
+// node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/supports-color/index.js
 var import_node_process = __toESM(require("process"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var import_node_tty = __toESM(require("tty"), 1);
-function hasFlag(flag, argv = import_node_process.default.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
   const position = argv.indexOf(prefix + flag);
   const terminatorPosition = argv.indexOf("--");
@@ -18868,6 +19347,9 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
       return 2;
     }
   }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
   if (haveStream && !streamIsTTY && forceColor === void 0) {
     return 0;
   }
@@ -18883,7 +19365,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 1;
   }
   if ("CI" in env) {
-    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+    if ("GITHUB_ACTIONS" in env) {
+      return 3;
+    }
+    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
       return 1;
     }
     return min;
@@ -18891,19 +19376,21 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
   if ("TEAMCITY_VERSION" in env) {
     return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
   }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
   if (env.COLORTERM === "truecolor") {
     return 3;
   }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
   if ("TERM_PROGRAM" in env) {
     const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
-      case "iTerm.app":
+      case "iTerm.app": {
         return version >= 3 ? 3 : 2;
-      case "Apple_Terminal":
+      }
+      case "Apple_Terminal": {
         return 2;
+      }
     }
   }
   if (/-256(color)?$/i.test(env.TERM)) {
@@ -18930,7 +19417,7 @@ var supportsColor = {
 };
 var supports_color_default = supportsColor;
 
-// node_modules/.pnpm/chalk@5.1.2/node_modules/chalk/source/utilities.js
+// node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
   let index4 = string.indexOf(substring);
   if (index4 === -1) {
@@ -18960,7 +19447,7 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index4) {
   return returnValue;
 }
 
-// node_modules/.pnpm/chalk@5.1.2/node_modules/chalk/source/index.js
+// node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/index.js
 var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
 var GENERATOR = Symbol("GENERATOR");
 var STYLER = Symbol("STYLER");
@@ -19333,8 +19820,8 @@ var prepareMigration = (outFolder = "drizzle", schemaPath, _dialect) => {
   const serialized = serializer_default(schemaPath, _dialect);
   const id = (0, import_crypto.randomUUID)();
   const idPrev = prevSnapshot.id;
-  const { version, dialect: dialect6, ...rest } = serialized;
-  const result = { version, dialect: dialect6, id, prevId: idPrev, ...rest };
+  const { version, dialect: dialect7, ...rest } = serialized;
+  const result = { version, dialect: dialect7, id, prevId: idPrev, ...rest };
   return { prev: prevSnapshot, cur: result };
 };
 var migrationPreparator_default = prepareMigration;
@@ -19345,9 +19832,9 @@ var import_hanji3 = __toESM(require_hanji());
 var prepareAndMigrate = async (config) => {
   const outFolder = config.out;
   const schemaPath = config.schema;
-  const dialect6 = config.dialect;
+  const dialect7 = config.dialect;
   try {
-    const { prev, cur } = migrationPreparator_default(outFolder, schemaPath, dialect6);
+    const { prev, cur } = migrationPreparator_default(outFolder, schemaPath, dialect7);
     const toSave = JSON.parse(JSON.stringify(cur));
     const validatedPrev = commonSchema.parse(prev);
     const validatedCur = commonSchema.parse(cur);
@@ -19357,7 +19844,7 @@ var prepareAndMigrate = async (config) => {
     freeeeeeze(validatedPrev);
     freeeeeeze(validatedCur);
     console.log(schema4(cur));
-    const sql = await prepareSQL(validatedPrev, validatedCur, dialect6);
+    const sql = await prepareSQL(validatedPrev, validatedCur, dialect7);
     if (sql.length === 0) {
       console.log("No schema changes, nothing to migrate \u{1F634}");
       return;
@@ -19386,7 +19873,7 @@ var freeeeeeze = (obj) => {
     }
   }
 };
-var prepareSQL = async (prev, cur, dialect6) => {
+var prepareSQL = async (prev, cur, dialect7) => {
   const tablesResolver = async (input) => {
     try {
       const { created, deleted, renamed } = await promptTablesConflict(
@@ -19417,7 +19904,7 @@ var prepareSQL = async (prev, cur, dialect6) => {
     cur,
     tablesResolver,
     columnsResolver,
-    dialect6
+    dialect7
   );
 };
 var promptColumnsConflicts = async (tableName, newColumns, missingColumns) => {
@@ -19527,7 +20014,7 @@ var import_fs6 = __toESM(require("fs"));
 // src/cli/commands/check.ts
 var import_fs4 = __toESM(require("fs"));
 var checkHandler = (config) => {
-  const { dialect: dialect6, out } = config;
+  const { dialect: dialect7, out } = config;
   const outFolderExists = import_fs4.default.existsSync(out);
   if (!outFolderExists) {
     import_fs4.default.mkdirSync(out);
@@ -19571,7 +20058,7 @@ var import_crypto2 = require("crypto");
 var import_fs5 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
 var upHandler = (config) => {
-  const { dialect: dialect6, out } = config;
+  const { dialect: dialect7, out } = config;
   const outFolderExists = import_fs5.default.existsSync(out);
   if (!outFolderExists) {
     import_fs5.default.mkdirSync(out);
@@ -19737,7 +20224,7 @@ var migrationCommand = new Command("generate").alias("migrate").option(
   await prepareAndMigrate(result);
 });
 var prepareGenerateConfig = (options) => {
-  const { schema: schema5, out, dialect: dialect6, config } = options;
+  const { schema: schema5, out, dialect: dialect7, config } = options;
   if (!(schema5 || out)) {
     const path3 = config != null ? config : "drizzle.config.json";
     const drizzleConfig = JSON.parse(
@@ -19745,30 +20232,30 @@ var prepareGenerateConfig = (options) => {
     );
     return drizzleConfig;
   }
-  if (!schema5 || !dialect6) {
+  if (!schema5 || !dialect7) {
     return new Error(`'schema' and 'dialect' param must be set`);
   }
-  return configSchema.parse({ schema: schema5, out, dialect: dialect6 });
+  return configSchema.parse({ schema: schema5, out, dialect: dialect7 });
 };
 var checkSchema = objectType({
   dialect: stringType().default(""),
   out: stringType().default("drizzle")
 }).strict();
 var checkCommand = new Command("check").option("--out <out>", `Output folder, 'drizzle' by default`).option("--dialect <dialect>", "One of pg|mysql|sqlite, pg by default").action((options) => {
-  const { out, dialect: dialect6 } = checkSchema.parse(options);
-  if (!out || !dialect6) {
+  const { out, dialect: dialect7 } = checkSchema.parse(options);
+  if (!out || !dialect7) {
     (0, import_hanji4.render)(error(`'out' folder and 'dialect' params must be set`));
     process.exit(0);
   }
-  checkHandler({ out, dialect: dialect6 });
+  checkHandler({ out, dialect: dialect7 });
 });
 var upCommand = new Command("up").option("--out <out>", `Output folder, 'drizzle' by default`).option("--dialect <dialect>", "One of pg|mysql|sqlite, pg by default").action((options) => {
-  const { out, dialect: dialect6 } = checkSchema.parse(options);
-  if (!out || !dialect6) {
+  const { out, dialect: dialect7 } = checkSchema.parse(options);
+  if (!out || !dialect7) {
     (0, import_hanji4.render)(error(`'out' folder and 'dialect' params must be set`));
     process.exit(0);
   }
-  upHandler({ out, dialect: dialect6 });
+  upHandler({ out, dialect: dialect7 });
 });
 program.addCommand(migrationCommand);
 program.addCommand(checkCommand);