@verdocs/js-sdk 4.1.14 → 4.1.15

package/dist/index.mjs

@@ -1501,11 +1501,11 @@ const deleteEnvelopeReminder = (endpoint, envelopeId, reminderId) => endpoint.ap
 /**
  * Check to see if the user owns the envelope.
  */
-const userIsEnvelopeOwner = (session, envelope) => envelope.profile_id === session?.profile_id;
+const userIsEnvelopeOwner = (profile, envelope) => envelope.profile_id === profile?.id;
 /**
  * Check to see if the user owns the envelope.
  */
-const userIsEnvelopeRecipient = (session, envelope) => envelope.profile_id === session?.profile_id;
+const userIsEnvelopeRecipient = (profile, envelope) => envelope.profile_id === profile?.id;
 /**
  * Check to see if the envelope has pending actions.
  */
@@ -1517,14 +1517,14 @@ const envelopeIsComplete = (envelope) => envelope.status !== 'complete';
 /**
  * Check to see if the user owns the envelope.
  */
-const userCanCancelEnvelope = (session, envelope) => userIsEnvelopeOwner(session, envelope) &&
+const userCanCancelEnvelope = (profile, envelope) => userIsEnvelopeOwner(profile, envelope) &&
     envelope.status !== 'complete' &&
     envelope.status !== 'declined' &&
     envelope.status !== 'canceled';
 /**
  * Check to see if the user owns the envelope.
  */
-const userCanFinishEnvelope = (session, envelope) => userIsEnvelopeOwner(session, envelope) &&
+const userCanFinishEnvelope = (profile, envelope) => userIsEnvelopeOwner(profile, envelope) &&
     envelope.status !== 'complete' &&
     envelope.status !== 'declined' &&
     envelope.status !== 'canceled';
