drizzle-kit 0.20.0-50d6b73 → 0.20.0-572b8ee

package/cli/commands/pgIntrospect.d.ts

@@ -1,5 +1,6 @@
 import type { PgConfigIntrospect } from "../validations/pg";
 import type { DrizzleDbClient } from "src/drivers";
+export declare const pgSchemas: (client: DrizzleDbClient) => Promise<string[]>;
 export declare const pgPushIntrospect: (connection: {
     client: DrizzleDbClient;
 }, filters: string[], schemaFilters: string[]) => Promise<{

package/drivers/index.d.ts

@@ -1,6 +1,6 @@
-import { Client } from "@libsql/client";
-import { PgDatabase } from "drizzle-orm/pg-core";
-import { Client as PgClient } from "pg";
+import type { Client } from "@libsql/client";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import type { Client as PgClient } from "pg";
 export declare abstract class DrizzleDbClient<T = any> {
     protected db: T;
     constructor(db: T);

package/index.cjs

@@ -12701,7 +12701,7 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
         }
       }
     };
-    toDrizzle = (schema4) => {
+    toDrizzle = (schema4, schemaName) => {
       const tables = {};
       Object.values(schema4.tables).forEach((t) => {
         const columns = {};
@@ -12775,17 +12775,31 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
           }
           columns[columnName] = columnBuilder;
         });
-        tables[t.name] = (0, import_pg_core2.pgTable)(t.name, columns, (cb) => {
-          const res = {};
-          Object.values(t.compositePrimaryKeys).forEach((cpk) => {
-            const gh = cpk.columns.map((c) => cb[c]);
-            res[cpk.name] = new import_pg_core2.PrimaryKeyBuilder(
-              gh,
-              cpk.name
-            );
+        if (schemaName === "public") {
+          tables[t.name] = (0, import_pg_core2.pgTable)(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new import_pg_core2.PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
           });
-          return res;
-        });
+        } else {
+          tables[t.name] = (0, import_pg_core2.pgSchema)(schemaName).table(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new import_pg_core2.PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        }
       });
       return tables;
     };
