Method processEntity

packages/core/src/utils/Cursor.ts:114–155

(
      entity: T,
      prop: EntityKey<T>,
      direction: QueryOrderKeys<T>,
      object = false,
    )

   */
  from(entity: Entity | Loaded<Entity, Hint, Fields, Excludes>): string {
    const processEntity = <T extends object>(
      entity: T,
      prop: EntityKey<T>,
      direction: QueryOrderKeys<T>,
      object = false,
    ) => {
      if (Utils.isPlainObject(direction)) {
        const unwrapped = Reference.unwrapReference(entity[prop] as T);

        // 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] as QueryOrderKeys<T>, true));
          return o;
        }, {} as Dictionary);
      }

      let value: unknown = 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 as Entity, key, direction));
    return Cursor.encode(value);
  }