pqb 0.3.2 → 0.3.4

package/package.json

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

package/src/columnSchema/columnType.test.ts

@@ -10,6 +10,7 @@ import {
   useTestDatabase,
 } from '../test-utils';
 import { createDb } from '../db';
+import { columnTypes } from './columnTypes';
 
 describe('column base', () => {
   useTestDatabase();
@@ -107,7 +108,7 @@ describe('column base', () => {
       });
 
       it('should return column data as returned from db if not set', async () => {
-        const db = createDb({ adapter });
+        const db = createDb({ adapter, columnTypes });
 
         const UserWithPlainTimestamp = db('user', (t) => ({
           createdAt: t.timestamp(),

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.test.ts

@@ -30,7 +30,7 @@ describe('db', () => {
     it('should return date as string by default', async () => {
       await User.insert(userData);
 
-      const db = createDb({ adapter });
+      const db = createDb({ adapter, columnTypes });
       const table = db('user', (t) => ({
         createdAt: t.timestamp(),
       }));

package/src/db.ts

@@ -17,13 +17,11 @@ import { QueryData, SelectQueryData, Sql, ToSqlOptions } from './sql';
 import { AdapterOptions, Adapter } from './adapter';
 import {
   ColumnsShape,
-  columnTypes,
   ColumnShapeOutput,
-  TableSchema,
   ColumnShapeInput,
-  ColumnTypes,
   ColumnTypesBase,
   getColumnTypes,
+  SinglePrimaryKey,
 } from './columnSchema';
 import { applyMixins, pushOrNewArray } from './utils';
 import { StringKey } from './common';
@@ -46,23 +44,20 @@ export interface Db<
   ): this;
 
   adapter: Adapter;
+  columns: (keyof ColumnShapeOutput<Shape>)[];
+
   queryBuilder: Db;
   whereQueryBuilder: Query['whereQueryBuilder'];
+  onQueryBuilder: Query['onQueryBuilder'];
   table: Table;
   shape: Shape;
-  schema: TableSchema<Shape>;
+  singlePrimaryKey: SinglePrimaryKey<Shape>;
+  primaryKeys: Query['primaryKeys'];
   type: ColumnShapeOutput<Shape>;
   inputType: ColumnShapeInput<Shape>;
-  returnType: 'all';
-  then: ThenResult<
-    Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]
-  >;
   query: QueryData;
-  columns: (keyof ColumnShapeOutput<Shape>)[];
-  defaultSelectColumns: DefaultSelectColumns<Shape>;
-  columnsParsers?: ColumnsParsers;
   result: Pick<Shape, DefaultSelectColumns<Shape>[number]>;
-  hasSelect: false;
+  hasSelect: Query['hasSelect'];
   hasWhere: boolean;
   selectable: { [K in keyof Shape]: { as: K; column: Shape[K] } } & {
     [K in keyof Shape as `${Table}.${StringKey<K>}`]: {
@@ -70,11 +65,17 @@ export interface Db<
       column: Shape[K];
     };
   };
+  returnType: Query['returnType'];
+  then: ThenResult<
+    Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]
+  >;
   tableAlias: undefined;
-  windows: PropertyKey[];
-  withData: Query['withData'];
   joinedTables: Query['joinedTables'];
+  windows: Query['windows'];
+  defaultSelectColumns: DefaultSelectColumns<Shape>;
+  columnsParsers?: ColumnsParsers;
   relations: Relations;
+  withData: Query['withData'];
   [defaultsKey]: Record<
     {
       [K in keyof Shape]: Shape[K]['hasDefault'] extends true ? K : never;
@@ -105,7 +106,6 @@ export class Db<
     this.query = {
       adapter,
       handleResult: handleResult,
-      returnType: 'all',
       logger,
       log: logParamToLogObject(logger, options.log),
     } as QueryData;
@@ -114,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>)[];
@@ -176,18 +183,18 @@ type DbResult<CT extends ColumnTypesBase> = Db & {
   close: Adapter['close'];
 };
 
-export type DbOptions<CT extends ColumnTypesBase = ColumnTypes> = (
+export type DbOptions<CT extends ColumnTypesBase> = (
   | { adapter: Adapter }
   | Omit<AdapterOptions, 'log'>
 ) &
   QueryLogOptions & {
-    columnTypes?: CT;
+    columnTypes: CT;
   };
 
-export const createDb = <CT extends ColumnTypesBase = ColumnTypes>({
+export const createDb = <CT extends ColumnTypesBase>({
   log,
   logger,
-  columnTypes: ct = columnTypes as unknown as CT,
+  columnTypes: ct,
   ...options
 }: DbOptions<CT>): DbResult<CT> => {
   const adapter = 'adapter' in options ? options.adapter : new Adapter(options);

package/src/query.ts

@@ -1,20 +1,18 @@
-import { QueryMethods } from './queryMethods/queryMethods';
-import { QueryData } from './sql';
 import {
-  ColumnShapeOutput,
-  ColumnsShape,
-  ColumnType,
-  TableSchema,
-} from './columnSchema';
-import { Spread } from './utils';
+  QueryMethods,
+  ThenResult,
+  ColumnInfo,
+  WhereQueryBuilder,
+  OnQueryBuilder,
+  GetArg,
+  getValueKey,
+} from './queryMethods';
+import { QueryData } from './sql';
+import { ColumnShapeOutput, ColumnsShape, ColumnType } from './columnSchema';
+import { EmptyObject, Spread } from './utils';
 import { AliasOrTable, RawExpression, StringKey } from './common';
-import { ThenResult } from './queryMethods/then';
 import { Db } from './db';
-import { ColumnInfo } from './queryMethods/columnInfo';
 import { RelationQueryBase, RelationsBase } from './relations';
-import { WhereQueryBuilder } from './queryMethods/where';
-import { OnQueryBuilder } from './queryMethods/join';
-import { GetArg, getValueKey } from './queryMethods/get';
 
 export type ColumnParser = (input: unknown) => unknown;
 export type ColumnsParsers = Record<string | getValueKey, ColumnParser>;
@@ -48,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;
@@ -65,7 +59,7 @@ export type Query = QueryMethods & {
   then: ThenResult<unknown>;
   tableAlias: string | undefined;
   joinedTables: Record<string, Pick<Query, 'result' | 'tableAlias' | 'table'>>;
-  windows: PropertyKey[];
+  windows: EmptyObject;
   defaultSelectColumns: string[];
   columnsParsers?: ColumnsParsers;
   relations: RelationsBase;
@@ -93,15 +87,26 @@ export type QueryReturnType =
   | 'rowCount'
   | 'void';
 
+export const queryTypeWithLimitOne = {
+  one: true,
+  oneOrThrow: true,
+} as Record<QueryReturnType, true | undefined>;
+
 export type JoinedTablesBase = Record<
   string,
   Pick<Query, 'result' | 'tableAlias' | 'table'>
 >;
 
-type QueryThen<
+export type QueryReturnsAll<T extends QueryReturnType> = (
+  QueryReturnType extends T ? 'all' : T
+) extends 'all'
+  ? true
+  : false;
+
+export type QueryThen<
   ReturnType extends QueryReturnType,
   Result extends ColumnsShape,
-> = ReturnType extends 'all'
+> = QueryReturnsAll<ReturnType> extends true
   ? ThenResult<ColumnShapeOutput<Result>[]>
   : ReturnType extends 'one'
   ? ThenResult<ColumnShapeOutput<Result> | undefined>
@@ -130,15 +135,15 @@ type QueryThen<
 export type AddQuerySelect<
   T extends Pick<Query, 'hasSelect' | 'result' | 'then' | 'returnType'>,
   Result extends ColumnsShape,
-> = T['hasSelect'] extends false
-  ? Omit<T, 'hasSelect' | 'result' | 'then'> & {
+> = T['hasSelect'] extends true
+  ? Omit<T, 'result' | 'then'> & {
+      result: Spread<[T['result'], Result]>;
+      then: QueryThen<T['returnType'], Spread<[T['result'], Result]>>;
+    }
+  : Omit<T, 'result' | 'then'> & {
       hasSelect: true;
       result: Result;
       then: QueryThen<T['returnType'], Result>;
-    }
-  : Omit<T, 'result' | 'then'> & {
-      result: Spread<[T['result'], Result]>;
-      then: QueryThen<T['returnType'], Spread<[T['result'], Result]>>;
     };
 
 export type QuerySelectAll<T extends Query> = Omit<
@@ -288,7 +293,6 @@ export type AddQueryWith<
   With extends WithDataItem,
 > = SetQueryWith<T, Spread<[T['withData'], { [K in With['table']]: With }]>>;
 
-export type SetQueryWindows<T extends Query, W extends PropertyKey[]> = Omit<
-  T,
-  'windows'
-> & { windows: W };
+export type SetQueryWindows<T extends Query, W extends EmptyObject> = T & {
+  windows: W;
+};

package/src/queryDataUtils.ts

@@ -1,13 +1,6 @@
-import { Query } from './query';
 import { QueryData } from './sql';
 import { pushOrNewArrayToObject } from './utils';
 
-// TODO: remove
-export const removeFromQuery = <T extends Query>(q: T, key: string): T => {
-  if (q.query) delete q.query[key as keyof typeof q.query];
-  return q;
-};
-
 export const pushQueryArray = <T extends { query: QueryData }>(
   q: T,
   key: string,

package/src/queryMethods/aggregate.ts

@@ -7,7 +7,7 @@ import {
   StringExpression,
 } from '../common';
 import { AddQuerySelect, Query, SetQueryReturnsValue } from '../query';
-import { pushQueryValue, removeFromQuery } from '../queryDataUtils';
+import { pushQueryValue } from '../queryDataUtils';
 import {
   ArrayColumn,
   BooleanColumn,
@@ -42,7 +42,7 @@ export type AggregateOptions<
   filter?: WhereArg<T>;
   filterOr?: WhereArg<T>[];
   withinGroup?: boolean;
-  over?: T['windows'][number] | WindowArgDeclaration<T>;
+  over?: keyof T['windows'] | WindowArgDeclaration<T>;
 };
 
 // 1 in the name means only methods which takes 1 argument are listed here
@@ -130,7 +130,6 @@ const get = <T extends Query, Column extends ColumnType>(
   q: Query,
 ): SetQueryReturnsValue<T, Column> => {
   q.query.returnType = 'valueOrThrow';
-  removeFromQuery(q, 'take');
 
   const select = q.query.select as SelectItem[];
   if (select.length > 1) {

package/src/queryMethods/clear.ts

@@ -1,5 +1,4 @@
 import { Query } from '../query';
-import { removeFromQuery } from '../queryDataUtils';
 import { isRaw } from '../common';
 
 export type ClearStatement =
@@ -24,8 +23,8 @@ export class Clear {
   _clear<T extends Query>(this: T, ...clears: ClearStatement[]): T {
     clears.forEach((clear) => {
       if (clear === 'where') {
-        removeFromQuery(this, 'and');
-        removeFromQuery(this, 'or');
+        delete this.query.and;
+        delete this.query.or;
       } else if (clear === 'counters') {
         if ('type' in this.query && this.query.type === 'update') {
           this.query.updateData = this.query.updateData.filter((item) => {
@@ -50,7 +49,7 @@ export class Clear {
           });
         }
       } else {
-        removeFromQuery(this, clear);
+        delete (this.query as Record<string, unknown>)[clear];
       }
     });
     return this;

package/src/queryMethods/delete.ts

@@ -4,9 +4,9 @@ type DeleteArgs<T extends Query> = T['hasWhere'] extends true
   ? [forceAll?: boolean]
   : [true];
 
-type DeleteResult<T extends Query> = T['hasSelect'] extends false
-  ? SetQueryReturnsRowCount<T>
-  : T;
+type DeleteResult<T extends Query> = T['hasSelect'] extends true
+  ? T
+  : SetQueryReturnsRowCount<T>;
 
 const del = <T extends Query>(
   self: T,

package/src/queryMethods/from.test.ts

@@ -50,16 +50,15 @@ describe('from', () => {
   it('should not insert sub query and alias if provided query is simple', () => {
     const q = User.all();
     expectSql(
-      q.select('name').from(User).toSql(),
+      User.select('name').from(User).toSql(),
       'SELECT "user"."name" FROM "user"',
     );
     expectQueryNotMutated(q);
   });
 
   it('should add ONLY keyword when `only` parameter is provided', () => {
-    const q = User.all();
     expectSql(
-      q.select('id').from(User, { only: true }).toSql(),
+      User.select('id').from(User, { only: true }).toSql(),
       'SELECT "user"."id" FROM ONLY "user"',
     );
   });

package/src/queryMethods/get.ts

@@ -39,7 +39,6 @@ const _get = <
   arg: Arg,
 ): R extends 'value' ? GetOptionalResult<T, Arg> : GetResult<T, Arg> => {
   q.query.returnType = returnType;
-  q.query.take = true;
 
   if (typeof arg === 'object' && isRaw(arg)) {
     addParserForRawExpression(q, getValueKey, arg);

package/src/queryMethods/index.ts

@@ -11,6 +11,7 @@ export * from './insert';
 export * from './join';
 export * from './json';
 export * from './log';
+export * from './merge';
 export * from './queryMethods';
 export * from './select';
 export * from './then';

package/src/queryMethods/insert.ts

@@ -1,6 +1,7 @@
 import {
   defaultsKey,
   Query,
+  QueryReturnsAll,
   QueryReturnType,
   SetQueryReturnsAll,
   SetQueryReturnsOne,
@@ -136,19 +137,19 @@ type InsertHasManyData<
 
 type InsertRawData = { columns: string[]; values: RawExpression };
 
-type InsertOneResult<T extends Query> = T['hasSelect'] extends false
-  ? SetQueryReturnsRowCount<T>
-  : T['returnType'] extends 'all'
-  ? SetQueryReturnsOne<T>
-  : T['returnType'] extends 'one'
-  ? 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 InsertManyResult<T extends Query> = T['hasSelect'] extends false
-  ? SetQueryReturnsRowCount<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 OnConflictArg<T extends Query> =
   | keyof T['shape']
@@ -223,7 +224,7 @@ const createInsertCtx = (q: Query): InsertCtx => ({
 });
 
 const getInsertSingleReturnType = (q: Query) => {
-  const { select, returnType } = q.query;
+  const { select, returnType = 'all' } = q.query;
   if (select) {
     return returnType === 'all' ? 'one' : returnType;
   } else {

package/src/queryMethods/json.ts

@@ -1,4 +1,9 @@
-import { AddQuerySelect, Query, SetQueryReturnsValueOptional } from '../query';
+import {
+  AddQuerySelect,
+  Query,
+  queryTypeWithLimitOne,
+  SetQueryReturnsValueOptional,
+} from '../query';
 import { pushQueryValue } from '../queryDataUtils';
 import { ColumnType, StringColumn } from '../columnSchema';
 import { JsonItem } from '../sql';
@@ -51,12 +56,11 @@ export class Json {
     const q = this._wrap(this.__model.clone()) as T;
     q._getOptional(
       raw<StringColumn>(
-        this.query.take
+        queryTypeWithLimitOne[this.query.returnType]
           ? `row_to_json("t".*)`
           : `COALESCE(json_agg(row_to_json("t".*)), '[]')`,
       ),
     );
-    delete q.query.take;
     return q as unknown as SetQueryReturnsValueOptional<T, StringColumn>;
   }