drizzle-kit 0.20.0-8d6aad7 → 0.20.0-a6a840b

package/index.d.ts

@@ -41,7 +41,7 @@ export type DbConnection = {
         password?: string;
         database: string;
     } | {
-        connectionString: string;
+        uri: string;
     };
 };
 export type Config = {
@@ -93,7 +93,7 @@ export type Config = {
         password?: string;
         database: string;
     } | {
-        connectionString: string;
+        uri: string;
     };
 } | {
     driver: "d1";

package/orm-extenstions/d1-driver/session.d.ts

@@ -2,10 +2,9 @@ import { entityKind } from "drizzle-orm";
 import type { Logger } from "drizzle-orm";
 import { type RelationalSchemaConfig, type TablesRelationalConfig } from "drizzle-orm";
 import { type Query } from "drizzle-orm";
-import type { SQLiteAsyncDialect, SQLiteExecuteMethod } from "drizzle-orm/sqlite-core";
+import { SQLiteAsyncDialect, SQLiteExecuteMethod, SQLitePreparedQuery, SQLiteSession } from "drizzle-orm/sqlite-core";
 import type { SelectedFieldsOrdered } from "drizzle-orm/sqlite-core";
 import { type PreparedQueryConfig as PreparedQueryConfigBase, type SQLiteTransactionConfig } from "drizzle-orm/sqlite-core";
-import { PreparedQuery as PreparedQueryBase, SQLiteSession } from "drizzle-orm/sqlite-core";
 export interface SQLiteD1SessionOptions {
     logger?: Logger;
 }
@@ -25,7 +24,7 @@ export declare class SQLiteWranglerD1Session<TFullSchema extends Record<string,
     prepareQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][]) => unknown): PreparedQuery;
     transaction<T>(transaction: (tx: any) => T | Promise<T>, config?: SQLiteTransactionConfig): Promise<T>;
 }
-export declare class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends PreparedQueryBase<{
+export declare class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<{
     type: "async";
     run: D1WranglerResults;
     all: T["all"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.20.0-8d6aad7",
+  "version": "0.20.0-a6a840b",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",
@@ -40,7 +40,8 @@
     "packit": "pnpm build && cp package.json dist/ && cd dist && pnpm pack",
     "tsc": "tsc -p tsconfig.build.json",
     "pub": "cp package.json readme.md dist/ && cd dist && npm publish",
-    "studio": "./dist/index.cjs studio --verbose"
+    "studio": "./dist/index.cjs studio --verbose",
+    "studio:dev": "tsx ./src/cli/index.ts studio --verbose"
   },
   "ava": {
     "files": [
@@ -54,7 +55,7 @@
     ]
   },
   "dependencies": {
-    "@drizzle-team/studio": "^0.0.9",
+    "@drizzle-team/studio": "^0.0.27",
     "@esbuild-kit/esm-loader": "^2.5.5",
     "camelcase": "^7.0.1",
     "chalk": "^5.2.0",
@@ -76,20 +77,20 @@
     "@types/glob": "^8.1.0",
     "@types/minimatch": "^5.1.2",
     "@types/node": "^18.11.15",
-    "@types/pg": "^8.6.5",
+    "@types/pg": "^8.10.7",
     "@typescript-eslint/eslint-plugin": "^5.46.1",
     "@typescript-eslint/parser": "^5.46.1",
     "ava": "^5.1.0",
     "better-sqlite3": "^8.4.0",
     "dockerode": "^3.3.4",
     "dotenv": "^16.0.3",
-    "drizzle-orm": "0.28.7-4e094f0",
+    "drizzle-orm": "0.29.0-d3b1c58",
     "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",
     "get-port": "^6.1.2",
     "mysql2": "2.3.3",
-    "pg": "^8.8.0",
+    "pg": "^8.11.3",
     "postgres": "^3.3.5",
     "prettier": "^2.8.1",
     "tsx": "^3.12.1",

package/serializer/pgSerializer.d.ts

@@ -6,4 +6,4 @@ 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

@@ -1,13 +1,31 @@
+import type { Setup } from "@drizzle-team/studio";
 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 { StudioConfigConnections } from "src/cli/validations/studio";
+import { MySQLConnectionConfig } from "src/cli/validations/mysql";
+import { PgConnectionConfig } from "src/cli/validations/pg";
+import { StudioConfigConnections, StudioSqliteConnectionConfig as StudioSQLiteConnectionConfig } from "src/cli/validations/studio";
+export declare const preparePgSchema: (path: string | string[]) => Promise<{
+    schema: Record<string, Record<string, AnyPgTable<{}>>>;
+    relations: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
+}>;
+export declare const prepareMySqlSchema: (path: string | string[]) => Promise<{
+    schema: Record<string, Record<string, AnyMySqlTable<{}>>>;
+    relations: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
+}>;
+export declare const prepareSQLiteSchema: (path: string | string[]) => Promise<{
+    schema: Record<string, Record<string, AnySQLiteTable<{}>>>;
+    relations: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
+}>;
 export declare const prepareModels: (path: string | string[]) => Promise<{
     pgSchema: Record<string, AnyPgTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
     mysqlSchema: Record<string, AnyMySqlTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
     sqliteSchema: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>>;
 }>;
+export declare const drizzleForPostgres: (connectionConfig: PgConnectionConfig, pgSchema: Record<string, Record<string, AnyPgTable>>, relations: Record<string, Relations>, verbose: boolean) => Promise<Setup>;
+export declare const drizzleForMySQL: (config: MySQLConnectionConfig, mysqlSchema: Record<string, Record<string, AnyMySqlTable>>, relations: Record<string, Relations>, verbose: boolean) => Promise<Setup>;
+export declare const drizzleForSQLite: (config: StudioSQLiteConnectionConfig, sqliteSchema: Record<string, Record<string, AnySQLiteTable>>, relations: Record<string, Relations>, verbose: boolean) => Promise<Setup>;
 export declare const drizzleDb: (drizzleConfig: StudioConfigConnections, models: {
     pgSchema?: Record<string, AnyPgTable | Relations>;
     mysqlSchema?: Record<string, AnyMySqlTable | Relations>;

package/utils-studio.d.ts

@@ -2,4 +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 type { DrizzleDbClient } from "./drivers";
+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>>;