@ignisia/sql 0.2.1 → 0.3.0

package/dist/cjs/column/constants.d.cts

@@ -0,0 +1,150 @@
+declare const AcceptedColumnTypes: {
+    readonly INTEGER: "INTEGER";
+    readonly STRING: "STRING";
+    readonly BOOLEAN: "BOOLEAN";
+    readonly DATE: "DATE";
+    readonly FLOAT: "FLOAT";
+    readonly DECIMAL: "DECIMAL";
+    readonly BIGINT: "BIGINT";
+    readonly TEXT: "TEXT";
+    readonly BLOB: "BLOB";
+    readonly JSON: "JSON";
+    readonly VARCHAR: "VARCHAR";
+    readonly TIME: "TIME";
+    readonly TIMESTAMP: "TIMESTAMP";
+    readonly DOUBLE: "DOUBLE";
+    readonly DATETIME: "DATETIME";
+    readonly DATEONLY: "DATEONLY";
+    readonly ENUM: "ENUM";
+    readonly SERIAL: "SERIAL";
+};
+type AcceptedColumnTypes = (typeof AcceptedColumnTypes)[keyof typeof AcceptedColumnTypes];
+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: "NUMERIC";
+        readonly postgres: "DECIMAL";
+        readonly mysql: "DECIMAL";
+    };
+    readonly BIGINT: {
+        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: "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";
+        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, ColumnProperties, ColumnPropertyMapping, ColumnTypeMapping };

package/dist/cjs/column/constants.js

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

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

@@ -0,0 +1,43 @@
+import { Dialect } from '../table/constants.cjs';
+import { AcceptedColumnTypes } from './constants.cjs';
+import { ColumnOptions, AcceptedColumnTypeMap, EnumOptions, ColumnDefinition, ValueSelector } from './types.cjs';
+
+declare class Column<Type extends AcceptedColumnTypes = AcceptedColumnTypes, Values extends number | readonly string[] = Type extends typeof AcceptedColumnTypes.ENUM ? readonly string[] : number, Options extends ColumnOptions<Type, Values> = ColumnOptions<Type, Values>, ColumnValue extends AcceptedColumnTypeMap[Options['type']] = AcceptedColumnTypeMap[Options['type']], Value extends Options extends EnumOptions<infer Value> ? Value[number] : ColumnValue = ColumnValue, Definition extends Partial<ColumnDefinition<Value, Dialect>> = NonNullable<unknown>> {
+    readonly definition: Definition;
+    readonly type: Options['type'];
+    readonly length: number | null;
+    readonly enums: readonly Value[];
+    readonly _output: ValueSelector<Definition, Value>;
+    protected constructor(options: Options);
+    static define<Type extends AcceptedColumnTypes = AcceptedColumnTypes, Values extends number | readonly string[] = number | readonly string[], Options extends ColumnOptions<Type, Values> = ColumnOptions<Type, Values>>(options: Options): Column<AcceptedColumnTypes, number | readonly string[], Options, AcceptedColumnTypeMap[Options["type"]], Options extends EnumOptions<infer Value extends readonly string[]> ? Value[number] : AcceptedColumnTypeMap[Options["type"]], {}>;
+    autoIncrement(): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        autoIncrement: true;
+    }>;
+    primaryKey(): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        primaryKey: true;
+    }>;
+    notNull(): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        notNull: true;
+    }>;
+    unique(): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        unique: true;
+    }>;
+    comment<Comment extends string | null>(value: Comment): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        comment: Comment;
+    }>;
+    default<FinalValue extends ValueSelector<Definition, Value>>(value: FinalValue): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        default: FinalValue;
+    }>;
+    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[];
+    };
+    toString(): string;
+    infer(): this['_output'];
+}
+
+export { Column };

package/dist/cjs/column/index.js

