Runtime Client

1
{
2
  '/names.json': {
3
    path: '/var/task/files/ZNdad14da2e70d2533f640cf362fec0609',
4
    open: [Function: open]
5
  },
6
  '/rickroll.mp3': {
7
    path: '/var/task/files/ZNdfbfaf15a02e244fa11337548dabd9d0',
8
    open: [Function: open]
9
  },
10
  '/helper-method.js': {
11
    path: '/var/task/files/ZN5d6d933785a76da25056328a5764d49b',
12
    open: [Function: open]
13
  }
14
}

1
exports.handler = function (context, event, callback) {
2
  // Note: the leading slash and file extension are necessary to access the Asset
3
  const path = Runtime.getAssets()['/my-asset.json'].path;
4

5
  console.log('The path is: ' + path);
6

7
  return callback();
8
};

1
exports.handler = function (context, event, callback) {
2
  // First, get the path for the Asset
3
  const path = Runtime.getAssets()['/answer-generator.js'].path;
4

5
  // Next, you can use require() to import the library
6
  const module = require(path);
7

8
  // Finally, use the module as you would any other!
9
  console.log('The answer to your riddle is: ' + module.getAnswer());
10

11
  return callback();
12
};

1
exports.handler = function (context, event, callback) {
2
  const openFile = Runtime.getAssets()['/my_file.txt'].open;
3
  // Calling open is equivalent to using fs.readFileSync(asset.filePath, 'utf8')
4
  const text = openFile();
5

6
  console.log('Your file contents: ' + text);
7

8
  return callback();
9
};

1
// We're reading a file from the file system, so we'll need to import fs
2
const fs = require('fs');
3

4
exports.handler = async function (context, event, callback) {
5
  // Retrieve the path of your file
6
  const file = Runtime.getAssets()['/my_file.txt'].path;
7
  // Asynchronously read the file using a different encoding from utf8
8
  const text = await fs.readFile(file, 'base64');
9

10
  console.log('Your file contents: ' + text);
11

12
  return callback();
13
};

1
{
2
  'sms/reply': {
3
    path: '/var/task/handlers/ZNdad14da2e70d2533f640cf362fec0609.js',
4
  },
5
  'helper': {
6
    path: '/var/task/handlers/ZNdfbfaf15a02e244fa11337548dabd9d0.js',
7
  },
8
  'example-function': {
9
    path: '/var/task/handlers/ZN5d6d933785a76da25056328a5764d49b.js',
10
  },
11
}

1
exports.handler = function (context, event, callback) {
2
  // Get the path for the Function. Note that the key of the function
3
  // is not preceded by a "/" as is the case with Assets
4
  const path = Runtime.getFunctions()['example-function'].path;
5

6
  console.log('The path to your Function is: ' + path);
7

8
  return callback();
9
};

1
exports.ask = () => {
2
  // We're not totally sure if Zoltar's advice is all that helpful
3
  const fortunes = [
4
    'A long-forgotten loved one will appear soon.',
5
    'Are you sure the back door is locked?',
6
    "Communicate!  It can't make things any worse.",
7
    'Do not sleep in a eucalyptus tree tonight.',
8
    'Fine day for friends.',
9
    'Good news.  Ten weeks from Friday will be a pretty good day.',
10
    'Living your life is a task so difficult, it has never been attempted before.',
11
    'Stay away from flying saucers today.',
12
    'The time is right to make new friends.',
13
    'Try to relax and enjoy the crisis.',
14
    'You need more time; and you probably always will.',
15
    'Your business will assume vast proportions.',
16
  ];
17

18
  // Generate a random index and return the given fortune
19
  return fortunes[Math.floor(Math.random() * fortunes.length)];
20
};

1
exports.handler = function (context, event, callback) {
2
  // First, get the path for the Function. Note that the key of the function
3
  // is not preceded by a "/" as is the case with Assets
4
  const zoltarPath = Runtime.getFunctions()['zoltar'].path;
5
 
6
  // Next, use require() to import the library
7
  const zoltar = require(zoltarPath);
8
 
9
  // Finally, use the module as you would any other!
10
  console.log('The answer to your riddle is: ' + zoltar.ask());
11
 
12
  return callback();
13
}

1
exports.handler = (context, event, callback) => {
2
  // Use the getSync method with no arguments to get a reference to the default
3
  // Sync document for your account. Fetch returns a Promise, which will
4
  // eventually resolve to metadata about the Sync Service, such as its SID
5
  Runtime.getSync()
6
    .fetch()
7
    .then((defaultSyncService) => {
8
      console.log('Sync Service SID: ', defaultSyncService.sid);
9
      return callback(null, defaultSyncService.sid);
10
    })
11
    .catch((error) => {
12
      console.log('Sync Error: ', error);
13
      return callback(error);
14
    });
15
};

