@ignisia/sql 0.2.2 → 0.4.0

package/dist/cjs/table/index.d.cts

@@ -1,7 +1,8 @@
-export { T as Table } from '../index-CwiFQh0I.cjs';
+export { T as Table } from '../index-CHxuUiO4.cjs';
 import '../column/index.cjs';
 import './constants.cjs';
-import '../column/constants.cjs';
+import 'bun';
 import '../types.cjs';
 import '../query/constants.cjs';
+import '../column/constants.cjs';
 import '../column/types.cjs';

package/dist/cjs/table/index.js

@@ -5,22 +5,21 @@ var utilities = require('./utilities');
 
 class Table {
   client;
-  dialect;
+  _dialect;
   name;
   columns;
   timestamp;
   paranoid;
   _output;
   constructor(options) {
-    this.dialect = options.dialect;
+    this._dialect = options.dialect || null;
     this.name = options.name;
     this.columns = options.columns;
     this.paranoid = options.paranoid || null;
     this.timestamp = options.timestamp || null;
     this.client = null;
-    for (const column of Object.values(this.columns)) {
-      column.dialect(options.dialect);
-    }
+    if (!this._dialect) return;
+    this.setColumnDialect(this._dialect);
   }
   infer() {
     return null;
@@ -32,18 +31,39 @@ class Table {
       columns
     });
   }