@@ -0,0 +1,127 @@
+'use strict';
+
+var constants$1 = require('../table/constants');
+var utilities = require('../utilities');
+var constants = require('./constants');
+var utils = require('./utils');
+
+class Column {
+  definition;
+  type;
+  length;
+  enums;
+  _output;
+  constructor(options) {
+    this.type = options.type;
+    this.enums = [];
+    this.length = null;
+    if ("length" in options) {
+      this.length = options.length;
+    }
+    if ("values" in options) {
+      this.enums = options.values;
+    }
+    this.definition = {
+      autoIncrement: false,
+      primaryKey: false,
+      notNull: false,
+      unique: false,
+      comment: null,
+      default: void 0
+    };
+  }
+  static define(options) {
+    return new Column(options);
+  }
+  autoIncrement() {
+    this.definition.autoIncrement = true;
+    return this;
+  }
+  primaryKey() {
+    this.definition.primaryKey = true;
+    return this;
+  }
+  notNull() {
+    this.definition.notNull = true;
+    return this;
+  }
+  unique() {
+    this.definition.unique = true;
+    return this;
+  }
+  comment(value) {
+    this.definition.comment = value;
+    return this;
+  }
+  default(value) {
+    this.definition.default = value;
+    return this;
+  }
+  dialect(dialect) {
+    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, utilities.deepClone(this.definition));
+    return column;
+  }
+  toQuery() {
+    if (!this.definition.dialect) {
+      throw new Error("No DB Dialect defined");
+    }
+    const type = constants.ColumnTypeMapping[this.type][this.definition.dialect];
+    const properties = utils.columnProperty(this.definition.dialect);
+    let sql = type + (this.length ? `(${this.length})` : "");
+    if (this.definition.primaryKey) {
+      sql += ` ${properties.PRIMARY_KEY}`;
+    }
+    if (this.definition.autoIncrement || this.type === constants.AcceptedColumnTypes.SERIAL) {
+      const isPrimaryKey = !!this.definition.primaryKey;
+      const sqls = [];
+      if (this.definition.dialect === constants$1.Dialect.POSTGRES) {
+        sqls.push(type);
+        if (isPrimaryKey) {
+          sqls.push(properties.PRIMARY_KEY);
+        }
+        sql = sqls.join(" ");
+      } else {
+        if (this.type !== constants.AcceptedColumnTypes.SERIAL) {
+          sql += ` ${properties.AUTO_INCREMENT}`;
+        } else {
+          sqls.push(type);
+          if (isPrimaryKey) {
+            sqls.push(properties.PRIMARY_KEY);
+          }
+          sqls.push(properties.AUTO_INCREMENT);
+          sql = sqls.join(" ");
+        }
+      }
+    }
+    if (this.definition.notNull) {
+      sql += ` ${properties.NOT_NULL}`;
+    }
+    if (this.definition.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 += ` ${properties.DEFAULT} ${finalValue}`;
+    }
+    return { query: sql, params: [] };
+  }
+  toString() {
+    return this.toQuery().query;
+  }
+  infer() {
+    return null;
+  }
+}
+
+exports.Column = Column;

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

