@friggframework/core 2.0.0--canary.690.08cd07e.0 → 2.0.0--canary.694.f66a64a.0

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

@@ -1,216 +0,0 @@
-/**
- * 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');
-
-// The one queue worker every Netlify deployment has (provider-netlify's
-// worker-background function); it dispatches by integrationName.
-const DEFAULT_WORKER_PATH = '/.netlify/functions/worker-background';
-const DEFAULT_LEASE_MS = 5 * 60 * 1000;
-
-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
-     * @param {number} [options.leaseMs] - how long a claimed (PROCESSING) job
-     *   is held before another tick may take it again (default 5 minutes,
-     *   well past a Netlify scheduled function's 60-second limit)
-     */
-    constructor(options = {}) {
-        super();
-        this.repository = options.repository;
-        this.queueProvider = options.queueProvider;
-        this.leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
-
-        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();
-        }
-    }
-
-    /**
-     * Where a due job is sent. Netlify has no per-integration queues, so an
-     * SQS-style queue URL (often unset here) maps to the worker function;
-     * a function path is kept as given.
-     *
-     * @param {string} [queueUrl]
-     * @returns {string} a path NetlifyBackgroundProvider.send() accepts
-     */
-    toQueueResourceId(queueUrl) {
-        return typeof queueUrl === 'string' && queueUrl.startsWith('/')
-            ? queueUrl
-            : DEFAULT_WORKER_PATH;
-    }
-
-    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, skipped: 0 };
-        }
-
-        const now = new Date();
-        const lease = { leaseMs: this.leaseMs };
-        const dueSchedules = await this.repository.findDue(now, lease);
-
-        let processed = 0;
-        let errors = 0;
-        let skipped = 0;
-
-        for (const schedule of dueSchedules) {
-            try {
-                // Claim before dispatch. Two overlapping ticks can both see
-                // the row in findDue; only the one whose conditional update
-                // wins sends it. A repository without claim() (a custom one)
-                // keeps the old unconditional PROCESSING write.
-                const claimed =
-                    typeof this.repository.claim === 'function'
-                        ? await this.repository.claim(schedule.scheduleName, now, lease)
-                        : (await this.repository.save({ ...schedule, state: 'PROCESSING' }), true);
-                if (!claimed) {
-                    skipped++;
-                    continue;
-                }
-
-                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, ${skipped} claimed elsewhere`
-        );
-        return { processed, errors, skipped };
-    }
-}
-
-module.exports = { NetlifySchedulerAdapter, DEFAULT_WORKER_PATH, DEFAULT_LEASE_MS };

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

@@ -1,118 +0,0 @@
-/**
- * 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/integrations/repositories/integration-not-found.js

@@ -1,14 +0,0 @@
-/**
- * The error `findIntegrationById` throws for an id with no row, and the one
- * predicate that recognises it. The adapters build the error here and the
- * use cases match it here, so the message is written once and a missing
- * integration can be told from any other failure without widening a regex.
- */
-const MESSAGE = /^Integration with id .+ not found$/;
-
-const integrationNotFoundError = (id) =>
-    new Error(`Integration with id ${id} not found`);
-
-const isIntegrationNotFound = (error) => MESSAGE.test(error?.message || '');
-
-module.exports = { integrationNotFoundError, isIntegrationNotFound };

package/integrations/schedule-config.js

@@ -1,80 +0,0 @@
-/**
- * An integration's schedule configuration (`static Definition.schedule`),
- * read by hosts that tick ONGOING_SYNC from a cron (provider-netlify's
- * scheduled-sync function).
- *
- *   schedule: {
- *       // 'class' (default): one ONGOING_SYNC per integration class per tick,
- *       //   with no integration id: the worker runs it on an unhydrated
- *       //   instance, so the handler finds its own installations.
- *       // 'installation': one ONGOING_SYNC per ENABLED integration record of
- *       //   the class, carrying `data.integrationId`, so the worker hydrates
- *       //   that installation before the handler runs.
- *       scope: 'installation',
- *       // Optional, 'installation' only: (integration, { now }) => boolean |
- *       // Promise<boolean>. Return false to skip that installation this tick.
- *       // Without it every installation is dispatched on every tick.
- *       isDue: (integration, { now }) => true,
- *   }
- *
- * Validated at load (loadAppDefinition) so a mistyped scope stops the app
- * rather than silently falling back to 'class'.
- */
-
-const SCHEDULE_SCOPES = Object.freeze({
-    CLASS: 'class',
-    INSTALLATION: 'installation',
-});
-
-const DEFAULT_SCHEDULE_SCOPE = SCHEDULE_SCOPES.CLASS;
-
-class ScheduleConfigError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ScheduleConfigError';
-        this.code = 'SCHEDULE_CONFIG_INVALID';
-    }
-}
-
-/**
- * @param {Object} [definition] - an integration's static Definition
- * @returns {{ scope: 'class'|'installation', isDue: Function|null }}
- * @throws {ScheduleConfigError} when `schedule` is malformed
- */
-function resolveScheduleConfig(definition) {
-    const name = definition?.name || 'integration';
-    const schedule = definition?.schedule;
-    if (schedule === undefined || schedule === null) {
-        return { scope: DEFAULT_SCHEDULE_SCOPE, isDue: null };
-    }
-    if (typeof schedule !== 'object' || Array.isArray(schedule)) {
-        throw new ScheduleConfigError(`${name}: Definition.schedule must be an object`);
-    }
-
-    const scopes = Object.values(SCHEDULE_SCOPES);
-    const scope = schedule.scope === undefined ? DEFAULT_SCHEDULE_SCOPE : schedule.scope;
-    if (!scopes.includes(scope)) {
-        throw new ScheduleConfigError(
-            `${name}: Definition.schedule.scope must be one of ${scopes.map((s) => `'${s}'`).join(', ')} (got ${JSON.stringify(schedule.scope)})`
-        );
-    }
-
-    const isDue = schedule.isDue === undefined ? null : schedule.isDue;
-    if (isDue !== null && typeof isDue !== 'function') {
-        throw new ScheduleConfigError(`${name}: Definition.schedule.isDue must be a function`);
-    }
-    if (isDue && scope !== SCHEDULE_SCOPES.INSTALLATION) {
-        throw new ScheduleConfigError(
-            `${name}: Definition.schedule.isDue applies to scope 'installation' only`
-        );
-    }
-
-    return { scope, isDue };
-}
-
-module.exports = {
-    SCHEDULE_SCOPES,
-    DEFAULT_SCHEDULE_SCOPE,
-    ScheduleConfigError,
-    resolveScheduleConfig,
-};

package/integrations/use-cases/dispatch-ongoing-syncs.js

@@ -1,100 +0,0 @@
-const {
-    SCHEDULE_SCOPES,
-    resolveScheduleConfig,
-} = require('../schedule-config');
-
-const ONGOING_SYNC_EVENT = 'ONGOING_SYNC';
-const ACTIVE_STATUS = 'ENABLED';
-
-/**
- * Dispatches one cron tick of ONGOING_SYNC to the queue worker, per each
- * integration class's `Definition.schedule.scope` (schedule-config.js):
- *
- * - 'class' (default): one message per class, `data: {}`.
- * - 'installation': one message per ENABLED integration record of the class,
- *   `data: { integrationId }`, so the worker hydrates that installation;
- *   skipped when the definition's `isDue(integration, { now })` says no.
- *
- * Only classes that implement `startOngoingSync` take part. A failure for one
- * class or installation is counted and logged; the rest still go out.
- */
-class DispatchOngoingSyncs {
-    /**
-     * @param {Object} params
-     * @param {Object} params.integrationRepository - findIntegrations({ type, status })
-     * @param {Object} params.queueProvider - send(message, queueId)
-     * @param {string} params.queueId - the worker the messages go to
-     * @param {() => Date} [params.now]
-     * @param {Object} [params.logger=console]
-     */
-    constructor({ integrationRepository, queueProvider, queueId, now = () => new Date(), logger = console }) {
-        this.integrationRepository = integrationRepository;
-        this.queueProvider = queueProvider;
-        this.queueId = queueId;
-        this.now = now;
-        this.logger = logger;
-    }
-
-    /**
-     * @param {Array<Function>} integrationClasses
-     * @returns {Promise<{ dispatched: number, notDue: number, errors: number }>}
-     */
-    async execute(integrationClasses = []) {
-        const result = { dispatched: 0, notDue: 0, errors: 0 };
-        const now = this.now();
-
-        for (const IntegrationClass of integrationClasses) {
-            const name = IntegrationClass?.Definition?.name;
-            if (!name) continue;
-            if (typeof IntegrationClass.prototype?.startOngoingSync !== 'function') continue;
-
-            try {
-                const { scope, isDue } = resolveScheduleConfig(IntegrationClass.Definition);
-                if (scope === SCHEDULE_SCOPES.INSTALLATION) {
-                    await this._dispatchPerInstallation(name, isDue, now, result);
-                } else {
-                    await this._send(name, {});
-                    result.dispatched++;
-                }
-            } catch (error) {
-                result.errors++;
-                this.logger.error(`[ScheduledSync] Failed to dispatch sync for ${name}:`, error.message);
-            }
-        }
-
-        return result;
-    }
-
-    async _dispatchPerInstallation(name, isDue, now, result) {
-        const integrations = await this.integrationRepository.findIntegrations({
-            type: name,
-            status: ACTIVE_STATUS,
-        });
-
-        for (const integration of integrations || []) {
-            try {
-                if (isDue && (await isDue(integration, { now })) !== true) {
-                    result.notDue++;
-                    continue;
-                }
-                await this._send(name, { integrationId: integration.id });
-                result.dispatched++;
-            } catch (error) {
-                result.errors++;
-                this.logger.error(
-                    `[ScheduledSync] Failed to dispatch sync for ${name} integration ${integration?.id}:`,
-                    error.message
-                );
-            }
-        }
-    }
-
-    _send(integrationName, data) {
-        return this.queueProvider.send(
-            { integrationName, event: ONGOING_SYNC_EVENT, data },
-            this.queueId
-        );
-    }
-}
-
-module.exports = { DispatchOngoingSyncs, ONGOING_SYNC_EVENT };