@friggframework/core 2.0.0--canary.549.a579cca.0 → 2.0.0--canary.549.6674256.0

package/assertions/jest.config.ts

@@ -0,0 +1,7 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+    preset: '@friggframework/test-environment',
+};
+
+export default config;

package/database/jest.config.ts

@@ -0,0 +1,7 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+    preset: '@friggframework/test-environment',
+};
+
+export default config;

package/database/models/WorkflowExecutionModel.ts

@@ -0,0 +1,315 @@
+const { mongoose } = require('../mongoose');
+
+const stepExecutionSchema = new mongoose.Schema({
+    stepId: {
+        type: String,
+        required: true
+    },
+    stepName: {
+        type: String,
+        required: true
+    },
+    status: {
+        type: String,
+        enum: ['RUNNING', 'COMPLETED', 'FAILED', 'RETRYING'],
+        required: true
+    },
+    startTime: {
+        type: Date,
+        required: true
+    },
+    endTime: Date,
+    result: mongoose.Schema.Types.Mixed,
+    error: {
+        message: String,
+        stack: String,
+        code: String,
+        timestamp: Date
+    },
+    retryCount: {
+        type: Number,
+        default: 0
+    },
+    duration: Number // Duration in milliseconds
+}, { _id: false });
+
+const fanOutStateSchema = new mongoose.Schema({
+    stepId: String,
+    stepName: String,
+    totalBatches: {
+        type: Number,
+        required: true
+    },
+    completedBatches: {
+        type: Number,
+        default: 0
+    },
+    batchResults: [mongoose.Schema.Types.Mixed],
+    aggregatedResult: mongoose.Schema.Types.Mixed,
+    status: {
+        type: String,
+        enum: ['RUNNING', 'COMPLETED', 'FAILED'],
+        default: 'RUNNING'
+    },
+    fanOutType: {
+        type: String,
+        enum: ['PAGINATION', 'DATA_PROCESSING'],
+        required: true
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now
+    },
+    completedAt: Date,
+    lastUpdated: {
+        type: Date,
+        default: Date.now
+    }
+}, { _id: false });
+
+const workflowExecutionSchema = new mongoose.Schema({
+    workflowId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'WorkflowModel',
+        required: true,
+        index: true
+    },
+    triggerType: {
+        type: String,
+        enum: ['MANUAL', 'WEBHOOK', 'SCHEDULE', 'EVENT'],
+        required: true,
+        index: true
+    },
+    status: {
+        type: String,
+        enum: ['RUNNING', 'COMPLETED', 'FAILED', 'PAUSED', 'CANCELLED'],
+        default: 'RUNNING',
+        index: true
+    },
+    startTime: {
+        type: Date,
+        required: true,
+        default: Date.now,
+        index: true
+    },
+    endTime: Date,
+    stepExecutions: [stepExecutionSchema],
+    context: {
+        triggerData: mongoose.Schema.Types.Mixed,
+        stepResults: mongoose.Schema.Types.Mixed,
+        variables: mongoose.Schema.Types.Mixed,
+        currentStep: String,
+        fanOutStates: {
+            type: Map,
+            of: fanOutStateSchema
+        }
+    },
+    metadata: {
+        totalSteps: {
+            type: Number,
+            default: 0
+        },
+        completedSteps: {
+            type: Number,
+            default: 0
+        },
+        failedSteps: {
+            type: Number,
+            default: 0
+        },
+        retryCount: {
+            type: Number,
+            default: 0
+        },
+        userId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'IndividualUser'
+        },
+        integrationId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Integration'
+        },
+        executionSource: String, // 'UI', 'API', 'WEBHOOK', etc.
+        parentExecutionId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'WorkflowExecutionModel'
+        }
+    },
+    lastUpdated: {
+        type: Date,
+        default: Date.now,
+        index: true
+    }
+}, {
+    timestamps: true
+});
+
+// Indexes for performance
+workflowExecutionSchema.index({ workflowId: 1, startTime: -1 });
+workflowExecutionSchema.index({ status: 1, lastUpdated: 1 });
+workflowExecutionSchema.index({ 'metadata.userId': 1, startTime: -1 });
+workflowExecutionSchema.index({ triggerType: 1, status: 1 });
+
+// TTL index to automatically delete old completed executions after 90 days
+workflowExecutionSchema.index(
+    { endTime: 1 }, 
+    { 
+        expireAfterSeconds: 90 * 24 * 60 * 60, // 90 days
+        partialFilterExpression: { 
+            status: { $in: ['COMPLETED', 'FAILED', 'CANCELLED'] } 
+        }
+    }
+);
+
+// Virtual properties
+workflowExecutionSchema.virtual('duration').get(function() {
+    if (!this.startTime) return 0;
+    const endTime = this.endTime || new Date();
+    return endTime.getTime() - this.startTime.getTime();
+});
+
+workflowExecutionSchema.virtual('progress').get(function() {
+    if (!this.metadata.totalSteps || this.metadata.totalSteps === 0) return 0;
+    return (this.metadata.completedSteps / this.metadata.totalSteps) * 100;
+});
+
+workflowExecutionSchema.virtual('isRunning').get(function() {
+    return this.status === 'RUNNING';
+});
+
+workflowExecutionSchema.virtual('isCompleted').get(function() {
+    return this.status === 'COMPLETED';
+});
+
+workflowExecutionSchema.virtual('isFailed').get(function() {
+    return this.status === 'FAILED';
+});
+
+// Pre-save middleware
+workflowExecutionSchema.pre('save', function(next) {
+    this.lastUpdated = new Date();
+    
+    // Calculate completed steps from stepExecutions
+    if (this.stepExecutions) {
+        this.metadata.completedSteps = this.stepExecutions.filter(
+            step => step.status === 'COMPLETED'
+        ).length;
+        this.metadata.failedSteps = this.stepExecutions.filter(
+            step => step.status === 'FAILED'
+        ).length;
+    }
+    
+    next();
+});
+
+// Pre-update middleware
+workflowExecutionSchema.pre(['updateOne', 'findOneAndUpdate'], function(next) {
+    this.set({ lastUpdated: new Date() });
+    next();
+});
+
+// Instance methods
+workflowExecutionSchema.methods.addStepExecution = function(stepExecution) {
+    // Calculate duration if not provided
+    if (stepExecution.startTime && stepExecution.endTime && !stepExecution.duration) {
+        stepExecution.duration = stepExecution.endTime.getTime() - stepExecution.startTime.getTime();
+    }
+    
+    this.stepExecutions.push(stepExecution);
+    this.lastUpdated = new Date();
+    
+    // Update context with step result if provided
+    if (stepExecution.result && stepExecution.stepName) {
+        if (!this.context.stepResults) {
+            this.context.stepResults = {};
+        }
+        this.context.stepResults[stepExecution.stepName] = stepExecution.result;
+    }
+    
+    this.context.currentStep = stepExecution.stepId;
+};
+
+workflowExecutionSchema.methods.updateStatus = function(newStatus, endTime = null) {
+    this.status = newStatus;
+    this.lastUpdated = new Date();
+    
+    if (endTime) {
+        this.endTime = endTime;
+    } else if (newStatus === 'COMPLETED' || newStatus === 'FAILED' || newStatus === 'CANCELLED') {
+        this.endTime = new Date();
+    }
+};
+
+workflowExecutionSchema.methods.getLastCompletedStep = function() {
+    const completedSteps = this.stepExecutions.filter(step => step.status === 'COMPLETED');
+    return completedSteps.length > 0 ? completedSteps[completedSteps.length - 1] : null;
+};
+
+workflowExecutionSchema.methods.getSummary = function() {
+    return {
+        id: this._id,
+        workflowId: this.workflowId,
+        triggerType: this.triggerType,
+        status: this.status,
+        startTime: this.startTime,
+        endTime: this.endTime,
+        duration: this.duration,
+        progress: this.progress,
+        stepCount: this.stepExecutions.length,
+        completedSteps: this.metadata.completedSteps,
+        failedSteps: this.metadata.failedSteps,
+        currentStep: this.context.currentStep,
+        fanOutSteps: this.context.fanOutStates ? Array.from(this.context.fanOutStates.keys()) : []
+    };
+};
+
+// Static methods
+workflowExecutionSchema.statics.findByWorkflow = function(workflowId, options = {}) {
+    const query = this.find({ workflowId });
+    
+    if (options.limit) query.limit(options.limit);
+    if (options.sort) query.sort(options.sort);
+    else query.sort({ startTime: -1 });
+    
+    return query;
+};
+
+workflowExecutionSchema.statics.findRunning = function(filters = {}) {
+    return this.find({ status: 'RUNNING', ...filters });
+};
+
+workflowExecutionSchema.statics.findStalled = function(minutesStalled = 30) {
+    const stalledTime = new Date(Date.now() - minutesStalled * 60 * 1000);
+    return this.find({
+        status: 'RUNNING',
+        lastUpdated: { $lt: stalledTime }
+    });
+};
+
+workflowExecutionSchema.statics.getStatistics = function(filters = {}) {
+    return this.aggregate([
+        { $match: filters },
+        {
+            $group: {
+                _id: '$status',
+                count: { $sum: 1 },
+                avgDuration: { 
+                    $avg: { 
+                        $cond: [
+                            { $and: ['$startTime', '$endTime'] },
+                            { $subtract: ['$endTime', '$startTime'] },
+                            null
+                        ]
+                    }
+                },
+                avgCompletedSteps: { $avg: '$metadata.completedSteps' }
+            }
+        },
+        { $sort: { _id: 1 } }
+    ]);
+};
+
+const WorkflowExecutionModel = mongoose.models.WorkflowExecutionModel || 
+    mongoose.model('WorkflowExecutionModel', workflowExecutionSchema);
+
+module.exports = { WorkflowExecutionModel };

