@cubist-labs/cubesigner-sdk 0.4.237 → 0.4.241

package/src/client/base_client.ts

@@ -9,6 +9,7 @@ import type { SessionData, SessionManager, SessionMetadata } from "./session";
 import { MemorySessionManager, metadata, parseBase64SessionData } from "./session";
 import type { NewSessionResponse, ErrorResponse } from "../schema_types";
 import type { EnvInterface } from "../env";
+import { mergeHeaders } from "openapi-fetch";
 
 /** CubeSigner SDK package name */
 export const NAME: string = pkg.name;
@@ -163,14 +164,16 @@ export class BaseClient extends EventEmitter<ClientEvents> {
       // If we have an activeSession, let it dictate the baseUrl. Otherwise fall back to the one set at construction
       baseUrl,
       ...opts,
-      headers: {
-        "User-Agent": browserUserAgent ?? `${NAME}@${VERSION}`,
-        "X-Cubist-Ts-Sdk": `${NAME}@${VERSION}`,
-        Origin: this.config.origin,
-        Authorization: token,
-        ...(this.config.headers ?? {}),
-        ...opts.headers,
-      },
+      headers: mergeHeaders(
+        {
+          "User-Agent": browserUserAgent ?? `${NAME}@${VERSION}`,
+          "X-Cubist-Ts-Sdk": `${NAME}@${VERSION}`,
+          Origin: this.config.origin,
+        },
+        authHeader(token),
+        this.config.headers,
+        opts.headers,
+      ),
       params: {
         ...opts.params,
         path: {
@@ -308,3 +311,13 @@ export type OmitAutoParams<O> = DeepOmit<
     params: { path: { org_id: string } };
   }
 > & { params?: { path?: Record<string, unknown> } };
+
+/**
+ * Creates {@link HeadersInit} containing a single "Authorization" header with a given value.
+ *
+ * @param token The "Authorization" header value
+ * @returns A {@link HeadersInit} object containing a single "Authorization" header with a given value.
+ */
+export function authHeader(token: string): HeadersInit {
+  return { Authorization: token };
+}

package/src/client.ts

@@ -1,19 +1,11 @@
 import { ApiClient } from "./client/api_client";
-import type { IdentityProof, RatchetConfig, EmailOtpResponse } from "./schema_types";
+import type { EmailOtpResponse, IdentityProof, RatchetConfig } from "./schema_types";
 
 // used in doc comments
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { AddFidoChallenge, TotpChallenge } from "./mfa";
 import { Org } from "./org";
-import type {
-  CubeSignerResponse,
-  EnvInterface,
-  MfaReceipts,
-  Scope,
-  SessionData,
-  SessionInfo,
-  SessionManager,
-} from ".";
+import type { MfaReceipts, SessionData, SessionInfo, SessionManager } from ".";
 import { Key } from ".";
 
 /** Options for logging in with OIDC token */
@@ -122,71 +114,45 @@ export class CubeSignerClient {
   }
 
   /**
-   * Exchange an OIDC token for a CubeSigner session token.
-   *
-   * @param env The environment to log into
-   * @param orgId The org to log into.
-   * @param token The OIDC token to exchange
-   * @param scopes The scopes for the new session
-   * @param lifetimes Lifetimes of the new session.
-   * @param mfaReceipt Optional MFA receipt(s)
-   * @param purpose Optional session description.
-   * @returns The session data.
+   * Create a new OIDC-backed session.
+   *
+   * Same as {@link ApiClient.oidcSessionCreate}, see its documentation for more details.
+   *
+   * @param args Request arguments
+   * @returns The new session data
    */
   static async createOidcSession(
-    env: EnvInterface,
-    orgId: string,
-    token: string,
-    scopes: Array<Scope>,
-    lifetimes?: RatchetConfig,
-    mfaReceipt?: MfaReceipts,
-    purpose?: string,
-  ): Promise<CubeSignerResponse<SessionData>> {
-    return await ApiClient.oidcSessionCreate(
-      env,
-      orgId,
-      token,
-      scopes,
-      lifetimes,
-      mfaReceipt,
-      purpose,
-    );
+    ...args: Parameters<typeof ApiClient.oidcSessionCreate>
+  ): Promise<Awaited<ReturnType<typeof ApiClient.oidcSessionCreate>>> {
+    return await ApiClient.oidcSessionCreate(...args);
   }
 
   /**
-   * Exchange an OIDC token for a proof of authentication.
+   * Prove an OIDC identity.
+   *
+   * Same as {@link ApiClient.identityProveOidc}, see its documentation for more details.
    *
-   * @param env The environment to log into
-   * @param orgId The org id in which to generate proof
-   * @param token The oidc token
+   * @param args Request arguments
    * @returns Proof of authentication
    */
   static async proveOidcIdentity(
-    env: EnvInterface,
-    orgId: string,
-    token: string,
+    ...args: Parameters<typeof ApiClient.identityProveOidc>
   ): Promise<IdentityProof> {
-    return await ApiClient.identityProveOidc(env, orgId, token);
+    return await ApiClient.identityProveOidc(...args);
   }
 
   /**
-   * Initiates login via Email OTP.
-   * Returns an unsigned OIDC token and sends an email to the user containing the signature of that token.
-   * The OIDC token can be reconstructed by appending the signature to the partial token like so:
+   * Initialize email OTP authentication.
    *
-   * token = partial_token + signature
+   * Same as {@link ApiClient.initEmailOtpAuth}, see its documentation for more details.
    *
-   * @param env The environment to use
-   * @param orgId The org to login to
-   * @param email The email to send the signature to
-   * @returns The partial OIDC token that must be combined with the signature in the email
+   * @param args Request arguments
+   * @returns — The partial OIDC token that must be combined with the signature in the email
    */
   static async initEmailOtpAuth(
-    env: EnvInterface,
-    orgId: string,
-    email: string,
+    ...args: Parameters<typeof ApiClient.initEmailOtpAuth>
   ): Promise<EmailOtpResponse> {
-    return await ApiClient.initEmailOtpAuth(env, orgId, email);
+    return await ApiClient.initEmailOtpAuth(...args);
   }
 
   /**

package/src/schema_types.ts

@@ -221,7 +221,7 @@ export type QueryMetricsRequest = schemas["QueryMetricsRequest"];
 export type QueryMetricsResponse = schemas["QueryMetricsResponse"];
 export type AuditLogRequest = schemas["AuditLogRequest"];
 export type AuditLogResponse = schemas["PaginatedAuditLogResponse"];
-export type AuditLogEntry = schemas["AuditLogEntry"];
+export type { AuditLogEntry } from "./audit_log";
 
 export type DiffieHellmanRequest = schemas["DiffieHellmanRequest"];
 export type DiffieHellmanResponse = schemas["DiffieHellmanResponse"];