pqb 0.0.1

package/src/queryMethods/from.test.ts

@@ -0,0 +1,66 @@
+import { expectQueryNotMutated, expectSql, User } from '../test-utils';
+import { raw } from '../common';
+
+describe('from', () => {
+  it('should accept string parameter', () => {
+    const q = User.all();
+    expectSql(q.from('profile').toSql(), `SELECT * FROM "profile"`);
+    expectQueryNotMutated(q);
+  });
+
+  it('should accept string parameter with respect to `as`', () => {
+    const q = User.all();
+    expectSql(
+      q.as('t').from('profile').toSql(),
+      `SELECT * FROM "profile" AS "t"`,
+    );
+    expectQueryNotMutated(q);
+  });
+
+  it('should accept raw parameter', () => {
+    const q = User.all();
+    expectSql(
+      q.as('t').from(raw('profile')).toSql(),
+      `SELECT * FROM profile AS "t"`,
+    );
+    expectQueryNotMutated(q);
+  });
+
+  it('should accept query parameter', () => {
+    const q = User.all();
+    expectSql(
+      q.select('name').from(User.select('name')).toSql(),
+      'SELECT "user"."name" FROM (SELECT "user"."name" FROM "user") AS "user"',
+    );
+    expectQueryNotMutated(q);
+  });
+
+  it('accept `as` parameter', () => {
+    const q = User.all();
+    expectSql(
+      q.select('name').from(User.select('name'), 'wrapped').toSql(),
+      `
+        SELECT "wrapped"."name"
+        FROM (SELECT "user"."name" FROM "user") AS "wrapped"
+      `,
+    );
+    expectQueryNotMutated(q);
+  });
+
+  it('should not insert sub query and alias if provided query is simple', () => {
+    const q = User.all();
+    expectSql(
+      q.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(),
+      'SELECT "user"."id" FROM ONLY "user"',
+    );
+  });
+});

package/src/queryMethods/from.ts

@@ -0,0 +1,58 @@
+import { Query, SetQueryTableAlias } from '../query';
+import { AliasOrTable, isRaw, RawExpression } from '../common';
+import { SelectQueryData } from '../sql';
+
+type FromArgs<T extends Query> = [
+  first:
+    | string
+    | Query
+    | RawExpression
+    | Exclude<keyof T['withData'], symbol | number>,
+  second?: string | { as?: string; only?: boolean },
+];
+
+type FromResult<
+  T extends Query,
+  Args extends FromArgs<T>,
+> = Args[1] extends string
+  ? SetQueryTableAlias<T, Args[1]>
+  : Args[1] extends { as: string }
+  ? SetQueryTableAlias<T, Args[1]['as']>
+  : Args[0] extends string
+  ? SetQueryTableAlias<T, Args[0]>
+  : Args[0] extends Query
+  ? SetQueryTableAlias<T, AliasOrTable<Args[0]>>
+  : T;
+
+export class From {
+  from<T extends Query, Args extends FromArgs<T>>(
+    this: T,
+    ...args: Args
+  ): FromResult<T, Args> {
+    return this.clone()._from(...args) as FromResult<T, Args>;
+  }
+
+  _from<T extends Query, Args extends FromArgs<T>>(
+    this: T,
+    ...args: Args
+  ): FromResult<T, Args> {
+    let as: string | undefined;
+    if (typeof args[1] === 'string') {
+      as = args[1];
+    } else if (typeof args[1] === 'object' && args[1].as) {
+      as = args[1].as;
+    } else if (typeof args[0] === 'string') {
+      if (!this.query.as) as = args[0];
+    } else if (!isRaw(args[0] as RawExpression)) {
+      as = (args[0] as Query).query.as || (args[0] as Query).table;
+    }
+
+    if (typeof args[1] === 'object' && 'only' in args[1]) {
+      (this.query as SelectQueryData).fromOnly = args[1].only;
+    }
+
+    const q = as ? this._as(as) : this;
+    q.query.from = args[0];
+    return q as unknown as FromResult<T, Args>;
+  }
+}

package/src/queryMethods/get.test.ts

