@forzalabs/remora 1.0.21 → 1.1.1

package/engines/scheduler/CronScheduler.js

@@ -1,222 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const cron = __importStar(require("node-cron"));
-const Environment_1 = __importDefault(require("../Environment"));
-const ExecutorOrchestrator_1 = __importDefault(require("../../executors/ExecutorOrchestrator"));
-const settings_1 = require("../../settings");
-class CronScheduler {
-    constructor() {
-        this.scheduledJobs = new Map();
-        this.isInitialized = false;
-    }
-    /**
-     * Initialize the CRON scheduler by scanning all consumers and scheduling those with CRON triggers
-     */
-    initialize() {
-        if (this.isInitialized) {
-            console.log('CRON scheduler already initialized');
-            return;
-        }
-        console.log('Initializing CRON scheduler...');
-        try {
-            const consumers = Environment_1.default.getAllConsumers();
-            let cronJobCount = 0;
-            for (const consumer of consumers) {
-                if (this.hasCronTrigger(consumer)) {
-                    this.scheduleConsumer(consumer);
-                    cronJobCount++;
-                }
-            }
-            this.isInitialized = true;
-            console.log(`CRON scheduler initialized with ${cronJobCount} scheduled jobs`);
-        }
-        catch (error) {
-            console.error('Failed to initialize CRON scheduler:', error);
-            throw error;
-        }
-    }
-    /**
-     * Check if a consumer has any CRON triggers configured
-     */
-    hasCronTrigger(consumer) {
-        return consumer.outputs.some(output => { var _a; return ((_a = output.trigger) === null || _a === void 0 ? void 0 : _a.type) === 'CRON' && output.trigger.value; });
-    }
-    /**
-     * Schedule a consumer with CRON triggers
-     */
-    scheduleConsumer(consumer) {
-        consumer.outputs.forEach((output, index) => {
-            var _a;
-            if (((_a = output.trigger) === null || _a === void 0 ? void 0 : _a.type) === 'CRON' && output.trigger.value) {
-                const jobKey = `${consumer.name}_output_${index}`;
-                const cronExpression = output.trigger.value;
-                try {
-                    // Validate CRON expression
-                    if (!cron.validate(cronExpression)) {
-                        console.error(`Invalid CRON expression for consumer ${consumer.name}: ${cronExpression}`);
-                        return;
-                    }
-                    // Schedule the job
-                    const task = cron.schedule(cronExpression, () => __awaiter(this, void 0, void 0, function* () {
-                        yield this.executeConsumerOutput(consumer, output, index);
-                    }));
-                    // Don't start the task immediately, we'll start it manually
-                    task.stop();
-                    this.scheduledJobs.set(jobKey, task);
-                    task.start();
-                    console.log(`Scheduled CRON job for consumer "${consumer.name}" output ${index} with expression: ${cronExpression}`);
-                }
-                catch (error) {
-                    console.error(`Failed to schedule CRON job for consumer ${consumer.name}:`, error);
-                }
-            }
-        });
-    }
-    /**
-     * Execute a consumer output when triggered by CRON
-     */
-    executeConsumerOutput(consumer, output, outputIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                console.log(`Executing CRON job for consumer "${consumer.name}" output ${outputIndex}`);
-                const user = settings_1.REMORA_WORKER_USER;
-                const runner = { _id: user._id, name: user.name, type: 'actor' };
-                const result = yield ExecutorOrchestrator_1.default.launch({
-                    consumer,
-                    details: {
-                        invokedBy: 'CRON',
-                        user: runner
-                    },
-                    logProgress: false
-                });
-                console.log(`CRON job completed successfully for consumer "${consumer.name}" output ${outputIndex}`);
-                // Log execution statistics
-                if (result) {
-                    console.log(`CRON job stats: ${result.elapsedMS}ms, size: ${result.outputCount}, cycles: ${result.cycles}`);
-                }
-            }
-            catch (error) {
-                console.error(`CRON job failed for consumer "${consumer.name}" output ${outputIndex}:`, error);
-                // Optionally, you could implement error handling strategies here:
-                // - Send notifications
-                // - Log to a monitoring system
-                // - Retry logic
-                // - Disable the job after repeated failures
-            }
-        });
-    }
-    /**
-     * Add or update a CRON job for a specific consumer
-     */
-    updateConsumerSchedule(consumer) {
-        // First, remove any existing schedules for this consumer
-        this.removeConsumerSchedule(consumer.name);
-        // Then, add new schedules if they have CRON triggers
-        if (this.hasCronTrigger(consumer)) {
-            this.scheduleConsumer(consumer);
-        }
-    }
-    /**
-     * Remove all scheduled jobs for a consumer
-     */
-    removeConsumerSchedule(consumerName) {
-        const jobsToRemove = Array.from(this.scheduledJobs.keys()).filter(key => key.startsWith(`${consumerName}_output_`));
-        jobsToRemove.forEach(jobKey => {
-            const task = this.scheduledJobs.get(jobKey);
-            if (task) {
-                task.stop();
-                task.destroy();
-                this.scheduledJobs.delete(jobKey);
-                console.log(`Removed CRON job: ${jobKey}`);
-            }
-        });
-    }
-    /**
-     * Get information about all scheduled jobs
-     */
-    getScheduledJobs() {
-        return Array.from(this.scheduledJobs.entries()).map(([jobKey, task]) => ({
-            jobKey,
-            isRunning: task.getStatus() === 'scheduled'
-        }));
-    }
-    /**
-     * Stop all scheduled jobs
-     */
-    stopAllJobs() {
-        console.log('Stopping all CRON jobs...');
-        this.scheduledJobs.forEach((task, jobKey) => {
-            task.stop();
-            task.destroy();
-            console.log(`Stopped CRON job: ${jobKey}`);
-        });
-        this.scheduledJobs.clear();
-        this.isInitialized = false;
-        console.log('All CRON jobs stopped');
-    }
-    /**
-     * Restart the scheduler (useful for configuration reloads)
-     */
-    restart() {
-        console.log('Restarting CRON scheduler...');
-        this.stopAllJobs();
-        this.initialize();
-    }
-    /**
-     * Get the scheduler status
-     */
-    getStatus() {
-        return {
-            initialized: this.isInitialized,
-            jobCount: this.scheduledJobs.size,
-            jobs: this.getScheduledJobs()
-        };
-    }
-}
-// Export a singleton instance
-exports.default = new CronScheduler();

