@uql/core 3.1.1 → 3.1.3

package/src/mongo/mongodbQuerier.ts

@@ -1,256 +0,0 @@
-import type { ClientSession, Document, MongoClient, OptionalUnlessRequiredId, UpdateFilter } from 'mongodb';
-import { getMeta } from '../entity/index.js';
-import { AbstractQuerier, Serialized } from '../querier/index.js';
-import type {
-  ExtraOptions,
-  IdValue,
-  Query,
-  QueryConflictPaths,
-  QueryOptions,
-  QuerySearch,
-  QueryWhere,
-  Type,
-} from '../type/index.js';
-import { clone, getFieldCallbackValue, getKeys, hasKeys, isSelectingRelations } from '../util/index.js';
-
-import type { MongoDialect } from './mongoDialect.js';
-
-export class MongodbQuerier extends AbstractQuerier {
-  private session: ClientSession;
-
-  constructor(
-    readonly dialect: MongoDialect,
-    readonly conn: MongoClient,
-    readonly extra?: ExtraOptions,
-  ) {
-    super();
-  }
-
-  @Serialized()
-  private async execute<T>(task: (session: ClientSession) => Promise<T>): Promise<T> {
-    return task(this.session);
-  }
-
-  override async findMany<E extends Document>(entity: Type<E>, q: Query<E>) {
-    const meta = getMeta(entity);
-
-    let documents: E[];
-    const hasSelectedRelations = isSelectingRelations(meta, q.$select);
-
-    if (hasSelectedRelations) {
-      const pipeline = this.dialect.aggregationPipeline(entity, q);
-      this.extra?.logger('findMany', entity.name, JSON.stringify(pipeline, null, 2));
-      documents = await this.execute((session) =>
-        this.collection(entity).aggregate<E>(pipeline, { session }).toArray(),
-      );
-      documents = this.dialect.normalizeIds(meta, documents) as E[];
-      await this.fillToManyRelations(entity, documents, q.$select);
-    } else {
-      const cursor = this.collection(entity).find<E>({}, { session: this.session });
-
-      const filter = this.dialect.where(entity, q.$where);
-      if (hasKeys(filter)) {
-        cursor.filter(filter);
-      }
-      const select = this.dialect.select(entity, q.$select);
-      if (hasKeys(select)) {
-        cursor.project(select);
-      }
-      const sort = this.dialect.sort(entity, q.$sort);
-      if (hasKeys(sort)) {
-        cursor.sort(sort);
-      }
-      if (q.$skip) {
-        cursor.skip(q.$skip);
-      }
-      if (q.$limit) {
-        cursor.limit(q.$limit);
-      }
-
-      this.extra?.logger?.('findMany', entity.name, q);
-
-      documents = await this.execute(() => cursor.toArray() as Promise<E[]>);
-      documents = this.dialect.normalizeIds(meta, documents) as E[];
-    }
-
-    return documents;
-  }
-
-  override count<E extends Document>(entity: Type<E>, qm: QuerySearch<E> = {}) {
-    const filter = this.dialect.where(entity, qm.$where);
-    this.extra?.logger?.('count', entity.name, filter);
-    return this.execute((session) =>
-      this.collection(entity).countDocuments(filter, {
-        session,
-      }),
-    );
-  }
-
-  override async insertMany<E extends Document>(entity: Type<E>, payloads: E[]) {
-    if (!payloads?.length) {
-      return [];
-    }
-
-    payloads = clone(payloads);
-
-    const meta = getMeta(entity);
-    const persistables = this.dialect.getPersistables(meta, payloads, 'onInsert') as OptionalUnlessRequiredId<E>[];
-
-    this.extra?.logger?.('insertMany', entity.name, persistables);
-
-    const { insertedIds } = await this.execute((session) =>
-      this.collection(entity).insertMany(persistables, { session }),
-    );
-
-    const ids = Object.values(insertedIds) as unknown as IdValue<E>[];
-
-    for (const [index, it] of payloads.entries()) {
-      it[meta.id] = ids[index];
-    }
-
-    await this.insertRelations(entity, payloads);
-
-    return ids;
-  }
-
-  override async updateMany<E extends Document>(entity: Type<E>, qm: QuerySearch<E>, payload: E) {
-    payload = clone(payload);
-    const meta = getMeta(entity);
-    const persistable = this.dialect.getPersistable(meta, payload, 'onUpdate');
-    const where = this.dialect.where(entity, qm.$where);
-    const update = { $set: persistable } satisfies UpdateFilter<E>;
-
-    this.extra?.logger?.('updateMany', entity.name, where, update);
-
-    const { matchedCount } = await this.execute((session) =>
-      this.collection(entity).updateMany(where, update, {
-        session,
-      }),
-    );
-
-    await this.updateRelations(entity, qm, payload);
-
-    return matchedCount;
-  }
-
-  override async upsertOne<E extends Document>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E) {
-    payload = clone(payload);
-
-    const meta = getMeta(entity);
-    const persistable = this.dialect.getPersistable(meta, payload, 'onInsert') as OptionalUnlessRequiredId<E>;
-
-    this.extra?.logger?.('upsertOne', entity.name, persistable);
-
-    const where = getKeys(conflictPaths).reduce(
-      (acc, key) => {
-        acc[key] = payload[key];
-        return acc;
-      },
-      {} as QueryWhere<E>,
-    );
-
-    const filter = this.dialect.where(entity, where);
-
-    const update = { $set: persistable } as UpdateFilter<E>;
-
-    const res = await this.execute((session) =>
-      this.collection(entity).findOneAndUpdate(filter, update, {
-        upsert: true,
-        session,
-      }),
-    );
-
-    const firstId = res?._id as unknown as string;
-
-    return { firstId, changes: firstId ? 1 : 0 };
-  }
-
-  override async deleteMany<E extends Document>(entity: Type<E>, qm: QuerySearch<E>, opts: QueryOptions = {}) {
-    const meta = getMeta(entity);
-    const where = this.dialect.where(entity, qm.$where);
-    this.extra?.logger?.('deleteMany', entity.name, where, opts);
-    const founds = await this.execute((session) =>
-      this.collection(entity)
-        .find(where, {
-          projection: { _id: true },
-          session,
-        })
-        .toArray(),
-    );
-    if (!founds.length) {
-      return 0;
-    }
-    const ids = this.dialect.normalizeIds(meta, founds as unknown as E[]).map((found) => found[meta.id]);
-    let changes: number;
-    if (meta.softDelete && !opts.softDelete) {
-      const onDeleteValue = getFieldCallbackValue(meta.fields[meta.softDelete].onDelete);
-      const updateResult = await this.execute((session) =>
-        this.collection(entity).updateMany(
-          { _id: { $in: ids } },
-          { $set: { [meta.softDelete]: onDeleteValue } } as UpdateFilter<E>,
-          {
-            session,
-          },
-        ),
-      );
-      changes = updateResult.matchedCount;
-    } else {
-      const deleteResult = await this.execute((session) =>
-        this.collection(entity).deleteMany({ _id: { $in: ids } }, { session }),
-      );
-      changes = deleteResult.deletedCount;
-    }
-    await this.deleteRelations(entity, ids, opts);
-    return changes;
-  }
-
-  override get hasOpenTransaction() {
-    return this.session?.inTransaction();
-  }
-
-  collection<E extends Document>(entity: Type<E>) {
-    const { name } = getMeta(entity);
-    return this.db.collection<E>(name);
-  }
-
-  get db() {
-    return this.conn.db();
-  }
-
-  @Serialized()
-  override async beginTransaction() {
-    if (this.hasOpenTransaction) {
-      throw TypeError('pending transaction');
-    }
-    this.extra?.logger?.('beginTransaction');
-    await this.session?.endSession();
-    this.session = this.conn.startSession();
-    this.session.startTransaction();
-  }
-
-  @Serialized()
-  override async commitTransaction() {
-    if (!this.hasOpenTransaction) {
-      throw TypeError('not a pending transaction');
-    }
-    this.extra?.logger?.('commitTransaction');
-    await this.session.commitTransaction();
-  }
-
-  @Serialized()
-  override async rollbackTransaction() {
-    if (!this.hasOpenTransaction) {
-      throw TypeError('not a pending transaction');
-    }
-    this.extra?.logger?.('rollbackTransaction');
-    await this.session.abortTransaction();
-  }
-
-  override async internalRelease() {
-    if (this.hasOpenTransaction) {
-      throw TypeError('pending transaction');
-    }
-    await this.session?.endSession();
-    this.session = undefined;
-  }
-}

