apeframework 0.0.0-dev.1

package/db/config/mysql.ts

@@ -0,0 +1,58 @@
+import fs from 'fs-extra'
+import { getConfig } from '../../config'
+import type { Database } from '../database'
+
+const dbConfig: () => Database.Config = () => {
+  const config = getConfig()
+
+  if (!config.dbMysqlHost) throw new Error('db: mysql host not provided')
+  if (!config.dbMysqlPort) throw new Error('db: mysql port not provided')
+  if (!config.dbMysqlDatabase) throw new Error('db: mysql database not provided')
+
+  let typeCastValue: any
+
+  const typeCast = (field: any, next: any) => {
+    switch (field.type) {
+      case 'BIT':
+        typeCastValue = field.buffer()
+        return typeCastValue === null ? null : !!typeCastValue[0]
+      case 'NEWDECIMAL':
+        typeCastValue = field.string()
+        return typeCastValue === null ? null : parseFloat(typeCastValue)
+      default:
+        return next()
+    }
+  }
+
+  return {
+    client: 'mysql2',
+    connection: {
+      host: config.dbMysqlHost,
+      port: config.dbMysqlPort,
+      ...config.dbMysqlUser ? { user: config.dbMysqlUser } : {},
+      ...config.dbMysqlPassword ? { password: config.dbMysqlPassword } : {},
+      database: config.dbMysqlDatabase,
+      ...config.dbMysqlSsl
+        ? {
+          ssl: {
+            ...config.dbMysqlSslCa
+              ? { ca: fs.readFileSync(config.dbMysqlSslCa).toString() }
+              : {},
+            ...config.dbMysqlSslCert
+              ? { cert: fs.readFileSync(config.dbMysqlSslCert).toString() }
+              : {},
+            ...config.dbMysqlSslKey
+              ? { key: fs.readFileSync(config.dbMysqlSslKey).toString() }
+              : {},
+            rejectUnauthorized: config.dbMysqlSslVerify,
+          },
+        }
+        : {},
+      dateStrings: true,
+      typeCast,
+    },
+    pool: { min: 0, max: config.dbMysqlPoolMax },
+  }
+}
+
+export default dbConfig

package/db/config/postgres.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from '../database';
+declare const dbConfig: () => Database.Config;
+export default dbConfig;

package/db/config/postgres.js

@@ -0,0 +1,59 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_extra_1 = __importDefault(require("fs-extra"));
+var pg_1 = require("pg");
+var config_1 = require("../../config");
+var dbConfig = function () {
+    var config = (0, config_1.getConfig)();
+    if (!config.dbPostgresHost)
+        throw new Error('db: postgres host not provided');
+    if (!config.dbPostgresPort)
+        throw new Error('db: postgres port not provided');
+    if (!config.dbPostgresDatabase)
+        throw new Error('db: postgres database not provided');
+    var timeRegex = /^(.{8})(\..{0,3})?/;
+    var timestampRegex = /^(.{19})(\..{0,3})?/;
+    var timeMatch;
+    var timeParser = function (regex) { return function (value) {
+        timeMatch = value.match(regex);
+        return timeMatch
+            ? "".concat(timeMatch[1]).concat(timeMatch[2] ? timeMatch[2].padEnd(4, '0') : '.000')
+            : value;
+    }; };
+    pg_1.types.setTypeParser(pg_1.types.builtins.BPCHAR, function (value) { return value.trimEnd(); });
+    pg_1.types.setTypeParser(pg_1.types.builtins.DATE, function (value) { return value; });
+    pg_1.types.setTypeParser(pg_1.types.builtins.INT8, function (value) { return parseInt(value, 10); });
+    pg_1.types.setTypeParser(pg_1.types.builtins.NUMERIC, function (value) { return parseFloat(value); });
+    pg_1.types.setTypeParser(pg_1.types.builtins.TIME, timeParser(timeRegex));
+    pg_1.types.setTypeParser(pg_1.types.builtins.TIMESTAMP, timeParser(timestampRegex));
+    return {
+        client: 'pg',
+        connection: __assign(__assign(__assign(__assign({ host: config.dbPostgresHost, port: config.dbPostgresPort }, config.dbPostgresUser ? { user: config.dbPostgresUser } : {}), config.dbPostgresPassword ? { password: config.dbPostgresPassword } : {}), { database: config.dbPostgresDatabase }), config.dbPostgresSsl
+            ? {
+                ssl: __assign(__assign(__assign(__assign({}, config.dbPostgresSslCa
+                    ? { ca: fs_extra_1.default.readFileSync(config.dbPostgresSslCa).toString() }
+                    : {}), config.dbPostgresSslCert
+                    ? { cert: fs_extra_1.default.readFileSync(config.dbPostgresSslCert).toString() }
+                    : {}), config.dbPostgresSslKey
+                    ? { key: fs_extra_1.default.readFileSync(config.dbPostgresSslKey).toString() }
+                    : {}), { rejectUnauthorized: config.dbPostgresSslVerify }),
+            }
+            : {}),
+        pool: { min: 0, max: config.dbPostgresPoolMax },
+    };
+};
+exports.default = dbConfig;

