@adobe/aio-lib-runtime v6.1.1

Adobe I/O Runtime Lib

Installing

npm install @adobe/aio-lib-runtime

Usage

1) Initialize the SDK

```javascript
const sdk = require('@adobe/aio-lib-runtime')

async function sdkTest() {
  //initialize sdk. Takes in OpenwhiskOptions
  const client = await sdk.init({ apihost: 'https://adobeioruntime.net', api_key: 'your_auth_key', namespace: 'your_runtime_namespace' })
}
```

2) Call methods using the initialized SDK

```javascript
const sdk = require('@adobe/aio-lib-runtime')

async function sdkTest() {
  //initialize sdk. Takes in OpenwhiskOptions
  const client = await sdk.init({ apihost: 'https://adobeioruntime.net', api_key: 'your_auth_key', namespace: 'your_runtime_namespace' })

  // call methods
  try {
    // get... something
    const result = await client.getSomething({})
    console.log(result)

  } catch (e) {
    console.error(e)
  }
}
```

Classes

Functions

Typedefs

LogForwarding

Log Forwarding management API

Kind: global class

• LogForwarding
  • .get() ⇒ Promise.<*>
  • .setAdobeIoRuntime() ⇒ Promise.<(*|undefined)>
  • .setAzureLogAnalytics(customerId, sharedKey, logType) ⇒ Promise.<(*|undefined)>
  • .setSplunkHec(host, port, index, hecToken) ⇒ Promise.<(*|undefined)>
  • .getSupportedDestinations() ⇒ Array.<object>
  • .getDestinationSettings(destination) ⇒ Array.<object>
  • .setDestination(destination, config) ⇒ Promise.<*>
  • .getErrors() ⇒ object

logForwarding.get() ⇒ Promise.<*>

Get current Log Forwarding settings

Kind: instance method of LogForwarding
Returns: Promise.<*> - response from get API

logForwarding.setAdobeIoRuntime() ⇒ Promise.<(*|undefined)>

Deprecated

Set Log Forwarding to Adobe I/O Runtime (default behavior)

Kind: instance method of LogForwarding
Returns: Promise.<(*|undefined)> - response from set API

logForwarding.setAzureLogAnalytics(customerId, sharedKey, logType) ⇒ Promise.<(*|undefined)>

Deprecated

Set Log Forwarding to Azure Log Analytics

Kind: instance method of LogForwarding
Returns: Promise.<(*|undefined)> - response from set API

logForwarding.setSplunkHec(host, port, index, hecToken) ⇒ Promise.<(*|undefined)>

Deprecated

Set Log Forwarding to Splunk HEC

Kind: instance method of LogForwarding
Returns: Promise.<(*|undefined)> - response from set API

logForwarding.getSupportedDestinations() ⇒ Array.<object>

Get supported destinations

Kind: instance method of LogForwarding
Returns: Array.<object> - in format: { value: , name: }

logForwarding.getDestinationSettings(destination) ⇒ Array.<object>

Get destination settings

Kind: instance method of LogForwarding
Returns: Array.<object> - in format: { name: , message: , type: }

logForwarding.setDestination(destination, config) ⇒ Promise.<*>

Configure destination

Kind: instance method of LogForwarding
Returns: Promise.<*> - response from set API

logForwarding.getErrors() ⇒ object

Get log forwarding errors

Kind: instance method of LogForwarding
Returns: object - Errors in format { destination: '', errors: [] }

LogForwardingLocalDestinationsProvider

Log Forwarding destination provider

Kind: global class

• LogForwardingLocalDestinationsProvider
  • .getSupportedDestinations() ⇒ Array.<object>
  • .getDestinationSettings(destination) ⇒ Array.<object>

logForwardingLocalDestinationsProvider.getSupportedDestinations() ⇒ Array.<object>

Get supported destinations

Kind: instance method of LogForwardingLocalDestinationsProvider
Returns: Array.<object> - in format: { value: , name: }

logForwardingLocalDestinationsProvider.getDestinationSettings(destination) ⇒ Array.<object>

Get destination settings

Kind: instance method of LogForwardingLocalDestinationsProvider
Returns: Array.<object> - in format: { name: , message: , type: }

RuntimeAPI

This class provides methods to call your RuntimeAPI APIs. Before calling any method initialize the instance by calling the init method on it with valid options argument

Kind: global class

runtimeAPI.init(options) ⇒ Promise.<OpenwhiskClient>

Initializes a RuntimeAPI object and returns it.

Kind: instance method of RuntimeAPI
Returns: Promise.<OpenwhiskClient> - a RuntimeAPI object

Triggers

Kind: global class

• Triggers
  • new Triggers()
  • .create(options) ⇒ Promise.<object>
  • .delete(options) ⇒ Promise.<object>

new Triggers()

A class to manage triggers

