@friggframework/core 2.0.0--canary.680.6bacd26.0 → 2.0.0--canary.663.8de669c.0

package/integrations/use-cases/integration-operations-for-user.js

@@ -1,225 +0,0 @@
-const Boom = require('@hapi/boom');
-const { userOwns } = require('../../modules/use-cases/get-entity-module-for-user');
-
-/**
- * Management API v2 integration operations. They put an ownership check
- * (missing or foreign integration = 404) in front of the existing
- * integration use cases, and pass the record's owner id on, so the
- * organisation user model works the same as for entities.
- */
-
-const notFound = (integrationId) =>
-    Boom.notFound(`Integration ${integrationId} not found`, {
-        code: 'INTEGRATION_NOT_FOUND',
-    });
-
-/** The integration record, or 404 when it is missing or not the caller's. */
-class GetOwnedIntegrationRecord {
-    constructor({ integrationRepository }) {
-        this.integrationRepository = integrationRepository;
-    }
-
-    async execute(integrationId, user) {
-        let record = null;
-        try {
-            record = await this.integrationRepository.findIntegrationById(
-                integrationId
-            );
-        } catch (error) {
-            if (/Invalid ID|ObjectId|Malformed/i.test(error?.message || '')) {
-                throw notFound(integrationId);
-            }
-            throw error;
-        }
-        if (!record || !userOwns(user, record.userId)) {
-            throw notFound(integrationId);
-        }
-        return record;
-    }
-}
-
-/**
- * Creates (or reuses) an integration between entities the caller owns.
- * Unlike v1, the entities' ownership and the integration type are checked
- * before anything is written.
- */
-class CreateIntegrationForUser {
-    constructor({ createIntegration, getEntityModuleForUser, integrationClasses }) {
-        this.createIntegration = createIntegration;
-        this.getEntityModuleForUser = getEntityModuleForUser;
-        this.integrationClasses = integrationClasses || [];
-    }
-
-    async execute({ entities, config }, user) {
-        if (!config || typeof config !== 'object' || typeof config.type !== 'string') {
-            throw Boom.badRequest('config.type is required', {
-                code: 'VALIDATION_ERROR',
-                details: { field: 'config.type' },
-            });
-        }
-        const known = this.integrationClasses.some(
-            (IntegrationClass) => IntegrationClass.Definition?.name === config.type
-        );
-        if (!known) {
-            throw Boom.badRequest(`Unknown integration type '${config.type}'`, {
-                code: 'UNKNOWN_INTEGRATION_TYPE',
-            });
-        }
-        if (
-            !Array.isArray(entities) ||
-            entities.some((id) => typeof id !== 'string' && typeof id !== 'number')
-        ) {
-            throw Boom.badRequest('entities must be an array of entity ids', {
-                code: 'VALIDATION_ERROR',
-                details: { field: 'entities' },
-            });
-        }
-        for (const entityId of entities) {
-            await this.getEntityModuleForUser.loadOwnedEntity(String(entityId), user);
-        }
-        return this.createIntegration.execute(
-            entities.map(String),
-            user.getId(),
-            config
-        );
-    }
-}
-
-/** The hydrated integration instance (modules loaded) for an owned integration. */
-class GetIntegrationInstanceForUser {
-    constructor({ getOwnedIntegrationRecord, getIntegrationInstance }) {
-        this.getOwnedIntegrationRecord = getOwnedIntegrationRecord;
-        this.getIntegrationInstance = getIntegrationInstance;
-    }
-
-    async execute(integrationId, user) {
-        const record = await this.getOwnedIntegrationRecord.execute(
-            integrationId,
-            user
-        );
-        return this.getIntegrationInstance.execute(record.id, record.userId);
-    }
-}
-
-/** Replaces an owned integration's config. */
-class UpdateIntegrationForUser {
-    constructor({ getOwnedIntegrationRecord, updateIntegration }) {
-        this.getOwnedIntegrationRecord = getOwnedIntegrationRecord;
-        this.updateIntegration = updateIntegration;
-    }
-
-    async execute(integrationId, user, config) {
-        if (!config || typeof config !== 'object' || Array.isArray(config)) {
-            throw Boom.badRequest('config must be an object', {
-                code: 'VALIDATION_ERROR',
-                details: { field: 'config' },
-            });
-        }
-        const record = await this.getOwnedIntegrationRecord.execute(
-            integrationId,
-            user
-        );
-        return this.updateIntegration.execute(record.id, record.userId, config);
-    }
-}
-
-/** Deletes an owned integration (runs its onDelete hooks). */
-class RemoveIntegrationForUser {
-    constructor({ getOwnedIntegrationRecord, deleteIntegrationForUser }) {
-        this.getOwnedIntegrationRecord = getOwnedIntegrationRecord;
-        this.deleteIntegrationForUser = deleteIntegrationForUser;
-    }
-
-    async execute(integrationId, user) {
-        const record = await this.getOwnedIntegrationRecord.execute(
-            integrationId,
-            user
-        );
-        await this.deleteIntegrationForUser.execute(record.id, record.userId);
-    }
-}
-
-/**
- * Sends one of the framework's user-facing events (GET_CONFIG_OPTIONS,
- * GET_USER_ACTIONS, ...) to an owned integration. Handlers pass fixed event
- * names only; caller-chosen action ids go through RunIntegrationActionForUser.
- */
-class SendIntegrationEventForUser {
-    constructor({ getIntegrationInstanceForUser }) {
-        this.getIntegrationInstanceForUser = getIntegrationInstanceForUser;
-    }
-
-    async execute(integrationId, user, event, payload) {
-        const instance = await this.getIntegrationInstanceForUser.execute(
-            integrationId,
-            user
-        );
-        return instance.send(event, payload);
-    }
-}
-
-/**
- * Runs a user action on an owned integration. Unlike v1, the action id must
- * be one the integration lists as a user action (static USER_ACTION events
- * or its dynamic user actions), so a caller cannot fire internal events such
- * as lifecycle hooks.
- */
-class RunIntegrationActionForUser {
-    constructor({ getIntegrationInstanceForUser }) {
-        this.getIntegrationInstanceForUser = getIntegrationInstanceForUser;
-    }
-
-    async execute(integrationId, user, actionId, payload) {
-        const instance = await this.getIntegrationInstanceForUser.execute(
-            integrationId,
-            user
-        );
-        const actions =
-            typeof instance.loadUserActions === 'function'
-                ? await instance.loadUserActions()
-                : {};
-        if (!actions || !Object.prototype.hasOwnProperty.call(actions, actionId)) {
-            throw Boom.notFound(
-                `Integration ${integrationId} has no user action '${actionId}'`,
-                { code: 'ACTION_NOT_FOUND' }
-            );
-        }
-        return instance.send(actionId, payload);
-    }
-}
-
-/**
- * Runs the integration's auth test and reconciles its status. Returns the
- * errors recorded during the test.
- */
-class TestIntegrationAuthForUser {
-    constructor({ getIntegrationInstanceForUser }) {
-        this.getIntegrationInstanceForUser = getIntegrationInstanceForUser;
-    }
-
-    /** @returns {Promise<{ ok: boolean, errors: Array<Object> }>} */
-    async execute(integrationId, user) {
-        const instance = await this.getIntegrationInstanceForUser.execute(
-            integrationId,
-            user
-        );
-        const start = Date.now();
-        const authPassed = await instance.testAuth();
-        await instance.reconcileAuthStatus(authPassed);
-        const errors = (instance.record?.messages?.errors || []).filter(
-            ({ timestamp }) => timestamp >= start
-        );
-        return { ok: Boolean(authPassed) && errors.length === 0, errors };
-    }
-}
-
-module.exports = {
-    GetOwnedIntegrationRecord,
-    CreateIntegrationForUser,
-    GetIntegrationInstanceForUser,
-    UpdateIntegrationForUser,
-    RemoveIntegrationForUser,
-    SendIntegrationEventForUser,
-    RunIntegrationActionForUser,
-    TestIntegrationAuthForUser,
-};

