caching for sync function

[mblandr]

Goals

1. Goal is clear - node, bun and deno - all have sync api for operation with SQLite db. But there is no way to cache this sync api. only create special async wrapper with artifical delay. Any change to have this?

Non-Goals

Background

1. Goal is clear - node, bun and deno - all have sync api for operation with SQLite db. But there is no way to cache this sync api. only create special async wrapper with artifical delay. Any change to have this?

Proposal

1. Goal is clear - node, bun and deno - all have sync api for operation with SQLite db. But there is no way to cache this sync api. only create special async wrapper with artifical delay. Any change to have this?

[SametDulger]

I see where you're coming from. Sync APIs are definitely convenient, especially when working with SQLite in Node, Bun, or Deno, but caching them isn't straightforward due to the nature of the JavaScript event loop.

Since sync functions block the main thread, most caching layers (which rely on async IO) don’t integrate naturally. That said, a few workarounds might help:

In-memory caching
If your use case is limited to the current runtime instance, you can implement a simple in-memory cache using a plain object or Map. Something like:

const cache = new Map();

function cachedQuery(key, fn) {
  if (cache.has(key)) return cache.get(key);
  const result = fn();
  cache.set(key, result);
  return result;
}

Worker threads (Node.js)
For more complex scenarios, especially in Node, using worker threads to isolate sync logic can give you more flexibility. It won’t make the cache itself sync, but it can offload the blocking work.

As for native sync caching APIs: it’s unlikely the runtimes will add support for this anytime soon, mainly due to the complexity and limitations around sync execution in JS environments. Still, it might be worth exploring at the library level for SQLite wrappers.

[icyJoseph]

only create special async wrapper with artificial delay

What do you mean? You'll likely need to wrap the db access anyway, to validate if the access is allowed. Anyway, you can wrap the call in an async function.

const getUserByUsername = database.prepare(`
  SELECT * FROM users WHERE username = ?
`);

async function readUsername(username) {
    'use cache'
     return getUserByUsername.get(username)
}

Something like that - I know some linters, etc, might say, well this is unnecessarily asynchronous, but that can be worked around too.

Also you can cache at different levels, you might want to cache the entire page result, if all you want is to produce a static shell that uses the data from the sqlite query, not just specific functions.

You might want to also cache only for this render pass, with React.cache.

What is your use case?