@forestadmin/agent-bff 1.31.0 → 1.33.0

package/README.md

@@ -36,6 +36,112 @@ dropped collection reachable.
 Two ways to run it: embedded in a Forest agent (`agent.addBff()`, see
 [Embedded in an agent](#embedded-in-an-agent)) or standalone, described here.
 
+### Docker (recommended)
+
+```bash
+cp .env.example .env   # then fill in the secrets
+docker compose up
+```
+
+The template targets a local, non-containerised run, so one value has to change for Docker:
+set `AGENT_URL=http://host.docker.internal:3351`. Left at `localhost`, it resolves to the BFF
+container itself and every agent call fails (see the note below).
+
+The `docker-compose.yml` at the root of this package starts a single BFF instance. See
+`.env.example` for the full list of environment variables and their descriptions.
+
+Or run the image directly:
+
+```bash
+docker run -d \
+  -p 3450:3450 \
+  --stop-timeout 15 \
+  --add-host host.docker.internal:host-gateway \
+  -e FOREST_AUTH_SECRET="..." \
+  -e FOREST_ENV_SECRET="..." \
+  -e FOREST_SERVER_URL="https://api.forestadmin.com" \
+  -e FOREST_APP_URL="https://app.forestadmin.com" \
+  -e AGENT_URL="http://host.docker.internal:3351" \
+  -e BFF_TOKEN_ENCRYPTION_KEY="$(openssl rand -base64 32)" \
+  ghcr.io/forestadmin/agent-bff:latest
+```
+
+> **Note:** When the BFF runs in Docker and your agent runs on the host machine, use
+> `host.docker.internal` instead of `localhost` in `AGENT_URL`. Docker Desktop resolves that
+> name natively; on Docker Engine for Linux it does not exist unless you map it, hence the
+> `--add-host` above (the Compose setup does the same through `extra_hosts`).
+
+The image's entry point is the CLI, so the subcommands below work the same way:
+
+```bash
+docker run --rm ghcr.io/forestadmin/agent-bff:latest openapi > openapi.json
+```
+
+Tags follow the npm package: `:latest`, `:1`, `:1.20` and the immutable `:1.20.2`.
+
+The package is public, so none of the commands above need a login. That visibility is set once,
+by hand, on the GHCR package: a package GHCR creates on its first push is private, and the
+workflow's `GITHUB_TOKEN` can push to it but not change what it is. Until someone flips it (the
+same step `workflow-executor` went through), pulls need
+`docker login ghcr.io -u <user> -p <token-with-read:packages>`.
+
+On `SIGTERM` or `SIGINT` the BFF stops accepting connections and gives the requests already in
+flight 10 seconds to finish before cutting their sockets, then exits 0. A second signal gives up on
+the wait and exits 1.
+
+Allow for that in your orchestrator's grace period. The whole budget is up to 11 seconds — the 10
+second deadline plus a 1 second fallback for the exit itself — and `docker stop` defaults to 10,
+so under load it would SIGKILL exactly when the shutdown is doing its job. Hence `--stop-timeout 15`
+above and `stop_grace_period: 15s` in the Compose file; on Kubernetes the default
+`terminationGracePeriodSeconds` of 30 already covers it.
+
+### Observability (OpenTelemetry)
+
+The Docker image ships with [OpenTelemetry](https://opentelemetry.io/) APM built in, and works with
+any OTLP-compatible backend (Datadog, Grafana Tempo, Jaeger, Honeycomb, etc.). It is **off by
+default** and turns on as soon as you point it at an OTLP receiver — no code changes or extra
+installs required. A setup that cannot start logs a warning and runs untraced rather than taking
+the process down with it. Tracing is set up before the app starts (auto-instrumentation for HTTP and the
+outbound calls to the agent and the Forest SaaS). The graceful shutdown described above waits for
+the buffered spans to be exported before it exits, but gives that its own 2 second deadline rather
+than the 10 seconds in-flight requests get: an unreachable collector costs you the last spans, never
+the ability to stop. Worst case it adds ~3 seconds to a shutdown.
+
+Configure it entirely through the standard OTel environment variables:
+
+| Variable | Description |
+| --- | --- |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP receiver URL (e.g. `http://collector:4318`). **Tracing stays off until this or `OTEL_TRACES_EXPORTER` is set.** |
+| `OTEL_SERVICE_NAME` | Service name reported in traces. Falls back to `service.name` in `OTEL_RESOURCE_ATTRIBUTES`, then to `forestadmin-agent-bff`. |
+| `OTEL_RESOURCE_ATTRIBUTES` | Extra resource attributes, e.g. `deployment.environment=production`. A `service.name` here is honoured when `OTEL_SERVICE_NAME` is unset. |
+| `OTEL_SDK_DISABLED` | Set to `true` (case-insensitive) to force-disable tracing whatever else is configured. |
+| `OTEL_TRACES_EXPORTER` | Which exporter the SDK builds: `otlp` (the default), `console`, `zipkin`, `none`, or a list. Setting it alone turns tracing on without an OTLP endpoint, which is what makes `console` usable for debugging. `none` keeps instrumentation running with nothing exported, so trace context still propagates to the agent and the Forest SaaS. |
+| `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` | Per-signal endpoint, taking precedence over the generic one above. Setting either turns tracing on. |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` | `http/protobuf` (the default), `http/json` or `grpc`, with `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` for traces alone. |
+| `OTEL_METRICS_EXPORTER` / `OTEL_LOGS_EXPORTER` | Default to `none` here, against the SDK's own `otlp`: this image arms tracing, and leaving them unset would otherwise export metrics and logs to `http://localhost:4318` on the side. Set either one (`otlp`, `console`, …) to opt that signal back in. |
+
+```bash
+docker run -d \
+  -p 3450:3450 \
+  --stop-timeout 15 \
+  --add-host host.docker.internal:host-gateway \
+  -e FOREST_AUTH_SECRET="..." \
+  -e FOREST_ENV_SECRET="..." \
+  -e FOREST_SERVER_URL="https://api.forestadmin.com" \
+  -e FOREST_APP_URL="https://app.forestadmin.com" \
+  -e AGENT_URL="http://host.docker.internal:3351" \
+  -e BFF_TOKEN_ENCRYPTION_KEY="$(openssl rand -base64 32)" \
+  -e OTEL_EXPORTER_OTLP_ENDPOINT="http://collector:4318" \
+  ghcr.io/forestadmin/agent-bff:latest
+```
+
+> **Note:** These variables only do anything in the Docker image. The image's entry point loads
+> the tracing preload before the CLI; the npm `forest-bff` bin runs the CLI on its own, and the
+> OpenTelemetry packages are not npm dependencies — so outside Docker an `OTEL_*` variable is
+> read by nothing and the process starts untraced, silently.
+
+### Without Docker
+
 Packaged / production — run the bin:
 
 ```bash
@@ -99,7 +205,7 @@ yarn start:dev         # node --env-file=.env dist/cli.js
 | `FOREST_APP_URL`              | yes       | Forest front base URL, used to build the OAuth front-channel redirect (`src/oauth/oauth-routes.ts`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `AGENT_URL`                   | yes       | The customer agent base URL the BFF calls via agent-client.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `BFF_TOKEN_ENCRYPTION_KEY`    | for OAuth | Base64-encoded 32-byte AES-256 key encrypting stored refresh tokens. Until it is set, the `/oauth/*` token-issuance routes are disabled and `/health` reports `configured.oauth: false` — but it stays `ok`, since the key gates OAuth and not boot; already-issued `bff_access` tokens still authenticate on `/agent/*` whenever `FOREST_AUTH_SECRET` is present.                                                                                                                                                                                                                                                                                                                                                                                             |
-| `HTTP_PORT`                   | no        | Server port, integer 0–65535. Defaults to `3450`. `0` binds an OS-assigned ephemeral port.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `HTTP_PORT`                   | no        | Server port, integer 0–65535. Defaults to `3450`. `0` binds an OS-assigned ephemeral port — useful for a local run, unusable in the Docker image, where nothing outside the process learns which port it got: it can be neither published nor probed, and the image's healthcheck would report the container unhealthy forever.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `BFF_ALLOWED_ORIGINS`         | no        | Comma-separated CORS allow-list of origins (scheme + host + port). An entry may carry a single `*` as the leading host label — `https://*.apps.zdusercontent.com` — which matches exactly one DNS label there, and nothing else: not two labels, not the apex, and never the scheme or the port. The host left after `*.` must be at least two non-empty labels, so `https://*.com` is refused; a two-label public suffix such as `https://*.co.uk` is not, and would allow every site under it. Any other `*` in the host is refused and warned about at boot; a `*` outside the host — in userinfo, a path or a query — is stripped along with the rest of the URL, so `https://*@example.com` is simply the exact origin `https://example.com`. Empty ⇒ no cross-origin browser access.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `BFF_DEFAULT_TIMEZONE`        | no        | Fallback IANA timezone used when a request carries neither an `X-Forest-Timezone` header nor a body `timezone`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `BFF_PUBLIC_URL`              | no        | The BFF's own external base URL, published as `servers[0].url` in the OpenAPI document so a generated client resolves endpoints without being configured by hand. Absent, `servers[0].url` stays `/`, which a consumer that fetched the document over HTTP resolves against that URL — but which leaves a client generated from an offline `forest-bff openapi` export with no base URL at all. Trailing slashes are stripped. A malformed value fails the boot, and so does one carrying credentials, a query string or a fragment: credentials would be published to every reader of the document, and anything behind a `?` or `#` swallows the path a generated client appends. |

package/dist/action/action-routes-middleware.d.ts

@@ -1,4 +1,5 @@
 import type { AgentActionClient, AgentActionClientOptions } from './agent-action-client';
+import type { ActivityLogWriter } from '../activity-log/activity-log-writer';
 import type { AgentTransport } from '../agent/agent-transport';
 import type { Logger } from '../ports/logger-port';
 import type ReadModelStore from '../read-model/read-model-store';
@@ -7,7 +8,8 @@ export interface ActionRoutesMiddlewareOptions {
     store: ReadModelStore;
     transport: AgentTransport;
     logger: Logger;
+    activityLogs: ActivityLogWriter;
     createClient?: (options: AgentActionClientOptions) => AgentActionClient;
 }
-export default function createActionRoutesMiddleware({ store, transport, logger, createClient, }: ActionRoutesMiddlewareOptions): Middleware;
+export default function createActionRoutesMiddleware({ store, transport, logger, activityLogs, createClient, }: ActionRoutesMiddlewareOptions): Middleware;
 //# sourceMappingURL=action-routes-middleware.d.ts.map

package/dist/action/action-routes-middleware.js

@@ -45,8 +45,19 @@ const agent_action_client_1 = __importStar(require("./agent-action-client"));
 const sanitize_action_html_1 = __importDefault(require("./sanitize-action-html"));
 const agent_error_mapper_1 = require("../http/agent-error-mapper");
 const agent_route_helpers_1 = require("../http/agent-route-helpers");
+const bff_http_error_1 = require("../http/bff-http-error");
 const bff_local_errors_1 = require("../http/bff-local-errors");
 const ACTION_ROUTE = /^\/agent\/v1\/([^/]+)\/actions\/([^/]+)\/(form|execute)$/;
+const EXECUTE_VERB = 'execute';
+/**
+ * An approval request is a business outcome, not a failure: the action was routed for review. The
+ * BFF answers it with a 403, but recording the entry as `failed` would make the same event count
+ * differently here and in mcp-server, which records it as a success — and action-failure statistics
+ * would mix refusals with runs that never happened.
+ */
+function isApprovalRequest(error) {
+    return error instanceof bff_http_error_1.BffHttpError && error.type === bff_local_errors_1.ACTION_REQUIRES_APPROVAL_TYPE;
+}
 // recordIds are opaque BFF ids; only presence and array-ness are checked. An empty array is allowed
 // on purpose (global/bulk actions have no selected records); the spec AC only covers a missing
 // recordIds, so `[]` is an explicit BFF choice, not a spec requirement.
@@ -148,7 +159,7 @@ async function handleExecute({ ctx, action, values, logger, }) {
     ctx.status = status;
     ctx.body = body;
 }
-function createActionRoutesMiddleware({ store, transport, logger, createClient = agent_action_client_1.default, }) {
+function createActionRoutesMiddleware({ store, transport, logger, activityLogs, createClient = agent_action_client_1.default, }) {
     return async function actionRoutesMiddleware(ctx, next) {
         const match = ACTION_ROUTE.exec(ctx.path);
         if (!match || ctx.method !== 'POST') {
@@ -162,12 +173,15 @@ function createActionRoutesMiddleware({ store, transport, logger, createClient =
         const readModel = await (0, agent_route_helpers_1.resolveReadModel)(store);
         // The read-model's action map IS the allow-list, so an absent action cannot be told from a
         // known-but-disallowed one — every non-exposed action maps to 404 here; `action_not_allowed`
-        // (403) has no local trigger, mirroring `collection_not_allowed`/`relation_not_allowed`. The
-        // URL identity is resolved before the body, so a bad action 404s before its payload is read.
+        // (403) has no local trigger, mirroring `collection_not_allowed`/`relation_not_allowed`.
         // TODO(PRD-673): distinguish disallowed from unknown when a separate exposure source exists.
-        if (!readModel.isActionAllowed(collection, actionName)) {
+        const allowed = readModel.isActionAllowed(collection, actionName);
+        const refuseUnknownAction = () => {
             throw (0, bff_local_errors_1.unknownAction)(`Unknown action: ${collection}.${actionName}`);
-        }
+        };
+        // The form is unaudited, so it keeps refusing before the body is read.
+        if (!allowed && verb !== EXECUTE_VERB)
+            refuseUnknownAction();
         const body = (ctx.request.body ?? {});
         assertKnownBodyKeys(body);
         const recordIds = parseRecordIds(body.recordIds);
@@ -177,19 +191,40 @@ function createActionRoutesMiddleware({ store, transport, logger, createClient =
             token,
             actionEndpoints: readModel.getActionEndpoints(),
         });
-        const action = await (0, agent_route_helpers_1.callAgent)(() => client.loadAction({
+        const loadAction = () => (0, agent_route_helpers_1.callAgent)(() => client.loadAction({
             collection,
             actionName,
             recordIds,
             timezone: ctx.state.timezone,
         }), logger);
-        const handlerArgs = { ctx, action, values, logger };
-        if (verb === 'execute') {
-            await handleExecute(handlerArgs);
-        }
-        else {
-            await handleForm(handlerArgs);
+        // The form is not audited, mirroring mcp-server, whose get-action-form tool writes no log
+        // either: the record-touching event the trail records is the execution.
+        if (verb !== EXECUTE_VERB) {
+            const action = await loadAction();
+            await handleForm({ ctx, action, values, logger });
+            return;
         }
+        // The whole sequence is audited, loadAction and setFields included, so the intent is recorded
+        // even when the attempt never reaches the agent's execute. The allow-list refusal is inside
+        // too, mirroring mcp-server, whose execute-action tool resolves the action within its own
+        // wrapper: an attempt on an action the caller may not trigger is exactly what the trail is
+        // for, and the record ids it names are only known once the body is read.
+        await activityLogs.record({
+            ctx,
+            action: 'action',
+            context: {
+                collectionName: collection,
+                recordIds,
+                label: `triggered the action "${actionName}"`,
+            },
+            isCompletedDespite: isApprovalRequest,
+            operation: async () => {
+                if (!allowed)
+                    refuseUnknownAction();
+                const action = await loadAction();
+                await handleExecute({ ctx, action, values, logger });
+            },
+        });
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-routes-middleware.js","sourceRoot":"","sources":["../../src/action/action-routes-middleware.ts"],"names":[],"mappings":"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"}

package/dist/activity-log/activity-log-drainer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Holds the audited requests and the status transitions they fire without `await`. Nothing else
+ * keeps the transitions alive: `server.close()` waits for connections, and one sent after the
+ * response is attached to none — without this, every deploy would leave entries stuck in `pending`.
+ *
+ * The requests are tracked too, and not only their transitions, for the embedded deployment: there
+ * the host owns the connections, so `stop()` returns while requests are still running and their
+ * transitions are not registered yet.
+ */
+export default class ActivityLogDrainer {
+    private readonly inFlight;
+    track<T>(operation: () => Promise<T>, description: string): Promise<T>;
+    /**
+     * Loops rather than settling one snapshot: a transition is registered only once the request it
+     * audits has finished, so a single pass would return before the work that outlives it.
+     *
+     * `timeoutMs` is the shutdown deadline the caller shares: a stalled audit store would otherwise
+     * hold the process past the grace its orchestrator gives it, and be SIGKILLed mid-drain. Returns
+     * what the deadline left unfinished, empty when everything settled.
+     */
+    drain(timeoutMs?: number): Promise<string[]>;
+    private settle;
+}
+//# sourceMappingURL=activity-log-drainer.d.ts.map

package/dist/activity-log/activity-log-drainer.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Holds the audited requests and the status transitions they fire without `await`. Nothing else
+ * keeps the transitions alive: `server.close()` waits for connections, and one sent after the
+ * response is attached to none — without this, every deploy would leave entries stuck in `pending`.
+ *
+ * The requests are tracked too, and not only their transitions, for the embedded deployment: there
+ * the host owns the connections, so `stop()` returns while requests are still running and their
+ * transitions are not registered yet.
+ */
+class ActivityLogDrainer {
+    constructor() {
+        this.inFlight = new Set();
+    }
+    track(operation, description) {
+        const promise = operation();
+        const entry = { promise, description };
+        this.inFlight.add(entry);
+        promise.finally(() => this.inFlight.delete(entry)).catch(() => { });
+        return promise;
+    }
+    /**
+     * Loops rather than settling one snapshot: a transition is registered only once the request it
+     * audits has finished, so a single pass would return before the work that outlives it.
+     *
+     * `timeoutMs` is the shutdown deadline the caller shares: a stalled audit store would otherwise
+     * hold the process past the grace its orchestrator gives it, and be SIGKILLed mid-drain. Returns
+     * what the deadline left unfinished, empty when everything settled.
+     */
+    async drain(timeoutMs) {
+        const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
+        while (this.inFlight.size > 0) {
+            const remainingMs = deadline === undefined ? undefined : deadline - Date.now();
+            if (remainingMs !== undefined && remainingMs <= 0)
+                break;
+            // eslint-disable-next-line no-await-in-loop
+            await this.settle(remainingMs);
+        }
+        return [...this.inFlight].map(entry => entry.description);
+    }
+    async settle(timeoutMs) {
+        const settled = Promise.allSettled([...this.inFlight].map(entry => entry.promise));
+        if (timeoutMs === undefined) {
+            await settled;
+            return;
+        }
+        let timer;
+        try {
+            await Promise.race([
+                settled,
+                new Promise(resolve => {
+                    timer = setTimeout(resolve, timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.default = ActivityLogDrainer;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/activity-log/activity-log-writer.d.ts

@@ -0,0 +1,26 @@
+import type { ActivityLogContext, BffActivityLogAction } from './activity-logs-creator';
+import type { ActivityLogsWriter } from './activity-logs-service';
+import type { Logger } from '../ports/logger-port';
+import type { Context } from 'koa';
+export interface RecordActivityLogOptions<T> {
+    ctx: Context;
+    action: BffActivityLogAction;
+    context?: ActivityLogContext;
+    operation: () => Promise<T>;
+    isCompletedDespite?: (error: unknown) => boolean;
+}
+export interface ActivityLogWriter {
+    record<T>(options: RecordActivityLogOptions<T>): Promise<T>;
+    /**
+     * Waits for the audited requests still running and for the status transitions no connection
+     * holds. Called when the server stops, which shares its deadline through `timeoutMs`; returns
+     * the operations that deadline left unfinished.
+     */
+    drain(timeoutMs?: number): Promise<string[]>;
+}
+export interface ActivityLogWriterOptions {
+    service: ActivityLogsWriter;
+    logger: Logger;
+}
+export default function createActivityLogWriter({ service, logger, }: ActivityLogWriterOptions): ActivityLogWriter;
+//# sourceMappingURL=activity-log-writer.d.ts.map

package/dist/activity-log/activity-log-writer.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createActivityLogWriter;
+const activity_log_drainer_1 = __importDefault(require("./activity-log-drainer"));
+const with_activity_log_1 = __importDefault(require("./with-activity-log"));
+function describeRequest(action, collectionName) {
+    return collectionName ? `'${action}' request on '${collectionName}'` : `'${action}' request`;
+}
+function createActivityLogWriter({ service, logger, }) {
+    const drainer = new activity_log_drainer_1.default();
+    return {
+        record(options) {
+            return drainer.track(() => (0, with_activity_log_1.default)({ ...options, service, drainer, logger }), describeRequest(options.action, options.context?.collectionName));
+        },
+        drain(timeoutMs) {
+            return drainer.drain(timeoutMs);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHktbG9nLXdyaXRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hY3Rpdml0eS1sb2cvYWN0aXZpdHktbG9nLXdyaXRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQW1DQSwwQ0FrQkM7QUFoREQsa0ZBQXdEO0FBQ3hELDRFQUFrRDtBQXlCbEQsU0FBUyxlQUFlLENBQUMsTUFBNEIsRUFBRSxjQUF1QjtJQUM1RSxPQUFPLGNBQWMsQ0FBQyxDQUFDLENBQUMsSUFBSSxNQUFNLGlCQUFpQixjQUFjLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUMvRixDQUFDO0FBRUQsU0FBd0IsdUJBQXVCLENBQUMsRUFDOUMsT0FBTyxFQUNQLE1BQU0sR0FDbUI7SUFDekIsTUFBTSxPQUFPLEdBQUcsSUFBSSw4QkFBa0IsRUFBRSxDQUFDO0lBRXpDLE9BQU87UUFDTCxNQUFNLENBQUksT0FBb0M7WUFDNUMsT0FBTyxPQUFPLENBQUMsS0FBSyxDQUNsQixHQUFHLEVBQUUsQ0FBQyxJQUFBLDJCQUFlLEVBQUMsRUFBRSxHQUFHLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDLEVBQy9ELGVBQWUsQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxPQUFPLEVBQUUsY0FBYyxDQUFDLENBQ2pFLENBQUM7UUFDSixDQUFDO1FBRUQsS0FBSyxDQUFDLFNBQWtCO1lBQ3RCLE9BQU8sT0FBTyxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNsQyxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUMifQ==

package/dist/activity-log/activity-logs-creator.d.ts

@@ -0,0 +1,42 @@
+import type ActivityLogDrainer from './activity-log-drainer';
+import type { ActivityLogsWriter } from './activity-logs-service';
+import type { Logger } from '../ports/logger-port';
+import type { ActivityLogAction, ActivityLogResponse } from '@forestadmin/forestadmin-client';
+import type { Context } from 'koa';
+/** The actions the BFF writes: its data routes read, and its action route writes. */
+export type BffActivityLogAction = Extract<ActivityLogAction, 'index' | 'search' | 'filter' | 'listRelatedData' | 'action'>;
+export interface ActivityLogContext {
+    collectionName?: string;
+    recordId?: string | number;
+    recordIds?: string[] | number[];
+    label?: string;
+}
+/**
+ * The token that created the log is kept for the status transition: the transition is fired after
+ * the response, when the session it came from may already be unreachable.
+ */
+export interface PendingActivityLog {
+    activityLog: ActivityLogResponse;
+    forestServerToken: string;
+}
+export interface CreatePendingActivityLogOptions {
+    ctx: Context;
+    service: ActivityLogsWriter;
+    action: BffActivityLogAction;
+    context?: ActivityLogContext;
+    logger: Logger;
+}
+export default function createPendingActivityLog({ ctx, service, action, context, logger, }: CreatePendingActivityLogOptions): Promise<PendingActivityLog | null>;
+export interface MarkActivityLogOptions {
+    service: ActivityLogsWriter;
+    drainer: ActivityLogDrainer;
+    pending: PendingActivityLog;
+    status: 'completed' | 'failed';
+    logger: Logger;
+}
+/**
+ * Fire-and-forget on purpose: the caller's response must not wait for the audit store. The drainer
+ * holds the promise so a shutdown can wait for it instead.
+ */
+export declare function markActivityLog(options: MarkActivityLogOptions): void;
+//# sourceMappingURL=activity-logs-creator.d.ts.map