drizzle-orm 0.10.21 → 0.10.24

package/dist/types/type.d.ts

@@ -0,0 +1,10 @@
+export default class Enum<T extends string> {
+    name: string;
+    values: T[];
+    constructor(name: string, values: T[]);
+}
+export declare type ExtractEnumValues<T> = T extends Enum<infer TValues> ? TValues : never;
+export declare function createEnum<T extends string>({ alias, values }: {
+    alias: string;
+    values: T[];
+}): Enum<T>;

package/dist/types/type.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnum = void 0;
+class Enum {
+    constructor(name, values) {
+        this.name = name;
+        this.values = values;
+    }
+}
+exports.default = Enum;
+function createEnum({ alias, values }) {
+    return new Enum(alias, values);
+}
+exports.createEnum = createEnum;

package/dist/utils/ecranate.d.ts

@@ -0,0 +1,2 @@
+export declare const ecranate: (data: string) => string;
+export declare const shouldEcranate: (value: any) => boolean;

package/dist/utils/ecranate.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldEcranate = exports.ecranate = void 0;
+const ecranate = (data) => `"${data}"`;
+exports.ecranate = ecranate;
+const shouldEcranate = (value) => typeof value === 'string'
+    || value instanceof Date || value === Object(value);
+exports.shouldEcranate = shouldEcranate;

package/package.json

@@ -1,19 +1,18 @@
 {
   "name": "drizzle-orm",
-  "version": "0.10.21",
+  "version": "0.10.24",
   "description": "",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "NODE_ENV=production webpack",
-    "ts": "tsc",
-    "lint": "eslint ./src --ext .ts",
-    "run": "ts-node src/tables/newAbstractTable.ts"
-  },
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/lambda-direct/drizzle-orm.git"
+    "url": "git+https://github.com/lambda-direct/drizzle-orm.git",
+    "directory": "orm"
   },
   "keywords": [],
   "author": "",
