@lunora/server 1.0.0-alpha.31 → 1.0.0-alpha.32

package/dist/packem_shared/mask-BepaW7YN.mjs

@@ -1,334 +0,0 @@
-import { LunoraError } from './LunoraError-WbxmrpxR.mjs';
-import { bindTableFacade, bindOrm } from './bindOrm-CaY7Wq9Z.mjs';
-
-const permissionName = (permission) => typeof permission === "string" ? permission : permission.name;
-const indexRolePermissions = (roles) => {
-  const map = /* @__PURE__ */ new Map();
-  for (const role of roles ?? []) {
-    map.set(role.name, new Set((role.permissions ?? []).map((permission) => permissionName(permission))));
-  }
-  return map;
-};
-const fnv1aHex = (input) => {
-  let hash = 2166136261;
-  for (let index = 0; index < input.length; index += 1) {
-    hash ^= input.codePointAt(index) ?? 0;
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-};
-const applyStrategy = (strategy, value, context) => {
-  try {
-    if (strategy === "redact") {
-      return null;
-    }
-    if (strategy === "hash") {
-      if (value === null || value === void 0) {
-        return value;
-      }
-      return fnv1aHex(typeof value === "string" ? value : JSON.stringify(value));
-    }
-    return strategy(value, context);
-  } catch {
-    return null;
-  }
-};
-const maskRow = (row, columns, base) => {
-  const out = { ...row };
-  for (const [column, strategy] of Object.entries(columns)) {
-    if (!(column in out)) {
-      continue;
-    }
-    out[column] = applyStrategy(strategy, row[column], { ...base, column, row });
-  }
-  return out;
-};
-const maskPage = (page, columns, base) => {
-  return { ...page, page: page.page.map((row) => maskRow(row, columns, base)) };
-};
-const assertIndexFieldsAllowed = (builderCallback, columns, tableName, method) => {
-  if (typeof builderCallback !== "function") {
-    return;
-  }
-  const referenced = /* @__PURE__ */ new Set();
-  const makeRecorder = () => /* @__PURE__ */ new Proxy(
-    {},
-    {
-      get: () => (field) => {
-        if (typeof field === "string") {
-          referenced.add(field);
-        }
-        return makeRecorder();
-      }
-    }
-  );
-  builderCallback(makeRecorder());
-  for (const field of referenced) {
-    if (field in columns) {
-      throw new LunoraError("MASK_UNSUPPORTED", `${method}() filtering "${tableName}" by masked column "${field}" is not supported`);
-    }
-  }
-};
-const isFacadeEntry = (value) => {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate["findMany"] === "function" && typeof candidate["withSearchIndex"] === "function";
-};
-const wrapDatabase = (base, perTable, context) => {
-  const wrapReader = (reader, columns, tableName) => {
-    return {
-      collect: async () => {
-        const rows = await reader.collect();
-        return rows.map((row) => maskRow(row, columns, context));
-      },
-      // SECURITY (value oracle): the predicate must see the MASKED row, not
-      // the raw stored row — otherwise a caller can `.filter(d => d.ssn ===
-      // guess)` to read the value the mask hides. Masking before the
-      // predicate keeps filtering on non-masked columns working while
-      // redacting masked cells the predicate can observe.
-      filter: (predicate) => wrapReader(
-        reader.filter((document) => predicate(maskRow(document, columns, context))),
-        columns,
-        tableName
-      ),
-      first: async () => {
-        const row = await reader.first();
-        return row ? maskRow(row, columns, context) : null;
-      },
-      order: (direction) => wrapReader(reader.order(direction), columns, tableName),
-      paginate: async (options) => maskPage(await reader.paginate(options), columns, context),
-      take: async (limit) => {
-        const rows = await reader.take(limit);
-        return rows.map((row) => maskRow(row, columns, context));
-      },
-      unique: async () => {
-        const row = await reader.unique();
-        return row ? maskRow(row, columns, context) : null;
-      },
-      // SECURITY (value oracle): reject before delegating when the range /
-      // search references a masked column — an index range or search term
-      // over a masked column is the same value oracle as a masked-column
-      // `where`, so it must fail closed (see `assertIndexFieldsAllowed`).
-      // Reads over NON-masked columns pass through and still mask output.
-      withIndex: (indexName, range) => {
-        assertIndexFieldsAllowed(range, columns, tableName, "withIndex");
-        return wrapReader(reader.withIndex(indexName, range), columns, tableName);
-      },
-      withSearchIndex: (indexName, search) => {
-        assertIndexFieldsAllowed(search, columns, tableName, "withSearchIndex");
-        return wrapReader(reader.withSearchIndex(indexName, search), columns, tableName);
-      },
-      // A geo query's builder (`.near`/`.within`) exposes no column name, so
-      // there's no masked-column value oracle to guard — just mask the output.
-      withGeoIndex: (indexName, build) => wrapReader(reader.withGeoIndex(indexName, build), columns, tableName)
-    };
-  };
-  const locate = async (id, expectedTable) => {
-    if (base.lookupById) {
-      const located = await base.lookupById(id, expectedTable);
-      if (!located) {
-        return { row: null, tableName: void 0 };
-      }
-      return { row: located.row, tableName: perTable.has(located.tableName) ? located.tableName : void 0 };
-    }
-    const row = await base.get(id, expectedTable);
-    if (!row) {
-      return { row: null, tableName: void 0 };
-    }
-    let probeTables;
-    if (expectedTable === void 0) {
-      probeTables = [...perTable.keys()];
-    } else if (perTable.has(expectedTable)) {
-      probeTables = [expectedTable];
-    } else {
-      probeTables = [];
-    }
-    const probes = await Promise.all(
-      probeTables.map(async (tableName) => {
-        const probe = await base.findFirst(tableName, { limit: 1, where: { _id: id } });
-        return probe?.["_id"] === id ? tableName : void 0;
-      })
-    );
-    return { row, tableName: probes.find((entry) => entry !== void 0) };
-  };
-  const assertReductionAllowed = (tableName, fields, method) => {
-    const columns = perTable.get(tableName);
-    if (!columns) {
-      return;
-    }
-    const offending = fields.find((field) => typeof field === "string" && field in columns);
-    if (offending !== void 0) {
-      throw new LunoraError("MASK_UNSUPPORTED", `${method}() over masked column "${offending}" on "${tableName}" is not supported`);
-    }
-  };
-  const collectWhereFields = (where, into) => {
-    if (!where || typeof where !== "object" || Array.isArray(where)) {
-      return;
-    }
-    for (const [key, value] of Object.entries(where)) {
-      if (key === "AND" || key === "OR") {
-        if (Array.isArray(value)) {
-          for (const clause of value) {
-            collectWhereFields(clause, into);
-          }
-        }
-      } else if (key === "NOT") {
-        collectWhereFields(value, into);
-      } else if (!key.startsWith("__")) {
-        into.add(key);
-      }
-    }
-  };
-  const assertWhereAllowed = (tableName, where, method) => {
-    const columns = perTable.get(tableName);
-    if (!columns || where === void 0) {
-      return;
-    }
-    const referenced = /* @__PURE__ */ new Set();
-    collectWhereFields(where, referenced);
-    for (const field of referenced) {
-      if (field in columns) {
-        throw new LunoraError("MASK_UNSUPPORTED", `${method}() filtering "${tableName}" by masked column "${field}" is not supported`);
-      }
-    }
-  };
-  const assertOrderByAllowed = (tableName, orderBy, method) => {
-    const columns = perTable.get(tableName);
-    if (!columns || !Array.isArray(orderBy)) {
-      return;
-    }
-    for (const entry of orderBy) {
-      if (entry && typeof entry === "object" && !Array.isArray(entry)) {
-        for (const field of Object.keys(entry)) {
-          if (field in columns) {
-            throw new LunoraError("MASK_UNSUPPORTED", `${method}() ordering "${tableName}" by masked column "${field}" is not supported`);
-          }
-        }
-      }
-    }
-  };
-  const wrapped = {
-    ...base,
-    async deleteWhere(tableName, where, options) {
-      assertWhereAllowed(tableName, where, "deleteMany({ where })");
-      if (base.deleteWhere === void 0) {
-        throw new LunoraError("INTERNAL", `ctx.db.${tableName}.deleteMany({ where }) is unavailable: this writer has no where-based delete`);
-      }
-      return base.deleteWhere(tableName, where, options);
-    },
-    async patchWhere(tableName, args, options) {
-      assertWhereAllowed(tableName, args.where, "patchMany({ where })");
-      if (base.patchWhere === void 0) {
-        throw new LunoraError("INTERNAL", `ctx.db.${tableName}.patchMany({ where }) is unavailable: this writer has no where-based patch`);
-      }
-      return base.patchWhere(tableName, args, options);
-    },
-    aggregate(tableName, options) {
-      assertReductionAllowed(tableName, [options.field], "aggregate");
-      assertWhereAllowed(tableName, options.where, "aggregate");
-      return base.aggregate(tableName, options);
-    },
-    count(tableName, whereOrArgs) {
-      const wrapper = whereOrArgs && typeof whereOrArgs === "object" && !Array.isArray(whereOrArgs) ? whereOrArgs : void 0;
-      const where = wrapper && ("where" in wrapper || "baseWhere" in wrapper || "restrictsCounts" in wrapper) ? wrapper.where : whereOrArgs;
-      assertWhereAllowed(tableName, where, "count");
-      if (wrapper) {
-        assertWhereAllowed(tableName, wrapper.baseWhere, "count");
-      }
-      return base.count(tableName, whereOrArgs);
-    },
-    async findFirst(tableName, args) {
-      assertWhereAllowed(tableName, args?.where, "findFirst");
-      assertWhereAllowed(tableName, args?.baseWhere, "findFirst");
-      assertOrderByAllowed(tableName, args?.orderBy, "findFirst");
-      const row = await base.findFirst(tableName, args);
-      const columns = perTable.get(tableName);
-      return row && columns ? maskRow(row, columns, context) : row;
-    },
-    async findFirstOrThrow(tableName, args) {
-      assertWhereAllowed(tableName, args?.where, "findFirstOrThrow");
-      assertWhereAllowed(tableName, args?.baseWhere, "findFirstOrThrow");
-      assertOrderByAllowed(tableName, args?.orderBy, "findFirstOrThrow");
-      const row = await base.findFirstOrThrow(tableName, args);
-      const columns = perTable.get(tableName);
-      return columns ? maskRow(row, columns, context) : row;
-    },
-    async findMany(tableName, args) {
-      assertWhereAllowed(tableName, args?.where, "findMany");
-      assertWhereAllowed(tableName, args?.baseWhere, "findMany");
-      assertOrderByAllowed(tableName, args?.orderBy, "findMany");
-      const page = await base.findMany(tableName, args);
-      const columns = perTable.get(tableName);
-      return columns ? maskPage(page, columns, context) : page;
-    },
-    async get(id, expectedTable) {
-      const { row, tableName } = await locate(id, expectedTable);
-      const columns = tableName === void 0 ? void 0 : perTable.get(tableName);
-      if (!row || !columns) {
-        return row;
-      }
-      return maskRow(row, columns, context);
-    },
-    groupBy(tableName, options) {
-      assertReductionAllowed(tableName, [...options.by, options.agg?.field], "groupBy");
-      assertWhereAllowed(tableName, options.where, "groupBy");
-      return base.groupBy(tableName, options);
-    },
-    query(tableName) {
-      const reader = base.query(tableName);
-      const columns = perTable.get(tableName);
-      return columns ? wrapReader(reader, columns, tableName) : reader;
-    },
-    async rankPage(tableName, indexName, options) {
-      const page = await base.rankPage(tableName, indexName, options);
-      const columns = perTable.get(tableName);
-      return columns ? maskPage(page, columns, context) : page;
-    }
-  };
-  const writableFacade = wrapped;
-  for (const tableName of perTable.keys()) {
-    if (isFacadeEntry(base[tableName])) {
-      writableFacade[tableName] = bindTableFacade(wrapped, tableName);
-    }
-  }
-  return wrapped;
-};
-const mask = (policies, options = {}) => {
-  const perTable = new Map(Object.entries(policies));
-  const rolePermissions = indexRolePermissions(options.roles);
-  return async ({ ctx, next }) => {
-    const auth = ctx.auth ?? {};
-    const identity = await auth.getIdentity?.() ?? null;
-    const roles = auth.roles ?? [];
-    const granted = /* @__PURE__ */ new Set();
-    for (const roleName of roles) {
-      for (const name of rolePermissions.get(roleName) ?? []) {
-        granted.add(name);
-      }
-    }
-    const maskContext = {
-      auth: {
-        can: (permission) => granted.has(permissionName(permission)),
-        identity,
-        roles,
-        // eslint-disable-next-line unicorn/no-null -- MaskContext.auth.userId is a public `null | string` type
-        userId: auth.userId ?? null
-      },
-      ctx
-    };
-    if (options.bypass?.(maskContext)) {
-      return next();
-    }
-    const wrapped = wrapDatabase(ctx.db, perTable, maskContext);
-    const extension = { db: wrapped };
-    const { orm } = ctx;
-    if (orm !== null && typeof orm === "object") {
-      extension.orm = bindOrm(wrapped);
-    }
-    return next({ ctx: extension });
-  };
-};
-
-export { mask };

package/dist/packem_shared/onConnect-CIPXKPyw.mjs

@@ -1,13 +0,0 @@
-const wrapLifecycle = (lifecycle, handler) => {
-  return {
-    args: {},
-    handler: (context, event) => handler(context, event),
-    kind: "mutation",
-    lifecycle,
-    visibility: "internal"
-  };
-};
-const onConnect = (handler) => wrapLifecycle("connect", handler);
-const onDisconnect = (handler) => wrapLifecycle("disconnect", handler);
-
-export { onConnect, onDisconnect };

package/dist/packem_shared/policy-tag-DvpVH2tv.mjs

@@ -1,13 +0,0 @@
-const RLS_TAG = /* @__PURE__ */ Symbol.for("lunora.rls.middleware-policies");
-const tagRlsMiddleware = (middleware, tag) => {
-  Object.defineProperty(middleware, RLS_TAG, { configurable: true, enumerable: false, value: tag });
-  return middleware;
-};
-const readRlsTag = (middleware) => {
-  if (middleware === null || typeof middleware !== "function" && typeof middleware !== "object") {
-    return void 0;
-  }
-  return middleware[RLS_TAG];
-};
-
-export { readRlsTag as r, tagRlsMiddleware as t };

package/dist/packem_shared/protectPublic-BlcGpiRc.mjs

@@ -1,15 +0,0 @@
-import { r as runMiddlewareChain } from './run-middleware-I6EiQfxL.mjs';
-
-const protectPublic = (options) => {
-  const chain = [options.rateLimit, options.captcha, ...options.use ?? []].filter(
-    (middleware) => middleware !== void 0
-  );
-  const composed = async ({ ctx, next }) => runMiddlewareChain(
-    chain,
-    ctx,
-    (context) => next({ ctx: context })
-  );
-  return composed;
-};
-
-export { protectPublic };