pqb 0.3.3 → 0.3.4

package/package.json

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

package/src/columnSchema/columnsSchema.ts

@@ -1,6 +1,7 @@
 import { ColumnInput, ColumnOutput, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
-import { SetOptional, SomeIsTrue, UnionToIntersection } from '../utils';
+import { SetOptional, SomeIsTrue } from '../utils';
+import { StringKey } from '../common';
 
 export type ColumnsShape = Record<string, ColumnType>;
 
@@ -53,63 +54,22 @@ export abstract class PluckResultColumnType<
   C extends ColumnType,
 > extends ColumnType<C['type'][], typeof Operators.any> {}
 
-type UnionKeyofToOvlds<S, U> = UnionToIntersection<
-  U extends keyof S ? (f: U) => void : never
->;
-
-type PopKeyofColumnShapeUnion<
-  S extends ColumnsShape,
-  U extends keyof S,
-> = UnionKeyofToOvlds<S, U> extends (a: infer A extends keyof S) => void
-  ? A
-  : never;
-
-type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
-
-export type UnionToArray<
-  S extends ColumnsShape,
-  T extends keyof S,
-  A extends [...(keyof S)[]] = [],
-> = IsUnion<T> extends true
-  ? UnionToArray<
-      S,
-      Exclude<T, PopKeyofColumnShapeUnion<S, T>>,
-      [PopKeyofColumnShapeUnion<S, T>, ...A]
-    >
-  : [T, ...A];
-
-type GetPrimaryKeys<S extends ColumnsShape> = UnionToArray<
-  S,
-  { [K in keyof S]: S[K] extends { isPrimaryKey: true } ? K : never }[keyof S]
+// resolves in string literal of single primary key
+// if table has two or more primary keys it will resolve in never
+export type SinglePrimaryKey<Shape extends ColumnsShape> = StringKey<
+  {
+    [K in keyof Shape]: Shape[K]['isPrimaryKey'] extends true
+      ? [
+          {
+            [S in keyof Shape]: Shape[S]['isPrimaryKey'] extends true
+              ? S extends K
+                ? never
+                : S
+              : never;
+          }[keyof Shape],
+        ] extends [never]
+        ? K
+        : never
+      : never;
+  }[keyof Shape]
 >;
-
-type GetPrimaryTypes<
-  S extends ColumnsShape,
-  Keys extends [...(keyof S | string)[]] = GetPrimaryKeys<S>,
-> = GetTypesFromKeys<S, Keys>;
-
-type GetTypesFromKeys<
-  S extends ColumnsShape,
-  T extends [...(keyof S)[]],
-> = T extends [
-  infer Head extends keyof S,
-  ...infer Tail extends [...(keyof S)[]],
-]
-  ? [GetTypeFromKey<S, Head>, ...GetTypesFromKeys<S, Tail>]
-  : [];
-
-type GetTypeFromKey<S extends ColumnsShape, T extends keyof S> = S[T]['type'];
-
-export class TableSchema<Shape extends ColumnsShape> {
-  primaryKeys: string extends keyof Shape ? string[] : GetPrimaryKeys<Shape>;
-  primaryTypes!: GetPrimaryTypes<Shape>;
-
-  constructor(public shape: Shape) {
-    this.primaryKeys = Object.entries(this.shape)
-      .filter(([, column]) => {
-        return column.isPrimaryKey;
-      })
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .map(([key]) => key) as any;
-  }
-}

package/src/db.ts

@@ -18,10 +18,10 @@ import { AdapterOptions, Adapter } from './adapter';
 import {
   ColumnsShape,
   ColumnShapeOutput,
-  TableSchema,
   ColumnShapeInput,
   ColumnTypesBase,
   getColumnTypes,
+  SinglePrimaryKey,
 } from './columnSchema';
 import { applyMixins, pushOrNewArray } from './utils';
 import { StringKey } from './common';
@@ -51,7 +51,8 @@ export interface Db<
   onQueryBuilder: Query['onQueryBuilder'];
   table: Table;
   shape: Shape;
-  schema: TableSchema<Shape>;
+  singlePrimaryKey: SinglePrimaryKey<Shape>;
+  primaryKeys: Query['primaryKeys'];
   type: ColumnShapeOutput<Shape>;
   inputType: ColumnShapeInput<Shape>;
   query: QueryData;
@@ -113,7 +114,14 @@ export class Db<
       this.query.schema = options.schema;
     }
 
