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

package/modules/requester/proxy-request.js

@@ -1,244 +0,0 @@
-const { FetchError } = require('../../errors/fetch-error');
-const { ProxyRequestError } = require('../proxy/proxy-errors');
-const {
-    normalizeProxyPath,
-    joinProxyUrl,
-} = require('../proxy/proxy-path');
-
-const MAX_REDIRECTS = 3;
-
-/**
- * The generic, path-checked request behind the Management API entity proxy
- * (ADR-052 §8). It runs through the requester's own `_request`, so auth
- * headers, token refresh (single-flight), the per-attempt timeout, telemetry
- * and log redaction all apply. What it adds:
- *
- * - the URL is always `module base URL + normalised path`; the caller cannot
- *   name a host, scheme or port;
- * - no backoff retries (the caller decides; a 429 comes back with its
- *   Retry-After), and upstream errors are returned, not thrown;
- * - redirects are handled manually: same origin and under the base path only,
- *   at most three hops, each re-checked with `isAllowedRedirect`;
- * - one deadline for the whole call and a cap on the response body.
- *
- * @param {import('./requester').Requester} requester
- * @param {Object} params
- * @param {string} params.method - upper case
- * @param {string} params.path - caller path, validated here
- * @param {Object} [params.query]
- * @param {Object} [params.headers] - already filtered by the caller's policy
- * @param {string|Buffer} [params.body] - already serialised
- * @param {string} [params.baseUrl] - module-declared proxy base URL; falls
- *   back to the requester's `proxyBaseUrl`, `baseUrl` or `baseURL`
- * @param {number} params.timeoutMs - budget for the whole call
- * @param {number} params.maxResponseBytes
- * @param {(path: string, method: string) => boolean} [params.isAllowedRedirect]
- * @returns {Promise<{ status: number, headers: Object, body: Buffer, contentType: string, redirectBlocked: boolean }>}
- * @throws {ProxyRequestError} INVALID_PROXY_REQUEST, PROXY_NOT_CONFIGURED,
- *   INVALID_CREDENTIALS, TIMEOUT, NETWORK_ERROR, RESPONSE_TOO_LARGE
- */
-async function proxyRequest(requester, params) {
-    const {
-        method,
-        path,
-        query,
-        headers = {},
-        body,
-        baseUrl,
-        timeoutMs,
-        maxResponseBytes,
-        isAllowedRedirect,
-    } = params;
-
-    const normalizedPath = normalizeProxyPath(path);
-    const base =
-        baseUrl ??
-        requester.proxyBaseUrl ??
-        requester.baseUrl ??
-        requester.baseURL;
-    if (!base) {
-        throw new ProxyRequestError(
-            'PROXY_NOT_CONFIGURED',
-            'The module declares no base URL to proxy to'
-        );
-    }
-    const target = joinProxyUrl(base, normalizedPath);
-    const deadline = Date.now() + timeoutMs;
-
-    const run = async () => {
-        let url = target.url;
-        let currentMethod = method;
-        let currentBody = body;
-        let currentQuery = query;
-        for (let hop = 0; ; hop++) {
-            const remaining = deadline - Date.now();
-            if (remaining <= 0) throw timeoutError();
-
-            const response = await requester._request(url, {
-                method: currentMethod,
-                headers: { ...headers },
-                query: currentQuery,
-                body: currentBody,
-                returnFullRes: true,
-                returnErrorResponses: true,
-                noRetry: true,
-                redirect: 'manual',
-                size: maxResponseBytes,
-                timeoutMs: remaining,
-            });
-
-            const location = response.headers.get('location');
-            if (response.status >= 300 && response.status < 400 && location) {
-                const next = sameApiRedirect(location, url, target);
-                const nextMethod = redirectMethod(response.status, currentMethod);
-                if (
-                    next &&
-                    hop < MAX_REDIRECTS &&
-                    (!isAllowedRedirect || isAllowedRedirect(next.path, nextMethod))
-                ) {
-                    if (nextMethod !== currentMethod) currentBody = undefined;
-                    currentMethod = nextMethod;
-                    url = next.url;
-                    currentQuery = undefined;
-                    continue;
-                }
-                return readResponse(response, maxResponseBytes, {
-                    redirectBlocked: !next,
-                });
-            }
-            return readResponse(response, maxResponseBytes, {
-                redirectBlocked: false,
-            });
-        }
-    };
-
-    let timer;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(timeoutError()), timeoutMs);
-    });
-    const work = run();
-    // If the deadline wins, the request still settles later; nothing awaits it.
-    work.catch(() => {});
-    try {
-        return await Promise.race([work, timeout]);
-    } catch (error) {
-        throw toProxyError(error);
-    } finally {
-        clearTimeout(timer);
-    }
-}
-
-function timeoutError() {
-    return new ProxyRequestError('TIMEOUT', 'The upstream API did not answer in time');
-}
-
-/**
- * A redirect target the proxy may follow: same origin as the module base URL
- * and under its base path. Returns null for anything else.
- */
-function sameApiRedirect(location, currentUrl, target) {
-    let next;
-    try {
-        next = new URL(location, currentUrl);
-    } catch {
-        return null;
-    }
-    if (next.origin !== target.origin || next.protocol !== 'https:') return null;
-    let decodedPath;
-    try {
-        decodedPath = decodeURIComponent(next.pathname);
-    } catch {
-        return null;
-    }
-    if (
-        !(decodedPath === target.basePath || decodedPath.startsWith(`${target.basePath}/`))
-    ) {
-        return null;
-    }
-    const relativePath = decodedPath.slice(target.basePath.length) || '/';
-    let checkedPath;
-    try {
-        checkedPath = normalizeProxyPath(relativePath);
-    } catch {
-        return null;
-    }
-    // _rawRequest percent-encodes the URL once, so hand it the decoded form.
-    return {
-        url: `${target.origin}${target.basePath}${checkedPath}${next.search ? decodeURI(next.search) : ''}`,
-        path: checkedPath,
-    };
-}
-
-/** Method for the next hop, as fetch does it. */
-function redirectMethod(status, method) {
-    if (status === 303 && method !== 'HEAD') return 'GET';
-    if ((status === 301 || status === 302) && method === 'POST') return 'GET';
-    return method;
-}
-
-async function readResponse(response, maxResponseBytes, { redirectBlocked }) {
-    const declaredLength = Number(response.headers.get('content-length'));
-    if (Number.isFinite(declaredLength) && declaredLength > maxResponseBytes) {
-        destroyBody(response);
-        throw tooLarge();
-    }
-    const buffer = Buffer.from(await response.arrayBuffer());
-    if (buffer.length > maxResponseBytes) throw tooLarge();
-    const headers = {};
-    response.headers.forEach((value, name) => {
-        headers[name.toLowerCase()] = value;
-    });
-    return {
-        status: response.status,
-        headers,
-        body: buffer,
-        contentType: headers['content-type'] || '',
-        redirectBlocked,
-    };
-}
-
-function destroyBody(response) {
-    try {
-        response.body?.destroy?.();
-    } catch {
-        // nothing to clean up
-    }
-}
-
-function tooLarge() {
-    return new ProxyRequestError(
-        'RESPONSE_TOO_LARGE',
-        'The upstream response is larger than the proxy allows'
-    );
-}
-
-/** Maps requester and fetch failures to the proxy's error codes. */
-function toProxyError(error) {
-    if (error instanceof ProxyRequestError) return error;
-    const causeType = error?.cause?.type ?? error?.type;
-    if (causeType === 'max-size') return tooLarge();
-    if (error?.isTimeout) return timeoutError();
-    if (error instanceof FetchError || error?.name === 'FetchError') {
-        if (error.statusCode === 401) {
-            return new ProxyRequestError(
-                'INVALID_CREDENTIALS',
-                'The upstream API rejected the stored credentials; re-authorize the entity',
-                { upstreamStatus: 401 }
-            );
-        }
-        if (!error.statusCode) {
-            return new ProxyRequestError(
-                'NETWORK_ERROR',
-                'Could not reach the upstream API'
-            );
-        }
-        return new ProxyRequestError(
-            'UPSTREAM_ERROR',
-            'The upstream API returned an error',
-            { upstreamStatus: error.statusCode }
-        );
-    }
-    return error;
-}
-
-module.exports = { proxyRequest, MAX_REDIRECTS };

