@logto/connector-aws-ses 1.1.2 → 1.2.1

package/lib/index-Cq0GQt9c.js

@@ -1,58 +0,0 @@
-import { C as CredentialsProviderError } from './index-s7VGoewj.js';
-import { readFileSync } from 'fs';
-import '@logto/connector-kit';
-import 'zod';
-import 'os';
-import 'path';
-import 'crypto';
-import 'buffer';
-import 'stream';
-import 'http';
-import 'https';
-import 'http2';
-import 'util';
-import 'process';
-
-const fromWebToken = (init) => async () => {
-    init.logger?.debug("@aws-sdk/credential-provider-web-identity", "fromWebToken");
-    const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
-    let { roleAssumerWithWebIdentity } = init;
-    if (!roleAssumerWithWebIdentity) {
-        const { getDefaultRoleAssumerWithWebIdentity } = await import('./loadSts-_S-bg8by.js');
-        roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({
-            ...init.clientConfig,
-            credentialProviderLogger: init.logger,
-            parentClientConfig: init.parentClientConfig,
-        }, init.clientPlugins);
-    }
-    return roleAssumerWithWebIdentity({
-        RoleArn: roleArn,
-        RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,
-        WebIdentityToken: webIdentityToken,
-        ProviderId: providerId,
-        PolicyArns: policyArns,
-        Policy: policy,
-        DurationSeconds: durationSeconds,
-    });
-};
-
-const ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE";
-const ENV_ROLE_ARN = "AWS_ROLE_ARN";
-const ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME";
-const fromTokenFile = (init = {}) => async () => {
-    init.logger?.debug("@aws-sdk/credential-provider-web-identity", "fromTokenFile");
-    const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
-    const roleArn = init?.roleArn ?? process.env[ENV_ROLE_ARN];
-    const roleSessionName = init?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME];
-    if (!webIdentityTokenFile || !roleArn) {
-        throw new CredentialsProviderError("Web identity configuration not specified");
-    }
-    return fromWebToken({
-        ...init,
-        webIdentityToken: readFileSync(webIdentityTokenFile, { encoding: "ascii" }),
-        roleArn,
-        roleSessionName,
-    })();
-};
-
-export { fromTokenFile, fromWebToken };

package/lib/index-DIAzYdwQ.js

@@ -1,77 +0,0 @@
-import 'os';
-import 'path';
-import { C as CredentialsProviderError, g as getProfileName } from './index-s7VGoewj.js';
-import 'crypto';
-import 'fs';
-import { p as parseKnownFiles } from './parseKnownFiles-DjQIrDWV.js';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import '@logto/connector-kit';
-import 'zod';
-import 'buffer';
-import 'stream';
-import 'http';
-import 'https';
-import 'http2';
-import 'process';
-
-const getValidatedProcessCredentials = (profileName, data) => {
-    if (data.Version !== 1) {
-        throw Error(`Profile ${profileName} credential_process did not return Version 1.`);
-    }
-    if (data.AccessKeyId === undefined || data.SecretAccessKey === undefined) {
-        throw Error(`Profile ${profileName} credential_process returned invalid credentials.`);
-    }
-    if (data.Expiration) {
-        const currentTime = new Date();
-        const expireTime = new Date(data.Expiration);
-        if (expireTime < currentTime) {
-            throw Error(`Profile ${profileName} credential_process returned expired credentials.`);
-        }
-    }
-    return {
-        accessKeyId: data.AccessKeyId,
-        secretAccessKey: data.SecretAccessKey,
-        ...(data.SessionToken && { sessionToken: data.SessionToken }),
-        ...(data.Expiration && { expiration: new Date(data.Expiration) }),
-        ...(data.CredentialScope && { credentialScope: data.CredentialScope }),
-    };
-};
-
-const resolveProcessCredentials = async (profileName, profiles) => {
-    const profile = profiles[profileName];
-    if (profiles[profileName]) {
-        const credentialProcess = profile["credential_process"];
-        if (credentialProcess !== undefined) {
-            const execPromise = promisify(exec);
-            try {
-                const { stdout } = await execPromise(credentialProcess);
-                let data;
-                try {
-                    data = JSON.parse(stdout.trim());
-                }
-                catch {
-                    throw Error(`Profile ${profileName} credential_process returned invalid JSON.`);
-                }
-                return getValidatedProcessCredentials(profileName, data);
-            }
-            catch (error) {
-                throw new CredentialsProviderError(error.message);
-            }
-        }
-        else {
-            throw new CredentialsProviderError(`Profile ${profileName} did not contain credential_process.`);
-        }
-    }
-    else {
-        throw new CredentialsProviderError(`Profile ${profileName} could not be found in shared credentials file.`);
-    }
-};
-
-const fromProcess = (init = {}) => async () => {
-    init.logger?.debug("@aws-sdk/credential-provider-process", "fromProcess");
-    const profiles = await parseKnownFiles(init);
-    return resolveProcessCredentials(getProfileName(init), profiles);
-};
-
-export { fromProcess };

