ghidoz / angular2-jsonapi / 446

pending completion

Build # 446

Build Type

Pull #279

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/ghidoz/angular2-jsonapi/commit/<a class=hub.com/ghidoz/angular2-jsonapi/commit/<a class="double-link" href="https://git"><a class=hub.com/ghidoz/angular2-jsonapi/commit/<a class="double-link" href="https://git"><a class=hub.com/ghidoz/angular2-jsonapi/commit/<a class="double-link" href="https://git"><a class=hub.com/ghidoz/angular2-jsonapi/commit/cb6c5b732bf3d9480adf91a0bb1ac1e019ef4c30">cb6c5b732">&lt;a href=&quot;https://github.com/ghidoz/angular2-jsonapi/commit/</a><a class="double-link" href="https://github.com/ghidoz/angular2-jsonapi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ghidoz/angular2-jsonapi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ghidoz/angular2-jsonapi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ghidoz/angular2-jsonapi/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ghidoz/angular2-jsonapi/commit/cb6c5b732bf3d9480adf91a0bb1ac1e019ef4c30">cb6c5b732</a><a href="https://github.com/ghidoz/angular2-jsonapi/commit/cb6c5b732bf3d9480adf91a0bb1ac1e019ef4c30">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/ghidoz/angular2-jsonapi/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ghidoz/angular2-jsonapi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ghidoz/angular2-jsonapi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ghidoz/angular2-jsonapi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ghidoz/angular2-jsonapi/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ghidoz/angular2-jsonapi/commit/cb6c5b732bf3d9480adf91a0bb1ac1e019ef4c30&quot;&gt;cb6c5b732&lt;/a&gt;&lt;a href=&quot;https://github.com/ghidoz/angular2-jsonapi/commit/cb6c5b732bf3d9480adf91a0bb1ac1e019ef4c30&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/ghidoz/angular2-jsonapi/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot... (continued)

Pull Request Pull Request #279: Use all provided resource objects when syncing relationships (not only those from the included section)

Run Details

275 of 351 branches covered (78.35%)

4 of 4 new or added lines in 1 file covered. (100.0%)

530 of 585 relevant lines covered (90.6%)

145.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.35

/projects/angular2-jsonapi/src/services/json-api-datastore.service.ts

import { Injectable } from '@angular/core';
import { HttpClient, HttpErrorResponse, HttpHeaders, HttpResponse } from '@angular/common/http';
import { find } from 'lodash-es';
import { catchError, map } from 'rxjs/operators';
import { Observable, of, throwError } from 'rxjs';
import { JsonApiModel } from '../models/json-api.model';
import { ErrorResponse } from '../models/error-response.model';
import { JsonApiQueryData } from '../models/json-api-query-data';
import * as qs from 'qs';
import { DatastoreConfig } from '../interfaces/datastore-config.interface';
import { ModelConfig } from '../interfaces/model-config.interface';
import { AttributeMetadata } from '../constants/symbols';
import 'reflect-metadata';

export type ModelType<T extends JsonApiModel> = new(datastore: JsonApiDatastore, data: any) => T;

/**
 * HACK/FIXME:
 * Type 'symbol' cannot be used as an index type.
 * TypeScript 2.9.x
 * See https://github.com/Microsoft/TypeScript/issues/24587.
 */
// tslint:disable-next-line:variable-name
const AttributeMetadataIndex: string = AttributeMetadata as any;

@Injectable()
export class JsonApiDatastore {

  protected config: DatastoreConfig;
  private globalHeaders: HttpHeaders;
  private globalRequestOptions: object = {};
  private internalStore: { [type: string]: { [id: string]: JsonApiModel } } = {};
  private toQueryString: (params: any) => string = this.datastoreConfig.overrides
  && this.datastoreConfig.overrides.toQueryString ?
    this.datastoreConfig.overrides.toQueryString : this._toQueryString;

  constructor(protected http: HttpClient) {
  }

  set headers(headers: HttpHeaders) {
    this.globalHeaders = headers;
  }

  set requestOptions(requestOptions: object) {
    this.globalRequestOptions = requestOptions;
  }

  public get datastoreConfig(): DatastoreConfig {
    const configFromDecorator: DatastoreConfig = Reflect.getMetadata('JsonApiDatastoreConfig', this.constructor);
    return Object.assign(configFromDecorator, this.config);
  }

  private get getDirtyAttributes() {
    if (this.datastoreConfig.overrides
      && this.datastoreConfig.overrides.getDirtyAttributes) {
      return this.datastoreConfig.overrides.getDirtyAttributes;
    }
    return JsonApiDatastore.getDirtyAttributes;
  }

  private static getDirtyAttributes(attributesMetadata: any): { string: any } {
    const dirtyData: any = {};

    for (const propertyName in attributesMetadata) {
      if (attributesMetadata.hasOwnProperty(propertyName)) {
        const metadata: any = attributesMetadata[propertyName];

        if (metadata.hasDirtyAttributes) {
          const attributeName = metadata.serializedName != null ? metadata.serializedName : propertyName;
          dirtyData[attributeName] = metadata.serialisationValue ? metadata.serialisationValue : metadata.newValue;
        }
      }
    }
    return dirtyData;
  }