package/management-api/create-management-api-router.js

@@ -1,49 +0,0 @@
-const express = require('express');
-const { resolveManagementApiConfig } = require('./management-api-config');
-const {
-    createV1DeprecationRouter,
-    createV1DisabledRouter,
-} = require('./v1-deprecation');
-
-/**
- * The Management API served by the auth Lambda (ADR-053): v2 under /api/v2
- * and the frozen, deprecated v1 at the unprefixed paths. With
- * `managementApi.v1: false` the v1 handlers are never built and the v1 paths
- * answer 410.
- *
- * @param {Object} [params]
- * @param {Object} [params.appDefinition] - defaults to loadAppDefinition().
- * @param {Function} [params.createV1Router] - defaults to createIntegrationRouter.
- * @param {Function} [params.createV2Router] - defaults to createManagementApiV2Router.
- */
-function createManagementApiRouter({
-    appDefinition,
-    createV1Router,
-    createV2Router,
-} = {}) {
-    const definition =
-        appDefinition ||
-        require('../handlers/app-definition-loader').loadAppDefinition();
-    const config = resolveManagementApiConfig(definition.managementApi);
-
-    const buildV1 =
-        createV1Router ||
-        require('../integrations/integration-router').createIntegrationRouter;
-    const buildV2 =
-        createV2Router ||
-        require('./v2/create-v2-router').createManagementApiV2Router;
-
-    const router = express.Router();
-    router.use(buildV2({ appDefinition: definition, config }));
-
-    if (config.v1) {
-        router.use(createV1DeprecationRouter());
-        router.use(buildV1());
-    } else {
-        router.use(createV1DisabledRouter());
-    }
-
-    return router;
-}
-
-module.exports = { createManagementApiRouter };

