@uql/core 3.1.1 → 3.1.3

package/src/querier/index.ts

@@ -1,4 +0,0 @@
-export * from './abstractQuerier.js';
-export * from './abstractQuerierPool.js';
-export * from './abstractSqlQuerier.js';
-export * from './decorator/index.js';

package/src/repository/genericRepository.spec.ts

@@ -1,111 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

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

package/src/sqlite/index.ts

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

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

@@ -1,4 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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;
-  }
-}