@mikro-orm/core 7.0.4-dev.9 → 7.0.4

package/utils/Cursor.d.ts

@@ -48,26 +48,44 @@ import { type QueryOrder } from '../enums.js';
  * }
  * ```
  */
-export declare class Cursor<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never, IncludeCount extends boolean = true> {
-    #private;
-    readonly items: Loaded<Entity, Hint, Fields, Excludes>[];
-    readonly totalCount: IncludeCount extends true ? number : undefined;
-    readonly hasPrevPage: boolean;
-    readonly hasNextPage: boolean;
-    constructor(items: Loaded<Entity, Hint, Fields, Excludes>[], totalCount: IncludeCount extends true ? number : undefined, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>, meta: EntityMetadata<Entity>);
-    get startCursor(): string | null;
-    get endCursor(): string | null;
-    /**
-     * Computes the cursor value for a given entity.
-     */
-    from(entity: Entity | Loaded<Entity, Hint, Fields, Excludes>): string;
-    [Symbol.iterator](): IterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
-    get length(): number;
-    /**
-     * Computes the cursor value for given entity and order definition.
-     */
-    static for<Entity extends object>(meta: EntityMetadata<Entity>, entity: FilterObject<Entity>, orderBy: OrderDefinition<Entity>): string;
-    static encode(value: unknown[]): string;
-    static decode(value: string): unknown[];
-    static getDefinition<Entity extends object>(meta: EntityMetadata<Entity>, orderBy: OrderDefinition<Entity>): [EntityKey, QueryOrder][];
+export declare class Cursor<
+  Entity extends object,
+  Hint extends string = never,
+  Fields extends string = never,
+  Excludes extends string = never,
+  IncludeCount extends boolean = true,
+> {
+  #private;
+  readonly items: Loaded<Entity, Hint, Fields, Excludes>[];
+  readonly totalCount: IncludeCount extends true ? number : undefined;
+  readonly hasPrevPage: boolean;
+  readonly hasNextPage: boolean;
+  constructor(
+    items: Loaded<Entity, Hint, Fields, Excludes>[],
+    totalCount: IncludeCount extends true ? number : undefined,
+    options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>,
+    meta: EntityMetadata<Entity>,
+  );
+  get startCursor(): string | null;
+  get endCursor(): string | null;
+  /**
+   * Computes the cursor value for a given entity.
+   */
+  from(entity: Entity | Loaded<Entity, Hint, Fields, Excludes>): string;
+  [Symbol.iterator](): IterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
+  get length(): number;
+  /**
+   * Computes the cursor value for given entity and order definition.
+   */
+  static for<Entity extends object>(
+    meta: EntityMetadata<Entity>,
+    entity: FilterObject<Entity>,
+    orderBy: OrderDefinition<Entity>,
+  ): string;
+  static encode(value: unknown[]): string;
+  static decode(value: string): unknown[];
+  static getDefinition<Entity extends object>(
+    meta: EntityMetadata<Entity>,
+    orderBy: OrderDefinition<Entity>,
+  ): [EntityKey, QueryOrder][];
 }

package/utils/Cursor.js

@@ -53,136 +53,144 @@ import { inspect } from '../logging/inspect.js';
  * ```
  */
 export class Cursor {
-    items;
-    totalCount;
-    hasPrevPage;
-    hasNextPage;
-    #definition;
-    constructor(items, totalCount, options, meta) {
-        this.items = items;
-        this.totalCount = totalCount;
-        const { first, last, before, after, orderBy, overfetch } = options;
-        const limit = first ?? last;
-        const isLast = !first && !!last;
-        const hasMorePages = !!overfetch && limit != null && items.length > limit;
-        this.hasPrevPage = isLast ? hasMorePages : !!after;
-        this.hasNextPage = isLast ? !!before : hasMorePages;
-        if (hasMorePages) {
-            if (isLast) {
-                items.shift();
-            }
-            else {
-                items.pop();
-            }
-        }
-        this.#definition = Cursor.getDefinition(meta, orderBy);
-    }
-    get startCursor() {
-        if (this.items.length === 0) {
-            return null;
-        }
-        return this.from(this.items[0]);
+  items;
+  totalCount;
+  hasPrevPage;
+  hasNextPage;
+  #definition;
+  constructor(items, totalCount, options, meta) {
+    this.items = items;
+    this.totalCount = totalCount;
+    const { first, last, before, after, orderBy, overfetch } = options;
+    const limit = first ?? last;
+    const isLast = !first && !!last;
+    const hasMorePages = !!overfetch && limit != null && items.length > limit;
+    this.hasPrevPage = isLast ? hasMorePages : !!after;
+    this.hasNextPage = isLast ? !!before : hasMorePages;
+    if (hasMorePages) {
+      if (isLast) {
+        items.shift();
+      } else {
+        items.pop();
+      }
     }
-    get endCursor() {
-        if (this.items.length === 0) {
-            return null;
-        }
-        return this.from(this.items[this.items.length - 1]);
+    this.#definition = Cursor.getDefinition(meta, orderBy);
+  }
+  get startCursor() {
+    if (this.items.length === 0) {
+      return null;
     }
-    /**
-     * Computes the cursor value for a given entity.
-     */
-    from(entity) {
-        const processEntity = (entity, prop, direction, object = false) => {
-            if (Utils.isPlainObject(direction)) {
-                const unwrapped = Reference.unwrapReference(entity[prop]);
-                // Check if the relation is loaded - for nested properties, undefined means not populated
-                if (Utils.isEntity(unwrapped) && !helper(unwrapped).isInitialized()) {
-                    throw CursorError.entityNotPopulated(entity, prop);
-                }
-                return Utils.keys(direction).reduce((o, key) => {
-                    Object.assign(o, processEntity(unwrapped, key, direction[key], true));
-                    return o;
-                }, {});
-            }
-            let value = entity[prop];
-            // Allow null/undefined values in cursor - they will be handled in createCursorCondition
-            // undefined can occur with forceUndefined config option which converts null to undefined
-            if (value == null) {
-                return object ? { [prop]: null } : null;
-            }
-            if (Utils.isEntity(value, true)) {
-                value = helper(value).getPrimaryKey();
-            }
-            if (Utils.isScalarReference(value)) {
-                value = value.unwrap();
-            }
-            if (object) {
-                return { [prop]: value };
-            }
-            return value;
-        };
-        const value = this.#definition.map(([key, direction]) => processEntity(entity, key, direction));
-        return Cursor.encode(value);
+    return this.from(this.items[0]);
+  }
+  get endCursor() {
+    if (this.items.length === 0) {
+      return null;
     }
-    *[Symbol.iterator]() {
-        for (const item of this.items) {
-            yield item;
+    return this.from(this.items[this.items.length - 1]);
+  }
+  /**
+   * Computes the cursor value for a given entity.
+   */
+  from(entity) {
+    const processEntity = (entity, prop, direction, object = false) => {
+      if (Utils.isPlainObject(direction)) {
+        const unwrapped = Reference.unwrapReference(entity[prop]);
+        // Check if the relation is loaded - for nested properties, undefined means not populated
+        if (Utils.isEntity(unwrapped) && !helper(unwrapped).isInitialized()) {
+          throw CursorError.entityNotPopulated(entity, prop);
         }
+        return Utils.keys(direction).reduce((o, key) => {
+          Object.assign(o, processEntity(unwrapped, key, direction[key], true));
+          return o;
+        }, {});
+      }
+      let value = entity[prop];
+      // Allow null/undefined values in cursor - they will be handled in createCursorCondition
+      // undefined can occur with forceUndefined config option which converts null to undefined
+      if (value == null) {
+        return object ? { [prop]: null } : null;
+      }
+      if (Utils.isEntity(value, true)) {
+        value = helper(value).getPrimaryKey();
+      }
+      if (Utils.isScalarReference(value)) {
+        value = value.unwrap();
+      }
+      if (object) {
+        return { [prop]: value };
+      }
+      return value;
+    };
+    const value = this.#definition.map(([key, direction]) => processEntity(entity, key, direction));
+    return Cursor.encode(value);
+  }
+  *[Symbol.iterator]() {
+    for (const item of this.items) {
+      yield item;
     }
-    get length() {
-        return this.items.length;
-    }
-    /**
-     * Computes the cursor value for given entity and order definition.
-     */
-    static for(meta, entity, orderBy) {
-        const definition = this.getDefinition(meta, orderBy);
-        return Cursor.encode(definition.map(([key]) => {
-            const value = entity[key];
-            if (value === undefined) {
-                throw CursorError.missingValue(meta.className, key);
-            }
-            return value;
-        }));
-    }
-    static encode(value) {
-        return Buffer.from(JSON.stringify(value)).toString('base64url');
-    }
-    static decode(value) {
-        return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')).map((value) => {
-            if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}/.exec(value)) {
-                return new Date(value);
-            }
-            return value;
-        });
-    }
-    static getDefinition(meta, orderBy) {
-        return Utils.asArray(orderBy).flatMap(order => {
-            const ret = [];
-            for (const key of Utils.getObjectQueryKeys(order)) {
-                if (Raw.isKnownFragmentSymbol(key)) {
-                    ret.push([key, order[key]]);
-                    continue;
-                }
-                const prop = meta.properties[key];
-                /* v8 ignore next */
-                if (!prop ||
-                    !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) ||
-                        (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
-                    continue;
-                }
-                ret.push([prop.name, order[prop.name]]);
-            }
-            return ret;
-        });
-    }
-    /** @ignore */
-    /* v8 ignore next */
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        const type = this.items[0]?.constructor.name;
-        const { items, startCursor, endCursor, hasPrevPage, hasNextPage, totalCount, length } = this;
-        const options = inspect({ startCursor, endCursor, totalCount, hasPrevPage, hasNextPage, items, length }, { depth: 0 });
-        return `Cursor${type ? `<${type}>` : ''} ${options.replace('items: [Array]', 'items: [...]')}`;
-    }
+  }
+  get length() {
+    return this.items.length;
+  }
+  /**
+   * Computes the cursor value for given entity and order definition.
+   */
+  static for(meta, entity, orderBy) {
+    const definition = this.getDefinition(meta, orderBy);
+    return Cursor.encode(
+      definition.map(([key]) => {
+        const value = entity[key];
+        if (value === undefined) {
+          throw CursorError.missingValue(meta.className, key);
+        }
+        return value;
+      }),
+    );
+  }
+  static encode(value) {
+    return Buffer.from(JSON.stringify(value)).toString('base64url');
+  }
+  static decode(value) {
+    return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')).map(value => {
+      if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}/.exec(value)) {
+        return new Date(value);
+      }
+      return value;
+    });
+  }
+  static getDefinition(meta, orderBy) {
+    return Utils.asArray(orderBy).flatMap(order => {
+      const ret = [];
+      for (const key of Utils.getObjectQueryKeys(order)) {
+        if (Raw.isKnownFragmentSymbol(key)) {
+          ret.push([key, order[key]]);
+          continue;
+        }
+        const prop = meta.properties[key];
+        /* v8 ignore next */
+        if (
+          !prop ||
+          !(
+            [ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) ||
+            (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner)
+          )
+        ) {
+          continue;
+        }
+        ret.push([prop.name, order[prop.name]]);
+      }
+      return ret;
+    });
+  }
+  /** @ignore */
+  /* v8 ignore next */
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    const type = this.items[0]?.constructor.name;
+    const { items, startCursor, endCursor, hasPrevPage, hasNextPage, totalCount, length } = this;
+    const options = inspect(
+      { startCursor, endCursor, totalCount, hasPrevPage, hasNextPage, items, length },
+      { depth: 0 },
+    );
+    return `Cursor${type ? `<${type}>` : ''} ${options.replace('items: [Array]', 'items: [...]')}`;
+  }
 }

