drizzle-kit 0.20.14-c82ab68 → 0.20.14-dc0459e

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 "../cli/views";
-import type { DrizzleDbClient } from "../drivers";
+import type { IntrospectStage, IntrospectStatus } from "src/cli/views";
+import type { DrizzleDbClient } from "src/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/snapshotsDiffer.d.ts

@@ -1,9 +1,6 @@
 import { TypeOf, ZodTypeAny, z } from "zod";
 import { JsonStatement } from "./jsonStatements";
-import { CommonSquashedSchema } from "./schemaValidator";
-import { SQLiteSchema } from "./serializer/sqliteSchema";
-import { MySqlSchema } from "./serializer/mysqlSchema";
-import { PgSchema } from "./serializer/pgSchema";
+import { CommonSquashedSchema, Dialect } from "./schemaValidator";
 export declare const makePatched: <T extends ZodTypeAny>(schema: T) => z.ZodUnion<[z.ZodObject<{
     type: z.ZodLiteral<"added">;
     value: T;
@@ -57,19 +54,19 @@ export declare const makePatched: <T extends ZodTypeAny>(schema: T) => z.ZodUnio
 }>[k_3_2]; } : never>]>;
 export declare const makeSelfOrPatched: <T extends ZodTypeAny>(schema: T) => z.ZodUnion<[z.ZodObject<{
     type: z.ZodLiteral<"none">;
-    value: T;
+    value: z.ZodOptional<T>;
 }, "strip", ZodTypeAny, z.objectUtil.addQuestionMarks<{
     type: "none";
-    value: T["_output"];
+    value: T["_output"] | undefined;
 }> extends infer T_1 ? { [k_1 in keyof T_1]: z.objectUtil.addQuestionMarks<{
     type: "none";
-    value: T["_output"];
+    value: T["_output"] | undefined;
 }>[k_1]; } : never, z.objectUtil.addQuestionMarks<{
     type: "none";
-    value: T["_input"];
+    value: T["_input"] | undefined;
 }> extends infer T_2 ? { [k_3 in keyof T_2]: z.objectUtil.addQuestionMarks<{
     type: "none";
-    value: T["_input"];
+    value: T["_input"] | undefined;
 }>[k_3]; } : never>, z.ZodObject<{
     type: z.ZodLiteral<"added">;
     value: T;
@@ -564,13 +561,13 @@ export declare const alteredTableScheme: z.ZodObject<{
     name: z.ZodString;
     schema: z.ZodUnion<[z.ZodObject<{
         type: z.ZodLiteral<"none">;
-        value: z.ZodString;
+        value: z.ZodOptional<z.ZodString>;
     }, "strip", ZodTypeAny, {
+        value?: string | undefined;
         type: "none";
-        value: string;
     }, {
+        value?: string | undefined;
         type: "none";
-        value: string;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"added">;
         value: z.ZodString;
@@ -1036,8 +1033,8 @@ export declare const alteredTableScheme: z.ZodObject<{
 }, "strict", ZodTypeAny, {
     name: string;
     schema: {
+        value?: string | undefined;
         type: "none";
-        value: string;
     } | {
         type: "added";
         value: string;
@@ -1167,8 +1164,8 @@ export declare const alteredTableScheme: z.ZodObject<{
 }, {
     name: string;
     schema: {
+        value?: string | undefined;
         type: "none";
-        value: string;
     } | {
         type: "added";
         value: string;
@@ -1461,13 +1458,13 @@ export declare const diffResultScheme: z.ZodObject<{
         name: z.ZodString;
         schema: z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"none">;
-            value: z.ZodString;
+            value: z.ZodOptional<z.ZodString>;
         }, "strip", ZodTypeAny, {
+            value?: string | undefined;
             type: "none";
-            value: string;
         }, {
+            value?: string | undefined;
             type: "none";
-            value: string;
         }>, z.ZodObject<{
             type: z.ZodLiteral<"added">;
             value: z.ZodString;
@@ -1933,8 +1930,8 @@ export declare const diffResultScheme: z.ZodObject<{
     }, "strict", ZodTypeAny, {
         name: string;
         schema: {
+            value?: string | undefined;
             type: "none";
-            value: string;
         } | {
             type: "added";
             value: string;
@@ -2064,8 +2061,8 @@ export declare const diffResultScheme: z.ZodObject<{
     }, {
         name: string;
         schema: {
+            value?: string | undefined;
             type: "none";
-            value: string;
         } | {
             type: "added";
             value: string;
@@ -2272,8 +2269,8 @@ export declare const diffResultScheme: z.ZodObject<{
     alteredTablesWithColumns: {
         name: string;
         schema: {
+            value?: string | undefined;
             type: "none";
-            value: string;
         } | {
             type: "added";
             value: string;
@@ -2460,8 +2457,8 @@ export declare const diffResultScheme: z.ZodObject<{
     alteredTablesWithColumns: {
         name: string;
         schema: {
+            value?: string | undefined;
             type: "none";
-            value: string;
         } | {
             type: "added";
             value: string;
@@ -2647,12 +2644,11 @@ export interface ColumnsResolverOutput<T extends {
     }[];
     deleted: T[];
 }
-export type SchemaFrom<D> = D extends "pg" ? PgSchema : D extends "mysql" ? MySqlSchema : D extends "sqlite" ? SQLiteSchema : undefined;
-export declare const applySnapshotsDiff: <DIALECT extends "mysql" | "pg" | "sqlite" = "mysql" | "pg" | "sqlite">(json1: CommonSquashedSchema, json2: CommonSquashedSchema, dialect: DIALECT, schemasResolver: (input: TablesResolverInput<{
+export declare const applySnapshotsDiff: (json1: CommonSquashedSchema, json2: CommonSquashedSchema, dialect: Dialect, schemasResolver: (input: TablesResolverInput<{
     name: string;
 }>) => Promise<TablesResolverOutput<{
     name: string;
-}>>, tablesResolver: (input: TablesResolverInput<Table>) => Promise<TablesResolverOutput<Table>>, columnsResolver: (input: ColumnsResolverInput<Column>) => Promise<ColumnsResolverOutput<Column>>, prevFull: SchemaFrom<DIALECT>, curFull: SchemaFrom<DIALECT>) => Promise<{
+}>>, tablesResolver: (input: TablesResolverInput<Table>) => Promise<TablesResolverOutput<Table>>, columnsResolver: (input: ColumnsResolverInput<Column>) => Promise<ColumnsResolverOutput<Column>>, prevFull?: any, curFull?: any) => Promise<{
     statements: JsonStatement[];
     sqlStatements: string[];
     _meta: {

package/utils-studio.js

@@ -1,4 +1,3 @@
-"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1077,26 +1076,15 @@ var require_hanji = __commonJS({
 var import_hanji;
 var init_views = __esm({
   "src/cli/views.ts"() {
-    "use strict";
     init_source();
     import_hanji = __toESM(require_hanji());
   }
 });
 
-// src/global.ts
-var originUUID;
-var init_global = __esm({
-  "src/global.ts"() {
-    "use strict";
-    originUUID = "00000000-0000-0000-0000-000000000000";
-  }
-});
-
 // src/serializer/index.ts
 var glob;
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
-    "use strict";
     glob = __toESM(require("glob"));
     init_source();
     init_views();
@@ -1106,14 +1094,12 @@ var init_serializer = __esm({
 // src/cli/validations/outputs.ts
 var init_outputs = __esm({
   "src/cli/validations/outputs.ts"() {
-    "use strict";
     init_source();
   }
 });
 
 // src/serializer/sqliteSerializer.ts
 function mapSqlToSqliteType(sqlType) {
-  const lowered = sqlType.toLowerCase();
   if ([
     "int",
     "integer",
@@ -1125,27 +1111,24 @@ function mapSqlToSqliteType(sqlType) {
     "unsigned big int",
     "int2",
     "int8"
-  ].some((it) => lowered.startsWith(it))) {
+  ].includes(sqlType.toLowerCase())) {
     return "integer";
   } else if ([
     "character",
     "varchar",
-    "varying character",
-    "national varying character",
+    "vatying character",
     "nchar",
     "native character",
     "nvarchar",
     "text",
     "clob"
-  ].some((it) => lowered.startsWith(it))) {
-    const match2 = lowered.match(/\d+/);
-    if (match2) {
-      return `text(${match2[0]})`;
-    }
+  ].some((it) => it.startsWith(sqlType.toLowerCase()))) {
     return "text";
-  } else if (lowered.startsWith("blob")) {
+  } else if (sqlType.toLowerCase() === "blob") {
     return "blob";
-  } else if (["real", "double", "double precision", "float"].some((it) => lowered.startsWith(it))) {
+  } else if (["real", "double", "double precision", "float"].includes(
+    sqlType.toLowerCase()
+  )) {
     return "real";
   } else {
     return "numeric";
@@ -1154,7 +1137,6 @@ function mapSqlToSqliteType(sqlType) {
 var import_drizzle_orm, import_sqlite_core2, dialect, fromDatabase;
 var init_sqliteSerializer = __esm({
   "src/serializer/sqliteSerializer.ts"() {
-    "use strict";
     import_drizzle_orm = require("drizzle-orm");
     import_sqlite_core2 = require("drizzle-orm/sqlite-core");
     init_serializer();
@@ -1573,7 +1555,6 @@ var require_brace_expansion = __commonJS({
 var import_pg_core2, import_pg_core3, import_drizzle_orm2, dialect2, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
 var init_pgSerializer = __esm({
   "src/serializer/pgSerializer.ts"() {
-    "use strict";
     import_pg_core2 = require("drizzle-orm/pg-core");
     import_pg_core3 = require("drizzle-orm/pg-core");
     import_drizzle_orm2 = require("drizzle-orm");
@@ -1590,7 +1571,7 @@ var init_pgSerializer = __esm({
         --end;
       return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
     };
-    fromDatabase2 = async (db, tablesFilter = () => true, schemaFilters, progressCallback) => {
+    fromDatabase2 = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
       const result = {};
       const internals = { tables: {} };
       const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
@@ -1917,7 +1898,7 @@ var init_pgSerializer = __esm({
       }
       const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
       return {
-        version: "6",
+        version: "5",
         dialect: "pg",
         tables: result,
         enums: enumsToReturn,
@@ -1989,368 +1970,10 @@ var init_pgSerializer = __esm({
   }
 });
 
-// node_modules/.pnpm/pluralize@8.0.0/node_modules/pluralize/pluralize.js
-var require_pluralize = __commonJS({
-  "node_modules/.pnpm/pluralize@8.0.0/node_modules/pluralize/pluralize.js"(exports, module2) {
-    (function(root, pluralize) {
-      if (typeof require === "function" && typeof exports === "object" && typeof module2 === "object") {
-        module2.exports = pluralize();
-      } else if (typeof define === "function" && define.amd) {
-        define(function() {
-          return pluralize();
-        });
-      } else {
-        root.pluralize = pluralize();
-      }
-    })(exports, function() {
-      var pluralRules = [];
-      var singularRules = [];
-      var uncountables = {};
-      var irregularPlurals = {};
-      var irregularSingles = {};
-      function sanitizeRule(rule) {
-        if (typeof rule === "string") {
-          return new RegExp("^" + rule + "$", "i");
-        }
-        return rule;
-      }
-      function restoreCase(word, token) {
-        if (word === token)
-          return token;
-        if (word === word.toLowerCase())
-          return token.toLowerCase();
-        if (word === word.toUpperCase())
-          return token.toUpperCase();
-        if (word[0] === word[0].toUpperCase()) {
-          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
-        }
-        return token.toLowerCase();
-      }
-      function interpolate(str, args) {
-        return str.replace(/\$(\d{1,2})/g, function(match2, index) {
-          return args[index] || "";
-        });
-      }
-      function replace(word, rule) {
-        return word.replace(rule[0], function(match2, index) {
-          var result = interpolate(rule[1], arguments);
-          if (match2 === "") {
-            return restoreCase(word[index - 1], result);
-          }
-          return restoreCase(match2, result);
-        });
-      }
-      function sanitizeWord(token, word, rules) {
-        if (!token.length || uncountables.hasOwnProperty(token)) {
-          return word;
-        }
-        var len = rules.length;
-        while (len--) {
-          var rule = rules[len];
-          if (rule[0].test(word))
-            return replace(word, rule);
-        }
-        return word;
-      }
-      function replaceWord(replaceMap, keepMap, rules) {
-        return function(word) {
-          var token = word.toLowerCase();
-          if (keepMap.hasOwnProperty(token)) {
-            return restoreCase(word, token);
-          }
-          if (replaceMap.hasOwnProperty(token)) {
-            return restoreCase(word, replaceMap[token]);
-          }
-          return sanitizeWord(token, word, rules);
-        };
-      }
-      function checkWord(replaceMap, keepMap, rules, bool) {
-        return function(word) {
-          var token = word.toLowerCase();
-          if (keepMap.hasOwnProperty(token))
-            return true;
-          if (replaceMap.hasOwnProperty(token))
-            return false;
-          return sanitizeWord(token, token, rules) === token;
-        };
-      }
-      function pluralize(word, count, inclusive) {
-        var pluralized = count === 1 ? pluralize.singular(word) : pluralize.plural(word);
-        return (inclusive ? count + " " : "") + pluralized;
-      }
-      pluralize.plural = replaceWord(
-        irregularSingles,
-        irregularPlurals,
-        pluralRules
-      );
-      pluralize.isPlural = checkWord(
-        irregularSingles,
-        irregularPlurals,
-        pluralRules
-      );
-      pluralize.singular = replaceWord(
-        irregularPlurals,
-        irregularSingles,
-        singularRules
-      );
-      pluralize.isSingular = checkWord(
-        irregularPlurals,
-        irregularSingles,
-        singularRules
-      );
-      pluralize.addPluralRule = function(rule, replacement) {
-        pluralRules.push([sanitizeRule(rule), replacement]);
-      };
-      pluralize.addSingularRule = function(rule, replacement) {
-        singularRules.push([sanitizeRule(rule), replacement]);
-      };
-      pluralize.addUncountableRule = function(word) {
-        if (typeof word === "string") {
-          uncountables[word.toLowerCase()] = true;
-          return;
-        }
-        pluralize.addPluralRule(word, "$0");
-        pluralize.addSingularRule(word, "$0");
-      };
-      pluralize.addIrregularRule = function(single, plural2) {
-        plural2 = plural2.toLowerCase();
-        single = single.toLowerCase();
-        irregularSingles[single] = plural2;
-        irregularPlurals[plural2] = single;
-      };
-      [
-        // Pronouns.
-        ["I", "we"],
-        ["me", "us"],
-        ["he", "they"],
-        ["she", "they"],
-        ["them", "them"],
-        ["myself", "ourselves"],
-        ["yourself", "yourselves"],
-        ["itself", "themselves"],
-        ["herself", "themselves"],
-        ["himself", "themselves"],
-        ["themself", "themselves"],
-        ["is", "are"],
-        ["was", "were"],
-        ["has", "have"],
-        ["this", "these"],
-        ["that", "those"],
-        // Words ending in with a consonant and `o`.
-        ["echo", "echoes"],
-        ["dingo", "dingoes"],
-        ["volcano", "volcanoes"],
-        ["tornado", "tornadoes"],
-        ["torpedo", "torpedoes"],
-        // Ends with `us`.
-        ["genus", "genera"],
-        ["viscus", "viscera"],
-        // Ends with `ma`.
-        ["stigma", "stigmata"],
-        ["stoma", "stomata"],
-        ["dogma", "dogmata"],
-        ["lemma", "lemmata"],
-        ["schema", "schemata"],
-        ["anathema", "anathemata"],
-        // Other irregular rules.
-        ["ox", "oxen"],
-        ["axe", "axes"],
-        ["die", "dice"],
-        ["yes", "yeses"],
-        ["foot", "feet"],
-        ["eave", "eaves"],
-        ["goose", "geese"],
-        ["tooth", "teeth"],
-        ["quiz", "quizzes"],
-        ["human", "humans"],
-        ["proof", "proofs"],
-        ["carve", "carves"],
-        ["valve", "valves"],
-        ["looey", "looies"],
-        ["thief", "thieves"],
-        ["groove", "grooves"],
-        ["pickaxe", "pickaxes"],
-        ["passerby", "passersby"]
-      ].forEach(function(rule) {
-        return pluralize.addIrregularRule(rule[0], rule[1]);
-      });
-      [
-        [/s?$/i, "s"],
-        [/[^\u0000-\u007F]$/i, "$0"],
-        [/([^aeiou]ese)$/i, "$1"],
-        [/(ax|test)is$/i, "$1es"],
-        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
-        [/(e[mn]u)s?$/i, "$1s"],
-        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
-        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
-        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
-        [/(seraph|cherub)(?:im)?$/i, "$1im"],
-        [/(her|at|gr)o$/i, "$1oes"],
-        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
-        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
-        [/sis$/i, "ses"],
-        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
-        [/([^aeiouy]|qu)y$/i, "$1ies"],
-        [/([^ch][ieo][ln])ey$/i, "$1ies"],
-        [/(x|ch|ss|sh|zz)$/i, "$1es"],
-        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
-        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
-        [/(pe)(?:rson|ople)$/i, "$1ople"],
-        [/(child)(?:ren)?$/i, "$1ren"],
-        [/eaux$/i, "$0"],
-        [/m[ae]n$/i, "men"],
-        ["thou", "you"]
-      ].forEach(function(rule) {
-        return pluralize.addPluralRule(rule[0], rule[1]);
-      });
-      [
-        [/s$/i, ""],
-        [/(ss)$/i, "$1"],
-        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
-        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
-        [/ies$/i, "y"],
-        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
-        [/\b(mon|smil)ies$/i, "$1ey"],
-        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
-        [/(seraph|cherub)im$/i, "$1"],
-        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
-        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
-        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
-        [/(test)(?:is|es)$/i, "$1is"],
-        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
-        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
-        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
-        [/(alumn|alg|vertebr)ae$/i, "$1a"],
-        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
-        [/(matr|append)ices$/i, "$1ix"],
-        [/(pe)(rson|ople)$/i, "$1rson"],
-        [/(child)ren$/i, "$1"],
-        [/(eau)x?$/i, "$1"],
-        [/men$/i, "man"]
-      ].forEach(function(rule) {
-        return pluralize.addSingularRule(rule[0], rule[1]);
-      });
-      [
-        // Singular words with no plurals.
-        "adulthood",
-        "advice",
-        "agenda",
-        "aid",
-        "aircraft",
-        "alcohol",
-        "ammo",
-        "analytics",
-        "anime",
-        "athletics",
-        "audio",
-        "bison",
-        "blood",
-        "bream",
-        "buffalo",
-        "butter",
-        "carp",
-        "cash",
-        "chassis",
-        "chess",
-        "clothing",
-        "cod",
-        "commerce",
-        "cooperation",
-        "corps",
-        "debris",
-        "diabetes",
-        "digestion",
-        "elk",
-        "energy",
-        "equipment",
-        "excretion",
-        "expertise",
-        "firmware",
-        "flounder",
-        "fun",
-        "gallows",
-        "garbage",
-        "graffiti",
-        "hardware",
-        "headquarters",
-        "health",
-        "herpes",
-        "highjinks",
-        "homework",
-        "housework",
-        "information",
-        "jeans",
-        "justice",
-        "kudos",
-        "labour",
-        "literature",
-        "machinery",
-        "mackerel",
-        "mail",
-        "media",
-        "mews",
-        "moose",
-        "music",
-        "mud",
-        "manga",
-        "news",
-        "only",
-        "personnel",
-        "pike",
-        "plankton",
-        "pliers",
-        "police",
-        "pollution",
-        "premises",
-        "rain",
-        "research",
-        "rice",
-        "salmon",
-        "scissors",
-        "series",
-        "sewage",
-        "shambles",
-        "shrimp",
-        "software",
-        "species",
-        "staff",
-        "swine",
-        "tennis",
-        "traffic",
-        "transportation",
-        "trout",
-        "tuna",
-        "wealth",
-        "welfare",
-        "whiting",
-        "wildebeest",
-        "wildlife",
-        "you",
-        /pok[eé]mon$/i,
-        // Regexes.
-        /[^aeiou]ese$/i,
-        // "chinese", "japanese"
-        /deer$/i,
-        // "deer", "reindeer"
-        /fish$/i,
-        // "fish", "blowfish", "angelfish"
-        /measles$/i,
-        /o[iu]s$/i,
-        // "carnivorous"
-        /pox$/i,
-        // "chickpox", "smallpox"
-        /sheep$/i
-      ].forEach(pluralize.addUncountableRule);
-      return pluralize;
-    });
-  }
-});
-
 // src/drivers/index.ts
 var import_drizzle_orm4, DrizzleDbClient, DrizzleORMPgClient, TursoSqlite;
 var init_drivers = __esm({
   "src/drivers/index.ts"() {
-    "use strict";
     import_drizzle_orm4 = require("drizzle-orm");
     DrizzleDbClient = class {
       constructor(db) {
@@ -2543,7 +2166,11 @@ var sqliteSchemaToDrizzle = (schema) => {
 
 // src/cli/commands/sqliteIntrospect.ts
 init_views();
-init_global();
+
+// src/global.ts
+var originUUID = "00000000-0000-0000-0000-000000000000";
+
+// src/cli/commands/sqliteIntrospect.ts
 init_sqliteSerializer();
 
 // node_modules/.pnpm/camelcase@7.0.1/node_modules/camelcase/index.js
@@ -2645,7 +2272,7 @@ String.prototype.camelCase = function() {
   return camelCase(String(this));
 };
 String.prototype.concatIf = function(it, condition) {
-  return condition ? `${this}${it}` : String(this);
+  return condition ? `${this}${it}` : this;
 };
 Array.prototype.random = function() {
   return this[~~(Math.random() * this.length)];
@@ -3725,12 +3352,10 @@ init_pgSerializer();
 
 // src/introspect-pg.ts
 var import_drizzle_orm3 = require("drizzle-orm");
-var import_pluralize = __toESM(require_pluralize());
 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) => {