Static function to globally enable history events. If you want to use history events please provide 'eventsource/lib/eventsource-polyfill' within your project.

import { PublicAPI } from 'ec.sdk';
import * as EventSource from 'eventsource/lib/eventsource-polyfill';

PublicAPI.enableHistoryEvents(EventSource);
…

Check if we can refresh a token

Create a new Resource. Note: Not all relations will support this.

return accounts.create('client', {
  clientID: 'myClient',
  callbackURL: 'https://example.com/login',
  config: {
    tokenMethod: 'query',
  },
})
.then(client => show(client));

Delete a single Resource identified by resourceID.

return accounts.deleteResource('account', me.accountID)
.then(()) => alert('Account deleted'));

Dispatch a request for helper lib. This will handle token refreshal on every request and on 401 errors

Abstract interface for PublicAPI#doRefreshToken. Exists until Accountserver has token refreshal of its own.

Returns a traverson request builder following the provided link. If the link is not present in the root resource it will try to reload the root resource. This is done since links can appear/disappear when login state changes.

Returns a collection of available relations in this API Connector.

Get a list of all avaliable filter options for a given relation.

Get a given link from the root resource

If you want to have access to the currently used refresh token you can call this function.

console.log(accounts.getRefreshToken()); // will log current refresh token

If you want to have access to the currently used token you can call this function.

console.log(accounts.getToken()); // will log current token

Check if a access token is stored

console.log(accounts.hasToken()); // will log true or false

Check if a refresh token is stored

console.log(accounts.hasRefreshToken()); // will log true or false

All API connectors have an underlying EventEmitter for emitting events. You can use this function for attaching an event listener. See EventEmitter for the events which will be emitted.

function myAlertFunc(string){
  console.log(`A new token was received: ${string}`);
}

session.on('login', myAlertFunc);
session.login(email, password);
// "A new token was received: <aJwtToken>" will be logged

This function preloads all schemas identified by schemas property.

You can remove a previously attached listener from the underlying EventEmitter with this function.

session.on('login', myAlertFunc);
session.login(email, password)
.then(token => {  // myAlertFunc will be called with token
  console.log(token);
  session.removeListener('login', myAlertFunc);
  // myAlertFunc will no longer be called.
});

Get a single Resource identified by resourceID.

return accounts.resource('account', me.accountID)
.then(account => show(account.email));

Load a ListResource of Resources filtered by the values specified by the options parameter.

return accounts.resourceList('account', {
  filter: {
    created: {
      from: new Date(new Date.getTime() - 600000).toISOString()),
    },
  },
})
.then(list => show(list))

If you have an existing access token you can use it by calling this function. All subsequent requests will use the provided Json Web Token with an Authorization header.

return accounts.me(); // will result in error
accounts.setToken('aJwtToken');
return accounts.mes(); // will resolve

If you have an existing refresh token you can use it by calling this function. It will be used to get a new token when time comes.

return accounts.me(); // will result in error
accounts.setToken('aJwtToken');
accounts.setRefreshToken('anotherJwtToken');
return accounts.me(); // will resolve

If you want to add additional information to the user agent used by ec.sdk you can use this function to add any string.

accounts.setUserAgent('editor/0.15.3 (a comment)');
// all subsequent requests will use x-user-agent: editor/0.15.3 (a comment) ec.sdk/<version>

Set the global locale for error output. 'de' and 'en' are available.

Check if we have a refresh token and if it is time (token expiraion < 24h) to refresh the token

Checks if the currently logged in user has a given permission.

Queries the current users permission trie for granted permissions. See shiro-trie.

Login with email and password. Currently only supports rest clientID with body post of credentials and tokenMethod body.

Logout with existing token. Will invalidate the token with the Account API and remove any cookie stored.

Set the clientID to use with the Accounts API. Currently only rest is supported.

Get a single AccountResource identified by accountID.

return accounts.account(accountList.getFirstItem().accountID)
.then(account => show(account.email));