-    this.schema = new TableSchema(shape);
+    this.primaryKeys = Object.keys(shape).filter(
+      (key) => shape[key].isPrimaryKey,
+    );
+    if (this.primaryKeys.length === 1) {
+      this.singlePrimaryKey = this
+        .primaryKeys[0] as unknown as SinglePrimaryKey<Shape>;
+    }
+
     const columns = Object.keys(
       shape,
     ) as unknown as (keyof ColumnShapeOutput<Shape>)[];

package/src/query.ts

@@ -8,12 +8,7 @@ import {
   getValueKey,
 } from './queryMethods';
 import { QueryData } from './sql';
-import {
-  ColumnShapeOutput,
-  ColumnsShape,
-  ColumnType,
-  TableSchema,
-} from './columnSchema';
+import { ColumnShapeOutput, ColumnsShape, ColumnType } from './columnSchema';
 import { EmptyObject, Spread } from './utils';
 import { AliasOrTable, RawExpression, StringKey } from './common';
 import { Db } from './db';
@@ -51,12 +46,8 @@ export type Query = QueryMethods & {
   onQueryBuilder: typeof OnQueryBuilder;
   table?: string;
   shape: ColumnsShape;
-  schema: Omit<TableSchema<ColumnsShape>, 'primaryKeys' | 'primaryTypes'> & {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    primaryKeys: any[];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    primaryTypes: any[];
-  };
+  singlePrimaryKey: string;
+  primaryKeys: string[];
   type: Record<string, unknown>;
   inputType: Record<string, unknown>;
   query: QueryData;

package/src/queryMethods/queryMethods.test.ts

@@ -4,13 +4,13 @@ import {
   adapter,
   User,
   Profile,
-  AssertEqual,
   useTestDatabase,
   db,
   expectSql,
   userData,
   now,
   assertType,
+  UserRecord,
 } from '../test-utils';
 import { NumberColumn } from '../columnSchema';
 import { NotFoundError } from '../errors';
@@ -25,8 +25,7 @@ describe('queryMethods', () => {
       expect(cloned.table).toBe(User.table);
       expect(cloned.shape).toBe(User.shape);
 
-      const eq: AssertEqual<typeof User, typeof cloned> = true;
-      expect(eq).toBe(true);
+      assertType<typeof User, typeof cloned>();
     });
   });
 
@@ -35,9 +34,7 @@ describe('queryMethods', () => {
       const sql = User.toSql();
       expectSql(sql, `SELECT * FROM "user"`);
 
-      const eq: AssertEqual<typeof sql, { text: string; values: unknown[] }> =
-        true;
-      expect(eq).toBe(true);
+      assertType<typeof sql, { text: string; values: unknown[] }>();
     });
   });
 