-  async create(db = this.client) {
+  setColumnDialect(dialect) {
+    for (const column of Object.values(this.columns)) {
+      column.dialect(dialect);
+    }
+  }
+  get dialect() {
+    return this._dialect;
+  }
+  setDialect(dialect) {
+    this._dialect = dialect;
+    this.setColumnDialect(dialect);
+    return this;
+  }
+  async create(options = {}) {
+    const db = options.db || this.client;
     if (!db) throw new Error("Database client not defined");
     const sql = `CREATE TABLE IF NOT EXISTS ${this.name} (${Object.entries(
       this.columns
     ).map(([name, column]) => `${name} ${column.toQuery().query}`).join(", ")});`;
-    await db.exec(sql);
+    await db.exec({
+      sql,
+      tx: options.tx
+    });
     return this;
   }
-  async drop(db = this.client) {
+  async drop(options = {}) {
+    const db = options.db || this.client;
     if (!db) throw new Error("Database client not defined");
     const sql = `DROP TABLE IF EXISTS ${this.name};`;
-    await db.exec(sql);
+    await db.exec({
+      sql,
+      tx: options.tx
+    });
     return this;
   }
   query() {

package/dist/cjs/table/types.d.cts

@@ -1,7 +1,8 @@
-export { M as MergeTimestampParanoid, s as TableOptions, t as TableOutput, a as TimestampOptions } from '../index-CwiFQh0I.cjs';
+import 'bun';
+export { X as ExecOptions, M as MergeTimestampParanoid, U as TableOptions, V as TableOutput, f as TimestampOptions } from '../index-CHxuUiO4.cjs';
 import '../column/index.cjs';
 import './constants.cjs';
-import '../column/constants.cjs';
 import '../types.cjs';
 import '../query/constants.cjs';
+import '../column/constants.cjs';
 import '../column/types.cjs';

package/dist/cjs/table/utilities.d.cts

@@ -1,7 +1,8 @@
 import '../column/constants.cjs';
 import '../column/index.cjs';
 import './constants.cjs';
-export { p as createdAt, r as defineColumns, q as deletedAt, u as updatedAt } from '../index-CwiFQh0I.cjs';
+export { K as createdAt, O as defineColumns, N as deletedAt, L as updatedAt } from '../index-CHxuUiO4.cjs';
 import '../column/types.cjs';
+import 'bun';
 import '../types.cjs';
 import '../query/constants.cjs';

package/dist/cjs/types.d.cts

@@ -1,3 +1,7 @@
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type BuildTuple<N extends number, T extends unknown[] = []> = T['length'] extends N ? T : BuildTuple<N, [...T, unknown]>;
+type Add<A extends number, B extends number, Result extends unknown[] = [...BuildTuple<A>, ...BuildTuple<B>]> = Result['length'] extends number ? Result['length'] : never;
+type Subtract<A extends number, B extends number> = BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest] ? Rest['length'] : never;
+type Multiply<A extends number, B extends number, Result extends unknown[] = []> = B extends 0 ? Result['length'] : Multiply<A, Subtract<B, 1>, [...Result, ...BuildTuple<A>]>;
 
-export type { UnionToIntersection };
+export type { Add, BuildTuple, Multiply, Subtract, UnionToIntersection };

package/dist/cjs/utilities.d.cts

@@ -1,4 +1,5 @@
 declare function deepClone<T>(obj: T): T;
+declare function cloneDefinition<T extends Record<string, unknown>>(def: T): T;
 declare function quoteIdentifier<T extends string, U extends `"${T}"`>(identifier: T): U;
 
-export { deepClone, quoteIdentifier };
+export { cloneDefinition, deepClone, quoteIdentifier };

package/dist/cjs/utilities.js

@@ -13,9 +13,31 @@ function deepClone(obj) {
   }
   return obj;
 }
+function cloneArray(arr) {
+  if (arr.length === 0) return [];
+  if (typeof arr[0] === "object" && arr[0] !== null) {
+    return arr.map((item) => ({ ...item }));
+  }
+  return arr.slice();
+}
+function cloneDefinition(def) {
+  const clone = {};
+  for (const key in def) {
+    const val = def[key];
+    if (val === null || typeof val !== "object") {
+      clone[key] = val;
+    } else if (Array.isArray(val)) {
+      clone[key] = cloneArray(val);
+    } else {
+      clone[key] = { ...val };
+    }
+  }
+  return clone;
+}
 function quoteIdentifier(identifier) {
   return `"${identifier.replace(/"/g, '""')}"`;
 }
 
+exports.cloneDefinition = cloneDefinition;
 exports.deepClone = deepClone;
 exports.quoteIdentifier = quoteIdentifier;

package/dist/esm/column/constants.d.ts

@@ -23,75 +23,128 @@ declare const ColumnTypeMapping: {
     readonly INTEGER: {
         readonly sqlite: "INTEGER";
         readonly postgres: "INTEGER";
+        readonly mysql: "INT";
     };
     readonly STRING: {
         readonly sqlite: "TEXT";
         readonly postgres: "VARCHAR";
+        readonly mysql: "VARCHAR";
     };
     readonly BOOLEAN: {
         readonly sqlite: "INTEGER";
         readonly postgres: "BOOLEAN";
+        readonly mysql: "TINYINT";
     };
     readonly DATE: {
         readonly sqlite: "TEXT";
         readonly postgres: "DATE";
+        readonly mysql: "DATE";
     };
     readonly FLOAT: {
         readonly sqlite: "REAL";
         readonly postgres: "FLOAT";
+        readonly mysql: "FLOAT PRECISION";
     };
     readonly DECIMAL: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "NUMERIC";
         readonly postgres: "DECIMAL";
+        readonly mysql: "DECIMAL";
     };
     readonly BIGINT: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "INTEGER";
         readonly postgres: "BIGINT";
+        readonly mysql: "BIGINT";
     };
     readonly TEXT: {
         readonly sqlite: "TEXT";
         readonly postgres: "TEXT";
+        readonly mysql: "TEXT";
     };
     readonly BLOB: {
         readonly sqlite: "BLOB";
         readonly postgres: "BYTEA";
+        readonly mysql: "BLOB";
     };
     readonly JSON: {
         readonly sqlite: "TEXT";
         readonly postgres: "JSONB";
+        readonly mysql: "JSON";
     };
     readonly VARCHAR: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "VARCHAR";
         readonly postgres: "VARCHAR";
+        readonly mysql: "VARCHAR";
     };
     readonly TIME: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIME";
+        readonly mysql: "TIME";
     };
     readonly TIMESTAMP: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIMESTAMP";
+        readonly mysql: "DATETIME";
     };
     readonly DOUBLE: {
         readonly sqlite: "REAL";
         readonly postgres: "DOUBLE PRECISION";
+        readonly mysql: "DOUBLE PRECISION";
     };
     readonly DATETIME: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIMESTAMP";
