@friggframework/core 2.0.0--canary.690.08cd07e.0 → 2.0.0--canary.693.d8859c2.0

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 };

package/integrations/use-cases/integration-operations-for-user.js

@@ -1,256 +0,0 @@
-const Boom = require('@hapi/boom');
-const { describeRecord } = require('../../modules/scope-visibility');
-const { DEFAULT_SCOPE_POLICY } = require('../../modules/scope-policy');
-const { assertCanManage } = require('../../modules/use-cases/manage-access');
-const { isIntegrationNotFound } = require('../repositories/integration-not-found');
-
-/**
- * Management API v2 integration operations. They put an access check
- * (missing or unavailable integration = 404) in front of the existing
- * integration use cases, and pass the record's owner id on. Access follows
- * the owner and the organization the integration was created in (ADR-056
- * §3.6), not the owner alone.
- */
-
-const notFound = (integrationId) =>
-    Boom.notFound(`Integration ${integrationId} not found`, {
-        code: 'INTEGRATION_NOT_FOUND',
-    });
-
-/**
- * The integration record, or 404 when it is missing or the caller may not
- * use it: not theirs or their active organization's, or created in another
- * organization.
- */
-class GetOwnedIntegrationRecord {
-    constructor({ integrationRepository, scopePolicy }) {
-        this.integrationRepository = integrationRepository;
-        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
-    }
-
-    /** `{ scope, owner, organizationId, access }` of a record to this caller, or null. */
-    describe(record, user) {
-        return describeRecord(record, this.scopePolicy.accessContext(user), 'integration');
-    }
-
-    /**
-     * @param {string} integrationId
-     * @param {Object} user - authenticated User
-     * @param {{manage?: boolean}} [options] - `manage: true` for changing or
-     *   deleting: a person may use an organization's integration but only an
-     *   admin may change it (403 ORG_ADMIN_REQUIRED)
-     */
-    async execute(integrationId, user, { manage = false } = {}) {
-        let record = null;
-        try {
-            record = await this.integrationRepository.findIntegrationById(
-                integrationId
-            );
-        } catch (error) {
-            if (
-                /Invalid ID|ObjectId|Malformed/i.test(error?.message || '') ||
-                isIntegrationNotFound(error)
-            ) {
-                throw notFound(integrationId);
-            }
-            throw error;
-        }
-        const tenancy = record && this.describe(record, user);
-        if (!tenancy) throw notFound(integrationId);
-        if (manage) assertCanManage(tenancy.access, `integration ${integrationId}`);
-        return record;
-    }
-}
-
-/**
- * Creates (or reuses) an integration between entities the caller may use.
- * The entities' access, the binding scopes and the integration type are
- * checked before anything is written, and the integration is owned and
- * paired with an organization by `resolveIntegrationOwnership` (§3, §3.6).
- */
-class CreateIntegrationForUser {
-    constructor({ createIntegration, resolveIntegrationOwnership, integrationClasses }) {
-        this.createIntegration = createIntegration;
-        this.resolveIntegrationOwnership = resolveIntegrationOwnership;
-        this.integrationClasses = integrationClasses || [];
-    }
-
-    async execute({ entities, config }, user) {
-        if (!config || typeof config !== 'object' || typeof config.type !== 'string') {
-            throw Boom.badRequest('config.type is required', {
-                code: 'VALIDATION_ERROR',
-                details: { field: 'config.type' },
-            });
-        }
-        const known = this.integrationClasses.some(
-            (IntegrationClass) => IntegrationClass.Definition?.name === config.type
-        );
-        if (!known) {
-            throw Boom.badRequest(`Unknown integration type '${config.type}'`, {
-                code: 'UNKNOWN_INTEGRATION_TYPE',
-            });
-        }
-        if (
-            !Array.isArray(entities) ||
-            entities.some((id) => typeof id !== 'string' && typeof id !== 'number')
-        ) {
-            throw Boom.badRequest('entities must be an array of entity ids', {
-                code: 'VALIDATION_ERROR',
-                details: { field: 'entities' },
-            });
-        }
-        const { ownerId, organizationId, adoptUnscoped } =
-            await this.resolveIntegrationOwnership.execute({
-                entityIds: entities,
-                config,
-                user,
-            });
-        return this.createIntegration.execute(
-            entities.map(String),
-            ownerId,
-            config,
-            { organizationId, adoptUnscoped }
-        );
-    }
-}
-
-/** The hydrated integration instance (modules loaded) for an owned integration. */
-class GetIntegrationInstanceForUser {
-    constructor({ getOwnedIntegrationRecord, getIntegrationInstance }) {
-        this.getOwnedIntegrationRecord = getOwnedIntegrationRecord;
-        this.getIntegrationInstance = getIntegrationInstance;
-    }
-
-    async execute(integrationId, user) {
-        const record = await this.getOwnedIntegrationRecord.execute(
-            integrationId,
-            user
-        );
-        return this.getIntegrationInstance.execute(record.id, record.userId);
-    }
-}
-
-/** Replaces an owned integration's config. */
-class UpdateIntegrationForUser {
-    constructor({ getOwnedIntegrationRecord, updateIntegration }) {
-        this.getOwnedIntegrationRecord = getOwnedIntegrationRecord;
-        this.updateIntegration = updateIntegration;
-    }
-
-    async execute(integrationId, user, config) {
-        if (!config || typeof config !== 'object' || Array.isArray(config)) {
-            throw Boom.badRequest('config must be an object', {
-                code: 'VALIDATION_ERROR',
-                details: { field: 'config' },
-            });
-        }
-        const record = await this.getOwnedIntegrationRecord.execute(
-            integrationId,
-            user,
-            { manage: true }
-        );
-        return this.updateIntegration.execute(record.id, record.userId, config);
-    }
-}
-
-/** Deletes an owned integration (runs its onDelete hooks). */
-class RemoveIntegrationForUser {
-    constructor({ getOwnedIntegrationRecord, deleteIntegrationForUser }) {
-        this.getOwnedIntegrationRecord = getOwnedIntegrationRecord;
-        this.deleteIntegrationForUser = deleteIntegrationForUser;
-    }
-
-    async execute(integrationId, user) {
-        const record = await this.getOwnedIntegrationRecord.execute(
-            integrationId,
-            user,
-            { manage: true }
-        );
-        await this.deleteIntegrationForUser.execute(record.id, record.userId);
-    }
-}
-
-/**
- * Sends one of the framework's user-facing events (GET_CONFIG_OPTIONS,
- * GET_USER_ACTIONS, ...) to an owned integration. Handlers pass fixed event
- * names only; caller-chosen action ids go through RunIntegrationActionForUser.
- */
-class SendIntegrationEventForUser {
-    constructor({ getIntegrationInstanceForUser }) {
-        this.getIntegrationInstanceForUser = getIntegrationInstanceForUser;
-    }
-
-    async execute(integrationId, user, event, payload) {
-        const instance = await this.getIntegrationInstanceForUser.execute(
-            integrationId,
-            user
-        );
-        return instance.send(event, payload);
-    }
-}
-
-/**
- * Runs a user action on an owned integration. Unlike v1, the action id must
- * be one the integration lists as a user action (static USER_ACTION events
- * or its dynamic user actions), so a caller cannot fire internal events such
- * as lifecycle hooks.
- */
-class RunIntegrationActionForUser {
-    constructor({ getIntegrationInstanceForUser }) {
-        this.getIntegrationInstanceForUser = getIntegrationInstanceForUser;
-    }
-
-    async execute(integrationId, user, actionId, payload) {
-        const instance = await this.getIntegrationInstanceForUser.execute(
-            integrationId,
-            user
-        );
-        const actions =
-            typeof instance.loadUserActions === 'function'
-                ? await instance.loadUserActions()
-                : {};
-        if (!actions || !Object.prototype.hasOwnProperty.call(actions, actionId)) {
-            throw Boom.notFound(
-                `Integration ${integrationId} has no user action '${actionId}'`,
-                { code: 'ACTION_NOT_FOUND' }
-            );
-        }
-        return instance.send(actionId, payload);
-    }
-}
-
-/**
- * Runs the integration's auth test and reconciles its status. Returns the
- * errors recorded during the test.
- */
-class TestIntegrationAuthForUser {
-    constructor({ getIntegrationInstanceForUser }) {
-        this.getIntegrationInstanceForUser = getIntegrationInstanceForUser;
-    }
-
-    /** @returns {Promise<{ ok: boolean, errors: Array<Object> }>} */
-    async execute(integrationId, user) {
-        const instance = await this.getIntegrationInstanceForUser.execute(
-            integrationId,
-            user
-        );
-        const start = Date.now();
-        const authPassed = await instance.testAuth();
-        await instance.reconcileAuthStatus(authPassed);
-        const errors = (instance.record?.messages?.errors || []).filter(
-            ({ timestamp }) => timestamp >= start
-        );
-        return { ok: Boolean(authPassed) && errors.length === 0, errors };
-    }
-}
-
-module.exports = {
-    GetOwnedIntegrationRecord,
-    CreateIntegrationForUser,
-    GetIntegrationInstanceForUser,
-    UpdateIntegrationForUser,
-    RemoveIntegrationForUser,
-    SendIntegrationEventForUser,
-    RunIntegrationActionForUser,
-    TestIntegrationAuthForUser,
-};