package/modules/tests/doubles/in-memory-authorization-session-repository.js

@@ -1,45 +0,0 @@
-const { AuthorizationSession } = require('../../domain/authorization-session');
-
-/** In-memory AuthorizationSession repository for tests. */
-class InMemoryAuthorizationSessionRepository {
-    constructor() {
-        this.rows = new Map();
-    }
-
-    _copy(session) {
-        return new AuthorizationSession({ ...session, stepData: { ...session.stepData } });
-    }
-
-    async create(session) {
-        this.rows.set(session.sessionId, this._copy(session));
-        return this._copy(session);
-    }
-
-    async findBySessionId(sessionId) {
-        const row = this.rows.get(sessionId);
-        if (!row || row.isExpired()) return null;
-        return this._copy(row);
-    }
-
-    async update(session) {
-        this.rows.set(session.sessionId, this._copy(session));
-        return this._copy(session);
-    }
-
-    async deleteBySessionId(sessionId) {
-        return this.rows.delete(sessionId) ? 1 : 0;
-    }
-
-    async deleteExpired(now = new Date()) {
-        let removed = 0;
-        for (const [id, row] of this.rows) {
-            if (row.isExpired(now)) {
-                this.rows.delete(id);
-                removed++;
-            }
-        }
-        return removed;
-    }
-}
-
-module.exports = { InMemoryAuthorizationSessionRepository };