triggers.create(options) ⇒ Promise.<object>

Creates a trigger and associated feeds

Kind: instance method of Triggers
Returns: Promise.<object> - the result of the create operation

triggers.delete(options) ⇒ Promise.<object>

Deletes a trigger and associated feeds

Kind: instance method of Triggers
Returns: Promise.<object> - the result of the delete operation

getWebpackConfigPath(actionPath, root) ⇒ Promise.<string>

Searches for a webpack config file, starting at the action path and working towards the root of the project. Will return the first one it finds.

Kind: global function
Returns: Promise.<string> - Webpack config file path, will be 'null' if not found

loadWebpackConfig(configPath, actionPath, tempBuildDir, outBuildFilename) ⇒ Promise.<object>

Loads a Webpack config file from the config path provided. Sets fields required for Runtime actions. Returns an object that can be passed to the Webpack library.

Kind: global function
Returns: Promise.<object> - Webpack config, can be passed to the Webpack library

prepareToBuildAction(action, root, dist) ⇒ Promise.<ActionBuild>

Will return data about an action ready to be built.

Kind: global function
Returns: Promise.<ActionBuild> - Relevant data for the zip process..

zipActions(buildsList, lastBuildsPath, distFolder, skipCheck) ⇒ Array.<string>

Will zip actions. By default only actions which were not built before will be zipped. Last built actions data will be used to validate which action needs zipping.

Kind: global function
Returns: Array.<string> - Array of zipped actions.

deployActions(config, deployConfig, logFunc) ⇒ Promise.<object>

runs the command

Kind: global function
Returns: Promise.<object> - deployedEntities

deployWsk(scriptConfig, manifestContent, logFunc, filterEntities) ⇒ Promise.<object>

Kind: global function
Returns: Promise.<object> - deployedEntities

deployWsk~_filterOutPackageEntity(pkgName, pkgEntity, filterItems, fullNameCheck) ⇒ object

Kind: inner method of deployWsk
Returns: object - package object containing only the filterItems

init(options) ⇒ Promise.<OpenwhiskClient>

Returns a Promise that resolves with a new RuntimeAPI object.

Kind: global function
Returns: Promise.<OpenwhiskClient> - a Promise with a RuntimeAPI object

printActionLogs(config, logger, limit, filterActions, strip, tail, fetchLogsInterval, startTime) ⇒ object

Prints action logs.

Kind: global function
Returns: object - activation timestamp of the last retrieved activation or null

undeployActions(config, logFunc)

Kind: global function

undeployWsk(packageName, manifestContent, owOptions, logger) ⇒ Promise.<void>

Kind: global function
Returns: Promise.<void> - void

getIncludesForAction(action) ⇒ Promise.<Array.<IncludeEntry>>

Gets the list of files matching the patterns defined by action.include

Kind: global function
Returns: Promise.<Array.<IncludeEntry>> - list of files matching the patterns defined by action.include

printLogs(activation, strip, logger)

Prints activation logs messages.

Kind: global function

printFilteredActionLogs(runtime, logger, limit, filterActions, strip, startTime) ⇒ object

Filters and prints action logs.

Kind: global function
Returns: object - activation timestamp of the last retrieved activation or null

• printFilteredActionLogs(runtime, logger, limit, filterActions, strip, startTime) ⇒ object
  • ~isSequenceActivation(activation) ⇒ boolean
  • ~printActivationLogs(activation, runtime)
  • ~printSequenceLogs(activation, runtime)
  • ~printLogs(activation, runtime)

printFilteredActionLogs~isSequenceActivation(activation) ⇒ boolean

Check if an activation entry is for a sequence.

Kind: inner method of printFilteredActionLogs
Returns: boolean - isSequenceActivation

printFilteredActionLogs~printActivationLogs(activation, runtime)

Print activation logs

Kind: inner method of printFilteredActionLogs

printFilteredActionLogs~printSequenceLogs(activation, runtime)

Print sequence logs

Kind: inner method of printFilteredActionLogs

printFilteredActionLogs~printLogs(activation, runtime)

Print logs

Kind: inner method of printFilteredActionLogs

getActionEntryFile(pkgJsonPath) ⇒ string

returns path to main function as defined in package.json OR default of index.js note: file MUST exist, caller's responsibility, this method will throw if it does not exist

Kind: global function
Returns: string - path to the entry file

zip(filePath, out, pathInZip) ⇒ Promise

Zip a file/folder using archiver

Kind: global function
Returns: Promise - returns with a blank promise when done

createKeyValueObjectFromArray(inputsArray) ⇒ object

returns key value pairs in an object from the key value array supplied. Used to create parameters object.

Kind: global function
Returns: object - An object of key value pairs in this format : {Your key1 : 'Your Value 1' , Your key2: 'Your value 2'}