Load a AccountList of AccountResources filtered by the values specified by the options parameter.

return accounts.accountList({
  filter: {
    created: {
      from: new Date(new Date.getTime() - 600000).toISOString()),
    },
  },
})
.then(list => show(list))

Change the logged in account to the given new email address.

return accounts.changeEmail(newEmail)
.then(() => show(`Email change started. Please verify with your new address.`))

Load a single ClientResource.

return accounts.client('thisOne')
.then(client => show(client));

Load the ClientList filtered by the values specified by the options parameter.

return accounts.clientList({
  filter: {
    callbackURL: 'thisOne', // the same as 'callbackURL: { exact: 'thisOne' }'
  },
})
.then(clients => show(clients.getFirstItem()));

Creates a new API token with 100 years validity (or how long you want).

return accounts.createAPIToken({ // all options are optional
  name: 'my-api-key', // PLEASE use a good identifier for the account
  validUntil: 1440, // token validity in minutes, leave blank for "distant future" (1440 = 24h)
  permissions: ['my:permission-string'], // directly attach permission. You need the right to do that!
  groups: [{ groupID: '...' }], // directly add account to group. You need the right to do that!
})
.then(({ jwt, accountID, iat, exp}) => {
  // do something with `jwt` because it is not accessable later
});

Create a new Client.

const accounts = new Accounts();

const publicClient = await accounts.createClient({
  clientID: 'my-public-client',
  clientName: 'A public client for web applications',
  grantTypes: ['authorization_code', 'refresh_token'],
  tokenEndpointAuthMethod: 'none',
  redirectURIs: ['https://my.app.com/redirect'],
  postLogoutRedirectURIs: ['https://my.app.com/logout'],
  authUIOrigin: 'https://login.entrecode.de',
  logoURI: 'https://entrecode.de/de/assets/ec-logo.svg'
});

const confidentialClient = await accounts.createClient({
  clientID: 'my-private-client',
  clientName: 'A confidential client for server side applications',
  grantTypes: ['authorization_code', 'refresh_token'],
  tokenEndpointAuthMethod: 'client_secret_basic',
  clientSecret: 'my-secret',
  redirectURIs: ['https://my.app.com/redirect'],
  postLogoutRedirectURIs: ['https://my.app.com/logout'],
  authUIOrigin: 'https://login.entrecode.de',
  logoURI: 'https://entrecode.de/de/assets/ec-logo.svg'
});

const apiClient = await accounts.createClient({
  clientID: 'my-api-client',
  clientName: 'A client for API access',
  grantTypes: ['client_credentials'],
  tokenEndpointAuthMethod: 'client_secret_basic',
  clientSecret: 'my-secret',
});

Create a new Group.

Create new invites. Specify number of invites to create with options.count, permissions with options.permissions or options.groups[].

Will check if the given email is available for login.

return accounts.emailAvailable(email)
.then((available) => {
   if (!available){
     return showError(new Error(`Email ${email} not available.`));
   }

   return accounts.signup(email, password);
});

Load a single group.

return accounts.group(groupID)
.then((group) => {
  group.addPermission('can-view-stacktrace');
  return group.save();
});

Load the GroupList filtered by the values specified by the options parameter.

return accounts.groupList({
  filter: {
    title: {
      search: 'dev',
    },
  },
})
.then(groups => {
  // all groups with 'dev' in the title
  return show(groups.getAllItems());
});

Get InvalidPermissionsResource to show all invalid permissions.

return accounts.invalidPermissions()
.then((invalidPermissions) => Promise.all([
  show(invalidPermissions.invalidAccountPermissions),
  show(invalidPermissions.invalidGroupPermissions),
]));

Load a single InviteResource. Only unused invites are returned.

Load the list of InviteResources. Only unused invites are in the list.

Get the AccountResource which is currently logged in.

return accounts.me()
.then((account) => {
  return show(`Your are logged in as ${account.name || account.email}`);
});

