Filtering resources by location

[mrnkr]

Context

My system uses postgres and typeorm.

I started with an entity with a location field defined as such:

@Column('geometry')
@Index({ spatial: true })
location!: Point;

Note that Point is the interface exposed by typeorm that represents a GeoJSON Point feature.

To consume this field, I created a simple class PointDto with the same shape as that interface:

@ObjectType('Point')
@InputType('PointInput')
export class PointDto implements Point {
  @Field({ description: 'Point' })
  @IsString()
  @IsIn(['Point'])
  type: 'Point';

  @Field(() => [Number], { description: '[lon, lat]' })
  @IsArray()
  @IsNumber({}, { each: true })
  @ArrayMinSize(2)
  @ArrayMaxSize(2)
  coordinates: number[];
}

This was enough for me to consume the point as a GeoJSON feature and store it as a postgis geometry field.

What I needed

I wanted to be able to filter my resources in a way that would let me get those that were within a given GeoJSON polygon feature or close to a point. Let's focus only on the polygon for now.

Here's an example query:

SELECT *
FROM resources
WHERE ST_Within(location, ST_GeomFromGeoJSON('<your_geojson_polygon>'));

How I achieved it

This took a lot of trial and error. Since I came up with a working solution I want everyone to be able to use it and, hopefully, improve upon it! If you do make it better, please share :D

First, I disabled read operations in my generated resolver.

@Module({
  imports: [
    TypeOrmModule.forFeature([MyEntity]),
    NestjsQueryGraphQLModule.forFeature({
      imports: [NestjsQueryTypeOrmModule.forFeature([MyEntity])],
      resolvers: [
        {
          read: { disabled: true },
        },
      ],
    }),
  ],
})
export class MyModule {}

Then, I made a custom resolver extending ReadResolver. My goal here was to change the generated graphql schema so that it would expose my custom filter which I specified as a DTO.

const ConnectionType = ResourceQueryDto.ConnectionType;

@Resolver(() => ResourceDto)
export class ResourceReadResolver extends ReadResolver(ResourceDto, {
  pagingStrategy: PagingStrategies.OFFSET,
  enableTotalCount: true,
}) {
  constructor(readonly service: ResourceQueryService) {
    super(service);
  }

  @ResolverQuery(
    () => ConnectionType.resolveType,
    {
      name: 'resources',
    },
    {},
    {
      interceptors: [
        HookInterceptor(HookTypes.BEFORE_QUERY_MANY, ResourceDto),
        AuthorizerInterceptor(ResourceDto),
      ],
    },
  )
  async queryMany(
    @HookArgs() query: ResourceQueryDto,
    @AuthorizerFilter({
      operationGroup: OperationGroup.READ,
      many: true,
    })
    authorizeFilter?: Filter<ResourceDto>,
    @GraphQLResultInfo(ResourceDto)
    resolveInfo?: GraphQLResolveInfoResult<ResourceDto>,
  ): Promise<InstanceType<typeof ConnectionType>> {
    return super.queryMany(query, authorizeFilter, resolveInfo);
  }
}

This resolver is an exact copy of what ReadResolver generates. Since I wasn't able to change the filter type any other way I redeclared the queryMany method with all its decorators and used my custom ResourceQueryDto so that my new operators would be recognized by graphql.

Let's take a look at my ResourceQueryDto:

@ArgsType()
export class ResourceQueryDto extends QueryArgsType(ResourceDto, {
  pagingStrategy: PagingStrategies.OFFSET,
  enableTotalCount: true,
}) {
  @Field(() => ResourceFilterDto, { nullable: true })
  @ValidateNested()
  @Type(() => ResourceFilterDto)
  filter?: Filter<ResourceDto>;
}

@InputType('CustomResourceFilter')
export class ResourceFilterDto extends OmitType(FilterType(ResourceDto), ['location']) {
  @Field(() => LocationComparisonDto)
  @ValidateNested()
  @Type(() => LocationComparisonDto)
  location?: LocationComparisonDto;
}

