@infoxchange/make-it-so 2.13.0 → 2.14.0-internal-testing-add-sst-3-support.2

package/src/components/ix/dns.ts

@@ -0,0 +1,280 @@
+// Based on https://github.com/anomalyco/sst/blob/3407c32b2cf97b85ea96a92361c6f4a0a8d55200/platform/src/components/aws/dns.ts
+/**
+ * The AWS DNS Adapter is used to create DNS records to manage domains hosted on
+ * [Route 53](https://aws.amazon.com/route53/).
+ *
+ * This adapter is passed in as `domain.dns` when setting a custom domain.
+ *
+ * @example
+ *
+ * ```ts
+ * {
+ *   domain: {
+ *     name: "example.com",
+ *     dns: sst.aws.dns()
+ *   }
+ * }
+ * ```
+ *
+ * You can also specify a hosted zone ID if you have multiple hosted zones with the same domain.
+ *
+ * ```ts
+ * {
+ *   domain: {
+ *     name: "example.com",
+ *     dns: sst.aws.dns({
+ *       zone: "Z2FDTNDATAQYW2"
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+import {
+  AliasRecord,
+  Dns,
+  Record as DnsRecord,
+} from "sst3/platform/src/components/dns";
+import { logicalName } from "sst3/platform/src/components/naming";
+import { ComponentResourceOptions, output } from "@pulumi/pulumi";
+import { Transform, transform } from "sst3/platform/src/components/component";
+import { Input } from "sst3/platform/src/components/input";
+import { useProvider } from "sst3/platform/src/components/aws/helpers/provider";
+import { route53 } from "@pulumi/aws";
+import { VisibleError } from "sst3/platform/src/components/error";
+import * as aws from "@pulumi/aws";
+
+export interface DnsArgs {
+  /**
+   * Set the hosted zone ID if you have multiple hosted zones that have the same
+   * domain in Route 53.
+   *
+   * The 14 letter ID of the [Route 53 hosted zone](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/hosted-zones-working-with.html) that contains the `domainName`. You can find the hosted zone ID in the Route 53 part of the AWS Console.
+   *
+   * @example
+   * ```js
+   * {
+   *   zone: "Z2FDTNDATAQYW2"
+   * }
+   * ```
+   */
+  zone?: Input<string>;
+  /**
+   * Set to `true` if you want to let the new DNS records replace the existing ones.
+   *
+   * :::tip
+   * Use this to migrate over your domain without any downtime.
+   * :::
+   *
+   * This is useful if your domain is currently used by another app and you want to switch it
+   * to your current app. Without setting this, you'll first have to remove the existing DNS
+   * records and then add the new one. This can cause downtime.
+   *
+   * You can avoid this by setting this to `true` and the existing DNS records will be replaced
+   * without any downtime. Just make sure that when you remove your old app, you don't remove
+   * the DNS records.
+   *
+   * @default `false`
+   * @example
+   * ```js
+   * {
+   *   override: true
+   * }
+   * ```
+   */
+  override?: Input<boolean>;
+  /**
+   * [Transform](/docs/components#transform) how this component creates its underlying
+   * resources.
+   */
+  transform?: {
+    /**
+     * Transform the AWS Route 53 record resource.
+     */
+    record?: Transform<
+      route53.RecordArgs & {
+        aliasIpType?: "IPv4" | "IPv6";
+        // Can be used to override the raw input to the IX DNS lambda
+        lambdaInput?: Record<string, unknown>;
+      }
+    >;
+  };
+}
+
+export function dns(args: DnsArgs = {}) {
+  return {
+    provider: "aws",
+    createAlias,
+    createCaa,
+    createRecord,
+  } satisfies Dns;
+
+  /**
+   * Creates alias records in the hosted zone.
+   *
+   * @param namePrefix The prefix to use for the resource names.
+   * @param record The alias record to create.
+   * @param opts The component resource options.
+   */
+  function createAlias(
+    namePrefix: string,
+    record: AliasRecord,
+    opts: ComponentResourceOptions,
+  ) {
+    return ["A", "AAAA"].map((type) =>
+      _createRecord(
+        namePrefix,
+        {
+          type,
+          name: record.name,
+          aliases: [
+            {
+              name: record.aliasName,
+              zoneId: record.aliasZone,
+              evaluateTargetHealth: true,
+            },
+          ],
+        },
+        opts,
+      ),
+    );
+  }
+
+  function createCaa(
+    /* eslint-disable @typescript-eslint/no-unused-vars -- Kept for typing even though it's not used for this
+    implementation of Dns */
+    namePrefix: string,
+    recordName: string,
+    opts: ComponentResourceOptions,
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ) {
+    // placeholder
+    return undefined;
+  }
+
+  /**
+   * Creates a DNS record in the hosted zone.
+   *
+   * @param namePrefix The prefix to use for the resource names.
+   * @param record The DNS record to create.
+   * @param opts The component resource options.
+   */
+  function createRecord(
+    namePrefix: string,
+    record: DnsRecord,
+    opts: ComponentResourceOptions,
+  ) {
+    return _createRecord(
+      namePrefix,
+      {
+        type: record.type,
+        name: record.name,
+        ttl: 60,
+        records: [record.value],
+      },
+      opts,
+    );
+  }
+
+  function _createRecord(
+    namePrefix: string,
+    partial: Omit<route53.RecordArgs, "zoneId">,
+    opts: ComponentResourceOptions,
+  ) {
+    return output(partial).apply((partial) => {
+      const nameSuffix = logicalName(partial.name);
+      const zoneId = ""; // The IX dns lambda will determine the zone ID based on the domain name
+      const dnsRecord = createRecord();
+      return dnsRecord;
+
+      function createRecord() {
+        const [name, mergedArgs, mergedOpts] = transform(
+          args.transform?.record,
+          `${namePrefix}${partial.type}Record${nameSuffix}`,
+          {
+            zoneId,
+            allowOverwrite: args.override,
+            ...partial,
+          },
+          opts,
+        );
+        const lambdaInput = output(mergedArgs).apply((mergedArgs) => {
+          const { aliases } = mergedArgs;
+          let { aliasIpType } = mergedArgs;
+          if (aliases && aliases.length > 1) {
+            throw new VisibleError(
+              "Aliases with multiple targets are not supported",
+            );
+          }
+          const [alias] = aliases || [];
+          if (alias) {
+            if (mergedArgs.type === "A") {
+              aliasIpType = "IPv4";
+            } else if (mergedArgs.type === "AAAA") {
+              aliasIpType = "IPv6";
+            } else {
+              throw new VisibleError(
+                "Alias records can only be created for A or AAAA record types",
+              );
+            }
+          }
+          return {
+            RecordType: mergedArgs.type,
+            // Even though a trailing dot is valid a bug in the IX dns lambda means that an error occurs
+            // when trying to find the hosted zone if there is a trailing dot.
+            RecordFQDN: mergedArgs.name.replace(/\.$/, ""),
+            // If giving the IX dns lambda multiple values we need to wrap in 'Value' objects
+            // unlike for single values where the lambda does it for us
+            // https://github.com/InfoxchangeTS/aws-gov/blob/213609c2e91b021375b93290efdaf38936ee98e1/components/xaccount-route53/dns-record-updater-lambda/src/index.py#L133
+            RecordValue: mergedArgs.records?.map((value) => ({ Value: value })),
+            ...(mergedArgs.zoneId ? { HostedZoneId: mergedArgs.zoneId } : {}),
+            ...(mergedArgs.ttl ? { RecordTTL: mergedArgs.ttl } : {}),
+            ...(alias
+              ? {
+                  RecordType: "ALIAS",
+                  // https://github.com/InfoxchangeTS/aws-gov/blob/213609c2e91b021375b93290efdaf38936ee98e1/components/xaccount-route53/dns-record-updater-lambda/src/index.py#L145
+                  RecordValue: alias.name,
+                  // https://github.com/InfoxchangeTS/aws-gov/blob/213609c2e91b021375b93290efdaf38936ee98e1/components/xaccount-route53/dns-record-updater-lambda/src/index.py#L144
+                  AliasZoneId: alias.zoneId,
+                  // alias.evaluateTargetHealth can't be set by the lambda
+                  IpAddressType: aliasIpType?.toLowerCase(),
+                }
+              : {}),
+            ...mergedArgs.lambdaInput,
+          };
+        });
+        // output([mergedArgs, lambdaInput]).apply(([mergedArgs, lambdaInput]) => console.log('________ BEFORE', mergedArgs, '___________ AFTER', lambdaInput));
+        return new aws.lambda.Invocation(
+          name,
+          {
+            input: output(lambdaInput).apply((lambdaInput) =>
+              JSON.stringify({
+                RequestType: "Create",
+                ResourceProperties: lambdaInput,
+                // We need some value so that the lambda doesn't throw an error but we don't want the lambda to actually
+                // send a response to this url (the response is for CloudFormation which we're not using). Setting an
+                // invalid domain will cause it to log an error but not throw so the lambda is considered successful.
+                ResponseURL: "invalid://make-it-so-dns",
+                StackId: "",
+                RequestId: "",
+                LogicalResourceId: "",
+              }),
+            ),
+            functionName: aws.ssm
+              .getParameter({
+                name: "/shared-services/route53/lambdaArn",
+              })
+              .then((param) => param.value),
+          },
+          {
+            ...mergedOpts,
+            // Function can only be invoked from within the same region it is deployed
+            provider: useProvider("ap-southeast-2"),
+          },
+        );
+      }
+    });
+  }
+}