@@ -1550,15 +1550,15 @@ const userCanAct = (email, recipientsWithActions) => {
 /**
  * Returns true if the user can act.
  */
-const userCanSignNow = (session, envelope) => {
-    if (!session) {
+const userCanSignNow = (profile, envelope) => {
+    if (!profile) {
         return false;
     }
     const recipientsWithActions = getRecipientsWithActions(envelope);
-    const myRecipient = recipientsWithActions.find((r) => r.profile_id === session?.profile_id || r.email === session?.email);
+    const myRecipient = recipientsWithActions.find((r) => r.profile_id === profile?.id || r.email === profile?.email);
     return (myRecipient &&
         envelopeIsActive(envelope) &&
-        userIsEnvelopeRecipient(session, envelope) &&
+        userIsEnvelopeRecipient(profile, envelope) &&
         recipientCanAct(myRecipient, recipientsWithActions));
 };
 const getNextRecipient = (envelope) => {
@@ -1614,9 +1614,9 @@ const deleteSignature = (endpoint, signatureId) => endpoint.api //
  * Get a list of keys for a given organization. The caller must have admin access to the organization.
  *
  * ```typescript
- * import {ApiKeys} from '@verdocs/js-sdk';
+ * import {getApiKeys} from '@verdocs/js-sdk';
  *
- * const keys = await ApiKeys.getKeys(ORGID);
+ * const keys = await getApiKeys(ORGID);
  * ```
  */
 const getApiKeys = (endpoint) => endpoint.api //
@@ -1626,9 +1626,9 @@ const getApiKeys = (endpoint) => endpoint.api //
  * Create an API key.
  *
  * ```typescript
- * import {ApiKeys} from '@verdocs/js-sdk';
+ * import {createApiKey} from '@verdocs/js-sdk';
  *
- * await ApiKeys.createKey(ORGID, {name: NEWNAME});
+ * await createApiKey(ORGID, {name: NEWNAME});
  * ```
  */
 const createApiKey = (endpoint, params) => endpoint.api //
@@ -1638,9 +1638,9 @@ const createApiKey = (endpoint, params) => endpoint.api //
  * Rotate the secret for an API key. The caller must have admin access to the organization.
  *
  * ```typescript
- * import {ApiKeys} from '@verdocs/js-sdk';
+ * import {rotateApiKey} from '@verdocs/js-sdk';
  *
- * const {client_secret: newSecret} = await ApiKeys.rotateKey(ORGID, CLIENTID);
+ * const {client_secret: newSecret} = await rotateApiKey(ORGID, CLIENTID);
  * ```
  */
 const rotateApiKey = (endpoint, clientId) => endpoint.api //
@@ -1650,9 +1650,9 @@ const rotateApiKey = (endpoint, clientId) => endpoint.api //
  * Update an API key to change its assigned Profile ID or Name.
  *
  * ```typescript
- * import {ApiKeys} from '@verdocs/js-sdk';
+ * import {updateApiKey} from '@verdocs/js-sdk';
  *
- * await ApiKeys.updateKey(ORGID, CLIENTID, {name: NEWNAME});
+ * await updateApiKey(ORGID, CLIENTID, {name: NEWNAME});
  * ```
  */
 const updateApiKey = (endpoint, clientId, params) => endpoint.api //
@@ -1662,9 +1662,9 @@ const updateApiKey = (endpoint, clientId, params) => endpoint.api //
  * Delete an API key.
  *
  * ```typescript
- * import {ApiKeys} from '@verdocs/js-sdk';
+ * import {deleteApiKey} from '@verdocs/js-sdk';
  *
- * await ApiKeys.deleteKey(ORGID, CLIENTID);
+ * await deleteApiKey(ORGID, CLIENTID);
  * ```
  */
 const deleteApiKey = (endpoint, clientId) => endpoint.api //
@@ -1788,19 +1788,37 @@ const declineOrganizationInvitation = (endpoint, email, token) => endpoint.api /
  */
 /**
  * Get a list of the members in the caller's organization.
+ *
+ * ```typescript
+ * import {getOrganizationMembers} from '@verdocs/js-sdk';
+ *
+ * const members = await deleteOrganizationMember(VerdocsEndpoint.getDefault()});
+ * ```
  */
 const getOrganizationMembers = (endpoint) => endpoint.api //
     .get(`/v2/organization-members`)
     .then((r) => r.data);
 /**
  * Delete a member from the caller's organization. Note that the caller must be an admin or owner,
- * may not delete him/herself
+ * may not delete him/herself.
+ *
+ * ```typescript
+ * import {deleteOrganizationMember} from '@verdocs/js-sdk';
+ *
+ * await deleteOrganizationMember(VerdocsEndpoint.getDefault(), 'PROFILEID'});
+ * ```
  */
 const deleteOrganizationMember = (endpoint, profileId) => endpoint.api //
     .delete(`/v2/organization-members/${profileId}`)
     .then((r) => r.data);
 /**
  * Update a member.
+ *
+ * ```typescript
+ * import {updateOrganizationMember} from '@verdocs/js-sdk';
+ *
+ * const result = await updateOrganizationMember(VerdocsEndpoint.getDefault(), 'PROFILEID', {roles:['member']});
+ * ```
  */
 const updateOrganizationMember = (endpoint, profileId, params) => endpoint.api //
     .patch(`/v2/organization-members/${profileId}`, params)
@@ -1898,13 +1916,27 @@ const updateOrganizationThumbnail = (endpoint, organizationId, file, onUploadPro
  * @module
  */
 /**
- * Get the registered Webhooks for the caller's organization.
+ * Get the registered Webhook configuration for the caller's organization.
+ *
+ * ```typescript
+ * import {getWebhooks} from '@verdocs/js-sdk';
+ *
+ * await getWebhooks(ORGID, params);
+ * ```
  */
 const getWebhooks = (endpoint) => endpoint.api //
     .get(`/v2/webhooks/organization`)
     .then((r) => r.data);
 /**
- * Update the registered Webhooks for the caller's organization.
+ * Update the registered Webhook configuration for the caller's organization. Note that
+ * Webhooks cannot currently be deleted, but may be easily disabled by setting `active`
+ * to `false` and/or setting the `url` to an empty string.
+ *
+ * ```typescript
+ * import {setWebhooks} from '@verdocs/js-sdk';
+ *
+ * await setWebhooks(ORGID, params);
+ * ```
  */
 const setWebhooks = (endpoint, params) => endpoint.api //
     .patch(`/v2/webhooks/organization`, params)
@@ -1913,16 +1945,16 @@ const setWebhooks = (endpoint, params) => endpoint.api //
 /**
  * Confirm whether the user has all of the specified permissions.
  */
-const userHasPermissions = (session, permissions) => permissions.every((perm) => (session?.permissions || []).includes(perm));
+const userHasPermissions = (profile, permissions) => permissions.every((perm) => (profile?.permissions || []).includes(perm));
 
-const canPerformTemplateAction = (session, action, template) => {
+const canPerformTemplateAction = (profile, action, template) => {
     if (!template && !action.includes('create')) {
         return { canPerform: false, message: 'Missing required template object' };
     }
     // We use BOGUS here to force the option-chain in things like template?.profile_id to NOT match profile?.profile_id because if both
     // were undefined, they would actually match.
-    const profile_id = session?.profile_id || 'BOGUS';
-    const organization_id = session?.organization_id || 'BOGUS';
+    const profile_id = profile?.id || 'BOGUS';
+    const organization_id = profile?.organization_id || 'BOGUS';
     if (!profile_id) {
         return { canPerform: false, message: 'Active session required' };
     }
@@ -1990,12 +2022,12 @@ const canPerformTemplateAction = (session, action, template) => {
         default:
             return { canPerform: false, message: 'Action is not defined' };
     }
-    if (hasRequiredPermissions(session, permissionsRequired)) {
+    if (hasRequiredPermissions(profile, permissionsRequired)) {
         return { canPerform: true, message: '' };
     }
     return { canPerform: false, message: `Insufficient access to perform '${action}'. Needed permissions: ${permissionsRequired.toString()}` };
 };
-const hasRequiredPermissions = (session, permissions) => permissions.every((perm) => (session?.permissions || []).includes(perm));
+const hasRequiredPermissions = (profile, permissions) => permissions.every((perm) => (profile?.permissions || []).includes(perm));
 
 /**
  * Add a field to a template.
@@ -2024,72 +2056,72 @@ const deleteField = (endpoint, templateId, fieldName) => endpoint.api //
 /**
  * Check to see if the user created the template.
  */
-const userIsTemplateCreator = (session, template) => session && template && session.profile_id === template.profile_id;
+const userIsTemplateCreator = (profile, template) => profile && template && profile.id === template.profile_id;
 /**
  * Check to see if a template is "shared" with the user.
  */
-const userHasSharedTemplate = (session, template) => session && template && !template.is_personal && session.organization_id === template.organization_id;
+const userHasSharedTemplate = (profile, template) => profile && template && !template.is_personal && profile.organization_id === template.organization_id;
 /**
  * Check to see if the user can create a personal/private template.
  */
-const userCanCreatePersonalTemplate = (session) => userHasPermissions(session, ['template:creator:create:personal']);
+const userCanCreatePersonalTemplate = (profile) => userHasPermissions(profile, ['template:creator:create:personal']);
 /**
  * Check to see if the user can create an org-shared template.
  */
-const userCanCreateOrgTemplate = (session) => userHasPermissions(session, ['template:creator:create:org']);
+const userCanCreateOrgTemplate = (profile) => userHasPermissions(profile, ['template:creator:create:org']);
 /**
  * Check to see if the user can create a public template.
  */
-const userCanCreatePublicTemplate = (session) => userHasPermissions(session, ['template:creator:create:public']);
+const userCanCreatePublicTemplate = (profile) => userHasPermissions(profile, ['template:creator:create:public']);
 /**
  * Check to see if the user can read/view a template.
  */
-const userCanReadTemplate = (session, template) => template.is_public ||
-    userIsTemplateCreator(session, template) ||
-    (userHasSharedTemplate(session, template) && userHasPermissions(session, ['template:member:read']));
+const userCanReadTemplate = (profile, template) => template.is_public ||
+    userIsTemplateCreator(profile, template) ||
+    (userHasSharedTemplate(profile, template) && userHasPermissions(profile, ['template:member:read']));
 /**
  * Check to see if the user can update a tempate.
  */
-const userCanUpdateTemplate = (session, template) => userIsTemplateCreator(session, template) ||
-    (userHasSharedTemplate(session, template) && userHasPermissions(session, ['template:member:read', 'template:member:write']));
+const userCanUpdateTemplate = (profile, template) => userIsTemplateCreator(profile, template) ||
+    (userHasSharedTemplate(profile, template) && userHasPermissions(profile, ['template:member:read', 'template:member:write']));
 /**
  * Check to see if the user can change whether a template is personal vs org-shared.
  */
-const userCanMakeTemplatePrivate = (session, template) => userIsTemplateCreator(session, template)
-    ? userHasPermissions(session, ['template:creator:create:personal'])
-    : userHasPermissions(session, ['template:member:visibility']);
+const userCanMakeTemplatePrivate = (profile, template) => userIsTemplateCreator(profile, template)
+    ? userHasPermissions(profile, ['template:creator:create:personal'])
+    : userHasPermissions(profile, ['template:member:visibility']);
 /**
  * Check to see if the user can change whether a template is personal vs org-shared.
  */
-const userCanMakeTemplateShared = (session, template) => userIsTemplateCreator(session, template)
-    ? userHasPermissions(session, ['template:creator:create:org'])
-    : userHasPermissions(session, ['template:member:visibility']);
+const userCanMakeTemplateShared = (profile, template) => userIsTemplateCreator(profile, template)
+    ? userHasPermissions(profile, ['template:creator:create:org'])
+    : userHasPermissions(profile, ['template:member:visibility']);
 /**
  * Check to see if the user can change whether a template is personal vs org-shared.
  */
-const userCanMakeTemplatePublic = (session, template) => userIsTemplateCreator(session, template)
-    ? userHasPermissions(session, ['template:creator:create:public'])
-    : userHasPermissions(session, ['template:member:visibility']);
+const userCanMakeTemplatePublic = (profile, template) => userIsTemplateCreator(profile, template)
+    ? userHasPermissions(profile, ['template:creator:create:public'])
+    : userHasPermissions(profile, ['template:member:visibility']);
 /**
  * Check to see if the user can change whether a template is personal vs org-shared.
  */
-const userCanChangeOrgVisibility = (session, template) => userIsTemplateCreator(session, template) && userHasPermissions(session, ['template:creator:create:personal']);
+const userCanChangeOrgVisibility = (profile, template) => userIsTemplateCreator(profile, template) && userHasPermissions(profile, ['template:creator:create:personal']);
 /**
  * Check to see if the user can change whether a template is personal vs org-shared.
  */
-const userCanDeleteTemplate = (session, template) => userIsTemplateCreator(session, template)
-    ? userHasPermissions(session, ['template:creator:delete'])
-    : userHasPermissions(session, ['template:member:delete']);
+const userCanDeleteTemplate = (profile, template) => userIsTemplateCreator(profile, template)
+    ? userHasPermissions(profile, ['template:creator:delete'])
+    : userHasPermissions(profile, ['template:member:delete']);
 /**
  * Confirm whether the user can create an envelope using the specified template.
  */
-const userCanSendTemplate = (session, template) => {
+const userCanSendTemplate = (profile, template) => {
     switch (template.sender) {
         case 'creator':
-            return userIsTemplateCreator(session, template);
+            return userIsTemplateCreator(profile, template);
         case 'organization_member':
         case 'organization_member_as_creator':
-            return userIsTemplateCreator(session, template) || template.organization_id === session?.organization_id;
+            return userIsTemplateCreator(profile, template) || template.organization_id === profile?.organization_id;
         default:
             return true;
     }
@@ -2097,19 +2129,19 @@ const userCanSendTemplate = (session, template) => {
 /**
  * Confirm whether the user can create a new template.
  */
-const userCanCreateTemplate = (session) => userCanCreatePersonalTemplate(session) || userCanCreateOrgTemplate(session) || userCanCreatePublicTemplate(session);
+const userCanCreateTemplate = (profile) => userCanCreatePersonalTemplate(profile) || userCanCreateOrgTemplate(profile) || userCanCreatePublicTemplate(profile);
 /**
  * Check to see if the user can "build" the template (use the field builder). The user must have write access to the
  * template, and the template must have at least one signer role.
  */
-const userCanBuildTemplate = (session, template) => userCanUpdateTemplate(session, template) && (template.roles || []).filter((role) => role.type === 'signer').length > 0;
+const userCanBuildTemplate = (profile, template) => userCanUpdateTemplate(profile, template) && (template.roles || []).filter((role) => role.type === 'signer').length > 0;
 const getFieldsForRole = (template, role_name) => (template.fields || []).filter((field) => field.role_name === role_name);
 /**
  * Check to see if the user can preview the template. The user must have read access to the template, the template must
  * have at least one signer, and every signer must have at least one field.
  */
-const userCanPreviewTemplate = (session, template) => {
-    const hasPermission = userCanReadTemplate(session, template);
+const userCanPreviewTemplate = (profile, template) => {
+    const hasPermission = userCanReadTemplate(profile, template);
     const signers = (template.roles || []).filter((role) => role.type === 'signer');
     return hasPermission && signers.length > 0 && signers.every((signer) => getFieldsForRole(template, signer.name).length > 0);
 };