package/management-api/error-response.js

@@ -1,116 +0,0 @@
-const Boom = require('@hapi/boom');
-
-/**
- * Error responses for the HTTP boundary (handlers/app-handler-helpers.js).
- *
- * - v1 and other unversioned routes keep their historical body:
- *   `{ error: message }` for 4xx, `{ error: 'Internal Server Error' }` for 5xx.
- * - Management API v2 and /api/meta answer `{ error: { code, message, details? } }`
- *   and carry `Frigg-API-Version: 2` even when the error happened before any
- *   v2 router ran (for example a body-parser failure).
- */
-
-const API_VERSION_HEADER = 'Frigg-API-Version';
-
-const CODE_BY_STATUS = {
-    400: 'BAD_REQUEST',
-    401: 'UNAUTHORIZED',
-    403: 'FORBIDDEN',
-    404: 'NOT_FOUND',
-    405: 'METHOD_NOT_ALLOWED',
-    409: 'CONFLICT',
-    410: 'GONE',
-    413: 'PAYLOAD_TOO_LARGE',
-    415: 'UNSUPPORTED_MEDIA_TYPE',
-    422: 'UNPROCESSABLE_ENTITY',
-    429: 'RATE_LIMITED',
-    500: 'INTERNAL_ERROR',
-    501: 'NOT_IMPLEMENTED',
-    502: 'BAD_GATEWAY',
-    503: 'SERVICE_UNAVAILABLE',
-    504: 'GATEWAY_TIMEOUT',
-};
-
-// body-parser (via http-errors) tags its failures with `type`.
-const CODE_BY_BODY_PARSER_TYPE = {
-    'entity.parse.failed': 'INVALID_JSON',
-    'entity.too.large': 'PAYLOAD_TOO_LARGE',
-    'encoding.unsupported': 'UNSUPPORTED_MEDIA_TYPE',
-    'charset.unsupported': 'UNSUPPORTED_MEDIA_TYPE',
-    'request.aborted': 'BAD_REQUEST',
-};
-
-/** True for paths that use the v2 error contract. */
-function isVersionedManagementApiPath(path = '') {
-    return (
-        path === '/api/v2' ||
-        path.startsWith('/api/v2/') ||
-        path === '/api/meta' ||
-        path.startsWith('/api/meta/')
-    );
-}
-
-/**
- * The HTTP status for an error. Boom errors carry theirs. Other errors are
- * trusted only when they declare a client error as safe to expose, as
- * http-errors (and so body-parser) does; anything else is a 500, so an
- * upstream FetchError's `statusCode` is never mistaken for ours.
- */
-function resolveStatusCode(err) {
-    if (err?.isBoom) return err.output.statusCode;
-    const status = err?.status ?? err?.statusCode;
-    if (
-        err?.expose === true &&
-        Number.isInteger(status) &&
-        status >= 400 &&
-        status < 500
-    ) {
-        return status;
-    }
-    return 500;
-}
-
-/** Normalises any thrown value into a Boom error with the right status. */
-function toBoom(err) {
-    if (err?.isBoom) return err;
-    const error = err instanceof Error ? err : new Error(String(err));
-    return Boom.boomify(error, { statusCode: resolveStatusCode(err) });
-}
-
-/** The v2 error body for a Boom error. */
-function toV2ErrorBody(boomError) {
-    const statusCode = boomError.output.statusCode;
-    const data =
-        boomError.data && typeof boomError.data === 'object'
-            ? boomError.data
-            : {};
-    const exposeServerError = statusCode >= 500 && data.expose === true;
-
-    const code =
-        (typeof data.code === 'string' && data.code) ||
-        CODE_BY_BODY_PARSER_TYPE[boomError.type] ||
-        CODE_BY_STATUS[statusCode] ||
-        (statusCode >= 500 ? 'INTERNAL_ERROR' : 'BAD_REQUEST');
-
-    const message =
-        statusCode < 500 || exposeServerError
-            ? boomError.message
-            : 'Internal Server Error';
-
-    const body = { code, message };
-    if (
-        data.details !== undefined &&
-        (statusCode < 500 || exposeServerError)
-    ) {
-        body.details = data.details;
-    }
-    return { error: body };
-}
-
-module.exports = {
-    API_VERSION_HEADER,
-    isVersionedManagementApiPath,
-    resolveStatusCode,
-    toBoom,
-    toV2ErrorBody,
-};