package/db/config/postgres.ts

@@ -0,0 +1,61 @@
+import fs from 'fs-extra'
+import { types } from 'pg'
+import { getConfig } from '../../config'
+import type { Database } from '../database'
+
+const dbConfig: () => Database.Config = () => {
+  const config = getConfig()
+
+  if (!config.dbPostgresHost) throw new Error('db: postgres host not provided')
+  if (!config.dbPostgresPort) throw new Error('db: postgres port not provided')
+  if (!config.dbPostgresDatabase) throw new Error('db: postgres database not provided')
+
+  const timeRegex = /^(.{8})(\..{0,3})?/
+  const timestampRegex = /^(.{19})(\..{0,3})?/
+
+  let timeMatch: any
+
+  const timeParser = (regex: RegExp) => (value: string) => {
+    timeMatch = value.match(regex)
+    return timeMatch
+      ? `${timeMatch[1]}${timeMatch[2] ? timeMatch[2].padEnd(4, '0') : '.000'}`
+      : value
+  }
+
+  types.setTypeParser(types.builtins.BPCHAR, (value: string) => value.trimEnd())
+  types.setTypeParser(types.builtins.DATE, (value: string) => value)
+  types.setTypeParser(types.builtins.INT8, (value: string) => parseInt(value, 10))
+  types.setTypeParser(types.builtins.NUMERIC, (value: string) => parseFloat(value))
+  types.setTypeParser(types.builtins.TIME, timeParser(timeRegex))
+  types.setTypeParser(types.builtins.TIMESTAMP, timeParser(timestampRegex))
+
+  return {
+    client: 'pg',
+    connection: {
+      host: config.dbPostgresHost,
+      port: config.dbPostgresPort,
+      ...config.dbPostgresUser ? { user: config.dbPostgresUser } : {},
+      ...config.dbPostgresPassword ? { password: config.dbPostgresPassword } : {},
+      database: config.dbPostgresDatabase,
+      ...config.dbPostgresSsl
+        ? {
+          ssl: {
+            ...config.dbPostgresSslCa
+              ? { ca: fs.readFileSync(config.dbPostgresSslCa).toString() }
+              : {},
+            ...config.dbPostgresSslCert
+              ? { cert: fs.readFileSync(config.dbPostgresSslCert).toString() }
+              : {},
+            ...config.dbPostgresSslKey
+              ? { key: fs.readFileSync(config.dbPostgresSslKey).toString() }
+              : {},
+            rejectUnauthorized: config.dbPostgresSslVerify,
+          },
+        }
+        : {},
+    },
+    pool: { min: 0, max: config.dbPostgresPoolMax },
+  }
+}
+
+export default dbConfig

package/db/config/sqlite.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from '../database';
+declare const dbConfig: () => Database.Config;
+export default dbConfig;