  /**
   * @deprecated use findAll method to take all models
   */
  query<T extends JsonApiModel>(
    modelType: ModelType<T>,
    params?: any,
    headers?: HttpHeaders,
    customUrl?: string
  ): Observable<T[]> {
    const requestHeaders: HttpHeaders = this.buildHttpHeaders(headers);
    const url: string = this.buildUrl(modelType, params, undefined, customUrl);
    return this.http.get(url, {headers: requestHeaders})
      .pipe(
        map((res: any) => this.extractQueryData(res, modelType)),
        catchError((res: any) => this.handleError(res))
      );
  }

  public findAll<T extends JsonApiModel>(
    modelType: ModelType<T>,
    params?: any,
    headers?: HttpHeaders,
    customUrl?: string
  ): Observable<JsonApiQueryData<T>> {
    const url: string = this.buildUrl(modelType, params, undefined, customUrl);
    const requestOptions: object = this.buildRequestOptions({headers, observe: 'response'});

    return this.http.get(url, requestOptions)
      .pipe(
        map((res: HttpResponse<object>) => this.extractQueryData(res, modelType, true)),
        catchError((res: any) => this.handleError(res))
      );
  }

  public findRecord<T extends JsonApiModel>(
    modelType: ModelType<T>,
    id: string,
    params?: any,
    headers?: HttpHeaders,
    customUrl?: string
  ): Observable<T> {
    const requestOptions: object = this.buildRequestOptions({headers, observe: 'response'});
    const url: string = this.buildUrl(modelType, params, id, customUrl);

    return this.http.get(url, requestOptions)
      .pipe(
        map((res: HttpResponse<object>) => this.extractRecordData(res, modelType)),
        catchError((res: any) => this.handleError(res))
      );
  }

  public createRecord<T extends JsonApiModel>(modelType: ModelType<T>, data?: any): T {
    return new modelType(this, {attributes: data});
  }

  public saveRecord<T extends JsonApiModel>(
    attributesMetadata: any,
    model: T,
    params?: any,
    headers?: HttpHeaders,
    customUrl?: string
  ): Observable<T> {
    const modelType = model.constructor as ModelType<T>;
    const modelConfig: ModelConfig = model.modelConfig;
    const typeName: string = modelConfig.type;
    const relationships: any = this.getRelationships(model);
    const url: string = this.buildUrl(modelType, params, model.id, customUrl);

    let httpCall: Observable<HttpResponse<object>>;
    const body: any = {
      data: {
        relationships,
        type: typeName,
        id: model.id,
        attributes: this.getDirtyAttributes(attributesMetadata, model)
      }
    };

    const requestOptions: object = this.buildRequestOptions({headers, observe: 'response'});

    if (model.id) {
      httpCall = this.http.patch<object>(url, body, requestOptions) as Observable<HttpResponse<object>>;
    } else {
      httpCall = this.http.post<object>(url, body, requestOptions) as Observable<HttpResponse<object>>;
    }

    return httpCall
      .pipe(
        map((res) => [200, 201].indexOf(res.status) !== -1 ? this.extractRecordData(res, modelType, model) : model),
        catchError((res) => {
          if (res == null) {
            return of(model);
          }
          return this.handleError(res);
        }),
        map((res) => this.updateRelationships(res, relationships))
      );
  }

  public deleteRecord<T extends JsonApiModel>(
    modelType: ModelType<T>,
    id: string,
    headers?: HttpHeaders,
    customUrl?: string
  ): Observable<Response> {
    const requestOptions: object = this.buildRequestOptions({headers});
    const url: string = this.buildUrl(modelType, null, id, customUrl);

    return this.http.delete(url, requestOptions)
      .pipe(
        catchError((res: HttpErrorResponse) => this.handleError(res))
      );
  }

  public peekRecord<T extends JsonApiModel>(modelType: ModelType<T>, id: string): T | null {
    const type: string = Reflect.getMetadata('JsonApiModelConfig', modelType).type;
    return this.internalStore[type] ? this.internalStore[type][id] as T : null;
  }

  public peekAll<T extends JsonApiModel>(modelType: ModelType<T>): Array<T> {
    const type = Reflect.getMetadata('JsonApiModelConfig', modelType).type;
    const typeStore = this.internalStore[type];
    return typeStore ? Object.keys(typeStore).map((key) => typeStore[key] as T) : [];
  }

  public deserializeModel<T extends JsonApiModel>(modelType: ModelType<T>, data: any) {
    data.attributes = this.transformSerializedNamesToPropertyNames(modelType, data.attributes);
    return new modelType(this, data);
  }

  public addToStore(modelOrModels: JsonApiModel | JsonApiModel[]): void {
    const models = Array.isArray(modelOrModels) ? modelOrModels : [modelOrModels];
    const type: string = models[0].modelConfig.type;
    let typeStore = this.internalStore[type];

    if (!typeStore) {
      typeStore = this.internalStore[type] = {};
    }

    for (const model of models) {
      typeStore[model.id] = model;
    }
  }

