@friggframework/core 2.0.0--canary.679.a2bcc2f.0 → 2.0.0--canary.686.87e9875.0

package/infrastructure/scheduler/netlify-scheduler-adapter.js

@@ -0,0 +1,185 @@
+/**
+ * Netlify Scheduler Adapter
+ *
+ * Implements SchedulerServiceInterface for Netlify deployments.
+ *
+ * Netlify Scheduled Functions use cron syntax but are defined statically in
+ * netlify.toml or via the @netlify/functions schedule() helper. They cannot
+ * be created dynamically at runtime like EventBridge Scheduler.
+ *
+ * Strategy for one-time scheduled jobs on Netlify:
+ *   1. Store the schedule in the database (same as mock adapter pattern)
+ *   2. A Netlify Scheduled Function runs on a cron interval (e.g., every 5 min)
+ *   3. The cron function queries for due schedules and dispatches them
+ *      to a background function for execution
+ *
+ * This is a "poll-and-dispatch" pattern vs EventBridge's "push" pattern.
+ * Trade-off: slightly less precise timing (up to cron interval delay),
+ * but works on any platform without cloud-specific scheduling APIs.
+ *
+ * For integrations that need the queue provider to dispatch jobs:
+ *   - queueResourceId maps to the background function URL path
+ *   - Payload is stored and forwarded when the cron fires
+ */
+
+const { SchedulerServiceInterface } = require('./scheduler-service-interface');
+
+class NetlifySchedulerAdapter extends SchedulerServiceInterface {
+    /**
+     * @param {Object} options
+     * @param {Object} options.repository - Repository for persisting schedules
+     *   Must implement: save(schedule), delete(scheduleName),
+     *   findByName(scheduleName), findDue(now)
+     * @param {Object} [options.queueProvider] - Queue provider for dispatching due jobs
+     */
+    constructor(options = {}) {
+        super();
+        this.repository = options.repository;
+        this.queueProvider = options.queueProvider;
+
+        if (!this.repository) {
+            console.warn(
+                '[NetlifyScheduler] No repository provided. ' +
+                    'Schedules will be stored in memory (lost on function restart). ' +
+                    'Provide a database-backed repository for production use.'
+            );
+            this._inMemorySchedules = new Map();
+        }
+    }
+
+    async scheduleOneTime({
+        scheduleName,
+        scheduleAt,
+        queueResourceId,
+        payload,
+    }) {
+        if (!scheduleName) throw new Error('scheduleName is required');
+        if (!scheduleAt || !(scheduleAt instanceof Date))
+            throw new Error('scheduleAt must be a valid Date object');
+        if (!queueResourceId) throw new Error('queueResourceId is required');
+
+        const scheduleData = {
+            scheduleName,
+            scheduledAt: scheduleAt.toISOString(),
+            queueResourceId,
+            payload,
+            createdAt: new Date().toISOString(),
+            state: 'PENDING',
+        };
+
+        if (this.repository) {
+            await this.repository.save(scheduleData);
+        } else {
+            this._inMemorySchedules.set(scheduleName, scheduleData);
+        }
+
+        console.log(
+            `[NetlifyScheduler] Scheduled: ${scheduleName} for ${scheduleAt.toISOString()}`
+        );
+
+        return {
+            scheduledJobId: `netlify-schedule-${scheduleName}`,
+            scheduledAt: scheduleAt.toISOString(),
+        };
+    }
+
+    async deleteSchedule(scheduleName) {
+        if (!scheduleName) throw new Error('scheduleName is required');
+
+        if (this.repository) {
+            await this.repository.delete(scheduleName);
+        } else {
+            this._inMemorySchedules.delete(scheduleName);
+        }
+
+        console.log(`[NetlifyScheduler] Deleted schedule: ${scheduleName}`);
+    }
+
+    async getScheduleStatus(scheduleName) {
+        if (!scheduleName) throw new Error('scheduleName is required');
+
+        let schedule;
+        if (this.repository) {
+            schedule = await this.repository.findByName(scheduleName);
+        } else {
+            schedule = this._inMemorySchedules.get(scheduleName);
+        }
+
+        if (!schedule) {
+            return { exists: false };
+        }
+
+        return {
+            exists: true,
+            scheduledAt: schedule.scheduledAt,
+            state: schedule.state,
+        };
+    }
+
+    /**
+     * Process due schedules. Called by the Netlify cron function.
+     *
+     * Finds all schedules where scheduledAt <= now, dispatches them
+     * to the queue provider, and marks them as completed.
+     *
+     * @returns {Promise<{ processed: number, errors: number }>}
+     */
+    async processDueSchedules() {
+        if (!this.repository) {
+            console.warn(
+                '[NetlifyScheduler] Cannot process due schedules without a repository'
+            );
+            return { processed: 0, errors: 0 };
+        }
+
+        const now = new Date();
+        const dueSchedules = await this.repository.findDue(now);
+
+        let processed = 0;
+        let errors = 0;
+
+        for (const schedule of dueSchedules) {
+            try {
+                // Mark as PROCESSING before dispatch so the next cron tick
+                // won't re-pick this schedule (findDue only returns PENDING).
+                await this.repository.save({
+                    ...schedule,
+                    state: 'PROCESSING',
+                });
+
+                if (this.queueProvider) {
+                    await this.queueProvider.send(
+                        schedule.payload,
+                        schedule.queueResourceId
+                    );
+                } else {
+                    console.log(
+                        `[NetlifyScheduler] No queue provider — logging payload for: ${schedule.scheduleName}`,
+                        JSON.stringify(schedule.payload)
+                    );
+                }
+
+                await this.repository.delete(schedule.scheduleName);
+                processed++;
+            } catch (error) {
+                console.error(
+                    `[NetlifyScheduler] Error processing schedule ${schedule.scheduleName}:`,
+                    error
+                );
+                // Mark as FAILED so it won't be re-dispatched automatically.
+                // Operators can inspect FAILED schedules and retry manually.
+                await this.repository
+                    .save({ ...schedule, state: 'FAILED' })
+                    .catch(() => {});
+                errors++;
+            }
+        }
+
+        console.log(
+            `[NetlifyScheduler] Processed ${processed} due schedules, ${errors} errors`
+        );
+        return { processed, errors };
+    }
+}
+
+module.exports = { NetlifySchedulerAdapter };

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

