JsonApi.ts



export class JsonApiRequest {
    data: JsonApiData[] | JsonApiData;
    errors: JsonApiError[];
    included: JsonApiData[];
    links: { [key: string]: MetaLink };
    //model: any;
    meta: Meta;
    jsonapi: JsonApiVersion;

    constructor() {

        // Do this later
        //this.jsonapi = new JsonApiVersion();
        //this.jsonapi.version = '1.0';
    }

    //GetErrorsAsString(): string {

    //    var err: string = '';
    //    if (this.errors && this.errors.length) {
    //        for (var i = 0; i < this.errors.length; i++) {
    //            err += this.errors[i].detail + ' ';
    //        }
    //        err = err.trim();
    //    } else {
    //        //Should not ever happen
    //        err = 'No response from server';
    //    }
    //    return err;
    //}

    WithError(error: JsonApiError): JsonApiRequest {
        this.errors = this.errors || new Array<JsonApiError>();
        this.errors.push(error);
        return this;
    }

    WithData(data: JsonApiData): JsonApiRequest {
        var d : JsonApiData[] = <JsonApiData[]>this.data || new Array<JsonApiData>();
        d.push(data);

        this.data = d;
        return this;
    }

    WithSingleData(data: JsonApiData): JsonApiRequest {
        this.data = data;
        return this;
    }

    WithIncluded(data: JsonApiData): JsonApiRequest {
        this.included = this.included || new Array<JsonApiData>();
        this.included.push(data);
        return this;
    }

    WithLink(linkType: string, uri: string): JsonApiRequest {
        this.links = this.links || {};
        this.links[linkType] = new MetaLink(uri);
        return this;
    }

    AddLink(linkType: string, link: MetaLink): JsonApiRequest {
        this.links = this.links || {};
        this.links[linkType] = link;
        return this;
    }

    WithMeta(key: string, value: string): JsonApiRequest {
        this.meta = this.meta || new Meta();
        this.meta[key] = value;
        return this;
    }
}

export class JsonApiData {
    id: string;
    type: string;

    attributes: { [key: string]: any; };
    links: { [key: string]: MetaLink };
    relationships: { [key: string]: JsonApiRelationship };


    constructor(type: string) {
        this.id = undefined;
        this.type = type;

        this.attributes = undefined;
        this.links = undefined;
        this.relationships = undefined;
    }


    WithAttribute(key: string, value: string): JsonApiData {
        this.attributes = this.attributes || {};
        this.attributes[key] = value;
        return this;
    }

    AddLink(linkType: string, link: MetaLink): JsonApiData {
        this.links = this.links || {};
        this.links[linkType] = link;
        return this;
    }

    WithLink(linkType: string, uri: string): JsonApiData {
        this.links = this.links || {};
        this.links[linkType] = new MetaLink(uri);
        return this;
    }

    WithId(id: string): JsonApiData {
        this.id = id;
        return this;
    }

    WithRelationship(relationName: string, relation: JsonApiRelationship) {
        this.relationships = this.relationships || {};
        this.relationships[relationName] = relation;
        return this;
    }

    GetSelfLink(): string {
        if (this.links && this.links['self']) {
            return this.links['self'].href;
        } else {
            return null;
        }
    }
}

export class JsonApiRelationship {
    links: { [key: string]: MetaLink };
    data: JsonApiData[] | JsonApiData;
    meta: Meta;

    constructor(isArray: boolean) {
        this.links = {};

        if (isArray === true) {
            this.data = new Array<JsonApiData>();
        } else {
            this.data = null;
        }
    }



    WithData(type: string, id: string): JsonApiRelationship {

        if (type && id) {
            if (this.data && Array.isArray(this.data)) {
                (<JsonApiData[]>this.data).push(new JsonApiData(type).WithId(id));
            } else {
                this.data = new JsonApiData(type).WithId(id);
            }
            return this;
        } else {
            throw new Error('Invalid call to "JsonApiRelationship.WithData" type and id required');
        }
    }

    AddLink(linkType: string, link: MetaLink): JsonApiRelationship {
        this.links[linkType] = link;
        return this;
    }

    WithLink(linkType: string, url: string): JsonApiRelationship {
        this.links[linkType] =  new MetaLink(url);
        return this;
    }

    FindLinkType(linkType: string): string {
        return (this.links && this.links[linkType]) ? this.links[linkType].href : null;
    }
}

export class MetaLink {
    href: string;
    meta: Meta;

    constructor(href: string, meta?: Meta) {
        this.href = href;
        this.meta = meta || new Meta();
    }
}

export class Meta {
    fields: { [key: string]: string; };

    constructor() {
        this.fields = undefined;
    }
}

export class JsonApiError {
    id: string;
    links: { [key: string]: MetaLink };
    status: number;
    code: number;
    title: string;
    detail: string;
    //source: Source;

    AddLink(linkType: string, link: MetaLink): JsonApiError {
        this.links[linkType] = link;
        return this;
    }
}

export class JsonApiVersion {
    version: string;
    //meta: Meta;
}