package/modules/use-cases/entity-operations-for-user.js

@@ -1,125 +0,0 @@
-const Boom = require('@hapi/boom');
-
-/**
- * Management API v2 entity operations. Each one starts from
- * GetEntityModuleForUser, so ownership is checked the same way everywhere
- * (missing or foreign entity = 404).
- */
-
-/** The caller's connected entities. */
-class ListEntitiesForUser {
-    constructor({ moduleRepository }) {
-        this.moduleRepository = moduleRepository;
-    }
-
-    /** @param {Object} user - authenticated User */
-    async execute(user) {
-        const entities = await this.moduleRepository.findEntitiesByUserId(
-            user.getId()
-        );
-        return Array.isArray(entities) ? entities : [];
-    }
-}
-
-/** One entity the caller owns. */
-class GetEntityForUser {
-    constructor({ getEntityModuleForUser }) {
-        this.getEntityModuleForUser = getEntityModuleForUser;
-    }
-
-    async execute(entityId, user) {
-        return this.getEntityModuleForUser.loadOwnedEntity(entityId, user);
-    }
-}
-
-/** Runs the module's testAuthRequest against the stored credential. */
-class TestEntityAuthForUser {
-    constructor({ getEntityModuleForUser }) {
-        this.getEntityModuleForUser = getEntityModuleForUser;
-    }
-
-    /** @returns {Promise<boolean>} */
-    async execute(entityId, user) {
-        const { module } = await this.getEntityModuleForUser.execute(
-            entityId,
-            user
-        );
-        return Boolean(await module.testAuth());
-    }
-}
-
-/** The module's entity options (e.g. objects a user can pick). */
-class GetEntityOptionsForUser {
-    constructor({ getEntityModuleForUser }) {
-        this.getEntityModuleForUser = getEntityModuleForUser;
-    }
-
-    async execute(entityId, user) {
-        const { module } = await this.getEntityModuleForUser.execute(
-            entityId,
-            user
-        );
-        return module.getEntityOptions();
-    }
-}
-
-/** Refreshes the module's entity options with caller input, then returns them. */
-class RefreshEntityOptionsForUser {
-    constructor({ getEntityModuleForUser }) {
-        this.getEntityModuleForUser = getEntityModuleForUser;
-    }
-
-    async execute(entityId, user, options = {}) {
-        const { module } = await this.getEntityModuleForUser.execute(
-            entityId,
-            user
-        );
-        return module.refreshEntityOptions(options);
-    }
-}
-
-/**
- * Deletes an entity the caller owns. Refuses with 409 while integrations
- * still use it, so an integration never points at a missing entity. The
- * credential is left alone (others may share it); delete it through
- * /api/v2/credentials.
- */
-class DeleteEntityForUser {
-    constructor({ getEntityModuleForUser, moduleRepository, integrationRepository }) {
-        this.getEntityModuleForUser = getEntityModuleForUser;
-        this.moduleRepository = moduleRepository;
-        this.integrationRepository = integrationRepository;
-    }
-
-    async execute(entityId, user) {
-        const entity = await this.getEntityModuleForUser.loadOwnedEntity(
-            entityId,
-            user
-        );
-        const integrations =
-            (await this.integrationRepository.findIntegrationsByEntityId(
-                entity.id
-            )) || [];
-        if (integrations.length > 0) {
-            throw Boom.conflict(
-                `Entity ${entity.id} is used by ${integrations.length} integration(s); delete them first`,
-                {
-                    code: 'ENTITY_IN_USE',
-                    details: {
-                        integrationIds: integrations.map((i) => String(i.id)),
-                    },
-                }
-            );
-        }
-        await this.moduleRepository.deleteEntity(entity.id);
-    }
-}
-
-module.exports = {
-    ListEntitiesForUser,
-    GetEntityForUser,
-    TestEntityAuthForUser,
-    GetEntityOptionsForUser,
-    RefreshEntityOptionsForUser,
-    DeleteEntityForUser,
-};

