@friggframework/core 2.0.0--canary.690.08cd07e.0 → 2.0.0--canary.693.d8859c2.0

package/modules/repositories/authorization-session-repository-documentdb.js

@@ -1,112 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    findOne,
-    insertOne,
-    updateOne,
-    deleteMany,
-} = require('../../database/documentdb-utils');
-const {
-    DocumentDBEncryptionService,
-} = require('../../database/documentdb-encryption-service');
-const { AuthorizationSession } = require('../domain/authorization-session');
-const {
-    AuthorizationSessionRepositoryInterface,
-} = require('./authorization-session-repository-interface');
-
-const COLLECTION = 'AuthorizationSession';
-
-/**
- * AuthorizationSession persistence for DocumentDB through raw commands.
- * `stepData` is encrypted with DocumentDBEncryptionService, as the Prisma
- * extension does not run for raw commands.
- */
-class AuthorizationSessionRepositoryDocumentDB extends AuthorizationSessionRepositoryInterface {
-    constructor() {
-        super();
-        this.prisma = prisma;
-        this.encryptionService = new DocumentDBEncryptionService();
-    }
-
-    async create(session) {
-        const now = new Date();
-        const document = await this.encryptionService.encryptFields(COLLECTION, {
-            sessionId: session.sessionId,
-            userId: session.userId,
-            entityType: session.entityType,
-            credentialId: session.credentialId,
-            currentStep: session.currentStep,
-            maxSteps: session.maxSteps,
-            stepData: session.stepData,
-            expiresAt: session.expiresAt,
-            completed: session.completed,
-            createdAt: now,
-            updatedAt: now,
-        });
-        await insertOne(this.prisma, COLLECTION, document);
-        return this._toDomain(
-            await this.encryptionService.decryptFields(COLLECTION, document)
-        );
-    }
-
-    async findBySessionId(sessionId) {
-        if (typeof sessionId !== 'string' || !sessionId) return null;
-        const document = await findOne(this.prisma, COLLECTION, {
-            sessionId,
-            expiresAt: { $gt: new Date() },
-        });
-        if (!document) return null;
-        return this._toDomain(
-            await this.encryptionService.decryptFields(COLLECTION, document)
-        );
-    }
-
-    async update(session) {
-        const encrypted = await this.encryptionService.encryptFields(COLLECTION, {
-            stepData: session.stepData,
-        });
-        await updateOne(
-            this.prisma,
-            COLLECTION,
-            { sessionId: session.sessionId },
-            {
-                $set: {
-                    currentStep: session.currentStep,
-                    stepData: encrypted.stepData,
-                    completed: session.completed,
-                    updatedAt: new Date(),
-                },
-            }
-        );
-        return session;
-    }
-
-    async deleteBySessionId(sessionId) {
-        const result = await deleteMany(this.prisma, COLLECTION, { sessionId });
-        return result?.n ?? 0;
-    }
-
-    async deleteExpired(now = new Date()) {
-        const result = await deleteMany(this.prisma, COLLECTION, {
-            expiresAt: { $lte: now },
-        });
-        return result?.n ?? 0;
-    }
-
-    _toDomain(document) {
-        return new AuthorizationSession({
-            sessionId: document.sessionId,
-            userId: document.userId,
-            entityType: document.entityType,
-            credentialId: document.credentialId ?? null,
-            currentStep: document.currentStep,
-            maxSteps: document.maxSteps,
-            stepData: document.stepData || {},
-            expiresAt: new Date(document.expiresAt),
-            completed: Boolean(document.completed),
-            createdAt: document.createdAt,
-            updatedAt: document.updatedAt,
-        });
-    }
-}
-
-module.exports = { AuthorizationSessionRepositoryDocumentDB };

package/modules/repositories/authorization-session-repository-factory.js

