@seamapi/http 0.9.3 → 0.10.1

package/README.md

@@ -56,19 +56,19 @@ Refer to the next section for keeping the types updated.
 #### Keeping up with the latest types
 
 This package depends on [@seamapi/types] for the latest TypeScript types.
-New versions of this package are generally not released when new types are published.
+New versions of this SDK are generally not released when new types are published.
 Unless your project frequently runs a blanket `npm update`,
 the types will become outdated with the Seam API over time.
-Thus, users of this package should explicitly install the types
+Thus, users of this package should explicitly install the types with
 
 ```
-$ npm install @seamapi/types
+$ npm install -D @seamapi/types
 ```
 
-and update them when consuming new API features:
+and update them when consuming new API features with
 
 ```
-$ npm install @seamapi/http@latest
+$ npm install -D @seamapi/http@latest
 ```
 
 ## Usage

package/dist/connect.cjs

@@ -476,8 +476,7 @@ var errorInterceptor = async (err) => {
     throw err;
   const { response } = err;
   const status = response?.status;
-  const headers = response?.headers;
-  const requestId = headers?.["seam-request-id"] ?? "";
+  const requestId = getRequestId(err);
   if (status == null)
     throw err;
   if (status === 401) {
@@ -497,7 +496,7 @@ var isApiErrorResponse = (response) => {
   const { headers, data } = response;
   if (headers == null)
     return false;
-  const contentType = headers["content-type"];
+  const contentType = headers["Content-Type"];
   if (typeof contentType === "string" && !contentType.startsWith("application/json")) {
     return false;
   }
@@ -506,6 +505,15 @@ var isApiErrorResponse = (response) => {
   }
   return false;
 };
+var getRequestId = (err) => {
+  const headers = err.response?.headers;
+  if (headers == null)
+    return "";
+  const requestId = headers["seam-request-id"];
+  if (requestId == null)
+    return "";
+  return requestId;
+};
 
 // src/lib/seam/connect/resolve-action-attempt.ts
 var resolveActionAttempt = async (actionAttempt, actionAttempts, { timeout = 5e3, pollingInterval = 500 }) => {
@@ -598,30 +606,25 @@ var paramsSerializer = (params) => {
         );
       }
       for (const v of value) {
-        throwIfUnserializable(name, v);
-        searchParams.append(name, v);
+        searchParams.append(name, serialize(name, v));
       }
       continue;
     }
-    throwIfUnserializable(name, value);
-    searchParams.set(name, value);
+    searchParams.set(name, serialize(name, value));
   }
   searchParams.sort();
   return searchParams.toString();
 };