@InputType('LocationComparison')
export class LocationComparisonDto {
  @Field(() => PolygonDto, { nullable: true })
  @ValidateNested()
  @Type(() => PolygonDto)
  within?: PolygonDto;

  @Field(() => PointDto, { nullable: true })
  @ValidateNested()
  @Type(() => PointDto)
  near?: PointDto;
}

@InputType('PolygonInput')
export class PolygonDto implements Polygon {
  @Field({ description: 'Polygon' })
  @IsString()
  @IsIn(['Polygon'])
  type: 'Polygon';

  @Field(() => [[[Number]]])
  @IsArray({ each: true })
  coordinates: number[][][];
}

At this point, I registered my resolver in my module and was able to send the location operators, within and near, in my filters.

@Module({
  imports: [
    TypeOrmModule.forFeature([MyEntity]),
    NestjsQueryGraphQLModule.forFeature({
      imports: [NestjsQueryTypeOrmModule.forFeature([MyEntity])],
      resolvers: [
        {
          read: { disabled: true },
        },
      ],
    }),
  ],
  providers: [ResourceReadResolver],
})
export class MyModule {}

All I was missing at this point was actually translating the filters provided to the API into sql where clauses. The library does this in the FilterQueryBuilder class, which is a public property of the TypeOrmQueryService class.

My first attempt was to extend that class and add the logic to process this new condition BUT since it's internal I wanted to avoid that. What I ended up going with was a Proxy.

I implemented my own ResourceQueryService extending the provided TypeOrmQueryService and, then, replaced the instance that is generated by the library with a proxy around it, like so:

@QueryService(MyEntity)
export class ResourceQueryService extends TypeOrmQueryService<MyEntity> {
  constructor(@InjectRepository(MyEntity) readonly repo: Repository<MyEntity>) {
    super(repo);

    Object.assign(this, {
      filterQueryBuilder: new Proxy(this.filterQueryBuilder, {
        get(target, prop, receiver) {
          if (String(prop) !== 'select') {
            return Reflect.get(target, prop, receiver);
          }

          const originalFn: (query: Query<MyEntity>) => SelectQueryBuilder<MyEntity> =
            Reflect.get(target, prop, receiver);

          return function ({
            filter: { location, ...filter } = {},
            paging,
            sorting,
            relations,
          }: Query<MyEntity>) {
            const qb: SelectQueryBuilder<MyEntity> = originalFn.apply(this, [
              { filter, paging, sorting, relations },
            ]);

            if (location) {
              const locationFilter = location as LocationComparisonDto;

              if (locationFilter.within) {
                qb.andWhere(
                  `ST_Within(${qb.alias}.location, ST_GeomFromGeoJSON(:polygon))`,
                  {
                    polygon: locationFilter.within,
                  },
                );
              }

              if (locationFilter.near) {
                qb.andWhere(
                  `ST_DWithin(${qb.alias}.location, ST_GeomFromGeoJSON(:point), 1500, true)`,
                  {
                    point: locationFilter.near,
                  },
                );
              }
            }

            return qb;
          };
        },
      }),
    });
  }
}

Lastly, I registered the new service in my module and injected it in my custom resolver. After that, my filters became functional.

@Module({
  imports: [
    TypeOrmModule.forFeature([MyEntity]),
    NestjsQueryGraphQLModule.forFeature({
      imports: [NestjsQueryTypeOrmModule.forFeature([MyEntity])],
      resolvers: [
        {
          ServiceClass: ResourceQueryService,
          read: { disabled: true },
        },
      ],
    }),
  ],
  providers: [ResourceReadResolver],
})
export class MyModule {}

I think I may have over-engineered this, I'm pretty sure I have, but this was the best I could come up with. If anybody has any ideas as to how I could simplify this, please do share!