Asana Node.js Client Library

By default, endpoints that return an array of results return a Collection object. This object includes a nextPage() method used to fetch subsequent pages of results.

Requirements for pagination:

• You must provide a limit query parameter in your initial request.
• The limit value must be between 1 and 100.

If you attempt to request an endpoint with more than 1000 results without pagination, you may receive the error: "The result is too large. You should use pagination (may require specifying a workspace)!"

const Asana = require('asana');

let client = new Asana.ApiClient();
client.authentications.token.accessToken = '<YOUR_ACCESS_TOKEN>';

let tasksApiInstance = new Asana.TasksApi(client);
let opts = {
    "project": "<YOUR_PROJECT_GID>",
    "limit": 100,
};

async function getAllTasks(opts) {
    let tasks = await tasksApiInstance.getTasks(opts).then(async (response) => {
        let result = [];
        let page = response;
        while(true) {
            // Add items on page to list of results
            result = result.concat(page.data);
            // Fetch the next page
            page = await page.nextPage();
            // If there is no data in the next page break from the loop
            if (!page.data) {
                break;
            }
        }
        return result;
    }, (error) => {
        console.error(error.response.body);
    });
    console.log('Tasks: ' + JSON.stringify(tasks, null, 2));
}

getAllTasks(opts);

Establishing a webhook is a two-part process that requires your server to handle requests asynchronously.

1. Initiation: Send a POST request to /webhooks with the desired resource and target URL.
2. Handshake: As part of the creation request, Asana will send a test POST to your target URL containing an X-Hook-Secret header.
3. Confirmation: Your server must respond to this test POST with a 200 OK or 204 No Content status and return the exact same X-Hook-Secret header value.

If you do not acknowledge the handshake while the initial POST request is still in-flight, the webhook setup will fail. It is strongly recommended to store the X-Hook-Secret returned in the final response to verify future webhook event signatures.

Note: Invalid hostnames like localhost will result in a 403 Forbidden error.

# 1. Initiation
curl -H "Authorization: Bearer <personal_access_token>" \
 -X POST https://app.asana.com/api/1.0/webhooks \
 -d "resource=8675309" \
 -d "target=https://example.com/receive-webhook/7654"

# 2. Handshake sent by Asana to your target
# POST /receive-webhook/7654
# X-Hook-Secret: b537207f20cbfa02357cf448134da559e8bd39d61597dcd5631b8012eae53e81

# 3. Your required response
# HTTP/1.1 200
# X-Hook-Secret: b537207f20cbfa02357cf448134da559e8bd39d61597dcd5631b8012eae53e81

To subscribe to events for a specific resource (task or project), you must use a sync token.

1. Initial Sync: Make an initial call to getEvents with an empty sync parameter. If the request fails with a specific error, the error response body will contain the required sync token.
2. Polling: Use the sync token in subsequent requests to fetch only new events.
3. Updating Token: After every successful event fetch, update your sync token using the sync value provided in the response (often found in result._response.sync or via a 412 error response body) to ensure you are tracking the latest changes.

const Asana = require('asana');

let client = new Asana.ApiClient();
client.authentications.token.accessToken = '<YOUR_ACCESS_TOKEN>';

let eventsApiInstance = new Asana.EventsApi(client);
let resource = "<YOUR_TASK_OR_PROJECT_GID>";
let opts = {
    "sync": ""
};
const timeouts = 5000

const setSyncToken = async () => {
    await eventsApiInstance.getEvents(resource, opts).then((result) => {
        console.log(JSON.stringify(result.data, null, 2));
    }, (error) => {
        let syncToken = error.response.body.sync;
        opts['sync'] = syncToken;
    });
}

const getEvents = async () => {
    await setSyncToken();
    while(true) {
        await eventsApiInstance.getEvents(resource, opts).then((result) => {
            console.log(JSON.stringify(result.data, null, 2));
            opts['sync'] = result._response.sync;
        }, (error) => {
            if (error.status === 412) {
                let syncToken = error.response.body.sync;
                opts['sync'] = syncToken;
            } else {
                console.error(error.response.text);
            }
        });
        await new Promise(resolve => setTimeout(resolve, timeouts));
    }
}

getEvents();

When customizing Mustache templates (like api.mustache), you can use debug flags during the CLI execution to inspect the objects and data being passed to the template engine. This helps you identify which keys and values are available for generation.

Available Debug Flags

• -DdebugSwagger: Prints the OpenAPI Specification as interpreted by the codegen.
• -DdebugModels: Prints models passed to the template engine.
• -DdebugOperations: Prints operations passed to the template engine.
• -DdebugSupportingFiles: Prints additional data passed to the template engine.

Example: Debugging Operations

To see the data available for operations, add the -DdebugOperations flag to your execution command:

java -DdebugOperations -cp /path/to/swagger-codegen-cli.jar:/path/to/your.jar io.swagger.codegen.v3.cli.SwaggerCodegen -l AsanaPythonClientCodegen -i /path/to/swagger.yaml -o ./test

This project serves as a boilerplate for generating custom client libraries using Swagger. It provides the basic plumbing required to start a custom generator, but requires manual modifications to the generator logic and templates to function as a specific client library.

Project Structure

A generated setup typically includes:

• pom.xml: The build script.
• src/main/java/.../AsanaPythonClientCodegenGenerator.java: The core generator file where logic is implemented.
• src/main/resources/AsanaPythonClientCodegen/: The directory containing Mustache template files.
• src/main/resources/META-INF/services/io.swagger.codegen.CodegenConfig: Service registration for the codegen engine.

# Typical project structure
.
|- README.md
|- pom.xml
|-- src
|--- main
|---- java
|----- com.asana.codegen.AsanaPythonClientCodegenGenerator.java
|---- resources
|----- AsanaPythonClientCodegen
|----- META-INF
|------ services
|------- io.swagger.codegen.CodegenConfig