drizzle-kit 0.20.14-a77266f → 0.20.14-f5f86f6

package/payload.mjs

@@ -2103,7 +2103,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 ");
@@ -6178,6 +6178,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, {
@@ -11805,6 +12025,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();
@@ -11975,22 +12202,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({
@@ -12484,9 +12695,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],
             {
@@ -12520,7 +12734,11 @@ var init_sqliteSchema = __esm({
       }
     });
     sqliteSchema = schema2;
-    backwardCompatibleSqliteSchema = unionType([schemaV3, schemaV4, schema2]);
+    backwardCompatibleSqliteSchema = unionType([
+      schemaV3,
+      schemaV4,
+      schema2
+    ]);
   }
 });
 
@@ -16170,60 +16388,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;

package/schemaValidator.d.ts

@@ -1,5 +1,5 @@
 import { TypeOf } from "zod";
-declare const dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
+export declare const dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
 export type Dialect = TypeOf<typeof dialect>;
 declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"5">;

package/serializer/mysqlSerializer.d.ts

@@ -1,6 +1,6 @@
 import { AnyMySqlTable, MySqlSchema } from "drizzle-orm/mysql-core";
-import { MySqlSchemaInternal } from "src/serializer/mysqlSchema";
-import { IntrospectStage, IntrospectStatus } from "src/cli/views";
+import { MySqlSchemaInternal } from "../serializer/mysqlSchema";
+import { IntrospectStage, IntrospectStatus } from "../cli/views";
 import { DrizzleDbClient } from "src/drivers";
 export declare const indexName: (tableName: string, columns: string[]) => string;
 export declare const generateMySqlSnapshot: (tables: AnyMySqlTable[], enums: any[], mysqlSchemas: MySqlSchema[]) => MySqlSchemaInternal;

package/serializer/sqliteSerializer.d.ts

@@ -1,6 +1,6 @@
 import type { SQLiteSchemaInternal } from "../serializer/sqliteSchema";
 import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
-import type { IntrospectStage, IntrospectStatus } from "src/cli/views";
-import type { DrizzleDbClient } from "src/drivers";
+import type { IntrospectStage, IntrospectStatus } from "../cli/views";
+import type { DrizzleDbClient } from "../drivers";
 export declare const generateSqliteSnapshot: (tables: AnySQLiteTable[], enums: any[]) => SQLiteSchemaInternal;
 export declare const fromDatabase: (db: DrizzleDbClient, tablesFilter?: (table: string) => boolean, progressCallback?: ((stage: IntrospectStage, count: number, status: IntrospectStatus) => void) | undefined) => Promise<SQLiteSchemaInternal>;

package/serializer/studioUtils.d.ts

@@ -0,0 +1,65 @@
+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 { MySQLConnectionConfig } from "../cli/validations/mysql";
+import { PgConnectionConfig } from "../cli/validations/pg";
+import { StudioConfigConnections, StudioSqliteConnectionConfig as StudioSQLiteConnectionConfig } from "../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>, ts: {
+    imports: string;
+    declarations: string;
+    schemaEntry: string;
+}, verbose: boolean) => Promise<Setup>;
+export declare const drizzleForMySQL: (config: MySQLConnectionConfig, mysqlSchema: Record<string, Record<string, AnyMySqlTable>>, relations: Record<string, Relations>, ts: {
+    imports: string;
+    declarations: string;
+    schemaEntry: string;
+}, verbose: boolean) => Promise<Setup>;
+export declare const drizzleForSQLite: (config: StudioSQLiteConnectionConfig, sqliteSchema: Record<string, Record<string, AnySQLiteTable>>, relations: Record<string, Relations>, ts: {
+    imports: string;
+    declarations: string;
+    schemaEntry: string;
+}, verbose: boolean) => Promise<Setup>;
+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<{
+    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;
+} | {
+    db: import("drizzle-orm/mysql2").MySql2Database<Record<string, never>>;
+    type: "mysql";
+    schema: Record<string, AnyMySqlTable<{}> | 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, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>> | undefined;
+} | {
+    db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database<Record<string, never>>;
+    type: "sqlite";
+    schema: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>> | undefined;
+} | {
+    db: import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>;
+    type: "sqlite";
+    schema: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>> | undefined;
+}>;

package/utils/certs.d.ts

@@ -0,0 +1,4 @@
+export declare const certs: () => Promise<{
+    key: string;
+    cert: string;
+} | null>;

package/utils-studio.js

@@ -1081,6 +1081,14 @@ var init_views = __esm({
   }
 });
 
