@friggframework/core 2.0.0--canary.686.df38e8e.0 → 2.0.0--canary.710.9045bbc.0

package/integrations/schedule-config.js

@@ -1,80 +0,0 @@
-/**
- * An integration's schedule configuration (`static Definition.schedule`),
- * read by hosts that tick ONGOING_SYNC from a cron (provider-netlify's
- * scheduled-sync function).
- *
- *   schedule: {
- *       // 'class' (default): one ONGOING_SYNC per integration class per tick,
- *       //   with no integration id: the worker runs it on an unhydrated
- *       //   instance, so the handler finds its own installations.
- *       // 'installation': one ONGOING_SYNC per ENABLED integration record of
- *       //   the class, carrying `data.integrationId`, so the worker hydrates
- *       //   that installation before the handler runs.
- *       scope: 'installation',
- *       // Optional, 'installation' only: (integration, { now }) => boolean |
- *       // Promise<boolean>. Return false to skip that installation this tick.
- *       // Without it every installation is dispatched on every tick.
- *       isDue: (integration, { now }) => true,
- *   }
- *
- * Validated at load (loadAppDefinition) so a mistyped scope stops the app
- * rather than silently falling back to 'class'.
- */
-
-const SCHEDULE_SCOPES = Object.freeze({
-    CLASS: 'class',
-    INSTALLATION: 'installation',
-});
-
-const DEFAULT_SCHEDULE_SCOPE = SCHEDULE_SCOPES.CLASS;
-
-class ScheduleConfigError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ScheduleConfigError';
-        this.code = 'SCHEDULE_CONFIG_INVALID';
-    }
-}
-
-/**
- * @param {Object} [definition] - an integration's static Definition
- * @returns {{ scope: 'class'|'installation', isDue: Function|null }}
- * @throws {ScheduleConfigError} when `schedule` is malformed
- */
-function resolveScheduleConfig(definition) {
-    const name = definition?.name || 'integration';
-    const schedule = definition?.schedule;
-    if (schedule === undefined || schedule === null) {
-        return { scope: DEFAULT_SCHEDULE_SCOPE, isDue: null };
-    }
-    if (typeof schedule !== 'object' || Array.isArray(schedule)) {
-        throw new ScheduleConfigError(`${name}: Definition.schedule must be an object`);
-    }
-
-    const scopes = Object.values(SCHEDULE_SCOPES);
-    const scope = schedule.scope === undefined ? DEFAULT_SCHEDULE_SCOPE : schedule.scope;
-    if (!scopes.includes(scope)) {
-        throw new ScheduleConfigError(
-            `${name}: Definition.schedule.scope must be one of ${scopes.map((s) => `'${s}'`).join(', ')} (got ${JSON.stringify(schedule.scope)})`
-        );
-    }
-
-    const isDue = schedule.isDue === undefined ? null : schedule.isDue;
-    if (isDue !== null && typeof isDue !== 'function') {
-        throw new ScheduleConfigError(`${name}: Definition.schedule.isDue must be a function`);
-    }
-    if (isDue && scope !== SCHEDULE_SCOPES.INSTALLATION) {
-        throw new ScheduleConfigError(
-            `${name}: Definition.schedule.isDue applies to scope 'installation' only`
-        );
-    }
-
-    return { scope, isDue };
-}
-
-module.exports = {
-    SCHEDULE_SCOPES,
-    DEFAULT_SCHEDULE_SCOPE,
-    ScheduleConfigError,
-    resolveScheduleConfig,
-};

package/integrations/use-cases/dispatch-ongoing-syncs.js