package/database/models/WorkflowModel.ts

@@ -0,0 +1,129 @@
+const { mongoose } = require('../mongoose');
+
+const workflowSchema = new mongoose.Schema({
+    name: { 
+        type: String, 
+        required: true,
+        trim: true,
+        maxlength: 200
+    },
+    description: { 
+        type: String,
+        trim: true,
+        maxlength: 1000
+    },
+    integrationId: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        ref: 'Integration', 
+        required: true,
+        index: true
+    },
+    userId: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        ref: 'IndividualUser', 
+        required: true,
+        index: true
+    },
+    status: { 
+        type: String, 
+        enum: ['ACTIVE', 'PAUSED', 'ERROR', 'DISABLED'],
+        default: 'ACTIVE',
+        index: true
+    },
+    definition: {
+        steps: [{ 
+            type: mongoose.Schema.Types.Mixed,
+            required: true
+        }],
+        triggers: [{ 
+            type: mongoose.Schema.Types.Mixed,
+            required: true
+        }]
+    },
+    metadata: {
+        createdAt: { 
+            type: Date, 
+            default: Date.now,
+            index: true
+        },
+        updatedAt: { 
+            type: Date, 
+            default: Date.now
+        },
+        version: { 
+            type: String, 
+            default: '1.0.0'
+        },
+        tags: [String],
+        category: String,
+        lastExecutedAt: Date,
+        executionCount: {
+            type: Number,
+            default: 0
+        }
+    }
+}, {
+    timestamps: true // Adds createdAt and updatedAt automatically
+});
+
+// Indexes for better query performance
+workflowSchema.index({ integrationId: 1, userId: 1 });
+workflowSchema.index({ status: 1, 'metadata.createdAt': -1 });
+workflowSchema.index({ userId: 1, status: 1 });
+
+// Virtual for workflow summary
+workflowSchema.virtual('stepCount').get(function() {
+    return this.definition && this.definition.steps ? this.definition.steps.length : 0;
+});
+
+workflowSchema.virtual('triggerCount').get(function() {
+    return this.definition && this.definition.triggers ? this.definition.triggers.length : 0;
+});
+
+// Pre-save middleware to update metadata.updatedAt
+workflowSchema.pre('save', function(next) {
+    this.metadata.updatedAt = new Date();
+    next();
+});
+
+// Pre-update middleware to update metadata.updatedAt
+workflowSchema.pre(['updateOne', 'findOneAndUpdate'], function(next) {
+    this.set({ 'metadata.updatedAt': new Date() });
+    next();
+});
+
+// Instance methods
+workflowSchema.methods.isExecutable = function() {
+    return this.status === 'ACTIVE' && 
+           this.definition && 
+           this.definition.steps && 
+           this.definition.steps.length > 0;
+};
+
+workflowSchema.methods.getSummary = function() {
+    return {
+        id: this._id,
+        name: this.name,
+        description: this.description,
+        status: this.status,
+        stepCount: this.stepCount,
+        triggerCount: this.triggerCount,
+        createdAt: this.metadata.createdAt,
+        updatedAt: this.metadata.updatedAt,
+        version: this.metadata.version,
+        executionCount: this.metadata.executionCount
+    };
+};
+
+// Static methods
+workflowSchema.statics.findByIntegrationAndUser = function(integrationId, userId) {
+    return this.find({ integrationId, userId });
+};
+
+workflowSchema.statics.findActiveWorkflows = function(filters = {}) {
+    return this.find({ status: 'ACTIVE', ...filters });
+};
+
+const WorkflowModel = mongoose.models.WorkflowModel || mongoose.model('WorkflowModel', workflowSchema);
+
+module.exports = { WorkflowModel };