  public transformSerializedNamesToPropertyNames<T extends JsonApiModel>(modelType: ModelType<T>, attributes: any) {
    const serializedNameToPropertyName = this.getModelPropertyNames(modelType.prototype);
    const properties: any = {};

    Object.keys(serializedNameToPropertyName).forEach((serializedName) => {
      if (attributes && attributes[serializedName] !== null && attributes[serializedName] !== undefined) {
        properties[serializedNameToPropertyName[serializedName]] = attributes[serializedName];
      }
    });

    return properties;
  }

  protected buildUrl<T extends JsonApiModel>(
    modelType: ModelType<T>,
    params?: any,
    id?: string,
    customUrl?: string
  ): string {
    // TODO: use HttpParams instead of appending a string to the url
    const queryParams: string = this.toQueryString(params);

    if (customUrl) {
      return queryParams ? `${customUrl}?${queryParams}` : customUrl;
    }

    const modelConfig: ModelConfig = Reflect.getMetadata('JsonApiModelConfig', modelType);

    const baseUrl = modelConfig.baseUrl || this.datastoreConfig.baseUrl;
    const apiVersion = modelConfig.apiVersion || this.datastoreConfig.apiVersion;
    const modelEndpointUrl: string = modelConfig.modelEndpointUrl || modelConfig.type;

    const url: string = [baseUrl, apiVersion, modelEndpointUrl, id].filter((x) => x).join('/');

    return queryParams ? `${url}?${queryParams}` : url;
  }

  protected getRelationships(data: any): any {
    let relationships: any;

    const belongsToMetadata: any[] = Reflect.getMetadata('BelongsTo', data) || [];
    const hasManyMetadata: any[] = Reflect.getMetadata('HasMany', data) || [];

    for (const key in data) {
      if (data.hasOwnProperty(key)) {
        if (data[key] instanceof JsonApiModel) {
          relationships = relationships || {};

          if (data[key].id) {
            const entity = belongsToMetadata.find((it: any) => it.propertyName === key);
            const relationshipKey = entity.relationship;
            relationships[relationshipKey] = {
              data: this.buildSingleRelationshipData(data[key])
            };
          }
        } else if (data[key] instanceof Array) {
          const entity = hasManyMetadata.find((it: any) => it.propertyName === key);
          if (entity && this.isValidToManyRelation(data[key])) {
            relationships = relationships || {};

            const relationshipKey = entity.relationship;
            const relationshipData = data[key]
              .filter((model: JsonApiModel) => model.id)
              .map((model: JsonApiModel) => this.buildSingleRelationshipData(model));

            relationships[relationshipKey] = {
              data: relationshipData
            };
          }
        }  else if (data[key] === null) {
          const entity = belongsToMetadata.find((anEntity: any) => anEntity.propertyName === key);

          if (entity) {
            relationships = relationships || {};

            relationships[entity.relationship] = {
              data: null
            };
          }
        }
      }
    }

    return relationships;
  }

  protected isValidToManyRelation(objects: Array<any>): boolean {
    if (!objects.length) {
      return true;
    }
    const isJsonApiModel = objects.every((item) => item instanceof JsonApiModel);
    if (!isJsonApiModel) {
      return false;
    }
    const types = objects.map((item: JsonApiModel) => item.modelConfig.modelEndpointUrl || item.modelConfig.type);
    return types
      .filter((type: string, index: number, self: string[]) => self.indexOf(type) === index)
      .length === 1;
  }

  protected buildSingleRelationshipData(model: JsonApiModel): any {
    const relationshipType: string = model.modelConfig.type;
    const relationShipData: { type: string, id?: string, attributes?: any } = {type: relationshipType};

    if (model.id) {
      relationShipData.id = model.id;
    } else {
      const attributesMetadata: any = Reflect.getMetadata('Attribute', model);
      relationShipData.attributes = this.getDirtyAttributes(attributesMetadata, model);
    }

    return relationShipData;
  }

  protected extractQueryData<T extends JsonApiModel>(
    response: HttpResponse<object>,
    modelType: ModelType<T>,
    withMeta = false
  ): Array<T> | JsonApiQueryData<T> {
    const body: any = response.body;
    const models: T[] = [];

    const resourceObjects = [...body.data, ...(body.included || [])];

    body.data.forEach((data: any) => {
      const model: T = this.deserializeModel(modelType, data);
      this.addToStore(model);

      model.syncRelationships(data, resourceObjects);
      this.addToStore(model);

      models.push(model);
    });

    if (withMeta && withMeta === true) {
      return new JsonApiQueryData(models, this.parseMeta(body, modelType));
    }

    return models;
  }

