@kensio/yulin 1.20.9 → 1.20.11

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/athena/engine/sim-athena-json-records.d.ts

@@ -0,0 +1,23 @@
+import type { SimAthenaEngineRow } from "./sim-athena-engine-row.js";
+/**
+ * How one table's JSON records reach its columns.
+ *
+ * `mappings` holds the column names the OpenX SerDe's `mapping.<column>`
+ * parameters declare, each against the record key it reads. A table declaring
+ * none leaves it empty, and every column is read by its own name.
+ *
+ * `caseInsensitive` is the SerDe's own `case.insensitive`, on unless a table
+ * turns it off. The SerDe folds a record's keys before looking one up. A
+ * mapping matches a key of any case until a table declares `FALSE`.
+ */
+export interface SimAthenaJsonFormat {
+    readonly mappings: ReadonlyMap<string, string>;
+    readonly caseInsensitive: boolean;
+}
+/**
+ * One object of JSON lines, read into rows.
+ *
+ * A nested object or array is kept as its JSON text, which is what makes
+ * `json_extract_scalar` and `cardinality` reach into it.
+ */
+export declare function simAthenaJsonRows(text: string, format: SimAthenaJsonFormat): readonly SimAthenaEngineRow[];

package/dist/service/athena/engine/sim-athena-json-records.js

@@ -0,0 +1,46 @@
+/**
+ * One object of JSON lines, read into rows.
+ *
+ * A nested object or array is kept as its JSON text, which is what makes
+ * `json_extract_scalar` and `cardinality` reach into it.
+ */
+export function simAthenaJsonRows(text, format) {
+    return text
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line))
+        .map((record) => mappedRow(record, format));
+}
+/**
+ * One record with its mapped columns laid over it.
+ *
+ * The record is kept whole underneath. A column no mapping names still reads
+ * by its own name. A mapped column is written whether or not the record
+ * carries the key, since the mapping is where that column reads from.
+ */
+function mappedRow(record, format) {
+    if (format.mappings.size === 0) {
+        return record;
+    }
+    const row = { ...record };
+    for (const [column, key] of format.mappings) {
+        row[column] = mappedValue(record, key, format.caseInsensitive);
+    }
+    return row;
+}
+function mappedValue(record, key, caseInsensitive) {
+    const exact = record[key];
+    if (exact !== undefined) {
+        return exact;
+    }
+    if (!caseInsensitive) {
+        return null;
+    }
+    const wanted = key.toLowerCase();
+    for (const [held, value] of Object.entries(record)) {
+        if (held.toLowerCase() === wanted) {
+            return value;
+        }
+    }
+    return null;
+}

package/dist/service/athena/engine/sim-athena-object-codec.d.ts

@@ -0,0 +1,13 @@
+/**
+ * One object's bytes, decompressed by the codec its key names.
+ *
+ * Athena reads the file extension, and so does this. A key ending `.gz` is
+ * gzip whatever its bytes hold, and a key ending anything else is text. The
+ * magic number would be the other way to tell, and it would read an object
+ * real Athena skips.
+ *
+ * A key naming a codec this simulation has no decompressor for raises, and the
+ * engine turns the query down. The declaration a test wrote answers it, which
+ * is what an object the engine cannot open already does.
+ */
+export declare function simAthenaDecompressedBytes(key: string, bytes: Buffer): Buffer;

package/dist/service/athena/engine/sim-athena-object-codec.js

@@ -0,0 +1,40 @@
+import { gunzipSync, inflateSync, zstdDecompressSync } from "node:zlib";
+import { SimAthenaSetUpError } from "../error/sim-athena.error.js";
+/** The file extensions naming a codec, against what decompresses each one. */
+const codecs = new Map([
+    ["gz", gunzipSync],
+    ["zst", zstdDecompressSync],
+    ["deflate", inflateSync],
+]);
+/**
+ * The file extensions naming a codec nothing here decompresses.
+ *
+ * Node's standard library has gzip, zstd and deflate. The rest would need a
+ * dependency, and this package takes none for a test to install.
+ */
+const unreadableCodecs = new Set(["bz2", "bzip2", "lz4", "lzo", "snappy"]);
+/**
+ * One object's bytes, decompressed by the codec its key names.
+ *
+ * Athena reads the file extension, and so does this. A key ending `.gz` is
+ * gzip whatever its bytes hold, and a key ending anything else is text. The
+ * magic number would be the other way to tell, and it would read an object
+ * real Athena skips.
+ *
+ * A key naming a codec this simulation has no decompressor for raises, and the
+ * engine turns the query down. The declaration a test wrote answers it, which
+ * is what an object the engine cannot open already does.
+ */
+export function simAthenaDecompressedBytes(key, bytes) {
+    const name = key.slice(key.lastIndexOf("/") + 1);
+    const dot = name.lastIndexOf(".");
+    if (dot === -1) {
+        return bytes;
+    }
+    const extension = name.slice(dot + 1).toLowerCase();
+    if (unreadableCodecs.has(extension)) {
+        throw new SimAthenaSetUpError(`Unsupported sim Athena compression: ${extension}`);
+    }
+    const decompress = codecs.get(extension);
+    return decompress === undefined ? bytes : decompress(bytes);
+}

package/dist/service/athena/engine/sim-athena-record-reader.js

@@ -1,10 +1,15 @@
 import { simAthenaDelimitedRows, } from "./sim-athena-delimited-records.js";
