pqb 0.4.6 → 0.4.8

package/src/queryMethods/create.ts

@@ -8,7 +8,6 @@ import {
   SetQueryReturnsOne,
 } from '../query';
 import { pushQueryArray } from '../queryDataUtils';
-import { RawExpression } from '../common';
 import {
   BelongsToNestedInsert,
   BelongsToRelation,
@@ -26,6 +25,9 @@ import { InsertQueryData, OnConflictItem, OnConflictMergeUpdate } from '../sql';
 import { WhereArg } from './where';
 import { parseResult, queryMethodByReturnType } from './then';
 import { NotFoundError } from '../errors';
+import { RawExpression } from '../common';
+import { ColumnsShape } from '../columnSchema';
+import { anyShape } from '../db';
 
 export type CreateData<
   T extends Query,
@@ -172,6 +174,8 @@ type CreateCtx = {
   relations: Record<string, Relation>;
 };
 
+type Encoder = (input: unknown) => unknown;
+
 const handleSelect = (q: Query) => {
   const select = q.query.select?.[0];
   const isCount =
@@ -191,7 +195,9 @@ const processCreateItem = (
   rowIndex: number,
   ctx: CreateCtx,
   columns: string[],
+  encoders: Record<string, Encoder>,
   columnsMap: Record<string, number>,
+  shape: ColumnsShape,
 ) => {
   Object.keys(item).forEach((key) => {
     if (ctx.relations[key]) {
@@ -222,8 +228,12 @@ const processCreateItem = (
           item[key] as NestedInsertItem,
         ]);
       }
-    } else if (columnsMap[key] === undefined) {
+    } else if (
+      columnsMap[key] === undefined &&
+      (shape[key] || shape === anyShape)
+    ) {
       columnsMap[key] = columns.length;
+      encoders[key] = shape[key]?.encodeFn as Encoder;
       columns.push(key);
     }
   });
@@ -256,8 +266,19 @@ const getManyReturnType = (q: Query) => {
   }
 };
 
+const mapColumnValues = (
+  columns: string[],
+  encoders: Record<string, Encoder>,
+  data: Record<string, unknown>,
+) => {
+  return columns.map((key) =>
+    encoders[key] ? encoders[key](data[key]) : data[key],
+  );
+};
+
 const handleOneData = (q: Query, data: CreateData<Query>, ctx: CreateCtx) => {
   const columns: string[] = [];
+  const encoders: Record<string, Encoder> = {};
   const columnsMap: Record<string, number> = {};
   const defaults = q.query.defaults;
 
@@ -265,9 +286,9 @@ const handleOneData = (q: Query, data: CreateData<Query>, ctx: CreateCtx) => {
     data = { ...defaults, ...data };
   }
 
-  processCreateItem(data, 0, ctx, columns, columnsMap);
+  processCreateItem(data, 0, ctx, columns, encoders, columnsMap, q.shape);
 
-  const values = [columns.map((key) => (data as Record<string, unknown>)[key])];
+  const values = [mapColumnValues(columns, encoders, data)];
 
   return { columns, values };
 };