@@ -0,0 +1,66 @@
+import { AssertEqual, User, userData, useTestDatabase } from '../test-utils';
+import { NumberColumn } from '../columnSchema';
+import { NotFoundError } from '../errors';
+import { raw } from '../common';
+
+describe('get', () => {
+  useTestDatabase();
+
+  describe('get', () => {
+    it('should select column and return a single value', async () => {
+      const { id } = await User.select('id').insert(userData);
+
+      const received = await User.get('id');
+
+      const eq: AssertEqual<typeof received, number> = true;
+      expect(eq).toBe(true);
+
+      expect(received).toBe(id);
+    });
+
+    it('should select raw and return a single value', async () => {
+      const received = await User.get(raw<NumberColumn>('count(*)::int'));
+
+      const eq: AssertEqual<typeof received, number> = true;
+      expect(eq).toBe(true);
+
+      expect(received).toBe(0);
+    });
+
+    it('should throw if not found', async () => {
+      await expect(() => User.get('id')).rejects.toThrowError(NotFoundError);
+    });
+  });
+
+  describe('getOptional', () => {
+    it('should select column and return a single value when exists', async () => {
+      const { id } = await User.select('id').insert(userData);
+
+      const received = await User.getOptional('id');
+
+      const eq: AssertEqual<typeof received, number | undefined> = true;
+      expect(eq).toBe(true);
+
+      expect(received).toBe(id);
+    });
+
+    it('should select raw and return a single value when exists', async () => {
+      const received = await User.getOptional(
+        raw<NumberColumn>('count(*)::int'),
+      );
+
+      const eq: AssertEqual<typeof received, number | undefined> = true;
+      expect(eq).toBe(true);
+
+      expect(received).toBe(0);
+    });
+
+    it('should return undefined if not found', async () => {
+      const value = await User.getOptional('id');
+      const eq: AssertEqual<typeof value, number | undefined> = true;
+      expect(eq).toBe(true);
+
+      expect(value).toBe(undefined);
+    });
+  });
+});

package/src/queryMethods/get.ts

@@ -0,0 +1,88 @@
+import {
+  Query,
+  QueryBase,
+  SetQueryReturnsValue,
+  SetQueryReturnsValueOptional,
+} from '../query';
+import { RelationQueryBase } from '../relations';
+import { isRaw, RawExpression } from '../common';
+import { addParserForRawExpression, processSelectArg } from './select';
+import { getQueryAs } from '../utils';
+
+export type GetArg<T extends QueryBase> =
+  | keyof T['selectable']
+  | (RelationQueryBase & { returnType: 'value' | 'valueOrThrow' })
+  | RawExpression;
+
+type UnwrapRaw<
+  T extends Query,
+  Arg extends GetArg<T>,
+> = Arg extends RawExpression ? Arg['__column'] : Exclude<Arg, RawExpression>;
+
+type GetResult<T extends Query, Arg extends GetArg<T>> = SetQueryReturnsValue<
+  T,
+  UnwrapRaw<T, Arg>
+>;
+
+type GetOptionalResult<
+  T extends Query,
+  Arg extends GetArg<T>,
+> = SetQueryReturnsValueOptional<T, UnwrapRaw<T, Arg>>;
+
+const _get = <
+  T extends Query,
+  R extends 'value' | 'valueOrThrow',
+  Arg extends GetArg<T>,
+>(
+  q: T,
+  returnType: R,
+  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, 'value', arg);
+    q.query.select = [arg];
+  } else {
+    q.query.select = [
+      processSelectArg(
+        q,
+        getQueryAs(q),
+        arg as Exclude<GetArg<T>, RawExpression>,
+      ),
+    ];
+  }
+
+  return q as unknown as GetResult<T, Arg> & GetOptionalResult<T, Arg>;
+};
+
+export class QueryGet {
+  get<T extends Query, Arg extends GetArg<T>>(
+    this: T,
+    arg: Arg,
+  ): GetResult<T, Arg> {
+    return this.clone()._get(arg);
+  }
+
+  _get<T extends Query, Arg extends GetArg<T>>(
+    this: T,
+    arg: Arg,
+  ): GetResult<T, Arg> {
+    return _get(this, 'valueOrThrow', arg);
+  }
+
+  getOptional<T extends Query, Arg extends GetArg<T>>(
+    this: T,
+    arg: Arg,
+  ): GetOptionalResult<T, Arg> {
+    return this.clone()._getOptional(arg);
+  }
+
+  _getOptional<T extends Query, Arg extends GetArg<T>>(
+    this: T,
+    arg: Arg,
+  ): GetOptionalResult<T, Arg> {
+    return _get(this, 'value', arg);
+  }
+}

