drizzle-kit 0.12.13 → 0.12.15

package/index.js

@@ -7349,12 +7349,12 @@ __export(imports_exports, {
   prepareFromMySqlImports: () => prepareFromMySqlImports,
   prepareFromSqliteImports: () => prepareFromSqliteImports
 });
-var import_drizzle_orm_mysql, import_drizzle_orm_pg, import_drizzle_orm_sqlite2, prepareFromImports, prepareFromMySqlImports, prepareFromSqliteImports;
+var import_drizzle_orm_mysql, import_drizzle_orm_pg, import_drizzle_orm_sqlite, prepareFromImports, prepareFromMySqlImports, prepareFromSqliteImports;
 var init_imports = __esm({
   "src/serializer/imports.ts"() {
     import_drizzle_orm_mysql = require("drizzle-orm-mysql");
     import_drizzle_orm_pg = require("drizzle-orm-pg");
-    import_drizzle_orm_sqlite2 = require("drizzle-orm-sqlite");
+    import_drizzle_orm_sqlite = require("drizzle-orm-sqlite");
     prepareFromImports = (imports) => {
       const tables = [];
       const enums = [];
@@ -7398,7 +7398,7 @@ var init_imports = __esm({
         const i0 = require(it);
         const i0values = Object.values(i0);
         i0values.forEach((t) => {
-          if (t instanceof import_drizzle_orm_sqlite2.SQLiteTable) {
+          if (t instanceof import_drizzle_orm_sqlite.SQLiteTable) {
             tables.push(t);
           }
         });
@@ -7413,20 +7413,20 @@ var pgSerializer_exports = {};
 __export(pgSerializer_exports, {
   generatePgSnapshot: () => generatePgSnapshot
 });
-var import_utils2, import_sql2, import_table2, generatePgSnapshot;
+var import_utils, import_sql, import_table, generatePgSnapshot;
 var init_pgSerializer = __esm({
   "src/serializer/pgSerializer.ts"() {
-    import_utils2 = require("drizzle-orm-pg/utils");
-    import_sql2 = require("drizzle-orm/sql");
-    import_table2 = require("drizzle-orm/table");
+    import_utils = require("drizzle-orm-pg/utils");
+    import_sql = require("drizzle-orm/sql");
+    import_table = require("drizzle-orm/table");
     generatePgSnapshot = (tables, enums) => {
       const result = {};
       for (const table4 of tables) {
-        const tableName = (0, import_table2.getTableName)(table4);
+        const tableName = (0, import_table.getTableName)(table4);
         const columnsObject = {};
         const indexesObject = {};
         const foreignKeysObject = {};
-        (0, import_utils2.getTableColumns)(table4).forEach((column4) => {
+        (0, import_utils.getTableColumns)(table4).forEach((column4) => {
           const notNull = column4.notNull;
           const primaryKey = column4.primary;
           const columnToSet = {
@@ -7436,7 +7436,7 @@ var init_pgSerializer = __esm({
             notNull
           };
           if (column4.default !== void 0) {
-            if (column4.default instanceof import_sql2.SQL) {
+            if (column4.default instanceof import_sql.SQL) {
               columnToSet.default = column4.default.queryChunks.map((it) => {
                 if (typeof it === "string") {
                   return `${it}`;
@@ -7449,13 +7449,13 @@ var init_pgSerializer = __esm({
           }
           columnsObject[column4.name] = columnToSet;
         });
-        const foreignKeys = (0, import_utils2.getTableForeignKeys)(table4).map((fk4) => {
+        const foreignKeys = (0, import_utils.getTableForeignKeys)(table4).map((fk4) => {
           const name = fk4.getName();
           const tableFrom = tableName;
           const onDelete = fk4.onDelete;
           const onUpdate = fk4.onUpdate;
           const reference = fk4.reference();
-          const tableTo = (0, import_table2.getTableName)(reference.foreignTable);
+          const tableTo = (0, import_table.getTableName)(reference.foreignTable);
           const columnsFrom = reference.columns.map((it) => it.name);
           const columnsTo = reference.foreignColumns.map((it) => it.name);
           return {
@@ -7471,7 +7471,7 @@ var init_pgSerializer = __esm({
         foreignKeys.forEach((it) => {
           foreignKeysObject[it.name] = it;
         });
-        (0, import_utils2.getTableIndexes)(table4).forEach((value) => {
+        (0, import_utils.getTableIndexes)(table4).forEach((value) => {
           var _a;
           const columns = value.columns;
           const name = value.name;
@@ -7503,6 +7503,111 @@ var init_pgSerializer = __esm({
   }
 });
 
+// src/serializer/sqliteSerializer.ts
+var sqliteSerializer_exports = {};
+__export(sqliteSerializer_exports, {
+  generateSqliteSnapshot: () => generateSqliteSnapshot
+});
+var import_table2, import_sql2, import_drizzle_orm_sqlite2, import_utils2, dialect4, generateSqliteSnapshot;
+var init_sqliteSerializer = __esm({
+  "src/serializer/sqliteSerializer.ts"() {
+    import_table2 = require("drizzle-orm/table");
+    import_sql2 = require("drizzle-orm/sql");
+    import_drizzle_orm_sqlite2 = require("drizzle-orm-sqlite");
+    import_utils2 = require("drizzle-orm-sqlite/utils");
+    dialect4 = new import_drizzle_orm_sqlite2.SQLiteSyncDialect();
+    generateSqliteSnapshot = (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
+          };
+          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("Only strings are allowed in .default()");
+              }).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 dialect4.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 = dialect4.sqlToQuery(value.config.where).sql;
+            }
+          }
+          indexesObject[name] = {
+            name,
+            columns: indexColumns,
+            isUnique: (_a = value.config.unique) != null ? _a : false,
+            where
+          };
+        });
+        result[tableName] = {
+          name: tableName,
+          columns: columnsObject,
+          indexes: indexesObject,
+          foreignKeys: foreignKeysObject
+        };
+      }
+      return { version: "3", dialect: "sqlite", tables: result, enums: {} };
+    };
+  }
+});
+
 // node_modules/.pnpm/heap@0.2.7/node_modules/heap/lib/heap.js
 var require_heap = __commonJS({
   "node_modules/.pnpm/heap@0.2.7/node_modules/heap/lib/heap.js"(exports, module2) {
@@ -17230,104 +17335,6 @@ var import_crypto = require("crypto");
 var import_fs = __toESM(require("fs"));
 var import_node = __toESM(require_node2());
 var import_path = __toESM(require("path"));
-
-// src/serializer/sqliteSerializer.ts
-var import_table = require("drizzle-orm/table");
-var import_sql = require("drizzle-orm/sql");
-var import_drizzle_orm_sqlite = require("drizzle-orm-sqlite");
-var import_utils = require("drizzle-orm-sqlite/utils");
-var dialect4 = new import_drizzle_orm_sqlite.SQLiteSyncDialect();
-var generateSqliteSnapshot = (tables, enums) => {
-  const result = {};
-  for (const table4 of tables) {
-    const tableName = (0, import_table.getTableName)(table4);
-    const columnsObject = {};
-    const indexesObject = {};
-    const foreignKeysObject = {};
-    (0, import_utils.getTableColumns)(table4).forEach((column4) => {
-      const notNull = column4.notNull;
-      const primaryKey = column4.primary;
-      const columnToSet = {
-        name: column4.name,
-        type: column4.getSQLType(),
-        primaryKey,
-        notNull
-      };
-      if (column4.default !== void 0) {
-        if (column4.default instanceof import_sql.SQL) {
-          columnToSet.default = column4.default.queryChunks.map((it) => {
-            if (typeof it === "string") {
-              return `${it}`;
-            }
-            throw new Error("Only strings are allowed in .default()");
-          }).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_utils.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_table.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_utils.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_sql.SQL) {
-          return dialect4.sqlToQuery(it).sql;
-        } else {
-          return it.name;
-        }
-      });
-      let where = void 0;
-      if (value.config.where !== void 0) {
-        if (value.config.where instanceof import_sql.SQL) {
-          where = dialect4.sqlToQuery(value.config.where).sql;
-        }
-      }
-      indexesObject[name] = {
-        name,
-        columns: indexColumns,
-        isUnique: (_a = value.config.unique) != null ? _a : false,
-        where
-      };
-    });
-    result[tableName] = {
-      name: tableName,
-      columns: columnsObject,
-      indexes: indexesObject,
-      foreignKeys: foreignKeysObject
-    };
-  }
-  return { version: "3", dialect: "sqlite", tables: result, enums: {} };
-};
-
-// src/serializer/index.ts
 var serialize = (path3, dialect5) => {
   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));
@@ -17345,9 +17352,11 @@ var serialize = (path3, dialect5) => {
     return {};
   } else if (dialect5 === "sqlite") {
     const { prepareFromSqliteImports: prepareFromSqliteImports2 } = (init_imports(), __toCommonJS(imports_exports));
+    const { generateSqliteSnapshot: generateSqliteSnapshot2 } = (init_sqliteSerializer(), __toCommonJS(sqliteSerializer_exports));
     const { tables, enums } = prepareFromSqliteImports2(filenames);
+    const result = generateSqliteSnapshot2(tables, enums);
     unregister();
-    return generateSqliteSnapshot(tables, enums);
+    return result;
   } else {
     return {};
   }
@@ -19717,6 +19726,7 @@ var update2to3 = (json, prevId) => {
 
 // src/cli/index.ts
 var import_hanji4 = __toESM(require_hanji());
+var import_path4 = __toESM(require("path"));
 var configSchema = objectType({
   schema: stringType(),
   dialect: enumType(["pg", "sqlite", "mysql"]),
@@ -19747,7 +19757,7 @@ var prepareGenerateConfig = (options) => {
   if (!(schema5 || out)) {
     const path3 = config != null ? config : "drizzle.config.json";
     const drizzleConfig = JSON.parse(
-      import_fs6.default.readFileSync(path3).toString()
+      import_fs6.default.readFileSync(import_path4.default.join(import_path4.default.resolve(path3))).toString()
     );
     return drizzleConfig;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.12.13",
+  "version": "0.12.15",
   "repository": "https://github.com/lambda-direct/drizzle-kit",
   "author": "Alex Blokh <aleksandrblokh@gmail.com>",
   "license": "MIT",