Example queries and mutations

You can use the following example queries and mutations to get started with Content Services GraphQL API development.

Retrieving a document
The following example shows the query for retrieving a document.
Retrieving a folder by path
Documents or folders can be identified by path as well as by GUID.
Retrieving metadata - classDescription
Metadata such as class descriptions and property descriptions can be obtained through the API.
Retrieving choice lists
Choice lists of property descriptions can be selected as a field of the PropertyDescription interface returned by the previous query.
Retrieving subclasses of a certain class
This query supports getting all subclasses of a single class description. It also allows paging.
Retrieving a class description along with all its subclasses’ property descriptions
This example retrieves document property descriptions and all its subclasses’ property descriptions (filtered by isHidden: false).
Retrieving a CmThumbnail object and converting it to image
This example retrieves a CmThumbnail object. You can then convert the thumbnail to an image for display.
Convenience security principal fields
The schema exposes several convenience security principal fields that correspond to CE system properties, holding only a string identifier of the principal. The identifier is usually a short name.
Shaping of complex fields
The schema maps closely with the CE object model of classes and properties. Many fields of an interface or type correspond to CE object valued properties – single, list, or enum. These fields can be further shaped in the output data to return these additional objects.
Retrieving content elements
The content of documents can be obtained by requesting the contentElements field.
Retrieving a domain and its object stores
You can use this query to discover the object stores in a domain.
Creating a document
You can use a mutation to create a document.
Checking out a document
You can use a mutation to check out a document.
Canceling checkout of a document
Checkout of document can be cancelled. The mutation of cancel checkout can take any version of the document in the VersionSeries as input.
Updating custom value properties
As shown in some previous examples, the values of custom properties can be modified through the properties field of input types such as DocumentPropertiesInput supplied as input arguments to various mutations.
Updating custom single value object properties
Properties can also be updated through an objectProperties field. Any properties can be updated through objectProperties by using a more verbose schema than what can be accomplished by using the properties field and the custom key and value scalars. The main purpose of objectProperties is to allow object valued properties to be specified.
Updating permissions
Permissions are an example of a dependent object in the CE object model. Most dependent objects are system classes corresponding to system properties and as such there are well known input fields for setting permissions.
Uploading content
You can upload content by issuing a multi-part form POST.
Non-file content upload
You can include non-file content in the multi-part form POST request.
Multiple mutations in a single GraphQL request
By default, with multiple mutations within a single GraphQL call, batching is enabled automatically by using a Content Platform Engine UpdatingBatch behind the scenes. If there is only one mutation within a single GraphQL call, batching is not used at all.
Document searches
A search specifically for documents can be executed using the documents() query. The from, where, and orderBy arguments in general follow the CE query SQL syntax for those parts of the SQL statement.
Getting total count of an object search
Various options can be passed to the searches. These options are supported in the CE query SQL syntax.
Generic repository object searches
A search for any searchable class of object can be executed with the repositoryObjects() query.
Multiple repository object searches
Multiple related searches can be executed to get back one contiguous set of results using the repositoryObjectSearches() query.
Generic object query
The generic object() query can be used to retrieve any object in the Content Engine even if there is not a specific query method available for that type of object.
Search with JOIN
Complex conditions involving joins can be specified as the search criteria. With the single object type searches (documents(), folders() or repositoryObjects()) the properties selected are still from a single class but the search criteria can involve multiple joined classes.
Full text search
Full text searches can be issued, involving a join with the ContentSearch class.
Repository rows search
For use cases that involve returning properties from multiple joined classes, you can use a repositoryRows() search. With this search the caller has control over and specifies the entire SQL statement and can be any SQL supported by the CE query syntax.
Generic object mutation
The generic changeObject() mutation can be used to execute most kinds of change actions in the Content Engine. It can be used to execute changes against types of objects for which there is not currently a specific mutation available or when change actions (pending actions in the CE Java API) must be combined in some custom manner.
Generic mutations with dependent objects
Any kinds of dependent objects, including system dependents, must be passed using generic input types when calling the generic changeObject() mutation. You can use the generic mutation for a document to combine other actions in an otherwise unsupported way, however, this is only for example purposes.
GraphQL variables
The use of GraphQL variables is fully supported.
Modifying dependent object lists
This first example modifies a list of content elements by using the enhanced editing features of dependent object lists.
Retrieving users and groups
A GraphQL query can be used to retrieve users and groups.
Processing multiple operations in a single request

Parent topic: Content Services GraphQL Development