@orbit/records/dist/commonjs/record-query-term.d.ts

A flexible data access and synchronization layer.

import { QueryTerm } from '@orbit/data';
import { RecordIdentity } from './record';
import { RecordQueryBuilder } from './record-query-builder';
import { AttributeSortSpecifier, FilterSpecifier, FindRecord, FindRecords, FindRelatedRecord, FindRelatedRecords, PageSpecifier, RecordQueryExpression, SetComparisonOperator, SortOrder, SortSpecifier, ValueComparisonOperator } from './record-query-expression';
export interface AttributeSortParam {
    attribute: string;
    order?: SortOrder;
}
export declare type SortParam = SortSpecifier | AttributeSortParam | string;
export interface PageParam {
    offset?: number;
    limit?: number;
}
export interface AttributeFilterParam {
    op?: ValueComparisonOperator;
    attribute: string;
    value: any;
}
export interface RelatedRecordFilterParam<RI = RecordIdentity> {
    op?: SetComparisonOperator;
    relation: string;
    record: RI | RI[] | null;
}
export interface RelatedRecordsFilterParam<RI = RecordIdentity> {
    op?: SetComparisonOperator;
    relation: string;
    records: RI[];
}
export declare type FilterParam<RI = RecordIdentity> = FilterSpecifier | AttributeFilterParam | RelatedRecordFilterParam<RI> | RelatedRecordsFilterParam<RI>;
export declare class BaseRecordQueryTerm<QE extends RecordQueryExpression, RT = string, RI = RecordIdentity> extends QueryTerm<QE> {
    $queryBuilder: RecordQueryBuilder<RT, RI>;
    constructor(queryBuilder: RecordQueryBuilder<RT, RI>, expression: QE);
    toQueryExpression(): QE;
}
/**
 * A query term representing a single record.
 */
export declare class FindRecordTerm<RT = string, RI = RecordIdentity> extends BaseRecordQueryTerm<FindRecord, RT, RI> {
    constructor(queryBuilder: RecordQueryBuilder<RT, RI>, record: RecordIdentity);
}
export declare class FindRelatedRecordTerm<RT = string, RI = RecordIdentity> extends BaseRecordQueryTerm<FindRelatedRecord, RT, RI> {
    constructor(queryBuilder: RecordQueryBuilder<RT, RI>, record: RecordIdentity, relationship: string);
}
export declare class FindRecordsTerm<RT = string, RI = RecordIdentity> extends BaseRecordQueryTerm<FindRecords | FindRelatedRecords, RT, RI> {
    /**
     * Applies sorting to a collection query.
     *
     * Sort specifiers can be expressed in object form, like:
     *
     * ```ts
     * { attribute: 'name', order: 'descending' }
     * { attribute: 'name', order: 'ascending' }
     * ```
     *
     * Or in string form, like:
     *
     * ```ts
     * '-name' // descending order
     * 'name'  // ascending order
     * ```
     */
    sort(...params: SortParam[]): this;
    /**
     * Applies pagination to a collection query.
     */
    page(param: PageParam): this;
    /**
     * Apply a filter expression.
     *
     * For example:
     *
     * ```ts
     * oqb
     *   .records('planet')
     *   .filter({ attribute: 'atmosphere', value: true },
     *           { attribute: 'classification', value: 'terrestrial' });
     * ```
     */
    filter(...params: FilterParam<RI>[]): this;
    $filterParamToSpecifier(param: FilterParam<RI>): FilterSpecifier;
    $pageParamToSpecifier(param: PageParam): PageSpecifier;
    $sortParamToSpecifier(param: SortParam): SortSpecifier;
    $parseSortParamString(sortSpecifier: string): AttributeSortSpecifier;
}
export declare type RecordQueryTerm<RT = string, RI = RecordIdentity> = FindRecordTerm<RT, RI> | FindRelatedRecordTerm<RT, RI> | FindRecordsTerm<RT, RI>;