package/engines/scheduler/QueueManager.js

@@ -1,314 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const client_sqs_1 = require("@aws-sdk/client-sqs");
-const Environment_1 = __importDefault(require("../Environment"));
-const ProcessENVManager_1 = __importDefault(require("../ProcessENVManager"));
-const SecretManager_1 = __importDefault(require("../SecretManager"));
-const ExecutorOrchestrator_1 = __importDefault(require("../../executors/ExecutorOrchestrator"));
-const settings_1 = require("../../settings");
-class QueueManager {
-    constructor() {
-        this.queueMappings = new Map();
-        this.pollingIntervals = new Map();
-        this.isInitialized = false;
-        this.POLLING_INTERVAL_MS = 5000; // Poll every 5 seconds
-        this.MAX_MESSAGES = 10; // Maximum messages to receive in one poll
-        // Initialize SQS client with default configuration
-        // Will be reconfigured when we know the specific queue details
-        this.sqsClient = new client_sqs_1.SQSClient({});
-    }
-    /**
-     * Initialize the Queue Manager by scanning all consumers and setting up queue listeners for those with QUEUE triggers
-     */
-    initialize() {
-        if (this.isInitialized) {
-            console.log('Queue Manager already initialized');
-            return;
-        }
-        console.log('Initializing Queue Manager...');
-        try {
-            const consumers = Environment_1.default.getAllConsumers();
-            let queueTriggerCount = 0;
-            for (const consumer of consumers) {
-                if (this.hasQueueTrigger(consumer)) {
-                    this.setupQueueListeners(consumer);
-                    queueTriggerCount++;
-                }
-            }
-            this.isInitialized = true;
-            console.log(`Queue Manager initialized with ${queueTriggerCount} queue triggers`);
-        }
-        catch (error) {
-            console.error('Failed to initialize Queue Manager:', error);
-            throw error;
-        }
-    }
-    /**
-     * Check if a consumer has any QUEUE triggers configured
-     */
-    hasQueueTrigger(consumer) {
-        return consumer.outputs.some(output => { var _a; return ((_a = output.trigger) === null || _a === void 0 ? void 0 : _a.type) === 'QUEUE' && output.trigger.value; });
-    }
-    /**
-     * Setup queue listeners for a consumer with QUEUE triggers
-     */
-    setupQueueListeners(consumer) {
-        consumer.outputs.forEach((output, index) => {
-            var _a;
-            if (((_a = output.trigger) === null || _a === void 0 ? void 0 : _a.type) === 'QUEUE' && output.trigger.value) {
-                try {
-                    const queueConfig = this.parseQueueConfig(output.trigger.value, output.trigger.metadata);
-                    const mapping = {
-                        consumer,
-                        outputIndex: index,
-                        queueUrl: queueConfig.queueUrl,
-                        messageType: queueConfig.messageType
-                    };
-                    // Add to mappings
-                    if (!this.queueMappings.has(queueConfig.queueUrl)) {
-                        this.queueMappings.set(queueConfig.queueUrl, []);
-                    }
-                    this.queueMappings.get(queueConfig.queueUrl).push(mapping);
-                    // Start polling for this queue if not already started
-                    if (!this.pollingIntervals.has(queueConfig.queueUrl)) {
-                        this.startQueuePolling(queueConfig.queueUrl, queueConfig.region, queueConfig.credentials);
-                    }
-                    console.log(`Setup queue listener for consumer "${consumer.name}" output ${index} on queue: ${queueConfig.queueUrl}`);
-                }
-                catch (error) {
-                    console.error(`Failed to setup queue listener for consumer ${consumer.name}:`, error);
-                }
-            }
-        });
-    }
-    /**
-     * Parse queue configuration from trigger value and metadata
-     */
-    parseQueueConfig(triggerValue, metadata) {
-        // triggerValue should be the queue URL or queue name
-        let queueUrl = triggerValue;
-        // If it's not a full URL, construct it
-        if (!queueUrl.startsWith('https://')) {
-            const region = (metadata === null || metadata === void 0 ? void 0 : metadata.region) || ProcessENVManager_1.default.getEnvVariable('AWS_DEFAULT_REGION') || 'us-east-1';
-            const accountId = (metadata === null || metadata === void 0 ? void 0 : metadata.accountId) || ProcessENVManager_1.default.getEnvVariable('AWS_ACCOUNT_ID');
-            if (!accountId) {
-                throw new Error('AWS Account ID is required for queue trigger. Set it in metadata.accountId or AWS_ACCOUNT_ID environment variable');
-            }
-            queueUrl = `https://sqs.${region}.amazonaws.com/${accountId}/${triggerValue}`;
-        }
-        // Extract region from URL if not provided in metadata
-        const urlParts = queueUrl.match(/https:\/\/sqs\.([^.]+)\.amazonaws\.com\//);
-        const region = (metadata === null || metadata === void 0 ? void 0 : metadata.region) || (urlParts === null || urlParts === void 0 ? void 0 : urlParts[1]) || 'us-east-1';
-        // Get credentials from metadata or environment
-        let credentials;
-        const accessKeyId = (metadata === null || metadata === void 0 ? void 0 : metadata.accessKeyId) || ProcessENVManager_1.default.getEnvVariable('AWS_ACCESS_KEY_ID');
-        const secretAccessKey = (metadata === null || metadata === void 0 ? void 0 : metadata.secretAccessKey) || ProcessENVManager_1.default.getEnvVariable('AWS_SECRET_ACCESS_KEY');
-        const sessionToken = (metadata === null || metadata === void 0 ? void 0 : metadata.sessionToken) || ProcessENVManager_1.default.getEnvVariable('AWS_SESSION_TOKEN');
-        if (accessKeyId && secretAccessKey) {
-            credentials = {
-                accessKeyId: SecretManager_1.default.replaceSecret(accessKeyId),
-                secretAccessKey: SecretManager_1.default.replaceSecret(secretAccessKey),
-                sessionToken: sessionToken ? SecretManager_1.default.replaceSecret(sessionToken) : undefined
-            };
-        }
-        return {
-            queueUrl,
-            messageType: metadata === null || metadata === void 0 ? void 0 : metadata.messageType,
-            region,
-            credentials
-        };
-    }
-    /**
-     * Start polling a specific queue for messages
-     */
-    startQueuePolling(queueUrl, region, credentials) {
-        // Create SQS client for this specific queue
-        const sqsClient = new client_sqs_1.SQSClient({
-            region,
-            credentials
-        });
-        const pollQueue = () => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const command = new client_sqs_1.ReceiveMessageCommand({
-                    QueueUrl: queueUrl,
-                    MaxNumberOfMessages: this.MAX_MESSAGES,
-                    WaitTimeSeconds: 20, // Long polling
-                    VisibilityTimeout: 300 // 5 minutes to process the message
-                });
-                const response = yield sqsClient.send(command);
-                if (response.Messages && response.Messages.length > 0) {
-                    console.log(`Received ${response.Messages.length} messages from queue: ${queueUrl}`);
-                    for (const message of response.Messages) {
-                        yield this.processMessage(queueUrl, message, sqsClient);
-                    }
-                }
-            }
-            catch (error) {
-                console.error(`Error polling queue ${queueUrl}:`, error);
-            }
-        });
-        // Start continuous polling
-        const interval = setInterval(pollQueue, this.POLLING_INTERVAL_MS);
-        this.pollingIntervals.set(queueUrl, interval);
-        // Start immediately
-        pollQueue();
-        console.log(`Started polling queue: ${queueUrl}`);
-    }
-    /**
-     * Process a message from the queue
-     */
-    processMessage(queueUrl, message, sqsClient) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const mappings = this.queueMappings.get(queueUrl);
-                if (!mappings || mappings.length === 0) {
-                    console.log(`No consumer mappings found for queue: ${queueUrl}`);
-                    return;
-                }
-                // Parse message body
-                let messageData;
-                try {
-                    messageData = JSON.parse(message.Body || '{}');
-                }
-                catch (_a) {
-                    console.warn(`Failed to parse message body as JSON for queue ${queueUrl}. Using raw body.`);
-                    messageData = { body: message.Body };
-                }
-                let messageProcessedByAnyConsumer = false;
-                // Process message for each mapped consumer that matches the message criteria
-                for (const mapping of mappings) {
-                    try {
-                        // Check if message type matches (if specified)
-                        if (mapping.messageType) {
-                            const messageType = messageData.type || messageData.messageType || messageData.eventType;
-                            if (messageType !== mapping.messageType) {
-                                console.log(`Message type ${messageType} does not match expected ${mapping.messageType} for consumer ${mapping.consumer.name} - skipping`);
-                                continue;
-                            }
-                        }
-                        console.log(`Processing queue message for consumer "${mapping.consumer.name}" output ${mapping.outputIndex}`);
-                        const user = settings_1.REMORA_WORKER_USER;
-                        const result = yield ExecutorOrchestrator_1.default.launch({
-                            consumer: mapping.consumer,
-                            details: {
-                                invokedBy: 'QUEUE',
-                                user: { _id: user._id, name: user.name, type: 'actor' }
-                            },
-                            logProgress: false
-                        });
-                        console.log(`Queue trigger completed successfully for consumer "${mapping.consumer.name}" output ${mapping.outputIndex}`);
-                        // Log execution statistics
-                        if (result) {
-                            console.log(`Queue trigger stats: ${result.elapsedMS}ms, size: ${result.outputCount}, cycles: ${result.cycles}`);
-                        }
-                        messageProcessedByAnyConsumer = true;
-                    }
-                    catch (error) {
-                        console.error(`Queue trigger failed for consumer "${mapping.consumer.name}" output ${mapping.outputIndex}:`, error);
-                        // Continue processing for other consumers even if one fails
-                    }
-                }
-                // Only delete message from queue if it was processed by at least one consumer
-                // This ensures messages intended for other consumers or systems remain in the queue
-                if (messageProcessedByAnyConsumer && message.ReceiptHandle) {
-                    yield sqsClient.send(new client_sqs_1.DeleteMessageCommand({
-                        QueueUrl: queueUrl,
-                        ReceiptHandle: message.ReceiptHandle
-                    }));
-                    console.log(`Deleted processed message ${message.MessageId} from queue`);
-                }
-                else if (!messageProcessedByAnyConsumer) {
-                    console.log(`Message ${message.MessageId} was not processed by any consumer - leaving in queue for other consumers or systems`);
-                }
-            }
-            catch (error) {
-                console.error(`Error processing message from queue ${queueUrl}:`, error);
-                // Message will remain in queue and be retried or go to DLQ based on queue configuration
-            }
-        });
-    }
-    /**
-     * Add or update queue listeners for a specific consumer
-     */
-    updateConsumerSchedule(consumer) {
-        // First, remove any existing listeners for this consumer
-        this.removeConsumerSchedule(consumer.name);
-        // Then, add new listeners if they have QUEUE triggers
-        if (this.hasQueueTrigger(consumer)) {
-            this.setupQueueListeners(consumer);
-        }
-    }
-    /**
-     * Remove all queue listeners for a consumer
-     */
-    removeConsumerSchedule(consumerName) {
-        // Remove mappings for this consumer
-        for (const [queueUrl, mappings] of this.queueMappings.entries()) {
-            const updatedMappings = mappings.filter(mapping => mapping.consumer.name !== consumerName);
-            if (updatedMappings.length === 0) {
-                // No more consumers listening to this queue, stop polling
-                const interval = this.pollingIntervals.get(queueUrl);
-                if (interval) {
-                    clearInterval(interval);
-                    this.pollingIntervals.delete(queueUrl);
-                    console.log(`Stopped polling queue: ${queueUrl}`);
-                }
-                this.queueMappings.delete(queueUrl);
-            }
-            else {
-                this.queueMappings.set(queueUrl, updatedMappings);
-            }
-        }
-    }
-    /**
-     * Stop all queue polling
-     */
-    stopAllQueues() {
-        console.log('Stopping all queue polling...');
-        this.pollingIntervals.forEach((interval, queueUrl) => {
-            clearInterval(interval);
-            console.log(`Stopped polling queue: ${queueUrl}`);
-        });
-        this.pollingIntervals.clear();
-        this.queueMappings.clear();
-        this.isInitialized = false;
-        console.log('All queue polling stopped');
-    }
-    /**
-     * Restart the queue manager (useful for configuration reloads)
-     */
-    restart() {
-        console.log('Restarting Queue Manager...');
-        this.stopAllQueues();
-        this.initialize();
-    }
-    /**
-     * Get the queue manager status
-     */
-    getStatus() {
-        const queues = Array.from(this.queueMappings.entries()).map(([queueUrl, mappings]) => ({
-            queueUrl,
-            consumerCount: mappings.length
-        }));
-        return {
-            initialized: this.isInitialized,
-            queueCount: this.queueMappings.size,
-            consumerCount: Array.from(this.queueMappings.values()).flat().length,
-            queues
-        };
-    }
-}
-// Export a singleton instance
-exports.default = new QueueManager();