package/src/mongo/mongodbQuerierPool.test.ts

@@ -1,25 +0,0 @@
-import { MongoMemoryReplSet } from 'mongodb-memory-server';
-import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
-import { createSpec } from '../test/index.js';
-import type { MongodbQuerier } from './mongodbQuerier.js';
-import { MongodbQuerierPool } from './mongodbQuerierPool.js';
-
-class MongodbQuerierPoolIt extends AbstractQuerierPoolIt<MongodbQuerier> {
-  static replSet: MongoMemoryReplSet;
-
-  async beforeAll() {
-    MongodbQuerierPoolIt.replSet = await MongoMemoryReplSet.create({
-      replSet: { count: 1, storageEngine: 'wiredTiger' },
-    });
-    const uri = MongodbQuerierPoolIt.replSet.getUri();
-    this.pool = new MongodbQuerierPool(uri);
-  }
-
-  override async afterAll() {
-    await super.afterAll();
-    await this.pool.end();
-    await MongodbQuerierPoolIt.replSet.stop();
-  }
-}
-
-createSpec(new MongodbQuerierPoolIt(new MongodbQuerierPool('mongodb://127.0.0.1:27017/test')));

package/src/mongo/mongodbQuerierPool.ts

@@ -1,24 +0,0 @@
-import { MongoClient, type MongoClientOptions } from 'mongodb';
-import { AbstractQuerierPool } from '../querier/index.js';
-import type { ExtraOptions } from '../type/index.js';
-import { MongoDialect } from './mongoDialect.js';
-import { MongodbQuerier } from './mongodbQuerier.js';
-
-export class MongodbQuerierPool extends AbstractQuerierPool<MongodbQuerier> {
-  private readonly client: MongoClient;
-
-  constructor(uri: string, opts?: MongoClientOptions, extra?: ExtraOptions) {
-    super('mongodb', extra);
-    this.client = new MongoClient(uri, opts);
-  }
-
-  async getQuerier() {
-    const conn = await this.client.connect();
-    const querier = new MongodbQuerier(new MongoDialect(), conn, this.extra);
-    return querier;
-  }
-
-  async end() {
-    await this.client.close();
-  }
-}