createKeyValueArrayFromObject(object) ⇒ Array

returns key value array from the object supplied.

Kind: global function
Returns: Array - An array of key value pairs in this format : {key : 'Your key 1' , value: 'Your value 1'}, {key : 'Your key 2' , value: 'Your value 2'}

safeParse(val) ⇒ object

returns JSON.parse of passed object, but handles exceptions, and numeric strings

Kind: global function
Returns: object - the parsed object

createKeyValueArrayFromFlag(flag) ⇒ Array

returns key value array from the parameters supplied. Used to create --param and --annotation key value pairs

Kind: global function
Returns: Array - An array of key value pairs in this format : {key : 'Your key 1' , value: 'Your value 1'}, {key : 'Your key 2' , value: 'Your value 2'}

createKeyValueArrayFromFile(file) ⇒ Array

returns key value array from the json file supplied. Used to create --param-file and annotation-file key value pairs

Kind: global function
Returns: Array - An array of key value pairs in this format : {key : 'Your key 1' , value: 'Your value 1'}, {key : 'Your key 2' , value: 'Your value 2'}

createKeyValueObjectFromFlag(flag) ⇒ object

returns key value pairs in an object from the parameters supplied. Used to create --param and --annotation key value pairs

Kind: global function
Returns: object - An object of key value pairs in this format : {Your key1 : 'Your Value 1' , Your key2: 'Your value 2'}

parsePackageName(name) ⇒ object

parses a package name string and returns the namespace and entity name for a package

Kind: global function
Returns: object - An object { namespace: string, name: string }

getKeyValueArrayFromMergedParameters(params, paramFilePath) ⇒ Array

returns key value array from the params and/or param-file supplied with more precendence to params.

Kind: global function
Returns: Array - An array of key value pairs in this format : {key : 'Your key 1' , value: 'Your value 1'}, {key : 'Your key 2' , value: 'Your value 2'}

getKeyValueObjectFromMergedParameters(params, paramFilePath) ⇒ object

returns key value object from the params and/or param-file supplied with more precendence to params.

Kind: global function
Returns: object - An object of key value pairs in this format : {Your key1 : 'Your Value 1' , Your key2: 'Your value 2'}

createKeyValueObjectFromFile(file) ⇒ object

returns key value pairs from the parameters supplied. Used to create --param-file and --annotation-file key value pairs

Kind: global function
Returns: object - An object of key value pairs in this format : {Your key1 : 'Your Value 1' , Your key2: 'Your value 2'}

createComponentsFromSequence(sequenceAction) ⇒ object

Creates an object representation of a sequence.

Kind: global function
Returns: object - the object representation of the sequence

createComponentsFromSequence(sequenceAction) ⇒ object

Deprecated

Kind: global function
Returns: object - the object representation of the sequence

returnUnion(firstObject, secondObject) ⇒ object

Creates a union of two objects

Kind: global function
Returns: object - the union of both objects

parsePathPattern(path) ⇒ Array

Parse a path pattern

Kind: global function
Returns: Array - array of matches

processInputs(input, params) ⇒ object

Process inputs

Kind: global function
Returns: object - the processed inputs

createKeyValueInput(input) ⇒ object

Create a key-value object from the input

Kind: global function
Returns: object - the processed input as a key-value object

getDeploymentPath() ⇒ string

Get the deployment yaml file path

Kind: global function
Returns: string - the deployment yaml path

getManifestPath() ⇒ string

Get the manifest yaml file path

Kind: global function
Returns: string - the manifest yaml path

returnDeploymentTriggerInputs(deploymentPackages) ⇒ object

Get the deployment trigger inputs.

Kind: global function
Returns: object - the deployment trigger inputs

returnAnnotations(action) ⇒ object

Get the annotations for an action

Kind: global function
Returns: object - the action annotation entities

createApiRoutes(pkg, pkgName, apiName, allowedActions, allowedSequences, pathOnly) ⇒ Array.<OpenWhiskEntitiesRoute>

Creates an array of route definitions from the given manifest-based package. See https://github.com/apache/openwhisk-wskdeploy/blob/master/parsers/manifest_parser.go#L1187

Kind: global function
Returns: Array.<OpenWhiskEntitiesRoute> - the array of route entities

createSequenceObject(fullName, manifestSequence, packageName) ⇒ OpenWhiskEntitiesAction

Create a sequence object that is compatible with the OpenWhisk API from a parsed manifest object

Kind: global function
Returns: OpenWhiskEntitiesAction - a sequence object describing the action entity

checkWebFlags(flag) ⇒ object

Check the web flags

Kind: global function
Returns: object - object with the appropriate web flags for an action

createActionObject(fullName, manifestAction) ⇒ OpenWhiskEntitiesAction

Create an action object compatible with the OpenWhisk API from an action object parsed from the manifest.