+// src/global.ts
+var originUUID;
+var init_global = __esm({
+  "src/global.ts"() {
+    originUUID = "00000000-0000-0000-0000-000000000000";
+  }
+});
+
 // src/serializer/index.ts
 var glob;
 var init_serializer = __esm({
@@ -1571,7 +1579,7 @@ var init_pgSerializer = __esm({
         --end;
       return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
     };
-    fromDatabase2 = async (db, tablesFilter = (table) => 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 ");
@@ -2166,11 +2174,7 @@ var sqliteSchemaToDrizzle = (schema) => {
 
 // src/cli/commands/sqliteIntrospect.ts
 init_views();
-
-// src/global.ts
-var originUUID = "00000000-0000-0000-0000-000000000000";
-
-// src/cli/commands/sqliteIntrospect.ts
+init_global();
 init_sqliteSerializer();
 
 // node_modules/.pnpm/camelcase@7.0.1/node_modules/camelcase/index.js
@@ -3356,6 +3360,7 @@ var import_relations = require("drizzle-orm/relations");
 init_pgSerializer();
 
 // src/cli/commands/pgIntrospect.ts
+init_global();
 var pgPushIntrospect = async (connection, filters, schemaFilters) => {
   const { client } = connection;
   const matchers = filters.map((it) => {

package/utils-studio.mjs

@@ -1083,6 +1083,14 @@ var init_views = __esm({
   }
 });
 
+// src/global.ts
+var originUUID;
+var init_global = __esm({
+  "src/global.ts"() {
+    originUUID = "00000000-0000-0000-0000-000000000000";
+  }
+});
+
 // src/serializer/index.ts
 import * as glob from "glob";
 var init_serializer = __esm({
@@ -1580,7 +1588,7 @@ var init_pgSerializer = __esm({
         --end;
       return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
     };
-    fromDatabase2 = async (db, tablesFilter = (table) => 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 ");
@@ -2200,11 +2208,7 @@ var sqliteSchemaToDrizzle = (schema) => {
 
 // src/cli/commands/sqliteIntrospect.ts
 init_views();
-
-// src/global.ts
-var originUUID = "00000000-0000-0000-0000-000000000000";
-
-// src/cli/commands/sqliteIntrospect.ts
+init_global();
 init_sqliteSerializer();
 
 // node_modules/.pnpm/camelcase@7.0.1/node_modules/camelcase/index.js
@@ -3395,6 +3399,7 @@ import {
 init_pgSerializer();
 
 // src/cli/commands/pgIntrospect.ts
+init_global();
 var pgPushIntrospect = async (connection, filters, schemaFilters) => {
   const { client } = connection;
   const matchers = filters.map((it) => {

package/utils.js

@@ -1086,6 +1086,22 @@ var init_views = __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;
+    };
+  }
+});
+
 // node_modules/.pnpm/zod@3.20.2/node_modules/zod/lib/index.mjs
 function getErrorMap() {
   return overrideErrorMap;
@@ -4262,18 +4278,8 @@ module.exports = __toCommonJS(utils_exports);
 var import_fs = require("fs");
 init_views();
 
-// src/global.ts
-var originUUID = "00000000-0000-0000-0000-000000000000";
-var snapshotVersion = "5";
-var mapValues = (obj, map) => {
-  const result = Object.keys(obj).reduce(function(result2, key) {
-    result2[key] = map(obj[key]);
-    return result2;
-  }, {});
-  return result;
-};
-
 // src/serializer/mysqlSchema.ts
+init_global();
 init_lib();
 var index = objectType({
   name: stringType(),
@@ -4478,6 +4484,7 @@ var dryMySql = mysqlSchema.parse({
 });
 
 // src/serializer/pgSchema.ts
+init_global();
 init_lib();
 var indexV2 = objectType({
   name: stringType(),
@@ -4804,6 +4811,7 @@ var dryPg = pgSchema.parse({
 });
 
 // src/serializer/sqliteSchema.ts
+init_global();
 init_lib();
 var index3 = objectType({
   name: stringType(),
@@ -4960,11 +4968,16 @@ var drySQLite = schema2.parse({
     columns: {}
   }
 });
-var backwardCompatibleSqliteSchema = unionType([schemaV32, schemaV42, schema2]);
+var backwardCompatibleSqliteSchema = unionType([
+  schemaV32,
+  schemaV42,
+  schema2
+]);
 
 // src/utils.ts
 init_source();
 var import_path = require("path");
+init_global();
 
 // src/jsonDiffer.js
 var import_json_diff = require("json-diff");
@@ -7711,6 +7724,7 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
 
 // src/cli/commands/pgUp.ts
 init_source();
+init_global();
 
 // src/cli/commands/mysqlUp.ts
 init_source();