@@ -60,8 +57,7 @@ describe('queryMethods', () => {
         .then((res) => res.rows[0]);
 
       const user = await q.take();
-      const eq: AssertEqual<typeof user, typeof User.type> = true;
-      expect(eq).toBe(true);
+      assertType<typeof user, UserRecord>();
 
       expect(user).toEqual({
         ...expected,
@@ -88,8 +84,7 @@ describe('queryMethods', () => {
         .then((res) => res.rows[0]);
 
       const user = await q.takeOptional();
-      const eq: AssertEqual<typeof user, typeof User.type | undefined> = true;
-      expect(eq).toBe(true);
+      assertType<typeof user, UserRecord | undefined>();
 
       expect(user).toEqual({
         ...expected,
@@ -100,8 +95,7 @@ describe('queryMethods', () => {
 
     it('should return undefined if not found', async () => {
       const user = await User.takeOptional();
-      const eq: AssertEqual<typeof user, typeof User.type | undefined> = true;
-      expect(eq).toBe(true);
+      assertType<typeof user, UserRecord | undefined>();
 
       expect(user).toBe(undefined);
     });
@@ -128,16 +122,14 @@ describe('queryMethods', () => {
       const result = await User.pluck('createdAt');
       expect(result).toEqual([now, now, now]);
 
-      const eq: AssertEqual<typeof result, Date[]> = true;
-      expect(eq).toBe(true);
+      assertType<typeof result, Date[]>();
     });
 
     it('should support raw expression', async () => {
       const result = await User.pluck(raw<NumberColumn>('123'));
       expect(result).toEqual([123, 123, 123]);
 
-      const eq: AssertEqual<typeof result, number[]> = true;
-      expect(eq).toBe(true);
+      assertType<typeof result, number[]>();
     });
   });
 
@@ -228,8 +220,7 @@ describe('queryMethods', () => {
       const q = User.all();
       const query = q.find(1);
 
-      const eq: AssertEqual<Awaited<typeof query>, typeof User.type> = true;
-      expect(eq).toBe(true);
+      assertType<Awaited<typeof query>, UserRecord>();
 
       expectSql(
         query.toSql(),
@@ -247,8 +238,7 @@ describe('queryMethods', () => {
       const q = User.all();
       const query = q.find(raw('$1 + $2', 1, 2));
 
-      const eq: AssertEqual<Awaited<typeof query>, typeof User.type> = true;
-      expect(eq).toBe(true);
+      assertType<Awaited<typeof query>, UserRecord>();
 
       expectSql(
         query.toSql(),
@@ -268,11 +258,7 @@ describe('queryMethods', () => {
       const q = User.all();
       const query = q.findOptional(1);
 
-      const eq: AssertEqual<
-        Awaited<typeof query>,
-        typeof User.type | undefined
-      > = true;
-      expect(eq).toBe(true);
+      assertType<Awaited<typeof query>, UserRecord | undefined>();
 
       expectSql(
         query.toSql(),
@@ -290,11 +276,7 @@ describe('queryMethods', () => {
       const q = User.all();
       const query = q.findOptional(raw('$1 + $2', 1, 2));
 
-      const eq: AssertEqual<
-        Awaited<typeof query>,
-        typeof User.type | undefined
-      > = true;
-      expect(eq).toBe(true);
+      assertType<Awaited<typeof query>, UserRecord | undefined>();
 
       expectSql(
         query.toSql(),
@@ -336,11 +318,7 @@ describe('queryMethods', () => {
       const q = User.all();
       const query = q.findByOptional({ name: 's' });
 
-      const eq: AssertEqual<
-        Awaited<typeof query>,
-        typeof User.type | undefined
-      > = true;
-      expect(eq).toBe(true);
+      assertType<Awaited<typeof query>, UserRecord | undefined>();
 
       expectSql(
         query.toSql(),
@@ -354,11 +332,7 @@ describe('queryMethods', () => {
       const q = User.all();
       const query = q.findByOptional({ name: raw(`'string'`) });
 
-      const eq: AssertEqual<
-        Awaited<typeof query>,
-        typeof User.type | undefined
-      > = true;
-      expect(eq).toBe(true);
+      assertType<Awaited<typeof query>, UserRecord | undefined>();
 
       expectSql(
         query.toSql(),

package/src/queryMethods/queryMethods.ts

@@ -13,12 +13,7 @@ import {
   SetQueryTableAlias,
   SetQueryWindows,
 } from '../query';
-import {
-  applyMixins,
-  EmptyObject,
-  getClonedQueryData,
-  GetTypesOrRaw,
-} from '../utils';
+import { applyMixins, EmptyObject, getClonedQueryData } from '../utils';
 import {
   SelectItem,
   SelectQueryData,
@@ -189,35 +184,33 @@ export class QueryMethods {
 
   find<T extends Query>(
     this: T,
-    ...args: GetTypesOrRaw<T['schema']['primaryTypes']>
+    value: T['shape'][T['singlePrimaryKey']]['type'] | RawExpression,
   ): SetQueryReturnsOne<WhereResult<T>> {
-    return this.clone()._find(...args);
+    return this.clone()._find(value);
   }
 
   _find<T extends Query>(
     this: T,
-    ...args: GetTypesOrRaw<T['schema']['primaryTypes']>
+    value: T['shape'][T['singlePrimaryKey']]['type'] | RawExpression,
   ): SetQueryReturnsOne<WhereResult<T>> {
-    const conditions: Partial<T['type']> = {};
-    this.schema.primaryKeys.forEach((key: string, i: number) => {
-      conditions[key as keyof T['type']] = args[i];
-    });
-    return this._where(conditions as WhereArg<T>)._take();
+    return this._where({
+      [this.singlePrimaryKey]: value,
+    } as WhereArg<T>)._take();
   }
 
   findOptional<T extends Query>(
     this: T,
-    ...args: GetTypesOrRaw<T['schema']['primaryTypes']>
+    value: T['shape'][T['singlePrimaryKey']]['type'] | RawExpression,
   ): SetQueryReturnsOneOptional<WhereResult<T>> {
-    return this.clone()._findOptional(...args);
+    return this.clone()._findOptional(value);
   }
 
   _findOptional<T extends Query>(
     this: T,
-    ...args: GetTypesOrRaw<T['schema']['primaryTypes']>
+    value: T['shape'][T['singlePrimaryKey']]['type'] | RawExpression,
   ): SetQueryReturnsOneOptional<WhereResult<T>> {
     return this._find(
-      ...args,
+      value,
     ).takeOptional() as unknown as SetQueryReturnsOneOptional<WhereResult<T>>;
   }
 

package/src/queryMethods/update.ts

@@ -232,11 +232,13 @@ export class Update {
       query.returnType = 'all';
 
       if (state?.updateLater) {
-        this.schema.primaryKeys.forEach((key: string) => {
-          if (!query.select?.includes('*') && !query.select?.includes(key)) {
-            this._select(key as StringKey<keyof T['selectable']>);
-          }
-        });
+        if (!query.select?.includes('*')) {
+          this.primaryKeys.forEach((key) => {
+            if (!query.select?.includes(key)) {
+              this._select(key as StringKey<keyof T['selectable']>);
+            }
+          });
+        }
       }
 
       const { handleResult } = query;
@@ -250,7 +252,7 @@ export class Update {
           await Promise.all(state.updateLaterPromises as Promise<void>[]);
 
           const t = this.__model.clone().transacting(q);
-          const keys = this.schema.primaryKeys as string[];
+          const keys = this.primaryKeys;
           (
             t._whereIn as unknown as (
               keys: string[],

package/src/utils.test.ts

@@ -1,7 +1,5 @@
 import { assertType } from './test-utils';
 import {
-  GetTypeOrRaw,
-  GetTypesOrRaw,
   makeRegexToFindInSql,
   MaybeArray,
   pushOrNewArray,
@@ -9,7 +7,6 @@ import {
   SetOptional,
   SomeIsTrue,
 } from './utils';
-import { RawExpression } from './common';
 
 describe('utils', () => {
   describe('SomeIsTrue', () => {
@@ -45,21 +42,6 @@ describe('utils', () => {
     });
   });
 
-  describe('GetTypesOrRaw', () => {
-    it('should add each element to union with RawExpression', () => {
-      assertType<
-        GetTypesOrRaw<[number, string]>,
-        [number | RawExpression, string | RawExpression]
-      >();
-    });
-  });
-
-  describe('GetTypeOrRaw', () => {
-    it('should add type to union with RawExpression', () => {
-      assertType<GetTypeOrRaw<number>, number | RawExpression>();
-    });
-  });
-
   describe('makeRegexToFindWordInSql', () => {
     it('should return a proper regex', () => {
       const regex = makeRegexToFindInSql('\\bupdatedAt\\b');

package/src/utils.ts

@@ -1,4 +1,3 @@
-import { RawExpression } from './common';
 import { QueryData, toSqlCacheKey } from './sql';
 
 export type SomeIsTrue<T extends unknown[]> = T extends [
@@ -16,28 +15,7 @@ export type SetOptional<T, K extends PropertyKey> = Omit<T, K> & {
   [P in K]?: P extends keyof T ? T[P] : never;
 };
 
-export type GetTypesOrRaw<T extends [...unknown[]]> = T extends [
-  infer Head,
-  ...infer Tail,
-]
-  ? [GetTypeOrRaw<Head>, ...GetTypesOrRaw<Tail>]
-  : [];
-
-export type GetTypeOrRaw<T> = T | RawExpression;
-
-// credits goes to https://stackoverflow.com/a/50375286
-export type UnionToIntersection<U> =
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  (U extends any ? (k: U) => void : never) extends (k: infer I) => void
-    ? I
-    : never;
-
 // Converts union to overloaded function
-export type UnionToOvlds<U> = UnionToIntersection<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  U extends any ? (f: U) => void : never
->;
-
 type OptionalPropertyNames<T> = {
   // eslint-disable-next-line @typescript-eslint/ban-types
   [K in keyof T]-?: {} extends { [P in K]: T[K] } ? K : never;

package/src/columnSchema/columnsSchema.test.ts

@@ -1,32 +0,0 @@
-import { AssertEqual } from '../test-utils';
-import { TableSchema } from './columnsSchema';
-import { columnTypes } from './columnTypes';
-
-describe('columnsSchema', () => {
-  describe('schema methods', () => {
-    const createSchema = () => {
-      return new TableSchema({
-        a: columnTypes.integer().primaryKey(),
-        b: columnTypes.decimal().primaryKey(),
-        c: columnTypes.text(),
-      });
-    };
-
-    describe('.primaryKeys', () => {
-      it('should be array of primary key names', () => {
-        const schema = createSchema();
-        const eq: AssertEqual<typeof schema.primaryKeys, ['a', 'b']> = true;
-        expect(eq).toBe(true);
-        expect(schema.primaryKeys).toEqual(['a', 'b']);
-      });
-    });
-
-    describe('.primaryTypes', () => {
-      const schema = createSchema();
-      const eq: AssertEqual<typeof schema.primaryTypes, [number, number]> =
-        true;
-      expect(eq).toBe(true);
-      expect(schema.primaryTypes).toEqual(undefined);
-    });
-  });
-});