#405

Committed 12 Aug 2024 09:07PM UTC coverage: 97.342% (-0.08%) from 97.422%

Build # #405

Build Type

push

Committed by

Commit Message

v1.2.0

Run Details

364 of 389 branches covered (93.57%)

Branch coverage included in aggregate %.

1504 of 1530 relevant lines covered (98.3%)

97.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.2

/packages/nukak-postgres/src/postgresDialect.ts

import {
  type QueryComparisonOptions,
  type QueryWhereMap,
  type QueryOptions,
  type QueryWhereFieldOperatorMap,
  type QueryTextSearchOptions,
  type Type,
  type FieldKey,
  type Scalar,
  type QueryConflictPaths,
  QueryRaw,
} from 'nukak/type';
import { AbstractSqlDialect } from 'nukak/dialect';
import { getMeta } from 'nukak/entity';
import { quoteLiteral } from 'node-pg-format';
import { getKeys, getPersistable, getRawValue } from 'nukak/util';

export class PostgresDialect extends AbstractSqlDialect {
  constructor() {
    super('"', 'BEGIN TRANSACTION');
  }

  override insert<E>(entity: Type<E>, payload: E | E[]): string {
    const sql = super.insert(entity, payload);
    const returning = this.returningId(entity);
    return `${sql} ${returning}`;
  }

  override upsert<E>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): string {
    const meta = getMeta(entity);
    const insert = super.insert(entity, payload);
    const record = getPersistable(meta, payload, 'onInsert');
    const columns = getKeys(record);
    const update = columns
      .filter((col) => !conflictPaths[col])
      .map((col) => `${this.escapeId(col)} = EXCLUDED.${this.escapeId(col)}`)
      .join(', ');
    const keysStr = getKeys(conflictPaths)
      .map((key) => this.escapeId(key))
      .join(', ');
    const returning = this.returningId(entity);
    return `${insert} ON CONFLICT (${keysStr}) DO UPDATE SET ${update} ${returning}`;
  }

  override compare<E, K extends keyof QueryWhereMap<E>>(
    entity: Type<E>,
    key: K,
    val: QueryWhereMap<E>[K],
    opts: QueryComparisonOptions = {},
  ): string {
    if (key === '$text') {
      const meta = getMeta(entity);
      const search = val as QueryTextSearchOptions<E>;
      const fields = search.$fields
        .map((field) => this.escapeId(meta.fields[field]?.name ?? field))
        .join(` || ' ' || `);
      return `to_tsvector(${fields}) @@ to_tsquery(${this.escape(search.$value)})`;
    }
    return super.compare(entity, key, val, opts);
  }

  override compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(
    entity: Type<E>,
    key: FieldKey<E>,
    op: K,
    val: QueryWhereFieldOperatorMap<E>[K],
    opts: QueryOptions = {},
  ): string {
    const comparisonKey = this.getComparisonKey(entity, key, opts);
    switch (op) {
      case '$istartsWith':
        return `${comparisonKey} ILIKE ${this.escape(`${val}%`)}`;
      case '$iendsWith':
        return `${comparisonKey} ILIKE ${this.escape(`%${val}`)}`;
      case '$iincludes':
        return `${comparisonKey} ILIKE ${this.escape(`%${val}%`)}`;
      case '$ilike':
        return `${comparisonKey} ILIKE ${this.escape(val)}`;
      case '$regex':
        return `${comparisonKey} ~ ${this.escape(val)}`;
      default:
        return super.compareFieldOperator(entity, key, op, val, opts);
    }
  }

  override escape(value: any): Scalar {
    if (value instanceof QueryRaw) {
      return getRawValue({ value, dialect: this });
    }
    return quoteLiteral(value);
  }
}

1	import {	1✔
2	type QueryComparisonOptions,
3	type QueryWhereMap,
4	type QueryOptions,
5	type QueryWhereFieldOperatorMap,
6	type QueryTextSearchOptions,
7	type Type,
8	type FieldKey,
9	type Scalar,
10	type QueryConflictPaths,
11	QueryRaw,
12	} from 'nukak/type';
13	import { AbstractSqlDialect } from 'nukak/dialect';	1✔
14	import { getMeta } from 'nukak/entity';	1✔
15	import { quoteLiteral } from 'node-pg-format';	1✔
16	import { getKeys, getPersistable, getRawValue } from 'nukak/util';	1✔
17
18	export class PostgresDialect extends AbstractSqlDialect {	1✔
19	constructor() {
20	super('"', 'BEGIN TRANSACTION');	1✔
21	}
22
23	override insert<E>(entity: Type<E>, payload: E \| E[]): string {
24	const sql = super.insert(entity, payload);	3✔
25	const returning = this.returningId(entity);	3✔
26	return `${sql} ${returning}`;	3✔
27	}
28
29	override upsert<E>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): string {
30	const meta = getMeta(entity);	1✔
31	const insert = super.insert(entity, payload);	1✔
32	const record = getPersistable(meta, payload, 'onInsert');	1✔
33	const columns = getKeys(record);	1✔
34	const update = columns	1✔
35	.filter((col) => !conflictPaths[col])	3✔
36	.map((col) => `${this.escapeId(col)} = EXCLUDED.${this.escapeId(col)}`)	2✔
37	.join(', ');
38	const keysStr = getKeys(conflictPaths)	1✔
39	.map((key) => this.escapeId(key))	1✔
40	.join(', ');
41	const returning = this.returningId(entity);	1✔
42	return `${insert} ON CONFLICT (${keysStr}) DO UPDATE SET ${update} ${returning}`;	1✔
43	}
44
45	override compare<E, K extends keyof QueryWhereMap<E>>(
46	entity: Type<E>,
47	key: K,
48	val: QueryWhereMap<E>[K],
49	opts: QueryComparisonOptions = {},	×
50	): string {
51	if (key === '$text') {	14✔
52	const meta = getMeta(entity);	2✔
53	const search = val as QueryTextSearchOptions<E>;	2✔
54	const fields = search.$fields	2✔
55	.map((field) => this.escapeId(meta.fields[field]?.name ?? field))	3!
56	.join(` \|\| ' ' \|\| `);
57	return `to_tsvector(${fields}) @@ to_tsquery(${this.escape(search.$value)})`;	2✔
58	}
59	return super.compare(entity, key, val, opts);	12✔
60	}
61
62	override compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(
63	entity: Type<E>,
64	key: FieldKey<E>,
65	op: K,
66	val: QueryWhereFieldOperatorMap<E>[K],
67	opts: QueryOptions = {},	×
68	): string {
69	const comparisonKey = this.getComparisonKey(entity, key, opts);	16✔
70	switch (op) {	16✔
71	case '$istartsWith':
72	return `${comparisonKey} ILIKE ${this.escape(`${val}%`)}`;	2✔
73	case '$iendsWith':
74	return `${comparisonKey} ILIKE ${this.escape(`%${val}`)}`;	2✔
75	case '$iincludes':
76	return `${comparisonKey} ILIKE ${this.escape(`%${val}%`)}`;	2✔
77	case '$ilike':
78	return `${comparisonKey} ILIKE ${this.escape(val)}`;	2✔
79	case '$regex':
80	return `${comparisonKey} ~ ${this.escape(val)}`;	1✔
81	default:
82	return super.compareFieldOperator(entity, key, op, val, opts);	7✔
83	}
84	}
85
86	override escape(value: any): Scalar {
87	if (value instanceof QueryRaw) {	36!
88	return getRawValue({ value, dialect: this });	×
89	}
90	return quoteLiteral(value);	36✔
91	}
92	}

rogerpadilla / nukak / #405

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous