@friggframework/core 2.0.0--canary.678.58db4b2.0 → 2.0.0--canary.680.b3ca7f1.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+# Unreleased
+
+#### Behaviour change: module credential fields are now encrypted
+
+- `credentialFields` declared in an API module's `encryption` config (for example `Definition.encryption.credentialFields`) were never registered for encryption: `loadModuleEncryptionSchemas` required a path that does not exist and the error was swallowed. They are now registered, for modules bound by integrations and for modules registered in `appDefinition.entities` (ADR-059).
+- Existing rows are not rewritten. A credential saved before this release stays plaintext until it is next written, and is read as stored.
+- Reads now tolerate plaintext: a value is only treated as ciphertext when it has the exact `keyId:iv:ciphertext:encryptedKey` shape (previously any string with three or more colons, such as `https://user:pw@host:443`), and a value that fails to decrypt is returned as stored with a warning instead of failing the whole read.
+- An app's own `encryption.schema` is no longer replaced when module fields are added to it.
+
+---
+
 # v1.2.2 (Fri Aug 09 2024)
 
 #### 🐛 Bug Fix

package/CLAUDE.md

@@ -332,14 +332,12 @@ class MyIntegration extends IntegrationBase {
 - Password-based (bcrypt hashed)
 - Token-based (Bearer tokens)
 - App-based (external app user IDs)
-- Adopter JWT (`authModes.adopterJwt`, `jwtConfig`; `jose`, JWKS or HMAC; see `README.md`)
 
 **Use Cases**:
 - `login-user.js` - User authentication
 - `create-individual-user.js` - Create personal account
 - `create-organization-user.js` - Create business account
 - `get-user-from-bearer-token.js` - Token authentication
-- `get-user-from-adopter-jwt.js` - Adopter JWT verification, find-or-create (ADR-056 §2); `adopter-jwt-config.js` validates `jwtConfig` at load
 
 **Repositories**:
 - `user-repository-factory.js` - Creates database-specific repositories

package/README.md

@@ -305,7 +305,6 @@ Comprehensive user authentication and authorization system supporting both indiv
 - **Password-based**: Traditional username/password authentication
 - **Token-based**: Bearer token authentication with session management
 - **App-based**: External app user ID authentication (passwordless)
-- **Adopter token (JWT)**: A token issued by your own identity system, verified by Frigg and safe to send from a browser (see below)
 
 **Usage:**
 ```javascript
@@ -353,62 +352,6 @@ console.log('Individual user:', user.getIndividualUser());
 console.log('Organization user:', user.getOrganizationUser());
 ```
 
-#### Adopter token (JWT) authentication
-
-For a multi-tenant product (ADR-056 §2), let the browser send the token your identity system
-already issues. Frigg verifies the signature and claims, then finds or creates the individual
-user and the organization user the token names. Unlike `sharedSecret` (`x-frigg-*` headers), a
-token cannot name a user other than the one it was issued for, so it is safe in a browser.
-
-```javascript
-// backend/index.js
-const appDefinition = {
-    user: {
-        primary: 'organization',
-        individualUserRequired: true,
-        organizationUserRequired: true,
-        authModes: { adopterJwt: true, friggToken: false, sharedSecret: false },
-        jwtConfig: {
-            jwksUri: 'https://login.example.com/.well-known/jwks.json',
-            issuer: 'https://login.example.com/',
-            audience: 'my-frigg-api', // required with jwksUri
-        },
-    },
-};
-```
-
-The client sends `Authorization: Bearer <token>`. `x-frigg-appuserid` / `x-frigg-apporgid`, if
-also sent, must match the token or the request is refused with 403. That match rule lives in
-`user/use-cases/authenticate-user.js` (`validateUserMatch`), not in the token verifier. A bearer
-value that is not a three-part JWT is not offered to the verifier at all; it falls through to
-`friggToken` (or is a 401 when that mode is off).
-
-| `jwtConfig` field | Default | Meaning |
-|---|---|---|
-| `jwksUri` | | Remote JWKS (rotating keys, one per verifier, cached by jose). Must be `https`; `http` only for `localhost`, `127.0.0.0/8` or `::1`. Set exactly one of this and `secret`. |
-| `secret` | | Shared HMAC secret. Read it from an environment variable. |
-| `issuer` | not checked | Required `iss`. With `jwksUri`, a startup warning is logged when it is unset. |
-| `audience` | not checked with `secret`; **required with `jwksUri`** | Accepted `aud` (a string or a list). |
-| `algorithms` | `['ES256','RS256']` with `jwksUri`, `['HS256']` with `secret` | Allow-list. HS* is only accepted with `secret`, never with `jwksUri`. The older single `algorithm` is a deprecated alias; setting both is an error. |
-| `clockToleranceSec` | `30` | Skew allowed on `exp` and `nbf`. |
-| `userIdClaim` | `sub` | App user id (required in the token). |
-| `orgIdClaim` | `org_id` | App organization id (optional). |
-| `roleClaim` | `org_role` | Read and exposed as `user.getOrgRole()`; not stored yet. |
-
-Rules worth knowing:
-
-- Tokens must carry `exp`. `alg: none` and any algorithm outside the allow-list are refused.
-- Startup fails (`loadAppDefinition` throws) when `adopterJwt` is on and the config is unusable:
-  neither or both of `jwksUri` and `secret`, a `jwksUri` that is not https (or loopback http),
-  no `audience` with `jwksUri`, or an algorithm list that does not fit the key type.
-- Failures are `401` with a stable `data.reason`: `token_expired`, `token_not_yet_valid`,
-  `token_invalid_signature`, `token_wrong_issuer`, `token_wrong_audience`,
-  `token_missing_user_claim`, `token_malformed`. The message never contains the token or its claims.
-  Any other verification failure, such as an unreachable or unresolvable JWKS, is `503`
-  `jwks_unavailable`, not a 401, so clients do not drop good sessions.
-- A person belongs to one organization for now: a token naming a second one gets `403`
-  `multi_org_unsupported` and nothing is moved (ADR-056 §3.6 replaces this with memberships).
-
 ### 8. Lambda Utilities (`/lambda`)
 
 AWS Lambda-specific utilities and helpers.

package/application/commands/integration-commands.js

@@ -30,8 +30,9 @@ const {
     PatchIntegrationConfig,
 } = require('../../integrations/use-cases/patch-integration-config');
 const {
-    getModulesDefinitionFromIntegrationClasses,
-} = require('../../integrations/utils/map-integration-dto');
+    getEntityTypeRegistry,
+    getEntityTypeDefinitions,
+} = require('../../modules/entity-type-registry');
 
 const ERROR_CODE_MAP = {
     ENTITY_NOT_FOUND: 401,
@@ -51,7 +52,16 @@ function mapErrorToResponse(error) {
     };
 }
 