package/management-api/management-api-config.js

@@ -1,82 +0,0 @@
-/**
- * Resolves `appDefinition.managementApi` (ADR-052, ADR-053).
- *
- * ```js
- * managementApi: {
- *     v1: false,              // drop the deprecated v1 routes (default true)
- *     proxy: {
- *         enable: true,       // entity proxy, off by default (ADR-052)
- *         timeoutMs: 25000,   // whole upstream call, lower only
- *         maxRequestBytes: 1048576,
- *         maxResponseBytes: 5242880, // lower only
- *         modules: {          // per-module allow-list override
- *             hubspot: { allow: 'module' },
- *             erp: { allow: [{ method: 'GET', path: '/v1/customers/**' }] },
- *         },
- *     },
- * }
- * ```
- */
-
-// ADR-052 §7. API Gateway HTTP APIs time out at 30s and Lambda responses cap
-// at 6MB, so the timeout and response defaults are also ceilings: an app may
-// lower them, not raise them.
-const DEFAULT_PROXY_LIMITS = Object.freeze({
-    timeoutMs: 25_000,
-    maxRequestBytes: 1024 * 1024,
-    maxResponseBytes: 5 * 1024 * 1024,
-});
-
-// The request-body limit has no platform ceiling below API Gateway's 10MB, so
-// an app may raise it up to that.
-const MAX_REQUEST_BYTES_CEILING = 10 * 1024 * 1024;
-
-const isPositiveNumber = (value) =>
-    typeof value === 'number' && Number.isFinite(value) && value > 0;
-
-/** The value, capped at `ceiling`; the ceiling when the value is unusable. */
-function positiveCapped(value, ceiling) {
-    return isPositiveNumber(value) ? Math.min(value, ceiling) : ceiling;
-}
-
-/** The value, capped at `ceiling`; `fallback` when the value is unusable. */
-function positiveOr(value, fallback, ceiling) {
-    return isPositiveNumber(value) ? Math.min(value, ceiling) : fallback;
-}
-
-/**
- * @param {Object} [managementApi] - `appDefinition.managementApi`
- * @returns {{ v1: boolean, proxy: { enable: boolean, timeoutMs: number, maxRequestBytes: number, maxResponseBytes: number, modules: Object } }}
- */
-function resolveManagementApiConfig(managementApi) {
-    const config =
-        managementApi && typeof managementApi === 'object' ? managementApi : {};
-    const proxy =
-        config.proxy && typeof config.proxy === 'object' ? config.proxy : {};
-
-    return {
-        v1: config.v1 !== false,
-        proxy: {
-            enable: proxy.enable === true,
-            timeoutMs: positiveCapped(
-                proxy.timeoutMs,
-                DEFAULT_PROXY_LIMITS.timeoutMs
-            ),
-            maxRequestBytes: positiveOr(
-                proxy.maxRequestBytes,
-                DEFAULT_PROXY_LIMITS.maxRequestBytes,
-                MAX_REQUEST_BYTES_CEILING
-            ),
-            maxResponseBytes: positiveCapped(
-                proxy.maxResponseBytes,
-                DEFAULT_PROXY_LIMITS.maxResponseBytes
-            ),
-            modules:
-                proxy.modules && typeof proxy.modules === 'object'
-                    ? proxy.modules
-                    : {},
-        },
-    };
-}
-
-module.exports = { resolveManagementApiConfig, DEFAULT_PROXY_LIMITS };

