drizzle-orm 0.9.14 → 0.9.18

package/migrator/migrator.js

@@ -1,87 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MigrationSession = void 0;
+/* eslint-disable no-restricted-syntax */
 /* eslint-disable import/export */
 /* eslint-disable max-classes-per-file */
-const create_1 = require("../builders/lowLvlBuilders/create");
+const fs = require("fs");
+const builders_1 = require("../builders");
 const transaction_1 = require("../builders/transaction/transaction");
-const migrationsTable_1 = require("../tables/migrationsTable");
-class MigrationSession {
-    constructor() {
-        this.finalQuery = '';
-        this.execute = (query) => {
-            this.finalQuery += query;
-            this.finalQuery += '\n';
-        };
-        this.getQuery = () => this.finalQuery;
-    }
-}
-exports.MigrationSession = MigrationSession;
+const tables_1 = require("../tables");
 class Migrator {
     constructor(db) {
-        this.migrationsPerVersion = new Map();
-        this.chain = (tag, migration) => {
-            const migrationSession = new MigrationSession();
-            migration(migrationSession);
-            this.migrationsPerVersion.set(+tag, migrationSession.getQuery());
-            return this;
-        };
-        this.getResultScript = () => {
-            const values = [];
-            // eslint-disable-next-line no-restricted-syntax
-            for (const value of this.migrationsPerVersion.values()) {
-                values.push(value);
-            }
-            return values;
-        };
-        this.execute = async () => {
-            const migrationsTable = new migrationsTable_1.default(this._db);
-            await this.session.execute(create_1.default.table(migrationsTable).build());
-            const migrations = await migrationsTable.select().all();
-            const transaction = new transaction_1.default(this.session);
-            await transaction.begin();
+        this.db = db;
+    }
+    async migrate(configPath, config) {
+        let migrationFolderTo;
+        if (configPath) {
+            const configAsString = fs.readFileSync(configPath, 'utf8');
+            const splitted = configAsString.trim().split('\n');
             // eslint-disable-next-line no-restricted-syntax
-            for await (const [key, value] of this.migrationsPerVersion) {
-                const dbMigrationByTag = migrations.find((it) => it.version === key);
-                if (dbMigrationByTag) {
-                    // const isHashSameAsInDb =
-                    // Buffer.from(dbMigrationByTag.hash, 'base64').toString('ascii') === value;
-                    // if (!isHashSameAsInDb) {
-                    //   throw Error(`Migration script was changed for version ${key}`);
-                    // }
+            for (const split of splitted) {
+                const entry = split.trim().split(':');
+                const key = entry[0];
+                const value = entry[1].trim().replace(/['"]+/g, '');
+                if (key === 'migrationFolder') {
+                    // proceed value
+                    migrationFolderTo = value;
                 }
-                else {
-                    try {
-                        const logger = this._db.logger();
-                        if (logger) {
-                            logger.info(`Executing migration with tag ${key} with query:\n${value}`);
-                        }
-                        await this._db.session().execute(value);
-                        await migrationsTable
-                            .insert({
-                            version: key,
-                            createdAt: new Date(),
-                            hash: Buffer.from(value).toString('base64'),
-                        }).execute();
-                    }
-                    catch (e) {
-                        await transaction.rollback();
-                        throw new Error(`Migration chain ${key} was not migrated sucessfully.\nMessage: ${e.message}`);
-                    }
+            }
+        }
+        if (config) {
+            migrationFolderTo = config.migrationFolder;
+        }
+        if (!migrationFolderTo) {
+            throw Error('no migration folder defined');
+        }
+        const migrationTable = new tables_1.MigrationsTable(this.db);
+        await this.db.session().execute(builders_1.Create.table(migrationTable).build());
+        const dbMigrations = await migrationTable.select().all();
+        const lastDbMigration = dbMigrations.length > 0
+            ? dbMigrations[dbMigrations.length - 1]
+            : undefined;
+        const files = fs.readdirSync(migrationFolderTo);
+        const transaction = new transaction_1.default(this.db.session());
+        await transaction.begin();
+        try {
+            for await (const migrationFolder of files) {
+                const migrationFiles = fs.readdirSync(`${migrationFolderTo}/${migrationFolder}`);
+                const migrationFile = migrationFiles.filter((file) => file === 'migration.sql')[0];
+                const query = fs.readFileSync(`${migrationFolderTo}/${migrationFolder}/${migrationFile}`).toString();
+                const folderAsMillis = new Date(migrationFolder).getTime();
+                if (!lastDbMigration || lastDbMigration.createdAt < folderAsMillis) {
+                    await this.db.session().execute(query);
+                    await migrationTable.insert({
+                        hash: this.generateHash(query),
+                        createdAt: folderAsMillis,
+                    }).execute();
                 }
             }
             await transaction.commit();
-            return true;
-        };
-        this._db = db;
-        this.session = db.session();
+        }
+        catch (e) {
+            if (this.db.logger()) {
+                this.db.logger().error(e);
+            }
+            transaction.rollback();
+        }
     }
     generateHash(value) {
         let hash = 0;
         let i;
         let chr;
         if (value.length === 0)
-            return hash;
+            return '';
         for (i = 0; i < value.length; i += 1) {
             chr = value.charCodeAt(i);
             // eslint-disable-next-line no-bitwise
@@ -89,7 +78,7 @@ class Migrator {
             // eslint-disable-next-line no-bitwise
             hash |= 0;
         }
-        return hash;
+        return Buffer.from(value).toString('base64');
     }
 }
 exports.default = Migrator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.9.14",
+  "version": "0.9.18",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/serializer/serializer.d.ts

@@ -1,5 +1,12 @@
+import { DB } from '../db';
 import { AbstractTable } from '../tables';
 import Enum from '../types/type';
+interface EnumsAsObject {
+    [name: string]: {
+        name: string;
+        values: string[];
+    };
+}
 interface ColumnAsObject {
     [name: string]: {
         name?: string;
@@ -37,5 +44,10 @@ export default class MigrationSerializer {
             [key: string]: Enum<any>;
         };
     };
+    fromDatabase: (db: DB) => Promise<{
+        version: string;
+        tables: TableAsObject;
+        enums: EnumsAsObject;
+    }>;
 }
 export {};

package/serializer/serializer.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable max-classes-per-file */
 /* eslint-disable import/no-named-as-default-member */
 /* eslint-disable import/no-named-as-default */
 /* eslint-disable no-param-reassign */
@@ -34,7 +35,7 @@ class MigrationSerializer {
                     if (value instanceof columns_1.Column) {
                         columnToReturn[value.getColumnName()] = {
                             name: value.getColumnName(),
-                            type: value.isAutoIncrement() ? 'serial' : value.getColumnType().getDbName(),
+                            type: value.getColumnType().getDbName(),
                             primaryKey: !!value.primaryKeyName,
                             unique: !!value.uniqueKeyName,
                             default: value.getDefaultValue() === null ? undefined : value.getDefaultValue(),
@@ -69,6 +70,172 @@ class MigrationSerializer {
             }, {});
             return { version: '1', tables: result, enums: enumsToReturn };
         };
+        this.fromDatabase = async (db) => {
+            var _a;
+            const result = {};
+            const allTables = await db.session().execute('SELECT table_schema, table_name FROM information_schema.tables WHERE table_schema != \'pg_catalog\' and table_schema != \'information_schema\';');
+            for await (const row of allTables.rows) {
+                try {
+                    // const tableSchema = row.table_schema;
+                    const tableName = row.table_name;
+                    const columnToReturn = {};
+                    const indexToReturn = {};
+                    const tableResponse = await db.session().execute(`SELECT a.attrelid::regclass::text, a.attname
+        , CASE WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[])
+             AND EXISTS (
+                SELECT FROM pg_attrdef ad
+                WHERE  ad.adrelid = a.attrelid
+                AND    ad.adnum   = a.attnum
+                AND    pg_get_expr(ad.adbin, ad.adrelid)
+                     = 'nextval('''
+                    || (pg_get_serial_sequence (a.attrelid::regclass::text
+                                             , a.attname))::regclass
+                    || '''::regclass)'
+                )
+           THEN CASE a.atttypid
+                   WHEN 'int'::regtype  THEN 'serial'
+                   WHEN 'int8'::regtype THEN 'bigserial'
+                   WHEN 'int2'::regtype THEN 'smallserial'
+                END
+           ELSE format_type(a.atttypid, a.atttypmod)
+           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default
+   FROM  pg_attribute  a
+   JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
+   WHERE  a.attrelid = '${tableName}'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}'
+   AND    a.attnum > 0
+   AND    NOT a.attisdropped
+   ORDER  BY a.attnum;`);
+                    const tableConstraints = await db.session().execute(`SELECT c.column_name, c.data_type, constraint_type, constraint_name
+      FROM information_schema.table_constraints tc 
+      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name) 
+      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
+        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+      WHERE tc.table_name = '${tableName}';`);
+                    const tableForeignKeys = await db.session().execute(`SELECT
+        tc.table_schema, 
+        tc.constraint_name, 
+        tc.table_name, 
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.delete_rule, rc.update_rule
+    FROM 
+        information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+          ON ccu.constraint_name = tc.constraint_name
+          AND ccu.table_schema = tc.table_schema
+        JOIN information_schema.referential_constraints AS rc
+          ON ccu.constraint_name = rc.constraint_name 
+    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${tableName}';`);
+                    const mappedRefernces = {};
+                    for (const fk of tableForeignKeys.rows) {
+                        // const tableFrom = fk.table_name;
+                        const columnFrom = fk.column_name;
+                        const tableTo = fk.foreign_table_name;
+                        const columnTo = fk.foreign_column_name;
+                        const foreignKeyName = fk.constraint_name;
+                        const onUpdate = fk.update_rule;
+                        const onDelete = fk.delete_rule;
+                        mappedRefernces[columnFrom] = {
+                            foreignKeyName,
+                            table: tableTo,
+                            column: columnTo,
+                            onDelete: onUpdate ? `ON UPDATE ${onUpdate}` : undefined,
+                            onUpdate: onDelete ? `ON DELETE ${onDelete}` : undefined,
+                        };
+                    }
+                    for (const columnResponse of tableResponse.rows) {
+                        const columnName = columnResponse.attname;
+                        const columnType = columnResponse.data_type;
+                        const primaryKey = tableConstraints.rows.filter((mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === 'PRIMARY KEY');
+                        const uniqueKey = tableConstraints.rows.filter((mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === 'UNIQUE');
+                        const defaultValue = columnResponse.column_default === null
+                            ? undefined : columnResponse.column_default;
+                        const isSerial = columnType === 'serial';
+                        columnToReturn[columnName] = {
+                            name: columnName,
+                            type: columnType,
+                            primaryKey: !!primaryKey[0],
+                            unique: !!uniqueKey[0],
+                            default: isSerial ? undefined : defaultValue,
+                            notNull: !columnResponse.is_nullable,
+                            references: (_a = mappedRefernces[columnName]) !== null && _a !== void 0 ? _a : undefined,
+                        };
+                    }
+                    const dbIndexes = await db.session().execute(`select
+        t.relname as table_name,
+        i.relname as index_name,
+        a.attname as column_name
+    from
+        pg_class t,
+        pg_class i,
+        pg_index ix,
+        pg_attribute a
+    where
+        t.oid = ix.indrelid
+        and i.oid = ix.indexrelid
+        and a.attrelid = t.oid
+        and a.attnum = ANY(ix.indkey)
+        and t.relkind = 'r'
+        and t.relname = '${tableName}'
+    order by
+        t.relname,
+        i.relname;`);
+                    for (const dbIndex of dbIndexes.rows) {
+                        const indexName = dbIndex.index_name;
+                        const indexColumnName = dbIndex.column_name;
+                        if (indexToReturn[indexName] !== undefined && indexToReturn[indexName] !== null) {
+                            indexToReturn[indexName].columns[indexColumnName] = {
+                                name: indexColumnName,
+                            };
+                        }
+                        else {
+                            indexToReturn[indexName] = {
+                                name: indexName,
+                                columns: {
+                                    [indexColumnName]: {
+                                        name: indexColumnName,
+                                    },
+                                },
+                            };
+                        }
+                    }
+                    result[tableName] = {
+                        name: tableName,
+                        columns: columnToReturn,
+                        indexes: indexToReturn,
+                    };
+                }
+                catch (e) {
+                    console.log(e);
+                }
+            }
+            const allEnums = await db.session().execute(`select n.nspname as enum_schema,  
+    t.typname as enum_name,  
+    e.enumlabel as enum_value
+    from pg_type t 
+    join pg_enum e on t.oid = e.enumtypid  
+    join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`);
+            const enumsToReturn = {};
+            for (const dbEnum of allEnums.rows) {
+                const enumName = dbEnum.enum_name;
+                const enumValue = dbEnum.enum_value;
+                if (enumsToReturn[enumName] !== undefined && enumsToReturn[enumName] !== null) {
+                    enumsToReturn[enumName].values.push(enumValue);
+                }
+                else {
+                    enumsToReturn[enumName] = {
+                        name: enumName,
+                        values: [enumValue],
+                    };
+                }
+            }
+            return { version: '1', tables: result, enums: enumsToReturn };
+        };
     }
 }
 exports.default = MigrationSerializer;

package/tables/abstractTable.d.ts

@@ -11,7 +11,7 @@ import InsertTRB from '../builders/highLvlBuilders/insertRequestBuilder';
 import DeleteTRB from '../builders/highLvlBuilders/deleteRequestBuilder';
 import UpdateTRB from '../builders/highLvlBuilders/updateRequestBuilder';
 import SelectTRB from '../builders/highLvlBuilders/selectRequestBuilder';
-import PgBigInt from '../columns/types/pgBigInt';
+import PgBigInt53, { PgBigInt64 } from '../columns/types/pgBigInt';
 import BaseLogger from '../logger/abstractLogger';
 import PgEnum from '../columns/types/pgEnum';
 import DB from '../db/db';
@@ -19,6 +19,9 @@ import { AbstractColumn, Column } from '../columns/column';
 import TableIndex from '../indexes/tableIndex';
 import { ExtractModel } from './inferTypes';
 import Enum, { ExtractEnumValues } from '../types/type';
+import PgSerial from '../columns/types/pgSerial';
+import PgTimestamptz from '../columns/types/pgTimestamptz';
+import PgBigSerial53, { PgBigSerial64 } from '../columns/types/pgBigSerial';
 export default abstract class AbstractTable<TTable extends AbstractTable<TTable>> {
     db: DB;
     private _session;
@@ -43,102 +46,23 @@ export default abstract class AbstractTable<TTable extends AbstractTable<TTable>
     protected uniqueIndex(columns: Column<ColumnType, boolean, boolean>): TableIndex;
     protected varchar(name: string, params?: {
         size?: number;
-        notNull: false;
     }): Column<PgVarChar, true>;
-    protected varchar(name: string, params: {
-        size?: number;
-        notNull: true;
-    }): Column<PgVarChar, false>;
-    protected varchar(name: string, params?: {
-        size?: number;
-        notNull?: false;
-    }): Column<PgVarChar, true>;
-    protected varchar(name: string, params: {
-        size?: number;
-        notNull?: true;
-    }): Column<PgVarChar, false>;
-    protected int(name: string, params?: {
-        notNull: false;
-    }): Column<PgInteger, true>;
-    protected int(name: string, params: {
-        notNull: true;
-    }): Column<PgInteger, false>;
-    protected smallInt(name: string, params?: {
-        notNull: false;
-    }): Column<PgInteger, true>;
-    protected smallInt(name: string, params: {
-        notNull: true;
-    }): Column<PgInteger, false>;
-    protected timestamp(name: string, params?: {
-        notNull: false;
-    }): Column<PgTimestamp, true>;
-    protected timestamp(name: string, params: {
-        notNull: true;
-    }): Column<PgTimestamp, false>;
-    protected bigint(name: string, params?: {
-        notNull: false;
-    }): Column<PgBigInt, true>;
-    protected bigint(name: string, params: {
-        notNull: true;
-    }): Column<PgBigInt, false>;
-    protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string, params?: {
-        notNull: false;
-    }): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, true>;
-    protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string, params: {
-        notNull: true;
-    }): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, false>;
+    protected int(name: string): Column<PgInteger, true>;
+    protected smallInt(name: string): Column<PgInteger, true>;
+    protected serial(name: string): Column<PgSerial, true, true>;
+    protected bigSerial(name: string, maxBytes: 'max_bytes_53'): Column<PgBigSerial53, true, true>;
+    protected bigSerial(name: string, maxBytes: 'max_bytes_64'): Column<PgBigSerial64, true, true>;
+    protected timestamp(name: string): Column<PgTimestamp, true>;
+    protected timestamptz(name: string): Column<PgTimestamptz, true>;
+    protected bigint(name: string, maxBytes: 'max_bytes_53'): Column<PgBigInt53, true, true>;
+    protected bigint(name: string, maxBytes: 'max_bytes_64'): Column<PgBigInt64, true, true>;
+    protected type<ETtype extends string>(typeEnum: Enum<ETtype>, name: string): Column<PgEnum<ExtractEnumValues<Enum<ETtype>>>, true>;
     protected decimal(name: string, params?: {
         precision?: number;
-        scale: number;
-        notNull?: false;
-    }): Column<PgBigDecimal, true>;
-    protected decimal(name: string, params: {
-        precision?: number;
-        scale: number;
-        notNull?: true;
-    }): Column<PgBigDecimal, false>;
-    protected decimal(name: string, params?: {
-        precision: number;
         scale?: number;
-        notNull?: false;
     }): Column<PgBigDecimal, true>;
-    protected decimal(name: string, params: {
-        precision: number;
-        scale?: number;
-        notNull?: true;
-    }): Column<PgBigDecimal, false>;
-    protected decimal(name: string, params?: {
-        precision?: number;
-        scale?: number;
-        notNull?: false;
-    }): Column<PgBigDecimal, true>;
-    protected decimal(name: string, params: {
-        precision?: number;
-        scale?: number;
-        notNull?: true;
-    }): Column<PgBigDecimal, false>;
-    protected time(name: string, params?: {
-        notNull: false;
-    }): Column<PgTime, true>;
-    protected time(name: string, params: {
-        notNull: true;
-    }): Column<PgTime, false>;
-    protected bool(name: string, params?: {
-        notNull: false;
-    }): Column<PgBoolean, true>;
-    protected bool(name: string, params: {
-        notNull: true;
-    }): Column<PgBoolean, false>;
-    protected text(name: string, params?: {
-        notNull: false;
-    }): Column<PgText, true>;
-    protected text(name: string, params: {
-        notNull: true;
-    }): Column<PgText, false>;
-    protected jsonb<TSubType>(name: string, params?: {
-        notNull: false;
-    }): Column<PgJsonb<TSubType>, true>;
-    protected jsonb<TSubType>(name: string, params: {
-        notNull: true;
-    }): Column<PgJsonb<TSubType>, false>;
+    protected time(name: string): Column<PgTime, true>;
+    protected bool(name: string): Column<PgBoolean, true>;
+    protected text(name: string): Column<PgText, true>;
+    protected jsonb<TSubType>(name: string): Column<PgJsonb<TSubType>, true>;
 }

package/tables/abstractTable.js

@@ -17,6 +17,9 @@ const pgEnum_1 = require("../columns/types/pgEnum");
 const column_1 = require("../columns/column");
 const tableIndex_1 = require("../indexes/tableIndex");
 const pgSmallInt_1 = require("../columns/types/pgSmallInt");
+const pgSerial_1 = require("../columns/types/pgSerial");
+const pgTimestamptz_1 = require("../columns/types/pgTimestamptz");
+const pgBigSerial_1 = require("../columns/types/pgBigSerial");
 class AbstractTable {
     constructor(db) {
         this.withLogger = (logger) => {
@@ -73,49 +76,53 @@ class AbstractTable {
         return new tableIndex_1.default(this.tableName(), columns instanceof Array ? columns : [columns]);
     }
     varchar(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgVarChar_1.default(params.size), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+        return new column_1.Column(this, name, new pgVarChar_1.default(params.size));
     }
-    int(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgInteger_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    int(name) {
+        return new column_1.Column(this, name, new pgInteger_1.default());
     }
-    smallInt(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgSmallInt_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    smallInt(name) {
+        return new column_1.Column(this, name, new pgSmallInt_1.default());
     }
-    timestamp(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgTimestamp_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    serial(name) {
+        return new column_1.Column(this, name, new pgSerial_1.default());
     }
-    bigint(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgBigInt_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    bigSerial(name, maxBytes) {
+        if (maxBytes === 'max_bytes_53') {
+            return new column_1.Column(this, name, new pgBigSerial_1.default());
+        }
+        return new column_1.Column(this, name, new pgBigSerial_1.PgBigSerial64());
+    }
+    timestamp(name) {
+        return new column_1.Column(this, name, new pgTimestamp_1.default());
+    }
+    timestamptz(name) {
+        return new column_1.Column(this, name, new pgTimestamptz_1.default());
+    }
+    bigint(name, maxBytes) {
+        if (maxBytes === 'max_bytes_53') {
+            return new column_1.Column(this, name, new pgBigInt_1.default());
+        }
+        return new column_1.Column(this, name, new pgBigInt_1.PgBigInt64());
     }
-    type(typeEnum, name, params = {}) {
-        var _a;
+    type(typeEnum, name) {
         const pgEnum = new pgEnum_1.default(typeEnum.name);
-        return new column_1.Column(this, name, pgEnum, (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+        return new column_1.Column(this, name, pgEnum);
     }
     decimal(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgBigDecimal_1.default(params.precision, params.scale), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+        return new column_1.Column(this, name, new pgBigDecimal_1.default(params.precision, params.scale));
     }
-    time(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgTime_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    time(name) {
+        return new column_1.Column(this, name, new pgTime_1.default());
     }
-    bool(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgBoolean_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    bool(name) {
+        return new column_1.Column(this, name, new pgBoolean_1.default());
     }
-    text(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgText_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    text(name) {
+        return new column_1.Column(this, name, new pgText_1.default());
     }
-    jsonb(name, params = {}) {
-        var _a;
-        return new column_1.Column(this, name, new pgJsonb_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    jsonb(name) {
+        return new column_1.Column(this, name, new pgJsonb_1.default());
     }
 }
 exports.default = AbstractTable;

package/tables/migrationsTable.d.ts

@@ -1,8 +1,7 @@
 import AbstractTable from './abstractTable';
 export default class MigrationsTable extends AbstractTable<MigrationsTable> {
-    id: import("../columns/column").IndexedColumn<import("..").PgInteger, true, true>;
-    version: import("..").Column<import("..").PgInteger, false, false>;
-    hash: import("..").Column<import("..").PgText, true, false>;
-    createdAt: import("..").Column<import("..").PgTimestamp, true, false>;
+    id: import("..").Column<import("../columns/types/pgSerial").default, true, true>;
+    hash: import("..").Column<import("..").PgText, false, false>;
+    createdAt: import("..").Column<import("..").PgBigInt, true, true>;
     tableName(): string;
 }

package/tables/migrationsTable.js

@@ -4,13 +4,12 @@ const abstractTable_1 = require("./abstractTable");
 class MigrationsTable extends abstractTable_1.default {
     constructor() {
         super(...arguments);
-        this.id = this.int('id').autoIncrement().primaryKey();
-        this.version = this.int('version', { notNull: true }).unique();
-        this.hash = this.text('hash');
-        this.createdAt = this.timestamp('created_at');
+        this.id = this.serial('id').primaryKey();
+        this.hash = this.text('hash').notNull();
+        this.createdAt = this.bigint('created_at', 'max_bytes_53');
     }
     tableName() {
-        return 'migrations';
+        return 'drizzle_migrations';
     }
 }
 exports.default = MigrationsTable;