-function createIntegrationCommands({ integrationClass } = {}) {
+/**
+ * @param {Object} [params]
+ * @param {Function} [params.integrationClass]
+ * @param {Array<object>} [params.moduleDefinitions] - the app's offered module
+ *   definitions (`loadAppDefinition().moduleDefinitions`). Integration code
+ *   calls this from a constructor with no app definition in hand, so when it
+ *   is omitted the commands hydrate with this integration's own modules only
+ *   (a registry built from `{ integrations: [integrationClass] }`).
+ */
+function createIntegrationCommands({ integrationClass, moduleDefinitions } = {}) {
     // Always use Frigg's default repositories and use cases
     const integrationRepository = createIntegrationRepository();
 
@@ -108,13 +118,13 @@ function createIntegrationCommands({ integrationClass } = {}) {
 
     const moduleRepository = createModuleRepository();
 
-    const moduleDefinitions = getModulesDefinitionFromIntegrationClasses([
-        integrationClass,
-    ]);
-
     const moduleFactory = new ModuleFactory({
         moduleRepository,
-        moduleDefinitions,
+        moduleDefinitions:
+            moduleDefinitions ??
+            getEntityTypeDefinitions(
+                getEntityTypeRegistry({ integrations: [integrationClass] })
+            ),
     });
 
     const loadIntegrationContextUseCase = new LoadIntegrationContextUseCase({

package/application/index.js

@@ -17,6 +17,7 @@ const { createUsageCommands } = require('./commands/usage-commands');
  *
  * @param {Object} params
  * @param {Object} params.integrationClass - Integration class (required)
+ * @param {Array<object>} [params.moduleDefinitions] - the app's offered module definitions; defaults to the integration's own modules
  * @returns {Object} Unified commands object with all CRUD operations
  *
  * @example
@@ -24,9 +25,12 @@ const { createUsageCommands } = require('./commands/usage-commands');
  * const user = await commands.createUser({ username: 'user@example.com' });
  * const credential = await commands.createCredential({ userId: user.id, ... });
  */
-function createFriggCommands({ integrationClass }) {
+function createFriggCommands({ integrationClass, moduleDefinitions }) {
     // All commands use Frigg's default repositories and use cases
-    const integrationCommands = createIntegrationCommands({ integrationClass });
+    const integrationCommands = createIntegrationCommands({
+        integrationClass,
+        moduleDefinitions,
+    });
 
     const userCommands = createUserCommands();
 

package/database/encryption/README.md

@@ -428,6 +428,8 @@ Format: "keyId:encryptedText:encryptedKey"
 Example: "base64KeyId:iv:ciphertext:base64EncryptedDataKey"
 ```
 
+**Recognising ciphertext on read.** A value is decrypted only when it has exactly four colon-separated parts: base64 `keyId`, 32-hex-character `iv`, hex ciphertext, base64 `encryptedKey`. Plaintext that merely contains colons (`https://user:pw@host:443`) is left alone. A value with that shape that still fails to decrypt is returned as stored and logged as a warning, so one bad field never fails a whole read. A field that becomes encrypted later (for example a module's `credentialFields`) stays plaintext in existing rows until they are next written.
+
 **Why Envelope Encryption?**
 
 -   Reduces KMS API calls (one DEK per field, cached)

package/database/encryption/encryption-schema-registry.js

@@ -10,6 +10,11 @@
 
 const { logger } = require('./logger');
 const { registerDeniedKeys } = require('../../logs/denied-keys');
+const {
+    getEntityTypeRegistry,
+    getEntityTypeDefinitions,
+    EntityRegistryError,
+} = require('../../modules/entity-type-registry');
 
 /**
  * Core encryption schema (immutable - cannot be overridden by custom schemas)
@@ -166,8 +171,9 @@ function extractCredentialFieldsFromModules(moduleDefinitions) {
  * Each module can declare credentialFields to encrypt in its encryption config.
  *
  * @param {Array} integrations - Array of integration classes with modules
+ * @param {object} [entities] - `appDefinition.entities` (ADR-059 registry)
  */
-function loadModuleEncryptionSchemas(integrations) {
+function loadModuleEncryptionSchemas(integrations, entities) {
     if (!integrations) {
         throw new Error('integrations parameter is required');
     }
@@ -176,27 +182,39 @@ function loadModuleEncryptionSchemas(integrations) {
         throw new Error('integrations must be an array');
     }
 
-    if (integrations.length === 0) {
+    // `entities` is the app definition's registry (ADR-059): a module an app
+    // registers without any integration still carries credentials to encrypt.
+    if (integrations.length === 0 && !entities) {
         return;
     }
 
-    const { getModulesDefinitionFromIntegrationClasses } = require('../integrations/utils/map-integration-dto');
-
-    const moduleDefinitions = getModulesDefinitionFromIntegrationClasses(integrations);
+    const moduleDefinitions = getEntityTypeDefinitions(
+        getEntityTypeRegistry({ integrations, entities })
+    );
     const credentialFields = extractCredentialFieldsFromModules(moduleDefinitions);
 
-    if (credentialFields.length === 0) {
+    // Core fields are encrypted already and a custom schema may not repeat
+    // them. Everything the app registered itself stays: module fields are added
+    // to the custom schema, never substituted for it (other models included).
+    const coreFields = new Set(CORE_ENCRYPTION_SCHEMA.Credential?.fields || []);
+    const fields = [
+        ...new Set([
+            ...(customSchema.Credential?.fields || []),
+            ...credentialFields.filter((field) => !coreFields.has(field)),
+        ]),
+    ];
+
+    if (fields.length === 0) {
         return;
     }
 
     const moduleSchema = {
-        Credential: {
-            fields: credentialFields
-        }
+        ...customSchema,
+        Credential: { ...customSchema.Credential, fields },
     };
 
     logger.info(
-        `Registering module-level encryption for ${credentialFields.length} credential fields`
+        `Registering module-level encryption for ${fields.length} credential fields`
     );
 
     registerCustomSchema(moduleSchema);
@@ -248,10 +266,15 @@ function loadCustomEncryptionSchema() {
 
         // Load module-level encryption schemas from integrations
         const integrations = appDefinition.integrations;
-        if (integrations && Array.isArray(integrations)) {
-            loadModuleEncryptionSchemas(integrations);
+        if (Array.isArray(integrations) || appDefinition.entities) {
+            loadModuleEncryptionSchemas(
+                Array.isArray(integrations) ? integrations : [],
+                appDefinition.entities
+            );
         }
     } catch (error) {
+        // A bad entity registry is a configuration error, not "no custom schema".
+        if (error instanceof EntityRegistryError) throw error;
         // Silently ignore errors - custom schema is optional
         // This handles cases like:
         // - Backend package.json not found (tests, standalone usage)

package/database/encryption/field-encryption-service.js

@@ -4,6 +4,16 @@
  * Infrastructure layer service that orchestrates field-level encryption/decryption.
  * Handles nested JSON paths (e.g., 'data.access_token') and bulk operations.
  */
+const { logger } = require('./logger');
+
+// Cryptor.encrypt() returns `${keyId}:${iv}:${ciphertext}:${encryptedKey}`:
+// keyId and encryptedKey are base64, iv is 16 bytes of hex, ciphertext is hex.
+// Plaintext with three colons (`https://user:pw@host:443`, `a:b:c:d`) must not
+// be mistaken for it.
+const BASE64_PART = /^[A-Za-z0-9+/]+={0,2}$/;
+const IV_PART = /^[0-9a-f]{32}$/i;
+const CIPHERTEXT_PART = /^(?:[0-9a-f]{2})+$/i;
+
 class FieldEncryptionService {
     constructor({ cryptor, schema }) {
         if (!cryptor) {
@@ -97,12 +107,23 @@ class FieldEncryptionService {
         const decryptionPromises = fields.map(async (fieldPath) => {
             const value = this._getNestedValue(decrypted, fieldPath);
 
-            if (this._isEncrypted(value)) {
+            if (!this._isEncrypted(value)) {
+                return null;
+            }
+            try {
                 const decryptedValue = await this.cryptor.decrypt(value);
                 const deserializedValue = this._deserializeAfterDecryption(decryptedValue);
                 return { fieldPath, decryptedValue: deserializedValue };
+            } catch (error) {
+                // A value that looks like ciphertext but is not (or was written
+                // before the field was encrypted) is read as it is stored. One
+                // such field must not fail the whole read, findMany included.
+                logger.warn(
+                    `Could not decrypt ${modelName}.${fieldPath}; returning the stored value`,
+                    { errorName: error?.name }
+                );
+                return null;
             }
-            return null;
         });
 
         const results = await Promise.all(decryptionPromises);
@@ -152,7 +173,13 @@ class FieldEncryptionService {
         }
 
         const parts = value.split(':');
-        return parts.length >= 4;
+        return (
+            parts.length === 4 &&
+            BASE64_PART.test(parts[0]) &&
+            IV_PART.test(parts[1]) &&
+            CIPHERTEXT_PART.test(parts[2]) &&
+            BASE64_PART.test(parts[3])
+        );
     }
 
     _getNestedValue(obj, path) {

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

@@ -0,0 +1,15 @@
+/**
+ * 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 };

package/handlers/app-definition-loader.js

@@ -2,22 +2,20 @@ const { findNearestBackendPackageJson } = require('@friggframework/core/utils');
 const path = require('node:path');
 const fs = require('fs-extra');
 const { resolveTelemetryConfig } = require('../telemetry/telemetry-config');
-const { assertAdopterJwtConfig } = require('../user/adopter-jwt-config');
 const { registerDeniedKeys } = require('../logs/denied-keys');
 const {
     extractCredentialFieldsFromModules,
 } = require('../database/encryption/encryption-schema-registry');
 const {
-    getModulesDefinitionFromIntegrationClasses,
-} = require('../integrations/utils/map-integration-dto');
+    getEntityTypeRegistry,
+    getEntityTypeDefinitions,
+} = require('../modules/entity-type-registry');
 
 // Handlers without a database never load the encryption registry, so the
 // credential leaf keys are registered for redaction here too.
-function registerCredentialLogKeys(appDefinition, integrations) {
+function registerCredentialLogKeys(appDefinition, moduleDefinitions) {
     try {
-        extractCredentialFieldsFromModules(
-            getModulesDefinitionFromIntegrationClasses(integrations)
-        );
+        extractCredentialFieldsFromModules(moduleDefinitions);
     } catch {
         // An odd integration shape must not stop the app from loading.
     }
@@ -34,10 +32,9 @@ function registerCredentialLogKeys(appDefinition, integrations) {
  * @function loadAppDefinition
  * @description Searches for the nearest backend package.json, loads the corresponding index.js file,
  * and extracts the application definition containing integrations and user configuration.
- * @returns {{integrations: Array<object>, userConfig: object | null, adminScripts: Array<object>, reports: Array<object>, admin: object, telemetry: object, logging: object | null, managementApi: object}} An object containing the application definition.
+ * @returns {{integrations: Array<object>, entities: object | null, entityTypeRegistry: Map<string, object>, moduleDefinitions: Array<object>, userConfig: object | null, adminScripts: Array<object>, reports: Array<object>, admin: object, telemetry: object, logging: object | null, managementApi: object}} An object containing the application definition.
  * @throws {Error} Throws error if backend package.json cannot be found.
  * @throws {Error} Throws error if index.js file cannot be found in the backend directory.
- * @throws {Error} Throws error if user.authModes.adopterJwt is enabled without a usable user.jwtConfig.
  * @example
  * const { integrations, userConfig, telemetry } = loadAppDefinition();
  * console.log(`Found ${integrations.length} integrations`);
@@ -59,6 +56,7 @@ function loadAppDefinition() {
 
     const {
         integrations = [],
+        entities = null,
         user: userConfig = null,
         adminScripts = [],
         reports = [],
@@ -67,11 +65,13 @@ function loadAppDefinition() {
         managementApi = {},
     } = appDefinition;
 
-    // Fail at load, not on the first request: an adopter-token mode with no
-    // key source would otherwise start cleanly and answer every login with 500.
-    assertAdopterJwtConfig(userConfig);
+    // Fail fast: a bad `entities` registry (key/name mismatch, conflicting
+    // definitions, `$infer: false` with an unregistered module) must stop the
+    // app at load, not on the first request that needs a module.
+    const entityTypeRegistry = getEntityTypeRegistry(appDefinition);
+    const moduleDefinitions = getEntityTypeDefinitions(entityTypeRegistry);
 
-    registerCredentialLogKeys(appDefinition, integrations);
+    registerCredentialLogKeys(appDefinition, moduleDefinitions);
 
     // Degrade consistently: an invalid telemetry block must never take down a
     // router bundle that loads the app definition at module scope (telemetry is
@@ -96,6 +96,9 @@ function loadAppDefinition() {
 
     return {
         integrations,
+        entities,
+        entityTypeRegistry,
+        moduleDefinitions,
         userConfig,
         adminScripts,
         reports,

package/handlers/backend-utils.js

@@ -18,8 +18,9 @@ const {
     createModuleRepository,
 } = require('../modules/repositories/module-repository-factory');
 const {
-    getModulesDefinitionFromIntegrationClasses,
-} = require('../integrations/utils/map-integration-dto');
+    getEntityTypeRegistry,
+    getEntityTypeDefinitions,
+} = require('../modules/entity-type-registry');
 const { processNotFound } = require('../integrations/use-cases/process-errors');
 
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
@@ -61,30 +62,18 @@ const initializeRepositories = () => {
     return { processRepository, integrationRepository, moduleRepository };
 };
 
-const createModuleFactoryWithDefinitions = (
-    moduleRepository,
-    integrationClasses
-) => {
-    const moduleDefinitions =
-        getModulesDefinitionFromIntegrationClasses(integrationClasses);
-
-    return new ModuleFactory({
-        moduleRepository,
-        moduleDefinitions,
-    });
-};
-
 const loadIntegrationForWebhook = async (integrationId) => {
     const { loadAppDefinition } = require('./app-definition-loader');
-    const { integrations: integrationClasses } = loadAppDefinition();
+    const { integrations: integrationClasses, moduleDefinitions } =
+        loadAppDefinition();
 
     const { integrationRepository, moduleRepository } =
         initializeRepositories();
 
-    const moduleFactory = createModuleFactoryWithDefinitions(
+    const moduleFactory = new ModuleFactory({
         moduleRepository,
-        integrationClasses
-    );
+        moduleDefinitions,
+    });
 
     const getIntegrationInstance = new GetIntegrationInstance({
         integrationRepository,
@@ -129,13 +118,23 @@ const integrationExists = async (integrationId) => {
     }
 };
 
-const loadIntegrationForProcess = async (processId, integrationClass) => {
+const loadIntegrationForProcess = async (
+    processId,
+    integrationClass,
+    moduleDefinitions
+) => {
     const { processRepository, integrationRepository, moduleRepository } =
         initializeRepositories();
 
-    const moduleFactory = createModuleFactoryWithDefinitions(moduleRepository, [
-        integrationClass,
-    ]);
+    const moduleFactory = new ModuleFactory({
+        moduleRepository,
+        moduleDefinitions:
+            moduleDefinitions ??
+            // No app definition handed in: this integration's own modules only.
+            getEntityTypeDefinitions(
+                getEntityTypeRegistry({ integrations: [integrationClass] })
+            ),
+    });
 
     const getIntegrationInstance = new GetIntegrationInstance({
         integrationRepository,
@@ -161,7 +160,13 @@ const loadIntegrationForProcess = async (processId, integrationClass) => {
     return instance;
 };
 
-const createQueueWorker = (integrationClass) => {
+/**
+ * @param {Function} integrationClass
+ * @param {{moduleDefinitions?: Array<object>}} [options] - the app's offered
+ *   module definitions (`loadAppDefinition().moduleDefinitions`). When omitted
+ *   the worker hydrates with this integration's own modules only.
+ */
+const createQueueWorker = (integrationClass, { moduleDefinitions } = {}) => {
     const integrationName = integrationClass.Definition.name;
 
     class QueueWorker extends Worker {
@@ -183,7 +188,8 @@ const createQueueWorker = (integrationClass) => {
                     console.log(`[QueueWorker] hydrating by processId`, logCtx);
                     integrationInstance = await loadIntegrationForProcess(
                         params.data.processId,
-                        integrationClass
+                        integrationClass,
+                        moduleDefinitions
                     );
                     console.log(`[QueueWorker] hydrated`, {
                         ...logCtx,

package/handlers/routers/health.js

@@ -2,9 +2,6 @@ const { Router } = require('express');
 const { createAppHandler } = require('./../app-handler-helpers');
 const { loadAppDefinition } = require('./../app-definition-loader');
 const { ModuleFactory } = require('../../modules/module-factory');
-const {
-    getModulesDefinitionFromIntegrationClasses,
-} = require('../../integrations/utils/map-integration-dto');
 const {
     createModuleRepository,
 } = require('../../modules/repositories/module-repository-factory');
@@ -45,7 +42,7 @@ try {
     integrationClasses = appDef.integrations || [];
 
     const moduleRepository = createModuleRepository();
-    const moduleDefinitions = getModulesDefinitionFromIntegrationClasses(integrationClasses);
+    const { moduleDefinitions } = appDef;
 
     moduleFactory = new ModuleFactory({
         moduleRepository,

package/handlers/workers/integration-defined-workers.js

@@ -10,10 +10,13 @@ const { createQueueWorker } = require('../backend-utils');
 // const { getExtensionWorkers } = require('../../integrations/extension');
 
 const handlers = {};
-const { integrations: integrationClasses } = loadAppDefinition();
+const { integrations: integrationClasses, moduleDefinitions } =
+    loadAppDefinition();
 
 integrationClasses.forEach((IntegrationClass) => {
-    const defaultQueueWorker = createQueueWorker(IntegrationClass);
+    const defaultQueueWorker = createQueueWorker(IntegrationClass, {
+        moduleDefinitions,
+    });
 
     handlers[`${IntegrationClass.Definition.name}`] = {
         queueWorker: createHandler({

package/index.js

@@ -63,7 +63,6 @@ const {
     Options,
     createIntegrationRouter,
     checkRequiredParams,
-    getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
 } = require('./integrations/index');
 const {
@@ -99,6 +98,8 @@ const {
     Requester,
     ModuleConstants,
     ModuleFactory,
+    getEntityTypeRegistry,
+    EntityRegistryError,
 } = require('./modules/index');
 const application = require('./application');
 const utils = require('./utils');
@@ -150,7 +151,6 @@ module.exports = {
     Options,
     checkRequiredParams,
     createIntegrationRouter,
-    getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
     CreateProcess,
     UpdateProcessState,
@@ -206,6 +206,8 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
+    getEntityTypeRegistry,
+    EntityRegistryError,
     // queues
     QueuerUtil,
 

package/integrations/index.js

@@ -4,9 +4,6 @@ const {
     createIntegrationRouter,
     checkRequiredParams,
 } = require('./integration-router');
-const {
-    getModulesDefinitionFromIntegrationClasses,
-} = require('./utils/map-integration-dto');
 const {
     LoadIntegrationContextUseCase,
 } = require('./use-cases/load-integration-context');
@@ -21,7 +18,6 @@ module.exports = {
     Options,
     createIntegrationRouter,
     checkRequiredParams,
-    getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
     validateExtensionBinding,
     getExtensionRoutes,