+        readonly mysql: "DATETIME";
     };
     readonly DATEONLY: {
         readonly sqlite: "TEXT";
         readonly postgres: "DATE";
+        readonly mysql: "DATE";
     };
     readonly ENUM: {
         readonly sqlite: "TEXT";
         readonly postgres: "TEXT";
+        readonly mysql: "TEXT";
     };
     readonly SERIAL: {
-        readonly sqlite: "INTEGER AUTOINCREMENT";
+        readonly sqlite: "INTEGER";
         readonly postgres: "SERIAL";
+        readonly mysql: "INT";
+    };
+};
+declare const ColumnProperties: {
+    readonly NOT_NULL: "NOT_NULL";
+    readonly UNIQUE: "UNIQUE";
+    readonly DEFAULT: "DEFAULT";
+    readonly AUTO_INCREMENT: "AUTO_INCREMENT";
+    readonly PRIMARY_KEY: "PRIMARY_KEY";
+};
+type ColumnProperties = (typeof ColumnProperties)[keyof typeof ColumnProperties];
+declare const ColumnPropertyMapping: {
+    NOT_NULL: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    UNIQUE: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    DEFAULT: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    AUTO_INCREMENT: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    PRIMARY_KEY: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
     };
 };
 
-export { AcceptedColumnTypes, ColumnTypeMapping };
+export { AcceptedColumnTypes, ColumnProperties, ColumnPropertyMapping, ColumnTypeMapping };

package/dist/esm/column/constants.js

@@ -24,76 +24,131 @@ var AcceptedColumnTypes = {
 var ColumnTypeMapping = {
   [AcceptedColumnTypes.INTEGER]: {
     [Dialect.SQLITE]: "INTEGER",
-    [Dialect.POSTGRES]: "INTEGER"
+    [Dialect.POSTGRES]: "INTEGER",
+    [Dialect.MYSQL]: "INT"
   },
   [AcceptedColumnTypes.STRING]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "VARCHAR"
+    [Dialect.POSTGRES]: "VARCHAR",
+    [Dialect.MYSQL]: "VARCHAR"
   },
   [AcceptedColumnTypes.BOOLEAN]: {
     [Dialect.SQLITE]: "INTEGER",
-    [Dialect.POSTGRES]: "BOOLEAN"
+    [Dialect.POSTGRES]: "BOOLEAN",
+    [Dialect.MYSQL]: "TINYINT"
   },
   [AcceptedColumnTypes.DATE]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "DATE"
+    [Dialect.POSTGRES]: "DATE",
+    [Dialect.MYSQL]: "DATE"
   },
   [AcceptedColumnTypes.FLOAT]: {
     [Dialect.SQLITE]: "REAL",
-    [Dialect.POSTGRES]: "FLOAT"
+    [Dialect.POSTGRES]: "FLOAT",
+    [Dialect.MYSQL]: "FLOAT PRECISION"
   },
   [AcceptedColumnTypes.DECIMAL]: {
-    [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "DECIMAL"
+    [Dialect.SQLITE]: "NUMERIC",
+    [Dialect.POSTGRES]: "DECIMAL",
+    [Dialect.MYSQL]: "DECIMAL"
   },
   [AcceptedColumnTypes.BIGINT]: {
-    [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "BIGINT"
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "BIGINT",
+    [Dialect.MYSQL]: "BIGINT"
   },
   [AcceptedColumnTypes.TEXT]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TEXT"
+    [Dialect.POSTGRES]: "TEXT",
+    [Dialect.MYSQL]: "TEXT"
   },
   [AcceptedColumnTypes.BLOB]: {
     [Dialect.SQLITE]: "BLOB",
-    [Dialect.POSTGRES]: "BYTEA"
+    [Dialect.POSTGRES]: "BYTEA",
+    [Dialect.MYSQL]: "BLOB"
   },
   [AcceptedColumnTypes.JSON]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "JSONB"
+    [Dialect.POSTGRES]: "JSONB",
+    [Dialect.MYSQL]: "JSON"
   },
   [AcceptedColumnTypes.VARCHAR]: {
-    [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "VARCHAR"
+    [Dialect.SQLITE]: "VARCHAR",
+    [Dialect.POSTGRES]: "VARCHAR",
+    [Dialect.MYSQL]: "VARCHAR"
   },
   [AcceptedColumnTypes.TIME]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TIME"
+    [Dialect.POSTGRES]: "TIME",
+    [Dialect.MYSQL]: "TIME"
   },
   [AcceptedColumnTypes.TIMESTAMP]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TIMESTAMP"
