A database that never slows down
DynamoDB answers in single-digit milliseconds at any scale — because it only does what scales. Items are found by a partition key (which machine) and a sort key (order within it). You don't join; you design keys so each question is one query: pk = USER#asha, sk begins_with ORDER#.
Partition + sort
function createTable({ partitionKey, sortKey }) {
const partitions = new Map(); // partition key → (sort key → item)
function keysOf(item) {
const pk = item[partitionKey];
const sk = sortKey ? item[sortKey] : "";
if (pk === undefined || sk === undefined) throw new Error("Missing key");
return [pk, sk];
}
return {
put(item) {
const [pk, sk] = keysOf(item);
if (!partitions.has(pk)) partitions.set(pk, new Map());
partitions.get(pk).set(sk, { ...item }); // replaces the whole item
},
get(pk, sk = "") {
const item = partitions.get(pk)?.get(sk);
return item ? { ...item } : undefined;
},
query({ pk, beginsWith, between, limit = Infinity, forward = true }) {
let entries = [...(partitions.get(pk) ?? new Map())].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
if (beginsWith !== undefined) entries = entries.filter(([sk]) => sk.startsWith(beginsWith));
if (between) entries = entries.filter(([sk]) => sk >= between[0] && sk <= between[1]);
if (!forward) entries.reverse();
return entries.slice(0, limit).map(([, item]) => ({ ...item }));
},
};
}