package/db/config/sqlite.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("../../config");
+var postProcess_1 = __importDefault(require("../postProcess"));
+var dbConfig = function () {
+    var config = (0, config_1.getConfig)();
+    if (!config.dbSqliteFile)
+        throw new Error('db: sqlite file not provided');
+    return {
+        client: 'sqlite3',
+        connection: {
+            filename: config.dbSqliteFile,
+        },
+        pool: { min: 0, max: 1 },
+        postProcessResponse: postProcess_1.default,
+    };
+};
+exports.default = dbConfig;

package/db/config/sqlite.ts

@@ -0,0 +1,20 @@
+import { getConfig } from '../../config'
+import postProcessResponse from '../postProcess'
+import type { Database } from '../database'
+
+const dbConfig: () => Database.Config = () => {
+  const config = getConfig()
+
+  if (!config.dbSqliteFile) throw new Error('db: sqlite file not provided')
+
+  return {
+    client: 'sqlite3',
+    connection: {
+      filename: config.dbSqliteFile,
+    },
+    pool: { min: 0, max: 1 },
+    postProcessResponse,
+  }
+}
+
+export default dbConfig

package/db/database.d.ts

@@ -0,0 +1,3 @@
+import type { Knex as Database } from 'knex';
+export { Database };
+export default Database;

package/db/database.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Database;

package/db/database.ts

@@ -0,0 +1,5 @@
+import type { Knex as Database } from 'knex'
+
+export { Database }
+
+export default Database

package/db/index.d.ts

@@ -0,0 +1,10 @@
+import { ColumnBuilder } from './schema/builder/columnBuilder';
+import { SchemaBuilder } from './schema/builder';
+import { TableBuilder } from './schema/builder/tableBuilder';
+import type { Database } from './database';
+import type { Migration } from './schema/migration';
+import type { MigrationList } from './schema/migrationList';
+import type { Schema } from './schema/schema';
+export { ColumnBuilder, Database, Migration, MigrationList, Schema, SchemaBuilder, TableBuilder, };
+declare const database: Database;
+export default database;

package/db/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableBuilder = exports.SchemaBuilder = exports.ColumnBuilder = void 0;
+var knex_1 = __importDefault(require("knex"));
+var columnBuilder_1 = require("./schema/builder/columnBuilder");
+Object.defineProperty(exports, "ColumnBuilder", { enumerable: true, get: function () { return columnBuilder_1.ColumnBuilder; } });
+var builder_1 = require("./schema/builder");
+Object.defineProperty(exports, "SchemaBuilder", { enumerable: true, get: function () { return builder_1.SchemaBuilder; } });
+var tableBuilder_1 = require("./schema/builder/tableBuilder");
+Object.defineProperty(exports, "TableBuilder", { enumerable: true, get: function () { return tableBuilder_1.TableBuilder; } });
+var config_1 = __importDefault(require("./config"));
+var log_1 = __importDefault(require("../log"));
+config_1.default.pool = __assign(__assign({}, config_1.default.pool), { afterCreate: function (connection, done) {
+        log_1.default.debug('db: new connection');
+        done(undefined, connection);
+    } });
+var database = (0, knex_1.default)(config_1.default);
+exports.default = database;

package/db/index.ts

@@ -0,0 +1,26 @@
+import knex from 'knex'
+import { ColumnBuilder } from './schema/builder/columnBuilder'
+import { SchemaBuilder } from './schema/builder'
+import { TableBuilder } from './schema/builder/tableBuilder'
+import config from './config'
+import log from '../log'
+import type { Database } from './database'
+import type { Migration } from './schema/migration'
+import type { MigrationList } from './schema/migrationList'
+import type { Schema } from './schema/schema'
+
+export {
+  ColumnBuilder, Database, Migration, MigrationList, Schema, SchemaBuilder, TableBuilder,
+}
+
+config.pool = {
+  ...config.pool,
+  afterCreate: (connection: any, done: any) => {
+    log.debug('db: new connection')
+    done(undefined, connection)
+  },
+}
+
+const database: Database = knex(config)
+
+export default database

package/db/postProcess.d.ts

@@ -0,0 +1,3 @@
+export declare const booleanColumnRegex: RegExp;
+declare const postProcess: (response: any) => any;
+export default postProcess;