package/management-api/meta-router.js

@@ -1,57 +0,0 @@
-const { Router } = require('express');
-const Boom = require('@hapi/boom');
-const { resolveManagementApiConfig } = require('./management-api-config');
-const {
-    GetManagementApiMeta,
-} = require('./use-cases/get-management-api-meta');
-const { isValidAdminApiKey } = require('../handlers/middleware/admin-auth');
-const { version: coreVersion } = require('../package.json');
-const { MANAGEMENT_API_VERSIONS } = require('./route-registry');
-const { buildOpenApiDocument } = require('./openapi/build-openapi');
-
-/**
- * Version-neutral discovery routes (ADR-053 §4, §5), mounted on the DB-free
- * health Lambda. No authentication: the admin API key only adds the core
- * version to the response.
- *
- * @param {Object} params
- * @param {Object} params.appDefinition - the loaded app definition
- *   (`managementApi` is read).
- */
-function createManagementApiMetaRouter({ appDefinition = {} } = {}) {
-    const config = resolveManagementApiConfig(appDefinition.managementApi);
-    const getMeta = new GetManagementApiMeta({ config, coreVersion });
-
-    const router = Router();
-
-    router.get('/api/meta', (req, res) => {
-        const isAdmin = isValidAdminApiKey(req.get('x-frigg-admin-api-key'));
-        res.set('Cache-Control', 'no-store');
-        res.json(getMeta.execute({ isAdmin }));
-    });
-
-    // One OpenAPI document per major (ADR-053 §5). Static per deployment, so
-    // built once; the entity proxy appears only when the app enables it.
-    const documents = new Map();
-    for (const major of Object.keys(MANAGEMENT_API_VERSIONS)) {
-        router.get(`/api/meta/openapi/v${major}.json`, (_req, res) => {
-            if (!documents.has(major)) {
-                documents.set(
-                    major,
-                    buildOpenApiDocument(major, { proxy: config.proxy.enable })
-                );
-            }
-            res.set('Cache-Control', 'public, max-age=300');
-            res.json(documents.get(major));
-        });
-    }
-
-    // Anything else under /api/meta is a v2-shaped 404, not Express's page.
-    router.use('/api/meta', (req, _res, next) => {
-        next(Boom.notFound(`No Management API meta route for ${req.method} ${req.originalUrl.split('?')[0]}`));
-    });
-
-    return router;
-}
-
-module.exports = { createManagementApiMetaRouter };

package/management-api/openapi/build-openapi.js