+import { simAthenaJsonRows, } from "./sim-athena-json-records.js";
+/** The SerDe class name that takes `mapping.<column>` parameters. */
+const openXSerDe = "org.openx.data.jsonserde.jsonserde";
 /** The SerDe class names that mean JSON lines. */
 const jsonSerDes = new Set([
-    "org.openx.data.jsonserde.jsonserde",
+    openXSerDe,
     "org.apache.hive.hcatalog.data.jsonserde",
     "org.apache.hadoop.hive.serde2.jsonserde",
 ]);
+/** What a `mapping.<column>` parameter is named with. */
+const mappingPrefix = "mapping.";
 /**
  * The SerDe class names that mean delimited text, and what each one reads
  * before the table's own parameters are applied.
@@ -39,7 +44,8 @@ export function simAthenaRecordReader(table) {
         return undefined;
     }
     if (jsonSerDes.has(library)) {
-        return jsonRows;
+        const format = jsonFormat(table, library);
+        return (text) => simAthenaJsonRows(text, format);
     }
     const defaults = delimitedSerDes.get(library);
     if (defaults === undefined) {
@@ -50,16 +56,26 @@ export function simAthenaRecordReader(table) {
     return (text) => simAthenaDelimitedRows(text, format, columns);
 }
 /**
- * JSON lines, one record per line.
+ * How one table's JSON records reach its columns.
  *
- * A nested object or array is kept as its JSON text, which is what makes
- * `json_extract_scalar` and `cardinality` reach into it.
+ * Only the OpenX SerDe takes the mappings. The Hive JSON SerDes have no
+ * `mapping` property, and a table declaring one against them reads by its
+ * column names on real Athena the same as here.
  */
-function jsonRows(text) {
-    return text
-        .split("\n")
-        .filter((line) => line.trim().length > 0)
-        .map((line) => JSON.parse(line));
+function jsonFormat(table, library) {
+    const parameters = library === openXSerDe
+        ? (table.storageDescriptor?.SerdeInfo?.Parameters ?? {})
+        : {};
+    const mappings = new Map();
+    for (const [name, key] of Object.entries(parameters)) {
+        if (name.toLowerCase().startsWith(mappingPrefix)) {
+            mappings.set(name.slice(mappingPrefix.length), key);
+        }
+    }
+    return {
+        mappings,
+        caseInsensitive: parameters["case.insensitive"]?.toLowerCase() !== "false",
+    };
 }
 function delimitedFormat(table, defaults) {
     const parameters = table.storageDescriptor?.SerdeInfo?.Parameters ?? {};

package/dist/service/athena/engine/sim-athena-table-objects.d.ts

@@ -26,5 +26,5 @@ export interface SimAthenaTableObjects extends SimAthenaScannedObjects {
  * there because nothing holds the data it would answer from.
  */
 export declare function simAthenaTableObjects(s3: Partial<SimAthenaTableObjects> | undefined): SimAthenaTableObjects | undefined;
-/** One object's bytes, read as UTF-8 text. */
+/** One object's bytes, decompressed by its key and read as UTF-8 text. */
 export declare function simAthenaObjectText(objects: SimAthenaTableObjects, bucket: string, key: string, caller: SimAwsCaller | undefined): Promise<string>;

package/dist/service/athena/engine/sim-athena-table-objects.js

@@ -1,3 +1,4 @@
+import { simAthenaDecompressedBytes } from "./sim-athena-object-codec.js";
 /**
  * Whether this simulated S3 can open an object as well as list one.
  *
@@ -9,9 +10,10 @@ export function simAthenaTableObjects(s3) {
         ? undefined
         : s3;
 }
-/** One object's bytes, read as UTF-8 text. */
+/** One object's bytes, decompressed by its key and read as UTF-8 text. */
 export async function simAthenaObjectText(objects, bucket, key, caller) {
     const got = await objects.getObject({ input: { Bucket: bucket, Key: key } }, caller === undefined ? undefined : { caller });
     const chunks = await Array.fromAsync(got.Body ?? []);
-    return new TextDecoder().decode(Buffer.concat(chunks));
+    const bytes = simAthenaDecompressedBytes(key, Buffer.concat(chunks));
+    return new TextDecoder().decode(bytes);
 }

package/dist/service/athena/sim-athena-engine.fixture.d.ts

@@ -34,5 +34,7 @@ export declare function anEngineSimulation(clock?: SimClock): Promise<SimAthenaE
 export declare function aCatalogTable(simAws: SimAws, table: SimAthenaEngineTableInput): void;
 /** Put one object of literal text under the logs Bucket. */
 export declare function aSeededObject(simAws: SimAws, key: string, body: string): Promise<void>;
+/** Put one object of raw bytes under the logs Bucket. */
+export declare function aSeededBytes(simAws: SimAws, key: string, body: Uint8Array): Promise<void>;
 /** Put one object of JSON lines under the logs Bucket. */
 export declare function aSeededJson(simAws: SimAws, key: string, records: readonly Record<string, unknown>[]): Promise<void>;

package/dist/service/athena/sim-athena-engine.fixture.js

@@ -58,6 +58,12 @@ export async function aSeededObject(simAws, key, body) {
         .s3()
         .putObject({ input: { Bucket: logsBucket, Key: key, Body: body } });
 }
+/** Put one object of raw bytes under the logs Bucket. */
+export async function aSeededBytes(simAws, key, body) {
+    await simAws
+        .s3()
+        .putObject({ input: { Bucket: logsBucket, Key: key, Body: body } });
+}
 /** Put one object of JSON lines under the logs Bucket. */
 export async function aSeededJson(simAws, key, records) {
     const lines = records.map((record) => JSON.stringify(record));

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.11",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",