drizzle-orm 0.10.11 → 0.10.14

package/README.md

@@ -0,0 +1,439 @@
+# 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().findOne();
+```
+#### **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();
+```
+#### **Partial Selecting**
+ ```typescript
+    const partialSelect = await usersTable.select({
+      mappedId: usersTable.id,
+      mappedPhone: usersTable.phone,
+    }).all();
+
+    // Usage
+    const { mappedId, mappedPhone } = partialSelect;
+ ```
+
+
+### **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' })
+  .findOne();
+```
+
+### **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'))
+      .findOne();
+```
+
+### **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(),
+}).findOne();
+```
+##### 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(UsersToUserGroupsTable, 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(UsersToUserGroupsTable, 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,
+    };
+```
+### Join using partial field select
+##### Join Cities with Users getting only needed fields form request
+```typescript
+await citiesTable.select({
+      id: citiesTable.id,
+      userId: citiesTable.userId,
+    })
+    .where(eq(citiesTable.id, 1))
+    .leftJoin(UsersTable,
+        (city) => city.userId,
+        (users) => users.id,
+        {
+          id: usersTable.id,
+        })
+    .execute();
+
+const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
+```
+
+
+## Migrations
+#### To run migrations generated by drizzle-kit you could use `Migrator` class
+##### Provide drizzle-kit config path
+```typescript
+await drizzle.migrator(db).migrate('src/drizzle.config.yaml');
+```
+##### Another possibility is to provide object with path to folder with migrations
+```typescript
+await drizzle.migrator(db).migrate({ migrationFolder: 'drizzle' });
+```
+
+
+## Raw query usage
+#### If you have some complex queries to execute and drizzle-orm can't handle them yet, then you could use `rawQuery` execution
+
+
+##### Execute custom raw query
+```typescript
+const res: QueryResult<any> = await db.session().execute('SELECT * FROM users WHERE user.id = $1', [1]);
+```

package/builders/aggregators/selectAggregator.js

@@ -45,7 +45,8 @@ class SelectAggregator extends abstractAggregator_1.default {
         this.orderBy = (column, order) => {
             if (column !== null && column !== undefined) {
                 this._orderBy.push('ORDER BY ');
-                this._orderBy.push(`${column.getColumnName()} `);
+                const columnParent = this._joinCache[column.getParent().tableName()] ? this._joinCache[column.getParent().tableName()] : column.getParent();
+                this._orderBy.push(`${columnParent}.${ecranate_1.ecranate(column.getColumnName())} `);
                 this._orderBy.push(order_1.default[order]);
             }
             return this;

package/builders/requestBuilders/where/constArray.js

@@ -15,7 +15,7 @@ class ConstArray extends where_1.default {
                     finalArray.push(`$${nextPosition}`);
                     finalValues.push(`${value.toISOString()}`);
                 }
-                if (ecranate_1.shouldEcranate(value)) {
+                else if (ecranate_1.shouldEcranate(value)) {
                     finalArray.push(`$${nextPosition}`);
                     finalValues.push(`${value.toString()}`);
                 }
@@ -28,7 +28,7 @@ class ConstArray extends where_1.default {
                 }
                 nextPosition += 1;
             }
-            return { query: finalArray.join(','), values: finalValues };
+            return { query: finalArray.join(''), values: finalValues };
         };
         this.values = values;
     }

package/columns/column.js

@@ -16,7 +16,15 @@ class AbstractColumn {
         this.getParent = () => this.parent;
         this.getParentName = () => this.parentTableName;
         this.defaultValue = (value) => {
-            this.defaultParam = value;
+            if (Defaults[value] !== undefined) {
+                this.defaultParam = value;
+            }
+            else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+                this.defaultParam = value;
+            }
+            else {
+                this.defaultParam = `'${value}'`;
+            }
             return this;
         };
         this.unique = () => {

package/columns/types/pgInteger.js

@@ -9,6 +9,9 @@ class PgInteger extends columnType_1.default {
         this.dbName = 'INT';
     }
     selectStrategy(value) {
+        if (typeof value === 'string') {
+            return value ? parseInt(value, 10) : undefined;
+        }
         return value;
     }
 }

package/package.json

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

package/tables/aggregators.d.ts

@@ -0,0 +1,27 @@
+import { AbstractColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+import { DB } from '../db';
+import AbstractTable from './abstractTable';
+export declare class AggregatedColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> extends AbstractColumn<T, TNullable, TAutoIncrement, TParent> {
+    columnToAggregate?: AbstractColumn<ColumnType<any>, boolean, boolean>;
+    constructor(parent: TParent, columnName: string, columnType: T, columnToAggregate?: AbstractColumn<ColumnType<any>, boolean, boolean>);
+    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => AbstractColumn<T, boolean, boolean, TParent>, onConstraint: {
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT' | undefined;
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT' | undefined;
+    }): AbstractColumn<T, TNullable, TAutoIncrement, any>;
+    primaryKey(): AbstractColumn<T, boolean, boolean, TParent>;
+    notNull(): AbstractColumn<T, boolean, boolean, TParent>;
+    getAlias(): string;
+}
+export declare abstract class PgAggregatedColumnType<TType, T extends AbstractColumn<ColumnType<any>, boolean, boolean> = any> extends ColumnType<TType> {
+    protected dbName: string;
+    protected column?: T;
+    constructor(column?: T);
+    insertStrategy(value: TType): string;
+}
+export declare class PgCount<T extends AbstractColumn<ColumnType<any>, boolean, boolean> = any> extends PgAggregatedColumnType<number, T> {
+    constructor(column?: T);
+    getDbName(): string;
+    selectStrategy(value: any): number | undefined;
+}
+export declare const count: <TType extends ColumnType<any>, T extends AbstractColumn<TType, boolean, boolean, any>>(column?: T | undefined) => AggregatedColumn<PgCount<any>, false, true, any>;