package/utils/DataloaderUtils.d.ts

@@ -4,48 +4,63 @@ import { type EntityManager } from '../EntityManager.js';
 import { type LoadReferenceOptions } from '../entity/Reference.js';
 type BatchLoadFn<K, V> = (keys: readonly K[]) => PromiseLike<ArrayLike<V | Error>>;
 export declare class DataloaderUtils {
-    private static DataLoader?;
-    /**
-     * Groups identified references by entity and returns a Map with the
-     * class name as the index and the corresponding primary keys as the value.
-     */
-    static groupPrimaryKeysByEntityAndOpts(refsWithOpts: readonly [Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?][]): Map<string, Set<Primary<any>>>;
-    /**
-     * Returns the reference dataloader batchLoadFn, which aggregates references by entity,
-     * makes one query per entity and maps each input reference to the corresponding result.
-     */
-    static getRefBatchLoadFn(em: EntityManager): BatchLoadFn<[Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?], any>;
-    /**
-     * Groups collections by entity and returns a Map whose keys are the entity names and whose values are filter Maps
-     * which we can use to narrow down the find query to return just the items of the collections that have been dataloaded.
-     * The entries of the filter Map will be used as the values of an $or operator so we end up with a query per entity.
-     */
-    static groupInversedOrMappedKeysByEntityAndOpts(collsWithOpts: readonly [Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?][]): Map<string, Map<string, Set<Primary<any>>>>;
-    /**
-     * Turn the entity+options map into actual queries.
-     * The keys are the entity names + a stringified version of the options and the values are filter Maps which will be used as the values of an $or operator so we end up with a query per entity+opts.
-     * We must populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s).
-     * Together with the query the promises will also return the key which can be used to narrow down the results pertaining to a certain set of options.
-     */
-    static entitiesAndOptsMapToQueries(entitiesAndOptsMap: Map<string, Map<string, Set<Primary<any>>>>, em: EntityManager): Promise<[string, any[]]>[];
-    /**
-     * Creates a filter which returns the results pertaining to a certain collection.
-     * First checks if the Entity type matches, then retrieves the inverse side of the relationship
-     * where the filtering will be done in order to match the target collection.
-     */
-    static getColFilter<T, S extends T>(collection: Collection<any>): (result: T) => result is S;
-    /**
-     * Returns the 1:M collection dataloader batchLoadFn, which aggregates collections by entity,
-     * makes one query per entity and maps each input collection to the corresponding result.
-     */
-    static getColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
-    /**
-     * Returns the M:N collection dataloader batchLoadFn, which aggregates collections by entity,
-     * makes one query per entity and maps each input collection to the corresponding result.
-     */
-    static getManyToManyColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
-    static getDataLoader(): Promise<Constructor<{
-        load: (...args: unknown[]) => Promise<unknown>;
-    }>>;
+  private static DataLoader?;
+  /**
+   * Groups identified references by entity and returns a Map with the
+   * class name as the index and the corresponding primary keys as the value.
+   */
+  static groupPrimaryKeysByEntityAndOpts(
+    refsWithOpts: readonly [Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?][],
+  ): Map<string, Set<Primary<any>>>;
+  /**
+   * Returns the reference dataloader batchLoadFn, which aggregates references by entity,
+   * makes one query per entity and maps each input reference to the corresponding result.
+   */
+  static getRefBatchLoadFn(
+    em: EntityManager,
+  ): BatchLoadFn<[Ref<any>, Omit<LoadReferenceOptions<any, any>, 'dataloader'>?], any>;
+  /**
+   * Groups collections by entity and returns a Map whose keys are the entity names and whose values are filter Maps
+   * which we can use to narrow down the find query to return just the items of the collections that have been dataloaded.
+   * The entries of the filter Map will be used as the values of an $or operator so we end up with a query per entity.
+   */
+  static groupInversedOrMappedKeysByEntityAndOpts(
+    collsWithOpts: readonly [Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?][],
+  ): Map<string, Map<string, Set<Primary<any>>>>;
+  /**
+   * Turn the entity+options map into actual queries.
+   * The keys are the entity names + a stringified version of the options and the values are filter Maps which will be used as the values of an $or operator so we end up with a query per entity+opts.
+   * We must populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s).
+   * Together with the query the promises will also return the key which can be used to narrow down the results pertaining to a certain set of options.
+   */
+  static entitiesAndOptsMapToQueries(
+    entitiesAndOptsMap: Map<string, Map<string, Set<Primary<any>>>>,
+    em: EntityManager,
+  ): Promise<[string, any[]]>[];
+  /**
+   * Creates a filter which returns the results pertaining to a certain collection.
+   * First checks if the Entity type matches, then retrieves the inverse side of the relationship
+   * where the filtering will be done in order to match the target collection.
+   */
+  static getColFilter<T, S extends T>(collection: Collection<any>): (result: T) => result is S;
+  /**
+   * Returns the 1:M collection dataloader batchLoadFn, which aggregates collections by entity,
+   * makes one query per entity and maps each input collection to the corresponding result.
+   */
+  static getColBatchLoadFn(
+    em: EntityManager,
+  ): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+  /**
+   * Returns the M:N collection dataloader batchLoadFn, which aggregates collections by entity,
+   * makes one query per entity and maps each input collection to the corresponding result.
+   */
+  static getManyToManyColBatchLoadFn(
+    em: EntityManager,
+  ): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+  static getDataLoader(): Promise<
+    Constructor<{
+      load: (...args: unknown[]) => Promise<unknown>;
+    }>
+  >;
 }
 export {};