Start a password reset.

return accounts.resetPassword(email)
.then(() => show(`Password reset link send to ${email}`))

Set the clientID to use with the Accounts API. Currently only rest is supported.

Signup a new account. Invite may be required.

return accounts.signup(email, password, invite)
.then((token) => {
  accounts.setToken(token);
  return show('Successfully registered account');
});

Get a single AppResource identified by appID.

return apps.app(deleteThisID)
.then(app => app.del());

Load a AppList of AppResource filtered by the values specified by the options parameter.

return apps.appList()
.then(list => list.map((app) => {
  app.name = 'haha all your apps are named the same';
  return app.save();
}));

Create a new App

return apps.create({
  title: 'my new app',
  hexColor: '#ffffff',
})
.then(app => show(app));

Load a single AppStatsResource.

return dm.stats(app.appID)
.then(stats => show(stats));

Load the AppStatsList.

return apps.statsList()
.then(stats => show(stats.getAllItems()));

Load the TypesResource. This resource contains information about all available plugin types.

Create a new DataManager.

return dm.create({ title: 'my new dm' })
.then(dm => createRequiredModelsFor(dm));

Create a new template.

return dm.createTemplate({
  collection: {…},
  dataSchema: {…},
})
.then(template => template.createDM())
.then(dm => show(dm));

Get a single DataManagerResource identified by dataManagerID.

return dm.dataManager(myDmID)
.then(dm => dm.del());

Load a DataManagerList of DataManagerResource filtered by the values specified by the options parameter.

Best file helper for files.

Best file helper for image thumbnails.

Best file helper for images.

Load the HistoryEvents for this DataManager from v3 API. Note: This Request only has pagination when you load a single modelID.

Load a single DMStatsResource.

return dm.stats(myDM.dataManagerID)
.then(stats => show(stats));

Load the DMStatsList.

return dm.statsList()
.then(templates => show(templates.getAllItems()));

Load a single TemplateResource.

return dm.template('thisOne')
.then(template => {
  const data = createRandomDataFromSchema(template.dataSchema);
  return template.creatDM(data);
});

Load the TemplateList.

return dm.template({
  filter: {
    name: {
      search: 'clubapp',
    },
  },
  sort: ['-version'],
  size: 2,
})
.then(templates => );

Load a single PublicAssetResource.

return api.asset(thisOne)
.then(asset => show(asset));

Load the list of assetGroupIDs.

Load the PublicAssetList.

return api.assetList({ filter: { type: 'image'} })
.then(assets => assets.getAllItems().find(asset => asset.title.toLowerCase() === 'favicon' ))
.then(asset => show(asset));

Change the logged in account to the given new email address.

return api.changeEmail(newEmail)
.then(() => show(`Email change started. Please verify with your new address.`))

Checks a permission for the currently logged in public user. ec.users check their permission with Session#checkPermission.

Programatically signup a user, mostly used for special register flows using legacy users or magic link login.

const createdAccount = await api.configurableSignup({
  email: 'test@entrecode.de',
  password: 'CorrectHorseBatteryStaple', // optional
  invite: null, // optional
  pending: true, // optional
  sendWelcomeMail: false, // optional
  anonymousToken: 'eyasldfaslfkelaewjflejf...', // optional
});

const { accountID, email, hasPassword, pending } = createdAccount;

Programatically complete a signup with a single use validationToken, mostly used for special register flows using legacy users or magic link login.

Creates a new anonymous account.

return api.createAnonymous()
.then(token => yourFancySaveFkt(token));

Create a new asset. This should handle various input types.

The most basic type is a string representing a file path, this can be used on node projects. Another option for node is providing a Buffer object (eg. fs.readFile, …). When providing a Buffer you must specify 'fileName' in options object.

For frontend usage you musst provide a FormData object containing the file in a field with the name 'file'.

Create a legacy asset. This should handle various input types.

