drizzle-kit 0.21.2-f3756f2 → 0.21.3

package/utils-studio.js

@@ -33,6 +33,516 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/vendor/ansi-styles/index.js
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm({
+  "node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/vendor/ansi-styles/index.js"() {
+    ANSI_BACKGROUND_OFFSET = 10;
+    wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+    wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+    styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39],
+        // Alias of `blackBright`
+        grey: [90, 39],
+        // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49],
+        // Alias of `bgBlackBright`
+        bgGrey: [100, 49],
+        // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    modifierNames = Object.keys(styles.modifier);
+    foregroundColorNames = Object.keys(styles.color);
+    backgroundColorNames = Object.keys(styles.bgColor);
+    colorNames = [...foregroundColorNames, ...backgroundColorNames];
+    ansiStyles = assembleStyles();
+    ansi_styles_default = ansiStyles;
+  }
+});
+
+// node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process.default.platform === "win32") {
+    const osRelease = import_node_os.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) {
+      return 3;
+    }
+    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var import_node_process, import_node_os, import_node_tty, env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/vendor/supports-color/index.js"() {
+    import_node_process = __toESM(require("node:process"), 1);
+    import_node_os = __toESM(require("node:os"), 1);
+    import_node_tty = __toESM(require("node:tty"), 1);
+    ({ env } = import_node_process.default);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+    };
+    supports_color_default = supportsColor;
+  }
+});
+
+// node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index4 = string.indexOf(substring);
+  if (index4 === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index4) + substring + replacer;
+    endIndex = index4 + substringLength;
+    index4 = string.indexOf(substring, endIndex);
+  } while (index4 !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index4) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index4 - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index4 - 1 : index4) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index4 + 1;
+    index4 = string.indexOf("\n", endIndex);
+  } while (index4 !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+var init_utilities = __esm({
+  "node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/utilities.js"() {
+  }
+});
+
+// node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/index.js
+function createChalk(options) {
+  return chalkFactory(options);
+}
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr, source_default;
+var init_source = __esm({
+  "node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/index.js"() {
+    init_ansi_styles();
+    init_supports_color();
+    init_utilities();
+    ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
+    GENERATOR = Symbol("GENERATOR");
+    STYLER = Symbol("STYLER");
+    IS_EMPTY = Symbol("IS_EMPTY");
+    levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    styles2 = /* @__PURE__ */ Object.create(null);
+    applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    chalkFactory = (options) => {
+      const chalk2 = (...strings) => strings.join(" ");
+      applyOptions(chalk2, options);
+      Object.setPrototypeOf(chalk2, createChalk.prototype);
+      return chalk2;
+    };
+    Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+    for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+      styles2[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
+    }
+    styles2.visible = {
+      get() {
+        const builder = createBuilder(this, this[STYLER], true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    getModelAnsi = (model, level, type, ...arguments_) => {
+      if (model === "rgb") {
+        if (level === "ansi16m") {
+          return ansi_styles_default[type].ansi16m(...arguments_);
+        }
+        if (level === "ansi256") {
+          return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+        }
+        return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+      }
+      if (model === "hex") {
+        return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+      }
+      return ansi_styles_default[type][model](...arguments_);
+    };
+    usedModels = ["rgb", "hex", "ansi256"];
+    for (const model of usedModels) {
+      styles2[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+    }
+    proto = Object.defineProperties(() => {
+    }, {
+      ...styles2,
+      level: {
+        enumerable: true,
+        get() {
+          return this[GENERATOR].level;
+        },
+        set(level) {
+          this[GENERATOR].level = level;
+        }
+      }
+    });
+    createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    createBuilder = (self2, _styler, _isEmpty) => {
+      const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      Object.setPrototypeOf(builder, proto);
+      builder[GENERATOR] = self2;
+      builder[STYLER] = _styler;
+      builder[IS_EMPTY] = _isEmpty;
+      return builder;
+    };
+    applyStyle = (self2, string) => {
+      if (self2.level <= 0 || !string) {
+        return self2[IS_EMPTY] ? "" : string;
+      }
+      let styler = self2[STYLER];
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.includes("\x1B")) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    Object.defineProperties(createChalk.prototype, styles2);
+    chalk = createChalk();
+    chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+    source_default = chalk;
+  }
+});
+
 // node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/readline.js
 var require_readline = __commonJS({
   "node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/readline.js"(exports2) {
@@ -545,7 +1055,7 @@ var require_hanji = __commonJS({
       return;
     }
     exports2.render = render2;
-    function renderWithTask2(view, task) {
+    function renderWithTask3(view, task) {
       return __awaiter(this, void 0, void 0, function* () {
         const terminal = new TaskTerminal(view, process.stdout);
         terminal.requestLayout();
@@ -554,7 +1064,7 @@ var require_hanji = __commonJS({
         return result;
       });
     }
-    exports2.renderWithTask = renderWithTask2;
+    exports2.renderWithTask = renderWithTask3;
     var terminateHandler;
     function onTerminate(callback) {
       terminateHandler = callback;
@@ -569,7 +1079,7 @@ var init_global = __esm({
   "src/global.ts"() {
     "use strict";
     originUUID = "00000000-0000-0000-0000-000000000000";
-    snapshotVersion = "7";
+    snapshotVersion = "6";
   }
 });
 
@@ -4498,7 +5008,7 @@ var init_mysqlSchema = __esm({
 });
 
 // src/serializer/pgSchema.ts
-var indexV2, columnV2, tableV2, enumSchemaV1, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, indexColumn, index2, indexV4, indexV5, indexV6, fk2, column2, tableV32, compositePK2, uniqueConstraint2, tableV42, tableV6, tableV5, table2, schemaHash2, kitInternals2, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaInternalV5, pgSchemaInternalV6, pgSchemaExternal, pgSchemaInternal, tableSquashed2, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashedV6, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchemaV5, pgSchemaV6, pgSchema2, backwardCompatiblePgSchema, dryPg;
+var indexV2, columnV2, tableV2, enumSchemaV1, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, index2, fk2, column2, tableV32, compositePK2, uniqueConstraint2, tableV42, table2, schemaHash2, kitInternals2, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaInternalV5, pgSchemaExternal, pgSchemaInternal, tableSquashed2, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchemaV5, pgSchema2, backwardCompatiblePgSchema, dryPg;
 var init_pgSchema = __esm({
   "src/serializer/pgSchema.ts"() {
     "use strict";
@@ -4566,48 +5076,10 @@ var init_pgSchema = __esm({
       tables: recordType(stringType(), tableV1),
       enums: recordType(stringType(), enumSchemaV1)
     }).strict();
-    indexColumn = objectType({
-      expression: stringType(),
-      isExpression: booleanType(),
-      asc: booleanType(),
-      nulls: stringType().optional(),
-      opclass: stringType().optional()
-    });
     index2 = objectType({
-      name: stringType(),
-      columns: indexColumn.array(),
-      isUnique: booleanType(),
-      with: recordType(stringType(), anyType()).optional(),
-      method: stringType().default("btree"),
-      where: stringType().optional(),
-      concurrently: booleanType().default(false)
-    }).strict();
-    indexV4 = objectType({
       name: stringType(),
       columns: stringType().array(),
-      isUnique: booleanType(),
-      with: recordType(stringType(), stringType()).optional(),
-      method: stringType().default("btree"),
-      where: stringType().optional(),
-      concurrently: booleanType().default(false)
-    }).strict();
-    indexV5 = objectType({
-      name: stringType(),
-      columns: stringType().array(),
-      isUnique: booleanType(),
-      with: recordType(stringType(), stringType()).optional(),
-      method: stringType().default("btree"),
-      where: stringType().optional(),
-      concurrently: booleanType().default(false)
-    }).strict();
-    indexV6 = objectType({
-      name: stringType(),
-      columns: stringType().array(),
-      isUnique: booleanType(),
-      with: recordType(stringType(), stringType()).optional(),
-      method: stringType().default("btree"),
-      where: stringType().optional(),
-      concurrently: booleanType().default(false)
+      isUnique: booleanType()
     }).strict();
     fk2 = objectType({
       name: stringType(),
@@ -4649,27 +5121,9 @@ var init_pgSchema = __esm({
       name: stringType(),
       schema: stringType(),
       columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), indexV4),
+      indexes: recordType(stringType(), index2),
       foreignKeys: recordType(stringType(), fk2)
     }).strict();
-    tableV6 = objectType({
-      name: stringType(),
-      schema: stringType(),
-      columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), indexV6),
-      foreignKeys: recordType(stringType(), fk2),
-      compositePrimaryKeys: recordType(stringType(), compositePK2),
-      uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
-    }).strict();
-    tableV5 = objectType({
-      name: stringType(),
-      schema: stringType(),
-      columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), indexV5),
-      foreignKeys: recordType(stringType(), fk2),
-      compositePrimaryKeys: recordType(stringType(), compositePK2),
-      uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
-    }).strict();
     table2 = objectType({
       name: stringType(),
       schema: stringType(),
@@ -4714,7 +5168,7 @@ var init_pgSchema = __esm({
     pgSchemaInternalV5 = objectType({
       version: literalType("5"),
       dialect: literalType("pg"),
-      tables: recordType(stringType(), tableV5),
+      tables: recordType(stringType(), table2),
       enums: recordType(stringType(), enumSchemaV1),
       schemas: recordType(stringType(), stringType()),
       _meta: objectType({
@@ -4724,19 +5178,6 @@ var init_pgSchema = __esm({
       }),
       internal: kitInternals2
     }).strict();
-    pgSchemaInternalV6 = objectType({
-      version: literalType("6"),
-      dialect: literalType("postgresql"),
-      tables: recordType(stringType(), tableV6),
-      enums: recordType(stringType(), enumSchema),
-      schemas: recordType(stringType(), stringType()),
-      _meta: objectType({
-        schemas: recordType(stringType(), stringType()),
-        tables: recordType(stringType(), stringType()),
-        columns: recordType(stringType(), stringType())
-      }),
-      internal: kitInternals2
-    }).strict();
     pgSchemaExternal = objectType({
       version: literalType("5"),
       dialect: literalType("pg"),
@@ -4750,7 +5191,7 @@ var init_pgSchema = __esm({
       })
     }).strict();
     pgSchemaInternal = objectType({
-      version: literalType("7"),
+      version: literalType("6"),
       dialect: literalType("postgresql"),
       tables: recordType(stringType(), table2),
       enums: recordType(stringType(), enumSchema),
@@ -4785,15 +5226,8 @@ var init_pgSchema = __esm({
       enums: recordType(stringType(), enumSchemaV1),
       schemas: recordType(stringType(), stringType())
     }).strict();
-    pgSchemaSquashedV6 = objectType({
-      version: literalType("6"),
-      dialect: literalType("postgresql"),
-      tables: recordType(stringType(), tableSquashed2),
-      enums: recordType(stringType(), enumSchema),
-      schemas: recordType(stringType(), stringType())
-    }).strict();
     pgSchemaSquashed = objectType({
-      version: literalType("7"),
+      version: literalType("6"),
       dialect: literalType("postgresql"),
       tables: recordType(stringType(), tableSquashed2),
       enums: recordType(stringType(), enumSchema),
@@ -4802,13 +5236,8 @@ var init_pgSchema = __esm({
     pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash2);
     pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash2);
     pgSchemaV5 = pgSchemaInternalV5.merge(schemaHash2);
-    pgSchemaV6 = pgSchemaInternalV6.merge(schemaHash2);
     pgSchema2 = pgSchemaInternal.merge(schemaHash2);
-    backwardCompatiblePgSchema = unionType([
-      pgSchemaV5,
-      pgSchemaV6,
-      pgSchema2
-    ]);
+    backwardCompatiblePgSchema = unionType([pgSchemaV5, pgSchema2]);
     dryPg = pgSchema2.parse({
       version: snapshotVersion,
       dialect: "postgresql",
@@ -4964,12 +5393,49 @@ var init_utils = __esm({
 });
 
 // src/cli/views.ts
-var import_hanji;
+var import_hanji, Spinner, ProgressView;
 var init_views = __esm({
   "src/cli/views.ts"() {
     "use strict";
+    init_source();
     import_hanji = __toESM(require_hanji());
     init_utils();
+    Spinner = class {
+      constructor(frames) {
+        this.frames = frames;
+        this.offset = 0;
+        this.tick = () => {
+          this.iterator();
+        };
+        this.value = () => {
+          return this.frames[this.offset];
+        };
+        this.iterator = () => {
+          this.offset += 1;
+          this.offset %= frames.length - 1;
+        };
+      }
+    };
+    ProgressView = class extends import_hanji.TaskView {
+      constructor(progressText, successText) {
+        super();
+        this.progressText = progressText;
+        this.successText = successText;
+        this.spinner = new Spinner("\u28F7\u28EF\u28DF\u287F\u28BF\u28FB\u28FD\u28FE".split(""));
+        this.timeout = setInterval(() => {
+          this.spinner.tick();
+          this.requestLayout();
+        }, 128);
+        this.on("detach", () => clearInterval(this.timeout));
+      }
+      render(status) {
+        if (status === "pending") {
+          const spin = this.spinner.value();
+          return `[${spin}] ${this.progressText}`;
+        }
+        return `[${source_default.green("\u2713")}] ${this.successText}`;
+      }
+    };
   }
 });
 
@@ -5047,12 +5513,24 @@ var init_sqliteSerializer = __esm({
         `SELECT 
     m.name as "tableName", p.name as "columnName", p.type as "columnType", p."notnull" as "notNull", p.dflt_value as "defaultValue", p.pk as pk
     FROM sqlite_master AS m JOIN pragma_table_info(m.name) AS p
-    WHERE m.type = 'table' and m.tbl_name != 'sqlite_sequence' and m.tbl_name != 'sqlite_stat1' and m.tbl_name != '_litestream_seq' and m.tbl_name != '_litestream_lock' and m.tbl_name != 'libsql_wasm_func_table' and m.tbl_name != '__drizzle_migrations';
+    WHERE m.type = 'table' 
+    and m.tbl_name != 'sqlite_sequence' 
+    and m.tbl_name != 'sqlite_stat1' 
+    and m.tbl_name != '_litestream_seq' 
+    and m.tbl_name != '_litestream_lock' 
+    and m.tbl_name != 'libsql_wasm_func_table' 
+    and m.tbl_name != '__drizzle_migrations' 
+    and m.tbl_name != '_cf_KV';
     `
       );
       const tablesWithSeq = [];
       const seq = await db.query(
-        `SELECT * FROM sqlite_master WHERE name != 'sqlite_sequence' and name != 'sqlite_stat1' and name != '_litestream_seq' and name != '_litestream_lock' and sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*';`
+        `SELECT * FROM sqlite_master WHERE name != 'sqlite_sequence' 
+    and name != 'sqlite_stat1' 
+    and name != '_litestream_seq' 
+    and name != '_litestream_lock' 
+    and tbl_name != '_cf_KV' 
+    and sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*';`
       );
       for (const s of seq) {
         tablesWithSeq.push(s.name);
@@ -5137,7 +5615,8 @@ var init_sqliteSerializer = __esm({
       try {
         const fks = await db.query(
           `SELECT m.name as "tableFrom", f.id as "id", f."table" as "tableTo", f."from", f."to", f."on_update" as "onUpdate", f."on_delete" as "onDelete", f.seq as "seq"
-      FROM sqlite_master m, pragma_foreign_key_list(m.name) as f;`
+      FROM sqlite_master m, pragma_foreign_key_list(m.name) as f 
+      where m.tbl_name != '_cf_KV';`
         );
         const fkByTableName = {};
         for (const fkRow of fks) {
@@ -5196,7 +5675,9 @@ FROM sqlite_master AS m,
     pragma_index_list(m.name) AS il,
     pragma_index_info(il.name) AS ii
 WHERE 
-    m.type = 'table' and il.name NOT LIKE 'sqlite_autoindex_%';`
+    m.type = 'table' 
+    and il.name NOT LIKE 'sqlite_autoindex_%'
+    and m.tbl_name != '_cf_KV';`
       );
       for (const idxRow of idxs) {
         const tableName = idxRow.tableName;
@@ -5449,13 +5930,6 @@ var require_brace_expansion = __commonJS({
   }
 });
 
-// src/extensions/vector.ts
-var init_vector = __esm({
-  "src/extensions/vector.ts"() {
-    "use strict";
-  }
-});
-
 // src/serializer/pgSerializer.ts
 var import_pg_core2, import_pg_core3, import_drizzle_orm2, dialect4, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
 var init_pgSerializer = __esm({
@@ -5466,7 +5940,6 @@ var init_pgSerializer = __esm({
     import_drizzle_orm2 = require("drizzle-orm");
     init_serializer();
     init_outputs();
-    init_vector();
     dialect4 = new import_pg_core2.PgDialect();
     trimChar = (str, char) => {
       let start = 0;
@@ -5728,10 +6201,7 @@ var init_pgSerializer = __esm({
               columnTypeMapped = trimChar(columnTypeMapped, '"');
               columnToReturn[columnName] = {
                 name: columnName,
-                type: (
-                  // filter vectors, but in future we should filter any extension that was installed by user
-                  columnAdditionalDT === "USER-DEFINED" && enumType3 !== "vector" ? enumType3 : columnTypeMapped
-                ),
+                type: columnAdditionalDT === "USER-DEFINED" ? enumType3 : columnTypeMapped,
                 typeSchema: enumsToReturn[`${tableSchema}.${enumType3}`] !== void 0 ? enumsToReturn[`${tableSchema}.${enumType3}`].schema : void 0,
                 primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
                 // default: isSerial ? undefined : defaultValue,
@@ -5742,42 +6212,15 @@ var init_pgSerializer = __esm({
               }
             }
             const dbIndexes = await db.query(
-              `SELECT  DISTINCT ON (t.relname, ic.relname, k.i) t.relname as table_name, ic.relname AS indexname,
-        k.i AS index_order,
-        i.indisunique as is_unique,
-        am.amname as method,
-        ic.reloptions as with,
-        coalesce(a.attname,
-                  (('{' || pg_get_expr(
-                              i.indexprs,
-                              i.indrelid
-                          )
-                        || '}')::text[]
-                  )[k.i]
-                ) AS column_name,
-          CASE
-        WHEN pg_get_expr(i.indexprs, i.indrelid) IS NOT NULL THEN 1
-        ELSE 0
-    END AS is_expression,
-        i.indoption[k.i-1] & 1 = 1 AS descending,
-        i.indoption[k.i-1] & 2 = 2 AS nulls_first,
-        pg_get_expr(
-                              i.indpred,
-                              i.indrelid
-                          ) as where,
-         opc.opcname
-      FROM pg_class t
-          LEFT JOIN pg_index i ON t.oid = i.indrelid
-          LEFT JOIN pg_class ic ON ic.oid = i.indexrelid
-		  CROSS JOIN LATERAL (SELECT unnest(i.indkey), generate_subscripts(i.indkey, 1) + 1) AS k(attnum, i)
-          LEFT JOIN pg_attribute AS a
-            ON i.indrelid = a.attrelid AND k.attnum = a.attnum
-          JOIN pg_namespace c on c.oid = t.relnamespace
-        LEFT JOIN pg_am AS am ON ic.relam = am.oid
-        JOIN pg_opclass opc ON opc.oid = ANY(i.indclass)
-      WHERE
-      c.nspname = '${tableSchema}' AND
-      t.relname = '${tableName}';`
+              `SELECT t.relname as table_name, i.relname AS index_name, ix.indisunique AS is_unique, a.attname AS column_name
+          FROM pg_class t
+          JOIN pg_index ix ON t.oid = ix.indrelid
+          JOIN pg_class i ON i.oid = ix.indexrelid
+          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+          JOIN pg_namespace ns ON ns.oid = t.relnamespace
+          WHERE ns.nspname = '${tableSchema}'
+            AND t.relname = '${tableName}'
+            and ix.indisprimary = false;`
             );
             const dbIndexFromConstraint = await db.query(
               `SELECT
@@ -5794,51 +6237,18 @@ var init_pgSerializer = __esm({
             );
             const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) => it.index_name);
             for (const dbIndex of dbIndexes) {
-              const indexName = dbIndex.indexname;
+              const indexName = dbIndex.index_name;
               const indexColumnName = dbIndex.column_name;
               const indexIsUnique = dbIndex.is_unique;
-              const indexMethod = dbIndex.method;
-              const indexWith = dbIndex.with;
-              const indexWhere = dbIndex.where;
-              const opclass = dbIndex.opcname;
-              const isExpression = dbIndex.is_expression === 1;
-              const desc = dbIndex.descending;
-              const nullsFirst = dbIndex.nulls_first;
-              const mappedWith = {};
-              if (indexWith !== null) {
-                indexWith.forEach((it) => {
-                  const splitted = it.split("=");
-                  mappedWith[splitted[0]] = splitted[1];
-                });
-              }
               if (idxsInConsteraint.includes(indexName))
                 continue;
               if (typeof indexToReturn[indexName] !== "undefined") {
-                indexToReturn[indexName].columns.push({
-                  expression: indexColumnName,
-                  asc: !desc,
-                  nulls: nullsFirst ? "first" : "last",
-                  opclass,
-                  isExpression
-                });
+                indexToReturn[indexName].columns.push(indexColumnName);
               } else {
                 indexToReturn[indexName] = {
                   name: indexName,
-                  columns: [
-                    {
-                      expression: indexColumnName,
-                      asc: !desc,
-                      nulls: nullsFirst ? "first" : "last",
-                      opclass,
-                      isExpression
-                    }
-                  ],
-                  isUnique: indexIsUnique,
-                  // should not be a part of diff detecs
-                  concurrently: false,
-                  method: indexMethod,
-                  where: indexWhere === null ? void 0 : indexWhere,
-                  with: mappedWith
+                  columns: [indexColumnName],
+                  isUnique: indexIsUnique
                 };
               }
             }
@@ -5874,7 +6284,7 @@ var init_pgSerializer = __esm({
       }
       const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
       return {
-        version: "7",
+        version: "6",
         dialect: "postgresql",
         tables: result,
         enums: enumsToReturn,
@@ -5896,6 +6306,7 @@ var init_pgSerializer = __esm({
       "time without time zone": "::time without time zone",
       // "timestamp with time zone": "::timestamp with time zone",
       "timestamp without time zone": "::timestamp without time zone",
+      "timestamp(": "::timestamp without time zone",
       // date: "::date",
       // interval: "::interval",
       // character: "::bpchar",
@@ -5908,15 +6319,15 @@ var init_pgSerializer = __esm({
       "character(": "::bpchar"
     };
     defaultForColumn = (column4) => {
+      if (column4.column_default === null) {
+        return void 0;
+      }
       if (column4.data_type === "serial" || column4.data_type === "smallserial" || column4.data_type === "bigserial") {
         return void 0;
       }
       const hasDifferentDefaultCast = Object.keys(columnToDefault).find(
         (it) => column4.data_type.startsWith(it)
       );
-      if (column4.column_default === null) {
-        return void 0;
-      }
       const columnDefaultAsString = column4.column_default.toString();
       if (columnDefaultAsString.endsWith(
         hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column4.data_type
@@ -7281,7 +7692,14 @@ var sqlitePushIntrospect = async (db, filters) => {
     }
     return false;
   };
-  const res = await fromDatabase(db, filter2);
+  const progress = new ProgressView(
+    "Pulling schema from database...",
+    "Pulling schema from database..."
+  );
+  const res = await (0, import_hanji2.renderWithTask)(
+    progress,
+    fromDatabase(db, filter2)
+  );
   const schema3 = { id: originUUID, prevId: "", ...res };
   return { schema: schema3 };
 };
@@ -7289,6 +7707,8 @@ var sqlitePushIntrospect = async (db, filters) => {
 // src/cli/commands/pgIntrospect.ts
 init_pgSerializer();
 init_global();
+init_views();
+var import_hanji3 = __toESM(require_hanji());
 var pgPushIntrospect = async (db, filters, schemaFilters) => {
   const matchers = filters.map((it) => {
     return new Minimatch(it);
@@ -7303,7 +7723,14 @@ var pgPushIntrospect = async (db, filters, schemaFilters) => {
     }
     return false;
   };
-  const res = await fromDatabase2(db, filter2, schemaFilters);
+  const progress = new ProgressView(
+    "Pulling schema from database...",
+    "Pulling schema from database..."
+  );
+  const res = await (0, import_hanji3.renderWithTask)(
+    progress,
+    fromDatabase2(db, filter2, schemaFilters)
+  );
   const schema3 = { id: originUUID, prevId: "", ...res };
   const { internal, ...schemaWithoutInternals } = schema3;
   return { schema: schemaWithoutInternals };