The quickest way to get started is by exploring schema and trying a few queries. Oracle Content Management includes a GraphQL IDE that helps you explore schema and run queries.

GraphQL queries work against a schema or data model of the content. With Oracle Content Management, you don't need to create GraphQL schemas; every asset type in Oracle Content Management is automatically represented in the schema. The GraphQL type names are based on the API names of the asset types in Oracle Content Management, with prefixes where needed to avoid conflicts and collisions with reserved words in GraphQL.

Let's examine the schema for our PressRelease asset type in detail.

Oracle Content Management automatically generates queries for accessing assets. There is a generic item query (getItem(..)), and each core asset type gets a corresponding query (for example, getPressRelease(..)).

As previously mentioned, you type your query in the left panel, then click The IDE will help you write your query, but here is the basic format you'll use to get an item, replacing the text in italics with the appropriate values. You must include a channelToken, either as an argument in the query or as a header in the HTTP request. You must include either the ID or slug of the asset.

{
    getItem(channelToken: channel_token, id: ID, slug: slug): item
}

or

{
    getPressRelease(channelToken: channel_token, id: ID, slug: slug): pressRelease
}

In addition to queries that fetch a single asset, GraphQL also supports fetching many assets together, optionally based on a filtering criteria and sort order. In order to do that an out of the box query is included in the schema.

{
	getItems(channelToken: String, 
filter: standardFilter, 
query: queryFilter, 
sort: [standardSort], 
limit: int, offset: int) : itemCollection
}

A few standard types are introduced to support this functionality:

• standardFilter offers support for building filtering criteria for assets.
• queryFilter supports searching across many fields.
• standardSort specifies the sort order results based on field values.
• limit and offset provides means for client to paginate results.

The results of this query is itself a type that is a collection of other items, itemCollection, which in turn has an items array, along with pagination details.

The standardFilter type is defined in the schema as an input type.

Field names in this type are the same the names of the standard fields in Oracle Content Management for the item. Values accepted for these fields are themselves an input type, such as stringFilter, idFilter and others. These input types are specific to the underlying data type of the field, which represents a tuple of operation and value. The stringFilter type is expanded below to show the shape of this tuple.

With these data-type-specific input fields, a query can include only valid criteria for the data type. Please see GraphQL data types and available operations table for details.

In addition to the generic item query (getItems(..)) which uses the standardFilter type, GraphQL also supports type-specific queries with the ability to specify type-specific fields. To do this, for every asset type defined in Oracle Content Management, an accompanying type-specific filter is included. Continuing with the example of a PressRelease asset type, the filter for that is expressed as follows:

Note that all fields present in the standardFilter type are available in the pressReleaseFilter type as well. This means, any query that is possible with the standardFilter type can also be built with the type-specific filter, but you can specify user-defined, field-specific filters as well. As with the standardFilter type, type-specific filters can be combined using AND, OR, and NOT.

Also note that type-specific fields include a field called fields that references another input type listing all user defined fields.

In addition to retrieving item content, the GraphQL schema also supports retrieving published taxonomy information using the following queries.

{
	getTaxonomy(channelToken: String, id: ID): taxonomy
}

and

{
	getTaxonomies(channelToken: String, sort: [taxonomySort]) : taxonomyCollection
}

Categories can be fetched either from a taxonomy or directly, using the following queries.

{
	getCategory(id: ID, taxonomyId: ID, channelToken: String, apiName: String): category
}

{
	getCategories(id: ID, taxonomyId: ID, channelToken: String, limit: int, offset: int): categoryCollection
}

Retrieve Assets: Filter and Sort Assets by Standard Fields

Retrieving assets by filtering using standard fields (name, id, description, type, and so on) is accomplished by the use of standardFilter. For example, retrieving assets of a specific type is accomplished by standardFilter using criteria based on the type field’s value.

{ getItems(channelToken: "573ae0bcb95347d283cdbea8a4d29641", filter: {type: {op: EQUALS, value: "MyType"}}) { totalResults items { id name description } }}

You could just as easily retrieve assets of more than one type by creating an OR condition in the standardFilter.