The most basic type is an array of strings representing a file paths, this can be used on node projects. Another option for node is providing an array of Buffer objects (eg. fs.readFile, …). When providing a Buffer you must specify 'fileName' in options object.

For frontend usage you musst provide a FormData object containing the multiple files in a field with the name 'file'.

Create one or multiple new assets. This should handle various input types.

The most basic type is a string representing a file path, this can be used on node projects. Another option for node is providing a Buffer object (eg. fs.readFile, …). When providing a Buffer you must specify 'fileName' in options object.

For frontend usage you must provide a FormData object containing the multiple files in a field with the name 'file'.

In both cases you can add a string representing an url. DataManager will then create the assets from this url.

const createdAssets = await api.createDMAssets(
  'myAssetGroup',
  ['/path/to/file1', '/path/to/file2'],
  {
    fileName: ['filename1.png', 'filename2.png'], // omit for default filenames
    deduplicate: true, // you'll get back existing assets if duplicates exist
    defaultVariants: [ 256 ], // will generate a 256px-variant right away instead of on first request. Only use if needed!
  }
);

Create a new entry.

Delete a single PublicAssetResource.

return api.deleteAsset(thisOne)
.then(()) => alert('Asset deleted'));

Delete a single EntryResource.

return api.deleteEntry('myModel', '1234567')
.then(()) => alert('Entry deleted'));

Load a single DMAssetResource.

return api.dmAsset(thisOne)
.then(asset => show(asset));

Delete a single DMAssetResource.

return api.deleteDmAsset(thisOne)
.then(() => alert('Asset deleted'));

Load the DMAssetList.

return api.dmAssetList('public', { filter: { type: 'image'} })
.then(assets => assets.getAllItems().find(asset => asset.title.toLowerCase() === 'favicon' ))
.then(asset => show(asset));

When the logged in user has a refresh token this function will do the token refresh. On successful refreshal PublicAPI will emmit the event refresh, if it failes it will emmit refreshError. You MUST handle these events.

Will check if the given email is available for login.

return api.emailAvailable(email)
.then((available) => {
   if (available){
     return api.signup(email, password);
   } else {
     return showError(new Error(`Email ${email} already registered.`));
   }
});

Load a single EntryResource.

return api.entry('myModel', '1234567')
.then(entry => {
  return show(entry);
});
// since 0.17.10
const entry = await api.entry('myModel', { urltitle: 'this-is-unique' });
await show(entry);

Load the EntryList.

return api.entryList('myModel')
.then(list => {
  return list.getAllItems().find(entry => entry.id === '1234567');
})
.then(entry => {
  return show(entry);
});

This is a short hand for Core#link for auth links in public APIs. It will load ${shortID}:_auth/${name} link.

Load the HistoryEvents for this DataManager from v3 API. Note: This Request only has pagination when you load a single modelID.

Load fieldConfig for one or many models. Can be used to configure and style forms etc.

Best file helper for files.

Generic file helper for images and thumbnails.

Best file helper for image thumbnails.

Best file helper for images.

Loads the JSON Schema for a given model. Loaded Schemas will be stored in tv4 cache upon first load.

Create a single-use validation token for a user. The token should then be send to the user via mail and MUST NOT be displayed to her.

Create validation tokens for a user to change the email address. The tokens should then be send to the old and new email address and MUST NOT be displayed to the user. Validating with the new address updates the email. Aborting via the old email address resets to the old address and invalidates the token to change it.

Validate and perform a email change request. Depending on the token type (changeEmail or revokeEmail), the email address is changed or reset to the old address (with invalidation of the changeEmail-Token).

Login with email and password. Currently only supports rest clientID with body post of credentials and tokenMethod body.

Login with token from magic link

Logout with existing token. Will invalidate the token with the public API and remove any cookie stored.

Loads the account object of a public user.

Load the list of models. Will resolve to a object with modelTitle as key and Model as value.

Call PublicAPI#refCount with model, field and desired ids to get a simple object with ref counts.