package/src/queryMethods/having.test.ts

@@ -0,0 +1,247 @@
+import { expectQueryNotMutated, expectSql, User } from '../test-utils';
+import { raw } from '../common';
+
+describe('having', () => {
+  it('should support { count: value } object', () => {
+    const q = User.all();
+
+    expectSql(
+      q.having({ count: 5 }).toSql(),
+      `
+        SELECT *
+        FROM "user"
+        HAVING count(*) = 5
+      `,
+    );
+
+    expectQueryNotMutated(q);
+  });
+
+  it('should support simple object as argument', () => {
+    const q = User.all();
+
+    expectSql(
+      q
+        .having({
+          count: {
+            id: 5,
+          },
+        })
+        .toSql(),
+      `
+        SELECT *
+        FROM "user"
+        HAVING count("user"."id") = $1
+      `,
+      [5],
+    );
+
+    expectQueryNotMutated(q);
+  });
+
+  it('should support column operators', () => {
+    const q = User.all();
+
+    expectSql(
+      q
+        .having({
+          sum: {
+            id: {
+              gt: 5,
+              lt: 20,
+            },
+          },
+        })
+        .toSql(),
+      `
+        SELECT *
+        FROM "user"
+        HAVING sum("user"."id") > $1 AND sum("user"."id") < $2
+      `,
+      [5, 20],
+    );
+
+    expectQueryNotMutated(q);
+  });
+
+  it('should support distinct option', () => {
+    const q = User.all();
+
+    expectSql(
+      q
+        .having({
+          count: {
+            id: {
+              equals: 10,
+              distinct: true,
+            },
+          },
+        })
+        .toSql(),
+      `
+        SELECT *
+        FROM "user"
+        HAVING count(DISTINCT "user"."id") = $1
+      `,
+      [10],
+    );
+
+    expectQueryNotMutated(q);
+  });
+
+  it('should support order option', () => {
+    const q = User.all();
+
+    expectSql(
+      q
+        .having({
+          count: {
+            id: {
+              equals: 10,
+              order: {
+                name: 'ASC',
+              },
+            },
+          },
+        })
+        .toSql(),
+      `
+        SELECT *
+        FROM "user"
+        HAVING count("user"."id" ORDER BY "user"."name" ASC) = $1
+      `,
+      [10],
+    );
+
+    expectQueryNotMutated(q);
+  });
+
+  it('should support filter and filterOr option', () => {
+    const q = User.all();
+
+    expectSql(
+      q
+        .having({
+          count: {
+            id: {
+              equals: 10,
+              filter: {
+                id: {
+                  lt: 10,
+                },
+              },
+              filterOr: [
+                {
+                  id: {
+                    equals: 15,
+                  },
+                },
+                {
+                  id: {
+                    gt: 20,
+                  },
+                },
+              ],
+            },
+          },
+        })
+        .toSql(),
+      `
+        SELECT *
+        FROM "user"
+        HAVING count("user"."id")
+          FILTER (
+            WHERE "user"."id" < $1 OR "user"."id" = $2 OR "user"."id" > $3
+          ) = $4
+      `,
+      [10, 15, 20, 10],
+    );
+
+    expectQueryNotMutated(q);
+  });
+
+  it('should support withinGroup option', () => {
+    const q = User.all();
+
+    expectSql(
+      q
+        .having({
+          count: {
+            id: {
+              equals: 10,
+              withinGroup: true,
+              order: { name: 'ASC' },
+            },
+          },
+        })
+        .toSql(),
+      `
+        SELECT *
+        FROM "user"
+        HAVING count("user"."id") WITHIN GROUP (ORDER BY "user"."name" ASC) = $1
+      `,
+      [10],
+    );
+
+    expectQueryNotMutated(q);
+  });
+
+  it('adds having condition with raw sql', () => {
+    const q = User.clone();
+
+    const expectedSql = `
+      SELECT *
+      FROM "user"
+      HAVING count(*) = 1 AND sum(id) = 2
+    `;
+
+    expectSql(
+      q.having(raw('count(*) = 1'), raw('sum(id) = 2')).toSql(),
+      expectedSql,
+    );
+    expectQueryNotMutated(q);
+
+    q._having(raw('count(*) = 1'), raw('sum(id) = 2'));
+    expectSql(q.toSql(), expectedSql);
+  });
+
+  describe('havingOr', () => {
+    it('should join conditions with or', () => {
+      const q = User.all();
+      expectSql(
+        q.havingOr({ count: 1 }, { count: 2 }).toSql(),
+        `
+        SELECT * FROM "user"
+        HAVING count(*) = 1 OR count(*) = 2
+      `,
+      );
+      expectQueryNotMutated(q);
+    });
+
+    it('should handle sub queries', () => {
+      const q = User.all();
+      expectSql(
+        q
+          .havingOr({ count: 1 }, User.having({ count: 2 }, { count: 3 }))
+          .toSql(),
+        `
+        SELECT * FROM "user"
+        HAVING count(*) = 1 OR (count(*) = 2 AND count(*) = 3)
+      `,
+      );
+      expectQueryNotMutated(q);
+    });
+
+    it('should accept raw sql', () => {
+      const q = User.all();
+      expectSql(
+        q.havingOr(raw('count(*) = 1 + 2'), raw('count(*) = 2 + 3')).toSql(),
+        `
+        SELECT * FROM "user"
+        HAVING count(*) = 1 + 2 OR count(*) = 2 + 3
+      `,
+      );
+      expectQueryNotMutated(q);
+    });
+  });
+});