@@ -7,16 +7,20 @@
  * 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 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'];
@@ -47,22 +51,47 @@ function determineProvider() {
  * @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:
+        case SCHEDULER_PROVIDERS.EVENTBRIDGE: {
+            const { EventBridgeSchedulerAdapter } = require('./eventbridge-scheduler-adapter');
             return new EventBridgeSchedulerAdapter({
                 region: options.region,
             });
-        case SCHEDULER_PROVIDERS.MOCK:
+        }
+        case SCHEDULER_PROVIDERS.MOCK: {
+            const { MockSchedulerAdapter } = require('./mock-scheduler-adapter');
             return new MockSchedulerAdapter({
                 verbose: options.verbose,
             });
-        default:
-            throw new Error(`Unknown scheduler provider: ${provider}`);
+        }
+        case SCHEDULER_PROVIDERS.NETLIFY: {
+            const { NetlifySchedulerAdapter } = require('./netlify-scheduler-adapter');
+            return new NetlifySchedulerAdapter({
+                repository: options.repository,
+                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);
+        }
     }
 }
 

package/integrations/integration-router.js

@@ -51,22 +51,27 @@ const {
 const {
     createUserRepository,
 } = require('../user/repositories/user-repository-factory');
-const {
-    GetUserFromBearerToken,
-} = require('../user/use-cases/get-user-from-bearer-token');
-const {
-    GetUserFromXFriggHeaders,
-} = require('../user/use-cases/get-user-from-x-frigg-headers');
-const {
-    GetUserFromAdopterJwt,
-} = require('../user/use-cases/get-user-from-adopter-jwt');
 const {
     AuthenticateWithSharedSecret,
 } = require('../user/use-cases/authenticate-with-shared-secret');
 const { AuthenticateUser } = require('../user/use-cases/authenticate-user');
+const {
+    buildUserAuthentication,
+} = require('../user/create-user-authentication');
 const {
     ProcessAuthorizationCallback,
 } = require('../modules/use-cases/process-authorization-callback');
+const { createScopePolicy } = require('../modules/scope-policy');
+const {
+    AuthorizeEntityForUser,
+} = require('../modules/use-cases/authorize-entity-for-user');
+const {
+    CreateEntityFromCredential,
+} = require('../modules/use-cases/create-entity-from-credential');
+const {
+    ResolveIntegrationOwnership,
+} = require('./use-cases/resolve-integration-ownership');
+const { GetOwnedIntegrationRecord } = require('./use-cases/integration-operations-for-user');
 
 const log = getLogger('frigg.integrations');
 
@@ -77,26 +82,20 @@ function createIntegrationRouter() {
         integrations: integrationClasses,
         userConfig,
         moduleDefinitions,
+        ownership,
+        entityTypeRegistry,
     } = loadAppDefinition();
+    // Ownership by scope (ADR-056 §3): one object every use case asks.
+    const scopePolicy = createScopePolicy({ ownership, entityTypeRegistry });
     const moduleRepository = createModuleRepository();
     const integrationRepository = createIntegrationRepository();
     const credentialRepository = createCredentialRepository();
     const userRepository = createUserRepository();
-
-    const getUserFromBearerToken = new GetUserFromBearerToken({
-        userRepository,
-        userConfig,
-    });
-
-    const getUserFromXFriggHeaders = new GetUserFromXFriggHeaders({
-        userRepository,
-        userConfig,
-    });
-
-    const getUserFromAdopterJwt = new GetUserFromAdopterJwt({
-        userRepository,
-        userConfig,
-    });
+    const {
+        getUserFromBearerToken,
+        getUserFromXFriggHeaders,
+        getUserFromAdopterJwt,
+    } = buildUserAuthentication({ userConfig, userRepository });
 
     const authenticateWithSharedSecret = new AuthenticateWithSharedSecret();
 
@@ -123,6 +122,19 @@ function createIntegrationRouter() {
         integrationClasses,
         moduleFactory,
         moduleRepository,
+        scopePolicy,
+    });
+
+    // Decides who owns a new integration and which entities the caller may bind
+    // (the v1 create used to check neither), and who may reach an existing one.
+    const resolveIntegrationOwnership = new ResolveIntegrationOwnership({
+        moduleRepository,
+        integrationClasses,
+        scopePolicy,
+    });
+    const getOwnedIntegrationRecord = new GetOwnedIntegrationRecord({
+        integrationRepository,
+        scopePolicy,
     });
 
     const getCredentialForUser = new GetCredentialForUser({
@@ -138,6 +150,7 @@ function createIntegrationRouter() {
     const getEntitiesForUser = new GetEntitiesForUser({
         moduleRepository,
         moduleDefinitions,
+        scopePolicy,
     });
 
     const getIntegrationInstance = new GetIntegrationInstance({
@@ -163,37 +176,55 @@ function createIntegrationRouter() {
     const testModuleAuth = new TestModuleAuth({
         moduleRepository,
         moduleDefinitions,
+        scopePolicy,
     });
 
     const getModule = new GetModule({
         moduleRepository,
         moduleDefinitions,
+        scopePolicy,
     });
 
     const getEntityOptionsById = new GetEntityOptionsById({
         moduleRepository,
         moduleDefinitions,
+        scopePolicy,
     });
 
     const refreshEntityOptions = new RefreshEntityOptions({
         moduleRepository,
         moduleDefinitions,
+        scopePolicy,
     });
 
     const getPossibleIntegrations = new GetPossibleIntegrations({
         integrationClasses,
     });
 
+    // The owner of what an authorization creates follows its scope (ADR-056 §3.2).
     const processAuthorizationCallback = new ProcessAuthorizationCallback({
         moduleRepository,
         credentialRepository,
         integrationRepository,
         moduleDefinitions,
     });
+    const authorizeEntityForUser = new AuthorizeEntityForUser({
+        scopePolicy,
+        processAuthorizationCallback,
+    });
+    // v1 POST /api/entity: same owner resolution as /api/authorize.
+    const createEntityFromCredential = new CreateEntityFromCredential({
+        authorizeEntityForUser,
+        processAuthorizationCallback,
+        credentialRepository,
+        moduleDefinitions,
+    });
 
     const router = express();
 
     setIntegrationRoutes(router, authenticateUser, {
+        resolveIntegrationOwnership,
+        getOwnedIntegrationRecord,
         createIntegration,
         deleteIntegrationForUser,
         getIntegrationsForUser,
@@ -210,7 +241,8 @@ function createIntegrationRouter() {
         getModule,
         getEntityOptionsById,
         refreshEntityOptions,
-        processAuthorizationCallback,
+        authorizeEntityForUser,
+        createEntityFromCredential,
     });
     return router;
 }
@@ -247,6 +279,8 @@ function checkRequiredParams(params, requiredKeys) {
  */
 function setIntegrationRoutes(router, authenticateUser, useCases) {
     const {
+        resolveIntegrationOwnership,
+        getOwnedIntegrationRecord,
         createIntegration,
         deleteIntegrationForUser,
         getIntegrationsForUser,
@@ -255,15 +289,22 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
         updateIntegration,
         getPossibleIntegrations,
     } = useCases;
+
+    // The owner of an integration the caller may reach (404 otherwise), which is
+    // what the id-and-owner use cases below expect. `manage: true` is for
+    // changing or deleting: an organization's integration needs an admin (403).
+    const ownerOf = async (integrationId, user, options) =>
+        (await getOwnedIntegrationRecord.execute(integrationId, user, options))
+            .userId;
+
     router.route('/api/integrations').get(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
-            const userId = user.getId();
-            const integrations = await getIntegrationsForUser.execute(userId);
+            const integrations = await getIntegrationsForUser.execute(user);
             const results = {
                 entities: {
                     options: await getPossibleIntegrations.execute(),
-                    authorized: await getEntitiesForUser.execute(userId),
+                    authorized: await getEntitiesForUser.execute(user),
                 },
                 integrations: integrations,
             };
@@ -275,7 +316,6 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
     router.route('/api/integrations').post(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
-            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entities',
                 'config',
@@ -283,10 +323,17 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
 
             get(params.config, 'type');
 
+            const { ownerId, organizationId, adoptUnscoped } =
+                await resolveIntegrationOwnership.execute({
+                    entityIds: params.entities,
+                    config: params.config,
+                    user,
+                });
             const integration = await createIntegration.execute(
                 params.entities,
-                userId,
-                params.config
+                ownerId,
+                params.config,
+                { organizationId, adoptUnscoped }
             );
 
             res.status(201).json(integration);
@@ -296,12 +343,11 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
     router.route('/api/integrations/:integrationId').patch(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
-            const userId = user.getId();
             const params = checkRequiredParams(req.body, ['config']);
 
             const integration = await updateIntegration.execute(
                 req.params.integrationId,
-                userId,
+                await ownerOf(req.params.integrationId, user, { manage: true }),
                 params.config
             );
             res.json(integration);
@@ -314,7 +360,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             await deleteIntegrationForUser.execute(
                 params.integrationId,
-                user.getId()
+                await ownerOf(params.integrationId, user, { manage: true })
             );
             res.status(204).json({});
         })
@@ -326,7 +372,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             const integration = await getIntegrationInstance.execute(
                 params.integrationId,
-                user.getId()
+                await ownerOf(params.integrationId, user)
             );
             res.json(await integration.send('GET_CONFIG_OPTIONS'));
         })
@@ -342,7 +388,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
                 ]);
                 const integration = await getIntegrationInstance.execute(
                     params.integrationId,
-                    user.getId()
+                    await ownerOf(params.integrationId, user)
                 );
 
                 res.json(
@@ -356,7 +402,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             const integration = await getIntegrationInstance.execute(
                 params.integrationId,
-                user.getId()
+                await ownerOf(params.integrationId, user)
             );
             res.json(await integration.send('GET_USER_ACTIONS', req.body));
         })
@@ -373,7 +419,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
                 ]);
                 const integration = await getIntegrationInstance.execute(
                     params.integrationId,
-                    user.getId()
+                    await ownerOf(params.integrationId, user)
                 );
 
                 res.json(
@@ -398,7 +444,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
                 ]);
                 const integration = await getIntegrationInstance.execute(
                     params.integrationId,
-                    user.getId()
+                    await ownerOf(params.integrationId, user)
                 );
 
                 res.json(
@@ -419,7 +465,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             ]);
             const integration = await getIntegrationInstance.execute(
                 params.integrationId,
-                user.getId()
+                await ownerOf(params.integrationId, user)
             );
             res.json(await integration.send(params.actionId, req.body));
         })
