@kensio/yulin 1.20.14 → 1.20.15

package/dist/service/iam/policy/parse/sim-iam-document-parser.js

@@ -1,9 +1,15 @@
 import { simIamPolicyDocumentStatements } from "../sim-iam-pol-document-statements.js";
+import { simIamStatementLabel } from "../sim-iam-statement-label.js";
+import { simIamStatementStrings } from "../sim-iam-statement-strings.js";
 /**
  * Parse raw IAM policy document shapes into a form convenient for evaluation.
  *
  * IAM policy JSON commonly allows either a single value or an array. The decision
  * engine should not need to care which source shape was used.
+ *
+ * A document stored without validation can hold a value of the wrong type in
+ * one of those fields. Parsing it reports a malformed policy naming the
+ * statement.
  */
 export class SimIamPolicyDocumentParser {
     /**
@@ -11,30 +17,22 @@ export class SimIamPolicyDocumentParser {
      */
     parse(policy) {
         return {
-            statements: simIamPolicyDocumentStatements(policy).map((statement) => this.parseStatement(statement)),
+            statements: simIamPolicyDocumentStatements(policy).map((statement, index) => this.parseStatement(statement, index)),
         };
     }
-    parseStatement(statement) {
+    parseStatement(statement, index) {
+        const label = simIamStatementLabel(index);
         return {
             source: statement,
             sid: statement.Sid,
             effect: statement.Effect,
-            actions: this.stringList(statement.Action),
-            notActions: this.stringList(statement.NotAction),
-            resources: this.stringList(statement.Resource),
-            notResources: this.stringList(statement.NotResource),
+            actions: simIamStatementStrings(statement.Action, label, "Action"),
+            notActions: simIamStatementStrings(statement.NotAction, label, "NotAction"),
+            resources: simIamStatementStrings(statement.Resource, label, "Resource"),
+            notResources: simIamStatementStrings(statement.NotResource, label, "NotResource"),
             principal: statement.Principal,
             notPrincipal: statement.NotPrincipal,
             condition: statement.Condition,
         };
     }
-    stringList(value) {
-        if (value === undefined) {
-            return undefined;
-        }
-        if (typeof value === "string") {
-            return [value];
-        }
-        return [...value];
-    }
 }

package/dist/service/iam/policy/sim-iam-statement-label.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What a policy document is attached to, for naming it when one of its
+ * statements is rejected.
+ */
+export interface SimIamPolicyDocumentSubject {
+    /**
+     * The kind of thing the document is attached to, such as `Role` or `Bucket`.
+     */
+    readonly attachedTo: string;
+    /**
+     * The name of the thing the document is attached to.
+     */
+    readonly name: string;
+    /**
+     * The policy's own name, for a document stored under one.
+     */
+    readonly policyName?: string | undefined;
+}
+/**
+ * Name one statement of a policy document, for a message about what is wrong
+ * with it.
+ *
+ * A malformed statement usually arrives from a CloudFormation template. The
+ * reader chasing one back needs the document it came from as well as the fault
+ * in it. Statements carry no names of their own. The position in the document
+ * stands in for one.
+ */
+export declare function simIamStatementLabel(index: number, subject?: SimIamPolicyDocumentSubject): string;

package/dist/service/iam/policy/sim-iam-statement-label.js

@@ -0,0 +1,17 @@
+/**
+ * Name one statement of a policy document, for a message about what is wrong
+ * with it.
+ *
+ * A malformed statement usually arrives from a CloudFormation template. The
+ * reader chasing one back needs the document it came from as well as the fault
+ * in it. Statements carry no names of their own. The position in the document
+ * stands in for one.
+ */
+export function simIamStatementLabel(index, subject) {
+    const statement = `statement ${index + 1}`;
+    if (subject === undefined) {
+        return `IAM policy ${statement}`;
+    }
+    const policy = subject.policyName === undefined ? "" : ` policy "${subject.policyName}"`;
+    return `${subject.attachedTo} "${subject.name}"${policy} ${statement}`;
+}

package/dist/service/iam/policy/sim-iam-statement-strings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read a statement field holding either one string or a list of strings.
+ *
+ * Action, NotAction, Resource and NotResource each take either shape, and
+ * anything else is a malformed document. An unresolved CloudFormation intrinsic
+ * is the usual way one arrives. The IAM policy parsers store `PolicyDocument`
+ * whole, and a `Ref` or `Fn::GetAtt` nested inside a statement is kept as
+ * written. Refusing it here keeps it out of evaluation, where the same value
+ * surfaces as a `TypeError` naming no policy.
+ */
+export declare function simIamStatementStrings(value: unknown, label: string, field: string): readonly string[] | undefined;

package/dist/service/iam/policy/sim-iam-statement-strings.js

@@ -0,0 +1,27 @@
+import { SimIamMalformedPolicyDocument } from "../error/sim-iam.error.js";
+/**
+ * Read a statement field holding either one string or a list of strings.
+ *
+ * Action, NotAction, Resource and NotResource each take either shape, and
+ * anything else is a malformed document. An unresolved CloudFormation intrinsic
+ * is the usual way one arrives. The IAM policy parsers store `PolicyDocument`
+ * whole, and a `Ref` or `Fn::GetAtt` nested inside a statement is kept as
+ * written. Refusing it here keeps it out of evaluation, where the same value
+ * surfaces as a `TypeError` naming no policy.
+ */
+export function simIamStatementStrings(value, label, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (isStringArray(value)) {
+        return [...value];
+    }
+    throw new SimIamMalformedPolicyDocument(`${label}: ${field} must be a string or an array of strings, but holds ${JSON.stringify(value)}`);
+}
+function isStringArray(value) {
+    return (Array.isArray(value) &&
+        value.every((entry) => typeof entry === "string"));
+}

package/dist/service/iam/validate/sim-iam-policy-document-validator.d.ts

@@ -1,17 +1,24 @@
 import { type JSONString } from "../../../util/type-guard/json.js";
 import type { SimIamPolicyDocument } from "../policy/sim-iam-policy.js";
+import { type SimIamPolicyDocumentSubject } from "../policy/sim-iam-statement-label.js";
 /**
  * Performs basic IAM policy document validation shared by IAM policy commands.
+ *
+ * A caller can say what the document is attached to, and a rejection names it.
+ * Malformed documents usually arrive from a CloudFormation template, and the
+ * failure has to carry enough for a reader to find the template that wrote
+ * it.
  */
 export declare class SimIamPolicyDocumentValidator {
     /**
      * Validate a required JSON IAM policy document string.
      */
-    validateRequired(policyDocument: string | undefined): asserts policyDocument is JSONString<SimIamPolicyDocument>;
+    validateRequired(policyDocument: string | undefined, subject?: SimIamPolicyDocumentSubject): asserts policyDocument is JSONString<SimIamPolicyDocument>;
     /**
      * Validate an optional JSON IAM policy document string when present.
      */
-    validateOptional(policyDocument: string | undefined): asserts policyDocument is JSONString<SimIamPolicyDocument> | undefined;
+    validateOptional(policyDocument: string | undefined, subject?: SimIamPolicyDocumentSubject): asserts policyDocument is JSONString<SimIamPolicyDocument> | undefined;
     private validate;
     private validateParsed;
+    private validateStatement;
 }

package/dist/service/iam/validate/sim-iam-policy-document-validator.js

@@ -1,45 +1,63 @@
 import { jsonParse } from "../../../util/type-guard/json.js";
 import { SimIamMalformedPolicyDocument } from "../error/sim-iam.error.js";
 import { simIamPolicyDocumentStatements } from "../policy/sim-iam-pol-document-statements.js";
+import { simIamStatementLabel, } from "../policy/sim-iam-statement-label.js";
+import { simIamStatementStrings } from "../policy/sim-iam-statement-strings.js";
 /**
  * Performs basic IAM policy document validation shared by IAM policy commands.
+ *
+ * A caller can say what the document is attached to, and a rejection names it.
+ * Malformed documents usually arrive from a CloudFormation template, and the
+ * failure has to carry enough for a reader to find the template that wrote
+ * it.
  */
 export class SimIamPolicyDocumentValidator {
     /**
      * Validate a required JSON IAM policy document string.
      */
-    validateRequired(policyDocument) {
+    validateRequired(policyDocument, subject) {
         if (policyDocument === undefined || policyDocument.length === 0) {
             throw new Error("PolicyDocument is required");
         }
-        this.validate(policyDocument);
+        this.validate(policyDocument, subject);
     }
     /**
      * Validate an optional JSON IAM policy document string when present.
      */
-    validateOptional(policyDocument) {
+    validateOptional(policyDocument, subject) {
         if (policyDocument === undefined || policyDocument.length === 0) {
             return;
         }
-        this.validate(policyDocument);
+        this.validate(policyDocument, subject);
     }
-    validate(policyDocument) {
+    validate(policyDocument, subject) {
         const parsedPolicyDocument = jsonParse(policyDocument);
-        this.validateParsed(parsedPolicyDocument);
+        this.validateParsed(parsedPolicyDocument, subject);
     }
-    validateParsed(policyDocument) {
-        for (const statement of simIamPolicyDocumentStatements(policyDocument)) {
-            // oxlint-disable-next-line typescript/no-unnecessary-condition
-            if (statement.Effect !== "Allow" && statement.Effect !== "Deny") {
-                throw new SimIamMalformedPolicyDocument('IAM policy statement Effect must be either "Allow" or "Deny"');
-            }
-            if (statement.Action === undefined && statement.NotAction === undefined) {
-                throw new SimIamMalformedPolicyDocument("IAM policy statement must define either Action or NotAction");
-            }
-            if (statement.Resource === undefined &&
-                statement.NotResource === undefined) {
-                throw new SimIamMalformedPolicyDocument("IAM policy statement must define either Resource or NotResource");
-            }
+    validateParsed(policyDocument, subject) {
+        const statements = simIamPolicyDocumentStatements(policyDocument);
+        for (const [index, statement] of statements.entries()) {
+            this.validateStatement(statement, simIamStatementLabel(index, subject));
         }
     }
+    validateStatement(statement, label) {
+        // oxlint-disable-next-line typescript/no-unnecessary-condition
+        if (statement.Effect !== "Allow" && statement.Effect !== "Deny") {
+            throw new SimIamMalformedPolicyDocument(`${label}: Effect must be either "Allow" or "Deny"`);
+        }
+        if (statement.Action === undefined && statement.NotAction === undefined) {
+            throw new SimIamMalformedPolicyDocument(`${label}: must define either Action or NotAction`);
+        }
+        if (statement.Resource === undefined &&
+            statement.NotResource === undefined) {
+            throw new SimIamMalformedPolicyDocument(`${label}: must define either Resource or NotResource`);
+        }
+        // Read for the types alone. A field of the wrong type throws while the
+        // document is still beside the call that wrote it. Left to the first
+        // authorization, the same fault names no policy at all.
+        simIamStatementStrings(statement.Action, label, "Action");
+        simIamStatementStrings(statement.NotAction, label, "NotAction");
+        simIamStatementStrings(statement.Resource, label, "Resource");
+        simIamStatementStrings(statement.NotResource, label, "NotResource");
+    }
 }

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"));
-}

package/dist/service/lambda/function/code/vm/sim-lambda-host-modules.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Require from the host a module the real Lambda runtime provides without it
+ * being bundled: a Node.js built-in, or an AWS SDK package.
+ *
+ * The SDK packages are installed by the consuming project, as the real
+ * runtime provides them rather than this package. Requiring from this
+ * module's context covers hoisted installs; the working-directory fallback
+ * covers stricter package layouts.
+ */
+export declare function requireHostModule(specifier: string): unknown;
+/**
+ * Whether an error is a Node.js module resolution failure, as opposed to an
+ * error thrown while a resolved module initializes.
+ */
+export declare function isModuleNotFoundError(error: unknown): boolean;

package/dist/service/lambda/function/code/vm/sim-lambda-host-modules.js

@@ -0,0 +1,31 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+const hostRequire = createRequire(import.meta.url);
+/**
+ * Require from the host a module the real Lambda runtime provides without it
+ * being bundled: a Node.js built-in, or an AWS SDK package.
+ *
+ * The SDK packages are installed by the consuming project, as the real
+ * runtime provides them rather than this package. Requiring from this
+ * module's context covers hoisted installs; the working-directory fallback
+ * covers stricter package layouts.
+ */
+export 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.
+ */
+export function isModuleNotFoundError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND"));
+}

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

@@ -14,6 +14,13 @@ export declare class SimLambdaVmModuleResolver {
      * Resolve a require specifier to an archive file path.
      */
     resolveFilePath(specifier: string, fromDirectory: string): string;
+    /**
+     * Whether the archive bundles a bare specifier itself.
+     *
+     * The archive takes precedence over anything the runtime provides, so a
+     * specifier it resolves is never asked of the module provider.
+     */
+    bundlesPackage(specifier: string): boolean;
     private resolveCandidates;
     /**
      * Resolve a bare specifier against node_modules bundled in the archive.

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

@@ -22,6 +22,21 @@ export class SimLambdaVmModuleResolver {
         }
         return this.resolvePackage(specifier);
     }
+    /**
+     * Whether the archive bundles a bare specifier itself.
+     *
+     * The archive takes precedence over anything the runtime provides, so a
+     * specifier it resolves is never asked of the module provider.
+     */
+    bundlesPackage(specifier) {
+        try {
+            this.resolvePackage(specifier);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     resolveCandidates(basePath, specifier) {
         const candidates = [
             basePath,