pqb 0.4.7 → 0.4.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pqb",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Postgres query builder",
   "homepage": "https://porm.netlify.app/guide/query-builder.html",
   "repository": {

package/src/columnSchema/columnType.test.ts

@@ -125,4 +125,224 @@ describe('column base', () => {
       });
     });
   });
+
+  describe('as', () => {
+    const numberTimestamp = columnTypes
+      .timestamp()
+      .encode((input: number) => new Date(input))
+      .parse(Date.parse)
+      .as(columnTypes.integer());
+
+    const dateTimestamp = columnTypes
+      .timestamp()
+      .parse((input) => new Date(input));
+
+    const db = createDb({
+      adapter,
+      columnTypes: {
+        ...columnTypes,
+        numberTimestamp: () => numberTimestamp,
+        dateTimestamp: () => dateTimestamp,
+      },
+    });
+
+    const UserWithCustomTimestamps = db('user', (t) => ({
+      id: t.serial().primaryKey(),
+      name: t.text(),
+      password: t.text(),
+      createdAt: t.numberTimestamp(),
+      updatedAt: t.dateTimestamp(),
+    }));
+
+    it('should accept only column of same type and input type', () => {
+      columnTypes
+        .timestamp()
+        .encode((input: number) => input.toString())
+        // @ts-expect-error should have both encode and parse with matching types
+        .as(columnTypes.integer());
+
+      // @ts-expect-error should have both encode and parse with matching types
+      columnTypes.timestamp().parse(Date.parse).as(columnTypes.integer());
+    });
+
+    it('should return same column with overridden type', () => {
+      const timestamp = columnTypes
+        .timestamp()
+        .encode((input: number) => new Date(input))
+        .parse(Date.parse);
+
+      const column = timestamp.as(columnTypes.integer());
+
+      expect(column).toBe(timestamp);
+    });
+
+    it('should parse correctly', async () => {
+      const id = await User.get('id').create(userData);
+
+      const user = await UserWithCustomTimestamps.find(id);
+
+      expect(typeof user.createdAt).toBe('number');
+      expect(user.updatedAt).toBeInstanceOf(Date);
+    });
+
+    it('should encode columns when creating', () => {
+      const createdAt = Date.now();
+      const updatedAt = new Date();
+
+      const query = UserWithCustomTimestamps.create({
+        ...userData,
+        createdAt,
+        updatedAt,
+      });
+
+      expectSql(
+        query.toSql(),
+        `
+          INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
+          VALUES ($1, $2, $3, $4)
+          RETURNING *
+        `,
+        [userData.name, userData.password, new Date(createdAt), updatedAt],
+      );
+    });
+
+    it('should encode columns when update', async () => {
+      const id = await User.get('id').create(userData);
+      const createdAt = Date.now();
+      const updatedAt = new Date();
+
+      const query = UserWithCustomTimestamps.find(id).update({
+        createdAt,
+        updatedAt,
+      });
+
+      expectSql(
+        query.toSql(),
+        `
+          UPDATE "user"
+          SET "createdAt" = $1, "updatedAt" = $2
+          WHERE "user"."id" = $3
+        `,
+        [new Date(createdAt), updatedAt, id],
+      );
+    });
+  });
+
+  describe('timestamp().asNumber()', () => {
+    it('should parse and encode timestamp as a number', async () => {
+      const UserWithNumberTimestamp = db('user', (t) => ({
+        id: t.serial().primaryKey(),
+        name: t.text(),
+        password: t.text(),
+        createdAt: t.timestamp().asNumber(),
+        updatedAt: t.timestamp().asNumber(),
+      }));
+
+      const now = Date.now();
+
+      const createQuery = UserWithNumberTimestamp.create({
+        ...userData,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      expectSql(
+        createQuery.toSql(),
+        `
+          INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
+          VALUES ($1, $2, $3, $4)
+          RETURNING *
+        `,
+        [userData.name, userData.password, new Date(now), new Date(now)],
+      );
+
+      const { id } = await createQuery;
+      const user = await UserWithNumberTimestamp.select(
+        'createdAt',
+        'updatedAt',
+      ).find(id);
+
+      assertType<typeof user, { createdAt: number; updatedAt: number }>();
+
+      expect(typeof user.createdAt).toBe('number');
+      expect(typeof user.updatedAt).toBe('number');
+
+      const updateQuery = UserWithNumberTimestamp.find(id).update({
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      expectSql(
+        updateQuery.toSql(),
+        `
+          UPDATE "user"
+          SET "createdAt" = $1, "updatedAt" = $2
+          WHERE "user"."id" = $3
+        `,
+        [new Date(now), new Date(now), id],
+      );
+    });
+  });
+
+  describe('timestamp().asDate()', () => {
+    it('should parse and encode timestamp as a number', async () => {
+      columnTypes
+        .text()
+        .encode((input: number) => input)
+        .parse((text) => parseInt(text))
+        .as(columnTypes.integer());
+
+      const UserWithNumberTimestamp = db('user', (t) => ({
+        id: t.serial().primaryKey(),
+        name: t.text(),
+        password: t.text(),
+        createdAt: columnTypes.timestamp().asDate(),
+        updatedAt: columnTypes.timestamp().asDate(),
+      }));
+
+      const now = new Date();
+
+      const createQuery = UserWithNumberTimestamp.create({
+        ...userData,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      expectSql(
+        createQuery.toSql(),
+        `
+          INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
+          VALUES ($1, $2, $3, $4)
+          RETURNING *
+        `,
+        [userData.name, userData.password, new Date(now), new Date(now)],
+      );
+
+      const { id } = await createQuery;
+      const user = await UserWithNumberTimestamp.select(
+        'createdAt',
+        'updatedAt',
+      ).find(id);
+
+      assertType<typeof user, { createdAt: Date; updatedAt: Date }>();
+
+      expect(user.createdAt).toBeInstanceOf(Date);
+      expect(user.updatedAt).toBeInstanceOf(Date);
+
+      const updateQuery = UserWithNumberTimestamp.find(id).update({
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      expectSql(
+        updateQuery.toSql(),
+        `
+          UPDATE "user"
+          SET "createdAt" = $1, "updatedAt" = $2
+          WHERE "user"."id" = $3
+        `,
+        [now, now, id],
+      );
+    });
+  });
 });

package/src/columnSchema/columnType.ts

@@ -46,6 +46,7 @@ export type ColumnData = {
   compression?: string;
   foreignKey?: ForeignKey<string, string[]>;
   modifyQuery?: (q: Query) => void;
+  as?: ColumnType;
 };
 
 type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
@@ -221,6 +222,13 @@ export abstract class ColumnType<
     return this as unknown as Omit<T, 'type'> & { type: Output };
   }
 
+  as<
+    T extends ColumnType,
+    C extends ColumnType<T['type'], Operators, T['inputType']>,
+  >(this: T, column: C): C {
+    return addColumnData(this, 'as', column) as unknown as C;
+  }
+
   toSQL() {
     return this.dataType;
   }

package/src/columnSchema/dateTime.ts

@@ -3,6 +3,7 @@ import { Operators } from '../columnsOperators';
 import { joinTruthy } from '../utils';
 import { dateTypeMethods } from './commonMethods';
 import { assignMethodsToClass } from './utils';
+import { IntegerColumn } from './number';
 
 export type DateColumnData = ColumnData & {
   min?: Date;
@@ -22,6 +23,16 @@ export abstract class DateBaseColumn extends ColumnType<
 > {
   data = {} as DateColumnData;
   operators = Operators.date;
+
+  asNumber() {
+    return this.encode((input: number) => new Date(input)).parse(
+      Date.parse,
+    ) as unknown as IntegerColumn;
+  }
+
+  asDate<T extends ColumnType>(this: T) {
+    return this.parse((input) => new Date(input as string));
+  }
 }
 
 assignMethodsToClass(DateBaseColumn, dateTypeMethods);

package/src/db.ts

@@ -22,6 +22,7 @@ import {
   ColumnTypesBase,
   getColumnTypes,
   SinglePrimaryKey,
+  ColumnType,
 } from './columnSchema';
 import { applyMixins, pushOrNewArray } from './utils';
 import { StringKey } from './common';
@@ -93,6 +94,8 @@ export interface Db<
   >;
 }
 
+export const anyShape = {} as Record<string, ColumnType>;
+
 export class Db<
   Table extends string | undefined = undefined,
   Shape extends ColumnsShape = Record<string, never>,
@@ -107,7 +110,7 @@ export class Db<
     public adapter: Adapter,
     public queryBuilder: Db,
     public table: Table = undefined as Table,
-    public shape: Shape = {} as Shape,
+    public shape: Shape = anyShape as Shape,
     public columnTypes: CT,
     options: DbTableOptions,
   ) {

package/src/queryMethods/create.test.ts

@@ -150,6 +150,24 @@ describe('create functions', () => {
         ['name', 'override'],
       );
     });
+
+    it('should strip unknown keys', () => {
+      const query = User.create({
+        name: 'name',
+        password: 'password',
+        unknown: 'should be stripped',
+      } as unknown as UserRecord);
+
+      expectSql(
+        query.toSql(),
+        `
+          INSERT INTO "user"("name", "password")
+          VALUES ($1, $2)
+          RETURNING *
+        `,
+        ['name', 'password'],
+      );
+    });
   });
 
   describe('createMany', () => {
@@ -265,6 +283,31 @@ describe('create functions', () => {
 
       expectQueryNotMutated(q);
     });
+
+    it('should strip unknown keys', () => {
+      const query = User.createMany([
+        {
+          name: 'name',
+          password: 'password',
+          unknown: 'should be stripped',
+        },
+        {
+          name: 'name',
+          password: 'password',
+          unknown: 'should be stripped',
+        },
+      ] as unknown as UserRecord[]);
+
+      expectSql(
+        query.toSql(),
+        `
+          INSERT INTO "user"("name", "password")
+          VALUES ($1, $2), ($3, $4)
+          RETURNING *
+        `,
+        ['name', 'password', 'name', 'password'],
+      );
+    });
   });
 
   describe('createFrom', () => {

package/src/queryMethods/create.ts

@@ -26,6 +26,8 @@ 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/update.test.ts

@@ -5,6 +5,7 @@ import {
   expectSql,
   User,
   userData,
+  UserRecord,
   useTestDatabase,
 } from '../test-utils';
 
@@ -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]);
       }
     }