const counts = await api.refCount('myModel', 'myField', [entryID1, entryID2, ...entryIDn]);
alert(`Entry ${entryID1} has ${counts[entryID1]} references`);

Start a password reset.

return api.resetPassword(email)
.then(() => show(`Password reset link send to ${email}`))

Resolves the root response of ths PublicAPI DataManager

Set the clientID to use with the public API. Currently only rest is supported.

Signup a new account. Invite may be required.

return api.signup(email, password, invite)
.then((tokenResponse) => {
  api.setToken(tokenResponse.access_token);
  return show('Successfully registered account');
});

Load a single PublicTagResource.

return assetList.tag('thisOne')
.then(tag => {
  return show(tag);
});

Load the PublicTagList.

return assetList.tagList()
.then(tags => {
  return tags.getAllItems().filter(tags => tag.tag === 'thisOne');
})
.then(tagsArray => {
  return show(tagsArray[0]);
});

// This would actually be better:
return dm.tagList({
  filter: {
    assetID: 'thisOne',
  },
})
.then(tags => {
  return show(tags.getFirstItem());
});

Load the active sessions for the current user - the DMAuthTokenList.

const tokenList = await dm.tokenList();
await tokenList.map((token) => {
   // delete all sessions that are not the active one
   if (!token.isCurrent) {
     await token.delete();
   }
});

Validates a single-use token from a user. Checks if the token is valid and responds with user information.

Call PublicAPI#valueCount with model and field to get a simple array with value counts.

const values = await api.valueCount('myModel', 'myField');
alert(`Values are: ${values.map(x => `Value: ${x.value} (${x.count})`).join(', ')}`);

Get all Problems as an array.

More detailed string representation for this error. Will contain newlines.

More detailed string representation for this and short strin representation for all sub errors. Will contain newlines.

Get short string representation of this error.

Get short string representation for this and all sub errors. Will contain newlines for each sub error.

Returns a collection of available relations in this Resource.

Get all links of this resource.

Create a new Resource. Note: Not all relations will support this.

return accounts.create('client', {
  clientID: 'myClient',
  callbackURL: 'https://example.com/login',
  config: {
    tokenMethod: 'query',
  },
})
.then(client => show(client));

Deletes this Resource.

alias for Resource#del()

Loads the given link and returns a Resource with the loaded result.

Returns an object with selected properties of the Resource. Will return all properties when properties array is empty or undefined.

Get the first link with the given name.

Get all links with the given name.

Will return a single selected property identified by property.

Checks if this Resource has at least one {@link https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5 link} with the given name.

Returns a traverson request builder following the provided link.

Reset this Resource to its initial state. Resource#isDirty will be false afterwards.

Reloads this Resource. Can be used when this resource was loaded from any ListResource from _embedded.

Get a list of all avaliable filter options for a given relation.

Get a single Resource identified by resourceID.

return accounts.resource('account', me.accountID)
.then(account => show(account.email));

Load a ListResource of Resources filtered by the values specified by the options parameter.

return accounts.resourceList('account', {
  filter: {
    created: {
      from: new Date(new Date.getTime() - 600000).toISOString()),
    },
  },
})
.then(list => show(list))

Saves this Resource.

Will assign all properties in resource to this Resource.

Set a new value to the property identified by property.

Validates this Resource against its schema (found in _links.self.profile)

The filter() method creates a new array with all elements that pass the test implemented by the provided function. It will use ListResource#followNextLink. Keep in mind that altering the list within the map method is possible but can change the order of the list. E.g. do not use on lists sorted by modified and update the entries during the process.

The find() method returns the first element that passes the test implemented by the provided function. It will use ListResource#followNextLink. Keep in mind that altering the list within the map method is possible but can change the order of the list. E.g. do not use on lists sorted by modified and update the entries during the process.

Loads the first link and returns a ListResource with the loaded result.

Loads the next link and returns a ListResource with the loaded result.