package/src/components/ix/index.ts

@@ -0,0 +1,2 @@
+export * from "./dns.js";
+export * from "./InternalNetwork.js";

package/src/deployConfig.ts

@@ -27,12 +27,18 @@ const ixDeployConfigSchema = z
     environment: z.enum(["dev", "test", "uat", "prod"]),
     workloadGroup: z.enum(["ds", "srs"]),
     primaryAwsRegion: z.literal("ap-southeast-2"),
-    siteDomains: z
-      .string()
-      .transform((val) => val.split(",").map((domain) => domain.trim())),
-    siteDomainAliases: z
-      .string()
-      .transform((val) => val.split(",").map((domain) => domain.trim())),
+    siteDomains: z.string().transform((val) =>
+      val
+        .split(",")
+        .map((domain) => domain.trim())
+        .filter(Boolean),
+    ),
+    siteDomainAliases: z.string().transform((val) =>
+      val
+        .split(",")
+        .map((domain) => domain.trim())
+        .filter(Boolean),
+    ),
     isInternalApp: z.coerce.boolean(),
     deploymentType: z.enum(["docker", "serverless"]),
     sourceCommitRef: z.string().min(1),

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./deployConfig.js";
+export * from "./lib/sst/component-defaults.js";
+export * from "./lib/proxy/fetch.js";

