drizzle-kit 0.20.14-c82ab68 → 0.20.14-d8f1e46

package/utils-studio.mjs

@@ -1078,26 +1078,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
 import * as glob from "glob";
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
-    "use strict";
     init_source();
     init_views();
   }
@@ -1106,7 +1095,6 @@ var init_serializer = __esm({
 // src/cli/validations/outputs.ts
 var init_outputs = __esm({
   "src/cli/validations/outputs.ts"() {
-    "use strict";
     init_source();
   }
 });
@@ -1120,7 +1108,6 @@ import {
   uniqueKeyName
 } from "drizzle-orm/sqlite-core";
 function mapSqlToSqliteType(sqlType) {
-  const lowered = sqlType.toLowerCase();
   if ([
     "int",
     "integer",
@@ -1132,27 +1119,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";
@@ -1161,7 +1145,6 @@ function mapSqlToSqliteType(sqlType) {
 var dialect, fromDatabase;
 var init_sqliteSerializer = __esm({
   "src/serializer/sqliteSerializer.ts"() {
-    "use strict";
     init_serializer();
     init_outputs();
     init_source();
@@ -1584,7 +1567,6 @@ import { is as is2, SQL as SQL2, getTableName as getTableName2 } from "drizzle-o
 var dialect2, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
 var init_pgSerializer = __esm({
   "src/serializer/pgSerializer.ts"() {
-    "use strict";
     init_serializer();
     init_source();
     init_outputs();
@@ -1598,7 +1580,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 ");
@@ -1925,7 +1907,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,
@@ -1997,369 +1979,11 @@ 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, module) {
-    (function(root, pluralize) {
-      if (typeof __require === "function" && typeof exports === "object" && typeof module === "object") {
-        module.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
 import { sql } from "drizzle-orm";
 var DrizzleDbClient, DrizzleORMPgClient, TursoSqlite;
 var init_drivers = __esm({
   "src/drivers/index.ts"() {
-    "use strict";
     DrizzleDbClient = class {
       constructor(db) {
         this.db = db;
@@ -2576,7 +2200,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
@@ -2678,7 +2306,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)];
@@ -3757,7 +3385,6 @@ init_views();
 init_pgSerializer();
 
 // src/introspect-pg.ts
-var import_pluralize = __toESM(require_pluralize());
 import { getTableName as getTableName3, is as is3 } from "drizzle-orm";
 import {
   createTableRelationsHelpers,
@@ -3768,7 +3395,6 @@ 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.d.ts

@@ -1,6 +1,6 @@
 import type { Dialect } from "./schemaValidator";
 import { NamedWithSchema } from "./cli/commands/migrate";
-export declare const assertV1OutFolder: (out: string) => void;
+export declare const assertV1OutFolder: (out: string, dialect: Dialect | "{dialect}") => void;
 export type Journal = {
     version: string;
     dialect: Dialect;
@@ -50,9 +50,9 @@ export declare const prepareMigrationMeta: (schemas: {
         column: string;
     };
 }[]) => {
-    schemas: Record<string, string>;
-    tables: Record<string, string>;
-    columns: Record<string, string>;
+    schemas: {};
+    tables: {};
+    columns: {};
 };
 export declare const schemaRenameKey: (it: string) => string;
 export declare const tableRenameKey: (it: NamedWithSchema) => string;
@@ -73,6 +73,10 @@ export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
                 } | undefined>;
             } | undefined>;
         } | undefined;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "pg";
         tables: Record<string, {
             name: string;
             columns: Record<string, {
@@ -111,10 +115,6 @@ export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
                 nullsNotDistinct: boolean;
             }>;
         }>;
-        id: string;
-        prevId: string;
-        version: "6";
-        dialect: "pg";
         schemas: Record<string, string>;
         _meta: {
             columns: Record<string, string>;
@@ -136,6 +136,10 @@ export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
                 } | undefined>;
             } | undefined>;
         } | undefined;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "pg";
         tables: Record<string, {
             name: string;
             columns: Record<string, {
@@ -174,10 +178,6 @@ export declare const statementsForDiffs: (in1: any, in2: any) => Promise<{
                 nullsNotDistinct: boolean;
             }>;
         }>;
-        id: string;
-        prevId: string;
-        version: "6";
-        dialect: "pg";
         schemas: Record<string, string>;
         _meta: {
             columns: Record<string, string>;