@memberjunction/scheduling-engine 5.44.0 → 5.45.1

package/dist/UserRoutineProcessor.js

@@ -0,0 +1,169 @@
+/**
+ * @fileoverview Pure, side-effect-free logic for the User Routines dispatcher.
+ *
+ * Everything in this module is deterministic and unit-testable without a database:
+ * due-evaluation (activation window + NextRunAt), next-run/claim computation (cron with a
+ * StartAt floor), OnChange result hashing, the notify-condition matrix, and recipient
+ * ordering. The `UserRoutineDispatcherDriver` composes these primitives with the entity
+ * layer; `MJUserRoutineEntityServer` (in @memberjunction/core-entities-server) reuses
+ * `ComputeRoutineNextRunAt` so the entity save path and the dispatcher compute NextRunAt
+ * with the SAME cron helper and StartAt semantics.
+ *
+ * @module @memberjunction/scheduling-engine
+ */
+import { createHash } from 'node:crypto';
+import { CronExpressionHelper } from './CronExpressionHelper.js';
+/**
+ * Same 1-second tolerance the ScheduledJobEngine applies when comparing NextRunAt to the
+ * evaluation time, so a routine whose NextRunAt lands a few hundred ms after the sweep
+ * timestamp still runs on this pass instead of waiting a full dispatcher interval.
+ */
+export const ROUTINE_DUE_TOLERANCE_MS = 1000;
+/**
+ * Compute the next run time for a routine: the first cron occurrence strictly after
+ * `fromDate`, floored by the routine's activation-window start. When `startAt` is in the
+ * future relative to `fromDate`, the next occurrence is computed from `startAt` instead —
+ * an Active routine never gets a NextRunAt before its window opens.
+ *
+ * @throws when the cron expression or timezone is invalid (callers validate first via
+ *         {@link CronExpressionHelper.ValidateExpression} / entity Validate()).
+ */
+export function ComputeRoutineNextRunAt(cronExpression, timezone, fromDate, startAt) {
+    const effectiveFrom = startAt != null && startAt.getTime() > fromDate.getTime() ? startAt : fromDate;
+    return CronExpressionHelper.GetNextRunTime(cronExpression, timezone || 'UTC', effectiveFrom);
+}
+/**
+ * Activation-window check (independent of NextRunAt):
+ * - StartAt: NULL = eligible immediately; otherwise eligible once `StartAt <= now`.
+ * - EndAt:   NULL = no end; otherwise eligible only while `EndAt > now` (automatic sunset —
+ *   a routine whose EndAt equals the evaluation time has already ended).
+ */
+export function IsRoutineWithinActivationWindow(fields, now) {
+    if (fields.StartAt != null && fields.StartAt.getTime() > now.getTime()) {
+        return false;
+    }
+    if (fields.EndAt != null && fields.EndAt.getTime() <= now.getTime()) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Full due-evaluation: Active + inside the activation window + NextRunAt set and passed
+ * (within {@link ROUTINE_DUE_TOLERANCE_MS}). A NULL NextRunAt is never "due" — it means the
+ * routine needs seeding (see {@link RoutineNeedsSeeding}).
+ */
+export function IsRoutineDue(fields, now) {
+    if (fields.Status !== 'Active') {
+        return false;
+    }
+    if (!IsRoutineWithinActivationWindow(fields, now)) {
+        return false;
+    }
+    if (fields.NextRunAt == null) {
+        return false;
+    }
+    return fields.NextRunAt.getTime() <= now.getTime() + ROUTINE_DUE_TOLERANCE_MS;
+}
+/**
+ * A routine "needs seeding" when it is Active, inside its activation window, and has never
+ * had a NextRunAt computed (newly created outside the entity-server save path, or legacy
+ * rows). The dispatcher computes + saves NextRunAt for these WITHOUT running them — they
+ * become due on a later sweep once their first cron occurrence passes.
+ */
+export function RoutineNeedsSeeding(fields, now) {
+    return fields.Status === 'Active' && fields.NextRunAt == null && IsRoutineWithinActivationWindow(fields, now);
+}
+/**
+ * SQL prefilter for the dispatcher's due-routine sweep. Matches Active routines inside
+ * their activation window whose NextRunAt is NULL (seeding candidates) or has passed.
+ * Every row returned is re-verified in JS via {@link IsRoutineDue} / {@link RoutineNeedsSeeding}
+ * — the SQL filter only narrows the sweep, it is not the source of truth.
+ */
+export function BuildDueRoutineFilter(nowIso) {
+    return `Status='Active'` +
+        ` AND (StartAt IS NULL OR StartAt <= '${nowIso}')` +
+        ` AND (EndAt IS NULL OR EndAt > '${nowIso}')` +
+        ` AND (NextRunAt IS NULL OR NextRunAt <= '${nowIso}')`;
+}
+/**
+ * Matches ISO-8601 date-time tokens (with optional fractional seconds and timezone) —
+ * volatile "when did this run" markers that many targets embed in their results (e.g. the
+ * Calculate Expression action's `evaluatedAt`). They are execution metadata, not result
+ * content, so OnChange normalization strips them before hashing.
+ */
+const ISO_TIMESTAMP_PATTERN = /\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g;
+/**
+ * SHA-256 hex digest of the normalized result content. Normalization strips embedded
+ * ISO-8601 timestamps (volatile execution metadata that would otherwise register a
+ * "change" on every run), collapses whitespace runs to single spaces, and trims — so
+ * cosmetic formatting differences never trigger OnChange detection.
+ * Null/undefined content hashes as the empty string — deterministic, never throws.
+ */
+export function ComputeResultHash(content) {
+    const normalized = (content ?? '')
+        .replace(ISO_TIMESTAMP_PATTERN, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return createHash('sha256').update(normalized, 'utf8').digest('hex');
+}
+/**
+ * The notify-condition matrix. Only terminal outcomes (Success/Failed) can notify —
+ * Running/Skipped never do, regardless of condition.
+ *
+ * - `Always`:    any terminal outcome.
+ * - `OnSuccess`: Status === 'Success'.
+ * - `OnFailure`: Status === 'Failed'.
+ * - `OnChange`:  the run's ResultHash differs from the routine's prior LastResultHash.
+ *   A NULL prior hash (first run) counts as changed — the first observation of a
+ *   monitored value is itself news.
+ */
+export function EvaluateNotifyCondition(condition, runStatus, resultHash, priorResultHash) {
+    if (runStatus !== 'Success' && runStatus !== 'Failed') {
+        return false;
+    }
+    switch (condition) {
+        case 'Always':
+            return true;
+        case 'OnSuccess':
+            return runStatus === 'Success';
+        case 'OnFailure':
+            return runStatus === 'Failed';
+        case 'OnChange':
+            return resultHash != null && resultHash !== priorResultHash;
+        default:
+            // Future CHECK-constraint values flow through the generated union; stay total
+            // and conservative (no notification) until explicitly handled.
+            return false;
+    }
+}
+/**
+ * Returns a new array of recipients ordered by ascending Sequence. Ties preserve the
+ * input order (stable). The input array is not mutated.
+ */
+export function SortRecipientsBySequence(recipients) {
+    return [...recipients].sort((a, b) => a.Sequence - b.Sequence);
+}
+/**
+ * Run `worker` over `items` with at most `limit` concurrent executions. Results are
+ * returned in input order. The worker is responsible for its own error handling — a
+ * rejection from one item propagates, so dispatcher callers wrap each routine's work in
+ * its own try/catch (per-routine error isolation).
+ */
+export async function RunWithBoundedConcurrency(items, limit, worker) {
+    const effectiveLimit = Math.max(1, Math.floor(limit));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const lane = async () => {
+        while (true) {
+            const index = nextIndex++;
+            if (index >= items.length) {
+                return;
+            }
+            results[index] = await worker(items[index]);
+        }
+    };
+    const lanes = Array.from({ length: Math.min(effectiveLimit, items.length) }, () => lane());
+    await Promise.all(lanes);
+    return results;
+}
+//# sourceMappingURL=UserRoutineProcessor.js.map

package/dist/UserRoutineProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserRoutineProcessor.js","sourceRoot":"","sources":["../src/UserRoutineProcessor.ts"],"names":[],"mappings":"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"}

package/dist/drivers/UserRoutineDispatcherDriver.d.ts

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview Driver for the User Routine Dispatcher scheduled job (P1.5).
+ *
+ * One admin-owned Scheduled Job of this type (seeded via metadata, 1-minute cron) sweeps
+ * `MJ: User Routines` for due routines, claims each by advancing NextRunAt BEFORE running
+ * (so an overlapping pass never double-runs it), executes the routine's target (Agent /
+ * Action / Prompt) with bounded concurrency and per-routine error isolation, records each
+ * execution in `MJ: User Routine Runs` (telemetry lives on the linked AgentRun / PromptRun /
+ * ActionExecutionLog — never duplicated), and notifies the owner + recipients per the
+ * routine's NotifyCondition through the MJ template + notification stack.
+ *
+ * @module @memberjunction/scheduling-engine
+ */
+import { ValidationResult, UserInfo } from '@memberjunction/core';
+import { MJScheduledJobEntity, MJUserRoutineEntity } from '@memberjunction/core-entities';
+import { ScheduledJobResult, NotificationContent, ScheduledJobConfiguration } from '@memberjunction/scheduling-base-types';
+import { BaseScheduledJob, ScheduledJobExecutionContext } from '../BaseScheduledJob.js';
+/**
+ * Optional configuration (stored in ScheduledJob.Configuration). All fields optional —
+ * the dispatcher runs with sensible defaults when Configuration is empty.
+ */
+export interface UserRoutineDispatcherConfiguration extends ScheduledJobConfiguration {
+    /** Maximum routines executed concurrently within one sweep. Default 3. */
+    MaxConcurrentRoutines?: number;
+}
+/**
+ * Driver for the User Routine Dispatcher scheduled job.
+ *
+ * Configuration schema (stored in ScheduledJob.Configuration):
+ * `{ MaxConcurrentRoutines?: number }`
+ *
+ * Execution result details (stored in ScheduledJobRun.Details):
+ * `{ RoutinesEvaluated, RoutinesSeeded, RoutinesRun, Succeeded, Failed, Notified }`
+ */
+export declare class UserRoutineDispatcherDriver extends BaseScheduledJob {
+    /**
+     * The dispatcher is a by-design 1-minute sweeper: each pass claims due routines and
+     * does bounded work, so the engine's high-frequency cron warning doesn't apply.
+     */
+    get IsHighFrequencyByDesign(): boolean;
+    Execute(context: ScheduledJobExecutionContext): Promise<ScheduledJobResult>;
+    ValidateConfiguration(schedule: MJScheduledJobEntity): ValidationResult;
+    FormatNotification(context: ScheduledJobExecutionContext, result: ScheduledJobResult): NotificationContent;
+    /** Tolerant parse — the dispatcher needs no configuration, so empty/missing/invalid JSON yields defaults. */
+    private parseDispatcherConfiguration;
+    /**
+     * Load Active routines that are inside their activation window and either due or in
+     * need of NextRunAt seeding. The SQL prefilter narrows the sweep; JS re-verifies.
+     */
+    private loadCandidateRoutines;
+    /** Compute + persist NextRunAt for a never-scheduled routine WITHOUT running it. */
+    private seedNextRunAt;
+    /**
+     * Claim a due routine by advancing NextRunAt to the next cron occurrence BEFORE running.
+     * Persisting the claim first means an overlapping dispatcher pass (or a crash mid-run)
+     * can never double-run this occurrence — the routine simply isn't due anymore. Cross-
+     * process exclusion of whole sweeps is additionally provided by the Scheduled Job lock
+     * (the dispatcher job runs with ConcurrencyMode='Skip').
+     *
+     * @returns true when the claim persisted and the routine should run on this pass.
+     */
+    private claimRoutine;
+    /**
+     * Execute one claimed routine end-to-end: run row → target execution → run/routine
+     * bookkeeping → notification decision + delivery. Never throws for target failures —
+     * those are recorded on the run row; only run-row creation failures propagate.
+     */
+    private executeRoutine;
+    /** Create the `MJ: User Routine Runs` row in its initial Running state. */
+    private createRunRow;
+    /** Persist the run's terminal state + linkage. Telemetry stays on the linked records. */
+    private finalizeRunRow;
+    /** Roll the run outcome up onto the routine (LastRunAt / LastRunStatus / LastResultHash). */
+    private updateRoutineAfterRun;
+    /** Compact, capped text describing the outcome — the run row's human-readable summary. */
+    private buildResultSummary;
+    /**
+     * Dispatch by target type. The parameter type is derived from the generated entity so
+     * a future CHECK-constraint widening surfaces here at compile time.
+     */
+    private executeTarget;
+    /**
+     * Run an Agent target via AgentRunner, threading StartingPayload + RequestedSkillIDs.
+     *
+     * When the routine's dedicated conversation is available (existing `ConversationID`,
+     * or creatable — see {@link EnsureRoutineConversation}), the run goes through
+     * `RunAgentInConversation` so it lands as a proper conversation turn: a user
+     * ConversationDetail carrying InitialMessage, an assistant ConversationDetail with the
+     * agent result, and the AIAgentRun stamped with ConversationID/ConversationDetailID.
+     * When no conversation can be resolved, the run falls back to standalone `RunAgent`
+     * — identical outcome recording, just no conversation thread.
+     */
+    private executeAgentTarget;
+    /**
+     * Resolves (or lazily creates) the routine's dedicated conversation. Public so the
+     * integration suite can exercise the creation/reuse contract without an LLM call.
+     *
+     * The conversation is owned by the routine's owner and created with
+     * `ApplicationScope='Application'` + the "${ROUTINES_APPLICATION_NAME}" Application's ID,
+     * which keeps it OUT of the default chat list (the same hide mechanism meeting-room and
+     * Form Builder cockpit conversations use) while remaining fully reachable from the
+     * routine's UI. It is also Linked to the routine record (LinkedEntityID/LinkedRecordID)
+     * and pins the routine's agent as DefaultAgentID.
+     *
+     * Best-effort by design: any resolution/creation failure logs and returns null so the
+     * run proceeds standalone — a missing Routines app must never break a scheduled run.
+     */
+    EnsureRoutineConversation(routine: MJUserRoutineEntity, owner: UserInfo): Promise<string | null>;
+    /** The "${ROUTINES_APPLICATION_NAME}" Application row whose scope hides routine conversations from the default chat list. */
+    private findRoutinesApplication;
+    /** Parse RequestedSkillIDs (JSON array of AISkill IDs) — invalid/non-array content is ignored with a log. */
+    private parseRequestedSkillIDs;
+    /** Run a Prompt target via AIPromptRunner, passing StartingPayload as the data context. */
+    private executePromptTarget;
+    /** Run an Action target via ActionEngineServer; StartingPayload maps to input params by name. */
+    private executeActionTarget;
+    /** Map the routine's StartingPayload JSON object to ActionParam inputs (key → param name). */
+    private buildActionParams;
+    /**
+     * Deliver notifications for a run to the routine's owner + recipients (Sequence order),
+     * honoring per-recipient Channel and the routine's channel toggles. In-app goes through
+     * the standard NotificationEngine (metadata-seeded 'User Routine' type) with a raw
+     * `MJ: User Notifications` fallback; email is a structured TODO (see queueEmailDelivery).
+     *
+     * Best-effort: any delivery error is logged, never propagated into the run outcome.
+     *
+     * @returns true when at least one notification was actually delivered.
+     */
+    private sendRoutineNotifications;
+    /** Load the routine's recipients (ordering applied in JS via SortRecipientsBySequence). */
+    private loadRecipients;
+    /**
+     * Render the notification body through the MJ template stack: the routine's own
+     * NotificationTemplateID when set, else the metadata-seeded default template resolved
+     * BY NAME. Falls back to a plain-text body when no template resolves or rendering fails.
+     */
+    private renderNotificationMessage;
+    /** Resolve the routine's template (by ID) or the seeded default (by name) from the template cache. */
+    private resolveNotificationTemplate;
+    /** Plain-text notification body used when no template is resolvable. */
+    private buildPlainTextMessage;
+    /**
+     * In-app delivery: the standard NotificationEngine path first (respects the seeded
+     * 'User Routine' type + per-user preferences); when the engine cannot deliver (e.g. the
+     * type is not seeded in this instance), fall back to a raw `MJ: User Notifications` row
+     * — the same pattern used by TaskOrchestrator / shareNotification's default dispatch.
+     *
+     * @returns true when a notification record was actually created (a user who opted out
+     *          via preferences yields false WITHOUT triggering the raw fallback).
+     */
+    private deliverInApp;
+    /** Raw `MJ: User Notifications` insert — the minimal, always-available in-app path. */
+    private deliverInAppRaw;
+    /**
+     * TODO(email delivery): wire this through the Communication framework
+     * (`@memberjunction/communication-engine` — see NotificationEngine.sendEmail for the
+     * template + provider pattern). Email delivery needs a configured communication provider
+     * plus recipient-address resolution (UserID → user email, or the recipient row's Email),
+     * so it is deliberately left as a structured seam rather than half-implemented. In-app
+     * delivery is fully functional; this method only logs the gap.
+     */
+    private queueEmailDelivery;
+}
+//# sourceMappingURL=UserRoutineDispatcherDriver.d.ts.map

package/dist/drivers/UserRoutineDispatcherDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserRoutineDispatcherDriver.d.ts","sourceRoot":"","sources":["../../src/drivers/UserRoutineDispatcherDriver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EACH,gBAAgB,EAGhB,QAAQ,EAIX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAGH,oBAAoB,EACpB,mBAAmB,EAKtB,MAAM,+BAA+B,CAAC;AAQvC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAC3H,OAAO,EAAE,gBAAgB,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAYrF;;;GAGG;AACH,MAAM,WAAW,kCAAmC,SAAQ,yBAAyB;IACjF,0EAA0E;IAC1E,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAClC;AAmCD;;;;;;;;GAQG;AACH,qBACa,2BAA4B,SAAQ,gBAAgB;IAC7D;;;OAGG;IACH,IAAoB,uBAAuB,IAAI,OAAO,CAErD;IAEY,OAAO,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAmDjF,qBAAqB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,gBAAgB;IAgBvE,kBAAkB,CAAC,OAAO,EAAE,4BAA4B,EAAE,MAAM,EAAE,kBAAkB,GAAG,mBAAmB;IAwBjH,6GAA6G;IAC7G,OAAO,CAAC,4BAA4B;IAOpC;;;OAGG;YACW,qBAAqB;IAcnC,oFAAoF;YACtE,aAAa;IAc3B;;;;;;;;OAQG;YACW,YAAY;IAmB1B;;;;OAIG;YACW,cAAc;IA6C5B,2EAA2E;YAC7D,YAAY;IAkB1B,yFAAyF;YAC3E,cAAc;IAoB5B,6FAA6F;YAC/E,qBAAqB;IAUnC,0FAA0F;IAC1F,OAAO,CAAC,kBAAkB;IAW1B;;;OAGG;YACW,aAAa;IAkB3B;;;;;;;;;;OAUG;YACW,kBAAkB;IAsChC;;;;;;;;;;;;;OAaG;IACU,yBAAyB,CAAC,OAAO,EAAE,mBAAmB,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IA2C7G,6HAA6H;YAC/G,uBAAuB;IAUrC,6GAA6G;IAC7G,OAAO,CAAC,sBAAsB;IAY9B,2FAA2F;YAC7E,mBAAmB;IAyBjC,iGAAiG;YACnF,mBAAmB;IA6BjC,8FAA8F;IAC9F,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;;;;OASG;YACW,wBAAwB;IAsDtC,2FAA2F;YAC7E,cAAc;IAe5B;;;;OAIG;YACW,yBAAyB;IAqCvC,sGAAsG;IACtG,OAAO,CAAC,2BAA2B;IAWnC,wEAAwE;IACxE,OAAO,CAAC,qBAAqB;IAS7B;;;;;;;;OAQG;YACW,YAAY;IA6B1B,uFAAuF;YACzE,eAAe;IA4B7B;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;CAa7B"}