@cfast/db 0.3.0 → 0.4.1

package/dist/index.js

@@ -63,6 +63,7 @@ function checkOperationPermissions(grants, descriptors) {
 }
 
 // src/utils.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { and, or } from "drizzle-orm";
 import { getTableName as getTableName2 } from "@cfast/permissions";
 function deduplicateDescriptors(descriptors) {
@@ -77,12 +78,20 @@ function deduplicateDescriptors(descriptors) {
   }
   return result;
 }
+var lookupCacheStorage = new AsyncLocalStorage();
 function createLookupCache() {
   return /* @__PURE__ */ new Map();
 }
+function runWithLookupCache(fn, cache = createLookupCache()) {
+  return lookupCacheStorage.run(cache, fn);
+}
+function getActiveLookupCache(fallback) {
+  return lookupCacheStorage.getStore() ?? fallback;
+}
 async function resolveGrantLookups(grant, user, lookupDb, cache) {
   if (!grant.with) return {};
-  const cached = cache.get(grant);
+  const activeCache = getActiveLookupCache(cache);
+  const cached = activeCache.get(grant);
   if (cached) return cached;
   const entries = Object.entries(grant.with);
   const promise = (async () => {
@@ -94,7 +103,7 @@ async function resolveGrantLookups(grant, user, lookupDb, cache) {
     );
     return resolved;
   })();
-  cache.set(grant, promise);
+  activeCache.set(grant, promise);
   return promise;
 }
 async function buildPermissionFilter(grants, action, table, user, unsafe, getLookupDb, cache) {
@@ -665,6 +674,139 @@ function createCacheManager(config) {
   };
 }
 
+// src/transaction.ts
+var TransactionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TransactionError";
+  }
+};
+function wrapWriteOperation(ctx, op) {
+  const record = (toQueue) => {
+    if (ctx.closed) {
+      throw new TransactionError(
+        "Cannot run an operation after the transaction has committed or aborted."
+      );
+    }
+    if (ctx.aborted) {
+      throw new TransactionError(
+        "Transaction has been aborted; no further operations may run."
+      );
+    }
+    ctx.pending.push({ op: toQueue });
+  };
+  const proxied = {
+    permissions: op.permissions,
+    async run() {
+      record(op);
+      return void 0;
+    }
+  };
+  if (typeof op.returning === "function") {
+    proxied.returning = () => {
+      const returningOp = op.returning();
+      return {
+        permissions: returningOp.permissions,
+        async run() {
+          record(returningOp);
+          return void 0;
+        }
+      };
+    };
+  }
+  return proxied;
+}
+function createTxHandle(db, ctx) {
+  return {
+    query: (table) => {
+      return db.query(table);
+    },
+    insert: (table) => {
+      const realBuilder = db.insert(table);
+      return {
+        values: (values) => {
+          const realOp = realBuilder.values(values);
+          return wrapWriteOperation(ctx, realOp);
+        }
+      };
+    },
+    update: (table) => {
+      const realBuilder = db.update(table);
+      return {
+        set: (values) => {
+          const realSet = realBuilder.set(values);
+          return {
+            where: (condition) => {
+              const realOp = realSet.where(condition);
+              return wrapWriteOperation(ctx, realOp);
+            }
+          };
+        }
+      };
+    },
+    delete: (table) => {
+      const realBuilder = db.delete(table);
+      return {
+        where: (condition) => {
+          const realOp = realBuilder.where(condition);
+          return wrapWriteOperation(ctx, realOp);
+        }
+      };
+    },
+    transaction: (callback) => {
+      return runTransaction(db, callback, ctx);
+    }
+  };
+}
+async function flushWrites(db, pending) {
+  if (pending.length === 0) return;
+  const ops = pending.map((p) => p.op);
+  for (const op of ops) {
+    if (getBatchable(op) === void 0) {
+      throw new TransactionError(
+        "Internal error: a pending transaction operation was not batchable. Transactions only accept operations produced by tx.insert/update/delete."
+      );
+    }
+  }
+  await db.batch(ops).run({});
+}
+async function runTransaction(db, callback, parentCtx) {
+  if (parentCtx) {
+    if (parentCtx.closed || parentCtx.aborted) {
+      throw new TransactionError(
+        "Cannot start a nested transaction: parent has already committed or aborted."
+      );
+    }
+    const nestedTx = createTxHandle(db, parentCtx);
+    return callback(nestedTx);
+  }
+  const ctx = {
+    pending: [],
+    closed: false,
+    aborted: false,
+    nested: false
+  };
+  const tx = createTxHandle(db, ctx);
+  let result;
+  try {
+    result = await callback(tx);
+  } catch (err) {
+    ctx.aborted = true;
+    ctx.closed = true;
+    ctx.pending.length = 0;
+    throw err;
+  }
+  try {
+    await flushWrites(db, ctx.pending);
+    ctx.closed = true;
+  } catch (err) {
+    ctx.aborted = true;
+    ctx.closed = true;
+    throw err;
+  }
+  return result;
+}
+
 // src/create-db.ts
 function createDb(config) {
   const lookupCache = createLookupCache();
@@ -744,11 +886,14 @@ function buildDb(config, isUnsafe, lookupCache) {
         permissions: allPermissions,
         async run(params) {
           const p = params ?? {};
+          if (operations.length === 0) {
+            return [];
+          }
           if (!isUnsafe) {
             checkOperationPermissions(config.grants, allPermissions);
           }
           const batchables = operations.map((op) => getBatchable(op));
-          const everyOpBatchable = operations.length > 0 && batchables.every((b) => b !== void 0);
+          const everyOpBatchable = batchables.every((b) => b !== void 0);
           if (everyOpBatchable) {
             const sharedDb = drizzle3(config.d1, { schema: config.schema });
             await Promise.all(
@@ -775,6 +920,9 @@ function buildDb(config, isUnsafe, lookupCache) {
         }
       };
     },
+    transaction(callback) {
+      return runTransaction(db, callback);
+    },
     cache: {
       async invalidate(options) {
         if (!cacheManager) return;
@@ -787,13 +935,32 @@ function buildDb(config, isUnsafe, lookupCache) {
           }
         }
       }
+    },
+    clearLookupCache() {
+      lookupCache.clear();
     }
   };
   return db;
 }