+    [Dialect.POSTGRES]: "TIMESTAMP",
+    [Dialect.MYSQL]: "DATETIME"
   },
   [AcceptedColumnTypes.DOUBLE]: {
     [Dialect.SQLITE]: "REAL",
-    [Dialect.POSTGRES]: "DOUBLE PRECISION"
+    [Dialect.POSTGRES]: "DOUBLE PRECISION",
+    [Dialect.MYSQL]: "DOUBLE PRECISION"
   },
   [AcceptedColumnTypes.DATETIME]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TIMESTAMP"
+    [Dialect.POSTGRES]: "TIMESTAMP",
+    [Dialect.MYSQL]: "DATETIME"
   },
   [AcceptedColumnTypes.DATEONLY]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "DATE"
+    [Dialect.POSTGRES]: "DATE",
+    [Dialect.MYSQL]: "DATE"
   },
   [AcceptedColumnTypes.ENUM]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TEXT"
+    [Dialect.POSTGRES]: "TEXT",
+    [Dialect.MYSQL]: "TEXT"
   },
   [AcceptedColumnTypes.SERIAL]: {
-    [Dialect.SQLITE]: "INTEGER AUTOINCREMENT",
-    [Dialect.POSTGRES]: "SERIAL"
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "SERIAL",
+    [Dialect.MYSQL]: "INT"
+  }
+};
+var ColumnProperties = {
+  NOT_NULL: "NOT_NULL",
+  UNIQUE: "UNIQUE",
+  DEFAULT: "DEFAULT",
+  AUTO_INCREMENT: "AUTO_INCREMENT",
+  PRIMARY_KEY: "PRIMARY_KEY"
+};
+var ColumnPropertyMapping = {
+  [ColumnProperties.NOT_NULL]: {
+    [Dialect.SQLITE]: "NOT NULL",
+    [Dialect.POSTGRES]: "NOT NULL",
+    [Dialect.MYSQL]: "NOT NULL"
+  },
+  [ColumnProperties.UNIQUE]: {
+    [Dialect.SQLITE]: "UNIQUE",
+    [Dialect.POSTGRES]: "UNIQUE",
+    [Dialect.MYSQL]: "UNIQUE"
+  },
+  [ColumnProperties.DEFAULT]: {
+    [Dialect.SQLITE]: "DEFAULT",
+    [Dialect.POSTGRES]: "DEFAULT",
+    [Dialect.MYSQL]: "DEFAULT"
+  },
+  [ColumnProperties.AUTO_INCREMENT]: {
+    // sqlite does not support AUTOINCREMENT
+    [Dialect.SQLITE]: "AUTOINCREMENT",
+    // postgres does not support AUTOINCREMENT
+    [Dialect.POSTGRES]: "AUTOINCREMENT",
+    // Exists only for mysql since mysql supports AUTOINCREMENT
+    [Dialect.MYSQL]: "AUTO_INCREMENT"
+  },
+  [ColumnProperties.PRIMARY_KEY]: {
+    [Dialect.SQLITE]: "PRIMARY KEY",
+    [Dialect.POSTGRES]: "PRIMARY KEY",
+    [Dialect.MYSQL]: "PRIMARY KEY"
   }
 };
 
-export { AcceptedColumnTypes, ColumnTypeMapping };
+export { AcceptedColumnTypes, ColumnProperties, ColumnPropertyMapping, ColumnTypeMapping };

package/dist/esm/column/index.d.ts

@@ -31,6 +31,7 @@ declare class Column<Type extends AcceptedColumnTypes = AcceptedColumnTypes, Val
     dialect<DbDialect extends Dialect>(dialect: DbDialect): Column<Type, Values, Options, ColumnValue, Value, Definition & {
         dialect: DbDialect;
     }>;
