reflectdb 0.1.0

package/dist/shared/esm-z1xse19c.js

@@ -0,0 +1,369 @@
+// src/server/drizzle.ts
+import { createRequire } from "node:module";
+
+// src/server/factory.ts
+function getByDottedPath(root, path) {
+  const parts = path.split(".");
+  let cur = root;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== "object")
+      return;
+    cur = cur[p];
+  }
+  return cur;
+}
+function renderTemplate(template, ctx) {
+  return template.replace(/\$\{([^}]+)\}/g, (_m, expr) => {
+    const trimmed = expr.trim();
+    const path = trimmed.includes(".") ? trimmed : `params.${trimmed}`;
+    const v = getByDottedPath(ctx, path);
+    return v == null ? "" : String(v);
+  });
+}
+function resolveStamp(source, ctx) {
+  if (typeof source === "function")
+    return source(ctx);
+  if (source === "auth.userId")
+    return ctx.auth.userId;
+  if (source === "auth.name")
+    return ctx.auth.name;
+  if (typeof source === "string" && source.includes(".")) {
+    return getByDottedPath(ctx, source);
+  }
+  return source;
+}
+function buildScopeFilter(scope, ctx) {
+  if (!scope)
+    return;
+  if (typeof scope === "function")
+    return;
+  if (typeof scope === "string") {
+    const val2 = ctx.params[scope];
+    if (val2 === undefined) {
+      throw new Error(`params.${scope} required for scoped query`);
+    }
+    return { kind: "params", column: scope, value: val2 };
+  }
+  const { auth: authKey, column } = scope;
+  const val = ctx.auth[authKey];
+  if (val === undefined) {
+    throw new Error(`auth.${authKey} required for scoped query`);
+  }
+  return { kind: "auth", column, value: val };
+}
+function defineTable(adapter, opts = {}) {
+  const pkName = opts.pk ?? adapter.pk ?? "id";
+  const query = opts.query ? opts.query : (ctx, db) => {
+    if (typeof opts.scope === "function") {
+      throw new Error("function-form scope requires opts.query override on defineTable (no SQL fragment to pass to adapter)");
+    }
+    const scope = buildScopeFilter(opts.scope, ctx);
+    return adapter.list({ db, scope });
+  };
+  const authorize = async (action, ctx, _db) => {
+    if (action.type === "read" && opts.policy?.read) {
+      const ok = await opts.policy.read({ ctx });
+      if (!ok)
+        throw new Error("policy denied read");
+    }
+  };
+  const mutate = async (op, rawCtx, db) => {
+    const ctx = rawCtx;
+    const payload = op.payload ? { ...op.payload } : {};
+    if (op.type !== "delete")
+      delete payload[pkName];
+    if (opts.rowId) {
+      const expected = renderTemplate(opts.rowId, {
+        auth: ctx.auth,
+        params: ctx.params
+      });
+      if (op.rowId !== expected) {
+        throw new Error("rowId mismatch");
+      }
+    }
+    if (opts.scope && typeof opts.scope === "string" && op.type === "insert") {
+      const col = opts.scope;
+      const paramVal = ctx.params[col];
+      if (paramVal === undefined) {
+        throw new Error(`params.${col} required for scoped mutation`);
+      }
+      if (payload[col] !== paramVal) {
+        throw new Error(`${col} mismatch`);
+      }
+    }
+    if (opts.scope && typeof opts.scope === "object" && !Array.isArray(opts.scope) && "auth" in opts.scope && op.type === "insert") {
+      const { auth: authKey, column } = opts.scope;
+      const authVal = ctx.auth[authKey];
+      if (authVal === undefined) {
+        throw new Error(`auth.${authKey} required for scoped mutation`);
+      }
+      if (payload[column] !== authVal) {
+        throw new Error(`${column} mismatch`);
+      }
+    }
+    const existing = op.type !== "insert" ? await Promise.resolve(adapter.find({ db, rowId: op.rowId })) : null;
+    if (op.type !== "insert" && existing) {
+      if (opts.scope && typeof opts.scope === "string") {
+        const col = opts.scope;
+        const paramVal = ctx.params[col];
+        if (paramVal === undefined) {
+          throw new Error(`params.${col} required for scoped mutation`);
+        }
+        if (existing[col] !== paramVal) {
+          throw new Error(`${col} mismatch`);
+        }
+      }
+      if (opts.scope && typeof opts.scope === "object" && !Array.isArray(opts.scope) && "auth" in opts.scope) {
+        const { auth: authKey, column } = opts.scope;
+        const authVal = ctx.auth[authKey];
+        if (authVal === undefined) {
+          throw new Error(`auth.${authKey} required for scoped mutation`);
+        }
+        if (existing[column] !== authVal) {
+          throw new Error(`${column} mismatch`);
+        }
+      }
+    }
+    if (op.type === "insert" && opts.policy?.insert) {
+      const ok = await opts.policy.insert({ ctx, payload });
+      if (!ok)
+        throw new Error("policy denied insert");
+    } else if (op.type === "update" && opts.policy?.update) {
+      const ok = await opts.policy.update({
+        ctx,
+        existing: existing ?? {},
+        payload
+      });
+      if (!ok)
+        throw new Error("policy denied update");
+    } else if (op.type === "delete" && opts.policy?.delete) {
+      const ok = await opts.policy.delete({ ctx, existing: existing ?? {} });
+      if (!ok)
+        throw new Error("policy denied delete");
+    }
+    if (opts.policy?.fields && op.type !== "delete") {
+      for (const [field, rule] of Object.entries(opts.policy.fields)) {
+        if (rule === "server-only") {
+          delete payload[field];
+        } else if (rule === "insert-only") {
+          if (op.type === "update")
+            delete payload[field];
+        } else if (typeof rule === "object" && rule && "write" in rule) {
+          const allow = await rule.write({
+            ctx,
+            existing: existing ?? null,
+            payload
+          });
+          if (!allow)
+            delete payload[field];
+        }
+      }
+    }
+    if (op.type === "insert" && opts.ownerStamp) {
+      for (const [field, source] of Object.entries(opts.ownerStamp)) {
+        if (source === undefined)
+          continue;
+        payload[field] = resolveStamp(source, ctx);
+      }
+    }
+    if (op.type !== "delete" && opts.serverSet) {
+      for (const [field, val] of Object.entries(opts.serverSet)) {
+        if (val === undefined)
+          continue;
+        payload[field] = typeof val === "function" ? val(ctx) : val;
+      }
+    }
+    if (op.type === "insert") {
+      await opts.hooks?.beforeInsert?.({ payload, ctx, db });
+    } else if (op.type === "update") {
+      await opts.hooks?.beforeUpdate?.({
+        payload,
+        existing: existing ?? {},
+        ctx,
+        db
+      });
+    } else if (op.type === "delete") {
+      await opts.hooks?.beforeDelete?.({ existing: existing ?? {}, ctx, db });
+    }
+    if (op.type === "delete") {
+      if (opts.delete) {
+        await opts.delete({ rowId: op.rowId, existing, ctx, db });
+      } else {
+        await Promise.resolve(adapter.delete({ db, rowId: op.rowId }));
+      }
+    } else if (op.type === "insert" && opts.insert) {
+      await opts.insert({ payload, existing, ctx, db });
+    } else if (op.type === "update" && opts.update) {
+      await opts.update({ payload, existing: existing ?? {}, ctx, db });
+    } else if (op.type === "update") {
+      if (Object.keys(payload).length > 0) {
+        await Promise.resolve(adapter.update({ db, rowId: op.rowId, payload }));
+      }
+    } else {
+      await Promise.resolve(adapter.insert({ db, rowId: op.rowId, payload }));
+    }
+    if (op.type === "delete") {
+      await opts.hooks?.afterDelete?.({ rowId: op.rowId, ctx, db });
+    } else {
+      const hookName = op.type === "insert" ? "afterInsert" : "afterUpdate";
+      const after = opts.hooks?.[hookName];
+      if (after) {
+        const row = await Promise.resolve(adapter.find({ db, rowId: op.rowId })) ?? {};
+        if (op.type === "insert") {
+          await opts.hooks?.afterInsert?.({ row, ctx, db });
+        } else {
+          await opts.hooks?.afterUpdate?.({
+            row,
+            previous: existing ?? {},
+            ctx,
+            db
+          });
+        }
+      }
+    }
+  };
+  return { query, mutate, authorize };
+}
+
+// src/server/drizzle.ts
+var requireFn = createRequire(import.meta.url);
+var cachedDrizzle;
+function loadDrizzleSync() {
+  if (cachedDrizzle === undefined) {
+    try {
+      const mod = requireFn("drizzle-orm");
+      cachedDrizzle = { eq: mod.eq, sql: mod.sql, getTableName: mod.getTableName };
+    } catch {
+      cachedDrizzle = null;
+    }
+  }
+  if (!cachedDrizzle) {
+    throw new Error("drizzleTable / drizzleTxAtomic require drizzle-orm to be installed. Add it to your dependencies, or use defineTable with a custom TableAdapter.");
+  }
+  return cachedDrizzle;
+}
+async function execAll(query) {
+  const q = query;
+  if (q && typeof q.all === "function") {
+    return await Promise.resolve(q.all());
+  }
+  const res = await Promise.resolve(query);
+  return Array.isArray(res) ? res : [];
+}
+function drizzleAdapter(table, pk) {
+  const pkName = pk ?? "id";
+  const pkCol = table[pkName];
+  let cachedName = "";
+  const adapter = {
+    get name() {
+      return cachedName;
+    },
+    pk: pkName,
+    async list({ db, scope }) {
+      const { eq, getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      if (!scope) {
+        return await execAll(db.select().from(table));
+      }
+      const col = table[scope.column];
+      return await execAll(db.select().from(table).where(eq(col, scope.value)));
+    },
+    async find({ db, rowId }) {
+      const { eq, getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      const rows = await execAll(db.select().from(table).where(eq(pkCol, rowId)));
+      return rows[0] ?? null;
+    },
+    async insert({ db, rowId, payload }) {
+      const { getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      const values = { ...payload, [pkName]: rowId };
+      if (Object.keys(payload).length > 0) {
+        await Promise.resolve(db.insert(table).values(values).onConflictDoUpdate({ target: pkCol, set: payload }));
+      } else {
+        await Promise.resolve(db.insert(table).values(values).onConflictDoNothing());
+      }
+    },
+    async update({ db, rowId, payload }) {
+      const { eq, getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      await Promise.resolve(db.update(table).set(payload).where(eq(pkCol, rowId)));
+    },
+    async delete({ db, rowId }) {
+      const { eq, getTableName } = loadDrizzleSync();
+      if (!cachedName)
+        cachedName = getTableName(table);
+      await Promise.resolve(db.delete(table).where(eq(pkCol, rowId)));
+    }
+  };
+  return adapter;
+}
+function drizzleQueryFn(table, opts) {
+  if (opts.query)
+    return opts.query;
+  return (ctx, db) => {
+    const where = buildDrizzleScopeWhere(opts.scope, ctx, table);
+    return where ? db.select().from(table).where(where) : db.select().from(table);
+  };
+}
+function buildDrizzleScopeWhere(scope, ctx, table) {
+  if (!scope)
+    return;
+  if (typeof scope === "function")
+    return scope(ctx);
+  const { eq } = loadDrizzleSync();
+  if (typeof scope === "string") {
+    const col2 = table[scope];
+    const val2 = ctx.params[scope];
+    if (val2 === undefined) {
+      throw new Error(`params.${String(scope)} required for scoped query`);
+    }
+    return eq(col2, val2);
+  }
+  const col = table[scope.column];
+  const val = ctx.auth[scope.auth];
+  if (val === undefined) {
+    throw new Error(`auth.${String(scope.auth)} required for scoped query`);
+  }
+  return eq(col, val);
+}
+function drizzleTable(table, opts = {}) {
+  const adapter = drizzleAdapter(table, opts.pk);
+  const query = drizzleQueryFn(table, opts);
+  return defineTable(adapter, {
+    ...opts,
+    query
+  });
+}
+var drizzleTxAtomic = {
+  async begin(db) {
+    const { sql } = loadDrizzleSync();
+    const handle = db;
+    if (typeof handle?.run !== "function") {
+      throw new Error("drizzleTxAtomic.begin requires a drizzle db with a run() method");
+    }
+    await Promise.resolve(handle.run(sql`BEGIN`));
+  },
+  async commit(db) {
+    const { sql } = loadDrizzleSync();
+    const handle = db;
+    if (typeof handle?.run !== "function") {
+      throw new Error("drizzleTxAtomic.commit requires a drizzle db with a run() method");
+    }
+    await Promise.resolve(handle.run(sql`COMMIT`));
+  },
+  async rollback(db) {
+    const { sql } = loadDrizzleSync();
+    const handle = db;
+    if (typeof handle?.run !== "function") {
+      throw new Error("drizzleTxAtomic.rollback requires a drizzle db with a run() method");
+    }
+    await Promise.resolve(handle.run(sql`ROLLBACK`));
+  }
+};
+
+export { defineTable, drizzleTable, drizzleTxAtomic };