drizzle-kit 0.20.14-a183d8b → 0.20.14-c82ab68

package/snapshotsDiffer.d.ts

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

package/utils-studio.js

@@ -1,3 +1,4 @@
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1076,6 +1077,7 @@ var require_hanji = __commonJS({
 var import_hanji;
 var init_views = __esm({
   "src/cli/views.ts"() {
+    "use strict";
     init_source();
     import_hanji = __toESM(require_hanji());
   }
@@ -1085,6 +1087,7 @@ var init_views = __esm({
 var originUUID;
 var init_global = __esm({
   "src/global.ts"() {
+    "use strict";
     originUUID = "00000000-0000-0000-0000-000000000000";
   }
 });
@@ -1093,6 +1096,7 @@ var init_global = __esm({
 var glob;
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
+    "use strict";
     glob = __toESM(require("glob"));
     init_source();
     init_views();
@@ -1102,12 +1106,14 @@ 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",
@@ -1119,24 +1125,27 @@ function mapSqlToSqliteType(sqlType) {
     "unsigned big int",
     "int2",
     "int8"
-  ].includes(sqlType.toLowerCase())) {
+  ].some((it) => lowered.startsWith(it))) {
     return "integer";
   } else if ([
     "character",
     "varchar",
-    "vatying character",
+    "varying character",
+    "national varying character",
     "nchar",
     "native character",
     "nvarchar",
     "text",
     "clob"
-  ].some((it) => it.startsWith(sqlType.toLowerCase()))) {
+  ].some((it) => lowered.startsWith(it))) {
+    const match2 = lowered.match(/\d+/);
+    if (match2) {
+      return `text(${match2[0]})`;
+    }
     return "text";
-  } else if (sqlType.toLowerCase() === "blob") {
+  } else if (lowered.startsWith("blob")) {
     return "blob";
-  } else if (["real", "double", "double precision", "float"].includes(
-    sqlType.toLowerCase()
-  )) {
+  } else if (["real", "double", "double precision", "float"].some((it) => lowered.startsWith(it))) {
     return "real";
   } else {
     return "numeric";
@@ -1145,6 +1154,7 @@ 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();
@@ -1563,6 +1573,7 @@ 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");
@@ -1906,7 +1917,7 @@ var init_pgSerializer = __esm({
       }
       const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
       return {
-        version: "5",
+        version: "6",
         dialect: "pg",
         tables: result,
         enums: enumsToReturn,
@@ -1978,10 +1989,368 @@ 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) {
@@ -2276,7 +2645,7 @@ String.prototype.camelCase = function() {
   return camelCase(String(this));
 };
 String.prototype.concatIf = function(it, condition) {
-  return condition ? `${this}${it}` : this;
+  return condition ? `${this}${it}` : String(this);
 };
 Array.prototype.random = function() {
   return this[~~(Math.random() * this.length)];
@@ -3356,6 +3725,7 @@ 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();