+    clone(): Column<Type, Values, Options, ColumnValue, Value, {}>;
     toQuery(): {
         query: string;
         params: never[];

package/dist/esm/column/index.js

@@ -1,5 +1,7 @@
 import { Dialect } from '../table/constants.js';
+import { cloneDefinition } from '../utilities.js';
 import { ColumnTypeMapping, AcceptedColumnTypes } from './constants.js';
+import { columnProperty } from './utils.js';
 
 // src/column/index.ts
 var Column = class _Column {
@@ -18,14 +20,7 @@ var Column = class _Column {
     if ("values" in options) {
       this.enums = options.values;
     }
-    this.definition = {
-      autoIncrement: false,
-      primaryKey: false,
-      notNull: false,
-      unique: false,
-      comment: null,
-      default: void 0
-    };
+    this.definition = {};
   }
   static define(options) {
     return new _Column(options);
@@ -58,40 +53,58 @@ var Column = class _Column {
     this.definition.dialect = dialect;
     return this;
   }
+  clone() {
+    const column = new _Column({
+      type: this.type,
+      ...this.length && { length: this.length },
+      ...this.enums.length && { values: this.enums }
+    });
+    Object.assign(column.definition, cloneDefinition(this.definition));
+    return column;
+  }
   toQuery() {
     if (!this.definition.dialect) {
       throw new Error("No DB Dialect defined");
     }
-    const correctType = ColumnTypeMapping[this.type][this.definition.dialect];
-    let sql = correctType + (this.length ? `(${this.length})` : "");
+    const type = ColumnTypeMapping[this.type][this.definition.dialect];
+    const properties = columnProperty(this.definition.dialect);
+    let sql = type + (this.length ? `(${this.length})` : "");
     if (this.definition.primaryKey) {
-      sql += " PRIMARY KEY";
+      sql += ` ${properties.PRIMARY_KEY}`;
     }
     if (this.definition.autoIncrement || this.type === AcceptedColumnTypes.SERIAL) {
       const isPrimaryKey = !!this.definition.primaryKey;
+      const sqls = [];
       if (this.definition.dialect === Dialect.POSTGRES) {
-        sql = `SERIAL${isPrimaryKey ? " PRIMARY KEY" : ""}`;
+        sqls.push(type);
+        if (isPrimaryKey) {
+          sqls.push(properties.PRIMARY_KEY);
+        }
+        sql = sqls.join(" ");
       } else {
         if (this.type !== AcceptedColumnTypes.SERIAL) {
-          sql += " AUTOINCREMENT";
+          sql += ` ${properties.AUTO_INCREMENT}`;
         } else {
-          const sqls = ["INTEGER", "PRIMARY KEY", "AUTOINCREMENT"];
-          if (!isPrimaryKey) sqls.splice(1, 1);
+          sqls.push(type);
+          if (isPrimaryKey) {
+            sqls.push(properties.PRIMARY_KEY);
+          }
+          sqls.push(properties.AUTO_INCREMENT);
           sql = sqls.join(" ");
         }
       }
     }
     if (this.definition.notNull) {
-      sql += " NOT NULL";
+      sql += ` ${properties.NOT_NULL}`;
     }
     if (this.definition.unique) {
-      sql += " UNIQUE";
+      sql += ` ${properties.UNIQUE}`;
     }
     if (this.definition.default !== void 0) {
       const value = this.definition.default;
       const isString = typeof this.definition.default === "string";
       const finalValue = isString ? `'${value}'` : value;
-      sql += ` DEFAULT ${finalValue}`;
+      sql += ` ${properties.DEFAULT} ${finalValue}`;
     }
     return { query: sql, params: [] };
   }

package/dist/esm/column/utils.d.ts

@@ -0,0 +1,133 @@
+import { Dialect } from '../table/constants.js';
+import { ColumnProperties } from './constants.js';
+
+declare function getColumnProperty<DbDialect extends Dialect>(dialect: DbDialect, property: ColumnProperties): ({
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+})[DbDialect];
+declare function columnProperty<DbDialect extends Dialect>(dialect: DbDialect): {
+    NOT_NULL: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    UNIQUE: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    DEFAULT: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    AUTO_INCREMENT: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    PRIMARY_KEY: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+};
+
+export { columnProperty, getColumnProperty };