package/db/postProcess.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanColumnRegex = void 0;
+exports.booleanColumnRegex = /^((is|has)(_|[A-Z]))/;
+var booleanColumns = function (columns) { return columns.filter(function (column) { return column.match(exports.booleanColumnRegex); }); };
+var postProcessRow = function (row, boolColumns) {
+    boolColumns.forEach(function (column) {
+        row[column] = row[column] === null ? null : !!row[column];
+    });
+    return row;
+};
+var postProcess = function (response) {
+    if (Array.isArray(response) && typeof response[0] === 'object') {
+        for (var _i = 0, response_1 = response; _i < response_1.length; _i++) {
+            var row = response_1[_i];
+            postProcessRow(row, booleanColumns(Object.keys(response[0])));
+        }
+        return response;
+    }
+    if (typeof response === 'object') {
+        return postProcessRow(response, booleanColumns(Object.keys(response)));
+    }
+    return response;
+};
+exports.default = postProcess;

package/db/postProcess.ts

@@ -0,0 +1,27 @@
+export const booleanColumnRegex = /^((is|has)(_|[A-Z]))/
+
+const booleanColumns = (columns: string[]) => columns.filter(
+  (column) => column.match(booleanColumnRegex),
+)
+
+const postProcessRow = (row: any, boolColumns: string[]) => {
+  boolColumns.forEach((column) => {
+    row[column] = row[column] === null ? null : !!row[column]
+  })
+  return row
+}
+
+const postProcess = (response: any) => {
+  if (Array.isArray(response) && typeof response[0] === 'object') {
+    for (const row of response) {
+      postProcessRow(row, booleanColumns(Object.keys(response[0])))
+    }
+    return response
+  }
+  if (typeof response === 'object') {
+    return postProcessRow(response, booleanColumns(Object.keys(response)))
+  }
+  return response
+}
+
+export default postProcess

package/db/schema/builder/_.d.ts

@@ -0,0 +1,30 @@
+import type { Database } from '../../database';
+export interface Table {
+    db: Database;
+    name: string;
+}
+export interface Column {
+    name: string;
+    dataType: DataType;
+    nullConstraint: NullConstraint;
+    index?: Index;
+    referencedTable?: string;
+    onDelete?: OnDelete;
+}
+export type DataType = 'boolean' | 'decimal' | 'integer' | 'string';
+export type NullConstraint = 'notNull' | 'null';
+export type Index = 'index' | 'noIndex' | 'primary' | 'unique';
+export type OnDelete = 'cascade' | 'restrict';
+export declare const shortName: (...name: string[]) => string;
+export declare const createTable: (table: Table, ...columns: Column[]) => Database.SchemaBuilder;
+export declare const dropTable: (table: Table) => Database.SchemaBuilder;
+export declare const table: (db: Database, name: string) => Table;
+export declare const column: (name: string, dataType: DataType, nullConstraint: NullConstraint, index?: Index, referencedTable?: string, onDelete?: OnDelete) => Column;
+declare const _default: {
+    column: (name: string, dataType: DataType, nullConstraint: NullConstraint, index?: Index | undefined, referencedTable?: string | undefined, onDelete?: OnDelete | undefined) => Column;
+    createTable: (table: Table, ...columns: Column[]) => Database.SchemaBuilder;
+    dropTable: (table: Table) => Database.SchemaBuilder;
+    shortName: (...name: string[]) => string;
+    table: (db: Database<any, any[]>, name: string) => Table;
+};
+export default _default;

