extensions-spark

The extensions-spark module is one of Canva's Java SDKs for developing server-side extensions. It streamlines the development process and helps you avoid common pitfalls, such as misspelled field names and signature verification issues. Additionally, it provides everything you need to integrate Canva Apps with the Spark framework.
This module contains:
Publish, Content and Configuration Controller classes which handle the correct API endpoints, validate requests, and verify signatures.
Publish, Content and Configuration Service interfaces which you implement with your apps functionality.
Everything provided by the extensions-core module.
Usage
1.Download the module via Maven Central: search.maven.org/artifact/com.canva/extensions-spark​
2.Import the relevant components:
1
// Controllers
2
import com.canva.extensions.content.ContentApiController;
3
import com.canva.extensions.publish.PublishApiController;
4
import com.canva.extensions.configuration.ConfigurationApiController;
5
​
6
// Services
7
import com.canva.extensions.content.ContentApiService;
8
import com.canva.extensions.publish.PublishApiService;
9
import com.canva.extensions.configuration.ConfigurationApiService;
10
​
11
// Models
12
import com.canva.extensions.content.model.*;
13
import com.canva.extensions.publish.model.*;
Copied!
Services
You'll want to implement a service for each extension your app implements. The ContentApiService for content extensions, and the PublishApiService for publish extensions, respectively.
Each service interface contains methods which are supported by the particular extension. For example, the ContentApiService exposes a findResources method, which corresponds to the content/resources/find endpoint.
The ConfigurationApiService is recommended if your content or publish extension requires authentication.
In the example below, all that's required is to implement the findResources method, by handling the FindResourcesRequest and returning a FindResourcesResponse. See the API specification for more details.
1
import com.canva.extensions.content.ContentApiService;
2
import com.canva.extensions.content.model.*;
3
​
4
public class ContentApiServiceImpl implements ContentApiService {
5
​
6
    @Override
7
    public FindResourcesResponse findResources(FindResourcesRequest request) {
8
        throw new RuntimeException("Implement me :)");
9
    }
10
}
Copied!
Controllers
You'll want to register a controller for each extension your app implements. The ContentApiController for content extensions, and the PublishApiController for publish extensions, respectively.
The controllers handle:
Deserialization & serialization of request & responses.
Signature verification.
Request validation.
Mapping HTTP endpoints to Service methods - for example, a POST to /content/resources/find will invoke ContentApiService#findResources.
Each Controller exposes a register method, which must be invoked on initialization of the Spark application. This binds the Controllers to the supported HTTP paths and methods.
Example: Using the extensions-spark module
This example demonstrates how to wire up the controllers and services for an app with a content and publish extension that requires authentication. You need to call this in your Spark application's equivalent of a main method.
1
import com.canva.extensions.configuration.ConfigurationApiController;
2
import com.canva.extensions.content.ContentApiController;
3
import com.canva.extensions.publish.PublishApiController;
4
import com.canva.extensions.util.Signer;
5
import com.fasterxml.jackson.databind.ObjectMapper;
6
​
7
import java.time.Clock;
8
​
9
public class Example {
10
    public static void main(String[] args) {
11
        // Initialize your service implementation classes, with whatever dependencies they need. Left
12
        // empty here for illustratory purposes.
13
        final var contentService = new ContentApiServiceImpl();
14
        final var publishService = new PublishApiServiceImpl();
15
        final var configService = new ConfigurationServiceApiImpl();
16
​
17
        // The Signer (from extensions-core) implements the signature verifcation logic. It requires the
18
        // shared secret to be instantiated.
19
        final var signer = new Signer("canvaSecret");
20
        // A java.time.Clock instance, used to support signature verification.
21
        final var clock = Clock.systemUTC();
22
        // Used for serializing & deserializing request/response classes.
23
        final var mapper = new ObjectMapper();
24
​
25
        // Finally, register each controller.
26
        ContentApiController.register(contentService, signer, mapper, clock);
27
        PublishApiController.register(publishService, signer, mapper, clock);
28
        ConfigurationApiController.register(configService, signer, mapper, clock);
29
    }
30
}
Copied!
Do not commit the secret to the Signer in plaintext. Instead, provide it through an environment variable, configuration file, etc.

extensions-core

Next - Distribution

UX guidelines

Last modified 7mo ago

Copy link

Contents

Usage