M
H
M
globalObject.localStorage wouldn't work? If so, using AsyncLocalStorage, am I right that it would look something like this, to store a global property for later reading downstream?
C
K
run takes the object you want to store, and then a callbackMKKMKrun requires the callbackKKMmystore.run({foo: bar}) is insufficient to write to the storage? If so, what would any callback I passed actually "do", if all I want to do is write for later reading?KrunKrun and return my Response thereKasyncLocalStorage.getStore(); to access req, env, ctxMrun()'s callback?MKMfooApi.bar() (in controllers/foo.js) be able to access that stored value.Mcontrollers/foo:KKalsHK
globalThis.als = new AsyncLocalStorage would workKM
globalThis in the first place and bypass ALS?)HHMMimportglobalThis.als = new AsyncLocalStorage(); seems to work tooK
K
Kd7d6d2f4 isn't overwritten by 987f4e92 like it would be if you just stored them on globalThis)MglobalThis runs the risk of multi-request leakage, how come I avoid that problem by hooking the (same) ALS onto globalThis? How does that avoid the same issue, since each request will be running that code (making a store, hooking the same property name onto it?) In other words, what guarantees that request 1 hooking foo=1 and request 2 hooking foo=2 will be preserved within the scope of their respective requests, using ALS?K
K
magic MglobalThis.foo set in one file and read in another file risks mutation/leakage from other requestsglobalThis.als, where als is a store with {foo: <something>} set on it, avoids that problemKK
KMKfetchals.run(..., async () => { ... }); inside your fetchals keeps track of what context it was called in (this specific call of the fetchals.getStore(), those modules were called within that run callback - it's tied to that invocation of the fetchals.getStore() within the fetchrun callback, it'd be undefinedrun stores what you pass to it in a context that's only available to the callback, and other calls to run by other requests doesn't mutate our store since als knows that is a separate invocation of the fetch
A
U
wrangler dev --remoteglobalObject.localStorageimport { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
fooStore.run('bar'); //<-- running in some async middlewareimport { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
const fooVal = fooStore.getStore(); //"bar"runrunrunrunrunrunrunrunmystore.run({foo: bar})asyncLocalStorage.getStore();run()import fooApi from '../controllers/foo'
router.post('/foo/bar', async req => {
const resp = fooApi.bar(); //e.g. "hello world"
return resp;
})fooApi.bar()controllers/foo.jscontrollers/fooexport default {
bar: () => {
//how to access local storage value in here? I'm not in the middleware's storage.run() callback at this point...
}
};alsalsalsalsglobalThis.als = new AsyncLocalStorageglobalThisglobalThisglobalThisglobalThisimport { als } from ".";globalThis.als = new AsyncLocalStorage();d7d6d2f4987f4e92foo=1foo=2globalThis.fooglobalThis.als{foo: <something>}als.run(..., async () => { ... });als.getStore()als.getStore()import { AsyncLocalStorage } from "node:async_hooks";
const asyncLocalStorage = new AsyncLocalStorage();
async function doStuff() {
const { req, env, ctx } = asyncLocalStorage.getStore();
const obj = await env.KV.get("foo");
// ...
}
export default {
async fetch(req, env, ctx) {
return asyncLocalStorage.run({ req, env, ctx }, async () => {
await doStuff();
return new Response("Hello World!");
});
},
};export const als = new AsyncLocalStorage();
router.get("/", async () => {
return als.run("foo", async () => {
const resp = foo.bar();
return new Response(resp);
});
});import { als } from ".";
export default {
bar: () => {
return als.getStore();
},
};