@friggframework/core 2.0.0--canary.704.79d9a63.0 → 2.0.0--canary.686.e94de4d.0

package/infrastructure/scheduler/scheduled-job-repository.js

@@ -0,0 +1,118 @@
+/**
+ * Scheduled Job Repository
+ *
+ * Prisma-based implementation of the repository interface required by
+ * NetlifySchedulerAdapter. Persists one-time scheduled jobs to the
+ * ScheduledJob model so they survive function restarts.
+ *
+ * Repository interface:
+ *   save(scheduleData)        — Upsert a scheduled job
+ *   delete(scheduleName)      — Remove a scheduled job
+ *   findByName(scheduleName)  — Find a single scheduled job
+ *   findDue(now, { leaseMs }) — Find due jobs: PENDING, or PROCESSING with an
+ *                               expired lease (a dispatcher that died after
+ *                               claiming), where scheduledAt <= now
+ *   claim(scheduleName, now, { leaseMs })
+ *                             — Atomically move one due job to PROCESSING;
+ *                               true only for the one caller that won it
+ *
+ * The lease clock is the row's updatedAt: a claim writes it, so a PROCESSING
+ * row whose updatedAt is older than now - leaseMs is claimable again.
+ */
+
+const DEFAULT_LEASE_MS = 5 * 60 * 1000;
+
+// Rows a dispatcher may take: never claimed, or claimed by one that has not
+// finished within the lease.
+function claimableWhere(now, leaseMs = DEFAULT_LEASE_MS) {
+    return {
+        OR: [
+            { state: 'PENDING' },
+            {
+                state: 'PROCESSING',
+                updatedAt: { lt: new Date(now.getTime() - leaseMs) },
+            },
+        ],
+    };
+}
+
+class ScheduledJobRepository {
+    /**
+     * @param {Object} options
+     * @param {import('@prisma/client').PrismaClient} options.prismaClient
+     */
+    constructor({ prismaClient }) {
+        if (!prismaClient) {
+            throw new Error(
+                'ScheduledJobRepository requires a prismaClient instance'
+            );
+        }
+        this.prisma = prismaClient;
+    }
+
+    async save(scheduleData) {
+        return this.prisma.scheduledJob.upsert({
+            where: { scheduleName: scheduleData.scheduleName },
+            update: {
+                scheduledAt: new Date(scheduleData.scheduledAt),
+                queueResourceId: scheduleData.queueResourceId,
+                payload: scheduleData.payload ?? undefined,
+                state: scheduleData.state || 'PENDING',
+            },
+            create: {
+                scheduleName: scheduleData.scheduleName,
+                scheduledAt: new Date(scheduleData.scheduledAt),
+                queueResourceId: scheduleData.queueResourceId,
+                payload: scheduleData.payload ?? undefined,
+                state: scheduleData.state || 'PENDING',
+            },
+        });
+    }
+
+    async delete(scheduleName) {
+        try {
+            await this.prisma.scheduledJob.delete({
+                where: { scheduleName },
+            });
+        } catch (error) {
+            // P2025 = record not found — safe to ignore on delete
+            if (error.code !== 'P2025') {
+                throw error;
+            }
+        }
+    }
+
+    async findByName(scheduleName) {
+        return this.prisma.scheduledJob.findUnique({
+            where: { scheduleName },
+        });
+    }
+
+    async findDue(now, { leaseMs = DEFAULT_LEASE_MS } = {}) {
+        return this.prisma.scheduledJob.findMany({
+            where: {
+                scheduledAt: { lte: now },
+                ...claimableWhere(now, leaseMs),
+            },
+            orderBy: { scheduledAt: 'asc' },
+        });
+    }
+
+    /**
+     * Conditional update: only a row that is still claimable moves to
+     * PROCESSING, so of two overlapping ticks exactly one gets count === 1.
+     * (PostgreSQL re-checks the WHERE on the row it locked; MongoDB updates
+     * each document atomically.)
+     *
+     * @returns {Promise<boolean>} true when this caller claimed the job
+     */
+    async claim(scheduleName, now, { leaseMs = DEFAULT_LEASE_MS } = {}) {
+        const { count } = await this.prisma.scheduledJob.updateMany({
+            where: { scheduleName, ...claimableWhere(now, leaseMs) },
+            data: { state: 'PROCESSING', updatedAt: now },
+        });
+        return count === 1;
+    }
+}
+
+module.exports = { ScheduledJobRepository, DEFAULT_LEASE_MS };

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

@@ -7,16 +7,22 @@
  * 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'];
@@ -32,6 +38,12 @@ 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;
@@ -40,6 +52,13 @@ 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
  *
@@ -47,22 +66,51 @@ 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({
+                // 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);
+        }
     }
 }
 

package/integrations/index.js

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

package/integrations/integration-base.js

@@ -457,35 +457,6 @@ 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
      */