package/engines/schema/SchemaValidator.js

@@ -1,67 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ajv_1 = __importDefault(require("ajv"));
-const ajv_formats_1 = __importDefault(require("ajv-formats"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const Affirm_1 = __importDefault(require("../../core/Affirm"));
-class SchemaValidatorClass {
-    constructor() {
-        this.addSchema = (schema, schemaKey) => {
-            const isValid = this.ajv.validateSchema(schema);
-            (0, Affirm_1.default)(isValid, `Invalid JSON Schema: ${JSON.stringify(this.ajv.errors)}`);
-            this.ajv.addSchema(schema, schemaKey);
-        };
-        this.getSchema = (schemaKey) => {
-            return this.ajv.getSchema(schemaKey);
-        };
-        this.validate = (schemaKey, data) => {
-            var _a;
-            const validateFn = this.ajv.getSchema(schemaKey);
-            (0, Affirm_1.default)(validateFn, `Failed to get validator for schema '${schemaKey}'`);
-            const isValid = validateFn(data);
-            return { isValid, errors: (_a = validateFn.errors) !== null && _a !== void 0 ? _a : [], data };
-        };
-        this.validateAndReturn = (schemaKey, data) => {
-            const res = this.validate(schemaKey, data);
-            if (res.isValid)
-                return res.data;
-            else
-                return null;
-        };
-        this.unloadSchemas = () => {
-            const result = this.ajv.removeSchema();
-            (0, Affirm_1.default)(result, `Failed to remove schemas`);
-            this.loadInternalSchema();
-            return true;
-        };
-        this.loadInternalSchema = () => {
-            const internalSchemaDir = path_1.default.join(__dirname, '../../definitions/json_schemas');
-            const internalSchemas = [
-                'project-schema',
-                'source-schema',
-                'producer-schema',
-                'consumer-schema'
-            ];
-            internalSchemas.forEach(sn => {
-                const sp = path_1.default.join(internalSchemaDir, `${sn}.json`);
-                const parsed = JSON.parse(fs_1.default.readFileSync(sp, 'utf-8'));
-                this.addSchema(parsed, sn);
-            });
-            return true;
-        };
-        this.ajv = new ajv_1.default({
-            allErrors: true,
-            strict: true,
-            strictSchema: false,
-            validateFormats: true
-        });
-        (0, ajv_formats_1.default)(this.ajv);
-        this.loadInternalSchema();
-    }
-}
-const SchemaValidator = new SchemaValidatorClass();
-exports.default = SchemaValidator;