@@ -1,100 +0,0 @@
-const {
-    SCHEDULE_SCOPES,
-    resolveScheduleConfig,
-} = require('../schedule-config');
-
-const ONGOING_SYNC_EVENT = 'ONGOING_SYNC';
-const ACTIVE_STATUS = 'ENABLED';
-
-/**
- * Dispatches one cron tick of ONGOING_SYNC to the queue worker, per each
- * integration class's `Definition.schedule.scope` (schedule-config.js):
- *
- * - 'class' (default): one message per class, `data: {}`.
- * - 'installation': one message per ENABLED integration record of the class,
- *   `data: { integrationId }`, so the worker hydrates that installation;
- *   skipped when the definition's `isDue(integration, { now })` says no.
- *
- * Only classes that implement `startOngoingSync` take part. A failure for one
- * class or installation is counted and logged; the rest still go out.
- */
-class DispatchOngoingSyncs {
-    /**
-     * @param {Object} params
-     * @param {Object} params.integrationRepository - findIntegrations({ type, status })
-     * @param {Object} params.queueProvider - send(message, queueId)
-     * @param {string} params.queueId - the worker the messages go to
-     * @param {() => Date} [params.now]
-     * @param {Object} [params.logger=console]
-     */
-    constructor({ integrationRepository, queueProvider, queueId, now = () => new Date(), logger = console }) {
-        this.integrationRepository = integrationRepository;
-        this.queueProvider = queueProvider;
-        this.queueId = queueId;
-        this.now = now;
-        this.logger = logger;
-    }
-
-    /**
-     * @param {Array<Function>} integrationClasses
-     * @returns {Promise<{ dispatched: number, notDue: number, errors: number }>}
-     */
-    async execute(integrationClasses = []) {
-        const result = { dispatched: 0, notDue: 0, errors: 0 };
-        const now = this.now();
-
-        for (const IntegrationClass of integrationClasses) {
-            const name = IntegrationClass?.Definition?.name;
-            if (!name) continue;
-            if (typeof IntegrationClass.prototype?.startOngoingSync !== 'function') continue;
-
-            try {
-                const { scope, isDue } = resolveScheduleConfig(IntegrationClass.Definition);
-                if (scope === SCHEDULE_SCOPES.INSTALLATION) {
-                    await this._dispatchPerInstallation(name, isDue, now, result);
-                } else {
-                    await this._send(name, {});
-                    result.dispatched++;
-                }
-            } catch (error) {
-                result.errors++;
-                this.logger.error(`[ScheduledSync] Failed to dispatch sync for ${name}:`, error.message);
-            }
-        }
-
-        return result;
-    }
-
-    async _dispatchPerInstallation(name, isDue, now, result) {
-        const integrations = await this.integrationRepository.findIntegrations({
-            type: name,
-            status: ACTIVE_STATUS,
-        });
-
-        for (const integration of integrations || []) {
-            try {
-                if (isDue && (await isDue(integration, { now })) !== true) {
-                    result.notDue++;
-                    continue;
-                }
-                await this._send(name, { integrationId: integration.id });
-                result.dispatched++;
-            } catch (error) {
-                result.errors++;
-                this.logger.error(
-                    `[ScheduledSync] Failed to dispatch sync for ${name} integration ${integration?.id}:`,
-                    error.message
-                );
-            }
-        }
-    }
-
-    _send(integrationName, data) {
-        return this.queueProvider.send(
-            { integrationName, event: ONGOING_SYNC_EVENT, data },
-            this.queueId
-        );
-    }
-}
-
-module.exports = { DispatchOngoingSyncs, ONGOING_SYNC_EVENT };

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