-var throwIfUnserializable = (k, v) => {
-  if (v == null) {
-    throw new UnserializableParamError(k, `is ${v} or contains ${v}`);
-  }
-  if (typeof v === "function") {
-    throw new UnserializableParamError(
-      k,
-      "is a function or contains a function"
-    );
-  }
-  if (typeof v === "object") {
-    throw new UnserializableParamError(k, "is an object or contains an object");
-  }
+var serialize = (k, v) => {
+  if (typeof v === "string")
+    return v.toString();
+  if (typeof v === "number")
+    return v.toString();
+  if (typeof v === "bigint")
+    return v.toString();
+  if (typeof v === "boolean")
+    return v.toString();
+  throw new UnserializableParamError(k, `is a ${typeof v}`);
 };
 var UnserializableParamError = class extends Error {
   constructor(name, message) {
@@ -1097,6 +1100,153 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
   }
 };
 
+// src/lib/seam/connect/routes/acs-credential-pools.ts
+var SeamHttpAcsCredentialPools = class _SeamHttpAcsCredentialPools {
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAcsCredentialPools(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsCredentialPools(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsCredentialPools(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpAcsCredentialPools.fromClientSessionToken(token, options);
+  }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsCredentialPools(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsCredentialPools(constructorOptions);
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/acs/credential_pools/list",
+      method: "post",
+      data: body
+    });
+    return data.acs_credential_pools;
+  }
+};
+
+// src/lib/seam/connect/routes/acs-credential-provisioning-automations.ts
+var SeamHttpAcsCredentialProvisioningAutomations = class _SeamHttpAcsCredentialProvisioningAutomations {
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAcsCredentialProvisioningAutomations(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsCredentialProvisioningAutomations(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsCredentialProvisioningAutomations(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpAcsCredentialProvisioningAutomations.fromClientSessionToken(
+      token,
+      options
+    );
+  }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsCredentialProvisioningAutomations(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsCredentialProvisioningAutomations(constructorOptions);
+  }
+  async launch(body) {
+    const { data } = await this.client.request(
+      {
+        url: "/acs/credential_provisioning_automations/launch",
+        method: "post",
+        data: body
+      }
+    );
+    return data.acs_credential_provisioning_automation;
+  }
+};
+
 // src/lib/seam/connect/routes/acs-credentials.ts
 var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
   constructor(apiKeyOrOptions = {}) {
@@ -1215,6 +1365,92 @@ var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
   }
 };
 
+// src/lib/seam/connect/routes/acs-entrances.ts
+var SeamHttpAcsEntrances = class _SeamHttpAcsEntrances {
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAcsEntrances(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsEntrances(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsEntrances(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpAcsEntrances.fromClientSessionToken(token, options);
+  }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsEntrances(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsEntrances(constructorOptions);
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/acs/entrances/get",
+      method: "post",
+      data: body
+    });
+    return data.acs_entrance;
+  }
+  async grantAccess(body) {
+    await this.client.request({
+      url: "/acs/entrances/grant_access",
+      method: "post",
+      data: body
+    });
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/acs/entrances/list",
+      method: "post",
+      data: body
+    });
+    return data.acs_entrances;
+  }
+};
+
 // src/lib/seam/connect/routes/acs-systems.ts
 var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
   constructor(apiKeyOrOptions = {}) {
@@ -1487,9 +1723,21 @@ var SeamHttpAcs = class _SeamHttpAcs {
   get accessGroups() {
     return SeamHttpAcsAccessGroups.fromClient(this.client, this.defaults);
   }
+  get credentialPools() {
+    return SeamHttpAcsCredentialPools.fromClient(this.client, this.defaults);
+  }
+  get credentialProvisioningAutomations() {
+    return SeamHttpAcsCredentialProvisioningAutomations.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
   get credentials() {
     return SeamHttpAcsCredentials.fromClient(this.client, this.defaults);
   }
+  get entrances() {
+    return SeamHttpAcsEntrances.fromClient(this.client, this.defaults);
+  }
   get systems() {
     return SeamHttpAcsSystems.fromClient(this.client, this.defaults);
   }
@@ -1773,6 +2021,16 @@ var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
     });
     return data.connected_accounts;
   }
+  async update(body) {
+    const { data } = await this.client.request(
+      {
+        url: "/connected_accounts/update",
+        method: "post",
+        data: body
+      }
+    );
+    return data.connected_account;
+  }
 };
 
 // src/lib/seam/connect/routes/devices-unmanaged.ts
@@ -3045,7 +3303,10 @@ exports.SeamHttpAccessCodes = SeamHttpAccessCodes;
 exports.SeamHttpAccessCodesUnmanaged = SeamHttpAccessCodesUnmanaged;
 exports.SeamHttpAcs = SeamHttpAcs;
 exports.SeamHttpAcsAccessGroups = SeamHttpAcsAccessGroups;
+exports.SeamHttpAcsCredentialPools = SeamHttpAcsCredentialPools;
+exports.SeamHttpAcsCredentialProvisioningAutomations = SeamHttpAcsCredentialProvisioningAutomations;
 exports.SeamHttpAcsCredentials = SeamHttpAcsCredentials;
+exports.SeamHttpAcsEntrances = SeamHttpAcsEntrances;
 exports.SeamHttpAcsSystems = SeamHttpAcsSystems;
 exports.SeamHttpAcsUsers = SeamHttpAcsUsers;
 exports.SeamHttpActionAttempts = SeamHttpActionAttempts;