+function createAppDb(config) {
+  const { d1, schema, cache } = config;
+  const getD1 = typeof d1 === "function" ? d1 : () => d1;
+  return (grants, user) => createDb({
+    d1: getD1(),
+    schema,
+    grants,
+    user,
+    cache
+  });
+}
 
 // src/compose.ts
 function compose(operations, executor) {
+  if (executor.length > 0 && executor.length !== operations.length) {
+    throw new Error(
+      `compose(): executor declares ${executor.length} parameter(s) but ${operations.length} operation(s) were passed. Each operation must have a corresponding run-function parameter (in array order), otherwise sub-operations will silently go uninvoked. Prefer composeSequentialCallback() for by-name binding.`
+    );
+  }
   const allPermissions = deduplicateDescriptors(
     operations.flatMap((op) => op.permissions)
   );
@@ -864,7 +1031,7 @@ function wrapForTracking(target, perms) {
   });
 }
 function createTrackingDb(real, perms) {
-  return {
+  const trackingDb = {
     query: (table) => wrapForTracking(real.query(table), perms),
     insert: (table) => wrapForTracking(real.insert(table), perms),
     update: (table) => wrapForTracking(real.update(table), perms),
@@ -881,8 +1048,24 @@ function createTrackingDb(real, perms) {
         }
       };
     },
-    cache: real.cache
+    transaction: async (callback) => {
+      const trackingTx = {
+        query: trackingDb.query,
+        insert: trackingDb.insert,
+        update: trackingDb.update,
+        delete: trackingDb.delete,
+        transaction: (cb) => trackingDb.transaction(cb)
+      };
+      try {
+        await callback(trackingTx);
+      } catch {
+      }
+      return createSentinel();
+    },
+    cache: real.cache,
+    clearLookupCache: () => real.clearLookupCache()
   };
+  return trackingDb;
 }
 function composeSequentialCallback(db, callback) {
   const collected = [];
@@ -911,11 +1094,43 @@ function composeSequentialCallback(db, callback) {
     }
   };
 }
+
+// src/seed.ts
+function defineSeed(config) {
+  const entries = Object.freeze(
+    config.entries.map((entry) => ({
+      table: entry.table,
+      rows: Object.freeze([...entry.rows])
+    }))
+  );
+  return {
+    entries,
+    async run(db) {
+      const unsafeDb = db.unsafe();
+      for (const entry of entries) {
+        if (entry.rows.length === 0) continue;
+        const ops = entry.rows.map(
+          (row) => unsafeDb.insert(entry.table).values(row)
+        );
+        if (ops.length === 1) {
+          await ops[0].run({});
+        } else {
+          await unsafeDb.batch(ops).run({});
+        }
+      }
+    }
+  };
+}
 export {
+  TransactionError,
   compose,
   composeSequential,
   composeSequentialCallback,
+  createAppDb,
   createDb,
+  createLookupCache,
+  defineSeed,
   parseCursorParams,
-  parseOffsetParams
+  parseOffsetParams,
+  runWithLookupCache
 };