Kind: global function
Returns: OpenWhiskEntitiesAction - the action entity object

processPackage(packages, deploymentPackages, deploymentTriggers, params, namesOnly, owOptions) ⇒ OpenWhiskEntities

Process the manifest and deployment content and returns deployment entities.

Kind: global function
Returns: OpenWhiskEntities - deployment entities

setPaths(flags) ⇒ DeploymentFileComponents

Get the deployment file components.

Kind: global function
Returns: DeploymentFileComponents - fileComponents

deployPackage(entities, ow, logger, imsOrgId)

Deploy all processed entities: can deploy packages, actions, triggers, rules and apis.

Kind: global function

undeployPackage(entities, ow, logger)

Undeploy all processed entities: can undeploy packages, actions, triggers, rules and apis. Entity definitions do not need to be complete, only the names are needed for un-deployment.

Kind: global function

syncProject(projectName, manifestPath, manifestContent, entities, ow, logger, imsOrgId, deleteEntities)

Sync a project. This is a higher level function that can be used to sync a local manifest with deployed entities.

syncProject doesn't only deploy entities it might also undeploy entities that are not defined in the manifest. This behavior can be disabled via the deleteEntities boolean parameter.

Kind: global function

getProjectEntities(project, isProjectHash, ow) ⇒ Promise.<OpenWhiskEntities>

Get deployed entities for a managed project. This methods retrieves all the deployed entities for a given project name or project hash. This only works if the project was deployed using the whisk-managed annotation. This annotation can be set pre-deployement using [addManagedProjectAnnotations](#addmanagedprojectannotations).

Note that returned apis will always be empty as they don't support annotations and hence are not managed as part of a project.

Kind: global function
Returns: Promise.<OpenWhiskEntities> - the deployed project entities

addManagedProjectAnnotations(entities, manifestPath, projectName, projectHash)

Add the whisk-managed annotation to processed entities. This is needed for syncing managed projects.

Kind: global function

getProjectHash(manifestContent) ⇒ string

Compute the project hash based on the manifest content string. This is used for syncing managed projects.

Kind: global function
Returns: string - the project hash

findProjectHashOnServer(ow, projectName) ⇒ Promise.<string>

Retrieve the project hash from a deployed managed project.

Kind: global function
Returns: Promise.<string> - the project hash, or '' if not found

findProjectHashOnServer(ow, projectName) ⇒ Promise.<string>

Deprecated

Retrieve the project hash from a deployed managed project.

Kind: global function
Returns: Promise.<string> - the project hash, or '' if not found

_relApp(root, p) ⇒ string

Path relative to the root

Kind: global function
Returns: string - relative path

_absApp(root, p) ⇒ string

Absolute path

Kind: global function
Returns: string - absolute path

checkOpenWhiskCredentials(config)

Checks the existence of required openwhisk credentials

Kind: global function

getActionUrls(appConfig, isRemoteDev, isLocalDev, legacy) ⇒ object

Returns action URLs based on the manifest config

Kind: global function
Returns: object - urls of actions

urlJoin(...args) ⇒ string

Joins url path parts

Kind: global function
Returns: string - joined url

removeProtocolFromURL(url) ⇒ string

Kind: global function
Returns: string - url

replacePackagePlaceHolder(config) ⇒ object

Kind: global function
Returns: object - sanitized config

validateActionRuntime(action)

Deprecated

Checks the validity of nodejs version in action definition and throws an error if invalid.

Kind: global function

isSupportedActionKind(action) ⇒ boolean

Checks the validity of nodejs version in action definition returns true if valid.

Kind: global function
Returns: boolean - true if action kind is supported

getActionZipFileName(pkgName, actionName, defaultPkg) ⇒ string

Returns the action's build file name without the .zip extension

Kind: global function
Returns: string - name of zip file for the action contents

getActionNameFromZipFile(zipFile) ⇒ string

Returns the action name based on the zipFile name.

Kind: global function
Returns: string - name of the action or empty string.

activationLogBanner(logFunc, activation, activationLogs)

Creates an info banner for an activation.

Kind: global function

actionBuiltBefore(lastBuildsData, buildData) ⇒ boolean

Will tell if the action was built before based on it's contentHash.

Kind: global function
Returns: boolean - true if the action was built before

dumpActionsBuiltInfo(lastBuiltActionsPath, actionBuildData, prevBuildData) ⇒ Promise.<boolean>

Will dump the previously actions built data information.

Kind: global function
Returns: Promise.<boolean> - If the contentHash already belongs to the deploymentLogs file

getSupportedServerRuntimes(apihost) ⇒ Array.<string>

Gets a list of the supported runtime kinds from the apihost.

Kind: global function
Returns: Array.<string> - a list of runtime kinds supported by the runtime apihost

ActionBuild : object

Kind: global typedef
Properties

</