@kensio/yulin 1.20.9 → 1.20.10

package/dist/serve/controller/host/sim-aws-service-hosts.d.ts

@@ -32,6 +32,10 @@ export declare class SimAwsNoServiceHosts implements SimAwsServiceHosts {
  * project picked rather than names AWS generated. Resolution asks one thing
  * about a hostname, so the holders are gathered here rather than each being
  * threaded separately through it.
+ *
+ * Resolution asks twice. A hosted-zone record outranks some claims and leaves
+ * others alone, and which of these a holder is gathered into is what says when
+ * the hostnames it holds are answered for.
  */
 export declare class SimAwsAnyServiceHosts implements SimAwsServiceHosts {
     private readonly holders;

package/dist/serve/controller/host/sim-aws-service-hosts.js

@@ -18,6 +18,10 @@ export class SimAwsNoServiceHosts {
  * project picked rather than names AWS generated. Resolution asks one thing
  * about a hostname, so the holders are gathered here rather than each being
  * threaded separately through it.
+ *
+ * Resolution asks twice. A hosted-zone record outranks some claims and leaves
+ * others alone, and which of these a holder is gathered into is what says when
+ * the hostnames it holds are answered for.
  */
 export class SimAwsAnyServiceHosts {
     holders;

package/dist/service/apigatewayv2/domain/sim-http-api-domain-endpoint.d.ts

@@ -0,0 +1,59 @@
+import type { Brand } from "../../../util/brand.type.js";
+/**
+ * The id API Gateway allocates for the regional endpoint of one custom domain,
+ * which is the leading DNS label of that endpoint's hostname.
+ */
+export type SimHttpApiDomainId = Brand<string, "SimHttpApiDomainId">;
+/**
+ * What a custom domain's regional endpoint hostname is built from.
+ */
+export interface SimHttpApiDomainEndpointParts {
+    readonly domainId: SimHttpApiDomainId;
+    readonly regionName: string;
+}
+/**
+ * Allocate a domain endpoint id in the shape real API Gateway uses: `d-`
+ * followed by 10 lowercase alphanumeric characters, forming one DNS label.
+ */
+export declare function makeSimHttpApiDomainId(): SimHttpApiDomainId;
+/**
+ * Whether a DNS label is a custom domain endpoint id rather than an API id.
+ *
+ * A custom domain and an API are issued endpoints of the same shape, so this
+ * is what decides which of the two a hostname names. API ids carry no hyphen,
+ * which is what leaves the prefix free to say it.
+ */
+export declare function isSimHttpApiDomainId(label: string): boolean;
+/**
+ * Build the real AWS endpoint hostname for a custom domain, which is what
+ * `RegionalDomainName` answers with and what a record for the custom domain
+ * name points at.
+ */
+export declare function simHttpApiDomainEndpointHost(parts: SimHttpApiDomainEndpointParts): string;
+/**
+ * Build the logical hostname for a custom domain endpoint: the AWS endpoint
+ * hostname without the real AWS domain, which is the form Yulin serves on
+ * localhost.
+ */
+export declare function simHttpApiDomainEndpointLogicalHost(parts: SimHttpApiDomainEndpointParts): string;
+/**
+ * A custom domain's regional endpoint hostname, as it was read.
+ */
+export interface SimHttpApiDomainEndpointHost {
+    /**
+     * The hostname without the AWS domain, which is the name simulated DNS
+     * resolves and the domain registry holds.
+     */
+    readonly logicalHost: string;
+    readonly regionName: string;
+}
+/**
+ * Read a custom domain's regional endpoint hostname, in either the form real
+ * API Gateway reports it or the local form the AWS domain is dropped from.
+ *
+ * Both forms are read here because a request arriving over HTTP has had the
+ * AWS domain rewritten away and a record value written as `RegionalDomainName`
+ * answered has not, and a record pointing the custom domain name at the
+ * endpoint is how the domain is reached on AWS.
+ */
+export declare function readSimHttpApiDomainEndpointHost(hostname: string): SimHttpApiDomainEndpointHost | undefined;

package/dist/service/apigatewayv2/domain/sim-http-api-domain-endpoint.js

@@ -0,0 +1,67 @@
+import { faker } from "@faker-js/faker";
+import { executeApiDomain, executeApiHostLabel, } from "../api/sim-http-api-host.js";
+/**
+ * The first character of the id API Gateway allocates a custom domain, which
+ * is what tells its endpoint hostname apart from the one an API gets.
+ */
+const domainIdPrefix = "d-";
+/**
+ * Allocate a domain endpoint id in the shape real API Gateway uses: `d-`
+ * followed by 10 lowercase alphanumeric characters, forming one DNS label.
+ */
+export function makeSimHttpApiDomainId() {
+    return `${domainIdPrefix}${faker.helpers.fromRegExp(/[a-z0-9]{10}/)}`;
+}
+/**
+ * Whether a DNS label is a custom domain endpoint id rather than an API id.
+ *
+ * A custom domain and an API are issued endpoints of the same shape, so this
+ * is what decides which of the two a hostname names. API ids carry no hyphen,
+ * which is what leaves the prefix free to say it.
+ */
+export function isSimHttpApiDomainId(label) {
+    return label.startsWith(domainIdPrefix);
+}
+/**
+ * Build the real AWS endpoint hostname for a custom domain, which is what
+ * `RegionalDomainName` answers with and what a record for the custom domain
+ * name points at.
+ */
+export function simHttpApiDomainEndpointHost(parts) {
+    return `${simHttpApiDomainEndpointLogicalHost(parts)}.${executeApiDomain}`;
+}
+/**
+ * Build the logical hostname for a custom domain endpoint: the AWS endpoint
+ * hostname without the real AWS domain, which is the form Yulin serves on
+ * localhost.
+ */
+export function simHttpApiDomainEndpointLogicalHost(parts) {
+    return `${parts.domainId}.${executeApiHostLabel}.${parts.regionName}`;
+}
+/**
+ * Read a custom domain's regional endpoint hostname, in either the form real
+ * API Gateway reports it or the local form the AWS domain is dropped from.
+ *
+ * Both forms are read here because a request arriving over HTTP has had the
+ * AWS domain rewritten away and a record value written as `RegionalDomainName`
+ * answered has not, and a record pointing the custom domain name at the
+ * endpoint is how the domain is reached on AWS.
+ */
+export function readSimHttpApiDomainEndpointHost(hostname) {
+    const awsDomainSuffix = `.${executeApiDomain}`;
+    const logicalHost = hostname.endsWith(awsDomainSuffix)
+        ? hostname.slice(0, -awsDomainSuffix.length)
+        : hostname;
+    const labels = logicalHost.split(".");
+    if (labels.length !== 3) {
+        return undefined;
+    }
+    const [domainId, service, regionName] = labels;
+    if (domainId === undefined ||
+        regionName === undefined ||
+        service !== executeApiHostLabel ||
+        !isSimHttpApiDomainId(domainId)) {
+        return undefined;
+    }
+    return { logicalHost, regionName };
+}

package/dist/service/apigatewayv2/domain/sim-http-api-domain-name.d.ts

@@ -1,4 +1,5 @@
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import { type SimHttpApiDomainId } from "./sim-http-api-domain-endpoint.js";
 import { SimApiMappingStore } from "./sim-api-mapping-store.js";
 /**
  * The expression API Gateway selects an API mapping with, which is the request
@@ -12,7 +13,7 @@ export declare const simApiMappingSelectionExpression = "$request.basepath";
  * Real API Gateway publishes a different id per Region. One fixed value stands
  * for all of them here, the way `simElbV2CanonicalHostedZoneId` does for a
  * load balancer: nothing resolves through it, and an alias record reaches the
- * domain by the name it points at.
+ * domain by the regional endpoint name it points at.
  */
 export declare const simHttpApiRegionalHostedZoneId = "Z0000000000001";
 /**
@@ -29,13 +30,21 @@ export interface SimHttpApiDomainNameConfiguration {
     EndpointType?: string | undefined;
     SecurityPolicy?: string | undefined;
 }
+/**
+ * One entry of a domain's `DomainNameConfigurations` as a command reports it,
+ * which is what was written plus the endpoint API Gateway made for it.
+ */
+export interface SimHttpApiDomainNameConfigurationView extends SimHttpApiDomainNameConfiguration {
+    ApiGatewayDomainName: string;
+    HostedZoneId: string;
+}
 /**
  * Minimal structural domain name view, as the Create and Get commands return.
  */
 export interface SimHttpApiDomainNameView {
     DomainName: string;
     ApiMappingSelectionExpression: string;
-    DomainNameConfigurations: readonly SimHttpApiDomainNameConfiguration[];
+    DomainNameConfigurations: readonly SimHttpApiDomainNameConfigurationView[];
 }
 interface SimHttpApiDomainNameProperties {
     readonly domainName: string;
@@ -45,9 +54,11 @@ interface SimHttpApiDomainNameProperties {
 /**
  * A simulated API Gateway custom domain name.
  *
- * The domain answers on a hostname of its own rather than on one API Gateway
- * generated, which is how an HTTP API is reached under a name the project
- * owns. It owns its API mappings, because a mapping is addressed by domain on
+ * The domain has the two names real API Gateway gives it. One is the hostname
+ * the project owns, which is how an HTTP API is reached under a name of its
+ * own. The other is the regional endpoint API Gateway issues alongside it,
+ * which a record for the custom domain name points at. The domain answers on
+ * both. It owns its API mappings, because a mapping is addressed by domain on
  * real AWS and none of them outlives the domain.
  *
  * A domain and the APIs it maps live in one Account and Region, as they do on
@@ -58,6 +69,10 @@ export declare class SimHttpApiDomainName {
     readonly accountRegionScope: SimAwsAccountRegionScope;
     readonly configurations: readonly SimHttpApiDomainNameConfiguration[];
     readonly apiMappings: SimApiMappingStore;
+    /**
+     * The id API Gateway allocated this domain's regional endpoint.
+     */
+    readonly domainId: SimHttpApiDomainId;
     constructor(properties: SimHttpApiDomainNameProperties);
     /**
      * The hostname this domain answers requests on.
@@ -67,13 +82,17 @@ export declare class SimHttpApiDomainName {
      * The hostname a DNS record pointing at this domain names, which is what
      * `Fn::GetAtt RegionalDomainName` answers with.
      *
-     * Real API Gateway issues a separate `d-<id>.execute-api.<region>` name here
-     * and expects the custom domain to be pointed at it. This answers with the
-     * custom domain's own hostname instead, so a CloudFront Origin or a Route53
-     * alias built on it reaches the domain. An `execute-api` name would be read
-     * as a generated API endpoint by simulated DNS and route to no API at all.
+     * This is the domain's published address. A CloudFront Origin points at it
+     * directly, and a record for the custom domain name points at it. The custom
+     * domain name is reached through that record.
      */
     get regionalDomainName(): string;
+    /**
+     * The hostnames a request can reach this domain by. They are the custom
+     * domain name and the regional endpoint, the second without the AWS domain
+     * the local URL rewriting drops.
+     */
+    get hostnames(): readonly string[];
     /**
      * The ARN of this domain, which `Fn::GetAtt DomainNameArn` answers with.
      *
@@ -86,5 +105,18 @@ export declare class SimHttpApiDomainName {
      * Get the AWS-like view of this domain name.
      */
     view(): SimHttpApiDomainNameView;
+    /**
+     * What this domain's regional endpoint hostname is built from.
+     */
+    private get endpointParts();
+    /**
+     * The domain's configurations as a command reports them.
+     *
+     * Each one is what was written plus the endpoint API Gateway made for it. A
+     * domain created without a configuration still reports one, because the
+     * endpoint exists whether or not anything was written about the certificate
+     * in front of it, and real API Gateway reports it there.
+     */
+    private configurationViews;
 }
 export {};

package/dist/service/apigatewayv2/domain/sim-http-api-domain-name.js

@@ -1,3 +1,4 @@
+import { makeSimHttpApiDomainId, simHttpApiDomainEndpointHost, simHttpApiDomainEndpointLogicalHost, } from "./sim-http-api-domain-endpoint.js";
 import { SimApiMappingStore } from "./sim-api-mapping-store.js";
 /**
  * The expression API Gateway selects an API mapping with, which is the request
@@ -11,15 +12,17 @@ export const simApiMappingSelectionExpression = "$request.basepath";
  * Real API Gateway publishes a different id per Region. One fixed value stands
  * for all of them here, the way `simElbV2CanonicalHostedZoneId` does for a
  * load balancer: nothing resolves through it, and an alias record reaches the
- * domain by the name it points at.
+ * domain by the regional endpoint name it points at.
  */
 export const simHttpApiRegionalHostedZoneId = "Z0000000000001";
 /**
  * A simulated API Gateway custom domain name.
  *
- * The domain answers on a hostname of its own rather than on one API Gateway
- * generated, which is how an HTTP API is reached under a name the project
- * owns. It owns its API mappings, because a mapping is addressed by domain on
+ * The domain has the two names real API Gateway gives it. One is the hostname
+ * the project owns, which is how an HTTP API is reached under a name of its
+ * own. The other is the regional endpoint API Gateway issues alongside it,
+ * which a record for the custom domain name points at. The domain answers on
+ * both. It owns its API mappings, because a mapping is addressed by domain on
  * real AWS and none of them outlives the domain.
  *
  * A domain and the APIs it maps live in one Account and Region, as they do on
@@ -30,6 +33,10 @@ export class SimHttpApiDomainName {
     accountRegionScope;
     configurations;
     apiMappings = new SimApiMappingStore();
+    /**
+     * The id API Gateway allocated this domain's regional endpoint.
+     */
+    domainId = makeSimHttpApiDomainId();
     constructor(properties) {
         this.domainName = properties.domainName;
         this.accountRegionScope = properties.accountRegionScope;
@@ -45,14 +52,23 @@ export class SimHttpApiDomainName {
      * The hostname a DNS record pointing at this domain names, which is what
      * `Fn::GetAtt RegionalDomainName` answers with.
      *
-     * Real API Gateway issues a separate `d-<id>.execute-api.<region>` name here
-     * and expects the custom domain to be pointed at it. This answers with the
-     * custom domain's own hostname instead, so a CloudFront Origin or a Route53
-     * alias built on it reaches the domain. An `execute-api` name would be read
-     * as a generated API endpoint by simulated DNS and route to no API at all.
+     * This is the domain's published address. A CloudFront Origin points at it
+     * directly, and a record for the custom domain name points at it. The custom
+     * domain name is reached through that record.
      */
     get regionalDomainName() {
-        return this.hostname;
+        return simHttpApiDomainEndpointHost(this.endpointParts);
+    }
+    /**
+     * The hostnames a request can reach this domain by. They are the custom
+     * domain name and the regional endpoint, the second without the AWS domain
+     * the local URL rewriting drops.
+     */
+    get hostnames() {
+        return [
+            this.hostname,
+            simHttpApiDomainEndpointLogicalHost(this.endpointParts),
+        ];
     }
     /**
      * The ARN of this domain, which `Fn::GetAtt DomainNameArn` answers with.
@@ -71,9 +87,37 @@ export class SimHttpApiDomainName {
         return {
             DomainName: this.domainName,
             ApiMappingSelectionExpression: simApiMappingSelectionExpression,
-            DomainNameConfigurations: this.configurations.map((configuration) => ({
-                ...configuration,
-            })),
+            DomainNameConfigurations: this.configurationViews(),
+        };
+    }
+    /**
+     * What this domain's regional endpoint hostname is built from.
+     */
+    get endpointParts() {
+        return {
+            domainId: this.domainId,
+            regionName: this.accountRegionScope.regionName,
+        };
+    }
+    /**
+     * The domain's configurations as a command reports them.
+     *
+     * Each one is what was written plus the endpoint API Gateway made for it. A
+     * domain created without a configuration still reports one, because the
+     * endpoint exists whether or not anything was written about the certificate
+     * in front of it, and real API Gateway reports it there.
+     */
+    configurationViews() {
+        const endpoint = {
+            ApiGatewayDomainName: this.regionalDomainName,
+            HostedZoneId: simHttpApiRegionalHostedZoneId,
         };
+        if (this.configurations.length === 0) {
+            return [endpoint];
+        }
+        return this.configurations.map((configuration) => ({
+            ...configuration,
+            ...endpoint,
+        }));
     }
 }

package/dist/service/apigatewayv2/registry/sim-http-api-domain-registry.d.ts

@@ -14,6 +14,11 @@ import type { SimHttpApiDomainName } from "../domain/sim-http-api-domain-name.js
  * and nothing saying it is an API Gateway hostname at all. That makes this the
  * answer to which simulated service a hostname belongs to, which is what
  * `SimAwsServiceHosts` asks.
+ *
+ * Simulated DNS asks a hosted-zone record about a custom domain name first,
+ * the way the custom domain name reaches the domain through a record on AWS.
+ * This answers where no record names the hostname. That is how a test that
+ * creates only a domain reaches it.
  */
 export declare class SimHttpApiDomainRegistry implements SimAwsServiceHosts {
     private readonly domainsByHost;
@@ -28,7 +33,8 @@ export declare class SimHttpApiDomainRegistry implements SimAwsServiceHosts {
      */
     deregister(domain: SimHttpApiDomainName): void;
     /**
-     * Find the domain a request's hostname reaches.
+     * Find the domain a request's hostname reaches, by either of the two names
+     * the domain answers on.
      */
     findByHost(hostname: string): SimHttpApiDomainName | undefined;
     /**

package/dist/service/apigatewayv2/registry/sim-http-api-domain-registry.js

@@ -12,6 +12,11 @@ import { SimApiGatewayV2BadRequest } from "../error/sim-api-gateway-v2.error.js"
  * and nothing saying it is an API Gateway hostname at all. That makes this the
  * answer to which simulated service a hostname belongs to, which is what
  * `SimAwsServiceHosts` asks.
+ *
+ * Simulated DNS asks a hosted-zone record about a custom domain name first,
+ * the way the custom domain name reaches the domain through a record on AWS.
+ * This answers where no record names the hostname. That is how a test that
+ * creates only a domain reaches it.
  */
 export class SimHttpApiDomainRegistry {
     domainsByHost = new Map();
@@ -24,18 +29,25 @@ export class SimHttpApiDomainRegistry {
      */
     register(domain) {
         this.requireUnused(domain);
-        this.domainsByHost.set(domain.hostname.toLowerCase(), domain);
+        for (const hostname of domain.hostnames) {
+            this.domainsByHost.set(hostname.toLowerCase(), domain);
+        }
+        // Only the custom domain name is claimed. The regional endpoint is a name
+        // API Gateway made up, and takes no hostname away from another service.
         this.claims.claim(domain.hostname);
     }
     /**
      * Forget a deleted domain, so its hostname stops resolving.
      */
     deregister(domain) {
-        this.domainsByHost.delete(domain.hostname.toLowerCase());
+        for (const hostname of domain.hostnames) {
+            this.domainsByHost.delete(hostname.toLowerCase());
+        }
         this.claims.release(domain.hostname);
     }
     /**
-     * Find the domain a request's hostname reaches.
+     * Find the domain a request's hostname reaches, by either of the two names
+     * the domain answers on.
      */
     findByHost(hostname) {
         return this.domainsByHost.get(hostname.toLowerCase());

package/dist/service/apigatewayv2/serve/sim-http-api-serving.js

@@ -76,7 +76,9 @@ export class SimHttpApiServingResolver {
      */
     mapped(target, method, path) {
         const domain = this.domains.route(target);
-        /* v8 ignore if -- a domain target only resolves from a registered domain */
+        // A regional endpoint hostname is recognised by its shape, as a generated
+        // API endpoint is, so one naming no domain arrives here and is answered
+        // the way a path no mapping claims is.
         if (domain === undefined) {
             return notFound;
         }

package/dist/service/aws/factory/sim-aws-account-service-cache.d.ts

@@ -20,6 +20,7 @@ interface SimAwsAccountServiceCacheProperties {
     readonly route53Registry: SimRoute53Registry;
     readonly kmsRegistry: SimKmsRegistry;
     readonly serviceHosts: SimAwsServiceHosts;
+    readonly shadowableServiceHosts: SimAwsServiceHosts;
     readonly iamRegistry: SimIamRegistry;
     readonly accessKeyRegistry: SimIamAccessKeyRegistry;
 }
@@ -54,6 +55,7 @@ export declare class SimAwsAccountServiceCache {
     private readonly route53Registry;
     private readonly kmsRegistry;
     private readonly serviceHosts;
+    private readonly shadowableServiceHosts;
     /**
      * Shared memo for account-scoped service instances.
      *

package/dist/service/aws/factory/sim-aws-account-service-cache.js

@@ -40,6 +40,7 @@ export class SimAwsAccountServiceCache {
     route53Registry;
     kmsRegistry;
     serviceHosts;
+    shadowableServiceHosts;
     /**
      * Shared memo for account-scoped service instances.
      *
@@ -58,6 +59,7 @@ export class SimAwsAccountServiceCache {
         this.route53Registry = properties.route53Registry;
         this.kmsRegistry = properties.kmsRegistry;
         this.serviceHosts = properties.serviceHosts;
+        this.shadowableServiceHosts = properties.shadowableServiceHosts;
     }
     /**
      * The collaborators every Account/Region scoped service takes.
@@ -128,6 +130,7 @@ export class SimAwsAccountServiceCache {
             background: this.background,
             route53Registry: this.route53Registry,
             serviceHosts: this.serviceHosts,
+            shadowableServiceHosts: this.shadowableServiceHosts,
             // A DNSSEC key-signing key names a KMS key by ARN, in whichever
             // Region holds it, so Route53 resolves it through the registry.
             kmsKeys: this.kmsRegistry,

package/dist/service/aws/factory/sim-aws-scoped-service-registries.d.ts

@@ -94,6 +94,13 @@ export declare class SimAwsScopedServiceRegistries {
      * simulated DNS resolution asks after the built-in hostname shapes.
      */
     readonly serviceHosts: SimAwsServiceHosts;
+    /**
+     * Where a hostname a hosted-zone record outranks is looked up. An API
+     * Gateway custom domain name is reached through a record on AWS, so a record
+     * for one decides where the name goes and the domain answers where no record
+     * names it.
+     */
+    readonly shadowableServiceHosts: SimAwsServiceHosts;
     /**
      * The hostnames the domain registries have handed out. A public hostname is
      * unique across the whole of AWS rather than within one service, so the two

package/dist/service/aws/factory/sim-aws-scoped-service-registries.js

@@ -95,6 +95,13 @@ export class SimAwsScopedServiceRegistries {
      * simulated DNS resolution asks after the built-in hostname shapes.
      */
     serviceHosts;
+    /**
+     * Where a hostname a hosted-zone record outranks is looked up. An API
+     * Gateway custom domain name is reached through a record on AWS, so a record
+     * for one decides where the name goes and the domain answers where no record
+     * names it.
+     */
+    shadowableServiceHosts;
     /**
      * The hostnames the domain registries have handed out. A public hostname is
      * unique across the whole of AWS rather than within one service, so the two
@@ -104,8 +111,8 @@ export class SimAwsScopedServiceRegistries {
     constructor() {
         this.cognitoDomains = new SimCognitoDomainRegistry(this.hostnameClaims);
         this.httpApiDomains = new SimHttpApiDomainRegistry(this.hostnameClaims);
-        this.serviceHosts = new SimAwsAnyServiceHosts([
-            this.cognitoDomains,
+        this.serviceHosts = new SimAwsAnyServiceHosts([this.cognitoDomains]);
+        this.shadowableServiceHosts = new SimAwsAnyServiceHosts([
             this.httpApiDomains,
         ]);
     }

package/dist/service/aws/factory/sim-aws-service-factory.js

@@ -88,8 +88,10 @@ export class SimAwsServiceFactory {
             kmsRegistry: this.registries.kms,
             // A Cognito hosted domain and an API Gateway custom domain each answer
             // on a hostname of their own, so DNS resolution asks the registries
-            // holding those domains about it.
+            // holding those domains about it. A record outranks the API Gateway one,
+            // as it does on AWS, which is what keeps the two apart here.
             serviceHosts: this.registries.serviceHosts,
+            shadowableServiceHosts: this.registries.shadowableServiceHosts,
             iamRegistry: this.iamRegistry,
             accessKeyRegistry: this.requestAuth.accessKeyRegistry,
         });

package/dist/service/cloudformation/resource/cfn/apigatewayv2/sim-http-api-domain-name-cfn.d.ts

@@ -19,10 +19,10 @@ export declare class SimHttpApiDomainNameCfn implements SimCfnResourceValueAdapt
      * AWS::ApiGatewayV2::DomainName publishes RegionalDomainName,
      * RegionalHostedZoneId and DomainNameArn.
      *
-     * `RegionalDomainName` is the hostname the domain answers on, so a
-     * CloudFront Origin or a Route53 alias built on it reaches the domain. Real
-     * API Gateway answers with a separate `d-<id>.execute-api.<region>` name and
-     * expects DNS to point the custom domain at it.
+     * `RegionalDomainName` is the `d-<id>.execute-api.<region>` endpoint API
+     * Gateway issued the domain, which is the published address a CloudFront
+     * Origin reaches directly and a Route53 alias points the custom domain name
+     * at.
      */
     attributeValue(attributeName: string): SimCfnTemplateValue;
 }

package/dist/service/cloudformation/resource/cfn/apigatewayv2/sim-http-api-domain-name-cfn.js

@@ -18,10 +18,10 @@ export class SimHttpApiDomainNameCfn {
      * AWS::ApiGatewayV2::DomainName publishes RegionalDomainName,
      * RegionalHostedZoneId and DomainNameArn.
      *
-     * `RegionalDomainName` is the hostname the domain answers on, so a
-     * CloudFront Origin or a Route53 alias built on it reaches the domain. Real
-     * API Gateway answers with a separate `d-<id>.execute-api.<region>` name and
-     * expects DNS to point the custom domain at it.
+     * `RegionalDomainName` is the `d-<id>.execute-api.<region>` endpoint API
+     * Gateway issued the domain, which is the published address a CloudFront
+     * Origin reaches directly and a Route53 alias points the custom domain name
+     * at.
      */
     attributeValue(attributeName) {
         if (attributeName === "RegionalDomainName") {

package/dist/service/route53/resolve/sim-r53-service-target-resolver.d.ts

@@ -24,6 +24,18 @@ export declare class SimRoute53ServiceTargetResolver {
      * name that simulated AWS services expose.
      */
     resolve(hostname: string): SimAwsServiceTarget | undefined;
+    /**
+     * Resolve the regional endpoint hostname of an API Gateway custom domain:
+     *
+     *   d-<id>.execute-api.<region>.amazonaws.com
+     *
+     * This is read ahead of the endpoints below, because a domain endpoint and
+     * the endpoint of an API have the same shape and only the `d-` prefix tells
+     * them apart. The whole hostname is the resource name, since the domain
+     * registry answers about both of the names a domain has and the custom
+     * domain name is a hostname too.
+     */
+    private apiGatewayDomainServiceTarget;
     /**
      * Resolve Yulin's own Route53 introspection hostname.
      *

package/dist/service/route53/resolve/sim-r53-service-target-resolver.js

@@ -1,3 +1,4 @@
+import { readSimHttpApiDomainEndpointHost } from "../../apigatewayv2/domain/sim-http-api-domain-endpoint.js";
 import { readSimElbV2LoadBalancerHost } from "../../elbv2/load-balancer/sim-elbv2-load-balancer-host.js";
 import { simRoute53LogicalName } from "../local-name/sim-route53-local-name.js";
 import { simRoute53DnsHostName } from "../serve/sim-route53-dns-host.js";
@@ -38,8 +39,31 @@ export class SimRoute53ServiceTargetResolver {
             this.s3Targets.resolve(logicalName) ??
             this.cloudFrontServiceTarget(logicalName) ??
             this.loadBalancerServiceTarget(logicalName) ??
+            this.apiGatewayDomainServiceTarget(logicalName) ??
             this.regionalTargets.resolve(logicalName));
     }
+    /**
+     * Resolve the regional endpoint hostname of an API Gateway custom domain:
+     *
+     *   d-<id>.execute-api.<region>.amazonaws.com
+     *
+     * This is read ahead of the endpoints below, because a domain endpoint and
+     * the endpoint of an API have the same shape and only the `d-` prefix tells
+     * them apart. The whole hostname is the resource name, since the domain
+     * registry answers about both of the names a domain has and the custom
+     * domain name is a hostname too.
+     */
+    apiGatewayDomainServiceTarget(logicalName) {
+        const endpoint = readSimHttpApiDomainEndpointHost(logicalName);
+        if (endpoint === undefined) {
+            return undefined;
+        }
+        return {
+            service: "apiGatewayDomain",
+            resourceName: endpoint.logicalHost,
+            regionName: endpoint.regionName,
+        };
+    }
     /**
      * Resolve Yulin's own Route53 introspection hostname.
      *

package/dist/service/route53/resolve/sim-route53-resolver.d.ts

@@ -8,6 +8,11 @@ interface SimRoute53ResolverProperties {
      * such as a Cognito user pool custom domain.
      */
     readonly serviceHosts?: SimAwsServiceHosts | undefined;
+    /**
+     * Where a hostname a hosted-zone record outranks is looked up, which is a
+     * claim answering only where no record names the hostname.
+     */
+    readonly shadowableServiceHosts?: SimAwsServiceHosts | undefined;
 }
 /**
  * Resolves Yulin-local hostnames through simulated Route53 hosted-zone records.
@@ -16,6 +21,7 @@ export declare class SimRoute53Resolver {
     private readonly recordFinder;
     private readonly serviceTargetResolver;
     private readonly serviceHosts;
+    private readonly shadowableServiceHosts;
     constructor(properties: SimRoute53ResolverProperties);
     /**
      * Resolve an HTTP hostname to a simulated AWS service target.
@@ -26,7 +32,9 @@ export declare class SimRoute53Resolver {
      *    logical Route53 name.
      * 2. Check whether that name already points at a built-in simulated service.
      * 3. If not, follow CNAME or alias records to the next hostname.
-     * 4. Stop when a service target is found, a chain breaks, a cycle appears, or
+     * 4. Where no record names it, answer with a hostname a resource claimed for
+     *    itself, such as an API Gateway custom domain.
+     * 5. Stop when a service target is found, a chain breaks, a cycle appears, or
      *    the maximum CNAME depth is reached.
      *
      * The suffix is optional because the simulated DNS server answers for logical

package/dist/service/route53/resolve/sim-route53-resolver.js

@@ -10,9 +10,12 @@ export class SimRoute53Resolver {
     recordFinder;
     serviceTargetResolver = new SimRoute53ServiceTargetResolver();
     serviceHosts;
+    shadowableServiceHosts;
     constructor(properties) {
         this.recordFinder = new SimRoute53HostedZoneRecordFinder(properties.hostedZones);
         this.serviceHosts = properties.serviceHosts ?? new SimAwsNoServiceHosts();
+        this.shadowableServiceHosts =
+            properties.shadowableServiceHosts ?? new SimAwsNoServiceHosts();
     }
     /**
      * Resolve an HTTP hostname to a simulated AWS service target.
@@ -23,7 +26,9 @@ export class SimRoute53Resolver {
      *    logical Route53 name.
      * 2. Check whether that name already points at a built-in simulated service.
      * 3. If not, follow CNAME or alias records to the next hostname.
-     * 4. Stop when a service target is found, a chain breaks, a cycle appears, or
+     * 4. Where no record names it, answer with a hostname a resource claimed for
+     *    itself, such as an API Gateway custom domain.
+     * 5. Stop when a service target is found, a chain breaks, a cycle appears, or
      *    the maximum CNAME depth is reached.
      *
      * The suffix is optional because the simulated DNS server answers for logical
@@ -63,7 +68,10 @@ export class SimRoute53Resolver {
             const nextRecord = this.findNextResolutionRecord(logicalName);
             const nextTarget = nextRecord?.values[0];
             if (nextTarget === undefined || nextTarget.length === 0) {
-                return undefined;
+                // An API Gateway custom domain is reached through a record on AWS, so
+                // the record decides where the name goes and the claim answers only
+                // where no record names it.
+                return this.shadowableServiceHosts.targetForHost(logicalName);
             }
             localName = simRoute53LocalName(nextTarget);
         }

package/dist/service/route53/sim-route53.d.ts

@@ -23,6 +23,12 @@ interface SimRoute53Properties {
      * one arrives at the service holding it.
      */
     readonly serviceHosts?: SimAwsServiceHosts | undefined;
+    /**
+     * Where a hostname a hosted-zone record outranks is looked up, such as an
+     * API Gateway custom domain, which is reached through a record on AWS. A
+     * claim there answers only where no record names the hostname.
+     */
+    readonly shadowableServiceHosts?: SimAwsServiceHosts | undefined;
     /**
      * Where a KMS key ARN is looked up. A DNSSEC key-signing key is built on a
      * customer managed key, and Route53 checks that key before it takes one.

package/dist/service/route53/sim-route53.js

@@ -24,6 +24,7 @@ export class SimRoute53 {
         this.resolver = new SimRoute53Resolver({
             hostedZones: route53Registry.hostedZones,
             serviceHosts: properties.serviceHosts,
+            shadowableServiceHosts: properties.shadowableServiceHosts,
         });
         this.commands = new SimRoute53Commands({
             hostedZones: this.hostedZones,

package/dist/service/s3/mount/sim-s3-mount.type.d.ts

@@ -35,7 +35,7 @@ export interface SimS3MountFilesystemOptions {
      * the web's own types, and nothing else — so that pointing a Bucket at a
      * directory cannot be talked into reading whatever else is in it. A site
      * serving a data file of its own needs its extension named here: a pinyin
-     * dictionary's `.freq`, a `.wasm` module, a `.pdf`.
+     * dictionary's `.freq`, a `.wasm` module, a `.parquet` table.
      *
      * Added to the list rather than replacing it, and a leading dot is optional.
      */

package/dist/service/s3/storage/filesystem/s3-filesystem-allowed.js

@@ -61,6 +61,7 @@ export const defaultAllowedObjectFileExtensions = new Set([
     ".map",
     ".mjs",
     ".otf",
+    ".pdf",
     ".png",
     ".svg",
     ".ttc",

package/dist/service/s3/storage/filesystem/s3-filesystem-object-metadata.js

@@ -41,6 +41,7 @@ const contentTypesByExtension = new Map([
     [".mjs", "text/javascript"],
     [".json", "application/json"],
     [".map", "application/json"],
+    [".pdf", "application/pdf"],
     [".png", "image/png"],
     [".otf", "font/otf"],
     [".svg", "image/svg+xml"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "1.20.9",
+  "version": "1.20.10",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",