@adobe/aio-commerce-lib-auth 0.1.0 → 0.2.0

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @adobe/aio-commerce-lib-auth@0.1.0 build /home/runner/work/aio-commerce-sdk/aio-commerce-sdk/packages/aio-commerce-lib-auth
+> @adobe/aio-commerce-lib-auth@0.2.0 build /home/runner/work/aio-commerce-sdk/aio-commerce-sdk/packages/aio-commerce-lib-auth
 > tsdown
 
-ℹ tsdown v0.12.9 powered by rolldown v1.0.0-beta.21
+ℹ tsdown v0.12.9 powered by rolldown v1.0.0-beta.24
 ℹ Using tsdown config: /home/runner/work/aio-commerce-sdk/aio-commerce-sdk/packages/aio-commerce-lib-auth/tsdown.config.ts
 ℹ entry: source/index.ts
 ℹ target: node22.0.0
 ℹ tsconfig: tsconfig.json
 ℹ Build start
-ℹ [CJS] dist/cjs/index.cjs  4.81 kB │ gzip: 1.71 kB
-ℹ [CJS] 1 files, total: 4.81 kB
-ℹ [CJS] dist/index.d.cts  2.33 kB │ gzip: 0.69 kB
-ℹ [CJS] 1 files, total: 2.33 kB
-ℹ [ESM] dist/es/index.js    3.63 kB │ gzip: 1.27 kB
-ℹ [ESM] dist/es/index.d.ts  2.33 kB │ gzip: 0.69 kB
-ℹ [ESM] 2 files, total: 5.97 kB
-✔ Build complete in 1768ms
+ℹ [CJS] dist/cjs/index.cjs  10.48 kB │ gzip: 2.73 kB
+ℹ [CJS] 1 files, total: 10.48 kB
+ℹ [CJS] dist/index.d.cts  7.68 kB │ gzip: 1.41 kB
+ℹ [CJS] 1 files, total: 7.68 kB
+ℹ [ESM] dist/es/index.js    8.55 kB │ gzip: 2.28 kB
+ℹ [ESM] dist/es/index.d.ts  7.63 kB │ gzip: 1.41 kB
+ℹ [ESM] 2 files, total: 16.18 kB
+✔ Build complete in 2646ms

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @adobe/aio-commerce-lib-auth
 
