@uql/core 1.0.12 → 3.1.0

package/src/repository/genericRepository.spec.ts

@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it, jest } from 'bun:test';
+import { User } from '../test/index.js';
+import type { Querier, Repository } from '../type/index.js';
+import { GenericRepository } from './genericRepository.js';
+
+describe('repository', () => {
+  let repository: Repository<User>;
+  let querier: Record<keyof Querier, jest.Mock>;
+
+  beforeEach(() => {
+    querier = {
+      count: jest.fn(),
+      findOneById: jest.fn(),
+      findOne: jest.fn(),
+      findMany: jest.fn(),
+      findManyAndCount: jest.fn(),
+      insertOne: jest.fn(),
+      insertMany: jest.fn(),
+      updateOneById: jest.fn(),
+      updateMany: jest.fn(),
+      saveOne: jest.fn(),
+      saveMany: jest.fn(),
+      deleteOneById: jest.fn(),
+      deleteMany: jest.fn(),
+      upsertOne: jest.fn(),
+      getRepository: jest.fn(),
+      hasOpenTransaction: undefined,
+      transaction: jest.fn(),
+      beginTransaction: jest.fn(),
+      commitTransaction: jest.fn(),
+      rollbackTransaction: jest.fn(),
+      release: jest.fn(),
+    };
+    repository = new GenericRepository(User, querier as unknown as Querier);
+  });
+
+  it('count', async () => {
+    await repository.count({});
+    expect(querier.count).toHaveBeenCalledWith(User, {});
+  });
+
+  it('findOneById', async () => {
+    await repository.findOneById(1);
+    expect(querier.findOneById).toHaveBeenCalledWith(User, 1, undefined);
+  });
+
+  it('findOne', async () => {
+    await repository.findOne({});
+    expect(querier.findOne).toHaveBeenCalledWith(User, {});
+  });
+
+  it('findMany', async () => {
+    await repository.findMany({});
+    expect(querier.findMany).toHaveBeenCalledWith(User, {});
+  });
+
+  it('findManyAndCount', async () => {
+    await repository.findManyAndCount({});
+    expect(querier.findManyAndCount).toHaveBeenCalledWith(User, {});
+  });
+
+  it('insertOne', async () => {
+    await repository.insertOne({});
+    expect(querier.insertOne).toHaveBeenCalledWith(User, {});
+  });
+
+  it('insertMany', async () => {
+    await repository.insertMany([{}]);
+    expect(querier.insertMany).toHaveBeenCalledWith(User, [{}]);
+  });
+
+  it('updateMany', async () => {
+    await repository.updateMany({}, {});
+    expect(querier.updateMany).toHaveBeenCalledWith(User, {}, {});
+  });
+
+  it('updateOneById', async () => {
+    await repository.updateOneById(1, {});
+    expect(querier.updateOneById).toHaveBeenCalledWith(User, 1, {});
+  });
+
+  it('saveOne', async () => {
+    await repository.saveOne({});
+    expect(querier.saveOne).toHaveBeenCalledWith(User, {});
+  });
+
+  it('insertMany', async () => {
+    await repository.saveMany([{}]);
+    expect(querier.saveMany).toHaveBeenCalledWith(User, [{}]);
+  });
+
+  it('deleteOneById', async () => {
+    await repository.deleteOneById(1);
+    expect(querier.deleteOneById).toHaveBeenCalledWith(User, 1, undefined);
+
+    await repository.deleteOneById(1, { softDelete: false });
+    expect(querier.deleteOneById).toHaveBeenCalledWith(User, 1, { softDelete: false });
+  });
+
+  it('deleteMany', async () => {
+    await repository.deleteMany({});
+    expect(querier.deleteMany).toHaveBeenCalledWith(User, {}, undefined);
+
+    await repository.deleteMany({}, { softDelete: false });
+    expect(querier.deleteMany).toHaveBeenCalledWith(User, {}, { softDelete: false });
+  });
+
+  it('repository property', () => {
+    expect(repository.querier).toBe(querier);
+  });
+});