package/lib/index-DIymHkFl.js

@@ -1,218 +0,0 @@
-import { f as fromArrayBuffer, h as streamCollector, C as CredentialsProviderError, H as HttpRequest, N as NodeHttpHandler } from './index-s7VGoewj.js';
-import 'http2';
-import { Readable } from 'stream';
-import fs from 'fs/promises';
-import 'buffer';
-import 'http';
-import 'https';
-import { TextDecoder } from 'util';
-import { p as parseRfc3339DateTime } from './date-utils-vaX2R5qo.js';
-import '@logto/connector-kit';
-import 'zod';
-import 'os';
-import 'path';
-import 'crypto';
-import 'fs';
-import 'process';
-
-const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
-const sdkStreamMixin = (stream) => {
-    if (!(stream instanceof Readable)) {
-        const name = stream?.__proto__?.constructor?.name || stream;
-        throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
-    }
-    let transformed = false;
-    const transformToByteArray = async () => {
-        if (transformed) {
-            throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
-        }
-        transformed = true;
-        return await streamCollector(stream);
-    };
-    return Object.assign(stream, {
-        transformToByteArray,
-        transformToString: async (encoding) => {
-            const buf = await transformToByteArray();
-            if (encoding === undefined || Buffer.isEncoding(encoding)) {
-                return fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
-            }
-            else {
-                const decoder = new TextDecoder(encoding);
-                return decoder.decode(buf);
-            }
-        },
-        transformToWebStream: () => {
-            if (transformed) {
-                throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
-            }
-            if (stream.readableFlowing !== null) {
-                throw new Error("The stream has been consumed by other callbacks.");
-            }
-            if (typeof Readable.toWeb !== "function") {
-                throw new Error("Readable.toWeb() is not supported. Please make sure you are using Node.js >= 17.0.0, or polyfill is available.");
-            }
-            transformed = true;
-            return Readable.toWeb(stream);
-        },
-    });
-};
-
-const ECS_CONTAINER_HOST = "169.254.170.2";
-const EKS_CONTAINER_HOST_IPv4 = "169.254.170.23";
-const EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]";
-const checkUrl = (url) => {
-    if (url.protocol === "https:") {
-        return;
-    }
-    if (url.hostname === ECS_CONTAINER_HOST ||
-        url.hostname === EKS_CONTAINER_HOST_IPv4 ||
-        url.hostname === EKS_CONTAINER_HOST_IPv6) {
-        return;
-    }
-    if (url.hostname.includes("[")) {
-        if (url.hostname === "[::1]" || url.hostname === "[0000:0000:0000:0000:0000:0000:0000:0001]") {
-            return;
-        }
-    }
-    else {
-        if (url.hostname === "localhost") {
-            return;
-        }
-        const ipComponents = url.hostname.split(".");
-        const inRange = (component) => {
-            const num = parseInt(component, 10);
-            return 0 <= num && num <= 255;
-        };
-        if (ipComponents[0] === "127" &&
-            inRange(ipComponents[1]) &&
-            inRange(ipComponents[2]) &&
-            inRange(ipComponents[3]) &&
-            ipComponents.length === 4) {
-            return;
-        }
-    }
-    throw new CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following:
-  - loopback CIDR 127.0.0.0/8 or [::1/128]
-  - ECS container host 169.254.170.2
-  - EKS container host 169.254.170.23 or [fd00:ec2::23]`);
-};
-
-function createGetRequest(url) {
-    return new HttpRequest({
-        protocol: url.protocol,
-        hostname: url.hostname,
-        port: Number(url.port),
-        path: url.pathname,
-        query: Array.from(url.searchParams.entries()).reduce((acc, [k, v]) => {
-            acc[k] = v;
-            return acc;
-        }, {}),
-        fragment: url.hash,
-    });
-}
-async function getCredentials(response) {
-    const contentType = response?.headers["content-type"] ?? response?.headers["Content-Type"] ?? "";
-    if (!contentType.includes("json")) {
-        console.warn("HTTP credential provider response header content-type was not application/json. Observed: " + contentType + ".");
-    }
-    const stream = sdkStreamMixin(response.body);
-    const str = await stream.transformToString();
-    if (response.statusCode === 200) {
-        const parsed = JSON.parse(str);
-        if (typeof parsed.AccessKeyId !== "string" ||
-            typeof parsed.SecretAccessKey !== "string" ||
-            typeof parsed.Token !== "string" ||
-            typeof parsed.Expiration !== "string") {
-            throw new CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: " +
-                "{ AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }");
-        }
-        return {
-            accessKeyId: parsed.AccessKeyId,
-            secretAccessKey: parsed.SecretAccessKey,
-            sessionToken: parsed.Token,
-            expiration: parseRfc3339DateTime(parsed.Expiration),
-        };
-    }
-    if (response.statusCode >= 400 && response.statusCode < 500) {
-        let parsedBody = {};
-        try {
-            parsedBody = JSON.parse(str);
-        }
-        catch (e) { }
-        throw Object.assign(new CredentialsProviderError(`Server responded with status: ${response.statusCode}`), {
-            Code: parsedBody.Code,
-            Message: parsedBody.Message,
-        });
-    }
-    throw new CredentialsProviderError(`Server responded with status: ${response.statusCode}`);
-}
-
-const retryWrapper = (toRetry, maxRetries, delayMs) => {
-    return async () => {
-        for (let i = 0; i < maxRetries; ++i) {
-            try {
-                return await toRetry();
-            }
-            catch (e) {
-                await new Promise((resolve) => setTimeout(resolve, delayMs));
-            }
-        }
-        return await toRetry();
-    };
-};
-
-const AWS_CONTAINER_CREDENTIALS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI";
-const DEFAULT_LINK_LOCAL_HOST = "http://169.254.170.2";
-const AWS_CONTAINER_CREDENTIALS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI";
-const AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE";
-const AWS_CONTAINER_AUTHORIZATION_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN";
-const fromHttp = (options) => {
-    options.logger?.debug("@aws-sdk/credential-provider-http", "fromHttp");
-    let host;
-    const relative = options.awsContainerCredentialsRelativeUri ?? process.env[AWS_CONTAINER_CREDENTIALS_RELATIVE_URI];
-    const full = options.awsContainerCredentialsFullUri ?? process.env[AWS_CONTAINER_CREDENTIALS_FULL_URI];
-    const token = options.awsContainerAuthorizationToken ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN];
-    const tokenFile = options.awsContainerAuthorizationTokenFile ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE];
-    if (relative && full) {
-        console.warn("AWS SDK HTTP credentials provider:", "you have set both awsContainerCredentialsRelativeUri and awsContainerCredentialsFullUri.");
-        console.warn("awsContainerCredentialsFullUri will take precedence.");
-    }
-    if (token && tokenFile) {
-        console.warn("AWS SDK HTTP credentials provider:", "you have set both awsContainerAuthorizationToken and awsContainerAuthorizationTokenFile.");
-        console.warn("awsContainerAuthorizationToken will take precedence.");
-    }
-    if (full) {
-        host = full;
-    }
-    else if (relative) {
-        host = `${DEFAULT_LINK_LOCAL_HOST}${relative}`;
-    }
-    else {
-        throw new CredentialsProviderError(`No HTTP credential provider host provided.
-Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.`);
-    }
-    const url = new URL(host);
-    checkUrl(url);
-    const requestHandler = new NodeHttpHandler({
-        requestTimeout: options.timeout ?? 1000,
-        connectionTimeout: options.timeout ?? 1000,
-    });
-    return retryWrapper(async () => {
-        const request = createGetRequest(url);
-        if (token) {
-            request.headers.Authorization = token;
-        }
-        else if (tokenFile) {
-            request.headers.Authorization = (await fs.readFile(tokenFile)).toString();
-        }
-        try {
-            const result = await requestHandler.handle(request);
-            return getCredentials(result.response);
-        }
-        catch (e) {
-            throw new CredentialsProviderError(String(e));
-        }
-    }, options.maxRetries ?? 3, options.timeout ?? 1000);
-};
-
-export { fromHttp };

package/lib/index-DaduCA7X.js

@@ -1,160 +0,0 @@
-import 'os';
-import 'path';
-import { C as CredentialsProviderError, g as getProfileName } from './index-s7VGoewj.js';
-import 'crypto';
-import 'fs';
-import { p as parseKnownFiles } from './parseKnownFiles-DjQIrDWV.js';
-import '@logto/connector-kit';
-import 'zod';
-import 'buffer';
-import 'stream';
-import 'http';
-import 'https';
-import 'http2';
-import 'util';
-import 'process';
-
-const resolveCredentialSource = (credentialSource, profileName) => {
-    const sourceProvidersMap = {
-        EcsContainer: (options) => import('./index-BoQzAHHB.js').then(({ fromContainerMetadata }) => fromContainerMetadata(options)),
-        Ec2InstanceMetadata: (options) => import('./index-BoQzAHHB.js').then(({ fromInstanceMetadata }) => fromInstanceMetadata(options)),
-        Environment: (options) => import('./index-CMob0Rvo.js').then(({ fromEnv }) => fromEnv(options)),
-    };
-    if (credentialSource in sourceProvidersMap) {
-        return sourceProvidersMap[credentialSource];
-    }
-    else {
-        throw new CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, ` +
-            `expected EcsContainer or Ec2InstanceMetadata or Environment.`);
-    }
-};
-
-const isAssumeRoleProfile = (arg) => Boolean(arg) &&
-    typeof arg === "object" &&
-    typeof arg.role_arn === "string" &&
-    ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 &&
-    ["undefined", "string"].indexOf(typeof arg.external_id) > -1 &&
-    ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 &&
-    (isAssumeRoleWithSourceProfile(arg) || isAssumeRoleWithProviderProfile(arg));
-const isAssumeRoleWithSourceProfile = (arg) => typeof arg.source_profile === "string" && typeof arg.credential_source === "undefined";
-const isAssumeRoleWithProviderProfile = (arg) => typeof arg.credential_source === "string" && typeof arg.source_profile === "undefined";
-const resolveAssumeRoleCredentials = async (profileName, profiles, options, visitedProfiles = {}) => {
-    options.logger?.debug("@aws-sdk/credential-provider-ini", "resolveAssumeRoleCredentials (STS)");
-    const data = profiles[profileName];
-    if (!options.roleAssumer) {
-        const { getDefaultRoleAssumer } = await import('./loadSts-CqVZgkwk.js');
-        options.roleAssumer = getDefaultRoleAssumer({
-            ...options.clientConfig,
-            credentialProviderLogger: options.logger,
-            parentClientConfig: options?.parentClientConfig,
-        }, options.clientPlugins);
-    }
-    const { source_profile } = data;
-    if (source_profile && source_profile in visitedProfiles) {
-        throw new CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile` +
-            ` ${getProfileName(options)}. Profiles visited: ` +
-            Object.keys(visitedProfiles).join(", "), false);
-    }
-    const sourceCredsProvider = source_profile
-        ? resolveProfileData(source_profile, profiles, options, {
-            ...visitedProfiles,
-            [source_profile]: true,
-        })
-        : (await resolveCredentialSource(data.credential_source, profileName)(options))();
-    const params = {
-        RoleArn: data.role_arn,
-        RoleSessionName: data.role_session_name || `aws-sdk-js-${Date.now()}`,
-        ExternalId: data.external_id,
-        DurationSeconds: parseInt(data.duration_seconds || "3600", 10),
-    };
-    const { mfa_serial } = data;
-    if (mfa_serial) {
-        if (!options.mfaCodeProvider) {
-            throw new CredentialsProviderError(`Profile ${profileName} requires multi-factor authentication, but no MFA code callback was provided.`, false);
-        }
-        params.SerialNumber = mfa_serial;
-        params.TokenCode = await options.mfaCodeProvider(mfa_serial);
-    }
-    const sourceCreds = await sourceCredsProvider;
-    return options.roleAssumer(sourceCreds, params);
-};
-
-const isProcessProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.credential_process === "string";
-const resolveProcessCredentials = async (options, profile) => import('./index-DIAzYdwQ.js').then(({ fromProcess }) => fromProcess({
-    ...options,
-    profile,
-})());
-
-const resolveSsoCredentials = async (profile, options = {}) => {
-    const { fromSSO } = await import('./index-BjiMjUem.js');
-    return fromSSO({
-        profile,
-        logger: options.logger,
-    })();
-};
-const isSsoProfile = (arg) => arg &&
-    (typeof arg.sso_start_url === "string" ||
-        typeof arg.sso_account_id === "string" ||
-        typeof arg.sso_session === "string" ||
-        typeof arg.sso_region === "string" ||
-        typeof arg.sso_role_name === "string");
-
-const isStaticCredsProfile = (arg) => Boolean(arg) &&
-    typeof arg === "object" &&
-    typeof arg.aws_access_key_id === "string" &&
-    typeof arg.aws_secret_access_key === "string" &&
-    ["undefined", "string"].indexOf(typeof arg.aws_session_token) > -1;
-const resolveStaticCredentials = (profile, options) => {
-    options?.logger?.debug("@aws-sdk/credential-provider-ini", "resolveStaticCredentials");
-    return Promise.resolve({
-        accessKeyId: profile.aws_access_key_id,
-        secretAccessKey: profile.aws_secret_access_key,
-        sessionToken: profile.aws_session_token,
-        credentialScope: profile.aws_credential_scope,
-    });
-};
-
-const isWebIdentityProfile = (arg) => Boolean(arg) &&
-    typeof arg === "object" &&
-    typeof arg.web_identity_token_file === "string" &&
-    typeof arg.role_arn === "string" &&
-    ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1;
-const resolveWebIdentityCredentials = async (profile, options) => import('./index-Cq0GQt9c.js').then(({ fromTokenFile }) => fromTokenFile({
-    webIdentityTokenFile: profile.web_identity_token_file,
-    roleArn: profile.role_arn,
-    roleSessionName: profile.role_session_name,
-    roleAssumerWithWebIdentity: options.roleAssumerWithWebIdentity,
-    logger: options.logger,
-    parentClientConfig: options.parentClientConfig,
-})());
-
-const resolveProfileData = async (profileName, profiles, options, visitedProfiles = {}) => {
-    const data = profiles[profileName];
-    if (Object.keys(visitedProfiles).length > 0 && isStaticCredsProfile(data)) {
-        return resolveStaticCredentials(data, options);
-    }
-    if (isAssumeRoleProfile(data)) {
-        return resolveAssumeRoleCredentials(profileName, profiles, options, visitedProfiles);
-    }
-    if (isStaticCredsProfile(data)) {
-        return resolveStaticCredentials(data, options);
-    }
-    if (isWebIdentityProfile(data)) {
-        return resolveWebIdentityCredentials(data, options);
-    }
-    if (isProcessProfile(data)) {
-        return resolveProcessCredentials(options, profileName);
-    }
-    if (isSsoProfile(data)) {
-        return await resolveSsoCredentials(profileName, options);
-    }
-    throw new CredentialsProviderError(`Profile ${profileName} could not be found or parsed in shared credentials file.`);
-};
-
-const fromIni = (init = {}) => async () => {
-    init.logger?.debug("@aws-sdk/credential-provider-ini", "fromIni");
-    const profiles = await parseKnownFiles(init);
-    return resolveProfileData(getProfileName(init), profiles, init);
-};
-
-export { fromIni };

package/lib/index-Dh6q8yRM.js

@@ -1,14 +0,0 @@
-export { a as credentialsTreatedAsExpired, c as credentialsWillNeedRefresh, d as defaultProvider } from './index-s7VGoewj.js';
-import '@logto/connector-kit';
-import 'zod';
-import 'os';
-import 'path';
-import 'crypto';
-import 'fs';
-import 'buffer';
-import 'stream';
-import 'http';
-import 'https';
-import 'http2';
-import 'util';
-import 'process';