@nocobase/app-plugin-office-flows-example 0.0.0-stage → 0.1.0-beta.0

package/dist/server/providers/office-flows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"office-flows.d.ts","sourceRoot":"","sources":["../../../server/providers/office-flows.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAUzE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAQ7D,2EAA2E;AAC3E,eAAO,MAAM,QAAQ,EAAE,MAAe,CAAC;AAEvC;;;;;;GAMG;AACH,qBAAa,mBAAoB,SAAQ,eAAe,CAAC,oBAAoB,CAAC;IAC5E,SAAgB,IAAI,EAAE,MAAM,CAAsB;IAClD,OAAO,CAAC,IAAI,CAA4B;IACxC,OAAO,CAAC,OAAO,CAA+B;IAE9B,QAAQ,IAAI,IAAI;IAWV,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/C,OAAO,CAAC,gBAAgB;IAwBxB,+DAA+D;IAC/D,OAAO,CAAC,UAAU;CA0BnB"}

package/dist/server/providers/office-flows.js

@@ -0,0 +1,90 @@
+import { jobExecutorServiceToken } from '@nocobase/app-server/jobs';
+import { loggingToken } from '@nocobase/app-server/logging';
+import { databaseManagerToken } from '@nocobase/db';
+import { createRepositoryLifecycleStore, LifecycleRuntime, } from '@nocobase/lifecycle';
+import { createLifecycleJobs, } from '@nocobase/lifecycle/jobs';
+import { ServiceProvider } from '@nocobase/service-provider';
+import { registerLifecycles } from '../lifecycles/index.js';
+import { COLLECTIONS, OFFICE_FLOWS_SCOPE } from '../scope.js';
+import { OfficeFlowsService } from '../services/office-flows.js';
+import { OfficeStore } from '../services/store.js';
+import { officeFlowsServiceToken } from '../tokens.js';
+/** How often idle records are checked and due extraction tasks created. */
+export const SWEEP_MS = 60_000;
+/**
+ * Wires the six lifecycles to the application through `createLifecycleJobs()`:
+ * effects as jobs on a JobExecutor, and one ScheduleExecutor rule that sweeps
+ * the triggers and creates the extraction tasks falling due. A real
+ * deployment would sweep once a day; the example sweeps every minute so a new
+ * request shows its first task without waiting.
+ */
+export class OfficeFlowsProvider extends ServiceProvider {
+    name = OFFICE_FLOWS_SCOPE;
+    jobs;
+    runtime;
+    register() {
+        this.app.container.singleton(officeFlowsServiceToken, () => {
+            const database = this.app.container.resolve(databaseManagerToken);
+            return new OfficeFlowsService(database, this.lifecycleRuntime(), new OfficeStore(database));
+        });
+    }
+    async start() {
+        await this.effectJobs().start(this.lifecycleRuntime());
+    }
+    async shutdown() {
+        await this.jobs?.shutdown();
+        this.jobs = undefined;
+    }
+    lifecycleRuntime() {
+        if (this.runtime)
+            return this.runtime;
+        const database = this.app.container.resolve(databaseManagerToken);
+        const logger = this.app.container
+            .resolve(loggingToken)
+            .getLogger('office-flows-example');
+        const runtime = new LifecycleRuntime({
+            store: createRepositoryLifecycleStore(database, {
+                collections: {
+                    transitions: COLLECTIONS.transitions,
+                    effectRuns: COLLECTIONS.effectRuns,
+                },
+            }),
+            dispatcher: this.effectJobs(),
+            logger: {
+                warn: (message, details) => logger.warn({ details }, message),
+                error: (message, details) => logger.error({ details }, message),
+            },
+        });
+        registerLifecycles(runtime, new OfficeStore(database));
+        this.runtime = runtime;
+        return runtime;
+    }
+    /** The dispatcher, created before the runtime that uses it. */
+    effectJobs() {
+        if (this.jobs)
+            return this.jobs;
+        const executors = this.app.container.resolve(jobExecutorServiceToken);
+        const logger = this.app.container
+            .resolve(loggingToken)
+            .getLogger('office-flows-example');
+        this.jobs = createLifecycleJobs({
+            jobs: executors.getJobExecutor(OFFICE_FLOWS_SCOPE),
+            schedule: executors.getScheduleExecutor(OFFICE_FLOWS_SCOPE),
+            // Stored with every queued task: keep it stable.
+            jobName: `${OFFICE_FLOWS_SCOPE}/effect`,
+            sweepName: 'sweep',
+            sweepEveryMs: SWEEP_MS,
+            // The extraction tasks due today, after the triggers have run.
+            onSweep: () => this.app.container
+                .resolve(officeFlowsServiceToken)
+                .runSchedule()
+                .then(() => undefined),
+            logger: {
+                warn: (message, details) => logger.warn({ details }, message),
+                error: (message, details) => logger.error({ details }, message),
+            },
+        });
+        return this.jobs;
+    }
+}
+//# sourceMappingURL=office-flows.js.map

