@friggframework/core 2.0.0--canary.707.df80bfd.0 → 2.0.0--canary.680.d670696.0

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

@@ -1,169 +1,117 @@
 const { createAppHandler } = require('./../app-handler-helpers');
-const { loadAppDefinition } = require('../app-definition-loader');
+const {
+    loadAppDefinition,
+} = require('../app-definition-loader');
 const express = require('express');
 const { Router } = express;
 const { loadRouterFromObject } = require('../backend-utils');
 const { getExtensionRoutes } = require('../../integrations/extension');
 
+const handlers = {};
+const { integrations: integrationClasses } = loadAppDefinition();
+
 const routeKey = (method, path) => `${(method || 'ANY').toUpperCase()} ${path}`;
 
 // Serverless function keys must be alphanumeric; binding keys are developer-chosen.
 const sanitizeBindingKey = (name) => String(name).replace(/[^A-Za-z0-9]/g, '');
 
-/**
- * Builds the Express routers for every integration's Definition.routes and
- * extension bindings. Pure: no handler wrapping, so the AWS handlers below
- * and other hosts (provider-netlify's integration-routes function) mount the
- * very same routers.
- *
- * @param {Array<Function>} integrationClasses
- * @returns {Array<{ key: string, eventName: string, router: import('express').Router, useDatabase: boolean }>}
- *   One entry per integration, then one per extension binding (key
- *   `${name}__${binding}`), in declaration order.
- */
-function buildIntegrationRouters(integrationClasses) {
-    const entries = [];
-    const keys = new Set();
-    //todo: this should be in a use case class
-    for (const IntegrationClass of integrationClasses) {
-        const router = Router();
-        const basePath = `/api/${IntegrationClass.Definition.name}-integration`;
-        // Track (method, path) tuples to fail fast on conflicts between Definition.routes,
-        // extension routes, or two extensions claiming the same path.
-        const claimedRoutes = new Map();
-        const claim = (method, path, source) => {
-            const key = routeKey(method, path);
-            if (claimedRoutes.has(key)) {
-                const prev = claimedRoutes.get(key);
-                throw new Error(
-                    `Integration "${IntegrationClass.Definition.name}" route conflict: ` +
-                        `${key} declared by ${prev} and ${source}`
-                );
-            }
-            claimedRoutes.set(key, source);
-        };
-
-        console.log(
-            `\n│ Configuring routes for ${IntegrationClass.Definition.name} Integration:`
-        );
-
-        const routes = IntegrationClass.Definition.routes || [];
-        for (const routeDef of routes) {
-            if (typeof routeDef === 'function') {
-                router.use(basePath, routeDef(IntegrationClass));
-                console.log(`│ ANY ${basePath}/* (function handler)`);
-            } else if (routeDef instanceof express.Router) {
-                router.use(basePath, routeDef);
-                console.log(`│ ANY ${basePath}/* (express router)`);
-            } else if (typeof routeDef === 'object') {
-                claim(routeDef.method, routeDef.path, 'Definition.routes');
-                router.use(
-                    basePath,
-                    loadRouterFromObject(IntegrationClass, routeDef)
-                );
-                const method = (routeDef.method || 'ANY').toUpperCase();
-                const fullPath = `${basePath}${routeDef.path}`;
-                console.log(`│ ${method} ${fullPath}`);
-            }
-        }
-
-        // Each extension binding gets its own namespaced handler (/{bindingName}),
-        // so two modules' extensions can share a path like /webhooks without colliding.
-        const bindingGroups = new Map();
-        for (const extRoute of getExtensionRoutes(IntegrationClass)) {
-            const namespacedPath = `/${extRoute.bindingName}${extRoute.path}`;
-            claim(
-                extRoute.method,
-                namespacedPath,
-                `extension "${extRoute.extensionName}" (binding "${extRoute.bindingName}")`
-            );
-            if (!bindingGroups.has(extRoute.bindingName)) {
-                bindingGroups.set(extRoute.bindingName, {
-                    router: Router(),
-                    useDatabase: extRoute.useDatabase,
-                });
-            }
-            const group = bindingGroups.get(extRoute.bindingName);
-            group.router.use(
-                `${basePath}/${extRoute.bindingName}`,
-                loadRouterFromObject(IntegrationClass, extRoute)
-            );
-            console.log(
-                `│ ${extRoute.method.toUpperCase()} ${basePath}/${
-                    extRoute.bindingName
-                }${extRoute.path}  (extension: ${
-                    extRoute.extensionName
-                }, useDatabase: ${extRoute.useDatabase})`
+//todo: this should be in a use case class
+for (const IntegrationClass of integrationClasses) {
+    const router = Router();
+    const basePath = `/api/${IntegrationClass.Definition.name}-integration`;
+    // Track (method, path) tuples to fail fast on conflicts between Definition.routes,
+    // extension routes, or two extensions claiming the same path.
+    const claimedRoutes = new Map();
+    const claim = (method, path, source) => {
+        const key = routeKey(method, path);
+        if (claimedRoutes.has(key)) {
+            const prev = claimedRoutes.get(key);
+            throw new Error(
+                `Integration "${IntegrationClass.Definition.name}" route conflict: ` +
+                    `${key} declared by ${prev} and ${source}`
             );
         }
-        console.log('│');
+        claimedRoutes.set(key, source);
+    };
 
-        entries.push({
-            key: `${IntegrationClass.Definition.name}`,
-            eventName: `HTTP Event: ${IntegrationClass.Definition.name}`,
-            router,
-            useDatabase: true,
-        });
-        keys.add(`${IntegrationClass.Definition.name}`);
+    console.log(`\n│ Configuring routes for ${IntegrationClass.Definition.name} Integration:`);
 
-        for (const [bindingName, group] of bindingGroups) {
-            // Wire contract: integration-builder.js (devtools) derives the identical
-            // function key for the serverless config. Keep both in sync.
-            const fnKey = `${
-                IntegrationClass.Definition.name
-            }__${sanitizeBindingKey(bindingName)}`;
-            // Distinct binding keys can sanitize to the same fnKey — fail loud rather than overwrite.
-            if (keys.has(fnKey)) {
-                throw new Error(
-                    `Integration "${IntegrationClass.Definition.name}" extension handler conflict: ` +
-                        `binding "${bindingName}" sanitizes to "${fnKey}", which is already taken. ` +
-                        `Use binding keys that are distinct after stripping non-alphanumeric characters.`
-                );
-            }
-            entries.push({
-                key: fnKey,
-                eventName: `HTTP Event: ${IntegrationClass.Definition.name} extension ${bindingName}`,
-                router: group.router,
-                useDatabase: group.useDatabase,
-            });
-            keys.add(fnKey);
+    const routes = IntegrationClass.Definition.routes || [];
+    for (const routeDef of routes) {
+        if (typeof routeDef === 'function') {
+            router.use(basePath, routeDef(IntegrationClass));
+            console.log(`│ ANY ${basePath}/* (function handler)`);
+        } else if (routeDef instanceof express.Router) {
+            router.use(basePath, routeDef);
+            console.log(`│ ANY ${basePath}/* (express router)`);
+        } else if (typeof routeDef === 'object') {
+            claim(routeDef.method, routeDef.path, 'Definition.routes');
+            router.use(
+                basePath,
+                loadRouterFromObject(IntegrationClass, routeDef)
+            );
+            const method = (routeDef.method || 'ANY').toUpperCase();
+            const fullPath = `${basePath}${routeDef.path}`;
+            console.log(`│ ${method} ${fullPath}`);
         }
     }
-    return entries;
-}
 
-/**
- * One router serving every integration-defined route and extension binding,
- * for hosts that run them all in one function (provider-netlify).
- *
- * @param {Array<Function>} [integrationClasses] - defaults to the app's.
- * @returns {import('express').Router}
- */
-function createIntegrationDefinedRouter(integrationClasses) {
-    const classes = integrationClasses || loadAppDefinition().integrations;
-    const combined = Router();
-    for (const entry of buildIntegrationRouters(classes)) {
-        combined.use(entry.router);
+    // Each extension binding gets its own namespaced handler (/{bindingName}),
+    // so two modules' extensions can share a path like /webhooks without colliding.
+    const bindingGroups = new Map();
+    for (const extRoute of getExtensionRoutes(IntegrationClass)) {
+        const namespacedPath = `/${extRoute.bindingName}${extRoute.path}`;
+        claim(
+            extRoute.method,
+            namespacedPath,
+            `extension "${extRoute.extensionName}" (binding "${extRoute.bindingName}")`
+        );
+        if (!bindingGroups.has(extRoute.bindingName)) {
+            bindingGroups.set(extRoute.bindingName, {
+                router: Router(),
+                useDatabase: extRoute.useDatabase,
+            });
+        }
+        const group = bindingGroups.get(extRoute.bindingName);
+        group.router.use(
+            `${basePath}/${extRoute.bindingName}`,
+            loadRouterFromObject(IntegrationClass, extRoute)
+        );
+        console.log(
+            `│ ${extRoute.method.toUpperCase()} ${basePath}/${extRoute.bindingName}${extRoute.path}  (extension: ${extRoute.extensionName}, useDatabase: ${extRoute.useDatabase})`
+        );
     }
-    return combined;
-}
+    console.log('│');
 
-// The AWS handlers (one Lambda per integration and per extension binding,
-// see devtools integration-builder). Built at require time on purpose: a
-// route conflict fails the cold start, not the first request.
-const handlers = {};
-for (const entry of buildIntegrationRouters(loadAppDefinition().integrations)) {
-    handlers[entry.key] = {
+    handlers[`${IntegrationClass.Definition.name}`] = {
         handler: createAppHandler(
-            entry.eventName,
-            entry.router,
-            entry.useDatabase
+            `HTTP Event: ${IntegrationClass.Definition.name}`,
+            router
         ),
     };
+
+    for (const [bindingName, group] of bindingGroups) {
+        // Wire contract: integration-builder.js (devtools) derives the identical
+        // function key for the serverless config. Keep both in sync.
+        const fnKey = `${IntegrationClass.Definition.name}__${sanitizeBindingKey(
+            bindingName
+        )}`;
+        // Distinct binding keys can sanitize to the same fnKey — fail loud rather than overwrite.
+        if (Object.prototype.hasOwnProperty.call(handlers, fnKey)) {
+            throw new Error(
+                `Integration "${IntegrationClass.Definition.name}" extension handler conflict: ` +
+                    `binding "${bindingName}" sanitizes to "${fnKey}", which is already taken. ` +
+                    `Use binding keys that are distinct after stripping non-alphanumeric characters.`
+            );
+        }
+        handlers[fnKey] = {
+            handler: createAppHandler(
+                `HTTP Event: ${IntegrationClass.Definition.name} extension ${bindingName}`,
+                group.router,
+                group.useDatabase
+            ),
+        };
+    }
 }
 
-module.exports = {
-    handlers,
-    buildIntegrationRouters,
-    createIntegrationDefinedRouter,
-};
+module.exports = { handlers };

package/handlers/routers/integration-webhook-routers.js

@@ -6,120 +6,82 @@ const {
     IntegrationEventDispatcher,
 } = require('../integration-event-dispatcher');
 
+const handlers = {};
+const { integrations: integrationClasses } = loadAppDefinition();
+
 // `webhooks.received` is counted at the DB-connected ON_WEBHOOK dispatch (see
 // usage-rollup-subscriber), not in this DB-free receipt handler.
 
-/**
- * Builds the webhook receiver router for every integration with webhooks
- * enabled. Pure: no handler wrapping, so the AWS handlers below and other
- * hosts (provider-netlify's webhooks function) mount the same routers.
- *
- * @param {Array<Function>} integrationClasses
- * @returns {Array<{ key: string, eventName: string, router: import('express').Router }>}
- */
-function buildWebhookRouters(integrationClasses) {
-    const entries = [];
-    for (const IntegrationClass of integrationClasses) {
-        const webhookConfig = IntegrationClass.Definition.webhooks;
-
-        // Skip if webhooks not enabled
-        if (
-            !webhookConfig ||
-            (typeof webhookConfig === 'object' && !webhookConfig.enabled)
-        ) {
-            continue;
-        }
-
-        const router = Router();
-        const basePath = `/api/${IntegrationClass.Definition.name}-integration/webhooks`;
+for (const IntegrationClass of integrationClasses) {
+    const webhookConfig = IntegrationClass.Definition.webhooks;
 
-        console.log(
-            `\n│ Configuring webhook routes for ${IntegrationClass.Definition.name}:`
-        );
+    // Skip if webhooks not enabled
+    if (
+        !webhookConfig ||
+        (typeof webhookConfig === 'object' && !webhookConfig.enabled)
+    ) {
+        continue;
+    }
 
-        // General webhook route (no integration ID)
-        router.post(basePath, async (req, res, next) => {
-            try {
-                const integrationInstance = new IntegrationClass();
-                const dispatcher = new IntegrationEventDispatcher(
-                    integrationInstance
-                );
-                await dispatcher.dispatchHttp({
-                    event: 'WEBHOOK_RECEIVED',
-                    req,
-                    res,
-                    next,
-                });
-            } catch (error) {
-                next(error);
-            }
-        });
-        console.log(`│ POST ${basePath}`);
+    const router = Router();
+    const basePath = `/api/${IntegrationClass.Definition.name}-integration/webhooks`;
 
-        // Integration-specific webhook route (with integration ID)
-        router.post(`${basePath}/:integrationId`, async (req, res, next) => {
-            try {
-                const integrationInstance = new IntegrationClass();
-                const dispatcher = new IntegrationEventDispatcher(
-                    integrationInstance
-                );
-                // Logs only: the id comes from an unauthenticated URL, so it must
-                // not reach the telemetry context that drives usage attribution.
-                await runInContext(
-                    {
-                        [LOGGER_SCOPE_KEY]: {
-                            integrationId: req.params.integrationId,
-                        },
-                    },
-                    () =>
-                        dispatcher.dispatchHttp({
-                            event: 'WEBHOOK_RECEIVED',
-                            req,
-                            res,
-                            next,
-                        })
-                );
-            } catch (error) {
-                next(error);
-            }
-        });
-        console.log(`│ POST ${basePath}/:integrationId`);
-        console.log('│');
+    console.log(
+        `\n│ Configuring webhook routes for ${IntegrationClass.Definition.name}:`
+    );
 
-        entries.push({
-            key: `${IntegrationClass.Definition.name}Webhook`,
-            eventName: `HTTP Event: ${IntegrationClass.Definition.name} Webhook`,
-            router,
-        });
-    }
-    return entries;
-}
+    // General webhook route (no integration ID)
+    router.post(basePath, async (req, res, next) => {
+        try {
+            const integrationInstance = new IntegrationClass();
+            const dispatcher = new IntegrationEventDispatcher(
+                integrationInstance
+            );
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next,
+            });
+        } catch (error) {
+            next(error);
+        }
+    });
+    console.log(`│ POST ${basePath}`);
 
-/**
- * One router serving every integration's webhook routes, for hosts that run
- * them all in one function (provider-netlify).
- *
- * @param {Array<Function>} [integrationClasses] - defaults to the app's.
- * @returns {import('express').Router}
- */
-function createWebhookRouter(integrationClasses) {
-    const classes = integrationClasses || loadAppDefinition().integrations;
-    const combined = Router();
-    for (const entry of buildWebhookRouters(classes)) {
-        combined.use(entry.router);
-    }
-    return combined;
-}
+    // Integration-specific webhook route (with integration ID)
+    router.post(`${basePath}/:integrationId`, async (req, res, next) => {
+        try {
+            const integrationInstance = new IntegrationClass();
+            const dispatcher = new IntegrationEventDispatcher(
+                integrationInstance
+            );
+            // Logs only: the id comes from an unauthenticated URL, so it must
+            // not reach the telemetry context that drives usage attribution.
+            await runInContext(
+                { [LOGGER_SCOPE_KEY]: { integrationId: req.params.integrationId } },
+                () =>
+                    dispatcher.dispatchHttp({
+                        event: 'WEBHOOK_RECEIVED',
+                        req,
+                        res,
+                        next,
+                    })
+            );
+        } catch (error) {
+            next(error);
+        }
+    });
+    console.log(`│ POST ${basePath}/:integrationId`);
+    console.log('│');
 
-const handlers = {};
-for (const entry of buildWebhookRouters(loadAppDefinition().integrations)) {
-    handlers[entry.key] = {
+    handlers[`${IntegrationClass.Definition.name}Webhook`] = {
         handler: createAppHandler(
-            entry.eventName,
-            entry.router,
+            `HTTP Event: ${IntegrationClass.Definition.name} Webhook`,
+            router,
             false // shouldUseDatabase = false
         ),
     };
 }
 
-module.exports = { handlers, buildWebhookRouters, createWebhookRouter };
+module.exports = { handlers };

package/index.js

@@ -25,14 +25,6 @@ const {
     UserRepositoryMongo,
     UserRepositoryPostgres,
 } = require('./user/repositories/user-repository-factory');
-const {
-    createOrganizationMembershipRepository,
-    OrganizationMembershipRepositoryMongo,
-    OrganizationMembershipRepositoryPostgres,
-} = require('./user/repositories/organization-membership-repository-factory');
-const {
-    EnsureOrganizationMembership,
-} = require('./user/use-cases/ensure-organization-membership');
 const {
     GetUserFromXFriggHeaders,
 } = require('./user/use-cases/get-user-from-x-frigg-headers');
@@ -71,7 +63,6 @@ const {
     Options,
     createIntegrationRouter,
     checkRequiredParams,
-    getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
 } = require('./integrations/index');
 const {
@@ -109,34 +100,11 @@ const {
     ModuleFactory,
     getEntityTypeRegistry,
     EntityRegistryError,
-    resolveScope,
-    listBindingScopes,
-    OwnershipConfigError,
 } = require('./modules/index');
-const {
-    ManagementApiConfigError,
-} = require('./management-api/management-api-config');
 const application = require('./application');
 const utils = require('./utils');
 
-const {
-    QueuerUtil,
-    QueueProvider,
-    QueueClientInterface,
-    createQueueProvider,
-    QUEUE_PROVIDERS,
-} = require('./queues');
-const {
-    resolveProvider,
-    determineProviderName,
-    providerPackageName,
-    KNOWN_PROVIDERS,
-    isDeployedRuntime,
-} = require('./providers');
-
-// App-level core extensions (appDefinition.coreExtensions): Prisma models, encrypted
-// fields, admin routes and bootstrap hooks (friggframework/frigg#545).
-const extensions = require('./extensions');
+const { QueuerUtil } = require('./queues');
 
 module.exports = {
     // assertions
@@ -163,10 +131,6 @@ module.exports = {
     createUserRepository,
     UserRepositoryMongo,
     UserRepositoryPostgres,
-    createOrganizationMembershipRepository,
-    OrganizationMembershipRepositoryMongo,
-    OrganizationMembershipRepositoryPostgres,
-    EnsureOrganizationMembership,
     GetUserFromXFriggHeaders,
     GetUserFromAdopterJwt,
     AuthenticateUser,
@@ -187,8 +151,6 @@ module.exports = {
     Options,
     checkRequiredParams,
     createIntegrationRouter,
-    // Deprecated (ADR-059): use getEntityTypeRegistry.
-    getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
     CreateProcess,
     UpdateProcessState,
@@ -246,33 +208,8 @@ module.exports = {
     ModuleFactory,
     getEntityTypeRegistry,
     EntityRegistryError,
-    resolveScope,
-    listBindingScopes,
-    OwnershipConfigError,
-    ManagementApiConfigError,
     // queues
     QueuerUtil,
-    QueueProvider,
-    QueueClientInterface,
-    createQueueProvider,
-    QUEUE_PROVIDERS,
-
-    // provider plugins (appDefinition.provider)
-    resolveProvider,
-    determineProviderName,
-    providerPackageName,
-    KNOWN_PROVIDERS,
-    isDeployedRuntime,
-
-    // app-level extensions
-    extensions,
-    loadExtensions: extensions.loadExtensions,
-    composeSchemas: extensions.composeSchemas,
-    composeExtensionPrisma: extensions.composeExtensionPrisma,
-    mountExtensionRoutes: extensions.mountExtensionRoutes,
-    createExtensionRoutesRouter: extensions.createExtensionRoutesRouter,
-    runExtensionBootstraps: extensions.runExtensionBootstraps,
-    initializeApp: extensions.initializeApp,
 
     // utils
     ...utils,

package/infrastructure/scheduler/index.js

@@ -5,19 +5,13 @@
  * Follows hexagonal architecture with interface + adapters pattern.
  *
  * Providers:
- * - eventbridge: AWS EventBridge Scheduler (production on AWS)
- * - netlify: poll-and-dispatch from a Netlify scheduled function
+ * - eventbridge: AWS EventBridge Scheduler (production)
  * - mock: In-memory mock scheduler (local development)
- *
- * Adapters are lazy getters (friggframework/frigg#545, 1176a004): the
- * EventBridge adapter requires @aws-sdk/client-scheduler, which is not a
- * core dependency, and core/index -> application -> scheduler-commands ->
- * this barrel runs on every require('@friggframework/core'). An eager
- * require crashed any deployment without that SDK (e.g. a pruned Netlify
- * function bundle).
  */
 
 const { SchedulerServiceInterface } = require('./scheduler-service-interface');
+const { EventBridgeSchedulerAdapter } = require('./eventbridge-scheduler-adapter');
+const { MockSchedulerAdapter } = require('./mock-scheduler-adapter');
 const {
     createSchedulerService,
     SCHEDULER_PROVIDERS,
@@ -28,16 +22,9 @@ module.exports = {
     // Interface (Port)
     SchedulerServiceInterface,
 
-    // Adapters (loaded on access)
-    get EventBridgeSchedulerAdapter() {
-        return require('./eventbridge-scheduler-adapter').EventBridgeSchedulerAdapter;
-    },
-    get MockSchedulerAdapter() {
-        return require('./mock-scheduler-adapter').MockSchedulerAdapter;
-    },
-    get NetlifySchedulerAdapter() {
-        return require('./netlify-scheduler-adapter').NetlifySchedulerAdapter;
-    },
+    // Adapters
+    EventBridgeSchedulerAdapter,
+    MockSchedulerAdapter,
 
     // Factory
     createSchedulerService,