@adobe/aio-commerce-lib-auth 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @adobe/aio-commerce-lib-auth
 
+## 0.3.2
+
+### Patch Changes
+
+- [`08edb37`](https://github.com/adobe/aio-commerce-sdk/commit/08edb372c6b1a97ffed26d5f84b1c189bd6bd330) Thanks [@jnatherley](https://github.com/jnatherley)! - `ImsAuthConfig.context` could be received as `undefined` by the `context.set` method, after an `assertImsAuthParams` due to us discarding the Valibot output (which was setting a default). Now, the value is manually defaulted if not set.
+
+- [`0b37a82`](https://github.com/adobe/aio-commerce-sdk/commit/0b37a821f3a7d8c8acd1d2bb16e12b55a5ec7c71) Thanks [@iivvaannxx](https://github.com/iivvaannxx)! - Fix small typo in validation message of `stringArray` schema.
+
+## 0.3.1
+
+### Patch Changes
+
+- Updated dependencies [[`4b75585`](https://github.com/adobe/aio-commerce-sdk/commit/4b75585c0d27bd472de3277be5ddaf6a977664de)]:
+  - @adobe/aio-commerce-lib-core@0.4.0
+
 ## 0.3.0
 
 ### Minor Changes

package/README.md

@@ -7,15 +7,6 @@ Authentication utilities for Adobe Commerce apps deployed in Adobe App Builder.
 
 This library provides a unified interface for authentication in Adobe Commerce App Builder applications, supporting multiple authentication mechanisms required for different integration scenarios.
 
-## Overview
-
-The library supports two main authentication providers:
-
-- **IMS Provider**: For authenticating users or services via Adobe Identity Management System (IMS) using OAuth2
-- **Integrations Provider**: For authenticating with Adobe Commerce integrations using OAuth 1.0a
-
-These providers abstract the complexity of authentication, making it easy to obtain and use access tokens in your App Builder applications.
-
 ## Installation
 
 ```shell
@@ -24,114 +15,7 @@ pnpm install @adobe/aio-commerce-lib-auth
 
 ## Usage
 
-In your App Builder application, you can use the library to authenticate users or services and obtain access tokens.
-
-### IMS Provider
-
-```typescript
-import {
-  assertImsAuthParams,
-  getImsAuthProvider,
-} from "@adobe/aio-commerce-lib-auth";
-
-import { CommerceSdkValidationError } from "@adobe/aio-commerce-lib-core";
-
-export const main = async function (params: Record<string, unknown>) {
-  try {
-    // Validate parameters and get the IMS auth provider
-    assertImsAuthParams(params);
-    const imsAuthProvider = getImsAuthProvider(params);
-
-    const token = await imsAuthProvider.getAccessToken();
-    const headers = await imsAuthProvider.getHeaders();
-
-    // Use headers in your API calls
-    // business logic e.g requesting orders
-    return { statusCode: 200 };
-  } catch (error) {
-    if (error instanceof CommerceSdkValidationError) {
-      return {
-        statusCode: 400,
-        body: {
-          error: `Invalid IMS configuration: ${error.message}`,
-        },
-      };
-    }
-    throw error;
-  }
-};
-```
-
-### Integrations Provider
-
-```typescript
-import {
-  assertIntegrationAuthParams,
-  getIntegrationAuthProvider,
-} from "@adobe/aio-commerce-lib-auth";
-
-import { CommerceSdkValidationError } from "@adobe/aio-commerce-lib-core";
-
-export const main = async function (params: Record<string, unknown>) {
-  try {
-    // Validate parameters and get the integration auth provider
-    assertIntegrationAuthParams(params);
-    const integrationsAuth = getIntegrationAuthProvider(params);
-
-    // Get OAuth headers for API requests
-    const headers = integrationsAuth.getHeaders(
-      "GET",
-      "http://localhost/rest/V1/orders",
-    );
-
-    // Use headers in your API calls
-    // business logic e.g requesting orders
-    return { statusCode: 200 };
-  } catch (error) {
-    if (error instanceof CommerceSdkValidationError) {
-      return {
-        statusCode: 400,
-        body: {
-          error: `Invalid Integration configuration: ${error.message}`,
-        },
-      };
-    }
-    throw error;
-  }
-};
-```
-
-## Error Handling
-
-The library uses validation to ensure all required parameters are provided and correctly formatted. When validation fails, a `CommerceSdkValidationError` is thrown with detailed information about what went wrong.
-
-```typescript
-import { CommerceSdkValidationError } from "@adobe/aio-commerce-lib-core/error";
-
-try {
-  assertImsAuthParams({
-    clientId: "valid-id",
-    // Missing required fields
-  });
-} catch (error) {
-  if (error instanceof CommerceSdkValidationError) {
-    console.error(error.display());
-    // Output:
-    // Invalid ImsAuthProvider configuration
-    // ├── Schema validation error at clientSecrets → Expected at least one client secret for IMS auth
-    // ├── Schema validation error at technicalAccountId → Expected a non-empty string value for the IMS auth parameter technicalAccountId
-    // └── Schema validation error at technicalAccountEmail → Expected a valid email format for technicalAccountEmail
-  }
-}
-```
-
-## Best Practices
-
-1. **Always validate parameters** - Use the `assert*` functions before creating providers
-2. **Handle errors gracefully** - Catch and properly handle validation and authentication errors
-3. **Store credentials securely** - Use environment variables or secure configuration management
-4. **Cache tokens when possible** - The IMS provider handles token lifecycle internally
-5. **Use TypeScript** - Leverage the full type safety provided by the library
+See the [Usage Guide](./docs/usage.md) for more information.
 
 ## Contributing
 

package/dist/cjs/index.cjs

@@ -1,78 +1,44 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
+/**
+* @license
+* 
+* Copyright 2025 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __copyProps = (to, from, except, desc) => {
+	if (from && typeof from == "object" || typeof from == "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) key = keys[i], !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+		get: ((k) => from[k]).bind(null, key),
+		enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+	});
 	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+}, __toESM = (mod, isNodeMode, target) => (target = mod == null ? {} : __create(__getProtoOf(mod)), __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
 	value: mod,
-	enumerable: true
+	enumerable: !0
 }) : target, mod));
-
-//#endregion
-const __adobe_aio_commerce_lib_core_error = __toESM(require("@adobe/aio-commerce-lib-core/error"));
-const __adobe_aio_lib_ims = __toESM(require("@adobe/aio-lib-ims"));
-const valibot = __toESM(require("valibot"));
-const node_crypto = __toESM(require("node:crypto"));
-const oauth_1_0a = __toESM(require("oauth-1.0a"));
-
-//#region source/lib/ims-auth/schema.ts
-/**
-* Creates a validation schema for a required IMS auth string parameter.
-* @param name The name of the parameter for error messages.
-* @returns A validation pipeline that ensures the parameter is a non-empty string.
-*/
-const imsAuthParameter = (name) => (0, valibot.pipe)((0, valibot.string)(`Expected a string value for the IMS auth parameter ${name}`), (0, valibot.nonEmpty)(`Expected a non-empty string value for the IMS auth parameter ${name}`));
-/**
-* Creates a validation schema for an IMS auth string array parameter.
-* @param name The name of the parameter for error messages.
-* @returns A validation pipeline that ensures the parameter is an array of strings.
-*/
-const stringArray = (name) => {
-	return (0, valibot.pipe)((0, valibot.array)((0, valibot.string)(), `Expected a stringified JSON array value for the IMS auth parameter ${name}`));
-};
-/** The environments accepted by the IMS auth service. */
-const IMS_AUTH_ENV = {
+const __adobe_aio_commerce_lib_core_error = __toESM(require("@adobe/aio-commerce-lib-core/error")), __adobe_aio_lib_ims = __toESM(require("@adobe/aio-lib-ims")), valibot = __toESM(require("valibot")), crypto = __toESM(require("crypto")), oauth_1_0a = __toESM(require("oauth-1.0a")), imsAuthParameter = (name) => (0, valibot.pipe)((0, valibot.string)(`Expected a string value for the IMS auth parameter ${name}`), (0, valibot.nonEmpty)(`Expected a non-empty string value for the IMS auth parameter ${name}`)), stringArray = (name) => (0, valibot.pipe)((0, valibot.array)((0, valibot.string)(), `Expected a string array value for the IMS auth parameter ${name}`)), IMS_AUTH_ENV = {
 	PROD: "prod",
 	STAGE: "stage"
-};
-/** Validation schema for IMS auth environment values. */
-const ImsAuthEnvSchema = (0, valibot.enum)(IMS_AUTH_ENV);
-/** Defines the schema to validate the necessary parameters for the IMS auth service. */
-const ImsAuthParamsSchema = (0, valibot.object)({
+}, ImsAuthEnvSchema = (0, valibot.enum)(IMS_AUTH_ENV), ImsAuthParamsSchema = (0, valibot.object)({
 	clientId: imsAuthParameter("clientId"),
 	clientSecrets: (0, valibot.pipe)(stringArray("clientSecrets"), (0, valibot.minLength)(1, "Expected at least one client secret for IMS auth")),
 	technicalAccountId: imsAuthParameter("technicalAccountId"),
 	technicalAccountEmail: (0, valibot.pipe)((0, valibot.string)("Expected a string value for the IMS auth parameter technicalAccountEmail"), (0, valibot.email)("Expected a valid email format for technicalAccountEmail")),
 	imsOrgId: imsAuthParameter("imsOrgId"),
 	environment: (0, valibot.pipe)((0, valibot.optional)(ImsAuthEnvSchema, IMS_AUTH_ENV.PROD)),
-	context: (0, valibot.pipe)((0, valibot.optional)((0, valibot.string)(), "aio-commerce-sdk-creds")),
+	context: (0, valibot.pipe)((0, valibot.optional)((0, valibot.string)())),
 	scopes: (0, valibot.pipe)(stringArray("scopes"), (0, valibot.minLength)(1, "Expected at least one scope for IMS auth"))
 });
-
-//#endregion
-//#region source/lib/ims-auth/provider.ts
-/**
-* Converts IMS auth configuration properties to snake_case format.
-* @param config The IMS auth configuration with camelCase properties.
-* @returns The configuration with snake_case properties.
-*/
 function toImsAuthConfig(config) {
 	return {
 		scopes: config.scopes,
 		env: config?.environment ?? "prod",
-		context: config.context,
+		context: config.context ?? "aio-commerce-lib-auth-creds",
 		client_id: config.clientId,
 		client_secrets: config.clientSecrets,
 		technical_account_id: config.technicalAccountId,
@@ -80,90 +46,16 @@ function toImsAuthConfig(config) {
 		ims_org_id: config.imsOrgId
 	};
 }
-/**
-* Asserts the provided configuration for an Adobe IMS authentication provider. {@link ImsAuthParams}
-* {@link ImsAuthProvider}
-* @param config {Record<PropertyKey, unknown>} The configuration to validate.
-* @throws {CommerceSdkValidationError} If the configuration is invalid.
-* @example
-* ```typescript
-* const config = {
-*   clientId: "your-client-id",
-*   clientSecrets: ["your-client-secret"],
-*   technicalAccountId: "your-technical-account-id",
-*   technicalAccountEmail: "your-account@example.com",
-*   imsOrgId: "your-ims-org-id@AdobeOrg",
-*   scopes: ["AdobeID", "openid"],
-*   environment: "prod", // or "stage"
-*   context: "my-app-context"
-* };
-*
-* // This will validate the config and throw if invalid
-* assertImsAuthParams(config);
-*```
-* @example
-* ```typescript
-* // Example of a failing assert:
-* try {
-*   assertImsAuthParams({
-*     clientId: "valid-client-id",
-*     // Missing required fields like clientSecrets, technicalAccountId, etc.
-*   });
-* } catch (error) {
-*   console.error(error.message); // "Invalid ImsAuthProvider configuration"
-*   console.error(error.issues); // Array of validation issues
-* }
-* ```
-*/
 function assertImsAuthParams(config) {
-	const result = (0, valibot.safeParse)(ImsAuthParamsSchema, config);
+	let result = (0, valibot.safeParse)(ImsAuthParamsSchema, config);
 	if (!result.success) throw new __adobe_aio_commerce_lib_core_error.CommerceSdkValidationError("Invalid ImsAuthProvider configuration", { issues: result.issues });
 }
-/**
-* Creates an {@link ImsAuthProvider} based on the provided configuration.
-* @param config An {@link ImsAuthParams} parameter that contains the configuration for the IMS auth provider.
-* @returns An {@link ImsAuthProvider} instance that can be used to get access token and auth headers.
-* @example
-* ```typescript
-* const config = {
-*   clientId: "your-client-id",
-*   clientSecrets: ["your-client-secret"],
-*   technicalAccountId: "your-technical-account-id",
-*   technicalAccountEmail: "your-account@example.com",
-*   imsOrgId: "your-ims-org-id@AdobeOrg",
-*   scopes: ["AdobeID", "openid"],
-*   environment: "prod",
-*   context: "my-app-context"
-* };
-*
-* const authProvider = getImsAuthProvider(config);
-*
-* // Get access token
-* const token = await authProvider.getAccessToken();
-* console.log(token); // "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9..."
-*
-* // Get headers for API requests
-* const headers = await authProvider.getHeaders();
-* console.log(headers);
-* // {
-* //   Authorization: "Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...",
-* //   "x-api-key": "your-client-id"
-* // }
-*
-* // Use headers in API calls
-* const response = await fetch('https://api.adobe.io/some-endpoint', {
-*   headers: await authProvider.getHeaders()
-* });
-* ```
-*/
 function getImsAuthProvider(authParams) {
-	const getAccessToken = async () => {
-		const imsAuthConfig = toImsAuthConfig(authParams);
-		await __adobe_aio_lib_ims.context.set(authParams.context, imsAuthConfig);
-		return (0, __adobe_aio_lib_ims.getToken)(authParams.context, {});
-	};
-	const getHeaders = async () => {
-		const accessToken = await getAccessToken();
+	let getAccessToken = async () => {
+		let imsAuthConfig = toImsAuthConfig(authParams);
+		return await __adobe_aio_lib_ims.context.set(imsAuthConfig.context, imsAuthConfig), (0, __adobe_aio_lib_ims.getToken)(imsAuthConfig.context, {});
+	}, getHeaders = async () => {
+		let accessToken = await getAccessToken();
 		return {
 			Authorization: `Bearer ${accessToken}`,
 			"x-api-key": authParams.clientId
@@ -174,119 +66,34 @@ function getImsAuthProvider(authParams) {
 		getHeaders
 	};
 }
-
-//#endregion
-//#region source/lib/integration-auth/schema.ts
-/**
-* Creates a validation schema for a required Commerce Integration string parameter.
-* @param name The name of the parameter for error messages.
-* @returns A validation pipeline that ensures the parameter is a non-empty string.
-*/
-const integrationAuthParameter = (name) => (0, valibot.pipe)((0, valibot.string)(`Expected a string value for the Commerce Integration parameter ${name}`), (0, valibot.nonEmpty)(`Expected a non-empty string value for the Commerce Integration parameter ${name}`));
-/** Validation schema for the Adobe Commerce endpoint base URL. */
-const BaseUrlSchema = (0, valibot.pipe)((0, valibot.string)("Expected a string for the Adobe Commerce endpoint"), (0, valibot.nonEmpty)("Expected a non-empty string for the Adobe Commerce endpoint"), (0, valibot.url)("Expected a valid url for the Adobe Commerce endpoint"));
-/** Validation schema that accepts either a URL string or URL instance and normalizes to string. */
-const UrlSchema = (0, valibot.pipe)((0, valibot.union)([BaseUrlSchema, (0, valibot.instance)(URL)]), (0, valibot.transform)((url) => {
-	if (url instanceof URL) return url.toString();
-	return url;
-}));
-/**
-* The schema for the Commerce Integration parameters.
-* This is used to validate the parameters passed to the Commerce Integration provider.
-*/
-const IntegrationAuthParamsSchema = (0, valibot.nonOptional)((0, valibot.object)({
+const integrationAuthParameter = (name) => (0, valibot.pipe)((0, valibot.string)(`Expected a string value for the Commerce Integration parameter ${name}`), (0, valibot.nonEmpty)(`Expected a non-empty string value for the Commerce Integration parameter ${name}`)), BaseUrlSchema = (0, valibot.pipe)((0, valibot.string)("Expected a string for the Adobe Commerce endpoint"), (0, valibot.nonEmpty)("Expected a non-empty string for the Adobe Commerce endpoint"), (0, valibot.url)("Expected a valid url for the Adobe Commerce endpoint")), UrlSchema = (0, valibot.pipe)((0, valibot.union)([BaseUrlSchema, (0, valibot.instance)(URL)]), (0, valibot.transform)((url) => url instanceof URL ? url.toString() : url)), IntegrationAuthParamsSchema = (0, valibot.nonOptional)((0, valibot.object)({
 	consumerKey: integrationAuthParameter("consumerKey"),
 	consumerSecret: integrationAuthParameter("consumerSecret"),
 	accessToken: integrationAuthParameter("accessToken"),
 	accessTokenSecret: integrationAuthParameter("accessTokenSecret")
 }));
-
-//#endregion
-//#region source/lib/integration-auth/provider.ts
-/**
-* Asserts the provided configuration for an Adobe Commerce integration authentication provider. {@link IntegrationAuthParams}
-* {@link IntegrationAuthProvider}
-* @param config {Record<PropertyKey, unknown>} The configuration to validate.
-* @throws {CommerceSdkValidationError} If the configuration is invalid.
-* @example
-* ```typescript
-* const config = {
-*   consumerKey: "your-consumer-key",
-*   consumerSecret: "your-consumer-secret",
-*   accessToken: "your-access-token",
-*   accessTokenSecret: "your-access-token-secret"
-* };
-*
-* // This will validate the config and throw if invalid
-* assertIntegrationAuthParams(config);
-* ```
-* @example
-* ```typescript
-* // Example of a failing assert:
-* try {
-*   assertIntegrationAuthParams({
-*     consumerKey: "valid-consumer-key",
-*     // Missing required fields like consumerSecret, accessToken, accessTokenSecret
-*   });
-* } catch (error) {
-*   console.error(error.message); // "Invalid IntegrationAuthProvider configuration"
-*   console.error(error.issues); // Array of validation issues
-* }
-* ```
-*/
 function assertIntegrationAuthParams(config) {
-	const result = (0, valibot.safeParse)(IntegrationAuthParamsSchema, config);
+	let result = (0, valibot.safeParse)(IntegrationAuthParamsSchema, config);
 	if (!result.success) throw new __adobe_aio_commerce_lib_core_error.CommerceSdkValidationError("Invalid IntegrationAuthProvider configuration", { issues: result.issues });
 }
-/**
-* Creates an {@link IntegrationAuthProvider} based on the provided configuration.
-* @param config {IntegrationAuthParams} The configuration for the integration.
-* @returns An {@link IntegrationAuthProvider} instance that can be used to get auth headers.
-* @example
-* ```typescript
-* const config = {
-*   consumerKey: "your-consumer-key",
-*   consumerSecret: "your-consumer-secret",
-*   accessToken: "your-access-token",
-*   accessTokenSecret: "your-access-token-secret"
-* };
-*
-* const authProvider = getIntegrationAuthProvider(config);
-*
-* // Get OAuth headers for a REST API call
-* const headers = authProvider.getHeaders("GET", "https://your-store.com/rest/V1/products");
-* console.log(headers); // { Authorization: "OAuth oauth_consumer_key=..., oauth_signature=..." }
-*
-* // Can also be used with URL objects
-* const url = new URL("https://your-store.com/rest/V1/customers");
-* const postHeaders = authProvider.getHeaders("POST", url);
-* ```
-*/
 function getIntegrationAuthProvider(authParams) {
-	const oauth = new oauth_1_0a.default({
+	let oauth = new oauth_1_0a.default({
 		consumer: {
 			key: authParams.consumerKey,
 			secret: authParams.consumerSecret
 		},
 		signature_method: "HMAC-SHA256",
-		hash_function: (baseString, key) => node_crypto.default.createHmac("sha256", key).update(baseString).digest("base64")
-	});
-	const oauthToken = {
+		hash_function: (baseString, key) => crypto.default.createHmac("sha256", key).update(baseString).digest("base64")
+	}), oauthToken = {
 		key: authParams.accessToken,
 		secret: authParams.accessTokenSecret
 	};
 	return { getHeaders: (method, url) => {
-		const urlString = url instanceof URL ? url.toString() : url;
+		let urlString = url instanceof URL ? url.toString() : url;
 		return oauth.toHeader(oauth.authorize({
 			url: urlString,
 			method
 		}, oauthToken));
 	} };
 }
-
-//#endregion
-exports.IMS_AUTH_ENV = IMS_AUTH_ENV;
-exports.assertImsAuthParams = assertImsAuthParams;
-exports.assertIntegrationAuthParams = assertIntegrationAuthParams;
-exports.getImsAuthProvider = getImsAuthProvider;
-exports.getIntegrationAuthProvider = getIntegrationAuthProvider;
+exports.IMS_AUTH_ENV = IMS_AUTH_ENV, exports.assertImsAuthParams = assertImsAuthParams, exports.assertIntegrationAuthParams = assertIntegrationAuthParams, exports.getImsAuthProvider = getImsAuthProvider, exports.getIntegrationAuthProvider = getIntegrationAuthProvider;

package/dist/cjs/index.d.cts

@@ -1,39 +1,132 @@
-import * as valibot24 from "valibot";
+/**
+ * @license
+ * 
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import * as valibot21 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region source/lib/ims-auth/schema.d.ts
+/** The environments accepted by the IMS auth service. */
 declare const IMS_AUTH_ENV: {
   readonly PROD: "prod";
   readonly STAGE: "stage";
 };
-declare const ImsAuthEnvSchema: valibot24.EnumSchema<{
+/** Validation schema for IMS auth environment values. */
+declare const ImsAuthEnvSchema: valibot21.EnumSchema<{
   readonly PROD: "prod";
   readonly STAGE: "stage";
 }, undefined>;
-declare const ImsAuthParamsSchema: valibot24.ObjectSchema<{
-  readonly clientId: valibot24.SchemaWithPipe<readonly [valibot24.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot24.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
-  readonly clientSecrets: valibot24.SchemaWithPipe<readonly [valibot24.SchemaWithPipe<readonly [valibot24.ArraySchema<valibot24.StringSchema<undefined>, `Expected a stringified JSON array value for the IMS auth parameter ${string}`>]>, valibot24.MinLengthAction<string[], 1, "Expected at least one client secret for IMS auth">]>;
-  readonly technicalAccountId: valibot24.SchemaWithPipe<readonly [valibot24.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot24.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
-  readonly technicalAccountEmail: valibot24.SchemaWithPipe<readonly [valibot24.StringSchema<"Expected a string value for the IMS auth parameter technicalAccountEmail">, valibot24.EmailAction<string, "Expected a valid email format for technicalAccountEmail">]>;
-  readonly imsOrgId: valibot24.SchemaWithPipe<readonly [valibot24.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot24.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
-  readonly environment: valibot24.SchemaWithPipe<readonly [valibot24.OptionalSchema<valibot24.EnumSchema<{
+/** Defines the schema to validate the necessary parameters for the IMS auth service. */
+declare const ImsAuthParamsSchema: valibot21.ObjectSchema<{
+  readonly clientId: valibot21.SchemaWithPipe<readonly [valibot21.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot21.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
+  readonly clientSecrets: valibot21.SchemaWithPipe<readonly [valibot21.SchemaWithPipe<readonly [valibot21.ArraySchema<valibot21.StringSchema<undefined>, `Expected a string array value for the IMS auth parameter ${string}`>]>, valibot21.MinLengthAction<string[], 1, "Expected at least one client secret for IMS auth">]>;
+  readonly technicalAccountId: valibot21.SchemaWithPipe<readonly [valibot21.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot21.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
+  readonly technicalAccountEmail: valibot21.SchemaWithPipe<readonly [valibot21.StringSchema<"Expected a string value for the IMS auth parameter technicalAccountEmail">, valibot21.EmailAction<string, "Expected a valid email format for technicalAccountEmail">]>;
+  readonly imsOrgId: valibot21.SchemaWithPipe<readonly [valibot21.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot21.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
+  readonly environment: valibot21.SchemaWithPipe<readonly [valibot21.OptionalSchema<valibot21.EnumSchema<{
     readonly PROD: "prod";
     readonly STAGE: "stage";
   }, undefined>, "prod">]>;
-  readonly context: valibot24.SchemaWithPipe<readonly [valibot24.OptionalSchema<valibot24.StringSchema<undefined>, "aio-commerce-sdk-creds">]>;
-  readonly scopes: valibot24.SchemaWithPipe<readonly [valibot24.SchemaWithPipe<readonly [valibot24.ArraySchema<valibot24.StringSchema<undefined>, `Expected a stringified JSON array value for the IMS auth parameter ${string}`>]>, valibot24.MinLengthAction<string[], 1, "Expected at least one scope for IMS auth">]>;
+  readonly context: valibot21.SchemaWithPipe<readonly [valibot21.OptionalSchema<valibot21.StringSchema<undefined>, undefined>]>;
+  readonly scopes: valibot21.SchemaWithPipe<readonly [valibot21.SchemaWithPipe<readonly [valibot21.ArraySchema<valibot21.StringSchema<undefined>, `Expected a string array value for the IMS auth parameter ${string}`>]>, valibot21.MinLengthAction<string[], 1, "Expected at least one scope for IMS auth">]>;
 }, undefined>;
+/** Defines the parameters for the IMS auth service. */
 type ImsAuthParams = InferOutput<typeof ImsAuthParamsSchema>;
+/** Defines the environments accepted by the IMS auth service. */
 type ImsAuthEnv = InferOutput<typeof ImsAuthEnvSchema>;
 //#endregion
 //#region source/lib/ims-auth/provider.d.ts
+/** Defines the header keys used for IMS authentication. */
 type ImsAuthHeader = "Authorization" | "x-api-key";
+/** Defines the headers required for IMS authentication. */
 type ImsAuthHeaders = Record<ImsAuthHeader, string>;
+/** Defines an authentication provider for Adobe IMS. */
 interface ImsAuthProvider {
   getAccessToken: () => Promise<string>;
   getHeaders: () => Promise<ImsAuthHeaders>;
 }
+/**
+ * Asserts the provided configuration for an {@link ImsAuthProvider}.
+ * @param config The configuration to validate.
+ * @throws {CommerceSdkValidationError} If the configuration is invalid.
+ * @example
+ * ```typescript
+ * const config = {
+ *   clientId: "your-client-id",
+ *   clientSecrets: ["your-client-secret"],
+ *   technicalAccountId: "your-technical-account-id",
+ *   technicalAccountEmail: "your-account@example.com",
+ *   imsOrgId: "your-ims-org-id@AdobeOrg",
+ *   scopes: ["AdobeID", "openid"],
+ *   environment: "prod", // or "stage"
+ *   context: "my-app-context"
+ * };
+ *
+ * // This will validate the config and throw if invalid
+ * assertImsAuthParams(config);
+ *```
+ * @example
+ * ```typescript
+ * // Example of a failing assert:
+ * try {
+ *   assertImsAuthParams({
+ *     clientId: "valid-client-id",
+ *     // Missing required fields like clientSecrets, technicalAccountId, etc.
+ *   });
+ * } catch (error) {
+ *   console.error(error.message); // "Invalid ImsAuthProvider configuration"
+ *   console.error(error.issues); // Array of validation issues
+ * }
+ * ```
+ */
 declare function assertImsAuthParams(config: Record<PropertyKey, unknown>): asserts config is ImsAuthParams;
+/**
+ * Creates an {@link ImsAuthProvider} based on the provided configuration.
+ * @param authParams An {@link ImsAuthParams} parameter that contains the configuration for the {@link ImsAuthProvider}.
+ * @returns An {@link ImsAuthProvider} instance that can be used to get access token and auth headers.
+ * @example
+ * ```typescript
+ * const config = {
+ *   clientId: "your-client-id",
+ *   clientSecrets: ["your-client-secret"],
+ *   technicalAccountId: "your-technical-account-id",
+ *   technicalAccountEmail: "your-account@example.com",
+ *   imsOrgId: "your-ims-org-id@AdobeOrg",
+ *   scopes: ["AdobeID", "openid"],
+ *   environment: "prod",
+ *   context: "my-app-context"
+ * };
+ *
+ * const authProvider = getImsAuthProvider(config);
+ *
+ * // Get access token
+ * const token = await authProvider.getAccessToken();
+ * console.log(token); // "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9..."
+ *
+ * // Get headers for API requests
+ * const headers = await authProvider.getHeaders();
+ * console.log(headers);
+ * // {
+ * //   Authorization: "Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...",
+ * //   "x-api-key": "your-client-id"
+ * // }
+ *
+ * // Use headers in API calls
+ * const response = await fetch('https://api.adobe.io/some-endpoint', {
+ *   headers: await authProvider.getHeaders()
+ * });
+ * ```
+ */
 declare function getImsAuthProvider(authParams: ImsAuthParams): {
   getAccessToken: () => Promise<string>;
   getHeaders: () => Promise<{
@@ -43,23 +136,92 @@ declare function getImsAuthProvider(authParams: ImsAuthParams): {
 };
 //#endregion
 //#region source/lib/integration-auth/schema.d.ts
+/**
+ * The HTTP methods supported by Commerce.
+ * This is used to determine which headers to include in the signing of the authorization header.
+ */
 type HttpMethodInput = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-declare const IntegrationAuthParamsSchema: valibot24.NonOptionalSchema<valibot24.ObjectSchema<{
-  readonly consumerKey: valibot24.SchemaWithPipe<readonly [valibot24.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot24.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
-  readonly consumerSecret: valibot24.SchemaWithPipe<readonly [valibot24.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot24.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
-  readonly accessToken: valibot24.SchemaWithPipe<readonly [valibot24.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot24.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
-  readonly accessTokenSecret: valibot24.SchemaWithPipe<readonly [valibot24.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot24.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
+/** Validation schema that accepts either a URL string or URL instance and normalizes to string. */
+
+/**
+ * The schema for the Commerce Integration parameters.
+ * This is used to validate the parameters passed to the Commerce Integration provider.
+ */
+declare const IntegrationAuthParamsSchema: valibot21.NonOptionalSchema<valibot21.ObjectSchema<{
+  readonly consumerKey: valibot21.SchemaWithPipe<readonly [valibot21.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot21.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
+  readonly consumerSecret: valibot21.SchemaWithPipe<readonly [valibot21.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot21.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
+  readonly accessToken: valibot21.SchemaWithPipe<readonly [valibot21.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot21.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
+  readonly accessTokenSecret: valibot21.SchemaWithPipe<readonly [valibot21.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot21.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
 }, undefined>, undefined>;
+/** Defines the parameters required for Commerce Integration authentication. */
 type IntegrationAuthParams = InferOutput<typeof IntegrationAuthParamsSchema>;
 //#endregion
 //#region source/lib/integration-auth/provider.d.ts
+/** Defines the header key used for Commerce Integration authentication. */
 type IntegrationAuthHeader = "Authorization";
+/** Defines the headers required for Commerce Integration authentication. */
 type IntegrationAuthHeaders = Record<IntegrationAuthHeader, string>;
+/** Represents a URL for Adobe Commerce endpoints, accepting either string or URL object. */
 type AdobeCommerceUrl = string | URL;
+/** Defines an authentication provider for Adobe Commerce integrations. */
 interface IntegrationAuthProvider {
   getHeaders: (method: HttpMethodInput, url: AdobeCommerceUrl) => IntegrationAuthHeaders;
 }
+/**
+ * Asserts the provided configuration for an Adobe Commerce {@link IntegrationAuthProvider}.
+ * @param config The configuration to validate.
+ * @throws {CommerceSdkValidationError} If the configuration is invalid.
+ * @example
+ * ```typescript
+ * const config = {
+ *   consumerKey: "your-consumer-key",
+ *   consumerSecret: "your-consumer-secret",
+ *   accessToken: "your-access-token",
+ *   accessTokenSecret: "your-access-token-secret"
+ * };
+ *
+ * // This will validate the config and throw if invalid
+ * assertIntegrationAuthParams(config);
+ * ```
+ * @example
+ * ```typescript
+ * // Example of a failing assert:
+ * try {
+ *   assertIntegrationAuthParams({
+ *     consumerKey: "valid-consumer-key",
+ *     // Missing required fields like consumerSecret, accessToken, accessTokenSecret
+ *   });
+ * } catch (error) {
+ *   console.error(error.message); // "Invalid IntegrationAuthProvider configuration"
+ *   console.error(error.issues); // Array of validation issues
+ * }
+ * ```
+ */
 declare function assertIntegrationAuthParams(config: Record<PropertyKey, unknown>): asserts config is IntegrationAuthParams;
+/**
+ * Creates an {@link IntegrationAuthProvider} based on the provided configuration.
+ * @param authParams The configuration for the integration.
+ * @returns An {@link IntegrationAuthProvider} instance that can be used to get auth headers.
+ * @example
+ * ```typescript
+ * const config = {
+ *   consumerKey: "your-consumer-key",
+ *   consumerSecret: "your-consumer-secret",
+ *   accessToken: "your-access-token",
+ *   accessTokenSecret: "your-access-token-secret"
+ * };
+ *
+ * const authProvider = getIntegrationAuthProvider(config);
+ *
+ * // Get OAuth headers for a REST API call
+ * const headers = authProvider.getHeaders("GET", "https://your-store.com/rest/V1/products");
+ * console.log(headers); // { Authorization: "OAuth oauth_consumer_key=..., oauth_signature=..." }
+ *
+ * // Can also be used with URL objects
+ * const url = new URL("https://your-store.com/rest/V1/customers");
+ * const postHeaders = authProvider.getHeaders("POST", url);
+ * ```
+ */
 declare function getIntegrationAuthProvider(authParams: IntegrationAuthParams): IntegrationAuthProvider;
 //#endregion
-export { IMS_AUTH_ENV, ImsAuthEnv, ImsAuthParams, ImsAuthProvider, IntegrationAuthParams, IntegrationAuthProvider, assertImsAuthParams, assertIntegrationAuthParams, getImsAuthProvider, getIntegrationAuthProvider };
+export { IMS_AUTH_ENV, type ImsAuthEnv, type ImsAuthParams, type ImsAuthProvider, type IntegrationAuthParams, type IntegrationAuthProvider, assertImsAuthParams, assertIntegrationAuthParams, getImsAuthProvider, getIntegrationAuthProvider };

package/dist/es/index.d.ts

@@ -1,18 +1,35 @@
+/**
+ * @license
+ * 
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
 import * as valibot0 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region source/lib/ims-auth/schema.d.ts
+/** The environments accepted by the IMS auth service. */
 declare const IMS_AUTH_ENV: {
   readonly PROD: "prod";
   readonly STAGE: "stage";
 };
+/** Validation schema for IMS auth environment values. */
 declare const ImsAuthEnvSchema: valibot0.EnumSchema<{
   readonly PROD: "prod";
   readonly STAGE: "stage";
 }, undefined>;
+/** Defines the schema to validate the necessary parameters for the IMS auth service. */
 declare const ImsAuthParamsSchema: valibot0.ObjectSchema<{
   readonly clientId: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot0.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
-  readonly clientSecrets: valibot0.SchemaWithPipe<readonly [valibot0.SchemaWithPipe<readonly [valibot0.ArraySchema<valibot0.StringSchema<undefined>, `Expected a stringified JSON array value for the IMS auth parameter ${string}`>]>, valibot0.MinLengthAction<string[], 1, "Expected at least one client secret for IMS auth">]>;
+  readonly clientSecrets: valibot0.SchemaWithPipe<readonly [valibot0.SchemaWithPipe<readonly [valibot0.ArraySchema<valibot0.StringSchema<undefined>, `Expected a string array value for the IMS auth parameter ${string}`>]>, valibot0.MinLengthAction<string[], 1, "Expected at least one client secret for IMS auth">]>;
   readonly technicalAccountId: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot0.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
   readonly technicalAccountEmail: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<"Expected a string value for the IMS auth parameter technicalAccountEmail">, valibot0.EmailAction<string, "Expected a valid email format for technicalAccountEmail">]>;
   readonly imsOrgId: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot0.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
@@ -20,20 +37,96 @@ declare const ImsAuthParamsSchema: valibot0.ObjectSchema<{
     readonly PROD: "prod";
     readonly STAGE: "stage";
   }, undefined>, "prod">]>;
-  readonly context: valibot0.SchemaWithPipe<readonly [valibot0.OptionalSchema<valibot0.StringSchema<undefined>, "aio-commerce-sdk-creds">]>;
-  readonly scopes: valibot0.SchemaWithPipe<readonly [valibot0.SchemaWithPipe<readonly [valibot0.ArraySchema<valibot0.StringSchema<undefined>, `Expected a stringified JSON array value for the IMS auth parameter ${string}`>]>, valibot0.MinLengthAction<string[], 1, "Expected at least one scope for IMS auth">]>;
+  readonly context: valibot0.SchemaWithPipe<readonly [valibot0.OptionalSchema<valibot0.StringSchema<undefined>, undefined>]>;
+  readonly scopes: valibot0.SchemaWithPipe<readonly [valibot0.SchemaWithPipe<readonly [valibot0.ArraySchema<valibot0.StringSchema<undefined>, `Expected a string array value for the IMS auth parameter ${string}`>]>, valibot0.MinLengthAction<string[], 1, "Expected at least one scope for IMS auth">]>;
 }, undefined>;
+/** Defines the parameters for the IMS auth service. */
 type ImsAuthParams = InferOutput<typeof ImsAuthParamsSchema>;
+/** Defines the environments accepted by the IMS auth service. */
 type ImsAuthEnv = InferOutput<typeof ImsAuthEnvSchema>;
 //#endregion
 //#region source/lib/ims-auth/provider.d.ts
+/** Defines the header keys used for IMS authentication. */
 type ImsAuthHeader = "Authorization" | "x-api-key";
+/** Defines the headers required for IMS authentication. */
 type ImsAuthHeaders = Record<ImsAuthHeader, string>;
+/** Defines an authentication provider for Adobe IMS. */
 interface ImsAuthProvider {
   getAccessToken: () => Promise<string>;
   getHeaders: () => Promise<ImsAuthHeaders>;
 }
+/**
+ * Asserts the provided configuration for an {@link ImsAuthProvider}.
+ * @param config The configuration to validate.
+ * @throws {CommerceSdkValidationError} If the configuration is invalid.
+ * @example
+ * ```typescript
+ * const config = {
+ *   clientId: "your-client-id",
+ *   clientSecrets: ["your-client-secret"],
+ *   technicalAccountId: "your-technical-account-id",
+ *   technicalAccountEmail: "your-account@example.com",
+ *   imsOrgId: "your-ims-org-id@AdobeOrg",
+ *   scopes: ["AdobeID", "openid"],
+ *   environment: "prod", // or "stage"
+ *   context: "my-app-context"
+ * };
+ *
+ * // This will validate the config and throw if invalid
+ * assertImsAuthParams(config);
+ *```
+ * @example
+ * ```typescript
+ * // Example of a failing assert:
+ * try {
+ *   assertImsAuthParams({
+ *     clientId: "valid-client-id",
+ *     // Missing required fields like clientSecrets, technicalAccountId, etc.
+ *   });
+ * } catch (error) {
+ *   console.error(error.message); // "Invalid ImsAuthProvider configuration"
+ *   console.error(error.issues); // Array of validation issues
+ * }
+ * ```
+ */
 declare function assertImsAuthParams(config: Record<PropertyKey, unknown>): asserts config is ImsAuthParams;
+/**
+ * Creates an {@link ImsAuthProvider} based on the provided configuration.
+ * @param authParams An {@link ImsAuthParams} parameter that contains the configuration for the {@link ImsAuthProvider}.
+ * @returns An {@link ImsAuthProvider} instance that can be used to get access token and auth headers.
+ * @example
+ * ```typescript
+ * const config = {
+ *   clientId: "your-client-id",
+ *   clientSecrets: ["your-client-secret"],
+ *   technicalAccountId: "your-technical-account-id",
+ *   technicalAccountEmail: "your-account@example.com",
+ *   imsOrgId: "your-ims-org-id@AdobeOrg",
+ *   scopes: ["AdobeID", "openid"],
+ *   environment: "prod",
+ *   context: "my-app-context"
+ * };
+ *
+ * const authProvider = getImsAuthProvider(config);
+ *
+ * // Get access token
+ * const token = await authProvider.getAccessToken();
+ * console.log(token); // "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9..."
+ *
+ * // Get headers for API requests
+ * const headers = await authProvider.getHeaders();
+ * console.log(headers);
+ * // {
+ * //   Authorization: "Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...",
+ * //   "x-api-key": "your-client-id"
+ * // }
+ *
+ * // Use headers in API calls
+ * const response = await fetch('https://api.adobe.io/some-endpoint', {
+ *   headers: await authProvider.getHeaders()
+ * });
+ * ```
+ */
 declare function getImsAuthProvider(authParams: ImsAuthParams): {
   getAccessToken: () => Promise<string>;
   getHeaders: () => Promise<{
@@ -43,23 +136,92 @@ declare function getImsAuthProvider(authParams: ImsAuthParams): {
 };
 //#endregion
 //#region source/lib/integration-auth/schema.d.ts
+/**
+ * The HTTP methods supported by Commerce.
+ * This is used to determine which headers to include in the signing of the authorization header.
+ */
 type HttpMethodInput = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/** Validation schema that accepts either a URL string or URL instance and normalizes to string. */
+
+/**
+ * The schema for the Commerce Integration parameters.
+ * This is used to validate the parameters passed to the Commerce Integration provider.
+ */
 declare const IntegrationAuthParamsSchema: valibot0.NonOptionalSchema<valibot0.ObjectSchema<{
   readonly consumerKey: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot0.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
   readonly consumerSecret: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot0.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
   readonly accessToken: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot0.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
   readonly accessTokenSecret: valibot0.SchemaWithPipe<readonly [valibot0.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot0.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
 }, undefined>, undefined>;
+/** Defines the parameters required for Commerce Integration authentication. */
 type IntegrationAuthParams = InferOutput<typeof IntegrationAuthParamsSchema>;
 //#endregion
 //#region source/lib/integration-auth/provider.d.ts
+/** Defines the header key used for Commerce Integration authentication. */
 type IntegrationAuthHeader = "Authorization";
+/** Defines the headers required for Commerce Integration authentication. */
 type IntegrationAuthHeaders = Record<IntegrationAuthHeader, string>;
+/** Represents a URL for Adobe Commerce endpoints, accepting either string or URL object. */
 type AdobeCommerceUrl = string | URL;
+/** Defines an authentication provider for Adobe Commerce integrations. */
 interface IntegrationAuthProvider {
   getHeaders: (method: HttpMethodInput, url: AdobeCommerceUrl) => IntegrationAuthHeaders;
 }
+/**
+ * Asserts the provided configuration for an Adobe Commerce {@link IntegrationAuthProvider}.
+ * @param config The configuration to validate.
+ * @throws {CommerceSdkValidationError} If the configuration is invalid.
+ * @example
+ * ```typescript
+ * const config = {
+ *   consumerKey: "your-consumer-key",
+ *   consumerSecret: "your-consumer-secret",
+ *   accessToken: "your-access-token",
+ *   accessTokenSecret: "your-access-token-secret"
+ * };
+ *
+ * // This will validate the config and throw if invalid
+ * assertIntegrationAuthParams(config);
+ * ```
+ * @example
+ * ```typescript
+ * // Example of a failing assert:
+ * try {
+ *   assertIntegrationAuthParams({
+ *     consumerKey: "valid-consumer-key",
+ *     // Missing required fields like consumerSecret, accessToken, accessTokenSecret
+ *   });
+ * } catch (error) {
+ *   console.error(error.message); // "Invalid IntegrationAuthProvider configuration"
+ *   console.error(error.issues); // Array of validation issues
+ * }
+ * ```
+ */
 declare function assertIntegrationAuthParams(config: Record<PropertyKey, unknown>): asserts config is IntegrationAuthParams;
+/**
+ * Creates an {@link IntegrationAuthProvider} based on the provided configuration.
+ * @param authParams The configuration for the integration.
+ * @returns An {@link IntegrationAuthProvider} instance that can be used to get auth headers.
+ * @example
+ * ```typescript
+ * const config = {
+ *   consumerKey: "your-consumer-key",
+ *   consumerSecret: "your-consumer-secret",
+ *   accessToken: "your-access-token",
+ *   accessTokenSecret: "your-access-token-secret"
+ * };
+ *
+ * const authProvider = getIntegrationAuthProvider(config);
+ *
+ * // Get OAuth headers for a REST API call
+ * const headers = authProvider.getHeaders("GET", "https://your-store.com/rest/V1/products");
+ * console.log(headers); // { Authorization: "OAuth oauth_consumer_key=..., oauth_signature=..." }
+ *
+ * // Can also be used with URL objects
+ * const url = new URL("https://your-store.com/rest/V1/customers");
+ * const postHeaders = authProvider.getHeaders("POST", url);
+ * ```
+ */
 declare function getIntegrationAuthProvider(authParams: IntegrationAuthParams): IntegrationAuthProvider;
 //#endregion
-export { IMS_AUTH_ENV, ImsAuthEnv, ImsAuthParams, ImsAuthProvider, IntegrationAuthParams, IntegrationAuthProvider, assertImsAuthParams, assertIntegrationAuthParams, getImsAuthProvider, getIntegrationAuthProvider };
+export { IMS_AUTH_ENV, type ImsAuthEnv, type ImsAuthParams, type ImsAuthProvider, type IntegrationAuthParams, type IntegrationAuthProvider, assertImsAuthParams, assertIntegrationAuthParams, getImsAuthProvider, getIntegrationAuthProvider };

package/dist/es/index.js

@@ -1,55 +1,39 @@
+/**
+* @license
+* 
+* Copyright 2025 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
 import { CommerceSdkValidationError } from "@adobe/aio-commerce-lib-core/error";
 import { context, getToken } from "@adobe/aio-lib-ims";
 import { array, email, enum as enum$1, instance, minLength, nonEmpty, nonOptional, object, optional, pipe, safeParse, string, transform, union, url } from "valibot";
-import crypto from "node:crypto";
+import crypto from "crypto";
 import OAuth1a from "oauth-1.0a";
-
-//#region source/lib/ims-auth/schema.ts
-/**
-* Creates a validation schema for a required IMS auth string parameter.
-* @param name The name of the parameter for error messages.
-* @returns A validation pipeline that ensures the parameter is a non-empty string.
-*/
-const imsAuthParameter = (name) => pipe(string(`Expected a string value for the IMS auth parameter ${name}`), nonEmpty(`Expected a non-empty string value for the IMS auth parameter ${name}`));
-/**
-* Creates a validation schema for an IMS auth string array parameter.
-* @param name The name of the parameter for error messages.
-* @returns A validation pipeline that ensures the parameter is an array of strings.
-*/
-const stringArray = (name) => {
-	return pipe(array(string(), `Expected a stringified JSON array value for the IMS auth parameter ${name}`));
-};
-/** The environments accepted by the IMS auth service. */
-const IMS_AUTH_ENV = {
+const imsAuthParameter = (name) => pipe(string(`Expected a string value for the IMS auth parameter ${name}`), nonEmpty(`Expected a non-empty string value for the IMS auth parameter ${name}`)), stringArray = (name) => pipe(array(string(), `Expected a string array value for the IMS auth parameter ${name}`)), IMS_AUTH_ENV = {
 	PROD: "prod",
 	STAGE: "stage"
-};
-/** Validation schema for IMS auth environment values. */
-const ImsAuthEnvSchema = enum$1(IMS_AUTH_ENV);
-/** Defines the schema to validate the necessary parameters for the IMS auth service. */
-const ImsAuthParamsSchema = object({
+}, ImsAuthEnvSchema = enum$1(IMS_AUTH_ENV), ImsAuthParamsSchema = object({
 	clientId: imsAuthParameter("clientId"),
 	clientSecrets: pipe(stringArray("clientSecrets"), minLength(1, "Expected at least one client secret for IMS auth")),
 	technicalAccountId: imsAuthParameter("technicalAccountId"),
 	technicalAccountEmail: pipe(string("Expected a string value for the IMS auth parameter technicalAccountEmail"), email("Expected a valid email format for technicalAccountEmail")),
 	imsOrgId: imsAuthParameter("imsOrgId"),
 	environment: pipe(optional(ImsAuthEnvSchema, IMS_AUTH_ENV.PROD)),
-	context: pipe(optional(string(), "aio-commerce-sdk-creds")),
+	context: pipe(optional(string())),
 	scopes: pipe(stringArray("scopes"), minLength(1, "Expected at least one scope for IMS auth"))
 });
-
-//#endregion
-//#region source/lib/ims-auth/provider.ts
-/**
-* Converts IMS auth configuration properties to snake_case format.
-* @param config The IMS auth configuration with camelCase properties.
-* @returns The configuration with snake_case properties.
-*/
 function toImsAuthConfig(config) {
 	return {
 		scopes: config.scopes,
 		env: config?.environment ?? "prod",
-		context: config.context,
+		context: config.context ?? "aio-commerce-lib-auth-creds",
 		client_id: config.clientId,
 		client_secrets: config.clientSecrets,
 		technical_account_id: config.technicalAccountId,
@@ -57,90 +41,16 @@ function toImsAuthConfig(config) {
 		ims_org_id: config.imsOrgId
 	};
 }
-/**
-* Asserts the provided configuration for an Adobe IMS authentication provider. {@link ImsAuthParams}
-* {@link ImsAuthProvider}
-* @param config {Record<PropertyKey, unknown>} The configuration to validate.
-* @throws {CommerceSdkValidationError} If the configuration is invalid.
-* @example
-* ```typescript
-* const config = {
-*   clientId: "your-client-id",
-*   clientSecrets: ["your-client-secret"],
-*   technicalAccountId: "your-technical-account-id",
-*   technicalAccountEmail: "your-account@example.com",
-*   imsOrgId: "your-ims-org-id@AdobeOrg",
-*   scopes: ["AdobeID", "openid"],
-*   environment: "prod", // or "stage"
-*   context: "my-app-context"
-* };
-*
-* // This will validate the config and throw if invalid
-* assertImsAuthParams(config);
-*```
-* @example
-* ```typescript
-* // Example of a failing assert:
-* try {
-*   assertImsAuthParams({
-*     clientId: "valid-client-id",
-*     // Missing required fields like clientSecrets, technicalAccountId, etc.
-*   });
-* } catch (error) {
-*   console.error(error.message); // "Invalid ImsAuthProvider configuration"
-*   console.error(error.issues); // Array of validation issues
-* }
-* ```
-*/
 function assertImsAuthParams(config) {
-	const result = safeParse(ImsAuthParamsSchema, config);
+	let result = safeParse(ImsAuthParamsSchema, config);
 	if (!result.success) throw new CommerceSdkValidationError("Invalid ImsAuthProvider configuration", { issues: result.issues });
 }
-/**
-* Creates an {@link ImsAuthProvider} based on the provided configuration.
-* @param config An {@link ImsAuthParams} parameter that contains the configuration for the IMS auth provider.
-* @returns An {@link ImsAuthProvider} instance that can be used to get access token and auth headers.
-* @example
-* ```typescript
-* const config = {
-*   clientId: "your-client-id",
-*   clientSecrets: ["your-client-secret"],
-*   technicalAccountId: "your-technical-account-id",
-*   technicalAccountEmail: "your-account@example.com",
-*   imsOrgId: "your-ims-org-id@AdobeOrg",
-*   scopes: ["AdobeID", "openid"],
-*   environment: "prod",
-*   context: "my-app-context"
-* };
-*
-* const authProvider = getImsAuthProvider(config);
-*
-* // Get access token
-* const token = await authProvider.getAccessToken();
-* console.log(token); // "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9..."
-*
-* // Get headers for API requests
-* const headers = await authProvider.getHeaders();
-* console.log(headers);
-* // {
-* //   Authorization: "Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...",
-* //   "x-api-key": "your-client-id"
-* // }
-*
-* // Use headers in API calls
-* const response = await fetch('https://api.adobe.io/some-endpoint', {
-*   headers: await authProvider.getHeaders()
-* });
-* ```
-*/
 function getImsAuthProvider(authParams) {
-	const getAccessToken = async () => {
-		const imsAuthConfig = toImsAuthConfig(authParams);
-		await context.set(authParams.context, imsAuthConfig);
-		return getToken(authParams.context, {});
-	};
-	const getHeaders = async () => {
-		const accessToken = await getAccessToken();
+	let getAccessToken = async () => {
+		let imsAuthConfig = toImsAuthConfig(authParams);
+		return await context.set(imsAuthConfig.context, imsAuthConfig), getToken(imsAuthConfig.context, {});
+	}, getHeaders = async () => {
+		let accessToken = await getAccessToken();
 		return {
 			Authorization: `Bearer ${accessToken}`,
 			"x-api-key": authParams.clientId
@@ -151,115 +61,36 @@ function getImsAuthProvider(authParams) {
 		getHeaders
 	};
 }
-
-//#endregion
-//#region source/lib/integration-auth/schema.ts
-/**
-* Creates a validation schema for a required Commerce Integration string parameter.
-* @param name The name of the parameter for error messages.
-* @returns A validation pipeline that ensures the parameter is a non-empty string.
-*/
-const integrationAuthParameter = (name) => pipe(string(`Expected a string value for the Commerce Integration parameter ${name}`), nonEmpty(`Expected a non-empty string value for the Commerce Integration parameter ${name}`));
-/** Validation schema for the Adobe Commerce endpoint base URL. */
-const BaseUrlSchema = pipe(string("Expected a string for the Adobe Commerce endpoint"), nonEmpty("Expected a non-empty string for the Adobe Commerce endpoint"), url("Expected a valid url for the Adobe Commerce endpoint"));
-/** Validation schema that accepts either a URL string or URL instance and normalizes to string. */
-const UrlSchema = pipe(union([BaseUrlSchema, instance(URL)]), transform((url$1) => {
-	if (url$1 instanceof URL) return url$1.toString();
-	return url$1;
-}));
-/**
-* The schema for the Commerce Integration parameters.
-* This is used to validate the parameters passed to the Commerce Integration provider.
-*/
+const integrationAuthParameter = (name) => pipe(string(`Expected a string value for the Commerce Integration parameter ${name}`), nonEmpty(`Expected a non-empty string value for the Commerce Integration parameter ${name}`)), BaseUrlSchema = pipe(string("Expected a string for the Adobe Commerce endpoint"), nonEmpty("Expected a non-empty string for the Adobe Commerce endpoint"), url("Expected a valid url for the Adobe Commerce endpoint"));
+pipe(union([BaseUrlSchema, instance(URL)]), transform((url$1) => url$1 instanceof URL ? url$1.toString() : url$1));
 const IntegrationAuthParamsSchema = nonOptional(object({
 	consumerKey: integrationAuthParameter("consumerKey"),
 	consumerSecret: integrationAuthParameter("consumerSecret"),
 	accessToken: integrationAuthParameter("accessToken"),
 	accessTokenSecret: integrationAuthParameter("accessTokenSecret")
 }));
-
-//#endregion
-//#region source/lib/integration-auth/provider.ts
-/**
-* Asserts the provided configuration for an Adobe Commerce integration authentication provider. {@link IntegrationAuthParams}
-* {@link IntegrationAuthProvider}
-* @param config {Record<PropertyKey, unknown>} The configuration to validate.
-* @throws {CommerceSdkValidationError} If the configuration is invalid.
-* @example
-* ```typescript
-* const config = {
-*   consumerKey: "your-consumer-key",
-*   consumerSecret: "your-consumer-secret",
-*   accessToken: "your-access-token",
-*   accessTokenSecret: "your-access-token-secret"
-* };
-*
-* // This will validate the config and throw if invalid
-* assertIntegrationAuthParams(config);
-* ```
-* @example
-* ```typescript
-* // Example of a failing assert:
-* try {
-*   assertIntegrationAuthParams({
-*     consumerKey: "valid-consumer-key",
-*     // Missing required fields like consumerSecret, accessToken, accessTokenSecret
-*   });
-* } catch (error) {
-*   console.error(error.message); // "Invalid IntegrationAuthProvider configuration"
-*   console.error(error.issues); // Array of validation issues
-* }
-* ```
-*/
 function assertIntegrationAuthParams(config) {
-	const result = safeParse(IntegrationAuthParamsSchema, config);
+	let result = safeParse(IntegrationAuthParamsSchema, config);
 	if (!result.success) throw new CommerceSdkValidationError("Invalid IntegrationAuthProvider configuration", { issues: result.issues });
 }
-/**
-* Creates an {@link IntegrationAuthProvider} based on the provided configuration.
-* @param config {IntegrationAuthParams} The configuration for the integration.
-* @returns An {@link IntegrationAuthProvider} instance that can be used to get auth headers.
-* @example
-* ```typescript
-* const config = {
-*   consumerKey: "your-consumer-key",
-*   consumerSecret: "your-consumer-secret",
-*   accessToken: "your-access-token",
-*   accessTokenSecret: "your-access-token-secret"
-* };
-*
-* const authProvider = getIntegrationAuthProvider(config);
-*
-* // Get OAuth headers for a REST API call
-* const headers = authProvider.getHeaders("GET", "https://your-store.com/rest/V1/products");
-* console.log(headers); // { Authorization: "OAuth oauth_consumer_key=..., oauth_signature=..." }
-*
-* // Can also be used with URL objects
-* const url = new URL("https://your-store.com/rest/V1/customers");
-* const postHeaders = authProvider.getHeaders("POST", url);
-* ```
-*/
 function getIntegrationAuthProvider(authParams) {
-	const oauth = new OAuth1a({
+	let oauth = new OAuth1a({
 		consumer: {
 			key: authParams.consumerKey,
 			secret: authParams.consumerSecret
 		},
 		signature_method: "HMAC-SHA256",
 		hash_function: (baseString, key) => crypto.createHmac("sha256", key).update(baseString).digest("base64")
-	});
-	const oauthToken = {
+	}), oauthToken = {
 		key: authParams.accessToken,
 		secret: authParams.accessTokenSecret
 	};
 	return { getHeaders: (method, url$1) => {
-		const urlString = url$1 instanceof URL ? url$1.toString() : url$1;
+		let urlString = url$1 instanceof URL ? url$1.toString() : url$1;
 		return oauth.toHeader(oauth.authorize({
 			url: urlString,
 			method
 		}, oauthToken));
 	} };
 }
-
-//#endregion
-export { IMS_AUTH_ENV, assertImsAuthParams, assertIntegrationAuthParams, getImsAuthProvider, getIntegrationAuthProvider };
+export { IMS_AUTH_ENV, assertImsAuthParams, assertIntegrationAuthParams, getImsAuthProvider, getIntegrationAuthProvider };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@adobe/aio-commerce-lib-auth",
   "type": "module",
-  "version": "0.3.0",
-  "private": false,
   "author": "Adobe Inc.",
+  "version": "0.3.2",
+  "private": false,
   "engines": {
-    "node": ">=22"
+    "node": ">=20 <=24"
   },
   "license": "Apache-2.0",
   "description": "Authentication utilities for Adobe Commerce apps deployed in Adobe App Builder.",
@@ -21,7 +21,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/adobe/aio-commerce-sdk.git",
+    "url": "git+https://github.com/adobe/aio-commerce-sdk.git",
     "directory": "packages/aio-commerce-lib-auth"
   },
   "main": "./dist/cjs/index.cjs",
@@ -51,25 +51,29 @@
     "ansis": "^4.1.0",
     "oauth-1.0a": "^2.2.6",
     "valibot": "^1.1.0",
-    "@adobe/aio-commerce-lib-core": "0.3.0"
+    "@adobe/aio-commerce-lib-core": "0.4.0"
   },
   "devDependencies": {
-    "vitest": "^3.2.4",
+    "@aio-commerce-sdk/config-tsdown": "1.0.0",
+    "@aio-commerce-sdk/config-typedoc": "1.0.0",
     "@aio-commerce-sdk/config-typescript": "1.0.0",
-    "@aio-commerce-sdk/config-tsdown": "1.0.0"
+    "@aio-commerce-sdk/config-vitest": "1.0.0"
   },
   "sideEffects": false,
   "scripts": {
     "build": "tsdown",
-    "assist": "pnpm -w assist .",
-    "assist:apply": "pnpm -w assist:apply .",
-    "check:ci": "pnpm -w check:ci .",
-    "format": "pnpm -w format .",
-    "format:check": "pnpm -w format:check .",
-    "lint": "pnpm -w lint .",
-    "lint:fix": "pnpm -w lint:fix .",
+    "docs": "typedoc && prettier --write '**/*.md'",
+    "assist": "biome check --formatter-enabled=false --linter-enabled=false --assist-enabled=true --no-errors-on-unmatched",
+    "assist:apply": "biome check --write --formatter-enabled=false --linter-enabled=false --assist-enabled=true --no-errors-on-unmatched",
+    "check:ci": "biome ci --formatter-enabled=true --linter-enabled=true --assist-enabled=true --no-errors-on-unmatched",
+    "format": "biome format --write --no-errors-on-unmatched",
+    "format:markdown": "prettier --no-error-on-unmatched-pattern --write '**/*.md' \"!**/{CODE_OF_CONDUCT.md,COPYRIGHT,LICENSE,SECURITY.md,CONTRIBUTING.md}\"",
+    "format:check": "biome format --no-errors-on-unmatched",
+    "lint": "biome lint --no-errors-on-unmatched",
+    "lint:fix": "biome lint --write --no-errors-on-unmatched",
     "typecheck": "tsc --noEmit && echo '✅ No type errors found.'",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "test": "vitest run --coverage",
+    "test:watch": "vitest --coverage",
+    "test:ui": "vitest --ui"
   }
 }