package/src/queryMethods/having.ts

@@ -0,0 +1,99 @@
+import { Query } from '../query';
+import {
+  AggregateItemOptions,
+  ColumnOperators,
+  HavingItem,
+  OrderItem,
+  WhereItem,
+} from '../sql';
+import { pushQueryArray } from '../queryDataUtils';
+import { Aggregate1ArgumentTypes, AggregateOptions } from './aggregate';
+import { isRaw, RawExpression } from '../common';
+
+type HavingArgObject<
+  T extends Query,
+  Agg extends keyof Aggregate1ArgumentTypes<T>,
+> = {
+  [Column in Exclude<Aggregate1ArgumentTypes<T>[Agg], RawExpression>]?:
+    | T['selectable'][Column]['column']['type']
+    | (ColumnOperators<T['selectable'], Column> & AggregateOptions<T>);
+};
+
+export type HavingArg<T extends Query = Query> =
+  | ({
+      [Agg in keyof Aggregate1ArgumentTypes<T>]?: HavingArgObject<T, Agg>;
+    } & {
+      count?: number | HavingArgObject<T, 'count'>;
+    })
+  | Query
+  | RawExpression;
+
+const processHavingArg = <T extends Query>(arg: HavingArg<T>): HavingItem => {
+  if ('__model' in arg || isRaw(arg)) {
+    return arg;
+  } else {
+    const processed = { ...arg } as Record<
+      string,
+      Record<string, AggregateItemOptions>
+    >;
+
+    for (const fn in arg) {
+      const data = arg[fn as keyof typeof arg];
+      if (typeof data === 'object') {
+        processed[fn] = { ...data } as typeof processed[string];
+        for (const column in data) {
+          const value = data[column as keyof typeof data];
+
+          if (typeof value === 'object') {
+            processed[fn][column] = { ...(value as object) };
+
+            const options = value as AggregateOptions<T>;
+
+            if (
+              'order' in options &&
+              options.order &&
+              !Array.isArray(options.order)
+            ) {
+              processed[fn][column].order = [options.order as OrderItem];
+            }
+
+            if ('filter' in options && options.filter) {
+              processed[fn][column].filter = options.filter as WhereItem;
+            }
+
+            if ('filterOr' in options && options.filterOr) {
+              processed[fn][column].filterOr = options.filterOr as WhereItem[];
+            }
+          }
+        }
+      }
+    }
+    return processed;
+  }
+};
+
+export class Having {
+  having<T extends Query>(this: T, ...args: HavingArg<T>[]): T {
+    return this.clone()._having(...args);
+  }
+
+  _having<T extends Query>(this: T, ...args: HavingArg<T>[]): T {
+    return pushQueryArray(
+      this,
+      'having',
+      args.map((arg) => processHavingArg(arg)),
+    );
+  }
+
+  havingOr<T extends Query>(this: T, ...args: HavingArg<T>[]): T {
+    return this.clone()._havingOr(...args);
+  }
+
+  _havingOr<T extends Query>(this: T, ...args: HavingArg<T>[]): T {
+    return pushQueryArray(
+      this,
+      'havingOr',
+      args.map((arg) => [processHavingArg(arg)]),
+    );
+  }
+}