pqb 0.4.0 → 0.4.2

package/src/queryMethods/{insert.ts → create.ts}

@@ -3,9 +3,9 @@ import {
   Query,
   QueryReturnsAll,
   QueryReturnType,
+  queryTypeWithLimitOne,
   SetQueryReturnsAll,
   SetQueryReturnsOne,
-  SetQueryReturnsRowCount,
 } from '../query';
 import { pushQueryArray } from '../queryDataUtils';
 import { RawExpression } from '../common';
@@ -26,13 +26,13 @@ import { InsertQueryData, OnConflictItem, OnConflictMergeUpdate } from '../sql';
 import { WhereArg } from './where';
 import { parseResult, queryMethodByReturnType } from './then';
 
-export type InsertData<
+export type CreateData<
   T extends Query,
   DefaultKeys extends PropertyKey = keyof T[defaultsKey],
   Data = SetOptional<T['inputType'], DefaultKeys>,
 > = [keyof T['relations']] extends [never]
   ? Data
-  : OmitBelongsToForeignKeys<T['relations'], Data> & InsertRelationData<T>;
+  : OmitBelongsToForeignKeys<T['relations'], Data> & CreateRelationData<T>;
 
 type OmitBelongsToForeignKeys<R extends RelationsBase, Data> = Omit<
   Data,
@@ -43,17 +43,17 @@ type OmitBelongsToForeignKeys<R extends RelationsBase, Data> = Omit<
   }[keyof R]
 >;
 
-type InsertRelationData<T extends Query> = {
+type CreateRelationData<T extends Query> = {
   [K in keyof T['relations']]: T['relations'][K] extends BelongsToRelation
-    ? InsertBelongsToData<T, K, T['relations'][K]>
+    ? CreateBelongsToData<T, K, T['relations'][K]>
     : T['relations'][K] extends HasOneRelation
-    ? InsertHasOneData<T, K, T['relations'][K]>
+    ? CreateHasOneData<T, K, T['relations'][K]>
     : T['relations'][K] extends HasManyRelation | HasAndBelongsToManyRelation
-    ? InsertHasManyData<T, K, T['relations'][K]>
+    ? CreateHasManyData<T, K, T['relations'][K]>
     : EmptyObject;
 }[keyof T['relations']];
 
-type InsertBelongsToData<
+type CreateBelongsToData<
   T extends Query,
   Key extends keyof T['relations'],
   Rel extends BelongsToRelation,
@@ -69,7 +69,7 @@ type InsertBelongsToData<
   | {
       [K in Key]:
         | {
-            create: InsertData<Rel['nestedCreateQuery']>;
+            create: CreateData<Rel['nestedCreateQuery']>;
             connect?: never;
             connectOrCreate?: never;
           }
@@ -83,12 +83,12 @@ type InsertBelongsToData<
             connect?: never;
             connectOrCreate: {
               where: WhereArg<Rel['model']>;
-              create: InsertData<Rel['nestedCreateQuery']>;
+              create: CreateData<Rel['nestedCreateQuery']>;
             };
           };
     };
 
-type InsertHasOneData<
+type CreateHasOneData<
   T extends Query,
   Key extends keyof T['relations'],
   Rel extends HasOneRelation,
@@ -98,7 +98,7 @@ type InsertHasOneData<
   : {
       [K in Key]?:
         | {
-            create: InsertData<Rel['nestedCreateQuery']>;
+            create: CreateData<Rel['nestedCreateQuery']>;
             connect?: never;
             connectOrCreate?: never;
           }
@@ -112,12 +112,12 @@ type InsertHasOneData<
             connect?: never;
             connectOrCreate: {
               where?: WhereArg<Rel['model']>;
-              create?: InsertData<Rel['nestedCreateQuery']>;
+              create?: CreateData<Rel['nestedCreateQuery']>;
             };
           };
     };
 
-type InsertHasManyData<
+type CreateHasManyData<
   T extends Query,
   Key extends keyof T['relations'],
   Rel extends HasManyRelation | HasAndBelongsToManyRelation,