package/src/repository/genericRepository.ts

@@ -0,0 +1,74 @@
+import type {
+  IdValue,
+  Querier,
+  Query,
+  QueryConflictPaths,
+  QueryOne,
+  QueryOptions,
+  QuerySearch,
+  Repository,
+  Type,
+} from '../type/index.js';
+
+export class GenericRepository<E> implements Repository<E> {
+  constructor(
+    readonly entity: Type<E>,
+    readonly querier: Querier,
+  ) {}
+
+  findOneById(id: IdValue<E>, q?: QueryOne<E>) {
+    return this.querier.findOneById(this.entity, id, q);
+  }
+
+  findOne(q: QueryOne<E>) {
+    return this.querier.findOne(this.entity, q);
+  }
+
+  findMany(q: Query<E>) {
+    return this.querier.findMany(this.entity, q);
+  }
+
+  findManyAndCount(q: Query<E>) {
+    return this.querier.findManyAndCount(this.entity, q);
+  }
+
+  count(q?: QuerySearch<E>) {
+    return this.querier.count(this.entity, q);
+  }
+
+  insertOne(payload: E) {
+    return this.querier.insertOne(this.entity, payload);
+  }
+
+  upsertOne(conflictPaths: QueryConflictPaths<E>, payload: E) {
+    return this.querier.upsertOne(this.entity, conflictPaths, payload);
+  }
+
+  insertMany(payload: E[]) {
+    return this.querier.insertMany(this.entity, payload);
+  }
+
+  updateOneById(id: IdValue<E>, payload: E) {
+    return this.querier.updateOneById(this.entity, id, payload);
+  }
+
+  updateMany(qm: QuerySearch<E>, payload: E) {
+    return this.querier.updateMany(this.entity, qm, payload);
+  }
+
+  saveOne(payload: E) {
+    return this.querier.saveOne(this.entity, payload);
+  }
+
+  saveMany(payload: E[]) {
+    return this.querier.saveMany(this.entity, payload);
+  }
+
+  deleteOneById(id: IdValue<E>, opts?: QueryOptions) {
+    return this.querier.deleteOneById(this.entity, id, opts);
+  }
+
+  deleteMany(qm: QuerySearch<E>, opts?: QueryOptions) {
+    return this.querier.deleteMany(this.entity, qm, opts);
+  }
+}

package/src/repository/index.ts

@@ -0,0 +1 @@
+export * from './genericRepository.js';

package/src/sqlite/index.ts

@@ -0,0 +1,3 @@
+export * from './sqliteDialect.js';
+export * from './sqliteQuerier.js';
+export * from './sqliteQuerierPool.js';

package/src/sqlite/manual-types.d.ts

@@ -0,0 +1,4 @@
+declare module 'sqlstring-sqlite' {
+  // biome-ignore lint/suspicious/noShadowRestrictedNames: exported by third-party
+  export function escape(value: unknown): string;
+}

package/src/sqlite/sqliteDialect.spec.ts

