pqb 0.4.0 → 0.4.2

package/src/queryMethods/select.test.ts

@@ -22,8 +22,8 @@ import { addQueryOn } from './join';
 import { RelationQuery, relationQueryKey } from '../relations';
 
 const insertUserAndProfile = async () => {
-  const id = await User.get('id').insert(userData);
-  await Profile.insert({ ...profileData, userId: id });
+  const id = await User.get('id').create(userData);
+  await Profile.create({ ...profileData, userId: id });
 };
 
 describe('selectMethods', () => {
@@ -195,9 +195,9 @@ describe('selectMethods', () => {
       });
 
       it('should parse columns in single relation record result', async () => {
-        const userId = await User.get('id').insert(userData);
+        const userId = await User.get('id').create(userData);
         const now = new Date();
-        await Profile.insert({ userId, updatedAt: now, createdAt: now });
+        await Profile.create({ userId, updatedAt: now, createdAt: now });
 
         const [record] = await User.select('id', {
           profile: () => profileRelation,
@@ -272,9 +272,9 @@ describe('selectMethods', () => {
       });
 
       it('should parse columns in multiple relation records result', async () => {
-        const { id: authorId } = await User.select('id').insert(userData);
-        const { id: chatId } = await Chat.select('id').insert(chatData);
-        await Message.insert({
+        const { id: authorId } = await User.select('id').create(userData);
+        const { id: chatId } = await Chat.select('id').create(chatData);
+        await Message.create({
           authorId,
           chatId,
           ...messageData,

package/src/queryMethods/then.ts

@@ -80,8 +80,8 @@ const then = async (
     let beforeCallbacks: BeforeCallback[] | undefined;
     let afterCallbacks: AfterCallback[] | undefined;
     if (q.query.type === 'insert') {
-      beforeCallbacks = q.query.beforeInsert;
-      afterCallbacks = q.query.afterInsert;
+      beforeCallbacks = q.query.beforeCreate;
+      afterCallbacks = q.query.afterCreate;
     } else if (q.query.type === 'update') {
       beforeCallbacks = q.query.beforeUpdate;
       afterCallbacks = q.query.afterUpdate;

package/src/queryMethods/update.test.ts

@@ -35,7 +35,7 @@ describe('update', () => {
 
   it('should update record with raw sql, returning updated rows count', async () => {
     const count = 2;
-    const users = await User.select('id').insertMany([userData, userData]);
+    const users = await User.select('id').createMany([userData, userData]);
 
     const query = User.or(...users).updateRaw(raw(`name = 'name'`));
     expectSql(
@@ -55,7 +55,7 @@ describe('update', () => {
   });
 
   it('should update record, returning updated row count', async () => {
-    const { id } = await User.select('id').insert(userData);
+    const { id } = await User.select('id').create(userData);
 
     const update = {
       name: 'new name',
@@ -85,7 +85,7 @@ describe('update', () => {
   });
 
   it('should update record, returning value', async () => {
-    const id = await User.get('id').insert(userData);
+    const id = await User.get('id').create(userData);
 
     const update = {
       name: 'new name',
@@ -116,7 +116,7 @@ describe('update', () => {
   });
 
   it('should update one record, return selected columns', async () => {
-    const id = await User.get('id').insert(userData);
+    const id = await User.get('id').create(userData);
 
     const query = User.select('id', 'name').find(id).update(update);
 
@@ -141,7 +141,7 @@ describe('update', () => {
   });
 
   it('should update one record, return all columns', async () => {
-    const id = await User.get('id').insert(userData);
+    const id = await User.get('id').create(userData);
 
     const query = User.selectAll().find(id).update(update);
 
@@ -166,7 +166,7 @@ describe('update', () => {
   });
 
   it('should update multiple records, returning selected columns', async () => {
-    const ids = await User.pluck('id').insertMany([userData, userData]);
+    const ids = await User.pluck('id').createMany([userData, userData]);
 
     const update = {
       name: 'new name',
@@ -198,7 +198,7 @@ describe('update', () => {
   });
 
   it('should update multiple records, returning all columns', async () => {
-    const ids = await User.pluck('id').insertMany([userData, userData]);
+    const ids = await User.pluck('id').createMany([userData, userData]);
 
     const update = {
       name: 'new name',
@@ -270,7 +270,7 @@ describe('update', () => {
   });
 
   it('should return one record when searching for one to update', async () => {
-    const { id } = await User.select('id').insert(userData);
+    const { id } = await User.select('id').create(userData);
 
     const update = {
       name: 'new name',

package/src/queryMethods/update.ts

@@ -13,7 +13,7 @@ import {
 } from '../relations';
 import { WhereArg, WhereResult } from './where';
 import { EmptyObject, MaybeArray } from '../utils';
-import { InsertData } from './insert';
+import { CreateData } from './create';
 import { parseResult, queryMethodByReturnType } from './then';
 import { UpdateQueryData } from '../sql';
 
@@ -41,14 +41,14 @@ type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> =
   | { delete: boolean }
   | { update: UpdateData<Rel['model']> }
   | {
-      create: InsertData<Rel['nestedCreateQuery']>;
+      create: CreateData<Rel['nestedCreateQuery']>;
     }
   | (QueryReturnsAll<T['returnType']> extends true
       ? never
       : {
           upsert: {
             update: UpdateData<Rel['model']>;
-            create: InsertData<Rel['nestedCreateQuery']>;
+            create: CreateData<Rel['nestedCreateQuery']>;
           };
         });
 
@@ -63,11 +63,11 @@ type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> =
           | {
               upsert: {
                 update: UpdateData<Rel['model']>;
-                create: InsertData<Rel['nestedCreateQuery']>;
+                create: CreateData<Rel['nestedCreateQuery']>;
               };
             }
           | {
-              create: InsertData<Rel['nestedCreateQuery']>;
+              create: CreateData<Rel['nestedCreateQuery']>;
             });
 
 type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
@@ -81,7 +81,7 @@ type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
   ? EmptyObject
   : {
       set?: MaybeArray<WhereArg<Rel['model']>>;
-      create?: InsertData<Rel['nestedCreateQuery']>[];
+      create?: CreateData<Rel['nestedCreateQuery']>[];
     });
 
 type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
@@ -92,7 +92,7 @@ type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
     where: MaybeArray<WhereArg<Rel['model']>>;
     data: UpdateData<Rel['model']>;
   };
-  create?: InsertData<Rel['nestedCreateQuery']>[];
+  create?: CreateData<Rel['nestedCreateQuery']>[];
 };
 
 type UpdateArgs<T extends Query, ForceAll extends boolean> = (

package/src/queryMethods/upsert.ts

@@ -1,12 +1,12 @@
 import { Query, SetQueryReturnsOne, SetQueryReturnsVoid } from '../query';
 import { UpdateData } from './update';
-import { InsertData } from './insert';
+import { CreateData } from './create';
 import { WhereResult } from './where';
 import { MoreThanOneRowError } from '../errors';
 
 export type UpsertData<T extends Query> = {
   update: UpdateData<T>;
-  create: InsertData<T>;
+  create: CreateData<T>;
 };
 
 export type UpsertResult<T extends Query> = T['hasSelect'] extends true
@@ -29,7 +29,7 @@ export class QueryUpsert {
     const { handleResult } = this.query;
     this.query.handleResult = async (q, queryResult) => {
       if (queryResult.rowCount === 0) {
-        return (q as Query).insert(data.create as InsertData<Query>);
+        return (q as Query).create(data.create as CreateData<Query>);
       } else if (queryResult.rowCount > 1) {
         throw new MoreThanOneRowError(
           `Only one row was expected to find for upsert, found ${queryResult.rowCount} rows.`,

package/src/queryMethods/window.test.ts

@@ -20,11 +20,11 @@ describe('window functions', () => {
   `('$method', ({ method, functionName, results }) => {
     it('should return array of objects with number value', async () => {
       if (method === 'selectCumeDist') {
-        await User.insertMany([
+        await User.createMany([
           { ...userData, age: 20 },
           { ...userData, age: 20 },
         ]);
-        await User.insertMany([
+        await User.createMany([
           { ...userData, age: 30 },
           { ...userData, age: 30 },
         ]);

package/src/relations.ts

@@ -1,5 +1,5 @@
 import { defaultsKey, Query, QueryBase, QueryWithTable } from './query';
-import { WhereArg, UpdateData } from './queryMethods';
+import { WhereArg, UpdateData, CreateMethodsNames } from './queryMethods';
 import { MaybeArray } from './utils';
 
 export type NestedInsertOneItem = {
@@ -184,15 +184,26 @@ export type RelationQueryBase = Query & {
   [isRequiredRelationKey]: boolean;
 };
 
+type PrepareRelationQuery<
+  T extends Query,
+  RelationName extends PropertyKey,
+  Required extends boolean,
+> = Omit<T, 'tableAlias'> & {
+  tableAlias: RelationName extends string ? RelationName : never;
+  [isRequiredRelationKey]: Required;
+  [relationQueryKey]: string;
+};
+
 export type RelationQuery<
-  RelationName extends PropertyKey = string,
+  Name extends PropertyKey = string,
   Params extends Record<string, unknown> = never,
   Populate extends string = never,
   T extends Query = Query,
   Required extends boolean = boolean,
-  Q extends RelationQueryBase = Omit<T, 'tableAlias'> & {
-    tableAlias: RelationName extends string ? RelationName : never;
-    [isRequiredRelationKey]: Required;
-    [relationQueryKey]: string;
-  },
+  ChainedCreate extends boolean = false,
+  Q extends RelationQueryBase = ChainedCreate extends true
+    ? PrepareRelationQuery<T, Name, Required>
+    : PrepareRelationQuery<T, Name, Required> & {
+        [K in CreateMethodsNames]: never;
+      },
 > = ((params: Params) => Q & { [defaultsKey]: Record<Populate, true> }) & Q;

package/src/sql/insert.ts

@@ -1,10 +1,11 @@
 import { InsertQueryData, QueryData } from './types';
 import { addValue, q } from './common';
-import { getRaw, isRaw } from '../common';
+import { getRaw, isRaw, raw } from '../common';
 import { pushWhereStatementSql } from './where';
 import { QueryBase } from '../query';
 import { selectToSql } from './select';
 import { ToSqlCtx } from './toSql';
+import { pushQueryValue } from '../queryDataUtils';
 
 export const pushInsertSql = (
   ctx: ToSqlCtx,
@@ -14,24 +15,27 @@ export const pushInsertSql = (
 ) => {
   const quotedColumns = query.columns.map(q);
 
-  ctx.sql.push(
-    `INSERT INTO ${quotedAs}(${quotedColumns.join(', ')}) VALUES ${
-      isRaw(query.values)
-        ? getRaw(query.values, ctx.values)
-        : query.values
-            .map(
-              (row) =>
-                `(${row
-                  .map((value) =>
-                    value === undefined
-                      ? 'DEFAULT'
-                      : addValue(ctx.values, value),
-                  )
-                  .join(', ')})`,
-            )
-            .join(', ')
-    }`,
-  );
+  ctx.sql.push(`INSERT INTO ${quotedAs}(${quotedColumns.join(', ')})`);
+
+  if (query.fromQuery) {
+    const q = query.fromQuery.clone();
+
+    pushQueryValue(
+      q,
+      'select',
+      isRaw(query.values) ? query.values : raw(encodeRow(ctx, query.values[0])),
+    );
+
+    ctx.sql.push(q.toSql({ values: ctx.values }).text);
+  } else {
+    ctx.sql.push(
+      `VALUES ${
+        isRaw(query.values)
+          ? getRaw(query.values, ctx.values)
+          : query.values.map((row) => `(${encodeRow(ctx, row)})`).join(', ')
+      }`,
+    );
+  }
 
   if (query.onConflict) {
     ctx.sql.push('ON CONFLICT');
@@ -85,6 +89,14 @@ export const pushInsertSql = (
   pushReturningSql(ctx, model, query, quotedAs);
 };
 
+const encodeRow = (ctx: ToSqlCtx, row: unknown[]) => {
+  return row
+    .map((value) =>
+      value === undefined ? 'DEFAULT' : addValue(ctx.values, value),
+    )
+    .join(', ');
+};
+
 export const pushReturningSql = (
   ctx: ToSqlCtx,
   model: QueryBase,

package/src/sql/types.ts

@@ -100,6 +100,7 @@ export type InsertQueryData = CommonQueryData & {
   type: 'insert';
   columns: string[];
   values: unknown[][] | RawExpression;
+  fromQuery?: Query;
   using?: JoinItem[];
   join?: JoinItem[];
   joinedParsers?: Record<string, ColumnsParsers>;
@@ -113,8 +114,8 @@ export type InsertQueryData = CommonQueryData & {
         expr?: OnConflictItem;
         update?: OnConflictMergeUpdate;
       };
-  beforeInsert?: BeforeCallback[];
-  afterInsert?: AfterCallback[];
+  beforeCreate?: BeforeCallback[];
+  afterCreate?: AfterCallback[];
 };
 
 export type UpdateQueryDataObject = Record<

package/src/test-utils.ts

@@ -11,7 +11,10 @@ import { columnTypes } from './columnSchema';
 import { MaybeArray, toArray } from './utils';
 import { Adapter } from './adapter';
 
-export const dbOptions = { connectionString: process.env.DATABASE_URL };
+export const dbOptions = {
+  connectionString: process.env.DATABASE_URL,
+  columnTypes,
+};
 
 export const dbClient = new Client(dbOptions);