@friggframework/core 2.0.0--canary.686.df38e8e.0 → 2.0.0--canary.710.9045bbc.0

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/handlers/workers/integration-defined-workers.js

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

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');
@@ -65,6 +57,7 @@ const {
     HaltError,
     RequiredPropertyError,
     ParameterTypeError,
+    MappingAlreadyExistsError,
 } = require('./errors/index');
 const {
     IntegrationBase,
@@ -107,36 +100,11 @@ const {
     Requester,
     ModuleConstants,
     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,
@@ -181,13 +145,13 @@ module.exports = {
     HaltError,
     RequiredPropertyError,
     ParameterTypeError,
+    MappingAlreadyExistsError,
 
     // integrations
     IntegrationBase,
     Options,
     checkRequiredParams,
     createIntegrationRouter,
-    // Deprecated (ADR-059): use getEntityTypeRegistry.
     getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
     CreateProcess,
@@ -244,34 +208,8 @@ module.exports = {
     Requester,
     ModuleConstants,
     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/eventbridge-scheduler-adapter.js

@@ -11,19 +11,65 @@
  * This adapter implements SchedulerServiceInterface for AWS EventBridge Scheduler.
  */
 
-const {
-    SchedulerClient,
-    CreateScheduleCommand,
-    DeleteScheduleCommand,
-    GetScheduleCommand,
-    ResourceNotFoundException,
-} = require('@aws-sdk/client-scheduler');
-
 const { SchedulerServiceInterface } = require('./scheduler-service-interface');
 
+const SCHEDULER_SDK = '@aws-sdk/client-scheduler';
+
+/**
+ * Lazily load the AWS EventBridge Scheduler SDK.
+ *
+ * Requiring `@aws-sdk/client-scheduler` at module top level would put the AWS
+ * SDK on the load path of every consumer of `@friggframework/core`, including
+ * those using the mock scheduler or no scheduler at all. Loading it here, on
+ * construction of the EventBridge adapter, keeps it out of the module-load
+ * path. The adapter calls it exactly once, in its constructor, and keeps the
+ * classes its methods need on the instance.
+ *
+ * Only a MODULE_NOT_FOUND for the scheduler SDK itself is rewritten into an
+ * actionable message; any other failure (including a missing transitive
+ * dependency) is rethrown unchanged so the real cause is not masked.
+ *
+ * @returns {object} The relevant exports from `@aws-sdk/client-scheduler`.
+ */
+function loadSchedulerSdk() {
+    try {
+        // Keep the literal specifier so bundlers (esbuild) can resolve it.
+        return require('@aws-sdk/client-scheduler');
+    } catch (error) {
+        const isSchedulerSdkMissing =
+            error &&
+            error.code === 'MODULE_NOT_FOUND' &&
+            typeof error.message === 'string' &&
+            error.message.includes(SCHEDULER_SDK);
+        if (isSchedulerSdkMissing) {
+            throw new Error(
+                `The EventBridge scheduler requires the "${SCHEDULER_SDK}" package, ` +
+                    `which is not installed. Install it (\`npm install ${SCHEDULER_SDK}\`) ` +
+                    'to use the EventBridge scheduler provider, or use the mock scheduler provider ' +
+                    '(SCHEDULER_PROVIDER=mock) for local development.',
+                { cause: error }
+            );
+        }
+        throw error;
+    }
+}
+
 class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
     constructor({ region } = {}) {
         super();
+        const {
+            SchedulerClient,
+            CreateScheduleCommand,
+            DeleteScheduleCommand,
+            GetScheduleCommand,
+            ResourceNotFoundException,
+        } = loadSchedulerSdk();
+        this.sdk = {
+            CreateScheduleCommand,
+            DeleteScheduleCommand,
+            GetScheduleCommand,
+            ResourceNotFoundException,
+        };
         this.client = new SchedulerClient({
             region: region || process.env.AWS_REGION || 'us-east-1',
         });
@@ -42,7 +88,12 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
      * @param {Object} params.payload - Message payload
      * @returns {Promise<{scheduledJobId: string, scheduledAt: string}>}
      */
-    async scheduleOneTime({ scheduleName, scheduleAt, queueResourceId, payload }) {
+    async scheduleOneTime({
+        scheduleName,
+        scheduleAt,
+        queueResourceId,
+        payload,
+    }) {
         if (!scheduleName) {
             throw new Error('scheduleName is required');
         }
@@ -59,8 +110,11 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
         }
 
         // Format date to AWS schedule expression (at(yyyy-mm-ddThh:mm:ss))
-        const scheduleExpression = `at(${scheduleAt.toISOString().replace(/\.\d{3}Z$/, '')})`;
+        const scheduleExpression = `at(${scheduleAt
+            .toISOString()
+            .replace(/\.\d{3}Z$/, '')})`;
 
+        const { CreateScheduleCommand } = this.sdk;
         const command = new CreateScheduleCommand({
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
@@ -107,6 +161,7 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
             throw new Error('scheduleName is required');
         }
 
+        const { DeleteScheduleCommand, ResourceNotFoundException } = this.sdk;
         const command = new DeleteScheduleCommand({
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
@@ -141,6 +196,7 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
             throw new Error('scheduleName is required');
         }
 
+        const { GetScheduleCommand, ResourceNotFoundException } = this.sdk;
         const command = new GetScheduleCommand({
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
@@ -153,9 +209,7 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
             // Format: at(yyyy-mm-ddThh:mm:ss)
             let scheduledAt = null;
             if (response.ScheduleExpression) {
-                const match = response.ScheduleExpression.match(
-                    /^at\((.+)\)$/
-                );
+                const match = response.ScheduleExpression.match(/^at\((.+)\)$/);
                 if (match) {
                     scheduledAt = new Date(match[1] + 'Z').toISOString();
                 }

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,

package/infrastructure/scheduler/scheduler-service-factory.js

@@ -7,22 +7,16 @@
  * Environment Detection:
  * - SCHEDULER_PROVIDER=eventbridge -> Use AWS EventBridge Scheduler
  * - SCHEDULER_PROVIDER=mock -> Use in-memory mock scheduler
- * - SCHEDULER_PROVIDER=netlify -> Netlify poll-and-dispatch scheduler
- *   (friggframework/frigg#545; needs `repository`, usually `queueProvider`)
- * - Default on Netlify (NETLIFY=true, set by the Netlify runtime and build;
- *   provider-netlify's generated functions also set SCHEDULER_PROVIDER) -> Netlify
  * - Default in dev/test/local stages -> Mock scheduler
  * - Default in other stages -> EventBridge scheduler
- * - Any other name -> require('@friggframework/provider-<name>').SchedulerAdapter
- *
- * Adapters are required inside their branch so building one never loads
- * another's SDK (@aws-sdk/client-scheduler is not a core dependency).
  */
 
+const { EventBridgeSchedulerAdapter } = require('./eventbridge-scheduler-adapter');
+const { MockSchedulerAdapter } = require('./mock-scheduler-adapter');
+
 const SCHEDULER_PROVIDERS = {
     EVENTBRIDGE: 'eventbridge',
     MOCK: 'mock',
-    NETLIFY: 'netlify',
 };
 
 const LOCAL_STAGES = ['dev', 'test', 'local'];
@@ -38,12 +32,6 @@ function determineProvider() {
         return explicitProvider;
     }
 
-    // Checked before the stage: a Netlify site with no STAGE (or STAGE=dev)
-    // must still persist schedules where scheduled-sync reads them.
-    if (process.env.NETLIFY === 'true') {
-        return SCHEDULER_PROVIDERS.NETLIFY;
-    }
-
     const stage = process.env.STAGE || 'dev';
     if (LOCAL_STAGES.includes(stage)) {
         return SCHEDULER_PROVIDERS.MOCK;
@@ -52,13 +40,6 @@ function determineProvider() {
     return SCHEDULER_PROVIDERS.EVENTBRIDGE;
 }
 
-function createDefaultScheduledJobRepository() {
-    const { ScheduledJobRepository } = require('./scheduled-job-repository');
-    // The prisma export is a lazy proxy: nothing connects until a query runs.
-    const { prisma } = require('../../database/prisma');
-    return new ScheduledJobRepository({ prismaClient: prisma });
-}
-
 /**
  * Create a scheduler service instance
  *
@@ -66,51 +47,22 @@ function createDefaultScheduledJobRepository() {
  * @param {string} options.provider - Scheduler provider ('eventbridge' or 'mock')
  * @param {string} options.region - AWS region (for EventBridge)
  * @param {boolean} options.verbose - Verbose logging (for Mock)
- * @param {Object} [options.repository] - Schedule repository (for Netlify: persists schedules)
- * @param {Object} [options.queueProvider] - Queue provider (for Netlify: dispatches due jobs)
  * @returns {SchedulerServiceInterface} Implementation of scheduler interface
  */
 function createSchedulerService(options = {}) {
     const provider = options.provider || determineProvider();
 
     switch (provider) {
-        case SCHEDULER_PROVIDERS.EVENTBRIDGE: {
-            const { EventBridgeSchedulerAdapter } = require('./eventbridge-scheduler-adapter');
+        case SCHEDULER_PROVIDERS.EVENTBRIDGE:
             return new EventBridgeSchedulerAdapter({
                 region: options.region,
             });
-        }
-        case SCHEDULER_PROVIDERS.MOCK: {
-            const { MockSchedulerAdapter } = require('./mock-scheduler-adapter');
+        case SCHEDULER_PROVIDERS.MOCK:
             return new MockSchedulerAdapter({
                 verbose: options.verbose,
             });
-        }
-        case SCHEDULER_PROVIDERS.NETLIFY: {
-            const { NetlifySchedulerAdapter } = require('./netlify-scheduler-adapter');
-            return new NetlifySchedulerAdapter({
-                // Default: the Prisma ScheduledJob rows that the Netlify
-                // scheduled-sync function polls. Without it the adapter
-                // falls back to memory, and a schedule made in one function
-                // is never seen by the cron.
-                repository: options.repository || createDefaultScheduledJobRepository(),
-                queueProvider: options.queueProvider,
-            });
-        }
-        default: {
-            let plugin;
-            try {
-                plugin = require('../../providers/resolve-provider').resolveProvider(null, {
-                    provider,
-                });
-            } catch (error) {
-                throw new Error(`Unknown scheduler provider: ${provider} (${error.message})`);
-            }
-            if (!plugin.SchedulerAdapter) {
-                throw new Error(`Unknown scheduler provider: ${provider}`);
-            }
-            return new plugin.SchedulerAdapter(options);
-        }
+        default:
+            throw new Error(`Unknown scheduler provider: ${provider}`);
     }
 }
 

package/integrations/index.js

@@ -21,7 +21,6 @@ module.exports = {
     Options,
     createIntegrationRouter,
     checkRequiredParams,
-    // Deprecated (ADR-059): a wrapper over getEntityTypeRegistry.
     getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
     validateExtensionBinding,

package/integrations/integration-base.js

@@ -457,6 +457,35 @@ class IntegrationBase {
         );
     }
 
+    /**
+     * Insert-only mapping write; usable as an atomic claim/lock row.
+     * @throws {MappingAlreadyExistsError} If a mapping for sourceId exists
+     */
+    async createMapping(sourceId, mapping) {
+        if (!sourceId) {
+            throw new Error(`sourceId must be set`);
+        }
+        return await this.integrationMappingRepository.createMapping(
+            this.id,
+            sourceId,
+            mapping
+        );
+    }
+
+    /**
+     * Deletes the mapping for sourceId. A missing mapping is not an error
+     * (resolves with deletedCount 0).
+     */
+    async deleteMapping(sourceId) {
+        if (!sourceId) {
+            throw new Error(`sourceId must be set`);
+        }
+        return await this.integrationMappingRepository.deleteMapping(
+            this.id,
+            sourceId
+        );
+    }
+
     /**
      * CHILDREN CAN OVERRIDE THESE CONFIGURATION METHODS
      */