drizzle-orm 0.11.0 → 0.11.3

package/README.md

@@ -1,294 +1,198 @@
-# 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
-
+## DrizzleORM
+DrizzleORM is a TypeScript ORM library with a [drizzle-kit](https://github.com/lambda-direct/drizzle-orm/tree/develop/kit) CLI companion for automatic SQL migrations generation. It's meant to be a library, not a framework, stay as an opt-in solution all the time at any levels. We try to follow SQL-like syntax whenever possible, be strongly typed ground top and fail in compile time, not in runtime. We implemented best in class `joins` and second to none `migrations generation`. Library has almost zero dependencies and being battle tested on production projects by multiple teams 🚀
+
+| database    | support |
+|:--          |  :---:  |
+| PostgreSQL  | ✅      |
+| MySQL       | ⏳      |
+| DynamoDB    | ⏳      |
+| SQLite      | ⏳      |
+| MS SQL      | ⏳      |
+| CockroachDB | ⏳      |
+
+### Installation
 ```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
----
+### Quick start
 ```typescript
+import { drizzle, PgTable } from 'drizzle-orm'
 
-export const rolesEnum = createEnum({ alias: 'test-enum', values: ['user', 'guest', 'admin'] });
-
-export default class UsersTable extends AbstractTable<UsersTable> {
+export class UsersTable extends PgTable<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 type User = InferType<UsersTable>
 
-export default class CitiesTable extends AbstractTable<CitiesTable> {
-  public id = this.serial('id').primaryKey();
+const db = await drizzle.connect("postgres://user:password@host:port/db");
+const usersTable = new UsersTable(db);
 
-  public foundationDate = this.timestamp('name').notNull();
-  public location = this.varchar('page', { size: 256 });
+const users: User[] = await usersTable.select().execute();
+```
 
-  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onUpdate: 'CASCADE' });
+### Connecting to database
+```typescript
 
-  public metadata = this.jsonb<CityMeta>('metadata');
+const db = await drizzle.connect("postgres://user:password@host:port/db");
+const db = await drizzle.connect({
+  host: "127.0.0.1",
+  port: 5432,
+  user: "postgres",
+  password: "postgres",
+  db: "db_name",
+});
+```
 
-  public tableName(): string {
-    return 'cities';
-  }
-}
+### SQL schema declaration
+With `drizzle-orm` you declare SQL schema in typescritp. You can have either one `schema.ts` file with all declarations or you can group them logically in multiple files. We prefer to use single file schema.
 ```
-### User Groups Table
----
+📦project
+ ├ 📂src
+ │ ├ 📂data
+ │ │ └ 📜schema.ts
+ │ └ ...
+ ├ ...
+ └ 📜package.json
+ 
+## or multiple schema files
+├ 📂data
+  ├ 📜users.ts
+  ├ 📜countries.ts
+  ├ 📜cities.ts
+  ├ 📜products.ts
+  ├ 📜clients.ts
+  ├ 📜enums.ts
+  └ 📜etc.ts
+```
+This is how you declare SQL schema in `schema.ts`. You can declare tables, indexes and constraints, foreign keys and enums. Please pay attention to `export` keyword, they are mandatory if you'll be using drizzle-kit SQL migrations generator.
 ```typescript
-export default class UserGroupsTable extends AbstractTable<UserGroupsTable> {
-  public id = this.serial('id').primaryKey();
+// declaring enum in database
+export const popularityEnum = createEnum({ alias: 'popularity', values: ['unknown', 'known', 'popular'] });
 
-  public name = this.varchar('name');
-  public description = this.varchar('description');
+export class CountriesTable extends PgTable<CountriesTable> {
+  id = this.serial("id").primaryKey();
+  name = this.varchar("name", { size: 256 })
+	
+  // declaring index
+  nameIndex = this.uniqueIndex(this.name)
 
   public tableName(): string {
-    return 'user_groups';
+    return 'countries';
   }
 }
-```
-### 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]);
+export class CitiesTable extends PgTable<CitiesTable> {
+  id = this.serial("id").primaryKey();
+  name = this.varchar("name", { size: 256 })
+  countryId = this.int("country_id").foreignKey(CountriesTable, (country) => country.id)
+
+  // declaring enum column in table
+  popularity = this.type(popularityEnum, "popularity")
 
   public tableName(): string {
-    return 'users_to_user_groups';
+    return 'cities';
   }
 }
 ```
-
-## CRUD
-### **SELECT**
----
+The list of all possible types. You can also create custom types - !!see here!!.
 ```typescript
-const db = await new DbConnector()
-  .connectionString('postgresql://postgres@127.0.0.1/drizzle')
-  .connect();
+export const enum = createEnum({ alias: "database-name", values: ["value1", "value2", "value3"] });
+type(enum, "...")
 
-const usersTable = new UsersTable(db);
+smallint("...")
+int("...")
+bigint("...", maxBytes: "max_bytes_53")
+bigint("...", maxBytes: "max_bytes_64")
 
-// select all
-const allSelect = await usersTable.select().all();
+bool("...")
+text("...");
+varchar("...");
+varchar("...", { size: 256 });
 
-// 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();
+serial("...");
+bigserial("...", maxBytes: "max_bytes_53");
+bigserial("...", maxBytes: "max_bytes_64");
 
-    // Usage
-    const { mappedId, mappedPhone } = partialSelect;
- ```
+decimal("...", { precision: 100, scale: 2 });
 
+jsonb<...>("...");
+jsonb<string[]>("...");
 
-### **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();
-```
+time("...")
+timestamp("...")    // with timezone
+timestamptz("..."); // without timezone
+timestamp("...").defaultValue(Defaults.CURRENT_TIMESTAMP)
 
-### **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();
+index(column);
+index([column1, column2, ...]);
+uniqueIndex(column);
+uniqueIndex([column1, column2, ...]);
+
+
+column.primaryKey()
+column.notNull()
+column.defaultValue(...)
+
+// 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT'
+column.foreignKey(Table, (table) => table.column, { onDelete: "CASCADE", onUpdate: "CASCADE" });
 ```
-##### Delete `user` where phone is `"hello"` returning updated `User` model
+
+### Create Read Update Delete
+Querying, sorting and filtering. We also support partial select.
 ```typescript
-await usersTable.delete()
-      .where(eq(usersTable.phone, 'hello'))
-      .findOne();
-```
+const db = await drizzle.connect("...")
+const table = new UsersTable(db);
+
+const result: User[] = await table.select().execute();
+await table.select().where(
+  eq(table.id, 42)
+).execute();
+
+// you can combine filters with eq(...) or or(...)
+await table.select().where(
+  and([eq(table.id, 42), eq(table.name, "Dan")])
+).execute();
 
-### **Insert**
+await table.select().where(
+  or([eq(table.id, 42), eq(table.id, 1)])
+).execute();
+
+// partial select
+const result = await table.select({
+     mapped1: table.id,
+     mapped2: table.name,
+}).execute();
+const { mapped1, mapped2 } = result[0];
+
+// limit offset & order by
+await table.select().limit(10).offset(10).execute()
+await table.select().orderBy((table) => table.name, Order.ASC)
+await table.select().orderBy((table) => table.name, Order.DESC)
+
+// list of all filter operators
+eq(table.column, value)
+notEq(table.column, value)
+less(table.column, value)
+lessEq(table.column, value)
+greater(table.column, value)
+greaterEq(table.column, value)
+isNull(table.column)
+isNotNull(table.column)
+
+inArray(table.column, [...values])
+like(table.column, value)
+raw("raw sql filter")
+
+and(exressions: Expr[])
+or(exressions: Expr[])
+```
+Inserting
 ##### Insert `user` with required fields
 ```typescript
 await usersTable.insert({
@@ -298,67 +202,83 @@ await usersTable.insert({
 ```
 ##### Insert `user` with required fields and get all rows as array
 ```typescript
-const user = await usersTable.insert({
-  test: 1,
+const result = await usersTable.insert({
+  name: "Andrew",
   createdAt: new Date(),
-}).all();
-```
-##### Insert `user` with required fields and get inserted entity
-```typescript
-const user = await usersTable.insert({
-  test: 1,
+}).execute();
+
+const result = await usersTable.insertMany([{
+  name: "Andrew",
   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();
+}, {
+  name: "Dan",
+  createdAt: new Date(),
+}]).execute();
+
+//await usersTable.insert({
+//  name: "Dan"
+//})
+//.onConflict(
+//	(table) => table.name,
+//	{ name: 'name value to be upserted' }
+//).execute();
 ```
-##### Insert many `users` with required fields and get all inserted entities. If such user already exists - update `phone` field
+
+Update and Delete
 ```typescript
-await usersTable.insertMany([{
-      test: 1,
-      createdAt: new Date(),
-    }, {
-      test: 2,
-      createdAt: new Date(),
-    }])
-      .onConflict(
-        (table) => table.phoneIndex,
-        { phone: 'confilctUpdate' },
-      ).all();
+await usersTable.update()
+  .where(eq(usersTable.name, 'Dan'))
+  .set({ name: 'Mr. Dan' })
+  .execute();
+	
+await usersTable.delete()
+  .where(eq(usersTable.name, 'Dan'))
+  .execute();
 ```
 
-## Joins
-### Join One-To-Many Tables
-##### Join Cities with Users and map to city object with full user
+### Joins
+Last but not least. Probably the most powerful feature in the library🚀
+Many-to-one
 ```typescript
 const usersTable = new UsersTable(db);
 const citiesTable = new CitiesTable(db);
 
-const userWithCities = await citiesTable.select()
-  .where(eq(citiesTable.id, 1))
-  .leftJoin(usersTable, (cities, users) => onEq(cities.userId, users.id))
+const result = await citiesTable.select()
+  .leftJoin(usersTable, (cities, users) => eq(cities.userId, users.id))
+  .where((cities, users) => eq(cities.id, 1))
   .execute();
 
-const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
+const citiesWithUsers: { city: City, user: User }[] = result.map((city, user) => ({ city, user }));
 ```
-
-### Join Many-To-Many Tables
-##### Join User Groups with Users, using many-to-many table
+Many-to-many
 ```typescript
-  const usersWithUserGroups = await usersToUserGroupsTable.select()
-      .where(eq(userGroupsTable.id, 1))
-      .leftJoin(usersTable, (usersToUserGroups, users) => onEq(usersToUserGroups.userId, users.id))
-      .leftJoin(userGroupsTable, (usersToUserGroups, _users, userGroups) => onEq(usersToUserGroups.groupId, userGroups.id))
-      .execute();
+export class UsersTable extends PgTable<UsersTable> {
+  id = this.serial("id").primaryKey();
+	name = this.varchar("name");
+}
+
+export class ChatGroupsTable extends PgTable<ChatGroupsTable> {
+  id = this.serial("id").primaryKey();
+}
+
+export class ManyToManyTable extends PgTable<ManyToManyTable> {
+  userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onDelete: 'CASCADE' });
+  groupId = this.int('group_id').foreignKey(ChatGroupsTable, (table) => table.id, { onDelete: 'CASCADE' });
+}
+
+...
+const usersTable = new UsersTable(db);
+const chatGroupsTable = new ChatGroupsTable(db);
+const manyToManyTable = new ManyToManyTable(db);
+
+// querying user group with id 1 and all the participants(users)
+const usersWithUserGroups = await manyToManyTable.select()
+  .leftJoin(usersTable, (manyToMany, users) => eq(manyToManyTable.userId, users.id))
+  .leftJoin(chatGroupsTable, (manyToMany, _users, chatGroups) => eq(manyToManyTable.groupId, chatGroups.id))
+  .where((manyToMany, _users, userGroups) => eq(userGroups.id, 1))
+  .execute();
 ```
+
 ### Join using partial field select
 ##### Join Cities with Users getting only needed fields form request
 ```typescript
@@ -366,8 +286,8 @@ const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user
       id: citiesTable.id,
       userId: citiesTable.userId,
     })
-      .where(eq(citiesTable.id, 1))
-      .leftJoin(usersTable, (cities, users) => onEq(cities.userId, users.id))
+      .leftJoin(usersTable, (cities, users) => eq(cities.userId, users.id))
+      .where((cities, users) => eq(cities.id, 1))
       .execute();
 
 const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
@@ -375,8 +295,8 @@ const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user
 ### Another join examples with different callback ON statements
 ```typescript
 await citiesTable.select()
-  .where(eq(citiesTable.location, 'q'))
   .leftJoin(usersTable, (cities, _users) => eq(cities.id, 13))
+  .where((cities, _users) => eq(cities.location, 'q'))
   .execute();
 // Join statement generated from query
 // LEFT JOIN users AS users_1
@@ -397,8 +317,8 @@ await citiesTable.select()
 // Values: [13, 14]
 
 await citiesTable.select()
-  .where(eq(citiesTable.location, 'location'))
   .leftJoin(usersTable, (_cities, _users) => raw('<custom expression after ON statement>'))
+  .where((cities, _users) => eq(cities.location, 'location'))
   .execute();
 // Join statement generated from query
 // LEFT JOIN users AS users_1

package/builders/aggregators/abstractAggregator.d.ts

@@ -8,4 +8,5 @@ export default class Aggregator {
         [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>;
     });
     protected generateSelectArray: (table: string, columns: AbstractColumn<ColumnType>[], id?: number | undefined) => string[];
+    protected generateSelectArrayV1: (table: string, columns: AbstractColumn<ColumnType>[], id?: number | undefined) => string[];
 }

package/builders/aggregators/abstractAggregator.js

@@ -23,6 +23,22 @@ class Aggregator {
             selectFields.pop();
             return selectFields;
         };
+        this.generateSelectArrayV1 = (table, columns, id) => {
+            const selectFields = [];
+            columns.forEach((field) => {
+                if (field instanceof column_1.Column) {
+                    selectFields.push(' ');
+                    selectFields.push(table);
+                    selectFields.push('.');
+                    selectFields.push(ecranate_1.ecranate(field.getColumnName()));
+                    selectFields.push(' AS ');
+                    selectFields.push(ecranate_1.ecranate(`${field.getAlias()}${id ? `_${id}` : ''}`));
+                    selectFields.push(',');
+                }
+            });
+            selectFields.pop();
+            return selectFields;
+        };
         this._table = table;
         if (!partial) {
             this._fields = this.generateSelectArray(this._table.tableName(), Object.values(this._table.mapServiceToDb()));
@@ -33,3 +49,4 @@ class Aggregator {
     }
 }
 exports.default = Aggregator;
+//# sourceMappingURL=abstractAggregator.js.map

package/builders/aggregators/abstractAggregator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractAggregator.js","sourceRoot":"","sources":["../../../../src/builders/aggregators/abstractAggregator.ts"],"names":[],"mappings":";;AAAA,4BAA4B;AAC5B,iDAA8D;AAG9D,mDAAgD;AAEhD,mCAAmC;AACnC,MAAqB,UAAU;IAI7B,YAAmB,KAAyB,EAAE,OAAmG;QAHvI,YAAO,GAAkB,EAAE,CAAC;QAc5B,wBAAmB,GAAG,CAAC,KAAa,EAAE,OAAqC,EAAE,EAAW,EAAE,EAAE;YACpG,MAAM,YAAY,GAAa,EAAE,CAAC;YAElC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAU,EAAE,EAAE;gBAC7B,IAAI,KAAK,YAAY,eAAM,EAAE;oBAC3B,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACvB,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBACzB,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACvB,YAAY,CAAC,IAAI,CAAC,mBAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;oBACnD,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBAC1B,YAAY,CAAC,IAAI,CAAC,mBAAQ,CAAC,GAAG,KAAK,IAAI,KAAK,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC,CAAC;oBACjE,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;iBACxB;YACH,CAAC,CAAC,CAAC;YAEH,YAAY,CAAC,GAAG,EAAE,CAAC;YACnB,OAAO,YAAY,CAAC;QACtB,CAAC,CAAC;QAEQ,0BAAqB,GAAG,CAAC,KAAa,EAAE,OAAqC,EAAE,EAAW,EAAE,EAAE;YACtG,MAAM,YAAY,GAAa,EAAE,CAAC;YAElC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAU,EAAE,EAAE;gBAC7B,IAAI,KAAK,YAAY,eAAM,EAAE;oBAC3B,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACvB,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBACzB,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACvB,YAAY,CAAC,IAAI,CAAC,mBAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;oBACnD,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBAC1B,YAAY,CAAC,IAAI,CAAC,mBAAQ,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;oBACxE,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;iBACxB;YACH,CAAC,CAAC,CAAC;YAEH,YAAY,CAAC,GAAG,EAAE,CAAC;YACnB,OAAO,YAAY,CAAC;QACtB,CAAC,CAAC;QA9CA,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,OAAO,EAAE;YACZ,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,EAC7D,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;SAChD;aAAM;YACL,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,EAC7D,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;SAC3B;IACH,CAAC;CAuCF;AApDD,6BAoDC"}

package/builders/aggregators/deleteAggregator.js

@@ -40,3 +40,4 @@ class DeleteAggregator extends abstractAggregator_1.default {
     }
 }
 exports.default = DeleteAggregator;
+//# sourceMappingURL=deleteAggregator.js.map

package/builders/aggregators/deleteAggregator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteAggregator.js","sourceRoot":"","sources":["../../../../src/builders/aggregators/deleteAggregator.ts"],"names":[],"mappings":";;;;;AAEA,8EAA8C;AAE9C,MAAqB,gBAAiB,SAAQ,4BAAU;IAMtD,YAAmB,KAAyB;QAC1C,KAAK,CAAC,KAAK,CAAC,CAAC;QANP,UAAK,GAAkB,EAAE,CAAC;QAC1B,aAAQ,GAAkB,EAAE,CAAC;QAC7B,YAAO,GAAe,EAAE,CAAC;QACzB,YAAO,GAAkB,CAAC,QAAQ,CAAC,CAAC;QAMrC,YAAO,GAAG,CAAC,OAAa,EAAoB,EAAE;YACnD,IAAI,OAAO,EAAE;gBACX,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;gBAC3E,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAC7B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;gBACtC,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC;aACnC;YACD,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;QAEK,eAAU,GAAG,CAAC,SAAiB,EAAoB,EAAE;YAC1D,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC1B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC3B,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;QAEK,eAAU,GAAG,GAA0C,EAAE;YAC9D,4CAA4C;YAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YACvC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YAC1C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YAEzC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC;QAChE,CAAC,CAAC;IA9BF,CAAC;CA+BF;AAvCD,mCAuCC"}

package/builders/aggregators/insertAggregator.js

@@ -107,3 +107,4 @@ class InsertAggregator extends abstractAggregator_1.default {
     }
 }
 exports.default = InsertAggregator;
+//# sourceMappingURL=insertAggregator.js.map