  protected extractRecordData<T extends JsonApiModel>(
    res: HttpResponse<object>,
    modelType: ModelType<T>,
    model?: T
  ): T {
    const body: any = res.body;
    // Error in Angular < 5.2.4 (see https://github.com/angular/angular/issues/20744)
    // null is converted to 'null', so this is temporary needed to make testcase possible
    // (and to avoid a decrease of the coverage)
    if (!body || body === 'null') {
      throw new Error('no body in response');
    }

    if (!body.data) {
      if (res.status === 201 || !model) {
        throw new Error('expected data in response');
      }
      return model;
    }

    if (model) {
      model.modelInitialization = true;
      model.id = body.data.id;
      Object.assign(model, body.data.attributes);
      model.modelInitialization = false;
    }

    const deserializedModel = model || this.deserializeModel(modelType, body.data);
    this.addToStore(deserializedModel);
    if (body.included) {
      deserializedModel.syncRelationships(body.data, body.included);
      this.addToStore(deserializedModel);
    }

    return deserializedModel;
  }

  protected handleError(error: any): Observable<any> {
    if (
      error instanceof HttpErrorResponse &&
      error.error instanceof Object &&
      error.error.errors &&
      error.error.errors instanceof Array
    ) {
      const errors: ErrorResponse = new ErrorResponse(error.error.errors);
      return throwError(errors);
    }

    return throwError(error);
  }

  protected parseMeta(body: any, modelType: ModelType<JsonApiModel>): any {
    const metaModel: any = Reflect.getMetadata('JsonApiModelConfig', modelType).meta;
    return new metaModel(body);
  }

  /**
   * @deprecated use buildHttpHeaders method to build request headers
   */
  protected getOptions(customHeaders?: HttpHeaders): any {
    return {
      headers: this.buildHttpHeaders(customHeaders),
    };
  }

  protected buildHttpHeaders(customHeaders?: HttpHeaders): HttpHeaders {
    let requestHeaders: HttpHeaders = new HttpHeaders({
      Accept: 'application/vnd.api+json',
      'Content-Type': 'application/vnd.api+json'
    });

    if (this.globalHeaders) {
      this.globalHeaders.keys().forEach((key) => {
        if (this.globalHeaders.has(key)) {
          requestHeaders = requestHeaders.set(key, this.globalHeaders.get(key));
        }
      });
    }

    if (customHeaders) {
      customHeaders.keys().forEach((key) => {
        if (customHeaders.has(key)) {
          requestHeaders = requestHeaders.set(key, customHeaders.get(key));
        }
      });
    }

    return requestHeaders;
  }

  protected resetMetadataAttributes<T extends JsonApiModel>(res: T, attributesMetadata: any, modelType: ModelType<T>) {
    for (const propertyName in attributesMetadata) {
      if (attributesMetadata.hasOwnProperty(propertyName)) {
        const metadata: any = attributesMetadata[propertyName];

        if (metadata.hasDirtyAttributes) {
          metadata.hasDirtyAttributes = false;
        }
      }
    }

    // @ts-ignore
    res[AttributeMetadataIndex] = attributesMetadata;
    return res;
  }

  protected updateRelationships<T extends JsonApiModel>(model: T, relationships: any): T {
    const modelsTypes: any = Reflect.getMetadata('JsonApiDatastoreConfig', this.constructor).models;

    for (const relationship in relationships) {
      if (relationships.hasOwnProperty(relationship) && model.hasOwnProperty(relationship) && model[relationship]) {
        const relationshipModel: JsonApiModel = model[relationship];
        const hasMany: any[] = Reflect.getMetadata('HasMany', relationshipModel);
        const propertyHasMany: any = find(hasMany, (property) => {
          return modelsTypes[property.relationship] === model.constructor;
        });

        if (propertyHasMany) {
          relationshipModel[propertyHasMany.propertyName] = relationshipModel[propertyHasMany.propertyName] || [];

          const indexOfModel = relationshipModel[propertyHasMany.propertyName].indexOf(model);

          if (indexOfModel === -1) {
            relationshipModel[propertyHasMany.propertyName].push(model);
          } else {
            relationshipModel[propertyHasMany.propertyName][indexOfModel] = model;
          }
        }
      }
    }

    return model;
  }

  protected getModelPropertyNames(model: JsonApiModel) {
    return Reflect.getMetadata('AttributeMapping', model) || [];
  }

  private buildRequestOptions(customOptions: any = {}): object {
    const httpHeaders: HttpHeaders = this.buildHttpHeaders(customOptions.headers);

    const requestOptions: object = Object.assign(customOptions, {
      headers: httpHeaders
    });

    return Object.assign(this.globalRequestOptions, requestOptions);
  }

  private _toQueryString(params: any): string {
    return qs.stringify(params, {arrayFormat: 'brackets'});
  }
}

