Merge pull request #765 from tchak/add-query-expression-options

Add options to QueryExpression and Operation

packages/@orbit/data/src/index.ts

@@ -2,6 +2,7 @@ export { default } from '@orbit/core';
 export * from './exception';
 export * from './key-map';
 export * from './operation';
+export * from './operation-term';
 export * from './options';
 export * from './query-builder';
 export * from './query-expression';

packages/@orbit/data/src/operation-term.ts

@@ -0,0 +1,173 @@
+import { deepMerge } from '@orbit/utils';
+import {
+  Operation,
+  AddRecordOperation,
+  UpdateRecordOperation,
+  RemoveRecordOperation,
+  ReplaceAttributeOperation,
+  ReplaceKeyOperation,
+  AddToRelatedRecordsOperation,
+  RemoveFromRelatedRecordsOperation,
+  ReplaceRelatedRecordsOperation,
+  ReplaceRelatedRecordOperation
+} from './operation';
+import { RequestOptions } from './request';
+import { RecordIdentity } from './record';
+
+/**
+ * Operation terms are used by transform builders to allow for the construction of
+ * operations in composable patterns.
+ */
+export class OperationTerm<T extends Operation = Operation> {
+  operation: T;
+
+  constructor(operation?: T) {
+    this.operation = operation;
+  }
+
+  toOperation(): T {
+    return this.operation;
+  }
+
+  options(options: RequestOptions): this {
+    this.operation.options = deepMerge(this.operation.options || {}, options);
+    return this;
+  }
+}
+
+export class AddRecordTerm extends OperationTerm<AddRecordOperation> {
+  constructor(record: RecordIdentity) {
+    const operation: AddRecordOperation = {
+      op: 'addRecord',
+      record
+    };
+
+    super(operation);
+  }
+}
+
+export class UpdateRecordTerm extends OperationTerm<UpdateRecordOperation> {
+  constructor(record: RecordIdentity) {
+    const operation: UpdateRecordOperation = {
+      op: 'updateRecord',
+      record
+    };
+
+    super(operation);
+  }
+}
+
+export class RemoveRecordTerm extends OperationTerm<RemoveRecordOperation> {
+  constructor(record: RecordIdentity) {
+    const operation: RemoveRecordOperation = {
+      op: 'removeRecord',
+      record
+    };
+
+    super(operation);
+  }
+}
+
+export class ReplaceAttributeTerm extends OperationTerm<
+  ReplaceAttributeOperation
+> {
+  constructor(record: RecordIdentity, attribute: string, value: unknown) {
+    const operation: ReplaceAttributeOperation = {
+      op: 'replaceAttribute',
+      record,
+      attribute,
+      value
+    };
+
+    super(operation);
+  }
+}
+
+export class ReplaceKeyTerm extends OperationTerm<ReplaceKeyOperation> {
+  constructor(record: RecordIdentity, key: string, value: string) {
+    const operation: ReplaceKeyOperation = {
+      op: 'replaceKey',
+      record,
+      key,
+      value
+    };
+
+    super(operation);
+  }
+}
+
+export class AddToRelatedRecordsTerm extends OperationTerm<
+  AddToRelatedRecordsOperation
+> {
+  constructor(
+    record: RecordIdentity,
+    relationship: string,
+    relatedRecord: RecordIdentity
+  ) {
+    const operation: AddToRelatedRecordsOperation = {
+      op: 'addToRelatedRecords',
+      record,
+      relationship,
+      relatedRecord
+    };
+
+    super(operation);
+  }
+}
+
+export class RemoveFromRelatedRecordsTerm extends OperationTerm<
+  RemoveFromRelatedRecordsOperation
+> {
+  constructor(
+    record: RecordIdentity,
+    relationship: string,
+    relatedRecord: RecordIdentity
+  ) {
+    const operation: RemoveFromRelatedRecordsOperation = {
+      op: 'removeFromRelatedRecords',
+      record,
+      relationship,
+      relatedRecord
+    };
+
+    super(operation);
+  }
+}
+
+export class ReplaceRelatedRecordsTerm extends OperationTerm<
+  ReplaceRelatedRecordsOperation
+> {
+  constructor(
+    record: RecordIdentity,
+    relationship: string,
+    relatedRecords: RecordIdentity[]
+  ) {
+    const operation: ReplaceRelatedRecordsOperation = {
+      op: 'replaceRelatedRecords',
+      record,
+      relationship,
+      relatedRecords
+    };
+
+    super(operation);
+  }
+}
+
+export class ReplaceRelatedRecordTerm extends OperationTerm<
+  ReplaceRelatedRecordOperation
+> {
+  constructor(
+    record: RecordIdentity,
+    relationship: string,
+    relatedRecord: RecordIdentity | null
+  ) {
+    const operation: ReplaceRelatedRecordOperation = {
+      op: 'replaceRelatedRecord',
+      record,
+      relationship,
+      relatedRecord
+    };
+
+    super(operation);
+  }
+}

