drizzle-orm 0.10.25 → 0.10.28

package/src/docs/cases/simple_join.ts

@@ -0,0 +1,140 @@
+/* eslint-disable max-len */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Create, DbConnector } from '../..';
+import { eq } from '../../builders';
+import ConsoleLogger from '../../logger/consoleLogger';
+import { ExtractModel } from '../../tables/inferTypes';
+import CitiesTable from '../tables/citiesTable';
+import UserGroupsTable from '../tables/userGroupsTable';
+import UsersTable from '../tables/usersTable';
+import UsersToUserGroupsTable from '../tables/usersToUserGroups';
+
+(async () => {
+  try {
+    const db = await new DbConnector()
+      .connectionString('postgresql://postgres@127.0.0.1/migrator')
+      .connect();
+
+    db.useLogger(new ConsoleLogger());
+
+    const usersTable = new UsersTable(db);
+    const citiesTable = new CitiesTable(db);
+    const usersToUserGroupsTable = new UsersToUserGroupsTable(db);
+    const userGroupsTable = new UserGroupsTable(db);
+
+    // await db.session().execute(Create.table(usersTable).build());
+    // await db.session().execute(Create.table(citiesTable).build());
+    // await db.session().execute(Create.table(userGroupsTable).build());
+    // await db.session().execute(Create.table(usersToUserGroupsTable).build());
+
+    const userRes = await usersTable.insertMany([{
+      decimalField: 4.2,
+      createdAt: new Date(),
+      role: 'foo',
+    }, {
+      decimalField: 5.8,
+      createdAt: new Date(),
+      role: 'foo',
+    }]).all();
+
+    const citiesRes = await citiesTable.insertMany([{
+      foundationDate: new Date(),
+      userId: userRes[0]?.id!,
+    }, {
+      foundationDate: new Date(),
+      userId: userRes[1]?.id!,
+    }]).all();
+
+    const userGroups = await userGroupsTable.insertMany([{
+      name: 'firstGroup',
+    }, {
+      name: 'secondGroup',
+    }]).all();
+
+    await usersToUserGroupsTable.insertMany([{
+      userId: userRes[0]?.id!,
+      groupId: userGroups[0]?.id!,
+    },
+    {
+      userId: userRes[1]?.id!,
+      groupId: userGroups[1]?.id!,
+    }]).execute();
+
+    // map case
+    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 }));
+
+    // foreach case
+    // const userWithCities1 = await citiesTable.select()
+    //   .where(eq(citiesTable.id, 1))
+    //   .leftJoin(UsersTable,
+    //     (city) => city.userId,
+    //     (users) => users.id)
+    //   .execute();
+
+    // let user;
+    // const cities = [];
+
+    // userWithCities.foreach((dbCity, dbUser) => {
+    //   cities.push(dbCity);
+    //   user = dbUser;
+    // });
+
+    // const usersTable = new UsersTable(db);
+    // const citiesTable = new CitiesTable(db);
+
+    const sdf = 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();
+
+    // group case
+    const usersWithUserGroups = await usersToUserGroupsTable.select()
+      .where(eq(userGroupsTable.id, 1))
+      .leftJoin(UsersTable,
+        (userToGroup) => userToGroup.userId,
+        (users) => users.id,
+        {
+          id: usersTable.id,
+        })
+      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,
+        (userToGroup) => userToGroup.groupId,
+        (userGroup) => userGroup.id,
+        {
+          id: userGroupsTable.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,
+    // };
+
+    // console.log('city', city!);
+    // console.log('cityUsers', cityUsers);
+    // console.log('cityWithUsers', forEachCities);
+    // console.log('cityWithUsers1', forEachUsers);
+
+    // how to handle many-to-many relations
+  } catch (e) {
+    console.log(e);
+  }
+})();

package/src/docs/cases/simple_select.ts