@@ -126,30 +126,28 @@ type InsertHasManyData<
     {}
   : {
       [K in Key]?: {
-        create?: InsertData<Rel['nestedCreateQuery']>[];
+        create?: CreateData<Rel['nestedCreateQuery']>[];
         connect?: WhereArg<Rel['model']>[];
         connectOrCreate?: {
           where: WhereArg<Rel['model']>;
-          create: InsertData<Rel['nestedCreateQuery']>;
+          create: CreateData<Rel['nestedCreateQuery']>;
         }[];
       };
     };
 
-type InsertRawData = { columns: string[]; values: RawExpression };
+type CreateResult<T extends Query> = T extends { isCount: true }
+  ? T
+  : QueryReturnsAll<T['returnType']> extends true
+  ? SetQueryReturnsOne<T>
+  : T;
 
-type InsertOneResult<T extends Query> = T['hasSelect'] extends true
-  ? QueryReturnsAll<T['returnType']> extends true
-    ? SetQueryReturnsOne<T>
-    : T['returnType'] extends 'one'
-    ? SetQueryReturnsOne<T>
-    : T
-  : SetQueryReturnsRowCount<T>;
+type CreateManyResult<T extends Query> = T extends { isCount: true }
+  ? T
+  : T['returnType'] extends 'one' | 'oneOrThrow'
+  ? SetQueryReturnsAll<T>
+  : T;
 
-type InsertManyResult<T extends Query> = T['hasSelect'] extends true
-  ? T['returnType'] extends 'one' | 'oneOrThrow'
-    ? SetQueryReturnsAll<T>
-    : T
-  : SetQueryReturnsRowCount<T>;
+type CreateRawData = { columns: string[]; values: RawExpression };
 
 type OnConflictArg<T extends Query> =
   | keyof T['shape']
@@ -166,17 +164,31 @@ type AppendRelations = Record<
   [rowIndex: number, data: NestedInsertItem][]
 >;
 
