drizzle-kit 0.20.16 → 0.20.17

package/bin.cjs

@@ -22453,23 +22453,23 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve2, reject) {
-          isexe(path5, options || {}, function(er, is8) {
+          isexe(path5, options || {}, function(er, is9) {
             if (er) {
               reject(er);
             } else {
-              resolve2(is8);
+              resolve2(is9);
             }
           });
         });
       }
-      core(path5, options || {}, function(er, is8) {
+      core(path5, options || {}, function(er, is9) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
-            is8 = false;
+            is9 = false;
           }
         }
-        cb(er, is8);
+        cb(er, is9);
       });
     }
     function sync2(path5, options) {
@@ -22532,8 +22532,8 @@ var require_lib = __commonJS({
         const p2 = getPathPart(envPart, cmd);
         for (const ext2 of pathExt) {
           const withExt = p2 + ext2;
-          const is8 = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
-          if (is8) {
+          const is9 = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is9) {
             if (!opt.all) {
               return withExt;
             }
@@ -22556,8 +22556,8 @@ var require_lib = __commonJS({
         const p2 = getPathPart(pathEnvPart, cmd);
         for (const ext2 of pathExt) {
           const withExt = p2 + ext2;
-          const is8 = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
-          if (is8) {
+          const is9 = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is9) {
             if (!opt.all) {
               return withExt;
             }
@@ -60336,9 +60336,12 @@ __export(studio_exports, {
   drizzleForMySQL: () => drizzleForMySQL,
   drizzleForPostgres: () => drizzleForPostgres,
   drizzleForSQLite: () => drizzleForSQLite,
+  prepareMySqlSchema: () => prepareMySqlSchema,
+  preparePgSchema: () => preparePgSchema,
+  prepareSQLiteSchema: () => prepareSQLiteSchema,
   prepareServer: () => prepareServer
 });
-var import_node_https, drizzleForPostgres, drizzleForMySQL, prepareParams, drizzleForSQLite, init, proxySchema, schema4, jsonStringify, prepareServer;
+var import_node_https, import_pg_core4, import_drizzle_orm8, import_mysql_core4, import_sqlite_core3, preparePgSchema, prepareMySqlSchema, prepareSQLiteSchema, getCustomDefaults, drizzleForPostgres, drizzleForMySQL, prepareParams, drizzleForSQLite, init, proxySchema, defaultsSchema, schema4, jsonStringify, prepareServer;
 var init_studio = __esm({
   "src/serializer/studio.ts"() {
     init_dist();
@@ -60350,7 +60353,110 @@ var init_studio = __esm({
     init_lib();
     init_utils3();
     init_global();
-    drizzleForPostgres = async (connectionConfig) => {
+    init_serializer();
+    import_pg_core4 = require("drizzle-orm/pg-core");
+    import_drizzle_orm8 = require("drizzle-orm");
+    init_utils();
+    import_mysql_core4 = require("drizzle-orm/mysql-core");
+    import_sqlite_core3 = require("drizzle-orm/sqlite-core");
+    preparePgSchema = async (path5) => {
+      const imports = prepareFilenames(path5);
+      const pgSchema3 = {};
+      const relations4 = {};
+      const { unregister } = await safeRegister();
+      for (let i = 0; i < imports.length; i++) {
+        const it = imports[i];
+        const i0 = require(`${it}`);
+        const i0values = Object.entries(i0);
+        i0values.forEach(([k, t]) => {
+          if ((0, import_drizzle_orm8.is)(t, import_pg_core4.PgTable)) {
+            const schema5 = (0, import_pg_core4.getTableConfig)(t).schema || "public";
+            pgSchema3[schema5] = pgSchema3[schema5] || {};
+            pgSchema3[schema5][k] = t;
+          }
+          if ((0, import_drizzle_orm8.is)(t, import_drizzle_orm8.Relations)) {
+            relations4[k] = t;
+          }
+        });
+      }
+      unregister();
+      return { schema: pgSchema3, relations: relations4 };
+    };
+    prepareMySqlSchema = async (path5) => {
+      const imports = prepareFilenames(path5);
+      const mysqlSchema5 = {
+        public: {}
+      };
+      const relations4 = {};
+      const { unregister } = await safeRegister();
+      for (let i = 0; i < imports.length; i++) {
+        const it = imports[i];
+        const i0 = require(`${it}`);
+        const i0values = Object.entries(i0);
+        i0values.forEach(([k, t]) => {
+          if ((0, import_drizzle_orm8.is)(t, import_mysql_core4.MySqlTable)) {
+            const schema5 = (0, import_mysql_core4.getTableConfig)(t).schema || "public";
+            mysqlSchema5[schema5][k] = t;
+          }
+          if ((0, import_drizzle_orm8.is)(t, import_drizzle_orm8.Relations)) {
+            relations4[k] = t;
+          }
+        });
+      }
+      unregister();
+      return { schema: mysqlSchema5, relations: relations4 };
+    };
+    prepareSQLiteSchema = async (path5) => {
+      const imports = prepareFilenames(path5);
+      const sqliteSchema3 = {
+        public: {}
+      };
+      const relations4 = {};
+      const { unregister } = await safeRegister();
+      for (let i = 0; i < imports.length; i++) {
+        const it = imports[i];
+        const i0 = require(`${it}`);
+        const i0values = Object.entries(i0);
+        i0values.forEach(([k, t]) => {
+          if ((0, import_drizzle_orm8.is)(t, import_sqlite_core3.SQLiteTable)) {
+            const schema5 = "public";
+            sqliteSchema3[schema5][k] = t;
+          }
+          if ((0, import_drizzle_orm8.is)(t, import_drizzle_orm8.Relations)) {
+            relations4[k] = t;
+          }
+        });
+      }
+      unregister();
+      return { schema: sqliteSchema3, relations: relations4 };
+    };
+    getCustomDefaults = (schema5) => {
+      const customDefaults = [];
+      Object.entries(schema5).map(([schema6, tables]) => {
+        Object.entries(tables).map(([, table4]) => {
+          let tableConfig;
+          if ((0, import_drizzle_orm8.is)(table4, import_pg_core4.PgTable)) {
+            tableConfig = (0, import_pg_core4.getTableConfig)(table4);
+          } else if ((0, import_drizzle_orm8.is)(table4, import_mysql_core4.MySqlTable)) {
+            tableConfig = (0, import_mysql_core4.getTableConfig)(table4);
+          } else {
+            tableConfig = (0, import_sqlite_core3.getTableConfig)(table4);
+          }
+          tableConfig.columns.map((column7) => {
+            if (column7.defaultFn) {
+              customDefaults.push({
+                schema: schema6,
+                table: tableConfig.name,
+                column: column7.name,
+                func: column7.defaultFn
+              });
+            }
+          });
+        });
+      });
+      return customDefaults;
+    };
+    drizzleForPostgres = async (connectionConfig, pgSchema3, relations4) => {
       assertPackages("pg");
       const pg = await Promise.resolve().then(() => __toESM(require_lib3()));
       const client = new pg.default.Pool(connectionConfig.dbCredentials);
@@ -60362,12 +60468,14 @@ var init_studio = __esm({
         });
         return result.rows;
       };
+      const customDefaults = getCustomDefaults(pgSchema3);
       return {
         dialect: "pg",
-        proxy
+        proxy,
+        customDefaults
       };
     };
-    drizzleForMySQL = async (config) => {
+    drizzleForMySQL = async (config, mysqlSchema5, relations4) => {
       assertPackages("mysql2");
       const { createPool } = await Promise.resolve().then(() => __toESM(require_promise()));
       const client = createPool({ ...config.dbCredentials, connectionLimit: 1 });
@@ -60379,9 +60487,11 @@ var init_studio = __esm({
         });
         return result[0];
       };
+      const customDefaults = getCustomDefaults(mysqlSchema5);
       return {
         dialect: "mysql",
-        proxy
+        proxy,
+        customDefaults
       };
     };
     prepareParams = (params) => {
@@ -60392,15 +60502,17 @@ var init_studio = __esm({
         return param;
       });
     };
-    drizzleForSQLite = async (config) => {
+    drizzleForSQLite = async (config, sqliteSchema3, relations4) => {
       const { driver: driver2, dbCredentials } = config;
+      const customDefaults = getCustomDefaults(sqliteSchema3);
       if (driver2 === "d1") {
         const proxy = async (params) => {
           throw new Error("Proxy is not implemented for D1");
         };
         return {
           dialect: "sqlite",
-          proxy
+          proxy,
+          customDefaults
         };
       }
       if (driver2 === "better-sqlite") {
@@ -60416,7 +60528,8 @@ var init_studio = __esm({
         };
         return {
           dialect: "sqlite",
-          proxy
+          proxy,
+          customDefaults
         };
       }
       if (driver2 === "libsql" || driver2 === "turso") {
@@ -60437,7 +60550,8 @@ var init_studio = __esm({
         };
         return {
           dialect: "sqlite",
-          proxy
+          proxy,
+          customDefaults
         };
       }
       assertUnreachable(driver2);
@@ -60454,9 +60568,18 @@ var init_studio = __esm({
         method: mod.union([mod.literal("values"), mod.literal("get"), mod.literal("all"), mod.literal("run"), mod.literal("execute")])
       })
     });
+    defaultsSchema = mod.object({
+      type: mod.literal("defaults"),
+      data: mod.array(mod.object({
+        schema: mod.string(),
+        table: mod.string(),
+        column: mod.string()
+      })).min(1)
+    });
     schema4 = mod.union([
       init,
-      proxySchema
+      proxySchema,
+      defaultsSchema
     ]);
     SuperJSON.registerCustom(
       {
@@ -60479,7 +60602,7 @@ var init_studio = __esm({
         return value;
       });
     };
-    prepareServer = async ({ dialect: dialect6, proxy }, app) => {
+    prepareServer = async ({ dialect: dialect6, proxy, customDefaults }, app) => {
       app = app !== void 0 ? app : new Hono2();
       app.use(cors());
       app.onError((err2, ctx) => {
@@ -60493,7 +60616,12 @@ var init_studio = __esm({
         const body = c.req.valid("json");
         const { type } = body;
         if (type === "init") {
-          return c.json({ version: "4", dialect: dialect6 });
+          const preparedDefaults = customDefaults.map((d) => ({
+            schema: d.schema,
+            table: d.table,
+            column: d.column
+          }));
+          return c.json({ version: "5", dialect: dialect6, customDefaults: preparedDefaults });
         }
         if (type === "proxy") {
           const { sql: sql2, params, mode, method } = body.data;
@@ -60505,6 +60633,23 @@ var init_studio = __esm({
           });
           return c.json(JSON.parse(jsonStringify(result)));
         }
+        if (type === "defaults") {
+          const columns = body.data;
+          const result = columns.map((column7) => {
+            const found = customDefaults.find((d) => {
+              return d.schema === column7.schema && d.table === column7.table && d.column === column7.column;
+            });
+            if (!found) {
+              throw new Error(`Custom default not found for ${column7.schema}.${column7.table}.${column7.column}`);
+            }
+            const value = found.func();
+            return {
+              ...column7,
+              value
+            };
+          });
+          return c.json(JSON.parse(jsonStringify(result)));
+        }
         throw new Error(`Unknown type: ${type}`);
       });
       return {
@@ -62371,10 +62516,10 @@ __export(drivers_exports, {
   PgPostgres: () => PgPostgres,
   TursoSqlite: () => TursoSqlite
 });
-var import_drizzle_orm8, DrizzleDbClient, DrizzleORMPgClient, DrizzleORMMySQLClient, DrizzleORMSQLiteClient, BetterSqlite, MySQL2Client, TursoSqlite, PgPostgres;
+var import_drizzle_orm9, DrizzleDbClient, DrizzleORMPgClient, DrizzleORMMySQLClient, DrizzleORMSQLiteClient, BetterSqlite, MySQL2Client, TursoSqlite, PgPostgres;
 var init_drivers = __esm({
   "src/drivers/index.ts"() {
-    import_drizzle_orm8 = require("drizzle-orm");
+    import_drizzle_orm9 = require("drizzle-orm");
     DrizzleDbClient = class {
       constructor(db) {
         this.db = db;
@@ -62382,30 +62527,30 @@ var init_drivers = __esm({
     };
     DrizzleORMPgClient = class extends DrizzleDbClient {
       async query(query, values) {
-        const res = await this.db.execute(import_drizzle_orm8.sql.raw(query));
+        const res = await this.db.execute(import_drizzle_orm9.sql.raw(query));
         return res.rows;
       }
       async run(query) {
-        const res = await this.db.execute(import_drizzle_orm8.sql.raw(query));
+        const res = await this.db.execute(import_drizzle_orm9.sql.raw(query));
         return res.rows;
       }
     };
     DrizzleORMMySQLClient = class extends DrizzleDbClient {
       async query(query, values) {
-        const res = await this.db.execute(import_drizzle_orm8.sql.raw(query));
+        const res = await this.db.execute(import_drizzle_orm9.sql.raw(query));
         return res[0];
       }
       async run(query) {
-        await this.db.execute(import_drizzle_orm8.sql.raw(query));
+        await this.db.execute(import_drizzle_orm9.sql.raw(query));
       }
     };
     DrizzleORMSQLiteClient = class extends DrizzleDbClient {
       async query(query, values) {
-        const res = this.db.all(import_drizzle_orm8.sql.raw(query));
+        const res = this.db.all(import_drizzle_orm9.sql.raw(query));
         return res;
       }
       async run(query) {
-        this.db.run(import_drizzle_orm8.sql.raw(query));
+        this.db.run(import_drizzle_orm9.sql.raw(query));
       }
     };
     BetterSqlite = class extends DrizzleDbClient {
@@ -62560,10 +62705,10 @@ var init_pgConnect = __esm({
 });
 
 // src/introspect-pg.ts
-var import_drizzle_orm9, import_relations, pgImportsList, objToStatement22, timeConfig2, possibleIntervals, intervalStrToObj, intervalConfig, importsPatch2, relations2, withCasing, schemaToTypeScript2, isCyclic2, isSelf2, column5, dimensionsInArray, createTableColumns2, createTableIndexes2, createTablePKs2, createTableUniques2, createTableFKs2;
+var import_drizzle_orm10, import_relations, pgImportsList, objToStatement22, timeConfig2, possibleIntervals, intervalStrToObj, intervalConfig, importsPatch2, relations2, withCasing, schemaToTypeScript2, isCyclic2, isSelf2, column5, dimensionsInArray, createTableColumns2, createTableIndexes2, createTablePKs2, createTableUniques2, createTableFKs2;
 var init_introspect_pg = __esm({
   "src/introspect-pg.ts"() {
-    import_drizzle_orm9 = require("drizzle-orm");
+    import_drizzle_orm10 = require("drizzle-orm");
     import_relations = require("drizzle-orm/relations");
     init_utils4();
     init_pgSerializer();
@@ -63745,7 +63890,7 @@ init_source();
 // package.json
 var package_default = {
   name: "drizzle-kit",
-  version: "0.20.16",
+  version: "0.20.17",
   repository: "https://github.com/drizzle-team/drizzle-kit-mirror",
   author: "Drizzle Team",
   license: "MIT",
@@ -66550,22 +66695,34 @@ var studioCommand = new import_commander.Command("studio").option("--port <port>
   const drizzleConfig = await validateStudio2(options);
   const {
     drizzleForPostgres: drizzleForPostgres2,
+    preparePgSchema: preparePgSchema2,
+    prepareMySqlSchema: prepareMySqlSchema2,
     drizzleForMySQL: drizzleForMySQL2,
+    prepareSQLiteSchema: prepareSQLiteSchema2,
     drizzleForSQLite: drizzleForSQLite2
   } = await Promise.resolve().then(() => (init_studio(), studio_exports));
   const { driver: driver2, schema: schemaPath } = drizzleConfig;
   let setup;
   if (driver2 === "pg") {
+    const { schema: schema5, relations: relations4 } = await preparePgSchema2(schemaPath);
     setup = await drizzleForPostgres2(
-      drizzleConfig
+      drizzleConfig,
+      schema5,
+      relations4
     );
   } else if (driver2 === "mysql2") {
+    const { schema: schema5, relations: relations4 } = await prepareMySqlSchema2(schemaPath);
     setup = await drizzleForMySQL2(
-      drizzleConfig
+      drizzleConfig,
+      schema5,
+      relations4
     );
   } else if (driver2 === "better-sqlite" || driver2 === "d1" || driver2 === "libsql" || driver2 === "turso") {
+    const { schema: schema5, relations: relations4 } = await prepareSQLiteSchema2(schemaPath);
     setup = await drizzleForSQLite2(
-      drizzleConfig
+      drizzleConfig,
+      schema5,
+      relations4
     );
   } else {
     assertUnreachable(driver2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.20.16",
+  "version": "0.20.17",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",