+## 0.2.0
+
+### Minor Changes
+
+- [#18](https://github.com/adobe/aio-commerce-sdk/pull/18) [`aadbff1`](https://github.com/adobe/aio-commerce-sdk/commit/aadbff1acd08120f9d5cb8db4e3c849f552d8c79) Thanks [@jnatherley](https://github.com/jnatherley)! - Introduces the `aio-commerce-lib-core` package, which contains core utilities for the AIO Commerce SDK. It includes:
+  - A `Result` type based on Rust's `Result` type, to do better error handling.
+  - A set of validation utilities, including pretty printing of validation errors, and custom validation error types.
+  - Refactor aio-commerce-lib-auth to use aio-commerce-lib-core
+
+  Implements validation for the `aio-commerce-lib-auth` operations via `valibot`.
+
+### Patch Changes
+
+- Updated dependencies [[`aadbff1`](https://github.com/adobe/aio-commerce-sdk/commit/aadbff1acd08120f9d5cb8db4e3c849f552d8c79)]:
+  - @adobe/aio-commerce-lib-core@0.2.0
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -11,15 +11,29 @@ This library provides a unified interface for authentication in Adobe Commerce A
 
 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
+- **IMS Provider**: For authenticating users or services via Adobe Identity Management System (IMS) using OAuth2.
+  - Required Params
+    - AIO_COMMERCE_IMS_CLIENT_ID: string
+    - AIO_COMMERCE_IMS_CLIENT_SECRETS: string
+    - AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID: string
+    - AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL: string
+    - AIO_COMMERCE_IMS_IMS_ORG_ID: string
+    - AIO_COMMERCE_IMS_ENV: string e.g `'prod'` or `'stage'`
+    - AIO_COMMERCE_IMS_SCOPES: string e.g `'["value1", "value2"]'`
+    - AIO_COMMERCE_IMS_CTX: string
+- **Integrations Provider**: For authenticating with Adobe Commerce integrations using OAuth 1.0a.
+  - Required params
+    - AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY: string
+    - AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET: string
+    - AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN: string
+    - AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET: string
 
 These providers abstract the complexity of authentication, making it easy to obtain and use access tokens in your App Builder applications.
 
 ## Installation
 
 ```shell
-pnpm install @adobe/aio-commerce-lib-auth
+npm install @adobe/aio-commerce-lib-auth
 ```
 
 ## Usage
@@ -31,13 +45,36 @@ In your App Builder application, you can use the library to authenticate users o
 In the runtime action you can generate an access token using the IMS Provider:
 
 ```typescript
-import { getImsAuthProvider } from "@adobe/aio-commerce-lib-auth";
+import { tryGetImsAuthProvider } from "@adobe/aio-commerce-lib-auth";
+import { isErr, unwrap } from "@adobe/aio-commerce-lib-core";
 
 export const main = async function (params: Record<string, unknown>) {
-  // Generate the needed headers for API requests
-  const imsAuth = getImsAuthProvider(params);
-  const headers = await imsAuth.getHeaders();
-
+  const result = tryGetImsAuthProvider(params); // Validate parameters and get the integration auth provider
+
+  if (isErr(result)) {
+    const { error } = result;
+    return {
+      statusCode: 400,
+      body: {
+        error: `Unable to get IMS Auth Provider ${error.message}`,
+      },
+    };
+  }
+
+  const imsAuthProvider = unwrap(result);
+  const headersResult = imsAuthProvider.getHeaders();
+
+  if (isErr(headersResult)) {
+    const { error } = result;
+    return {
+      statusCode: 400,
+      body: {
+        error: `Unable to get auth headers for IMS Auth Provider ${error.message}`,
+      },
+    };
+  }
+
+  // business logic e.g requesting orders
   return { statusCode: 200 };
 };
 ```
@@ -47,20 +84,44 @@ export const main = async function (params: Record<string, unknown>) {
 In the runtime action you can generate an access token using the Integrations Provider:
 
 ```typescript
-import { getIntegrationsAuthProvider } from "@adobe/aio-commerce-lib-auth";
+import { tryGetIntegrationAuthProvider } from "@adobe/aio-commerce-lib-auth";
+import { isErr, unwrapErr, unwrap } from "@adobe/aio-commerce-lib-core";
 
 export const main = async function (params: Record<string, unknown>) {
-  // Generate the needed headers for API requests
-  const integrationsAuth = getIntegrationsAuthProvider(params);
-  const headers = integrationsAuth.getHeaders(
+  const result = tryGetIntegrationAuthProvider(params); // Validate parameters and get the integration auth provider
+
+  if (isErr(result)) {
+    const { error } = result;
+    return {
+      statusCode: 400,
+      body: {
+        error: `Unable to get Integration Auth Provider ${error.message}`,
+      },
+    };
+  }
+
+  const integrationsAuth = unwrap(result);
+  const headersResult = integrationsAuth.getHeaders(
     "GET",
     "http://localhost/rest/V1/orders",
   );
 
+  if (isErr(headersResult)) {
+    const { error } = result;
+    return {
+      statusCode: 400,
+      body: {
+        error: `Unable to get auth headers for Integration Auth Provider ${error.message}`,
+      },
+    };
+  }
+
+  // business logic e.g requesting orders
+
   return { statusCode: 200 };
 };
 ```
 
 ## Contributing
 
-This package is part of the Adobe Commerce SDK monorepo. See the [Contributing Guide](../../.github/CONTRIBUTING.md) and [Development Guide](../../.github/DEVELOPMENT.md) for development setup and guidelines.
+This package is part of the Adobe Commerce SDK monorepo. See the [Contributing Guide](https://github.com/adobe/aio-commerce-sdk/blob/main/.github/CONTRIBUTING.md) and [Development Guide](https://github.com/adobe/aio-commerce-sdk/blob/main/.github/DEVELOPMENT.md) for development setup and guidelines.

package/dist/cjs/index.cjs

@@ -21,115 +21,208 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+const __adobe_aio_commerce_lib_core_result = __toESM(require("@adobe/aio-commerce-lib-core/result"));
 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/params.ts
+//#region source/lib/ims-auth/schema.ts
+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}`));
+const jsonStringArray = (name) => {
+	const jsonStringArraySchema = (0, valibot.message)((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}`), (0, valibot.parseJson)()), `An error occurred while parsing the JSON string array parameter ${name}`);
+	return (0, valibot.pipe)(jsonStringArraySchema, (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 = {
+	PROD: "prod",
+	STAGE: "stage"
+};
+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)({
+	AIO_COMMERCE_IMS_CLIENT_ID: imsAuthParameter("AIO_COMMERCE_IMS_CLIENT_ID"),
+	AIO_COMMERCE_IMS_CLIENT_SECRETS: jsonStringArray("AIO_COMMERCE_IMS_CLIENT_SECRETS"),
+	AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID: imsAuthParameter("AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID"),
+	AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL: imsAuthParameter("AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL"),
+	AIO_COMMERCE_IMS_IMS_ORG_ID: imsAuthParameter("AIO_COMMERCE_IMS_IMS_ORG_ID"),
+	AIO_COMMERCE_IMS_ENV: (0, valibot.pipe)((0, valibot.optional)(ImsAuthEnvSchema, IMS_AUTH_ENV.PROD)),
+	AIO_COMMERCE_IMS_CTX: (0, valibot.pipe)((0, valibot.optional)((0, valibot.string)(), "aio-commerce-sdk-creds")),
+	AIO_COMMERCE_IMS_SCOPES: jsonStringArray("AIO_COMMERCE_IMS_SCOPES")
+});
+
+//#endregion
+//#region source/lib/ims-auth/provider.ts
+function snakeCaseImsAuthConfig(config) {
+	return {
+		...config,
+		client_id: config.clientId,
+		client_secrets: config.clientSecrets,
+		technical_account_id: config.technicalAccountId,
+		technical_account_email: config.technicalAccountEmail,
+		ims_org_id: config.imsOrgId
+	};
+}
+function makeImsAuthValidationError(message, issues) {
+	return {
+		_tag: "ImsAuthValidationError",
+		message,
+		issues
+	};
+}
+function makeImsAuthError(message, error) {
+	return {
+		_tag: "ImsAuthError",
+		message,
+		error
+	};
+}
+function fromParams$1(params) {
+	return {
+		clientId: params.AIO_COMMERCE_IMS_CLIENT_ID,
+		clientSecrets: params.AIO_COMMERCE_IMS_CLIENT_SECRETS,
+		technicalAccountId: params.AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID,
+		technicalAccountEmail: params.AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL,
+		imsOrgId: params.AIO_COMMERCE_IMS_IMS_ORG_ID,
+		scopes: params.AIO_COMMERCE_IMS_SCOPES,
+		environment: params.AIO_COMMERCE_IMS_ENV,
+		context: params.AIO_COMMERCE_IMS_CTX
+	};
+}
+async function tryGetAccessToken(contextName) {
+	try {
+		const accessToken = await (0, __adobe_aio_lib_ims.getToken)(contextName, {});
+		return (0, __adobe_aio_commerce_lib_core_result.ok)(accessToken);
+	} catch (error) {
+		return (0, __adobe_aio_commerce_lib_core_result.err)(makeImsAuthError("Failed to retrieve IMS access token", error));
+	}
+}
 /**
-* Checks if the given value is non-empty.
-*
-* @param name of the parameter. Required because of `aio app dev` compatibility: inputs mapped to undefined env vars come as $<input_name> in dev mode, but as '' in prod mode.
-* @param value of the parameter.
+* Creates an {@link ImsAuthProvider} based on the provided configuration.
+* @param config The configuration for the IMS Auth Provider.
+* @returns An {@link ImsAuthProvider} instance that can be used to get access token and auth headers.
 */
-function nonEmpty(name, value) {
-	const v = value?.trim();
-	return v !== void 0 && v !== `$${name}`;
+function getImsAuthProvider(config) {
+	const getAccessToken = async () => {
+		const snakeCasedConfig = snakeCaseImsAuthConfig(config);
+		await __adobe_aio_lib_ims.context.set(config.context, snakeCasedConfig);
+		return tryGetAccessToken(config.context);
+	};
+	const getHeaders = async () => {
+		const result = await getAccessToken();
+		return (0, __adobe_aio_commerce_lib_core_result.map)(result, (accessToken) => ({
+			Authorization: `Bearer ${accessToken}`,
+			"x-api-key": config.clientId
+		}));
+	};
+	return {
+		getAccessToken,
+		getHeaders
+	};
 }
 /**
-* Checks if all required parameters are non-empty.
-* @param params action input parameters.
-* @param required list of required parameter names.
+* Tries to create an {@link ImsAuthProvider} based on the provided parameters.
+* @param params The parameters required to create the IMS Auth Provider.
+* @returns An {@link ImsAuthProvider} instance that can be used to get access token and auth headers.
 */
-function allNonEmpty(params, required) {
-	return required.every((name) => nonEmpty(name, params[name]));
+function tryGetImsAuthProvider(params) {
+	const validation = (0, valibot.safeParse)(ImsAuthParamsSchema, params);
+	if (!validation.success) return (0, __adobe_aio_commerce_lib_core_result.err)(makeImsAuthValidationError("Failed to validate the provided IMS parameters", validation.issues));
+	return (0, __adobe_aio_commerce_lib_core_result.ok)(getImsAuthProvider(fromParams$1(validation.output)));
 }
 
 //#endregion
-//#region source/lib/ims-auth.ts
+//#region source/lib/integration-auth/schema.ts
 /**
-* If the required IMS parameters are present, this function returns an {@link ImsAuthProvider}.
-* @param params includes IMS parameters
+* The HTTP methods supported by Commerce.
+* This is used to determine which headers to include in the signing of the authorization header.
 */
-async function getImsAuthProvider(params) {
-	const config = resolveImsConfig(params);
-	if (config) {
-		const contextName = params.AIO_COMMERCE_IMS_CTX ?? "aio-commerce-sdk-creds";
-		await __adobe_aio_lib_ims.context.set(contextName, config);
-		return {
-			getAccessToken: async () => (0, __adobe_aio_lib_ims.getToken)(contextName, {}),
-			getHeaders: async () => {
-				const accessToken = await (0, __adobe_aio_lib_ims.getToken)(contextName, {});
-				return {
-					Authorization: `Bearer ${accessToken}`,
-					"x-api-key": config.client_id
-				};
-			}
-		};
-	}
-}
-function resolveImsConfig(params) {
-	if (allNonEmpty(params, [
-		"AIO_COMMERCE_IMS_CLIENT_ID",
-		"AIO_COMMERCE_IMS_CLIENT_SECRETS",
-		"AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID",
-		"AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL",
-		"AIO_COMMERCE_IMS_IMS_ORG_ID",
-		"AIO_COMMERCE_IMS_SCOPES"
-	])) return {
-		client_id: params.AIO_COMMERCE_IMS_CLIENT_ID,
-		client_secrets: JSON.parse(params.AIO_COMMERCE_IMS_CLIENT_SECRETS ?? "[]"),
-		technical_account_id: params.AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID,
-		technical_account_email: params.AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL,
-		ims_org_id: params.AIO_COMMERCE_IMS_IMS_ORG_ID,
-		scopes: JSON.parse(params.AIO_COMMERCE_IMS_SCOPES ?? "[]"),
-		environment: params.AIO_COMMERCE_IMS_ENV ?? "prod"
-	};
-}
-
-//#endregion
-//#region source/lib/integration-auth.ts
+const AllowedHttpMethod = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
+const HttpMethodSchema = (0, valibot.picklist)(AllowedHttpMethod);
+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}`));
+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"));
+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;
+}));
 /**
-* If the required integration parameters are present, this function returns an {@link IntegrationAuthProvider}.
-* @param params includes integration parameters
+* The schema for the Commerce Integration parameters.
+* This is used to validate the parameters passed to the Commerce Integration provider.
 */
-function getIntegrationAuthProvider(params) {
-	const config = resolveIntegrationConfig(params);
-	if (config) {
-		const oauth = new oauth_1_0a.default({
-			consumer: {
-				key: config.consumerKey,
-				secret: config.consumerSecret
-			},
-			signature_method: "HMAC-SHA256",
-			hash_function: (baseString, key) => node_crypto.default.createHmac("sha256", key).update(baseString).digest("base64")
-		});
-		const oauthToken = {
-			key: config.accessToken,
-			secret: config.accessTokenSecret
-		};
-		return { getHeaders(method, url) {
-			return oauth.toHeader(oauth.authorize({
-				url,
-				method
-			}, oauthToken));
-		} };
-	}
+const IntegrationAuthParamsSchema = (0, valibot.nonOptional)((0, valibot.object)({
+	AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY: integrationAuthParameter("AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY"),
+	AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET: integrationAuthParameter("AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET"),
+	AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN: integrationAuthParameter("AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN"),
+	AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET: integrationAuthParameter("AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET")
+}));
+
+//#endregion
+//#region source/lib/integration-auth/provider.ts
+function makeIntegrationAuthValidationError(message, issues) {
+	return {
+		_tag: "IntegrationAuthValidationError",
+		message,
+		issues
+	};
 }
-function resolveIntegrationConfig(params) {
-	if (allNonEmpty(params, [
-		"AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY",
-		"AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET",
-		"AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN",
-		"AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET"
-	])) return {
+function fromParams(params) {
+	return {
 		consumerKey: params.AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY,
 		consumerSecret: params.AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET,
 		accessToken: params.AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN,
 		accessTokenSecret: params.AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET
 	};
 }
+/**
+* Creates an {@link IntegrationAuthProvider} based on the provided configuration.
+* @param config The configuration for the integration.
+* @returns An {@link IntegrationAuthProvider} instance that can be used to get auth headers.
+*/
+function getIntegrationAuthProvider(config) {
+	const oauth = new oauth_1_0a.default({
+		consumer: {
+			key: config.consumerKey,
+			secret: config.consumerSecret
+		},
+		signature_method: "HMAC-SHA256",
+		hash_function: (baseString, key) => node_crypto.default.createHmac("sha256", key).update(baseString).digest("base64")
+	});
+	const oauthToken = {
+		key: config.accessToken,
+		secret: config.accessTokenSecret
+	};
+	const getHeaders = (method, url) => {
+		const uriValidation = (0, valibot.safeParse)(UrlSchema, url);
+		if (!uriValidation.success) return (0, __adobe_aio_commerce_lib_core_result.err)(makeIntegrationAuthValidationError("Failed to validate the provided Adobe Commerce URL", uriValidation.issues));
+		const finalUrl = uriValidation.output;
+		const headers = oauth.toHeader(oauth.authorize({
+			url: finalUrl,
+			method
+		}, oauthToken));
+		return (0, __adobe_aio_commerce_lib_core_result.ok)(headers);
+	};
+	return { getHeaders };
+}
+/**
+* Tries to create an {@link IntegrationAuthProvider} based on the provided parameters.
+* @param params The parameters required for integration authentication.
+* @returns An {@link IntegrationAuthProvider} instance that can be used to get auth headers.
+*/
+function tryGetIntegrationAuthProvider(params) {
+	const validation = (0, valibot.safeParse)(IntegrationAuthParamsSchema, params);
+	if (!validation.success) return (0, __adobe_aio_commerce_lib_core_result.err)(makeIntegrationAuthValidationError("Failed to validate the provided integration parameters", validation.issues));
+	return (0, __adobe_aio_commerce_lib_core_result.ok)(getIntegrationAuthProvider(fromParams(validation.output)));
+}
 
 //#endregion
+exports.IMS_AUTH_ENV = IMS_AUTH_ENV;
 exports.getImsAuthProvider = getImsAuthProvider;
-exports.getIntegrationAuthProvider = getIntegrationAuthProvider;
+exports.getIntegrationAuthProvider = getIntegrationAuthProvider;
+exports.tryGetImsAuthProvider = tryGetImsAuthProvider;
+exports.tryGetIntegrationAuthProvider = tryGetIntegrationAuthProvider;

package/dist/cjs/index.d.cts

@@ -1,39 +1,88 @@
-import OAuth1a from "oauth-1.0a";
+import { ErrorType, Result } from "@adobe/aio-commerce-lib-core/result";
+import { ValidationErrorType } from "@adobe/aio-commerce-lib-core/validation";
+import * as valibot25 from "valibot";
+import { InferInput, InferIssue, InferOutput } from "valibot";
+import * as url5 from "url";
 
-//#region source/lib/ims-auth.d.ts
-declare const IMS_AUTH_HEADERS: readonly ["Authorization", "x-api-key"];
-declare const IMS_AUTH_PARAMS: readonly ["AIO_COMMERCE_IMS_CLIENT_ID", "AIO_COMMERCE_IMS_CLIENT_SECRETS", "AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID", "AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL", "AIO_COMMERCE_IMS_IMS_ORG_ID", "AIO_COMMERCE_IMS_SCOPES", "AIO_COMMERCE_IMS_ENV", "AIO_COMMERCE_IMS_CTX"];
-type ImsAuthParam = (typeof IMS_AUTH_PARAMS)[number];
-type ImsAuthParams = Partial<Record<ImsAuthParam, string>>;
-type ImsAuthHeader = (typeof IMS_AUTH_HEADERS)[number];
-type ImsAuthHeaders = Record<ImsAuthHeader, string>;
+//#region source/lib/ims-auth/schema.d.ts
+declare const IMS_AUTH_ENV: {
+  readonly PROD: "prod";
+  readonly STAGE: "stage";
+};
+declare const ImsAuthEnvSchema: valibot25.EnumSchema<{
+  readonly PROD: "prod";
+  readonly STAGE: "stage";
+}, undefined>;
+declare const ImsAuthParamsSchema: valibot25.ObjectSchema<{
+  readonly AIO_COMMERCE_IMS_CLIENT_ID: valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
+  readonly AIO_COMMERCE_IMS_CLIENT_SECRETS: valibot25.SchemaWithPipe<readonly [valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>, valibot25.ParseJsonAction<string, undefined, undefined>]>, valibot25.ArraySchema<valibot25.StringSchema<undefined>, `Expected a stringified JSON array value for the IMS auth parameter ${string}`>]>;
+  readonly AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID: valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
+  readonly AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL: valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
+  readonly AIO_COMMERCE_IMS_IMS_ORG_ID: valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>]>;
+  readonly AIO_COMMERCE_IMS_ENV: valibot25.SchemaWithPipe<readonly [valibot25.OptionalSchema<valibot25.EnumSchema<{
+    readonly PROD: "prod";
+    readonly STAGE: "stage";
+  }, undefined>, "prod">]>;
+  readonly AIO_COMMERCE_IMS_CTX: valibot25.SchemaWithPipe<readonly [valibot25.OptionalSchema<valibot25.StringSchema<undefined>, "aio-commerce-sdk-creds">]>;
+  readonly AIO_COMMERCE_IMS_SCOPES: valibot25.SchemaWithPipe<readonly [valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the IMS auth parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the IMS auth parameter ${string}`>, valibot25.ParseJsonAction<string, undefined, undefined>]>, valibot25.ArraySchema<valibot25.StringSchema<undefined>, `Expected a stringified JSON array value for the IMS auth parameter ${string}`>]>;
+}, undefined>;
+type ImsAuthParams = InferOutput<typeof ImsAuthParamsSchema>;
+type ImsAuthEnv = InferOutput<typeof ImsAuthEnvSchema>;
+//#endregion
+//#region source/lib/ims-auth/provider.d.ts
 type ImsAccessToken = string;
