#526

Committed 29 Dec 2025 06:29PM UTC coverage: 86.953% (+0.4%) from 86.536%

Build # #526

Build Type

push

Committed by

Commit Message

v1.8.0

Run Details

683 of 922 branches covered (74.08%)

Branch coverage included in aggregate %.

2376 of 2596 relevant lines covered (91.53%)

149.63 hits per line

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

85.37

/packages/sqlite/src/sqliteDialect.ts

import { AbstractSqlDialect } from 'nukak/dialect';
import { getMeta } from 'nukak/entity';
import type {
  FieldKey,
  NamingStrategy,
  QueryComparisonOptions,
  QueryConflictPaths,
  QueryContext,
  QueryTextSearchOptions,
  QueryWhereFieldOperatorMap,
  QueryWhereMap,
  Type,
} from 'nukak/type';
import sqlstring from 'sqlstring-sqlite';

export class SqliteDialect extends AbstractSqlDialect {
  constructor(namingStrategy?: NamingStrategy) {
    super(namingStrategy, '`', 'BEGIN TRANSACTION');
  }

  override addValue(values: unknown[], value: unknown): string {
    if (value instanceof Date) {
      value = value.getTime();
    } else if (typeof value === 'boolean') {
      value = value ? 1 : 0;
    }
    return super.addValue(values, value);
  }

  override compare<E, K extends keyof QueryWhereMap<E>>(
    ctx: QueryContext,
    entity: Type<E>,
    key: K,
    val: QueryWhereMap<E>[K],
    opts?: QueryComparisonOptions,
  ): void {
    if (key === '$text') {
      const meta = getMeta(entity);
      const search = val as QueryTextSearchOptions<E>;
      const fields = search.$fields.map((fKey) => {
        const field = meta.fields[fKey];
        const columnName = this.resolveColumnName(fKey as string, field);
        return this.escapeId(columnName);
      });
      const tableName = this.resolveTableName(entity, meta);
      ctx.append(`${this.escapeId(tableName)} MATCH {${fields.join(' ')}} : `);
      ctx.addValue(search.$value);
      return;
    }
    super.compare(ctx, entity, key, val, opts);
  }

  override compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(
    ctx: QueryContext,
    entity: Type<E>,
    key: FieldKey<E>,
    op: K,
    val: QueryWhereFieldOperatorMap<E>[K],
    opts: QueryComparisonOptions = {},
  ): void {
    super.compareFieldOperator(ctx, entity, key, op, val, opts);
  }

  override upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): void {
    const meta = getMeta(entity);
    const update = this.getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, (name) => `EXCLUDED.${name}`);
    const keysStr = this.getUpsertConflictPathsStr(meta, conflictPaths);
    const onConflict = update ? `DO UPDATE SET ${update}` : 'DO NOTHING';
    this.insert(ctx, entity, payload);
    ctx.append(` ON CONFLICT (${keysStr}) ${onConflict}`);
  }

  override escape(value: unknown): string {
    return sqlstring.escape(value);
  }
}

1	import { AbstractSqlDialect } from 'nukak/dialect';	5✔
2	import { getMeta } from 'nukak/entity';	5✔
3	import type {
4	FieldKey,
5	NamingStrategy,
6	QueryComparisonOptions,
7	QueryConflictPaths,
8	QueryContext,
9	QueryTextSearchOptions,
10	QueryWhereFieldOperatorMap,
11	QueryWhereMap,
12	Type,
13	} from 'nukak/type';
14	import sqlstring from 'sqlstring-sqlite';	5✔
15
16	export class SqliteDialect extends AbstractSqlDialect {	5✔
17	constructor(namingStrategy?: NamingStrategy) {
18	super(namingStrategy, '`', 'BEGIN TRANSACTION');	5✔
19	}
20
21	override addValue(values: unknown[], value: unknown): string {
22	if (value instanceof Date) {	871✔
23	value = value.getTime();	2✔
24	} else if (typeof value === 'boolean') {	869!
25	value = value ? 1 : 0;	×
26	}
27	return super.addValue(values, value);	871✔
28	}
29
30	override compare<E, K extends keyof QueryWhereMap<E>>(
31	ctx: QueryContext,
32	entity: Type<E>,
33	key: K,
34	val: QueryWhereMap<E>[K],
35	opts?: QueryComparisonOptions,
36	): void {
37	if (key === '$text') {	465✔
38	const meta = getMeta(entity);	2✔
39	const search = val as QueryTextSearchOptions<E>;	2✔
40	const fields = search.$fields.map((fKey) => {	2✔
41	const field = meta.fields[fKey];	3✔
42	const columnName = this.resolveColumnName(fKey as string, field);	3✔
43	return this.escapeId(columnName);	3✔
44	});
45	const tableName = this.resolveTableName(entity, meta);	2✔
46	ctx.append(`${this.escapeId(tableName)} MATCH {${fields.join(' ')}} : `);	2✔
47	ctx.addValue(search.$value);	2✔
48	return;	2✔
49	}
50	super.compare(ctx, entity, key, val, opts);	463✔
51	}
52
53	override compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(
54	ctx: QueryContext,
55	entity: Type<E>,
56	key: FieldKey<E>,
57	op: K,
58	val: QueryWhereFieldOperatorMap<E>[K],
59	opts: QueryComparisonOptions = {},	×
60	): void {
61	super.compareFieldOperator(ctx, entity, key, op, val, opts);	443✔
62	}
63
64	override upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): void {
65	const meta = getMeta(entity);	6✔
66	const update = this.getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, (name) => `EXCLUDED.${name}`);	10✔
67	const keysStr = this.getUpsertConflictPathsStr(meta, conflictPaths);	6✔
68	const onConflict = update ? `DO UPDATE SET ${update}` : 'DO NOTHING';	6✔
69	this.insert(ctx, entity, payload);	6✔
70	ctx.append(` ON CONFLICT (${keysStr}) ${onConflict}`);	6✔
71	}
72
73	override escape(value: unknown): string {
74	return sqlstring.escape(value);	×
75	}
76	}

rogerpadilla / nukak / #526

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