@friggframework/core 2.0.0--canary.703.12b980b.0 → 2.0.0--canary.707.df80bfd.0

package/integrations/integration-base.js

@@ -22,7 +22,6 @@ const { getTelemetry } = require('../telemetry/telemetry-runtime');
 const { instrumentHandler } = require('../telemetry/instrument-handler');
 const { bindTelemetryContext } = require('../telemetry/bind-telemetry-context');
 const { getLogger } = require('../logs');
-const { TRIGGER_RUN, TRIGGER_TICK, resolveTrigger } = require('./triggers');
 
 const constantsToBeMigrated = {
     defaultEvents: {
@@ -36,8 +35,6 @@ const constantsToBeMigrated = {
         REFRESH_USER_ACTION_OPTIONS: 'REFRESH_USER_ACTION_OPTIONS',
         WEBHOOK_RECEIVED: 'WEBHOOK_RECEIVED', // HTTP handler, no DB
         ON_WEBHOOK: 'ON_WEBHOOK', // Queue worker, DB-connected
-        [TRIGGER_RUN]: TRIGGER_RUN, // Queue worker: one recurring trigger run (ADR-055)
-        [TRIGGER_TICK]: TRIGGER_TICK, // Queue worker: a trigger tick carrying on from its page cursor
         // etc...
     },
     types: {
@@ -46,26 +43,6 @@ const constantsToBeMigrated = {
     },
 };
 
-/**
- * The facts about a webhook request that signature checks need, small enough to travel in the queue message: the
- * method, the public URL the vendor called, and the raw body (up to 96 KB; beyond that it is left out and a check that
- * needs it fails closed, because SQS messages are capped at 256 KB and the parsed body travels too).
- */
-const RAW_BODY_LIMIT = 96 * 1024;
-function webhookRequestFacts(req) {
-    const h = req.headers || {};
-    const proto = String(h['x-forwarded-proto'] || req.protocol || 'https').split(',')[0].trim();
-    const host = h['x-forwarded-host'] || h.host;
-    const url = host ? `${proto}://${host}${req.originalUrl || req.url || ''}` : undefined;
-    const raw = req.rawBody;
-    const rawBody = raw == null ? undefined : (Buffer.isBuffer(raw) ? raw.toString('utf8') : String(raw));
-    return {
-        method: req.method,
-        ...(url ? { url } : {}),
-        ...(rawBody !== undefined && Buffer.byteLength(rawBody) <= RAW_BODY_LIMIT ? { rawBody } : {}),
-    };
-}
-
 class IntegrationBase {
     // todo: maybe we can pass this as Dependency Injection in the sub-class constructor
     integrationRepository = createIntegrationRepository();
@@ -114,9 +91,6 @@ class IntegrationBase {
         extensions: {},
         // usage: { canonical: ['records.synced'], custom: { 'deals.enriched': { unit, label } } }
         usage: {},
-        // Recurring triggers (ADR-055) — see integrations/triggers.js
-        // Shape: { [name]: { every | at | cron, timezone?, tick?, when?, overlap?, configurable?, handler } }
-        triggers: {},
         display: {
             name: 'Integration Name',
             logo: '',
@@ -129,14 +103,6 @@ class IntegrationBase {
         return this.Definition.name;
     }
 
-    /**
-     * The deployed integration whose queue and functions this one runs on: itself, unless another class hosts it
-     * (`static Host`, e.g. a published integration definition run by the shared runtime).
-     */
-    static getDeploymentName() {
-        return (this.Host || this).Definition.name;
-    }
-
     static getCurrentVersion() {
         return this.Definition.version;
     }
@@ -205,14 +171,6 @@ class IntegrationBase {
                 type: constantsToBeMigrated.types.LIFE_CYCLE_EVENT,
                 handler: this.onWebhook,
             },
-            [TRIGGER_RUN]: {
-                type: constantsToBeMigrated.types.LIFE_CYCLE_EVENT,
-                handler: this.onTriggerRun,
-            },
-            [TRIGGER_TICK]: {
-                type: constantsToBeMigrated.types.LIFE_CYCLE_EVENT,
-                handler: this.onTriggerTick,
-            },
         };
     }
 
@@ -499,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
      */
@@ -564,90 +493,10 @@ class IntegrationBase {
         } else if (this.status === 'NEEDS_CONFIG') {
             await this.persistStatus('ENABLED');
         }
-        await this.reportTriggerChoices();
     }
 
     async onDelete(params) {}
 
-    /**
-     * The recurring triggers declared for one installation (ADR-055): `Definition.triggers`, each with its `name`.
-     * Static so the tick can read them from a record without hydrating the installation; a class whose triggers
-     * depend on the installation (integrations published as definitions, `Definition.instanceTriggers`) overrides it.
-     * @param {{ config?: Object, record?: Object }} [installation]
-     * @returns {Promise<Array<Object>>}
-     */
-    static async triggersFor(installation = {}) {
-        return Object.entries(this.Definition?.triggers || {}).map(([name, t]) => ({ ...t, name }));
-    }
-
-    /** This installation's trigger declarations (the static `triggersFor`, unless a subclass knows better). */
-    async triggerDeclarations() {
-        return this.constructor.triggersFor({ config: this.config || {}, record: this.record });
-    }
-
-    /**
-     * Run one recurring trigger: the queue worker dispatches `FRIGG_TRIGGER_RUN` here with
-     * `{ integrationId, trigger, scheduledFor }` after hydrating the installation. The handler is called as
-     * `handler(payload, ctx)` with `payload = { trigger, scheduledFor }` and `ctx = { modules, config, log, integration }`
-     * (ADR-054); a string handler names a method on this instance. Overlap and the run record: use-cases/run-trigger.js.
-     */
-    async onTriggerRun({ data = {} } = {}) {
-        const declarations = await this.triggerDeclarations();
-        const declaration = declarations.find((t) => t.name === data.trigger);
-        const resolved = declaration ? resolveTrigger(declaration.name, declaration, this.config || {}) : null;
-        const payload = { trigger: data.trigger, scheduledFor: data.scheduledFor };
-        const invoke = async (p) => {
-            const handler = typeof declaration.handler === 'string' ? this[declaration.handler] : declaration.handler;
-            if (typeof handler !== 'function') throw new Error(`Trigger "${declaration.name}" handler "${declaration.handler}" is not a method of ${this.constructor.Definition?.name}`);
-            return handler.call(this, p, { modules: this.modules, config: this.config || {}, log: this.logger, integration: this });
-        };
-        const { RunTrigger } = require('./use-cases/run-trigger');
-        if (!this.triggerProcessRepository) {
-            const { createProcessRepository } = require('./repositories/process-repository-factory');
-            this.triggerProcessRepository = createProcessRepository();
-        }
-        const outcome = await new RunTrigger({ processRepository: this.triggerProcessRepository }).execute({ integration: this, resolved, invoke, payload });
-        if (outcome.status !== 'ran') {
-            this.logger.info('Trigger run not started', { eventName: `${this.logger.name}.trigger_${outcome.status}`, trigger: data.trigger, reason: outcome.reason });
-        }
-        return outcome;
-    }
-
-    /** The queue a one-time scheduled job (a paused run's resume) fires into: this integration's deployment queue (`<NAME>_QUEUE_URL`). */
-    scheduleQueueUrl() {
-        if (typeof this.getQueueUrl === 'function') return this.getQueueUrl();
-        return process.env[`${this.constructor.getDeploymentName().toUpperCase().replace(/-/g, '_')}_QUEUE_URL`];
-    }
-
-    /** A tick that ran out of time continues here, on a dry instance, from its page cursor. */
-    async onTriggerTick({ data = {}, context } = {}) {
-        const { runTriggerTick } = require('./use-cases/run-trigger-tick');
-        return runTriggerTick(this.constructor, data, context);
-    }
-
-    /**
-     * Report each trigger timing this installation chose that cannot be used (not configurable, or under the
-     * floor): the trigger keeps its default, and the integration gets a warning message saying why. No-op for an
-     * integration without triggers.
-     */
-    async reportTriggerChoices() {
-        if (this.id === undefined || this.id === null) return [];
-        try {
-            const declarations = await this.triggerDeclarations();
-            const problems = declarations
-                .map((t) => ({ name: t.name, problems: resolveTrigger(t.name, t, this.config || {}).problems }))
-                .filter((p) => p.problems.length);
-            for (const p of problems) {
-                await this.updateIntegrationMessages.execute(this.id, 'warnings', 'Trigger timing not changed', `${p.name}: ${p.problems.join('; ')}`, Date.now());
-            }
-            return problems;
-        } catch (error) {
-            // A report, never a reason to fail the update.
-            this.logger.warn('Trigger choices not checked', { eventName: `${this.logger.name}.trigger_choices_unchecked`, error });
-            return [];
-        }
-    }
-
     async getConfigOptions() {
         const options = {
             jsonSchema: {},
@@ -719,7 +568,6 @@ class IntegrationBase {
             body,
             headers: req.headers,
             query: req.query,
-            ...webhookRequestFacts(req),
         });
 
         res.status(200).json({ received: true });
@@ -729,15 +577,6 @@ class IntegrationBase {
         // Default: no-op, integrations override this
     }
 
-    /**
-     * What a module's verifyWebhookSignature needs about a queued delivery (onWebhookReceived put it there): the
-     * headers, the parsed body, the raw body exactly as received, and the method and public URL some vendors sign
-     * (HubSpot v3). Call as `this.<module>.api.verifyWebhookSignature(this.webhookVerificationInput(data))`.
-     */
-    webhookVerificationInput(data = {}) {
-        return { headers: data.headers || {}, body: data.body, query: data.query || {}, rawBody: data.rawBody, method: data.method, url: data.url };
-    }
-
     /**
      * Queue a webhook for asynchronous worker dispatch.
      *
@@ -754,7 +593,7 @@ class IntegrationBase {
     async queueWebhook(data) {
         const { QueuerUtil } = require('../queues');
 
-        const queueName = `${this.constructor.getDeploymentName()
+        const queueName = `${this.constructor.Definition.name
             .toUpperCase()
             .replace(/-/g, '_')}_QUEUE_URL`;
         const queueUrl = process.env[queueName];
@@ -1096,4 +935,4 @@ class IntegrationBase {
     }
 }
 
-module.exports = { IntegrationBase, webhookRequestFacts };
+module.exports = { IntegrationBase };