Class PrimaryResource

A resource contained in the top level data member of a Document.

Always constructed non-lazily from raw JSON:API data. Normally this is done automatically when accessing the resource or resources accessors.

Example

// a document containing one _article_ resource
const doc = await JsonApi.Document.fromURL(new URL('http://example.com/article'), context);
const article = doc.resource;  // the primary resource

Remarks

Methods and accessors marked as memoized are only executed once per instance (the first time they are called) and return a cached result on subsequent calls.

Hierarchy

Constructors

constructor

Properties

document id pRawData type

Accessors

attributes links meta metaLinks rawData relatedDocuments relatedResource relatedResources relationships selfLink

Methods

getData

Constructors

constructor

Properties

Protected Readonly document

document: Document

The parent document that contains this resource

Readonly id

id: string

The id of this resource

Private Readonly pRawData

pRawData: ResourceObject

Readonly type

type: string

The resource type

Accessors

attributes

links

meta

metaLinks

  • Object containing all entries inside links of meta interpreted as JSON:API Link (either string or link object)

    Memoized

    Returns Links

rawData

relatedDocuments

  • get relatedDocuments(): RelationshipToDocument

  • Proxy providing all Documents reachable via related links in relationships.

    Example

    For this JSON:API document

    {
      "data": {
        "type": "articles",
        "id": "1",
        "relationships": {
          "author": {
            "links": {"related": "http://example.com/people/1"}
          },
          "reviewer": {
            "links": {"related": "http://example.com/people/12"}
          }
        }
      }
    }

    calling relatedDocuments on the primary articles resource will give you access to the following data:

    {
      author: Document(...),
      reviewer: Document(...)
    }

    Remarks

    As this is only a proxy object, calling relatedDocuments does not yet fetch any related documents. Only when accessing a specific related document (e.g. calling article.relatedDocuments['author']) is the new document actually requested from the server.

    Returns RelationshipToDocument

relatedResource

  • get relatedResource(): RelationshipToResource

  • Proxy providing all singular Resources reachable via relationships from this resource.

    Example

    For this JSON:API document

    {
      "data": {
        "type": "articles",
        "id": "1",
        "relationships": {
          "author": {
            "data": {"type":"people", "id":"1"}
          },
          "reviewer": {
            "data": {"type":"people", "id":"12"}
          }
        }
      },
      "included": [...]
    }

    calling relatedResource on the primary articles resource will give you access to the following data:

    {
      author: RelatedResource(...),
      reviewer: RelatedResource(...)
    }

    This accessor is a shortcut so that you do not have to go through relationships manually every time. Writing

    const author = await article.relatedResource['author'];

    is equivalent to

    const author = await article.relationships['author'].resource();

    Remarks

    As this shortcut uses the resource method, it prefers resource linkage (i.e. id/type pairs in data) to related links should both be present in the relationship. You can use the resourceFromRelatedLink method if you need to fetch a related resource via link instead of resource linkage.

    As this is only a proxy object, calling relatedResource will not yet construct any RelatedResource instances. Only when accessing a specific related resource (e.g. calling article.relatedResource['author']) is the new resource actually constructed.

    Returns RelationshipToResource

relatedResources

  • get relatedResources(): RelationshipToResources

  • Proxy providing all multiple Resources reachable via relationships from this resource.

    Example

    For this JSON:API document

    {
      "data": {
        "type": "articles",
        "id": "1",
        "relationships": {
          "comments": {
            "data": [{"type":"comments", "id":"1"}, {"type":"comments", "id":"2"}]
          },
          "ratings": {
            "data": [{"type":"ratings", "id":"1"}, {"type":"ratings", "id":"2"}]
          }
        }
      },
      "included": [...]
    }

    calling relatedResources on the primary articles resource will give you access to the following data:

    {
      comments: [
        RelatedResource(...),
        RelatedResource(...)
      ],
      ratings: [
        RelatedResource(...),
        RelatedResource(...)
      ]
    }

    This accessor is a shortcut so that you do not have to go through relationships manually every time. Writing

    const comments = await article.relatedResources['comments'];

    is equivalent to

    const comments = await article.relationships['comments'].resources();

    Remarks

    As this shortcut uses the resources method, it prefers resource linkage (i.e. id/type pairs in data) to related links should both be present in the relationship. You can use the resourcesFromRelatedLink method if you need to fetch related resources via link instead of resource linkage.

    As this is only a proxy object, calling relatedResources will not yet construct any RelatedResource instances. Only when accessing a specific related resource (e.g. calling article.relatedResources['comments']) are the new resources actually constructed.

    Returns RelationshipToResources

relationships

selfLink

Methods

Protected getData

Settings

Member Visibility

Theme

Generated using TypeDoc