-type InsertCtx = {
+type CreateCtx = {
   prependRelations: PrependRelations;
   appendRelations: AppendRelations;
   requiredReturning: Record<string, boolean>;
   relations: Record<string, Relation>;
 };
 
-const processInsertItem = (
+const handleSelect = (q: Query) => {
+  const select = q.query.select?.[0];
+  const isCount =
+    typeof select === 'object' &&
+    'function' in select &&
+    select.function === 'count';
+
+  if (isCount) {
+    q.query.select = undefined;
+  } else if (isCount || !q.query.select) {
+    q.query.select = ['*'];
+  }
+};
+
+const processCreateItem = (
   item: Record<string, unknown>,
   rowIndex: number,
-  ctx: InsertCtx,
+  ctx: CreateCtx,
   columns: string[],
   columnsMap: Record<string, number>,
 ) => {
@@ -216,14 +228,14 @@ const processInsertItem = (
   });
 };
 
-const createInsertCtx = (q: Query): InsertCtx => ({
+const createCtx = (q: Query): CreateCtx => ({
   prependRelations: {},
   appendRelations: {},
   requiredReturning: {},
   relations: (q as unknown as Query).relations,
 });
 
-const getInsertSingleReturnType = (q: Query) => {
+const getSingleReturnType = (q: Query) => {
   const { select, returnType = 'all' } = q.query;
   if (select) {
     return returnType === 'all' ? 'one' : returnType;
@@ -232,7 +244,7 @@ const getInsertSingleReturnType = (q: Query) => {
   }
 };
 
-const getInsertManyReturnType = (q: Query) => {
+const getManyReturnType = (q: Query) => {
   const { select, returnType } = q.query;
   if (select) {
     return returnType === 'one' || returnType === 'oneOrThrow'
@@ -243,11 +255,7 @@ const getInsertManyReturnType = (q: Query) => {
   }
 };
 
-const handleInsertOneData = (
-  q: Query,
-  data: InsertData<Query>,
-  ctx: InsertCtx,
-) => {
+const handleOneData = (q: Query, data: CreateData<Query>, ctx: CreateCtx) => {
   const columns: string[] = [];
   const columnsMap: Record<string, number> = {};
   const defaults = q.query.defaults;
@@ -256,17 +264,17 @@ const handleInsertOneData = (
     data = { ...defaults, ...data };
   }
 
-  processInsertItem(data, 0, ctx, columns, columnsMap);
+  processCreateItem(data, 0, ctx, columns, columnsMap);
 
   const values = [columns.map((key) => (data as Record<string, unknown>)[key])];
 
   return { columns, values };
 };
 
-const handleInsertManyData = (
+const handleManyData = (
   q: Query,
-  data: InsertData<Query>[],
-  ctx: InsertCtx,
+  data: CreateData<Query>[],
+  ctx: CreateCtx,
 ) => {
   const columns: string[] = [];
   const columnsMap: Record<string, number> = {};
@@ -277,7 +285,7 @@ const handleInsertManyData = (
   }
 
   data.forEach((item, i) => {
-    processInsertItem(item, i, ctx, columns, columnsMap);
+    processCreateItem(item, i, ctx, columns, columnsMap);
   });
 
   const values = Array(data.length);
@@ -299,7 +307,7 @@ const insert = (
     values: unknown[][] | RawExpression;
   },
   returnType: QueryReturnType,
-  ctx?: InsertCtx,
+  ctx?: CreateCtx,
 ) => {
   const q = self as Query & { query: InsertQueryData };
   const returning = q.query.select;
@@ -407,102 +415,115 @@ const insert = (
   return q;
 };
 
-export class Insert {
-  insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T> {
-    return this.clone()._insert(data);
+export type CreateMethodsNames =
+  | 'create'
+  | '_create'
+  | 'createMany'
+  | '_createMany'
+  | 'createRaw'
+  | '_createRaw'
+  | 'createFrom'
+  | '_createFrom';
+
+export class Create {
+  create<T extends Query>(this: T, data: CreateData<T>): CreateResult<T> {
+    return this.clone()._create(data);
   }
-  _insert<T extends Query>(this: T, data: InsertData<T>): InsertOneResult<T> {
-    const ctx = createInsertCtx(this);
+  _create<T extends Query>(this: T, data: CreateData<T>): CreateResult<T> {
+    handleSelect(this);
+
+    const ctx = createCtx(this);
+
+    const obj = handleOneData(this, data, ctx);
+    let { columns } = obj;
+
+    const { fromQuery } = this.query as InsertQueryData;
+    if (fromQuery) {
+      if (!queryTypeWithLimitOne[fromQuery.query.returnType]) {
+        throw new Error(
+          'Cannot create based on a query which returns multiple records',
+        );
+      }
+
+      const queryColumns: string[] = [];
+      fromQuery.query.select?.forEach((item) => {
+        if (typeof item === 'string') {
+          const index = item.indexOf('.');
+          queryColumns.push(index === -1 ? item : item.slice(index + 1));
+        } else if ('selectAs' in item) {
+          queryColumns.push(...Object.keys(item.selectAs));
+        }
+      });
+
+      queryColumns.push(...columns);
+      columns = queryColumns;
+    }
+
     return insert(
       this,
-      handleInsertOneData(this, data, ctx),
-      getInsertSingleReturnType(this),
+      { columns, values: obj.values },
+      getSingleReturnType(this),
       ctx,
-    ) as InsertOneResult<T>;
+    ) as CreateResult<T>;
   }
 
-  insertMany<T extends Query>(
+  createMany<T extends Query>(
     this: T,
-    data: InsertData<T>[],
-  ): InsertManyResult<T> {
-    return this.clone()._insertMany(data);
+    data: CreateData<T>[],
+  ): CreateManyResult<T> {
+    return this.clone()._createMany(data);
   }
-  _insertMany<T extends Query>(
+  _createMany<T extends Query>(
     this: T,
-    data: InsertData<T>[],
-  ): InsertManyResult<T> {
-    const ctx = createInsertCtx(this);
+    data: CreateData<T>[],
+  ): CreateManyResult<T> {
+    handleSelect(this);
+    const ctx = createCtx(this);
     return insert(
       this,
-      handleInsertManyData(this, data, ctx),
-      getInsertManyReturnType(this),
+      handleManyData(this, data, ctx),
+      getManyReturnType(this),
       ctx,
-    ) as InsertManyResult<T>;
+    ) as CreateManyResult<T>;
   }
 
-  insertRaw<T extends Query>(
+  createRaw<T extends Query>(
     this: T,
-    data: InsertRawData,
-  ): InsertManyResult<T> {
-    return this.clone()._insertRaw(data);
+    data: CreateRawData,
+  ): CreateManyResult<T> {
+    return this.clone()._createRaw(data);
   }
-  _insertRaw<T extends Query>(
+  _createRaw<T extends Query>(
     this: T,
-    data: InsertRawData,
-  ): InsertManyResult<T> {
-    return insert(
-      this,
-      data,
-      getInsertManyReturnType(this),
-    ) as InsertManyResult<T>;
+    data: CreateRawData,
+  ): CreateManyResult<T> {
+    handleSelect(this);
+    return insert(this, data, getManyReturnType(this)) as CreateManyResult<T>;
   }
 
-  create<T extends Query>(this: T, data: InsertData<T>): SetQueryReturnsOne<T> {
-    return this.clone()._create(data);
-  }
-  _create<T extends Query>(
+  createFrom<
+    T extends Query,
+    Q extends Query & { returnType: 'one' | 'oneOrThrow' },
+  >(
     this: T,
-    data: InsertData<T>,
+    query: Q,
+    data: Omit<CreateData<T>, keyof Q['result']>,
   ): SetQueryReturnsOne<T> {
-    if (!this.query.select) {
-      this.query.select = ['*'];
-    }
-    return this.clone()._insert(data) as SetQueryReturnsOne<T>;
-  }
-
-  createMany<T extends Query>(
-    this: T,
-    data: InsertData<T>[],
-  ): SetQueryReturnsAll<T> {
-    return this.clone()._createMany(data);
-  }
-  _createMany<T extends Query>(
-    this: T,
-    data: InsertData<T>[],
-  ): SetQueryReturnsAll<T> {
-    if (!this.query.select) {
-      this.query.select = ['*'];
-    }
-    return this.clone()._insertMany(data) as SetQueryReturnsAll<T>;
+    return this.clone()._createFrom(query, data);
   }
-
-  createRaw<T extends Query>(
-    this: T,
-    data: InsertRawData,
-  ): SetQueryReturnsAll<T> {
-    return this.clone()._createRaw(data);
-  }
-  _createRaw<T extends Query>(
+  _createFrom<
+    T extends Query,
+    Q extends Query & { returnType: 'one' | 'oneOrThrow' },
+  >(
     this: T,
-    data: InsertRawData,
-  ): SetQueryReturnsAll<T> {
-    if (!this.query.select) {
-      this.query.select = ['*'];
-    }
-    return this.clone()._insertRaw(data) as SetQueryReturnsAll<T>;
+    query: Q,
+    data: Omit<CreateData<T>, keyof Q['result']>,
+  ): CreateResult<T> {
+    (this.query as InsertQueryData).fromQuery = query;
+    return this._create(data as CreateData<T>);
   }
 
-  defaults<T extends Query, Data extends Partial<InsertData<T>>>(
+  defaults<T extends Query, Data extends Partial<CreateData<T>>>(
     this: T,
     data: Data,
   ): T & {
@@ -510,7 +531,7 @@ export class Insert {
   } {
     return (this.clone() as T)._defaults(data);
   }
-  _defaults<T extends Query, Data extends Partial<InsertData<T>>>(
+  _defaults<T extends Query, Data extends Partial<CreateData<T>>>(
     this: T,
     data: Data,
   ): T & { [defaultsKey]: Record<keyof Data, true> } {

package/src/queryMethods/delete.test.ts

@@ -29,7 +29,7 @@ describe('delete', () => {
   });
 
   it('should delete records, returning value', async () => {
-    const id = await User.get('id').insert(userData);
+    const id = await User.get('id').create(userData);
     const q = User.all();
 
     const query = q.find(id).get('id').delete();
@@ -54,7 +54,7 @@ describe('delete', () => {
     const rowsCount = 3;
 
     for (let i = 0; i < rowsCount; i++) {
-      await User.insert(userData);
+      await User.create(userData);
     }
 
     const q = User.all();

package/src/queryMethods/get.test.ts

@@ -8,7 +8,7 @@ describe('get', () => {
 
   describe('get', () => {
     it('should select column and return a single value', async () => {
-      const { id } = await User.select('id').insert(userData);
+      const { id } = await User.select('id').create(userData);
 
       const received = await User.get('id');
 
@@ -32,7 +32,7 @@ describe('get', () => {
 
   describe('getOptional', () => {
     it('should select column and return a single value when exists', async () => {
-      const { id } = await User.select('id').insert(userData);
+      const { id } = await User.select('id').create(userData);
 
       const received = await User.getOptional('id');
 

package/src/queryMethods/index.ts

@@ -7,7 +7,7 @@ export * from './for';
 export * from './from';
 export * from './get';
 export * from './having';
-export * from './insert';
+export * from './create';
 export * from './join';
 export * from './json';
 export * from './log';

package/src/queryMethods/json.test.ts

@@ -48,7 +48,7 @@ describe('json methods', () => {
 
   describe('processing and selecting json data', () => {
     beforeEach(async () => {
-      await User.insert({
+      await User.create({
         ...userData,
         data: { name: 'value', tags: ['one'] },
       });

package/src/queryMethods/log.test.ts

@@ -2,6 +2,7 @@ import { createDb } from '../db';
 import { adapter, dbOptions, userData, useTestDatabase } from '../test-utils';
 import { logColors } from './log';
 import { noop } from '../utils';
+import { columnTypes } from '../columnSchema';
 
 describe('query log', () => {
   useTestDatabase();
@@ -45,7 +46,7 @@ describe('query log', () => {
       error: jest.fn(),
     };
 
-    const db = createDb({ adapter, log: true, logger });
+    const db = createDb({ adapter, columnTypes, log: true, logger });
 
     await db('user').where({ name: 'name' });
 
@@ -68,7 +69,12 @@ describe('query log', () => {
       error: jest.fn(),
     };
 
-    const db = createDb({ adapter, log: { colors: false }, logger });
+    const db = createDb({
+      adapter,
+      columnTypes,
+      log: { colors: false },
+      logger,
+    });
 
     await db('user').where({ name: 'name' });
 
@@ -87,7 +93,7 @@ describe('query log', () => {
       error: jest.fn(),
     };
 
-    const db = createDb({ adapter, log: true, logger });
+    const db = createDb({ adapter, columnTypes, log: true, logger });
 
     await db('user').where({ wrongColumn: 'value' }).then(noop, noop);
 
@@ -112,7 +118,12 @@ describe('query log', () => {
       error: jest.fn(),
     };
 
-    const db = createDb({ adapter, log: { colors: false }, logger });
+    const db = createDb({
+      adapter,
+      columnTypes,
+      log: { colors: false },
+      logger,
+    });
 
     await db('user').where({ wrongColumn: 'value' }).then(noop, noop);
 
@@ -133,10 +144,15 @@ describe('query log', () => {
       error: jest.fn(),
     };
 
-    const db = createDb({ adapter, log: { colors: false }, logger });
+    const db = createDb({
+      adapter,
+      columnTypes,
+      log: { colors: false },
+      logger,
+    });
 
     await db.transaction(async (q) => {
-      await db('user').transacting(q).insert(userData);
+      await db('user').transacting(q).create(userData);
     });
 
     expect(logger.log.mock.calls).toEqual([
@@ -156,11 +172,16 @@ describe('query log', () => {
       error: jest.fn(),
     };
 
-    const db = createDb({ adapter, log: { colors: false }, logger });
+    const db = createDb({
+      adapter,
+      columnTypes,
+      log: { colors: false },
+      logger,
+    });
 
     await expect(
       db.transaction(async (q) => {
-        await db('user').transacting(q).insert({ name: 'name' });
+        await db('user').transacting(q).create({ name: 'name' });
       }),
     ).rejects.toThrow();
 

package/src/queryMethods/merge.test.ts

@@ -373,8 +373,8 @@ describe('merge queries', () => {
       i2.join = [{ type: 'b', args: ['b'] }];
       i1.onConflict = { type: 'ignore' };
       i2.onConflict = { type: 'merge' };
-      i1.beforeInsert = [() => {}];
-      i2.beforeInsert = [() => {}];
+      i1.beforeCreate = [() => {}];
+      i2.beforeCreate = [() => {}];
 
       const u1 = q1.query as unknown as UpdateQueryData;
       const u2 = q2.query as unknown as UpdateQueryData;
@@ -451,7 +451,7 @@ describe('merge queries', () => {
       expect(i.using).toEqual([...i1.using, ...i2.using]);
       expect(i.join).toEqual([...i1.join, ...i2.join]);
       expect(i.onConflict).toEqual(i2.onConflict);
-      expect(i.beforeInsert).toEqual([...i1.beforeInsert, ...i2.beforeInsert]);
+      expect(i.beforeCreate).toEqual([...i1.beforeCreate, ...i2.beforeCreate]);
 
       const u = q as UpdateQueryData;
       expect(u.updateData).toEqual([...u1.updateData, ...u2.updateData]);

package/src/queryMethods/queryMethods.test.ts

@@ -46,7 +46,7 @@ describe('queryMethods', () => {
 
   describe('take', () => {
     it('limits to one and returns only one', async () => {
-      await User.insert(userData);
+      await User.create(userData);
 
       const q = User.all();
       expectSql(q.take().toSql(), `SELECT * FROM "user" LIMIT $1`, [1]);
@@ -73,7 +73,7 @@ describe('queryMethods', () => {
 
   describe('takeOptional', () => {
     it('limits to one and returns only one', async () => {
-      await User.insert(userData);
+      await User.create(userData);
 
       const q = User.all();
       expectSql(q.takeOptional().toSql(), `SELECT * FROM "user" LIMIT $1`, [1]);
@@ -114,7 +114,7 @@ describe('queryMethods', () => {
   describe('pluck', () => {
     beforeEach(async () => {
       for (let i = 0; i < 3; i++) {
-        await User.insert({ ...userData, createdAt: now });
+        await User.create({ ...userData, createdAt: now });
       }
     });
 
@@ -573,7 +573,7 @@ describe('queryMethods', () => {
 
       expect(await query).toBe(false);
 
-      await User.insert(userData);
+      await User.create(userData);
 
       expect(await query).toBe(true);
 

package/src/queryMethods/queryMethods.ts

@@ -33,7 +33,7 @@ import { Join } from './join';
 import { With } from './with';
 import { Union } from './union';
 import { Json } from './json';
-import { Insert } from './insert';
+import { Create } from './create';
 import { Update } from './update';
 import { Delete } from './delete';
 import { Transaction } from './transaction';
@@ -81,7 +81,7 @@ export interface QueryMethods
     With,
     Union,
     Json,
-    Insert,
+    Create,
     Update,
     Delete,
     Transaction,
@@ -381,7 +381,7 @@ applyMixins(QueryMethods, [
   With,
   Union,
   Json,
-  Insert,
+  Create,
   Update,
   Delete,
   Transaction,