@mikro-orm/core 7.0.4 → 7.0.5-dev.0

package/utils/Cursor.d.ts

@@ -48,44 +48,26 @@ 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,144 +53,136 @@ 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]);
-  }
-  get endCursor() {
-    if (this.items.length === 0) {
-      return null;
-    }
-    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);
+    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();
+            }
         }
-        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;
+        this.#definition = Cursor.getDefinition(meta, orderBy);
     }
-  }
-  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);
+    get startCursor() {
+        if (this.items.length === 0) {
+            return null;
         }
-        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;
+        return this.from(this.items[0]);
+    }
+    get endCursor() {
+        if (this.items.length === 0) {
+            return null;
         }
-        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;
+        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;
         }
-        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,63 +4,48 @@ 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 {};