package/src/mysql/index.ts

@@ -1,3 +0,0 @@
-export * from './mysql2Querier.js';
-export * from './mysql2QuerierPool.js';
-export * from './mysqlDialect.js';

package/src/mysql/mysql2Querier.test.ts

@@ -1,20 +0,0 @@
-import { AbstractSqlQuerierIt } from '../querier/abstractSqlQuerier-test.js';
-import { createSpec } from '../test/index.js';
-import { MySql2QuerierPool } from './mysql2QuerierPool.js';
-
-export class MySql2QuerierIt extends AbstractSqlQuerierIt {
-  constructor() {
-    super(
-      new MySql2QuerierPool({
-        host: '0.0.0.0',
-        port: 3316,
-        user: 'test',
-        password: 'test',
-        database: 'test',
-      }),
-      'INT AUTO_INCREMENT PRIMARY KEY',
-    );
-  }
-}
-
-createSpec(new MySql2QuerierIt());

package/src/mysql/mysql2Querier.ts

@@ -1,49 +0,0 @@
-import type { PoolConnection } from 'mysql2/promise';
-import { AbstractSqlQuerier } from '../querier/index.js';
-import type { ExtraOptions, QueryUpdateResult } from '../type/index.js';
-import { MySqlDialect } from './mysqlDialect.js';
-
-export class MySql2Querier extends AbstractSqlQuerier {
-  conn: PoolConnection;
-
-  constructor(
-    readonly connect: () => Promise<PoolConnection>,
-    readonly extra?: ExtraOptions,
-  ) {
-    super(new MySqlDialect(extra?.namingStrategy));
-  }
-
-  override async internalAll<T>(query: string, values?: unknown[]) {
-    this.extra?.logger?.(query, values);
-    await this.lazyConnect();
-    const [res] = await this.conn.query(query, values);
-    return res as T[];
-  }
-
-  override async internalRun(query: string, values?: unknown[]) {
-    this.extra?.logger?.(query, values);
-    await this.lazyConnect();
-    const [res]: any = await this.conn.query(query, values);
-    const ids = res.insertId
-      ? Array(res.affectedRows)
-          .fill(res.insertId)
-          .map((i, index) => i + index)
-      : [];
-    return { changes: res.affectedRows, ids, firstId: ids[0] } satisfies QueryUpdateResult;
-  }
-
-  async lazyConnect() {
-    this.conn ??= await this.connect();
-  }
-
-  override async internalRelease() {
-    if (this.hasOpenTransaction) {
-      throw TypeError('pending transaction');
-    }
-    if (!this.conn) {
-      return;
-    }
-    await this.conn.release();
-    this.conn = undefined;
-  }
-}

