soda-angular/fluent-query/fluent-query.js

Socrata SODA client for Angular

import { Column, OrderColumn, WhereOperator, Operator } from "../soql-query/clauses";
import { SoqlQueryBuilder } from '../soql-query/soql-query-builder';
import { BasicWhereFilter } from './filters/basic-where-filter';
import { GeometryFilter } from './filters/geometry-filter';
import { LocationFilter } from './filters/location-filter';
export class FluentQuery {
    constructor(sodaResource, queryBuilder) {
        this.sodaResource = sodaResource;
        this.queryBuilder = queryBuilder;
        if (!sodaResource) {
            throw new Error("resource must be provided");
        }
        if (!queryBuilder) {
            this.queryBuilder = new SoqlQueryBuilder();
        }
    }
    //region IQueryable
    select(column) {
        const newBuilder = this.cloneBuilder().select(Column.of(column));
        return this.updateQuery(newBuilder);
    }
    where(column) {
        return new BasicWhereFilter(this, Column.of(column));
    }
    // TODO: If TypeScript ever allows type guards on generics, create an overload where() instead
    location(column) {
        return new LocationFilter(this, Column.of(column));
    }
    // TODO: If TypeScript ever allows type guards on generics, create an overload where() instead
    geometry(column) {
        return new GeometryFilter(this, Column.of(column));
    }
    limit(records) {
        const newBuilder = this.cloneBuilder().limit(records);
        return this.updateQuery(newBuilder);
    }
    offset(records) {
        const newBuilder = this.cloneBuilder().offset(records);
        return this.updateQuery(newBuilder);
    }
    orderBy(column, descending) {
        const newBuilder = this.cloneBuilder().orderBy(new OrderColumn(Column.of(column).Name, descending));
        return this.updateQuery(newBuilder);
    }
    observable() {
        return this.sodaResource.Context.Client.getResource(this.sodaResource, this);
    }
    toString() {
        return this.queryBuilder.getQuery().toString();
    }
    //endregion
    //region IFilteredQueryable
    and(column) {
        return new BasicWhereFilter(this, Column.of(column), new WhereOperator(Operator.And));
    }
    or(column) {
        return new BasicWhereFilter(this, Column.of(column), new WhereOperator(Operator.Or));
    }
    //endregion
    //region IInternalQuery
    addFilter(...filters) {
        const newBuilder = this.cloneBuilder().filter(...filters);
        return new FluentQuery(this.sodaResource, newBuilder);
    }
    //endregion
    updateQuery(newBuilder) {
        return new FluentQuery(this.sodaResource, newBuilder);
    }
    cloneBuilder() {
        return this.queryBuilder.clone();
    }
}