@@ -436,7 +482,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             const integration = await getIntegrationInstance.execute(
                 params.integrationId,
-                user.getId()
+                await ownerOf(params.integrationId, user)
             );
 
             // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
@@ -456,7 +502,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             const instance = await getIntegrationInstance.execute(
                 params.integrationId,
-                user.getId()
+                await ownerOf(params.integrationId, user)
             );
 
             if (!instance) {
@@ -494,16 +540,21 @@ function setEntityRoutes(router, authenticateUser, useCases) {
         getModule,
         getEntityOptionsById,
         refreshEntityOptions,
-        processAuthorizationCallback,
+        authorizeEntityForUser,
+        createEntityFromCredential,
     } = useCases;
 
     router.route('/api/authorize').get(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
-            const userId = user.getId();
             const params = checkRequiredParams(req.query, ['entityType']);
+            // The owner POST stores under, so GET and POST describe one connection.
+            const { ownerId } = authorizeEntityForUser.resolveOwnership({
+                user,
+                entityType: params.entityType,
+            });
             const module = await getModuleInstanceFromType.execute(
-                userId,
+                ownerId,
                 params.entityType,
                 { state: req.query.state }
             );
@@ -522,11 +573,15 @@ function setEntityRoutes(router, authenticateUser, useCases) {
     router.route('/api/authorize').post(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
-            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entityType',
                 'data',
             ]);
+            const ownership = authorizeEntityForUser.resolveOwnership({
+                user,
+                entityType: params.entityType,
+            });
+            const userId = ownership.ownerId;
 
             const dataKeys =
                 params.data && typeof params.data === 'object'
@@ -538,11 +593,13 @@ function setEntityRoutes(router, authenticateUser, useCases) {
                 dataKeys,
             });
 
-            const entityDetails = await processAuthorizationCallback.execute(
-                userId,
-                params.entityType,
-                params.data
-            );
+            const { result: entityDetails } =
+                await authorizeEntityForUser.execute({
+                    user,
+                    entityType: params.entityType,
+                    data: params.data,
+                    ownership,
+                });
 
             log.info('Entity authorized', {
                 eventName: 'frigg.integrations.authorized',
@@ -559,35 +616,20 @@ function setEntityRoutes(router, authenticateUser, useCases) {
     router.route('/api/entity').post(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
-            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entityType',
                 'data',
             ]);
             checkRequiredParams(req.body.data, ['credential_id']);
 
-            // May want to pass along the user ID as well so credential ID's can't be fished???
-            const credential = await getCredentialForUser.execute(
-                params.data.credential_id,
-                userId
-            );
-
-            if (!credential) {
-                throw Boom.badRequest('Invalid credential ID');
-            }
-
-            const module = await getModuleInstanceFromType.execute(
-                userId,
-                params.entityType
-            );
-            const entityDetails = await module.getEntityDetails(
-                module.api,
-                null,
-                null,
-                userId
+            // The owner follows the entity type's scope, as /api/authorize.
+            res.json(
+                await createEntityFromCredential.execute({
+                    user,
+                    entityType: params.entityType,
+                    credentialId: params.data.credential_id,
+                })
             );
-
-            res.json(await module.findOrCreateEntity(entityDetails));
         })
     );