package/dist/server/providers/office-flows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"office-flows.js","sourceRoot":"","sources":["../../../server/providers/office-flows.ts"],"names":[],"mappings":"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"}

package/dist/server/routes/index.d.ts

@@ -0,0 +1,8 @@
+import type { AppPluginApplication } from '@nocobase/app-server/plugins';
+import { type AppApiRouteContribution } from '@nocobase/app-server/router';
+/** The namespace of every route this plugin owns, and the domain of its errors. */
+export declare const OFFICE_FLOWS_DOMAIN: string;
+export declare const apiRoutes: AppApiRouteContribution<AppPluginApplication>;
+declare const routes: readonly AppApiRouteContribution<AppPluginApplication>[];
+export default routes;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/routes/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAWL,KAAK,uBAAuB,EAC7B,MAAM,6BAA6B,CAAC;AAsCrC,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,EAAE,MAA4B,CAAC;AAoH/D,eAAO,MAAM,SAAS,EAAE,uBAAuB,CAAC,oBAAoB,CA4tBhE,CAAC;AAEL,QAAA,MAAM,MAAM,EAAE,SAAS,uBAAuB,CAAC,oBAAoB,CAAC,EAEnE,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/server/routes/index.js

@@ -0,0 +1,553 @@
+import { authenticationToken, } from '@nocobase/app-plugin-authentication';
+import { ApiError, apiErrorHandler, apiErrorResponse, apiValidator, dataResponse, defineApiRoutes, describeRoute, emptyResponse, listResponse, } from '@nocobase/app-server/router';
+import { LifecycleError, lifecycleErrorFields } from '@nocobase/lifecycle';
+import { Hono } from 'hono';
+import { emptyDataRequest, } from '../../shared/data-request.js';
+import { OFFICE_FLOWS_ROUTES } from '../../shared/routes.js';
+import { OfficeFlowsError } from '../services/office-flows.js';
+import { officeFlowsServiceToken } from '../tokens.js';
+import { ActAsPageQuery, ActAsQuery, Created, CreateExtractionInput, DataRequestFormInput, DispatchingTaskParams, ExtractionParams, ExtractionValuesInput, FireInput, IncomingParams, IncomingValuesInput, ManagementRowInput, OfficeConfig, OfficeDetail, OfficeRecord, PageMeta, PageQuery, RequestParams, RowInput, RowParams, ScheduleRun, TaskParams, TaskValuesInput, } from './schemas.js';
+/** The namespace of every route this plugin owns, and the domain of its errors. */
+export const OFFICE_FLOWS_DOMAIN = OFFICE_FLOWS_ROUTES;
+/** Every route below starts here; the client reads the same constant. */
+const BASE = `/${OFFICE_FLOWS_ROUTES}`;
+/** Every route of this plugin is listed under one tag in the API document at `/api/swagger/docs`. */
+const tags = ['OfficeFlowsExample'];
+const SERVICE_STATUS = {
+    NOT_FOUND: 'NOT_FOUND',
+    FORBIDDEN: 'PERMISSION_DENIED',
+    INVALID: 'INVALID_ARGUMENT',
+    LOCKED: 'FAILED_PRECONDITION',
+    CONFLICT: 'ABORTED',
+};
+/**
+ * The service's refusals and the lifecycles', as the standard error body.
+ * `inputField` names where a transition's input sits in the request body.
+ */
+function toApiError(error, inputField) {
+    if (error instanceof LifecycleError) {
+        const fields = lifecycleErrorFields(error, inputField ? { inputField } : {});
+        // A broken definition is the server's fault: the application answers 500.
+        return fields
+            ? new ApiError({ ...fields, domain: OFFICE_FLOWS_DOMAIN })
+            : error;
+    }
+    if (error instanceof OfficeFlowsError)
+        return new ApiError({
+            status: SERVICE_STATUS[error.code],
+            reason: error.reason,
+            domain: OFFICE_FLOWS_DOMAIN,
+            message: error.message,
+            ...(error.fields.length
+                ? {
+                    fieldViolations: error.fields.map((field) => ({
+                        field,
+                        description: error.message,
+                    })),
+                }
+                : {}),
+        });
+    return error;
+}
+/**
+ * A value as a response carries it: every id — `id` and each `…Id` — a
+ * string, since the collections' integer keys would otherwise reach a
+ * client as numbers.
+ */
+function outward(value) {
+    if (Array.isArray(value))
+        return value.map(outward);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, field]) => [
+        key,
+        (key === 'id' || key.endsWith('Id')) && typeof field === 'number'
+            ? String(field)
+            : outward(field),
+    ]));
+}
+const data = (value) => ({
+    data: outward(value),
+});
+function page(result, query) {
+    return {
+        data: outward(result.records),
+        meta: { page: query.page, pageSize: query.pageSize, total: result.total },
+    };
+}
+/** A new request's form: a field the request leaves out starts empty. */
+function form(values) {
+    return { ...emptyDataRequest(), ...values };
+}
+const noContent = emptyResponse();
+const unauthorized = apiErrorResponse(401);
+const internal = apiErrorResponse(500);
+const notFound = apiErrorResponse(404, 'No such record (`RECORD_NOT_FOUND`).');
+const fireRefusals = {
+    400: apiErrorResponse(400, 'The state does not allow it, or the record is not complete enough (`INVALID_STATE`); every guard that refused waits for the record to change (`GUARD_REJECTED`, status `FAILED_PRECONDITION`), such as an open extraction task; its input is invalid (`INVALID_INPUT`) or the transition is unknown (`UNKNOWN_TRANSITION`).'),
+    403: apiErrorResponse(403, 'A guard refused the persona while others may still act (`GUARD_REJECTED`), such as a clerk who has already countersigned.'),
+    409: apiErrorResponse(409, 'A concurrent change won (`CONFLICT`).'),
+};
+const editRefusals = {
+    400: apiErrorResponse(400, 'The record cannot be edited at this step (`RECORD_LOCKED`).'),
+    403: apiErrorResponse(403, 'The persona cannot edit it (`EDIT_NOT_ALLOWED`).'),
+    409: apiErrorResponse(409, 'Concurrent changes kept winning; the edit was reapplied and gave up (`RECORD_CHANGED`).'),
+};
+export const apiRoutes = defineApiRoutes(({ container }) => {
+    const router = new Hono();
+    const authentication = container.resolve(authenticationToken);
+    const service = container.resolve(officeFlowsServiceToken);
+    const fire = async (work) => {
+        try {
+            await work();
+        }
+        catch (error) {
+            // The transition's input sits under `input` in these bodies.
+            throw toApiError(error, 'input');
+        }
+    };
+    router.use(`${BASE}/*`, authentication.required());
+    router.onError((error, context) => apiErrorHandler(toApiError(error), context));
+    // ── Reference data and the persona's reminders ──────────────────────
+    router.get(`${BASE}/config`, describeRoute({
+        tags,
+        summary: 'Get the reference data',
+        operationId: 'officeFlowsExampleGetConfig',
+        description: 'The cast and its roles, the departments, the management groups and the holidays.',
+        responses: {
+            200: dataResponse(OfficeConfig),
+            401: unauthorized,
+            500: internal,
+        },
+    }), async (context) => context.json(data(await service.config())));
+    router.get(`${BASE}/notices`, describeRoute({
+        tags,
+        summary: 'List the persona’s reminders',
+        operationId: 'officeFlowsExampleListNotices',
+        responses: {
+            200: listResponse(OfficeRecord, PageMeta),
+            401: unauthorized,
+            500: internal,
+        },
+    }), apiValidator('query', ActAsPageQuery), async (context) => {
+        const query = context.req.valid('query');
+        return context.json(page(await service.notices(query.actAs, query), query));
+    });
+    router.post(`${BASE}/runSchedule`, describeRoute({
+        tags,
+        summary: 'Create the extraction tasks that are due',
+        operationId: 'officeFlowsExampleRunSchedule',
+        description: 'The daily sweep, now: every request in acceptance gets the extraction tasks due by today. Safe to repeat.',
+        responses: {
+            200: dataResponse(ScheduleRun),
+            401: unauthorized,
+            500: internal,
+        },
+    }), async (context) => context.json({ data: { created: await service.runSchedule() } }));
+    // ── Data usage requests ─────────────────────────────────────────────
+    router.get(`${BASE}/dataRequests`, describeRoute({
+        tags,
+        summary: 'List data usage requests',
+        operationId: 'officeFlowsExampleListDataRequests',
+        responses: {
+            200: listResponse(OfficeRecord, PageMeta),
+            401: unauthorized,
+            500: internal,
+        },
+    }), apiValidator('query', PageQuery), async (context) => {
+        const query = context.req.valid('query');
+        return context.json(page(await service.listDataRequests(query), query));
+    });
+    router.post(`${BASE}/dataRequests`, describeRoute({
+        tags,
+        summary: 'Draft a data usage request',
+        operationId: 'officeFlowsExampleCreateDataRequest',
+        responses: {
+            201: dataResponse(OfficeRecord, 'The request, in `draft`.'),
+            401: unauthorized,
+            403: apiErrorResponse(403, 'Only the applicant drafts one (`APPLICANT_ONLY`).'),
+            500: internal,
+        },
+    }), apiValidator('query', ActAsQuery), apiValidator('json', DataRequestFormInput), async (context) => {
+        const { actAs } = context.req.valid('query');
+        const values = context.req.valid('json');
+        return context.json(data(await service.createDataRequest(form(values.form), actAs)), 201);
+    });
+    router.get(`${BASE}/dataRequests/:requestId`, describeRoute({
+        tags,
+        summary: 'Get a data usage request',
+        operationId: 'officeFlowsExampleGetDataRequest',
+        responses: {
+            200: dataResponse(OfficeDetail),
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', RequestParams), apiValidator('query', ActAsQuery), async (context) => {
+        const { requestId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        return context.json(data(await service.dataRequestDetail(requestId, actAs)));
+    });
+    router.patch(`${BASE}/dataRequests/:requestId`, describeRoute({
+        tags,
+        summary: 'Edit a draft data usage request',
+        operationId: 'officeFlowsExampleUpdateDataRequest',
+        description: 'Changes only the form fields sent; the others keep their values. Answers the choices hide are cleared, as on creation.',
+        responses: {
+            200: dataResponse(OfficeDetail, 'The request as edited.'),
+            ...editRefusals,
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', RequestParams), apiValidator('query', ActAsQuery), apiValidator('json', DataRequestFormInput), async (context) => {
+        const { requestId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const values = context.req.valid('json');
+        // Only the fields sent: the schema adds none, so the rest stay as stored.
+        await service.updateDataRequest(requestId, values.form, actAs);
+        return context.json(data(await service.dataRequestDetail(requestId, actAs)));
+    });
+    router.post(`${BASE}/dataRequests/:requestId/fire`, describeRoute({
+        tags,
+        summary: 'Fire a transition on a data usage request',
+        operationId: 'officeFlowsExampleFireDataRequestTransition',
+        responses: {
+            204: noContent,
+            ...fireRefusals,
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', RequestParams), apiValidator('query', ActAsQuery), apiValidator('json', FireInput), async (context) => {
+        const { requestId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const { transition, input } = context.req.valid('json');
+        await fire(() => service.fire('dataRequests', requestId, transition, input, actAs, true));
+        return context.body(null, 204);
+    });
+    router.post(`${BASE}/dataRequests/:requestId/extractions`, describeRoute({
+        tags,
+        summary: 'Create an extraction task by hand',
+        operationId: 'officeFlowsExampleCreateExtraction',
+        description: 'Only the acceptor, while the request is in acceptance; the task takes the next number.',
+        responses: {
+            201: dataResponse(OfficeRecord, 'The extraction task, `pending`.'),
+            400: apiErrorResponse(400, 'No topic or no valid first date (`EXTRACTION_FIELDS_REQUIRED`, with `fieldViolations`).'),
+            401: unauthorized,
+            403: apiErrorResponse(403, 'Not the acceptor, or not in acceptance (`ACCEPTOR_ONLY`).'),
+            404: notFound,
+            409: apiErrorResponse(409, 'The request left acceptance meanwhile (`REQUEST_LEFT_ACCEPTANCE`).'),
+            500: internal,
+        },
+    }), apiValidator('param', RequestParams), apiValidator('query', ActAsQuery), apiValidator('json', CreateExtractionInput), async (context) => {
+        const { requestId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const values = context.req.valid('json');
+        return context.json(data(await service.createManualExtraction(requestId, values, actAs)), 201);
+    });
+    // ── Extraction tasks ────────────────────────────────────────────────
+    router.get(`${BASE}/extractions/:extractionId`, describeRoute({
+        tags,
+        summary: 'Get an extraction task',
+        operationId: 'officeFlowsExampleGetExtraction',
+        responses: {
+            200: dataResponse(OfficeDetail),
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', ExtractionParams), apiValidator('query', ActAsQuery), async (context) => {
+        const { extractionId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        return context.json(data(await service.extractionDetail(extractionId, actAs)));
+    });
+    router.patch(`${BASE}/extractions/:extractionId`, describeRoute({
+        tags,
+        summary: 'Edit a pending extraction task',
+        operationId: 'officeFlowsExampleUpdateExtraction',
+        responses: {
+            200: dataResponse(OfficeDetail, 'The task as edited.'),
+            ...editRefusals,
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', ExtractionParams), apiValidator('query', ActAsQuery), apiValidator('json', ExtractionValuesInput), async (context) => {
+        const { extractionId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const { values } = context.req.valid('json');
+        await service.updateExtraction(extractionId, values, actAs);
+        return context.json(data(await service.extractionDetail(extractionId, actAs)));
+    });
+    router.post(`${BASE}/extractions/:extractionId/fire`, describeRoute({
+        tags,
+        summary: 'Fire a transition on an extraction task',
+        operationId: 'officeFlowsExampleFireExtractionTransition',
+        responses: {
+            204: noContent,
+            ...fireRefusals,
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', ExtractionParams), apiValidator('query', ActAsQuery), apiValidator('json', FireInput), async (context) => {
+        const { extractionId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const { transition, input } = context.req.valid('json');
+        await fire(() => service.fire('extractions', extractionId, transition, input, actAs, true));
+        return context.body(null, 204);
+    });
+    // ── Incoming documents ──────────────────────────────────────────────
+    router.get(`${BASE}/incoming`, describeRoute({
+        tags,
+        summary: 'List incoming documents',
+        operationId: 'officeFlowsExampleListIncoming',
+        responses: {
+            200: listResponse(OfficeRecord, PageMeta),
+            401: unauthorized,
+            500: internal,
+        },
+    }), apiValidator('query', PageQuery), async (context) => {
+        const query = context.req.valid('query');
+        return context.json(page(await service.listIncoming(query), query));
+    });
+    router.post(`${BASE}/incoming`, describeRoute({
+        tags,
+        summary: 'Record an incoming document',
+        operationId: 'officeFlowsExampleCreateIncoming',
+        responses: {
+            201: dataResponse(OfficeRecord, 'The document, in `draft`.'),
+            401: unauthorized,
+            403: apiErrorResponse(403, 'Only the office registrar records one (`REGISTRAR_ONLY`).'),
+            500: internal,
+        },
+    }), apiValidator('query', ActAsQuery), apiValidator('json', IncomingValuesInput), async (context) => {
+        const { actAs } = context.req.valid('query');
+        const { values } = context.req.valid('json');
+        return context.json(data(await service.createIncoming(values, actAs)), 201);
+    });
+    router.get(`${BASE}/incoming/:incomingId`, describeRoute({
+        tags,
+        summary: 'Get an incoming document',
+        operationId: 'officeFlowsExampleGetIncoming',
+        responses: {
+            200: dataResponse(OfficeDetail),
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', IncomingParams), apiValidator('query', ActAsQuery), async (context) => {
+        const { incomingId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        return context.json(data(await service.incomingDetail(incomingId, actAs)));
+    });
+    router.patch(`${BASE}/incoming/:incomingId`, describeRoute({
+        tags,
+        summary: 'Edit a draft incoming document',
+        operationId: 'officeFlowsExampleUpdateIncoming',
+        responses: {
+            200: dataResponse(OfficeDetail, 'The document as edited.'),
+            ...editRefusals,
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', IncomingParams), apiValidator('query', ActAsQuery), apiValidator('json', IncomingValuesInput), async (context) => {
+        const { incomingId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const { values } = context.req.valid('json');
+        await service.updateIncoming(incomingId, values, actAs);
+        return context.json(data(await service.incomingDetail(incomingId, actAs)));
+    });
+    router.post(`${BASE}/incoming/:incomingId/fire`, describeRoute({
+        tags,
+        summary: 'Fire a transition on an incoming document',
+        operationId: 'officeFlowsExampleFireIncomingTransition',
+        description: 'A dispatch carries the rows pending now, so a retried click sends the same ones.',
+        responses: {
+            204: noContent,
+            ...fireRefusals,
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', IncomingParams), apiValidator('query', ActAsQuery), apiValidator('json', FireInput), async (context) => {
+        const { incomingId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const { transition, input } = context.req.valid('json');
+        await fire(() => service.fireIncoming(incomingId, transition, input, actAs));
+        return context.body(null, 204);
+    });
+    router.post(`${BASE}/incoming/:incomingId/rows`, describeRoute({
+        tags,
+        summary: 'Add a distribution row to an incoming document',
+        operationId: 'officeFlowsExampleCreateIncomingRow',
+        responses: {
+            201: dataResponse(Created, 'The row.'),
+            400: apiErrorResponse(400, 'No clerks or no department (`ROW_CLERKS_REQUIRED`, `DEPARTMENT_REQUIRED`, with `fieldViolations`).'),
+            401: unauthorized,
+            403: apiErrorResponse(403, 'Not the registrar, or not being dispatched (`ROWS_NOT_ALLOWED`).'),
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', IncomingParams), apiValidator('query', ActAsQuery), apiValidator('json', RowInput), async (context) => {
+        const { incomingId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const row = context.req.valid('json');
+        const id = await service.addRow('incoming', incomingId, row, actAs);
+        return context.json({ data: { id: String(id) } }, 201);
+    });
+    router.post(`${BASE}/incoming/:incomingId/managementRows`, describeRoute({
+        tags,
+        summary: 'Copy an incoming document to a management group',
+        operationId: 'officeFlowsExampleCreateManagementRow',
+        description: 'A configured group by `groupId`, or a named group of chosen members.',
+        responses: {
+            201: dataResponse(Created, 'The row.'),
+            400: apiErrorResponse(400, 'No such configured group (`MANAGEMENT_GROUP_NOT_FOUND`), or no group name or no members (`MANAGEMENT_GROUP_REQUIRED`), with `fieldViolations`.'),
+            401: unauthorized,
+            403: apiErrorResponse(403, 'Not the registrar, or not being dispatched (`MANAGEMENT_NOT_ALLOWED`).'),
+            404: apiErrorResponse(404, 'No such document (`RECORD_NOT_FOUND`).'),
+            500: internal,
+        },
+    }), apiValidator('param', IncomingParams), apiValidator('query', ActAsQuery), apiValidator('json', ManagementRowInput), async (context) => {
+        const { incomingId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const { groupId, groupName, members } = context.req.valid('json');
+        const id = await service.addManagement(incomingId, {
+            ...(groupId === undefined ? {} : { groupId: Number(groupId) }),
+            ...(groupName === undefined ? {} : { groupName }),
+            ...(members === undefined ? {} : { members }),
+        }, actAs);
+        return context.json({ data: { id: String(id) } }, 201);
+    });
+    router.delete(`${BASE}/managementRows/:rowId`, describeRoute({
+        tags,
+        summary: 'Remove a management copy that was not forwarded',
+        operationId: 'officeFlowsExampleDeleteManagementRow',
+        responses: {
+            204: noContent,
+            400: apiErrorResponse(400, 'Already forwarded (`MANAGEMENT_ROW_FORWARDED`).'),
+            401: unauthorized,
+            403: apiErrorResponse(403, 'Not the registrar (`MANAGEMENT_ROW_NOT_ALLOWED`).'),
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', RowParams), apiValidator('query', ActAsQuery), async (context) => {
+        const { rowId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        await service.removeManagement(rowId, actAs);
+        return context.body(null, 204);
+    });
+    router.delete(`${BASE}/rows/:rowId`, describeRoute({
+        tags,
+        summary: 'Remove a distribution row that was not dispatched',
+        operationId: 'officeFlowsExampleDeleteRow',
+        responses: {
+            204: noContent,
+            400: apiErrorResponse(400, 'Already dispatched (`ROW_DISPATCHED`).'),
+            401: unauthorized,
+            403: apiErrorResponse(403, 'Someone else added it (`ROW_OWNER_ONLY`).'),
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', RowParams), apiValidator('query', ActAsQuery), async (context) => {
+        const { rowId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        await service.removeRow(rowId, actAs);
+        return context.body(null, 204);
+    });
+    // ── Incoming-document tasks ─────────────────────────────────────────
+    router.get(`${BASE}/tasks`, describeRoute({
+        tags,
+        summary: 'List the persona’s tasks',
+        operationId: 'officeFlowsExampleListTasks',
+        description: 'Every kind of task assigned to the persona, each with its `kind`.',
+        responses: {
+            200: listResponse(OfficeRecord, PageMeta),
+            401: unauthorized,
+            500: internal,
+        },
+    }), apiValidator('query', ActAsPageQuery), async (context) => {
+        const query = context.req.valid('query');
+        return context.json(page(await service.myTasks(query.actAs, query), query));
+    });
+    router.get(`${BASE}/tasks/:taskKind/:taskId`, describeRoute({
+        tags,
+        summary: 'Get a task',
+        operationId: 'officeFlowsExampleGetTask',
+        responses: {
+            200: dataResponse(OfficeDetail),
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', TaskParams), apiValidator('query', ActAsQuery), async (context) => {
+        const { taskKind, taskId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        return context.json(data(await service.taskDetail(taskKind, taskId, actAs)));
+    });
+    router.patch(`${BASE}/tasks/:taskKind/:taskId`, describeRoute({
+        tags,
+        summary: 'Edit a task in progress',
+        operationId: 'officeFlowsExampleUpdateTask',
+        responses: {
+            200: dataResponse(OfficeDetail, 'The task as edited.'),
+            ...editRefusals,
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', TaskParams), apiValidator('query', ActAsQuery), apiValidator('json', TaskValuesInput), async (context) => {
+        const { taskKind, taskId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const { values } = context.req.valid('json');
+        await service.updateTask(taskKind, taskId, values, actAs);
+        return context.json(data(await service.taskDetail(taskKind, taskId, actAs)));
+    });
+    router.post(`${BASE}/tasks/:taskKind/:taskId/fire`, describeRoute({
+        tags,
+        summary: 'Fire a transition on a task',
+        operationId: 'officeFlowsExampleFireTaskTransition',
+        responses: {
+            204: noContent,
+            ...fireRefusals,
+            401: unauthorized,
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', TaskParams), apiValidator('query', ActAsQuery), apiValidator('json', FireInput), async (context) => {
+        const { taskKind, taskId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const { transition, input } = context.req.valid('json');
+        await fire(() => service.fireTask(taskKind, taskId, transition, input, actAs));
+        return context.body(null, 204);
+    });
+    router.post(`${BASE}/tasks/:taskKind/:taskId/rows`, describeRoute({
+        tags,
+        summary: 'Add a distribution row to a task',
+        operationId: 'officeFlowsExampleCreateTaskRow',
+        description: 'A clerk’s or a team’s task dispatches further; an executor’s has nothing to dispatch.',
+        responses: {
+            201: dataResponse(Created, 'The row.'),
+            400: apiErrorResponse(400, 'No clerks or no department (`ROW_CLERKS_REQUIRED`, `DEPARTMENT_REQUIRED`, with `fieldViolations`).'),
+            401: unauthorized,
+            403: apiErrorResponse(403, 'Not an assignee of a task in progress (`TASK_ROWS_NOT_ALLOWED`).'),
+            404: notFound,
+            500: internal,
+        },
+    }), apiValidator('param', DispatchingTaskParams), apiValidator('query', ActAsQuery), apiValidator('json', RowInput), async (context) => {
+        const { taskKind, taskId } = context.req.valid('param');
+        const { actAs } = context.req.valid('query');
+        const row = context.req.valid('json');
+        const id = await service.addRow(taskKind, taskId, row, actAs);
+        return context.json({ data: { id: String(id) } }, 201);
+    });
+    return new Hono().route('/', router);
+});
+const routes = [
+    apiRoutes,
+];
+export default routes;
+//# sourceMappingURL=index.js.map