@@ -0,0 +1,155 @@
+import { expect } from 'bun:test';
+import { AbstractSqlDialectSpec } from '../dialect/abstractSqlDialect-spec.js';
+import { Company, createSpec, InventoryAdjustment, Item, ItemTag, Profile, TaxCategory, User } from '../test/index.js';
+import { SqliteDialect } from './sqliteDialect.js';
+
+class SqliteDialectSpec extends AbstractSqlDialectSpec {
+  constructor() {
+    super(new SqliteDialect());
+  }
+
+  override shouldBeginTransaction() {
+    expect(this.dialect.beginTransactionCommand).toBe('BEGIN TRANSACTION');
+  }
+
+  override shouldUpsert() {
+    const { sql, values } = this.exec((ctx) =>
+      this.dialect.upsert(
+        ctx,
+        TaxCategory,
+        { pk: true },
+        {
+          pk: 'a',
+          name: 'Some Name D',
+          createdAt: 1,
+          updatedAt: 1,
+        },
+      ),
+    );
+    expect(sql).toMatch(
+      /^INSERT INTO `TaxCategory` \(.*`pk`.*`name`.*`createdAt`.*`updatedAt`.*\) VALUES \(\?, \?, \?, \?\) ON CONFLICT \(`pk`\) DO UPDATE SET .*`name` = EXCLUDED.`name`.*`createdAt` = EXCLUDED.`createdAt`.*`updatedAt` = EXCLUDED.`updatedAt`.*$/,
+    );
+    expect(values).toEqual(['a', 'Some Name D', 1, 1]);
+  }
+
+  shouldUpsertWithDifferentColumnNames() {
+    const { sql, values } = this.exec((ctx) =>
+      this.dialect.upsert(
+        ctx,
+        Profile,
+        { pk: true },
+        {
+          pk: 1,
+          picture: 'image.jpg',
+        },
+      ),
+    );
+    expect(sql).toMatch(
+      /^INSERT INTO `user_profile` \(.*`pk`.*`image`.*`updatedAt`.*`createdAt`.*\) VALUES \(\?, \?, \?, \?\) ON CONFLICT \(`pk`\) DO UPDATE SET .*`image` = EXCLUDED.`image`.*`updatedAt` = EXCLUDED.`updatedAt`.*$/,
+    );
+    expect(values).toEqual([1, 'image.jpg', expect.any(Number), expect.any(Number)]);
+  }
+
+  shouldUpsertWithNonUpdatableFields() {
+    const { sql, values } = this.exec((ctx) =>
+      this.dialect.upsert(
+        ctx,
+        User,
+        { id: true },
+        {
+          id: 1,
+          email: 'a@b.com',
+        },
+      ),
+    );
+    expect(sql).toMatch(
+      /^INSERT INTO `User` \(.*`id`.*`email`.*`updatedAt`.*`createdAt`.*\) VALUES \(\?, \?, \?, \?\) ON CONFLICT \(`id`\) DO UPDATE SET .*`updatedAt` = EXCLUDED.`updatedAt`.*$/,
+    );
+    expect(values).toEqual([1, 'a@b.com', expect.any(Number), expect.any(Number)]);
+  }
+
+  override shouldInsertOne() {
+    let res = this.exec((ctx) =>
+      this.dialect.insert(ctx, User, {
+        name: 'Some Name',
+        email: 'someemail@example.com',
+        createdAt: 123,
+      }),
+    );
+    expect(res.sql).toBe('INSERT INTO `User` (`name`, `email`, `createdAt`) VALUES (?, ?, ?)');
+    expect(res.values).toEqual(['Some Name', 'someemail@example.com', 123]);
+
+    res = this.exec((ctx) =>
+      this.dialect.insert(ctx, InventoryAdjustment, {
+        date: new Date(2021, 11, 31, 23, 59, 59, 999),
+        createdAt: 123,
+      }),
+    );
+    expect(res.sql).toBe('INSERT INTO `InventoryAdjustment` (`date`, `createdAt`) VALUES (?, ?)');
+    expect(res.values[0]).toBe(1640995199999);
+    expect(res.values[1]).toBe(123);
+  }
+
+  shouldUpsertWithDoNothing() {
+    const { sql, values } = this.exec((ctx) =>
+      this.dialect.upsert(
+        ctx,
+        ItemTag,
+        { id: true },
+        {
+          id: 1,
+        },
+      ),
+    );
+    expect(sql).toBe('INSERT INTO `ItemTag` (`id`) VALUES (?) ON CONFLICT (`id`) DO NOTHING');
+    expect(values).toEqual([1]);
+  }
+
+  override shouldFind$text() {
+    let res = this.exec((ctx) =>
+      this.dialect.find(ctx, Item, {
+        $select: { id: true },
+        $where: { $text: { $fields: ['name', 'description'], $value: 'some text' }, companyId: 1 },
+        $limit: 30,
+      }),
+    );
+    expect(res.sql).toBe(
+      'SELECT `id` FROM `Item` WHERE `Item` MATCH {`name` `description`} : ? AND `companyId` = ? LIMIT 30',
+    );
+    expect(res.values).toEqual(['some text', 1]);
+
+    res = this.exec((ctx) =>
+      this.dialect.find(ctx, User, {
+        $select: { id: 1 },
+        $where: {
+          $text: { $fields: ['name'], $value: 'something' },
+          name: { $ne: 'other unwanted' },
+          companyId: 1,
+        },
+        $limit: 10,
+      }),
+    );
+    expect(res.sql).toBe(
+      'SELECT `id` FROM `User` WHERE `User` MATCH {`name`} : ? AND `name` <> ? AND `companyId` = ? LIMIT 10',
+    );
+    expect(res.values).toEqual(['something', 'other unwanted', 1]);
+  }
+
+  override shouldUpdateWithJsonbField() {
+    const { sql, values } = this.exec((ctx) =>
+      this.dialect.update(
+        ctx,
+        Company,
+        { $where: { id: 1 } },
+        {
+          kind: { private: 1 },
+          updatedAt: 123,
+        },
+      ),
+    );
+    expect(sql).toBe('UPDATE `Company` SET `kind` = ?, `updatedAt` = ? WHERE `id` = ?');
+    expect(values).toEqual(['{"private":1}', 123, 1]);
+  }
+}
+
+createSpec(new SqliteDialectSpec());

