drizzle-orm 0.9.13 → 0.9.17

package/README.md

@@ -0,0 +1,399 @@
+# DrizzleORM
+
+**DrizzleORM** is an ORM framework for 
+[TypeScript](https://www.typescriptlang.org/).
+It offers you several levels of Database communication:
+* Typesafe Table View approach 
+* Typesafe Query Builder
+* Simple SQL query execution
+
+Drizzle ORM is highly influenced by [Exposed](https://github.com/JetBrains/Exposed) and Jetbrains development methodology
+
+## Supported Databases
+
+* PostgreSQL
+
+## Links
+
+In Progress
+
+## Installing
+
+```bash
+npm install drizzle-orm drizzle-kit
+```
+#### **In Progress**
+```bash
+yarn add drizzle-orm drizzle-kit
+bower install drizzle-orm drizzle-kit
+```
+
+## Connecting to database
+
+```tsx
+import { DbConnector } from "drizzle-orm";
+
+// connect via postgresql connection url
+const db = await new DbConnector()
+	.connectionString("postgres://user:password@host:port/db")
+	.connect();
+
+// or by params
+const db = await new DbConnector()
+	.params({
+		host: '0.0.0.0',
+		port: 5432,
+		user: 'user',
+		password: 'password',
+		db: 'optional_db_name'
+	}).connect();
+```
+## Project structure
+- tables folder
+- migrations folder
+
+## Create tables
+### Users Table
+---
+```typescript
+
+export const rolesEnum = createEnum({ alias: 'test-enum', values: ['user', 'guest', 'admin'] });
+
+export default class UsersTable extends AbstractTable<UsersTable> {
+  public id = this.serial('id').primaryKey();
+  public fullName = this.text('full_name');
+
+  public phone = this.varchar('phone', { size: 256 });
+  public media = this.jsonb<string[]>('media');
+  public decimalField = this.decimal('test', { precision: 100, scale: 2 }).notNull();
+  public bigIntField = this.bigint('test1', 'max_bytes_53');
+  public role = this.type(rolesEnum, 'name_in_table').notNull();
+
+  public createdAt = this.timestamp('created_at').notNull();
+
+  public createdAtWithTimezone = this.timestamptz('created_at_time_zone');
+
+  public updatedAt = this.timestamp('updated_at').defaultValue(Defaults.CURRENT_TIMESTAMP);
+  public isArchived = this.bool('is_archived').defaultValue(false);
+
+  public phoneFullNameIndex = this.index([this.phone, this.fullName]);
+  public phoneIndex = this.uniqueIndex(this.phone);
+
+  public tableName(): string {
+    return 'users';
+  }
+}
+```
+### Cities Table
+---
+```typescript
+interface CityMeta {
+  population: number,
+  connection: string,
+}
+
+export default class CitiesTable extends AbstractTable<CitiesTable> {
+  public id = this.serial('id').primaryKey();
+
+  public foundationDate = this.timestamp('name').notNull();
+  public location = this.varchar('page', { size: 256 });
+
+  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onUpdate: 'CASCADE' });
+
+  public metadata = this.jsonb<CityMeta>('metadata');
+
+  public tableName(): string {
+    return 'cities';
+  }
+}
+```
+### User Groups Table
+---
+```typescript
+export default class UserGroupsTable extends AbstractTable<UserGroupsTable> {
+  public id = this.serial('id').primaryKey();
+
+  public name = this.varchar('name');
+  public description = this.varchar('description');
+
+  public tableName(): string {
+    return 'user_groups';
+  }
+}
+```
+### User to User Groups Table
+---
+#### Many to many connection between Users and User Groups
+```typescript
+export default class UsersToUserGroupsTable extends AbstractTable<UsersToUserGroupsTable> {
+  public groupId = this.int('city_id').foreignKey(UserGroupsTable, (table) => table.id, { onDelete: 'CASCADE' });
+  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onDelete: 'CASCADE' });
+
+  public manyToManyIndex = this.index([this.groupId, this.userId]);
+
+  public tableName(): string {
+    return 'users_to_user_groups';
+  }
+}
+```
+
+## CRUD
+### **SELECT**
+---
+```typescript
+const db = await new DbConnector()
+  .connectionString('postgresql://postgres@127.0.0.1/drizzle')
+  .connect();
+
+const usersTable = new UsersTable(db);
+
+// select all
+const allSelect = await usersTable.select().all();
+
+// select first
+const firstSelect = await usersTable.select().first();
+```
+#### **Sorting and Filtering**
+---
+##### Select all records from `Users` where phone is `"hello"`
+```typescript
+const eqSelect = await usersTable.select().where(
+  eq(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where **both** phone is `"hello"` **and** phone is `"hello"`
+```typescript
+const andSelect = await usersTable.select().where(
+  and([
+    eq(usersTable.phone, 'hello'),
+    eq(usersTable.phone, 'hello')
+  ]),
+).all();
+```
+##### Select all records from `Users` where **either** phone is `"hello"` **or** phone is `"hello"`
+```typescript
+const orSelect = await usersTable.select().where(
+  or([eq(usersTable.phone, 'hello')]),
+).all();
+```
+##### Select all records from `Users` using **LIMIT** and **OFFSET**
+```typescript
+const limitOffsetSelect = await usersTable.select({ limit: 10, offset: 10 }).all();
+```
+##### Select all records from `Users` where `phone` contains `"hello"`
+```typescript
+const likeSelect = await usersTable.select().where(
+  like(usersTable.phone, '%hello%')
+).all();
+```
+##### Select all records from `Users` where `phone` equals to some of values from array
+```typescript
+const inArraySelect = usersTable.select().where(
+  inArray(usersTable.phone, ['hello'])
+).all();
+```
+##### Select all records from `Users` where `phone` greater(**>**) than `"hello"`
+```typescript
+const greaterSelect = usersTable.select().where(
+  greater(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where `phone` less(**<**) than `"hello"`
+```typescript
+const lessSelect = usersTable.select().where(
+  less(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where `phone` greater or equals(**>=**) than `"hello"`
+```typescript
+const greaterEqSelect = usersTable.select().where(
+  greaterEq(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where `phone` less or equals(**<=**) 
+```typescript
+const lessEqSelect = usersTable.select().where(
+  lessEq(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where `phone` is **NULL**
+```typescript
+const isNullSelect = usersTable.select().where(
+  isNull(usersTable.phone)
+).all();
+```
+##### Select all records from `Users` where `phone` not equals to `"hello"`
+```typescript
+const notEqSelect = usersTable.select().where(
+  notEq(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` ordered by `phone` in ascending order
+```typescript
+const ordered = await usersTable.select().orderBy((table) => table.phone, Order.ASC).all();
+```
+
+### **Update**
+---
+##### Update `fullName` to `newName` in `Users` where phone is `"hello"`
+```typescript
+await usersTable.update()
+  .where(eq(usersTable.phone, 'hello'))
+  .set({ fullName: 'newName' })
+  .execute();
+```
+##### Update `fullName` to `newName` in `Users` where phone is `"hello"` returning updated `User` model
+```typescript
+await usersTable.update()
+  .where(eq(usersTable.phone, 'hello'))
+  .set({ fullName: 'newName' })
+  .all();
+```
+##### Update `fullName` to `newName` in `Users` where phone is `"hello"` returning updated `User` model
+```typescript
+await usersTable.update()
+  .where(eq(usersTable.phone, 'hello'))
+  .set({ fullName: 'newName' })
+  .first();
+```
+
+### **Delete**
+##### Delete `user` where phone is `"hello"`
+```typescript
+await usersTable.delete()
+      .where(eq(usersTable.phone, 'hello'))
+      .execute();
+```
+##### Delete `user` where phone is `"hello"` returning updated `User` model
+```typescript
+await usersTable.delete()
+      .where(eq(usersTable.phone, 'hello'))
+      .all();
+```
+##### Delete `user` where phone is `"hello"` returning updated `User` model
+```typescript
+await usersTable.delete()
+      .where(eq(usersTable.phone, 'hello'))
+      .first();
+```
+
+### **Insert**
+##### Insert `user` with required fields
+```typescript
+await usersTable.insert({
+  test: 1,
+  createdAt: new Date(),
+}).execute();
+```
+##### Insert `user` with required fields and get all rows as array
+```typescript
+const user = await usersTable.insert({
+  test: 1,
+  createdAt: new Date(),
+}).all();
+```
+##### Insert `user` with required fields and get inserted entity
+```typescript
+const user = await usersTable.insert({
+  test: 1,
+  createdAt: new Date(),
+}).first();
+```
+##### Insert many `users` with required fields and get all inserted entities
+```typescript
+const users = await usersTable.insertMany([{
+      test: 1,
+      createdAt: new Date(),
+    }, {
+      test: 2,
+      createdAt: new Date(),
+    }]).all();
+```
+##### Insert many `users` with required fields and get all inserted entities. If such user already exists - update `phone` field
+```typescript
+await usersTable.insertMany([{
+      test: 1,
+      createdAt: new Date(),
+    }, {
+      test: 2,
+      createdAt: new Date(),
+    }])
+      .onConflict(
+        (table) => table.phoneIndex,
+        { phone: 'confilctUpdate' },
+      ).all();
+```
+
+## Joins
+### Join One-To-Many Tables
+##### Join Cities with Users and map to city object with full user
+```typescript
+const usersTable = new UsersTable(db);
+const citiesTable = new CitiesTable(db);
+
+ const userWithCities = await citiesTable.select()
+      .where(eq(citiesTable.id, 1))
+      .leftJoin(UsersTable,
+        (city) => city.userId,
+        (users) => users.id)
+      .execute();
+
+const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
+```
+
+### Join Many-To-Many Tables
+##### Join User Groups with Users, using many-to-many table and map response to get user object with groups array
+```typescript
+    const usersWithUserGroups = await usersToUserGroupsTable.select()
+      .where(eq(userGroupsTable.id, 1))
+      .leftJoin(UsersTable,
+        (userToGroup) => userToGroup.userId,
+        (users) => users.id)
+      .leftJoin(UserGroupsTable,
+        (userToGroup) => userToGroup.groupId,
+        (users) => users.id)
+      .execute();
+
+    const userGroupWithUsers = usersWithUserGroups.group({
+      one: (_, dbUser, dbUserGroup) => dbUser!,
+      many: (_, dbUser, dbUserGroup) => dbUserGroup!,
+    });
+
+    const userWithGroups: ExtractModel<UsersTable> & { groups: ExtractModel<UserGroupsTable>[] } = {
+      ...userGroupWithUsers.one,
+      groups: userGroupWithUsers.many,
+    };
+```
+##### Join User Groups with Users, using many-to-many table and map response to get user group object with users array
+```typescript
+    const usersWithUserGroups = await usersToUserGroupsTable.select()
+      .where(eq(userGroupsTable.id, 1))
+      .leftJoin(UsersTable,
+        (userToGroup) => userToGroup.userId,
+        (users) => users.id)
+      .leftJoin(UserGroupsTable,
+        (userToGroup) => userToGroup.groupId,
+        (users) => users.id)
+      .execute();
+
+    const userGroupWithUsers = usersWithUserGroups.group({
+      one: (_, dbUser, dbUserGroup) => dbUserGroup!,
+      many: (_, dbUser, dbUserGroup) => dbUser!,
+    });
+
+    const userWithGroups: ExtractModel<UserGroupsTable> & { users: ExtractModel<UsersTable>[] } = {
+      ...userGroupWithUsers.one,
+      users: userGroupWithUsers.many,
+    };
+```
+
+## Migrations
+#### To run migrations generated by drizzle-kit you could use `Migtator` class
+##### Provide drizzle-kit config path
+```typescript
+await drizzle.migrator(db).migrate('src/drizzle.config.yaml');
+```
+##### Provide object with path to folder with migrations
+```typescript
+await drizzle.migrator(db).migrate({ migrationFolder: 'drizzle' });
+```

package/builders/lowLvlBuilders/create.js

@@ -38,7 +38,7 @@ class Create {
                     }
                     this.columnsBuilder.push(ecranate_1.ecranate(column.getColumnName()));
                     this.columnsBuilder.push(' ');
-                    this.columnsBuilder.push(column.isAutoIncrement() ? 'SERIAL' : column.getColumnType().getDbName());
+                    this.columnsBuilder.push(column.getColumnType().getDbName());
                     this.columnsBuilder.push(' ');
                     this.columnsBuilder.push(column.getDefaultValue() != null ? `DEFAULT ${column.getColumnType().insertStrategy(column.getDefaultValue())}` : '');
                     this.columnsBuilder.push(column.isNullableFlag ? '' : ' NOT NULL');

package/columns/column.d.ts

@@ -1,18 +1,15 @@
+import { PgTime, PgTimestamp } from '.';
 import DB from '../db/db';
 import { AbstractTable } from '../tables';
 import ColumnType from './types/columnType';
-declare type ExtractColumnType<T extends ColumnType> = T extends ColumnType<infer TCodeType> ? TCodeType : never;
-export declare enum OnDelete {
-    RESTRICT = "ON DELETE RESTRICT",
-    CASCADE = "ON DELETE CASCADE"
-}
-export declare enum OnUpdate {
-    RESTRICT = "ON UPDATE RESTRICT",
-    CASCADE = "ON UPDATE RESTRICT"
+import PgTimestamptz from './types/pgTimestamptz';
+export declare enum Defaults {
+    CURRENT_TIMESTAMP = "CURRENT_TIMESTAMP"
 }
+declare type PgTimes = PgTimestamptz | PgTime | PgTimestamp;
+export declare type ExtractColumnType<T extends ColumnType> = T extends ColumnType<infer TCodeType> ? T extends PgTimes ? TCodeType | Defaults : TCodeType : never;
 export declare abstract class AbstractColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> {
-    isNullableFlag: TNullable;
-    autoIncrementType: TAutoIncrement;
+    isNullableFlag: boolean;
     primaryKeyName?: string;
     uniqueKeyName?: string;
     protected onDelete?: string;
@@ -21,10 +18,9 @@ export declare abstract class AbstractColumn<T extends ColumnType, TNullable ext
     protected parentTableName: string;
     protected columnType: T;
     protected columnName: string;
-    protected autoIncrementFlag: boolean;
     protected defaultParam: any;
     protected referenced: AbstractColumn<T, boolean, boolean>;
-    constructor(parent: AbstractTable<any>, columnName: string, columnType: T, nullable: TNullable);
+    constructor(parent: AbstractTable<any>, columnName: string, columnType: T);
     getOnDelete: () => string | undefined;
     getOnUpdate: () => string | undefined;
     getAlias: () => string;
@@ -33,38 +29,34 @@ export declare abstract class AbstractColumn<T extends ColumnType, TNullable ext
     abstract foreignKey<ITable extends AbstractTable<ITable>>(table: {
         new (db: DB): ITable;
     }, callback: (table: ITable) => AbstractColumn<T, boolean, boolean>, onConstraint: {
-        onDelete?: 'CASCADE' | 'RESTRICT';
-        onUpdate?: 'CASCADE' | 'RESTRICT';
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
     }): AbstractColumn<T, TNullable, TAutoIncrement>;
     defaultValue: (value: ExtractColumnType<T>) => this;
-    abstract autoIncrement(): AbstractColumn<T, boolean, boolean>;
     abstract primaryKey(): AbstractColumn<T, boolean, boolean>;
-    abstract serial(): AbstractColumn<T, boolean, boolean>;
     unique: () => this;
-    isAutoIncrement: () => boolean;
+    abstract notNull(): AbstractColumn<T, boolean, boolean>;
     getColumnName: () => string;
     getReferenced: () => AbstractColumn<T, boolean, boolean>;
     getColumnType: () => T;
     getDefaultValue: () => any;
 }
 export declare class Column<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> extends AbstractColumn<T, TNullable, TAutoIncrement> {
-    constructor(parent: AbstractTable<any>, columnName: string, columnType: T, nullable: TNullable);
-    serial(): Column<T, false, true>;
+    constructor(parent: AbstractTable<any>, columnName: string, columnType: T);
+    notNull(): Column<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement>;
     primaryKey(): Column<T, TAutoIncrement extends true ? true : false, TAutoIncrement>;
     foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => Column<T, boolean, boolean>, onConstraint?: {
-        onDelete?: 'CASCADE' | 'RESTRICT';
-        onUpdate?: 'CASCADE' | 'RESTRICT';
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
     }): Column<T, TNullable, TAutoIncrement>;
-    autoIncrement(): IndexedColumn<T, true, true>;
 }
 export declare class IndexedColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> extends AbstractColumn<T, TNullable, TAutoIncrement> {
     constructor(parent: AbstractTable<any>, columnName: string, columnType: T, nullable: TNullable);
-    serial(): IndexedColumn<T, false, true>;
+    notNull(): IndexedColumn<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement>;
     primaryKey(): IndexedColumn<T, TAutoIncrement extends true ? true : false, TAutoIncrement>;
     foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => IndexedColumn<T, boolean, boolean>, onConstraint?: {
-        onDelete?: 'CASCADE' | 'RESTRICT';
-        onUpdate?: 'CASCADE' | 'RESTRICT';
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
     }): IndexedColumn<T, TNullable, TAutoIncrement>;
-    autoIncrement(): IndexedColumn<T, true, true>;
 }
 export {};

package/columns/column.js

@@ -1,20 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedColumn = exports.Column = exports.AbstractColumn = exports.OnUpdate = exports.OnDelete = void 0;
-var OnDelete;
-(function (OnDelete) {
-    OnDelete["RESTRICT"] = "ON DELETE RESTRICT";
-    OnDelete["CASCADE"] = "ON DELETE CASCADE";
-})(OnDelete = exports.OnDelete || (exports.OnDelete = {}));
-var OnUpdate;
-(function (OnUpdate) {
-    OnUpdate["RESTRICT"] = "ON UPDATE RESTRICT";
-    OnUpdate["CASCADE"] = "ON UPDATE RESTRICT";
-})(OnUpdate = exports.OnUpdate || (exports.OnUpdate = {}));
+exports.IndexedColumn = exports.Column = exports.AbstractColumn = exports.Defaults = void 0;
+var Defaults;
+(function (Defaults) {
+    Defaults["CURRENT_TIMESTAMP"] = "CURRENT_TIMESTAMP";
+})(Defaults = exports.Defaults || (exports.Defaults = {}));
 // eslint-disable-next-line max-len
 class AbstractColumn {
-    constructor(parent, columnName, columnType, nullable) {
-        this.autoIncrementFlag = false;
+    constructor(parent, columnName, columnType) {
+        this.isNullableFlag = true;
         this.defaultParam = null;
         this.getOnDelete = () => this.onDelete;
         this.getOnUpdate = () => this.onUpdate;
@@ -29,7 +23,6 @@ class AbstractColumn {
             this.uniqueKeyName = this.columnName;
             return this;
         };
-        this.isAutoIncrement = () => this.autoIncrementFlag;
         this.getColumnName = () => this.columnName;
         this.getReferenced = () => this.referenced;
         this.getColumnType = () => this.columnType;
@@ -38,17 +31,16 @@ class AbstractColumn {
         this.columnName = columnName;
         this.parentTableName = parent.tableName();
         this.parent = parent;
-        this.isNullableFlag = nullable;
     }
 }
 exports.AbstractColumn = AbstractColumn;
 // eslint-disable-next-line max-len
 class Column extends AbstractColumn {
-    constructor(parent, columnName, columnType, nullable) {
-        super(parent, columnName, columnType, nullable);
+    constructor(parent, columnName, columnType) {
+        super(parent, columnName, columnType);
     }
-    serial() {
-        this.autoIncrementFlag = true;
+    notNull() {
+        this.isNullableFlag = false;
         return this;
     }
     primaryKey() {
@@ -63,19 +55,15 @@ class Column extends AbstractColumn {
         this.onUpdate = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onUpdate) ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
         return this;
     }
-    autoIncrement() {
-        this.autoIncrementFlag = true;
-        return this;
-    }
 }
 exports.Column = Column;
 // eslint-disable-next-line max-len
 class IndexedColumn extends AbstractColumn {
     constructor(parent, columnName, columnType, nullable) {
-        super(parent, columnName, columnType, nullable);
+        super(parent, columnName, columnType);
     }
-    serial() {
-        this.autoIncrementFlag = true;
+    notNull() {
+        this.isNullableFlag = false;
         return this;
     }
     primaryKey() {
@@ -90,9 +78,5 @@ class IndexedColumn extends AbstractColumn {
         this.onUpdate = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onUpdate) ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
         return this;
     }
-    autoIncrement() {
-        this.autoIncrementFlag = true;
-        return this;
-    }
 }
 exports.IndexedColumn = IndexedColumn;

package/columns/index.d.ts

@@ -1,4 +1,4 @@
-export { Column } from './column';
+export { Column, ExtractColumnType, Defaults } from './column';
 export { default as PgBigDecimal } from './types/pgBigDecimal';
 export { default as PgBigInt } from './types/pgBigInt';
 export { default as PgBoolean } from './types/pgBoolean';

package/columns/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PgVarChar = exports.PgTimestamp = exports.PgTime = exports.PgText = exports.PgJsonb = exports.PgInteger = exports.PgBoolean = exports.PgBigInt = exports.PgBigDecimal = exports.Column = void 0;
+exports.PgVarChar = exports.PgTimestamp = exports.PgTime = exports.PgText = exports.PgJsonb = exports.PgInteger = exports.PgBoolean = exports.PgBigInt = exports.PgBigDecimal = exports.Defaults = exports.Column = void 0;
 var column_1 = require("./column");
 Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return column_1.Column; } });
+Object.defineProperty(exports, "Defaults", { enumerable: true, get: function () { return column_1.Defaults; } });
 var pgBigDecimal_1 = require("./types/pgBigDecimal");
 Object.defineProperty(exports, "PgBigDecimal", { enumerable: true, get: function () { return pgBigDecimal_1.default; } });
 var pgBigInt_1 = require("./types/pgBigInt");

package/columns/types/pgBigInt.d.ts

@@ -1,8 +1,15 @@
 import ColumnType from './columnType';
-export default class PgBigInt extends ColumnType<number> {
+export default class PgBigInt53 extends ColumnType<number> {
     dbName: string;
     constructor();
-    getDbName(): string;
+    getDbName: () => string;
     insertStrategy: (value: number) => string;
     selectStrategy(value: string): number | undefined;
 }
+export declare class PgBigInt64 extends ColumnType<bigint> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: bigint) => string;
+    selectStrategy(value: string): bigint | undefined;
+}

package/columns/types/pgBigInt.js

@@ -1,17 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgBigInt64 = void 0;
+// eslint-disable-next-line max-classes-per-file
 const columnType_1 = require("./columnType");
-class PgBigInt extends columnType_1.default {
+class PgBigInt53 extends columnType_1.default {
     constructor() {
         super();
+        this.getDbName = () => this.dbName;
         this.insertStrategy = (value) => `${value}`;
         this.dbName = 'BIGINT';
     }
-    getDbName() {
-        return this.dbName;
-    }
     selectStrategy(value) {
         return value ? parseInt(value, 10) : undefined;
     }
 }
-exports.default = PgBigInt;
+exports.default = PgBigInt53;
+class PgBigInt64 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGINT';
+    }
+    selectStrategy(value) {
+        return value ? BigInt(value) : undefined;
+    }
+}
+exports.PgBigInt64 = PgBigInt64;

package/columns/types/pgBigSerial.d.ts

@@ -0,0 +1,15 @@
+import ColumnType from './columnType';
+export default class PgBigSerial53 extends ColumnType<number> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: number) => string;
+    selectStrategy(value: string): number | undefined;
+}
+export declare class PgBigSerial64 extends ColumnType<bigint> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: bigint) => string;
+    selectStrategy(value: string): bigint | undefined;
+}