package/src/lib/sst/component-defaults.ts

@@ -0,0 +1,80 @@
+import { $transform as sst3$transform } from "sst3/platform/src/components/component";
+import type * as aws from "sst3/platform/src/components/aws";
+import type * as cloudflare from "sst3/platform/src/components/cloudflare";
+import { dns } from "@/components/ix/dns";
+import { output } from "@pulumi/pulumi";
+import { getDeployConfig } from "@/deployConfig";
+
+export default function setupComponentDefaults({
+  $transform,
+  sst: partiallyTypedSst,
+}: {
+  $transform: typeof sst3$transform;
+  sst: {
+    /* eslint-disable @typescript-eslint/no-explicit-any -- SST works by creating types dynamically in the
+            project where it's used. Therefore we can't import them in this library. For the sake of ensuring the
+            correctness of this code we cast to equivalent classes from the "sst3" module we download directly from
+            GitHub since we can't guarantee the whole type will exactly match.
+             */
+    aws: {
+      StaticSite: any;
+      Nextjs: any;
+    };
+    cloudflare: {
+      StaticSite: any;
+    };
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+  };
+}) {
+  const sst: {
+    aws: {
+      StaticSite: typeof aws.StaticSite;
+      Nextjs: typeof aws.Nextjs;
+    };
+    cloudflare: {
+      StaticSite: typeof cloudflare.StaticSite;
+    };
+  } = partiallyTypedSst;
+
+  $transform(sst.aws.StaticSite, (args, opts, name) => {
+    addDefaultDomain(args, name);
+  });
+  $transform(sst.aws.Nextjs, (args, opts, name) => {
+    addDefaultDomain(args, name);
+  });
+  $transform(sst.cloudflare.StaticSite, (args, opts, name) => {
+    addDefaultDomain(args, name);
+  });
+}
+
+function addDefaultDomain(
+  args:
+    | aws.StaticSiteArgs
+    | aws.NextjsArgs
+    | cloudflare.StaticSiteArgs
+    | undefined,
+  name: string,
+) {
+  if (!args) {
+    throw new Error(`No args provided to ${name}`);
+  }
+  const domainArgs = {
+    name: getDeployConfig().siteDomains[0],
+    dns: dns(),
+  };
+  if (!("domain" in args)) {
+    args.domain = domainArgs;
+  } else if (args.domain) {
+    args.domain = output(args.domain).apply((domain) => {
+      if (typeof domain === "string") {
+        return {
+          name: domain,
+          dns: domainArgs.dns,
+        };
+      } else if (!("dns" in domain)) {
+        domain.dns = domainArgs.dns;
+      }
+      return domain;
+    });
+  }
+}