@@ -1,144 +0,0 @@
-const {
-    MANAGEMENT_API_VERSIONS,
-    V1_ROUTES,
-    META_ROUTES,
-    V1_MIGRATION_DOCS_URL,
-    listV2Routes,
-    toGatewayPath,
-} = require('../route-registry');
-const { SCHEMAS, RESPONSES, SECURITY_SCHEMES } = require('./components');
-const { V2_OPERATIONS, META_OPERATIONS } = require('./v2-operations');
-const { V1_OPERATIONS } = require('./v1-operations');
-const { version: coreVersion } = require('../../package.json');
-
-const COMPATIBILITY_RULES = `
-Compatibility (ADR-053): within a major, changes are additive only. Clients
-must ignore response fields and enum values they do not know. Operations
-marked \`x-frigg-stability: beta\` may still change in a core minor.
-
-Errors: \`{ "error": { "code", "message", "details"? } }\`. Every response
-carries \`Frigg-API-Version: 2\`.`;
-
-const DESCRIPTIONS = {
-    1: `The original, unprefixed Management API. Deprecated (ADR-053): every response carries
-\`Deprecation\` and \`Link: <${V1_MIGRATION_DOCS_URL}>; rel="deprecation"\`. It is frozen,
-and \`managementApi.v1: false\` turns it off. Use v2.`,
-    2: `Integrations, entities, credentials, multi-step authorization and the entity proxy, under
-\`/api/v2\`. Discover what a deployment serves with \`GET /api/meta\`.
-${COMPATIBILITY_RULES}`,
-};
-
-const TAGS = [
-    { name: 'Integrations', description: 'Integrations between connected entities' },
-    { name: 'Entities', description: 'Connected accounts, entity types and the entity proxy' },
-    { name: 'Credentials', description: 'Stored credentials (always masked) and re-authorization' },
-    { name: 'Authorization', description: 'Single- and multi-step authorization' },
-    { name: 'Meta', description: 'Version-neutral discovery' },
-];
-
-/** Path parameters, derived from the Express path. */
-function pathParameters(expressPath) {
-    return [...expressPath.matchAll(/:([A-Za-z0-9_]+)/g)].map(([, name]) => ({
-        name,
-        in: 'path',
-        required: true,
-        schema: { type: 'string' },
-    }));
-}
-
-function operationFor(route, docs, extra = {}) {
-    if (!docs) {
-        throw new Error(
-            `No OpenAPI documentation for ${route.method} ${route.path} (${route.operationId || 'v1'})`
-        );
-    }
-    const parameters = [...pathParameters(route.path), ...(docs.parameters || [])];
-    return {
-        operationId: route.operationId,
-        ...(route.tag && { tags: [route.tag] }),
-        ...docs,
-        ...(parameters.length && { parameters }),
-        ...(route.stability && { 'x-frigg-stability': route.stability }),
-        ...extra,
-    };
-}
-
-function addOperation(paths, route, operation) {
-    const path = toGatewayPath(route.path);
-    paths[path] = paths[path] || {};
-    // An ANY route (router.all in v1) is documented as GET and POST, the two
-    // methods callers use.
-    const methods = route.method === 'ANY' ? ['get', 'post'] : [route.method.toLowerCase()];
-    for (const method of methods) {
-        paths[path][method] = {
-            ...operation,
-            ...(methods.length > 1 && {
-                operationId: `${operation.operationId}${method === 'get' ? '' : 'Post'}`,
-            }),
-        };
-    }
-}
-
-/**
- * Builds the OpenAPI 3 document for one Management API major from the route
- * registry (ADR-053 §5).
- *
- * @param {string} major - '1' or '2'
- * @param {Object} [options]
- * @param {boolean} [options.proxy=true] - include the entity proxy (served
- *   documents follow managementApi.proxy.enable)
- * @returns {Object}
- */
-function buildOpenApiDocument(major, { proxy = true } = {}) {
-    const info = MANAGEMENT_API_VERSIONS[major];
-    if (!info) throw new Error(`Unknown Management API version: ${major}`);
-
-    const paths = {};
-    if (major === '1') {
-        for (const route of V1_ROUTES) {
-            const key = `${route.method} ${route.path}`;
-            addOperation(
-                paths,
-                route,
-                operationFor({ ...route, operationId: V1_OPERATIONS[key]?.operationId }, V1_OPERATIONS[key], {
-                    deprecated: true,
-                })
-            );
-        }
-    } else {
-        for (const route of listV2Routes({ proxy })) {
-            addOperation(paths, route, operationFor(route, V2_OPERATIONS[route.operationId]));
-        }
-    }
-    for (const route of META_ROUTES) {
-        addOperation(
-            paths,
-            route,
-            operationFor({ ...route, tag: 'Meta' }, META_OPERATIONS[route.operationId])
-        );
-    }
-
-    return {
-        openapi: '3.0.3',
-        info: {
-            title: `Frigg Management API v${major}`,
-            version: coreVersion,
-            description: DESCRIPTIONS[major],
-            license: { name: 'MIT' },
-        },
-        'x-frigg-api-version': major,
-        'x-frigg-api-status': info.status,
-        ...(info.deprecatedAt && { 'x-frigg-deprecated-at': info.deprecatedAt }),
-        servers: [{ url: '/', description: 'This Frigg deployment' }],
-        security: [{ bearerAuth: [] }, { friggApiKey: [] }],
-        tags: TAGS,
-        paths,
-        components: {
-            schemas: SCHEMAS,
-            responses: RESPONSES,
-            securitySchemes: SECURITY_SCHEMES,
-        },
-    };
-}
-
-module.exports = { buildOpenApiDocument };