1	import { Injectable } from '@angular/core';
2	import { HttpClient, HttpErrorResponse, HttpHeaders, HttpResponse } from '@angular/common/http';
3	import { find } from 'lodash-es';
4	import { catchError, map } from 'rxjs/operators';
5	import { Observable, of, throwError } from 'rxjs';
6	import { JsonApiModel } from '../models/json-api.model';
7	import { ErrorResponse } from '../models/error-response.model';
8	import { JsonApiQueryData } from '../models/json-api-query-data';
9	import * as qs from 'qs';
10	import { DatastoreConfig } from '../interfaces/datastore-config.interface';
11	import { ModelConfig } from '../interfaces/model-config.interface';
12	import { AttributeMetadata } from '../constants/symbols';
13	import 'reflect-metadata';
14
15	export type ModelType<T extends JsonApiModel> = new(datastore: JsonApiDatastore, data: any) => T;
16
17	/**
18	* HACK/FIXME:
19	* Type 'symbol' cannot be used as an index type.
20	* TypeScript 2.9.x
21	* See https://github.com/Microsoft/TypeScript/issues/24587.
22	*/
23	// tslint:disable-next-line:variable-name
24	const AttributeMetadataIndex: string = AttributeMetadata as any;	2✔
25
26	@Injectable()
27	export class JsonApiDatastore {	2✔
28
29	protected config: DatastoreConfig;
30	private globalHeaders: HttpHeaders;
31	private globalRequestOptions: object = {};	176✔
32	private internalStore: { [type: string]: { [id: string]: JsonApiModel } } = {};	176✔
33	private toQueryString: (params: any) => string = this.datastoreConfig.overrides	176!
34	&& this.datastoreConfig.overrides.toQueryString ?
35	this.datastoreConfig.overrides.toQueryString : this._toQueryString;	176!
36
37	constructor(protected http: HttpClient) {	176✔
38	}
39
40	set headers(headers: HttpHeaders) {	2✔
41	this.globalHeaders = headers;	2✔
42	}
43
44	set requestOptions(requestOptions: object) {	2✔
45	this.globalRequestOptions = requestOptions;	×
46	}
47
48	public get datastoreConfig(): DatastoreConfig {	2✔
49	const configFromDecorator: DatastoreConfig = Reflect.getMetadata('JsonApiDatastoreConfig', this.constructor);	346✔
50	return Object.assign(configFromDecorator, this.config);	346✔
51	}
52
53	private get getDirtyAttributes() {	2✔
54	if (this.datastoreConfig.overrides	32!
55	&& this.datastoreConfig.overrides.getDirtyAttributes) {
56	return this.datastoreConfig.overrides.getDirtyAttributes;	×
57	}
58	return JsonApiDatastore.getDirtyAttributes;	32✔
59	}
60
61	private static getDirtyAttributes(attributesMetadata: any): { string: any } {	2✔
62	const dirtyData: any = {};	32✔
63
64	for (const propertyName in attributesMetadata) {	32✔
65	if (attributesMetadata.hasOwnProperty(propertyName)) {	50!
66	const metadata: any = attributesMetadata[propertyName];	50✔
67
68	if (metadata.hasDirtyAttributes) {	50✔
69	const attributeName = metadata.serializedName != null ? metadata.serializedName : propertyName;	34✔
70	dirtyData[attributeName] = metadata.serialisationValue ? metadata.serialisationValue : metadata.newValue;	34!
71	}
72	}
73	}
74	return dirtyData;	32✔
75	}
76
77	/**
78	* @deprecated use findAll method to take all models
79	*/
80	query<T extends JsonApiModel>(	2✔
81	modelType: ModelType<T>,
82	params?: any,
83	headers?: HttpHeaders,
84	customUrl?: string
85	): Observable<T[]> {
86	const requestHeaders: HttpHeaders = this.buildHttpHeaders(headers);	×
87	const url: string = this.buildUrl(modelType, params, undefined, customUrl);	×
88	return this.http.get(url, {headers: requestHeaders})	×
89	.pipe(
90	map((res: any) => this.extractQueryData(res, modelType)),	×
91	catchError((res: any) => this.handleError(res))	×
92	);
93	}
94
95	public findAll<T extends JsonApiModel>(	34✔
96	modelType: ModelType<T>,
97	params?: any,
98	headers?: HttpHeaders,
99	customUrl?: string
100	): Observable<JsonApiQueryData<T>> {
101	const url: string = this.buildUrl(modelType, params, undefined, customUrl);	34✔
102	const requestOptions: object = this.buildRequestOptions({headers, observe: 'response'});	34✔
103
104	return this.http.get(url, requestOptions)	34✔
105	.pipe(
106	map((res: HttpResponse<object>) => this.extractQueryData(res, modelType, true)),	32✔
107	catchError((res: any) => this.handleError(res))	2✔
108	);
109	}
110
111	public findRecord<T extends JsonApiModel>(	4✔
112	modelType: ModelType<T>,
113	id: string,
114	params?: any,
115	headers?: HttpHeaders,
116	customUrl?: string
117	): Observable<T> {
118	const requestOptions: object = this.buildRequestOptions({headers, observe: 'response'});	4✔
119	const url: string = this.buildUrl(modelType, params, id, customUrl);	4✔
120
121	return this.http.get(url, requestOptions)	4✔
122	.pipe(
123	map((res: HttpResponse<object>) => this.extractRecordData(res, modelType)),	4✔
124	catchError((res: any) => this.handleError(res))	×
125	);
126	}
127
128	public createRecord<T extends JsonApiModel>(modelType: ModelType<T>, data?: any): T {	2✔
129	return new modelType(this, {attributes: data});	34✔
130	}
131
132	public saveRecord<T extends JsonApiModel>(	32✔
133	attributesMetadata: any,
134	model: T,
135	params?: any,
136	headers?: HttpHeaders,
137	customUrl?: string
138	): Observable<T> {
139	const modelType = model.constructor as ModelType<T>;	32✔
140	const modelConfig: ModelConfig = model.modelConfig;	32✔
141	const typeName: string = modelConfig.type;	32✔
142	const relationships: any = this.getRelationships(model);	32✔
143	const url: string = this.buildUrl(modelType, params, model.id, customUrl);	32✔
144
145	let httpCall: Observable<HttpResponse<object>>;
146	const body: any = {	32✔
147	data: {
148	relationships,
149	type: typeName,
150	id: model.id,
151	attributes: this.getDirtyAttributes(attributesMetadata, model)
152	}
153	};
154
155	const requestOptions: object = this.buildRequestOptions({headers, observe: 'response'});	32✔
156
157	if (model.id) {	32✔
158	httpCall = this.http.patch<object>(url, body, requestOptions) as Observable<HttpResponse<object>>;	12✔
159	} else {
160	httpCall = this.http.post<object>(url, body, requestOptions) as Observable<HttpResponse<object>>;	20✔
161	}
162
163	return httpCall	32✔
164	.pipe(
165	map((res) => [200, 201].indexOf(res.status) !== -1 ? this.extractRecordData(res, modelType, model) : model),	32✔
166	catchError((res) => {
167	if (res == null) {	4!
168	return of(model);	×
169	}
170	return this.handleError(res);	4✔
171	}),
172	map((res) => this.updateRelationships(res, relationships))	28✔
173	);
174	}
175
176	public deleteRecord<T extends JsonApiModel>(	2✔
177	modelType: ModelType<T>,
178	id: string,
179	headers?: HttpHeaders,
180	customUrl?: string
181	): Observable<Response> {
182	const requestOptions: object = this.buildRequestOptions({headers});	×
183	const url: string = this.buildUrl(modelType, null, id, customUrl);	×
184
185	return this.http.delete(url, requestOptions)	×
186	.pipe(
187	catchError((res: HttpErrorResponse) => this.handleError(res))	×
188	);
189	}
190
191	public peekRecord<T extends JsonApiModel>(modelType: ModelType<T>, id: string): T \| null {	2✔
192	const type: string = Reflect.getMetadata('JsonApiModelConfig', modelType).type;	528✔
193	return this.internalStore[type] ? this.internalStore[type][id] as T : null;	528✔
194	}
195
196	public peekAll<T extends JsonApiModel>(modelType: ModelType<T>): Array<T> {	2✔
197	const type = Reflect.getMetadata('JsonApiModelConfig', modelType).type;	×
198	const typeStore = this.internalStore[type];	×
199	return typeStore ? Object.keys(typeStore).map((key) => typeStore[key] as T) : [];	×
200	}
201
202	public deserializeModel<T extends JsonApiModel>(modelType: ModelType<T>, data: any) {	2✔
203	data.attributes = this.transformSerializedNamesToPropertyNames(modelType, data.attributes);	180✔
204	return new modelType(this, data);	180✔
205	}
206
207	public addToStore(modelOrModels: JsonApiModel \| JsonApiModel[]): void {	2✔
208	const models = Array.isArray(modelOrModels) ? modelOrModels : [modelOrModels];	200!
209	const type: string = models[0].modelConfig.type;	200✔
210	let typeStore = this.internalStore[type];	200✔
211
212	if (!typeStore) {	200✔
213	typeStore = this.internalStore[type] = {};	64✔
214	}
215
216	for (const model of models) {	200✔
217	typeStore[model.id] = model;	200✔
218	}
219	}
220
221	public transformSerializedNamesToPropertyNames<T extends JsonApiModel>(modelType: ModelType<T>, attributes: any) {	2✔
222	const serializedNameToPropertyName = this.getModelPropertyNames(modelType.prototype);	390✔
223	const properties: any = {};	390✔
224
225	Object.keys(serializedNameToPropertyName).forEach((serializedName) => {	390✔
226	if (attributes && attributes[serializedName] !== null && attributes[serializedName] !== undefined) {	1,476✔
227	properties[serializedNameToPropertyName[serializedName]] = attributes[serializedName];	1,304✔
228	}
229	});
230
231	return properties;	390✔
232	}
233
234	protected buildUrl<T extends JsonApiModel>(	2✔
235	modelType: ModelType<T>,
236	params?: any,
237	id?: string,
238	customUrl?: string
239	): string {
240	// TODO: use HttpParams instead of appending a string to the url
241	const queryParams: string = this.toQueryString(params);	70✔
242
243	if (customUrl) {	70!
244	return queryParams ? `${customUrl}?${queryParams}` : customUrl;	×
245	}
246
247	const modelConfig: ModelConfig = Reflect.getMetadata('JsonApiModelConfig', modelType);	70✔
248
249	const baseUrl = modelConfig.baseUrl \|\| this.datastoreConfig.baseUrl;	70✔
250	const apiVersion = modelConfig.apiVersion \|\| this.datastoreConfig.apiVersion;	70✔
251	const modelEndpointUrl: string = modelConfig.modelEndpointUrl \|\| modelConfig.type;	70✔
252
253	const url: string = [baseUrl, apiVersion, modelEndpointUrl, id].filter((x) => x).join('/');	280✔
254
255	return queryParams ? `${url}?${queryParams}` : url;	70✔
256	}
257
258	protected getRelationships(data: any): any {	32✔
259	let relationships: any;
260
261	const belongsToMetadata: any[] = Reflect.getMetadata('BelongsTo', data) \|\| [];	32✔
262	const hasManyMetadata: any[] = Reflect.getMetadata('HasMany', data) \|\| [];	32!
263
264	for (const key in data) {	764✔
265	if (data.hasOwnProperty(key)) {	764✔
266	if (data[key] instanceof JsonApiModel) {	168✔
267	relationships = relationships \|\| {};	4✔
268
269	if (data[key].id) {	4!
270	const entity = belongsToMetadata.find((it: any) => it.propertyName === key);	6✔
271	const relationshipKey = entity.relationship;	4✔
272	relationships[relationshipKey] = {	4✔
273	data: this.buildSingleRelationshipData(data[key])
274	};
275	}
276	} else if (data[key] instanceof Array) {	164✔
277	const entity = hasManyMetadata.find((it: any) => it.propertyName === key);	18✔
278	if (entity && this.isValidToManyRelation(data[key])) {	16✔
279	relationships = relationships \|\| {};	12✔
280
281	const relationshipKey = entity.relationship;	12✔
282	const relationshipData = data[key]	12✔
283	.filter((model: JsonApiModel) => model.id)	14✔
284	.map((model: JsonApiModel) => this.buildSingleRelationshipData(model));	10✔
285
286	relationships[relationshipKey] = {	12✔
287	data: relationshipData
288	};
289	}
290	} else if (data[key] === null) {	148!
291	const entity = belongsToMetadata.find((anEntity: any) => anEntity.propertyName === key);	×
292
293	if (entity) {	×
294	relationships = relationships \|\| {};	×
295
296	relationships[entity.relationship] = {	×
297	data: null
298	};
299	}
300	}
301	}
302	}
303
304	return relationships;	32✔
305	}
306
307	protected isValidToManyRelation(objects: Array<any>): boolean {	2✔
308	if (!objects.length) {	14✔
309	return true;	2✔
310	}
311	const isJsonApiModel = objects.every((item) => item instanceof JsonApiModel);	18✔
312	if (!isJsonApiModel) {	12!
313	return false;	×
314	}
315	const types = objects.map((item: JsonApiModel) => item.modelConfig.modelEndpointUrl \|\| item.modelConfig.type);	18✔
316	return types	12✔
317	.filter((type: string, index: number, self: string[]) => self.indexOf(type) === index)	18✔
318	.length === 1;
319	}
320
321	protected buildSingleRelationshipData(model: JsonApiModel): any {	2✔
322	const relationshipType: string = model.modelConfig.type;	14✔
323	const relationShipData: { type: string, id?: string, attributes?: any } = {type: relationshipType};	14✔
324
325	if (model.id) {	14!
326	relationShipData.id = model.id;	14✔
327	} else {
328	const attributesMetadata: any = Reflect.getMetadata('Attribute', model);	×
329	relationShipData.attributes = this.getDirtyAttributes(attributesMetadata, model);	×
330	}
331
332	return relationShipData;	14✔
333	}
334
335	protected extractQueryData<T extends JsonApiModel>(	32✔
336	response: HttpResponse<object>,
337	modelType: ModelType<T>,
338	withMeta = false	32!
339	): Array<T> \| JsonApiQueryData<T> {
340	const body: any = response.body;	32✔
341	const models: T[] = [];	32✔
342
343	const resourceObjects = [...body.data, ...(body.included \|\| [])];	32✔
344
345	body.data.forEach((data: any) => {	32✔
346	const model: T = this.deserializeModel(modelType, data);	14✔
347	this.addToStore(model);	14✔
348
349	model.syncRelationships(data, resourceObjects);	14✔
350	this.addToStore(model);	14✔
351
352	models.push(model);	14✔
353	});
354
355	if (withMeta && withMeta === true) {	32!
356	return new JsonApiQueryData(models, this.parseMeta(body, modelType));	32✔
357	}
358
359	return models;	×
360	}
361
362	protected extractRecordData<T extends JsonApiModel>(	2✔
363	res: HttpResponse<object>,
364	modelType: ModelType<T>,
365	model?: T
366	): T {
367	const body: any = res.body;	24✔
368	// Error in Angular < 5.2.4 (see https://github.com/angular/angular/issues/20744)
369	// null is converted to 'null', so this is temporary needed to make testcase possible
370	// (and to avoid a decrease of the coverage)
371	if (!body \|\| body === 'null') {	24✔
372	throw new Error('no body in response');	2✔
373	}
374
375	if (!body.data) {	22✔
376	if (res.status === 201 \|\| !model) {	14✔
377	throw new Error('expected data in response');	2✔
378	}
379	return model;	12✔
380	}
381
382	if (model) {	8✔
383	model.modelInitialization = true;	4✔
384	model.id = body.data.id;	4✔
385	Object.assign(model, body.data.attributes);	4✔
386	model.modelInitialization = false;	4✔
387	}
388
389	const deserializedModel = model \|\| this.deserializeModel(modelType, body.data);	8✔
390	this.addToStore(deserializedModel);	8✔
391	if (body.included) {	8!
392	deserializedModel.syncRelationships(body.data, body.included);	×
393	this.addToStore(deserializedModel);	×
394	}
395
396	return deserializedModel;	8✔
397	}
398
399	protected handleError(error: any): Observable<any> {	2✔
400	if (	6✔
401	error instanceof HttpErrorResponse &&	12✔
402	error.error instanceof Object &&
403	error.error.errors &&
404	error.error.errors instanceof Array
405	) {
406	const errors: ErrorResponse = new ErrorResponse(error.error.errors);	2✔
407	return throwError(errors);	2✔
408	}
409
410	return throwError(error);	4✔
411	}
412
413	protected parseMeta(body: any, modelType: ModelType<JsonApiModel>): any {	2✔
414	const metaModel: any = Reflect.getMetadata('JsonApiModelConfig', modelType).meta;	32✔
415	return new metaModel(body);	32✔
416	}
417
418	/**
419	* @deprecated use buildHttpHeaders method to build request headers
420	*/
421	protected getOptions(customHeaders?: HttpHeaders): any {	2✔
422	return {	×
423	headers: this.buildHttpHeaders(customHeaders),
424	};
425	}
426
427	protected buildHttpHeaders(customHeaders?: HttpHeaders): HttpHeaders {	70✔
428	let requestHeaders: HttpHeaders = new HttpHeaders({	70✔
429	Accept: 'application/vnd.api+json',
430	'Content-Type': 'application/vnd.api+json'
431	});
432
433	if (this.globalHeaders) {	70✔
434	this.globalHeaders.keys().forEach((key) => {	2✔
435	if (this.globalHeaders.has(key)) {	2!
436	requestHeaders = requestHeaders.set(key, this.globalHeaders.get(key));	2✔
437	}
438	});
439	}
440
441	if (customHeaders) {	70✔
442	customHeaders.keys().forEach((key) => {	4✔
443	if (customHeaders.has(key)) {	4!
444	requestHeaders = requestHeaders.set(key, customHeaders.get(key));	4✔
445	}
446	});
447	}
448
449	return requestHeaders;	70✔
450	}
451
452	protected resetMetadataAttributes<T extends JsonApiModel>(res: T, attributesMetadata: any, modelType: ModelType<T>) {	2✔
453	for (const propertyName in attributesMetadata) {	×
454	if (attributesMetadata.hasOwnProperty(propertyName)) {	×
455	const metadata: any = attributesMetadata[propertyName];	×
456
457	if (metadata.hasDirtyAttributes) {	×
458	metadata.hasDirtyAttributes = false;	×
459	}
460	}
461	}
462
463	// @ts-ignore
464	res[AttributeMetadataIndex] = attributesMetadata;	×
465	return res;	×
466	}
467
468	protected updateRelationships<T extends JsonApiModel>(model: T, relationships: any): T {	2✔
469	const modelsTypes: any = Reflect.getMetadata('JsonApiDatastoreConfig', this.constructor).models;	28✔
470
471	for (const relationship in relationships) {	28✔
472	if (relationships.hasOwnProperty(relationship) && model.hasOwnProperty(relationship) && model[relationship]) {	16✔
473	const relationshipModel: JsonApiModel = model[relationship];	12✔
474	const hasMany: any[] = Reflect.getMetadata('HasMany', relationshipModel);	12✔
475	const propertyHasMany: any = find(hasMany, (property) => {	12✔
476	return modelsTypes[property.relationship] === model.constructor;	2✔
477	});
478
479	if (propertyHasMany) {	12✔
480	relationshipModel[propertyHasMany.propertyName] = relationshipModel[propertyHasMany.propertyName] \|\| [];	2✔
481
482	const indexOfModel = relationshipModel[propertyHasMany.propertyName].indexOf(model);	2✔
483
484	if (indexOfModel === -1) {	2!
485	relationshipModel[propertyHasMany.propertyName].push(model);	2✔
486	} else {
487	relationshipModel[propertyHasMany.propertyName][indexOfModel] = model;	×
488	}
489	}
490	}
491	}
492
493	return model;	28✔
494	}
495
496	protected getModelPropertyNames(model: JsonApiModel) {	2✔
497	return Reflect.getMetadata('AttributeMapping', model) \|\| [];	390✔
498	}
499
500	private buildRequestOptions(customOptions: any = {}): object {	70!
501	const httpHeaders: HttpHeaders = this.buildHttpHeaders(customOptions.headers);	70✔
502
503	const requestOptions: object = Object.assign(customOptions, {	70✔
504	headers: httpHeaders
505	});
506
507	return Object.assign(this.globalRequestOptions, requestOptions);	70✔
508	}
509
510	private _toQueryString(params: any): string {	2✔
511	return qs.stringify(params, {arrayFormat: 'brackets'});	70✔
512	}
513	}	2✔

ghidoz / angular2-jsonapi / 446

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous