drizzle-kit 0.20.5-c7dc2fe → 0.20.5-fd4dd75

package/utils-studio.js

@@ -542,1358 +542,1359 @@ var init_source = __esm({
   }
 });
 
-// src/serializer/index.ts
-var glob;
-var init_serializer = __esm({
-  "src/serializer/index.ts"() {
-    glob = __toESM(require("glob"));
-    init_source();
+// 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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.prepareReadLine = void 0;
+    var prepareReadLine = () => {
+      const stdin = process.stdin;
+      const stdout = process.stdout;
+      const readline = require("readline");
+      const rl = readline.createInterface({
+        input: stdin,
+        escapeCodeTimeout: 50
+      });
+      readline.emitKeypressEvents(stdin, rl);
+      return {
+        stdin,
+        stdout,
+        closable: rl
+      };
+    };
+    exports.prepareReadLine = prepareReadLine;
   }
 });
 
-// src/cli/validations/outputs.ts
-var init_outputs = __esm({
-  "src/cli/validations/outputs.ts"() {
-    init_source();
+// node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module2) {
+    "use strict";
+    var ESC = "\x1B";
+    var CSI = `${ESC}[`;
+    var beep = "\x07";
+    var cursor = {
+      to(x, y) {
+        if (!y)
+          return `${CSI}${x + 1}G`;
+        return `${CSI}${y + 1};${x + 1}H`;
+      },
+      move(x, y) {
+        let ret = "";
+        if (x < 0)
+          ret += `${CSI}${-x}D`;
+        else if (x > 0)
+          ret += `${CSI}${x}C`;
+        if (y < 0)
+          ret += `${CSI}${-y}A`;
+        else if (y > 0)
+          ret += `${CSI}${y}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI}${count}A`,
+      down: (count = 1) => `${CSI}${count}B`,
+      forward: (count = 1) => `${CSI}${count}C`,
+      backward: (count = 1) => `${CSI}${count}D`,
+      nextLine: (count = 1) => `${CSI}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI}F`.repeat(count),
+      left: `${CSI}G`,
+      hide: `${CSI}?25l`,
+      show: `${CSI}?25h`,
+      save: `${ESC}7`,
+      restore: `${ESC}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI}S`.repeat(count),
+      down: (count = 1) => `${CSI}T`.repeat(count)
+    };
+    var erase = {
+      screen: `${CSI}2J`,
+      up: (count = 1) => `${CSI}1J`.repeat(count),
+      down: (count = 1) => `${CSI}J`.repeat(count),
+      line: `${CSI}2K`,
+      lineEnd: `${CSI}K`,
+      lineStart: `${CSI}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i = 0; i < count; i++)
+          clear += this.line + (i < count - 1 ? cursor.up() : "");
+        if (count)
+          clear += cursor.left;
+        return clear;
+      }
+    };
+    module2.exports = { cursor, scroll, erase, beep };
   }
 });
 
-// src/serializer/pgSerializer.ts
-var import_pg_core, import_pg_core2, import_drizzle_orm, dialect, trimChar, fromDatabase, columnToDefault, defaultForColumn, toDrizzle;
-var init_pgSerializer = __esm({
-  "src/serializer/pgSerializer.ts"() {
-    import_pg_core = require("drizzle-orm/pg-core");
-    import_pg_core2 = require("drizzle-orm/pg-core");
-    import_drizzle_orm = require("drizzle-orm");
-    init_serializer();
-    init_source();
-    init_outputs();
-    dialect = new import_pg_core.PgDialect();
-    trimChar = (str, char) => {
-      let start = 0;
-      let end = str.length;
-      while (start < end && str[start] === char)
-        ++start;
-      while (end > start && str[end - 1] === char)
-        --end;
-      return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
+// node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/utils.js
+var require_utils = __commonJS({
+  "node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.clear = void 0;
+    var sisteransi_1 = require_src();
+    var strip = (str) => {
+      const pattern = [
+        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"
+      ].join("|");
+      const RGX = new RegExp(pattern, "g");
+      return typeof str === "string" ? str.replace(RGX, "") : str;
     };
-    fromDatabase = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
-      const result = {};
-      const internals = { tables: {} };
-      const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
-      const allTables = await db.query(
-        `SELECT table_schema, table_name FROM information_schema.tables WHERE ${where};`
-      );
-      const schemas = new Set(allTables.map((it) => it.table_schema));
-      schemas.delete("public");
-      const allSchemas = await db.query(`select s.nspname as table_schema
-  from pg_catalog.pg_namespace s
-  join pg_catalog.pg_user u on u.usesysid = s.nspowner
-  where nspname not in ('information_schema', 'pg_catalog', 'public')
-        and nspname not like 'pg_toast%'
-        and nspname not like 'pg_temp_%'
-  order by table_schema;`);
-      allSchemas.forEach((item) => {
-        if (schemaFilters.includes(item.table_schema)) {
-          schemas.add(item.table_schema);
+    var stringWidth = (str) => [...strip(str)].length;
+    var clear = function(prompt, perLine) {
+      if (!perLine)
+        return sisteransi_1.erase.line + sisteransi_1.cursor.to(0);
+      let rows = 0;
+      const lines = prompt.split(/\r?\n/);
+      for (let line of lines) {
+        rows += 1 + Math.floor(Math.max(stringWidth(line) - 1, 0) / perLine);
+      }
+      return sisteransi_1.erase.lines(rows);
+    };
+    exports.clear = clear;
+  }
+});
+
+// node_modules/.pnpm/lodash.throttle@4.1.1/node_modules/lodash.throttle/index.js
+var require_lodash = __commonJS({
+  "node_modules/.pnpm/lodash.throttle@4.1.1/node_modules/lodash.throttle/index.js"(exports, module2) {
+    var FUNC_ERROR_TEXT = "Expected a function";
+    var NAN = 0 / 0;
+    var symbolTag = "[object Symbol]";
+    var reTrim = /^\s+|\s+$/g;
+    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+    var reIsBinary = /^0b[01]+$/i;
+    var reIsOctal = /^0o[0-7]+$/i;
+    var freeParseInt = parseInt;
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    var objectProto = Object.prototype;
+    var objectToString = objectProto.toString;
+    var nativeMax = Math.max;
+    var nativeMin = Math.min;
+    var now = function() {
+      return root.Date.now();
+    };
+    function debounce(func, wait, options) {
+      var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+      if (typeof func != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      wait = toNumber(wait) || 0;
+      if (isObject(options)) {
+        leading = !!options.leading;
+        maxing = "maxWait" in options;
+        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+        trailing = "trailing" in options ? !!options.trailing : trailing;
+      }
+      function invokeFunc(time) {
+        var args = lastArgs, thisArg = lastThis;
+        lastArgs = lastThis = void 0;
+        lastInvokeTime = time;
+        result = func.apply(thisArg, args);
+        return result;
+      }
+      function leadingEdge(time) {
+        lastInvokeTime = time;
+        timerId = setTimeout(timerExpired, wait);
+        return leading ? invokeFunc(time) : result;
+      }
+      function remainingWait(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait - timeSinceLastCall;
+        return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
+      }
+      function shouldInvoke(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+        return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+      }
+      function timerExpired() {
+        var time = now();
+        if (shouldInvoke(time)) {
+          return trailingEdge(time);
         }
-      });
-      let columnsCount = 0;
-      let indexesCount = 0;
-      let foreignKeysCount = 0;
-      let tableCount = 0;
-      const all = allTables.map((row) => {
-        return new Promise(async (res, rej) => {
-          const tableName = row.table_name;
-          if (!tablesFilter(tableName))
-            return res("");
-          tableCount += 1;
-          const tableSchema = row.table_schema;
-          try {
-            const columnToReturn = {};
-            const indexToReturn = {};
-            const foreignKeysToReturn = {};
-            const primaryKeys = {};
-            const uniqueConstrains = {};
-            const tableResponse = await db.query(
-              `SELECT a.attrelid::regclass::text, a.attname, is_nullable, a.attndims as array_dimensions
-        , CASE WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[])
-             AND EXISTS (
-                SELECT FROM pg_attrdef ad
-                WHERE  ad.adrelid = a.attrelid
-                AND    ad.adnum   = a.attnum
-                AND    pg_get_expr(ad.adbin, ad.adrelid)
-                     = 'nextval('''
-                    || (pg_get_serial_sequence (a.attrelid::regclass::text
-                                             , a.attname))::regclass
-                    || '''::regclass)'
-                )
-           THEN CASE a.atttypid
-                   WHEN 'int'::regtype  THEN 'serial'
-                   WHEN 'int8'::regtype THEN 'bigserial'
-                   WHEN 'int2'::regtype THEN 'smallserial'
-                END
-           ELSE format_type(a.atttypid, a.atttypmod)
-           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default, INFORMATION_SCHEMA.COLUMNS.data_type as additional_dt
-   FROM  pg_attribute  a
-   JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
-   WHERE  a.attrelid = '"${tableSchema}"."${tableName}"'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}'
-   AND    a.attnum > 0
-   AND    NOT a.attisdropped
-   ORDER  BY a.attnum;`
-            );
-            const tableConstraints = await db.query(
-              `SELECT c.column_name, c.data_type, constraint_type, constraint_name, constraint_schema
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name)
-      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
-        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
-      WHERE tc.table_name = '${tableName}' and constraint_schema = '${tableSchema}';`
-            );
-            columnsCount += tableResponse.length;
-            if (progressCallback) {
-              progressCallback("columns", columnsCount, "fetching");
-            }
-            const tableForeignKeys = await db.query(
-              `SELECT
-        tc.table_schema,
-        tc.constraint_name,
-        tc.table_name,
-        kcu.column_name,
-        ccu.table_schema AS foreign_table_schema,
-        ccu.table_name AS foreign_table_name,
-        ccu.column_name AS foreign_column_name,
-        rc.delete_rule, rc.update_rule
-    FROM
-        information_schema.table_constraints AS tc
-        JOIN information_schema.key_column_usage AS kcu
-          ON tc.constraint_name = kcu.constraint_name
-          AND tc.table_schema = kcu.table_schema
-        JOIN information_schema.constraint_column_usage AS ccu
-          ON ccu.constraint_name = tc.constraint_name
-          AND ccu.table_schema = tc.table_schema
-        JOIN information_schema.referential_constraints AS rc
-          ON ccu.constraint_name = rc.constraint_name
-    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${tableName}' and tc.table_schema='${tableSchema}';`
-            );
-            foreignKeysCount += tableForeignKeys.length;
-            if (progressCallback) {
-              progressCallback("fks", foreignKeysCount, "fetching");
-            }
-            for (const fk of tableForeignKeys) {
-              const columnFrom = fk.column_name;
-              const tableTo = fk.foreign_table_name;
-              const columnTo = fk.foreign_column_name;
-              const foreignKeyName = fk.constraint_name;
-              const onUpdate = fk.update_rule.toLowerCase();
-              const onDelete = fk.delete_rule.toLowerCase();
-              if (typeof foreignKeysToReturn[foreignKeyName] !== "undefined") {
-                foreignKeysToReturn[foreignKeyName].columnsFrom.push(columnFrom);
-                foreignKeysToReturn[foreignKeyName].columnsTo.push(columnTo);
-              } else {
-                foreignKeysToReturn[foreignKeyName] = {
-                  name: foreignKeyName,
-                  tableFrom: tableName,
-                  tableTo,
-                  columnsFrom: [columnFrom],
-                  columnsTo: [columnTo],
-                  onDelete,
-                  onUpdate
-                };
-              }
-              foreignKeysToReturn[foreignKeyName].columnsFrom = [
-                ...new Set(foreignKeysToReturn[foreignKeyName].columnsFrom)
-              ];
-              foreignKeysToReturn[foreignKeyName].columnsTo = [
-                ...new Set(foreignKeysToReturn[foreignKeyName].columnsTo)
-              ];
-            }
-            const uniqueConstrainsRows = tableConstraints.filter(
-              (mapRow) => mapRow.constraint_type === "UNIQUE"
-            );
-            for (const unqs of uniqueConstrainsRows) {
-              const columnName = unqs.column_name;
-              const constraintName = unqs.constraint_name;
-              if (typeof uniqueConstrains[constraintName] !== "undefined") {
-                uniqueConstrains[constraintName].columns.push(columnName);
-              } else {
-                uniqueConstrains[constraintName] = {
-                  columns: [columnName],
-                  nullsNotDistinct: false,
-                  name: constraintName
-                };
-              }
-            }
-            for (const columnResponse of tableResponse) {
-              const columnName = columnResponse.attname;
-              const columnAdditionalDT = columnResponse.additional_dt;
-              const columnDimensions = columnResponse.array_dimensions;
-              let columnType = columnResponse.data_type;
-              const primaryKey = tableConstraints.filter(
-                (mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === "PRIMARY KEY"
-              );
-              const cprimaryKey = tableConstraints.filter(
-                (mapRow) => mapRow.constraint_type === "PRIMARY KEY"
-              );
-              if (cprimaryKey.length > 1) {
-                const tableCompositePkName = await db.query(
-                  `SELECT conname AS primary_key
-            FROM   pg_constraint join pg_class on (pg_class.oid = conrelid)
-            WHERE  contype = 'p' 
-            AND    connamespace = $1::regnamespace  
-            AND    pg_class.relname = $2;`,
-                  [tableSchema, tableName]
-                );
-                primaryKeys[tableCompositePkName[0].primary_key] = {
-                  name: tableCompositePkName[0].primary_key,
-                  columns: cprimaryKey.map((c) => c.column_name)
-                };
-              }
-              const defaultValue = defaultForColumn(columnResponse);
-              const isSerial = columnType === "serial";
-              let columnTypeMapped = columnType;
-              if (columnTypeMapped.startsWith("numeric(")) {
-                columnTypeMapped = columnTypeMapped.replace(",", ", ");
-              }
-              if (columnAdditionalDT === "ARRAY") {
-                if (typeof internals.tables[tableName] === "undefined") {
-                  internals.tables[tableName] = {
-                    columns: {
-                      [columnName]: {
-                        isArray: true,
-                        dimensions: columnDimensions,
-                        rawType: columnTypeMapped.substring(
-                          0,
-                          columnTypeMapped.length - 2
-                        )
-                      }
-                    }
-                  };
-                } else {
-                  if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
-                    internals.tables[tableName].columns[columnName] = {
-                      isArray: true,
-                      dimensions: columnDimensions,
-                      rawType: columnTypeMapped.substring(
-                        0,
-                        columnTypeMapped.length - 2
-                      )
-                    };
-                  }
-                }
-              }
-              if (columnAdditionalDT === "ARRAY") {
-                for (let i = 1; i < Number(columnDimensions); i++) {
-                  columnTypeMapped += "[]";
-                }
-              }
-              columnTypeMapped = columnTypeMapped.replace("character varying", "varchar").replace(" without time zone", "").replace("character", "char");
-              columnTypeMapped = trimChar(columnTypeMapped, '"');
-              columnToReturn[columnName] = {
-                name: columnName,
-                type: columnTypeMapped,
-                primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
-                // default: isSerial ? undefined : defaultValue,
-                notNull: columnResponse.is_nullable === "NO"
-              };
-              if (!isSerial && typeof defaultValue !== "undefined") {
-                columnToReturn[columnName].default = defaultValue;
-              }
-            }
-            const dbIndexes = await db.query(
-              `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
-          idx.indexrelname AS index_name,
-          idx.relname AS table_name,
-          schemaname,
-          CASE WHEN con.conname IS NOT NULL THEN 1 ELSE 0 END AS generated_by_constraint
-        FROM
-          pg_stat_user_indexes idx
-        LEFT JOIN
-          pg_constraint con ON con.conindid = idx.indexrelid
-        WHERE idx.relname = '${tableName}' and schemaname = '${tableSchema}'
-        group by index_name, table_name,schemaname, generated_by_constraint;`
-            );
-            const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) => it.index_name);
-            for (const dbIndex of dbIndexes) {
-              const indexName2 = dbIndex.index_name;
-              const indexColumnName = dbIndex.column_name;
-              const indexIsUnique = dbIndex.is_unique;
-              if (idxsInConsteraint.includes(indexName2))
-                continue;
-              if (typeof indexToReturn[indexName2] !== "undefined") {
-                indexToReturn[indexName2].columns.push(indexColumnName);
-              } else {
-                indexToReturn[indexName2] = {
-                  name: indexName2,
-                  columns: [indexColumnName],
-                  isUnique: indexIsUnique
-                };
-              }
-            }
-            indexesCount += Object.keys(indexToReturn).length;
-            if (progressCallback) {
-              progressCallback("indexes", indexesCount, "fetching");
-            }
-            result[tableName] = {
-              name: tableName,
-              schema: tableSchema !== "public" ? tableSchema : "",
-              columns: columnToReturn,
-              indexes: indexToReturn,
-              foreignKeys: foreignKeysToReturn,
-              compositePrimaryKeys: primaryKeys,
-              uniqueConstraints: uniqueConstrains
-            };
-          } catch (e) {
-            rej(e);
-            return;
-          }
-          res("");
-        });
-      });
-      if (progressCallback) {
-        progressCallback("tables", tableCount, "done");
+        timerId = setTimeout(timerExpired, remainingWait(time));
       }
-      for await (const _ of all) {
+      function trailingEdge(time) {
+        timerId = void 0;
+        if (trailing && lastArgs) {
+          return invokeFunc(time);
+        }
+        lastArgs = lastThis = void 0;
+        return result;
       }
-      if (progressCallback) {
-        progressCallback("columns", columnsCount, "done");
-        progressCallback("indexes", indexesCount, "done");
-        progressCallback("fks", foreignKeysCount, "done");
+      function cancel() {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = void 0;
       }
-      const allEnums = await db.query(
-        `select n.nspname as enum_schema,
-  t.typname as enum_name,
-  e.enumlabel as enum_value
-  from pg_type t
-  join pg_enum e on t.oid = e.enumtypid
-  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`
-      );
-      const enumsToReturn = {};
-      for (const dbEnum of allEnums) {
-        const enumName = dbEnum.enum_name;
-        const enumValue = dbEnum.enum_value;
-        if (enumsToReturn[enumName] !== void 0 && enumsToReturn[enumName] !== null) {
-          enumsToReturn[enumName].values[enumValue] = enumValue;
-        } else {
-          enumsToReturn[enumName] = {
-            name: enumName,
-            values: { [enumValue]: enumValue }
-          };
+      function flush() {
+        return timerId === void 0 ? result : trailingEdge(now());
+      }
+      function debounced() {
+        var time = now(), isInvoking = shouldInvoke(time);
+        lastArgs = arguments;
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+          if (timerId === void 0) {
+            return leadingEdge(lastCallTime);
+          }
+          if (maxing) {
+            timerId = setTimeout(timerExpired, wait);
+            return invokeFunc(lastCallTime);
+          }
+        }
+        if (timerId === void 0) {
+          timerId = setTimeout(timerExpired, wait);
         }
+        return result;
       }
-      if (progressCallback) {
-        progressCallback("enums", Object.keys(enumsToReturn).length, "done");
+      debounced.cancel = cancel;
+      debounced.flush = flush;
+      return debounced;
+    }
+    function throttle(func, wait, options) {
+      var leading = true, trailing = true;
+      if (typeof func != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
       }
-      const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
-      return {
-        version: "5",
-        dialect: "pg",
-        tables: result,
-        enums: enumsToReturn,
-        schemas: schemasObject,
-        _meta: {
-          schemas: {},
-          tables: {},
-          columns: {}
-        },
-        internal: internals
-      };
+      if (isObject(options)) {
+        leading = "leading" in options ? !!options.leading : leading;
+        trailing = "trailing" in options ? !!options.trailing : trailing;
+      }
+      return debounce(func, wait, {
+        "leading": leading,
+        "maxWait": wait,
+        "trailing": trailing
+      });
+    }
+    function isObject(value) {
+      var type = typeof value;
+      return !!value && (type == "object" || type == "function");
+    }
+    function isObjectLike(value) {
+      return !!value && typeof value == "object";
+    }
+    function isSymbol(value) {
+      return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+    }
+    function toNumber(value) {
+      if (typeof value == "number") {
+        return value;
+      }
+      if (isSymbol(value)) {
+        return NAN;
+      }
+      if (isObject(value)) {
+        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+        value = isObject(other) ? other + "" : other;
+      }
+      if (typeof value != "string") {
+        return value === 0 ? value : +value;
+      }
+      value = value.replace(reTrim, "");
+      var isBinary = reIsBinary.test(value);
+      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+    }
+    module2.exports = throttle;
+  }
+});
+
+// node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/index.js
+var require_hanji = __commonJS({
+  "node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/index.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
     };
-    columnToDefault = {
-      "numeric(": "::numeric",
-      // text: "::text",
-      // "character varying": "::character varying",
-      // "double precision": "::double precision",
-      // "time with time zone": "::time with time zone",
-      "time without time zone": "::time without time zone",
-      // "timestamp with time zone": "::timestamp with time zone",
-      "timestamp without time zone": "::timestamp without time zone",
-      // date: "::date",
-      // interval: "::interval",
-      // character: "::bpchar",
-      // macaddr8: "::macaddr8",
-      // macaddr: "::macaddr",
-      // inet: "::inet",
-      // cidr: "::cidr",
-      // jsonb: "::jsonb",
-      // json: "::json",
-      "character(": "::bpchar"
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
     };
-    defaultForColumn = (column) => {
-      if (column.data_type === "serial" || column.data_type === "smallserial" || column.data_type === "bigserial") {
-        return void 0;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.onTerminate = exports.renderWithTask = exports.render = exports.TaskTerminal = exports.TaskView = exports.Terminal = exports.deferred = exports.SelectState = exports.Prompt = void 0;
+    var readline_1 = require_readline();
+    var sisteransi_1 = require_src();
+    var utils_1 = require_utils();
+    var lodash_throttle_1 = __importDefault(require_lodash());
+    var Prompt2 = class {
+      constructor() {
+        this.attachCallbacks = [];
+        this.detachCallbacks = [];
+        this.inputCallbacks = [];
       }
-      const hasDifferentDefaultCast = Object.keys(columnToDefault).find(
-        (it) => column.data_type.startsWith(it)
-      );
-      if (column.column_default === null) {
-        return void 0;
+      requestLayout() {
+        this.terminal.requestLayout();
       }
-      const columnDefaultAsString = column.column_default.toString();
-      if (columnDefaultAsString.endsWith(
-        hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column.data_type
-      )) {
-        const nonPrefixPart = column.column_default.length - (hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`).length - 1;
-        const rt = column.column_default.toString().substring(1, nonPrefixPart);
-        if (/^-?[\d.]+(?:e-?\d+)?$/.test(rt) && !column.data_type.startsWith("numeric")) {
-          return Number(rt);
-        } else if (column.data_type === "json" || column.data_type === "jsonb") {
-          const jsonWithoutSpaces = JSON.stringify(JSON.parse(rt));
-          return `'${jsonWithoutSpaces}'${hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`}`;
-        } else if (column.data_type === "boolean") {
-          return column.column_default === "true";
-        } else {
-          return `'${rt}'`;
+      on(type, callback) {
+        if (type === "attach") {
+          this.attachCallbacks.push(callback);
+        } else if (type === "detach") {
+          this.detachCallbacks.push(callback);
+        } else if (type === "input") {
+          this.inputCallbacks.push(callback);
         }
-      } else {
-        if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString) && !column.data_type.startsWith("numeric")) {
-          return Number(columnDefaultAsString);
-        } else if (column.data_type === "boolean") {
-          return column.column_default === "true";
-        } else {
-          return `${columnDefaultAsString}`;
+      }
+      attach(terminal) {
+        this.terminal = terminal;
+        this.attachCallbacks.forEach((it) => it(terminal));
+      }
+      detach(terminal) {
+        this.detachCallbacks.forEach((it) => it(terminal));
+        this.terminal = void 0;
+      }
+      input(str, key) {
+        this.inputCallbacks.forEach((it) => it(str, key));
+      }
+    };
+    exports.Prompt = Prompt2;
+    var SelectState2 = class {
+      constructor(items) {
+        this.items = items;
+        this.selectedIdx = 0;
+      }
+      bind(prompt) {
+        prompt.on("input", (str, key) => {
+          const invalidate = this.consume(str, key);
+          if (invalidate)
+            prompt.requestLayout();
+        });
+      }
+      consume(str, key) {
+        if (!key)
+          return false;
+        if (key.name === "down") {
+          this.selectedIdx = (this.selectedIdx + 1) % this.items.length;
+          return true;
+        }
+        if (key.name === "up") {
+          this.selectedIdx -= 1;
+          this.selectedIdx = this.selectedIdx < 0 ? this.items.length - 1 : this.selectedIdx;
+          return true;
         }
+        return false;
       }
     };
-    toDrizzle = (schema, schemaName) => {
-      const tables = {};
-      Object.values(schema.tables).forEach((t) => {
-        const columns = {};
-        Object.values(t.columns).forEach((c) => {
-          const columnName = c.name;
-          const type = c.type;
-          let columnBuilder;
-          if (type === "bigint") {
-            columnBuilder = new import_pg_core.PgBigInt53Builder(columnName);
-          } else if (type === "bigserial") {
-            columnBuilder = new import_pg_core.PgBigSerial53Builder(columnName);
-          } else if (type === "boolean") {
-            columnBuilder = new import_pg_core.PgBooleanBuilder(columnName);
-          } else if (type === "cidr") {
-            columnBuilder = new import_pg_core.PgCidrBuilder(columnName);
-          } else if (type === "date") {
-            columnBuilder = new import_pg_core.PgDateBuilder(columnName);
-          } else if (type === "double precision") {
-            columnBuilder = new import_pg_core.PgDoublePrecisionBuilder(columnName);
-          } else if (type === "inet") {
-            columnBuilder = new import_pg_core.PgInetBuilder(columnName);
-          } else if (type === "integer") {
-            columnBuilder = new import_pg_core.PgIntegerBuilder(columnName);
-          } else if (type === "interval" || type.startsWith("interval ")) {
-            columnBuilder = new import_pg_core.PgIntervalBuilder(columnName, {});
-          } else if (type === "json") {
-            columnBuilder = new import_pg_core.PgJsonBuilder(columnName);
-          } else if (type === "jsonb") {
-            columnBuilder = new import_pg_core.PgJsonbBuilder(columnName);
-          } else if (type === "macaddr") {
-            columnBuilder = new import_pg_core.PgMacaddrBuilder(columnName);
-          } else if (type === "macaddr8") {
-            columnBuilder = new import_pg_core.PgMacaddr8Builder(columnName);
-          } else if (type === "numeric" || type.startsWith("numeric(")) {
-            columnBuilder = new import_pg_core.PgNumericBuilder(columnName);
-          } else if (type === "real") {
-            columnBuilder = new import_pg_core.PgRealBuilder(columnName);
-          } else if (type === "serial") {
-            columnBuilder = new import_pg_core.PgSerialBuilder(columnName);
-          } else if (type === "smallint") {
-            columnBuilder = new import_pg_core.PgSmallIntBuilder(columnName);
-          } else if (type === "smallserial") {
-            columnBuilder = new import_pg_core.PgSmallSerialBuilder(columnName);
-          } else if (type === "text") {
-            columnBuilder = new import_pg_core.PgTextBuilder(columnName, {});
-          } else if (type === "time" || type.startsWith("time(") || type === "time with time zone") {
-            columnBuilder = new import_pg_core.PgTimeBuilder(columnName, false, void 0);
-          } else if (type === "timestamp" || type.startsWith("timestamp(") || type === "timestamp with time zone") {
-            columnBuilder = new import_pg_core.PgTimestampBuilder(columnName, false, void 0);
-          } else if (type === "uuid") {
-            columnBuilder = new import_pg_core.PgUUIDBuilder(columnName);
-          } else if (type === "varchar" || type.startsWith("varchar(")) {
-            columnBuilder = new import_pg_core.PgVarcharBuilder(columnName, {});
-          } else if (type === "char" || type.startsWith("char(")) {
-            columnBuilder = new import_pg_core.PgCharBuilder(columnName, {});
-          } else {
-            columnBuilder = (0, import_pg_core.customType)({
-              dataType() {
-                return type;
-              }
-            })(columnName);
-          }
-          if (c.notNull) {
-            columnBuilder = columnBuilder.notNull();
+    exports.SelectState = SelectState2;
+    var deferred = () => {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      return {
+        resolve,
+        reject,
+        promise
+      };
+    };
+    exports.deferred = deferred;
+    var Terminal = class {
+      constructor(view, stdin, stdout, closable) {
+        this.view = view;
+        this.stdin = stdin;
+        this.stdout = stdout;
+        this.closable = closable;
+        this.text = "";
+        this.status = "idle";
+        if (this.stdin.isTTY)
+          this.stdin.setRawMode(true);
+        const keypress = (str, key) => {
+          if (key.name === "c" && key.ctrl === true) {
+            this.requestLayout();
+            this.view.detach(this);
+            this.tearDown(keypress);
+            if (terminateHandler) {
+              terminateHandler(this.stdin, this.stdout);
+              return;
+            }
+            this.stdout.write(`
+^C
+`);
+            process.exit(1);
           }
-          if (c.default) {
-            columnBuilder = columnBuilder.default(c.default);
+          if (key.name === "escape") {
+            this.status = "aborted";
+            this.requestLayout();
+            this.view.detach(this);
+            this.tearDown(keypress);
+            this.resolve({ status: "aborted", data: void 0 });
+            return;
           }
-          if (c.primaryKey) {
-            columnBuilder = columnBuilder.primaryKey();
+          if (key.name === "return") {
+            this.status = "submitted";
+            this.requestLayout();
+            this.view.detach(this);
+            this.tearDown(keypress);
+            this.resolve({ status: "submitted", data: this.view.result() });
+            return;
           }
-          columns[columnName] = columnBuilder;
+          view.input(str, key);
+        };
+        this.stdin.on("keypress", keypress);
+        this.view.attach(this);
+        const { resolve, promise } = (0, exports.deferred)();
+        this.resolve = resolve;
+        this.promise = promise;
+        this.renderFunc = (0, lodash_throttle_1.default)((str) => {
+          this.stdout.write(str);
         });
-        if (schemaName === "public") {
-          tables[t.name] = (0, import_pg_core.pgTable)(t.name, columns, (cb) => {
-            const res = {};
-            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
-              const gh = cpk.columns.map((c) => cb[c]);
-              res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
-                gh,
-                cpk.name
-              );
-            });
-            return res;
-          });
+      }
+      tearDown(keypress) {
+        this.stdout.write(sisteransi_1.cursor.show);
+        this.stdin.removeListener("keypress", keypress);
+        if (this.stdin.isTTY)
+          this.stdin.setRawMode(false);
+        this.closable.close();
+      }
+      result() {
+        return this.promise;
+      }
+      toggleCursor(state) {
+        if (state === "hide") {
+          this.stdout.write(sisteransi_1.cursor.hide);
         } else {
-          tables[t.name] = (0, import_pg_core.pgSchema)(schemaName).table(t.name, columns, (cb) => {
-            const res = {};
-            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
-              const gh = cpk.columns.map((c) => cb[c]);
-              res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
-                gh,
-                cpk.name
-              );
-            });
-            return res;
-          });
+          this.stdout.write(sisteransi_1.cursor.show);
         }
-      });
-      return tables;
+      }
+      requestLayout() {
+        const string = this.view.render(this.status);
+        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
+        this.text = string;
+        this.renderFunc(`${clearPrefix}${string}`);
+      }
+    };
+    exports.Terminal = Terminal;
+    var TaskView2 = class {
+      constructor() {
+        this.attachCallbacks = [];
+        this.detachCallbacks = [];
+      }
+      requestLayout() {
+        this.terminal.requestLayout();
+      }
+      attach(terminal) {
+        this.terminal = terminal;
+        this.attachCallbacks.forEach((it) => it(terminal));
+      }
+      detach(terminal) {
+        this.detachCallbacks.forEach((it) => it(terminal));
+        this.terminal = void 0;
+      }
+      on(type, callback) {
+        if (type === "attach") {
+          this.attachCallbacks.push(callback);
+        } else if (type === "detach") {
+          this.detachCallbacks.push(callback);
+        }
+      }
+    };
+    exports.TaskView = TaskView2;
+    var TaskTerminal = class {
+      constructor(view, stdout) {
+        this.view = view;
+        this.stdout = stdout;
+        this.text = "";
+        this.view.attach(this);
+      }
+      requestLayout() {
+        const string = this.view.render("pending");
+        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
+        this.text = string;
+        this.stdout.write(`${clearPrefix}${string}`);
+      }
+      clear() {
+        const string = this.view.render("done");
+        this.view.detach(this);
+        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
+        this.stdout.write(`${clearPrefix}${string}`);
+      }
     };
+    exports.TaskTerminal = TaskTerminal;
+    function render2(view) {
+      const { stdin, stdout, closable } = (0, readline_1.prepareReadLine)();
+      if (view instanceof Prompt2) {
+        const terminal = new Terminal(view, stdin, stdout, closable);
+        terminal.requestLayout();
+        return terminal.result();
+      }
+      stdout.write(`${view}
+`);
+      closable.close();
+      return;
+    }
+    exports.render = render2;
+    function renderWithTask3(view, task) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const terminal = new TaskTerminal(view, process.stdout);
+        terminal.requestLayout();
+        const result = yield task;
+        terminal.clear();
+        return result;
+      });
+    }
+    exports.renderWithTask = renderWithTask3;
+    var terminateHandler;
+    function onTerminate(callback) {
+      terminateHandler = callback;
+    }
+    exports.onTerminate = onTerminate;
   }
 });
 
-// src/serializer/sqliteSerializer.ts
-function mapSqlToSqliteType(sqlType) {
-  if ([
-    "int",
-    "integer",
-    "integer auto_increment",
-    "tinyint",
-    "smallint",
-    "mediumint",
-    "bigint",
-    "unsigned big int",
-    "int2",
-    "int8"
-  ].includes(sqlType.toLowerCase())) {
-    return "integer";
-  } else if ([
-    "character",
-    "varchar",
-    "vatying character",
-    "nchar",
-    "native character",
-    "nvarchar",
-    "text",
-    "clob"
-  ].some((it) => it.startsWith(sqlType.toLowerCase()))) {
-    return "text";
-  } else if (sqlType.toLowerCase() === "blob") {
-    return "blob";
-  } else if (["real", "double", "double precision", "float"].includes(
-    sqlType.toLowerCase()
-  )) {
-    return "real";
-  } else {
-    return "numeric";
+// src/cli/views.ts
+var import_hanji;
+var init_views = __esm({
+  "src/cli/views.ts"() {
+    init_source();
+    import_hanji = __toESM(require_hanji());
   }
-}
-var import_drizzle_orm2, import_sqlite_core, dialect2, fromDatabase2, toDrizzle2;
-var init_sqliteSerializer = __esm({
-  "src/serializer/sqliteSerializer.ts"() {
-    import_drizzle_orm2 = require("drizzle-orm");
-    import_sqlite_core = require("drizzle-orm/sqlite-core");
+});
+
+// src/serializer/index.ts
+var glob;
+var init_serializer = __esm({
+  "src/serializer/index.ts"() {
+    glob = __toESM(require("glob"));
+    init_source();
+    init_views();
+  }
+});
+
+// src/cli/validations/outputs.ts
+var init_outputs = __esm({
+  "src/cli/validations/outputs.ts"() {
+    init_source();
+  }
+});
+
+// src/serializer/pgSerializer.ts
+var import_pg_core, import_pg_core2, import_drizzle_orm, dialect, trimChar, fromDatabase, columnToDefault, defaultForColumn, toDrizzle;
+var init_pgSerializer = __esm({
+  "src/serializer/pgSerializer.ts"() {
+    import_pg_core = require("drizzle-orm/pg-core");
+    import_pg_core2 = require("drizzle-orm/pg-core");
+    import_drizzle_orm = require("drizzle-orm");
     init_serializer();
-    init_outputs();
     init_source();
-    dialect2 = new import_sqlite_core.SQLiteSyncDialect();
-    fromDatabase2 = async (db, tablesFilter = (table) => true, progressCallback) => {
+    init_outputs();
+    dialect = new import_pg_core.PgDialect();
+    trimChar = (str, char) => {
+      let start = 0;
+      let end = str.length;
+      while (start < end && str[start] === char)
+        ++start;
+      while (end > start && str[end - 1] === char)
+        --end;
+      return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
+    };
+    fromDatabase = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
       const result = {};
-      const columns = await db.query(
-        `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';
-    `
-      );
-      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[^'']*';`
+      const internals = { tables: {} };
+      const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
+      const allTables = await db.query(
+        `SELECT table_schema, table_name FROM information_schema.tables WHERE ${where};`
       );
-      for (const s of seq) {
-        tablesWithSeq.push(s.name);
-      }
+      const schemas = new Set(allTables.map((it) => it.table_schema));
+      schemas.delete("public");
+      const allSchemas = await db.query(`select s.nspname as table_schema
+  from pg_catalog.pg_namespace s
+  join pg_catalog.pg_user u on u.usesysid = s.nspowner
+  where nspname not in ('information_schema', 'pg_catalog', 'public')
+        and nspname not like 'pg_toast%'
+        and nspname not like 'pg_temp_%'
+  order by table_schema;`);
+      allSchemas.forEach((item) => {
+        if (schemaFilters.includes(item.table_schema)) {
+          schemas.add(item.table_schema);
+        }
+      });
       let columnsCount = 0;
-      let tablesCount = /* @__PURE__ */ new Set();
       let indexesCount = 0;
       let foreignKeysCount = 0;
-      const tableToPk = {};
-      for (const column of columns) {
-        if (!tablesFilter(column.tableName))
-          continue;
-        columnsCount += 1;
-        if (progressCallback) {
-          progressCallback("columns", columnsCount, "fetching");
-        }
-        const tableName = column.tableName;
-        tablesCount.add(tableName);
-        if (progressCallback) {
-          progressCallback("tables", tablesCount.size, "fetching");
-        }
-        const columnName = column.columnName;
-        const isNotNull = column.notNull === 1;
-        const columnType = column.columnType;
-        const isPrimary = column.pk !== 0;
-        const columnDefault = column.defaultValue;
-        const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
-        if (isPrimary) {
-          if (typeof tableToPk[tableName] === "undefined") {
-            tableToPk[tableName] = [columnName];
-          } else {
-            tableToPk[tableName].push(columnName);
-          }
-        }
-        const table = result[tableName];
-        const newColumn = {
-          default: columnDefault === null ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) ? Number(columnDefault) : ["CURRENT_TIME", "CURRENT_DATE", "CURRENT_TIMESTAMP"].includes(
-            columnDefault
-          ) ? `(${columnDefault})` : columnDefault === "false" ? false : columnDefault === "true" ? true : columnDefault.startsWith("'") && columnDefault.endsWith("'") ? columnDefault : (
-            // ? columnDefault.substring(1, columnDefault.length - 1)
-            `(${columnDefault})`
-          ),
-          autoincrement: isAutoincrement,
-          name: columnName,
-          type: mapSqlToSqliteType(columnType),
-          primaryKey: false,
-          notNull: isNotNull
-        };
-        if (!table) {
-          result[tableName] = {
-            name: tableName,
-            columns: {
-              [columnName]: newColumn
-            },
-            compositePrimaryKeys: {},
-            indexes: {},
-            foreignKeys: {},
-            uniqueConstraints: {}
-          };
-        } else {
-          result[tableName].columns[columnName] = newColumn;
-        }
-      }
-      for (const [key, value] of Object.entries(tableToPk)) {
-        if (value.length > 1) {
-          value.sort();
-          result[key].compositePrimaryKeys = {
-            [`${key}_${value.join("_")}_pk`]: {
-              columns: value,
-              name: `${key}_${value.join("_")}_pk`
+      let tableCount = 0;
+      const all = allTables.map((row) => {
+        return new Promise(async (res, rej) => {
+          const tableName = row.table_name;
+          if (!tablesFilter(tableName))
+            return res("");
+          tableCount += 1;
+          const tableSchema = row.table_schema;
+          try {
+            const columnToReturn = {};
+            const indexToReturn = {};
+            const foreignKeysToReturn = {};
+            const primaryKeys = {};
+            const uniqueConstrains = {};
+            const tableResponse = await db.query(
+              `SELECT a.attrelid::regclass::text, a.attname, is_nullable, a.attndims as array_dimensions
+        , CASE WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[])
+             AND EXISTS (
+                SELECT FROM pg_attrdef ad
+                WHERE  ad.adrelid = a.attrelid
+                AND    ad.adnum   = a.attnum
+                AND    pg_get_expr(ad.adbin, ad.adrelid)
+                     = 'nextval('''
+                    || (pg_get_serial_sequence (a.attrelid::regclass::text
+                                             , a.attname))::regclass
+                    || '''::regclass)'
+                )
+           THEN CASE a.atttypid
+                   WHEN 'int'::regtype  THEN 'serial'
+                   WHEN 'int8'::regtype THEN 'bigserial'
+                   WHEN 'int2'::regtype THEN 'smallserial'
+                END
+           ELSE format_type(a.atttypid, a.atttypmod)
+           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default, INFORMATION_SCHEMA.COLUMNS.data_type as additional_dt
+   FROM  pg_attribute  a
+   JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
+   WHERE  a.attrelid = '"${tableSchema}"."${tableName}"'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}'
+   AND    a.attnum > 0
+   AND    NOT a.attisdropped
+   ORDER  BY a.attnum;`
+            );
+            const tableConstraints = await db.query(
+              `SELECT c.column_name, c.data_type, constraint_type, constraint_name, constraint_schema
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name)
+      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
+        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+      WHERE tc.table_name = '${tableName}' and constraint_schema = '${tableSchema}';`
+            );
+            columnsCount += tableResponse.length;
+            if (progressCallback) {
+              progressCallback("columns", columnsCount, "fetching");
             }
-          };
-        } else if (value.length === 1) {
-          result[key].columns[value[0]].primaryKey = true;
-        } else {
-        }
-      }
-      if (progressCallback) {
-        progressCallback("columns", columnsCount, "done");
-        progressCallback("tables", tablesCount.size, "done");
-      }
-      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;`
-        );
-        const fkByTableName = {};
-        for (const fkRow of fks) {
-          foreignKeysCount += 1;
-          if (progressCallback) {
-            progressCallback("fks", foreignKeysCount, "fetching");
-          }
-          const tableName = fkRow.tableFrom;
-          const columnName = fkRow.from;
-          const refTableName = fkRow.tableTo;
-          const refColumnName = fkRow.to;
-          const updateRule = fkRow.onUpdate;
-          const deleteRule = fkRow.onDelete;
-          const sequence = fkRow.seq;
-          const id = fkRow.id;
-          const tableInResult = result[tableName];
-          if (typeof tableInResult === "undefined")
-            continue;
-          if (typeof fkByTableName[`${tableName}_${id}`] !== "undefined") {
-            fkByTableName[`${tableName}_${id}`].columnsFrom.push(columnName);
-            fkByTableName[`${tableName}_${id}`].columnsTo.push(refColumnName);
-          } else {
-            fkByTableName[`${tableName}_${id}`] = {
-              name: "",
-              tableFrom: tableName,
-              tableTo: refTableName,
-              columnsFrom: [columnName],
-              columnsTo: [refColumnName],
-              onDelete: deleteRule == null ? void 0 : deleteRule.toLowerCase(),
-              onUpdate: updateRule == null ? void 0 : updateRule.toLowerCase()
-            };
-          }
-          const columnsFrom = fkByTableName[`${tableName}_${id}`].columnsFrom;
-          const columnsTo = fkByTableName[`${tableName}_${id}`].columnsTo;
-          fkByTableName[`${tableName}_${id}`].name = `${tableName}_${columnsFrom.join(
-            "_"
-          )}_${refTableName}_${columnsTo.join("_")}_fk`;
-        }
-        for (const idx of Object.keys(fkByTableName)) {
-          const value = fkByTableName[idx];
-          result[value.tableFrom].foreignKeys[value.name] = value;
-        }
-      } catch (e) {
-      }
-      if (progressCallback) {
-        progressCallback("fks", foreignKeysCount, "done");
-      }
-      const idxs = await db.query(
-        `SELECT 
-    m.tbl_name as tableName,
-    il.name as indexName,
-    ii.name as columnName,
-    il.[unique] as isUnique,
-    il.seq as seq
-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_%';`
-      );
-      for (const idxRow of idxs) {
-        const tableName = idxRow.tableName;
-        const constraintName = idxRow.indexName;
-        const columnName = idxRow.columnName;
-        const isUnique = idxRow.isUnique === 1;
-        const tableInResult = result[tableName];
-        if (typeof tableInResult === "undefined")
-          continue;
-        indexesCount += 1;
-        if (progressCallback) {
-          progressCallback("indexes", indexesCount, "fetching");
-        }
-        if (typeof tableInResult.indexes[constraintName] !== "undefined") {
-          tableInResult.indexes[constraintName].columns.push(columnName);
-        } else {
-          tableInResult.indexes[constraintName] = {
-            name: constraintName,
-            columns: [columnName],
-            isUnique
-          };
-        }
-      }
-      if (progressCallback) {
-        progressCallback("indexes", indexesCount, "done");
-        progressCallback("enums", 0, "done");
-      }
-      return {
-        version: "5",
-        dialect: "sqlite",
-        tables: result,
-        enums: {},
-        _meta: {
-          tables: {},
-          columns: {}
-        }
-      };
-    };
-    toDrizzle2 = (schema) => {
-      const tables = {};
-      Object.values(schema.tables).forEach((t) => {
-        const columns = {};
-        Object.values(t.columns).forEach((c) => {
-          const columnName = c.name;
-          const type = c.type;
-          let columnBuilder;
-          if (type === "integer") {
-            columnBuilder = new import_sqlite_core.SQLiteIntegerBuilder(columnName);
-          } else if (type === "text") {
-            columnBuilder = new import_sqlite_core.SQLiteTextBuilder(columnName, {});
-          } else if (type === "blob") {
-            columnBuilder = new import_sqlite_core.SQLiteBlobBufferBuilder(columnName);
-          } else if (type === "real") {
-            columnBuilder = new import_sqlite_core.SQLiteRealBuilder(columnName);
-          } else {
-            columnBuilder = new import_sqlite_core.SQLiteNumericBuilder(columnName);
-          }
-          if (c.notNull) {
-            columnBuilder = columnBuilder.notNull();
-          }
-          if (c.default) {
-            columnBuilder = columnBuilder.default(c.default);
-          }
-          if (c.primaryKey) {
-            columnBuilder = columnBuilder.primaryKey();
-          }
-          columns[columnName] = columnBuilder;
-        });
-        tables[t.name] = (0, import_sqlite_core.sqliteTable)(t.name, columns, (cb) => {
-          const res = {};
-          Object.values(t.compositePrimaryKeys).forEach((cpk) => {
-            const gh = cpk.columns.map((c) => cb[c]);
-            res[cpk.name] = new import_sqlite_core.PrimaryKeyBuilder(
-              gh,
-              cpk.name
+            const tableForeignKeys = await db.query(
+              `SELECT
+        tc.table_schema,
+        tc.constraint_name,
+        tc.table_name,
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.delete_rule, rc.update_rule
+    FROM
+        information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+          ON ccu.constraint_name = tc.constraint_name
+          AND ccu.table_schema = tc.table_schema
+        JOIN information_schema.referential_constraints AS rc
+          ON ccu.constraint_name = rc.constraint_name
+    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${tableName}' and tc.table_schema='${tableSchema}';`
             );
-          });
-          return res;
-        });
-      });
-      return tables;
-    };
-  }
-});
-
-// 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"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.prepareReadLine = void 0;
-    var prepareReadLine = () => {
-      const stdin = process.stdin;
-      const stdout = process.stdout;
-      const readline = require("readline");
-      const rl = readline.createInterface({
-        input: stdin,
-        escapeCodeTimeout: 50
-      });
-      readline.emitKeypressEvents(stdin, rl);
-      return {
-        stdin,
-        stdout,
-        closable: rl
-      };
-    };
-    exports.prepareReadLine = prepareReadLine;
-  }
-});
-
-// node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
-var require_src = __commonJS({
-  "node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module2) {
-    "use strict";
-    var ESC = "\x1B";
-    var CSI = `${ESC}[`;
-    var beep = "\x07";
-    var cursor = {
-      to(x, y) {
-        if (!y)
-          return `${CSI}${x + 1}G`;
-        return `${CSI}${y + 1};${x + 1}H`;
-      },
-      move(x, y) {
-        let ret = "";
-        if (x < 0)
-          ret += `${CSI}${-x}D`;
-        else if (x > 0)
-          ret += `${CSI}${x}C`;
-        if (y < 0)
-          ret += `${CSI}${-y}A`;
-        else if (y > 0)
-          ret += `${CSI}${y}B`;
-        return ret;
-      },
-      up: (count = 1) => `${CSI}${count}A`,
-      down: (count = 1) => `${CSI}${count}B`,
-      forward: (count = 1) => `${CSI}${count}C`,
-      backward: (count = 1) => `${CSI}${count}D`,
-      nextLine: (count = 1) => `${CSI}E`.repeat(count),
-      prevLine: (count = 1) => `${CSI}F`.repeat(count),
-      left: `${CSI}G`,
-      hide: `${CSI}?25l`,
-      show: `${CSI}?25h`,
-      save: `${ESC}7`,
-      restore: `${ESC}8`
-    };
-    var scroll = {
-      up: (count = 1) => `${CSI}S`.repeat(count),
-      down: (count = 1) => `${CSI}T`.repeat(count)
-    };
-    var erase = {
-      screen: `${CSI}2J`,
-      up: (count = 1) => `${CSI}1J`.repeat(count),
-      down: (count = 1) => `${CSI}J`.repeat(count),
-      line: `${CSI}2K`,
-      lineEnd: `${CSI}K`,
-      lineStart: `${CSI}1K`,
-      lines(count) {
-        let clear = "";
-        for (let i = 0; i < count; i++)
-          clear += this.line + (i < count - 1 ? cursor.up() : "");
-        if (count)
-          clear += cursor.left;
-        return clear;
-      }
-    };
-    module2.exports = { cursor, scroll, erase, beep };
-  }
-});
-
-// node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/utils.js
-var require_utils = __commonJS({
-  "node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/utils.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.clear = void 0;
-    var sisteransi_1 = require_src();
-    var strip = (str) => {
-      const pattern = [
-        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
-        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"
-      ].join("|");
-      const RGX = new RegExp(pattern, "g");
-      return typeof str === "string" ? str.replace(RGX, "") : str;
-    };
-    var stringWidth = (str) => [...strip(str)].length;
-    var clear = function(prompt, perLine) {
-      if (!perLine)
-        return sisteransi_1.erase.line + sisteransi_1.cursor.to(0);
-      let rows = 0;
-      const lines = prompt.split(/\r?\n/);
-      for (let line of lines) {
-        rows += 1 + Math.floor(Math.max(stringWidth(line) - 1, 0) / perLine);
-      }
-      return sisteransi_1.erase.lines(rows);
-    };
-    exports.clear = clear;
-  }
-});
-
-// node_modules/.pnpm/lodash.throttle@4.1.1/node_modules/lodash.throttle/index.js
-var require_lodash = __commonJS({
-  "node_modules/.pnpm/lodash.throttle@4.1.1/node_modules/lodash.throttle/index.js"(exports, module2) {
-    var FUNC_ERROR_TEXT = "Expected a function";
-    var NAN = 0 / 0;
-    var symbolTag = "[object Symbol]";
-    var reTrim = /^\s+|\s+$/g;
-    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
-    var reIsBinary = /^0b[01]+$/i;
-    var reIsOctal = /^0o[0-7]+$/i;
-    var freeParseInt = parseInt;
-    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-    var root = freeGlobal || freeSelf || Function("return this")();
-    var objectProto = Object.prototype;
-    var objectToString = objectProto.toString;
-    var nativeMax = Math.max;
-    var nativeMin = Math.min;
-    var now = function() {
-      return root.Date.now();
-    };
-    function debounce(func, wait, options) {
-      var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
-      if (typeof func != "function") {
-        throw new TypeError(FUNC_ERROR_TEXT);
-      }
-      wait = toNumber(wait) || 0;
-      if (isObject(options)) {
-        leading = !!options.leading;
-        maxing = "maxWait" in options;
-        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
-        trailing = "trailing" in options ? !!options.trailing : trailing;
-      }
-      function invokeFunc(time) {
-        var args = lastArgs, thisArg = lastThis;
-        lastArgs = lastThis = void 0;
-        lastInvokeTime = time;
-        result = func.apply(thisArg, args);
-        return result;
-      }
-      function leadingEdge(time) {
-        lastInvokeTime = time;
-        timerId = setTimeout(timerExpired, wait);
-        return leading ? invokeFunc(time) : result;
-      }
-      function remainingWait(time) {
-        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait - timeSinceLastCall;
-        return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
-      }
-      function shouldInvoke(time) {
-        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
-        return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
-      }
-      function timerExpired() {
-        var time = now();
-        if (shouldInvoke(time)) {
-          return trailingEdge(time);
-        }
-        timerId = setTimeout(timerExpired, remainingWait(time));
-      }
-      function trailingEdge(time) {
-        timerId = void 0;
-        if (trailing && lastArgs) {
-          return invokeFunc(time);
-        }
-        lastArgs = lastThis = void 0;
-        return result;
-      }
-      function cancel() {
-        if (timerId !== void 0) {
-          clearTimeout(timerId);
-        }
-        lastInvokeTime = 0;
-        lastArgs = lastCallTime = lastThis = timerId = void 0;
-      }
-      function flush() {
-        return timerId === void 0 ? result : trailingEdge(now());
-      }
-      function debounced() {
-        var time = now(), isInvoking = shouldInvoke(time);
-        lastArgs = arguments;
-        lastThis = this;
-        lastCallTime = time;
-        if (isInvoking) {
-          if (timerId === void 0) {
-            return leadingEdge(lastCallTime);
-          }
-          if (maxing) {
-            timerId = setTimeout(timerExpired, wait);
-            return invokeFunc(lastCallTime);
+            foreignKeysCount += tableForeignKeys.length;
+            if (progressCallback) {
+              progressCallback("fks", foreignKeysCount, "fetching");
+            }
+            for (const fk of tableForeignKeys) {
+              const columnFrom = fk.column_name;
+              const tableTo = fk.foreign_table_name;
+              const columnTo = fk.foreign_column_name;
+              const foreignKeyName = fk.constraint_name;
+              const onUpdate = fk.update_rule.toLowerCase();
+              const onDelete = fk.delete_rule.toLowerCase();
+              if (typeof foreignKeysToReturn[foreignKeyName] !== "undefined") {
+                foreignKeysToReturn[foreignKeyName].columnsFrom.push(columnFrom);
+                foreignKeysToReturn[foreignKeyName].columnsTo.push(columnTo);
+              } else {
+                foreignKeysToReturn[foreignKeyName] = {
+                  name: foreignKeyName,
+                  tableFrom: tableName,
+                  tableTo,
+                  columnsFrom: [columnFrom],
+                  columnsTo: [columnTo],
+                  onDelete,
+                  onUpdate
+                };
+              }
+              foreignKeysToReturn[foreignKeyName].columnsFrom = [
+                ...new Set(foreignKeysToReturn[foreignKeyName].columnsFrom)
+              ];
+              foreignKeysToReturn[foreignKeyName].columnsTo = [
+                ...new Set(foreignKeysToReturn[foreignKeyName].columnsTo)
+              ];
+            }
+            const uniqueConstrainsRows = tableConstraints.filter(
+              (mapRow) => mapRow.constraint_type === "UNIQUE"
+            );
+            for (const unqs of uniqueConstrainsRows) {
+              const columnName = unqs.column_name;
+              const constraintName = unqs.constraint_name;
+              if (typeof uniqueConstrains[constraintName] !== "undefined") {
+                uniqueConstrains[constraintName].columns.push(columnName);
+              } else {
+                uniqueConstrains[constraintName] = {
+                  columns: [columnName],
+                  nullsNotDistinct: false,
+                  name: constraintName
+                };
+              }
+            }
+            for (const columnResponse of tableResponse) {
+              const columnName = columnResponse.attname;
+              const columnAdditionalDT = columnResponse.additional_dt;
+              const columnDimensions = columnResponse.array_dimensions;
+              let columnType = columnResponse.data_type;
+              const primaryKey = tableConstraints.filter(
+                (mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === "PRIMARY KEY"
+              );
+              const cprimaryKey = tableConstraints.filter(
+                (mapRow) => mapRow.constraint_type === "PRIMARY KEY"
+              );
+              if (cprimaryKey.length > 1) {
+                const tableCompositePkName = await db.query(
+                  `SELECT conname AS primary_key
+            FROM   pg_constraint join pg_class on (pg_class.oid = conrelid)
+            WHERE  contype = 'p' 
+            AND    connamespace = $1::regnamespace  
+            AND    pg_class.relname = $2;`,
+                  [tableSchema, tableName]
+                );
+                primaryKeys[tableCompositePkName[0].primary_key] = {
+                  name: tableCompositePkName[0].primary_key,
+                  columns: cprimaryKey.map((c) => c.column_name)
+                };
+              }
+              const defaultValue = defaultForColumn(columnResponse);
+              const isSerial = columnType === "serial";
+              let columnTypeMapped = columnType;
+              if (columnTypeMapped.startsWith("numeric(")) {
+                columnTypeMapped = columnTypeMapped.replace(",", ", ");
+              }
+              if (columnAdditionalDT === "ARRAY") {
+                if (typeof internals.tables[tableName] === "undefined") {
+                  internals.tables[tableName] = {
+                    columns: {
+                      [columnName]: {
+                        isArray: true,
+                        dimensions: columnDimensions,
+                        rawType: columnTypeMapped.substring(
+                          0,
+                          columnTypeMapped.length - 2
+                        )
+                      }
+                    }
+                  };
+                } else {
+                  if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
+                    internals.tables[tableName].columns[columnName] = {
+                      isArray: true,
+                      dimensions: columnDimensions,
+                      rawType: columnTypeMapped.substring(
+                        0,
+                        columnTypeMapped.length - 2
+                      )
+                    };
+                  }
+                }
+              }
+              if (columnAdditionalDT === "ARRAY") {
+                for (let i = 1; i < Number(columnDimensions); i++) {
+                  columnTypeMapped += "[]";
+                }
+              }
+              columnTypeMapped = columnTypeMapped.replace("character varying", "varchar").replace(" without time zone", "").replace("character", "char");
+              columnTypeMapped = trimChar(columnTypeMapped, '"');
+              columnToReturn[columnName] = {
+                name: columnName,
+                type: columnTypeMapped,
+                primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
+                // default: isSerial ? undefined : defaultValue,
+                notNull: columnResponse.is_nullable === "NO"
+              };
+              if (!isSerial && typeof defaultValue !== "undefined") {
+                columnToReturn[columnName].default = defaultValue;
+              }
+            }
+            const dbIndexes = await db.query(
+              `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
+          idx.indexrelname AS index_name,
+          idx.relname AS table_name,
+          schemaname,
+          CASE WHEN con.conname IS NOT NULL THEN 1 ELSE 0 END AS generated_by_constraint
+        FROM
+          pg_stat_user_indexes idx
+        LEFT JOIN
+          pg_constraint con ON con.conindid = idx.indexrelid
+        WHERE idx.relname = '${tableName}' and schemaname = '${tableSchema}'
+        group by index_name, table_name,schemaname, generated_by_constraint;`
+            );
+            const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) => it.index_name);
+            for (const dbIndex of dbIndexes) {
+              const indexName2 = dbIndex.index_name;
+              const indexColumnName = dbIndex.column_name;
+              const indexIsUnique = dbIndex.is_unique;
+              if (idxsInConsteraint.includes(indexName2))
+                continue;
+              if (typeof indexToReturn[indexName2] !== "undefined") {
+                indexToReturn[indexName2].columns.push(indexColumnName);
+              } else {
+                indexToReturn[indexName2] = {
+                  name: indexName2,
+                  columns: [indexColumnName],
+                  isUnique: indexIsUnique
+                };
+              }
+            }
+            indexesCount += Object.keys(indexToReturn).length;
+            if (progressCallback) {
+              progressCallback("indexes", indexesCount, "fetching");
+            }
+            result[tableName] = {
+              name: tableName,
+              schema: tableSchema !== "public" ? tableSchema : "",
+              columns: columnToReturn,
+              indexes: indexToReturn,
+              foreignKeys: foreignKeysToReturn,
+              compositePrimaryKeys: primaryKeys,
+              uniqueConstraints: uniqueConstrains
+            };
+          } catch (e) {
+            rej(e);
+            return;
           }
-        }
-        if (timerId === void 0) {
-          timerId = setTimeout(timerExpired, wait);
-        }
-        return result;
+          res("");
+        });
+      });
+      if (progressCallback) {
+        progressCallback("tables", tableCount, "done");
       }
-      debounced.cancel = cancel;
-      debounced.flush = flush;
-      return debounced;
-    }
-    function throttle(func, wait, options) {
-      var leading = true, trailing = true;
-      if (typeof func != "function") {
-        throw new TypeError(FUNC_ERROR_TEXT);
+      for await (const _ of all) {
       }
-      if (isObject(options)) {
-        leading = "leading" in options ? !!options.leading : leading;
-        trailing = "trailing" in options ? !!options.trailing : trailing;
+      if (progressCallback) {
+        progressCallback("columns", columnsCount, "done");
+        progressCallback("indexes", indexesCount, "done");
+        progressCallback("fks", foreignKeysCount, "done");
       }
-      return debounce(func, wait, {
-        "leading": leading,
-        "maxWait": wait,
-        "trailing": trailing
-      });
-    }
-    function isObject(value) {
-      var type = typeof value;
-      return !!value && (type == "object" || type == "function");
-    }
-    function isObjectLike(value) {
-      return !!value && typeof value == "object";
-    }
-    function isSymbol(value) {
-      return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
-    }
-    function toNumber(value) {
-      if (typeof value == "number") {
-        return value;
+      const allEnums = await db.query(
+        `select n.nspname as enum_schema,
+  t.typname as enum_name,
+  e.enumlabel as enum_value
+  from pg_type t
+  join pg_enum e on t.oid = e.enumtypid
+  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`
+      );
+      const enumsToReturn = {};
+      for (const dbEnum of allEnums) {
+        const enumName = dbEnum.enum_name;
+        const enumValue = dbEnum.enum_value;
+        if (enumsToReturn[enumName] !== void 0 && enumsToReturn[enumName] !== null) {
+          enumsToReturn[enumName].values[enumValue] = enumValue;
+        } else {
+          enumsToReturn[enumName] = {
+            name: enumName,
+            values: { [enumValue]: enumValue }
+          };
+        }
       }
-      if (isSymbol(value)) {
-        return NAN;
+      if (progressCallback) {
+        progressCallback("enums", Object.keys(enumsToReturn).length, "done");
       }
-      if (isObject(value)) {
-        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
-        value = isObject(other) ? other + "" : other;
+      const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
+      return {
+        version: "5",
+        dialect: "pg",
+        tables: result,
+        enums: enumsToReturn,
+        schemas: schemasObject,
+        _meta: {
+          schemas: {},
+          tables: {},
+          columns: {}
+        },
+        internal: internals
+      };
+    };
+    columnToDefault = {
+      "numeric(": "::numeric",
+      // text: "::text",
+      // "character varying": "::character varying",
+      // "double precision": "::double precision",
+      // "time with time zone": "::time with time zone",
+      "time without time zone": "::time without time zone",
+      // "timestamp with time zone": "::timestamp with time zone",
+      "timestamp without time zone": "::timestamp without time zone",
+      // date: "::date",
+      // interval: "::interval",
+      // character: "::bpchar",
+      // macaddr8: "::macaddr8",
+      // macaddr: "::macaddr",
+      // inet: "::inet",
+      // cidr: "::cidr",
+      // jsonb: "::jsonb",
+      // json: "::json",
+      "character(": "::bpchar"
+    };
+    defaultForColumn = (column) => {
+      if (column.data_type === "serial" || column.data_type === "smallserial" || column.data_type === "bigserial") {
+        return void 0;
       }
-      if (typeof value != "string") {
-        return value === 0 ? value : +value;
+      const hasDifferentDefaultCast = Object.keys(columnToDefault).find(
+        (it) => column.data_type.startsWith(it)
+      );
+      if (column.column_default === null) {
+        return void 0;
       }
-      value = value.replace(reTrim, "");
-      var isBinary = reIsBinary.test(value);
-      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
-    }
-    module2.exports = throttle;
-  }
-});
-
-// node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/index.js
-var require_hanji = __commonJS({
-  "node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/index.js"(exports) {
-    "use strict";
-    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
-      function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve) {
-          resolve(value);
-        });
+      const columnDefaultAsString = column.column_default.toString();
+      if (columnDefaultAsString.endsWith(
+        hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column.data_type
+      )) {
+        const nonPrefixPart = column.column_default.length - (hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`).length - 1;
+        const rt = column.column_default.toString().substring(1, nonPrefixPart);
+        if (/^-?[\d.]+(?:e-?\d+)?$/.test(rt) && !column.data_type.startsWith("numeric")) {
+          return Number(rt);
+        } else if (column.data_type === "json" || column.data_type === "jsonb") {
+          const jsonWithoutSpaces = JSON.stringify(JSON.parse(rt));
+          return `'${jsonWithoutSpaces}'${hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`}`;
+        } else if (column.data_type === "boolean") {
+          return column.column_default === "true";
+        } else {
+          return `'${rt}'`;
+        }
+      } else {
+        if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString) && !column.data_type.startsWith("numeric")) {
+          return Number(columnDefaultAsString);
+        } else if (column.data_type === "boolean") {
+          return column.column_default === "true";
+        } else {
+          return `${columnDefaultAsString}`;
+        }
       }
-      return new (P || (P = Promise))(function(resolve, reject) {
-        function fulfilled(value) {
-          try {
-            step(generator.next(value));
-          } catch (e) {
-            reject(e);
+    };
+    toDrizzle = (schema, schemaName) => {
+      const tables = {};
+      Object.values(schema.tables).forEach((t) => {
+        const columns = {};
+        Object.values(t.columns).forEach((c) => {
+          const columnName = c.name;
+          const type = c.type;
+          let columnBuilder;
+          if (type === "bigint") {
+            columnBuilder = new import_pg_core.PgBigInt53Builder(columnName);
+          } else if (type === "bigserial") {
+            columnBuilder = new import_pg_core.PgBigSerial53Builder(columnName);
+          } else if (type === "boolean") {
+            columnBuilder = new import_pg_core.PgBooleanBuilder(columnName);
+          } else if (type === "cidr") {
+            columnBuilder = new import_pg_core.PgCidrBuilder(columnName);
+          } else if (type === "date") {
+            columnBuilder = new import_pg_core.PgDateBuilder(columnName);
+          } else if (type === "double precision") {
+            columnBuilder = new import_pg_core.PgDoublePrecisionBuilder(columnName);
+          } else if (type === "inet") {
+            columnBuilder = new import_pg_core.PgInetBuilder(columnName);
+          } else if (type === "integer") {
+            columnBuilder = new import_pg_core.PgIntegerBuilder(columnName);
+          } else if (type === "interval" || type.startsWith("interval ")) {
+            columnBuilder = new import_pg_core.PgIntervalBuilder(columnName, {});
+          } else if (type === "json") {
+            columnBuilder = new import_pg_core.PgJsonBuilder(columnName);
+          } else if (type === "jsonb") {
+            columnBuilder = new import_pg_core.PgJsonbBuilder(columnName);
+          } else if (type === "macaddr") {
+            columnBuilder = new import_pg_core.PgMacaddrBuilder(columnName);
+          } else if (type === "macaddr8") {
+            columnBuilder = new import_pg_core.PgMacaddr8Builder(columnName);
+          } else if (type === "numeric" || type.startsWith("numeric(")) {
+            columnBuilder = new import_pg_core.PgNumericBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new import_pg_core.PgRealBuilder(columnName);
+          } else if (type === "serial") {
+            columnBuilder = new import_pg_core.PgSerialBuilder(columnName);
+          } else if (type === "smallint") {
+            columnBuilder = new import_pg_core.PgSmallIntBuilder(columnName);
+          } else if (type === "smallserial") {
+            columnBuilder = new import_pg_core.PgSmallSerialBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new import_pg_core.PgTextBuilder(columnName, {});
+          } else if (type === "time" || type.startsWith("time(") || type === "time with time zone") {
+            columnBuilder = new import_pg_core.PgTimeBuilder(columnName, false, void 0);
+          } else if (type === "timestamp" || type.startsWith("timestamp(") || type === "timestamp with time zone") {
+            columnBuilder = new import_pg_core.PgTimestampBuilder(columnName, false, void 0);
+          } else if (type === "uuid") {
+            columnBuilder = new import_pg_core.PgUUIDBuilder(columnName);
+          } else if (type === "varchar" || type.startsWith("varchar(")) {
+            columnBuilder = new import_pg_core.PgVarcharBuilder(columnName, {});
+          } else if (type === "char" || type.startsWith("char(")) {
+            columnBuilder = new import_pg_core.PgCharBuilder(columnName, {});
+          } else {
+            columnBuilder = (0, import_pg_core.customType)({
+              dataType() {
+                return type;
+              }
+            })(columnName);
           }
-        }
-        function rejected(value) {
-          try {
-            step(generator["throw"](value));
-          } catch (e) {
-            reject(e);
+          if (c.notNull) {
+            columnBuilder = columnBuilder.notNull();
           }
+          if (c.default) {
+            columnBuilder = columnBuilder.default(c.default);
+          }
+          if (c.primaryKey) {
+            columnBuilder = columnBuilder.primaryKey();
+          }
+          columns[columnName] = columnBuilder;
+        });
+        if (schemaName === "public") {
+          tables[t.name] = (0, import_pg_core.pgTable)(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        } else {
+          tables[t.name] = (0, import_pg_core.pgSchema)(schemaName).table(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
         }
-        function step(result) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-        }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
+      return tables;
     };
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.onTerminate = exports.renderWithTask = exports.render = exports.TaskTerminal = exports.TaskView = exports.Terminal = exports.deferred = exports.SelectState = exports.Prompt = void 0;
-    var readline_1 = require_readline();
-    var sisteransi_1 = require_src();
-    var utils_1 = require_utils();
-    var lodash_throttle_1 = __importDefault(require_lodash());
-    var Prompt2 = class {
-      constructor() {
-        this.attachCallbacks = [];
-        this.detachCallbacks = [];
-        this.inputCallbacks = [];
-      }
-      requestLayout() {
-        this.terminal.requestLayout();
-      }
-      on(type, callback) {
-        if (type === "attach") {
-          this.attachCallbacks.push(callback);
-        } else if (type === "detach") {
-          this.detachCallbacks.push(callback);
-        } else if (type === "input") {
-          this.inputCallbacks.push(callback);
-        }
-      }
-      attach(terminal) {
-        this.terminal = terminal;
-        this.attachCallbacks.forEach((it) => it(terminal));
-      }
-      detach(terminal) {
-        this.detachCallbacks.forEach((it) => it(terminal));
-        this.terminal = void 0;
-      }
-      input(str, key) {
-        this.inputCallbacks.forEach((it) => it(str, key));
-      }
-    };
-    exports.Prompt = Prompt2;
-    var SelectState2 = class {
-      constructor(items) {
-        this.items = items;
-        this.selectedIdx = 0;
-      }
-      bind(prompt) {
-        prompt.on("input", (str, key) => {
-          const invalidate = this.consume(str, key);
-          if (invalidate)
-            prompt.requestLayout();
-        });
+  }
+});
+
+// src/serializer/sqliteSerializer.ts
+function mapSqlToSqliteType(sqlType) {
+  if ([
+    "int",
+    "integer",
+    "integer auto_increment",
+    "tinyint",
+    "smallint",
+    "mediumint",
+    "bigint",
+    "unsigned big int",
+    "int2",
+    "int8"
+  ].includes(sqlType.toLowerCase())) {
+    return "integer";
+  } else if ([
+    "character",
+    "varchar",
+    "vatying character",
+    "nchar",
+    "native character",
+    "nvarchar",
+    "text",
+    "clob"
+  ].some((it) => it.startsWith(sqlType.toLowerCase()))) {
+    return "text";
+  } else if (sqlType.toLowerCase() === "blob") {
+    return "blob";
+  } else if (["real", "double", "double precision", "float"].includes(
+    sqlType.toLowerCase()
+  )) {
+    return "real";
+  } else {
+    return "numeric";
+  }
+}
+var import_drizzle_orm2, import_sqlite_core, dialect2, fromDatabase2, toDrizzle2;
+var init_sqliteSerializer = __esm({
+  "src/serializer/sqliteSerializer.ts"() {
+    import_drizzle_orm2 = require("drizzle-orm");
+    import_sqlite_core = require("drizzle-orm/sqlite-core");
+    init_serializer();
+    init_outputs();
+    init_source();
+    dialect2 = new import_sqlite_core.SQLiteSyncDialect();
+    fromDatabase2 = async (db, tablesFilter = (table) => true, progressCallback) => {
+      const result = {};
+      const columns = await db.query(
+        `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';
+    `
+      );
+      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[^'']*';`
+      );
+      for (const s of seq) {
+        tablesWithSeq.push(s.name);
       }
-      consume(str, key) {
-        if (!key)
-          return false;
-        if (key.name === "down") {
-          this.selectedIdx = (this.selectedIdx + 1) % this.items.length;
-          return true;
+      let columnsCount = 0;
+      let tablesCount = /* @__PURE__ */ new Set();
+      let indexesCount = 0;
+      let foreignKeysCount = 0;
+      const tableToPk = {};
+      for (const column of columns) {
+        if (!tablesFilter(column.tableName))
+          continue;
+        columnsCount += 1;
+        if (progressCallback) {
+          progressCallback("columns", columnsCount, "fetching");
         }
-        if (key.name === "up") {
-          this.selectedIdx -= 1;
-          this.selectedIdx = this.selectedIdx < 0 ? this.items.length - 1 : this.selectedIdx;
-          return true;
+        const tableName = column.tableName;
+        tablesCount.add(tableName);
+        if (progressCallback) {
+          progressCallback("tables", tablesCount.size, "fetching");
         }
-        return false;
-      }
-    };
-    exports.SelectState = SelectState2;
-    var deferred = () => {
-      let resolve;
-      let reject;
-      const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-      });
-      return {
-        resolve,
-        reject,
-        promise
-      };
-    };
-    exports.deferred = deferred;
-    var Terminal = class {
-      constructor(view, stdin, stdout, closable) {
-        this.view = view;
-        this.stdin = stdin;
-        this.stdout = stdout;
-        this.closable = closable;
-        this.text = "";
-        this.status = "idle";
-        if (this.stdin.isTTY)
-          this.stdin.setRawMode(true);
-        const keypress = (str, key) => {
-          if (key.name === "c" && key.ctrl === true) {
-            this.requestLayout();
-            this.view.detach(this);
-            this.tearDown(keypress);
-            if (terminateHandler) {
-              terminateHandler(this.stdin, this.stdout);
-              return;
-            }
-            this.stdout.write(`
-^C
-`);
-            process.exit(1);
-          }
-          if (key.name === "escape") {
-            this.status = "aborted";
-            this.requestLayout();
-            this.view.detach(this);
-            this.tearDown(keypress);
-            this.resolve({ status: "aborted", data: void 0 });
-            return;
-          }
-          if (key.name === "return") {
-            this.status = "submitted";
-            this.requestLayout();
-            this.view.detach(this);
-            this.tearDown(keypress);
-            this.resolve({ status: "submitted", data: this.view.result() });
-            return;
+        const columnName = column.columnName;
+        const isNotNull = column.notNull === 1;
+        const columnType = column.columnType;
+        const isPrimary = column.pk !== 0;
+        const columnDefault = column.defaultValue;
+        const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
+        if (isPrimary) {
+          if (typeof tableToPk[tableName] === "undefined") {
+            tableToPk[tableName] = [columnName];
+          } else {
+            tableToPk[tableName].push(columnName);
           }
-          view.input(str, key);
-        };
-        this.stdin.on("keypress", keypress);
-        this.view.attach(this);
-        const { resolve, promise } = (0, exports.deferred)();
-        this.resolve = resolve;
-        this.promise = promise;
-        this.renderFunc = (0, lodash_throttle_1.default)((str) => {
-          this.stdout.write(str);
-        });
-      }
-      tearDown(keypress) {
-        this.stdout.write(sisteransi_1.cursor.show);
-        this.stdin.removeListener("keypress", keypress);
-        if (this.stdin.isTTY)
-          this.stdin.setRawMode(false);
-        this.closable.close();
-      }
-      result() {
-        return this.promise;
-      }
-      toggleCursor(state) {
-        if (state === "hide") {
-          this.stdout.write(sisteransi_1.cursor.hide);
+        }
+        const table = result[tableName];
+        const newColumn = {
+          default: columnDefault === null ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) ? Number(columnDefault) : ["CURRENT_TIME", "CURRENT_DATE", "CURRENT_TIMESTAMP"].includes(
+            columnDefault
+          ) ? `(${columnDefault})` : columnDefault === "false" ? false : columnDefault === "true" ? true : columnDefault.startsWith("'") && columnDefault.endsWith("'") ? columnDefault : (
+            // ? columnDefault.substring(1, columnDefault.length - 1)
+            `(${columnDefault})`
+          ),
+          autoincrement: isAutoincrement,
+          name: columnName,
+          type: mapSqlToSqliteType(columnType),
+          primaryKey: false,
+          notNull: isNotNull
+        };
+        if (!table) {
+          result[tableName] = {
+            name: tableName,
+            columns: {
+              [columnName]: newColumn
+            },
+            compositePrimaryKeys: {},
+            indexes: {},
+            foreignKeys: {},
+            uniqueConstraints: {}
+          };
         } else {
-          this.stdout.write(sisteransi_1.cursor.show);
+          result[tableName].columns[columnName] = newColumn;
         }
       }
-      requestLayout() {
-        const string = this.view.render(this.status);
-        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
-        this.text = string;
-        this.renderFunc(`${clearPrefix}${string}`);
-      }
-    };
-    exports.Terminal = Terminal;
-    var TaskView2 = class {
-      constructor() {
-        this.attachCallbacks = [];
-        this.detachCallbacks = [];
-      }
-      requestLayout() {
-        this.terminal.requestLayout();
-      }
-      attach(terminal) {
-        this.terminal = terminal;
-        this.attachCallbacks.forEach((it) => it(terminal));
+      for (const [key, value] of Object.entries(tableToPk)) {
+        if (value.length > 1) {
+          value.sort();
+          result[key].compositePrimaryKeys = {
+            [`${key}_${value.join("_")}_pk`]: {
+              columns: value,
+              name: `${key}_${value.join("_")}_pk`
+            }
+          };
+        } else if (value.length === 1) {
+          result[key].columns[value[0]].primaryKey = true;
+        } else {
+        }
       }
-      detach(terminal) {
-        this.detachCallbacks.forEach((it) => it(terminal));
-        this.terminal = void 0;
+      if (progressCallback) {
+        progressCallback("columns", columnsCount, "done");
+        progressCallback("tables", tablesCount.size, "done");
       }
-      on(type, callback) {
-        if (type === "attach") {
-          this.attachCallbacks.push(callback);
-        } else if (type === "detach") {
-          this.detachCallbacks.push(callback);
+      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;`
+        );
+        const fkByTableName = {};
+        for (const fkRow of fks) {
+          foreignKeysCount += 1;
+          if (progressCallback) {
+            progressCallback("fks", foreignKeysCount, "fetching");
+          }
+          const tableName = fkRow.tableFrom;
+          const columnName = fkRow.from;
+          const refTableName = fkRow.tableTo;
+          const refColumnName = fkRow.to;
+          const updateRule = fkRow.onUpdate;
+          const deleteRule = fkRow.onDelete;
+          const sequence = fkRow.seq;
+          const id = fkRow.id;
+          const tableInResult = result[tableName];
+          if (typeof tableInResult === "undefined")
+            continue;
+          if (typeof fkByTableName[`${tableName}_${id}`] !== "undefined") {
+            fkByTableName[`${tableName}_${id}`].columnsFrom.push(columnName);
+            fkByTableName[`${tableName}_${id}`].columnsTo.push(refColumnName);
+          } else {
+            fkByTableName[`${tableName}_${id}`] = {
+              name: "",
+              tableFrom: tableName,
+              tableTo: refTableName,
+              columnsFrom: [columnName],
+              columnsTo: [refColumnName],
+              onDelete: deleteRule == null ? void 0 : deleteRule.toLowerCase(),
+              onUpdate: updateRule == null ? void 0 : updateRule.toLowerCase()
+            };
+          }
+          const columnsFrom = fkByTableName[`${tableName}_${id}`].columnsFrom;
+          const columnsTo = fkByTableName[`${tableName}_${id}`].columnsTo;
+          fkByTableName[`${tableName}_${id}`].name = `${tableName}_${columnsFrom.join(
+            "_"
+          )}_${refTableName}_${columnsTo.join("_")}_fk`;
         }
+        for (const idx of Object.keys(fkByTableName)) {
+          const value = fkByTableName[idx];
+          result[value.tableFrom].foreignKeys[value.name] = value;
+        }
+      } catch (e) {
       }
-    };
-    exports.TaskView = TaskView2;
-    var TaskTerminal = class {
-      constructor(view, stdout) {
-        this.view = view;
-        this.stdout = stdout;
-        this.text = "";
-        this.view.attach(this);
+      if (progressCallback) {
+        progressCallback("fks", foreignKeysCount, "done");
       }
-      requestLayout() {
-        const string = this.view.render("pending");
-        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
-        this.text = string;
-        this.stdout.write(`${clearPrefix}${string}`);
+      const idxs = await db.query(
+        `SELECT 
+    m.tbl_name as tableName,
+    il.name as indexName,
+    ii.name as columnName,
+    il.[unique] as isUnique,
+    il.seq as seq
+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_%';`
+      );
+      for (const idxRow of idxs) {
+        const tableName = idxRow.tableName;
+        const constraintName = idxRow.indexName;
+        const columnName = idxRow.columnName;
+        const isUnique = idxRow.isUnique === 1;
+        const tableInResult = result[tableName];
+        if (typeof tableInResult === "undefined")
+          continue;
+        indexesCount += 1;
+        if (progressCallback) {
+          progressCallback("indexes", indexesCount, "fetching");
+        }
+        if (typeof tableInResult.indexes[constraintName] !== "undefined") {
+          tableInResult.indexes[constraintName].columns.push(columnName);
+        } else {
+          tableInResult.indexes[constraintName] = {
+            name: constraintName,
+            columns: [columnName],
+            isUnique
+          };
+        }
       }
-      clear() {
-        const string = this.view.render("done");
-        this.view.detach(this);
-        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
-        this.stdout.write(`${clearPrefix}${string}`);
+      if (progressCallback) {
+        progressCallback("indexes", indexesCount, "done");
+        progressCallback("enums", 0, "done");
       }
+      return {
+        version: "5",
+        dialect: "sqlite",
+        tables: result,
+        enums: {},
+        _meta: {
+          tables: {},
+          columns: {}
+        }
+      };
     };
-    exports.TaskTerminal = TaskTerminal;
-    function render2(view) {
-      const { stdin, stdout, closable } = (0, readline_1.prepareReadLine)();
-      if (view instanceof Prompt2) {
-        const terminal = new Terminal(view, stdin, stdout, closable);
-        terminal.requestLayout();
-        return terminal.result();
-      }
-      stdout.write(`${view}
-`);
-      closable.close();
-      return;
-    }
-    exports.render = render2;
-    function renderWithTask3(view, task) {
-      return __awaiter(this, void 0, void 0, function* () {
-        const terminal = new TaskTerminal(view, process.stdout);
-        terminal.requestLayout();
-        const result = yield task;
-        terminal.clear();
-        return result;
+    toDrizzle2 = (schema) => {
+      const tables = {};
+      Object.values(schema.tables).forEach((t) => {
+        const columns = {};
+        Object.values(t.columns).forEach((c) => {
+          const columnName = c.name;
+          const type = c.type;
+          let columnBuilder;
+          if (type === "integer") {
+            columnBuilder = new import_sqlite_core.SQLiteIntegerBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new import_sqlite_core.SQLiteTextBuilder(columnName, {});
+          } else if (type === "blob") {
+            columnBuilder = new import_sqlite_core.SQLiteBlobBufferBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new import_sqlite_core.SQLiteRealBuilder(columnName);
+          } else {
+            columnBuilder = new import_sqlite_core.SQLiteNumericBuilder(columnName);
+          }
+          if (c.notNull) {
+            columnBuilder = columnBuilder.notNull();
+          }
+          if (c.default) {
+            columnBuilder = columnBuilder.default(c.default);
+          }
+          if (c.primaryKey) {
+            columnBuilder = columnBuilder.primaryKey();
+          }
+          columns[columnName] = columnBuilder;
+        });
+        tables[t.name] = (0, import_sqlite_core.sqliteTable)(t.name, columns, (cb) => {
+          const res = {};
+          Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+            const gh = cpk.columns.map((c) => cb[c]);
+            res[cpk.name] = new import_sqlite_core.PrimaryKeyBuilder(
+              gh,
+              cpk.name
+            );
+          });
+          return res;
+        });
       });
-    }
-    exports.renderWithTask = renderWithTask3;
-    var terminateHandler;
-    function onTerminate(callback) {
-      terminateHandler = callback;
-    }
-    exports.onTerminate = onTerminate;
-  }
-});
-
-// src/cli/views.ts
-var import_hanji;
-var init_views = __esm({
-  "src/cli/views.ts"() {
-    init_source();
-    import_hanji = __toESM(require_hanji());
+      return tables;
+    };
   }
 });
 
@@ -2109,10 +2110,10 @@ var require_brace_expansion = __commonJS({
 });
 
 // src/drivers/index.ts
-var import_drizzle_orm3, DrizzleDbClient, DrizzleORMPgClient, TursoSqlite;
+var import_drizzle_orm4, DrizzleDbClient, DrizzleORMPgClient, TursoSqlite;
 var init_drivers = __esm({
   "src/drivers/index.ts"() {
-    import_drizzle_orm3 = require("drizzle-orm");
+    import_drizzle_orm4 = require("drizzle-orm");
     DrizzleDbClient = class {
       constructor(db) {
         this.db = db;
@@ -2120,11 +2121,11 @@ var init_drivers = __esm({
     };
     DrizzleORMPgClient = class extends DrizzleDbClient {
       async query(query, values) {
-        const res = await this.db.execute(import_drizzle_orm3.sql.raw(query));
+        const res = await this.db.execute(import_drizzle_orm4.sql.raw(query));
         return res.rows;
       }
       async run(query) {
-        const res = await this.db.execute(import_drizzle_orm3.sql.raw(query));
+        const res = await this.db.execute(import_drizzle_orm4.sql.raw(query));
         return res.rows;
       }
     };
@@ -3340,7 +3341,9 @@ var import_hanji3 = __toESM(require_hanji());
 init_views();
 init_pgSerializer();
 
-// src/introspect.ts
+// src/introspect-pg.ts
+var import_drizzle_orm3 = require("drizzle-orm");
+var import_relations = require("drizzle-orm/relations");
 init_pgSerializer();
 
 // src/cli/commands/pgIntrospect.ts