drizzle-kit 0.20.14-f5f86f6 → 0.20.14-fa7577a

package/cli/commands/migrate.d.ts

@@ -1,9 +1,9 @@
 import { CommonSchema, CommonSquashedSchema, Dialect } from "../../schemaValidator";
 import { schema } from "../views";
-import { PgSchema } from "../../serializer/pgSchema";
-import { SQLiteSchema } from "../../serializer/sqliteSchema";
-import { MySqlSchema } from "../../serializer/mysqlSchema";
-import { Journal } from "../../utils";
+import { PgSchema } from "src/serializer/pgSchema";
+import { SQLiteSchema } from "src/serializer/sqliteSchema";
+import { MySqlSchema } from "src/serializer/mysqlSchema";
+import { Journal } from "src/utils";
 import { GenerateConfig } from "./utils";
 export type Named = {
     name: string;
@@ -132,7 +132,7 @@ export declare const prepareMySQLPush: (config: {
             schemas: Record<string, string>;
         };
     };
-}>;
+} | undefined>;
 export declare const prepareSQLitePush: (config: {
     schema: string | string[];
 }, snapshot: SQLiteSchema) => Promise<{
@@ -183,7 +183,7 @@ export declare const prepareSQLitePush: (config: {
         tables: {};
         columns: {};
     } | undefined;
-}>;
+} | undefined>;
 export declare const preparePgPush: (config: {
     schema: string | string[];
 }, snapshot: PgSchema, schemaFilter: string[]) => Promise<{
@@ -243,7 +243,7 @@ export declare const preparePgPush: (config: {
             values: Record<string, string>;
         }>;
     };
-}>;
+} | undefined>;
 export declare const prepareAndMigrateMySql: (config: GenerateConfig) => Promise<void>;
 export declare const prepareAndMigrateSqlite: (config: GenerateConfig) => Promise<void>;
 export declare const prepareSQL: (prev: CommonSquashedSchema, cur: CommonSquashedSchema, dialect: Dialect, prevFull?: any, curFull?: any) => Promise<{

package/cli/commands/mysqlPushUtils.d.ts

@@ -1,6 +1,6 @@
 import { DrizzleDbClient } from "src/drivers";
-import { JsonStatement } from "../../jsonStatements";
-import { mysqlSchema } from "../../serializer/mysqlSchema";
+import { JsonStatement } from "src/jsonStatements";
+import { mysqlSchema } from "src/serializer/mysqlSchema";
 import { TypeOf } from "zod";
 export declare const filterStatements: (statements: JsonStatement[], currentSchema: TypeOf<typeof mysqlSchema>, prevSchema: TypeOf<typeof mysqlSchema>) => JsonStatement[];
 export declare const logSuggestionsAndReturn: ({ connection, statements, json2, }: {

package/cli/commands/mysqlUp.d.ts

@@ -1,4 +1,4 @@
-import { MySqlSchema, MySqlSchemaV4 } from "../../serializer/mysqlSchema";
+import { MySqlSchema, MySqlSchemaV4 } from "src/serializer/mysqlSchema";
 export declare const upMysqlHandler: (out: string) => void;
 export declare const upMySqlHandlerV4toV5: (obj: MySqlSchemaV4) => MySqlSchema;
 export declare const upMysqlHandlerV4: (out: string) => void;

package/cli/commands/pgConnect.d.ts

@@ -1,5 +1,5 @@
 import type { PgConnectionConfig } from "../validations/pg";
-import { PgPostgres } from "../../drivers";
+import { PgPostgres } from "src/drivers";
 export declare const connectToPg: (config: PgConnectionConfig) => Promise<{
     client: PgPostgres;
 }>;

package/cli/commands/pgIntrospect.d.ts

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

package/cli/commands/pgPushUtils.d.ts

@@ -1,5 +1,5 @@
-import { DrizzleDbClient } from "../../drivers";
-import { JsonStatement } from "../../jsonStatements";
+import { DrizzleDbClient } from "src/drivers";
+import { JsonStatement } from "src/jsonStatements";
 export declare const pgSuggestions: ({ connection, statements, }: {
     statements: JsonStatement[];
     connection: DrizzleDbClient;

package/cli/commands/pgUp.d.ts

@@ -1,4 +1,4 @@
-import { PgSchema, PgSchemaV4 } from "../../serializer/pgSchema";
+import { PgSchema, PgSchemaV4 } from "src/serializer/pgSchema";
 export declare const upPgHandlerV4toV5: (obj: PgSchemaV4) => PgSchema;
 export declare const upPgHandler: (out: string) => void;
 export declare const upPgHandlerV4: (out: string) => void;

package/cli/commands/sqlitePushUtils.d.ts

@@ -1,6 +1,6 @@
-import { DrizzleDbClient } from "../../drivers";
-import { JsonStatement } from "../../jsonStatements";
-import { SQLiteSchemaInternal, SQLiteSchemaSquashed } from "../../serializer/sqliteSchema";
+import { DrizzleDbClient } from "src/drivers";
+import { JsonStatement } from "src/jsonStatements";
+import { SQLiteSchemaInternal, SQLiteSchemaSquashed } from "src/serializer/sqliteSchema";
 export declare const _moveDataStatements: (tableName: string, json: SQLiteSchemaSquashed, dataLoss?: boolean) => string[];
 export declare const getOldTableName: (tableName: string, meta: SQLiteSchemaInternal["_meta"]) => string;
 export declare const getNewTableName: (tableName: string, meta: SQLiteSchemaInternal["_meta"]) => string;

package/cli/commands/upFolders.d.ts

@@ -1,4 +1,4 @@
-import { Dialect } from "../../schemaValidator";
+import { Dialect } from "src/schemaValidator";
 import { Named, NamedWithSchema } from "./migrate";
 export declare const resolveSchemas: <T extends Named>(missingSchemas: T[], newSchemas: T[], predicate: (leftMissing: T[], created: T) => T | undefined) => {
     created: T[];

package/cli/commands/utils.d.ts

@@ -1,8 +1,4 @@
 import { TypeOf } from "zod";
-import { CliParamsPush } from "..";
-import { MySQLPushConfig } from "../validations/mysql";
-import { PgPushConfig } from "../validations/pg";
-import { SQLitePushConfig } from "../validations/sqlite";
 export declare const safeRegister: () => Promise<{
     unregister: () => void;
 }>;
@@ -20,11 +16,6 @@ export declare const prepareGenerateConfig: (options: {
     breakpoints: boolean;
     custom: boolean;
 }) => Promise<GenerateConfig>;
-export declare const preparePushConfig: (options: CliParamsPush) => Promise<{
-    config: MySQLPushConfig | PgPushConfig | SQLitePushConfig;
-    schemaFiles: string[];
-    tablesFilter: string[];
-}>;
 export declare const assertOutFolder: (it: {
     config?: string;
 } | {
@@ -47,8 +38,8 @@ export declare const configCommonSchema: import("zod").ZodObject<{
     schemaFilter: string | string[];
 }, {
     out?: string | undefined;
-    driver?: "turso" | "better-sqlite" | "libsql" | "d1" | "pg" | "mysql2" | "expo" | undefined;
     breakpoints?: boolean | undefined;
+    driver?: "turso" | "better-sqlite" | "libsql" | "d1" | "pg" | "mysql2" | "expo" | undefined;
     tablesFilter?: string | string[] | undefined;
     schemaFilter?: string | string[] | undefined;
     schema: string | string[];
@@ -190,8 +181,8 @@ export declare const mySqlCliConfigSchema: import("zod").ZodIntersection<import(
     schemaFilter: string | string[];
 }, {
     out?: string | undefined;
-    driver?: "turso" | "better-sqlite" | "libsql" | "d1" | "pg" | "mysql2" | "expo" | undefined;
     breakpoints?: boolean | undefined;
+    driver?: "turso" | "better-sqlite" | "libsql" | "d1" | "pg" | "mysql2" | "expo" | undefined;
     tablesFilter?: string | string[] | undefined;
     schemaFilter?: string | string[] | undefined;
     schema: string | string[];

package/cli/validations/common.d.ts

@@ -3,7 +3,7 @@ export type CollusionCheckOutput = {
     message?: string;
     action: "config" | "cli" | "error";
 };
-export type Commands = "push:sqlite" | "introspect:sqlite" | "introspect:pg" | "generate" | "check:pg" | "check:mysql" | "check:sqlite" | "up:pg" | "up:mysql" | "up:sqlite" | "drop" | "introspect:mysql" | "push:mysql" | "push:pg";
+export type Commands = "push:sqlite" | "introspect:sqlite" | "introspect:pg" | "generate:pg" | "generate:sqlite" | "generate:mysql" | "check:pg" | "check:mysql" | "check:sqlite" | "up:pg" | "up:mysql" | "up:sqlite" | "drop" | "introspect:mysql" | "push:mysql" | "push:pg";
 /**
  * This function checks an input from a user and if there are any params together with config path - return true
  * @param options - user input

package/cli/views.d.ts

@@ -1,5 +1,5 @@
 import { Prompt, TaskView } from "hanji";
-import type { CommonSchema } from "../schemaValidator";
+import type { CommonSchema } from "src/schemaValidator";
 import type { Named } from "./commands/migrate";
 export declare const warning: (msg: string) => void;
 export declare const err: (msg: string) => void;

package/package.json

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

package/payload.js

@@ -2090,7 +2090,7 @@ ${withStyle.errorWarning(
         --end;
       return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
     };
-    fromDatabase2 = async (db, tablesFilter = () => true, schemaFilters, progressCallback) => {
+    fromDatabase2 = async (db, tablesFilter = (table4) => true, schemaFilters, progressCallback) => {
       const result = {};
       const internals = { tables: {} };
       const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
@@ -6160,226 +6160,6 @@ var init_lib = __esm({
   }
 });
 
-// src/cli/validations/common.ts
-var init_common = __esm({
-  "src/cli/validations/common.ts"() {
-    init_outputs();
-  }
-});
-
-// src/cli/validations/mysql.ts
-var mysqlConnectionCli, mysql2credentials, mysqlConnectionConfig, mysqlConfigIntrospectSchema, mysqlCliIntrospectParams, mysqlCliPushParams, mysqlConfigPushParams;
-var init_mysql = __esm({
-  "src/cli/validations/mysql.ts"() {
-    init_lib();
-    init_utils();
-    init_common();
-    init_outputs();
-    mysqlConnectionCli = unionType([
-      objectType({
-        driver: literalType("mysql2"),
-        host: stringType(),
-        port: coerce.number().optional(),
-        user: stringType().default("mysql"),
-        password: stringType().optional(),
-        database: stringType()
-      }),
-      objectType({
-        driver: literalType("mysql2"),
-        uri: stringType()
-        // TODO: change docs
-      })
-    ]);
-    mysql2credentials = unionType([
-      objectType({
-        host: stringType(),
-        port: coerce.number().optional(),
-        user: stringType().default("mysql"),
-        password: stringType().optional(),
-        database: stringType()
-      }),
-      objectType({
-        uri: stringType()
-        // TODO: change docs
-      })
-    ]);
-    mysqlConnectionConfig = objectType({
-      driver: literalType("mysql2"),
-      dbCredentials: mysql2credentials
-    });
-    mysqlConfigIntrospectSchema = intersectionType(
-      configIntrospectSchema,
-      mysqlConnectionConfig
-    );
-    mysqlCliIntrospectParams = intersectionType(
-      configIntrospectCliSchema,
-      mysqlConnectionCli
-    );
-    mysqlCliPushParams = intersectionType(
-      configPushSchema,
-      mysqlConnectionCli
-    );
-    mysqlConfigPushParams = intersectionType(
-      configPushSchema,
-      mysqlConnectionConfig
-    );
-  }
-});
-
-// src/cli/validations/pg.ts
-var pgConnectionCli, pgConnectionConfig, pgConfigIntrospectSchema, pgCliIntrospectParams, pgCliPushParams, pgConfigPushParams;
-var init_pg = __esm({
-  "src/cli/validations/pg.ts"() {
-    init_lib();
-    init_utils();
-    init_common();
-    init_outputs();
-    pgConnectionCli = unionType([
-      objectType({
-        driver: literalType("pg"),
-        host: stringType(),
-        port: coerce.number().optional(),
-        user: stringType().default("postgres"),
-        password: stringType().optional(),
-        database: stringType(),
-        ssl: coerce.boolean().optional(),
-        type: literalType("params").default("params")
-      }),
-      objectType({
-        driver: literalType("pg"),
-        connectionString: stringType(),
-        type: literalType("url").default("url")
-      })
-    ]);
-    pgConnectionConfig = unionType([
-      objectType({
-        driver: literalType("pg"),
-        dbCredentials: objectType({
-          host: stringType(),
-          port: coerce.number().optional(),
-          user: stringType().default("postgres"),
-          password: stringType().optional(),
-          database: stringType(),
-          ssl: coerce.boolean().optional(),
-          type: literalType("params").default("params").optional()
-        })
-      }),
-      objectType({
-        driver: literalType("pg"),
-        dbCredentials: objectType({
-          connectionString: stringType(),
-          type: literalType("url").default("url").optional()
-        })
-      })
-    ]);
-    pgConfigIntrospectSchema = intersectionType(
-      configIntrospectSchema,
-      pgConnectionConfig
-    );
-    pgCliIntrospectParams = intersectionType(
-      configIntrospectCliSchema,
-      pgConnectionCli
-    );
-    pgCliPushParams = intersectionType(
-      configPushSchema,
-      pgConnectionCli
-    );
-    pgConfigPushParams = intersectionType(
-      configPushSchema,
-      pgConnectionConfig
-    );
-  }
-});
-
-// src/cli/commands/sqliteUtils.ts
-var sqliteConnectionSchema, sqliteCliConfigSchema;
-var init_sqliteUtils = __esm({
-  "src/cli/commands/sqliteUtils.ts"() {
-    init_lib();
-    init_utils();
-    sqliteConnectionSchema = unionType([
-      objectType({
-        driver: literalType("turso"),
-        dbCredentials: objectType({
-          url: stringType(),
-          authToken: stringType().optional()
-        })
-      }),
-      objectType({
-        driver: literalType("libsql"),
-        dbCredentials: objectType({
-          url: stringType()
-        })
-      }),
-      objectType({
-        driver: literalType("better-sqlite"),
-        dbCredentials: objectType({
-          url: stringType()
-        })
-      })
-    ]);
-    sqliteCliConfigSchema = intersectionType(
-      configIntrospectSchema,
-      sqliteConnectionSchema
-    );
-  }
-});
-
-// src/cli/validations/sqlite.ts
-var sqliteConnectionCli, sqliteCliIntrospectParams, sqliteCliPushParams, sqliteConfigPushParams;
-var init_sqlite = __esm({
-  "src/cli/validations/sqlite.ts"() {
-    init_lib();
-    init_sqliteUtils();
-    init_utils();
-    init_common();
-    init_outputs();
-    sqliteConnectionCli = unionType([
-      objectType({
-        driver: literalType("turso"),
-        url: stringType(),
-        authToken: stringType()
-      }),
-      objectType({
-        driver: literalType("better-sqlite"),
-        url: stringType()
-      }),
-      objectType({
-        driver: literalType("libsql"),
-        url: stringType()
-      })
-    ]);
-    sqliteCliIntrospectParams = intersectionType(
-      configIntrospectCliSchema,
-      sqliteConnectionCli
-    );
-    sqliteCliPushParams = intersectionType(
-      configPushSchema,
-      sqliteConnectionCli
-    );
-    sqliteConfigPushParams = intersectionType(
-      configPushSchema,
-      sqliteConnectionSchema
-    );
-  }
-});
-
-// src/global.ts
-var originUUID, snapshotVersion, mapValues;
-var init_global = __esm({
-  "src/global.ts"() {
-    originUUID = "00000000-0000-0000-0000-000000000000";
-    snapshotVersion = "5";
-    mapValues = (obj, map) => {
-      const result = Object.keys(obj).reduce(function(result2, key) {
-        result2[key] = map(obj[key]);
-        return result2;
-      }, {});
-      return result;
-    };
-  }
-});
-
 // src/cli/commands/_es5.ts
 var es5_exports = {};
 __export(es5_exports, {
@@ -12007,13 +11787,6 @@ var init_utils = __esm({
     init_source();
     init_views();
     import_hanji2 = __toESM(require_hanji());
-    init_mysql();
-    init_pg();
-    init_sqlite();
-    init_outputs();
-    init_pg();
-    init_sqlite();
-    init_global();
     assertES5 = async (unregister) => {
       try {
         init_es5();
@@ -12180,6 +11953,22 @@ var init_pgImports = __esm({
   }
 });
 
+// src/global.ts
+var originUUID, snapshotVersion, mapValues;
+var init_global = __esm({
+  "src/global.ts"() {
+    originUUID = "00000000-0000-0000-0000-000000000000";
+    snapshotVersion = "5";
+    mapValues = (obj, map) => {
+      const result = Object.keys(obj).reduce(function(result2, key) {
+        result2[key] = map(obj[key]);
+        return result2;
+      }, {});
+      return result;
+    };
+  }
+});
+
 // src/serializer/pgSchema.ts
 var indexV2, columnV2, tableV2, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, index, fk, column, tableV3, compositePK, uniqueConstraint, tableV4, table, schemaHash, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaExternal, kitInternals, pgSchemaInternal, tableSquashed, tableSquashedV4, pgSchemaSquashedV4, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchema, backwardCompatiblePgSchema, PgSquasher, squashPgScheme, dryPg;
 var init_pgSchema = __esm({
@@ -12673,12 +12462,9 @@ var init_sqliteSchema = __esm({
           const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
             return SQLiteSquasher.squashPK(pk);
           });
-          const squashedUniqueConstraints = mapValues(
-            it[1].uniqueConstraints,
-            (unq) => {
-              return SQLiteSquasher.squashUnique(unq);
-            }
-          );
+          const squashedUniqueConstraints = mapValues(it[1].uniqueConstraints, (unq) => {
+            return SQLiteSquasher.squashUnique(unq);
+          });
           return [
             it[0],
             {
@@ -12712,11 +12498,7 @@ var init_sqliteSchema = __esm({
       }
     });
     sqliteSchema = schema2;
-    backwardCompatibleSqliteSchema = unionType([
-      schemaV3,
-      schemaV4,
-      schema2
-    ]);
+    backwardCompatibleSqliteSchema = unionType([schemaV3, schemaV4, schema2]);
   }
 });
 
@@ -16360,50 +16142,60 @@ var init_migrate = __esm({
         return { sqlStatements, statements, validatedCur, validatedPrev };
       } catch (e) {
         console.error(e);
-        process.exit(1);
       }
     };
     prepareSQLitePush = async (config, snapshot) => {
       const schemaPath = config.schema;
-      const { prev, cur } = await prepareSQLiteDbPushSnapshot(snapshot, schemaPath);
-      const validatedPrev = sqliteSchema.parse(prev);
-      const validatedCur = sqliteSchema.parse(cur);
-      const squashedPrev = squashSqliteScheme(validatedPrev);
-      const squashedCur = squashSqliteScheme(validatedCur);
-      const { sqlStatements, statements, _meta } = await prepareSQL(
-        squashedPrev,
-        squashedCur,
-        "sqlite",
-        validatedPrev,
-        validatedCur
-      );
-      return {
-        sqlStatements,
-        statements,
-        squashedPrev,
-        squashedCur,
-        meta: _meta
-      };
+      try {
+        const { prev, cur } = await prepareSQLiteDbPushSnapshot(
+          snapshot,
+          schemaPath
+        );
+        const validatedPrev = sqliteSchema.parse(prev);
+        const validatedCur = sqliteSchema.parse(cur);
+        const squashedPrev = squashSqliteScheme(validatedPrev);
+        const squashedCur = squashSqliteScheme(validatedCur);
+        const { sqlStatements, statements, _meta } = await prepareSQL(
+          squashedPrev,
+          squashedCur,
+          "sqlite",
+          validatedPrev,
+          validatedCur
+        );
+        return {
+          sqlStatements,
+          statements,
+          squashedPrev,
+          squashedCur,
+          meta: _meta
+        };
+      } catch (e) {
+        console.error(e);
+      }
     };
     preparePgPush = async (config, snapshot, schemaFilter) => {
       const schemaPath = config.schema;
-      const { prev, cur } = await preparePgDbPushSnapshot(
-        snapshot,
-        schemaPath,
-        schemaFilter
-      );
-      const validatedPrev = pgSchema.parse(prev);
-      const validatedCur = pgSchema.parse(cur);
-      const squashedPrev = squashPgScheme(validatedPrev);
-      const squashedCur = squashPgScheme(validatedCur);
-      const { sqlStatements, statements } = await prepareSQL(
-        squashedPrev,
-        squashedCur,
-        "pg",
-        validatedPrev,
-        validatedCur
-      );
-      return { sqlStatements, statements, squashedPrev, squashedCur };
+      try {
+        const { prev, cur } = await preparePgDbPushSnapshot(
+          snapshot,
+          schemaPath,
+          schemaFilter
+        );
+        const validatedPrev = pgSchema.parse(prev);
+        const validatedCur = pgSchema.parse(cur);
+        const squashedPrev = squashPgScheme(validatedPrev);
+        const squashedCur = squashPgScheme(validatedCur);
+        const { sqlStatements, statements } = await prepareSQL(
+          squashedPrev,
+          squashedCur,
+          "pg",
+          validatedPrev,
+          validatedCur
+        );
+        return { sqlStatements, statements, squashedPrev, squashedCur };
+      } catch (e) {
+        console.error(e);
+      }
     };
     prepareAndMigrateMySql = async (config) => {
       const outFolder = config.out;