package/tables/aggregators.js

@@ -0,0 +1,56 @@
+"use strict";
+/* eslint-disable import/no-cycle */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable max-len */
+/* eslint-disable max-classes-per-file */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.count = exports.PgCount = exports.PgAggregatedColumnType = exports.AggregatedColumn = void 0;
+const column_1 = require("../columns/column");
+const columnType_1 = require("../columns/types/columnType");
+const ecranate_1 = require("../utils/ecranate");
+class AggregatedColumn extends column_1.AbstractColumn {
+    constructor(parent, columnName, columnType, columnToAggregate) {
+        super(parent, columnName, columnType);
+        this.columnToAggregate = columnToAggregate;
+    }
+    foreignKey(table, callback, onConstraint) {
+        throw new Error('Method not implemented.');
+    }
+    primaryKey() {
+        throw new Error('Method not implemented.');
+    }
+    notNull() {
+        throw new Error('Method not implemented.');
+    }
+    getAlias() {
+        super.getAlias();
+        return `${this.columnName}`;
+    }
+}
+exports.AggregatedColumn = AggregatedColumn;
+class PgAggregatedColumnType extends columnType_1.default {
+    constructor(column) {
+        super();
+        this.column = column;
+    }
+    insertStrategy(value) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.PgAggregatedColumnType = PgAggregatedColumnType;
+class PgCount extends PgAggregatedColumnType {
+    constructor(column) {
+        super(column);
+    }
+    getDbName() {
+        const tableName = this.column ? `${this.column.getParentName()}.` : '*';
+        const columnName = this.column ? ecranate_1.ecranate(this.column.getColumnName()) : '';
+        return `COUNT(${tableName}${columnName})`;
+    }
+    selectStrategy(value) {
+        return value ? parseInt(value, 10) : undefined;
+    }
+}
+exports.PgCount = PgCount;
+const count = (column) => new AggregatedColumn(column ? column.getParent() : undefined, 'count', new PgCount(column), column);
+exports.count = count;

package/tables/inferTypes.d.ts

@@ -25,7 +25,7 @@ export declare type ExtractUpdateModel<TTable> = {
 } & {
     [Key in ExtractOptionalFieldNames<TTable>]?: ExtractCodeType<TTable[Key]> | UpdateCustomExpr<TTable[Key]>;
 };
-export declare type ExtractCodeType<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> = T extends AbstractColumn<ColumnType<infer TCodeType>, infer TNullable, infer TAutoIncrement> ? TCodeType : never;
+export declare type ExtractCodeType<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> = T extends AbstractColumn<ColumnType<infer TCodeType>, infer TNullable, infer TAutoIncrement, any> ? TCodeType : never;
 export declare type ExtractTypeEnum<T extends Type<any>> = T extends Type<infer TEnum> ? TEnum : never;
 export declare type Indexing = IndexedColumn<ColumnType, boolean, boolean> | TableIndex;
 export declare type AnyColumn = Column<ColumnType, boolean, boolean> | IndexedColumn<ColumnType, boolean, boolean>;

package/test.d.ts

@@ -0,0 +1 @@
+export {};

package/test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dbConnector_1 = require("./db/dbConnector");
+const usersTable_1 = require("./docs/tables/usersTable");
+const consoleLogger_1 = require("./logger/consoleLogger");
+const serializer_1 = require("./serializer/serializer");
+(async () => {
+    try {
+        const db = await new dbConnector_1.default()
+            .connectionString('postgresql://postgres@127.0.0.1/migrator')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        db.useLogger(new consoleLogger_1.default());
+        const ser = new serializer_1.default();
+        const res = ser.generate([usersTable], []);
+        console.log(JSON.stringify(res, null, 2));
+        // const f = {
+        //   id: count(usersTable.id),
+        // };
+        // type d = ExtractModel<typeof f>;
+        // const res = await usersTable.select({
+        //   piska: count(),
+        //   mongodibil: count(usersTable.phone),
+        // })
+        //   .where({
+        //     piska: eq(),
+        //     mongodibil: eq(usersTable.phone),
+        //   }).leftJoin(UsersTable, (table) => table.id, (table) => table.id)
+        //   .leftJoin(UsersTable, UsersTable, (table) => table.id, (table) => table.id)
+        //   .groupBy((table, join1, join2, join3) => [table.id, join1.id, join1.phone])
+        //   .orderBy((table, join1, join2, join3) => [{table.id}, join1.id, join1.phone])
+        //   .execute();
+        // const res = await usersTable.select()
+        //   .groupBy((table, join1, join2, join3) => [table.id, join1.id, join1.phone])
+        //   .leftJoin(UsersTable, (table) => table.id, (table) => table.id)
+        //   .leftJoin(UsersTable, UsersTable, (table) => table.id, (table) => table.id)
+        //   .leftJoin(UsersTable, UsersTable, (table) => table.id, (table) => table.id)
+        //   // .groupBy({
+        //   //   usersTable: usersTable.id,
+        //   //   firstJoin: [usersTable.id],
+        //   //   secondJoin: usersTable.id,
+        //   //   thirdJoin: usersTable.id,
+        //   // })
+        //   .execute();
+        // console.log(res);
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();