@@ -0,0 +1,72 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Create, DbConnector } from '../..';
+import {
+  and, eq, like, or,
+} from '../../builders';
+import Order from '../../builders/highLvlBuilders/order';
+import {
+  greater, greaterEq, inArray, isNull, less, lessEq, notEq,
+} from '../../builders/requestBuilders/where/static';
+import ConsoleLogger from '../../logger/consoleLogger';
+import UsersTable from '../tables/usersTable';
+
+(async () => {
+  try {
+    const db = await new DbConnector()
+      .connectionString('postgresql://postgres@127.0.0.1/migrator')
+      .connect();
+
+    const usersTable = new UsersTable(db);
+
+    db.useLogger(new ConsoleLogger());
+
+    // select all
+    const allSelect = await usersTable.select().all();
+
+    // select first
+    const firstSelect = await usersTable.select().all();
+
+    // select using filters
+    const eqSelect = await usersTable.select().where(eq(usersTable.phone, 'hello')).all();
+
+    const andSelect = await usersTable.select().where(
+      and([eq(usersTable.phone, 'hello')]),
+    ).all();
+
+    const orSelect = await usersTable.select().where(
+      or([eq(usersTable.phone, 'hello')]),
+    ).all();
+
+    // select using limit, offset
+    const limitOffsetSelect = await usersTable.select().limit(20).offset(20).all();
+
+    const likeSelect = await usersTable.select().where(like(usersTable.phone, 'hello')).all();
+
+    const inArraySelect = await usersTable.select().where(inArray(usersTable.phone, ['hello'])).all();
+
+    const greaterSelect = await usersTable.select().where(greater(usersTable.bigIntField, 3)).all();
+
+    const lessSelect = await usersTable.select().where(less(usersTable.bigIntField, 3)).all();
+
+    const greaterEqSelect = await usersTable.select().where(greaterEq(usersTable.bigIntField, 3))
+      .all();
+
+    const lessEqSelect = await usersTable.select().where(lessEq(usersTable.bigIntField, 3));
+
+    const isNullSelect = await usersTable.select().where(isNull(usersTable.phone)).all();
+
+    const notEqSelect = await usersTable.select().where(notEq(usersTable.phone, 'hello')).all();
+
+    const partialSelect = await usersTable.select({
+      mappedId: usersTable.id,
+      mappedPhone: usersTable.phone,
+    }).all();
+
+    // const { mappedId, mappedPhone } = partialSelect;
+
+    // ordered select
+    const ordered = await usersTable.select().orderBy((table) => table.phone, Order.ASC).all();
+  } catch (e) {
+    console.log(e);
+  }
+})();

package/src/docs/cases/simple_update.ts

@@ -0,0 +1,40 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { DbConnector } from '../..';
+import { eq } from '../../builders';
+import ConsoleLogger from '../../logger/consoleLogger';
+import CitiesTable from '../tables/citiesTable';
+import UserGroupsTable from '../tables/userGroupsTable';
+import UsersTable from '../tables/usersTable';
+
+(async () => {
+  try {
+    const db = await new DbConnector()
+      .connectionString('postgresql://postgres@127.0.0.1/migrator')
+      .connect();
+
+    db.useLogger(new ConsoleLogger());
+
+    const usersTable = new UsersTable(db);
+    const citiesTable = new CitiesTable(db);
+    const userGroupsTable = new UserGroupsTable(db);
+
+    await usersTable.update()
+      .where(eq(usersTable.phone, 'hello'))
+      .set({ fullName: 'newName' })
+      .execute();
+
+    const updatedCities = await citiesTable.update()
+      .where(eq(citiesTable.location, 'USA'))
+      .set({ metadata: { population: 1, connection: 'first' } })
+      .all();
+
+    console.log(updatedCities);
+
+    const updatedUserGroup = await userGroupsTable.update()
+      .where(eq(userGroupsTable.id, 1))
+      .set({ description: 'updated description' })
+      .all();
+  } catch (e) {
+    console.log(e);
+  }
+})();

package/src/docs/tables/citiesTable.ts

@@ -0,0 +1,22 @@
+import AbstractTable from '../../tables/abstractTable';
+import UsersTable from './usersTable';
+
+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';
+  }
+}

package/src/docs/tables/userGroupsTable.ts

@@ -0,0 +1,12 @@
+import AbstractTable from '../../tables/abstractTable';
+
+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';
+  }
+}

package/src/docs/tables/usersTable.ts

@@ -0,0 +1,33 @@
+/* eslint-disable max-classes-per-file */
+// import { Defaults } from '../../columns/column';
+import { Defaults } from '../../columns/column';
+import AbstractTable from '../../tables/abstractTable';
+import { createEnum } from '../../types/type';
+// import { rolesEnum } from '../types/rolesType';
+
+export const rolesEnum = createEnum({ alias: 'test-enum', values: ['foo', 'bar', 'baz'] });
+
+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');
+
+  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';
+  }
+}

package/src/docs/tables/usersToUserGroups.ts

@@ -0,0 +1,14 @@
+import AbstractTable from '../../tables/abstractTable';
+import UserGroupsTable from './userGroupsTable';
+import UsersTable from './usersTable';
+
+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';
+  }
+}

package/src/docs/types/rolesType.ts

@@ -0,0 +1,4 @@
+import { createEnum } from '../../types/type';
+
+// eslint-disable-next-line import/prefer-default-export
+export const rolesEnum = createEnum({ alias: 'test-enum', values: ['foo', 'bar', 'baz'] });

package/src/errors/baseError.ts