package/jest-global-setup-noop.ts

@@ -0,0 +1,3 @@
+export default async function noopGlobalSetup(): Promise<void> {
+    // No global setup required for unit tests.
+}

package/jest-global-teardown-noop.ts

@@ -0,0 +1,3 @@
+export default async function noopGlobalTeardown(): Promise<void> {
+    // No global teardown required for unit tests.
+}

package/jest-resolver.ts

@@ -0,0 +1,36 @@
+const path = require('path');
+
+interface ResolverOptions {
+    defaultResolver: (request: string, options: ResolverOptions) => string;
+    rootDir?: string;
+    basedir: string;
+}
+
+module.exports = (request: string, options: ResolverOptions): string => {
+    const { defaultResolver } = options;
+    try {
+        return defaultResolver(request, options);
+    } catch (error: unknown) {
+        if (
+            error instanceof Error &&
+            'code' in error &&
+            (error as NodeJS.ErrnoException).code === 'MODULE_NOT_FOUND' &&
+            !request.startsWith('@') &&
+            !path.isAbsolute(request)
+        ) {
+            const rootDir = options.rootDir || path.resolve(__dirname);
+            const resolved = path.resolve(options.basedir, request);
+            const relative = path.relative(rootDir, resolved);
+
+            if (relative && !relative.startsWith('..') && !relative.startsWith('node_modules')) {
+                const distPath = path.join(rootDir, 'dist', relative);
+                try {
+                    return defaultResolver(distPath, { ...options, basedir: rootDir });
+                } catch {
+                    // fall through to original error
+                }
+            }
+        }
+        throw error;
+    }
+};