package/src/sst-globals.d.ts

@@ -0,0 +1 @@
+import "sst3/platform/src/global.d.ts";

package/tsconfig.build.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "noEmit": false
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.json

@@ -1,9 +1,13 @@
 {
   "compilerOptions": {
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist"
+    "moduleResolution": "bundler",
+    "module": "es2022",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    },
+    "noEmit": true
   },
-  "include": ["src/**/*.ts"],
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
   "extends": "@tsconfig/node21/tsconfig.json"
 }

package/vitest.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from "vitest/config";
+import { resolve } from "path";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: ["**/*.config.*", "**/dist/**", "**/tests/**", "**/build.*"],
+    },
+  },
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "./src"),
+    },
+  },
+});

package/dist/cdk-constructs/IxApi.d.ts

@@ -1,12 +0,0 @@
-import { Api } from "sst/constructs";
-type ConstructScope = ConstructorParameters<typeof Api>[0];
-type ConstructId = ConstructorParameters<typeof Api>[1];
-type ConstructProps = Exclude<ConstructorParameters<typeof Api>[2], undefined>;
-export declare class IxApi extends Api {
-    constructor(scope: ConstructScope, id: ConstructId, props?: ConstructProps);
-    private static setupCustomDomain;
-    private static setupCertificate;
-    private createDnsRecords;
-}
-export {};
-//# sourceMappingURL=IxApi.d.ts.map

package/dist/cdk-constructs/IxApi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IxApi.d.ts","sourceRoot":"","sources":["../../src/cdk-constructs/IxApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAMrC,KAAK,cAAc,GAAG,qBAAqB,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3D,KAAK,WAAW,GAAG,qBAAqB,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACxD,KAAK,cAAc,GAAG,OAAO,CAAC,qBAAqB,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAE/E,qBAAa,KAAM,SAAQ,GAAG;gBAE1B,KAAK,EAAE,cAAc,EACrB,EAAE,EAAE,WAAW,EACf,KAAK,GAAE,cAAmB;IAc5B,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAgBhC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAuB/B,OAAO,CAAC,gBAAgB;CAazB"}

package/dist/cdk-constructs/IxApi.js

