@owlmeans/server-job 0.1.18-rc.2 → 0.1.18-rc.21

package/src/utils/owner.ts

@@ -1,60 +0,0 @@
-import type { BasicConfig, BasicContext } from '@owlmeans/context'
-import type { AbstractRequest } from '@owlmeans/entrypoint'
-import { AuthorizationError } from '@owlmeans/auth'
-import type { Criteria } from '@owlmeans/resource'
-import type { JobRecord } from '@owlmeans/queue'
-import { DEFAULT_OWNER_FIELD } from '../consts.js'
-import type { JobHandlerOptions } from '../types.js'
-
-/**
- * The subject a job is attributed to.
- *
- * Profile first, user second — the same pair `@owlmeans/server-socket` addresses a connection by,
- * so a job enqueued for one profile of a multi-profile account is not visible to the others.
- */
-export const jobOwnerOf = (req: AbstractRequest): string | undefined =>
-  req.auth?.profileId ?? req.auth?.userId
-
-/**
- * @throws {AuthorizationError} when the request carries no authenticated subject.
- */
-export const requireJobOwner = (req: AbstractRequest): string => {
-  const owner = jobOwnerOf(req)
-  if (owner == null || owner === '') {
-    throw new AuthorizationError()
-  }
-
-  return owner
-}
-
-export const ownerFieldOf = (opts?: JobHandlerOptions): string =>
-  opts?.ownerField ?? DEFAULT_OWNER_FIELD
-
-/** What one record says its owner is — the payload's own field, never a broker one. */
-export const ownerOf = (record: JobRecord, opts?: JobHandlerOptions): unknown =>
-  (record.data as Record<string, unknown> | undefined)?.[ownerFieldOf(opts)]
-
-/**
- * Who this request reads the queue as: the owner every record must name, or `undefined` for a
- * request that reads it unscoped.
- *
- * `undefined` is reachable only through {@link JobHandlerOptions.admin}. Absent an admin check
- * every read is narrowed to the caller's own jobs and an anonymous request is refused, so a group
- * wired with no options at all is scoped rather than open.
- *
- * @throws {AuthorizationError}
- */
-export const jobViewer = async <C extends BasicConfig, T extends BasicContext<C>>(
-  req: AbstractRequest, ctx: T, opts?: JobHandlerOptions
-): Promise<string | undefined> => {
-  if (opts?.admin != null && await opts.admin(req, ctx as BasicContext<BasicConfig>)) {
-    return undefined
-  }
-
-  return requireJobOwner(req)
-}
-
-/** The criteria one viewer reads the queue through; nothing to add when they read it unscoped. */
-export const jobScope = (
-  viewer: string | undefined, opts?: JobHandlerOptions
-): Criteria<JobRecord> => viewer == null ? {} : { [`data.${ownerFieldOf(opts)}`]: viewer }

package/src/utils/resource.ts

@@ -1,40 +0,0 @@
-import type { BasicConfig, BasicContext } from '@owlmeans/context'
-import type { JobRecord, QueueResource } from '@owlmeans/queue'
-import { UnknownJob } from '@owlmeans/queue'
-import type { Context, JobHandlerOptions } from '../types.js'
-import { ownerOf } from './owner.js'
-
-/**
- * The queue these handlers read.
- *
- * Named by the declaration or, with nothing named, the context's sole declared queue — which
- * `ctx.jobs()` refuses to guess once a second queue exists, so an app that grows one is told to
- * name it rather than quietly served the wrong backlog.
- */
-export const jobsOf = <D = unknown, R = unknown>(
-  ctx: BasicContext<BasicConfig>, opts?: JobHandlerOptions
-): QueueResource<D, R> => (ctx as unknown as Context).jobs<D, R>(opts?.queue)
-
-/** Does this viewer own that record? An unscoped viewer (`undefined`) owns everything. */
-export const owns = (
-  record: JobRecord, viewer: string | undefined, opts?: JobHandlerOptions
-): boolean => viewer == null || ownerOf(record, opts) === viewer
-
-/**
- * One job, as this viewer is allowed to see it.
- *
- * A job that exists but belongs to someone else answers exactly as an absent one does: telling an
- * unauthorized caller apart from a wrong id is what turns an id space into an enumeration oracle.
- *
- * @throws {UnknownJob}
- */
-export const readOwnedJob = async <D = unknown, R = unknown>(
-  resource: QueueResource<D, R>, id: string, viewer: string | undefined, opts?: JobHandlerOptions
-): Promise<JobRecord<D, R>> => {
-  const record = await resource.load(id)
-  if (record == null || !owns(record, viewer, opts)) {
-    throw new UnknownJob(`${resource.queue}:${id}`)
-  }
-
-  return record
-}