@@ -23,17 +22,23 @@
   },
   "homepage": "https://github.com/lambda-direct/drizzle-orm#readme",
   "devDependencies": {
-    "@types/node": "^17.0.20",
     "@typescript-eslint/eslint-plugin": "4.10.0",
     "eslint": "7.15.0",
     "eslint-config-airbnb-typescript": "12.0.0",
     "eslint-plugin-import": "2.22.1",
     "eslint-plugin-prefer-arrow": "1.2.2",
     "ts-node": "^10.0.0",
-    "typescript": "^4.2.4"
+    "typescript": "4.2.4"
   },
   "dependencies": {
     "@types/pg": "^8.6.1",
     "pg": "^8.6.0"
-  }
-}
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "ts": "tsc",
+    "lint": "eslint ./src --ext .ts",
+    "run": "ts-node src/tables/newAbstractTable.ts"
+  },
+  "readme": "# DrizzleORM\n\n**DrizzleORM** is an ORM framework for \n[TypeScript](https://www.typescriptlang.org/).\nIt offers you several levels of Database communication:\n* Typesafe Table View approach \n* Typesafe Query Builder\n* Simple SQL query execution\n\nDrizzle ORM is highly influenced by [Exposed](https://github.com/JetBrains/Exposed) and Jetbrains development methodology\n\n## Supported Databases\n\n* PostgreSQL\n\n## Links\n\nIn Progress\n\n## Installing\n\n```bash\nnpm install drizzle-orm drizzle-kit\n```\n#### **In Progress**\n```bash\nyarn add drizzle-orm drizzle-kit\nbower install drizzle-orm drizzle-kit\n```\n\n## Connecting to database\n\n```tsx\nimport { DbConnector } from \"drizzle-orm\";\n\n// connect via postgresql connection url\nconst db = await new DbConnector()\n\t.connectionString(\"postgres://user:password@host:port/db\")\n\t.connect();\n\n// or by params\nconst db = await new DbConnector()\n\t.params({\n\t\thost: '0.0.0.0',\n\t\tport: 5432,\n\t\tuser: 'user',\n\t\tpassword: 'password',\n\t\tdb: 'optional_db_name'\n\t}).connect();\n```\n## Project structure\n- tables folder\n- migrations folder\n\n## Create tables\n### Users Table\n---\n```typescript\n\nexport const rolesEnum = createEnum({ alias: 'test-enum', values: ['user', 'guest', 'admin'] });\n\nexport default class UsersTable extends AbstractTable<UsersTable> {\n  public id = this.serial('id').primaryKey();\n  public fullName = this.text('full_name');\n\n  public phone = this.varchar('phone', { size: 256 });\n  public media = this.jsonb<string[]>('media');\n  public decimalField = this.decimal('test', { precision: 100, scale: 2 }).notNull();\n  public bigIntField = this.bigint('test1', 'max_bytes_53');\n  public role = this.type(rolesEnum, 'name_in_table').notNull();\n\n  public createdAt = this.timestamp('created_at').notNull();\n\n  public createdAtWithTimezone = this.timestamptz('created_at_time_zone');\n\n  public updatedAt = this.timestamp('updated_at').defaultValue(Defaults.CURRENT_TIMESTAMP);\n  public isArchived = this.bool('is_archived').defaultValue(false);\n\n  public phoneFullNameIndex = this.index([this.phone, this.fullName]);\n  public phoneIndex = this.uniqueIndex(this.phone);\n\n  public tableName(): string {\n    return 'users';\n  }\n}\n```\n### Cities Table\n---\n```typescript\ninterface CityMeta {\n  population: number,\n  connection: string,\n}\n\nexport default class CitiesTable extends AbstractTable<CitiesTable> {\n  public id = this.serial('id').primaryKey();\n\n  public foundationDate = this.timestamp('name').notNull();\n  public location = this.varchar('page', { size: 256 });\n\n  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onUpdate: 'CASCADE' });\n\n  public metadata = this.jsonb<CityMeta>('metadata');\n\n  public tableName(): string {\n    return 'cities';\n  }\n}\n```\n### User Groups Table\n---\n```typescript\nexport default class UserGroupsTable extends AbstractTable<UserGroupsTable> {\n  public id = this.serial('id').primaryKey();\n\n  public name = this.varchar('name');\n  public description = this.varchar('description');\n\n  public tableName(): string {\n    return 'user_groups';\n  }\n}\n```\n### User to User Groups Table\n---\n#### Many to many connection between Users and User Groups\n```typescript\nexport default class UsersToUserGroupsTable extends AbstractTable<UsersToUserGroupsTable> {\n  public groupId = this.int('city_id').foreignKey(UserGroupsTable, (table) => table.id, { onDelete: 'CASCADE' });\n  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onDelete: 'CASCADE' });\n\n  public manyToManyIndex = this.index([this.groupId, this.userId]);\n\n  public tableName(): string {\n    return 'users_to_user_groups';\n  }\n}\n```\n\n## CRUD\n### **SELECT**\n---\n```typescript\nconst db = await new DbConnector()\n  .connectionString('postgresql://postgres@127.0.0.1/drizzle')\n  .connect();\n\nconst usersTable = new UsersTable(db);\n\n// select all\nconst allSelect = await usersTable.select().all();\n\n// select first\nconst firstSelect = await usersTable.select().findOne();\n```\n#### **Sorting and Filtering**\n---\n##### Select all records from `Users` where phone is `\"hello\"`\n```typescript\nconst eqSelect = await usersTable.select().where(\n  eq(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where **both** phone is `\"hello\"` **and** phone is `\"hello\"`\n```typescript\nconst andSelect = await usersTable.select().where(\n  and([\n    eq(usersTable.phone, 'hello'),\n    eq(usersTable.phone, 'hello')\n  ]),\n).all();\n```\n##### Select all records from `Users` where **either** phone is `\"hello\"` **or** phone is `\"hello\"`\n```typescript\nconst orSelect = await usersTable.select().where(\n  or([eq(usersTable.phone, 'hello')]),\n).all();\n```\n##### Select all records from `Users` using **LIMIT** and **OFFSET**\n```typescript\nconst limitOffsetSelect = await usersTable.select().limit(10).offset(10).all();\n```\n##### Select all records from `Users` where `phone` contains `\"hello\"`\n```typescript\nconst likeSelect = await usersTable.select().where(\n  like(usersTable.phone, '%hello%')\n).all();\n```\n##### Select all records from `Users` where `phone` equals to some of values from array\n```typescript\nconst inArraySelect = usersTable.select().where(\n  inArray(usersTable.phone, ['hello'])\n).all();\n```\n##### Select all records from `Users` where `phone` greater(**>**) than `\"hello\"`\n```typescript\nconst greaterSelect = usersTable.select().where(\n  greater(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where `phone` less(**<**) than `\"hello\"`\n```typescript\nconst lessSelect = usersTable.select().where(\n  less(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where `phone` greater or equals(**>=**) than `\"hello\"`\n```typescript\nconst greaterEqSelect = usersTable.select().where(\n  greaterEq(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where `phone` less or equals(**<=**) \n```typescript\nconst lessEqSelect = usersTable.select().where(\n  lessEq(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where `phone` is **NULL**\n```typescript\nconst isNullSelect = usersTable.select().where(\n  isNull(usersTable.phone)\n).all();\n```\n##### Select all records from `Users` where `phone` not equals to `\"hello\"`\n```typescript\nconst notEqSelect = usersTable.select().where(\n  notEq(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` ordered by `phone` in ascending order\n```typescript\nconst ordered = await usersTable.select().orderBy((table) => table.phone, Order.ASC).all();\n```\n#### **Partial Selecting**\n ```typescript\n    const partialSelect = await usersTable.select({\n      mappedId: usersTable.id,\n      mappedPhone: usersTable.phone,\n    }).all();\n\n    // Usage\n    const { mappedId, mappedPhone } = partialSelect;\n ```\n\n\n### **Update**\n---\n##### Update `fullName` to `newName` in `Users` where phone is `\"hello\"`\n```typescript\nawait usersTable.update()\n  .where(eq(usersTable.phone, 'hello'))\n  .set({ fullName: 'newName' })\n  .execute();\n```\n##### Update `fullName` to `newName` in `Users` where phone is `\"hello\"` returning updated `User` model\n```typescript\nawait usersTable.update()\n  .where(eq(usersTable.phone, 'hello'))\n  .set({ fullName: 'newName' })\n  .all();\n```\n##### Update `fullName` to `newName` in `Users` where phone is `\"hello\"` returning updated `User` model\n```typescript\nawait usersTable.update()\n  .where(eq(usersTable.phone, 'hello'))\n  .set({ fullName: 'newName' })\n  .findOne();\n```\n\n### **Delete**\n##### Delete `user` where phone is `\"hello\"`\n```typescript\nawait usersTable.delete()\n      .where(eq(usersTable.phone, 'hello'))\n      .execute();\n```\n##### Delete `user` where phone is `\"hello\"` returning updated `User` model\n```typescript\nawait usersTable.delete()\n      .where(eq(usersTable.phone, 'hello'))\n      .all();\n```\n##### Delete `user` where phone is `\"hello\"` returning updated `User` model\n```typescript\nawait usersTable.delete()\n      .where(eq(usersTable.phone, 'hello'))\n      .findOne();\n```\n\n### **Insert**\n##### Insert `user` with required fields\n```typescript\nawait usersTable.insert({\n  test: 1,\n  createdAt: new Date(),\n}).execute();\n```\n##### Insert `user` with required fields and get all rows as array\n```typescript\nconst user = await usersTable.insert({\n  test: 1,\n  createdAt: new Date(),\n}).all();\n```\n##### Insert `user` with required fields and get inserted entity\n```typescript\nconst user = await usersTable.insert({\n  test: 1,\n  createdAt: new Date(),\n}).findOne();\n```\n##### Insert many `users` with required fields and get all inserted entities\n```typescript\nconst users = await usersTable.insertMany([{\n      test: 1,\n      createdAt: new Date(),\n    }, {\n      test: 2,\n      createdAt: new Date(),\n    }]).all();\n```\n##### Insert many `users` with required fields and get all inserted entities. If such user already exists - update `phone` field\n```typescript\nawait usersTable.insertMany([{\n      test: 1,\n      createdAt: new Date(),\n    }, {\n      test: 2,\n      createdAt: new Date(),\n    }])\n      .onConflict(\n        (table) => table.phoneIndex,\n        { phone: 'confilctUpdate' },\n      ).all();\n```\n\n## Joins\n### Join One-To-Many Tables\n##### Join Cities with Users and map to city object with full user\n```typescript\nconst usersTable = new UsersTable(db);\nconst citiesTable = new CitiesTable(db);\n\n const userWithCities = await citiesTable.select()\n      .where(eq(citiesTable.id, 1))\n      .leftJoin(UsersTable,\n        (city) => city.userId,\n        (users) => users.id)\n      .execute();\n\nconst citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));\n```\n\n### Join Many-To-Many Tables\n##### Join User Groups with Users, using many-to-many table and map response to get user object with groups array\n```typescript\n    const usersWithUserGroups = await usersToUserGroupsTable.select()\n      .where(eq(userGroupsTable.id, 1))\n      .leftJoin(UsersTable,\n        (userToGroup) => userToGroup.userId,\n        (users) => users.id)\n      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,\n        (userToGroup) => userToGroup.groupId,\n        (users) => users.id)\n      .execute();\n\n    const userGroupWithUsers = usersWithUserGroups.group({\n      one: (_, dbUser, dbUserGroup) => dbUser!,\n      many: (_, dbUser, dbUserGroup) => dbUserGroup!,\n    });\n\n    const userWithGroups: ExtractModel<UsersTable> & { groups: ExtractModel<UserGroupsTable>[] } = {\n      ...userGroupWithUsers.one,\n      groups: userGroupWithUsers.many,\n    };\n```\n##### Join User Groups with Users, using many-to-many table and map response to get user group object with users array\n```typescript\n    const usersWithUserGroups = await usersToUserGroupsTable.select()\n      .where(eq(userGroupsTable.id, 1))\n      .leftJoin(UsersTable,\n        (userToGroup) => userToGroup.userId,\n        (users) => users.id)\n      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,\n        (userToGroup) => userToGroup.groupId,\n        (users) => users.id)\n      .execute();\n\n    const userGroupWithUsers = usersWithUserGroups.group({\n      one: (_, dbUser, dbUserGroup) => dbUserGroup!,\n      many: (_, dbUser, dbUserGroup) => dbUser!,\n    });\n\n    const userWithGroups: ExtractModel<UserGroupsTable> & { users: ExtractModel<UsersTable>[] } = {\n      ...userGroupWithUsers.one,\n      users: userGroupWithUsers.many,\n    };\n```\n### Join using partial field select\n##### Join Cities with Users getting only needed fields form request\n```typescript\nawait citiesTable.select({\n      id: citiesTable.id,\n      userId: citiesTable.userId,\n    })\n    .where(eq(citiesTable.id, 1))\n    .leftJoin(UsersTable,\n        (city) => city.userId,\n        (users) => users.id,\n        {\n          id: usersTable.id,\n        })\n    .execute();\n\nconst citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));\n```\n\n\n## Migrations\n#### To run migrations generated by drizzle-kit you could use `Migrator` class\n##### Provide drizzle-kit config path\n```typescript\nawait drizzle.migrator(db).migrate('src/drizzle.config.yaml');\n```\n##### Another possibility is to provide object with path to folder with migrations\n```typescript\nawait drizzle.migrator(db).migrate({ migrationFolder: 'drizzle' });\n```\n\n\n## Raw query usage\n#### If you have some complex queries to execute and drizzle-orm can't handle them yet, then you could use `rawQuery` execution\n\n\n##### Execute custom raw query\n```typescript\nconst res: QueryResult<any> = await db.session().execute('SELECT * FROM users WHERE user.id = $1', [1]);\n```"
+}

package/tables/aggregators.d.ts

@@ -1,27 +0,0 @@
-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

@@ -1,56 +0,0 @@
-"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;