Serverless Platform SDK
This Serverless Platform SDK makes it easy to interact with the Serverless Platform and perform operations on it. Please note that there is an existing @serverless/platform-sdk
npm module for interacting with the Serverless Inc. SaaS original platform services. This SDK is for the new services, which are multi-cloud, self-hostable and focued on Components. At some point, we will try to merge these SDKs.
The SDK is light-weight, so that it can be used in the following: CLIs, Dashboards, Back-End Services, FaaS Layers. Please DO NOT add any big Node.js dependencies to this SDK.
This SDK should guide the interface design between Services and Clients. All Clients and Services MUST use the SDK and should never hardcode API endpoints or FaaS resources identifiers.
Quick-Start
If you are working within a Node.js environment, install the Serverless Platform Client SDK via NPM:
npm i @serverless/platform-client
If you are working within a web/browser environment, use the CDN hosted Serverless Platform Client SDK:
This is minified, tree-shaked, browserified. The CDN fetches it directly from NPM, so just reference any npm version, like below.
This CDN service has several locations in China, so it works well there.
// In index.html <head></head>
<!-- Load the Serverless Platform (Components) SDK -->
<script src="https://cdn.jsdelivr.net/npm/@serverless/platform-client@0.17.2" async></script>
You can also pin to the latest version, but this could break at any time:
// In index.html <head></head>
<!-- Load the Serverless Platform (Components) SDK -->
<script src="https://cdn.jsdelivr.net/npm/@serverless/platform-client" async></script>
If you are working with the dev
environment of the Serverless Platform, set the following environment variable, or configure the client programmatically, as detailed below.
export SERVERLESS_PLATFORM_STAGE=dev
Here is how you require, instantiate the Client and use it:
const { ServerlessSDK } = require('@serverless/platform-client');
sdk = new ServerlessSDK({
platformStage: 'dev',
accessKey: 'JA98JAJFASLFJSALFJASLFJ',
});
const instances = await sdk.listInstances('my-org');
Classes
- ServerlessSDK
The Serverless Platform SDK Class
Typedefs
- onEvent :
function
onEvent
callback
- onDisconnect :
function
onDisconnect
callback
ServerlessSDK
The Serverless Platform SDK Class
Kind: global class
- ServerlessSDK
- new ServerlessSDK()
- .session :
object
- .events :
object
- .webhooks :
object
- .accessKeys :
object
- .connections :
object
- .create(orgUid, providerUid, accountAlias) ⇒
Promise.<object>
- .list(orgUid) ⇒
Promise.<object>
- .get(orgUid, connectionUid) ⇒
Promise.<object>
- .getByOrgAndAccountAlias(orgUid, accountAlias) ⇒
Promise.<object>
- .update(orgUid, connectionUid, providerUid, accountAlias, status) ⇒
Promise.<object>
- .remove(orgUid, connectionUid) ⇒
Promise.<object>
- .syncAll(orgUid) ⇒
Promise.<object>
- .unsync(orgUid, connectionUid) ⇒
Promise.<object>
- .config() ⇒
null
- .getDomain(serviceName) ⇒
string
- .getUser() ⇒
object
- .getUserMeta() ⇒
object
- .saveUserMeta(userMeta) ⇒
object
- .validateUserAndOrgName(userAndOrgName) ⇒
array
- .createUserAndOrg(userAndOrgName) ⇒
object
- .createOrg(userAndOrgName) ⇒
object
- .getOrgByName(orgName) ⇒
object
- .listOrgs(username) ⇒
object
- .createApp(orgName) ⇒
object
- .updateApp(orgName) ⇒
object
- .deleteApp(orgName, appName)
- .listApps(orgName)
- .createInitToken(orgName)
- .getInitToken(initTokenUid)
- .createProvider(orgUid, data)
- .updateProvider(orgUid, providerUid, data)
- .deleteProvider(orgUid, providerUid)
- .createProviderLink(orgUid, linkType, linkUid, providerUid)
- .deleteProviderLink(orgUid, linkType, linkUid, providerUid)
- .getProviders(orgUid)
- .getProvider(orgUid, providerUid)
- .getProvidersByOrgServiceInstance(orgUid, serviceUid, instanceUid)
- .getProvidersByLink(orgUid, linkType, linkUid)
- .getAllowedProviders()
- .createParam(orgUid, linkType, linkUid, data)
- .deleteParam(orgUid, linkType, linkUid, paramUid)
- .updateParam(orgUid, linkType, linkUid, paramUid, data)
- .getParams(orgUid, linkType, linkUid)
- .getParamsByOrgServiceInstance(orgUid, serviceUid, instanceUid)
- .getParamsAndProvidersByOrgServiceInstance(orgUid, serviceUid, instanceUid)
- .connect([options]) ⇒
null
- .disconnect() ⇒
null
- .isConnected() ⇒
boolean
- .unpublishFromRegistry(registryPackage)
- .publishToRegistry(registryPackage) ⇒
object
- .getFromRegistry(name, version) ⇒
object
- .generateInstanceId(orgUid, stageName, appUid, instanceName) ⇒
object
- .validateInstance(instanceToValidate) ⇒
object
- .createInstance(orgName, stageName, appName, instanceName, instanceStatus) ⇒
object
- .saveInstance(instanceRecord)
- .getInstance(orgName, stageName, appName, instanceName)
- .listInstances(orgName, orgUid)
- .run(action, instanceData, credentials, options)
- .runFinish(method, instanceData)
- .deploy()
- .remove()
- .startInterceptingLogs(eventType, context)
- .stopInterceptingLogs()
new ServerlessSDK()
Creates an instance of the SDK. Accepts a configuration object and calls the config()
method. See the config()
method for more information on allowed configuration.
Param | Type | Description |
---|
[config.accessKey] | string | Can either be a Serverless Platform Access Key or an ID Token. |
[config.platformStage] | string | The Serverless Platform Stage you wish to interact with. This can also be set by the environment variable SERVERLESS_PLATFORM_STAGE= |
[context.orgName] | string | The name of the Serverless Platform Organization you wish to interact with. If set, this value is used upon creating a Websockets connection, and auto-added to every Event you publish. |
[context.orgUid] | string | The ID of the Serverless Platform Organization you wish to interact with. If set, this value is used upon creating a Websockets connection, and auto-added to every Event you publish. |
[context.stageName] | string | The Serverless Platform Organization Stage you wish to interact with. If set, this value is auto-added to every Event you publish. |
[context.appName] | string | The Serverless Platform Application you wish to interact with. If set, this value is auto-added to every Event you publish. |
[context.instanceName] | string | The Serverless Platform Instance you wish to interact with. If set, this value is auto-added to every Event you publish. |
[context.componentName] | string | The Serverless Platform Component you wish to interact with. If set, this value is auto-added to every Event you publish. |
[context.componentVersion] | string | The Serverless Platform Component version you wish to interact with. If set, this value is auto-added to every Event you publish. |
Example
const { ServerlessSDK } = require('@serverless/platform-client');
const sdk = new ServerlessSDK({
accessKey: '123456789',
context: {
orgName: 'my-org',
orgUid: '1234',
stageName: 'prod',
appName: 'my-app',
instanceName: 'my-instance',
},
});
serverlessSDK.session : object
Methods to create, update, delete User Sessions on the Serverless Platform
Kind: instance namespace of ServerlessSDK
session.refreshToken(refreshToken) ⇒ Promise.<object>
Uses a Refresh Token to generate a new ID Token for a User within a specific Serverless Organization.
Kind: static method of session
Param | Type | Description |
---|
refreshToken | string | The refresh token used to create a new ID Token. |
Example
const tokenData = await sdk.session.refreshToken(refreshToken);
serverlessSDK.events : object
Publish and retrieve Serverless Platform Events
Kind: instance namespace of ServerlessSDK
events.publish(event) ⇒ Promise.<null>
Publishes Serverless Platform Event(s) via HTTP API. The use-case for this is synchronous publishing, where you do not want to open a websockets connection.
Kind: static method of events
Returns: Promise.<null>
- A successful publish request will be ack'ed with a 200:OK
HTTP status and empty response.
Param | Type | Description |
---|
event | Object | Array.<Object> | An event object, or if publishing a batch of events, an array of event objects. |
event.event | string | Event type. Serverless Platform system events are required to follow a <entity>[.<sub-entity>].<action> naming convention (e.g. user.created , org.membership.updated , etc). |
event.data | Object | Event metadata. Serverless Platform system events are required to be formatted as described in the example below. |
Example (user event)
sdk.config({ context: { orgUid: '3xVy2MWGFqpGYSlRMd' } });
await sdk.events.publish({
event: 'user.created',
data: {
id: 'user-123',
username: 'testuser',
},
});
Example (system event)
await sdk.events.publish({
event: 'entity.updated',
user_uid: 'user-111',
org_uid: 'org-42',
org_name: 'serverless',
app_name: 'app-222',
instance_name: 'instance-333',
stage_name: 'us-east-1',
component_name: 'component-444',
component_version: '1.2.3',
data: {
object: {
object: 'name',
},
previous_attributes: {
},
},
});
events.get(uid) ⇒ Promise.<Object>
Retrieve a Serverless Platform Event.
Kind: static method of events
Returns: Promise.<Object>
- An event object if a valid id was provided.
Param | Type | Description |
---|
uid | string | UID of event to be fetched. |
Example
const event = await sdk.events.get('evt_EsbM82sYTVscqYvcD4CKcLe1');
console.log(JSON.stringify(event, null, 2));
events.list([options]) ⇒ Promise.<Object>
List all Serverless Platform events.
Kind: static method of events
Returns: Promise.<Object>
- A dictionary with a data
property that contains an array of up to limit
events, starting after event starting_after
. Each entry in the array is a separate event
Object. If no more events are available, the resulting array will be empty.
Param | Type | Description |
---|
[options] | Object | List options |
options.org_uid | string | UID of the Serverless Platform Organization. Optional - defaults to inheriting from current SDK context. |
options.org_name | string | Name of the Serverless Platform Organization. Optional - defaults to inheriting from current SDK context. |
options.event | string | A string containing a specific event name, or all events by using '*' as a wildcard. |
options.limit | number | A limit on the number of events to be returned. Limit can range between 1 and 100, and the default is 10. |
options.created | number | A filter on the list based on the object created field. The value can be an integer Unix timestamp, or it can be a dictionary with the following options: - created.gt , created.gte , created.lt , created.lte returning results where the event created field is greater, greater than or equal to, lesser than, or lesser than or equal to respectively. |
options.starting_after | string | A cursor for use in pagination. starting_after is an event ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with evt_foo , your subsequent call can include starting_after=evt_foo in order to fetch the next page of the list. |
Example
const events = await sdk.events.list({
event: 'member.invite.accepted',
created: {
gte: 1600686488878,
},
limit: 1,
});
console.log(JSON.stringify(events, null, 2));
events.send(event) ⇒ Promise.<null>
Deprecated
Dispatches a Serverless Platform Event via Websockets. The use-case for this is asynchronous publishing, where you do not want to synchronous auth requests, where every message must be authorized first, adding latency.
Kind: static method of events
Returns: Promise.<null>
- A successful publish request will be ack'ed with a 200: OK
HTTP status and empty response.
See: publish
Param | Type | Description |
---|
event | Object | Array.<Object> | An event object, or if publishing a batch of events, an array of event objects. |
event.event | string | Event type. Serverless Platform system events are required to follow a <entity>[.<sub-entity>].<action> naming convention (e.g. user.created , org.membership.updated , etc). |
event.data | Object | Event metadata. Serverless Platform system events are required to be formatted as described in the example below. |
serverlessSDK.webhooks : object
Register, modify and query Serverless Platform Event Webhooks
Kind: instance namespace of ServerlessSDK
webhooks.register(url, [options]) ⇒ Promise.<object>
Registers a webhook endpoint to receive Serverless Platform events.
Endpoint should be able to receieve JSON formatted events as a HTTP POST payload.
Furthermore, a 3
second timeout limit is enforced on event delivery with no additional retries performed.
The following HTTP headers are set on the POST request:
Header | Value |
---|
Content-type | application/json |
X-Serverless-Event | Event type |
X-Serverless-Delivery | Unique delivery ID |
User-Agent | Prefix of Serverless-Webhook/ |
Kind: static method of webhooks
Returns: Promise.<object>
- Registered webhook endpoint.
Param | Type | Description |
---|
url | string | HTTP webhook endpoint URL. |
[options] | Object | Registration options. |
options.description | string | An optional description of what the webhook is used for. |
options.org_uid | string | UID of the Serverless Platform Organization. Optional - defaults to inheriting from current SDK context. If registering a Serverless Platform system webhook, use a special wildcard value of '*' to consume events generated from all orgs. |
options.org_name | string | Name of the Serverless Platform Organization. Optional - defaults to inheriting from current SDK context. |
options.filter | Object | Optionally, filter which events this endpoint should receive. |
options.filter.enabled_events | Array.<string> | The list of events to enable for this endpoint. ["*"] indicates that all events are enabled. |
Example
const webhook = await sdk.webhooks.register('https://postb.in/1598300732037-0682672155089', {
description: 'This is my webhook, I like it a lot',
});
console.log(JSON.stringify(webhook, null, 2));
webhooks.list([options]) ⇒ Promise.<object>
Lists all regsitered webhook endpoints.
Kind: static method of webhooks
Returns: Promise.<object>
- A dictionary with a data
property that contains an array, with each entry being a webhook
object.
Param | Type | Description |
---|
[options] | Object | List options. |
options.starting_after | string | A cursor for use in pagination. starting_after is a webhook endpoint object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with whe_foo , your subsequent call can include starting_after=whe_foo in order to fetch the next page of the list. |
options.limit | number | A limit on the number of webhook endpoints to be returned. Limit can range between 1 and 100, and the default is 10. |
Example
const webhooks = await sdk.webhooks.list({
limit: 1,
});
console.log(JSON.stringify(webhooks, null, 2));
webhooks.get(uid) ⇒ Promise.<object>
Retrieves a webhook endpoint with the given ID.
Kind: static method of webhooks
Returns: Promise.<object>
- A webhook endpoint if a valid webhook endpoint ID was provided.
Param | Type | Description |
---|
uid | string | Webhook endpoint ID. |
Example
const webhook = await sdk.webhooks.get('whe_FPYDtTL37ye13m3sJvtcdyuF');
console.log(JSON.stringify(webhook, null, 2));
webhooks.update(uid) ⇒ Promise.<object>
Updates the registered webhook endpoint. You may edit the url, description, the list of filters, and the status of your endpoint.
Kind: static method of webhooks
Returns: Promise.<object>
- Updated webhook endpoint.
Param | Type | Description |
---|
uid | string | Webhook endpoint ID. |
updates.url | string | HTTP webhook endpoint url, if updating. |
updates.description | string | An optional updated description of what the webhook is used for. |
updates.filter | Object | Optionally, update filter which events this endpoint should receive. An existing filter can reset by setting it to null . |
updates.filter.enabled_events | Array.<string> | The list of events to enable for this endpoint. ["*"] indicates that all events are enabled. |
updates.status.disabled | boolean | Enable/disable the webhook endpoint. |
Example
const webhook = await sdk.webhooks.update('whe_FPYDtTL37ye13m3sJvtcdyuF', {
url: 'http://437f01fa092e.ngrok.io',
filter: {
enabled_events: ['user.created', 'member.invite.sent'],
},
});
console.log(JSON.stringify(webhook, null, 2));
webhooks.delete(uid) ⇒ Promise.<object>
Deletes the webhook endpoint with the given ID.
Kind: static method of webhooks
Returns: Promise.<object>
- An object with the deleted webhook endpoints’s ID if a valid webhook endpoint ID was provided. Otherwise, this call throws an error, such as if the webhook endpoint has already been deleted.
Param | Type | Description |
---|
uid | string | Webhook endpoint ID. |
Example
const webhook = await sdk.webhooks.delete('whe_FPYDtTL37ye13m3sJvtcdyuF');
console.log(JSON.stringify(webhook, null, 2));
serverlessSDK.accessKeys : object
Create, get and delete Serverless Platform Access Keys for an Organization
Kind: instance namespace of ServerlessSDK
accessKeys.create(orgName, userName, accessKeyName) ⇒ Promise.<object>
Creates a new Access Key for a User within a Serverless Organization.
Kind: static method of accessKeys
Param | Type | Description |
---|
orgName | string | The name of the Serverless Organization to create the Access Key for |
userName | string | The name of the User within the Serverless Organization to create the Access Key for |
accessKeyName | string | The name of the Access Key you would like to create |
Example
const accessKey = await sdk.accessKeys.create(orgName, accessKeyName);
accessKeys.list(orgName) ⇒ Promise.<object>
Lists all Access Keys within a Serverless Organization.
Kind: static method of accessKeys
Param | Type | Description |
---|
orgName | string | The name of the Serverless Organization to list Access Keys |
Example
const accessKeys = await sdk.accessKeys.list(orgName);
accessKeys.remove(orgName, uid) ⇒ Promise.<object>
Delete an Access Key from a Serverless Organization.
Kind: static method of accessKeys
Param | Type | Description |
---|
orgName | string | The name of the Serverless Organization that the Access Key belongs to |
uid | string | The UID of the of the Access Key |
Example
const accessKeys = await sdk.accessKeys.remove(orgName, uid);
serverlessSDK.connections : object
Create, manage and sync Serverless Platform Connections between vendor accounts and their Serverless Organization.
Kind: instance namespace of ServerlessSDK
- .connections :
object
- .create(orgUid, providerUid, accountAlias) ⇒
Promise.<object>
- .list(orgUid) ⇒
Promise.<object>
- .get(orgUid, connectionUid) ⇒
Promise.<object>
- .getByOrgAndAccountAlias(orgUid, accountAlias) ⇒
Promise.<object>
- .update(orgUid, connectionUid, providerUid, accountAlias, status) ⇒
Promise.<object>
- .remove(orgUid, connectionUid) ⇒
Promise.<object>
- .syncAll(orgUid) ⇒
Promise.<object>
- .unsync(orgUid, connectionUid) ⇒
Promise.<object>
connections.create(orgUid, providerUid, accountAlias) ⇒ Promise.<object>
Creates a new Connection between a vendor account and a Serverless Organization.
Kind: static method of connections
Param | Type | Description |
---|
orgUid | string | The UID of the Serverless Organization to create a Connection in. |
providerUid | string | The UID of an existing Serverless Provider tied to a vendor account within the Organization to use for this Connection. A vendor account (e.g. an AWS account) can only be registered once with a Connection, across all Serverless Organizations. They are globally unique. |
accountAlias | string | An alias or nickname of the vendor account used to conveniently identify which account this Connection is used with. This must be unique within the Serverless Organization. |
connections.list(orgUid) ⇒ Promise.<object>
List all Connections within the Serverless Organization.
Kind: static method of connections
Param | Type | Description |
---|
orgUid | string | The UID of the Serverless Organization to create a Connection in. |
connections.get(orgUid, connectionUid) ⇒ Promise.<object>
Get a single Connection within the Serverless Organization.
Kind: static method of connections
Param | Type | Description |
---|
orgUid | string | The UID of the Serverless Organization to get a Connection in. |
connectionUid | string | The UID of the Connection to get within the Serverless Organization. |
connections.getByOrgAndAccountAlias(orgUid, accountAlias) ⇒ Promise.<object>
Get a single Connection by Organization UID and vendor account alias within the Serverless Organization.
Kind: static method of connections
Param | Type | Description |
---|
orgUid | string | The UID of the Serverless Organization to get a Connection in. |
accountAlias | string | The alias of the Connection to get within the Serverless Organization. |
connections.update(orgUid, connectionUid, providerUid, accountAlias, status) ⇒ Promise.<object>
Update a single Connection within the Serverless Organization.
Kind: static method of connections
Param | Type | Description |
---|
orgUid | string | The UID of the Serverless Organization to update a Connection in. |
connectionUid | string | The UID of the Connection to update within the Serverless Organization. |
providerUid | string | The updated Provider UID within the Connection. |
accountAlias | string | The updated alias of the Connection. |
status | string | The updated status of the Connection. |
connections.remove(orgUid, connectionUid) ⇒ Promise.<object>
Remove a single Connection within the Serverless Organization.
Kind: static method of connections
Param | Type | Description |
---|
orgUid | string | The UID of the Serverless Organization to remove a Connection in. |
connectionUid | string | The UID of the Connection to remove within the Serverless Organization. |
connections.syncAll(orgUid) ⇒ Promise.<object>
Run a sync operation across all Connections within the Serverless Organization. This only runs sync on Connections with an "inactive", "synced", "unsynced", "error" state. Call connections.list()
to view status of all Connections.
Kind: static method of connections
Param | Type | Description |
---|
orgUid | string | The UID of the Serverless Organization to sync all Connections in. |
connections.unsync(orgUid, connectionUid) ⇒ Promise.<object>
Run an unsync operation on a specific Connection within the Serverless Organization. This only runs sync on Connections with an "synced", "error" state. Call connections.list()
to view status of all Connections.
Kind: static method of connections
Param | Type | Description |
---|
orgUid | string | The UID of the Serverless Organization to sync all Connections in. |
connectionUid | string | The UID of the Connection to unsync within the Serverless Organization. |
serverlessSDK.config() ⇒ null
Updates the SDK configuration
Kind: instance method of ServerlessSDK
Param | Type | Description |
---|
[config.accessKey] | string | Can either be a Serverless Platform Access Key or an ID Token. |
[config.platformStage] | string | The Serverless Platform Stage you wish to interact with. This can also be set by the environment variable SERVERLESS_PLATFORM_STAGE= |
[context.orgName] | string | The name of the Serverless Platform Organization you wish to interact with. If set, this value is used upon creating a Websockets connection, and auto-added to every Event you publish. |
[context.orgUid] | string | The ID of the Serverless Platform Organization you wish to interact with. If set, this value is used upon creating a Websockets connection, and auto-added to every Event you publish. |
[context.stageName] | string | The Serverless Platform Organization Stage you wish to interact with. If set, this value is auto-added to every Event you publish. |
[context.appName] | string | The Serverless Platform Application you wish to interact with. If set, this value is auto-added to every Event you publish. |
[context.instanceName] | string | The Serverless Platform Instance you wish to interact with. If set, this value is auto-added to every Event you publish. |
[context.componentName] | string | The Serverless Platform Component you wish to interact with. If set, this value is auto-added to every Event you publish. |
[context.componentVersion] | string | The Serverless Platform Component version you wish to interact with. If set, this value is auto-added to every Event you publish. |
Example
const { ServerlessSDK } = require('@serverless/platform-client');
const sdk = new ServerlessSDK();
sdk.config({
accessKey: '123456789',
context: {
orgName: 'my-org',
orgUid: '1234',
stageName: 'prod',
appName: 'my-app',
instanceName: 'my-instance',
},
});
serverlessSDK.getDomain(serviceName) ⇒ string
Gets a domain for a specific service: 'engine', 'registry', 'events-streaming'
Kind: instance method of ServerlessSDK
Returns: string
- The domain of that service.
Param | Type | Default | Description |
---|
serviceName | string | null | The name of the Serverless Platform Service you want the domain for. |
serverlessSDK.getUser() ⇒ object
Get User account
Kind: instance method of ServerlessSDK
Returns: object
- Returns a user record.
serverlessSDK.getUserMeta() ⇒ object
Get User account meta information.
Kind: instance method of ServerlessSDK
Returns: object
- Returns a data object of custom "meta" information.
serverlessSDK.saveUserMeta(userMeta) ⇒ object
Updates User account meta information. This method fetches meta information and merges it with the meta object you provide before saving. Please note that this does a shallow merge and not a deep merge. That means nested properties might be replaced.
Kind: instance method of ServerlessSDK
Returns: object
- Returns a data object of User data.
Param | Type | Description |
---|
userMeta | object | An object of new userMeta that will be automaticaly merged with the old user meta. |
serverlessSDK.validateUserAndOrgName(userAndOrgName) ⇒ array
Validates whether a potential User and Organization name meets the Platform requirements. Most importantly, this calls the Platform to validate whether the User and Organization names are already taken. This method is necessary because every User must have an Organization and we want to be sure both namespaces are availbale, before creating one or the other. In the future, both of these records should be created in the back-end, not on the client-side. Until then, this method is essential.
Kind: instance method of ServerlessSDK
Returns: array
- Returns an array of validation errors, if any. Otherwise, returns null.
Param | Type | Description |
---|
userAndOrgName | string | The name of the User and Org name. |
serverlessSDK.createUserAndOrg(userAndOrgName) ⇒ object
In the Serverless Platform, every User must have an Organization by default. This method creates both a User and an Organization record, at the same time. Please note, the endpoint called is specific to Tenants (Organizations), which also has User creation logic within it. This API design is non-sensible and we should consider a better API design ASAP. Until then, this method abstracts over that.
Kind: instance method of ServerlessSDK
Returns: object
- Returns the newly create Organization.
Param | Type | Description |
---|
userAndOrgName | string | The name of the User and Org name. |
serverlessSDK.createOrg(userAndOrgName) ⇒ object
Creates an Organization.
Kind: instance method of ServerlessSDK
Returns: object
- Returns the newly create Organization.
Param | Type | Description |
---|
userAndOrgName | string | The name of the Organization you wish to create. WARNING: This also creates a User record if one does not exist under this Organization name. This API design needs improvement. |
serverlessSDK.getOrgByName(orgName) ⇒ object
Gets an Organization by Organization name.
Kind: instance method of ServerlessSDK
Returns: object
- Returns the Organization record.
Param | Type | Description |
---|
orgName | string | The name of the Organization you wish to retrieve. |
serverlessSDK.listOrgs(username) ⇒ object
Lists Organizations by User, whether the User is an Owner or a Member of a given Organization.
Kind: instance method of ServerlessSDK
Returns: object
- Returns an array of Organizations
Param | Type | Description |
---|
username | string | The name of the User whose Organizations you wish to list. |
serverlessSDK.createApp(orgName) ⇒ object
Create an Application within an Organization
Kind: instance method of ServerlessSDK
Returns: object
- Returns a data object of the newly created Application
Param | Type | Default | Description |
---|
orgName | string | null | The name of the Organization you wish to create an Application in. |
app.name | string | | The name of the Application. |
app.description | string | | The description of the Application. |
app.deploymentProfiles | object | | An object of deployment profiles and stages. This structure is a bit confusing. Look at the back-end service for more details and hopefully we can design this more elegantly in the future. |
serverlessSDK.updateApp(orgName) ⇒ object
Update an Application within an Organization
Kind: instance method of ServerlessSDK
Returns: object
- Returns a data object of the updated Application
Param | Type | Default | Description |
---|
orgName | string | null | The name of the Organization the Application belongs to. |
app.name | string | | The name of the Application you wish to update. This property cannot be updated due to current data modeling issues. |
app.description | string | | The description of the Application. This property can be updated. |
app.deploymentProfiles | object | | An object of deployment profiles and stages. This property can be updated. This structure is a bit confusing. Look at the back-end service for more details and hopefully we can design this more elegantly in the future. |
serverlessSDK.deleteApp(orgName, appName)
Delete an Application within an Organization
Kind: instance method of ServerlessSDK
Param | Type | Default | Description |
---|
orgName | string | null | The name of the Organization the Application belongs to. |
appName | string | null | The name of the Application you wish to delete. |
serverlessSDK.listApps(orgName)
List all Applications within an Organization
Kind: instance method of ServerlessSDK
Param | Type | Default | Description |
---|
orgName | string | null | The name of the Organization the Application belongs to. |
serverlessSDK.createInitToken(orgName)
Create an initToken for a user and organization
Kind: instance method of ServerlessSDK
Param | Type | Default | Description |
---|
orgName | string | null | The name of the Organization the Init Token belongs to. |
template.type | string | | Must be either s3, github, or existing. |
template.commands | Array.<string> | | Array of commands executed by the user's shell env in order to fetch and set up the template |
serverlessSDK.getInitToken(initTokenUid)
Get an initToken by UID
Kind: instance method of ServerlessSDK
Param | Type | Description |
---|
initTokenUid | string | Unique identifier of an initToken |
serverlessSDK.createProvider(orgUid, data)
Create a provider
Kind: instance method of ServerlessSDK
serverlessSDK.updateProvider(orgUid, providerUid, data)
Update a provider
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
providerUid | * |
data | * |
serverlessSDK.deleteProvider(orgUid, providerUid)
Delete a provider
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
providerUid | * |
serverlessSDK.createProviderLink(orgUid, linkType, linkUid, providerUid)
Create a providerLink
Link type can be either service
or instance
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
linkType | * |
linkUid | * |
providerUid | * |
serverlessSDK.deleteProviderLink(orgUid, linkType, linkUid, providerUid)
Delete a providerLink
Link type can be either service
or instance
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
linkType | * |
linkUid | * |
providerUid | * |
serverlessSDK.getProviders(orgUid)
List providers by OrgUid
Kind: instance method of ServerlessSDK
serverlessSDK.getProvider(orgUid, providerUid)
Get a Provider
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
providerUid | * |
serverlessSDK.getProvidersByOrgServiceInstance(orgUid, serviceUid, instanceUid)
Get providers by org, service, and instance
Configuration set at the instance level will override
defaults set at the service level
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
serviceUid | * |
instanceUid | * |
serverlessSDK.getProvidersByLink(orgUid, linkType, linkUid)
List providers by Link
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
linkType | * |
linkUid | * |
serverlessSDK.getAllowedProviders()
Returns the list of supported providers
Kind: instance method of ServerlessSDK
serverlessSDK.createParam(orgUid, linkType, linkUid, data)
Create a param and link it to a service or an instance
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
linkType | * |
linkUid | * |
data | * |
serverlessSDK.deleteParam(orgUid, linkType, linkUid, paramUid)
Destroy a param
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
linkType | * |
linkUid | * |
paramUid | * |
serverlessSDK.updateParam(orgUid, linkType, linkUid, paramUid, data)
Update a param
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
linkType | * |
linkUid | * |
paramUid | * |
data | * |
serverlessSDK.getParams(orgUid, linkType, linkUid)
List params by service or instance
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
linkType | * |
linkUid | * |
serverlessSDK.getParamsByOrgServiceInstance(orgUid, serviceUid, instanceUid)
List params by org, service, and instance
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
serviceUid | * |
instanceUid | * |
serverlessSDK.getParamsAndProvidersByOrgServiceInstance(orgUid, serviceUid, instanceUid)
List parameters and providers by org, service, and instance
Kind: instance method of ServerlessSDK
Param | Type |
---|
orgUid | * |
serviceUid | * |
instanceUid | * |
serverlessSDK.connect([options]) ⇒ null
Establishes a websockets connection with the Serverless Platform
Kind: instance method of ServerlessSDK
Param | Type | Default | Description |
---|
[options] | Object | {} | Connection options. |
[options.orgName] | string | | Name of the Serverless Platform Org. If not specified, inherits from SDK context. |
[options.orgUid] | string | | ID of the Serverless Platform Org. If not specified, inherits from SDK context. |
[options.onEvent] | onEvent | | A function that handles events recieved from the Serverless Platform. |
[options.onDisconnect] | onDisconnect | | Register a disconnect callback. Invoked with |
[options.filter] | Object | | Filters which events this connection should receive. |
[options.filter.stageName] | string | | Tells the SDK to only receive events on a specific stage. |
[options.filter.appName] | string | | Tells the SDK to only receive events on a specific app. |
[options.filter.instanceName] | string | | Tells the SDK to only receive events on a specific service. |
[options.filter.events] | Array.<string> | ["*"] | Restrict the types of receivable events. ["*"] indicates that all events are enabled. |
serverlessSDK.disconnect() ⇒ null
Disconnects a websockets connection with the Serverless Platform
Kind: instance method of ServerlessSDK
serverlessSDK.isConnected() ⇒ boolean
Checks if the SDK is currently connected to the Serverless Platform
Kind: instance method of ServerlessSDK
Returns: boolean
- Will return true if the websocket connection is active.
serverlessSDK.unpublishFromRegistry(registryPackage)
Unpublishes a package from the registry
Kind: instance method of ServerlessSDK
Param | Type | Description |
---|
registryPackage | * | An object containing the properties of a registry package. |
serverlessSDK.publishToRegistry(registryPackage) ⇒ object
Publishes a package to the registry
Kind: instance method of ServerlessSDK
Returns: object
- The published registry package is returned from the Platform API.
Param | Type | Description |
---|
registryPackage | * | An object containing the properties of a registry package. |
serverlessSDK.getFromRegistry(name, version) ⇒ object
Fetches package/s from the registry
Kind: instance method of ServerlessSDK
Returns: object
- Returns a registry package from the Registry.
Param | Type | Default | Description |
---|
name | * |
| The name of the registry package to fetch. If this is not provided, this method will return a list of everything in the registry. |
version | * |
| The version of the registry package to fetch. If this is not provided, this method will always return the latest version. |
serverlessSDK.generateInstanceId(orgUid, stageName, appUid, instanceName) ⇒ object
Returns a properly formatted ID for an Instance
Kind: instance method of ServerlessSDK
Returns: object
- Returns a properly formatted ID for an Instance
Param | Type | Description |
---|
orgUid | * | The Uid of the Serverless Platform Organization. |
stageName | * | The name of the Serverless Platform Stage. |
appUid | * | The Uid of the Serverless Platform Application. |
instanceName | * | The name of the Serverless Platform Instance. |
serverlessSDK.validateInstance(instanceToValidate) ⇒ object
Validates the properties of an Instance, as well as auto-corrects shortened syntax (e.g. org => orgName)
Kind: instance method of ServerlessSDK
Returns: object
- Returns a validated, formatted version of the Instance
Param | Type | Description |
---|
instanceToValidate | * | The Serverless Platform Instance you want to validate. |
serverlessSDK.createInstance(orgName, stageName, appName, instanceName, instanceStatus) ⇒ object
Returns a new Instance as a Javascript object.
Kind: instance method of ServerlessSDK
Returns: object
- Returns a new Instance definition as a Javascript Object.
Param | Type | Default | Description |
---|
orgName | * |
| The name of the Serverless Platform Organization. |
stageName | * |
| The name of the Serverless Platform Stage. |
appName | * |
| The name of the Serverless Platform Application. |
instanceName | * |
| The name of the Serverless Platform Instance. |
instanceStatus | * | inactive | The status of the instance |
serverlessSDK.saveInstance(instanceRecord)
Saves an instance record, defined by createInstance
Kind: instance method of ServerlessSDK
serverlessSDK.getInstance(orgName, stageName, appName, instanceName)
Get an Instance from the Serverless Platform by it's name and the names of its Organization, Stage, Application.
Kind: instance method of ServerlessSDK
Param | Type | Default | Description |
---|
orgName | * |
| The name of the Serverless Platform Organization. |
stageName | * |
| The name of the Serverless Platform Stage. |
appName | * |
| The name of the Serverless Platform Application. |
instanceName | * |
| The name of the Serverless Platform Instance. |
serverlessSDK.listInstances(orgName, orgUid)
List all Component Instances within an Org, given an org name or org UId
Kind: instance method of ServerlessSDK
Param | Type | Default | Description |
---|
orgName | * |
| Optional. Must include either orgName or orgUid. |
orgUid | * | | Optional. Must include either orgName or orgUid. |
serverlessSDK.run(action, instanceData, credentials, options)
Run an action on a Component Instance. Is an asynchronous call by default, but you can perform this synchronously if you set options.sync
. Please note that synchronous runs have a 24 second timeout limit. That is not ideal for long operations, and is not recommended for deployments.
Kind: instance method of ServerlessSDK
Param | Type |
---|
action | * |
instanceData | * |
credentials | * |
options | * |
serverlessSDK.runFinish(method, instanceData)
Run Finish
Kind: instance method of ServerlessSDK
Param | Type | Default | Description |
---|
method | string | null | The action that was performed on the Component. |
instanceData | object | | An object representing your Instance definition. |
serverlessSDK.deploy()
Performs a 'deploy' action and polls the 'getInstance' endpoint until its 'instanceStatus' reflects a successful deployment, or error.
Kind: instance method of ServerlessSDK
serverlessSDK.remove()
Performs a 'remove' action and polls the 'getInstance' endpoint until its 'instanceStatus' reflects a successful deployment, or error.
Kind: instance method of ServerlessSDK
serverlessSDK.startInterceptingLogs(eventType, context)
Intercepts console 'log' 'debug' and 'error' methods, and sends their data to the Serverless Platform as an Event, before writing to stdout.
Kind: instance method of ServerlessSDK
Param | Type | Default | Description |
---|
eventType | * |
| Optional. The event name used to publish logs. Defaults to "instance.logs". |
context | * | | Optional. Additional context added to the published log data. |
serverlessSDK.stopInterceptingLogs()
Stop intercepting console methods
Kind: instance method of ServerlessSDK
onEvent : function
onEvent
callback
Kind: global typedef
Param | Type | Description |
---|
event | Object | Incoming event |
onDisconnect : function
onDisconnect
callback
Kind: global typedef
Param | Type | Description |
---|
closeEvent | Object | Websocket CloseEvent |
Publishing the SDK
Before publishing the SDK, be sure to run the pre-publish script, which browserifies the code and updates its documentation, by running: npm run pre-publish
within the sdk
folder.
© Serverless Inc.