reflectdb 0.1.0

package/dist/cjs/server/drizzle.cjs

@@ -0,0 +1,413 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/server/drizzle.ts
+var exports_drizzle = {};
+__export(exports_drizzle, {
+  drizzleTxAtomic: () => drizzleTxAtomic,
+  drizzleTable: () => drizzleTable
+});
+module.exports = __toCommonJS(exports_drizzle);
+var import_node_module2 = require("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 = import_node_module2.createRequire(module.filename);
+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`));
+  }
+};

package/dist/cjs/server/drizzle.d.cts

@@ -0,0 +1,233 @@
+type OpType = "insert" | "update" | "delete";
+interface AuthContext {
+	userId: string;
+	[key: string]: unknown;
+}
+interface DrizzleTableLike {
+	$inferSelect: Record<string, unknown>;
+	$inferInsert: Record<string, unknown>;
+}
+/**
+* Adapter contract for `server.tx({ atomic: true })` — pluggable so non-drizzle
+* data layers (kysely, prisma, raw SQL) can wrap their own BEGIN/COMMIT/ROLLBACK
+* without reflectdb hard-coding a drizzle dependency.
+*
+* Pass an adapter via:
+* - `server.tx({ atomic: <adapter> }, fn)` — per-call override.
+* - `ServerConfig.txAtomic` — server-wide default for `atomic: true`.
+*
+* If neither is supplied and `atomic: true` is requested, reflectdb falls back to
+* the bundled drizzle adapter via dynamic import (no top-level dep). When
+* drizzle isn't installed the fallback throws a clear error directing users to
+* supply a `txAtomic` adapter.
+*/
+interface TxAtomicAdapter {
+	/** Begin a transaction on the given db handle. */
+	begin(db: unknown): Promise<void>;
+	/** Commit the in-flight transaction. */
+	commit(db: unknown): Promise<void>;
+	/** Roll back the in-flight transaction. */
+	rollback(db: unknown): Promise<void>;
+}
+interface ResolvedOp {
+	type: OpType;
+	table: string;
+	rowId: string;
+	payload: Record<string, unknown> | null;
+	hlc: string;
+}
+interface MutationContext<TAuth extends AuthContext = AuthContext> {
+	auth: TAuth;
+	params: Record<string, unknown>;
+}
+type AuthorizeAction = {
+	type: "read";
+	table: string;
+	params: Record<string, unknown>;
+} | {
+	type: "write";
+	table: string;
+	op: ResolvedOp;
+};
+type Ctx<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = {
+	auth: TAuth;
+	params: TParams;
+};
+/**
+* Function-form scope returns an adapter-interpreted SQL fragment (e.g. a
+* drizzle `SQL`, a kysely `Expression<boolean>`, or a raw string). The generic
+* factory treats it as opaque (`unknown`) — ORM-specific helpers like
+* `drizzleTable` narrow the return type at their call site.
+*/
+type ScopeFn<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = (ctx: Ctx<TAuth, TParams>) => unknown;
+type ScopeOpt<
+	TRowKey extends string,
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = TRowKey | {
+	auth: keyof TAuth & string;
+	column: TRowKey;
+} | ScopeFn<TAuth, TParams>;
+type StampSource<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = "auth.userId" | "auth.name" | string | ((ctx: Ctx<TAuth, TParams>) => unknown);
+type ServerSetSource<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = unknown | ((ctx: Ctx<TAuth, TParams>) => unknown);
+type FieldPolicy<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = "server-only" | "insert-only" | {
+	write: (input: {
+		ctx: Ctx<TAuth, TParams>;
+		existing?: Record<string, unknown> | null;
+		payload: Record<string, unknown>;
+	}) => boolean | Promise<boolean>;
+};
+interface DefineTableOpts<
+	TRow extends Record<string, unknown> = Record<string, unknown>,
+	TAuth extends AuthContext = AuthContext,
+	TParams extends Record<string, unknown> = Record<string, unknown>
+> {
+	scope?: ScopeOpt<keyof TRow & string, TAuth, TParams>;
+	rowId?: string;
+	ownerStamp?: Partial<Record<keyof TRow & string, StampSource<TAuth, TParams>>>;
+	serverSet?: Partial<Record<keyof TRow & string, ServerSetSource<TAuth, TParams>>>;
+	policy?: {
+		read?: (input: {
+			ctx: Ctx<TAuth, TParams>;
+			existing?: Record<string, unknown> | null;
+		}) => boolean | Promise<boolean>;
+		insert?: (input: {
+			ctx: Ctx<TAuth, TParams>;
+			payload: Record<string, unknown>;
+		}) => boolean | Promise<boolean>;
+		update?: (input: {
+			ctx: Ctx<TAuth, TParams>;
+			existing: Record<string, unknown>;
+			payload: Record<string, unknown>;
+		}) => boolean | Promise<boolean>;
+		delete?: (input: {
+			ctx: Ctx<TAuth, TParams>;
+			existing: Record<string, unknown>;
+		}) => boolean | Promise<boolean>;
+		fields?: Partial<Record<keyof TRow & string, FieldPolicy<TAuth, TParams>>>;
+	};
+	hooks?: {
+		beforeInsert?: (input: {
+			payload: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		afterInsert?: (input: {
+			row: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		beforeUpdate?: (input: {
+			payload: Record<string, unknown>;
+			existing: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		afterUpdate?: (input: {
+			row: Record<string, unknown>;
+			previous: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		beforeDelete?: (input: {
+			existing: Record<string, unknown>;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+		afterDelete?: (input: {
+			rowId: string;
+			ctx: Ctx<TAuth, TParams>;
+			db: any;
+		}) => Promise<void> | void;
+	};
+	query?: (ctx: Ctx<TAuth, TParams>, db: any) => unknown;
+	insert?: (input: {
+		payload: Record<string, unknown>;
+		existing?: Record<string, unknown> | null;
+		ctx: Ctx<TAuth, TParams>;
+		db: any;
+	}) => Promise<void> | void;
+	update?: (input: {
+		payload: Record<string, unknown>;
+		existing: Record<string, unknown>;
+		ctx: Ctx<TAuth, TParams>;
+		db: any;
+	}) => Promise<void> | void;
+	delete?: (input: {
+		rowId: string;
+		existing: Record<string, unknown> | null;
+		ctx: Ctx<TAuth, TParams>;
+		db: any;
+	}) => Promise<void> | void;
+	pk?: keyof TRow & string;
+}
+import { SQL as SQL_1rji } from "drizzle-orm";
+type SQL = SQL_1rji;
+type Ctx2<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = {
+	auth: TAuth;
+	params: TParams;
+};
+type DrizzleScopeFn<
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = (ctx: Ctx2<TAuth, TParams>) => SQL;
+type DrizzleScopeOpt<
+	TRowKey extends string,
+	TAuth extends AuthContext,
+	TParams extends Record<string, unknown>
+> = TRowKey | {
+	auth: keyof TAuth & string;
+	column: TRowKey;
+} | DrizzleScopeFn<TAuth, TParams>;
+/**
+* Drizzle-flavored options. Identical surface to `DefineTableOpts` except the
+* row type is derived from `$inferSelect` and function-form scope returns
+* drizzle's `SQL` (vs. the generic factory's `unknown`). Kept for backward
+* compat with the existing public `drizzleTable<TTable, ...>(opts)` call shape.
+*/
+interface DrizzleTableOpts<
+	TTable extends DrizzleTableLike,
+	TAuth extends AuthContext = AuthContext,
+	TParams extends Record<string, unknown> = Record<string, unknown>
+> extends Omit<DefineTableOpts<TTable["$inferSelect"], TAuth, TParams>, "scope"> {
+	scope?: DrizzleScopeOpt<keyof TTable["$inferSelect"] & string, TAuth, TParams>;
+}
+declare function drizzleTable<
+	TTable extends DrizzleTableLike,
+	TAuth extends AuthContext = AuthContext,
+	TParams extends Record<string, unknown> = Record<string, unknown>
+>(table: TTable, opts?: DrizzleTableOpts<TTable, TAuth, TParams>): {
+	query: (ctx: Ctx2<TAuth, TParams>, db: any) => unknown;
+	mutate: (op: ResolvedOp, ctx: MutationContext<TAuth>, db: any) => Promise<void>;
+	authorize: (action: AuthorizeAction, ctx: MutationContext<TAuth>, db: any) => Promise<void>;
+};
+/**
+* `TxAtomicAdapter` for drizzle handles. Uses raw SQL via `db.run(sql\`BEGIN\`)`
+* — drizzle's async `db.transaction(...)` is unsafe on the bun-sqlite dialect
+* (sync transaction commits before the async body finishes), so we route
+* through `db.run(...)` which is portable across sqlite and postgres adapters.
+*
+* Exported so users can pass it explicitly to `tx({ atomic: drizzleTxAtomic })`
+* or to `ServerConfig.txAtomic` — and so the server's lazy-loaded fallback
+* has a single source of truth.
+*/
+declare const drizzleTxAtomic: TxAtomicAdapter;
+export { drizzleTxAtomic, drizzleTable, DrizzleTableOpts };