drizzle-kit 0.20.14-a77266f → 0.20.14-f5f86f6

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 = (table4) => true, schemaFilters, progressCallback) => {
+    fromDatabase2 = async (db, tablesFilter = () => true, schemaFilters, progressCallback) => {
       const result = {};
       const internals = { tables: {} };
       const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
@@ -6160,6 +6160,226 @@ 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, {
@@ -11787,6 +12007,13 @@ 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();
@@ -11953,22 +12180,6 @@ 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({
@@ -12462,9 +12673,12 @@ 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],
             {
@@ -12498,7 +12712,11 @@ var init_sqliteSchema = __esm({
       }
     });
     sqliteSchema = schema2;
-    backwardCompatibleSqliteSchema = unionType([schemaV3, schemaV4, schema2]);
+    backwardCompatibleSqliteSchema = unionType([
+      schemaV3,
+      schemaV4,
+      schema2
+    ]);
   }
 });
 
@@ -16142,60 +16360,50 @@ 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;
-      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);
-      }
+      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
+      };
     };
     preparePgPush = async (config, snapshot, schemaFilter) => {
       const schemaPath = config.schema;
-      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);
-      }
+      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 };
     };
     prepareAndMigrateMySql = async (config) => {
       const outFolder = config.out;