package/modules/use-cases/entity-types.js

@@ -1,115 +0,0 @@
-const Boom = require('@hapi/boom');
-const { ModuleConstants } = require('../ModuleConstants');
-const { usedByOf } = require('../entity-type-registry');
-
-const AUTH_TYPE_BY_REQUESTER = {
-    [ModuleConstants.authType.oauth2]: 'oauth2',
-    [ModuleConstants.authType.oauth1]: 'oauth1',
-    [ModuleConstants.authType.apiKey]: 'api-key',
-    [ModuleConstants.authType.basic]: 'basic',
-};
-
-const callIfFunction = (target, name) =>
-    typeof target?.[name] === 'function' ? target[name]() : undefined;
-
-/** Number of authorization steps a module declares (1 unless multi-step). */
-function getAuthStepCount(definition) {
-    const count = callIfFunction(definition, 'getAuthStepCount');
-    return Number.isInteger(count) && count > 0 ? count : 1;
-}
-
-/**
- * Public description of an API module (an "entity type"). Reads only the
- * definition: display metadata, auth type and step count. Never credentials
- * or env values.
- */
-function describeEntityType(definition, typeName = definition.moduleName) {
-    const stepCount = getAuthStepCount(definition);
-    const display = definition.display || {};
-    const description = {
-        type: typeName,
-        name:
-            callIfFunction(definition, 'getDisplayName') ??
-            display.label ??
-            display.name ??
-            typeName,
-        authType:
-            callIfFunction(definition, 'getAuthType') ??
-            AUTH_TYPE_BY_REQUESTER[definition.API?.requesterType] ??
-            'custom',
-        isMultiStep: stepCount > 1,
-        stepCount,
-    };
-    const text = callIfFunction(definition, 'getDescription') ?? display.description;
-    if (text) description.description = text;
-    const capabilities = callIfFunction(definition, 'getCapabilities');
-    if (capabilities !== undefined) description.capabilities = capabilities;
-    return description;
-}
-
-function findDefinition(moduleDefinitions, entityType) {
-    const definition = moduleDefinitions.find(
-        (def) => def.moduleName === entityType
-    );
-    if (!definition) {
-        throw Boom.notFound(`Entity type '${entityType}' not found`, {
-            code: 'ENTITY_TYPE_NOT_FOUND',
-        });
-    }
-    return definition;
-}
-
-const describeEntry = (name, entry) => ({
-    // The registry key is the name the API uses, whatever the definition spells.
-    ...describeEntityType(entry.definition, name),
-    usedBy: usedByOf(entry),
-});
-
-function requireRegistry(entityTypeRegistry) {
-    if (!(entityTypeRegistry instanceof Map)) {
-        throw new TypeError('entityTypeRegistry is required (see getEntityTypeRegistry)');
-    }
-    return entityTypeRegistry;
-}
-
-/**
- * Lists the entity types this app can authorize: registry entries plus every
- * module an integration binds (ADR-059). `usedBy` names the integrations that
- * bind each type; it is empty for a registry-only type.
- */
-class ListEntityTypes {
-    constructor({ entityTypeRegistry }) {
-        this.registry = requireRegistry(entityTypeRegistry);
-    }
-
-    async execute() {
-        return [...this.registry]
-            .map(([name, entry]) => describeEntry(name, entry))
-            .sort((a, b) => a.name.localeCompare(b.name));
-    }
-}
-
-/** Describes one entity type, looked up by its registry key; 404 when absent. */
-class GetEntityType {
-    constructor({ entityTypeRegistry }) {
-        this.registry = requireRegistry(entityTypeRegistry);
-    }
-
-    async execute(entityType) {
-        const entry = this.registry.get(entityType);
-        if (!entry) {
-            throw Boom.notFound(`Entity type '${entityType}' not found`, {
-                code: 'ENTITY_TYPE_NOT_FOUND',
-            });
-        }
-        return describeEntry(entityType, entry);
-    }
-}
-
-module.exports = {
-    ListEntityTypes,
-    GetEntityType,
-    describeEntityType,
-    getAuthStepCount,
-    findDefinition,
-};