drizzle-kit 0.17.1-9fd4c75 → 0.17.1

package/index.js

@@ -14092,7 +14092,7 @@ ALTER TABLE "${statement.tableName}" ADD CONSTRAINT ${statement.newConstraintNam
         const onUpdateStatement = onUpdate ? `ON UPDATE ${onUpdate}` : "";
         const fromColumnsString = columnsFrom.map((it) => `"${it}"`).join(",");
         const toColumnsString = columnsTo.map((it) => `"${it}"`).join(",");
-        const alterStatement = `ALTER TABLE "${tableFrom}" ADD CONSTRAINT ${name} FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableTo}(${toColumnsString}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
+        const alterStatement = `ALTER TABLE ${tableFrom} ADD CONSTRAINT ${name} FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableTo}(${toColumnsString}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
         let sql = "DO $$ BEGIN\n";
         sql += " " + alterStatement + ";\n";
         sql += "EXCEPTION\n";
@@ -14143,13 +14143,13 @@ ALTER TABLE "${statement.tableName}" ADD CONSTRAINT ${statement.newConstraintNam
       convert(statement) {
         const newFk = PgSquasher.unsquashFK(statement.data);
         const oldFk = PgSquasher.unsquashFK(statement.oldFkey);
-        let sql = `ALTER TABLE "${oldFk.tableFrom}" DROP CONSTRAINT ${oldFk.name};
+        let sql = `ALTER TABLE ${oldFk.tableFrom} DROP CONSTRAINT ${oldFk.name};
 `;
         const onDeleteStatement = newFk.onDelete ? `ON DELETE ${newFk.onDelete}` : "";
         const onUpdateStatement = newFk.onUpdate ? `ON UPDATE ${newFk.onDelete}` : "";
         const fromColumnsString = newFk.columnsFrom.map((it) => `"${it}"`).join(",");
         const toColumnsString = newFk.columnsTo.map((it) => `"${it}"`).join(",");
-        const alterStatement = `ALTER TABLE "${newFk.tableFrom}" ADD CONSTRAINT ${newFk.name} FOREIGN KEY (${fromColumnsString}) REFERENCES ${newFk.tableTo}(${toColumnsString}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
+        const alterStatement = `ALTER TABLE ${newFk.tableFrom} ADD CONSTRAINT ${newFk.name} FOREIGN KEY (${fromColumnsString}) REFERENCES ${newFk.tableTo}(${toColumnsString}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
         sql += "DO $$ BEGIN\n";
         sql += " " + alterStatement + ";\n";
         sql += "EXCEPTION\n";
@@ -14180,7 +14180,7 @@ ALTER TABLE "${statement.tableName}" ADD CONSTRAINT ${statement.newConstraintNam
       convert(statement) {
         const tableFrom = statement.tableName;
         const { name } = PgSquasher.unsquashFK(statement.data);
-        return `ALTER TABLE "${tableFrom}" DROP CONSTRAINT ${name};
+        return `ALTER TABLE ${tableFrom} DROP CONSTRAINT ${name};
 `;
       }
     };
@@ -25712,9 +25712,7 @@ var init_mysqlImports = __esm({
         const i0values = Object.values(i0);
         i0values.forEach((t) => {
           if (t instanceof import_mysql_core.MySqlTable) {
-            tables.push(
-              t
-            );
+            tables.push(t);
           }
           if ((0, import_mysql_core.isMySqlSchema)(t)) {
             schemas.push(t);
@@ -25759,6 +25757,7 @@ var init_mysqlSerializer = __esm({
     import_sql = require("drizzle-orm/sql");
     import_common = require("drizzle-orm/mysql-core/columns/common");
     import_date = require("drizzle-orm/mysql-core/columns/date.common");
+    init_serializer();
     dialect3 = new import_mysql_core2.MySqlDialect();
     indexName = (tableName, columns) => {
       return `${tableName}_${columns.join("_")}_index`;
@@ -25792,12 +25791,7 @@ var init_mysqlSerializer = __esm({
           };
           if (column6.default !== void 0) {
             if (column6.default instanceof import_sql.SQL) {
-              columnToSet.default = column6.default.queryChunks.map((it) => {
-                if (typeof it === "string") {
-                  return `${it}`;
-                }
-                throw new Error();
-              }).join();
+              columnToSet.default = sqlToStr(column6.default);
             } else {
               if (typeof column6.default === "string") {
                 columnToSet.default = `'${column6.default}'`;
@@ -26111,9 +26105,7 @@ var init_pgImports = __esm({
             return;
           }
           if (t instanceof import_pg_core.PgTable) {
-            tables.push(
-              t
-            );
+            tables.push(t);
           }
           if ((0, import_pg_core.isPgSchema)(t)) {
             schemas.push(t);
@@ -26139,6 +26131,7 @@ var init_pgSerializer = __esm({
     import_utils10 = require("drizzle-orm/pg-core/utils");
     import_sql2 = require("drizzle-orm/sql");
     import_table2 = require("drizzle-orm/table");
+    init_serializer();
     dialect4 = new import_pg_core2.PgDialect();
     indexName2 = (tableName, columns) => {
       return `${tableName}_${columns.join("_")}_index`;
@@ -26171,12 +26164,7 @@ var init_pgSerializer = __esm({
           };
           if (column6.default !== void 0) {
             if (column6.default instanceof import_sql2.SQL) {
-              columnToSet.default = column6.default.queryChunks.map((it) => {
-                if (typeof it === "string") {
-                  return `${it}`;
-                }
-                throw new Error("Only strings are allowed in .default()");
-              }).join();
+              columnToSet.default = sqlToStr(column6.default);
             } else {
               if (typeof column6.default === "string") {
                 columnToSet.default = `'${column6.default}'`;
@@ -26644,6 +26632,7 @@ var init_sqliteSerializer = __esm({
     import_sql3 = require("drizzle-orm/sql");
     import_sqlite_core2 = require("drizzle-orm/sqlite-core");
     import_utils11 = require("drizzle-orm/sqlite-core/utils");
+    init_serializer();
     dialect5 = new import_sqlite_core2.SQLiteSyncDialect();
     generateSqliteSnapshot = (tables, enums) => {
       const result = {};
@@ -26657,7 +26646,6 @@ var init_sqliteSerializer = __esm({
           columns,
           indexes,
           foreignKeys: tableForeignKeys,
-          schema: schema4,
           primaryKeys
         } = (0, import_utils11.getTableConfig)(table4);
         columns.forEach((column6) => {
@@ -26672,12 +26660,7 @@ var init_sqliteSerializer = __esm({
           };
           if (column6.default !== void 0) {
             if (column6.default instanceof import_sql3.SQL) {
-              columnToSet.default = column6.default.queryChunks.map((it) => {
-                if (typeof it === "string") {
-                  return `${it}`;
-                }
-                throw new Error("Only strings are allowed in .default()");
-              }).join();
+              columnToSet.default = sqlToStr(column6.default);
             } else {
               columnToSet.default = typeof column6.default === "string" ? `'${column6.default}'` : column6.default;
             }
@@ -26762,7 +26745,7 @@ var init_sqliteSerializer = __esm({
 });
 
 // src/serializer/index.ts
-var import_fs5, import_node, import_path3, import_glob, safeRegister, serializeMySql, serializePg, serializeSQLite, prepareFilenames;
+var import_fs5, import_node, import_path3, import_glob, safeRegister, sqlToStr, serializeMySql, serializePg, serializeSQLite, prepareFilenames;
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
     import_fs5 = __toESM(require("fs"));
@@ -26781,6 +26764,19 @@ var init_serializer = __esm({
         } };
       }
     };
+    sqlToStr = (sql) => {
+      return sql.toQuery({
+        escapeName: (name) => {
+          throw new Error("we don't support params for `sql` default values");
+        },
+        escapeParam: (num, value) => {
+          throw new Error("we don't support params for `sql` default values");
+        },
+        escapeString: (str) => {
+          throw new Error("we don't support params for `sql` default values");
+        }
+      }).sql;
+    };
     serializeMySql = (path2) => {
       const filenames = prepareFilenames(path2);
       const { unregister } = safeRegister();
@@ -26845,7 +26841,13 @@ var init_migrationPreparator = __esm({
       const idPrev = prevSnapshot.id;
       const { version, dialect: dialect6, ...rest } = serialized;
       const result = { version, dialect: dialect6, id, prevId: idPrev, ...rest };
-      return { prev: prevSnapshot, cur: result };
+      const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
+      const custom = {
+        id,
+        prevId: idPrev,
+        ...prevRest
+      };
+      return { prev: prevSnapshot, cur: result, custom };
     };
     prepareSqliteMigrationSnapshot = (snapshots, schemaPath) => {
       const prevSnapshot = sqliteSchema.parse(
@@ -26862,7 +26864,13 @@ var init_migrationPreparator = __esm({
         prevId: idPrev,
         ...rest
       };
-      return { prev: prevSnapshot, cur: result };
+      const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
+      const custom = {
+        id,
+        prevId: idPrev,
+        ...prevRest
+      };
+      return { prev: prevSnapshot, cur: result, custom };
     };
     preparePgMigrationSnapshot = (snapshots, schemaPath) => {
       const prevSnapshot = pgSchema.parse(preparePrevSnapshot(snapshots, dryPg));
@@ -26871,7 +26879,13 @@ var init_migrationPreparator = __esm({
       const idPrev = prevSnapshot.id;
       const { version, dialect: dialect6, ...rest } = serialized;
       const result = { version, dialect: dialect6, id, prevId: idPrev, ...rest };
-      return { prev: prevSnapshot, cur: result };
+      const { id: _ignoredId, prevId: _ignoredPrevId, ...prevRest } = prevSnapshot;
+      const custom = {
+        id,
+        prevId: idPrev,
+        ...prevRest
+      };
+      return { prev: prevSnapshot, cur: result, custom };
     };
     preparePrevSnapshot = (snapshots, defaultPrev) => {
       let prevSnapshot;
@@ -26917,9 +26931,25 @@ var init_migrate = __esm({
       try {
         assertV1OutFolder(outFolder, "pg");
         const { snapshots, journal } = prepareMigrationFolder(outFolder, "pg");
-        const { prev, cur } = preparePgMigrationSnapshot(snapshots, schemaPath);
+        const { prev, cur, custom } = preparePgMigrationSnapshot(snapshots, schemaPath);
         const validatedPrev = pgSchema.parse(prev);
         const validatedCur = pgSchema.parse(cur);
+        if (config.custom) {
+          writeResult(
+            custom,
+            [],
+            journal,
+            {
+              columns: {},
+              schemas: {},
+              tables: {}
+            },
+            outFolder,
+            config.breakpoints,
+            "custom"
+          );
+          return;
+        }
         const squashedPrev = squashPgScheme(validatedPrev);
         const squashedCur = squashPgScheme(validatedCur);
         const { sqlStatements, _meta } = await prepareSQL(
@@ -26947,9 +26977,25 @@ var init_migrate = __esm({
       try {
         assertV1OutFolder(outFolder, "mysql");
         const { snapshots, journal } = prepareMigrationFolder(outFolder, "mysql");
-        const { prev, cur } = prepareMySqlMigrationSnapshot(snapshots, schemaPath);
+        const { prev, cur, custom } = prepareMySqlMigrationSnapshot(snapshots, schemaPath);
         const validatedPrev = mysqlSchema.parse(prev);
         const validatedCur = mysqlSchema.parse(cur);
+        if (config.custom) {
+          writeResult(
+            custom,
+            [],
+            journal,
+            {
+              columns: {},
+              schemas: {},
+              tables: {}
+            },
+            outFolder,
+            config.breakpoints,
+            "custom"
+          );
+          return;
+        }
         const squashedPrev = squashMysqlScheme(validatedPrev);
         const squashedCur = squashMysqlScheme(validatedCur);
         const { sqlStatements, _meta } = await prepareSQL(
@@ -26977,9 +27023,25 @@ var init_migrate = __esm({
       try {
         assertV1OutFolder(outFolder, "sqlite");
         const { snapshots, journal } = prepareMigrationFolder(outFolder, "sqlite");
-        const { prev, cur } = prepareSqliteMigrationSnapshot(snapshots, schemaPath);
+        const { prev, cur, custom } = prepareSqliteMigrationSnapshot(snapshots, schemaPath);
         const validatedPrev = sqliteSchema.parse(prev);
         const validatedCur = sqliteSchema.parse(cur);
+        if (config.custom) {
+          writeResult(
+            custom,
+            [],
+            journal,
+            {
+              columns: {},
+              schemas: {},
+              tables: {}
+            },
+            outFolder,
+            config.breakpoints,
+            "custom"
+          );
+          return;
+        }
         const squashedPrev = squashSqliteScheme(validatedPrev);
         const squashedCur = squashSqliteScheme(validatedCur);
         const { sqlStatements, _meta } = await prepareSQL(
@@ -27181,11 +27243,13 @@ var init_migrate = __esm({
       result.deleted.push(...leftMissing);
       return result;
     };
-    writeResult = (cur, sqlStatements, journal, _meta, outFolder, breakpoints, isIntrospect = false) => {
-      console.log(schema(cur));
-      if (sqlStatements.length === 0) {
-        console.log("No schema changes, nothing to migrate \u{1F634}");
-        return;
+    writeResult = (cur, sqlStatements, journal, _meta, outFolder, breakpoints, type = "none") => {
+      if (type === "none") {
+        console.log(schema(cur));
+        if (sqlStatements.length === 0) {
+          console.log("No schema changes, nothing to migrate \u{1F634}");
+          return;
+        }
       }
       const lastEntryInJournal = journal.entries[journal.entries.length - 1];
       const idx = typeof lastEntryInJournal === "undefined" ? 0 : lastEntryInJournal.idx + 1;
@@ -27200,13 +27264,17 @@ var init_migrate = __esm({
       );
       const sqlDelimiter = breakpoints ? "--> statement-breakpoint\n" : "\n";
       let sql = sqlStatements.join(sqlDelimiter);
-      if (isIntrospect) {
+      if (type === "introspect") {
         sql = `-- Current sql file was generated after introspecting the database
 -- If you want to run this migration please uncomment this code before executing migraitons
 /*
 ${sql}
 */`;
       }
+      if (type === "custom") {
+        console.log("Prepared empty file for your custom SQL migration!");
+        sql = "-- Custom SQL migration file, put you code below! --";
+      }
       journal.entries.push({
         idx,
         version: cur.version,
@@ -49242,7 +49310,7 @@ var assertPackages = (...pkgs) => {
     process.exit(1);
   }
 };
-var requiredApiVersion = 3;
+var requiredApiVersion = 4;
 var assertOrmCoreVersion = () => {
   const { compatibilityVersion } = require("drizzle-orm/version");
   if (compatibilityVersion && compatibilityVersion === requiredApiVersion)
@@ -49339,8 +49407,9 @@ var package_default = {
     "@typescript-eslint/parser": "^5.46.1",
     ava: "^5.1.0",
     dockerode: "^3.3.4",
+    dotenv: "^16.0.3",
     "drizzle-kit": "^0.16.8",
-    "drizzle-orm": "0.21.0-26e3751",
+    "drizzle-orm": "0.23.2-e17a5ba",
     esbuild: "^0.15.7",
     "esbuild-register": "^3.3.3",
     eslint: "^8.29.0",
@@ -49467,21 +49536,22 @@ drizzle-orm: v${npmVersion}` : "";
 var configSchema = objectType({
   schema: unionType([stringType(), stringType().array()]),
   out: stringType().default("drizzle"),
-  breakpoints: booleanType()
+  breakpoints: booleanType(),
+  custom: booleanType()
 }).strict();
 var optionsSchema = objectType({
   schema: unionType([stringType(), stringType().array()]).optional(),
   out: stringType().optional(),
   config: stringType().optional(),
-  breakpoints: booleanType().optional().default(false)
+  breakpoints: booleanType().optional().default(false),
+  custom: booleanType().optional().default(false)
 }).strict();
-var generatePgCommand = new Command("generate:pg").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(
+var generatePgCommand = new Command("generate:pg").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();
-  console.log(options);
   const oprtionsParsed = optionsSchema.parse(options);
   const result = prepareGenerateConfig(oprtionsParsed);
   if (result instanceof Error) {
@@ -49492,7 +49562,7 @@ var generatePgCommand = new Command("generate:pg").option("--schema <schema...>"
   const { prepareAndMigratePg: prepareAndMigratePg2 } = (init_migrate(), __toCommonJS(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(
+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) => {
@@ -49508,7 +49578,7 @@ var generateMysqlCommand = new Command("generate:mysql").option("--schema <schem
   const { prepareAndMigrateMySql: prepareAndMigrateMySql2 } = (init_migrate(), __toCommonJS(migrate_exports));
   await prepareAndMigrateMySql2(result);
 });
-var generateSqliteCommand = new Command("generate:sqlite").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(
+var generateSqliteCommand = new Command("generate:sqlite").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) => {
@@ -49525,7 +49595,7 @@ var generateSqliteCommand = new Command("generate:sqlite").option("--schema <sch
   await prepareAndMigrateSqlite2(result);
 });
 var prepareGenerateConfig = (options) => {
-  const { schema: schema4, out, config, breakpoints } = options;
+  const { schema: schema4, out, config, breakpoints, custom } = options;
   if (!(schema4 || out)) {
     const path2 = config != null ? config : "drizzle.config.json";
     const drizzleConfig = JSON.parse(
@@ -49536,7 +49606,7 @@ var prepareGenerateConfig = (options) => {
   if (!schema4) {
     return new Error(`'schema' param must be set`);
   }
-  return configSchema.parse({ schema: schema4, out, breakpoints });
+  return configSchema.parse({ schema: schema4, out, breakpoints, custom });
 };
 var checkSchema = objectType({
   out: stringType().optional(),
@@ -49657,7 +49727,7 @@ var introspectPgCommand = new Command("introspect:pg").option("--out <out>", `Mi
       _meta,
       res.data.out,
       res.data.breakpoints,
-      true
+      "introspect"
     );
   } else {
     (0, import_hanji6.render)(
@@ -49709,7 +49779,7 @@ var introspectMySqlCommand = new Command("introspect:mysql").option("--out <out>
       _meta,
       res.data.out,
       res.data.breakpoints,
-      true
+      "introspect"
     );
   } else {
     (0, import_hanji6.render)(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.17.1-9fd4c75",
+  "version": "0.17.1",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",
@@ -66,8 +66,9 @@
     "@typescript-eslint/parser": "^5.46.1",
     "ava": "^5.1.0",
     "dockerode": "^3.3.4",
+    "dotenv": "^16.0.3",
     "drizzle-kit": "^0.16.8",
-    "drizzle-orm": "0.21.0-26e3751",
+    "drizzle-orm": "0.23.2-e17a5ba",
     "esbuild": "^0.15.7",
     "esbuild-register": "^3.3.3",
     "eslint": "^8.29.0",

package/utils.js

@@ -11810,7 +11810,7 @@ var PgCreateForeignKeyConvertor = class extends Convertor {
     const onUpdateStatement = onUpdate ? `ON UPDATE ${onUpdate}` : "";
     const fromColumnsString = columnsFrom.map((it) => `"${it}"`).join(",");
     const toColumnsString = columnsTo.map((it) => `"${it}"`).join(",");
-    const alterStatement = `ALTER TABLE "${tableFrom}" ADD CONSTRAINT ${name} FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableTo}(${toColumnsString}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
+    const alterStatement = `ALTER TABLE ${tableFrom} ADD CONSTRAINT ${name} FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableTo}(${toColumnsString}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
     let sql = "DO $$ BEGIN\n";
     sql += " " + alterStatement + ";\n";
     sql += "EXCEPTION\n";
@@ -11861,13 +11861,13 @@ var PgAlterForeignKeyConvertor = class extends Convertor {
   convert(statement) {
     const newFk = PgSquasher.unsquashFK(statement.data);
     const oldFk = PgSquasher.unsquashFK(statement.oldFkey);
-    let sql = `ALTER TABLE "${oldFk.tableFrom}" DROP CONSTRAINT ${oldFk.name};
+    let sql = `ALTER TABLE ${oldFk.tableFrom} DROP CONSTRAINT ${oldFk.name};
 `;
     const onDeleteStatement = newFk.onDelete ? `ON DELETE ${newFk.onDelete}` : "";
     const onUpdateStatement = newFk.onUpdate ? `ON UPDATE ${newFk.onDelete}` : "";
     const fromColumnsString = newFk.columnsFrom.map((it) => `"${it}"`).join(",");
     const toColumnsString = newFk.columnsTo.map((it) => `"${it}"`).join(",");
-    const alterStatement = `ALTER TABLE "${newFk.tableFrom}" ADD CONSTRAINT ${newFk.name} FOREIGN KEY (${fromColumnsString}) REFERENCES ${newFk.tableTo}(${toColumnsString}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
+    const alterStatement = `ALTER TABLE ${newFk.tableFrom} ADD CONSTRAINT ${newFk.name} FOREIGN KEY (${fromColumnsString}) REFERENCES ${newFk.tableTo}(${toColumnsString}) ${onDeleteStatement} ${onUpdateStatement}`.replace(/  +/g, " ").trim();
     sql += "DO $$ BEGIN\n";
     sql += " " + alterStatement + ";\n";
     sql += "EXCEPTION\n";
@@ -11898,7 +11898,7 @@ var PgDeleteForeignKeyConvertor = class extends Convertor {
   convert(statement) {
     const tableFrom = statement.tableName;
     const { name } = PgSquasher.unsquashFK(statement.data);
-    return `ALTER TABLE "${tableFrom}" DROP CONSTRAINT ${name};
+    return `ALTER TABLE ${tableFrom} DROP CONSTRAINT ${name};
 `;
   }
 };