package/jest-setup.ts

@@ -0,0 +1,2 @@
+import { globalSetup } from '@friggframework/test';
+export default globalSetup;

package/jest-teardown.ts

@@ -0,0 +1,2 @@
+import { globalTeardown } from '@friggframework/test';
+export default globalTeardown;

package/jest.config.ts

@@ -0,0 +1,20 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+    resolver: './jest-resolver.ts',
+    transform: {
+        '^.+\\.tsx?$': ['ts-jest', { tsconfig: 'tsconfig.test.json', diagnostics: false }],
+    },
+    coverageThreshold: {
+        global: {
+            statements: 13,
+            branches: 0,
+            functions: 1,
+            lines: 13,
+        },
+    },
+    globalSetup: './jest-setup.ts',
+    globalTeardown: './jest-teardown.ts',
+};
+
+export default config;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.549.a579cca.0",
+    "version": "2.0.0--canary.549.6674256.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -40,14 +40,16 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.549.a579cca.0",
-        "@friggframework/prettier-config": "2.0.0--canary.549.a579cca.0",
-        "@friggframework/test": "2.0.0--canary.549.a579cca.0",
+        "@friggframework/eslint-config": "2.0.0--canary.549.6674256.0",
+        "@friggframework/prettier-config": "2.0.0--canary.549.6674256.0",
+        "@friggframework/test": "2.0.0--canary.549.6674256.0",
         "@prisma/client": "^6.17.0",
         "@types/common-tags": "^1.8.4",
         "@types/express": "^4.17.21",
+        "@types/jest": "^30.0.0",
         "@types/lodash": "4.17.15",
         "@types/node": "^22.0.0",
+        "@types/sinon": "^17.0.4",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
         "chai": "^4.3.6",
         "eslint": "^8.22.0",
@@ -58,6 +60,7 @@
         "prettier": "^2.7.1",
         "prisma": "^6.17.0",
         "sinon": "^16.1.1",
+        "ts-jest": "^29.4.6",
         "typescript": "^5.0.2"
     },
     "scripts": {
@@ -99,5 +102,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "a579cca5c61e1dc8187b05268a64c1c2453ca664"
+    "gitHead": "66742560debce86ce48a82f311234c655ac9553f"
 }