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

package/src/actions/cancel.ts

@@ -1,8 +1,7 @@
-import { handleParams } from '@owlmeans/server-api'
-import type { AbstractResponse } from '@owlmeans/entrypoint'
-import type { RefedEntrypointHandler } from '@owlmeans/server-entrypoint'
-import type { JobHandlerOptions } from '../types.js'
-import { jobViewer, jobsOf, readOwnedJob } from '../utils/index.js'
+import { handlers } from '@owlmeans/server-api'
+import { UnknownJob } from '@owlmeans/queue'
+import type { Context, JobEntrypoints, JobHandlerOptions } from '../types.js'
+import { jobsOf, readExposedJob } from '../utils/index.js'
 
 /**
  * Cancel a job and answer with what was cancelled.
@@ -15,12 +14,16 @@ import { jobViewer, jobsOf, readOwnedJob } from '../utils/index.js'
  * @throws {UnknownJob}
  */
 export const cancelJob = (
-  opts?: JobHandlerOptions
-): RefedEntrypointHandler<AbstractResponse<any>> =>
-  handleParams<{ id: string }>(async ({ id }, ctx, req) => {
+  protocol: JobEntrypoints['cancel'],
+  opts: JobHandlerOptions
+): ReturnType<ReturnType<typeof handlers<Context>>['params']> =>
+  handlers<Context>().params(protocol, async ({ id }, ctx, req) => {
     const resource = jobsOf(ctx, opts)
-    // Read first: `take` cannot tell whose job it removed, so ownership is settled before it.
-    await readOwnedJob(resource, id, await jobViewer(req, ctx, opts), opts)
-
-    return await resource.take(id)
+    const audience = await opts.policy.audience(req, ctx)
+    const record = await readExposedJob(resource, id, audience, opts)
+    if (opts.policy.cancel == null || !await opts.policy.cancel(record, audience)) {
+      throw new UnknownJob('job')
+    }
+    const removed = await resource.take(record.id as string)
+    return await opts.policy.map(removed, audience)
   })

package/src/actions/get.ts

@@ -1,8 +1,6 @@
-import { handleParams } from '@owlmeans/server-api'
-import type { AbstractResponse } from '@owlmeans/entrypoint'
-import type { RefedEntrypointHandler } from '@owlmeans/server-entrypoint'
-import type { JobHandlerOptions } from '../types.js'
-import { jobViewer, jobsOf, readOwnedJob } from '../utils/index.js'
+import { handlers } from '@owlmeans/server-api'
+import type { Context, JobEntrypoints, JobHandlerOptions } from '../types.js'
+import { jobsOf, readExposedJob } from '../utils/index.js'
 
 /**
  * One job.
@@ -10,10 +8,12 @@ import { jobViewer, jobsOf, readOwnedJob } from '../utils/index.js'
  * @throws {UnknownJob} for an id that is absent AND for one that belongs to someone else.
  */
 export const getJob = (
-  opts?: JobHandlerOptions
-): RefedEntrypointHandler<AbstractResponse<any>> =>
-  handleParams<{ id: string }>(async ({ id }, ctx, req) => {
+  protocol: JobEntrypoints['get'],
+  opts: JobHandlerOptions
+): ReturnType<ReturnType<typeof handlers<Context>>['params']> =>
+  handlers<Context>().params(protocol, async ({ id }, ctx, req) => {
     const resource = jobsOf(ctx, opts)
-
-    return await readOwnedJob(resource, id, await jobViewer(req, ctx, opts), opts)
+    const audience = await opts.policy.audience(req, ctx)
+    const record = await readExposedJob(resource, id, audience, opts)
+    return await opts.policy.map(record, audience)
   })

package/src/actions/list.ts

@@ -1,12 +1,8 @@
-import { handleRequest } from '@owlmeans/server-api'
-import type { AbstractResponse } from '@owlmeans/entrypoint'
-import type { RefedEntrypointHandler } from '@owlmeans/server-entrypoint'
-import type { Criteria } from '@owlmeans/resource'
-import type { JobRecord } from '@owlmeans/queue'
-import type { JobState } from '@owlmeans/queue'
-import { DEFAULT_JOB_SORT } from '../consts.js'
-import type { JobHandlerOptions, JobListQuery } from '../types.js'
-import { jobScope, jobViewer, jobsOf } from '../utils/index.js'
+import { handlers } from '@owlmeans/server-api'
+import type { JobView } from '@owlmeans/job'
+import type { ListResult } from '@owlmeans/resource'
+import type { Context, JobEntrypoints, JobHandlerOptions, JobListQuery } from '../types.js'
+import { jobsOf } from '../utils/index.js'
 
 /**
  * The caller's jobs, newest first.
@@ -17,20 +13,18 @@ import { jobScope, jobViewer, jobsOf } from '../utils/index.js'
  * for this list means the same thing applied to the store the browser holds.
  */
 export const listJobs = (
-  opts?: JobHandlerOptions
-): RefedEntrypointHandler<AbstractResponse<any>> => handleRequest(async (req, ctx) => {
+  protocol: JobEntrypoints['list'],
+  opts: JobHandlerOptions
+): ReturnType<ReturnType<typeof handlers<Context>>['request']> => handlers<Context>().request(protocol, async (req, ctx) => {
   const resource = jobsOf(ctx, opts)
-  const viewer = await jobViewer(req, ctx, opts)
+  const audience = await opts.policy.audience(req, ctx)
   const query = (req.query ?? {}) as JobListQuery
-
-  const where: Criteria<JobRecord> = {
-    ...jobScope(viewer, opts),
-    ...(query.state != null ? { state: query.state as JobState } : {}),
-    ...(query.name != null ? { name: query.name } : {}),
-  }
-
-  return await resource.list(where, {
-    sort: [{ field: DEFAULT_JOB_SORT, order: 'desc' }],
+  const listed = await resource.list(opts.policy.where(audience, query), {
+    sort: [{ field: 'createdAt', order: 'desc' }],
     ...(query.size != null ? { size: query.size, page: query.page ?? 0 } : {}),
   })
+  return {
+    ...listed,
+    items: await Promise.all(listed.items.map(record => opts.policy.map(record, audience))),
+  } satisfies ListResult<JobView>
 })

package/src/actions/watch.ts

@@ -1,18 +1,17 @@
-import { handleConnection } from '@owlmeans/server-socket'
-import type { AbstractResponse } from '@owlmeans/entrypoint'
-import type { RefedEntrypointHandler } from '@owlmeans/server-entrypoint'
+import { connection } from '@owlmeans/server-socket'
 import type { EventMessage } from '@owlmeans/socket'
 import { MessageType } from '@owlmeans/socket'
+import { JOB_EVENT } from '@owlmeans/job'
+import type { JobViewEvent } from '@owlmeans/job'
 import type { JobEvent } from '@owlmeans/queue'
-import { JOB_EVENT } from '../consts.js'
-import type { JobHandlerOptions } from '../types.js'
-import { jobViewer, jobsOf, owns } from '../utils/index.js'
+import type { Context, JobEntrypoints, JobHandlerOptions } from '../types.js'
+import { jobsOf } from '../utils/index.js'
 
 /**
  * Push this caller's job lifecycle events down a socket.
  *
- * The frames are `JobEvent`s exactly as the queue publishes them, under the {@link JOB_EVENT}
- * event name — no shape of this package's own, so a client applies them with the contract types.
+ * Broker events are resolved inside the caller's audience and mapped to {@link JobViewEvent}; raw
+ * queue ids, payloads, failures and ownership fields never cross the socket boundary.
  *
  * **A `JobEvent` carries no owner**, so each one is attributed by reading its job back, and the
  * ids that answered are remembered for the life of the connection. A queue configured with
@@ -21,30 +20,30 @@ import { jobViewer, jobsOf, owns } from '../utils/index.js'
  * rather than fanned out to everyone. Leave completed jobs in place on any queue that is watched.
  */
 export const watchJobs = (
-  opts?: JobHandlerOptions
-): RefedEntrypointHandler<AbstractResponse<any>> => handleConnection(async (conn, ctx, req) => {
+  protocol: JobEntrypoints['watch'],
+  opts: JobHandlerOptions
+): ReturnType<typeof connection> => connection<typeof protocol, Context>(protocol, async (conn, ctx, req) => {
   const resource = jobsOf(ctx, opts)
-  const viewer = await jobViewer(req, ctx, opts)
-  const mine = new Set<string>()
+  const audience = await opts.policy.audience(req, ctx)
+  const publicIds = new Map<string, string>()
 
-  const attributable = async (event: JobEvent): Promise<boolean> => {
-    if (viewer == null || mine.has(event.id)) {
-      return true
+  const project = async (event: JobEvent): Promise<JobViewEvent | null> => {
+    const record = await resource.load({
+      $and: [{ id: event.id }, opts.policy.where(audience, {})],
+    })
+    if (record != null) {
+      const job = await opts.policy.map(record, audience)
+      publicIds.set(event.id, job.id)
+      return { type: 'upsert', job }
     }
-    const record = await resource.load(event.id)
-    if (record == null || !owns(record, viewer, opts)) {
-      return false
-    }
-    mine.add(event.id)
-
-    return true
+    const id = publicIds.get(event.id)
+    return id == null ? null : { type: 'remove', id }
   }
 
   const unsubscribe = await resource.subscribe(async event => {
     try {
-      if (await attributable(event)) {
-        await conn.notify(JOB_EVENT, event)
-      }
+      const projected = await project(event)
+      if (projected != null) await conn.notify(JOB_EVENT, projected)
     } catch (e) {
       console.error('Job watch notify error:', e)
     }

package/src/helper.ts

@@ -1,28 +1,20 @@
-import { elevate } from '@owlmeans/server-entrypoint'
-import type { ServerEntrypoint } from '@owlmeans/server-entrypoint'
-import type { CommonEntrypoint } from '@owlmeans/entrypoint'
-import { jobEntrypointAliases } from './entrypoints.js'
+import { bind } from '@owlmeans/server-entrypoint'
 import { cancelJob, getJob, listJobs, watchJobs } from './actions/index.js'
-import type { JobHandlerOptions } from './types.js'
+import type { JobEntrypoints, JobHandlerOptions } from './types.js'
 
 /**
  * Attach this package's handlers to a group declared by {@link declareJobEntrypoints}.
  *
  * The whole server half of "a long job reports progress to the user's screen" is this call plus
  * the queue driver an app already wires — nothing is subclassed, and an app that wants one
- * handler of its own elevates that alias itself afterwards, since `elevate` replaces in place.
+ * handler of its own binds that alias itself afterwards.
  *
  * @throws {SyntaxError} when the array carries no group under that root.
  */
-export const serveJobEntrypoints = <R>(
-  entrypoints: (CommonEntrypoint | ServerEntrypoint<R>)[], root: string, opts?: JobHandlerOptions
-): ServerEntrypoint<R>[] => {
-  const aliases = jobEntrypointAliases(root)
-
-  elevate(entrypoints, aliases.base)
-  elevate(entrypoints, aliases.list, listJobs(opts))
-  elevate(entrypoints, aliases.watch, watchJobs(opts))
-  elevate(entrypoints, aliases.get, getJob(opts))
-
-  return elevate(entrypoints, aliases.cancel, cancelJob(opts))
-}
+export const serveJobEntrypoints = (entrypoints: JobEntrypoints, opts: JobHandlerOptions) => [
+  bind(entrypoints.base),
+  bind(entrypoints.list, listJobs(entrypoints.list, opts)),
+  bind(entrypoints.watch, watchJobs(entrypoints.watch, opts)),
+  bind(entrypoints.get, getJob(entrypoints.get, opts)),
+  bind(entrypoints.cancel, cancelJob(entrypoints.cancel, opts)),
+]

package/src/index.ts

@@ -1,8 +1,5 @@
 export type * from './types.js'
 
-export * from './consts.js'
-export * from './schemas.js'
-export * from './entrypoints.js'
 export * from './helper.js'
 export * from './actions/index.js'
 export * from './utils/index.js'

package/src/types.ts

@@ -1,6 +1,8 @@
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
 import type { AbstractRequest } from '@owlmeans/entrypoint'
-import type { QueueAppend, QueueConfig } from '@owlmeans/queue'
+import type { JobEntrypoints, JobListQuery, JobView } from '@owlmeans/job'
+import type { JobRecord, QueueAppend, QueueConfig, QueueResource } from '@owlmeans/queue'
+import type { Criteria } from '@owlmeans/resource'
 import type { ApiServerAppend } from '@owlmeans/server-api'
 import type { ServerConfig, ServerContext } from '@owlmeans/server-context'
 
@@ -11,56 +13,27 @@ export interface Config extends ServerConfig {
 export interface Context<C extends Config = Config> extends ServerContext<C>,
   ApiServerAppend, QueueAppend { }
 
-/** The alias every entrypoint of one job group answers under, derived from the group's root. */
-export interface JobEntrypointAliases {
-  base: string
-  list: string
-  get: string
-  cancel: string
-  watch: string
-}
-
-export interface JobEntrypointOptions {
-  /** The path segment the group answers under. Defaults to `/jobs`. */
-  path?: string
-  /** The entrypoint the group hangs under — an app's API base. Top level when omitted. */
-  parent?: string
-  /** The service route the group answers on, when it is not this app's own. */
-  service?: string
-  /**
-   * The guard the group's base carries, and every entrypoint under it inherits.
-   *
-   * `DEFAULT_GUARD` unless told otherwise, because ownership is derived from the authenticated
-   * subject and an unguarded declaration has no subject to derive it from. Pass `null` only for a
-   * group that is scoped some other way — its handlers then answer `AuthorizationError`.
-   */
-  guard?: string | null
-}
+export type JobAudience = Record<string, unknown>
 
-/** The list entrypoint's query, as it travels on the wire. */
-export interface JobListQuery {
-  state?: string
-  name?: string
-  page?: number
-  size?: number
+/** Required application policy at the raw-broker to public-domain boundary. */
+export interface JobExposurePolicy<A extends JobAudience = JobAudience> {
+  audience: (req: AbstractRequest, ctx: BasicContext<BasicConfig>) => A | Promise<A>
+  /** Translate public filters and authenticated scope into broker criteria. */
+  where: (audience: A, query: JobListQuery) => Criteria<JobRecord>
+  /** Resolve an opaque public id within the authenticated scope. */
+  lookup: (
+    id: string, audience: A, resource: QueueResource
+  ) => Promise<JobRecord | null>
+  /** Allowlist and map a scoped broker record into its public representation. */
+  map: (record: JobRecord, audience: A) => JobView | Promise<JobView>
+  /** Cancellation is unavailable unless this callback is present and approves the record. */
+  cancel?: (record: JobRecord, audience: A) => boolean | Promise<boolean>
 }
 
-/**
- * A request that may read the queue unscoped.
- *
- * A predicate rather than a permission name: which permission, gate or role means "operator" is
- * the application's decision, and hardcoding one here would make every deployment that names it
- * differently patch this package.
- */
-export interface JobAdminCheck {
-  (req: AbstractRequest, ctx: BasicContext<BasicConfig>): boolean | Promise<boolean>
-}
-
-export interface JobHandlerOptions {
+export interface JobHandlerOptions<A extends JobAudience = JobAudience> {
   /** Which declared queue these handlers read. The context's sole queue when omitted. */
   queue?: string
-  /** The field inside `JobRecord.data` that names the owner. Defaults to `owner`. */
-  ownerField?: string
-  /** The escape hatch — see {@link JobAdminCheck}. Nothing is unscoped without one. */
-  admin?: JobAdminCheck
+  policy: JobExposurePolicy<A>
 }
+
+export type { JobEntrypoints, JobListQuery }

package/src/utils/index.ts

@@ -1,2 +1,2 @@
-export * from './owner.js'
-export * from './resource.js'
+export * from './policy.js'
+export * from './view.js'

package/src/utils/policy.ts

@@ -0,0 +1,20 @@
+import type { BasicConfig, BasicContext } from '@owlmeans/context'
+import type { JobRecord, QueueResource } from '@owlmeans/queue'
+import { UnknownJob } from '@owlmeans/queue'
+import type { Context, JobAudience, JobHandlerOptions } from '../types.js'
+
+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)
+
+/** Resolve an opaque id without revealing whether it exists outside the current audience. */
+export const readExposedJob = async <A extends JobAudience>(
+  resource: QueueResource,
+  id: string,
+  audience: A,
+  opts: JobHandlerOptions<A>,
+): Promise<JobRecord> => {
+  const record = await opts.policy.lookup(id, audience, resource)
+  if (record == null) throw new UnknownJob('job')
+  return record
+}

package/src/utils/view.ts

@@ -0,0 +1,102 @@
+import { JobViewStatus } from '@owlmeans/job'
+import type { JobJson, JobProgressView, JobView, PublicJobError } from '@owlmeans/job'
+import { JobState } from '@owlmeans/queue'
+import type { JobRecord } from '@owlmeans/queue'
+
+export interface JobViewFields {
+  id: string
+  kind: string
+  summary?: string
+  metadata?: Record<string, JobJson>
+  result?: JobJson
+  error?: PublicJobError
+  cancellable?: boolean
+}
+
+const MAX_JSON_DEPTH = 8
+const MAX_JSON_ITEMS = 100
+const MAX_JSON_STRING = 16_384
+const FORBIDDEN_KEYS = new Set(['__proto__', 'prototype', 'constructor'])
+
+/** Copy JSON through bounded, prototype-free containers and discard every non-JSON value. */
+export const sanitizeJobJson = (value: unknown, depth: number = 0): JobJson | undefined => {
+  if (depth > MAX_JSON_DEPTH) return undefined
+  if (value == null || typeof value === 'boolean' || typeof value === 'string') {
+    return typeof value === 'string' ? value.slice(0, MAX_JSON_STRING) : value
+  }
+  if (typeof value === 'number') return Number.isFinite(value) ? value : undefined
+  if (Array.isArray(value)) {
+    return value.slice(0, MAX_JSON_ITEMS)
+      .map(item => sanitizeJobJson(item, depth + 1))
+      .filter((item): item is JobJson => item !== undefined)
+  }
+  if (typeof value !== 'object') return undefined
+
+  const result: Record<string, JobJson> = Object.create(null) as Record<string, JobJson>
+  for (const [key, item] of Object.entries(value).slice(0, MAX_JSON_ITEMS)) {
+    if (FORBIDDEN_KEYS.has(key)) continue
+    const safe = sanitizeJobJson(item, depth + 1)
+    if (safe !== undefined) result[key] = safe
+  }
+  return result
+}
+
+const sanitizeError = (error: PublicJobError | undefined): PublicJobError | undefined => error == null
+  ? undefined
+  : {
+      type: error.type.slice(0, 128),
+      message: error.message.slice(0, 2048),
+    }
+
+const statusOf = (state?: JobState): JobViewStatus => {
+  switch (state) {
+    case JobState.Active: return JobViewStatus.Running
+    case JobState.Completed: return JobViewStatus.Succeeded
+    case JobState.Failed: return JobViewStatus.Failed
+    default: return JobViewStatus.Queued
+  }
+}
+
+const progressOf = (value: unknown): JobProgressView | undefined => {
+  if (typeof value === 'number' && Number.isFinite(value)) return { percent: value }
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) return undefined
+  const raw = value as Record<string, unknown>
+  const progress: JobProgressView = {}
+  if (typeof raw.percent === 'number' && Number.isFinite(raw.percent)) progress.percent = raw.percent
+  if (typeof raw.done === 'number' && Number.isFinite(raw.done)) progress.done = raw.done
+  if (typeof raw.total === 'number' && Number.isFinite(raw.total)) progress.total = raw.total
+  if (typeof raw.message === 'string') progress.message = raw.message.slice(0, 512)
+  return Object.keys(progress).length === 0 ? undefined : progress
+}
+
+/** Build a public view from fields an application explicitly allowlisted. */
+export const jobViewOf = (record: JobRecord, fields: JobViewFields): JobView => {
+  const createdAt = record.createdAt ?? new Date(0).toISOString()
+  const updatedAt = record.finishedAt ?? record.startedAt ?? createdAt
+  const progress = progressOf(record.progress)
+  const metadata = sanitizeJobJson(fields.metadata)
+  const result = sanitizeJobJson(fields.result)
+  const error = sanitizeError(fields.error)
+  return {
+    id: fields.id,
+    kind: fields.kind.slice(0, 128),
+    status: statusOf(record.state),
+    ...(progress == null ? {} : { progress }),
+    ...(fields.summary == null ? {} : { summary: fields.summary.slice(0, 2048) }),
+    ...(metadata == null || Array.isArray(metadata) || typeof metadata !== 'object'
+      ? {} : { metadata }),
+    ...(result === undefined ? {} : { result }),
+    ...(error == null ? {} : { error }),
+    cancellable: fields.cancellable ?? false,
+    createdAt,
+    updatedAt,
+    ...(record.startedAt == null ? {} : { startedAt: record.startedAt }),
+    ...(record.finishedAt == null ? {} : { finishedAt: record.finishedAt }),
+  }
+}
+
+/** Safe default for a broker failure; raw reasons and stacks never cross the boundary. */
+export const publicJobError = (type: string = 'job-failed'): PublicJobError => ({
+  type,
+  message: 'The background operation failed.',
+})

package/tests/view.spec.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from 'bun:test'
+import { JobViewStatus } from '@owlmeans/job'
+import { JobState } from '@owlmeans/queue'
+import { jobViewOf, publicJobError, sanitizeJobJson } from '../src/utils/view.js'
+
+describe('@owlmeans/server-job — public projection boundary', () => {
+  test('maps only allowlisted fields and never copies a broker payload or raw failure', () => {
+    const view = jobViewOf({
+      id: 'broker-id', queue: 'private-lane', name: 'internal:build',
+      data: { accessToken: 'secret' }, error: 'stack and connection string',
+      state: JobState.Failed, progress: { percent: 65, secret: 'drop' },
+      createdAt: '2026-09-18T10:00:00.000Z', finishedAt: '2026-09-18T10:01:00.000Z',
+    }, {
+      id: 'opaque-id', kind: 'export', summary: 'Export failed',
+      error: publicJobError('export-failed'),
+    })
+
+    expect(view).toMatchObject({
+      id: 'opaque-id', kind: 'export', status: JobViewStatus.Failed,
+      progress: { percent: 65 }, error: {
+        type: 'export-failed', message: 'The background operation failed.',
+      },
+    })
+    expect(view).not.toHaveProperty('queue')
+    expect(view).not.toHaveProperty('name')
+    expect(view).not.toHaveProperty('data')
+  })
+
+  test('copies public JSON into bounded prototype-free values and drops executable data', () => {
+    const input = Object.create({ inherited: 'drop' }) as Record<string, unknown>
+    input.visible = { ok: true, fn: () => 'drop', infinity: Number.POSITIVE_INFINITY }
+    input.list = [1, undefined, Symbol('drop'), 'kept']
+
+    const sanitized = sanitizeJobJson(input) as Record<string, unknown>
+    expect(sanitized).toEqual({ visible: { ok: true }, list: [1, 'kept'] })
+    expect(Object.getPrototypeOf(sanitized)).toBeNull()
+    expect(sanitized).not.toHaveProperty('inherited')
+  })
+
+  test('caps public text before it reaches a serializer or a browser store', () => {
+    const view = jobViewOf({
+      id: 'raw', queue: 'lane', name: 'internal', state: JobState.Active,
+      progress: { message: 'm'.repeat(900) },
+    }, {
+      id: 'public', kind: 'k'.repeat(200), summary: 's'.repeat(3_000),
+      error: { type: 't'.repeat(200), message: 'e'.repeat(3_000) },
+    })
+
+    expect(view.kind).toHaveLength(128)
+    expect(view.summary).toHaveLength(2048)
+    expect(view.progress?.message).toHaveLength(512)
+    expect(view.error?.type).toHaveLength(128)
+    expect(view.error?.message).toHaveLength(2048)
+  })
+})

package/src/consts.ts

@@ -1,28 +0,0 @@
-/**
- * The alias root a target app gets when its declaration names none, and the path segment the
- * group answers under.
- */
-export const DEFAULT_JOB_ROOT = 'jobs'
-export const DEFAULT_JOB_PATH = '/jobs'
-
-/**
- * Where the owner is recorded inside a job's payload.
- *
- * A `JobRecord` has no owner column — the broker keeps only what the contract declares — so the
- * producer writes the subject into the job's own `data`, and every read here filters on
- * `data.<field>`. Change it per declaration when the app's payloads already name the subject
- * something else.
- */
-export const DEFAULT_OWNER_FIELD = 'owner'
-
-/**
- * The socket event a `JobEvent` frame is pushed under.
- *
- * This name, and the `<root>:<verb>` alias shape in `entrypoints.ts`, are the whole contract
- * between this package and `@owlmeans/client-job` — the two halves cannot share a module without
- * dragging fastify into a browser bundle, so they each state it and the skills pin it.
- */
-export const JOB_EVENT = 'job-event'
-
-/** Newest first: a job list is read to see what is happening now. */
-export const DEFAULT_JOB_SORT = 'createdAt'

package/src/entrypoints.ts

@@ -1,56 +0,0 @@
-import { entrypoint, filter, guard, query } from '@owlmeans/entrypoint'
-import type { CommonEntrypoint } from '@owlmeans/entrypoint'
-import { backend, route, RouteMethod, socket } from '@owlmeans/route'
-import type { RouteOptions } from '@owlmeans/route'
-import { DEFAULT_GUARD } from '@owlmeans/auth-common'
-import { DEFAULT_JOB_PATH } from './consts.js'
-import { JobListQuerySchema } from './schemas.js'
-import type { JobEntrypointAliases, JobEntrypointOptions } from './types.js'
-
-/**
- * The aliases one job group answers under.
- *
- * The shape — `<root>` and `<root>:<verb>` — is the contract `@owlmeans/client-job` addresses the
- * same group by, so a group renamed here is renamed there by passing the same root.
- */
-export const jobEntrypointAliases = (root: string): JobEntrypointAliases => ({
-  base: root,
-  list: `${root}:list`,
-  get: `${root}:get`,
-  cancel: `${root}:cancel`,
-  watch: `${root}:watch`,
-})
-
-/**
- * Declare the list/get/cancel/watch entrypoints of one job group.
- *
- * It belongs in the SHARED package of a target app — the one both the API and the browser import —
- * so that the server elevates and the client calls the very declarations, and neither side ever
- * writes a path. Declaring a second group is the same call with another root.
- *
- * The guard rides on the base alone: guards are inherited, so stating it once is what keeps the
- * four from drifting apart.
- */
-export const declareJobEntrypoints = (
-  root: string, opts?: JobEntrypointOptions
-): CommonEntrypoint[] => {
-  const aliases = jobEntrypointAliases(root)
-  const base: Partial<RouteOptions> = {
-    ...(opts?.parent != null ? { parent: opts.parent } : {}),
-    ...(opts?.service != null ? { service: opts.service } : {}),
-  }
-  const guarded = opts?.guard === null ? undefined : guard(opts?.guard ?? DEFAULT_GUARD)
-
-  return [
-    entrypoint(route(aliases.base, opts?.path ?? DEFAULT_JOB_PATH, backend(base)), guarded),
-    entrypoint(
-      route(aliases.list, '/', backend(aliases.base)),
-      filter(query(JobListQuerySchema))
-    ),
-    // Static before parametric, so `/watch` is not swallowed by `/:id`. The router picks the
-    // static branch on its own; the order here is for whoever reads the declaration.
-    entrypoint(route(aliases.watch, '/watch', socket(aliases.base))),
-    entrypoint(route(aliases.get, '/:id', backend(aliases.base))),
-    entrypoint(route(aliases.cancel, '/:id', backend(aliases.base, RouteMethod.DELETE))),
-  ]
-}

package/src/schemas.ts

@@ -1,19 +0,0 @@
-import type { JSONSchemaType } from 'ajv'
-import type { JobListQuery } from './types.js'
-
-/**
- * Every field is optional: a list screen opens before it has a filter, and a caller that knows
- * nothing about jobs must still get the page it is allowed to see. `state` and `name` are left as
- * plain strings rather than enums so that a driver reporting a state this line does not know
- * narrows the list instead of failing the request.
- */
-export const JobListQuerySchema: JSONSchemaType<JobListQuery> = {
-  type: 'object',
-  properties: {
-    state: { type: 'string', maxLength: 32, nullable: true },
-    name: { type: 'string', maxLength: 256, nullable: true },
-    page: { type: 'integer', minimum: 0, nullable: true },
-    size: { type: 'integer', minimum: 1, maximum: 200, nullable: true },
-  },
-  additionalProperties: true,
-}