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

package/integrations/integration-router.js

@@ -31,6 +31,9 @@ const {
     GetIntegrationInstance,
 } = require('./use-cases/get-integration-instance');
 const { UpdateIntegration } = require('./use-cases/update-integration');
+const {
+    getModulesDefinitionFromIntegrationClasses,
+} = require('./utils/map-integration-dto');
 const {
     GetModuleInstanceFromType,
 } = require('../modules/use-cases/get-module-instance-from-type');
@@ -71,13 +74,8 @@ const {
 const log = getLogger('frigg.integrations');
 
 function createIntegrationRouter() {
-    // moduleDefinitions is the app registry's definitions (ADR-059), so
-    // /api/authorize and friends accept a type no integration binds.
-    const {
-        integrations: integrationClasses,
-        userConfig,
-        moduleDefinitions,
-    } = loadAppDefinition();
+    const { integrations: integrationClasses, userConfig } =
+        loadAppDefinition();
     const moduleRepository = createModuleRepository();
     const integrationRepository = createIntegrationRepository();
     const credentialRepository = createCredentialRepository();
@@ -110,7 +108,8 @@ function createIntegrationRouter() {
 
     const moduleFactory = new ModuleFactory({
         moduleRepository,
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
     const deleteIntegrationForUser = new DeleteIntegrationForUser({
         integrationRepository,
@@ -137,7 +136,8 @@ function createIntegrationRouter() {
 
     const getEntitiesForUser = new GetEntitiesForUser({
         moduleRepository,
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
     const getIntegrationInstance = new GetIntegrationInstance({
@@ -153,31 +153,37 @@ function createIntegrationRouter() {
     });
 
     const getModuleInstanceFromType = new GetModuleInstanceFromType({
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
     const getEntityOptionsByType = new GetEntityOptionsByType({
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
     const testModuleAuth = new TestModuleAuth({
         moduleRepository,
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
     const getModule = new GetModule({
         moduleRepository,
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
     const getEntityOptionsById = new GetEntityOptionsById({
         moduleRepository,
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
     const refreshEntityOptions = new RefreshEntityOptions({
         moduleRepository,
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
     const getPossibleIntegrations = new GetPossibleIntegrations({
@@ -188,7 +194,8 @@ function createIntegrationRouter() {
         moduleRepository,
         credentialRepository,
         integrationRepository,
-        moduleDefinitions,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
     const router = express();

package/integrations/utils/map-integration-dto.js

@@ -20,4 +20,18 @@ function mapIntegrationClassToIntegrationDTO(integration) {
 }
 
 
-module.exports = { mapIntegrationClassToIntegrationDTO };
+const getModulesDefinitionFromIntegrationClasses = (integrationClasses) => {
+    return [
+        ...new Set(
+            integrationClasses
+                .map((integration) =>
+                    Object.values(integration.Definition.modules).map(
+                        (module) => module.definition
+                    )
+                )
+                .flat()
+        ),
+    ];
+};
+
+module.exports = { mapIntegrationClassToIntegrationDTO, getModulesDefinitionFromIntegrationClasses }; 

package/modules/index.js

@@ -4,10 +4,6 @@ const { OAuth2Requester } = require('./requester/oauth-2');
 const { Requester } = require('./requester/requester');
 const { ModuleConstants } = require('./ModuleConstants');
 const { ModuleFactory } = require('./module-factory');
-const {
-    getEntityTypeRegistry,
-    EntityRegistryError,
-} = require('./entity-type-registry');
 
 module.exports = {
     ApiKeyRequester,
@@ -16,6 +12,4 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    getEntityTypeRegistry,
-    EntityRegistryError,
 };

package/modules/requester/requester.js

@@ -8,7 +8,6 @@ const { getLogger } = require('../../logs');
 const { redactUrl } = require('../../logs/redact');
 const { toSanitizedSurrogate } = require('../../logs/serialize');
 const { getLoggerScope } = require('../../logs/context');
-const { proxyRequest } = require('./proxy-request');
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 
@@ -238,9 +237,7 @@ class Requester extends Delegate {
         // recursion (with its own backoff sleeps) always gets a clean
         // signal. Timer is cleared in the finally block regardless of
         // outcome.
-        // options.timeoutMs lets one call use a tighter budget (the
-        // Management API proxy passes what is left of its deadline).
-        const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs;
+        const timeoutMs = this.requestTimeoutMs;
         const controller = timeoutMs > 0 ? new AbortController() : null;
         const timeoutHandle = controller
             ? setTimeout(() => controller.abort(), timeoutMs)
@@ -278,11 +275,7 @@ class Requester extends Delegate {
                 // stall at batch scale.
                 const isTimeout =
                     e?.name === 'AbortError' || e?.type === 'aborted';
-                if (
-                    e?.code === 'ECONNRESET' &&
-                    !options.noRetry &&
-                    attempt < this.backOff.length
-                ) {
+                if (e?.code === 'ECONNRESET' && attempt < this.backOff.length) {
                     clearRequestTimer();
                     const delay = this.backOff[attempt] * 1000;
                     await new Promise((resolve) => setTimeout(resolve, delay));
@@ -308,7 +301,6 @@ class Requester extends Delegate {
             // If the status is retriable and there are back off requests left, retry the request
             if (
                 (status === 429 || status >= 500) &&
-                !options.noRetry &&
                 attempt < this.backOff.length
             ) {
                 clearRequestTimer();
@@ -394,12 +386,6 @@ class Requester extends Delegate {
             // If the error wasn't retried, throw. FetchError.create reads
             // the response body (response.text()) — timer must still be
             // alive to catch a stalled body stream.
-            // The proxy relays upstream errors to its caller instead of
-            // throwing; 401 keeps the refresh / invalidate handling above.
-            if (status >= 400 && options.returnErrorResponses) {
-                return response;
-            }
-
             if (status >= 400) {
                 this._logRequestFailed(encodedUrl, options, status);
                 const fetchError = await FetchError.create({
@@ -542,17 +528,6 @@ class Requester extends Delegate {
         return res;
     }
 
-    /**
-     * Generic, path-checked request for the Management API entity proxy
-     * (ADR-052 §8). The URL is always the module base URL plus a validated
-     * path; see ./proxy-request.js. Module methods are not involved.
-     *
-     * @param {Object} params - see proxyRequest()
-     */
-    async _proxyRequest(params) {
-        return proxyRequest(this, params);
-    }
-
     async _delete(options) {
         const fetchOptions = {
             method: 'DELETE',

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.680.6bacd26.0",
+    "version": "2.0.0--canary.663.8de669c.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -47,9 +47,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.680.6bacd26.0",
-        "@friggframework/prettier-config": "2.0.0--canary.680.6bacd26.0",
-        "@friggframework/test": "2.0.0--canary.680.6bacd26.0",
+        "@friggframework/eslint-config": "2.0.0--canary.663.8de669c.0",
+        "@friggframework/prettier-config": "2.0.0--canary.663.8de669c.0",
+        "@friggframework/test": "2.0.0--canary.663.8de669c.0",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -89,5 +89,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "6bacd2666932cc417e175260ee2dbf3522740572"
+    "gitHead": "8de669cbe925abbcd0908be6e792e38e2a14ffd8"
 }

package/prisma-mongodb/schema.prisma

@@ -453,30 +453,3 @@ model UsageCounter {
   @@index([metric, integrationType, window])
   @@map("UsageCounter")
 }
-
-// ============================================================================
-// MANAGEMENT API MODELS
-// ============================================================================
-
-/// Multi-step authorization state for Management API v2 (/api/v2/authorize,
-/// /api/v2/credentials/:id/reauthorize). Short-lived: expired documents are
-/// removed opportunistically. stepData is encrypted at rest.
-model AuthorizationSession {
-  id           String   @id @default(auto()) @map("_id") @db.ObjectId
-  sessionId    String   @unique
-  userId       String
-  entityType   String
-  credentialId String?
-  currentStep  Int      @default(1)
-  maxSteps     Int
-  stepData     Json     @default("{}")
-  expiresAt    DateTime
-  completed    Boolean  @default(false)
-
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  @@index([userId, entityType])
-  @@index([expiresAt])
-  @@map("AuthorizationSession")
-}

package/prisma-postgresql/schema.prisma

@@ -434,29 +434,3 @@ model UsageCounter {
   // Covers series() (metric + integrationType + window range).
   @@index([metric, integrationType, window])
 }
-
-// ============================================================================
-// MANAGEMENT API MODELS
-// ============================================================================
-
-/// Multi-step authorization state for Management API v2 (/api/v2/authorize,
-/// /api/v2/credentials/:id/reauthorize). Short-lived: expired rows are removed
-/// opportunistically. stepData is encrypted at rest.
-model AuthorizationSession {
-  id           Int      @id @default(autoincrement())
-  sessionId    String   @unique
-  userId       String
-  entityType   String
-  credentialId String?
-  currentStep  Int      @default(1)
-  maxSteps     Int
-  stepData     Json     @default("{}")
-  expiresAt    DateTime
-  completed    Boolean  @default(false)
-
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  @@index([userId, entityType])
-  @@index([expiresAt])
-}

package/types/index.d.ts

@@ -12,4 +12,3 @@
 /// <reference path="./eslint-config/index.d.ts" />
 /// <reference path="./associations/index.d.ts" />
 /// <reference path="./syncs/index.d.ts" />
-/// <reference path="./modules/index.d.ts" />

package/credential/use-cases/credential-operations-for-user.js

@@ -1,117 +0,0 @@
-const Boom = require('@hapi/boom');
-const { userOwns } = require('../../modules/use-cases/get-entity-module-for-user');
-
-/**
- * Management API v2 credential operations. A credential has no module name
- * of its own; its `type` and the entities that use it come from the
- * caller's entities. A missing or foreign credential is a 404.
- */
-
-const credentialIdOf = (entity) => {
-    const ref = entity.credential ?? entity.credentialId;
-    if (ref === undefined || ref === null) return null;
-    if (typeof ref === 'object') {
-        const id = ref.id ?? ref._id;
-        return id === undefined || id === null ? null : String(id);
-    }
-    return String(ref);
-};
-
-/** Adds `type` and `entityIds` from the user's entities to each credential. */
-function withEntityUsage(credentials, entities) {
-    const usage = new Map();
-    for (const entity of entities || []) {
-        const credentialId = credentialIdOf(entity);
-        if (!credentialId) continue;
-        const entry = usage.get(credentialId) || { type: null, entityIds: [] };
-        entry.type = entry.type || entity.moduleName || null;
-        entry.entityIds.push(String(entity.id));
-        usage.set(credentialId, entry);
-    }
-    return credentials.map((credential) => {
-        const entry = usage.get(String(credential.id)) || {
-            type: null,
-            entityIds: [],
-        };
-        return { ...credential, type: entry.type, entityIds: entry.entityIds };
-    });
-}
-
-/** The caller's credentials with their type and entity usage. */
-class ListCredentialsForUser {
-    constructor({ credentialRepository, moduleRepository }) {
-        this.credentialRepository = credentialRepository;
-        this.moduleRepository = moduleRepository;
-    }
-
-    async execute(user) {
-        const userId = user.getId();
-        const [credentials, entities] = await Promise.all([
-            this.credentialRepository.findCredentialsByUserId(userId),
-            this.moduleRepository.findEntitiesByUserId(userId),
-        ]);
-        return withEntityUsage(credentials || [], entities);
-    }
-}
-
-/** One credential the caller owns, with its type and entity usage. */
-class GetCredentialForUserV2 {
-    constructor({ credentialRepository, moduleRepository }) {
-        this.credentialRepository = credentialRepository;
-        this.moduleRepository = moduleRepository;
-    }
-
-    async execute(credentialId, user) {
-        let credential = null;
-        try {
-            credential = await this.credentialRepository.findCredentialById(
-                credentialId
-            );
-        } catch (error) {
-            if (!/Invalid ID|ObjectId|Malformed/i.test(error?.message || '')) {
-                throw error;
-            }
-        }
-        if (!credential || !userOwns(user, credential.userId)) {
-            throw Boom.notFound(`Credential ${credentialId} not found`, {
-                code: 'CREDENTIAL_NOT_FOUND',
-            });
-        }
-        const entities = await this.moduleRepository.findEntitiesByUserId(
-            credential.userId
-        );
-        return withEntityUsage([credential], entities)[0];
-    }
-}
-
-/**
- * Deletes a credential the caller owns. The entities that used it stay, with
- * their credential unset, so they show as needing re-authorization rather
- * than disappearing from integrations.
- */
-class DeleteCredentialForUser {
-    constructor({ credentialRepository, moduleRepository, getCredentialForUser }) {
-        this.credentialRepository = credentialRepository;
-        this.moduleRepository = moduleRepository;
-        this.getCredentialForUser = getCredentialForUser;
-    }
-
-    async execute(credentialId, user) {
-        const credential = await this.getCredentialForUser.execute(
-            credentialId,
-            user
-        );
-        for (const entityId of credential.entityIds) {
-            await this.moduleRepository.unsetCredential(entityId);
-        }
-        await this.credentialRepository.deleteCredentialById(credential.id);
-        return { id: String(credential.id), entityIds: credential.entityIds };
-    }
-}
-
-module.exports = {
-    ListCredentialsForUser,
-    GetCredentialForUserV2,
-    DeleteCredentialForUser,
-    withEntityUsage,
-};

package/credential/use-cases/reauthorize-credential-for-user.js

@@ -1,66 +0,0 @@
-const Boom = require('@hapi/boom');
-
-/**
- * Re-authorization of a credential the caller owns (Management API v2). It
- * runs the same flow as /api/v2/authorize for the credential's entity type,
- * with the session bound to the credential so it cannot be reused for
- * anything else.
- */
-async function credentialEntityType(getCredentialForUser, credentialId, user) {
-    const credential = await getCredentialForUser.execute(credentialId, user);
-    if (!credential.type) {
-        throw Boom.conflict(
-            `Credential ${credentialId} is not used by any entity, so its type is unknown; authorize a new connection instead`,
-            { code: 'CREDENTIAL_TYPE_UNKNOWN' }
-        );
-    }
-    return { entityType: credential.type, credentialId: String(credential.id) };
-}
-
-/** GET /api/v2/credentials/:credentialId/reauthorize */
-class GetCredentialReauthorization {
-    constructor({ getCredentialForUser, getAuthorizationStep }) {
-        this.getCredentialForUser = getCredentialForUser;
-        this.getAuthorizationStep = getAuthorizationStep;
-    }
-
-    async execute(credentialId, user, { step = 1, sessionId, state } = {}) {
-        const binding = await credentialEntityType(
-            this.getCredentialForUser,
-            credentialId,
-            user
-        );
-        return this.getAuthorizationStep.execute({
-            user,
-            ...binding,
-            step,
-            sessionId,
-            state,
-        });
-    }
-}
-
-/** POST /api/v2/credentials/:credentialId/reauthorize */
-class ReauthorizeCredentialForUser {
-    constructor({ getCredentialForUser, submitAuthorizationStep }) {
-        this.getCredentialForUser = getCredentialForUser;
-        this.submitAuthorizationStep = submitAuthorizationStep;
-    }
-
-    async execute(credentialId, user, { data, step = 1, sessionId } = {}) {
-        const binding = await credentialEntityType(
-            this.getCredentialForUser,
-            credentialId,
-            user
-        );
-        return this.submitAuthorizationStep.execute({
-            user,
-            ...binding,
-            data,
-            step,
-            sessionId,
-        });
-    }
-}
-
-module.exports = { GetCredentialReauthorization, ReauthorizeCredentialForUser };

package/database/encryption/test-support/fake-ciphertext.js

@@ -1,15 +0,0 @@
-/**
- * Test double for Cryptor output. Same shape as the real thing
- * (`keyId:iv:ciphertext:encryptedKey`: base64, 16-byte hex, hex, base64) so
- * FieldEncryptionService._isEncrypted accepts it, with the plaintext
- * recoverable for the fake decrypt.
- */
-const fakeCiphertext = (plain) =>
-    `a2V5SWQ=:${'0'.repeat(32)}:${Buffer.from(String(plain)).toString(
-        'hex'
-    )}:ZW5jS2V5`;
-
-const fakePlaintext = (ciphertext) =>
-    Buffer.from(String(ciphertext).split(':')[2], 'hex').toString();
-
-module.exports = { fakeCiphertext, fakePlaintext };