@@ -1,56 +0,0 @@
-import { Api } from "sst/constructs";
-import { IxCertificate } from "./IxCertificate.js";
-import { IxDnsRecord } from "./IxDnsRecord.js";
-import ixDeployConfig from "../deployConfig.js";
-import { convertToBase62Hash } from "../lib/utils/hash.js";
-export class IxApi extends Api {
-    constructor(scope, id, props = {}) {
-        if (ixDeployConfig.isIxDeploy) {
-            IxApi.setupCustomDomain(scope, id, props);
-        }
-        super(scope, id, props);
-        if (ixDeployConfig.isIxDeploy) {
-            this.createDnsRecords(scope);
-        }
-    }
-    // This must be static because we need to call it in the constructor before super
-    static setupCustomDomain(scope, id, props) {
-        // Default to using domains names passed in by the pipeline as the custom domain
-        if (ixDeployConfig.isIxDeploy && !("customDomain" in props)) {
-            props.customDomain = {
-                domainName: ixDeployConfig.siteDomains[0],
-            };
-        }
-        this.setupCertificate(scope, id, props);
-    }
-    // This must be static because we need to call it in the constructor before super
-    static setupCertificate(scope, id, props) {
-        if (!props?.customDomain)
-            return;
-        if (typeof props.customDomain === "string") {
-            props.customDomain = { domainName: props.customDomain };
-        }
-        const domainName = props.customDomain.domainName;
-        if (domainName) {
-            const domainCert = new IxCertificate(scope, id + "-IxCertificate", {
-                domainName,
-                region: "ap-southeast-2", // API Gateway wants southeast-2.
-            });
-            props.customDomain.isExternalDomain = true;
-            props.customDomain.cdk = props.customDomain.cdk ?? {};
-            props.customDomain.cdk.certificate = domainCert.acmCertificate;
-        }
-    }
-    createDnsRecords(scope) {
-        if (this.cdk.domainName?.name && this.cdk.domainName?.regionalDomainName) {
-            const domainNameLogicalId = convertToBase62Hash(this.cdk.domainName.name);
-            // API Gateway has a separate domain for using with a CNAME (regionalDomainName)
-            new IxDnsRecord(scope, `DnsRecord-${domainNameLogicalId}`, {
-                type: "CNAME",
-                name: this.cdk.domainName.name,
-                value: this.cdk.domainName?.regionalDomainName,
-                ttl: 900,
-            });
-        }
-    }
-}

package/dist/cdk-constructs/IxBucket.d.ts

@@ -1,9 +0,0 @@
-import { Bucket } from "sst/constructs";
-type ConstructScope = ConstructorParameters<typeof Bucket>[0];
-type ConstructId = ConstructorParameters<typeof Bucket>[1];
-type ConstructProps = Exclude<ConstructorParameters<typeof Bucket>[2], undefined>;
-export declare class IxBucket extends Bucket {
-    constructor(scope: ConstructScope, id: ConstructId, props?: ConstructProps);
-}
-export {};
-//# sourceMappingURL=IxBucket.d.ts.map

package/dist/cdk-constructs/IxBucket.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IxBucket.d.ts","sourceRoot":"","sources":["../../src/cdk-constructs/IxBucket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAIxC,KAAK,cAAc,GAAG,qBAAqB,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9D,KAAK,WAAW,GAAG,qBAAqB,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3D,KAAK,cAAc,GAAG,OAAO,CAC3B,qBAAqB,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,EACvC,SAAS,CACV,CAAC;AAEF,qBAAa,QAAS,SAAQ,MAAM;gBAEhC,KAAK,EAAE,cAAc,EACrB,EAAE,EAAE,WAAW,EACf,KAAK,GAAE,cAAmB;CAmB7B"}

package/dist/cdk-constructs/IxBucket.js

@@ -1,22 +0,0 @@
-import { Bucket } from "sst/constructs";
-import { BucketEncryption } from "aws-cdk-lib/aws-s3";
-import ixDeployConfig from "../deployConfig.js";
-export class IxBucket extends Bucket {
-    constructor(scope, id, props = {}) {
-        const bucketProps = {
-            blockPublicACLs: true,
-            ...props,
-            cdk: {
-                ...props.cdk,
-                bucket: {
-                    enforceSSL: true,
-                    ...(ixDeployConfig.isIxDeploy
-                        ? { encryption: BucketEncryption.S3_MANAGED }
-                        : {}),
-                    ...props.cdk?.bucket,
-                },
-            },
-        };
-        super(scope, id, bucketProps);
-    }
-}