@@ -0,0 +1,47 @@
+/* eslint-disable max-classes-per-file */
+export interface Failure {
+  type: PgSessionError;
+  reason: Error;
+}
+
+export enum PgSessionError {
+  PgQueryExecutionError,
+}
+
+export type Either<L, A> = Left<L, A> | Right<L, A>;
+
+export class Left<L, A> {
+  public readonly value: L;
+
+  public constructor(value: L) {
+    this.value = value;
+  }
+
+  public isLeft(): this is Left<L, A> {
+    return true;
+  }
+
+  public isRight(): this is Right<L, A> {
+    return false;
+  }
+}
+
+export class Right<L, A> {
+  public readonly value: A;
+
+  public constructor(value: A) {
+    this.value = value;
+  }
+
+  public isLeft(): this is Left<L, A> {
+    return false;
+  }
+
+  public isRight(): this is Right<L, A> {
+    return true;
+  }
+}
+
+export const left = <L, A>(l: L): Either<L, A> => new Left(l);
+
+export const right = <L, A>(a: A): Either<L, A> => new Right<L, A>(a);

package/src/errors/builderError.ts

@@ -0,0 +1,31 @@
+import Expr from '../builders/requestBuilders/where/where';
+import { AbstractColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+
+export enum BuilderType{
+  SELECT,
+  JOINED_SELECT,
+  TWO_JOINED_SELECT,
+  DELETE,
+  INSERT,
+  UPDATE,
+}
+
+export default class BuilderError extends Error {
+  public constructor(
+    builderType: BuilderType,
+    tableName: string,
+    columns: AbstractColumn<ColumnType>[],
+    reason: Error,
+    filter?: Expr,
+  ) {
+    super('');
+    this.message = ` Error while building select query from ${tableName}\n-----\nIf you see current error, please create [github issue](https://github.com/lambda-direct/drizzle-orm/issues) and provide following information\n
+Reason: ${reason.message}
+Query builder: ${BuilderType[builderType]}
+Table name: ${tableName}
+Filter query: ${filter ? filter.toQuery().query : 'undefined'}
+Values: ${filter ? filter.toQuery().values : 'undefined'}
+Column names: ${columns.map((column) => column.getColumnName()).join(', ')}\n-----\n`;
+  }
+}

package/src/errors/dbErrors.ts

@@ -0,0 +1,24 @@
+/* eslint-disable max-classes-per-file */
+export class DatabaseSelectError extends Error {
+  public constructor(tableName: string, reason: Error, query: string) {
+    super(` Got an error, while selecting from ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+  }
+}
+
+export class DatabaseDeleteError extends Error {
+  public constructor(tableName: string, reason: Error, query: string) {
+    super(` Got an error, while deleting from ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+  }
+}
+
+export class DatabaseInsertError extends Error {
+  public constructor(tableName: string, reason: Error, query: string) {
+    super(` Got an error, while inserting to ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+  }
+}
+
+export class DatabaseUpdateError extends Error {
+  public constructor(tableName: string, reason: Error, query: string) {
+    super(` Got an error, while updating ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+  }
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+/* eslint-disable import/export */
+import { ClientConfig } from 'pg';
+import { DB, DbConnector } from './db';
+import Migrator from './migrator/migrator';
+
+export * from './db';
+export * from './builders';
+export * from './columns';
+export * from './tables';
+
+export const drizzle = {
+  async connect(config: ClientConfig): Promise<DB> {
+    const dbConnector: DbConnector = new DbConnector().params(config);
+    return dbConnector.connect();
+  },
+
+  migrator(db: DB): Migrator {
+    return new Migrator(db);
+  },
+};

package/src/indexes/tableIndex.ts

@@ -0,0 +1,25 @@
+import { Column } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+
+export default class TableIndex {
+  private _columns: Column<ColumnType<any>, boolean, boolean>[] = [];
+  private _tableName: string;
+  private _isUnique: boolean;
+
+  public constructor(tableName: string,
+    columns: Column<ColumnType<any>, boolean, boolean>[],
+    isUnique: boolean = false) {
+    this._columns = columns;
+    this._tableName = tableName;
+    this._isUnique = isUnique;
+  }
+
+  public getColumns = (): Column<ColumnType<any>, boolean, boolean>[] => this._columns;
+
+  public indexName = (): string => {
+    const columnNames = this._columns.map((column) => column.getColumnName());
+    return `${this._tableName}_${columnNames.join('_')}_index`;
+  };
+
+  public isUnique = (): boolean => this._isUnique;
+}

package/src/logger/abstractLogger.ts

@@ -0,0 +1,4 @@
+export default abstract class BaseLogger {
+  public abstract info(msg: string): void;
+  public abstract error(msg: string): void;
+}

package/src/logger/consoleLogger.ts

@@ -0,0 +1,11 @@
+import BaseLogger from './abstractLogger';
+
+export default class ConsoleLogger extends BaseLogger {
+  public info(msg: string): void {
+    console.log(`INFO: ${msg}`);
+  }
+
+  public error(msg: string): void {
+    console.log(`ERROR: ${msg}`);
+  }
+}

package/src/mappers/responseMapper.ts

@@ -0,0 +1,46 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+import { ExtractModel } from '../tables/inferTypes';
+
+// eslint-disable-next-line max-len
+// const checkProperties = (obj: any) => Object.values(obj).every((x) => x === null || Number.isNaN(x));
+
+export default class QueryResponseMapper {
+  public static map = <ITable>(mappedServiceToDb: { [name in keyof ExtractModel<ITable>]
+    : AbstractColumn<ColumnType>; },
+    queryResult: QueryResult<any>, joinId?: number) => {
+    const response: Array<ExtractModel<ITable>> = [];
+
+    queryResult.rows.forEach((row) => {
+      const mappedRow: ExtractModel<ITable> = {} as ExtractModel<ITable>;
+
+      Object.keys(mappedServiceToDb).forEach((key) => {
+        const column = mappedServiceToDb[key as keyof ExtractModel<ITable>];
+        const alias = `${column.getAlias()}${joinId ? `_${joinId}` : ''}`;
+        const value = column.getColumnType().selectStrategy(row[alias]) as any;
+        mappedRow[key as keyof ExtractModel<ITable>] = value === null ? undefined : value;
+      });
+      response.push(mappedRow);
+    });
+    return response;
+  };
+
+  public static partialMap = <T>(partial: { [name: string]
+  : AbstractColumn<ColumnType>; }, queryResult: QueryResult<any>, joinId?: number) => {
+    const response: Array<ExtractModel<T>> = [];
+
+    queryResult.rows.forEach((row) => {
+      const mappedRow: ExtractModel<T> = {} as ExtractModel<T>;
+
+      Object.keys(partial).forEach((key) => {
+        const column = partial[key];
+        const alias = `${column.getAlias()}${joinId ? `_${joinId}` : ''}`;
+        const value = column.getColumnType().selectStrategy(row[alias]) as any;
+        mappedRow[key as keyof ExtractModel<T>] = value === null ? undefined : value;
+      });
+      response.push(mappedRow);
+    });
+    return response;
+  };
+}

package/src/migrator/migrator.ts

@@ -0,0 +1,97 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable import/export */
+/* eslint-disable max-classes-per-file */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto'
+import { Create } from '../builders';
+import Transaction from '../builders/transaction/transaction';
+import Db from '../db/db';
+import { MigrationsTable } from '../tables';
+
+export type InCodeConfig = { migrationFolder: string };
+
+export default class Migrator {
+  public constructor(private db: Db) {
+  }
+
+  public async migrate(configPath: string): Promise<void>
+  public async migrate(config: InCodeConfig): Promise<void>
+  public async migrate(configPath?: unknown) {
+    let migrationFolderTo: string | undefined;
+    if (typeof configPath === 'string') {
+      const configAsString = fs.readFileSync(path.resolve('.', configPath), 'utf8');
+      const splitted = configAsString.trim().split('\n');
+      // eslint-disable-next-line no-restricted-syntax
+      for (const split of splitted) {
+        const entry = split.trim().split(':');
+        const key = entry[0];
+        const value = entry[1].trim().replace(/['"]+/g, '');
+
+        if (key === 'migrationRootFolder') {
+          // proceed value
+          migrationFolderTo = value;
+        }
+      }
+    } else {
+      migrationFolderTo = (configPath as InCodeConfig).migrationFolder;
+    }
+
+    if (!migrationFolderTo) {
+      throw Error('no migration folder defined');
+    }
+
+    const migrationTable = new MigrationsTable(this.db);
+
+    await this.db.session().execute(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(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 year = Number(migrationFolder.slice(0, 4));
+        // second param for Date() is month index, that started from 0, so we need
+        // to decrement a value for month
+        const month = Number(migrationFolder.slice(4, 6)) - 1;
+        const day = Number(migrationFolder.slice(6, 8));
+        const hour = Number(migrationFolder.slice(8, 10));
+        const min = Number(migrationFolder.slice(10, 12));
+        const sec = Number(migrationFolder.slice(12, 14));
+
+        const folderAsMillis = new Date(year, month, day, hour, min, sec).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();
+    } catch (e) {
+      // if (this.db.logger()) {
+      //   this.db.logger()!.error(e);
+      // }
+      transaction.rollback();
+      throw e
+    }
+  }
+
+  private generateHash(value: string): string {
+    return crypto.createHash('sha256').update(value).digest('hex')
+  }
+}