package/src/mysql/mysql2QuerierPool.test.ts

@@ -1,20 +0,0 @@
-import { AbstractQuerierPoolIt } from '../querier/abstractQuerierPool-test.js';
-import { createSpec } from '../test/index.js';
-import type { MySql2Querier } from './mysql2Querier.js';
-import { MySql2QuerierPool } from './mysql2QuerierPool.js';
-
-export class MySql2QuerierPoolIt extends AbstractQuerierPoolIt<MySql2Querier> {
-  constructor() {
-    super(
-      new MySql2QuerierPool({
-        host: '0.0.0.0',
-        port: 3316,
-        user: 'test',
-        password: 'test',
-        database: 'test',
-      }),
-    );
-  }
-}
-
-createSpec(new MySql2QuerierPoolIt());

package/src/mysql/mysql2QuerierPool.ts

@@ -1,21 +0,0 @@
-import { createPool, type Pool, type PoolOptions } from 'mysql2/promise';
-import { AbstractQuerierPool } from '../querier/index.js';
-import type { ExtraOptions } from '../type/index.js';
-import { MySql2Querier } from './mysql2Querier.js';
-
-export class MySql2QuerierPool extends AbstractQuerierPool<MySql2Querier> {
-  readonly pool: Pool;
-
-  constructor(opts: PoolOptions, extra?: ExtraOptions) {
-    super('mysql', extra);
-    this.pool = createPool(opts);
-  }
-
-  async getQuerier() {
-    return new MySql2Querier(() => this.pool.getConnection(), this.extra);
-  }
-
-  async end() {
-    await this.pool.end();
-  }
-}

package/src/mysql/mysqlDialect.spec.ts

@@ -1,20 +0,0 @@
-import { expect } from 'bun:test';
-import { AbstractSqlDialectSpec } from '../dialect/abstractSqlDialect-spec.js';
-import { createSpec } from '../test/index.js';
-import { MySqlDialect } from './mysqlDialect.js';
-
-export class MySqlDialectSpec extends AbstractSqlDialectSpec {
-  constructor() {
-    super(new MySqlDialect());
-  }
-
-  shouldHandleDate() {
-    const dialect = new MySqlDialect();
-    const values: unknown[] = [];
-    expect(dialect.addValue(values, new Date())).toBe('?');
-    expect(values).toHaveLength(1);
-    expect(values[0]).toBeInstanceOf(Date);
-  }
-}
-
-createSpec(new MySqlDialectSpec());

