@uql/core 1.0.12 → 3.0.0

package/src/migrate/type.ts

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

package/src/mongo/index.ts

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

package/src/mongo/mongoDialect.spec.ts

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

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

@@ -0,0 +1,45 @@
+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());