@kensio/yulin 1.21.27 → 1.21.28

package/dist/config/eslint/cffjs2.eslint.config.js

@@ -13,6 +13,10 @@ export default defineConfig({
     files: ["**/*.cff.js"],
     extends: [tseslint.configs.disableTypeChecked],
     languageOptions: {
+        // The typescript-eslint rules below read scope information only its own
+        // parser produces. Under ESLint's default parser, `no-unused-vars` takes
+        // every reference for a type-only one and reports each variable.
+        parser: tseslint.parser,
         parserOptions: {
             projectService: false,
         },

package/dist/service/cloudformation/parameters/sim-cfn-parameter-list-type.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether a declared Parameter `Type` holds a list.
+ *
+ * `CommaDelimitedList` and every `List<...>` type do, whatever the member
+ * type. A `Ref` to one resolves to a list of strings, `List<Number>` included.
+ */
+export declare function isSimCfnParameterListType(type: string | undefined): boolean;

package/dist/service/cloudformation/parameters/sim-cfn-parameter-list-type.js

@@ -0,0 +1,9 @@
+/**
+ * Whether a declared Parameter `Type` holds a list.
+ *
+ * `CommaDelimitedList` and every `List<...>` type do, whatever the member
+ * type. A `Ref` to one resolves to a list of strings, `List<Number>` included.
+ */
+export function isSimCfnParameterListType(type) {
+    return type === "CommaDelimitedList" || (type?.startsWith("List<") ?? false);
+}

package/dist/service/cloudformation/parameters/sim-cfn-parameter-values.d.ts

@@ -13,6 +13,9 @@ interface SimCfnParameterValuesProperties {
  * the command wins over a template `Default`, and a Parameter declared as a
  * Parameter Store value type reads whichever of the two it ended up with as the
  * name to read.
+ *
+ * A `CommaDelimitedList` or `List<...>` Parameter is given its value as one
+ * comma-separated string, and holds it as the list of members.
  */
 export declare class SimCfnParameterValues {
     private readonly values;
@@ -29,5 +32,12 @@ export declare class SimCfnParameterValues {
      * `Default`.
      */
     private recordDefaults;
+    /**
+     * Split the value of each list-typed Parameter on its commas.
+     *
+     * Each member is trimmed of the spaces around it, as CloudFormation trims
+     * them. A value with no commas is a list of one.
+     */
+    private splitLists;
 }
 export {};

package/dist/service/cloudformation/parameters/sim-cfn-parameter-values.js

@@ -1,3 +1,4 @@
+import { isSimCfnParameterListType } from "./sim-cfn-parameter-list-type.js";
 import { SimCfnParameterStoreValues } from "./store/sim-cfn-parameter-store-values.js";
 /**
  * The runtime value of every Parameter a Stack was created with.
@@ -6,6 +7,9 @@ import { SimCfnParameterStoreValues } from "./store/sim-cfn-parameter-store-valu
  * the command wins over a template `Default`, and a Parameter declared as a
  * Parameter Store value type reads whichever of the two it ended up with as the
  * name to read.
+ *
+ * A `CommaDelimitedList` or `List<...>` Parameter is given its value as one
+ * comma-separated string, and holds it as the list of members.
  */
 export class SimCfnParameterValues {
     values;
@@ -15,6 +19,7 @@ export class SimCfnParameterValues {
         this.storeValues = new SimCfnParameterStoreValues({ store });
         this.values = new Map(Object.entries(supplied));
         this.recordDefaults(definitions);
+        this.splitLists(definitions);
         this.storeValues.applyTo(this.values, definitions);
     }
     /** Every Parameter that resolved to a stand-in value. */
@@ -39,4 +44,19 @@ export class SimCfnParameterValues {
             }
         }
     }
+    /**
+     * Split the value of each list-typed Parameter on its commas.
+     *
+     * Each member is trimmed of the spaces around it, as CloudFormation trims
+     * them. A value with no commas is a list of one.
+     */
+    splitLists(definitions) {
+        for (const [parameterName, definition] of definitions) {
+            const value = this.values.get(parameterName);
+            if (typeof value === "string" &&
+                isSimCfnParameterListType(definition.Type)) {
+                this.values.set(parameterName, value.split(",").map((member) => member.trim()));
+            }
+        }
+    }
 }

package/dist/service/cloudformation/parameters/sim-cfn-parameters.type.d.ts

@@ -5,9 +5,10 @@ import type { SimCfnParameterStoreReader } from "./store/sim-cfn-parameter-store
  * defaults and Parameter Store reads have been applied.
  *
  * A Parameter is given its value as a string, because AWS CloudFormation
- * command inputs provide ParameterValue as one. A Parameter declared as
- * `AWS::SSM::Parameter::Value<List<String>>` is given a parameter name and
- * resolves to the stored value split into a list, so a resolved value can be
+ * command inputs provide ParameterValue as one. A `CommaDelimitedList` or
+ * `List<...>` Parameter resolves to that string split into a list. So does an
+ * `AWS::SSM::Parameter::Value<List<String>>` Parameter, which is given a
+ * parameter name and splits the value stored under it. A resolved value can be
  * either.
  */
 export type SimCloudFormationParameterValue = string | string[];
@@ -61,8 +62,9 @@ export type SimCfnParametersContext = Pick<SimCfnParametersProperties, "definiti
  *
  * Most fields are recorded for structural typing/documentation. Runtime
  * behavior applies string Default values when a command does not provide an
- * explicit Parameter value, and reads an `AWS::SSM::Parameter::Value<...>`
- * Type from simulated Parameter Store.
+ * explicit Parameter value, splits the value of a `CommaDelimitedList` or
+ * `List<...>` Type, and reads an `AWS::SSM::Parameter::Value<...>` Type from
+ * simulated Parameter Store.
  */
 export interface SimCfnParameterDefinition {
     readonly Type?: string | undefined;

package/dist/service/cloudformation/parameters/store/sim-cfn-parameter-store-value-type.js

@@ -1,3 +1,4 @@
+import { isSimCfnParameterListType } from "../sim-cfn-parameter-list-type.js";
 /** The Parameter type that holds a Parameter Store name. */
 const parameterStoreValuePrefix = "AWS::SSM::Parameter::Value<";
 /**
@@ -14,6 +15,6 @@ export function simCfnParameterStoreValueType(declaredType) {
     }
     const innerType = declaredType.slice(parameterStoreValuePrefix.length, -1);
     return {
-        list: innerType === "CommaDelimitedList" || innerType.startsWith("List<"),
+        list: isSimCfnParameterListType(innerType),
     };
 }

package/dist/service/cloudformation/template/node/fn/join/sim-cfn-fn-join.d.ts

@@ -9,19 +9,25 @@ import type { SimCfnResolveContext } from "../../../resolve/sim-cfn-resolve-cont
  * {
  *   "Fn::Join": ["-", ["a", "b", { "Ref": "Name" }]]
  * }
+ *
+ * The values may also come from one function that returns the whole list:
+ *
+ * {
+ *   "Fn::Join": [",", { "Fn::GetAtt": ["Zone", "NameServers"] }]
+ * }
  */
 export declare class SimCfnFnJoin extends SimCfnNode {
     private readonly delimiter;
     private readonly values;
-    constructor(delimiter: string, values: readonly SimCfnNode[]);
+    constructor(delimiter: string, values: SimCfnNode);
     /**
-     * Resolve each value and join them with the delimiter.
+     * Resolve the values and join them with the delimiter.
      *
-     * Joining happens only when every value has resolved to a string. If any
-     * value is still an unresolved expression (for example a Resource `Ref`
-     * during the up-front pass before Resources exist), this node re-emits
-     * itself in template form. A later resolution pass can finish it once the
-     * referenced Resources are available.
+     * Joining happens only when the values have resolved to a list of strings.
+     * If the list, or any value in it, is still an unresolved expression (for
+     * example a Resource `Ref` during the up-front pass before Resources exist),
+     * this node re-emits itself in template form. A later resolution pass can
+     * finish it once the referenced Resources are available.
      *
      * A dynamic reference can be assembled out of the joined values, as CDK
      * writes one whenever the secret it reads sits in the same Stack: the
@@ -32,16 +38,15 @@ export declare class SimCfnFnJoin extends SimCfnNode {
      */
     resolve(context: SimCfnResolveContext): SimCfnTemplateValue;
     /**
-     * Collect referenced names from every joined value.
+     * Collect referenced names from the values.
      */
     referencedNames(): string[];
-    private resolveValue;
     /**
-     * Whether a resolved value is still an unresolved intrinsic expression.
+     * Refuse a value that can never become a string.
      *
-     * Only object-shaped values (a preserved `Ref` or nested function object)
-     * are treated as deferred. Other non-string primitives such as numbers are
-     * genuine type errors.
+     * A string joins now, and an unresolved expression may join on a later
+     * pass. Anything else (a number, a nested list, a plain object) is a type
+     * error, as CloudFormation joins a list of strings only.
      */
-    private isDeferredExpression;
+    private assertJoinable;
 }

package/dist/service/cloudformation/template/node/fn/join/sim-cfn-fn-join.js

@@ -1,4 +1,5 @@
 import { SimCfnNode } from "../../sim-cfn-node.js";
+import { isSimCfnUnresolvedExpression } from "../../../value/sim-cfn-unresolved-expression.js";
 /**
  * Simulated CloudFormation `Fn::Join` intrinsic function.
  *
@@ -7,6 +8,12 @@ import { SimCfnNode } from "../../sim-cfn-node.js";
  * {
  *   "Fn::Join": ["-", ["a", "b", { "Ref": "Name" }]]
  * }
+ *
+ * The values may also come from one function that returns the whole list:
+ *
+ * {
+ *   "Fn::Join": [",", { "Fn::GetAtt": ["Zone", "NameServers"] }]
+ * }
  */
 export class SimCfnFnJoin extends SimCfnNode {
     delimiter;
@@ -17,13 +24,13 @@ export class SimCfnFnJoin extends SimCfnNode {
         this.values = values;
     }
     /**
-     * Resolve each value and join them with the delimiter.
+     * Resolve the values and join them with the delimiter.
      *
-     * Joining happens only when every value has resolved to a string. If any
-     * value is still an unresolved expression (for example a Resource `Ref`
-     * during the up-front pass before Resources exist), this node re-emits
-     * itself in template form. A later resolution pass can finish it once the
-     * referenced Resources are available.
+     * Joining happens only when the values have resolved to a list of strings.
+     * If the list, or any value in it, is still an unresolved expression (for
+     * example a Resource `Ref` during the up-front pass before Resources exist),
+     * this node re-emits itself in template form. A later resolution pass can
+     * finish it once the referenced Resources are available.
      *
      * A dynamic reference can be assembled out of the joined values, as CDK
      * writes one whenever the secret it reads sits in the same Stack: the
@@ -33,37 +40,49 @@ export class SimCfnFnJoin extends SimCfnNode {
      * out of its variables.
      */
     resolve(context) {
-        const resolved = this.values.map((value) => this.resolveValue(value, context));
-        if (resolved.every((value) => typeof value === "string")) {
-            const joined = resolved.join(this.delimiter);
+        const values = this.values.resolve(context);
+        if (isSimCfnUnresolvedExpression(values)) {
+            return { "Fn::Join": [this.delimiter, values] };
+        }
+        if (!Array.isArray(values)) {
+            throw new TypeError(`Sim CloudFormation Fn::Join values must resolve to a list, got ${describe(values)}`);
+        }
+        for (const value of values) {
+            this.assertJoinable(value);
+        }
+        if (values.every((value) => typeof value === "string")) {
+            const joined = values.join(this.delimiter);
             return context.dynamicReferences?.substitute(joined) ?? joined;
         }
-        return { "Fn::Join": [this.delimiter, resolved] };
+        return { "Fn::Join": [this.delimiter, values] };
     }
     /**
-     * Collect referenced names from every joined value.
+     * Collect referenced names from the values.
      */
     referencedNames() {
-        return this.values.flatMap((value) => value.referencedNames());
-    }
-    resolveValue(value, context) {
-        const resolved = value.resolve(context);
-        if (typeof resolved === "string") {
-            return resolved;
-        }
-        if (this.isDeferredExpression(resolved)) {
-            return resolved;
-        }
-        throw new TypeError(`Sim CloudFormation Fn::Join values must each resolve to a string, got ${typeof resolved}`);
+        return this.values.referencedNames();
     }
     /**
-     * Whether a resolved value is still an unresolved intrinsic expression.
+     * Refuse a value that can never become a string.
      *
-     * Only object-shaped values (a preserved `Ref` or nested function object)
-     * are treated as deferred. Other non-string primitives such as numbers are
-     * genuine type errors.
+     * A string joins now, and an unresolved expression may join on a later
+     * pass. Anything else (a number, a nested list, a plain object) is a type
+     * error, as CloudFormation joins a list of strings only.
      */
-    isDeferredExpression(value) {
-        return typeof value === "object" && value !== null;
+    assertJoinable(value) {
+        if (typeof value === "string" || isSimCfnUnresolvedExpression(value)) {
+            return;
+        }
+        throw new TypeError(`Sim CloudFormation Fn::Join values must each resolve to a string, got ${describe(value)}`);
+    }
+}
+/**
+ * Name a resolved value's type for an error message, telling a list and a
+ * null apart from an object.
+ */
+function describe(value) {
+    if (Array.isArray(value)) {
+        return "list";
     }
+    return value === null ? "null" : typeof value;
 }

package/dist/service/cloudformation/template/parse/fn/join/sim-cfn-fn-join-parser.d.ts

@@ -10,10 +10,13 @@ import type { SimCfnValueParser } from "../../value/sim-cfn-value-parser.type.js
  *   "Fn::Join": ["-", ["a", { "Ref": "Name" }]]
  * }
  *
- * The parser validates only the Fn::Join envelope: a string delimiter and an
- * array of values. Each joined value is parsed through the recursive value
- * parser, because join entries may themselves be literals, Refs, other
- * intrinsic functions, arrays, or plain objects.
+ * The values argument goes through the recursive value parser. It may be a
+ * literal list, whose entries may themselves be literals, Refs or other
+ * intrinsic functions, or a function that returns a whole list (such as
+ * `Fn::GetAtt` on a hosted zone's `NameServers`, or `Fn::Split`). Whether it
+ * resolves to a list of strings is a resolution-time question, so it belongs
+ * to the node. A string, number or boolean in its place can never become a
+ * list, and is refused here.
  */
 export declare class SimCfnFnJoinParser {
     private readonly valueParser;

package/dist/service/cloudformation/template/parse/fn/join/sim-cfn-fn-join-parser.js

@@ -8,10 +8,13 @@ import { SimCfnFnJoin as SimCfnFunctionJoin } from "../../../node/fn/join/sim-cf
  *   "Fn::Join": ["-", ["a", { "Ref": "Name" }]]
  * }
  *
- * The parser validates only the Fn::Join envelope: a string delimiter and an
- * array of values. Each joined value is parsed through the recursive value
- * parser, because join entries may themselves be literals, Refs, other
- * intrinsic functions, arrays, or plain objects.
+ * The values argument goes through the recursive value parser. It may be a
+ * literal list, whose entries may themselves be literals, Refs or other
+ * intrinsic functions, or a function that returns a whole list (such as
+ * `Fn::GetAtt` on a hosted zone's `NameServers`, or `Fn::Split`). Whether it
+ * resolves to a list of strings is a resolution-time question, so it belongs
+ * to the node. A string, number or boolean in its place can never become a
+ * list, and is refused here.
  */
 export class SimCfnFnJoinParser {
     valueParser;
@@ -29,9 +32,10 @@ export class SimCfnFnJoinParser {
         if (typeof delimiter !== "string") {
             throw new TypeError("Sim CloudFormation Fn::Join delimiter must be a string");
         }
-        if (!Array.isArray(values)) {
-            throw new TypeError("Sim CloudFormation Fn::Join values must be an array");
+        if (typeof values !== "object" || values === null) {
+            throw new TypeError("Sim CloudFormation Fn::Join values must be a list or a function " +
+                "that returns one");
         }
-        return new SimCfnFunctionJoin(delimiter, values.map((item) => this.valueParser.parse(item)));
+        return new SimCfnFunctionJoin(delimiter, this.valueParser.parse(values));
     }
 }

package/docs/serve/README.md

@@ -415,6 +415,6 @@ service guide lists its supported commands.
 - `yulin watch` does not preserve simulated state across a restart or reload changed Lambda and
   CloudFront Function code inside the current process.
 - The shared AWS API endpoint refuses unsupported protocols and operations with `501 Not
-Implemented`.
+  Implemented`.
 - Some service functionality is available only through `SimAws` or SDK interception. Check the
   relevant service guide before depending on access through the local endpoint.

package/docs/services/cloudformation/README.md

@@ -948,8 +948,20 @@ console.log(
 
 A parameter with no supplied value takes the template default, when the template has one.
 
-A parameter's `Type` is read for the `AWS::SSM::Parameter::Value<...>` types, which hold a Parameter
-Store name and resolve to the value stored under it. See
+A `CommaDelimitedList` or `List<...>` parameter (`List<String>`, `List<Number>`,
+`List<AWS::EC2::Subnet::Id>` and the rest) is given one comma-separated string. A `Ref` to it
+resolves to the list of members, each trimmed of the spaces around it. `Fn::Join` and `Fn::Select`
+read that list as they read any other:
+
+```json
+{ "Fn::Join": ["-", { "Ref": "Names" }] }
+```
+
+With `Names` declared as a `CommaDelimitedList` and given `a, b, c`, this resolves to `a-b-c`. The
+members of a `List<Number>` are strings, as CloudFormation gives them.
+
+The `AWS::SSM::Parameter::Value<...>` types hold a Parameter Store name and resolve to the value
+stored under it. See
 [reading a parameter through a template Parameter](https://yulinsim.dev/services/ssm/#reading-a-parameter-through-a-template-parameter).
 Every other type is accepted and its value used as written, with no validation of the value against
 the type.
@@ -1217,6 +1229,17 @@ await simAws.cloudFormation().deployTemplate({
 });
 ```
 
+The second argument may also be a function that returns the whole list. CDK writes this for
+`Fn.join(",", zone.hostedZoneNameServers)`:
+
+```json
+{ "Fn::Join": [",", { "Fn::GetAtt": ["Zone", "NameServers"] }] }
+```
+
+`Fn::Split`, an `Fn::FindInMap` of a list value, `Fn::If` and a `Ref` to a list parameter can supply
+the list the same way. A list that resolves to anything but strings fails the deployment. That
+includes a number, and a list nested inside the list (CloudFormation joins one level only).
+
 ### `Fn::Sub`
 
 ```typescript sim-cloudformation-fn-sub
@@ -4545,9 +4568,9 @@ Each service's own docs describe what its resource types support.
   would reject as well. The simulator just rejects them later rather than up front.
 - `Fn::If` is a condition function inside the `Conditions` section, and is not a value an
   `Fn::Equals` can compare. Real CloudFormation allows only `Ref` and `Fn::FindInMap` there.
-- `Fn::Split` and `Fn::Select` accept any argument that resolves to the type they need. Real
-  CloudFormation allows only a named set of functions inside each of them. A template the simulator
-  resolves may still be one CloudFormation rejects.
+- `Fn::Join`, `Fn::Split` and `Fn::Select` accept any argument that resolves to the type they
+  need. Real CloudFormation allows only a named set of functions inside each of them. A template the
+  simulator resolves may still be one CloudFormation rejects.
 - The SAM transform is expanded for `AWS::Serverless::Function`, `AWS::Serverless::SimpleTable`,
   `AWS::Serverless::HttpApi` and `AWS::Serverless::Api`. Every other `AWS::Serverless::*` resource
   type is recorded as unsupported. `Api`, `HttpApi`, `SQS`, `DynamoDB`, `SNS`, `S3`, `Cognito`,

package/docs/services/dynamodb/README.md

@@ -3940,7 +3940,7 @@ is written.
   `AWS::DynamoDB::Table` path does, with the replica's `TableClass`, `DeletionProtectionEnabled` and
   `Tags` read off it, the table's writes and the replica's reads put back together into one
   provisioned capacity for the table and for each global secondary index, and `Ref`, `Fn::GetAtt …
-Arn`, `Fn::GetAtt … StreamArn` and `Fn::GetAtt … TableId` answering. A CDK `TableV2` stack deploys
+  Arn`, `Fn::GetAtt … StreamArn` and `Fn::GetAtt … TableId` answering. A CDK `TableV2` stack deploys
   through it without hand-editing.
 - SDK interception, and an intercepted `DynamoDBClient` or `DynamoDBStreamsClient` reaches the
   simulation.
@@ -4035,7 +4035,7 @@ Arn`, `Fn::GetAtt … StreamArn` and `Fn::GetAtt … TableId` answering. A CDK `
 - Time to live expiry is dispatched by moving the clock through `simAws.clock()`, not by real time
   elapsing. An item whose window goes by while a running-mode clock tracks the host stays where it
   is until something moves the clock. A simulated DynamoDB constructed standalone as `new
-SimDynamoDb()` has no clock control at all. No item there ever expires.
+  SimDynamoDb()` has no clock control at all. No item there ever expires.
 - A Lambda event source mapping is the only simulated service integration that consumes a stream.
   Anything else reads one through the Streams API itself. A Kinesis Data Streams destination is
   absent.

package/docs/services/s3/README.md

@@ -1079,7 +1079,7 @@ A delete on a versioned Bucket raises `s3:ObjectRemoved:DeleteMarkerCreated` rat
 
 - MFA delete is refused with `NotImplemented` rather than stored. Nothing here could enforce it, and
   a Bucket reporting a protection it does not apply is worse than one that says so. `MFADelete:
-"Disabled"` is taken, and any other value is refused with `InvalidArgument`.
+  "Disabled"` is taken, and any other value is refused with `InvalidArgument`.
 - A `versionId` in a `CopySource` is still refused with `NotImplemented`. A copy reads the current
   version.
 - `NoncurrentVersionTransitions` is stored and unread, because storage classes are left out. An

package/docs/services/sqs/README.md

@@ -1214,7 +1214,7 @@ Current documented limitations:
 - A Lambda event source mapping polls one batch at a time. Real Lambda runs several pollers at once
   and scales them with the queue, and what that concurrency does to ordering is invisible here. See
   [simulated Lambda](https://yulinsim.dev/services/lambda/#triggering-a-function-from-an-sqs-queue "Simulated Lambda event
-source mapping docs") for the rest of the mapping limitations.
+  source mapping docs") for the rest of the mapping limitations.
 - `AWS::SQS::Queue` and `AWS::SQS::QueuePolicy` are the SQS resource types CloudFormation creates.
   Any other is reported as unsupported and skipped. A queue attribute outside the range real SQS
   accepts fails the resource, and a property it has no behaviour for is recorded and the queue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "1.21.27",
+  "version": "1.21.28",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",
@@ -299,7 +299,7 @@
     "hyparquet": "^1.29.2",
     "hyparquet-writer": "^0.16.9",
     "node-sql-parser": "^5.4.0",
-    "oxfmt": "^0.71.0",
+    "oxfmt": "^0.72.0",
     "oxlint": "^1.77.0",
     "oxlint-tsgolint": "^7.0.2001",
     "semantic-release": "25.0.9",