@uql/core 3.1.1 → 3.1.3

package/src/migrate/type.ts

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

package/src/mongo/index.ts

@@ -1,3 +0,0 @@
-export * from './mongoDialect.js';
-export * from './mongodbQuerier.js';
-export * from './mongodbQuerierPool.js';

package/src/mongo/mongoDialect.spec.ts

@@ -1,251 +0,0 @@
-import { expect } from 'bun:test';
-import { ObjectId } from 'mongodb';
-import { getMeta } from '../entity/index.js';
-import { createSpec, Item, type Spec, Tax, TaxCategory, User } from '../test/index.js';
-import { MongoDialect } from './mongoDialect.js';
-
-class MongoDialectSpec implements Spec {
-  dialect: MongoDialect;
-
-  beforeEach() {
-    this.dialect = new MongoDialect();
-  }
-
-  shouldBuildWhere() {
-    expect(this.dialect.where(Item, undefined)).toEqual({});
-
-    expect(this.dialect.where(Item, {})).toEqual({});
-
-    expect(this.dialect.where(Item, { code: '123' })).toEqual({ code: '123' });
-
-    expect(this.dialect.where(Item, { $and: [{ code: '123', name: 'abc' }] })).toEqual({
-      $and: [{ code: '123', name: 'abc' }],
-    });
-
-    expect(
-      this.dialect.where(TaxCategory, {
-        creatorId: 1,
-        $or: [{ name: { $in: ['a', 'b', 'c'] } }, { name: 'abc' }],
-        pk: '507f191e810c19729de860ea',
-      }),
-    ).toEqual({
-      creatorId: 1,
-      $or: [{ name: { $in: ['a', 'b', 'c'] } }, { name: 'abc' }],
-      _id: new ObjectId('507f191e810c19729de860ea'),
-    });
-
-    expect(this.dialect.where(Item, '507f191e810c19729de860ea' as any)).toEqual({
-      _id: new ObjectId('507f191e810c19729de860ea'),
-    });
-
-    expect(this.dialect.where(Item, { id: '507f191e810c19729de860ea' as any })).toEqual({
-      _id: new ObjectId('507f191e810c19729de860ea'),
-    });
-
-    expect(this.dialect.where(Item, { id: new ObjectId('507f191e810c19729de860ea') as any })).toEqual({
-      _id: new ObjectId('507f191e810c19729de860ea'),
-    });
-
-    expect(this.dialect.where(TaxCategory, '507f191e810c19729de860ea')).toEqual({
-      _id: new ObjectId('507f191e810c19729de860ea'),
-    });
-
-    expect(this.dialect.where(TaxCategory, { pk: '507f191e810c19729de860ea' })).toEqual({
-      _id: new ObjectId('507f191e810c19729de860ea'),
-    });
-
-    expect(this.dialect.where(TaxCategory, { pk: new ObjectId('507f191e810c19729de860ea') as any })).toEqual({
-      _id: new ObjectId('507f191e810c19729de860ea'),
-    });
-  }
-
-  shouldSelect() {
-    expect(this.dialect.select(Tax, { name: true })).toEqual({ name: true });
-    expect(this.dialect.select(Tax, ['id', 'name'])).toEqual({ id: true, name: true });
-  }
-
-  shouldBuildSort() {
-    expect(this.dialect.sort(Item, {})).toEqual({});
-    expect(this.dialect.sort(Item, { code: 1 })).toEqual({ code: 1 });
-    expect(this.dialect.sort(Item, { code: -1 })).toEqual({ code: -1 });
-    expect(this.dialect.sort(Item, { code: 1 })).toEqual({ code: 1 });
-    expect(this.dialect.sort(Item, [{ field: 'code', sort: -1 }])).toEqual({ code: -1 });
-    expect(
-      this.dialect.sort(Item, [
-        ['name', 1],
-        ['createdAt', -1],
-      ]),
-    ).toEqual({ name: 1, createdAt: -1 });
-    expect(
-      this.dialect.sort(Item, [
-        ['name', -1],
-        ['createdAt', -1],
-      ]),
-    ).toEqual({ name: -1, createdAt: -1 });
-  }
-
-  shouldNormalizeIds() {
-    const meta = getMeta(User);
-    expect(
-      this.dialect.normalizeIds(meta, [
-        { _id: 'abc' } as Partial<User> as User,
-        { _id: 'def' } as Partial<User> as User,
-      ]),
-    ).toMatchObject([{ id: 'abc' }, { id: 'def' }]);
-    expect(this.dialect.normalizeIds(meta, undefined)).toBe(undefined);
-    expect(this.dialect.normalizeId(meta, undefined)).toBe(undefined);
-    expect(
-      this.dialect.normalizeId(meta, { _id: 'abc', company: {}, users: [] } as Partial<User> as User),
-    ).toMatchObject({
-      id: 'abc',
-      company: {},
-      users: [],
-    });
-  }
-
-  shouldBuildAggregationPipeline() {
-    expect(this.dialect.aggregationPipeline(Item, {})).toEqual([]);
-
-    expect(this.dialect.aggregationPipeline(Item, { $where: {} })).toEqual([]);
-
-    expect(this.dialect.aggregationPipeline(Item, {})).toEqual([]);
-
-    expect(this.dialect.aggregationPipeline(Item, { $sort: { code: 1 } })).toEqual([{ $sort: { code: 1 } }]);
-
-    expect(this.dialect.aggregationPipeline(User, { $select: { users: true } })).toEqual([]);
-
-    expect(
-      this.dialect.aggregationPipeline(TaxCategory, {
-        $select: { creator: true },
-        $where: { pk: '507f1f77bcf86cd799439011' },
-        $sort: { creatorId: -1 },
-      }),
-    ).toEqual([
-      {
-        $match: {
-          _id: new ObjectId('507f1f77bcf86cd799439011'),
-        },
-        $sort: {
-          creatorId: -1,
-        },
-      },
-      {
-        $lookup: {
-          from: 'User',
-          localField: 'creatorId',
-          foreignField: '_id',
-          as: 'creator',
-        },
-      },
-      {
-        $unwind: {
-          path: '$creator',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-    ]);
-
-    expect(
-      this.dialect.aggregationPipeline(Item, {
-        $select: { measureUnit: true, tax: true },
-        $where: { code: '123' },
-      }),
-    ).toEqual([
-      {
-        $match: {
-          code: '123',
-        },
-      },
-      {
-        $lookup: {
-          as: 'measureUnit',
-          foreignField: '_id',
-          from: 'MeasureUnit',
-          localField: 'measureUnitId',
-        },
-      },
-      {
-        $unwind: { path: '$measureUnit', preserveNullAndEmptyArrays: true },
-      },
-      {
-        $lookup: {
-          as: 'tax',
-          foreignField: '_id',
-          from: 'Tax',
-          localField: 'taxId',
-        },
-      },
-      {
-        $unwind: { path: '$tax', preserveNullAndEmptyArrays: true },
-      },
-    ]);
-
-    expect(
-      this.dialect.aggregationPipeline(User, {
-        $select: { profile: true },
-        $where: '65496146f8f7899f63768df1' as any,
-        $limit: 1,
-      }),
-    ).toEqual([
-      {
-        $match: {
-          _id: new ObjectId('65496146f8f7899f63768df1'),
-        },
-      },
-      {
-        $lookup: {
-          from: 'user_profile',
-          pipeline: [
-            {
-              $match: {
-                creatorId: new ObjectId('65496146f8f7899f63768df1'),
-              },
-            },
-          ],
-          as: 'profile',
-        },
-      },
-      {
-        $unwind: {
-          path: '$profile',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-    ]);
-
-    expect(
-      this.dialect.aggregationPipeline(User, {
-        $select: { profile: true },
-        $where: { id: '65496146f8f7899f63768df1' as any },
-        $limit: 1,
-      }),
-    ).toEqual([
-      {
-        $match: {
-          _id: new ObjectId('65496146f8f7899f63768df1'),
-        },
-      },
-      {
-        $lookup: {
-          from: 'user_profile',
-          pipeline: [
-            {
-              $match: {
-                creatorId: new ObjectId('65496146f8f7899f63768df1'),
-              },
-            },
-          ],
-          as: 'profile',
-        },
-      },
-      {
-        $unwind: {
-          path: '$profile',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-    ]);
-  }
-}
-
-createSpec(new MongoDialectSpec());

package/src/mongo/mongoDialect.ts

@@ -1,238 +0,0 @@
-import { type Document, type Filter, ObjectId, type Sort } from 'mongodb';
-import { AbstractDialect } from '../dialect/index.js';
-import { getMeta } from '../entity/index.js';
-import type {
-  EntityMeta,
-  FieldValue,
-  Query,
-  QueryOptions,
-  QuerySelect,
-  QuerySelectMap,
-  QuerySort,
-  QueryWhere,
-  RelationKey,
-  Type,
-} from '../type/index.js';
-import {
-  buildSortMap,
-  buldQueryWhereAsMap,
-  type CallbackKey,
-  fillOnFields,
-  filterFieldKeys,
-  filterRelationKeys,
-  getKeys,
-  hasKeys,
-} from '../util/index.js';
-
-export class MongoDialect extends AbstractDialect {
-  where<E extends Document>(entity: Type<E>, where: QueryWhere<E> = {}, { softDelete }: QueryOptions = {}): Filter<E> {
-    const meta = getMeta(entity);
-
-    where = buldQueryWhereAsMap(meta, where);
-
-    if (meta.softDelete && (softDelete || softDelete === undefined) && !where[meta.softDelete]) {
-      const field = meta.fields[meta.softDelete];
-      where[this.resolveColumnName(meta.softDelete, field)] = null;
-    }
-
-    return getKeys(where).reduce(
-      (acc, key) => {
-        let value = where[key];
-        if (key === '$and' || key === '$or') {
-          acc[key] = value.map((filterIt: QueryWhere<E>) => this.where(entity, filterIt));
-        } else {
-          const field = meta.fields[key];
-          if (key === '_id' || key === meta.id) {
-            key = '_id';
-            value = this.getIdValue(value);
-          } else if (field) {
-            key = this.resolveColumnName(key, field);
-          }
-          if (Array.isArray(value)) {
-            value = {
-              $in: value,
-            };
-          }
-          acc[key as keyof Filter<E>] = value;
-        }
-        return acc;
-      },
-      {} as Filter<E>,
-    );
-  }
-
-  select<E extends Document>(entity: Type<E>, select: QuerySelect<E>): QuerySelectMap<E> {
-    if (Array.isArray(select)) {
-      return select.reduce(
-        (acc, it) => {
-          acc[it as string] = true;
-          return acc;
-        },
-        {} satisfies QuerySelectMap<E>,
-      );
-    }
-    return select as QuerySelectMap<E>;
-  }
-
-  sort<E extends Document>(entity: Type<E>, sort: QuerySort<E>): Sort {
-    return buildSortMap(sort) as Sort;
-  }
-
-  aggregationPipeline<E extends Document>(entity: Type<E>, q: Query<E>): MongoAggregationPipelineEntry<E>[] {
-    const meta = getMeta(entity);
-
-    const where = this.where(entity, q.$where);
-    const sort = this.sort(entity, q.$sort);
-    const firstPipelineEntry: MongoAggregationPipelineEntry<E> = {};
-
-    if (hasKeys(where)) {
-      firstPipelineEntry.$match = where;
-    }
-    if (hasKeys(sort)) {
-      firstPipelineEntry.$sort = sort;
-    }
-
-    const pipeline: MongoAggregationPipelineEntry<E>[] = [];
-
-    if (hasKeys(firstPipelineEntry)) {
-      pipeline.push(firstPipelineEntry);
-    }
-
-    const relKeys = filterRelationKeys(meta, q.$select);
-
-    for (const relKey of relKeys) {
-      const relOpts = meta.relations[relKey];
-
-      if (relOpts.cardinality === '1m' || relOpts.cardinality === 'mm') {
-        // '1m' and 'mm' should be resolved in a higher layer because they will need multiple queries
-        continue;
-      }
-
-      const relEntity = relOpts.entity();
-      const relMeta = getMeta(relEntity);
-
-      if (relOpts.cardinality === 'm1') {
-        const localField = meta.fields[relOpts.references[0].local];
-        pipeline.push({
-          $lookup: {
-            from: this.resolveTableName(relEntity, relMeta),
-            localField: this.resolveColumnName(relOpts.references[0].local, localField),
-            foreignField: '_id',
-            as: relKey,
-          },
-        });
-      } else {
-        const foreignField = relMeta.fields[relOpts.references[0].foreign];
-        const foreignFieldName = this.resolveColumnName(relOpts.references[0].foreign, foreignField);
-        const referenceWhere = this.where(relEntity, where);
-        const referenceSort = this.sort(relEntity, q.$sort);
-        const referencePipelineEntry: MongoAggregationPipelineEntry<FieldValue<E>> = {
-          $match: { [foreignFieldName]: referenceWhere._id },
-        };
-        if (hasKeys(referenceSort)) {
-          referencePipelineEntry.$sort = referenceSort;
-        }
-        pipeline.push({
-          $lookup: {
-            from: this.resolveTableName(relEntity, relMeta),
-            pipeline: [referencePipelineEntry],
-            as: relKey,
-          },
-        });
-      }
-
-      pipeline.push({ $unwind: { path: `$${relKey}`, preserveNullAndEmptyArrays: true } });
-    }
-
-    return pipeline;
-  }
-
-  normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: E[]): E[] {
-    return docs?.map((doc) => this.normalizeId(meta, doc));
-  }
-
-  normalizeId<E extends Document>(meta: EntityMeta<E>, doc: E): E {
-    if (!doc) {
-      return;
-    }
-
-    const res = doc as any;
-
-    if (res._id) {
-      res[meta.id] = res._id;
-      if (meta.id !== '_id') {
-        delete res._id;
-      }
-    }
-
-    for (const key of getKeys(meta.fields)) {
-      const field = meta.fields[key];
-      const dbName = this.resolveColumnName(key, field);
-      if (dbName !== key && res[dbName] !== undefined) {
-        res[key] = res[dbName];
-        delete res[dbName];
-      }
-    }
-
-    const relKeys = getKeys(meta.relations).filter((key) => res[key]) as RelationKey<E>[];
-
-    for (const relKey of relKeys) {
-      const relOpts = meta.relations[relKey];
-      const relMeta = getMeta(relOpts.entity());
-      res[relKey] = Array.isArray(res[relKey])
-        ? this.normalizeIds(relMeta, res[relKey])
-        : this.normalizeId(relMeta, res[relKey]);
-    }
-
-    return res;
-  }
-
-  getIdValue<T extends IdValue>(value: T): T {
-    if (value instanceof ObjectId) {
-      return value;
-    }
-    try {
-      return new ObjectId(value) as T;
-    } catch (e) {
-      return value;
-    }
-  }
-
-  getPersistable<E>(meta: EntityMeta<E>, payload: E, callbackKey: CallbackKey): E {
-    return this.getPersistables(meta, payload, callbackKey)[0];
-  }
-
-  getPersistables<E>(meta: EntityMeta<E>, payload: E | E[], callbackKey: CallbackKey): E[] {
-    const payloads = fillOnFields(meta, payload, callbackKey);
-    const persistableKeys = filterFieldKeys(meta, payloads[0], callbackKey);
-    return payloads.map((it) =>
-      persistableKeys.reduce((acc, key) => {
-        const field = meta.fields[key];
-        acc[this.resolveColumnName(key, field)] = it[key];
-        return acc;
-      }, {} as E),
-    );
-  }
-}
-
-type MongoAggregationPipelineEntry<E extends Document> = {
-  readonly $lookup?: MongoAggregationLookup<E>;
-  $match?: Filter<E> | Record<string, any>;
-  $sort?: Sort;
-  readonly $unwind?: MongoAggregationUnwind;
-};
-
-type MongoAggregationLookup<E extends Document> = {
-  readonly from?: string;
-  readonly foreignField?: string;
-  readonly localField?: string;
-  readonly pipeline?: MongoAggregationPipelineEntry<FieldValue<E>>[];
-  readonly as?: RelationKey<E>;
-};
-
-type MongoAggregationUnwind = {
-  readonly path?: string;
-  readonly preserveNullAndEmptyArrays?: boolean;
-};
-
-type IdValue = string | ObjectId;

package/src/mongo/mongodbQuerier.test.ts

@@ -1,45 +0,0 @@
-import { MongoMemoryReplSet } from 'mongodb-memory-server';
-import { getEntities, getMeta } from '../entity/index.js';
-import { AbstractQuerierIt } from '../querier/abstractQuerier-test.js';
-import { createSpec } from '../test/index.js';
-import type { MongodbQuerier } from './mongodbQuerier.js';
-import { MongodbQuerierPool } from './mongodbQuerierPool.js';
-
-class MongodbQuerierIt extends AbstractQuerierIt<MongodbQuerier> {
-  static replSet: MongoMemoryReplSet;
-
-  constructor() {
-    super(new MongodbQuerierPool('mongodb://127.0.0.1:27017/test'));
-  }
-
-  override async beforeAll() {
-    MongodbQuerierIt.replSet = await MongoMemoryReplSet.create({
-      replSet: { count: 1, storageEngine: 'wiredTiger' },
-    });
-    const uri = MongodbQuerierIt.replSet.getUri();
-    this.pool = new MongodbQuerierPool(uri);
-    await super.beforeAll();
-  }
-
-  override async afterAll() {
-    await super.afterAll();
-    await this.pool.end();
-    await MongodbQuerierIt.replSet.stop();
-  }
-
-  override async createTables() {
-    const entities = getEntities();
-    await Promise.all(
-      entities.map((entity) => {
-        const meta = getMeta(entity);
-        return this.querier.conn.db().createCollection(meta.name);
-      }),
-    );
-  }
-
-  override async dropTables() {
-    await this.querier.conn.db().dropDatabase();
-  }
-}
-
-createSpec(new MongodbQuerierIt());