Draft CMIS

Showing results for 
Search instead for 
Did you mean: 

Draft CMIS

0 0 5,649

Obsolete Pages{{Obsolete}}

The official documentation is at: http://docs.alfresco.com


none|250px|CMIS Logo

Table of Contents

Content Management Interoperability Services (CMIS)

What is CMIS?

IMPORTANT NOTE: This page is a work in progress. Please refer to the main Alfresco CMIS page for information

Content Management Interoperability Services (CMIS) is a specification that defines how Enterprise Content Management (ECM) systems exchange content. ECM implementations today have proprietary APIs and query interfaces. Typically, those APIs are language-dependent, which makes it difficult to work across multiple ECM applications or to make them interoperate. The CMIS specification aims to bridge the gap between multiple ECM solutions within organizations by allowing application developers to access the repositories using an application and platform independent method.

The stated CMIS objective is to:

'define a domain model and set of bindings, such as Web Service and RESTful AtomPub that can be used by applications to work with one or more Content Management repositories/systems'.

By delivering platform independence, CMIS promises to be as important for the ECM industry as SQL in the database industry.


On September 10, 2008, Enterprise Content Management vendors EMC Corporation, IBM Corporation, and Microsoft Corporation announced the publication of Content Management Interoperability Services (CMIS), distributed as a ZIP archive with four prose documents and a collection of schemas, WSDLs, and XML instances.

On the same day, Alfresco announced the availability of the first implementation of the draft CMIS Specification.

On October 06, 2008, OASIS issued a public call for participation in a new technical committee chartered to define specifications for use of Web services and Web 2.0 interfaces to enable information sharing across content management repositories from different vendors. The OASIS CMIS TC works 'to standardize a Web services interface specification that will enable greater interoperability of Enterprise Content Management (ECM) systems. CMIS uses Web services and Web 2.0 interfaces to enable rich information to be shared across Internet protocols in vendor-neutral formats, among document systems, publishers and repositories, within one enterprise and between companies.'

Alfresco is a CMIS Technical Committee participant. Alfresco has provided its draft CMIS implementation to foster discussion, to provide a learning tool to gain hands-on experience, and to ensure a robust, implemented specification.

Going forward

As a contributing member of the draft technical specification, Alfresco is committed to growing the CMIS Community and being the leading Open Source CMIS member, driving development, discussion, and adoption of both CMIS and CMIS best practices.

Known CMIS implementations

Although the CMIS specification is still in a draft state, several initiatives are underway to implement both CMIS providers and clients.

Discussion of interoperability problems between CMIS clients or servers

CMIS providers (vendor repositories)

CMIS toolkits (Client APIs, protocol bindings, SPI, test repositories)

CMIS clients (user interfaces, tools)


PlugFests (Compatibility Testing Events)

Core CMIS concepts

Domain model

CMIS defines a common domain model for content management repositories. It covers common types and allows for extending those types with additional properties and creating relationships between the types.

Data model

The Data model allows for the discovery of defined custom content types. Note that CMIS does not specify how to define content - that is repository-specific.

Services model

CMIS addresses a common set of content services. CMIS doesn't define all the
common services vendors might possibly implement, but it looks at broadly accepted services most
content applications require and most content repositories provide, such as check-in/check-out,
versioning, and others. Importantly, CMIS also provides a capability to discover which services a
particular repository supports.

Protocol bindings

CMIS defines a set of protocol bindings to interact with the model. This allows
application developers to connect to the model and invoke some of the services. Initial protocol
bindings detailed in the specification are the AtomPub binding for REST-style (HTTP and URL interaction) and the SOAP binding for Web Services.

Query language

CMIS has a standardized query language based on SQL and adding its own extensions for content management including:

  • Full text search
  • Multi-valued properties
  • Folder hierarchy queries

This query language is very powerful because it offers a standard way of finding and querying information
which will allow application vendors to run against any CMIS-compliant repository without having to
make any changes to their code.

Alfresco CMIS implementation

Alfresco's draft CMIS implementation is available as part of Alfresco Community. This allows developers to gain hands-on experience with the specification as a CMIS provider or client.

  • For up-to-date news on the Draft Implementation, see the CMIS Blog
  • To discuss the Draft Implementation or CMIS in general, visit the CMIS Forum

Architectural overview