{
  getItems(channelToken: "573ae0bcb95347d283cdbea8a4d29641", 
    filter: { 
            OR: [
                {type: {op: EQUALS, value: "myType1"}}, 
                {type: {op: EQUALS, value: "myType2"}}
                ] 				}
  ) 
  
  {
    totalResults
    items {
      id
      name
      description
    }

Note that filtering is possible on any standard fields present in the Item interface. Each field offers various operations (such as EQUALS and NOT_EQUALS) depending on the data type. See the following table for available operations for each data type.

In addition to filtering, clients can specify sorting criteria for the query. The following example sorts the results by the name field’s value.

{
  getItems(channelToken: "573ae0bcb95347d283cdbea8a4d29641", 
    filter: {type: {op: EQUALS, value: "MyType"}}
    sort: {name :DESC}
  ) {
    totalResults
    items {
      id
      name
      description
    }
  }
}

In addition to the filtering and sorting, clients can specify pagination instructions by using limit and offset. The following example shows how a client can fetch up to 10 results (limit) after the first 20 (offset).

{
  getItems(channelToken: "573ae0bcb95347d283cdbea8a4d29641", 
    filter: {type: {op: EQUALS, value: "myType"}}
    sort: {name :DESC}
    limit: 10
    offset: 20
  ) {
    totalResults
    count
    items {
      id
      name
      description
    }
  }
}

Retrieving Assets of a Specific Type by Specifying a Type-Specific Filter

The filtering criteria in the following example includes a user-defined field title and queries for all PressRelease assets that have Oracle in the title field.

{
  getPressReleaseCollection(channelToken: "573ae0bcb95347d283cdbea8a4d29641", 
    filter: {fields: {title: {op: CONTAINS, value: "Oracle"}}}) {
    items {
      name
      id
    }
  }
}

As with any filters, type-specific filters can be nested.

{
  getPressReleaseCollection(channelToken: "573ae0bcb95347d283cdbea8a4d29641", 
    filter: {fields: {title: {op: CONTAINS, value: "Oracle"}}, AND: {language: {op: EQUALS, value: "en-US"}}}) {
    items {
      name
      id
      language
      fields {
        title
      }
    }
  }
}

Retrieve Taxonomy and Category Information

Just as in a single asset retrieval, taxonomy can be retrieved using getTaxonomy. The following example shows how a published taxonomy, along with the first 3 levels of category information, can retrieved.

{
  getTaxonomy(channelToken: "573ae0bcb95347d283cdbea8a4d29641", id: "F95CD0EB0E02427C9A3B7F1B8F33645C") {
    id
    name
    categories {
      id
      name
      children {
        id
        name
        children {
          id
          name
        }
      }
    }
  }
}

Likewise, it is possible to retrieve every published taxonomy by using getTaxonomies. The following example shows how to get every published taxonomy with first 3 levels of categories under each of them.

{
  getTaxonomies(channelToken: "573ae0bcb95347d283cdbea8a4d29641") {
    taxonomies {
      id
      name
      categories {
        id
        name
        children {
          id
          name
          children {
            id
            name
          }
        }
      }
    }
  }
}

Categories can themselves be listed as well as fetched by their id/apiName. The following example shows how to fetch a category by apiName and its children two levels down.

{
getCategory(channelToken:"573ae0bcb95347d283cdbea8a4d29641", taxonomyId: "F95CD0EB0E02427C9A3B7F1B8F33645C" apiName:"hk-p")
  {
    name
    id
    apiName
    children {
      name
      id
      apiName
    }
  }
}

GraphQL Data Types and Available Operations	Values
String	EQUALS NOT_EQUALS CONTAINS NOT_CONTAINS STARTS_WITH MATCH SIMILAR
ID	IS
DateTime	EQUALS NOT_EQUALS BEFORE AFTER BEFORE_OR_EQUAL AFTER_OR_EQUAL
Boolean	(no operation, just true/false)
Int and Float	EQUALS, NOT_EQUALS, GREATER_THAN

GraphQL supports querying unpublished content similar to Content Preview REST APIs. See REST API for Content Preview.

Content that is published to a channel or targeted to a channel is available through Content Preview API in GraphQL. GraphQL preview provides access to the latest version of the asset.

In order to access assets in the preview context, the GraphQL endpoint is at http://user_instance/content/preview/api/v1.1/graphql and the GraphQL IDE is available at http://user_instance/content/preview/api/v1.1/graphql/explorer.

Previewing assets in GraphQL requires user authentication. See Authorization in REST API for Content Preview.

All the GraphQL capabilities (queries and schema) available for published assets are also available in preview.