Serverless DeepDive #08：return後の処理は実行されるのか

const { randomUUID } = require("node:crypto");
const { setTimeout: sleep } = require("node:timers/promises");

const environmentId = randomUUID();
const records = [];
const orphanPromises = [];
let activeRequestId = null;
let activeMode = null;
let calls = 0;
let client;
const modes = ["await-store", "detach-store", "observe", "orphan-promise", "await-promise"];

function identifier(value, field) {
if (typeof value !== "string" || !/^[a-z0-9-]{1,64}$/.test(value))
throw new TypeError(`${field} must match [a-z0-9-]{1,64}`);
return value;
}

function delay(value) {
if (!Number.isInteger(value) || value < 0 || value > 3000)
throw new TypeError("delay_ms must be between 0 and 3000");
return value;
}

function snapshot() {
return records.map(
({ id, request_id, status, put_started_ms, stored_ms, active_request_id }) => ({
id,
request_id,
status,
put_started_ms: put_started_ms ?? null,
stored_ms: stored_ms ?? null,
active_request_id: active_request_id ?? null,
}),
);
}

async function store(record, delayMs) {
await sleep(delayMs);
record.put_started_ms = Date.now();
record.active_request_id = activeRequestId;
record.active_mode = activeMode;
record.status = "put-started";
console.log(JSON.stringify({ phase: "return-put-started", ...record }));
const bucket = process.env.LAB_EVIDENCE_BUCKET;
const prefix = process.env.LAB_EVIDENCE_PREFIX;
if (!bucket || !prefix) throw new Error("storage is not configured");
const { S3Client, PutObjectCommand } = require("@aws-sdk/client-s3");
if (!client) client = new S3Client({ maxAttempts: 1 });
record.sdk = require("@aws-sdk/client-s3/package.json").version;
record.key = `${prefix}${record.run_id}/${record.id}.json`;
await client.send(
new PutObjectCommand({ Bucket: bucket, Key: record.key, Body: JSON.stringify(record) }),
);
record.stored_ms = Date.now();
record.status = "stored";
console.log(JSON.stringify({ phase: "return-store-success", ...record }));
}

console.log(
JSON.stringify({ phase: "return-init", environment_id: environmentId, node: process.version }),
);

exports.handler = async (event, context) => {
if (!event || typeof event !== "object" || Array.isArray(event))
throw new TypeError("event must be a JSON object");
const mode = event.mode ?? "observe";
if (!modes.includes(mode)) throw new TypeError("unknown mode");
const id = identifier(event.id, "id");
const runId = identifier(event.run_id, "run_id");
const delayMs = delay(event.delay_ms ?? 1500);
if (event.wait_for_event_loop !== undefined && typeof event.wait_for_event_loop !== "boolean")
throw new TypeError("wait_for_event_loop must be boolean");
const propertyPresent = "callbackWaitsForEmptyEventLoop" in context;
const propertyBefore = context.callbackWaitsForEmptyEventLoop ?? null;
if (event.wait_for_event_loop !== undefined)
context.callbackWaitsForEmptyEventLoop = event.wait_for_event_loop;
calls += 1;
activeRequestId = context.awsRequestId;
activeMode = mode;
const record = {
id,
run_id: runId,
mode,
request_id: context.awsRequestId,
environment_id: environmentId,
node: process.version,
count: calls,
started_ms: Date.now(),
delay_ms: delayMs,
callback_property_present: propertyPresent,
callback_property_before: propertyBefore,
callback_property_after: context.callbackWaitsForEmptyEventLoop ?? null,
pending_before: snapshot(),
orphan_promises: orphanPromises.length,
};
console.log(JSON.stringify({ phase: "return-enter", ...record }));
if (mode === "await-store" || mode === "detach-store") {
if (records.length >= 64) throw new Error("record limit reached");
const workRecord = { ...record, status: "scheduled" };
records.push(workRecord);
const work = store(workRecord, delayMs);
if (mode === "await-store") await work;
else
void work.catch((error) => {
workRecord.status = "failed";
console.error(
JSON.stringify({ phase: "return-store-error", id, run_id: runId, error: error.name }),
);
});
} else if (mode === "observe") {
await sleep(delayMs);
} else {
if (orphanPromises.length >= 64) throw new Error("promise limit reached");
const never = new Promise(() => {});
orphanPromises.push(never);
if (mode === "await-promise") await never;
}
record.pending_after = snapshot();
record.finished_ms = Date.now();
record.orphan_promises = orphanPromises.length;
console.log(JSON.stringify({ phase: "return-result", ...record }));
return record;
};