The draft CMIS implementation provides:

The following architectural diagram represents the CMIS implementation with Alfresco:

none|450px|Alfresco Draft CMIS Implementation

When installed and started, the Alfresco Repository URI http://<host>:<port>/alfresco/service/api/cmis.html provides access to the Alfresco Draft CMIS Implementation, including reference documentation for the RESTful AtomPub binding, test harnesses and Web Service WSDL.

Specification compliance

Alfresco Labs (HEAD svn) currently supports the CMIS v0.61 specification.

Alfresco server

RESTful AtomPub binding

The Alfresco Content Repository provides the CMIS RESTful AtomPub v0.61 binding, an extension of the Atom Publishing Protocol. All CMIS RESTful AtomPub services are implemented as Alfresco Web Scripts and support all Web Script capabilities such as authentication, content negotiation, and tunneling.

Services binding

Browser binding

Web Services binding

The Alfresco Content Repository provides the CMIS Web Services v0.61 binding.

CMIS To Alfresco mapping

The Alfresco content repository is mapped to the CMIS technical specification as follows:

Repository Capabilities

  • Multi-filing -> TRUE
  • Unfiling -> FALSE
  • Version-specific-filing -> FALSE
  • PWC-Searchable -> TRUE
  • PWC-Updatable -> TRUE
  • Query-non-latest-versions -> FALSE 
  • Inner-join -> FALSE
  • Outer-join -> FALSE
  • Full-text-query -> Full-text + Properties

Model Mapping

  • Note: Node Refs are serialized ${sys:store_protocol}://${sys:store_id}/${sys:node-uuid}
  • Note: (*) - Not supported

Object properties

  • ObjectId -> sys:referencable node ref (as a String) + '/{versionLabel}' if versioned
  • Uri (*)
  • ObjectTypeId -> M2TypeDefinition.name (Note: refer to Meta Model mapping) as a String
  • CreatedBy -> cm:creator
  • CreationDate  -> cm:created
  • LastModifiedBy -> cm:modifier
  • LastModificationDate -> cm:modified
  • ChangeToken ->

Document (inc. Object) Properties

  • Name  -> cm:name
  • IsImmutable -> TRUE if cm:lockable.lockType == readonly || cm:versionable.auto-version == false
  • IsLatestVersion -> TRUE  (FALSE if PWC)
  • IsMajorVersion -> VersionService().getCurrentVersion().getVersionType() == VersionType.MAJOR   (FALSE if PWC)
  • IsLatestMajorVersion -> IS_MAJOR_VERSION
  • VersionLabel -> cm:versionLabel
  • VersionSeriesId -> sys:referencable node ref (as a String)
  • IsVersionSeriesCheckedOut -> TRUE if COCI.getWorkingCopy is not null
  • VersionSeriesCheckedOutBy -> if COCI.getWorkingCopy is not null cm:lockable.lockOwner
  • VERSION_SERIES_CHECKED_OUT_ID  -> if COCI.getWorkingCopy is not null then COCI.getWorkingCopy noderef (as a String)
  • CheckinComment -> VersionService().getCurrentVersion().getDescription()
  • ContentStreamAllowed -> ContentStreamAllowed.ALLOWED.toString()
  • ContentStreamLength -> cm:content.size
  • ContentStreamMimeType -> cm:content.mimetype
  • ContentStreamFilename-> cm:name
  • ContentStreamUri

Folder (inc. Object) properties

  • Name -> cm:name
  • ParentId -> primary parent node ref
  • AllowedChildObjecTypeIds -> M2ChildAssociationDefinition.targetClassName

Relationship (inc. Object) properties

  • ObjecTypeId -> M2AssociationDefinition.name (Note: refer to Meta Model mapping)
  • CreatedBy (*)
  • CreationDate (*)
  • LastModifiedBy (*)
  • LastModificationDate (*)
  • SourceId -> AssociationRef.sourceRef node ref
  • TargetId -> AssociationRef.targetRef node ref

Meta Model Mapping

Base Object Types

  • DOCUMENT_OBJECT_TYPE  -> cm:content type
  • FOLDER_OBJECT_TYPE  -> cm:folder type
  • RELATIONSHIP_OBJECT_TYPE  -> simulate (no natural mapping)

Note: This means any type outside the cm:content and cm:folder hierarchy is not exposed via the CMIS interface.