package/src/mysql/mysqlDialect.ts

@@ -1,16 +0,0 @@
-import SqlString from 'sqlstring';
-import { AbstractSqlDialect } from '../dialect/index.js';
-
-export class MySqlDialect extends AbstractSqlDialect {
-  override addValue(values: unknown[], value: unknown): string {
-    if (value instanceof Date) {
-      values.push(value);
-      return '?';
-    }
-    return super.addValue(values, value);
-  }
-
-  override escape(value: unknown): string {
-    return SqlString.escape(value);
-  }
-}

package/src/namingStrategy/defaultNamingStrategy.ts

@@ -1,18 +0,0 @@
-import type { NamingStrategy } from '../type/index.js';
-
-/**
- * Default naming strategy that returns identifiers as-is.
- */
-export class DefaultNamingStrategy implements NamingStrategy {
-  tableName(className: string): string {
-    return className;
-  }
-
-  columnName(propertyName: string): string {
-    return propertyName;
-  }
-
-  joinTableName(source: string, target: string, _propertyName?: string): string {
-    return `${source}_${target}`;
-  }
-}

package/src/namingStrategy/index.spec.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { DefaultNamingStrategy, SnakeCaseNamingStrategy } from './index.js';
-
-describe('NamingStrategy', () => {
-  describe('DefaultNamingStrategy', () => {
-    const strategy = new DefaultNamingStrategy();
-
-    it('tableName', () => {
-      expect(strategy.tableName('UserProfile')).toBe('UserProfile');
-    });
-
-    it('columnName', () => {
-      expect(strategy.columnName('firstName')).toBe('firstName');
-    });
-
-    it('joinTableName', () => {
-      expect(strategy.joinTableName('User', 'Role')).toBe('User_Role');
-    });
-  });
-
-  describe('SnakeCaseNamingStrategy', () => {
-    const strategy = new SnakeCaseNamingStrategy();
-
-    it('tableName', () => {
-      expect(strategy.tableName('UserProfile')).toBe('user_profile');
-    });
-
-    it('columnName', () => {
-      expect(strategy.columnName('firstName')).toBe('first_name');
-    });
-
-    it('joinTableName', () => {
-      expect(strategy.joinTableName('User', 'Role')).toBe('User_Role'); // Base implementation
-    });
-  });
-});

package/src/namingStrategy/index.ts

@@ -1,2 +0,0 @@
-export * from './defaultNamingStrategy.js';
-export * from './snakeCaseNamingStrategy.js';

package/src/namingStrategy/snakeCaseNamingStrategy.ts

@@ -1,15 +0,0 @@
-import { snakeCase } from '../util/index.js';
-import { DefaultNamingStrategy } from './defaultNamingStrategy.js';
-
-/**
- * Naming strategy that converts identifiers to snake_case.
- */
-export class SnakeCaseNamingStrategy extends DefaultNamingStrategy {
-  override tableName(className: string): string {
-    return snakeCase(className);
-  }
-
-  override columnName(propertyName: string): string {
-    return snakeCase(propertyName);
-  }
-}

package/src/options.spec.ts

@@ -1,41 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from 'bun:test';
-import { getQuerier, getQuerierPool, setQuerierPool } from './options.js';
-import { User } from './test/index.js';
-import type { Querier, Repository } from './type/index.js';
-
-describe('options', () => {
-  beforeEach(() => {
-    jest.spyOn(console, 'log');
-  });
-
-  it('getQuerierPool unset', () => {
-    expect(() => getQuerierPool()).toThrow('A default querier-pool has to be set first');
-  });
-
-  it('getQuerier', async () => {
-    const repositoryMock = {} as Repository<User>;
-
-    const querierMock = {
-      getRepository<T>(entity: T) {
-        return repositoryMock;
-      },
-    } as Querier;
-
-    setQuerierPool({
-      getQuerier: async () => querierMock,
-      end: async () => {},
-      dialect: 'postgres',
-    });
-
-    const querier1 = await getQuerierPool().getQuerier();
-    expect(querier1).toBe(querierMock);
-
-    const querier2 = await getQuerier();
-    expect(querier2).toBe(querierMock);
-
-    const repository1 = await querier2.getRepository(User);
-    expect(repository1).toBe(repositoryMock);
-
-    expect(getQuerierPool()).toBe(getQuerierPool());
-  });
-});

