@lunora/server 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/packem_shared/initLunora-CATvPsVt.mjs

@@ -1,86 +0,0 @@
-import { parseValidatorMap } from '@lunora/values';
-import { r as runMiddlewareChain } from './run-middleware-CYQOuoV6.mjs';
-
-const validateArgs = (validators, args) => parseValidatorMap(validators, args, "args");
-
-const runMiddleware = (middlewares, baseContext) => runMiddlewareChain(middlewares, baseContext, (context) => context);
-const makeHandler = (args, middlewares, userHandler, output) => async (context, rawArgs) => {
-  const parsed = validateArgs(args, rawArgs);
-  const resolvedContext = await runMiddleware(middlewares, context);
-  const result = await userHandler({ args: parsed, ctx: resolvedContext });
-  return output ? output.parse(result) : result;
-};
-const makeStreamHandler = (args, middlewares, userHandler) => (context, rawArgs, signal) => {
-  const parsed = validateArgs(args, rawArgs);
-  return (async function* drive() {
-    const resolvedContext = await runMiddleware(middlewares, context);
-    const source = userHandler({ args: parsed, ctx: resolvedContext, signal });
-    const iterator = source[Symbol.asyncIterator]();
-    try {
-      while (true) {
-        if (signal.aborted) {
-          return;
-        }
-        const next = await iterator.next();
-        if (next.done) {
-          return;
-        }
-        if (signal.aborted) {
-          return;
-        }
-        yield next.value;
-      }
-    } finally {
-      await iterator.return?.();
-    }
-  })();
-};
-const makeBuilder = (kind, state, visibility) => {
-  return {
-    __lunoraProcedure: kind,
-    ...visibility ? { __lunoraVisibility: visibility } : {},
-    input: (validators) => makeBuilder(kind, { ...state, args: { ...state.args, ...validators } }, visibility),
-    [kind]: (userHandler) => {
-      return {
-        args: state.args,
-        handler: makeHandler(state.args, state.middlewares, userHandler, state.output),
-        kind,
-        ...visibility ? { visibility } : {}
-      };
-    },
-    output: (validator) => makeBuilder(kind, { ...state, output: validator }, visibility),
-    // `.stream()` is meaningful only on query builders. It's harmless to expose
-    // on every builder shape (callers can't hit it from action/mutation builders
-    // anyway since the type system narrows it away), but emitting it
-    // unconditionally keeps the runtime free of per-kind branching.
-    ...kind === "query" ? {
-      stream: (userHandler) => {
-        return {
-          args: state.args,
-          handler: makeStreamHandler(state.args, state.middlewares, userHandler),
-          kind: "stream",
-          ...visibility ? { visibility } : {}
-        };
-      }
-    } : {},
-    use: (middleware) => makeBuilder(kind, { ...state, middlewares: [...state.middlewares, middleware] }, visibility)
-  };
-};
-const initLunora = {
-  dataModel: () => {
-    return {
-      create: (_options) => {
-        return {
-          action: makeBuilder("action", { args: {}, middlewares: [] }),
-          internalAction: makeBuilder("action", { args: {}, middlewares: [] }, "internal"),
-          internalMutation: makeBuilder("mutation", { args: {}, middlewares: [] }, "internal"),
-          internalQuery: makeBuilder("query", { args: {}, middlewares: [] }, "internal"),
-          mutation: makeBuilder("mutation", { args: {}, middlewares: [] }),
-          query: makeBuilder("query", { args: {}, middlewares: [] })
-        };
-      }
-    };
-  }
-};
-
-export { initLunora };

package/dist/packem_shared/mask-eCUYOwhd.mjs

@@ -1,211 +0,0 @@
-import { LunoraError } from './LunoraError-DhggBJZF.mjs';
-import { bindTableFacade, bindOrm } from './bindOrm-Ce57S3N9.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 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) => {
-    return {
-      collect: async () => {
-        const rows = await reader.collect();
-        return rows.map((row) => maskRow(row, columns, context));
-      },
-      filter: (predicate) => wrapReader(
-        reader.filter((document) => predicate(document)),
-        columns
-      ),
-      first: async () => {
-        const row = await reader.first();
-        return row ? maskRow(row, columns, context) : null;
-      },
-      order: (direction) => wrapReader(reader.order(direction), columns),
-      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;
-      },
-      withIndex: (indexName, range) => wrapReader(reader.withIndex(indexName, range), columns),
-      withSearchIndex: (indexName, search) => wrapReader(reader.withSearchIndex(indexName, search), columns)
-    };
-  };
-  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 wrapped = {
-    ...base,
-    aggregate(tableName, options) {
-      assertReductionAllowed(tableName, [options.field], "aggregate");
-      return base.aggregate(tableName, options);
-    },
-    async findFirst(tableName, args) {
-      const row = await base.findFirst(tableName, args);
-      const columns = perTable.get(tableName);
-      return row && columns ? maskRow(row, columns, context) : row;
-    },
-    async findFirstOrThrow(tableName, args) {
-      const row = await base.findFirstOrThrow(tableName, args);
-      const columns = perTable.get(tableName);
-      return columns ? maskRow(row, columns, context) : row;
-    },
-    async findMany(tableName, args) {
-      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");
-      return base.groupBy(tableName, options);
-    },
-    query(tableName) {
-      const reader = base.query(tableName);
-      const columns = perTable.get(tableName);
-      return columns ? wrapReader(reader, columns) : 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/protectPublic-BjFkQ_Or.mjs

@@ -1,15 +0,0 @@
-import { r as runMiddlewareChain } from './run-middleware-CYQOuoV6.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 };