drizzle-kit 0.20.0-5198fb7 → 0.20.0-c31f6ba

package/utils.js

@@ -4410,7 +4410,7 @@ var index, fk, column, tableV3, compositePK, uniqueConstraint, tableV4, table, d
 var init_mysqlSchema = __esm({
   "src/serializer/mysqlSchema.ts"() {
     init_global();
-    init_utilsR();
+    init_utils4();
     init_lib();
     index = objectType({
       name: stringType(),
@@ -4660,7 +4660,7 @@ var indexV2, columnV2, tableV2, enumSchema, pgSchemaV2, references, columnV1, ta
 var init_pgSchema = __esm({
   "src/serializer/pgSchema.ts"() {
     init_global();
-    init_utilsR();
+    init_utils4();
     init_lib();
     indexV2 = objectType({
       name: stringType(),
@@ -4989,7 +4989,7 @@ var index3, fk3, compositePK3, column3, tableV33, uniqueConstraint3, table3, dia
 var init_sqliteSchema = __esm({
   "src/serializer/sqliteSchema.ts"() {
     init_global();
-    init_utilsR();
+    init_utils4();
     init_lib();
     index3 = objectType({
       name: stringType(),
@@ -11726,9 +11726,10 @@ var pgSerializer_exports = {};
 __export(pgSerializer_exports, {
   fromDatabase: () => fromDatabase2,
   generatePgSnapshot: () => generatePgSnapshot,
-  indexName: () => indexName2
+  indexName: () => indexName2,
+  toDrizzle: () => toDrizzle
 });
-var import_pg_core2, import_pg_core3, import_drizzle_orm5, import_drizzle_orm6, dialect4, indexName2, generatePgSnapshot, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
+var import_pg_core2, import_pg_core3, import_drizzle_orm5, import_drizzle_orm6, dialect4, indexName2, generatePgSnapshot, trimChar, fromDatabase2, columnToDefault, defaultForColumn, toDrizzle;
 var init_pgSerializer = __esm({
   "src/serializer/pgSerializer.ts"() {
     import_pg_core2 = require("drizzle-orm/pg-core");
@@ -12339,6 +12340,94 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
         }
       }
     };
+    toDrizzle = (schema4) => {
+      const tables = {};
+      Object.values(schema4.tables).forEach((t) => {
+        const columns = {};
+        Object.values(t.columns).forEach((c) => {
+          const columnName = c.name;
+          const type = c.type;
+          let columnBuilder;
+          if (type === "bigint") {
+            columnBuilder = new import_pg_core2.PgBigInt53Builder(columnName);
+          } else if (type === "bigserial") {
+            columnBuilder = new import_pg_core2.PgBigSerial53Builder(columnName);
+          } else if (type === "boolean") {
+            columnBuilder = new import_pg_core2.PgBooleanBuilder(columnName);
+          } else if (type === "cidr") {
+            columnBuilder = new import_pg_core2.PgCidrBuilder(columnName);
+          } else if (type === "date") {
+            columnBuilder = new import_pg_core2.PgDateBuilder(columnName);
+          } else if (type === "double precision") {
+            columnBuilder = new import_pg_core2.PgDoublePrecisionBuilder(columnName);
+          } else if (type === "inet") {
+            columnBuilder = new import_pg_core2.PgInetBuilder(columnName);
+          } else if (type === "integer") {
+            columnBuilder = new import_pg_core2.PgIntegerBuilder(columnName);
+          } else if (type === "interval" || type.startsWith("interval ")) {
+            columnBuilder = new import_pg_core2.PgIntervalBuilder(columnName, {});
+          } else if (type === "json") {
+            columnBuilder = new import_pg_core2.PgJsonBuilder(columnName);
+          } else if (type === "jsonb") {
+            columnBuilder = new import_pg_core2.PgJsonbBuilder(columnName);
+          } else if (type === "macaddr") {
+            columnBuilder = new import_pg_core2.PgMacaddrBuilder(columnName);
+          } else if (type === "macaddr8") {
+            columnBuilder = new import_pg_core2.PgMacaddr8Builder(columnName);
+          } else if (type === "numeric" || type.startsWith("numeric(")) {
+            columnBuilder = new import_pg_core2.PgNumericBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new import_pg_core2.PgRealBuilder(columnName);
+          } else if (type === "serial") {
+            columnBuilder = new import_pg_core2.PgSerialBuilder(columnName);
+          } else if (type === "smallint") {
+            columnBuilder = new import_pg_core2.PgSmallIntBuilder(columnName);
+          } else if (type === "smallserial") {
+            columnBuilder = new import_pg_core2.PgSmallSerialBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new import_pg_core2.PgTextBuilder(columnName, {});
+          } else if (type === "time" || type.startsWith("time(") || type === "time with time zone") {
+            columnBuilder = new import_pg_core2.PgTimeBuilder(columnName, false, void 0);
+          } else if (type === "timestamp" || type.startsWith("timestamp(") || type === "timestamp with time zone") {
+            columnBuilder = new import_pg_core2.PgTimestampBuilder(columnName, false, void 0);
+          } else if (type === "uuid") {
+            columnBuilder = new import_pg_core2.PgUUIDBuilder(columnName);
+          } else if (type === "varchar" || type.startsWith("varchar(")) {
+            columnBuilder = new import_pg_core2.PgVarcharBuilder(columnName, {});
+          } else if (type === "char" || type.startsWith("char(")) {
+            columnBuilder = new import_pg_core2.PgCharBuilder(columnName, {});
+          } else {
+            columnBuilder = (0, import_pg_core2.customType)({
+              dataType() {
+                return type;
+              }
+            })(columnName);
+          }
+          if (c.notNull) {
+            columnBuilder = columnBuilder.notNull();
+          }
+          if (c.default) {
+            columnBuilder = columnBuilder.default(c.default);
+          }
+          if (c.primaryKey) {
+            columnBuilder = columnBuilder.primaryKey();
+          }
+          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
+            );
+          });
+          return res;
+        });
+      });
+      return tables;
+    };
   }
 });
 
@@ -12378,7 +12467,7 @@ var sqliteSerializer_exports = {};
 __export(sqliteSerializer_exports, {
   fromDatabase: () => fromDatabase3,
   generateSqliteSnapshot: () => generateSqliteSnapshot,
-  toDrizzle: () => toDrizzle
+  toDrizzle: () => toDrizzle2
 });
 function mapSqlToSqliteType(sqlType) {
   if ([
@@ -12415,7 +12504,7 @@ function mapSqlToSqliteType(sqlType) {
     return "numeric";
   }
 }
-var import_drizzle_orm8, import_drizzle_orm9, import_sqlite_core2, dialect5, generateSqliteSnapshot, fromDatabase3, toDrizzle;
+var import_drizzle_orm8, import_drizzle_orm9, import_sqlite_core2, dialect5, generateSqliteSnapshot, fromDatabase3, toDrizzle2;
 var init_sqliteSerializer = __esm({
   "src/serializer/sqliteSerializer.ts"() {
     import_drizzle_orm8 = require("drizzle-orm");
@@ -12784,7 +12873,7 @@ WHERE
         }
       };
     };
-    toDrizzle = (schema4) => {
+    toDrizzle2 = (schema4) => {
       const tables = {};
       Object.values(schema4.tables).forEach((t) => {
         const columns = {};
@@ -14349,7 +14438,7 @@ var init_migrate = __esm({
     init_pgSchema();
     init_sqliteSchema();
     init_mysqlSchema();
-    init_utilsR();
+    init_utils4();
     init_words();
     init_outputs();
     prepareAndMigratePg = async (config) => {
@@ -16619,12 +16708,13 @@ var init_jsonStatements = __esm({
     };
     prepareAddCompositePrimaryKeyPg = (tableName, schema4, pks, json2) => {
       return Object.values(pks).map((it) => {
+        const unsquashed = MySqlSquasher.unsquashPK(it);
         return {
           type: "create_composite_pk",
           tableName,
           data: it,
           schema: schema4,
-          constraintName: json2.tables[tableName].compositePrimaryKeys[`${tableName}_${PgSquasher.unsquashPK(it).columns.join("_")}`].name
+          constraintName: json2.tables[tableName].compositePrimaryKeys[unsquashed.name].name
         };
       });
     };
@@ -16722,7 +16812,7 @@ var init_snapshotsDiffer = __esm({
     init_lib();
     init_jsonDiffer();
     init_jsonStatements();
-    init_utilsR();
+    init_utils4();
     init_sqliteSchema();
     init_mysqlSchema();
     makeChanged = (schema4) => {
@@ -17032,8 +17122,6 @@ var init_snapshotsDiffer = __esm({
             deletedColumns = SQLiteSquasher.unsquashPK(deletedPkColumns);
           }
         }
-        addedColumns.sort();
-        deletedColumns.sort();
         const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
         let addedCompositePKs = [];
         let deletedCompositePKs = [];
@@ -17343,7 +17431,7 @@ var init_pgUp = __esm({
     init_source();
     init_global();
     init_pgSchema();
-    init_utilsR();
+    init_utils4();
   }
 });
 
@@ -17352,7 +17440,7 @@ var init_mysqlUp = __esm({
   "src/cli/commands/mysqlUp.ts"() {
     init_source();
     init_mysqlSchema();
-    init_utilsR();
+    init_utils4();
   }
 });
 
@@ -17364,7 +17452,7 @@ var init_upFolders = __esm({
     init_mysqlSchema();
     init_sqliteSchema();
     init_snapshotsDiffer();
-    init_utilsR();
+    init_utils4();
     init_words();
     init_pgUp();
     init_pgSchema();
@@ -23471,7 +23559,7 @@ var init_drivers = __esm({
 });
 
 // src/cli/commands/pgIntrospect.ts
-var import_hanji4, import_pg, pgPushIntrospect;
+var import_hanji4, import_pg, connectToPg, pgPushIntrospect;
 var init_pgIntrospect = __esm({
   "src/cli/commands/pgIntrospect.ts"() {
     import_hanji4 = __toESM(require_hanji());
@@ -23482,6 +23570,16 @@ var init_pgIntrospect = __esm({
     init_global();
     init_mjs();
     init_drivers();
+    connectToPg = async (config) => {
+      if (config.driver === "pg") {
+        const client = new import_pg.Client(config.dbCredentials);
+        await client.connect();
+        const connection = new PgPostgres(client);
+        return { client: connection };
+      } else {
+        throw Error(`Only "pg" is available as a driver option for introspection`);
+      }
+    };
     pgPushIntrospect = async (connection, filters, schemaFilters) => {
       const { client } = connection;
       const matchers = filters.map((it) => {
@@ -55939,9 +56037,9 @@ var init_studioUtils = __esm({
   }
 });
 
-// src/utilsR.ts
-var utilsR_exports = {};
-__export(utilsR_exports, {
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
   assertV1OutFolder: () => assertV1OutFolder,
   columnRenameKey: () => columnRenameKey,
   defineConfig: () => defineConfig,
@@ -55961,13 +56059,13 @@ __export(utilsR_exports, {
   tableRenameKey: () => tableRenameKey,
   validateWithReport: () => validateWithReport
 });
-module.exports = __toCommonJS(utilsR_exports);
+module.exports = __toCommonJS(utils_exports);
 function defineConfig(config) {
   return config;
 }
 var import_fs4, import_path3, import_crypto2, assertV1OutFolder, dryJournal, snapshotsPriorV4, prepareOutFolder2, mapValues, validatorForDialect, validateWithReport, prepareMigrationFolder, prepareMigrationMeta, schemaRenameKey, tableRenameKey, columnRenameKey, kloudMeta, statementsForDiffs, generateDrizzleJson, generateMigration, pushSchema, prepareFrom;
-var init_utilsR = __esm({
-  "src/utilsR.ts"() {
+var init_utils4 = __esm({
+  "src/utils.ts"() {
     import_fs4 = require("fs");
     init_views();
     init_mysqlSchema();
@@ -55986,6 +56084,7 @@ var init_utilsR = __esm({
     init_pgPushUtils();
     init_sqliteIntrospect();
     init_sqliteSerializer();
+    init_pgSerializer();
     init_studioUtils();
     assertV1OutFolder = (out, dialect6) => {
       if (!(0, import_fs4.existsSync)(out))
@@ -56303,14 +56402,27 @@ var init_utilsR = __esm({
           preparedConnection.client,
           []
         );
-        const models = toDrizzle(schema4);
+        const models = toDrizzle2(schema4);
         return await drizzleDb(connection, { sqliteSchema: models }, false);
+      } else if (connection.driver === "pg") {
+        const preparedConnection = await connectToPg({
+          driver: connection.driver,
+          // @ts-ignore I don't know how to fix it yet. But will find a way
+          dbCredentials: connection.dbCredentials
+        });
+        const { schema: schema4 } = await pgPushIntrospect(
+          { client: preparedConnection.client },
+          [],
+          []
+        );
+        const models = toDrizzle(schema4);
+        return await drizzleDb(connection, { pgSchema: models }, false);
       }
-      throw Error("Only sqlite is supported for now");
+      throw Error("Only sqlite and pg is supported for now");
     };
   }
 });
-init_utilsR();
+init_utils4();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   assertV1OutFolder,

package/utilsR.d.ts

@@ -1,232 +0,0 @@
-import { Dialect } from "./schemaValidator";
-import { NamedWithSchema } from "./cli/commands/migrate";
-import { AnyPgTable, PgDatabase } from "drizzle-orm/pg-core";
-import { PgSchema as PgSchemaKit } from "./serializer/pgSchema";
-import { Config, DbConnection } from "src";
-export declare const assertV1OutFolder: (out: string, dialect: Dialect | "{dialect}") => void;
-export type Journal = {
-    version: string;
-    dialect: Dialect;
-    entries: {
-        idx: number;
-        version: string;
-        when: number;
-        tag: string;
-        breakpoints: boolean;
-    }[];
-};
-export declare const dryJournal: (dialect: Dialect) => Journal;
-export declare const snapshotsPriorV4: (out: string) => string[];
-export declare function defineConfig(config: Config): Config;
-export declare const prepareOutFolder: (out: string, dialect: Dialect) => {
-    meta: string;
-    snapshots: string[];
-    journal: any;
-};
-export declare const mapValues: <IN, OUT>(obj: Record<string, IN>, map: (input: IN) => OUT) => Record<string, OUT>;
-export declare const validateWithReport: (snapshots: string[], dialect: Dialect) => {
-    malformed: string[];
-    nonLatest: string[];
-    idsMap: Record<string, {
-        parent: string;
-        snapshots: string[];
-    }>;
-    rawMap: Record<string, any>;
-};
-export declare const prepareMigrationFolder: (outFolder: string | undefined, dialect: Dialect) => {
-    snapshots: string[];
-    journal: any;
-};
-export declare const prepareMigrationMeta: (schemas: {
-    from: string;
-    to: string;
-}[], tables: {
-    from: NamedWithSchema;
-    to: NamedWithSchema;
-}[], columns: {
-    from: {
-        table: string;
-        schema: string;
-        column: string;
-    };
-    to: {
-        table: string;
-        schema: string;
-        column: string;
-    };
-}[]) => {
-    schemas: {};
-    tables: {};
-    columns: {};
-};
-export declare const schemaRenameKey: (it: string) => string;
-export declare const tableRenameKey: (it: NamedWithSchema) => string;
-export declare const columnRenameKey: (table: string, schema: string, column: string) => string;
-export declare const kloudMeta: () => {
-    pg: number[];
-    mysql: number[];
-    sqlite: number[];
-};
-export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
-    left: {
-        internal?: {
-            tables: Record<string, {
-                columns: Record<string, {
-                    isArray?: boolean | undefined;
-                    dimensions?: number | undefined;
-                    rawType?: string | undefined;
-                } | undefined>;
-            } | undefined>;
-        } | undefined;
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "pg";
-        tables: Record<string, {
-            name: string;
-            columns: Record<string, {
-                isUnique?: any;
-                default?: any;
-                uniqueName?: string | undefined;
-                nullsNotDistinct?: boolean | undefined;
-                name: string;
-                type: string;
-                primaryKey: boolean;
-                notNull: boolean;
-            }>;
-            indexes: Record<string, {
-                name: string;
-                columns: string[];
-                isUnique: boolean;
-            }>;
-            foreignKeys: Record<string, {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                name: string;
-                tableFrom: string;
-                columnsFrom: string[];
-                tableTo: string;
-                columnsTo: string[];
-            }>;
-            schema: string;
-            compositePrimaryKeys: Record<string, {
-                name: string;
-                columns: string[];
-            }>;
-            uniqueConstraints: Record<string, {
-                name: string;
-                columns: string[];
-                nullsNotDistinct: boolean;
-            }>;
-        }>;
-        schemas: Record<string, string>;
-        _meta: {
-            columns: Record<string, string>;
-            tables: Record<string, string>;
-            schemas: Record<string, string>;
-        };
-        enums: Record<string, {
-            name: string;
-            values: Record<string, string>;
-        }>;
-    };
-    right: {
-        internal?: {
-            tables: Record<string, {
-                columns: Record<string, {
-                    isArray?: boolean | undefined;
-                    dimensions?: number | undefined;
-                    rawType?: string | undefined;
-                } | undefined>;
-            } | undefined>;
-        } | undefined;
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "pg";
-        tables: Record<string, {
-            name: string;
-            columns: Record<string, {
-                isUnique?: any;
-                default?: any;
-                uniqueName?: string | undefined;
-                nullsNotDistinct?: boolean | undefined;
-                name: string;
-                type: string;
-                primaryKey: boolean;
-                notNull: boolean;
-            }>;
-            indexes: Record<string, {
-                name: string;
-                columns: string[];
-                isUnique: boolean;
-            }>;
-            foreignKeys: Record<string, {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                name: string;
-                tableFrom: string;
-                columnsFrom: string[];
-                tableTo: string;
-                columnsTo: string[];
-            }>;
-            schema: string;
-            compositePrimaryKeys: Record<string, {
-                name: string;
-                columns: string[];
-            }>;
-            uniqueConstraints: Record<string, {
-                name: string;
-                columns: string[];
-                nullsNotDistinct: boolean;
-            }>;
-        }>;
-        schemas: Record<string, string>;
-        _meta: {
-            columns: Record<string, string>;
-            tables: Record<string, string>;
-            schemas: Record<string, string>;
-        };
-        enums: Record<string, {
-            name: string;
-            values: Record<string, string>;
-        }>;
-    };
-    statements: import("./jsonStatements").JsonStatement[];
-    sqlStatements: string[];
-    _meta: {
-        schemas: {};
-        tables: {};
-        columns: {};
-    } | undefined;
-}>;
-export type DrizzleSnapshotJSON = PgSchemaKit;
-export declare const generateDrizzleJson: (imports: Record<string, unknown>, prevId?: string) => PgSchemaKit;
-export declare const generateMigration: (prev: DrizzleSnapshotJSON, cur: DrizzleSnapshotJSON) => Promise<string[]>;
-export declare const pushSchema: (imports: Record<string, unknown>, db: PgDatabase<any>) => Promise<{
-    hasDataLoss: boolean;
-    warnings: string[];
-    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/sqlite-core").AnySQLiteTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
-} | {
-    db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database<Record<string, never>>;
-    type: "sqlite";
-    schema: Record<string, import("drizzle-orm/sqlite-core").AnySQLiteTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
-} | {
-    db: import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>;
-    type: "sqlite";
-    schema: Record<string, import("drizzle-orm/sqlite-core").AnySQLiteTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
-}>;