@@ -1,31 +0,0 @@
-const config = require('../../database/config');
-const {
-    AuthorizationSessionRepositoryPrisma,
-} = require('./authorization-session-repository-prisma');
-const {
-    AuthorizationSessionRepositoryDocumentDB,
-} = require('./authorization-session-repository-documentdb');
-
-/**
- * AuthorizationSession repository for the configured database. PostgreSQL
- * and MongoDB share the Prisma adapter; DocumentDB uses raw commands.
- */
-function createAuthorizationSessionRepository() {
-    switch (config.DB_TYPE) {
-        case 'mongodb':
-        case 'postgresql':
-            return new AuthorizationSessionRepositoryPrisma();
-        case 'documentdb':
-            return new AuthorizationSessionRepositoryDocumentDB();
-        default:
-            throw new Error(
-                `Unsupported database type: ${config.DB_TYPE}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
-            );
-    }
-}
-
-module.exports = {
-    createAuthorizationSessionRepository,
-    AuthorizationSessionRepositoryPrisma,
-    AuthorizationSessionRepositoryDocumentDB,
-};

package/modules/repositories/authorization-session-repository-interface.js

@@ -1,47 +0,0 @@
-/**
- * Port for persisting AuthorizationSession records (Management API v2
- * multi-step authorization). Adapters return AuthorizationSession domain
- * objects and never expired sessions from lookups.
- */
-class AuthorizationSessionRepositoryInterface {
-    /**
-     * @param {import('../domain/authorization-session').AuthorizationSession} session
-     * @returns {Promise<import('../domain/authorization-session').AuthorizationSession>}
-     */
-    async create(session) {
-        throw new Error('Method create must be implemented by subclass');
-    }
-
-    /**
-     * @param {string} sessionId
-     * @returns {Promise<import('../domain/authorization-session').AuthorizationSession|null>}
-     *   null when missing or expired.
-     */
-    async findBySessionId(sessionId) {
-        throw new Error('Method findBySessionId must be implemented by subclass');
-    }
-
-    /**
-     * Saves currentStep, stepData and completed.
-     * @param {import('../domain/authorization-session').AuthorizationSession} session
-     */
-    async update(session) {
-        throw new Error('Method update must be implemented by subclass');
-    }
-
-    /** @param {string} sessionId */
-    async deleteBySessionId(sessionId) {
-        throw new Error('Method deleteBySessionId must be implemented by subclass');
-    }
-
-    /**
-     * Removes sessions that expired before `now`.
-     * @param {Date} [now]
-     * @returns {Promise<number>} how many were removed
-     */
-    async deleteExpired(now) {
-        throw new Error('Method deleteExpired must be implemented by subclass');
-    }
-}
-
-module.exports = { AuthorizationSessionRepositoryInterface };

package/modules/repositories/authorization-session-repository-prisma.js

@@ -1,87 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const { AuthorizationSession } = require('../domain/authorization-session');
-const {
-    AuthorizationSessionRepositoryInterface,
-} = require('./authorization-session-repository-interface');
-
-/**
- * AuthorizationSession persistence through the Prisma client, for PostgreSQL
- * and MongoDB (both schemas declare the same model; the session id, not the
- * row id, is the key, so no id conversion is needed). `stepData` is
- * encrypted by the Prisma encryption extension (encryption-schema-registry).
- */
-class AuthorizationSessionRepositoryPrisma extends AuthorizationSessionRepositoryInterface {
-    constructor(prismaClient = prisma) {
-        super();
-        this.prisma = prismaClient;
-    }
-
-    async create(session) {
-        const record = await this.prisma.authorizationSession.create({
-            data: {
-                sessionId: session.sessionId,
-                userId: session.userId,
-                entityType: session.entityType,
-                credentialId: session.credentialId,
-                currentStep: session.currentStep,
-                maxSteps: session.maxSteps,
-                stepData: session.stepData,
-                expiresAt: session.expiresAt,
-                completed: session.completed,
-            },
-        });
-        return toDomain(record);
-    }
-
-    async findBySessionId(sessionId) {
-        if (typeof sessionId !== 'string' || !sessionId) return null;
-        const record = await this.prisma.authorizationSession.findFirst({
-            where: { sessionId, expiresAt: { gt: new Date() } },
-        });
-        return record ? toDomain(record) : null;
-    }
-
-    async update(session) {
-        const record = await this.prisma.authorizationSession.update({
-            where: { sessionId: session.sessionId },
-            data: {
-                currentStep: session.currentStep,
-                stepData: session.stepData,
-                completed: session.completed,
-            },
-        });
-        return toDomain(record);
-    }
-
-    async deleteBySessionId(sessionId) {
-        const result = await this.prisma.authorizationSession.deleteMany({
-            where: { sessionId },
-        });
-        return result.count;
-    }
-
-    async deleteExpired(now = new Date()) {
-        const result = await this.prisma.authorizationSession.deleteMany({
-            where: { expiresAt: { lte: now } },
-        });
-        return result.count;
-    }
-}
-
-function toDomain(record) {
-    return new AuthorizationSession({
-        sessionId: record.sessionId,
-        userId: record.userId,
-        entityType: record.entityType,
-        credentialId: record.credentialId ?? null,
-        currentStep: record.currentStep,
-        maxSteps: record.maxSteps,
-        stepData: record.stepData || {},
-        expiresAt: record.expiresAt,
-        completed: record.completed,
-        createdAt: record.createdAt,
-        updatedAt: record.updatedAt,
-    });
-}
-
-module.exports = { AuthorizationSessionRepositoryPrisma, toDomain };

package/modules/repositories/entity-not-found.js

@@ -1,18 +0,0 @@
-/**
- * The error `findEntityById` throws for an id with no row, and the one
- * predicate that recognises it (as integration-not-found.js does for
- * integrations). The adapters build the error here and use cases match it
- * here, so a missing entity can be told from any other failure without
- * widening a regex.
- *
- * Why it matters: a use case that answers 404 for another tenant's entity must
- * answer the same 404 for an id that does not exist. Otherwise the status code
- * says which ids exist (ADR-052 §3, ADR-056 §3.6).
- */
-const MESSAGE = /^Entity .+ not found$/;
-
-const entityNotFoundError = (id) => new Error(`Entity ${id} not found`);
-
-const isEntityNotFound = (error) => MESSAGE.test(error?.message || '');
-
-module.exports = { entityNotFoundError, isEntityNotFound };

package/modules/requester/proxy-request.js

@@ -1,245 +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] - the module-declared URL of the base the
- *   caller named (ADR-052 amendment; resolved by the use case); 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 };