@friggframework/core 2.0.0--canary.686.df38e8e.0 → 2.0.0--canary.710.9045bbc.0

package/extensions/route-mounter.js

@@ -1,103 +0,0 @@
-/**
- * Route Mounter
- *
- * Mounts extension-defined Express routers onto the main app.
- * Each extension can declare routes with a base path and a handler factory.
- *
- * The handler factory receives (prisma, appDefinition) and returns an Express Router.
- * Routes are protected by the admin auth middleware by default.
- *
- * @example
- * mountExtensionRoutes(app, extensions, { prisma, appDefinition });
- */
-
-const { validateAdminApiKey } = require('../handlers/middleware/admin-auth');
-
-/**
- * Mounts all extension routes onto an Express app.
- *
- * @param {import('express').Express} app - Express app or router to mount on
- * @param {Array<Object>} extensions - Normalized extensions (from extension-loader)
- * @param {Object} context
- * @param {Object} context.prisma - Prisma client instance
- * @param {Object} context.appDefinition - Full app definition
- * @param {Function} [context.authMiddleware] - Override admin auth middleware
- */
-function mountExtensionRoutes(app, extensions, context = {}) {
-    if (!extensions || extensions.length === 0) return;
-
-    const { prisma, appDefinition, authMiddleware } = context;
-    const adminAuth = authMiddleware || validateAdminApiKey;
-
-    for (const ext of extensions) {
-        if (!ext.routes) continue;
-
-        const { path: basePath, handler } = ext.routes;
-
-        let router;
-        if (typeof handler === 'function') {
-            // Handler factory: (prisma, appDefinition) => Router
-            router = handler(prisma, appDefinition);
-        } else if (handler && handler.router) {
-            // Direct router object export pattern: { router }
-            router = handler.router;
-        } else if (handler && handler.default && typeof handler.default === 'function') {
-            // ES module default export
-            router = handler.default(prisma, appDefinition);
-        } else {
-            console.warn(
-                `Extension "${ext.name}": routes.handler is not a function or router object, skipping`
-            );
-            continue;
-        }
-
-        // Mount with admin auth middleware
-        app.use(basePath, adminAuth, router);
-    }
-}
-
-module.exports = { mountExtensionRoutes };
-
-/**
- * Builds one router serving every app-level extension's routes
- * (`appDefinition.coreExtensions[].routes`), each behind the admin API key.
- *
- * Lazy by design: the extensions, their route factories and the Prisma
- * client are only touched on the first request, so requiring a handler
- * module never connects anything.
- *
- * @param {Object} [params]
- * @param {Object} [params.appDefinition] - raw app Definition; defaults to
- *   loadAppDefinition().appDefinition on first request.
- * @param {Object} [params.prisma] - defaults to core's Prisma client.
- * @returns {import('express').Router}
- */
-function createExtensionRoutesRouter({ appDefinition, prisma } = {}) {
-    const express = require('express');
-    const outer = express.Router();
-    let inner = null;
-
-    outer.use((req, res, next) => {
-        if (!inner) {
-            const definition =
-                appDefinition ||
-                require('../handlers/app-definition-loader').loadAppDefinition()
-                    .appDefinition;
-            const { loadExtensions } = require('./extension-loader');
-            const extensions = loadExtensions(definition);
-            const built = express.Router();
-            if (extensions.some((ext) => ext.routes)) {
-                mountExtensionRoutes(built, extensions, {
-                    prisma: prisma || require('../database/prisma').prisma,
-                    appDefinition: definition,
-                });
-            }
-            inner = built;
-        }
-        return inner(req, res, next);
-    });
-
-    return outer;
-}
-
-module.exports.createExtensionRoutesRouter = createExtensionRoutesRouter;

package/extensions/schema-composer.js

