drizzle-kit 0.18.1-80e9ac8 → 0.18.1-a48fd5c

package/index.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S node --loader @esbuild-kit/esm-loader --no-warnings 
+#!/usr/bin/env -S node --loader drizzle-kit/loader.mjs -r esbuild-register --no-warnings
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -38,7 +38,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // node_modules/.pnpm/zod@3.20.2/node_modules/zod/lib/index.mjs
 function getErrorMap() {
@@ -5535,12 +5534,13 @@ import {
 var prepareFromMySqlImports;
 var init_mysqlImports = __esm({
   "src/serializer/mysqlImports.ts"() {
-    prepareFromMySqlImports = (imports) => {
+    prepareFromMySqlImports = async (imports) => {
       const tables = [];
       const enums = [];
       const schemas = [];
-      imports.forEach((it) => {
-        const i0 = __require(it);
+      for (let i = 0; i < imports.length; i++) {
+        const it = imports[i];
+        const i0 = await import(it);
         const i0values = Object.values(i0);
         i0values.forEach((t) => {
           if (t instanceof MySqlTable) {
@@ -5550,7 +5550,7 @@ var init_mysqlImports = __esm({
             schemas.push(t);
           }
         });
-      });
+      }
       return { tables, enums, schemas };
     };
   }
@@ -5950,12 +5950,13 @@ import {
 var prepareFromPgImports;
 var init_pgImports = __esm({
   "src/serializer/pgImports.ts"() {
-    prepareFromPgImports = (imports) => {
+    prepareFromPgImports = async (imports) => {
       const tables = [];
       const enums = [];
       const schemas = [];
-      imports.forEach((it) => {
-        const i0 = __require(it);
+      for (let i = 0; i < imports.length; i++) {
+        const it = imports[i];
+        const i0 = await import(it);
         const i0values = Object.values(i0);
         i0values.forEach((t) => {
           if (isPgEnum(t)) {
@@ -5969,7 +5970,7 @@ var init_pgImports = __esm({
             schemas.push(t);
           }
         });
-      });
+      }
       return { tables, enums, schemas };
     };
   }
@@ -6477,18 +6478,20 @@ import { SQLiteTable } from "drizzle-orm/sqlite-core";
 var prepareFromSqliteImports;
 var init_sqliteImports = __esm({
   "src/serializer/sqliteImports.ts"() {
-    prepareFromSqliteImports = (imports) => {
+    prepareFromSqliteImports = async (imports) => {
       const tables = [];
       const enums = [];
-      imports.forEach((it) => {
-        const i0 = __require(it);
+      for (let i = 0; i < imports.length; i++) {
+        const it = imports[i];
+        const i0 = await import(it);
         const i0values = Object.values(i0);
         i0values.forEach((t) => {
           if (t instanceof SQLiteTable) {
             tables.push(t);
           }
         });
-      });
+      }
+      ;
       return { tables, enums };
     };
   }
@@ -6623,7 +6626,7 @@ var init_sqliteSerializer = __esm({
 // src/serializer/index.ts
 import fs from "fs";
 import Path from "path";
-import glob from "glob";
+import * as glob from "glob";
 var sqlToStr, serializeMySql, serializePg, serializeSQLite, prepareFilenames;
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
@@ -6641,28 +6644,28 @@ var init_serializer = __esm({
         }
       }).sql;
     };
-    serializeMySql = (path3) => {
+    serializeMySql = async (path3) => {
       const filenames = prepareFilenames(path3);
       console.log(source_default.gray(`Reading schema files:
 ${filenames.join("\n")}
 `));
-      const { prepareFromMySqlImports: prepareFromMySqlImports2 } = (init_mysqlImports(), __toCommonJS(mysqlImports_exports));
-      const { generateMySqlSnapshot: generateMySqlSnapshot2 } = (init_mysqlSerializer(), __toCommonJS(mysqlSerializer_exports));
-      const { tables, enums, schemas } = prepareFromMySqlImports2(filenames);
+      const { prepareFromMySqlImports: prepareFromMySqlImports2 } = await Promise.resolve().then(() => (init_mysqlImports(), mysqlImports_exports));
+      const { generateMySqlSnapshot: generateMySqlSnapshot2 } = await Promise.resolve().then(() => (init_mysqlSerializer(), mysqlSerializer_exports));
+      const { tables, enums, schemas } = await prepareFromMySqlImports2(filenames);
       return generateMySqlSnapshot2(tables, enums, schemas);
     };
-    serializePg = (path3) => {
+    serializePg = async (path3) => {
       const filenames = prepareFilenames(path3);
-      const { prepareFromPgImports: prepareFromPgImports2 } = (init_pgImports(), __toCommonJS(pgImports_exports));
-      const { generatePgSnapshot: generatePgSnapshot2 } = (init_pgSerializer(), __toCommonJS(pgSerializer_exports));
-      const { tables, enums, schemas } = prepareFromPgImports2(filenames);
+      const { prepareFromPgImports: prepareFromPgImports2 } = await Promise.resolve().then(() => (init_pgImports(), pgImports_exports));
+      const { generatePgSnapshot: generatePgSnapshot2 } = await Promise.resolve().then(() => (init_pgSerializer(), pgSerializer_exports));
+      const { tables, enums, schemas } = await prepareFromPgImports2(filenames);
       return generatePgSnapshot2(tables, enums, schemas);
     };
-    serializeSQLite = (path3) => {
+    serializeSQLite = async (path3) => {
       const filenames = prepareFilenames(path3);
-      const { prepareFromSqliteImports: prepareFromSqliteImports2 } = (init_sqliteImports(), __toCommonJS(sqliteImports_exports));
-      const { generateSqliteSnapshot: generateSqliteSnapshot2 } = (init_sqliteSerializer(), __toCommonJS(sqliteSerializer_exports));
-      const { tables, enums } = prepareFromSqliteImports2(filenames);
+      const { prepareFromSqliteImports: prepareFromSqliteImports2 } = await Promise.resolve().then(() => (init_sqliteImports(), sqliteImports_exports));
+      const { generateSqliteSnapshot: generateSqliteSnapshot2 } = await Promise.resolve().then(() => (init_sqliteSerializer(), sqliteSerializer_exports));
+      const { tables, enums } = await prepareFromSqliteImports2(filenames);
       return generateSqliteSnapshot2(tables, enums);
     };
     prepareFilenames = (path3) => {
@@ -6693,19 +6696,19 @@ var init_migrationPreparator = __esm({
     init_pgSchema();
     init_sqliteSchema();
     init_mysqlSchema();
-    prepareMySqlDbPushSnapshot = (prev, schemaPath) => {
-      const serialized = serializeMySql(schemaPath);
+    prepareMySqlDbPushSnapshot = async (prev, schemaPath) => {
+      const serialized = await serializeMySql(schemaPath);
       const id = randomUUID();
       const idPrev = prev.id;
       const { version, dialect: dialect6, ...rest } = serialized;
       const result = { version, dialect: dialect6, id, prevId: idPrev, ...rest };
       return { prev, cur: result };
     };
-    prepareMySqlMigrationSnapshot = (migrationFolders, schemaPath) => {
+    prepareMySqlMigrationSnapshot = async (migrationFolders, schemaPath) => {
       const prevSnapshot = mysqlSchema.parse(
         preparePrevSnapshot(migrationFolders, dryMySql)
       );
-      const serialized = serializeMySql(schemaPath);
+      const serialized = await serializeMySql(schemaPath);
       const id = randomUUID();
       const idPrev = prevSnapshot.id;
       const { version, dialect: dialect6, ...rest } = serialized;
@@ -6718,11 +6721,11 @@ var init_migrationPreparator = __esm({
       };
       return { prev: prevSnapshot, cur: result, custom };
     };
-    prepareSqliteMigrationSnapshot = (snapshots, schemaPath) => {
+    prepareSqliteMigrationSnapshot = async (snapshots, schemaPath) => {
       const prevSnapshot = sqliteSchema.parse(
         preparePrevSnapshot(snapshots, drySQLite)
       );
-      const serialized = serializeSQLite(schemaPath);
+      const serialized = await serializeSQLite(schemaPath);
       const id = randomUUID();
       const idPrev = prevSnapshot.id;
       const { version, dialect: dialect6, ...rest } = serialized;
@@ -6741,9 +6744,9 @@ var init_migrationPreparator = __esm({
       };
       return { prev: prevSnapshot, cur: result, custom };
     };
-    preparePgMigrationSnapshot = (snapshots, schemaPath) => {
+    preparePgMigrationSnapshot = async (snapshots, schemaPath) => {
       const prevSnapshot = pgSchema.parse(preparePrevSnapshot(snapshots, dryPg));
-      const serialized = serializePg(schemaPath);
+      const serialized = await serializePg(schemaPath);
       const id = randomUUID();
       const idPrev = prevSnapshot.id;
       const { version, dialect: dialect6, ...rest } = serialized;
@@ -8123,7 +8126,7 @@ var init_migrate = __esm({
       try {
         assertV1OutFolder(outFolder, "pg");
         const { snapshots, journal } = prepareMigrationFolder(outFolder, "pg");
-        const { prev, cur, custom } = preparePgMigrationSnapshot(snapshots, schemaPath);
+        const { prev, cur, custom } = await preparePgMigrationSnapshot(snapshots, schemaPath);
         const validatedPrev = pgSchema.parse(prev);
         const validatedCur = pgSchema.parse(cur);
         if (config.custom) {
@@ -8166,7 +8169,7 @@ var init_migrate = __esm({
     prepareMySQLPush = async (config, snapshot) => {
       const schemaPath = config.schema;
       try {
-        const { prev, cur } = prepareMySqlDbPushSnapshot(snapshot, schemaPath);
+        const { prev, cur } = await prepareMySqlDbPushSnapshot(snapshot, schemaPath);
         const validatedPrev = mysqlSchema.parse(prev);
         const validatedCur = mysqlSchema.parse(cur);
         const squashedPrev = squashMysqlScheme(validatedPrev);
@@ -8189,7 +8192,7 @@ var init_migrate = __esm({
       try {
         assertV1OutFolder(outFolder, "mysql");
         const { snapshots, journal } = prepareMigrationFolder(outFolder, "mysql");
-        const { prev, cur, custom } = prepareMySqlMigrationSnapshot(snapshots, schemaPath);
+        const { prev, cur, custom } = await prepareMySqlMigrationSnapshot(snapshots, schemaPath);
         const validatedPrev = mysqlSchema.parse(prev);
         const validatedCur = mysqlSchema.parse(cur);
         if (config.custom) {
@@ -8235,7 +8238,7 @@ var init_migrate = __esm({
       try {
         assertV1OutFolder(outFolder, "sqlite");
         const { snapshots, journal } = prepareMigrationFolder(outFolder, "sqlite");
-        const { prev, cur, custom } = prepareSqliteMigrationSnapshot(snapshots, schemaPath);
+        const { prev, cur, custom } = await prepareSqliteMigrationSnapshot(snapshots, schemaPath);
         const validatedPrev = sqliteSchema.parse(prev);
         const validatedCur = sqliteSchema.parse(cur);
         if (config.custom) {
@@ -35451,11 +35454,12 @@ import Path2 from "path";
 
 // src/cli/utils.ts
 init_views();
-var assertPackages = (...pkgs) => {
+var assertPackages = async (...pkgs) => {
   try {
-    pkgs.forEach((it) => {
-      __require(it);
-    });
+    for (let i = 0; i < pkgs.length; i++) {
+      const it = pkgs[i];
+      await import(it);
+    }
   } catch (e) {
     err(
       `please install required packages: ${pkgs.map((it) => `'${it}'`).join(" ")}`
@@ -35464,8 +35468,8 @@ var assertPackages = (...pkgs) => {
   }
 };
 var requiredApiVersion = 4;
-var assertOrmCoreVersion = () => {
-  const { compatibilityVersion } = __require("drizzle-orm/version");
+var assertOrmCoreVersion = async () => {
+  const { compatibilityVersion } = await import("drizzle-orm/version");
   if (compatibilityVersion && compatibilityVersion === requiredApiVersion)
     return;
   if (!compatibilityVersion || compatibilityVersion < requiredApiVersion) {
@@ -35479,9 +35483,9 @@ var assertOrmCoreVersion = () => {
   }
   process.exit(1);
 };
-var ormCoreVersions = () => {
+var ormCoreVersions = async () => {
   try {
-    const { compatibilityVersion, npmVersion } = __require("drizzle-orm/version");
+    const { compatibilityVersion, npmVersion } = await import("drizzle-orm/version");
     return { compatibilityVersion, npmVersion };
   } catch (e) {
     return {};
@@ -35499,7 +35503,7 @@ var package_default = {
   author: "Drizzle Team",
   license: "MIT",
   bin: {
-    "drizzle-kit": "./bin.js"
+    "drizzle-kit": "./index.mjs"
   },
   scripts: {
     "migrate:old": "drizzle-kit generate:pg --out ./dev/migrations-pg --schema ./dev/migrations-pg/schema.ts",
@@ -35541,10 +35545,10 @@ var package_default = {
     ]
   },
   dependencies: {
-    "@esbuild-kit/esm-loader": "^2.5.5",
     camelcase: "^7.0.1",
     chalk: "^5.2.0",
     commander: "^9.4.1",
+    "esbuild-register": "^3.4.2",
     glob: "^8.1.0",
     hanji: "^0.0.5",
     "json-diff": "0.9.0",
@@ -35670,10 +35674,10 @@ init_views();
 var import_hanji4 = __toESM(require_hanji());
 import { join as join5, resolve } from "path";
 import { existsSync as existsSync3 } from "fs";
-var prepareGenerateConfig = (options) => {
+var prepareGenerateConfig = async (options) => {
   const { schema: schema4, out, config, breakpoints, custom } = options;
   if (!(schema4 && out)) {
-    const drizzleConfig = drizzleConfigFromFile(config);
+    const drizzleConfig = await drizzleConfigFromFile(config);
     if (!drizzleConfig.out) {
       console.log("You must specify 'out' param in config file");
       process.exit(1);
@@ -35700,10 +35704,10 @@ var prepareGenerateConfig = (options) => {
   }
   return { schema: schema4, out, breakpoints, custom };
 };
-var assertOutFolder = (it) => {
+var assertOutFolder = async (it) => {
   if ("out" in it)
     return it.out;
-  const cliConfig = drizzleConfigFromFile(it.config);
+  const cliConfig = await drizzleConfigFromFile(it.config);
   if (!cliConfig.out) {
     console.log(
       error(
@@ -35746,7 +35750,7 @@ var mySqlIntrospectConfigSchema = intersectionType(
   configIntrospectSchema,
   mysqlConnectionSchema
 );
-var drizzleConfigFromFile = (configPath) => {
+var drizzleConfigFromFile = async (configPath) => {
   const defaultTsConfigExists = existsSync3(join5(resolve("drizzle.config.ts")));
   const defaultJsConfigExists = existsSync3(join5(resolve("drizzle.config.js")));
   const defaultJsonConfigExists = existsSync3(
@@ -35766,8 +35770,10 @@ var drizzleConfigFromFile = (configPath) => {
     process.exit(1);
   }
   console.log(source_default.grey(`Reading config file '${path3}'`));
-  const required = __require(path3);
+  const required = await import(path3);
   const content = required.default ?? required;
+  console.log(required);
+  console.log(required.default);
   const res = mySqlCliConfigSchema.safeParse(content);
   if (!res.success) {
     console.error(res.error);
@@ -35776,7 +35782,7 @@ var drizzleConfigFromFile = (configPath) => {
   }
   return res.data;
 };
-var readDrizzleConfig = (configPath) => {
+var readDrizzleConfig = async (configPath) => {
   const defaultTsConfigExists = existsSync3(join5(resolve("drizzle.config.ts")));
   const defaultJsConfigExists = existsSync3(join5(resolve("drizzle.config.js")));
   const defaultJsonConfigExists = existsSync3(
@@ -35796,7 +35802,7 @@ var readDrizzleConfig = (configPath) => {
     process.exit(1);
   }
   console.log(source_default.grey(`Reading config file '${path3}'`));
-  const required = __require(path3);
+  const required = await import(path3);
   const content = required.default ?? required;
   return content;
 };
@@ -35970,12 +35976,13 @@ var logSuggestionsAndReturn = async ({
 
 // src/cli/index.ts
 init_serializer();
-var printVersions = () => {
-  console.log(`${source_default.gray(versions())}
+var printVersions = async () => {
+  const v = await versions();
+  console.log(`${source_default.gray(v)}
 `);
 };
-var versions = () => {
-  const { npmVersion } = ormCoreVersions();
+var versions = async () => {
+  const { npmVersion } = await ormCoreVersions();
   const ormVersion = npmVersion ? `
 drizzle-orm: v${npmVersion}` : "";
   const versions2 = `drizzle-kit: v${package_default.version}${ormVersion}`;
@@ -35992,24 +35999,24 @@ var generatePgCommand = new Command("generate:pg").option("--schema <schema...>"
   "--config <config>",
   "Path to a config.json file, drizzle.config.json by default"
 ).action(async (options) => {
-  printVersions();
-  assertOrmCoreVersion();
+  await printVersions();
+  await assertOrmCoreVersion();
   const oprtionsParsed = optionsSchema.parse(options);
-  const result = prepareGenerateConfig(oprtionsParsed);
-  assertPackages("drizzle-orm");
-  const { prepareAndMigratePg: prepareAndMigratePg2 } = (init_migrate(), __toCommonJS(migrate_exports));
+  const result = await prepareGenerateConfig(oprtionsParsed);
+  await assertPackages("drizzle-orm");
+  const { prepareAndMigratePg: prepareAndMigratePg2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
   await prepareAndMigratePg2(result);
 });
 var generateMysqlCommand = new Command("generate:mysql").option("--schema <schema...>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option("--custom", "Prepare empty migration file for custom SQL").option(
   "--config <config>",
   "Path to a config.json file, drizzle.config.json by default"
 ).action(async (options) => {
-  printVersions();
-  assertOrmCoreVersion();
+  await printVersions();
+  await assertOrmCoreVersion();
   const oprtionsParsed = optionsSchema.parse(options);
-  const result = prepareGenerateConfig(oprtionsParsed);
-  assertPackages("drizzle-orm");
-  const { prepareAndMigrateMySql: prepareAndMigrateMySql2 } = (init_migrate(), __toCommonJS(migrate_exports));
+  const result = await prepareGenerateConfig(oprtionsParsed);
+  await assertPackages("drizzle-orm");
+  const { prepareAndMigrateMySql: prepareAndMigrateMySql2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
   await prepareAndMigrateMySql2(result);
 });
 var Select = class extends import_hanji7.Prompt {
@@ -36018,7 +36025,7 @@ var Select = class extends import_hanji7.Prompt {
   constructor(items) {
     super();
     this.on("attach", (terminal) => terminal.toggleCursor("hide"));
-    this.on("detach", () => clearInterval(this.timeout));
+    this.on("detach", (terminal) => terminal.toggleCursor("show"));
     this.data = new import_hanji7.SelectState(
       items.map((it) => ({ label: it, value: `${it}-value` }))
     );
@@ -36045,11 +36052,11 @@ var dbPushMysqlCommand = new Command("push:mysql").option(
   "--config <config>",
   "Path to a config.json file, drizzle.config.json by default"
 ).action(async (options) => {
-  printVersions();
-  assertPackages("drizzle-orm");
-  assertOrmCoreVersion();
-  const { mysqlPushIntrospect: mysqlPushIntrospect2, connectToMySQL: connectToMySQL2 } = (init_mysqlIntrospect(), __toCommonJS(mysqlIntrospect_exports));
-  const drizzleConfig = drizzleConfigFromFile(options.config);
+  await printVersions();
+  await assertPackages("drizzle-orm");
+  await assertOrmCoreVersion();
+  const { mysqlPushIntrospect: mysqlPushIntrospect2, connectToMySQL: connectToMySQL2 } = await Promise.resolve().then(() => (init_mysqlIntrospect(), mysqlIntrospect_exports));
+  const drizzleConfig = await drizzleConfigFromFile(options.config);
   const fileNames = prepareFilenames(drizzleConfig.schema);
   if (fileNames.length === 0) {
     (0, import_hanji7.render)(
@@ -36061,7 +36068,7 @@ var dbPushMysqlCommand = new Command("push:mysql").option(
   const filterConfig = drizzleConfig.tablesFilter;
   const tablesFilter = filterConfig ? typeof filterConfig === "string" ? [filterConfig] : filterConfig : [];
   const { schema: schema4 } = await mysqlPushIntrospect2(connection, tablesFilter);
-  const { prepareMySQLPush: prepareMySQLPush2 } = (init_migrate(), __toCommonJS(migrate_exports));
+  const { prepareMySQLPush: prepareMySQLPush2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
   const statements = await prepareMySQLPush2(
     { schema: drizzleConfig.schema },
     schema4
@@ -36124,59 +36131,59 @@ var generateSqliteCommand = new Command("generate:sqlite").option("--schema <sch
   "--config <config>",
   "Path to a config.json file, drizzle.config.json by default"
 ).action(async (options) => {
-  printVersions();
-  assertOrmCoreVersion();
+  await printVersions();
+  await assertOrmCoreVersion();
   const oprtionsParsed = optionsSchema.parse(options);
-  const result = prepareGenerateConfig(oprtionsParsed);
-  assertPackages("drizzle-orm");
-  const { prepareAndMigrateSqlite: prepareAndMigrateSqlite2 } = (init_migrate(), __toCommonJS(migrate_exports));
+  const result = await prepareGenerateConfig(oprtionsParsed);
+  await assertPackages("drizzle-orm");
+  const { prepareAndMigrateSqlite: prepareAndMigrateSqlite2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
   await prepareAndMigrateSqlite2(result);
 });
 var checkSchema = objectType({
   out: stringType().optional(),
   config: stringType().default("drizzle.config.json")
 }).strict();
-var checkPgCommand = new Command("check:pg").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action((options) => {
-  printVersions();
-  assertOrmCoreVersion();
+var checkPgCommand = new Command("check:pg").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+  await printVersions();
+  await assertOrmCoreVersion();
   const params = checkSchema.parse(options);
-  const out = assertOutFolder(params);
+  const out = await assertOutFolder(params);
   checkHandler(out, "pg");
   console.log("Everything's fine \u{1F436}\u{1F525}");
 });
-var checkSqliteCommand = new Command("check:sqlite").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action((options) => {
-  printVersions();
-  assertOrmCoreVersion();
+var checkSqliteCommand = new Command("check:sqlite").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+  await printVersions();
+  await assertOrmCoreVersion();
   const params = checkSchema.parse(options);
-  const out = assertOutFolder(params);
+  const out = await assertOutFolder(params);
   checkHandler(out, "sqlite");
   console.log("Everything's fine \u{1F436}\u{1F525}");
 });
-var upPgCommand = new Command("up:pg").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action((options) => {
-  printVersions();
-  assertOrmCoreVersion();
+var upPgCommand = new Command("up:pg").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+  await printVersions();
+  await assertOrmCoreVersion();
   const params = checkSchema.parse(options);
-  const out = assertOutFolder(params);
-  assertPackages("drizzle-orm");
+  const out = await assertOutFolder(params);
+  await assertPackages("drizzle-orm");
   upPgHandlerV4(out);
   upgradeFolders("pg", out);
   upPgHandler(out);
 });
-var upMysqlCommand = new Command("up:mysql").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action((options) => {
-  printVersions();
-  assertOrmCoreVersion();
+var upMysqlCommand = new Command("up:mysql").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+  await printVersions();
+  await assertOrmCoreVersion();
   const params = checkSchema.parse(options);
-  const out = assertOutFolder(params);
-  assertPackages("drizzle-orm");
+  const out = await assertOutFolder(params);
+  await assertPackages("drizzle-orm");
   upMysqlHandlerV4(out);
   upgradeFolders("mysql", out);
   upMysqlHandler(out);
 });
-var upSqliteCommand = new Command("up:sqlite").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.ts]`).action((options) => {
-  printVersions();
-  assertOrmCoreVersion();
+var upSqliteCommand = new Command("up:sqlite").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
+  await printVersions();
+  await assertOrmCoreVersion();
   const params = checkSchema.parse(options);
-  const out = assertOutFolder(params);
+  const out = await assertOutFolder(params);
   upSqliteHandlerV4(out);
   upgradeFolders("sqlite", out);
   upSqliteHandler(out);
@@ -36186,11 +36193,11 @@ var pt1 = objectType({
   breakpoints: booleanType().optional().default(false)
 });
 var introspectPgCommand = new Command("introspect:pg").option("--out <out>", `Migrations folder`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option("--connectionString <connectionString>", "Postgres connection string").option("--host <host>", "Postgres host").option("--port <port>", "Postgres port").option("--user <user>", "Postgres user").option("--password <password>", "Postgres password").option("--database <database>", "Postgres database name").option("--ssl <ssl>", "Postgres ssl").option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
-  printVersions();
-  assertPackages("drizzle-orm");
-  assertOrmCoreVersion();
-  const { pgIntrospect: pgIntrospect2, PgConfig2: PgConfig22, PgConfig1: PgConfig12 } = (init_pgIntrospect(), __toCommonJS(pgIntrospect_exports));
-  const drizzleConfig = readDrizzleConfig(options.config);
+  await printVersions();
+  await assertPackages("drizzle-orm");
+  await assertOrmCoreVersion();
+  const { pgIntrospect: pgIntrospect2, PgConfig2: PgConfig22, PgConfig1: PgConfig12 } = await Promise.resolve().then(() => (init_pgIntrospect(), pgIntrospect_exports));
+  const drizzleConfig = await readDrizzleConfig(options.config);
   const pgIntrospectConfig = unionType([
     pt1.extend(PgConfig22.shape),
     pt1.extend(PgConfig12.shape)
@@ -36244,11 +36251,11 @@ var introspectMySqlCommand = new Command("introspect:mysql").option(
   "--config <config>",
   "Path to a config.json file, drizzle.config.json by default"
 ).option("--out <out>", `Migrations folder`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option("--connectionString <connectionString>", "MySQL connection string").option("--host <host>", "MySQL host").option("--port <port>", "MySQL port").option("--user <user>", "MySQL user").option("--password <password>", "MySQL password").option("--database <database>", "MySQL database name").action(async (options) => {
-  printVersions();
-  assertPackages("drizzle-orm");
-  assertOrmCoreVersion();
-  const { mysqlIntrospect: mysqlIntrospect2 } = (init_mysqlIntrospect(), __toCommonJS(mysqlIntrospect_exports));
-  const drizzleConfig = readDrizzleConfig(options.config);
+  await printVersions();
+  await assertPackages("drizzle-orm");
+  await assertOrmCoreVersion();
+  const { mysqlIntrospect: mysqlIntrospect2 } = await Promise.resolve().then(() => (init_mysqlIntrospect(), mysqlIntrospect_exports));
+  const drizzleConfig = await readDrizzleConfig(options.config);
   const res = mySqlIntrospectConfigSchema.safeParse(drizzleConfig);
   if (!res.success) {
     for (const issue of res.error.issues) {
@@ -36295,28 +36302,32 @@ var introspectMySqlCommand = new Command("introspect:mysql").option(
   );
   process.exit(0);
 });
-var dropCommand = new Command("drop").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action((options) => {
-  printVersions();
-  assertOrmCoreVersion();
+var dropCommand = new Command("drop").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+  await printVersions();
+  await assertOrmCoreVersion();
   const params = checkSchema.parse(options);
-  const out = assertOutFolder(params);
+  const out = await assertOutFolder(params);
   assertV1OutFolder(out, "{dialect}");
   dropMigration(out);
 });
-program.version(versions(), "--version, -v");
-program.addCommand(generatePgCommand);
-program.addCommand(generateMysqlCommand);
-program.addCommand(generateSqliteCommand);
-program.addCommand(checkPgCommand);
-program.addCommand(checkSqliteCommand);
-program.addCommand(upPgCommand);
-program.addCommand(upMysqlCommand);
-program.addCommand(upSqliteCommand);
-program.addCommand(introspectPgCommand);
-program.addCommand(introspectMySqlCommand);
-program.addCommand(dropCommand);
-program.addCommand(dbPushMysqlCommand);
-program.parse();
+var main = async () => {
+  const version = await versions();
+  program.version(version, "--version, -v");
+  program.addCommand(generatePgCommand);
+  program.addCommand(generateMysqlCommand);
+  program.addCommand(generateSqliteCommand);
+  program.addCommand(checkPgCommand);
+  program.addCommand(checkSqliteCommand);
+  program.addCommand(upPgCommand);
+  program.addCommand(upMysqlCommand);
+  program.addCommand(upSqliteCommand);
+  program.addCommand(introspectPgCommand);
+  program.addCommand(introspectMySqlCommand);
+  program.addCommand(dropCommand);
+  program.addCommand(dbPushMysqlCommand);
+  program.parse();
+};
+main();
 export {
   Select,
   checkSchema

package/loader.mjs

@@ -0,0 +1,13 @@
+const extensionsRegex = /\.(ts|tsx|mts|cts)$/
+
+export async function load(url, context, defaultLoad) {
+  if (extensionsRegex.test(url)) {
+    const { source } = await defaultLoad(url, { ...context, format: 'module' })
+    return {
+      ...context,
+      source: source,
+    }
+  }
+  // let Node.js handle all other URLs
+  return defaultLoad(url, context, defaultLoad)
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "drizzle-kit",
-  "version": "0.18.1-80e9ac8",
+  "version": "0.18.1-a48fd5c",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",
   "bin": {
-    "drizzle-kit": "./bin.js"
+    "drizzle-kit": "./index.mjs"
   },
   "scripts": {
     "migrate:old": "drizzle-kit generate:pg --out ./dev/migrations-pg --schema ./dev/migrations-pg/schema.ts",
@@ -47,10 +47,10 @@
     ]
   },
   "dependencies": {
-    "@esbuild-kit/esm-loader": "^2.5.5",
     "camelcase": "^7.0.1",
     "chalk": "^5.2.0",
     "commander": "^9.4.1",
+    "esbuild-register": "^3.4.2",
     "glob": "^8.1.0",
     "hanji": "^0.0.5",
     "json-diff": "0.9.0",