@@ -25262,9 +25276,10 @@ var init_pgConnect = __esm({
 var pgIntrospect_exports = {};
 __export(pgIntrospect_exports, {
   pgIntrospect: () => pgIntrospect,
-  pgPushIntrospect: () => pgPushIntrospect
+  pgPushIntrospect: () => pgPushIntrospect,
+  pgSchemas: () => pgSchemas
 });
-var import_hanji4, pgPushIntrospect, pgIntrospect;
+var import_hanji4, pgSchemas, pgPushIntrospect, pgIntrospect;
 var init_pgIntrospect = __esm({
   "src/cli/commands/pgIntrospect.ts"() {
     import_hanji4 = __toESM(require_hanji());
@@ -25273,6 +25288,18 @@ var init_pgIntrospect = __esm({
     init_introspect();
     init_global();
     init_mjs();
+    pgSchemas = async (client) => {
+      const res = await client.query(`select s.nspname as table_schema,
+                s.oid as schema_id,
+                u.usename as owner
+              from pg_catalog.pg_namespace s
+              join pg_catalog.pg_user u on u.usesysid = s.nspowner
+              where nspname not in ('information_schema', 'pg_catalog')
+               and nspname not like 'pg_toast%'
+               and nspname not like 'pg_temp_%'
+              order by table_schema;`);
+      return res.map((it) => it["table_schema"]);
+    };
     pgPushIntrospect = async (connection, filters, schemaFilters) => {
       const { client } = connection;
       const matchers = filters.map((it) => {
@@ -58014,7 +58041,7 @@ var init_studioUtils = __esm({
     prepareModels = async (path4) => {
       const imports = prepareFilenames(path4);
       const sqliteSchema2 = {};
-      const pgSchema3 = {};
+      const pgSchema4 = {};
       const mysqlSchema4 = {};
       const { unregister } = await safeRegister();
       for (let i = 0; i < imports.length; i++) {
@@ -58023,7 +58050,7 @@ var init_studioUtils = __esm({
         const i0values = Object.entries(i0);
         i0values.forEach(([k, t]) => {
           if ((0, import_drizzle_orm14.is)(t, import_pg_core4.PgTable)) {
-            pgSchema3[k] = t;
+            pgSchema4[k] = t;
           }
           if ((0, import_drizzle_orm14.is)(t, import_mysql_core4.MySqlTable)) {
             mysqlSchema4[k] = t;
@@ -58033,22 +58060,19 @@ var init_studioUtils = __esm({
           }
           if ((0, import_drizzle_orm14.is)(t, import_drizzle_orm14.Relations)) {
             sqliteSchema2[k] = t;
-            pgSchema3[k] = t;
+            pgSchema4[k] = t;
             mysqlSchema4[k] = t;
           }
         });
       }
       unregister();
-      return { pgSchema: pgSchema3, mysqlSchema: mysqlSchema4, sqliteSchema: sqliteSchema2 };
+      return { pgSchema: pgSchema4, mysqlSchema: mysqlSchema4, sqliteSchema: sqliteSchema2 };
     };
-    drizzleDb = async (drizzleConfig, models, logger) => {
+    drizzleDb = async (drizzleConfig, models, logger, pgClient) => {
       if (drizzleConfig.driver === "pg") {
         const { drizzle: drizzle2 } = await import("drizzle-orm/node-postgres");
-        const { Pool, types } = await Promise.resolve().then(() => __toESM(require_lib2()));
-        const client = new Pool({ ...drizzleConfig.dbCredentials, max: 1 });
-        types.setTypeParser(types.builtins.INTERVAL, (val) => val);
         return {
-          db: drizzle2(client, { logger }),
+          db: drizzle2(pgClient, { logger }),
           type: "pg",
           schema: models.pgSchema
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.20.0-50d6b73",
+  "version": "0.20.0-572b8ee",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",

package/serializer/pgSerializer.d.ts

@@ -1,9 +1,9 @@
 import { AnyPgTable, PgEnum, PgSchema } from "drizzle-orm/pg-core";
 import { Relations } from "drizzle-orm";
-import type { IntrospectStage, IntrospectStatus } from "src/cli/views";
-import type { PgSchemaInternal } from "src/serializer/pgSchema";
-import type { DrizzleDbClient } from "src/drivers";
+import type { IntrospectStage, IntrospectStatus } from "../cli/views";
+import type { PgSchemaInternal } from "../serializer/pgSchema";
+import type { DrizzleDbClient } from "../drivers";
 export declare const indexName: (tableName: string, columns: string[]) => string;
 export declare const generatePgSnapshot: (tables: AnyPgTable[], enums: PgEnum<any>[], schemas: PgSchema[], schemaFilter?: string[]) => PgSchemaInternal;
 export declare const fromDatabase: (db: DrizzleDbClient, tablesFilter: ((table: string) => boolean) | undefined, schemaFilters: string[], progressCallback?: ((stage: IntrospectStage, count: number, status: IntrospectStatus) => void) | undefined) => Promise<PgSchemaInternal>;
-export declare const toDrizzle: (schema: PgSchemaInternal) => Record<string, AnyPgTable | Relations>;
+export declare const toDrizzle: (schema: PgSchemaInternal, schemaName: string) => Record<string, AnyPgTable | Relations>;

package/serializer/studioUtils.d.ts

@@ -2,6 +2,7 @@ import { Relations } from "drizzle-orm";
 import { AnyMySqlTable } from "drizzle-orm/mysql-core";
 import { AnyPgTable } from "drizzle-orm/pg-core";
 import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+import type { Pool } from "pg";
 import { StudioConfigConnections } from "src/cli/validations/studio";
 export declare const prepareModels: (path: string | string[]) => Promise<{
     pgSchema: Record<string, AnyPgTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
@@ -12,7 +13,7 @@ export declare const drizzleDb: (drizzleConfig: StudioConfigConnections, models:
     pgSchema?: Record<string, AnyPgTable | Relations>;
     mysqlSchema?: Record<string, AnyMySqlTable | Relations>;
     sqliteSchema?: Record<string, AnySQLiteTable | Relations>;
-}, logger: boolean) => Promise<{
+}, logger: boolean, pgClient?: Pool) => Promise<{
     db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>>;
     type: "pg";
     schema: Record<string, AnyPgTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;

package/utils-studio.d.ts

@@ -2,3 +2,4 @@ export { toDrizzle as drizzleSchemaPg } from "./serializer/pgSerializer";
 export { toDrizzle as drizzleSchemaSQLite } from "./serializer/sqliteSerializer";
 export { sqlitePushIntrospect } from "./cli/commands/sqliteIntrospect";
 export { pgPushIntrospect } from "./cli/commands/pgIntrospect";
+export { DrizzleORMPgClient } from "./drivers";

package/utils-studio.js

@@ -967,7 +967,7 @@ var init_pgSerializer = __esm({
         }
       }
     };
-    toDrizzle = (schema) => {
+    toDrizzle = (schema, schemaName) => {
       const tables = {};
       Object.values(schema.tables).forEach((t) => {
         const columns = {};
@@ -1041,17 +1041,31 @@ var init_pgSerializer = __esm({
           }
           columns[columnName] = columnBuilder;
         });
-        tables[t.name] = (0, import_pg_core.pgTable)(t.name, columns, (cb) => {
-          const res = {};
-          Object.values(t.compositePrimaryKeys).forEach((cpk) => {
-            const gh = cpk.columns.map((c) => cb[c]);
-            res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
-              gh,
-              cpk.name
-            );
+        if (schemaName === "public") {
+          tables[t.name] = (0, import_pg_core.pgTable)(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
           });
-          return res;
-        });
+        } else {
+          tables[t.name] = (0, import_pg_core.pgSchema)(schemaName).table(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        }
       });
       return tables;
     };
@@ -2094,9 +2108,33 @@ var require_brace_expansion = __commonJS({
   }
 });
 
+// src/drivers/index.ts
+var import_drizzle_orm3, DrizzleDbClient, DrizzleORMPgClient;
+var init_drivers = __esm({
+  "src/drivers/index.ts"() {
+    import_drizzle_orm3 = require("drizzle-orm");
+    DrizzleDbClient = class {
+      constructor(db) {
+        this.db = db;
+      }
+    };
+    DrizzleORMPgClient = class extends DrizzleDbClient {
+      async query(query, values) {
+        const res = await this.db.execute(import_drizzle_orm3.sql.raw(query));
+        return res.rows;
+      }
+      async run(query) {
+        const res = await this.db.execute(import_drizzle_orm3.sql.raw(query));
+        return res.rows;
+      }
+    };
+  }
+});
+
 // src/utils-studio.ts
 var utils_studio_exports = {};
 __export(utils_studio_exports, {
+  DrizzleORMPgClient: () => DrizzleORMPgClient,
   drizzleSchemaPg: () => toDrizzle,
   drizzleSchemaSQLite: () => toDrizzle2,
   pgPushIntrospect: () => pgPushIntrospect,
@@ -3316,8 +3354,12 @@ var pgPushIntrospect = async (connection, filters, schemaFilters) => {
   const { internal, ...schemaWithoutInternals } = schema;
   return { schema: schemaWithoutInternals };
 };
+
+// src/utils-studio.ts
+init_drivers();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DrizzleORMPgClient,
   drizzleSchemaPg,
   drizzleSchemaSQLite,
   pgPushIntrospect,

package/utils.d.ts

@@ -1,6 +1,6 @@
 import { Dialect } from "./schemaValidator";
 import { NamedWithSchema } from "./cli/commands/migrate";
-import { AnyPgTable, PgDatabase } from "drizzle-orm/pg-core";
+import { PgDatabase } from "drizzle-orm/pg-core";
 import { PgSchema as PgSchemaKit } from "./serializer/pgSchema";
 import { Config, DbConnection } from ".";
 export declare const assertV1OutFolder: (out: string, dialect: Dialect | "{dialect}") => void;
@@ -209,24 +209,4 @@ export declare const pushSchema: (imports: Record<string, unknown>, db: PgDataba
     statementsToExecute: string[];
     apply: () => Promise<void>;
 }>;
-export declare const prepareFrom: (connection: DbConnection) => Promise<{
-    db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>>;
-    type: "pg";
-    schema: Record<string, AnyPgTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
-} | {
-    db: import("drizzle-orm/mysql2").MySql2Database<Record<string, never>>;
-    type: "mysql";
-    schema: Record<string, import("drizzle-orm/mysql-core").AnyMySqlTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
-} | {
-    db: import("./orm-extenstions/d1-driver/driver").DrizzleD1WranglerDatabase<Record<string, never>>;
-    type: "sqlite";
-    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
-} | {
-    db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database<Record<string, never>>;
-    type: "sqlite";
-    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
-} | {
-    db: import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>;
-    type: "sqlite";
-    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
-}>;
+export declare const prepareFrom: (connection: DbConnection) => Promise<Record<string, any>>;