@kensio/yulin 1.20.13 → 1.20.15

package/dist/service/lambda/cfn/function/sim-cfn-lambda-function-creator.js

@@ -21,7 +21,7 @@ export class SimCfnLambdaFunctionCreator {
      * through their actual handler while still deploying it through
      * CloudFormation.
      */
-    async create(resource, properties, bindings) {
+    async create(resource, properties, bindings, options) {
         const functionProperties = this.propertiesParser.parse(resource, properties);
         const codeInput = simCfnLambdaCodeInput({
             resource,
@@ -33,10 +33,9 @@ export class SimCfnLambdaFunctionCreator {
         if (skipError !== undefined) {
             throw skipError;
         }
+        const input = simCfnLambdaCreateFunctionInput(functionProperties, codeInput.code);
         try {
-            await this.lambda.createFunction({
-                input: simCfnLambdaCreateFunctionInput(functionProperties, codeInput.code),
-            });
+            await this.lambda.createFunction({ input }, options);
         }
         catch (error) {
             const assetsSkipError = this.skips.fromCreateFailure(resource, functionProperties, error);

package/dist/service/lambda/cfn/permission/sim-cfn-lambda-permission-creator.d.ts

@@ -2,6 +2,7 @@ import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-re
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
 import type { SimLambdaPermission } from "../../function/policy/sim-lambda-permission.js";
 import type { SimLambda } from "../../sim-lambda.js";
+import type { SimCfnResourceCallerOptions } from "../../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 interface SimCfnLambdaPermissionCreatorProperties {
     readonly lambda: SimLambda;
 }
@@ -30,6 +31,6 @@ export declare class SimCfnLambdaPermissionCreator {
      * statement after the logical ID, so that is what the permission is
      * addressed by afterwards, including by a later `RemovePermission`.
      */
-    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): Promise<SimLambdaPermission>;
+    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord, options?: SimCfnResourceCallerOptions): Promise<SimLambdaPermission>;
 }
 export {};

package/dist/service/lambda/cfn/permission/sim-cfn-lambda-permission-creator.js

@@ -28,7 +28,7 @@ export class SimCfnLambdaPermissionCreator {
      * statement after the logical ID, so that is what the permission is
      * addressed by afterwards, including by a later `RemovePermission`.
      */
-    async create(resource, properties) {
+    async create(resource, properties, options) {
         const { functionName, qualifier } = simCfnLambdaTargetFunction(this.propertyParser.requiredString(resource, properties["FunctionName"], "FunctionName"));
         await this.lambda.addPermission({
             input: {
@@ -43,7 +43,7 @@ export class SimCfnLambdaPermissionCreator {
                 PrincipalOrgID: this.propertyParser.optionalString(resource, properties["PrincipalOrgID"], "PrincipalOrgID"),
                 InvokedViaFunctionUrl: this.propertyParser.optionalBoolean(resource, properties["InvokedViaFunctionUrl"], "InvokedViaFunctionUrl"),
             },
-        });
+        }, options);
         const permission = this.lambda
             .getSimFunctionTarget(functionName, qualifier)
             ?.resource.resourcePolicy.get(resource.logicalId);

package/dist/service/lambda/cfn/permission/sim-cfn-lambda-permission-revoker.d.ts

@@ -1,5 +1,6 @@
 import type { SimLambda } from "../../sim-lambda.js";
 import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-resource.js";
+import type { SimCfnResourceCallerOptions } from "../../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 /**
  * Take an AWS::Lambda::Permission back off what it was granted on.
  *
@@ -8,4 +9,4 @@ import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-re
  * addresses it again here. A grant made on a version or an alias is revoked
  * from that same qualified resource, which the statement's own ARN names.
  */
-export declare function simCfnLambdaRevokePermission(lambda: SimLambda, resource: SimCfnResource): Promise<void>;
+export declare function simCfnLambdaRevokePermission(lambda: SimLambda, resource: SimCfnResource, options?: SimCfnResourceCallerOptions): Promise<void>;

package/dist/service/lambda/cfn/permission/sim-cfn-lambda-permission-revoker.js

@@ -8,7 +8,7 @@ import { simCfnLambdaTargetFunction } from "../function/sim-cfn-lambda-target-fu
  * addresses it again here. A grant made on a version or an alias is revoked
  * from that same qualified resource, which the statement's own ARN names.
  */
-export async function simCfnLambdaRevokePermission(lambda, resource) {
+export async function simCfnLambdaRevokePermission(lambda, resource, options) {
     const permission = simCfnLambdaCreatedResource(resource, "permission");
     const { functionName, qualifier } = simCfnLambdaTargetFunction(permission.resourceArn);
     await lambda.removePermission({
@@ -17,5 +17,5 @@ export async function simCfnLambdaRevokePermission(lambda, resource) {
             Qualifier: qualifier,
             StatementId: permission.statementId,
         },
-    });
+    }, options);
 }

package/dist/service/lambda/cfn/sim-cfn-lambda-resource-deleter.d.ts

@@ -1,5 +1,6 @@
 import type { SimCfnResource } from "../../cloudformation/resource/sim-cfn-resource.js";
 import type { SimLambda } from "../sim-lambda.js";
+import type { SimCfnResourceCallerOptions } from "../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 interface SimCfnLambdaResourceDeleterProperties {
     readonly lambda: SimLambda;
 }
@@ -16,13 +17,6 @@ export declare class SimCfnLambdaResourceDeleter {
     /**
      * Delete a simulated Lambda resource created from a CloudFormation Resource.
      */
-    delete(resourceTypeName: string, resource: SimCfnResource): Promise<void>;
-    private deleteFunction;
-    private deleteFunctionUrl;
-    private deleteEventSourceMapping;
-    /**
-     * Drop an alias, leaving the version it pointed at where it is.
-     */
-    private deleteAlias;
+    delete(resourceTypeName: string, resource: SimCfnResource, options?: SimCfnResourceCallerOptions): Promise<void>;
 }
 export {};

package/dist/service/lambda/cfn/sim-cfn-lambda-resource-deleter.js

@@ -1,4 +1,4 @@
-import { simCfnLambdaCreatedResource } from "./sim-cfn-lambda-created-resource.js";
+import { simCfnLambdaCreatedResource as created } from "./sim-cfn-lambda-created-resource.js";
 import { simCfnLambdaRemoveEventInvokeConfig } from "./event-invoke-config/sim-cfn-lambda-event-invoke-config-remover.js";
 import { simCfnLambdaRevokePermission } from "./permission/sim-cfn-lambda-permission-revoker.js";
 import { simCfnLambdaTargetFunctionName } from "./function/sim-cfn-lambda-target-function.js";
@@ -17,26 +17,29 @@ export class SimCfnLambdaResourceDeleter {
     /**
      * Delete a simulated Lambda resource created from a CloudFormation Resource.
      */
-    async delete(resourceTypeName, resource) {
+    async delete(resourceTypeName, resource, options) {
         switch (resourceTypeName) {
             case "Function": {
-                await this.deleteFunction(resource);
+                const { name } = created(resource, "function");
+                await this.lambda.deleteFunction({ input: { FunctionName: name } }, options);
                 return;
             }
             case "Url": {
-                await this.deleteFunctionUrl(resource);
+                const url = created(resource, "Function URL");
+                await this.lambda.deleteFunctionUrlConfig({ input: { FunctionName: url.functionName } }, options);
                 return;
             }
             case "EventSourceMapping": {
-                await this.deleteEventSourceMapping(resource);
+                const { uuid } = created(resource, "event source mapping");
+                await this.lambda.deleteEventSourceMapping({ input: { UUID: uuid } }, options);
                 return;
             }
             case "EventInvokeConfig": {
-                await simCfnLambdaRemoveEventInvokeConfig(this.lambda, resource);
+                await simCfnLambdaRemoveEventInvokeConfig(this.lambda, resource, options);
                 return;
             }
             case "Permission": {
-                await simCfnLambdaRevokePermission(this.lambda, resource);
+                await simCfnLambdaRevokePermission(this.lambda, resource, options);
                 return;
             }
             case "Version": {
@@ -48,7 +51,14 @@ export class SimCfnLambdaResourceDeleter {
                 return;
             }
             case "Alias": {
-                await this.deleteAlias(resource);
+                // The version the alias pointed at is left where it is.
+                const alias = created(resource, "alias");
+                await this.lambda.deleteAlias({
+                    input: {
+                        FunctionName: simCfnLambdaTargetFunctionName(alias.arn),
+                        Name: alias.name,
+                    },
+                }, options);
                 return;
             }
             default: {
@@ -56,34 +66,4 @@ export class SimCfnLambdaResourceDeleter {
             }
         }
     }
-    async deleteFunction(resource) {
-        const simFunction = simCfnLambdaCreatedResource(resource, "function");
-        await this.lambda.deleteFunction({
-            input: { FunctionName: simFunction.name },
-        });
-    }
-    async deleteFunctionUrl(resource) {
-        const functionUrl = simCfnLambdaCreatedResource(resource, "Function URL");
-        await this.lambda.deleteFunctionUrlConfig({
-            input: { FunctionName: functionUrl.functionName },
-        });
-    }
-    async deleteEventSourceMapping(resource) {
-        const mapping = simCfnLambdaCreatedResource(resource, "event source mapping");
-        await this.lambda.deleteEventSourceMapping({
-            input: { UUID: mapping.uuid },
-        });
-    }
-    /**
-     * Drop an alias, leaving the version it pointed at where it is.
-     */
-    async deleteAlias(resource) {
-        const alias = simCfnLambdaCreatedResource(resource, "alias");
-        await this.lambda.deleteAlias({
-            input: {
-                FunctionName: simCfnLambdaTargetFunctionName(alias.arn),
-                Name: alias.name,
-            },
-        });
-    }
 }

package/dist/service/lambda/cfn/sim-cfn-lambda-resource-factory.d.ts

@@ -1,4 +1,4 @@
-import type { SimCfnResource, SimCloudFormationResourceCreateContext } from "../../cloudformation/resource/sim-cfn-resource.js";
+import type { SimCfnResource, SimCloudFormationResourceCreateContext, SimCloudFormationResourceDeleteContext } from "../../cloudformation/resource/sim-cfn-resource.js";
 import type { SimCfnServiceResourceFactory } from "../../cloudformation/resource/factory/sim-cfn-resource-factory.type.js";
 import type { SimLambda } from "../sim-lambda.js";
 /**
@@ -21,5 +21,5 @@ export declare class SimLambdaCloudFormationResourceFactory implements SimCfnSer
     /**
      * Delete a simulated Lambda resource created from a CloudFormation Resource.
      */
-    delete(resourceTypeName: string, resource: SimCfnResource): Promise<void>;
+    delete(resourceTypeName: string, resource: SimCfnResource, context: SimCloudFormationResourceDeleteContext): Promise<void>;
 }

package/dist/service/lambda/cfn/sim-cfn-lambda-resource-factory.js

@@ -1,3 +1,4 @@
+import { simCfnResourceCallerOptions } from "../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 import { SimCfnLambdaAliasCreator } from "./alias/sim-cfn-lambda-alias-creator.js";
 import { SimCfnLambdaEventInvokeConfigCreator } from "./event-invoke-config/sim-cfn-lambda-event-invoke-config-creator.js";
 import { SimCfnLambdaEventSourceMappingCreator } from "./event-source-mapping/sim-cfn-lambda-event-source-mapping-creator.js";
@@ -36,27 +37,29 @@ export class SimLambdaCloudFormationResourceFactory {
      * Create a simulated Lambda resource from a CloudFormation Resource.
      */
     async create(resourceTypeName, resource, context) {
+        const properties = context.resolvedProperties ?? resource.properties;
+        const options = simCfnResourceCallerOptions(context.caller);
         switch (resourceTypeName) {
             case "Function": {
-                return await this.functionCreator.create(resource, context.resolvedProperties ?? resource.properties, context.bindings);
+                return await this.functionCreator.create(resource, properties, context.bindings, options);
             }
             case "Url": {
-                return await this.urlCreator.create(resource, context.resolvedProperties ?? resource.properties);
+                return await this.urlCreator.create(resource, properties, options);
             }
             case "EventSourceMapping": {
-                return await this.eventSourceMappingCreator.create(resource, context.resolvedProperties ?? resource.properties);
+                return await this.eventSourceMappingCreator.create(resource, properties, options);
             }
             case "EventInvokeConfig": {
-                return await this.eventInvokeConfigCreator.create(resource, context.resolvedProperties ?? resource.properties);
+                return await this.eventInvokeConfigCreator.create(resource, properties, options);
             }
             case "Permission": {
-                return await this.permissionCreator.create(resource, context.resolvedProperties ?? resource.properties);
+                return await this.permissionCreator.create(resource, properties, options);
             }
             case "Version": {
-                return await this.versionCreator.create(resource, context.resolvedProperties ?? resource.properties);
+                return await this.versionCreator.create(resource, properties, options);
             }
             case "Alias": {
-                return await this.aliasCreator.create(resource, context.resolvedProperties ?? resource.properties);
+                return await this.aliasCreator.create(resource, properties, options);
             }
             default: {
                 throw new Error(`Unsupported sim Lambda CloudFormation Resource ${resourceTypeName}`);
@@ -66,7 +69,7 @@ export class SimLambdaCloudFormationResourceFactory {
     /**
      * Delete a simulated Lambda resource created from a CloudFormation Resource.
      */
-    async delete(resourceTypeName, resource) {
-        await this.deleter.delete(resourceTypeName, resource);
+    async delete(resourceTypeName, resource, context) {
+        await this.deleter.delete(resourceTypeName, resource, simCfnResourceCallerOptions(context.caller));
     }
 }

package/dist/service/lambda/cfn/url/sim-cfn-lambda-url-creator.d.ts

@@ -2,6 +2,7 @@ import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-re
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
 import type { SimLambdaFunctionUrl } from "../../function/url/sim-lambda-function-url.js";
 import type { SimLambda } from "../../sim-lambda.js";
+import type { SimCfnResourceCallerOptions } from "../../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 interface SimCfnLambdaUrlCreatorProperties {
     readonly lambda: SimLambda;
 }
@@ -19,6 +20,6 @@ export declare class SimCfnLambdaUrlCreator {
     /**
      * Create a simulated Function URL from an AWS::Lambda::Url Resource.
      */
-    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): Promise<SimLambdaFunctionUrl>;
+    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord, options?: SimCfnResourceCallerOptions): Promise<SimLambdaFunctionUrl>;
 }
 export {};

package/dist/service/lambda/cfn/url/sim-cfn-lambda-url-creator.js

@@ -17,7 +17,7 @@ export class SimCfnLambdaUrlCreator {
     /**
      * Create a simulated Function URL from an AWS::Lambda::Url Resource.
      */
-    async create(resource, properties) {
+    async create(resource, properties, options) {
         const targetFunctionArn = this.propertyParser.requiredString(resource, properties["TargetFunctionArn"], "TargetFunctionArn");
         const functionName = simCfnLambdaTargetFunctionName(targetFunctionArn);
         await this.lambda.createFunctionUrlConfig({
@@ -26,7 +26,7 @@ export class SimCfnLambdaUrlCreator {
                 AuthType: this.propertyParser.requiredString(resource, properties["AuthType"], "AuthType"),
                 InvokeMode: this.propertyParser.optionalString(resource, properties["InvokeMode"], "InvokeMode"),
             },
-        });
+        }, options);
         const functionUrl = this.lambda.getSimFunctionUrl(functionName);
         assertDefined(functionUrl, `Sim Lambda Function URL for ${functionName} after CloudFormation creation`);
         return functionUrl;

package/dist/service/lambda/cfn/version/sim-cfn-lambda-version-creator.d.ts

@@ -2,6 +2,7 @@ import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-re
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
 import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
 import type { SimLambda } from "../../sim-lambda.js";
+import type { SimCfnResourceCallerOptions } from "../../../cloudformation/resource/caller/sim-cfn-resource-caller-options.js";
 interface SimCfnLambdaVersionCreatorProperties {
     readonly lambda: SimLambda;
 }
@@ -25,6 +26,6 @@ export declare class SimCfnLambdaVersionCreator {
     /**
      * Publish a version from an AWS::Lambda::Version Resource.
      */
-    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): Promise<SimLambdaFunction>;
+    create(resource: SimCfnResource, properties: SimCfnTemplateValueRecord, options?: SimCfnResourceCallerOptions): Promise<SimLambdaFunction>;
 }
 export {};

package/dist/service/lambda/cfn/version/sim-cfn-lambda-version-creator.js

@@ -23,14 +23,14 @@ export class SimCfnLambdaVersionCreator {
     /**
      * Publish a version from an AWS::Lambda::Version Resource.
      */
-    async create(resource, properties) {
+    async create(resource, properties, options) {
         const functionName = simCfnLambdaTargetFunctionName(this.propertyParser.requiredString(resource, properties["FunctionName"], "FunctionName"));
         const published = await this.lambda.publishVersion({
             input: {
                 FunctionName: functionName,
                 Description: this.propertyParser.optionalString(resource, properties["Description"], "Description"),
             },
-        });
+        }, options);
         const version = this.lambda.getSimFunctionTarget(functionName, published.Version)?.simFunction;
         assertDefined(version, `Sim Lambda version ${published.Version} of ${functionName} after ` +
             "CloudFormation creation");

package/dist/service/lambda/function/code/sim-lambda-vm-zip-function.factory.d.ts

@@ -2,6 +2,7 @@ import { MappedFactory } from "@kensio/part-factory";
 import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
 import { SimLambdaFunction } from "../sim-lambda-function.js";
 import { type LambdaCodeZipFiles } from "./make-lambda-code-zip.js";
+import type { SimLambdaVmSdkModuleProvider } from "./vm/sdk/sim-lambda-vm-sdk-module-provider.js";
 /**
  * What a test asks for when it wants a function backed by zip code running in
  * a vm sandbox.
@@ -16,6 +17,12 @@ export interface SimLambdaVmZipFunctionInput {
     readonly code: string | LambdaCodeZipFiles;
     readonly handlerName: string;
     readonly memorySizeMb: number;
+    /**
+     * What provides the modules the archive does not bundle, as the real
+     * runtime provides the AWS SDK. Left out, the code has none, and an SDK
+     * require is refused for want of one.
+     */
+    readonly sdkModuleProvider?: SimLambdaVmSdkModuleProvider | undefined;
 }
 /**
  * Builds a simulated Lambda function whose code is a real zip archive run in a

package/dist/service/lambda/function/code/sim-lambda-vm-zip-function.factory.js

@@ -39,6 +39,7 @@ export const simLambdaVmZipFunctionFactory = new MappedFactory(() => ({
             archive,
             handlerName: input.handlerName,
             environment,
+            sdkModuleProvider: input.sdkModuleProvider,
         }),
     });
 });

package/dist/service/lambda/function/code/vm/sdk/sim-lambda-provided-sdk-module.d.ts

@@ -0,0 +1,19 @@
+import type { SimZipArchive } from "../../../../../../util/zip/zip-archive.js";
+import type { SimLambdaVmSdkModuleProvider } from "./sim-lambda-vm-sdk-module-provider.js";
+/**
+ * What the archive holds and who provides for what it does not. Between them
+ * that is enough to tell an absent package from one already accounted for.
+ */
+interface SimLambdaMissingSdkPackagesContext {
+    readonly archive: SimZipArchive;
+    readonly sdkModuleProvider: SimLambdaVmSdkModuleProvider;
+}
+/**
+ * The module the runtime provides for a specifier the archive does not
+ * bundle, or undefined for a specifier the provider does not serve.
+ *
+ * A package the project has not installed is refused here naming every other
+ * AWS SDK package the function code imports and the project is missing too.
+ */
+export declare function provideSdkModule(specifier: string, context: SimLambdaMissingSdkPackagesContext): unknown;
+export {};

package/dist/service/lambda/function/code/vm/sdk/sim-lambda-provided-sdk-module.js

@@ -0,0 +1,78 @@
+import { assertDefined } from "../../../../../../util/type-guard/defined.js";
+import { SimLambdaVmModuleResolver } from "../sim-lambda-vm-module-resolver.js";
+import { SimLambdaSdkPackagesNotInstalledError } from "./sim-lambda-sdk-packages-not-installed.error.js";
+/**
+ * The archive entries worth reading specifiers out of.
+ */
+const javaScriptFilePattern = /\.[cm]?js$/;
+/**
+ * A quoted `@aws-sdk/*` specifier, however a file asks for it. A `require`
+ * call, a dynamic `import`, and a static import's `from` clause all match.
+ */
+const awsSdkImportPattern = /(?:\b(?:require|import)\s*\(|\b(?:from|import)\b)\s*["'](@aws-sdk\/[^"']+)["']/g;
+/**
+ * The module the runtime provides for a specifier the archive does not
+ * bundle, or undefined for a specifier the provider does not serve.
+ *
+ * A package the project has not installed is refused here naming every other
+ * AWS SDK package the function code imports and the project is missing too.
+ */
+export function provideSdkModule(specifier, context) {
+    try {
+        return context.sdkModuleProvider.provideModule(specifier);
+    }
+    catch (error) {
+        throw everyMissingSdkPackage(error, context);
+    }
+}
+/**
+ * The refusal to raise for a package the project has not installed, naming
+ * every other AWS SDK package the function code imports and the project is
+ * missing too. Any other error stands as it is.
+ *
+ * The runtime provides a package when the code requires it, so on its own a
+ * refusal only ever names the one the code reached. A function importing two
+ * absent packages would then cost two runs and two installs, and the archive
+ * is the only place to read what a third-party function imports. So the
+ * archive is read here, once a package has already turned out to be missing,
+ * and one install covers the set. An archive that runs is never read.
+ */
+function everyMissingSdkPackage(error, context) {
+    if (!(error instanceof SimLambdaSdkPackagesNotInstalledError)) {
+        return error;
+    }
+    const resolver = new SimLambdaVmModuleResolver(context.archive);
+    const candidates = archiveAwsSdkImports(context.archive).filter((specifier) => !error.specifiers.includes(specifier) &&
+        !resolver.bundlesPackage(specifier));
+    const missing = context.sdkModuleProvider.unresolvedModules?.(candidates) ?? [];
+    if (missing.length === 0) {
+        return error;
+    }
+    return new SimLambdaSdkPackagesNotInstalledError([...error.specifiers, ...missing], { cause: error.cause });
+}
+/**
+ * The AWS SDK packages a function code archive's own files import, in the
+ * order they appear.
+ *
+ * Bundled dependencies are left out. What a package under `node_modules/`
+ * imports is that package's own business, resolved from the bundle beside it,
+ * and reading a vendored tree to name one more install is a poor trade.
+ */
+function archiveAwsSdkImports(archive) {
+    const specifiers = new Set();
+    for (const filePath of archive.filePaths()) {
+        if (!isFunctionCodeFile(filePath)) {
+            continue;
+        }
+        const source = archive.file(filePath).toString();
+        for (const match of source.matchAll(awsSdkImportPattern)) {
+            const specifier = match[1];
+            assertDefined(specifier, "Matched import has no specifier");
+            specifiers.add(specifier);
+        }
+    }
+    return specifiers.values().toArray();
+}
+function isFunctionCodeFile(filePath) {
+    return (javaScriptFilePattern.test(filePath) && !filePath.includes("node_modules/"));
+}

package/dist/service/lambda/function/code/vm/sdk/sim-lambda-sdk-packages-not-installed.error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AWS SDK packages the sim Lambda runtime was asked to provide and the
+ * consuming project has not installed.
+ *
+ * The real Lambda runtime provides these packages from the execution
+ * environment rather than from the deployment package, so the simulated
+ * runtime provides them from the host project. The fix is the same for every
+ * one of them, which is why they are named together: install them, or bundle
+ * them into the function code archive.
+ */
+export declare class SimLambdaSdkPackagesNotInstalledError extends Error {
+    readonly specifiers: readonly string[];
+    readonly name = "SimLambdaSdkPackagesNotInstalledError";
+    constructor(specifiers: readonly string[], options?: ErrorOptions);
+}

package/dist/service/lambda/function/code/vm/sdk/sim-lambda-sdk-packages-not-installed.error.js

@@ -0,0 +1,27 @@
+/**
+ * AWS SDK packages the sim Lambda runtime was asked to provide and the
+ * consuming project has not installed.
+ *
+ * The real Lambda runtime provides these packages from the execution
+ * environment rather than from the deployment package, so the simulated
+ * runtime provides them from the host project. The fix is the same for every
+ * one of them, which is why they are named together: install them, or bundle
+ * them into the function code archive.
+ */
+export class SimLambdaSdkPackagesNotInstalledError extends Error {
+    specifiers;
+    name = "SimLambdaSdkPackagesNotInstalledError";
+    constructor(specifiers, options) {
+        super(notInstalledMessage(specifiers), options);
+        this.specifiers = specifiers;
+    }
+}
+function notInstalledMessage(specifiers) {
+    const [subject, object] = specifiers.length > 1
+        ? ["the packages are", "them"]
+        : ["the package is", "it"];
+    return (`Cannot provide ${specifiers.join(", ")} to sim Lambda function code: ` +
+        `${subject} not installed. Install ${object} in your project, as the ` +
+        `real Lambda runtime provides ${object}, or bundle ${object} into the ` +
+        "function code archive.");
+}

package/dist/service/lambda/function/code/vm/sdk/sim-lambda-vm-sdk-module-provider.d.ts

@@ -16,6 +16,15 @@ export declare const awsSdkPackagePrefix = "@aws-sdk/";
  */
 export interface SimLambdaVmSdkModuleProvider {
     provideModule(specifier: string): unknown;
+    /**
+     * Which of the given specifiers this provider serves and cannot resolve.
+     *
+     * The module system asks once a package has turned out to be missing. The
+     * refusal then names every package the project has to install, where on
+     * its own it would name only the one the function code reached first. A
+     * provider that does not answer is asked for one specifier at a time.
+     */
+    unresolvedModules?(specifiers: readonly string[]): readonly string[];
 }
 /**
  * Module provider used when no simulated AWS environment is wired up, such

package/dist/service/lambda/function/code/vm/sdk/sim-sdk-lambda-vm-module-provider.d.ts

@@ -46,6 +46,16 @@ export declare class SimSdkLambdaVmModuleProvider implements SimLambdaVmSdkModul
      * undefined for other specifiers.
      */
     provideModule(specifier: string): unknown;
+    /**
+     * Which of the given specifiers this provider serves and the host cannot
+     * resolve.
+     *
+     * Resolution only. A package that resolves and then throws while it
+     * initializes is installed, and that error belongs to the function code
+     * requiring it rather than to a report of what is missing.
+     */
+    unresolvedModules(specifiers: readonly string[]): readonly string[];
+    private resolves;
     private hostModuleExports;
 }
 export {};

package/dist/service/lambda/function/code/vm/sdk/sim-sdk-lambda-vm-module-provider.js

@@ -1,11 +1,10 @@
-import { createRequire } from "node:module";
-import path from "node:path";
 import { SimSdkModuleClientInterceptor } from "../../../../../../sdk/module/sim-sdk-module-client-interceptor.js";
 import { SimSdkCommandDispatcher } from "../../../../../../sdk/sim-sdk-command-dispatcher.js";
 import { SimLambdaAwsApiOutbound } from "../../../outbound/sim-lambda-aws-api-outbound.js";
 import { isSimLambdaHttpModuleSpecifier, makeSimLambdaHttpModule, simLambdaHttpModuleScheme, } from "../../../outbound/sim-lambda-http-module.js";
+import { isModuleNotFoundError, requireHostModule, } from "../sim-lambda-host-modules.js";
+import { SimLambdaSdkPackagesNotInstalledError } from "./sim-lambda-sdk-packages-not-installed.error.js";
 import { awsSdkPackagePrefix, } from "./sim-lambda-vm-sdk-module-provider.js";
-const hostRequire = createRequire(import.meta.url);
 /**
  * Provides host-installed AWS SDK v3 packages to sim Lambda vm function
  * code, with client classes intercepted into the owning simulated AWS
@@ -61,6 +60,29 @@ export class SimSdkLambdaVmModuleProvider {
         this.providedModules.set(specifier, module);
         return module;
     }
+    /**
+     * Which of the given specifiers this provider serves and the host cannot
+     * resolve.
+     *
+     * Resolution only. A package that resolves and then throws while it
+     * initializes is installed, and that error belongs to the function code
+     * requiring it rather than to a report of what is missing.
+     */
+    unresolvedModules(specifiers) {
+        return specifiers.filter((specifier) => specifier.startsWith(awsSdkPackagePrefix) && !this.resolves(specifier));
+    }
+    resolves(specifier) {
+        if (this.providedModules.has(specifier)) {
+            return true;
+        }
+        try {
+            this.requireModule(specifier);
+            return true;
+        }
+        catch (error) {
+            return !isModuleNotFoundError(error);
+        }
+    }
     hostModuleExports(specifier) {
         let moduleExports;
         try {
@@ -72,10 +94,9 @@ export class SimSdkLambdaVmModuleProvider {
             if (!isModuleNotFoundError(error)) {
                 throw error;
             }
-            throw new Error(`Cannot provide ${specifier} to sim Lambda function code: the ` +
-                "package is not installed. Install it in your project, as the " +
-                "real Lambda runtime provides it, or bundle it into the function " +
-                "code archive.", { cause: error });
+            throw new SimLambdaSdkPackagesNotInstalledError([specifier], {
+                cause: error,
+            });
         }
         if (typeof moduleExports !== "object" || moduleExports === null) {
             throw new Error(`Cannot provide ${specifier} to sim Lambda function code: the host ` +
@@ -84,30 +105,3 @@ export class SimSdkLambdaVmModuleProvider {
         return moduleExports;
     }
 }
-/**
- * Require an AWS SDK package from the host.
- *
- * The packages are installed by the consuming project, as they are provided
- * by the real Lambda runtime rather than by this package. Requiring from
- * this module's context covers hoisted installs; the working-directory
- * fallback covers stricter package layouts.
- */
-function requireHostModule(specifier) {
-    try {
-        return hostRequire(specifier);
-    }
-    catch {
-        /* v8 ignore next 4 -- only reachable in consumer package layouts where
-           this package's own require context cannot see the SDK packages. */
-        return createRequire(path.join(process.cwd(), "package.json"))(specifier);
-    }
-}
-/**
- * Whether an error is a Node.js module resolution failure, as opposed to an
- * error thrown while a resolved module initializes.
- */
-function isModuleNotFoundError(error) {
-    return (error instanceof Error &&
-        "code" in error &&
-        (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND"));
-}