+type ImsAuthHeader = "Authorization" | "x-api-key";
+type ImsAuthHeaders = Record<ImsAuthHeader, string>;
+type ImsAuthValidationError = ValidationErrorType<"ImsAuthValidationError", InferIssue<typeof ImsAuthParamsSchema>[]>;
+type ImsAuthError<TError = unknown> = ErrorType<"ImsAuthError", {
+  message: string;
+  error: TError;
+}>;
+interface ImsAuthConfig {
+  clientId: string;
+  clientSecrets: string[];
+  technicalAccountId: string;
+  technicalAccountEmail: string;
+  imsOrgId: string;
+  scopes: string[];
+  environment: ImsAuthEnv;
+  context: string;
+}
 interface ImsAuthProvider {
-  getHeaders: () => Promise<ImsAuthHeaders>;
-  getAccessToken: () => Promise<ImsAccessToken>;
+  getAccessToken: () => Promise<Result<ImsAccessToken, ImsAuthError>>;
+  getHeaders: () => Promise<Result<ImsAuthHeaders, ImsAuthError>>;
 }
-declare function getImsAuthProvider(params: ImsAuthParams): Promise<{
-  getAccessToken: () => Promise<string>;
-  getHeaders: () => Promise<{
-    Authorization: string;
-    "x-api-key": string;
-  }>;
-} | undefined>;
+declare function getImsAuthProvider(config: ImsAuthConfig): ImsAuthProvider;
+declare function tryGetImsAuthProvider(params: InferInput<typeof ImsAuthParamsSchema>): Result<ImsAuthProvider, ImsAuthValidationError>;
+//#endregion
+//#region source/lib/integration-auth/schema.d.ts
+declare const HttpMethodSchema: valibot25.PicklistSchema<readonly ["GET", "POST", "PUT", "PATCH", "DELETE"], undefined>;
+type HttpMethodInput = InferInput<typeof HttpMethodSchema>;
+declare const UrlSchema: valibot25.SchemaWithPipe<readonly [valibot25.UnionSchema<[valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<"Expected a string for the Adobe Commerce endpoint">, valibot25.NonEmptyAction<string, "Expected a non-empty string for the Adobe Commerce endpoint">, valibot25.UrlAction<string, "Expected a valid url for the Adobe Commerce endpoint">]>, valibot25.InstanceSchema<typeof url5.URL, undefined>], undefined>, valibot25.TransformAction<string | url5.URL, string>]>;
+type AdobeCommerceUri = InferInput<typeof UrlSchema>;
+declare const IntegrationAuthParamsSchema: valibot25.NonOptionalSchema<valibot25.ObjectSchema<{
+  readonly AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY: valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
+  readonly AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET: valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
+  readonly AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN: valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
+  readonly AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET: valibot25.SchemaWithPipe<readonly [valibot25.StringSchema<`Expected a string value for the Commerce Integration parameter ${string}`>, valibot25.NonEmptyAction<string, `Expected a non-empty string value for the Commerce Integration parameter ${string}`>]>;
+}, undefined>, undefined>;
+type IntegrationAuthParams = InferInput<typeof IntegrationAuthParamsSchema>;
 //#endregion
