chore: merge ssdk branch into main (#2279)

* chore: serialize rest json error code header (#2166)

* chore: short-circuit ssdk-incompatible integrations (#2167)

* chore: disable idempotency autofill import when not generating a client (#2181)

* Support generating non-AWS client (#2222)

* feat(config-resolver): make region optional for non-AWS client

* feat(codegen): skip integrations that are not relevant for non-AWS services

This is an initial version to get a working version of generated code
that compiles without manual edits in smithy-typescript-ssdk-demo. I
expect to make updates to this logic.

* chore(codegen): address code comments

The minor ones from adamthom-amzn/aws-sdk-js-v3#1

* fix(codegen): use SigV4Trait check instead of ServiceTrait

AddAwsRuntimeConfigTest is checking for some behaviors from
AddAwsAuthPlugin too, which was failing with missing aws.auth#sigv4
trait after my change. Added the trait for now to the test, but unit
tests will need to be added/refactored for all these changes.

* chore(codegen): move isAwsService check to utils class

* chore(codegen): code style formatting

* chore(codegen): check SigV4 trait for including region

* chore(codegen,config-resolver): refactor how endpoint is resolved for non-AWS client (#2287)

* chore(config-resolver): refactor EndpointsConfig for non AWS services

This reverts an earlier change to EndpointsConfig.ts and instead
provides the new functionality in separate
CustomEndpointsConfig.ts. This will be used as a separate plugin for
endpoint resolution in non AWS clients.

* feat(codegen): Use separate CustomEndpointsConfig for non-AWS clients

This depends on newly added CustomEndpointsConfig in
@aws-sdk/config-resolver package.

* test(config-resolver): add test for CustomEndpointsConfig (#2305)

Co-authored-by: Adam Thomas <[email protected]>
Co-authored-by: Jaykumar Gosar <[email protected]>

Author: 3 people

packages/config-resolver/src/CustomEndpointsConfig.spec.ts

@@ -0,0 +1,64 @@
+import { Endpoint } from "@aws-sdk/types";
+
+import { resolveCustomEndpointsConfig } from "./CustomEndpointsConfig";
+
+describe("CustomEndpointsConfig", () => {
+  const urlParser = jest.fn();
+
+  const input = { urlParser };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("endpoint", () => {
+    const mockEndpoint: Endpoint = { protocol: "protocol", hostname: "hostname", path: "path" };
+
+    it("returns output of urlParser if endpoint is of type string", async () => {
+      const endpoint = "endpoint";
+      urlParser.mockReturnValueOnce(mockEndpoint);
+      const { endpoint: endpointProvider, isCustomEndpoint } = resolveCustomEndpointsConfig({ ...input, endpoint });
+      expect(isCustomEndpoint).toBe(true);
+      const endpointOutput = await endpointProvider();
+      expect(endpointOutput).toStrictEqual(mockEndpoint);
+      expect(urlParser).toHaveBeenCalledTimes(1);
+      expect(urlParser).toHaveBeenCalledWith(endpoint);
+    });
+
+    it("returns promisified endpoint if it's of type object", async () => {
+      const endpoint = mockEndpoint;
+      const { endpoint: endpointProvider, isCustomEndpoint } = resolveCustomEndpointsConfig({ ...input, endpoint });
+      expect(isCustomEndpoint).toBe(true);
+      const endpointOutput = await endpointProvider();
+      expect(endpointOutput).toStrictEqual(endpoint);
+      expect(urlParser).not.toHaveBeenCalled();
+    });
+
+    it("returns endpoint if it's already Provider<Endpoint>", async () => {
+      const endpoint = () => Promise.resolve(mockEndpoint);
+      const { endpoint: endpointProvider, isCustomEndpoint } = resolveCustomEndpointsConfig({ ...input, endpoint });
+      expect(isCustomEndpoint).toBe(true);
+      const endpointOutput = await endpointProvider();
+      expect(endpointOutput).toStrictEqual(mockEndpoint);
+      expect(urlParser).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("tls", () => {
+    const endpoint = "endpoint";
+
+    beforeEach(() => {
+      urlParser.mockReturnValueOnce({ protocol: "protocol", hostname: "hostname", path: "path" });
+    });
+
+    [true, false].forEach((tls) => {
+      it(`returns input.tls when it's ${tls}`, () => {
+        expect(resolveCustomEndpointsConfig({ ...input, endpoint, tls }).tls).toStrictEqual(tls);
+      });
+    });
+
+    it("returns true is input.tls is undefined", () => {
+      expect(resolveCustomEndpointsConfig({ ...input, endpoint }).tls).toStrictEqual(true);
+    });
+  });
+});

packages/config-resolver/src/CustomEndpointsConfig.ts

@@ -0,0 +1,43 @@
+import { Endpoint, Provider, UrlParser } from "@aws-sdk/types";
+
+export interface CustomEndpointsInputConfig {
+  /**
+   * The fully qualified endpoint of the webservice.
+   */
+  endpoint: string | Endpoint | Provider<Endpoint>;
+
+  /**
+   * Whether TLS is enabled for requests.
+   */
+  tls?: boolean;
+}
+
+interface PreviouslyResolved {
+  urlParser: UrlParser;
+}
+
+export interface CustomEndpointsResolvedConfig extends Required<CustomEndpointsInputConfig> {
+  endpoint: Provider<Endpoint>;
+  isCustomEndpoint: true;
+}
+
+export const resolveCustomEndpointsConfig = <T>(
+  input: T & CustomEndpointsInputConfig & PreviouslyResolved
+): T & CustomEndpointsResolvedConfig => ({
+  ...input,
+  tls: input.tls ?? true,
+  endpoint: normalizeEndpoint(input),
+  isCustomEndpoint: true,
+});
+
+const normalizeEndpoint = (input: CustomEndpointsInputConfig & PreviouslyResolved): Provider<Endpoint> => {
+  const { endpoint, urlParser } = input;
+  if (typeof endpoint === "string") {
+    const promisified = Promise.resolve(urlParser(endpoint));
+    return () => promisified;
+  } else if (typeof endpoint === "object") {
+    const promisified = Promise.resolve(endpoint);
+    return () => promisified;
+  }
+  return endpoint;
+};

packages/config-resolver/src/index.ts

@@ -1,2 +1,3 @@
+export * from "./CustomEndpointsConfig";
 export * from "./EndpointsConfig";
 export * from "./RegionConfig";