package/db/schema/builder/_.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.column = exports.table = exports.dropTable = exports.createTable = exports.shortName = void 0;
+var longNameRegex = /[A-Z][a-z]{4,}|[a-z]{5,}/g;
+var shortName = function () {
+    var name = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        name[_i] = arguments[_i];
+    }
+    return name
+        .map(function (string) { return string.replace(longNameRegex, function (match) { return match.substring(0, 4); }); })
+        .join('_');
+};
+exports.shortName = shortName;
+var createTable = function (table) {
+    var columns = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        columns[_i - 1] = arguments[_i];
+    }
+    return table.db.schema
+        .createTable(table.name, function (tableBuilder) {
+        var primaryKey = [];
+        columns.forEach(function (column) {
+            var columnBuilder;
+            switch (column.dataType) {
+                case 'boolean':
+                    columnBuilder = tableBuilder.boolean(column.name);
+                    break;
+                case 'decimal':
+                    columnBuilder = tableBuilder.decimal(column.name, 32, 16);
+                    break;
+                case 'integer':
+                    columnBuilder = tableBuilder.integer(column.name);
+                    break;
+                default:
+                    columnBuilder = tableBuilder.string(column.name);
+            }
+            switch (column.nullConstraint) {
+                case 'null':
+                    columnBuilder.nullable();
+                    break;
+                default:
+                    columnBuilder.notNullable();
+            }
+            switch (column.index) {
+                case 'index':
+                    columnBuilder.index((0, exports.shortName)('IDX', table.name, column.name));
+                    break;
+                case 'primary':
+                    if (primaryKey.length) {
+                        columnBuilder.index((0, exports.shortName)('IDX', table.name, column.name));
+                    }
+                    primaryKey.push(column.name);
+                    break;
+                case 'unique':
+                    columnBuilder.unique({ indexName: (0, exports.shortName)('UNQ', table.name, column.name) });
+                    break;
+                default:
+            }
+            if (column.referencedTable) {
+                columnBuilder
+                    .references(column.name)
+                    .inTable(column.referencedTable)
+                    .withKeyName((0, exports.shortName)('FK', table.name, column.referencedTable, column.name))
+                    .onUpdate('CASCADE')
+                    .onDelete(column.onDelete ? column.onDelete.toUpperCase() : 'RESTRICT');
+            }
+        });
+        if (primaryKey.length) {
+            tableBuilder.primary(primaryKey);
+        }
+    });
+};
+exports.createTable = createTable;
+var dropTable = function (table) { return table.db.schema.dropTable(table.name); };
+exports.dropTable = dropTable;
+var table = function (db, name) { return ({ db: db, name: name }); };
+exports.table = table;
+var column = function (name, dataType, nullConstraint, index, referencedTable, onDelete) { return ({ name: name, dataType: dataType, nullConstraint: nullConstraint, index: index, referencedTable: referencedTable, onDelete: onDelete }); };
+exports.column = column;
+exports.default = {
+    column: exports.column,
+    createTable: exports.createTable,
+    dropTable: exports.dropTable,
+    shortName: exports.shortName,
+    table: exports.table,
+};

package/db/schema/builder/_.ts

