@foul11/awesome-db 1.1.0

package/dist/index.mjs

@@ -0,0 +1,1540 @@
+import { Kysely as __WEBPACK_EXTERNAL_MODULE_kysely_Kysely__, SqliteDialect as __WEBPACK_EXTERNAL_MODULE_kysely_SqliteDialect__, sql as __WEBPACK_EXTERNAL_MODULE_kysely_sql__ } from "kysely";
+import { Object_entries as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_Object_entries__, Object_keys as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_Object_keys__, isWebpack as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_isWebpack__, regex as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__ } from "@foul11/awesome";
+import { color as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_color__, f_printf as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_f_printf__, loggers as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_loggers__, pretty_message as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_pretty_message__, pretty_ms as __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_pretty_ms__ } from "@foul11/awesome-log";
+import { Migrator as __WEBPACK_EXTERNAL_MODULE_kysely_migration_c9f7ddf4_Migrator__ } from "kysely/migration";
+import { format as __WEBPACK_EXTERNAL_MODULE__foul11_sql_formatter_5d7ed540_format__ } from "@foul11/sql-formatter";
+import { v4 as __WEBPACK_EXTERNAL_MODULE_uuid_v4__ } from "uuid";
+import { default as __WEBPACK_EXTERNAL_MODULE_better_sqlite3_b46a9d6d_default__ } from "better-sqlite3";
+import { default as __WEBPACK_EXTERNAL_MODULE_bindings_default__ } from "bindings";
+import { default as __WEBPACK_EXTERNAL_MODULE_path_default__ } from "path";
+/******/ // The require scope
+/******/ var __webpack_require__ = {};
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+
+;// external "kysely"
+
+;// ./src/alter/utils.ts
+
+function columnDefinition(col, columnDef) {
+  if (columnDef.primary) col = col.primaryKey();
+  if (columnDef.unique) col = col.unique();
+  if (columnDef.auto_increment) col = col.autoIncrement();
+  if (columnDef.not_null) col = col.notNull();
+  if (columnDef.default !== null) {
+    if (typeof columnDef.default == 'string' && columnDef.default[0] == '(') {
+      col = col.defaultTo(__WEBPACK_EXTERNAL_MODULE_kysely_sql__.raw(columnDef.default));
+    } else {
+      col = col.defaultTo(__WEBPACK_EXTERNAL_MODULE_kysely_sql__.lit(columnDef.default));
+    }
+  }
+  if (columnDef.references) {
+    if (!columnDef.references.columns.length || columnDef.references.columns.length > 1) throw new Error('Only one column can be referenced');
+    const column_name = columnDef.references.columns[0];
+    const schema_name = [...columnDef.references.table.scheme_parts, columnDef.references.table.name, column_name].join('.');
+    col = col.references(schema_name);
+    if (columnDef.references.constraints) {
+      col = col.modifyEnd(__WEBPACK_EXTERNAL_MODULE_kysely_sql__.raw(` ${columnDef.references.constraints}`));
+    }
+  }
+  return col;
+}
+function itAddColumn(builder, columns) {
+  for (const column of columns) {
+    builder = builder.addColumn(column.name, column.type.toLowerCase(), col => columnDefinition(col, column));
+  }
+  return builder;
+}
+function tmpTableName(table) {
+  return `alter_${Math.floor(Date.now() / 1000)}_${table}`;
+}
+;// external "@foul11/awesome"
+
+;// ./src/SQLParser.js
+/* eslint-disable no-useless-assignment, jsdoc/reject-any-type, @stylistic/function-call-spacing */
+// spell-checker: words sqlv AUTOINCREMENT SAVEPOINT sqlited
+
+/** @param {string | TemplateStringsArray} str */
+function sqlv(str) {
+  if (Array.isArray(str)) str = str[0];
+  const arr = str.toString().split(/\r?\n/);
+  for (let i = 0; i < arr.length; i++) {
+    switch (true) {
+      case arr[i].trim().startsWith('INSERT INTO'):
+      case arr[i].trim().startsWith('ALTER TABLE'):
+      case arr[i].trim().startsWith('DROP TABLE'):
+      case arr[i].trim().startsWith('PRAGMA "main".foreign_key_check'):
+        arr[i] = arr[i] + ';';
+        break;
+    }
+  }
+  return arr.join('\n');
+}
+class SQLParser {
+  /**
+   * @typedef {string | number | null} sqlite_value
+   *
+   * @typedef {{
+   *  scheme_parts: string[],
+   *  name: string,
+   * }} sqlite_schema
+   *
+   * @typedef {{
+   *   name: string,
+   *   as: string?,
+   *   sort: 'ASC' | 'DESC' | null,
+   * }} sqlite_column
+   *
+   * @typedef {{
+   *  type: 'PRAGMA',
+   *  name: sqlite_schema,
+   *  value: sqlite_value,
+   * }} sqlite_PRAGMA
+   *
+   * @typedef {{
+   *  type: 'SAVEPOINT',
+   *  savepoint_name: string?,
+   * }} sqlite_SAVEPOINT
+   *
+   * @typedef {{
+   *  type: 'RELEASE',
+   *  savepoint_name: string?,
+   * }} sqlite_RELEASE
+   *
+   * @typedef {{
+   *  type: 'SELECT',
+   *  distinct: boolean,
+   *  columns: Exclude<sqlite_column, 'sort'>[],
+   *  from: sqlite_schema[],
+   *  where: string?,
+   *  group_by: string?,
+   *  order_by: string?,
+   *  limit: number?,
+   *  offset: number?,
+   * }} sqlite_SELECT
+   *
+   * @typedef {{
+   *  table: sqlite_schema,
+   *  columns: string[],
+   *  constraints: string?,
+   * }} sqlite_references
+   *
+   * @typedef {'TEXT' | 'INTEGER' | 'REAL' | 'BLOB' | 'DATETIME'} sqlite_types
+   *
+   * @typedef {{
+   *  name: string,
+   *  type: sqlite_types,
+   *  primary: boolean,
+   *  auto_increment: boolean,
+   *  not_null: boolean,
+   *  unique: boolean,
+   *  default: sqlite_value,
+   *  references: sqlite_references?,
+   * }} sqlite_column_def
+   *
+   * @typedef {Omit<Omit<sqlite_column_def, 'name'>, 'type'>} sqlite_constraint
+   *
+   * @typedef {{
+   *  type: 'CREATE_TABLE',
+   *  table: sqlite_schema,
+   *  if_not_exists: boolean,
+   *  columns: sqlite_column_def[],
+   * }} sqlite_CREATE_TABLE
+   *
+   * @typedef {{
+   *  type: 'CREATE_INDEX',
+   *  name: sqlite_schema,
+   *  table_name: string,
+   *  if_not_exists: boolean,
+   *  unique: boolean,
+   *  columns: Omit<sqlite_column, 'as'>[],
+   * }} sqlite_CREATE_INDEX
+   *
+   * @typedef {{
+   *  type: 'VALUES',
+   *  values: (number | string)[],
+   * }} sqlite_VALUES
+   *
+   * @typedef {{
+   *  type: 'INSERT',
+   *  table: sqlite_schema,
+   *  columns: Omit<Omit<sqlite_column, 'as'>, 'sort'>[],
+   *  expr: sqlite_VALUES | sqlite_SELECT,
+   * }} sqlite_INSERT
+   *
+   * @typedef {{
+   *  type: 'DROP_TABLE',
+   *  table: sqlite_schema,
+   *  if_not_exists: boolean,
+   * }} sqlite_DROP_TABLE
+   *
+   * @typedef {{
+   *  type: 'DROP_INDEX',
+   *  name: sqlite_schema,
+   *  if_not_exists: boolean,
+   * }} sqlite_DROP_INDEX
+   *
+   * @typedef {{
+   *  type: 'ALTER_RENAME_TO',
+   *  table: sqlite_schema,
+   *  to: string,
+   * }} sqlite_ALTER_RENAME_TO
+   *
+   * @typedef {{
+   *  type: 'ALTER_RENAME_COLUMN',
+   *  table: sqlite_schema,
+   *  from: string,
+   *  to: string,
+   * }} sqlite_ALTER_RENAME_COLUMN
+   *
+   * @typedef {{
+   *  type: 'ALTER_ADD',
+   *  table: sqlite_schema,
+   *  column: sqlite_column_def,
+   * }} sqlite_ALTER_ADD
+   *
+   * @typedef {{
+   *  type: 'ALTER_DROP',
+   *  table: sqlite_schema,
+   *  column_name: string,
+   * }} sqlite_ALTER_DROP
+   *
+   * @typedef {sqlite_PRAGMA              |
+   *           sqlite_SAVEPOINT           |
+   *           sqlite_RELEASE             |
+   *           sqlite_SELECT              |
+   *           sqlite_CREATE_TABLE        |
+   *           sqlite_CREATE_INDEX        |
+   *           sqlite_VALUES              |
+   *           sqlite_INSERT              |
+   *           sqlite_DROP_TABLE          |
+   *           sqlite_DROP_INDEX          |
+   *           sqlite_ALTER_RENAME_TO     |
+   *           sqlite_ALTER_RENAME_COLUMN |
+   *           sqlite_ALTER_ADD           |
+   *           sqlite_ALTER_DROP
+   * } sqlite_EXPRS
+   */
+  /**
+   * @param {string} sql
+   * @param {string} char
+   */
+  static splitQStrByChar(sql, char) {
+    const re = new RegExp(`((?=["'])(?:"[^"\\\\]*(?:\\\\[\\s\\S][^"\\\\]*)*"|'[^'\\\\]*(?:\\\\[\\s\\S][^'\\\\]*)*')|${char})`, 'g');
+    const out = /** @type {string[]} */[];
+    const acc = /** @type {string[]} */[];
+    /** @type {string[]} */
+    const res = sql.split(re);
+    for (const str of res) {
+      if (!str) continue;
+      acc.push(str);
+      if (str === char) {
+        out.push(acc.join(''));
+        acc.length = 0;
+      }
+    }
+    if (acc.length) out.push(acc.join(''));
+    return out;
+  }
+  /**
+   * @param {string} input
+   * @returns {sqlite_schema}
+   */
+  static sqliteSchema(input) {
+    const out = /** @type {string[]} */[];
+    // Регулярка объявлена вне regex функции, потому что на "\\" она багуется и не компилируется
+    const res = input.matchAll(/(?:(?=["'])(?:"[^"\\]*(?:\\[\s\S][^"\\]*)*"|'[^'\\]*(?:\\[\s\S][^'\\]*)*')|\.|[^.]+)/ig);
+    for (const match of res) {
+      const s = match[0];
+      if (!s || s === '.') continue;
+      if (s[0] === "'" || s[0] === '"') {
+        out.push(s.slice(1, -1));
+        continue;
+      }
+      out.push(s);
+    }
+    if (!out.length) throw new Error(`Can't parse name (empty): ${input}`);
+    return {
+      scheme_parts: out.splice(0, out.length - 1),
+      name: out[out.length - 1]
+    };
+  }
+  /** @param {string | null | undefined} input */
+  static sqliteName(input) {
+    if (!input) throw new Error(`Can't parse name (empty): ${input}`);
+    if (input[0] === '"') return input.slice(1, -1);
+    return input;
+  }
+  /**
+   * @param {string} input
+   * @returns {sqlite_column[]}
+   */
+  static sqliteColumns(input) {
+    const out = /** @type {ReturnType<typeof SQLParser['sqliteColumns']>} */[];
+    const columns = SQLParser.splitQStrByChar(input, ',').map(str => str.trim().match(SQLParser.regex.column));
+    for (const column of columns) {
+      if (!column || !column.groups) throw new Error(`Can't parse column: ${input}`);
+      const sort = /** @type {string | null} */column.groups.sort?.toUpperCase() ?? null;
+      if (sort && sort !== 'ASC' && sort !== 'DESC') throw new Error(`Can't parse sort: ${input}`);
+      out.push({
+        name: SQLParser.sqliteName(column.groups.name),
+        as: column.groups.as ? SQLParser.sqliteName(column.groups.as) : null,
+        sort: (/** @type {null | 'ASC' | 'DESC'} */sort)
+      });
+    }
+    return out;
+  }
+  /**
+   * @param {RegExp} rgx
+   * @param {string} input
+   */
+  static matchAllGroups(rgx, input) {
+    /** @type {Record<string, string | undefined>} */
+    const out = {};
+    const matches = input.matchAll(rgx);
+    for (const match of matches) Object.assign(out, ...__WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_Object_entries__(match.groups ?? {}).map(([k, v]) => v === undefined ? {} : {
+      [k]: v
+    }));
+    return {
+      groups: out
+    };
+  }
+  /**
+   * @param {string} input
+   * @returns {sqlite_column_def[]}
+   */
+  static sqliteColumnsDef(input) {
+    const out = /** @type {ReturnType<typeof SQLParser['sqliteColumnsDef']>} */[];
+    const columns = SQLParser.splitQStrByChar(input, ',').map(str => str.trim().match(SQLParser.regex.column_def));
+    for (const column of columns) {
+      if (!column || !column.groups) throw new Error(`Can't parse column: ${input}`);
+      if (!column.groups.name) {
+        // if not name then it's table constraint
+        if (!column.groups.table_constraint) throw new Error(`Can't parse table constraint or name: ${input}`);
+        const table_constraint = column.groups.table_constraint.trim().match(SQLParser.regex.table_constraint);
+        if (!table_constraint || !table_constraint.groups) throw new Error(`Can't parse table constraint: ${input}`);
+        const inline_columns = /** @type {sqlite_column[]} */[];
+        const props = /** @type {{ primary?: boolean, unique?: boolean, auto_increment?: boolean }} */{};
+        switch (true) {
+          case !!table_constraint.groups.primary_key_expr:
+            inline_columns.push(...SQLParser.sqliteColumns(table_constraint.groups.primary_key_expr));
+            if (table_constraint.groups.auto_increment) props.auto_increment = true;
+            props.primary = true;
+            break;
+          case !!table_constraint.groups.unique_expr:
+            inline_columns.push(...SQLParser.sqliteColumns(table_constraint.groups.unique_expr));
+            props.unique = true;
+            break;
+          default:
+            throw new Error(`Can't parse table constraint type: ${input}`);
+        }
+        const inline_names = new Set(inline_columns.map(c => c.name));
+        for (const inline_column of out.filter(c => inline_names.has(c.name))) {
+          for (const prop of __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_Object_keys__(props)) {
+            if (props[prop] === undefined) continue;
+            inline_column[prop] = props[prop];
+          }
+        }
+        continue;
+      }
+      const constraints = /** @type {sqlite_constraint} */{
+        auto_increment: false,
+        not_null: false,
+        primary: false,
+        unique: false,
+        default: null,
+        references: null
+      };
+      if (column.groups.constraint) {
+        const column_constraint = SQLParser.matchAllGroups(SQLParser.regex.constraint, column.groups.constraint.trim());
+        // .match(SQLParser.regex.constraint);
+        if (!column_constraint || !column_constraint.groups) throw new Error(`Can't parse column constraint: ${column.groups.constraint}`);
+        if (column_constraint.groups.auto_increment) constraints.auto_increment = true;
+        if (column_constraint.groups.not_null) constraints.not_null = true;
+        if (column_constraint.groups.primary_key) constraints.primary = true;
+        if (column_constraint.groups.unique) constraints.unique = true;
+        if (column_constraint.groups.default) {
+          const g = column_constraint.groups;
+          if (g.default_expr) {
+            constraints.default = g.default_expr;
+          } else {
+            constraints.default = SQLParser.sqliteValue(g.default_number ?? g.default_literal ?? g.default_const);
+          }
+        }
+        if (column_constraint.groups.references) constraints.references = {
+          table: SQLParser.sqliteSchema(column_constraint.groups.references_table ?? ''),
+          columns: SQLParser.splitQStrByChar(column_constraint.groups.columns_def_expr ?? '', ',').map(v => SQLParser.sqliteName(v.trim())),
+          constraints: column_constraint.groups.references_constraint ?? null
+        };
+      }
+      /** @type {string | null} */
+      const type = column.groups.type?.toUpperCase() ?? null;
+      if (!type) throw new Error(`Can't parse column type: ${input}`);
+      out.push({
+        name: SQLParser.sqliteName(column.groups.name),
+        type: (/** @type {sqlite_types} */type),
+        ...constraints
+      });
+    }
+    return out;
+  }
+  /**
+   * @param {string | null | undefined} input
+   * @returns {sqlite_value}
+   */
+  static sqliteValue(input) {
+    input = SQLParser.strOrNull(input);
+    if (input === null) return null;
+    const num = parseFloat(input);
+    if (!isNaN(num)) return num;
+    return input;
+  }
+  /** @param {string | null | undefined} str */
+  static strOrNull(str) {
+    if (str === null || str === undefined) return null;
+    if (str[0] === "'") return str.slice(1, -1);
+    return str;
+  }
+  /** @param {string | null | undefined} str */
+  static intOrNull(str) {
+    if (str === null || str === undefined) return null;
+    return parseInt(str);
+  }
+  static regex = {
+    PRAGMA: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                PRAGMA
+                (?: \s+       (?<name>     \S + ))?
+                (?: \s* = \s* (?<value> [\s\S]+ ))?
+            ;?)$
+        ``i`,
+    SAVEPOINT: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                SAVEPOINT
+                (?: \s+ (?<name> \S+ ))?
+            ;?)$
+        ``i`,
+    RELEASE: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                RELEASE
+                (?: \s+ (?<name> \S+ ))?
+            ;?)$
+        ``i`,
+    SELECT: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                SELECT
+                (?: \s+ (?<distinct> DISTINCT                                    ))?
+                (?: \s+ (?<columns>  [\s\S]+                                     ))
+                (?: \s+ (?<from>     FROM         \s+ (?<table _expr>  [\s\S]+?) ))
+                (?: \s+ (?<where>    WHERE        \s+ (?<where _expr>  [\s\S]+?) ))?
+                (?: \s+ (?<group_by> GROUP \s+ BY \s+ (?<group _expr>  [\s\S]+?) ))?
+                (?: \s+ (?<order_by> ORDER \s+ BY \s+ (?<order _expr>  [\s\S]+?) ))?
+                (?: \s+ (?<limit>    LIMIT        \s+ (?<limit _expr>  [\s\S]+?) ))?
+                (?: \s+ (?<offset>   OFFSET       \s+ (?<offset_expr>  [\s\S]+?) ))?
+            ;?)$
+        ``i`,
+    CREATE_TABLE: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                CREATE \s+ TABLE
+                (?: \s+ (?<if_not_exists>   IF \s+ NOT \s+ EXISTS             ))?
+                (?: \s+ (?<name>            (?<name_expr>        [\s\S]+?)    ))
+                (?: \s+ (?<columns_def>  \( (?<columns_def_expr> [\s\S]+?) \) ))
+            ;?)$
+        ``i`,
+    CREATE_INDEX: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                CREATE
+                (?: \s+ (?<unique>         UNIQUE                            ))?
+                (?: \s+ (?:                INDEX                             ))
+                (?: \s+ (?<if_not_exists>  IF \s+ NOT \s+ EXISTS             ))?
+                (?: \s+ (?<name>           (?<name_expr>        [\s\S]+?)    ))
+                (?: \s+ (?:                ON                                ))
+                (?: \s+ (?<table>          (?<table_expr>       [\s\S]+?)    ))
+                (?: \s+ (?<columns>     \( (?<columns_expr>     [\s\S]+?) \) ))
+            ;?)$
+        ``i`,
+    VALUES: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                VALUES
+                (?: \s+ \( (?<values>   [\s\S]+?) \) )
+            ;?)$
+        ``i`,
+    INSERT: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                INSERT \s+ INTO
+                (?: \s+ (?<table>          (?<table_expr>    [\s\S]+?)    ))
+                (?: \s+ (?<columns>     \( (?<columns_expr>  [\s\S]+?) \) ))
+                (?:
+                    (?: \s+ (?<values_expr> VALUES \s+  \( (?:   [\s\S]+?) \) )) |
+                    (?: \s+ (?<select_expr> SELECT \s+     (?:   [\s\S]+?)    ))
+                )
+            ;?)$
+        ``i`,
+    DROP: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                DROP
+                (?:
+                    (?: \s+ TABLE) |
+                    (?: \s+ INDEX)
+                )
+                (?: \s+ (?<if_not_exists> IF \s+ NOT \s+ EXISTS ))?
+                (?: \s+ (?<name>          [\s\S]+?              ))
+            ;?)$
+        ``i`,
+    ALTER_TABLE: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                ALTER \s+ TABLE
+                (?: \s+ (?<table>          (?<table_expr>    [\s\S]+?)    ))
+                (?:
+                    (?:
+                        (?: \s+ RENAME \s+ TO \s+            (?<rename_to > [\s\S]+? )) |
+                        (?: \s+ RENAME \s+ (?: COLUMN \s+ )?
+                            (?<rename_col_from> [\s\S]+? )
+                            (?: \s+ TO \s+ )
+                            (?<rename_col_to>   [\s\S]+? )
+                        ) |
+                        (?: \s+ DROP   \s+ (?: COLUMN \s+ )? (?<drop_col> [\s\S]+? ))
+                    ) |
+                        (?: \s+ ADD    \s+ (?: COLUMN \s+ )? (?<add_col>  [\s\S]+? ))
+                )
+            ;?)$
+        ``i`,
+    column: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                (?:         (?<name>                       [\s\S]+?    ))
+                (?:
+                    (?: \s+ (?<as>   AS \s+ (?<as_expr>    [\s\S]+?  ) ))? |
+                    (?: \s+ (?<sort>        (?<sort_expr>  ASC | DESC) ))?
+                )
+            ,?)$
+        ``i`,
+    column_def: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                (?:
+                    (?<table_constraint> (?: PRIMARY | UNIQUE | CHECK | FOREIGN ) [\s\S]+ )
+                ) |
+                (?:     (?<name>       [\s\S]+?                                       ))
+                (?: \s+ (?<type>       (?: TEXT | INTEGER | REAL | BLOB | DATETIME )  ))?
+                (?: \s+ (?<constraint> [\s\S]+?                                       ))?
+            ,?)$
+        ``i`,
+    constraint: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            (?:
+                // (?: \s* ) |
+                (?:
+                    (?<primary_key>  PRIMARY \s+ KEY 
+                        (?:     (?<primary_key_sort> ASC | DESC    ))?
+                        (?: \s+ (?<auto_increment>   AUTOINCREMENT ))?
+                    )
+                ) |
+                (?: (?<not_null>     NOT     \s+ NULL                              )) |
+                (?: (?<unique>       UNIQUE                                        )) |
+                (?: (?<default>      DEFAULT \s+
+                    (?:
+                        (?<default_expr> \(      [\s\S]+      \) ) |
+                        (?<default_number>  [+-]?  [\d]+         ) |
+                        (?<default_literal> ['"] [\s\S]+  ['"]   ) |
+                        (?<default_const>   TRUE | FALSE | NULL  )
+                    )
+                )) |
+                (?:
+                    (?<references> REFERENCES \s+
+                        (?<references_table> [\S]+)
+                        (?: \s* (?<columns_def>  \( (?<columns_def_expr> [\s\S]+?) \) ))?
+                        (?: \s* (?<references_constraint> (?:
+                            (?:    \s*
+                                ON \s+
+                                (?: DELETE | UPDATE ) \s+
+                                (?:
+                                    SET \s+ NULL    |
+                                    SET \s+ DEFAULT |
+                                    CASCADE         |
+                                    RESTRICT        |
+                                    NO  \s+ ACTION
+                                )
+                            ) |
+                            (?: \s* MATCH \s+ [\S]+) |
+                            (?: \s*
+                                (?: NOT \s+ )?
+                                DEFERRABLE
+                                (?:
+                                    \s+ INITIALLY \s+ DEFERRED |
+                                    \s+ INITIALLY \s+ IMMEDIATE
+                                )?
+                            ))+
+                        ))?
+                    )
+                )
+            )
+        ``ig`,
+    table_constraint: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_regex__`
+            ^(?:
+                (?:
+                    (?<primary_key>  PRIMARY \s+ KEY
+                        \(
+                            (?:     (?<primary_key_expr> [\s\S]+?         ))
+                            (?: \s+ (?<auto_increment>   AUTOINCREMENT    ))?
+                        \)
+                    )
+                ) |
+                (?: (?<unique>       UNIQUE  \s+      \((?<unique_expr>      [\s\S]+?)\)   ))
+            )$
+        ``i`
+  };
+  /** @param {string} sql */
+  static parse(sql) {
+    const out = /** @type {sqlite_EXPRS[]} */[];
+    const semi_split = SQLParser.splitQStrByChar(sql, ';');
+    for (const raw_str of semi_split) {
+      const str_expr = raw_str.trim();
+      switch (true) {
+        case /^PRAGMA/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.PRAGMA);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'PRAGMA',
+              name: SQLParser.sqliteSchema(parse.groups.name),
+              value: SQLParser.sqliteValue(parse.groups.value)
+            });
+            break;
+          }
+        case /^SAVEPOINT/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.SAVEPOINT);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'SAVEPOINT',
+              savepoint_name: SQLParser.strOrNull(parse.groups.name)
+            });
+            break;
+          }
+        case /^RELEASE/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.RELEASE);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'RELEASE',
+              savepoint_name: SQLParser.strOrNull(parse.groups.name)
+            });
+            break;
+          }
+        case /^SELECT/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.SELECT);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'SELECT',
+              distinct: !!parse.groups.distinct,
+              columns: SQLParser.sqliteColumns(parse.groups.columns),
+              from: SQLParser.splitQStrByChar(parse.groups.table_expr, ',').map(t => SQLParser.sqliteSchema(t)),
+              where: SQLParser.strOrNull(parse.groups.where_expr),
+              group_by: SQLParser.strOrNull(parse.groups.group_expr),
+              order_by: SQLParser.strOrNull(parse.groups.order_expr),
+              offset: SQLParser.intOrNull(parse.groups.offset_expr),
+              limit: SQLParser.intOrNull(parse.groups.limit_expr)
+            });
+            break;
+          }
+        case /^CREATE TABLE/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.CREATE_TABLE);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'CREATE_TABLE',
+              if_not_exists: !!parse.groups.if_not_exists,
+              table: SQLParser.sqliteSchema(parse.groups.name_expr),
+              columns: SQLParser.sqliteColumnsDef(parse.groups.columns_def_expr)
+            });
+            break;
+          }
+        case /^CREATE/i.test(str_expr):
+          {
+            // if not CREATE TABLE then CREATE INDEX
+            const parse = str_expr.match(SQLParser.regex.CREATE_INDEX);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'CREATE_INDEX',
+              name: SQLParser.sqliteSchema(parse.groups.name_expr),
+              table_name: SQLParser.sqliteName(parse.groups.table_expr),
+              if_not_exists: !!parse.groups.if_not_exists,
+              unique: !!parse.groups.unique,
+              columns: SQLParser.sqliteColumns(parse.groups.columns_expr)
+            });
+            break;
+          }
+        case /^INSERT/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.INSERT);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            const expr = SQLParser.parse(`${parse.groups.values_expr || parse.groups.select_expr};`)[0];
+            if (!expr || expr.type !== 'SELECT' && expr.type !== 'VALUES') throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'INSERT',
+              table: SQLParser.sqliteSchema(parse.groups.table_expr),
+              columns: SQLParser.sqliteColumns(parse.groups.columns_expr),
+              expr: expr
+            });
+            break;
+          }
+        case /^VALUES/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.VALUES);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            const values = SQLParser.splitQStrByChar(parse.groups.values, ',').map(v => v[0] !== '"' ? parseFloat(v) : v.slice(1, -1));
+            out.push({
+              type: 'VALUES',
+              values
+            });
+            break;
+          }
+        case /^DROP TABLE/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.DROP);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'DROP_TABLE',
+              if_not_exists: !!parse.groups.if_not_exists,
+              table: SQLParser.sqliteSchema(parse.groups.name)
+            });
+            break;
+          }
+        case /^DROP INDEX/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.DROP);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            out.push({
+              type: 'DROP_INDEX',
+              if_not_exists: !!parse.groups.if_not_exists,
+              name: SQLParser.sqliteSchema(parse.groups.name)
+            });
+            break;
+          }
+        case /^ALTER TABLE/i.test(str_expr):
+          {
+            const parse = str_expr.match(SQLParser.regex.ALTER_TABLE);
+            if (!parse || !parse.groups) throw new Error(`Can't parse: ${str_expr}`);
+            const table = SQLParser.sqliteSchema(parse.groups.table_expr);
+            switch (true) {
+              case !!parse.groups.rename_to:
+                out.push({
+                  type: 'ALTER_RENAME_TO',
+                  table,
+                  to: SQLParser.sqliteName(parse.groups.rename_to)
+                });
+                break;
+              case !!parse.groups.rename_col:
+                out.push({
+                  type: 'ALTER_RENAME_COLUMN',
+                  table,
+                  from: SQLParser.sqliteName(parse.groups.rename_col_from),
+                  to: SQLParser.sqliteName(parse.groups.rename_col_to)
+                });
+                break;
+              case !!parse.groups.add_col:
+                {
+                  const column = SQLParser.sqliteColumnsDef(parse.groups.add_col)[0];
+                  if (!column) throw new Error(`Can't parse: ${str_expr}`);
+                  out.push({
+                    type: 'ALTER_ADD',
+                    table,
+                    column: column
+                  });
+                  break;
+                }
+              case !!parse.groups.drop_col:
+                out.push({
+                  type: 'ALTER_DROP',
+                  table,
+                  column_name: SQLParser.sqliteName(parse.groups.drop_col)
+                });
+                break;
+              default:
+                throw new Error(`Can't parse: ${str_expr}`);
+            }
+            break;
+          }
+        case str_expr.trim() === '':
+          break;
+        default:
+          throw new Error(`Can't parse (default): ${str_expr}`);
+      }
+    }
+    return out;
+  }
+}
+class SQLiteDebugger {
+  /*
+      TODO:
+          Класс который будет разбивать операции с sqlv на отдельные части,
+          угадывать что было сделано RENAME/ADD COLUMN/REMOVE COLUMN/EDIT COLUMN и тд,
+          и красивенько выводить в stdout, показывать успешные операции, выполнять транзакции
+  */
+  // /** @param {import('better-sqlite3').Database} db */
+  /** @param {any} db */
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * @param {string} table
+   * @returns {{
+   *  cid: number,
+   *  name: string,
+   *  type: 'INTEGER' | 'REAL' | 'TEXT' | 'BLOB' | 'NUMERIC',
+   *  notnull: boolean,
+   *  dflt_value: string | null,
+   *  pk: boolean,
+   * }[]}
+   */
+  tableInfo(table) {
+    return this.db.prepare(`SELECT * FROM pragma_table_info('${table}')`).all().map((/** @type {*} */r) => {
+      return {
+        ...r,
+        notnull: !!r.notnull,
+        pk: !!r.pk
+      };
+    });
+  }
+  /**
+   * @returns {{
+   *  type: 'index' | 'table',
+   *  name: string,
+   *  tbl_name: string,
+   *  rootpage: number,
+   *  sql: string,
+   * }[]}
+   */
+  masterTable() {
+    return /** @type {*} */this.db.prepare(`SELECT * FROM sqlite_master`).all().filter((/** @type {*} */r) => r.name != 'sqlite_sequence');
+  }
+  /**
+   * @typedef {number | {
+   *  from: number,
+   *  to: number,
+   * }} sqlited_index
+   *
+   * @typedef {{
+   *  type: 'LINK_SQLITE',
+   *  index: number,
+   *  link: sqlite_EXPRS,
+   *  linked: Map<sqlited_link_logic_sub_type, Set<sqlited_link_logic | sqlited_link_sqlite>>,
+   * }} sqlited_link_sqlite
+   *
+   * @typedef {'SAVE/RELEASE' | 'LINK_TABLE'} sqlited_link_logic_sub_type
+   *
+   * @typedef {{
+   *  type: 'LINK',
+   *  sub_type: sqlited_link_logic_sub_type,
+   *  index: sqlited_index,
+   *  child: (sqlited_link_logic | sqlited_link_sqlite)[],
+   * }} sqlited_link_logic
+   */
+  /*
+      TODO:
+          t1 - новая
+          t2 - старая
+          [ ->] - необязательная операция
+          {number [/ link]} - номер/ссылка
+          {...S} - Миграция схемы
+          {...D} - Миграция данных
+          
+          * {1 S} [Добавление столбца (t2) ->] Создание (t1) -> перенос данных (t2 -> t1) -> удаление (t2) -> переименование (t1)
+              - Переименование (t2)                [При условии, что столбцы те же самые]
+              - Добавление/Удаление столбца (t2)   [При условии, что столбцы создаваемых таблиц отличаются от исходных]
+              - Частичный перенос (t2)             [При условии, что столбцы такие же, но выбраны для переноса не все]
+              - Изменения типа данных (t2)         [При условии, что у любого столба отличается тип данных от исходного]
+              - Изменения дефолтного значений (t2) [При условии, что у любого столба отличается дефолтное значение от исходного]
+              - Изменение аттрибутов uniq, ...(t2) [При условии, что у любого столба отличается аттрибут uniq, ... от исходного]
+              
+          * {2 S / before 1} Создание индексов (t2)
+              - Пересоздание индексов (t1)         [При условии, что индексы такие же в двух таблицах до и после]
+              - Добавление/Удаление индексов (t2)  [При условии, что индексы создаваемых таблиц отличаются от исходных, а так же может значит ошибку в случае если не будет хватать индекса]
+          
+          * {3 D} Добавление данных (t2)
+              - Просто вставка данных в таблицу (t2)
+              
+          * {4 D} Удаление данных (t2)
+              - Просто удаление данных из таблицы (t2)
+  */
+  /**
+   * @param {sqlited_index?} i1
+   * @param {sqlited_index?} i2
+   */
+  static sql_idx_min(i1, i2) {
+    if (i1 === null && i2 === null) return null;
+    if (i1 !== null && typeof i1 == 'object') i1 = Math.min(i1.from, i1.to);
+    if (i2 !== null && typeof i2 == 'object') i2 = Math.min(i2.from, i2.to);
+    if (i1 === null) return i2;
+    if (i2 === null) return i1;
+    return Math.min(i1, i2);
+  }
+  /**
+   * @param {sqlited_index?} i1
+   * @param {sqlited_index?} i2
+   */
+  static sql_idx_max(i1, i2) {
+    if (i1 === null && i2 === null) return null;
+    if (i1 !== null && typeof i1 == 'object') i1 = Math.max(i1.from, i1.to);
+    if (i2 !== null && typeof i2 == 'object') i2 = Math.max(i2.from, i2.to);
+    if (i1 === null) return i2;
+    if (i2 === null) return i1;
+    return Math.max(i1, i2);
+  }
+  /**
+   * @param {sqlited_index?} i1
+   * @param {sqlited_index?} i2
+   */
+  static sql_idx_outRange(i1, i2) {
+    const i1min = SQLiteDebugger.sql_idx_min(i1, null);
+    const i1max = SQLiteDebugger.sql_idx_max(i1, null);
+    const i2min = SQLiteDebugger.sql_idx_min(i2, null);
+    const i2max = SQLiteDebugger.sql_idx_max(i2, null);
+    if (i1min === null || i1max === null || i2min === null || i2max === null) return null;
+    return i1min < i2min && i1max > i2max;
+  }
+  /**
+   * @param {sqlited_index?} i1
+   * @param {sqlited_index?} i2
+   */
+  static sql_idx_inRange(i1, i2) {
+    const i1min = SQLiteDebugger.sql_idx_min(i1, null);
+    const i1max = SQLiteDebugger.sql_idx_max(i1, null);
+    const i2min = SQLiteDebugger.sql_idx_min(i2, null);
+    const i2max = SQLiteDebugger.sql_idx_max(i2, null);
+    if (i1min === null || i1max === null || i2min === null || i2max === null) return null;
+    return i1min >= i2min && i1min <= i2max && i1max <= i2max && i1max >= i2min;
+  }
+  /**
+   * @param {sqlited_index?} i1
+   * @param {sqlited_index?} i2
+   */
+  static sql_idx_invalidRange(i1, i2) {
+    const outRange = SQLiteDebugger.sql_idx_outRange(i1, i2);
+    const inRange = SQLiteDebugger.sql_idx_inRange(i1, i2);
+    return !outRange && !inRange;
+  }
+  /**
+   * @param {sqlited_link_sqlite[]} links
+   * @param {sqlited_link_sqlite} link
+   * @param {sqlited_link_logic_sub_type} sub_type
+   * @param {(link: sqlited_link_sqlite, input: sqlited_link_sqlite) => boolean} predicate
+   * @returns {sqlited_link_logic[]}
+   */
+  link_for_predicate(links, link, sub_type, predicate) {
+    if (!link.linked.has(sub_type)) link.linked.set(sub_type, new Set([link]));
+    /** @type {sqlited_link_sqlite[]} */
+    const out = [link];
+    const link_linked = link.linked.get(sub_type);
+    if (!link_linked) throw new Error('link_linked is null');
+    for (const l of links) {
+      if (!l.linked.has(sub_type)) l.linked.set(sub_type, new Set([l]));
+      const l_linked = l.linked.get(sub_type);
+      if (!l_linked) throw new Error('l_linked is undefined');
+      if (link_linked.has(l)) continue;
+      if (predicate(link, l)) {
+        link_linked.add(l);
+        l_linked.add(link);
+        out.push(l);
+      }
+    }
+    if (!out.length) return [];
+    const i_min = out.reduce((prev, l) => SQLiteDebugger.sql_idx_min(prev, l.index), /** @type {number?} */null);
+    const i_max = out.reduce((prev, l) => SQLiteDebugger.sql_idx_max(prev, l.index), /** @type {number?} */null);
+    if (i_min === null || i_max === null) throw new Error('Index is null');
+    return [{
+      type: 'LINK',
+      sub_type,
+      child: out,
+      index: {
+        from: i_min,
+        to: i_max
+      }
+    }];
+  }
+  /** @param {string} sql */
+  Heuristics_DBBrowserForSQLite(sql) {
+    /** @type {sqlited_link_sqlite[]} */
+    const parsed = SQLParser.parse(sql).map((e, i) => {
+      return {
+        type: 'LINK_SQLITE',
+        index: i,
+        link: e,
+        linked: new Map()
+      };
+    });
+    /** @type {sqlited_link_logic[]} */
+    const logics = [];
+    for (const link of parsed) {
+      switch (link.link.type) {
+        case 'SAVEPOINT':
+        case 'RELEASE':
+          logics.push(...this.link_for_predicate(parsed, link, 'SAVE/RELEASE', (stmt_link, l) => {
+            if ('savepoint_name' in stmt_link.link && 'savepoint_name' in l.link) return stmt_link.link.savepoint_name === l.link.savepoint_name;
+            return false;
+          }));
+          break;
+        case 'SELECT':
+        case 'CREATE_TABLE':
+        case 'INSERT':
+        case 'DROP_TABLE':
+        case 'ALTER_RENAME_TO':
+        case 'ALTER_RENAME_COLUMN':
+        case 'ALTER_ADD':
+        case 'ALTER_DROP':
+          {
+            let table = null;
+            if ('table' in link.link) {
+              table = new Set(link.link.table.name);
+            } else if ('from' in link.link) {
+              table = new Set(link.link.from.map(t => t.name));
+            } else {
+              throw new Error('table is null');
+            }
+            logics.push(...this.link_for_predicate(parsed, link, 'LINK_TABLE', (stmt_link, l) => {
+              if ('table' in l.link) {
+                return table.has(l.link.table.name);
+              } else if ('from' in l.link) {
+                return l.link.from.some(t => table.has(t.name));
+              }
+              return false;
+            }));
+            break;
+          }
+      }
+    }
+    console.log(logics);
+  }
+  /** @param {string | TemplateStringsArray} sql */
+  execFrom_DBBrowser(sql) {
+    if (Array.isArray(sql)) sql = sql[0];
+    // this.db.exec(sql.toString());
+  }
+}
+;// ./src/utils.ts
+
+
+async function table_info(db, table) {
+  return (await __WEBPACK_EXTERNAL_MODULE_kysely_sql__`SELECT * FROM pragma_table_info('${__WEBPACK_EXTERNAL_MODULE_kysely_sql__.raw(table)}')`.execute(db)).rows.map(r => ({
+    ...r,
+    notnull: !!r.notnull,
+    pk: !!r.pk,
+    type: r.type.toUpperCase()
+  }));
+}
+async function master_table(db) {
+  return (await db.selectFrom('sqlite_master').selectAll().execute()).filter(r => r.name != 'sqlite_sequence');
+}
+async function get_table_schema(db, table) {
+  const master = (await master_table(db)).find(r => r.name == table);
+  if (!master) return false;
+  const schema = SQLParser.parse(master.sql)[0];
+  if (schema?.type != 'CREATE_TABLE') return false;
+  return schema;
+}
+;// ./src/alter/pragma.ts
+
+async function pragma_foreign_keys(db, enable) {
+  return __WEBPACK_EXTERNAL_MODULE_kysely_sql__`PRAGMA foreign_keys = ${__WEBPACK_EXTERNAL_MODULE_kysely_sql__.lit(enable ? 1 : 0)}`.execute(db);
+}
+async function pragma_defer_foreign_keys(db, enable) {
+  return __WEBPACK_EXTERNAL_MODULE_kysely_sql__`PRAGMA defer_foreign_keys = ${__WEBPACK_EXTERNAL_MODULE_kysely_sql__.lit(enable ? 1 : 0)}`.execute(db);
+}
+;// ./src/alter/column_add.ts
+
+
+
+/**
+ * Alter column add after column, or first if null
+ */
+async function alter_column_add(db, table, column_name, column_type, after, col, eb) {
+  await pragma_foreign_keys(db, false);
+  await db.transaction().execute(async trx => {
+    const alter_table = tmpTableName(table);
+    const schema = await get_table_schema(trx, table);
+    if (!schema) throw new Error(`Table ${table} does not exist`);
+    if (schema.columns.some(c => c.name == column_name)) return; // passthrough if column already exists
+    const after_column_idx = schema.columns.findIndex(c => c.name == after);
+    let columns_after = [];
+    let columns_before = [];
+    if (after_column_idx !== -1) {
+      columns_after = schema.columns.slice(0, after_column_idx + 1);
+      columns_before = schema.columns.slice(after_column_idx + 1);
+    } else {
+      columns_after = [];
+      columns_before = schema.columns;
+    }
+    let builder = trx.schema.createTable(alter_table);
+    builder = itAddColumn(builder, columns_after);
+    builder = builder.addColumn(column_name, column_type, col);
+    builder = itAddColumn(builder, columns_before);
+    await builder.execute();
+    await trx.insertInto(alter_table).columns([...columns_after.map(c => c.name), ...(eb ? [column_name] : []), ...columns_before.map(c => c.name)]).expression(() => trx.selectFrom(table).select([...columns_after.map(c => `${table}.${c.name}`), ...(eb ? [eb] : []), ...columns_before.map(c => `${table}.${c.name}`)])).executeTakeFirstOrThrow();
+    await trx.schema.dropTable(table).execute();
+    await trx.schema.alterTable(alter_table).renameTo(table).execute();
+  });
+  await pragma_foreign_keys(db, true);
+}
+;// ./src/alter/column_drop.ts
+
+
+
+/**
+ * Alter column drop
+ */
+async function alter_column_drop(db, table, column_name) {
+  await pragma_foreign_keys(db, false);
+  await db.transaction().execute(async trx => {
+    const alter_table = tmpTableName(table);
+    const schema = await get_table_schema(trx, table);
+    if (!schema) throw new Error(`Table ${table} does not exist`);
+    if (!schema.columns.find(c => c.name == column_name)?.type) return; // passthrough if column not found
+    const columns = schema.columns.filter(c => c.name != column_name);
+    let builder = trx.schema.createTable(alter_table);
+    builder = itAddColumn(builder, columns);
+    await builder.execute();
+    await trx.insertInto(alter_table).columns(columns.map(c => c.name)).expression(eb => eb.selectFrom(table).select(columns.map(c => `${table}.${c.name}`))).executeTakeFirstOrThrow();
+    await trx.schema.dropTable(table).execute();
+    await trx.schema.alterTable(alter_table).renameTo(table).execute();
+  });
+  await pragma_foreign_keys(db, true);
+}
+;// ./src/alter/column_rename.ts
+
+
+
+/**
+ * Alter column rename
+ */
+async function alter_column_rename(db, table, column_name, new_column_name) {
+  await pragma_foreign_keys(db, false);
+  await db.transaction().execute(async trx => {
+    const alter_table = tmpTableName(table);
+    const schema = await get_table_schema(trx, table);
+    if (!schema) throw new Error(`Table ${table} does not exist`);
+    const columns = schema.columns;
+    if (columns.some(c => c.name === new_column_name)) return; // passthrough if column already exists
+    let builder = trx.schema.createTable(alter_table);
+    builder = itAddColumn(builder, columns.map(c => ({
+      ...c,
+      name: c.name == column_name ? new_column_name : c.name
+    })));
+    await builder.execute();
+    await trx.insertInto(alter_table).columns(columns.map(c => c.name == column_name ? new_column_name : c.name)).expression(eb => eb.selectFrom(table).select(columns.map(c => `${table}.${c.name}`))).executeTakeFirstOrThrow();
+    await trx.schema.dropTable(table).execute();
+    await trx.schema.alterTable(alter_table).renameTo(table).execute();
+  });
+  await pragma_foreign_keys(db, true);
+}
+;// ./src/alter/column_update.ts
+
+
+
+
+/**
+ * Alter column update settings (e.g. not null)
+ */
+async function alter_column_update(db, table, column_name, column_type, col, eb = null) {
+  await pragma_foreign_keys(db, false);
+  await db.transaction().execute(async trx => {
+    const alter_table = tmpTableName(table);
+    const schema = await get_table_schema(trx, table);
+    if (!schema) throw new Error(`Table ${table} does not exist`);
+    let columns_after = null;
+    let columns_before = null;
+    const prev_column_idx = schema.columns.findIndex(c => c.name == column_name);
+    if (prev_column_idx === -1) throw new Error(`Column ${column_name} does not exist`);
+    columns_after = schema.columns.slice(0, prev_column_idx);
+    columns_before = schema.columns.slice(prev_column_idx + 1);
+    let builder = trx.schema.createTable(alter_table);
+    builder = itAddColumn(builder, columns_after);
+    builder = builder.addColumn(column_name, column_type, col);
+    builder = itAddColumn(builder, columns_before);
+    const create_schema = SQLParser.parse(builder.compile().sql)[0];
+    if (create_schema?.type != 'CREATE_TABLE') throw new Error('Invalid builded SQL');
+    const old_column = schema.columns.find(c => c.name == column_name);
+    const new_column = create_schema.columns.find(c => c.name == column_name);
+    if (!old_column || !new_column) throw new Error('new/old column not found');
+    if (JSON.stringify(old_column) == JSON.stringify(new_column)) return; // passthrough if column settings are the same
+    await builder.execute();
+    await trx.insertInto(alter_table).columns([...columns_after.map(c => c.name), column_name, ...columns_before.map(c => c.name)]).expression(() => trx.selectFrom(table).select([...columns_after.map(c => `${table}.${c.name}`), ...(eb ? [eb] : [`${table}.${column_name}`]), ...columns_before.map(c => `${table}.${c.name}`)])).executeTakeFirstOrThrow();
+    await trx.schema.dropTable(table).execute();
+    await trx.schema.alterTable(alter_table).renameTo(table).execute();
+  });
+  await pragma_foreign_keys(db, true);
+}
+;// ./src/alter/columns_order.ts
+
+
+
+/**
+ * Alter column order
+ */
+async function alter_column_order(db, table, columns_name) {
+  await pragma_foreign_keys(db, false);
+  await db.transaction().execute(async trx => {
+    const alter_table = tmpTableName(table);
+    const schema = await get_table_schema(trx, table);
+    if (!schema) throw new Error(`Table ${table} does not exist`);
+    const schema_columns = new Map(schema.columns.map((c, i) => [c.name, i]));
+    const new_columns = new Map(columns_name.map((c, i) => [c, i]));
+    if (schema_columns.size != new_columns.size || schema_columns.size != columns_name.length) throw new Error(`Table ${table} column count mismatch`);
+    if (![...schema_columns.entries()].some(([c_name, idx]) => new_columns.get(c_name) != idx)) return; // passthrough if column order is the same
+    let builder = trx.schema.createTable(alter_table);
+    builder = itAddColumn(builder, columns_name.map(c => schema.columns[schema_columns.get(c)]));
+    await builder.execute();
+    await trx.insertInto(alter_table).columns(columns_name).expression(eb => eb.selectFrom(table).select(columns_name.map(c => `${table}.${c}`))).executeTakeFirstOrThrow();
+    await trx.schema.dropTable(table).execute();
+    await trx.schema.alterTable(alter_table).renameTo(table).execute();
+  });
+  await pragma_foreign_keys(db, true);
+}
+;// ./src/alter/index.ts
+
+
+
+
+
+
+;// ./src/defaults.ts
+
+const currTimeDefault = __WEBPACK_EXTERNAL_MODULE_kysely_sql__`(strftime('%FT%R:%fZ'))`;
+;// ./src/Error.ts
+class ErrorModule extends Error {}
+class ErrorDB extends ErrorModule {}
+class ErrorMigration extends ErrorDB {}
+class ErrorSchema extends ErrorDB {}
+class ErrorQuery extends ErrorDB {}
+class ErrorUnknown extends ErrorDB {}
+class ErrorFlag extends ErrorUnknown {}
+class ErrorFlagPack extends ErrorFlag {}
+class ErrorFlagUnpack extends ErrorFlag {}
+class ErrorFlagInvalid extends ErrorFlag {}
+;// ./src/indexer.ts
+
+async function indexer(db, options) {
+  const master = await master_table(db);
+  const idx_exclude = new Map(options.exclude || []);
+  const idx_include = new Map(options.include || []);
+  const cleanupOthers = options.cleanupOthers || false;
+  const tables = master.filter(r => r.type == 'table').filter(r => !options.include || idx_include.has(r.name)).map(r => r.name);
+  const indexes = new Set(master.filter(r => r.type == 'index').map(r => r.name));
+  const isExcluded = (table, column) => {
+    const exclude = idx_exclude.get(table);
+    if (exclude === true || exclude?.includes(column.name)) return true;
+    return false;
+  };
+  const isIncluded = (table, column) => {
+    const include = idx_include.get(table);
+    if (options.include && !(include == true || include?.includes(column.name))) return false;
+    return true;
+  };
+  for (const table of tables) {
+    const info = await table_info(db, table);
+    for (const column of info) {
+      const idx_name = `autoIdx_${table}_${column.name}`;
+      const skip = !isIncluded(table, column) || isExcluded(table, column) || column.pk;
+      if (indexes.has(idx_name)) {
+        if (cleanupOthers && skip) {
+          await db.schema.dropIndex(idx_name).execute();
+        }
+        continue;
+      }
+      if (skip) continue;
+      await db.schema.createIndex(idx_name).on(table).column(column.name).execute();
+    }
+  }
+}
+;// ./src/ORM.ts
+
+class ORM {
+  static async getWhereId(id, table, column, db_builder) {
+    const res = await db_builder.selectFrom(table).select(column).where('id', '=', id).executeTakeFirst();
+    if (!res) throw new ErrorUnknown(`Failed to get column ${String(column)} from ${String(table)}`);
+    return res[column];
+  }
+  static async setWhereId(id, table, value, db_builder) {
+    const result = await db_builder.updateTable(table).set(value).where('id', '=', id).executeTakeFirst();
+    return result.numUpdatedRows == 1n;
+  }
+}
+;// ./src/WebpackFileProvider.ts
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function isFunction(obj) {
+  return typeof obj === 'function';
+}
+function isObject(obj) {
+  return typeof obj === 'object' && obj !== null;
+}
+function isMigration(obj) {
+  return isObject(obj) && isFunction(obj.up);
+}
+class WebpackFileProvider {
+  static db_migrations = new Map();
+  #db_name;
+  constructor(db_name) {
+    this.#db_name = db_name;
+  }
+  getMigrations() {
+    const migrations_list = {};
+    const migrations = WebpackFileProvider.db_migrations.get(this.#db_name);
+    if (!migrations) return Promise.resolve(migrations_list);
+    for (const [file, exports] of Object.entries(migrations)) {
+      if (isMigration(exports?.default)) {
+        migrations_list[file] = exports.default;
+      } else if (isMigration(exports)) {
+        migrations_list[file] = exports;
+      }
+    }
+    return Promise.resolve(migrations_list);
+  }
+  static setupDynamicImport(ctx, db_name) {
+    for (const [fpath, exports] of ctx.keys().map(m => [m, ctx(m)])) {
+      const [, db, file] = /^.+[\\/]([^\\/]+)[\\/](.+)\.[jt]s$/i.exec(fpath) ?? [];
+      if (!db_name) db_name = db;
+      if (!db_name || !file) continue;
+      if (WebpackFileProvider.db_migrations.has(db_name)) {
+        WebpackFileProvider.db_migrations.get(db_name)[file] = exports;
+      } else {
+        WebpackFileProvider.db_migrations.set(db_name, {
+          [file]: exports
+        });
+      }
+    }
+  }
+}
+;// external "@foul11/awesome-log"
+
+;// ./src/log/access_log.ts
+/* eslint-disable @stylistic/indent-binary-ops */
+
+const logger_access_log = __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_loggers__.add('access_log', {
+  format: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_f_printf__(info => (`` + `${__WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_pretty_message__(info, {
+    disable_empty: true
+  })}` + `${info.runtime ? __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_color__('ms', ` took ${__WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_pretty_ms__(info.runtime).padStart(11, ' ')}`) : ' '.repeat(6 + 11)}` + `${info.data ? ` (${__WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_color__('string', `'${info.data.action}'`)}, total: ${__WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_color__('ms', __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_pretty_ms__(info.data.timings.total / 1e6).padStart(11, ' '))})` : ``}`).trim(), {
+    meta: {
+      label: 'access_log'
+    },
+    sanitize: ['data', 'runtime']
+  })
+});
+/* harmony default export */ const access_log = (logger_access_log);
+;// ./src/log/db.ts
+/* eslint-disable @stylistic/indent-binary-ops */
+
+const logger_db = __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_loggers__.add('db', {
+  format: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_f_printf__(info => (`` + `${__WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_pretty_message__(info, {
+    disable_empty: true
+  })}` + `${info.query ? `\n${info.query}\n` : ``}` + `${info.runtime ? __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_color__('string', `(runtime: ${__WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_color__('ms', __WEBPACK_EXTERNAL_MODULE__foul11_awesome_log_ab373ec3_pretty_ms__(info.runtime))})`) : ``}`).trim(), {
+    meta: {
+      label: 'db'
+    },
+    sanitize: ['query', 'runtime']
+  })
+});
+/* harmony default export */ const db = (logger_db);
+;// ./src/log/index.ts
+
+
+;// external "kysely/migration"
+
+;// external "@foul11/sql-formatter"
+
+;// external "uuid"
+
+;// external "better-sqlite3"
+
+;// external "bindings"
+
+;// external "path"
+
+;// ./src/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function create_sqlite(db_path) {
+  const db = new __WEBPACK_EXTERNAL_MODULE_better_sqlite3_b46a9d6d_default__(db_path, {
+    nativeBinding: __WEBPACK_EXTERNAL_MODULE__foul11_awesome_5cd072e2_isWebpack__() ? __WEBPACK_EXTERNAL_MODULE_bindings_default__({
+      module_root: process.cwd(),
+      bindings: 'better_sqlite3.node',
+      try: [['module_root', 'dist', 'bindings'], ['module_root', 'bindings'], ['dist', 'bindings'], ['bindings']],
+      path: true
+    }) : null
+  });
+  db.function('new_uuid', () => {
+    return __WEBPACK_EXTERNAL_MODULE_uuid_v4__();
+  });
+  return db;
+}
+function format_sqlite_no_throw(log_kysely_db, query) {
+  const sql = typeof query === 'string' ? query : query.sql;
+  try {
+    return __WEBPACK_EXTERNAL_MODULE__foul11_sql_formatter_5d7ed540_format__(sql, {
+      language: 'sqlite',
+      tabWidth: 4,
+      indentStyle: 'tabularRight',
+      ...(typeof query !== 'string' && {
+        params: query.parameters
+      })
+    });
+  } catch (e) {
+    log_kysely_db.error(e);
+    return sql;
+  }
+}
+function create_kysely(db, log_kysely_db) {
+  const db_kysely = new __WEBPACK_EXTERNAL_MODULE_kysely_Kysely__({
+    dialect: new __WEBPACK_EXTERNAL_MODULE_kysely_SqliteDialect__({
+      database: db
+    }),
+    log: event => {
+      db_kysely.transaction_logs.push(event.query.sql);
+      if (log_kysely_db.isSillyEnabled()) {
+        if (!db_kysely.in_migration) {
+          log_kysely_db.silly(`\n${format_sqlite_no_throw(log_kysely_db, event.query)}\n`, {
+            runtime: event.queryDurationMillis
+          });
+        } else {
+          db_kysely.migration_log.push(format_sqlite_no_throw(log_kysely_db, event.query));
+        }
+      }
+      if (event.level === 'error') {
+        log_kysely_db.error(event.error, {
+          query: db_kysely.transaction_logs.length ? db_kysely.transaction_logs.map(sql => format_sqlite_no_throw(log_kysely_db, sql)).join('\n') : format_sqlite_no_throw(log_kysely_db, event.query),
+          runtime: event.queryDurationMillis
+        });
+      }
+      if (/commit|begin|rollback/.test(event.query.sql)) {
+        db_kysely.transaction_logs = [];
+      }
+    }
+  });
+  /**
+   * Nested transaction hack
+   * Catch execute method,
+   * replace arg in func to proxy transaction,
+   * method transaction() return this transaction
+   */
+  function proxy_transaction(trx) {
+    return new Proxy(trx, {
+      get(target, prop) {
+        if (prop === 'transaction') return () => ({
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+          execute: fn => fn.apply(target, [target])
+        });
+        if (typeof target[prop] == 'function') {
+          return target[prop].bind(target);
+        } else {
+          return target[prop];
+        }
+      }
+    });
+  }
+  const old_transaction = db_kysely.transaction;
+  db_kysely.transaction = function (...trx_args) {
+    const transaction = old_transaction.call(this, ...trx_args);
+    return new Proxy(transaction, {
+      get(target, prop) {
+        if (prop === 'execute')
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+          return fn => target.execute((trx, ...args) => fn.apply(target, [proxy_transaction(trx), ...args]));
+        if (typeof target[prop] == 'function') {
+          return target[prop].bind(target);
+        } else {
+          return target[prop];
+        }
+      }
+    });
+  };
+  return db_kysely;
+}
+async function create_migrator(db_name, db, log_kysely_db) {
+  db.in_migration = true;
+  db.migration_log = [];
+  db.transaction_logs = [];
+  const migrator = new __WEBPACK_EXTERNAL_MODULE_kysely_migration_c9f7ddf4_Migrator__({
+    db,
+    provider: new WebpackFileProvider(db_name)
+  });
+  async function migrateToLatest() {
+    const {
+      error,
+      results
+    } = await migrator.migrateToLatest();
+    for (const result of results ?? []) {
+      if (result.status === 'Success') {
+        log_kysely_db.info(`migration "${result.migrationName}" was executed successfully`);
+      } else if (result.status === 'Error') {
+        log_kysely_db.error(`failed to execute migration "${result.migrationName}"`);
+      }
+    }
+    if (error) {
+      if (!(error instanceof Error)) throw error;
+      log_kysely_db.error('failed to migrate');
+      log_kysely_db.error(error.stack);
+      if (log_kysely_db.isDebugEnabled()) {
+        log_kysely_db.debug(`\n${db.migration_log.join('\n-------------- NEXT MIGRATION SQL-request --------------\n')}\n`, {});
+        // eslint-disable-next-line no-debugger
+        debugger;
+      }
+      throw error;
+    }
+  }
+  log_kysely_db.debug('starting migration to latest');
+  await migrateToLatest();
+  log_kysely_db.debug('migration to latest completed');
+  db.in_migration = false;
+  db.migration_log = [];
+  return migrator;
+}
+async function create_db(db_path, log_kysely) {
+  const db_name = __WEBPACK_EXTERNAL_MODULE_path_default__.parse(db_path).name;
+  const db_sqlite = create_sqlite(db_path);
+  const db_log = log_kysely.child({
+    label5: db_name
+  });
+  const db = create_kysely(db_sqlite, db_log);
+  const db_migrator = await create_migrator(db_name, db, db_log);
+  return {
+    db: db,
+    db_migrator,
+    db_sqlite,
+    db_log
+  };
+}
+const SqliteError = __WEBPACK_EXTERNAL_MODULE_better_sqlite3_b46a9d6d_default__.SqliteError;
+export { ErrorDB, ErrorFlag, ErrorFlagInvalid, ErrorFlagPack, ErrorFlagUnpack, ErrorMigration, ErrorModule, ErrorQuery, ErrorSchema, ErrorUnknown, ORM, SQLParser, SQLiteDebugger, SqliteError, WebpackFileProvider, alter_column_add, alter_column_drop, alter_column_order, alter_column_rename, alter_column_update, create_db, currTimeDefault, get_table_schema, indexer, access_log as logger_access_log, db as logger_db, master_table, pragma_defer_foreign_keys, pragma_foreign_keys, sqlv, table_info };
+
+//# sourceMappingURL=index.mjs.map