-//#region source/lib/integration-auth.d.ts
-declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
-declare const INTEGRATION_AUTH_HEADERS: readonly ["Authorization"];
-declare const INTEGRATION_AUTH_PARAMS: readonly ["AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY", "AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET", "AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN", "AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET"];
-type IntegrationAuthParam = (typeof INTEGRATION_AUTH_PARAMS)[number];
-type IntegrationAuthParams = Partial<Record<IntegrationAuthParam, string>>;
-type IntegrationAuthHeader = (typeof INTEGRATION_AUTH_HEADERS)[number];
+//#region source/lib/integration-auth/provider.d.ts
+type IntegrationAuthHeader = "Authorization";
 type IntegrationAuthHeaders = Record<IntegrationAuthHeader, string>;
-type HttpMethod = (typeof HTTP_METHODS)[number];
+interface IntegrationConfig {
+  consumerKey: string;
+  consumerSecret: string;
+  accessToken: string;
+  accessTokenSecret: string;
+}
+type ValidationIssues = InferIssue<typeof IntegrationAuthParamsSchema>[] | InferIssue<typeof UrlSchema>[];
+type IntegrationAuthError = ValidationErrorType<"IntegrationAuthValidationError", ValidationIssues>;
 interface IntegrationAuthProvider {
-  getHeaders: (method: HttpMethod, url: string) => IntegrationAuthHeaders;
+  getHeaders: (method: HttpMethodInput, url: AdobeCommerceUri) => Result<IntegrationAuthHeaders, IntegrationAuthError>;
 }
-declare function getIntegrationAuthProvider(params: IntegrationAuthParams): {
-  getHeaders(method: HttpMethod, url: string): OAuth1a.Header;
-} | undefined;
+declare function getIntegrationAuthProvider(config: IntegrationConfig): IntegrationAuthProvider;
+declare function tryGetIntegrationAuthProvider(params: IntegrationAuthParams): Result<IntegrationAuthProvider, IntegrationAuthError>;
 //#endregion
-export { ImsAuthHeader, ImsAuthHeaders, ImsAuthParam, ImsAuthParams, ImsAuthProvider, IntegrationAuthHeader, IntegrationAuthHeaders, IntegrationAuthParam, IntegrationAuthParams, IntegrationAuthProvider, getImsAuthProvider, getIntegrationAuthProvider };
+export { IMS_AUTH_ENV, ImsAuthConfig, ImsAuthEnv, ImsAuthError, ImsAuthParams, ImsAuthProvider, IntegrationAuthError, IntegrationAuthParams, IntegrationAuthProvider, IntegrationConfig, getImsAuthProvider, getIntegrationAuthProvider, tryGetImsAuthProvider, tryGetIntegrationAuthProvider };