@@ -0,0 +1,43 @@
+import { Dialect } from '../table/constants.cjs';
+import { AcceptedColumnTypes } from './constants.cjs';
+
+interface ColumnDefinition<T, U extends Dialect | null = null> {
+    primaryKey: boolean;
+    autoIncrement: boolean;
+    notNull: boolean;
+    unique: boolean;
+    comment: string | null;
+    default: T | undefined;
+    dialect: U | null;
+}
+type ValueSelector<Definition extends Partial<ColumnDefinition<Value, Dialect>> | ColumnDefinition<Value, Dialect>, Value> = Definition['notNull'] extends true ? Value | (string & {}) : Value | (string & {}) | null;
+type AcceptedColumnTypeMap<T = any> = {
+    [K in AcceptedColumnTypes]: K extends typeof AcceptedColumnTypes.INTEGER | typeof AcceptedColumnTypes.BIGINT | typeof AcceptedColumnTypes.FLOAT | typeof AcceptedColumnTypes.DOUBLE | typeof AcceptedColumnTypes.DECIMAL | typeof AcceptedColumnTypes.SERIAL ? number : K extends typeof AcceptedColumnTypes.STRING | typeof AcceptedColumnTypes.TEXT | typeof AcceptedColumnTypes.VARCHAR ? string : K extends typeof AcceptedColumnTypes.BOOLEAN ? boolean : K extends typeof AcceptedColumnTypes.DATE | typeof AcceptedColumnTypes.TIME | typeof AcceptedColumnTypes.TIMESTAMP | typeof AcceptedColumnTypes.DATETIME | typeof AcceptedColumnTypes.DATEONLY ? Date : K extends typeof AcceptedColumnTypes.JSON ? object : K extends typeof AcceptedColumnTypes.BLOB ? Buffer : K extends typeof AcceptedColumnTypes.ENUM ? T[number][] : never;
+};
+type DateOptions = {
+    type: typeof AcceptedColumnTypes.DATE | typeof AcceptedColumnTypes.TIME | typeof AcceptedColumnTypes.TIMESTAMP | typeof AcceptedColumnTypes.DATETIME | typeof AcceptedColumnTypes.DATEONLY;
+};
+type NumberOptions<Length extends number = number> = {
+    type: typeof AcceptedColumnTypes.INTEGER | typeof AcceptedColumnTypes.BIGINT | typeof AcceptedColumnTypes.FLOAT | typeof AcceptedColumnTypes.DECIMAL | typeof AcceptedColumnTypes.DOUBLE | typeof AcceptedColumnTypes.SERIAL;
+    length?: Length;
+};
+type StringOptions<Length extends number = number> = {
+    type: typeof AcceptedColumnTypes.STRING | typeof AcceptedColumnTypes.VARCHAR | typeof AcceptedColumnTypes.TEXT;
+    length?: Length;
+};
+type EnumOptions<Values extends readonly string[]> = {
+    type: typeof AcceptedColumnTypes.ENUM;
+    values: Values;
+};
+type BooleanOptions = {
+    type: typeof AcceptedColumnTypes.BOOLEAN;
+};
+type JsonOptions = {
+    type: typeof AcceptedColumnTypes.JSON;
+};
+type BlobOptions = {
+    type: typeof AcceptedColumnTypes.BLOB;
+};
+type ColumnOptions<Type extends AcceptedColumnTypes, U extends number | readonly string[]> = Type extends typeof AcceptedColumnTypes.BLOB ? BlobOptions : Type extends typeof AcceptedColumnTypes.JSON ? JsonOptions : Type extends typeof AcceptedColumnTypes.BOOLEAN ? BooleanOptions : Type extends typeof AcceptedColumnTypes.DATE | typeof AcceptedColumnTypes.TIME | typeof AcceptedColumnTypes.TIMESTAMP | typeof AcceptedColumnTypes.DATETIME | typeof AcceptedColumnTypes.DATEONLY ? DateOptions : Type extends typeof AcceptedColumnTypes.STRING | typeof AcceptedColumnTypes.VARCHAR | typeof AcceptedColumnTypes.TEXT ? U extends number ? StringOptions<U> : StringOptions : Type extends typeof AcceptedColumnTypes.INTEGER | typeof AcceptedColumnTypes.BIGINT | typeof AcceptedColumnTypes.FLOAT | typeof AcceptedColumnTypes.DECIMAL | typeof AcceptedColumnTypes.DOUBLE | typeof AcceptedColumnTypes.SERIAL ? U extends number ? NumberOptions<U> : NumberOptions : Type extends typeof AcceptedColumnTypes.ENUM ? U extends readonly string[] ? EnumOptions<U> : never : never;
+
+export type { AcceptedColumnTypeMap, BlobOptions, BooleanOptions, ColumnDefinition, ColumnOptions, DateOptions, EnumOptions, JsonOptions, NumberOptions, StringOptions, ValueSelector };

package/dist/cjs/column/types.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./constants');
+

package/dist/cjs/column/utils.d.cts

@@ -0,0 +1,133 @@
+import { Dialect } from '../table/constants.cjs';
+import { ColumnProperties } from './constants.cjs';
+
+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 };

package/dist/cjs/column/utils.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var constants = require('./constants');
+
+function getColumnProperty(dialect, property) {
+  return constants.ColumnPropertyMapping[property][dialect];
+}
+function columnProperty(dialect) {
+  return {
+    [constants.ColumnProperties.NOT_NULL]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.NOT_NULL
+    ),
+    [constants.ColumnProperties.UNIQUE]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.UNIQUE
+    ),
+    [constants.ColumnProperties.DEFAULT]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.DEFAULT
+    ),
+    [constants.ColumnProperties.AUTO_INCREMENT]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.AUTO_INCREMENT
+    ),
+    [constants.ColumnProperties.PRIMARY_KEY]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.PRIMARY_KEY
+    )
+  };
+}
+
+exports.columnProperty = columnProperty;
+exports.getColumnProperty = getColumnProperty;