package/src/sqlite/sqliteDialect.ts

@@ -0,0 +1,76 @@
+import sqlstring from 'sqlstring-sqlite';
+import { AbstractSqlDialect } from '../dialect/index.js';
+import { getMeta } from '../entity/index.js';
+import type {
+  FieldKey,
+  NamingStrategy,
+  QueryComparisonOptions,
+  QueryConflictPaths,
+  QueryContext,
+  QueryTextSearchOptions,
+  QueryWhereFieldOperatorMap,
+  QueryWhereMap,
+  Type,
+} from '../type/index.js';
+
+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);
+  }
+}

package/src/sqlite/sqliteQuerier.spec.ts

@@ -0,0 +1,36 @@
+import { jest, mock } from 'bun:test';
+import { AbstractSqlQuerierSpec } from '../querier/abstractSqlQuerier-spec.js';
+import { createSpec } from '../test/index.js';
+
+mock.module('better-sqlite3', () => {
+  const { Database } = require('bun:sqlite');
+  class BetterSqlite3 extends Database {
+    pragma(source: string) {
+      return this.query(`PRAGMA ${source}`).all();
+    }
+  }
+  return {
+    default: BetterSqlite3,
+  };
+});
+
+import { Sqlite3QuerierPool } from './sqliteQuerierPool.js';
+
+class SqliteQuerierSpec extends AbstractSqlQuerierSpec {
+  constructor() {
+    super(new Sqlite3QuerierPool(':memory:'), 'INTEGER PRIMARY KEY');
+  }
+
+  override async beforeEach() {
+    await super.beforeEach();
+    await Promise.all([
+      this.querier.run('PRAGMA foreign_keys = ON'),
+      this.querier.run('PRAGMA journal_mode = WAL'),
+      this.querier.run('PRAGMA synchronous = normal'),
+      this.querier.run('PRAGMA temp_store = memory'),
+    ]);
+    jest.spyOn(this.querier, 'run').mockClear();
+  }
+}
+
+createSpec(new SqliteQuerierSpec());

package/src/sqlite/sqliteQuerier.test.ts