packages/@orbit/data/src/operation.ts

@@ -1,16 +1,18 @@
+import { eq, deepGet, deepSet } from '@orbit/utils';
 import {
   Record,
   RecordIdentity,
   cloneRecordIdentity,
   equalRecordIdentities
 } from './record';
-import { eq, deepGet, deepSet } from '@orbit/utils';
+import { RequestOptions } from './request';
 
 /**
  * Base Operation interface, which requires just an `op` string.
  */
 export interface Operation {
   op: string;
+  options?: RequestOptions;
 }
 
 /**
@@ -54,7 +56,7 @@ export interface ReplaceAttributeOperation extends Operation {
   op: 'replaceAttribute';
   record: RecordIdentity;
   attribute: string;
-  value: any;
+  value: unknown;
 }
 
 /**
@@ -126,7 +128,10 @@ function mergeOperations(
   superceding: RecordOperation,
   consecutiveOps: boolean
 ): void {
-  if (equalRecordIdentities(superceded.record, superceding.record)) {
+  if (superceded.options || superceding.options) {
+    // do not merge if one of the operations have options
+    return;
+  } else if (equalRecordIdentities(superceded.record, superceding.record)) {
     if (superceding.op === 'removeRecord') {
       markOperationToDelete(superceded);
       if (superceded.op === 'addRecord') {

packages/@orbit/data/src/query-expression.ts

@@ -1,4 +1,5 @@
 import { RecordIdentity } from './record';
+import { RequestOptions } from './request';
 
 export type SortOrder = 'ascending' | 'descending';
 
@@ -69,6 +70,7 @@ export type PageSpecifier = BasePageSpecifier | OffsetLimitPageSpecifier;
  */
 export interface QueryExpression {
   op: string;
+  options?: RequestOptions;
 }
 
 export interface FindRecord extends QueryExpression {

packages/@orbit/data/src/query-term.ts

@@ -1,4 +1,4 @@
-import { isObject } from '@orbit/utils';
+import { isObject, deepMerge } from '@orbit/utils';
 import {
   QueryExpression,
   FindRecord,
@@ -17,6 +17,7 @@ import {
   RelatedRecordsFilterSpecifier
 } from './query-expression';
 import { RecordIdentity } from './record';
+import { RequestOptions } from './request';
 
 export interface AttributeSortQBParam {
   attribute: string;
@@ -58,24 +59,27 @@ export type FilterQBParam =
  * Query terms are used by query builders to allow for the construction of
  * query expressions in composable patterns.
  */
-export class QueryTerm {
-  expression: QueryExpression;
+export class QueryTerm<T extends QueryExpression = QueryExpression> {
+  expression: T;
 
-  constructor(expression?: QueryExpression) {
+  constructor(expression?: T) {
     this.expression = expression;
   }
 
-  toQueryExpression(): QueryExpression {
+  toQueryExpression(): T {
     return this.expression;
   }
+
+  options(options: RequestOptions): this {
+    this.expression.options = deepMerge(this.expression.options || {}, options);
+    return this;
+  }
 }
 
 /**
  * A query term representing a single record.
  */
-export class FindRecordTerm extends QueryTerm {
-  expression: FindRecord;
-
+export class FindRecordTerm extends QueryTerm<FindRecord> {
   constructor(record: RecordIdentity) {
     let expression: FindRecord = {
       op: 'findRecord',
@@ -86,9 +90,7 @@ export class FindRecordTerm extends QueryTerm {
   }
 }
 
-export class FindRelatedRecordTerm extends QueryTerm {
-  expression: FindRelatedRecord;
-
+export class FindRelatedRecordTerm extends QueryTerm<FindRelatedRecord> {
   constructor(record: RecordIdentity, relationship: string) {
     let expression: FindRelatedRecord = {
       op: 'findRelatedRecord',
@@ -100,9 +102,7 @@ export class FindRelatedRecordTerm extends QueryTerm {
   }
 }
 
-export class FindRelatedRecordsTerm extends QueryTerm {
-  expression: FindRelatedRecords;
-
+export class FindRelatedRecordsTerm extends QueryTerm<FindRelatedRecords> {
   constructor(record: RecordIdentity, relationship: string) {
     let expression: FindRelatedRecords = {
       op: 'findRelatedRecords',
@@ -130,7 +130,7 @@ export class FindRelatedRecordsTerm extends QueryTerm {
    * 'name'  // ascending order
    * ```
    */
-  sort(...params: SortQBParam[]): FindRelatedRecordsTerm {
+  sort(...params: SortQBParam[]): this {
     const specifiers = params.map(sortParamToSpecifier);
     this.expression.sort = (this.expression.sort || []).concat(specifiers);
     return this;
@@ -139,7 +139,7 @@ export class FindRelatedRecordsTerm extends QueryTerm {
   /**
    * Applies pagination to a collection query.
    */
-  page(param: PageQBParam): FindRelatedRecordsTerm {
+  page(param: PageQBParam): this {
     this.expression.page = pageParamToSpecifier(param);
     return this;
   }
@@ -156,16 +156,14 @@ export class FindRelatedRecordsTerm extends QueryTerm {
    *           { attribute: 'classification', value: 'terrestrial' });
    * ```
    */
-  filter(...params: FilterQBParam[]): FindRelatedRecordsTerm {
+  filter(...params: FilterQBParam[]): this {
     const specifiers = params.map(filterParamToSpecifier);
     this.expression.filter = (this.expression.filter || []).concat(specifiers);
     return this;
   }
 }
 
-export class FindRecordsTerm extends QueryTerm {
-  expression: FindRecords;
-
+export class FindRecordsTerm extends QueryTerm<FindRecords> {
   constructor(typeOrIdentities?: string | RecordIdentity[]) {
     let expression: FindRecords = {
       op: 'findRecords'
@@ -197,7 +195,7 @@ export class FindRecordsTerm extends QueryTerm {
    * 'name'  // ascending order
    * ```
    */
-  sort(...params: SortQBParam[]): FindRecordsTerm {
+  sort(...params: SortQBParam[]): this {
     const specifiers = params.map(sortParamToSpecifier);
     this.expression.sort = (this.expression.sort || []).concat(specifiers);
     return this;
@@ -206,7 +204,7 @@ export class FindRecordsTerm extends QueryTerm {
   /**
    * Applies pagination to a collection query.
    */
-  page(param: PageQBParam): FindRecordsTerm {
+  page(param: PageQBParam): this {
     this.expression.page = pageParamToSpecifier(param);
     return this;
   }
@@ -223,7 +221,7 @@ export class FindRecordsTerm extends QueryTerm {
    *           { attribute: 'classification', value: 'terrestrial' });
    * ```
    */
-  filter(...params: FilterQBParam[]): FindRecordsTerm {
+  filter(...params: FilterQBParam[]): this {
     const specifiers = params.map(filterParamToSpecifier);
     this.expression.filter = (this.expression.filter || []).concat(specifiers);
     return this;