@@ -0,0 +1,101 @@
+import type { Database } from '../../database'
+
+export interface Table {
+  db: Database,
+  name: string,
+}
+
+export interface Column {
+  name: string,
+  dataType: DataType,
+  nullConstraint: NullConstraint,
+  index?: Index,
+  referencedTable?: string,
+  onDelete?: OnDelete,
+}
+
+export type DataType = 'boolean' | 'decimal' | 'integer' | 'string'
+export type NullConstraint = 'notNull' | 'null'
+export type Index = 'index' | 'noIndex' | 'primary' | 'unique'
+export type OnDelete = 'cascade' | 'restrict'
+
+const longNameRegex = /[A-Z][a-z]{4,}|[a-z]{5,}/g
+
+export const shortName = (...name: string[]) => name
+  .map((string) => string.replace(longNameRegex, (match) => match.substring(0, 4)))
+  .join('_')
+
+export const createTable = (table: Table, ...columns: Column[]) => table.db.schema
+  .createTable(table.name, (tableBuilder) => {
+    const primaryKey: string[] = []
+    columns.forEach((column) => {
+      let columnBuilder: Database.ColumnBuilder
+      switch (column.dataType) {
+        case 'boolean':
+          columnBuilder = tableBuilder.boolean(column.name)
+          break
+        case 'decimal':
+          columnBuilder = tableBuilder.decimal(column.name, 32, 16)
+          break
+        case 'integer':
+          columnBuilder = tableBuilder.integer(column.name)
+          break
+        default:
+          columnBuilder = tableBuilder.string(column.name)
+      }
+      switch (column.nullConstraint) {
+        case 'null':
+          columnBuilder.nullable()
+          break
+        default:
+          columnBuilder.notNullable()
+      }
+      switch (column.index) {
+        case 'index':
+          columnBuilder.index(shortName('IDX', table.name, column.name))
+          break
+        case 'primary':
+          if (primaryKey.length) {
+            columnBuilder.index(shortName('IDX', table.name, column.name))
+          }
+          primaryKey.push(column.name)
+          break
+        case 'unique':
+          columnBuilder.unique({ indexName: shortName('UNQ', table.name, column.name) })
+          break
+        default:
+      }
+      if (column.referencedTable) {
+        columnBuilder
+          .references(column.name)
+          .inTable(column.referencedTable)
+          .withKeyName(shortName('FK', table.name, column.referencedTable, column.name))
+          .onUpdate('CASCADE')
+          .onDelete(column.onDelete ? column.onDelete.toUpperCase() : 'RESTRICT')
+      }
+    })
+    if (primaryKey.length) {
+      tableBuilder.primary(primaryKey)
+    }
+  })
+
+export const dropTable = (table: Table) => table.db.schema.dropTable(table.name)
+
+export const table = (db: Database, name: string): Table => ({ db, name })
+
+export const column = (
+  name: string,
+  dataType: DataType,
+  nullConstraint: NullConstraint,
+  index?: Index,
+  referencedTable?: string,
+  onDelete?: OnDelete,
+): Column => ({ name, dataType, nullConstraint, index, referencedTable, onDelete })
+
+export default {
+  column,
+  createTable,
+  dropTable,
+  shortName,
+  table,
+}

package/db/schema/builder/columnBuilder.d.ts

@@ -0,0 +1,7 @@
+import type { Database } from '../../database';
+export declare class ColumnBuilder {
+    private knexColumnBuilder;
+    constructor(knexColumnBuilder: Database.ColumnBuilder);
+    index(): void;
+}
+export default ColumnBuilder;

package/db/schema/builder/columnBuilder.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnBuilder = void 0;
+var ColumnBuilder = /** @class */ (function () {
+    function ColumnBuilder(knexColumnBuilder) {
+        this.knexColumnBuilder = knexColumnBuilder;
+    }
+    ColumnBuilder.prototype.index = function () {
+        this.knexColumnBuilder.index();
+    };
+    return ColumnBuilder;
+}());
+exports.ColumnBuilder = ColumnBuilder;
+exports.default = ColumnBuilder;

package/db/schema/builder/columnBuilder.ts

@@ -0,0 +1,15 @@
+import type { Database } from '../../database'
+
+export class ColumnBuilder {
+  private knexColumnBuilder: Database.ColumnBuilder
+
+  constructor(knexColumnBuilder: Database.ColumnBuilder) {
+    this.knexColumnBuilder = knexColumnBuilder
+  }
+
+  index() {
+    this.knexColumnBuilder.index()
+  }
+}
+
+export default ColumnBuilder

package/db/schema/builder/dataType.d.ts

@@ -0,0 +1,28 @@
+declare const _default: {
+    bigInt: () => string;
+    bigIntPrimaryAutoIncrement: () => string;
+    binary: (length: number) => string;
+    blob: () => string;
+    boolean: () => string;
+    char: (length: number) => string;
+    date: () => string;
+    dateTime: () => string;
+    double: () => string;
+    float: () => string;
+    int: () => string;
+    intPrimaryAutoIncrement: () => string;
+    longBlob: () => string;
+    longText: () => string;
+    numeric: (precision: number, scale: number) => string;
+    smallInt: () => string;
+    smallIntPrimaryAutoIncrement: () => string;
+    text: () => string;
+    time: () => string;
+    timestamp: () => string;
+    tinyBlob: () => string;
+    tinyInt: () => string;
+    tinyText: () => string;
+    varBinary: (maxLength: number) => string;
+    varChar: (maxLength: number) => string;
+};
+export default _default;