@@ -0,0 +1,21 @@
+import { AbstractSqlQuerierIt } from '../querier/abstractSqlQuerier-test.js';
+import { createSpec } from '../test/index.js';
+import { Sqlite3QuerierPool } from './sqliteQuerierPool.js';
+
+export class Sqlite3QuerierIt extends AbstractSqlQuerierIt {
+  constructor() {
+    super(new Sqlite3QuerierPool(':memory:'), 'INTEGER PRIMARY KEY');
+  }
+
+  override async beforeEach() {
+    await super.beforeEach();
+    await Promise.all([
+      this.querier.run('PRAGMA foreign_keys = ON'),
+      this.querier.run('PRAGMA journal_mode = WAL'),
+      this.querier.run('PRAGMA synchronous = normal'),
+      this.querier.run('PRAGMA temp_store = memory'),
+    ]);
+  }
+}
+
+createSpec(new Sqlite3QuerierIt());

package/src/sqlite/sqliteQuerier.ts

@@ -0,0 +1,37 @@
+import type { Database } from 'better-sqlite3';
+import { AbstractSqlQuerier } from '../querier/index.js';
+import type { ExtraOptions, QueryUpdateResult } from '../type/index.js';
+import { SqliteDialect } from './sqliteDialect.js';
+
+export class SqliteQuerier extends AbstractSqlQuerier {
+  constructor(
+    readonly db: Database,
+    readonly extra?: ExtraOptions,
+  ) {
+    super(new SqliteDialect(extra?.namingStrategy));
+  }
+
+  override async internalAll<T>(query: string, values?: unknown[]) {
+    this.extra?.logger?.(query, values);
+    return this.db.prepare(query).all(values || []) as T[];
+  }
+
+  override async internalRun(query: string, values?: unknown[]) {
+    this.extra?.logger?.(query, values);
+    const { changes, lastInsertRowid } = this.db.prepare(query).run(values || []);
+    const firstId = lastInsertRowid ? Number(lastInsertRowid) - (changes - 1) : undefined;
+    const ids = firstId
+      ? Array(changes)
+          .fill(firstId)
+          .map((i, index) => i + index)
+      : [];
+    return { changes, ids, firstId } satisfies QueryUpdateResult;
+  }
+
+  override async internalRelease() {
+    if (this.hasOpenTransaction) {
+      throw TypeError('pending transaction');
+    }
+    // no-op
+  }
+}

package/src/sqlite/sqliteQuerierPool.test.ts

@@ -0,0 +1,12 @@
+import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
+import { createSpec } from '../test/index.js';
+import type { SqliteQuerier } from './sqliteQuerier.js';
+import { Sqlite3QuerierPool } from './sqliteQuerierPool.js';
+
+export class Sqlite3QuerierPoolIt extends AbstractQuerierPoolIt<SqliteQuerier> {
+  constructor() {
+    super(new Sqlite3QuerierPool(':memory:'));
+  }
+}
+
+createSpec(new Sqlite3QuerierPoolIt());

package/src/sqlite/sqliteQuerierPool.ts

@@ -0,0 +1,38 @@
+import type { Options } from 'better-sqlite3';
+import { AbstractQuerierPool } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+import { SqliteQuerier } from './sqliteQuerier.js';
+
+export class Sqlite3QuerierPool extends AbstractQuerierPool<SqliteQuerier> {
+  private querier: SqliteQuerier;
+
+  constructor(
+    readonly filename?: string | Buffer,
+    readonly opts?: Options,
+    extra?: ExtraOptions,
+  ) {
+    super('sqlite', extra);
+  }
+
+  async getQuerier() {
+    if (!this.querier) {
+      let db: any;
+      if (typeof Bun !== 'undefined') {
+        const { Database } = await import('bun:sqlite');
+        db = new Database(this.filename as string, this.opts as any);
+        db.run('PRAGMA journal_mode = WAL');
+      } else {
+        const { default: Database } = await import('better-sqlite3');
+        db = new Database(this.filename, this.opts);
+        db.pragma('journal_mode = WAL');
+      }
+      this.querier = new SqliteQuerier(db, this.extra);
+    }
+    return this.querier;
+  }
+
+  async end() {
+    await this.querier.db.close();
+    delete this.querier;
+  }
+}