package/src/options.ts

@@ -1,18 +0,0 @@
-import type { Querier, QuerierPool } from './type/index.js';
-
-let defaultPool: QuerierPool;
-
-export function setQuerierPool<T extends QuerierPool = QuerierPool>(pool: T): void {
-  defaultPool = pool;
-}
-
-export function getQuerierPool(): QuerierPool {
-  if (!defaultPool) {
-    throw new TypeError('A default querier-pool has to be set first');
-  }
-  return defaultPool;
-}
-
-export function getQuerier(): Promise<Querier> {
-  return defaultPool.getQuerier();
-}

package/src/postgres/index.ts

@@ -1,3 +0,0 @@
-export * from './pgQuerier.js';
-export * from './pgQuerierPool.js';
-export * from './postgresDialect.js';

package/src/postgres/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/postgres/pgQuerier.test.ts

@@ -1,25 +0,0 @@
-import { types } from 'pg';
-import { AbstractSqlQuerierIt } from '../querier/abstractSqlQuerier-test.js';
-import { createSpec } from '../test/index.js';
-import { PgQuerierPool } from './pgQuerierPool.js';
-
-types.setTypeParser(types.builtins.INT8, (value: string) => Number.parseInt(value, 10));
-types.setTypeParser(types.builtins.FLOAT8, (value: string) => Number.parseFloat(value));
-types.setTypeParser(types.builtins.NUMERIC, (value: string) => Number.parseFloat(value));
-
-export class PostgresQuerierIt extends AbstractSqlQuerierIt {
-  constructor() {
-    super(
-      new PgQuerierPool({
-        host: '0.0.0.0',
-        port: 5442,
-        user: 'test',
-        password: 'test',
-        database: 'test',
-      }),
-      'SERIAL PRIMARY KEY',
-    );
-  }
-}
-
-createSpec(new PostgresQuerierIt());

package/src/postgres/pgQuerier.ts

@@ -1,45 +0,0 @@
-import type { PoolClient } from 'pg';
-import { AbstractSqlQuerier } from '../querier/index.js';
-import type { ExtraOptions, QueryUpdateResult } from '../type/index.js';
-import { PostgresDialect } from './postgresDialect.js';
-
-export class PgQuerier extends AbstractSqlQuerier {
-  conn: PoolClient;
-
-  constructor(
-    readonly connect: () => Promise<PoolClient>,
-    readonly extra?: ExtraOptions,
-  ) {
-    super(new PostgresDialect(extra?.namingStrategy));
-  }
-
-  override async internalAll<T>(query: string, values?: unknown[]) {
-    this.extra?.logger?.(query, values);
-    await this.lazyConnect();
-    const res = await this.conn.query<T>(query, values);
-    return res.rows;
-  }
-
-  override async internalRun(query: string, values?: unknown[]) {
-    this.extra?.logger?.(query, values);
-    await this.lazyConnect();
-    const { rowCount: changes, rows = [] }: any = await this.conn.query(query, values);
-    const ids = rows.map((r: any) => r.id);
-    return { changes, ids, firstId: ids[0] } satisfies QueryUpdateResult;
-  }
-
-  async lazyConnect() {
-    this.conn ??= await this.connect();
-  }
-
-  override async internalRelease() {
-    if (this.hasOpenTransaction) {
-      throw TypeError('pending transaction');
-    }
-    if (!this.conn) {
-      return;
-    }
-    await this.conn.release();
-    this.conn = undefined;
-  }
-}