@@ -1,256 +0,0 @@
-const Boom = require('@hapi/boom');
-const { describeRecord } = require('../../modules/scope-visibility');
-const { DEFAULT_SCOPE_POLICY } = require('../../modules/scope-policy');
-const { assertCanManage } = require('../../modules/use-cases/manage-access');
-const { isIntegrationNotFound } = require('../repositories/integration-not-found');
-
-/**
- * Management API v2 integration operations. They put an access check
- * (missing or unavailable integration = 404) in front of the existing
- * integration use cases, and pass the record's owner id on. Access follows
- * the owner and the organization the integration was created in (ADR-056
- * §3.6), not the owner alone.
- */
-
-const notFound = (integrationId) =>
-    Boom.notFound(`Integration ${integrationId} not found`, {
-        code: 'INTEGRATION_NOT_FOUND',
-    });
-
-/**
- * The integration record, or 404 when it is missing or the caller may not
- * use it: not theirs or their active organization's, or created in another
- * organization.
- */
-class GetOwnedIntegrationRecord {
-    constructor({ integrationRepository, scopePolicy }) {
-        this.integrationRepository = integrationRepository;
-        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
-    }
-
-    /** `{ scope, owner, organizationId, access }` of a record to this caller, or null. */
-    describe(record, user) {
-        return describeRecord(record, this.scopePolicy.accessContext(user), 'integration');
-    }
-
-    /**
-     * @param {string} integrationId
-     * @param {Object} user - authenticated User
-     * @param {{manage?: boolean}} [options] - `manage: true` for changing or
-     *   deleting: a person may use an organization's integration but only an
-     *   admin may change it (403 ORG_ADMIN_REQUIRED)
-     */
-    async execute(integrationId, user, { manage = false } = {}) {
-        let record = null;
-        try {
-            record = await this.integrationRepository.findIntegrationById(
-                integrationId
-            );
-        } catch (error) {
-            if (
-                /Invalid ID|ObjectId|Malformed/i.test(error?.message || '') ||
-                isIntegrationNotFound(error)
-            ) {
-                throw notFound(integrationId);
-            }
-            throw error;
-        }
-        const tenancy = record && this.describe(record, user);
-        if (!tenancy) throw notFound(integrationId);
-        if (manage) assertCanManage(tenancy.access, `integration ${integrationId}`);
-        return record;
-    }
-}
-
-/**
- * Creates (or reuses) an integration between entities the caller may use.
- * The entities' access, the binding scopes and the integration type are
- * checked before anything is written, and the integration is owned and
- * paired with an organization by `resolveIntegrationOwnership` (§3, §3.6).
- */
-class CreateIntegrationForUser {
-    constructor({ createIntegration, resolveIntegrationOwnership, integrationClasses }) {
-        this.createIntegration = createIntegration;
-        this.resolveIntegrationOwnership = resolveIntegrationOwnership;
-        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' },
-            });
-        }
-        const { ownerId, organizationId, adoptUnscoped } =
-            await this.resolveIntegrationOwnership.execute({
-                entityIds: entities,
-                config,
-                user,
-            });
-        return this.createIntegration.execute(
-            entities.map(String),
-            ownerId,
-            config,
-            { organizationId, adoptUnscoped }
-        );
-    }
-}
-
-/** 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,
-            { manage: true }
-        );
-        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,
-            { manage: true }
-        );
-        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/integrations/use-cases/resolve-integration-ownership.js

@@ -1,177 +0,0 @@
-const Boom = require('@hapi/boom');
-const { SCOPES, resolveScope } = require('../../modules/scope-resolution');
-const {
-    integrationOwnerKind,
-    resolveIntegrationOwner,
-} = require('../../modules/scope-resolution');
-const {
-    describeRecord,
-    unscopedRowsBelongHere,
-} = require('../../modules/scope-visibility');
-const {
-    bindingScopeSetting,
-    readIntegrationOwnership,
-} = require('../../modules/scope-config');
-const { DEFAULT_SCOPE_POLICY } = require('../../modules/scope-policy');
-const { entityTypeNameOf } = require('../../modules/entity-type-registry');
-
-const notFound = (entityId) =>
-    Boom.notFound(`Entity ${entityId} not found`, { code: 'ENTITY_NOT_FOUND' });
-
-/**
- * Who owns an integration about to be created, and in which organization
- * (ADR-056 §3, §3.3, §3.6). Shared by the v1 and v2 create paths. Nothing is
- * persisted before this has answered, so a refusal leaves no row behind.
- *
- * Every entity must be one the caller may use in the active organization. A
- * missing one, another organization's and a `global` one are the same 404, so
- * ids cannot be probed. When the integration declares a scope (a binding's
- * `scope` or `Definition.entities[key].scope`, or `Definition.ownership.scope`)
- * the entity's scope must be in it. Levels below the integration (entity type,
- * app, default) decide where a connection is CREATED and do not restrict what
- * an integration may bind, so an app that adds a registry scope later does not
- * break integrations that already use older connections.
- *
- * The owner follows the entities (all organization: the organization;
- * otherwise the person) unless `Definition.ownership.owner` says. Every entity
- * must then be of the owner's own scope: an integration is loaded by its owner,
- * who must own what it uses, so an integration that mixes an organization
- * entity with a person's own, or that names an owner that does not match, is
- * refused with a 400 here, before anything is written.
- */
-class ResolveIntegrationOwnership {
-    /**
-     * @param {Object} params
-     * @param {import('../../modules/repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository
-     * @param {Array<Function>} params.integrationClasses
-     * @param {Object} [params.scopePolicy] - from createScopePolicy
-     */
-    constructor({ moduleRepository, integrationClasses, scopePolicy }) {
-        this.moduleRepository = moduleRepository;
-        this.integrationClasses = integrationClasses || [];
-        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
-    }
-
-    /**
-     * @param {Object} params
-     * @param {Array<string|number>} params.entityIds
-     * @param {Object} params.config - `{ type }`
-     * @param {Object} params.user - authenticated User
-     * @returns {Promise<{ownerId: string, organizationId: (string|null), ownerKind: string, adoptUnscoped: boolean}>}
-     */
-    async execute({ entityIds, config, user }) {
-        const ctx = this.scopePolicy.accessContext(user);
-        const integrationClass = this.integrationClasses.find(
-            (IntegrationClass) => IntegrationClass.Definition?.name === config?.type
-        );
-        const ownership = readIntegrationOwnership(integrationClass);
-
-        const entities = await this.loadEntities(entityIds);
-        const scoped = entities.map((entity) => ({
-            entity,
-            scope: this.acceptedScope({ entity, ctx, integrationClass, ownership }),
-        }));
-
-        const ownerKind = integrationOwnerKind(
-            scoped.map(({ scope }) => scope),
-            ownership.owner
-        );
-        this.assertOneScope(scoped, ownerKind, config?.type);
-        return {
-            ...resolveIntegrationOwner(ownerKind, ctx),
-            ownerKind,
-            // Whether an existing integration with no organization (written
-            // before scoping) is this caller's to reuse. An organization-owned
-            // one is unambiguous: its owner is the organization, whoever asks
-            // and whatever their own legacy pointer says. A person's is theirs
-            // only where scope-visibility says (their legacy organization).
-            adoptUnscoped:
-                ownerKind === SCOPES.ORGANIZATION ||
-                unscopedRowsBelongHere(ctx, 'integration'),
-        };
-    }
-
-    /** Every entity must be of the integration owner's own scope (see the class comment). */
-    assertOneScope(scoped, ownerKind, type) {
-        for (const { entity, scope } of scoped) {
-            if (scope === ownerKind) continue;
-            // The load-time check (resolveOwnershipConfig) only sees declared
-            // scopes; this one sees the entities actually named.
-            if (ownerKind === SCOPES.ORGANIZATION) {
-                throw Boom.badRequest(
-                    "An organization-owned integration cannot use an 'individual' entity: a shared integration must not run on one person's credential",
-                    {
-                        code: 'ORG_INTEGRATION_INDIVIDUAL_ENTITY',
-                        details: { entityId: String(entity.id) },
-                    }
-                );
-            }
-            throw Boom.badRequest(
-                `Integration '${type}' would be owned by the person but uses the organization entity ${entity.id}. An integration must use entities of one scope: all of the person's, or all of the organization's.`,
-                {
-                    code: 'MIXED_ENTITY_SCOPES',
-                    details: { entityId: String(entity.id), scope },
-                }
-            );
-        }
-    }
-
-    async loadEntities(entityIds) {
-        const ids = (entityIds || []).map(String);
-        if (ids.length === 0) return [];
-        let found;
-        try {
-            found = await this.moduleRepository.findEntitiesByIds(ids);
-        } catch (error) {
-            // A malformed id (e.g. not an integer on PostgreSQL) is "not found".
-            if (/Invalid ID|ObjectId|Malformed/i.test(error?.message || '')) {
-                throw notFound(ids[0]);
-            }
-            throw error;
-        }
-        const byId = new Map((found || []).filter(Boolean).map((e) => [String(e.id), e]));
-        return ids.map((id) => {
-            if (!byId.has(id)) throw notFound(id);
-            return byId.get(id);
-        });
-    }
-
-    /** The entity's scope for this caller, or a refusal. */
-    acceptedScope({ entity, ctx, integrationClass, ownership }) {
-        const described = describeRecord(entity, ctx, 'entity');
-        if (!described) throw notFound(entity.id);
-        const { scope } = described;
-
-        const declared = this.declaredScope({ entity, integrationClass, ownership });
-        if (declared && !declared.allow.includes(scope)) {
-            throw Boom.badRequest(
-                `Entity ${entity.id} is ${scope}-scoped, but this integration binds ${entity.moduleName} at ${declared.allow.join(' or ')} scope`,
-                {
-                    code: 'ENTITY_SCOPE_MISMATCH',
-                    details: { entityId: String(entity.id), scope, allowed: declared.allow },
-                }
-            );
-        }
-        return scope;
-    }
-
-    /**
-     * What the integration itself declares for this entity's binding (levels 2
-     * and 3 only), or null when it declares nothing.
-     */
-    declaredScope({ entity, integrationClass, ownership }) {
-        const Definition = integrationClass?.Definition;
-        const key = Object.keys(Definition?.modules || {}).find(
-            (candidate) =>
-                entityTypeNameOf(Definition.modules[candidate]?.definition) ===
-                entity.moduleName
-        );
-        const resolved = resolveScope({
-            binding: key === undefined ? undefined : bindingScopeSetting(Definition, key),
-            integration: ownership.scope,
-        });
-        return resolved.decidedBy === 'default' ? null : resolved;
-    }
-}
-
-module.exports = { ResolveIntegrationOwnership };

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 };