@friggframework/core 2.0.0--canary.680.daae24e.0 → 2.0.0--canary.686.e94de4d.0

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

@@ -1,117 +1,169 @@
 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, '');
 
-//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);
-    };
+/**
+ * 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:`
+        );
 
-    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}`);
+            }
+        }
 
-    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)
+        // 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})`
             );
-            const method = (routeDef.method || 'ANY').toUpperCase();
-            const fullPath = `${basePath}${routeDef.path}`;
-            console.log(`│ ${method} ${fullPath}`);
         }
-    }
+        console.log('│');
 
-    // 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,
+        entries.push({
+            key: `${IntegrationClass.Definition.name}`,
+            eventName: `HTTP Event: ${IntegrationClass.Definition.name}`,
+            router,
+            useDatabase: true,
+        });
+        keys.add(`${IntegrationClass.Definition.name}`);
+
+        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 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})`
-        );
     }
-    console.log('│');
+    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);
+    }
+    return combined;
+}
 
-    handlers[`${IntegrationClass.Definition.name}`] = {
+// 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] = {
         handler: createAppHandler(
-            `HTTP Event: ${IntegrationClass.Definition.name}`,
-            router
+            entry.eventName,
+            entry.router,
+            entry.useDatabase
         ),
     };
-
-    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 };
+module.exports = {
+    handlers,
+    buildIntegrationRouters,
+    createIntegrationDefinedRouter,
+};

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

@@ -6,82 +6,120 @@ 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.
 
-for (const IntegrationClass of integrationClasses) {
-    const webhookConfig = IntegrationClass.Definition.webhooks;
+/**
+ * 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;
-    }
+        // Skip if webhooks not enabled
+        if (
+            !webhookConfig ||
+            (typeof webhookConfig === 'object' && !webhookConfig.enabled)
+        ) {
+            continue;
+        }
 
-    const router = Router();
-    const basePath = `/api/${IntegrationClass.Definition.name}-integration/webhooks`;
+        const router = Router();
+        const basePath = `/api/${IntegrationClass.Definition.name}-integration/webhooks`;
 
-    console.log(
-        `\n│ Configuring webhook routes for ${IntegrationClass.Definition.name}:`
-    );
+        console.log(
+            `\n│ Configuring webhook routes for ${IntegrationClass.Definition.name}:`
+        );
 
-    // 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}`);
+        // 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}`);
 
-    // 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('│');
+        // 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('│');
 
-    handlers[`${IntegrationClass.Definition.name}Webhook`] = {
-        handler: createAppHandler(
-            `HTTP Event: ${IntegrationClass.Definition.name} Webhook`,
+        entries.push({
+            key: `${IntegrationClass.Definition.name}Webhook`,
+            eventName: `HTTP Event: ${IntegrationClass.Definition.name} Webhook`,
             router,
+        });
+    }
+    return entries;
+}
+
+/**
+ * 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;
+}
+
+const handlers = {};
+for (const entry of buildWebhookRouters(loadAppDefinition().integrations)) {
+    handlers[entry.key] = {
+        handler: createAppHandler(
+            entry.eventName,
+            entry.router,
             false // shouldUseDatabase = false
         ),
     };
 }
 
-module.exports = { handlers };
+module.exports = { handlers, buildWebhookRouters, createWebhookRouter };

package/index.js

@@ -25,6 +25,14 @@ 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');
@@ -63,6 +71,7 @@ const {
     Options,
     createIntegrationRouter,
     checkRequiredParams,
+    getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
 } = require('./integrations/index');
 const {
@@ -100,11 +109,34 @@ 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 } = require('./queues');
+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');
 
 module.exports = {
     // assertions
@@ -131,6 +163,10 @@ module.exports = {
     createUserRepository,
     UserRepositoryMongo,
     UserRepositoryPostgres,
+    createOrganizationMembershipRepository,
+    OrganizationMembershipRepositoryMongo,
+    OrganizationMembershipRepositoryPostgres,
+    EnsureOrganizationMembership,
     GetUserFromXFriggHeaders,
     GetUserFromAdopterJwt,
     AuthenticateUser,
@@ -151,6 +187,8 @@ module.exports = {
     Options,
     checkRequiredParams,
     createIntegrationRouter,
+    // Deprecated (ADR-059): use getEntityTypeRegistry.
+    getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
     CreateProcess,
     UpdateProcessState,
@@ -208,8 +246,32 @@ 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,
+    mountExtensionRoutes: extensions.mountExtensionRoutes,
+    createExtensionRoutesRouter: extensions.createExtensionRoutesRouter,
+    runExtensionBootstraps: extensions.runExtensionBootstraps,
+    initializeApp: extensions.initializeApp,
 
     // utils
     ...utils,

package/infrastructure/scheduler/index.js

@@ -5,13 +5,19 @@
  * Follows hexagonal architecture with interface + adapters pattern.
  *
  * Providers:
- * - eventbridge: AWS EventBridge Scheduler (production)
+ * - eventbridge: AWS EventBridge Scheduler (production on AWS)
+ * - netlify: poll-and-dispatch from a Netlify scheduled function
  * - 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,
@@ -22,9 +28,16 @@ module.exports = {
     // Interface (Port)
     SchedulerServiceInterface,
 
-    // Adapters
-    EventBridgeSchedulerAdapter,
-    MockSchedulerAdapter,
+    // 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;
+    },
 
     // Factory
     createSchedulerService,