Object Type Definition

  • ObjectTypeId -> M2TypeDefinition.name - serialized as D|F|R|P/{prefix}_localName
  • ObjectTypeQueryName -> M2TypeDefinition.name - serialized as prefix_localName (Note: For above base types, use name as defined in CMIS spec)
  • ObjectTypeDisplayName  -> M2TypeDefinition.title
  • ParentTypeId  -> M2TypeDefinition.parentName - serialized as D|F|R|P/{prefix}_localName
  • RootTypeQueryName  -> as defined in CMIS spec
  • Description  -> M2TypeDefinition.description
  • Creatable  -> true for files and folders and false otherwise
  • Fileable  -> true for files and folders and false otherwise
  • Queryable -> true for files and folders and false otherwise
  • Controllable -> false
  • Versionable  -> true
  • ContentStreamAllowed  -> type == cm:content ? allowed : notallowed
  • AllowedSourceTypes -> Assocs - DD source definition if a valid CMIS type
  • AllowedTargetTypes -> Assocs - DD target definition if a valid CMIS type

Property Type Definition

  • PropertyName -> M2PropertyDefinition.name - serialized as prefix_localName
  • PropertyId -> M2PropertyDefinition.name - serialized as {uri}localName or just the CMIS propertyname
  • DisplayName -> M2PropertyDefinition.title
  • Description -> M2PropertyDefinition.description
  • IsInherited -> true if the type definition is inherited from a super type (or a mandatory aspect inherits from another aspect)
  • PropertyType -> M2PropertyDefinition.dataType (Note: refer to Property Type mapping)
  • Cardinality -> M2PropertyDefinition.isMultiValued
  • MaximumLength -> Set if there is an appropriate constraint
  • SchemaURI -> null
  • Encoding -> null
  • Choices  -> M2PropertyDefinition.constraints['list of values'], if any
  • OpenChoice  -> false
  • Required  -> M2PropertyDefinition.isMandatoryEnforced
  • DefaultValue  -> M2PropertyDefinition.defaultValue
  • Updatability  -> M2PropertyDefinition.isProtected
  • Queryable - if indexed
  • Orderable - if indexed and tokenisation supports ordering

Property Type Mapping

  • String -> d:text, d:mltext (server locale only?), d:category?
  • Decimal -> d:float, d:double
  • Integer -> d:int, d:long
  • Boolean -> d:boolean
  • DateTime  -> d:date, d:datetime
  • Uri
  • Id -> d:text
  • Xml
  • Html


  • ID Mapping - In the CMIS model a data type of d:qname, d:noderef is mapped to a CMIS ID in type and property definitions.  They are converted to text in the property mapping.
  • Alfresco data types not mapped - d:any, d:content, d:childassocref, d:assocref, dSmiley Tongueath, d:locale, d:version
  • Any Alfresco property whose data type is not mapped to CMIS MUST be excluded from CMIS type definitions.



  • DeleteObject -> DeleteNode
  • UpdateProperties  -> WriteProperties
  • CheckOut  -> CheckOut
  • CancelCheckout  -> CancelCheckOut
  • CheckIn  -> CheckIn (on PWC)
  • DeleteAllVersions  -> TRUE
  • AddDocumentToFolder  -> LinkChildren
  • RemoveDocumentFromFolder
  • SetContentStream  -> WriteContent
  • DeleteContentStream  -> WriteProperties
  • GetAllVersions  -> TRUE
  • GetDocumentParents  -> TRUE
  • GetRelationships  -> TRUE
  • GetProperties  -> ReadProperties
  • GetContentStream  -> ReadContent
  • MoveObject  -> DeleteNode?


  • DeleteObject  -> DeleteNode
  • DeleteTree  -> DeleteNode
  • UpdateProperties  -> WriteProperties
  • GetChildren  -> ReadChildren
  • GetDescendants  -> ReadChildren
  • GetFolderParent  -> TRUE
  • GetProperties  -> ReadProperties
  • GetRelationships  -> TRUE
  • MoveObject  -> DeleteNode?


  • DeleteObject  -> TRUE
  • UpdateProperties  -> N/A
  • GetProperties  -> N/A
  • GetRelationships

RESTful AtomPub binding test harness