package/dist/cdk-constructs/IxCertificate.d.ts

@@ -1,16 +0,0 @@
-import { Construct } from "constructs";
-import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
-type ConstructScope = ConstructorParameters<typeof Construct>[0];
-type ConstructId = ConstructorParameters<typeof Construct>[1];
-type Props = {
-    domainName: string;
-    subjectAlternativeNames?: string[];
-    region?: string;
-};
-export declare class IxCertificate extends Construct {
-    acmCertificate: ICertificate;
-    constructor(scope: ConstructScope, id: ConstructId, props: Props);
-    private createCertificate;
-}
-export {};
-//# sourceMappingURL=IxCertificate.d.ts.map

package/dist/cdk-constructs/IxCertificate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IxCertificate.d.ts","sourceRoot":"","sources":["../../src/cdk-constructs/IxCertificate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EAAe,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAG/E,KAAK,cAAc,GAAG,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AACjE,KAAK,WAAW,GAAG,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAE9D,KAAK,KAAK,GAAG;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,qBAAa,aAAc,SAAQ,SAAS;IACnC,cAAc,EAAE,YAAY,CAAC;gBAExB,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;IAKhE,OAAO,CAAC,iBAAiB;CA+B1B"}

package/dist/cdk-constructs/IxCertificate.js

@@ -1,26 +0,0 @@
-import { Construct } from "constructs";
-import { StringParameter } from "aws-cdk-lib/aws-ssm";
-import { Certificate } from "aws-cdk-lib/aws-certificatemanager";
-import { CustomResource } from "aws-cdk-lib";
-export class IxCertificate extends Construct {
-    acmCertificate;
-    constructor(scope, id, props) {
-        super(scope, id);
-        this.acmCertificate = this.createCertificate(scope, id, props);
-    }
-    createCertificate(scope, id, props) {
-        const certificateCreationLambdaArn = StringParameter.valueForStringParameter(scope, "/shared-services/acm/lambdaArn-v2");
-        const certificateCustomResource = new CustomResource(scope, "DomainCert-" + id, {
-            resourceType: "Custom::CertIssuingLambda",
-            serviceToken: certificateCreationLambdaArn,
-            properties: {
-                DomainName: props.domainName,
-                ...(props.subjectAlternativeNames && {
-                    SubjectAlternativeNames: props.subjectAlternativeNames,
-                }),
-                ...(props.region && { CertificateIssuingRegion: props.region }),
-            },
-        });
-        return Certificate.fromCertificateArn(scope, id + "-AwsCertificate", certificateCustomResource.ref);
-    }
-}

package/dist/cdk-constructs/IxDnsRecord.d.ts

@@ -1,23 +0,0 @@
-import { Construct } from "constructs";
-type ConstructScope = ConstructorParameters<typeof Construct>[0];
-type ConstructId = ConstructorParameters<typeof Construct>[1];
-type Props = {
-    name: string;
-    value: string;
-    ttl?: number;
-    hostedZoneId?: string;
-} & ({
-    type: "A" | "CNAME" | "NS" | "SOA" | "TXT";
-} | {
-    type: "ALIAS";
-    aliasZoneId: string;
-} | {
-    type: "MX";
-    priority: number;
-});
-export declare class IxDnsRecord extends Construct {
-    constructor(scope: ConstructScope, id: ConstructId, props: Props);
-    private createDnsRecord;
-}
-export {};
-//# sourceMappingURL=IxDnsRecord.d.ts.map

package/dist/cdk-constructs/IxDnsRecord.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IxDnsRecord.d.ts","sourceRoot":"","sources":["../../src/cdk-constructs/IxDnsRecord.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAKvC,KAAK,cAAc,GAAG,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AACjE,KAAK,WAAW,GAAG,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAE9D,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,CACA;IACE,IAAI,EAAE,GAAG,GAAG,OAAO,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;CAC5C,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;CAClB,CACJ,CAAC;AAEF,qBAAa,WAAY,SAAQ,SAAS;gBAC5B,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK;IAKhE,OAAO,CAAC,eAAe;CA6CxB"}