@@ -278,6 +299,7 @@ const handleManyData = (
   ctx: CreateCtx,
 ) => {
   const columns: string[] = [];
+  const encoders: Record<string, Encoder> = {};
   const columnsMap: Record<string, number> = {};
   const defaults = q.query.defaults;
 
@@ -286,13 +308,13 @@ const handleManyData = (
   }
 
   data.forEach((item, i) => {
-    processCreateItem(item, i, ctx, columns, columnsMap);
+    processCreateItem(item, i, ctx, columns, encoders, columnsMap, q.shape);
   });
 
   const values = Array(data.length);
 
   data.forEach((item, i) => {
-    (values as unknown[][])[i] = columns.map((key) => item[key]);
+    (values as unknown[][])[i] = mapColumnValues(columns, encoders, item);
   });
 
   return { columns, values };

package/src/queryMethods/for.test.ts

@@ -1,5 +1,4 @@
 import { expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { raw } from '../common';
 
 describe('for', () => {
   describe.each`
@@ -30,7 +29,7 @@ describe('for', () => {
     it('should accept raw sql', () => {
       const q = User.all();
       expectSql(
-        q[method as 'forUpdate'](raw('raw sql')).toSql(),
+        q[method as 'forUpdate'](User.raw('raw sql')).toSql(),
         `SELECT * FROM "user" FOR ${sql} OF raw sql`,
       );
       expectQueryNotMutated(q);

package/src/queryMethods/for.ts

@@ -1,6 +1,6 @@
 import { Query } from '../query';
-import { RawExpression } from '../common';
 import { SelectQueryData } from '../sql';
+import { RawExpression } from '../common';
 
 type ForQueryBuilder<Q extends Query> = Q & {
   noWait<T extends ForQueryBuilder<Q>>(this: T): T;

package/src/queryMethods/from.test.ts

@@ -1,5 +1,4 @@
-import { expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { raw } from '../common';
+import { db, expectQueryNotMutated, expectSql, User } from '../test-utils';
 
 describe('from', () => {
   it('should accept string parameter', () => {
@@ -20,7 +19,7 @@ describe('from', () => {
   it('should accept raw parameter', () => {
     const q = User.all();
     expectSql(
-      q.as('t').from(raw('profile')).toSql(),
+      q.as('t').from(db.raw('profile')).toSql(),
       `SELECT * FROM profile AS "t"`,
     );
     expectQueryNotMutated(q);

package/src/queryMethods/get.test.ts

@@ -1,7 +1,5 @@
-import { assertType, User, userData, useTestDatabase } from '../test-utils';
-import { NumberColumn } from '../columnSchema';
+import { assertType, db, User, userData, useTestDatabase } from '../test-utils';
 import { NotFoundError } from '../errors';
-import { raw } from '../common';
 
 describe('get', () => {
   useTestDatabase();
@@ -18,7 +16,9 @@ describe('get', () => {
     });
 
     it('should select raw and return a single value', async () => {
-      const received = await User.get(raw<NumberColumn>('count(*)::int'));
+      const received = await User.get(
+        db.raw((t) => t.integer(), 'count(*)::int'),
+      );
 
       assertType<typeof received, number>();
 
@@ -43,7 +43,7 @@ describe('get', () => {
 
     it('should select raw and return a single value when exists', async () => {
       const received = await User.getOptional(
-        raw<NumberColumn>('count(*)::int'),
+        db.raw((t) => t.integer(), 'count(*)::int'),
       );
 
       assertType<typeof received, number | undefined>();

package/src/queryMethods/having.test.ts

@@ -1,5 +1,4 @@
-import { expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { raw } from '../common';
+import { db, expectQueryNotMutated, expectSql, User } from '../test-utils';
 
 describe('having', () => {
   it('should support { count: value } object', () => {
@@ -196,12 +195,12 @@ describe('having', () => {
     `;
 
     expectSql(
-      q.having(raw('count(*) = 1'), raw('sum(id) = 2')).toSql(),
+      q.having(db.raw('count(*) = 1'), db.raw('sum(id) = 2')).toSql(),
       expectedSql,
     );
     expectQueryNotMutated(q);
 
-    q._having(raw('count(*) = 1'), raw('sum(id) = 2'));
+    q._having(db.raw('count(*) = 1'), db.raw('sum(id) = 2'));
     expectSql(q.toSql({ clearCache: true }), expectedSql);
   });
 
@@ -235,7 +234,9 @@ describe('having', () => {
     it('should accept raw sql', () => {
       const q = User.all();
       expectSql(
-        q.havingOr(raw('count(*) = 1 + 2'), raw('count(*) = 2 + 3')).toSql(),
+        q
+          .havingOr(db.raw('count(*) = 1 + 2'), db.raw('count(*) = 2 + 3'))
+          .toSql(),
         `
         SELECT * FROM "user"
         HAVING count(*) = 1 + 2 OR count(*) = 2 + 3

package/src/queryMethods/index.ts

@@ -21,3 +21,4 @@ export * from './update';
 export * from './upsert';
 export * from './where';
 export * from './with';
+export * from './raw';

package/src/queryMethods/json.ts

@@ -7,7 +7,7 @@ import {
 import { pushQueryValue } from '../queryDataUtils';
 import { ColumnType, StringColumn } from '../columnSchema';
 import { JsonItem } from '../sql';
-import { raw, StringKey } from '../common';
+import { StringKey } from '../common';
 
 type JsonColumnName<T extends Pick<Query, 'selectable'>> = StringKey<
   {
@@ -55,7 +55,7 @@ export class Json {
   ): SetQueryReturnsValueOptional<T, StringColumn> {
     const q = this._wrap(this.__model.clone()) as T;
     q._getOptional(
-      raw<StringColumn>(
+      this.raw<Query, StringColumn>(
         queryTypeWithLimitOne[this.query.returnType]
           ? `row_to_json("t".*)`
           : `COALESCE(json_agg(row_to_json("t".*)), '[]')`,

package/src/queryMethods/merge.test.ts

@@ -1,4 +1,11 @@
-import { assertType, expectSql, Message, Profile, User } from '../test-utils';
+import {
+  assertType,
+  db,
+  expectSql,
+  Message,
+  Profile,
+  User,
+} from '../test-utils';
 import { QueryReturnType } from '../query';
 import { IntegerColumn, TextColumn } from '../columnSchema';
 import { getValueKey } from './get';
@@ -11,7 +18,6 @@ import {
   TruncateQueryData,
   UpdateQueryData,
 } from '../sql';
-import { raw } from '../common';
 
 describe('merge queries', () => {
   describe('select', () => {
@@ -350,8 +356,8 @@ describe('merge queries', () => {
       s2.having = [{ b: { b: 2 } }];
       s1.havingOr = [[{ a: { a: 1 } }]];
       s2.havingOr = [[{ b: { b: 2 } }]];
-      s1.union = [{ arg: raw('a'), kind: 'UNION' }];
-      s2.union = [{ arg: raw('b'), kind: 'EXCEPT' }];
+      s1.union = [{ arg: db.raw('a'), kind: 'UNION' }];
+      s2.union = [{ arg: db.raw('b'), kind: 'EXCEPT' }];
       s1.order = [{ id: 'ASC' }];
       s2.order = [{ name: 'DESC' }];
       s1.limit = 1;

package/src/queryMethods/queryMethods.test.ts

@@ -1,4 +1,3 @@
-import { raw } from '../common';
 import {
   expectQueryNotMutated,
   adapter,
@@ -12,7 +11,6 @@ import {
   assertType,
   UserRecord,
 } from '../test-utils';
-import { NumberColumn } from '../columnSchema';
 import { NotFoundError } from '../errors';
 
 describe('queryMethods', () => {
@@ -126,7 +124,7 @@ describe('queryMethods', () => {
     });
 
     it('should support raw expression', async () => {
-      const result = await User.pluck(raw<NumberColumn>('123'));
+      const result = await User.pluck(db.raw((t) => t.integer(), '123'));
       expect(result).toEqual([123, 123, 123]);
 
       assertType<typeof result, number[]>();
@@ -206,7 +204,7 @@ describe('queryMethods', () => {
     it('should add distinct on raw sql', () => {
       const q = User.all();
       expectSql(
-        q.distinct(raw('"user".id')).toSql(),
+        q.distinct(db.raw('"user".id')).toSql(),
         `
           SELECT DISTINCT ON ("user".id) * FROM "user"
         `,
@@ -236,7 +234,7 @@ describe('queryMethods', () => {
 
     it('should accept raw sql', () => {
       const q = User.all();
-      const query = q.find(raw('$1 + $2', 1, 2));
+      const query = q.find(db.raw('$1 + $2', 1, 2));
 
       assertType<Awaited<typeof query>, UserRecord>();
 
@@ -274,7 +272,7 @@ describe('queryMethods', () => {
 
     it('should accept raw sql', () => {
       const q = User.all();
-      const query = q.findOptional(raw('$1 + $2', 1, 2));
+      const query = q.findOptional(db.raw('$1 + $2', 1, 2));
 
       assertType<Awaited<typeof query>, UserRecord | undefined>();
 
@@ -305,7 +303,7 @@ describe('queryMethods', () => {
     it('should accept raw', () => {
       const q = User.all();
       expectSql(
-        q.findBy({ name: raw(`'string'`) }).toSql(),
+        q.findBy({ name: db.raw(`'string'`) }).toSql(),
         `SELECT * FROM "user" WHERE "user"."name" = 'string' LIMIT $1`,
         [1],
       );
@@ -330,7 +328,7 @@ describe('queryMethods', () => {
 
     it('should accept raw', () => {
       const q = User.all();
-      const query = q.findByOptional({ name: raw(`'string'`) });
+      const query = q.findByOptional({ name: db.raw(`'string'`) });
 
       assertType<Awaited<typeof query>, UserRecord | undefined>();
 
@@ -431,10 +429,10 @@ describe('queryMethods', () => {
         SELECT * FROM "user"
         GROUP BY id, name
       `;
-      expectSql(q.group(raw('id'), raw('name')).toSql(), expectedSql);
+      expectSql(q.group(db.raw('id'), db.raw('name')).toSql(), expectedSql);
       expectQueryNotMutated(q);
 
-      q._group(raw('id'), raw('name'));
+      q._group(db.raw('id'), db.raw('name'));
       expectSql(q.toSql({ clearCache: true }), expectedSql);
     });
   });
@@ -471,7 +469,7 @@ describe('queryMethods', () => {
       const windowSql = 'PARTITION BY id ORDER BY name DESC';
       expectSql(
         q
-          .window({ w: raw(windowSql) })
+          .window({ w: db.raw(windowSql) })
           .selectAvg('id', {
             over: 'w',
           })
@@ -527,7 +525,7 @@ describe('queryMethods', () => {
     it('adds order with raw sql', () => {
       const q = User.all();
       expectSql(
-        q.order(raw('id ASC NULLS FIRST')).toSql(),
+        q.order(db.raw('id ASC NULLS FIRST')).toSql(),
         `
         SELECT * FROM "user"
         ORDER BY id ASC NULLS FIRST

package/src/queryMethods/queryMethods.ts

@@ -1,4 +1,4 @@
-import { Expression, raw, RawExpression } from '../common';
+import { Expression, RawExpression } from '../common';
 import {
   Query,
   QueryBase,
@@ -48,6 +48,7 @@ import { QueryCallbacks } from './callbacks';
 import { QueryUpsert } from './upsert';
 import { QueryGet } from './get';
 import { MergeQueryMethods } from './merge';
+import { RawMethods } from './raw';
 
 export type WindowArg<T extends Query> = Record<
   string,
@@ -96,7 +97,8 @@ export interface QueryMethods
     QueryCallbacks,
     QueryUpsert,
     QueryGet,
-    MergeQueryMethods {}
+    MergeQueryMethods,
+    RawMethods {}
 
 export class QueryMethods {
   windows!: EmptyObject;
@@ -309,7 +311,7 @@ export class QueryMethods {
     return query
       .as(as ?? 't')
       ._from(
-        raw(`(${sql.text})`, ...sql.values),
+        this.raw(`(${sql.text})`, ...sql.values),
       ) as unknown as SetQueryTableAlias<Q, As>;
   }
 
@@ -344,7 +346,7 @@ export class QueryMethods {
   }
 
   _exists<T extends Query>(this: T): SetQueryReturnsValue<T, BooleanColumn> {
-    const q = this._getOptional(raw<BooleanColumn>('true'));
+    const q = this._getOptional(this.raw<Query, BooleanColumn>('true'));
     q.query.notFoundDefault = false;
     q.query.coalesceValue = false;
     return q as unknown as SetQueryReturnsValue<T, BooleanColumn>;
@@ -397,4 +399,5 @@ applyMixins(QueryMethods, [
   QueryUpsert,
   QueryGet,
   MergeQueryMethods,
+  RawMethods,
 ]);

package/src/queryMethods/raw.test.ts

@@ -0,0 +1,19 @@
+import { ColumnType } from '../columnSchema';
+import { createDb } from '../db';
+import { adapter } from '../test-utils';
+
+describe('raw', () => {
+  it('should use column types in callback from a db instance', () => {
+    const type = {} as unknown as ColumnType;
+    const db = createDb({
+      adapter,
+      columnTypes: {
+        type: () => type,
+      },
+    });
+
+    const value = db.raw((t) => t.type(), 'sql');
+
+    expect(value.__column).toBe(type);
+  });
+});

package/src/queryMethods/raw.ts

@@ -0,0 +1,27 @@
+import { ColumnType, ColumnTypesBase } from '../columnSchema';
+import { Query } from '../query';
+import { RawExpression } from '../common';
+
+type RawArgs<CT extends ColumnTypesBase, C extends ColumnType> =
+  | [column: (types: CT) => C, sql: string, ...values: unknown[]]
+  | [sql: string, ...values: unknown[]];
+
+export class RawMethods {
+  raw<T extends Query, C extends ColumnType>(
+    this: T,
+    ...args: RawArgs<T['columnTypes'], C>
+  ): RawExpression<C> {
+    if (typeof args[0] === 'string') {
+      return {
+        __raw: args[0],
+        __values: args.slice(1),
+      } as RawExpression<C>;
+    } else {
+      return {
+        __column: args[0](this.columnTypes),
+        __raw: args[1],
+        __values: args.slice(2),
+      } as RawExpression<C>;
+    }
+  }
+}

package/src/queryMethods/select.test.ts

@@ -1,5 +1,6 @@
 import {
   assertType,
+  db,
   expectQueryNotMutated,
   expectSql,
   Profile,
@@ -9,7 +10,6 @@ import {
   UserRecord,
   useTestDatabase,
 } from '../test-utils';
-import { raw } from '../common';
 import { DateColumn } from '../columnSchema';
 
 const insertUserAndProfile = async () => {
@@ -236,7 +236,7 @@ describe('selectMethods', () => {
 
     it('can select raw', () => {
       const q = User.all();
-      const query = q.select({ one: raw('1') });
+      const query = q.select({ one: db.raw('1') });
 
       assertType<Awaited<typeof query>, { one: unknown }[]>();
 
@@ -345,8 +345,8 @@ describe('selectMethods', () => {
 
     it('should parse raw column', async () => {
       const q = User.select({
-        date: raw(
-          new DateColumn().parse((input) => new Date(input)),
+        date: db.raw(
+          () => new DateColumn().parse((input) => new Date(input)),
           '"createdAt"',
         ),
       });

package/src/queryMethods/then.test.ts

@@ -1,6 +1,4 @@
-import { assertType, User, useTestDatabase } from '../test-utils';
-import { raw } from '../common';
-import { columnTypes } from '../columnSchema';
+import { assertType, db, User, useTestDatabase } from '../test-utils';
 
 describe('then', () => {
   useTestDatabase();
@@ -8,7 +6,7 @@ describe('then', () => {
   describe('catch', () => {
     it('should catch error', (done) => {
       const query = User.select({
-        column: raw(columnTypes.boolean(), 'koko'),
+        column: db.raw((t) => t.boolean(), 'koko'),
       }).catch((err) => {
         expect(err.message).toBe(`column "koko" does not exist`);
         done();

package/src/queryMethods/union.test.ts

@@ -1,5 +1,10 @@
-import { Chat, expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { raw } from '../common';
+import {
+  Chat,
+  db,
+  expectQueryNotMutated,
+  expectSql,
+  User,
+} from '../test-utils';
 
 ['union', 'intersect', 'except'].forEach((what) => {
   const upper = what.toUpperCase();
@@ -7,10 +12,10 @@ import { raw } from '../common';
     it(`adds ${what}`, () => {
       const q = User.all();
       let query = q.select('id');
-      query = query[what as 'union']([Chat.select('id'), raw('SELECT 1')]);
+      query = query[what as 'union']([Chat.select('id'), db.raw('SELECT 1')]);
       query = query[
         (what + 'All') as 'unionAll' | 'intersectAll' | 'exceptAll'
-      ]([raw('SELECT 2')], true);
+      ]([db.raw('SELECT 2')], true);
 
       const wrapped = query.wrap(User.select('id'));
 
@@ -34,7 +39,7 @@ import { raw } from '../common';
 
     it('has modifier', () => {
       const q = User.select('id');
-      q[`_${what}` as '_union']([raw('SELECT 1')]);
+      q[`_${what}` as '_union']([db.raw('SELECT 1')]);
       expectSql(
         q.toSql(),
         `
@@ -43,7 +48,7 @@ import { raw } from '../common';
           SELECT 1
         `,
       );
-      q[`_${what}All` as '_unionAll']([raw('SELECT 2')], true);
+      q[`_${what}All` as '_unionAll']([db.raw('SELECT 2')], true);
       expectSql(
         q.toSql({ clearCache: true }),
         `

package/src/queryMethods/update.test.ts

@@ -1,12 +1,13 @@
 import {
   assertType,
+  db,
   expectQueryNotMutated,
   expectSql,
   User,
   userData,
+  UserRecord,
   useTestDatabase,
 } from '../test-utils';
-import { raw } from '../common';
 
 describe('update', () => {
   useTestDatabase();
@@ -37,7 +38,7 @@ describe('update', () => {
     const count = 2;
     const users = await User.select('id').createMany([userData, userData]);
 
-    const query = User.or(...users).updateRaw(raw(`name = 'name'`));
+    const query = User.or(...users).updateRaw(db.raw(`name = 'name'`));
     expectSql(
       query.toSql(),
       `
@@ -254,7 +255,7 @@ describe('update', () => {
 
   it('should support raw sql as a value', () => {
     const query = User.where({ id: 1 }).update({
-      name: raw(`'raw sql'`),
+      name: db.raw(`'raw sql'`),
     });
     expectSql(
       query.toSql(),
@@ -321,6 +322,23 @@ describe('update', () => {
     });
   });
 
+  it('should strip unknown keys', () => {
+    const query = User.find(1).update({
+      name: 'name',
+      unknown: 'should be stripped',
+    } as unknown as UserRecord);
+
+    expectSql(
+      query.toSql(),
+      `
+        UPDATE "user"
+        SET "name" = $1, "updatedAt" = now()
+        WHERE "user"."id" = $2
+      `,
+      ['name', 1],
+    );
+  });
+
   describe('increment', () => {
     it('should not mutate query', () => {
       const q = User.all();

package/src/queryMethods/update.ts

@@ -16,6 +16,8 @@ import { EmptyObject, MaybeArray } from '../utils';
 import { CreateData } from './create';
 import { parseResult, queryMethodByReturnType } from './then';
 import { UpdateQueryData } from '../sql';
+import { ColumnsShape } from '../columnSchema';
+import { anyShape } from '../db';
 
 export type UpdateData<T extends Query> = {
   [K in keyof T['type']]?: T['type'][K] | RawExpression;
@@ -174,7 +176,10 @@ export class Update {
     const set: Record<string, unknown> = { ...data };
     pushQueryValue(this, 'updateData', set);
 
-    const relations = this.relations as Record<string, Relation>;
+    const { relations, shape } = this as {
+      relations: Record<string, Relation>;
+      shape: ColumnsShape;
+    };
 
     const prependRelations: Record<string, Record<string, unknown>> = {};
     const appendRelations: Record<string, Record<string, unknown>> = {};
@@ -195,6 +200,11 @@ export class Update {
           }
           appendRelations[key] = data[key] as Record<string, unknown>;
         }
+      } else if (!shape[key] && shape !== anyShape) {
+        delete set[key];
+      } else {
+        const encode = shape[key].encodeFn;
+        if (encode) set[key] = encode(set[key]);
       }
     }