1
exports.handler = (context, event, callback) => {
2
  // Pass a serviceName to getSync to get a reference to that specific
3
  // Sync document on your account. Fetch returns a Promise, which will
4
  // eventually resolve to metadata about the Sync Service, such as friendlyName
5
  Runtime.getSync({ serviceName: 'ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX' })
6
    .fetch()
7
    .then((syncService) => {
8
      console.log('Sync Service Name: ' + syncService.friendlyName);
9
      return callback(null, syncService.friendlyName);
10
    })
11
    .catch((error) => {
12
      console.log('Sync Error: ', error);
13
      return callback(error);
14
    });
15
};

1
exports.handler = (context, event, callback) => {
2
  // maps, which is a shortcut to syncMaps, allows you to create a new Sync Map
3
  // instance. Be sure to provide a uniqueName identifier!
4
  Runtime.getSync()
5
    .maps.create({
6
      uniqueName: 'spaceShips',
7
    })
8
    .then((newMap) => {
9
      console.log(newMap);
10
      return callback(null, newMap);
11
    })
12
    .catch((error) => {
13
      console.log('Sync Error: ', error);
14
      return callback(error);
15
    });
16
};

1
exports.handler = (context, event, callback) => {
2
  // Given an existing Sync Map with the uniqueName of spaceShips, you can use
3
  // syncMapItems.create to add a new key:data pair which will be accessible
4
  // to any other Function or product with access to the Sync Map!
5
  Runtime.getSync()
6
    .maps('spaceShips')
7
    .syncMapItems.create({
8
      key: 'fastestShip',
9
      data: {
10
        name: 'Millenium Falcon',
11
      },
12
    })
13
    .then((response) => {
14
      console.log(response);
15
      return callback(null, response);
16
    })
17
    .catch((error) => {
18
      console.log('Sync Error: ', error);
19
      return callback(error);
20
    });
21
};

1
exports.handler = (context, event, callback) => {
2
  // If your use case warrants a list data structure instead of a map, you
3
  // can instantiate a Sync List. As with Maps, be sure to provide a uniqueName!
4
  Runtime.getSync()
5
    .lists.create({
6
      uniqueName: 'spaceShips',
7
    })
8
    .then((newList) => {
9
      console.log(newList);
10
      return callback(null, newList);
11
    })
12
    .catch((error) => {
13
      console.log('Sync Error: ', error);
14
      return callback(error);
15
    });
16
};

1
exports.handler = (context, event, callback) => {
2
  // Given an existing Sync List with the uniqueName of spaceShips, you can use
3
  // syncListItems.create to append a new data entry which will be accessible
4
  // to any other Function or product with access to the Sync List!
5
  Runtime.getSync()
6
    .lists('spaceShips')
7
    .syncListItems.create({
8
      data: {
9
        text: 'Millennium Falcon',
10
      },
11
    })
12
    .then((response) => {
13
      console.log(response);
14
      return callback(null, response);
15
    })
16
    .catch((error) => {
17
      console.log('Sync Error: ', error);
18
      return callback(error);
19
    });
20
};

1
exports.handler = (context, event, callback) => {
2
  // Last but not least, it's also possible to create Sync Documents.
3
  // As always, remember to provide a uniqueName to identify your Document.
4
  Runtime.getSync()
5
    .documents.create({
6
      uniqueName: 'userPreferences',
7
      data: {
8
        greeting: 'Ahoyhoy!',
9
      },
10
    })
11
    .then((newDoc) => {
12
      console.log(newDoc);
13
      return callback(null, newDoc);
14
    })
15
    .catch((error) => {
16
      console.log('Sync Error: ', error);
17
      return callback(error);
18
    });
19
};

1
exports.handler = async (context, event, callback) => {
2
  // Grab a reference to the Sync object since we'll be using it a few times
3
  const sync = Runtime.getSync();
4

5
  try {
6
    // First, lets create a brand new Sync Map
7
    const newMap = await sync.maps.create({ uniqueName: 'quicklyUpdatedMap' });
8
    console.log('newMap: ', newMap);
9

10
    // Now, let's access that map and add a new item to it.
11
    // Be sure to specify a unique key and data for the item!
12
    // Creation is an async operation, so we need to await it.
13
    const newMapItem = await sync.maps(newMap.sid).syncMapItems.create({
14
      key: 'fastestShip',
15
      data: {
16
        name: 'Millenium Falcon',
17
      },
18
    });
19

20
    // Now that we have a new item, let's log and return it.
21
    console.log('newMapItem: ', newMapItem);
22
    return callback(null, newMapItem);
23
  } catch (error) {
24
    // Be sure to log and return any errors that occur!
25
    console.error('Sync Error: ', error);
26
    return callback(error);
27
  }
28
};