Loads the prev link and returns a ListResource with the loaded result.

Get all list items {@link https://tools.ietf.org/html/draft-kelly-json-hal-08#section-4.1.2 embedded} into this ListResource.

Get the first {@link https://tools.ietf.org/html/draft-kelly-json-hal-08#section-4.1.2 embedded} item from the list

Get the n'th {@link https://tools.ietf.org/html/draft-kelly-json-hal-08#section-4.1.2 embedded} item from the list

Checks if this Resource has at least one {@link https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5 link} with the name 'first'.

Checks if this Resource has at least one {@link https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5 link} with the name 'next'.

Checks if this Resource has at least one {@link https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5 link} with the name 'prev'.

The map() method creates a new array with the results of calling a provided function on every item in this list. It will use ListResource#followNextLink. Keep in mind that altering the list within the map method is possible but can change the order of the list. E.g. do not use on lists sorted by modified and update the entries during the process.

Load the next page.

Check if there are more events available

Adds a new permission to permissions array.

Adds new permissions to permissions array.

Check if this Account has a given permission

Queries the Accounts permissions. See shiro-trie.

Returns an array of all permissions of this account. The array will contain the account permissions and all group permissions.

Load the TokenList for this account

Create an additional access token tokenResponse for this account. Only supported for API Keys.

• Error: if the account is not an API Key

return account.createToken()
.then(({ jwt, accountID, iat, exp}) => {
  // do something with `jwt` because it is not accessable later
});

Saves this AccountResource.

Adds a new permission to permissions array.

Adds a new permissions to permissions array.

Remove a single permission from this group.

Remove multiple permissions from this group.

Get the embedded account objects. Will be no account resources, but object containing only accountID and email.

Add an account to this group. You can add by accountID or by email. Note that email addings are only validated after you called .save() on your group.

Replace all accounts in this GroupResource with a new array. You can add by accountID or by email. Note that email addings are only validated after you called .save() on your group.

Remove an account from this group.

Saves this InviteResource.

Get a single CodeSourceResource identified by codeSourceID.

Load a CodeSourceList of CodeSourceResource filtered by the values specified by the options parameter.

Create a new codeSource.

Create a new dataSource.

Creates a new platform for this app. You will have to have a CodeSourceResource, DataSourceResource, and one or more TargetResource. In the ec.API this is performed as a POST request containing the plugins as links in HALs _links object - This is also an option here. But for convenience you can put the Resources into the object directly. See the example below for details.

const platform = {
  title: 'MyAwesomePlatform',
  platformType: 'website',
  config: {
    // …
  },
  codeSource = codeSourceResource,
  dataSource = dataSourceResource,
  target = [targetResource1, targetResource2],
};

// this would be ok as well
const otherPlatform = {
  title: 'MyAwesomePlatform',
  platformType: 'website',
  config: {
    // …
  },
  _links: {
    "ec:app/codesource": {
       href: "…",
    },
    "ec:app/datasource": {
       href: "…",
    },
    "ec:app/target": {
       href: "…",
    },
  }
}

app.createPlatform(platform)
.then(platform => doSomethingWith(platform));

Create a new target.

Get a single CodeSourceResource identified by dataSourceID.

Load a DataSourceList of CodeSourceResource filtered by the values specified by the options parameter.

Get a single PlatformResource identified by platformID.

Load a PlatformList of PlatformResource filtered by the values specified by the options parameter.

Get a single TargetResource identified by targetID.

Load a TargetList of TargetResource filtered by the values specified by the options parameter.

Get an Array of available types for code sources

Get an Array of available types for data sources

Get an Array of available types for platforms

Get an Array of available types for targets

Get an Array of available plugins for a given plugin name

Get a code source plugin by type.

Get a code source schema by type.

Get a data source plugin by type.

Get a data source schema by type.

Get a platform plugin by type.

Get a platform schema by type.

Get a plugin by plugin name and type.