@@ -1,188 +0,0 @@
-/**
- * Schema Composer
- *
- * Merges extension .prisma schema fragments with a base Prisma schema.
- * Extensions can add new models/enums that get composed into the final schema
- * used for `prisma generate` and migrations.
- *
- * Two approaches are supported:
- * 1. Build-time merge: Concatenate model definitions from extension files
- *    into the base schema and write a merged output file.
- * 2. Multi-file schema (Prisma 5.15+): Return a list of schema paths for
- *    Prisma's native `prismaSchemaFolder` feature.
- *
- * @example
- * const { composeSchemas } = require('@friggframework/core/extensions/schema-composer');
- *
- * // Build-time merge — writes a merged schema file
- * await composeSchemas({
- *   baseSchemaPath: '/path/to/prisma-postgresql/schema.prisma',
- *   extensionSchemaPaths: ['/path/to/extensions/db-credentials/schema.prisma'],
- *   outputPath: '/path/to/prisma-postgresql/schema.composed.prisma',
- * });
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Extracts model/enum blocks from a .prisma file, stripping out
- * generator and datasource blocks (which should only appear in the base schema).
- *
- * @param {string} schemaContent - Raw .prisma file content
- * @returns {string} Only model/enum/type definitions
- */
-function extractModelBlocks(schemaContent) {
-    const lines = schemaContent.split('\n');
-    const result = [];
-    let depth = 0;
-    let inBlock = false;
-    let blockType = null;
-
-    for (const line of lines) {
-        const trimmed = line.trim();
-
-        // Detect block start
-        if (depth === 0 && !inBlock) {
-            const blockMatch = trimmed.match(
-                /^(model|enum|type)\s+\w+\s*\{/
-            );
-            if (blockMatch) {
-                inBlock = true;
-                blockType = blockMatch[1];
-                result.push(line);
-                depth += (line.match(/\{/g) || []).length;
-                depth -= (line.match(/\}/g) || []).length;
-                continue;
-            }
-
-            // Skip generator/datasource blocks
-            const skipMatch = trimmed.match(
-                /^(generator|datasource)\s+\w+\s*\{/
-            );
-            if (skipMatch) {
-                inBlock = true;
-                blockType = 'skip';
-                depth += (line.match(/\{/g) || []).length;
-                depth -= (line.match(/\}/g) || []).length;
-                continue;
-            }
-
-            // Keep standalone comments between blocks
-            if (trimmed.startsWith('//') || trimmed === '') {
-                // Only keep if we've already accumulated some model blocks
-                if (result.length > 0) {
-                    result.push(line);
-                }
-                continue;
-            }
-        } else if (inBlock) {
-            depth += (line.match(/\{/g) || []).length;
-            depth -= (line.match(/\}/g) || []).length;
-
-            if (blockType !== 'skip') {
-                result.push(line);
-            }
-
-            if (depth <= 0) {
-                inBlock = false;
-                blockType = null;
-                depth = 0;
-                if (result.length > 0) {
-                    result.push(''); // blank line between blocks
-                }
-            }
-        }
-    }
-
-    return result.join('\n').trim();
-}
-
-/**
- * Composes a merged Prisma schema from a base schema + extension fragments.
- *
- * @param {Object} options
- * @param {string} options.baseSchemaPath - Absolute path to the core .prisma file
- * @param {string[]} options.extensionSchemaPaths - Absolute paths to extension .prisma files
- * @param {string} [options.outputPath] - Where to write the merged schema.
- *   Defaults to `<baseDir>/schema.composed.prisma`
- * @returns {string} The merged schema content
- */
-function composeSchemas({ baseSchemaPath, extensionSchemaPaths, outputPath }) {
-    if (!baseSchemaPath) {
-        throw new Error('baseSchemaPath is required');
-    }
-
-    if (
-        !extensionSchemaPaths ||
-        !Array.isArray(extensionSchemaPaths) ||
-        extensionSchemaPaths.length === 0
-    ) {
-        // No extensions — just return base schema as-is
-        const baseContent = fs.readFileSync(baseSchemaPath, 'utf-8');
-        return baseContent;
-    }
-
-    const baseContent = fs.readFileSync(baseSchemaPath, 'utf-8');
-
-    // Collect model blocks from each extension
-    const extensionBlocks = [];
-    for (const extPath of extensionSchemaPaths) {
-        if (!fs.existsSync(extPath)) {
-            throw new Error(
-                `Extension schema not found: ${extPath}`
-            );
-        }
-        const extContent = fs.readFileSync(extPath, 'utf-8');
-        const models = extractModelBlocks(extContent);
-        if (models) {
-            extensionBlocks.push(
-                `// --- Extension schema from: ${path.basename(path.dirname(extPath))}/${path.basename(extPath)} ---`,
-                models
-            );
-        }
-    }
-
-    if (extensionBlocks.length === 0) {
-        return baseContent;
-    }
-
-    // Append extension models to the base schema
-    const merged = [
-        baseContent.trimEnd(),
-        '',
-        '// =========================================================================',
-        '// Extension Models (auto-composed — do not edit manually)',
-        '// =========================================================================',
-        '',
-        ...extensionBlocks,
-        '',
-    ].join('\n');
-
-    // Write the merged schema if outputPath is specified
-    const resolvedOutput =
-        outputPath ||
-        path.join(path.dirname(baseSchemaPath), 'schema.composed.prisma');
-
-    fs.writeFileSync(resolvedOutput, merged, 'utf-8');
-
-    return merged;
-}
-
-/**
- * Returns schema paths suitable for Prisma's native multi-file schema support
- * (prismaSchemaFolder feature, Prisma 5.15+).
- *
- * @param {string} baseSchemaPath - Path to the core schema
- * @param {string[]} extensionSchemaPaths - Paths to extension schemas
- * @returns {string[]} All schema file paths
- */
-function getSchemaFilePaths(baseSchemaPath, extensionSchemaPaths) {
-    return [baseSchemaPath, ...(extensionSchemaPaths || [])];
-}
-
-module.exports = {
-    composeSchemas,
-    extractModelBlocks,
-    getSchemaFilePaths,
-};

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

@@ -1,220 +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');
-const {
-    isBackgroundFunctionPath,
-} = require('../../queues/providers/netlify-background-provider');
-
-// 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 background function path ('/.netlify/functions/<name>-background')
-     * is kept; any other value, including '//host/x' or a path with '..',
-     * maps to the worker too, so a stored job can only ever reach a
-     * background function on this site.
-     *
-     * @param {string} [queueUrl]
-     * @returns {string} a path NetlifyBackgroundProvider.send() accepts
-     */
-    toQueueResourceId(queueUrl) {
-        return isBackgroundFunctionPath(queueUrl) ? 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 };