The Alfresco test harness exercises the CMIS RESTful AtomPub binding. It's available in the following flavors:

  • JUnit test
  • Test Harness Web Page: http://<host>:<port>/alfresco/service/api/cmis.html

By default, the test executes against the Alfresco Draft CMIS Implementation. However, you can test any CMIS RESTful AtomPub binding provider by adjusting one or more of the following settings:

  • Service URI
  • Username/Password (BASIC HTTP Authentication, for now)
  • Validate Responses (against CMIS specification XSDs)
  • Trace Request/Responses
  • Argument Style (URL or Headers)

The test harness also doubles as a set of Java CMIS client samples:

Example of test harness as a web page:
none|550px|Alfresco CMIS Unit Tests

CMIS Query Language

The first part of the CMIS specification provides a definition of a standard query language for
CMIS. The query language is a form of SQL, which means the specification provides a mapping
between the domain model and the relational view of the model. This allows the CMIS repository to
be exposed as a relational database. Each object that can be queried is mapped as a relational type
or a virtual table.


The CMIS Query Language is a subset of SQL-92, with some extensions specific to the content
management world. These extensions include:

  • ANY - ability to query multi-valued properties common in properties such as keywords;
  • IN_FOLDER() and IN_TREE() - ability to find documents and recursively descend a folder hierarchy; and,
  • CONTAINS() and SCORE() $ - to search text inside the content and relevance ranking of results.

These can be combined with traditional attribute search.

All capabilities of CMIS SQL are supported (except join between Types). The Alfresco FTS language may be embedded in the CMIS SQL contains() predicate.

Alfresco Aspects may also be queried as if they were tables and joined to Types by ObjectId.


Search by document name

Search by document author

Search by exact text

This query finds documents containing the text string 'Caribbean Central America Cruise Tour' picking out any DepartureDates (multi-value property) after January 1st 2010. It also sorts based on relevance of the search.

SELECT ObjectId, SCORE() AS Relevance, Destination, DepartureDates
FROM TravelBrochure
AND F2010-1-15

The content stream is not part of the SQL specification and cannot be returned through
querying as other services handle retrieving the content. Additionally, there are some optional
repository specific capabilities which can be discovered, such as the level of search support, and inner
and left outer joins support, among others.

Alfresco client

Talking to the Alfresco server

Soap binding client APIs

AtomPub binding client APIs

Talking to web services

Viewing documents

Connecting to the Alfresco server

Integrating CMIS clients with Alfresco

Apache Abdera

Apache Abdera is an implementation of the Atom Syndication Format (RFC 4287) and Atom Publishing Protocol (RFC 5023) specifications. The CMIS REST API binding is an extension of the Atom Publishing Protocol. Therefore, Apache Abdera may be used as a client library to any CMIS REST provider.

To support the custom CMIS schema, the Alfresco Draft Implementation provides a CMIS extension to Apache Abdera.

Alfresco and Joomla

The CMIS Joomla-Alfresco Integration project provides a mechanism to achieve the benefits of Alfresco and Joomla working together through a standards-compliant interface.

The following is an example of a Joomla! Site with an Alfresco module.


Test the CMIS Joomla-Alfresco Demo yourself. Guest Login is demo/demo.

Alfresco and Drupal

The CMIS Drupal-Alfresco Integration project provides a mechanism to achieve the benefits of Alfresco and Drupal working together through a standards-compliant interface.

The following is an example of how Drupal can act as a CMIS client to Alfresco.


Test the CMIS Drupal-Alfresco Integration Module yourself. Guest Login is demo/demo.

Building CMIS applications with Alfresco SURF

Frequently Asked Questions

  1. What is CMIS?
  2. What problem does CMIS address?
  3. What functionality does CMIS address?
  4. How does CMIS relate to other standards?
  5. Which vendors are involved in CMIS and how long have they been working on the Draft Specification?
  6. What will be the impact of CMIS on the ECM market?
  7. Why CMIS?
  8. How do I get access to the Draft Specification and what is the OASIS process?
  9. How can I start developing against the CMIS API today to prepare for tomorrow?
10. How can I participate and comment on the Specification?



CMIS specification:

Alfresco CMIS Developer Toolbox:
To encourage developers to learn, explore and prototype CMIS, we've assembled the following collection of resources in the Content Community:

Alfresco CMIS materials:

EMC, IBM & Microsoft: