@aws-sdk/middleware-endpoint-discovery 3.32.0 → 3.36.0

package/src/resolveEndpointDiscoveryConfig.spec.ts

@@ -1,63 +0,0 @@
-import { EndpointCache } from "@aws-sdk/endpoint-cache";
-
-import { resolveEndpointDiscoveryConfig } from "./resolveEndpointDiscoveryConfig";
-
-jest.mock("@aws-sdk/endpoint-cache");
-
-describe(resolveEndpointDiscoveryConfig.name, () => {
-  const endpointDiscoveryCommandCtor = jest.fn();
-  const mockInput = {
-    isCustomEndpoint: false,
-    credentials: jest.fn(),
-    endpointDiscoveryEnabledProvider: jest.fn(),
-  };
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("assigns endpointDiscoveryCommandCtor in resolvedConfig", () => {
-    const resolvedConfig = resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
-    expect(resolvedConfig.endpointDiscoveryCommandCtor).toStrictEqual(endpointDiscoveryCommandCtor);
-  });
-
-  describe("endpointCache", () => {
-    it("creates cache of size endpointCacheSize if passed", () => {
-      const endpointCacheSize = 100;
-      resolveEndpointDiscoveryConfig(
-        {
-          ...mockInput,
-          endpointCacheSize,
-        },
-        { endpointDiscoveryCommandCtor }
-      );
-      expect(EndpointCache).toBeCalledWith(endpointCacheSize);
-    });
-
-    it("creates cache of size 1000 if endpointCacheSize not passed", () => {
-      resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
-      expect(EndpointCache).toBeCalledWith(1000);
-    });
-  });
-
-  describe("endpointDiscoveryEnabled", () => {
-    it.each<boolean>([false, true])(`sets to value passed in the config: %s`, (endpointDiscoveryEnabled) => {
-      const resolvedConfig = resolveEndpointDiscoveryConfig(
-        {
-          ...mockInput,
-          endpointDiscoveryEnabled,
-        },
-        { endpointDiscoveryCommandCtor }
-      );
-      expect(resolvedConfig.endpointDiscoveryEnabled()).resolves.toBe(endpointDiscoveryEnabled);
-      expect(mockInput.endpointDiscoveryEnabledProvider).not.toHaveBeenCalled();
-      expect(resolvedConfig.isClientEndpointDiscoveryEnabled).toStrictEqual(true);
-    });
-
-    it(`sets to endpointDiscoveryEnabledProvider if value is not passed`, () => {
-      const resolvedConfig = resolveEndpointDiscoveryConfig(mockInput, { endpointDiscoveryCommandCtor });
-      expect(resolvedConfig.endpointDiscoveryEnabled).toBe(mockInput.endpointDiscoveryEnabledProvider);
-      expect(resolvedConfig.isClientEndpointDiscoveryEnabled).toStrictEqual(false);
-    });
-  });
-});

package/src/resolveEndpointDiscoveryConfig.ts

@@ -1,73 +0,0 @@
-import { EndpointCache } from "@aws-sdk/endpoint-cache";
-import { Credentials, Provider } from "@aws-sdk/types";
-
-export interface EndpointDiscoveryInputConfig {}
-
-export interface PreviouslyResolved {
-  isCustomEndpoint: boolean;
-  credentials: Provider<Credentials>;
-  endpointDiscoveryEnabledProvider: Provider<boolean | undefined>;
-}
-
-export interface EndpointDiscoveryInputConfig {
-  /**
-   * The size of the client cache storing endpoints from endpoint discovery operations.
-   * Defaults to 1000.
-   */
-  endpointCacheSize?: number;
-
-  /**
-   * Whether to call operations with endpoints given by service dynamically.
-   * Setting this config to `true` will enable endpoint discovery for all applicable operations.
-   * Setting it to `false` will explicitly disable endpoint discovery even though operations that
-   * require endpoint discovery will presumably fail. Leaving it to undefined means SDK only do
-   * endpoint discovery when it's required. Defaults to `undefined`.
-   */
-  endpointDiscoveryEnabled?: boolean | undefined;
-}
-export interface EndpointDiscoveryResolvedConfig {
-  /**
-   * LRU Cache which stores endpoints from endpoint discovery operations.
-   * The size is either provided by {@link EndpointDiscoveryInputConfig.endpointCacheSize}.
-   */
-  endpointCache: EndpointCache;
-
-  /**
-   * The constructor of the Command used for discovering endpoints.
-   * @internal
-   */
-  endpointDiscoveryCommandCtor: new (comandConfig: any) => any;
-
-  /**
-   * Resolved value for input config {@link EndpointDiscoveryInputConfig.endpointDiscoveryEnabled}.
-   */
-  endpointDiscoveryEnabled: Provider<boolean | undefined>;
-
-  /**
-   * Stores whether endpoint discovery configuration is set locally by passing
-   * {@link EndpointDiscoveryInputConfig.endpointDiscoveryEnabled} during client creation.
-   * @internal
-   */
-  isClientEndpointDiscoveryEnabled: boolean;
-}
-
-export interface EndpointDiscoveryConfigOptions {
-  /**
-   * The constructor of the Command used for discovering endpoints.
-   */
-  endpointDiscoveryCommandCtor: new (comandConfig: any) => any;
-}
-
-export const resolveEndpointDiscoveryConfig = <T>(
-  input: T & PreviouslyResolved & EndpointDiscoveryInputConfig,
-  { endpointDiscoveryCommandCtor }: EndpointDiscoveryConfigOptions
-): T & EndpointDiscoveryResolvedConfig => ({
-  ...input,
-  endpointDiscoveryCommandCtor,
-  endpointCache: new EndpointCache(input.endpointCacheSize ?? 1000),
-  endpointDiscoveryEnabled:
-    input.endpointDiscoveryEnabled !== undefined
-      ? () => Promise.resolve(input.endpointDiscoveryEnabled)
-      : input.endpointDiscoveryEnabledProvider,
-  isClientEndpointDiscoveryEnabled: input.endpointDiscoveryEnabled !== undefined,
-});

package/src/updateDiscoveredEndpointInCache.spec.ts

@@ -1,172 +0,0 @@
-import { updateDiscoveredEndpointInCache } from "./updateDiscoveredEndpointInCache";
-
-describe(updateDiscoveredEndpointInCache.name, () => {
-  const cacheKey = "cacheKey";
-  const mockGet = jest.fn();
-  const mockSet = jest.fn();
-  const mockDelete = jest.fn();
-
-  const mockHandler = jest.fn();
-  const mockResolveMiddleware = jest.fn().mockReturnValue(mockHandler);
-
-  const mockEndpoints = [{ Address: "mockAddress", CachePeriodInMinutes: 2 }];
-  const placeholderEndpoints = [{ Address: "", CachePeriodInMinutes: 1 }];
-
-  const config = {
-    endpointCache: { get: mockGet, set: mockSet, delete: mockDelete },
-  };
-
-  const options = {
-    cacheKey,
-    commandName: "ExampleCommand",
-    endpointDiscoveryCommandCtor: jest.fn().mockReturnValue({ resolveMiddleware: mockResolveMiddleware }),
-    isDiscoveredEndpointRequired: false,
-    identifiers: { key: "value" },
-  };
-
-  beforeEach(() => {
-    mockGet.mockReturnValue(mockEndpoints);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it(`returns if endpoints are present in cacheKey`, async () => {
-    // @ts-ignore
-    await updateDiscoveredEndpointInCache(config, options);
-    expect(mockGet).toHaveBeenCalledWith(cacheKey);
-    expect(mockSet).not.toHaveBeenCalled();
-    expect(mockDelete).not.toHaveBeenCalled();
-  });
-
-  describe("calls endpointDiscoveryCommandCtor", () => {
-    beforeEach(() => {
-      mockGet.mockReturnValue(undefined);
-    });
-
-    const verifyCallsOnCacheUndefined = () => {
-      expect(mockGet).toHaveBeenCalledTimes(1);
-
-      expect(options.endpointDiscoveryCommandCtor).toHaveBeenCalledWith({
-        Operation: options.commandName.substr(0, options.commandName.length - 7),
-        Identifiers: options.identifiers,
-      });
-      expect(mockHandler).toHaveBeenCalledTimes(1);
-    };
-
-    it("on successful call: updates cache", async () => {
-      mockHandler.mockResolvedValueOnce({ output: { Endpoints: mockEndpoints } });
-
-      // @ts-ignore
-      await updateDiscoveredEndpointInCache(config, options);
-
-      verifyCallsOnCacheUndefined();
-      expect(mockDelete).not.toHaveBeenCalled();
-      expect(mockSet).toHaveBeenCalledTimes(2);
-      expect(mockSet).toHaveBeenNthCalledWith(1, cacheKey, placeholderEndpoints);
-      expect(mockSet).toHaveBeenNthCalledWith(2, cacheKey, mockEndpoints);
-    });
-
-    it("calls endpointDiscoveryCommandCtor command just once in case of parallel calls", async () => {
-      mockHandler.mockResolvedValueOnce({ output: { Endpoints: mockEndpoints } });
-      // First call returns undefined, while other ones return placeholder endpoints a call is in progress
-      mockGet
-        .mockReturnValueOnce(undefined)
-        .mockReturnValueOnce(placeholderEndpoints)
-        .mockReturnValueOnce(placeholderEndpoints);
-
-      await Promise.all([
-        // @ts-ignore
-        updateDiscoveredEndpointInCache(config, options),
-        // @ts-ignore
-        updateDiscoveredEndpointInCache(config, options),
-        // @ts-ignore
-        updateDiscoveredEndpointInCache(config, options),
-      ]);
-
-      expect(mockGet).toHaveBeenCalledTimes(3);
-
-      expect(options.endpointDiscoveryCommandCtor).toHaveBeenCalledWith({
-        Operation: options.commandName.substr(0, options.commandName.length - 7),
-        Identifiers: options.identifiers,
-      });
-      expect(mockHandler).toHaveBeenCalledTimes(1);
-
-      expect(mockDelete).not.toHaveBeenCalled();
-      expect(mockSet).toHaveBeenCalledTimes(2);
-      expect(mockSet).toHaveBeenNthCalledWith(1, cacheKey, placeholderEndpoints);
-      expect(mockSet).toHaveBeenNthCalledWith(2, cacheKey, mockEndpoints);
-    });
-
-    describe("on error", () => {
-      it(`throws if isDiscoveredEndpointRequired=true`, async () => {
-        const error = new Error("rejected");
-        mockHandler.mockRejectedValueOnce(error);
-
-        try {
-          // @ts-ignore
-          await updateDiscoveredEndpointInCache(config, { ...options, isDiscoveredEndpointRequired: true });
-          fail("updateDiscoveredEndpointInCache should throw");
-        } catch (error) {
-          expect(error).toEqual(
-            Object.assign(
-              new Error(
-                `The operation to discover endpoint failed.` +
-                  ` Please retry, or provide a custom endpoint and disable endpoint discovery to proceed.`
-              ),
-              { reason: error }
-            )
-          );
-        }
-        verifyCallsOnCacheUndefined();
-        expect(mockDelete).not.toHaveBeenCalled();
-        expect(mockSet).toHaveBeenCalledTimes(1);
-        expect(mockSet).toHaveBeenCalledWith(cacheKey, placeholderEndpoints);
-      });
-
-      it(`sets placeholder enpoint if isDiscoveredEndpointRequired=false`, async () => {
-        const error = new Error("rejected");
-        mockHandler.mockRejectedValueOnce(error);
-
-        // @ts-ignore
-        await updateDiscoveredEndpointInCache(config, options);
-
-        verifyCallsOnCacheUndefined();
-        expect(mockDelete).not.toHaveBeenCalled();
-        expect(mockSet).toHaveBeenCalledTimes(2);
-        expect(mockSet).toHaveBeenNthCalledWith(1, cacheKey, placeholderEndpoints);
-        expect(mockSet).toHaveBeenNthCalledWith(2, cacheKey, placeholderEndpoints);
-      });
-
-      describe(`deletes cacheKey in case of`, () => {
-        const verifyCallsOnCacheKeyDelete = () => {
-          expect(mockDelete).toHaveBeenCalledWith(cacheKey);
-          expect(mockSet).toHaveBeenCalledTimes(2);
-          expect(mockSet).toHaveBeenNthCalledWith(1, cacheKey, placeholderEndpoints);
-          expect(mockSet).toHaveBeenNthCalledWith(2, cacheKey, placeholderEndpoints);
-        };
-
-        it(`InvalidEndpointException`, async () => {
-          const error = Object.assign(new Error("Invalid endpoint!"), { name: "InvalidEndpointException" });
-          mockHandler.mockRejectedValueOnce(error);
-
-          // @ts-ignore
-          await updateDiscoveredEndpointInCache(config, options);
-          verifyCallsOnCacheUndefined();
-          verifyCallsOnCacheKeyDelete();
-        });
-
-        it(`Status code: 421`, async () => {
-          const error = Object.assign(new Error("Invalid endpoint!"), { $metadata: { httpStatusCode: 421 } });
-          mockHandler.mockRejectedValueOnce(error);
-
-          // @ts-ignore
-          await updateDiscoveredEndpointInCache(config, options);
-          verifyCallsOnCacheUndefined();
-          verifyCallsOnCacheKeyDelete();
-        });
-      });
-    });
-  });
-});

package/src/updateDiscoveredEndpointInCache.ts

@@ -1,88 +0,0 @@
-import { EndpointDiscoveryMiddlewareConfig } from "./getEndpointDiscoveryPlugin";
-import { EndpointDiscoveryResolvedConfig, PreviouslyResolved } from "./resolveEndpointDiscoveryConfig";
-
-export interface UpdateDiscoveredEndpointInCacheOptions extends EndpointDiscoveryMiddlewareConfig {
-  cacheKey: string;
-  commandName: string;
-  endpointDiscoveryCommandCtor: new (comandConfig: any) => any;
-}
-
-const requestQueue: { [key: string]: { resolve: Function; reject: Function }[] } = {};
-
-export const updateDiscoveredEndpointInCache = async (
-  config: EndpointDiscoveryResolvedConfig & PreviouslyResolved,
-  options: UpdateDiscoveredEndpointInCacheOptions
-) =>
-  new Promise<void>((resolve, reject) => {
-    const { endpointCache } = config;
-    const { cacheKey, commandName, identifiers } = options;
-
-    const endpoints = endpointCache.get(cacheKey);
-
-    if (endpoints && endpoints.length === 1 && endpoints[0].Address === "") {
-      // Endpoint operation already in-flight.
-      // Add request to request queue only if discovered endpoint is required.
-      if (options.isDiscoveredEndpointRequired) {
-        if (!requestQueue[cacheKey]) requestQueue[cacheKey] = [];
-        requestQueue[cacheKey].push({ resolve, reject });
-      } else {
-        resolve();
-      }
-    } else if (endpoints && endpoints.length > 0) {
-      // Endpoint record is present in cache.
-      resolve();
-    } else {
-      // put in a placeholder for endpoints already requested, prevent
-      // too much in-flight calls.
-      const placeholderEndpoints = [{ Address: "", CachePeriodInMinutes: 1 }];
-      endpointCache.set(cacheKey, placeholderEndpoints);
-
-      const command = new options.endpointDiscoveryCommandCtor({
-        Operation: commandName.substr(0, commandName.length - 7), // strip "Command"
-        Identifiers: identifiers,
-      });
-      const handler = command.resolveMiddleware(options.clientStack, config, options.options);
-      handler(command)
-        .then((result: any) => {
-          endpointCache.set(cacheKey, result.output.Endpoints);
-          if (requestQueue[cacheKey]) {
-            requestQueue[cacheKey].forEach(({ resolve }) => {
-              resolve();
-            });
-            delete requestQueue[cacheKey];
-          }
-          resolve();
-        })
-        .catch((error: any) => {
-          if (error.name === "InvalidEndpointException" || error.$metadata?.httpStatusCode === 421) {
-            // Endpoint is invalid, delete the cache entry.
-            endpointCache.delete(cacheKey);
-          }
-
-          const errorToThrow = Object.assign(
-            new Error(
-              `The operation to discover endpoint failed.` +
-                ` Please retry, or provide a custom endpoint and disable endpoint discovery to proceed.`
-            ),
-            { reason: error }
-          );
-
-          //fail all the pending requests in batch
-          if (requestQueue[cacheKey]) {
-            requestQueue[cacheKey].forEach(({ reject }) => {
-              reject(errorToThrow);
-            });
-            delete requestQueue[cacheKey];
-          }
-
-          if (options.isDiscoveredEndpointRequired) {
-            reject(errorToThrow);
-          } else {
-            // Endpoint Discovery is optional. No error needs to be thrown.
-            // Set placeHolder endpoint to disable refresh for one minute.
-            endpointCache.set(cacheKey, placeholderEndpoints);
-            resolve();
-          }
-        });
-    }
-  });

package/tsconfig.cjs.json

@@ -1,10 +0,0 @@
-{
-  "compilerOptions": {
-    "declarationDir": "./dist/types",
-    "rootDir": "./src",
-    "outDir": "./dist/cjs",
-    "baseUrl": "."
-  },
-  "extends": "../../tsconfig.cjs.json",
-  "include": ["src/"]
-}

package/tsconfig.es.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["es5", "es2015.promise", "es2015.collection", "es2015.iterable", "es2015.symbol.wellknown"],
-    "declarationDir": "./dist/types",
-    "rootDir": "./src",
-    "outDir": "./dist/es",
-    "baseUrl": "."
-  },
-  "extends": "../../tsconfig.es.json",
-  "include": ["src/"]
-}