@comake/skl-js-engine 1.5.4 → 1.5.6

package/dist/SklEngine.js

@@ -0,0 +1,1514 @@
+"use strict";
+/* eslint-disable no-div-regex */
+/* eslint-disable line-comment-position */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKLEngine = void 0;
+const openapi_operation_executor_1 = require("@comake/openapi-operation-executor");
+const rmlmapper_js_1 = require("@comake/rmlmapper-js");
+const axios_1 = __importDefault(require("axios"));
+const jsonpath_plus_1 = require("jsonpath-plus");
+const rdf_validate_shacl_1 = __importDefault(require("rdf-validate-shacl"));
+const constants_1 = require("./constants");
+const customCapabilities_1 = require("./customCapabilities");
+const globalHooks_1 = require("./hooks/globalHooks");
+const logger_1 = require("./logger");
+const Mapper_1 = require("./mapping/Mapper");
+const Exists_1 = require("./storage/operator/Exists");
+const In_1 = require("./storage/operator/In");
+const InversePath_1 = require("./storage/operator/InversePath");
+const Not_1 = require("./storage/operator/Not");
+const OneOrMorePath_1 = require("./storage/operator/OneOrMorePath");
+const SequencePath_1 = require("./storage/operator/SequencePath");
+const ZeroOrMorePath_1 = require("./storage/operator/ZeroOrMorePath");
+const SparqlQueryAdapter_1 = require("./storage/query-adapter/sparql/SparqlQueryAdapter");
+const PerformanceLogger_1 = require("./util/PerformanceLogger");
+const ReadCacheHelper_1 = require("./util/ReadCacheHelper");
+const Util_1 = require("./util/Util");
+const Vocabularies_1 = require("./util/Vocabularies");
+const DEFAULT_READ_CACHE_TTL_MS = 60000;
+const READ_CACHE_ENVELOPE_MARKER = '__sklReadCacheEnvelopeV1';
+class SKLEngine {
+    constructor(options) {
+        this.readCacheSingleflight = new ReadCacheHelper_1.ReadCacheSingleflight();
+        this.queryAdapter = new SparqlQueryAdapter_1.SparqlQueryAdapter(options);
+        this.disableValidation = options.disableValidation;
+        this.globalCallbacks = options.callbacks;
+        this.inputFiles = options.inputFiles;
+        this.skdsEndpointUrl = options.endpointUrl;
+        this.scriptPath = options.scriptPath;
+        this.readCache = options.readCache;
+        this.readCachePolicy = options.readCachePolicy;
+        this.readCacheNamespace = options.readCacheNamespace;
+        if (options.functions) {
+            this.functions = Object.fromEntries(Object.entries(options.functions).map(([key, func]) => [
+                key,
+                (data = {}) => {
+                    // Add the SKL instance to the data object
+                    // eslint-disable-next-line @typescript-eslint/no-this-alias
+                    data.skl = this;
+                    // Call the original function
+                    return func(data);
+                }
+            ]));
+        }
+        this.logger = logger_1.Logger.getInstance(options.debugMode);
+        // eslint-disable-next-line func-style
+        const getCapabilityHandler = (getTarget, property) => async (capabilityArgs, capabilityConfig) => this.executeCapabilityByName(property, capabilityArgs, capabilityConfig);
+        this.capability = new Proxy({}, { get: getCapabilityHandler });
+    }
+    setCodeExecutor(codeExecutor) {
+        this.codeExecutor = codeExecutor;
+    }
+    async executeRawQuery(query) {
+        return await this.queryAdapter.executeRawQuery(query);
+    }
+    async executeRawUpdate(query) {
+        return await this.queryAdapter.executeRawUpdate(query);
+    }
+    async executeRawConstructQuery(query, frame) {
+        return await this.queryAdapter.executeRawConstructQuery(query, frame);
+    }
+    cloneForReadCache(value) {
+        try {
+            return structuredClone(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    wrapReadCacheValue(value) {
+        return {
+            [READ_CACHE_ENVELOPE_MARKER]: true,
+            value
+        };
+    }
+    isReadCacheEnvelope(value) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        return value[READ_CACHE_ENVELOPE_MARKER] === true;
+    }
+    stripBypassCacheFromFindOneOptions(options) {
+        if (!options) {
+            return options;
+        }
+        const { bypassCache, ...rest } = options;
+        return rest;
+    }
+    stripBypassCacheFromFindAllOptions(options) {
+        if (!options) {
+            return options;
+        }
+        const { bypassCache, ...rest } = options;
+        return rest;
+    }
+    stripBypassCacheFromWhere(where) {
+        if (!where) {
+            return where;
+        }
+        const { bypassCache, ...rest } = where;
+        return rest;
+    }
+    async runReadWithCache(params) {
+        if (params.bypassCache) {
+            return await params.execute();
+        }
+        if (!this.readCache || !this.readCachePolicy) {
+            return await params.execute();
+        }
+        const policyDecision = this.readCachePolicy({
+            operation: params.operation,
+            args: params.args,
+            endpointUrl: this.skdsEndpointUrl,
+            namespace: this.readCacheNamespace
+        });
+        if (!policyDecision.cache) {
+            return await params.execute();
+        }
+        const ttlMs = policyDecision.ttlMs ?? DEFAULT_READ_CACHE_TTL_MS;
+        if (ttlMs <= 0) {
+            return await params.execute();
+        }
+        const cacheKey = (0, ReadCacheHelper_1.buildReadCacheKey)({
+            operation: params.operation,
+            args: params.args,
+            endpointUrl: this.skdsEndpointUrl,
+            namespace: this.readCacheNamespace,
+            keyHint: policyDecision.keyHint
+        });
+        return await this.readCacheSingleflight.do(cacheKey, async () => {
+            try {
+                const cached = await this.readCache?.get(cacheKey);
+                if (cached !== undefined) {
+                    if (this.isReadCacheEnvelope(cached)) {
+                        return this.cloneForReadCache(cached.value);
+                    }
+                    return this.cloneForReadCache(cached);
+                }
+            }
+            catch (error) {
+                this.logger.debug('Read cache lookup failed; continuing without cache', error);
+            }
+            const result = await params.execute();
+            try {
+                await this.readCache?.set(cacheKey, this.wrapReadCacheValue(this.cloneForReadCache(result)), ttlMs);
+            }
+            catch (error) {
+                this.logger.debug('Read cache write failed; continuing without cache', error);
+            }
+            return result;
+        });
+    }
+    async find(options) {
+        const bypassCache = options?.bypassCache;
+        const optionsWithoutBypass = this.stripBypassCacheFromFindOneOptions(options);
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.find', async () => {
+            const context = {
+                entities: [],
+                operation: 'find',
+                operationParameters: { options: optionsWithoutBypass },
+                sklEngine: this
+            };
+            await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.BEFORE, context);
+            try {
+                const entity = await this.runReadWithCache({
+                    operation: 'find',
+                    args: [optionsWithoutBypass],
+                    bypassCache,
+                    execute: async () => await this.queryAdapter.find(optionsWithoutBypass)
+                });
+                if (!entity) {
+                    throw new Error(`No schema found with fields matching ${JSON.stringify(optionsWithoutBypass)}`);
+                }
+                const updatedContext = { ...context, entities: [entity] };
+                const afterHookResult = await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.AFTER, updatedContext, entity);
+                return afterHookResult || entity;
+            }
+            catch (error) {
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.ERROR, context, error);
+                throw error;
+            }
+        }, { options: optionsWithoutBypass });
+    }
+    async findBy(where, notFoundErrorMessage) {
+        const bypassCache = where?.bypassCache;
+        const whereWithoutBypass = this.stripBypassCacheFromWhere(where);
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.findBy', async () => {
+            const context = {
+                entities: [],
+                operation: 'findBy',
+                operationParameters: { where: whereWithoutBypass },
+                sklEngine: this
+            };
+            await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.BEFORE, context);
+            try {
+                const entity = await this.runReadWithCache({
+                    operation: 'findBy',
+                    args: [whereWithoutBypass, notFoundErrorMessage],
+                    bypassCache,
+                    execute: async () => await this.queryAdapter.findBy(whereWithoutBypass)
+                });
+                if (entity) {
+                    const updatedContext = { ...context, entities: [entity] };
+                    await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.AFTER, updatedContext, entity);
+                    return entity;
+                }
+                throw new Error(notFoundErrorMessage ?? `No schema found with fields matching ${JSON.stringify(whereWithoutBypass)}`);
+            }
+            catch (error) {
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.ERROR, context, error);
+                throw error;
+            }
+        }, { where: whereWithoutBypass });
+    }
+    async findByIfExists(options) {
+        try {
+            const entity = await this.findBy(options);
+            return entity;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async findAll(options) {
+        const bypassCache = options?.bypassCache;
+        const optionsWithoutBypass = this.stripBypassCacheFromFindAllOptions(options);
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.findAll', async () => {
+            const context = {
+                entities: [],
+                operation: 'findAll',
+                operationParameters: { options: optionsWithoutBypass },
+                sklEngine: this
+            };
+            await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.BEFORE, context);
+            try {
+                const entities = await this.runReadWithCache({
+                    operation: 'findAll',
+                    args: [optionsWithoutBypass],
+                    bypassCache,
+                    execute: async () => await this.queryAdapter.findAll(optionsWithoutBypass)
+                });
+                const updatedContext = { ...context, entities };
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.AFTER, updatedContext, entities);
+                return entities;
+            }
+            catch (error) {
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.ERROR, context, error);
+                throw error;
+            }
+        }, { options: optionsWithoutBypass });
+    }
+    async groupBy(options) {
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.groupBy', async () => {
+            const context = {
+                entities: [],
+                operation: 'groupBy',
+                operationParameters: { options },
+                sklEngine: this
+            };
+            await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.BEFORE, context);
+            try {
+                const result = await this.queryAdapter.groupBy(options);
+                const updatedContext = { ...context, result };
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.AFTER, updatedContext, result);
+                return result;
+            }
+            catch (error) {
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.ERROR, context, error);
+                throw error;
+            }
+        }, { options });
+    }
+    async findAllBy(where) {
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.findAllBy', async () => {
+            const context = {
+                entities: [],
+                operation: 'findAllBy',
+                operationParameters: { where },
+                sklEngine: this
+            };
+            await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.BEFORE, context);
+            try {
+                const entities = await this.queryAdapter.findAllBy(where);
+                const updatedContext = { ...context, entities };
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.AFTER, updatedContext, entities);
+                return entities;
+            }
+            catch (error) {
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.READ, globalHooks_1.HookStages.ERROR, context, error);
+                throw error;
+            }
+        }, { where });
+    }
+    async exists(options) {
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.exists', async () => this.queryAdapter.exists(options), { options });
+    }
+    async count(options) {
+        const bypassCache = options?.bypassCache;
+        const optionsWithoutBypass = this.stripBypassCacheFromFindAllOptions(options);
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.count', async () => await this.runReadWithCache({
+            operation: 'count',
+            args: [optionsWithoutBypass],
+            bypassCache,
+            execute: async () => await this.queryAdapter.count(optionsWithoutBypass)
+        }), { options: optionsWithoutBypass });
+    }
+    async save(entityOrEntities, options) {
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.save', async () => {
+            const entityArray = Array.isArray(entityOrEntities) ? entityOrEntities : [entityOrEntities];
+            const isSingleEntity = !Array.isArray(entityOrEntities);
+            await globalHooks_1.globalHooks.executeBeforeCreate(entityArray, { sklEngine: this, bypassHooks: options?.bypassHooks });
+            try {
+                await this.validateEntitiesConformToObjectSchema(entityArray);
+                const savedEntities = await this.queryAdapter.save(entityArray);
+                await globalHooks_1.globalHooks.executeAfterCreate(savedEntities, { sklEngine: this, bypassHooks: options?.bypassHooks });
+                return isSingleEntity ? savedEntities[0] : savedEntities;
+            }
+            catch (error) {
+                await globalHooks_1.globalHooks.executeErrorCreate(entityArray, error, { sklEngine: this, bypassHooks: options?.bypassHooks });
+                throw error;
+            }
+        }, { entityCount: Array.isArray(entityOrEntities) ? entityOrEntities.length : 1 });
+    }
+    async update(idOrIds, attributes, options) {
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.update', async () => {
+            const idArray = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
+            const isSingleEntity = !Array.isArray(idOrIds);
+            await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.UPDATE, globalHooks_1.HookStages.BEFORE, {
+                entities: [],
+                operation: 'update',
+                operationParameters: { idArray, attributes },
+                sklEngine: this,
+                bypassHooks: options?.bypassHooks
+            });
+            try {
+                if (idArray.length > 1) {
+                    await this.validateEntitiesWithIdsConformsToObjectSchemaForAttributes(idArray, attributes);
+                }
+                else {
+                    await this.validateEntityWithIdConformsToObjectSchemaForAttributes(idArray[0], attributes);
+                }
+                await this.queryAdapter.update(isSingleEntity ? idArray[0] : idArray, attributes);
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.UPDATE, globalHooks_1.HookStages.AFTER, {
+                    entities: [],
+                    operation: 'update',
+                    operationParameters: { idArray, attributes },
+                    sklEngine: this,
+                    bypassHooks: options?.bypassHooks
+                });
+            }
+            catch (error) {
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.UPDATE, globalHooks_1.HookStages.ERROR, {
+                    entities: [],
+                    operation: 'update',
+                    operationParameters: { idArray, attributes },
+                    sklEngine: this,
+                    bypassHooks: options?.bypassHooks
+                }, error);
+                throw error;
+            }
+        }, { idCount: Array.isArray(idOrIds) ? idOrIds.length : 1 });
+    }
+    async validateEntitiesConformToObjectSchema(entities) {
+        const entitiesByType = this.groupEntitiesByType(entities);
+        for (const type of Object.keys(entitiesByType)) {
+            const object = await this.findByIfExists({ id: type });
+            if (object) {
+                const parentObjects = await this.getSuperClassesOfObject(type);
+                for (const currentObject of [object, ...parentObjects]) {
+                    const entitiesOfType = entitiesByType[type];
+                    const nounSchemaWithTarget = {
+                        ...currentObject,
+                        [constants_1.SHACL.targetNode]: entitiesOfType.map((entity) => ({ [constants_1.PROP_ENTITY_ID]: entity[constants_1.PROP_ENTITY_ID] }))
+                    };
+                    const report = await this.convertToQuadsAndValidateAgainstShape(entitiesOfType, nounSchemaWithTarget);
+                    if (!report.conforms) {
+                        const entityIds = entitiesOfType.map((entity) => entity[constants_1.PROP_ENTITY_ID]);
+                        this.throwValidationReportError(report, `Entity ${entityIds.join(', ')} does not conform to the ${currentObject[constants_1.PROP_ENTITY_ID]} schema.`);
+                    }
+                }
+            }
+        }
+    }
+    groupEntitiesByType(entities) {
+        return entities.reduce((groupedEntities, entity) => {
+            const entityTypes = Array.isArray(entity[constants_1.PROP_ENTITY_TYPE])
+                ? entity[constants_1.PROP_ENTITY_TYPE]
+                : [entity[constants_1.PROP_ENTITY_TYPE]];
+            for (const type of entityTypes) {
+                if (!groupedEntities[type]) {
+                    groupedEntities[type] = [];
+                }
+                groupedEntities[type].push(entity);
+            }
+            return groupedEntities;
+        }, {});
+    }
+    async getSuperClassesOfObject(object) {
+        return await this.getParentsOfSelector(object);
+    }
+    async getSuperClassesOfObjects(nouns) {
+        return await this.getParentsOfSelector((0, In_1.In)(nouns));
+    }
+    async getParentsOfSelector(selector) {
+        return await this.findAll({
+            where: {
+                id: (0, InversePath_1.InversePath)({
+                    subPath: (0, OneOrMorePath_1.OneOrMorePath)({ subPath: constants_1.RDFS.subClassOf }),
+                    value: selector
+                })
+            }
+        });
+    }
+    async validateEntityConformsToObjectSchema(entity) {
+        const nounIds = Array.isArray(entity[constants_1.PROP_ENTITY_TYPE]) ? entity[constants_1.PROP_ENTITY_TYPE] : [entity[constants_1.PROP_ENTITY_TYPE]];
+        const directObjects = await this.findAllBy({ id: (0, In_1.In)(nounIds) });
+        if (directObjects.length > 0) {
+            const existingObjectIds = directObjects.map((object) => object[constants_1.PROP_ENTITY_ID]);
+            const parentObjects = await this.getSuperClassesOfObjects(existingObjectIds);
+            for (const currentObject of [...directObjects, ...parentObjects]) {
+                const nounSchemaWithTarget = {
+                    ...currentObject,
+                    [constants_1.SHACL.targetNode]: { [constants_1.PROP_ENTITY_ID]: entity[constants_1.PROP_ENTITY_ID] }
+                };
+                const report = await this.convertToQuadsAndValidateAgainstShape(entity, nounSchemaWithTarget);
+                if (!report.conforms) {
+                    this.throwValidationReportError(report, `Entity ${entity[constants_1.PROP_ENTITY_ID]} does not conform to the ${currentObject[constants_1.PROP_ENTITY_ID]} schema.`);
+                }
+            }
+        }
+    }
+    async validateEntitiesWithIdsConformsToObjectSchemaForAttributes(ids, attributes) {
+        for (const id of ids) {
+            await this.validateEntityWithIdConformsToObjectSchemaForAttributes(id, attributes);
+        }
+    }
+    async getObjectsAndParentObjectsOfEntity(id) {
+        return await this.findAllBy({
+            id: (0, InversePath_1.InversePath)({
+                subPath: (0, SequencePath_1.SequencePath)({
+                    subPath: [constants_1.RDF.type, (0, ZeroOrMorePath_1.ZeroOrMorePath)({ subPath: constants_1.RDFS.subClassOf })]
+                }),
+                value: id
+            })
+        });
+    }
+    async validateEntityWithIdConformsToObjectSchemaForAttributes(id, attributes) {
+        const nouns = await this.getObjectsAndParentObjectsOfEntity(id);
+        for (const currentObject of nouns) {
+            if (constants_1.SHACL.property in currentObject) {
+                const nounProperties = (0, Util_1.ensureArray)(currentObject[constants_1.SHACL.property]).filter((property) => {
+                    const path = property[constants_1.SHACL.path];
+                    if (typeof path === 'string' && path in attributes) {
+                        return true;
+                    }
+                    if (typeof path === 'object' && constants_1.PROP_ENTITY_ID in path && path[constants_1.PROP_ENTITY_ID] in attributes) {
+                        return true;
+                    }
+                    return false;
+                });
+                if (nounProperties.length > 0) {
+                    const nounSchemaWithTarget = {
+                        [constants_1.PROP_ENTITY_TYPE]: constants_1.SHACL.NodeShape,
+                        [constants_1.SHACL.targetNode]: { [constants_1.PROP_ENTITY_ID]: id },
+                        [constants_1.SHACL.property]: nounProperties
+                    };
+                    const attributesWithId = { ...attributes, [constants_1.PROP_ENTITY_ID]: id };
+                    const report = await this.convertToQuadsAndValidateAgainstShape(attributesWithId, nounSchemaWithTarget);
+                    if (!report.conforms) {
+                        this.throwValidationReportError(report, `Entity ${id} does not conform to the ${currentObject[constants_1.PROP_ENTITY_ID]} schema.`);
+                    }
+                }
+            }
+        }
+    }
+    async delete(idOrIds, options) {
+        return PerformanceLogger_1.PerformanceLogger.withSpanRoot('SklEngine.delete', async () => {
+            const idArray = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
+            await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.DELETE, globalHooks_1.HookStages.BEFORE, {
+                entities: [],
+                operation: 'delete',
+                operationParameters: { idArray },
+                sklEngine: this,
+                bypassHooks: options?.bypassHooks
+            });
+            try {
+                await this.queryAdapter.delete(idArray);
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.DELETE, globalHooks_1.HookStages.AFTER, {
+                    entities: [],
+                    operation: 'delete',
+                    operationParameters: { idArray },
+                    sklEngine: this,
+                    bypassHooks: options?.bypassHooks
+                });
+            }
+            catch (error) {
+                await globalHooks_1.globalHooks.execute(globalHooks_1.HookTypes.DELETE, globalHooks_1.HookStages.ERROR, {
+                    entities: [],
+                    operation: 'delete',
+                    operationParameters: { idArray },
+                    sklEngine: this,
+                    bypassHooks: options?.bypassHooks
+                }, error);
+                throw error;
+            }
+        }, { idCount: Array.isArray(idOrIds) ? idOrIds.length : 1 });
+    }
+    async destroy(entityOrEntities) {
+        if (Array.isArray(entityOrEntities)) {
+            return await this.queryAdapter.destroy(entityOrEntities);
+        }
+        return await this.queryAdapter.destroy(entityOrEntities);
+    }
+    async destroyAll() {
+        return await this.queryAdapter.destroyAll();
+    }
+    async performMapping(args, mapping, frame, capabilityConfig, jsExecutionOptions) {
+        const mappingArray = (0, Util_1.ensureArray)(mapping);
+        const codeBlocks = mappingArray.filter((mappingItem) => mappingItem[constants_1.PROP_ENTITY_TYPE] === constants_1.EngineConstants.spec.codeBlock &&
+            this.isJavaScriptCode((0, Util_1.getValueIfDefined)(mappingItem[constants_1.EngineConstants.prop.codeBody])));
+        // FIXME: Handle if we can combine the codeb blocks with triples map.
+        // As of now if there is any code block, triples map does not get executed.
+        if (codeBlocks.length > 0) {
+            return await this.executeCodeBlocks(codeBlocks, args, jsExecutionOptions ?? {});
+        }
+        const functions = {
+            ...this.functions,
+            ...capabilityConfig?.functions
+        };
+        const mapper = new Mapper_1.Mapper({ functions });
+        return await mapper.apply(args, mapping, frame ?? {});
+    }
+    async executeTrigger(integration, payload) {
+        const triggerToCapabilityMapping = await this.findTriggerCapabilityMapping(integration);
+        const capabilityArgs = await this.performParameterMappingOnArgsIfDefined(payload, triggerToCapabilityMapping);
+        const capabilityId = await this.performCapabilityMappingWithArgs(payload, triggerToCapabilityMapping);
+        if (capabilityId) {
+            const mappedCapability = (await this.findBy({ id: capabilityId }));
+            await this.executeCapability(mappedCapability, capabilityArgs);
+        }
+    }
+    async findTriggerCapabilityMapping(integration) {
+        const triggerCapabilityMappingNew = (await this.findBy({
+            type: constants_1.EngineConstants.spec.capabilityMapping,
+            [constants_1.EngineConstants.prop.capability]: integration,
+            [constants_1.EngineConstants.prop.capabilityType]: constants_1.EngineConstants.spec.triggerCapabilityMapping
+        }, `Failed to find a Trigger Capability mapping for integration ${integration}`));
+        if (triggerCapabilityMappingNew) {
+            return triggerCapabilityMappingNew;
+        }
+        throw new Error(`Failed to find a Trigger Capability mapping for integration ${integration}`);
+    }
+    async executeCapabilityByName(capabilityName, capabilityArgs, capabilityConfig) {
+        const capability = await this.findCapabilityWithName(capabilityName);
+        return await this.executeCapability(capability, capabilityArgs, capabilityConfig);
+    }
+    async findCapabilityWithName(capabilityName) {
+        return (await this.findBy({ type: constants_1.EngineConstants.spec.capability, [constants_1.EngineConstants.prop.label]: capabilityName }, `Failed to find the capability ${capabilityName} in the schema.`));
+    }
+    async executeCapability(capability, capabilityArgs, capabilityConfig) {
+        this.globalCallbacks?.onCapabilityStart?.(capability[constants_1.PROP_ENTITY_ID], capabilityArgs);
+        if (capabilityConfig?.callbacks?.onCapabilityStart) {
+            this.logger.debug('Capability arguments', capabilityArgs);
+            capabilityConfig.callbacks.onCapabilityStart(capability[constants_1.PROP_ENTITY_ID], capabilityArgs);
+        }
+        const { mapping, account } = await this.findMappingForCapabilityContextually(capability[constants_1.PROP_ENTITY_ID], capabilityArgs);
+        this.logger.debug('Mapping', JSON.stringify(mapping));
+        const shouldValidate = this.shouldValidate(capabilityConfig);
+        if (shouldValidate) {
+            await this.assertCapabilityParamsMatchParameterSchemas(capabilityArgs, capability);
+        }
+        try {
+            // Execute capability mapping before hook if appropriate -
+            //  works for any mapping that can be used as a verb mapping
+            if (mapping) {
+                await globalHooks_1.globalHooks.executeBeforeExecuteCapabilityMapping([capabilityArgs], mapping, { sklEngine: this });
+            }
+            const verbReturnValue = await this.executeMapping(mapping, capabilityArgs, capabilityConfig, account);
+            if (shouldValidate) {
+                await this.assertCapabilityReturnValueMatchesReturnTypeSchema(verbReturnValue, capability);
+            }
+            // Execute capability mapping after hook if appropriate
+            if (mapping) {
+                await globalHooks_1.globalHooks.executeAfterExecuteCapabilityMapping([capabilityArgs], mapping, verbReturnValue, { sklEngine: this });
+            }
+            this.globalCallbacks?.onCapabilityEnd?.(capability[constants_1.PROP_ENTITY_ID], verbReturnValue);
+            if (capabilityConfig?.callbacks?.onCapabilityEnd) {
+                capabilityConfig.callbacks.onCapabilityEnd(capability[constants_1.PROP_ENTITY_ID], verbReturnValue);
+            }
+            return verbReturnValue;
+        }
+        catch (error) {
+            // Execute capability mapping error hook if appropriate
+            if (mapping) {
+                await globalHooks_1.globalHooks.executeErrorExecuteCapabilityMapping([capabilityArgs], mapping, error, { sklEngine: this });
+            }
+            throw error;
+        }
+    }
+    async findMappingForCapabilityContextually(capabilityId, args) {
+        if (args.mapping) {
+            const mapping = await this.findByIfExists({ id: args.mapping });
+            if (!mapping) {
+                throw new Error(`Mapping ${args.mapping} not found.`);
+            }
+            return { mapping: mapping };
+        }
+        if (args.object) {
+            const mapping = await this.findCapabilityObjectMapping(capabilityId, args.object);
+            if (mapping) {
+                return { mapping };
+            }
+        }
+        if (args.account) {
+            const account = await this.findBy({ id: args.account });
+            const integratedProductId = account[constants_1.EngineConstants.prop.integration][constants_1.PROP_ENTITY_ID];
+            const mapping = await this.findCapabilityIntegrationMapping(capabilityId, integratedProductId);
+            if (mapping) {
+                return { mapping, account };
+            }
+        }
+        const mappings = await this.findAllBy({
+            type: constants_1.EngineConstants.spec.capabilityMapping,
+            [constants_1.EngineConstants.prop.capability]: capabilityId,
+            [constants_1.EngineConstants.prop.integration]: (0, Not_1.Not)((0, Exists_1.Exists)()),
+            [constants_1.EngineConstants.prop.object]: (0, Not_1.Not)((0, Exists_1.Exists)())
+        });
+        if (mappings.length === 1) {
+            return { mapping: mappings[0] };
+        }
+        if (mappings.length > 1) {
+            throw new Error('Multiple mappings found for capability, please specify one.');
+        }
+        if (args.object) {
+            throw new Error(`Mapping between object ${args.object} and capability ${capabilityId} not found.`);
+        }
+        if (args.account) {
+            throw new Error(`Mapping between account ${args.account} and capability ${capabilityId} not found.`);
+        }
+        throw new Error(`No mapping found.`);
+    }
+    async executeMapping(mapping, args, capabilityConfig, account) {
+        args = await this.addPreProcessingMappingToArgs(mapping, args, capabilityConfig);
+        let returnValue;
+        // If (EngineConstants.prop.capability in mapping || EngineConstants.prop.capabilityMapping in mapping) {
+        //   const capabilityId = await this.performCapabilityMappingWithArgs(args, mapping, capabilityConfig);
+        //   const mappedArgs = await this.performParameterMappingOnArgsIfDefined(
+        //     { ...args, capabilityId },
+        //     mapping as MappingWithInputs,
+        //     capabilityConfig
+        //   );
+        //   Logger.getInstance().log('Mapped args', mappedArgs);
+        //   returnValue = await this.executeCapabilityMapping(mapping, args, mappedArgs, capabilityConfig);
+        // } else {
+        const mappedArgs = await this.performParameterMappingOnArgsIfDefined(args, mapping, capabilityConfig);
+        this.logger.debug('Mapped args', mappedArgs);
+        if (constants_1.EngineConstants.prop.operationId in mapping || constants_1.EngineConstants.prop.operationMapping in mapping) {
+            returnValue = (await this.executeOperationMapping(mapping, mappedArgs, args, account, capabilityConfig));
+        }
+        else if (constants_1.EngineConstants.prop.series in mapping) {
+            returnValue = await this.executeSeriesMapping(mapping, mappedArgs, capabilityConfig);
+        }
+        else if (constants_1.EngineConstants.prop.parallel in mapping) {
+            returnValue = await this.executeParallelMapping(mapping, mappedArgs, capabilityConfig);
+        }
+        else {
+            returnValue = mappedArgs;
+        }
+        // }
+        return await this.performReturnValueMappingWithFrameIfDefined(returnValue, mapping, capabilityConfig);
+    }
+    shouldValidate(capabilityConfig) {
+        return capabilityConfig?.disableValidation === undefined
+            ? this.disableValidation !== true
+            : !capabilityConfig.disableValidation;
+    }
+    async executeOperationMapping(mapping, mappedArgs, originalArgs, account, capabilityConfig) {
+        const integration = mapping[constants_1.EngineConstants.prop.integration]?.[constants_1.PROP_ENTITY_ID];
+        // If the mapping has an integration, it means that the operation is an integration operation
+        if (integration) {
+            const operationInfo = await this.performOperationMappingWithArgs(originalArgs, mapping, capabilityConfig);
+            const response = await this.performOperation(operationInfo, mappedArgs, originalArgs, account, capabilityConfig);
+            if (!this.ifCapabilityStreaming(capabilityConfig)) {
+                this.logger.debug('Original response', JSON.stringify(response));
+            }
+            return response;
+        }
+        // If the mapping does not have an integration, it means that the operation is a capability operation
+        return await this.executeCapabilityMapping(mapping, originalArgs, mappedArgs, capabilityConfig);
+    }
+    async executeSeriesMapping(mapping, args, capabilityConfig) {
+        const seriesCapabilityMappingsList = this.rdfListToArray(mapping[constants_1.EngineConstants.prop.series]);
+        const seriesCapabilityArgs = {
+            originalCapabilityParameters: args,
+            previousCapabilityReturnValue: {},
+            allStepsResults: []
+        };
+        return await this.executeSeriesFromList(seriesCapabilityMappingsList, seriesCapabilityArgs, capabilityConfig);
+    }
+    rdfListToArray(list) {
+        if (!(constants_1.RML_LIST in list)) {
+            return [
+                list[constants_1.RDF.first],
+                ...(0, rmlmapper_js_1.getIdFromNodeObjectIfDefined)(list[constants_1.RDF.rest]) === constants_1.RDF.nil
+                    ? []
+                    : this.rdfListToArray(list[constants_1.RDF.rest])
+            ];
+        }
+        return list[constants_1.RML_LIST];
+    }
+    async executeSeriesFromList(list, args, capabilityConfig) {
+        const nextCapabilityMapping = list[0];
+        const returnValue = await this.executeMapping(nextCapabilityMapping, args, capabilityConfig);
+        if (list.length > 1) {
+            return await this.executeSeriesFromList(list.slice(1), {
+                ...args,
+                previousCapabilityReturnValue: returnValue,
+                allStepsResults: [...args.allStepsResults ?? [], returnValue]
+            }, capabilityConfig);
+        }
+        return returnValue;
+    }
+    async executeCapabilityMapping(capabilityMapping, originalArgs, mappedArgs, capabilityConfig) {
+        const capabilityId = await this.performCapabilityMappingWithArgs(originalArgs, capabilityMapping, capabilityConfig);
+        if (capabilityId) {
+            if (capabilityId === constants_1.EngineConstants.dataSource.update) {
+                await this.updateEntityFromcapabilityArgs(mappedArgs);
+                return {};
+            }
+            if (capabilityId === constants_1.EngineConstants.dataSource.save) {
+                return await this.saveEntityOrEntitiesFromcapabilityArgs(mappedArgs);
+            }
+            if (capabilityId === constants_1.EngineConstants.dataSource.destroy) {
+                return await this.destroyEntityOrEntitiesFromcapabilityArgs(mappedArgs);
+            }
+            if (capabilityId === constants_1.EngineConstants.dataSource.findAll) {
+                return await this.findAll(mappedArgs);
+            }
+            if (capabilityId === constants_1.EngineConstants.dataSource.find) {
+                return await this.find(mappedArgs);
+            }
+            if (capabilityId === constants_1.EngineConstants.dataSource.count) {
+                return await this.countAndWrapValueFromcapabilityArgs(mappedArgs);
+            }
+            if (capabilityId === constants_1.EngineConstants.dataSource.exists) {
+                return await this.existsAndWrapValueFromcapabilityArgs(mappedArgs);
+            }
+            if (capabilityId === 'https://skl.ai/capability/execute-code') {
+                const codeBlocks = (0, Util_1.ensureArray)(capabilityMapping[constants_1.EngineConstants.prop.codeBlocks] ?? []).filter((mappingItem) => mappingItem[constants_1.PROP_ENTITY_TYPE] === constants_1.EngineConstants.spec.codeBlock &&
+                    this.isJavaScriptCode((0, Util_1.getValueIfDefined)(mappingItem[constants_1.EngineConstants.prop.codeBody])));
+                return await this.executeCodeBlocks(codeBlocks, mappedArgs, {});
+            }
+            // Check for custom capabilities
+            if (customCapabilities_1.globalCustomCapabilities.has(capabilityId)) {
+                return await customCapabilities_1.globalCustomCapabilities.execute(capabilityId, mappedArgs, this, capabilityConfig);
+            }
+            return await this.findAndExecuteCapability(capabilityId, mappedArgs, capabilityConfig);
+        }
+        return {};
+    }
+    async addPreProcessingMappingToArgs(capabilityMapping, args, capabilityConfig) {
+        if (constants_1.EngineConstants.prop.preProcessingMapping in capabilityMapping) {
+            const preMappingArgs = await this.performMapping(args, capabilityMapping[constants_1.EngineConstants.prop.preProcessingMapping], (0, Util_1.getValueIfDefined)(capabilityMapping[constants_1.EngineConstants.prop.preProcessingMappingFrame]), capabilityConfig);
+            return { ...args, preProcessedParameters: preMappingArgs };
+        }
+        return args;
+    }
+    replaceTypeAndId(entity) {
+        if (typeof entity !== 'object') {
+            throw new Error('Entity is not an object');
+        }
+        const clonedEntity = structuredClone(entity);
+        if (clonedEntity[constants_1.EngineConstants.prop.type]) {
+            clonedEntity[constants_1.PROP_ENTITY_TYPE] = clonedEntity[constants_1.EngineConstants.prop.type];
+        }
+        if (clonedEntity[constants_1.EngineConstants.prop.identifier]) {
+            clonedEntity[constants_1.PROP_ENTITY_ID] = Vocabularies_1.SKL_DATA_NAMESPACE + clonedEntity[constants_1.EngineConstants.prop.identifier];
+        }
+        return clonedEntity;
+    }
+    async updateEntityFromcapabilityArgs(args) {
+        let ids = args.id ?? args.ids;
+        if (!Array.isArray(ids)) {
+            ids = [ids];
+        }
+        // FIX: Temporary fix for the issue where the id always getting prefixed with the namespace
+        ids = ids.map((id) => (id.startsWith('http') ? id : `${Vocabularies_1.SKL_DATA_NAMESPACE}${id}`));
+        await this.update(ids, args.attributes);
+    }
+    async saveEntityOrEntitiesFromcapabilityArgs(args) {
+        if (args.entity && typeof args.entity === 'object') {
+            args.entity = this.replaceTypeAndId(args.entity);
+        }
+        if (args.entities && Array.isArray(args.entities)) {
+            args.entities = args.entities.map(this.replaceTypeAndId);
+        }
+        return await this.save(args.entity ?? args.entities);
+    }
+    async destroyEntityOrEntitiesFromcapabilityArgs(args) {
+        if (args.entity && typeof args.entity === 'object') {
+            args.entity = this.replaceTypeAndId(args.entity);
+        }
+        if (args.entities && Array.isArray(args.entities)) {
+            args.entities = args.entities.map(this.replaceTypeAndId);
+        }
+        return await this.destroy(args.entity ?? args.entities);
+    }
+    async countAndWrapValueFromcapabilityArgs(args) {
+        const count = await this.count(args);
+        return {
+            [constants_1.EngineConstants.dataSource.countResult]: {
+                [constants_1.PROP_ENTITY_VALUE]: count,
+                [constants_1.PROP_ENTITY_TYPE]: rmlmapper_js_1.XSD.integer
+            }
+        };
+    }
+    async existsAndWrapValueFromcapabilityArgs(args) {
+        const exists = await this.exists(args);
+        return {
+            [constants_1.EngineConstants.dataSource.existsResult]: {
+                [constants_1.PROP_ENTITY_VALUE]: exists,
+                [constants_1.PROP_ENTITY_TYPE]: rmlmapper_js_1.XSD.boolean
+            }
+        };
+    }
+    async findAndExecuteCapability(capabilityId, args, capabilityConfig) {
+        const capability = (await this.findBy({ id: capabilityId }));
+        return await this.executeCapability(capability, args, capabilityConfig);
+    }
+    async executeParallelMapping(mapping, args, capabilityConfig) {
+        const parallelCapabilityMappings = (0, Util_1.ensureArray)(mapping[constants_1.EngineConstants.prop.parallel]);
+        const nestedReturnValues = await Promise.all(parallelCapabilityMappings.map((capabilityMapping) => this.executeMapping(capabilityMapping, args, capabilityConfig)));
+        return nestedReturnValues.flat();
+    }
+    async findCapabilityIntegrationMapping(capabilityId, integratedProductId) {
+        return (await this.findByIfExists({
+            type: constants_1.EngineConstants.spec.capabilityMapping,
+            [constants_1.EngineConstants.prop.capability]: capabilityId,
+            [constants_1.EngineConstants.prop.integration]: integratedProductId
+        }));
+    }
+    async performOperationMappingWithArgs(args, mapping, capabilityConfig) {
+        if (mapping[constants_1.EngineConstants.prop.operationId]) {
+            return { [constants_1.EngineConstants.prop.operationId]: mapping[constants_1.EngineConstants.prop.operationId] };
+        }
+        if (mapping[constants_1.EngineConstants.prop.dataSource]) {
+            return { [constants_1.EngineConstants.prop.dataSource]: mapping[constants_1.EngineConstants.prop.dataSource] };
+        }
+        return await this.performMapping(args, mapping[constants_1.EngineConstants.prop.operationMapping], undefined, capabilityConfig);
+    }
+    async performOperation(operationInfo, operationArgs, originalArgs, account, capabilityConfig, securityCredentials) {
+        if (operationInfo[constants_1.EngineConstants.prop.schemeName]) {
+            return await this.performOauthSecuritySchemeStageWithCredentials(operationInfo, operationArgs, account, securityCredentials);
+        }
+        if (operationInfo[constants_1.EngineConstants.prop.dataSource]) {
+            return await this.getDataFromDataSource((0, rmlmapper_js_1.getIdFromNodeObjectIfDefined)(operationInfo[constants_1.EngineConstants.prop.dataSource]), capabilityConfig);
+        }
+        if (operationInfo[constants_1.EngineConstants.prop.operationId]) {
+            const response = await this.performOpenapiOperationWithCredentials((0, Util_1.getValueIfDefined)(operationInfo[constants_1.EngineConstants.prop.operationId]), operationArgs, account, capabilityConfig);
+            return this.axiosResponseAndParamsToOperationResponse(response, operationArgs, originalArgs);
+        }
+        throw new Error('Operation not supported.');
+    }
+    axiosResponseAndParamsToOperationResponse(response, operationParameters, originalArgs) {
+        return {
+            operationParameters,
+            originalCapabilityParameters: originalArgs,
+            data: response.data,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            config: {
+                headers: response.config.headers,
+                method: response.config.method,
+                url: response.config.url,
+                data: response.config.data
+            }
+        };
+    }
+    async performReturnValueMappingWithFrameIfDefined(returnValue, mapping, capabilityConfig) {
+        if (constants_1.EngineConstants.prop.outputsMapping in mapping) {
+            return await this.performMapping(returnValue, mapping[constants_1.EngineConstants.prop.outputsMapping], (0, Util_1.getValueIfDefined)(mapping[constants_1.EngineConstants.prop.outputsMappingFrame]), capabilityConfig);
+        }
+        return returnValue;
+    }
+    async performParameterMappingOnArgsIfDefined(args, mapping, capabilityConfig, convertToJsonDeep = false) {
+        if (constants_1.EngineConstants.prop.inputsReference in mapping) {
+            const reference = (0, Util_1.getValueIfDefined)(mapping[constants_1.EngineConstants.prop.inputsReference]);
+            return this.getDataAtReference(reference, args);
+        }
+        if (constants_1.EngineConstants.prop.inputsMappingRef in mapping) {
+            const reference = (0, Util_1.getValueIfDefined)(mapping[constants_1.EngineConstants.prop.inputsMappingRef]);
+            const referencedMapping = this.getDataAtReference(reference, args);
+            if (!referencedMapping || referencedMapping?.length === 0) {
+                return args;
+            }
+            // Handle inputsMappingFrameRef if present
+            let frame;
+            if (constants_1.EngineConstants.prop.inputsMappingFrameRef in mapping) {
+                const frameReference = (0, Util_1.getValueIfDefined)(mapping[constants_1.EngineConstants.prop.inputsMappingFrameRef]);
+                frame = this.getDataAtReference(frameReference, args);
+            }
+            else {
+                // Use direct frame if provided
+                frame = (0, Util_1.getValueIfDefined)(mapping[constants_1.EngineConstants.prop.inputsMappingFrame]);
+            }
+            // Perform mapping with the referenced mapping and frame
+            const mappedData = await this.performMapping(args, referencedMapping, frame, capabilityConfig);
+            return (0, Util_1.toJSON)(mappedData, convertToJsonDeep);
+        }
+        if (constants_1.EngineConstants.prop.inputsMapping in mapping) {
+            const mappedData = await this.performMapping(args, mapping[constants_1.EngineConstants.prop.inputsMapping], (0, Util_1.getValueIfDefined)(mapping[constants_1.EngineConstants.prop.inputsMappingFrame]), capabilityConfig);
+            return (0, Util_1.toJSON)(mappedData, convertToJsonDeep);
+        }
+        return args;
+    }
+    getDataAtReference(reference, data) {
+        const results = (0, jsonpath_plus_1.JSONPath)({
+            path: reference,
+            json: data,
+            resultType: 'value'
+        });
+        const isArrayOfLengthOne = Array.isArray(results) && results.length === 1;
+        let result = isArrayOfLengthOne ? results[0] : results;
+        if (result && typeof result === 'object' && constants_1.PROP_ENTITY_VALUE in result) {
+            result = result[constants_1.PROP_ENTITY_VALUE];
+        }
+        return result;
+    }
+    async getIntegrationInterface(integratedProductId, integrationType = constants_1.EngineConstants.spec.integrationInterface) {
+        if (integrationType === constants_1.EngineConstants.spec.integrationInterface) {
+            const integrationInterface = await this.findBy({
+                type: integrationType,
+                [constants_1.EngineConstants.prop.type]: constants_1.EngineConstants.spec.openApi,
+                [constants_1.EngineConstants.prop.integration]: integratedProductId
+            });
+            return integrationInterface;
+        }
+        // Add support for other integration types
+        return null;
+    }
+    async findSecurityCredentialsForAccountIfDefined(accountId) {
+        return await this.findByIfExists({
+            type: constants_1.EngineConstants.spec.integrationAuthenticationCredential,
+            [constants_1.EngineConstants.prop.accountOrUser]: accountId
+        });
+    }
+    async findgetOpenApiRuntimeAuthorizationCapabilityIfDefined() {
+        return (await this.findByIfExists({
+            type: constants_1.EngineConstants.spec.capability,
+            [constants_1.EngineConstants.prop.label]: constants_1.OPEN_API_RUNTIME_AUTHORIZATION
+        }));
+    }
+    async findRefreshCapabilityForIntegration(integrationId) {
+        const integration = await this.findByIfExists({ id: integrationId });
+        const configuredRefreshCapability = integration?.[constants_1.EngineConstants.prop.refreshCapability];
+        if (configuredRefreshCapability) {
+            const refreshCapabilityId = (0, rmlmapper_js_1.getIdFromNodeObjectIfDefined)(configuredRefreshCapability);
+            if (!refreshCapabilityId) {
+                throw new Error(`Integration ${integrationId} has an invalid refresh capability reference.`);
+            }
+            const refreshCapability = (await this.findByIfExists({ id: refreshCapabilityId }));
+            if (!refreshCapability) {
+                throw new Error(`Refresh capability ${refreshCapabilityId} configured for integration ${integrationId} was not found.`);
+            }
+            return refreshCapability;
+        }
+        return await this.findCapabilityWithName('getOauthTokens');
+    }
+    async getRuntimeCredentialsWithSecurityCredentials(securityCredentials, integrationId, openApiOperationInformation, operationArgs) {
+        const getOpenApiRuntimeAuthorizationCapability = await this.findgetOpenApiRuntimeAuthorizationCapabilityIfDefined();
+        if (!getOpenApiRuntimeAuthorizationCapability) {
+            return {};
+        }
+        const mapping = await this.findCapabilityIntegrationMapping(getOpenApiRuntimeAuthorizationCapability[constants_1.PROP_ENTITY_ID], integrationId);
+        if (!mapping) {
+            return {};
+        }
+        const args = {
+            securityCredentials,
+            openApiExecutorOperationWithPathInfo: openApiOperationInformation,
+            operationArgs
+        };
+        const operationInfoJsonLd = await this.performParameterMappingOnArgsIfDefined(args, mapping, undefined, true);
+        const headers = (0, Util_1.getValueIfDefined)(operationInfoJsonLd[constants_1.EngineConstants.prop.headers]);
+        return headers ?? {};
+    }
+    async createOpenApiOperationExecutorWithSpec(openApiDescription) {
+        const executor = new openapi_operation_executor_1.OpenApiOperationExecutor();
+        await executor.setOpenapiSpec(openApiDescription);
+        return executor;
+    }
+    async findCapabilityObjectMapping(capabilityId, object) {
+        return (await this.findByIfExists({
+            type: constants_1.EngineConstants.spec.capabilityMapping,
+            [constants_1.EngineConstants.prop.capability]: capabilityId,
+            [constants_1.EngineConstants.prop.object]: (0, InversePath_1.InversePath)({
+                subPath: (0, ZeroOrMorePath_1.ZeroOrMorePath)({ subPath: constants_1.RDFS.subClassOf }),
+                value: object
+            })
+        }));
+    }
+    async performCapabilityMappingWithArgs(args, mapping, capabilityConfig) {
+        if (mapping[constants_1.EngineConstants.prop.operationId]) {
+            return (0, Util_1.getValueIfDefined)(mapping[constants_1.EngineConstants.prop.operationId]);
+        }
+        if (mapping[constants_1.EngineConstants.prop.operationId]) {
+            return (0, Util_1.getValueIfDefined)(mapping[constants_1.EngineConstants.prop.operationId]);
+        }
+        const capabilityInfoJsonLd = await this.performMapping(args, mapping[constants_1.EngineConstants.prop.operationMapping], undefined, capabilityConfig);
+        return (0, Util_1.getValueIfDefined)(capabilityInfoJsonLd[constants_1.EngineConstants.prop.operationId]);
+    }
+    async assertCapabilityParamsMatchParameterSchemas(capabilityParams, capability) {
+        let parametersSchemaObject = capability[constants_1.EngineConstants.prop.inputs];
+        if (parametersSchemaObject?.[constants_1.PROP_ENTITY_ID] && Object.keys(parametersSchemaObject).length === 1) {
+            parametersSchemaObject = await this.findBy({ id: parametersSchemaObject[constants_1.PROP_ENTITY_ID] });
+        }
+        if (capabilityParams && parametersSchemaObject) {
+            const capabilityParamsAsJsonLd = {
+                '@context': (0, Util_1.getValueIfDefined)(capability[constants_1.EngineConstants.prop.inputsContext]),
+                [constants_1.PROP_ENTITY_TYPE]: constants_1.EngineConstants.spec.inputs,
+                ...capabilityParams
+            };
+            const report = await this.convertToQuadsAndValidateAgainstShape(capabilityParamsAsJsonLd, parametersSchemaObject);
+            if (!report.conforms) {
+                this.throwValidationReportError(report, `${(0, Util_1.getValueIfDefined)(capability[constants_1.EngineConstants.prop.label])} parameters do not conform to the schema`);
+            }
+        }
+    }
+    async performOpenapiOperationWithCredentials(operationId, operationArgs, account, capabilityConfig) {
+        const integratedProductId = account[constants_1.EngineConstants.prop.integration][constants_1.PROP_ENTITY_ID];
+        const restAPIInterface = await this.getIntegrationInterface(integratedProductId);
+        if (!restAPIInterface) {
+            throw new Error(`No integration interface found for integrated product ${integratedProductId}`);
+        }
+        const openApiDescription = (0, Util_1.getValueIfDefined)(restAPIInterface[constants_1.EngineConstants.prop.declarativeApiDescription]);
+        const openApiExecutor = await this.createOpenApiOperationExecutorWithSpec(openApiDescription);
+        // eslint-disable-next-line @typescript-eslint/await-thenable
+        const openApiOperationInformation = await openApiExecutor.getOperationWithPathInfoMatchingOperationId(operationId);
+        const securityCredentials = await this.findSecurityCredentialsForAccountIfDefined(account[constants_1.PROP_ENTITY_ID]);
+        let runtimeAuthorization = {};
+        if (securityCredentials) {
+            const generatedRuntimeCredentials = await this.getRuntimeCredentialsWithSecurityCredentials(securityCredentials, integratedProductId, openApiOperationInformation, operationArgs);
+            if (generatedRuntimeCredentials && Object.keys(generatedRuntimeCredentials).length > 0) {
+                runtimeAuthorization = generatedRuntimeCredentials;
+            }
+        }
+        const apiKey = [
+            (0, Util_1.getValueIfDefined)(securityCredentials?.[constants_1.EngineConstants.prop.apiKey]),
+            this.getAuthorizationHeaderFromRuntimeCredentials(runtimeAuthorization)
+        ].find(Boolean);
+        const configuration = {
+            accessToken: (0, Util_1.getValueIfDefined)(securityCredentials?.[constants_1.EngineConstants.prop.accessToken]),
+            bearerToken: (0, Util_1.getValueIfDefined)(securityCredentials?.[constants_1.EngineConstants.prop.bearerToken]),
+            apiKey,
+            basePath: (0, Util_1.getValueIfDefined)(account[constants_1.EngineConstants.prop.overrideBasePath]),
+            username: (0, Util_1.getValueIfDefined)(securityCredentials?.[constants_1.EngineConstants.prop.username]),
+            password: (0, Util_1.getValueIfDefined)(securityCredentials?.[constants_1.EngineConstants.prop.password])
+        };
+        let response;
+        let executeOperationOptions;
+        try {
+            const additionalHeaders = this.getHeadersFromRuntimeCredentials(runtimeAuthorization);
+            if (additionalHeaders &&
+                typeof additionalHeaders === 'object' &&
+                !Array.isArray(additionalHeaders) &&
+                Object.keys(additionalHeaders).length > 0) {
+                executeOperationOptions = { headers: additionalHeaders };
+            }
+            if (this.ifCapabilityStreaming(capabilityConfig)) {
+                executeOperationOptions = {
+                    ...executeOperationOptions,
+                    responseType: 'stream'
+                };
+            }
+            else if (this.ifCapabilityBuffering(capabilityConfig)) {
+                executeOperationOptions = {
+                    ...executeOperationOptions,
+                    responseType: 'arraybuffer'
+                };
+            }
+            if (capabilityConfig?.axiosOptions && typeof capabilityConfig.axiosOptions === 'object' && Object.keys(capabilityConfig.axiosOptions).length > 0) {
+                executeOperationOptions = {
+                    ...executeOperationOptions,
+                    ...capabilityConfig.axiosOptions
+                };
+            }
+            response = await openApiExecutor.executeOperation(operationId, configuration, operationArgs, executeOperationOptions);
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) &&
+                await this.isInvalidTokenError(error, integratedProductId) &&
+                securityCredentials) {
+                const refreshCapabilityConfig = capabilityConfig
+                    ? {
+                        ...capabilityConfig,
+                        stream: false,
+                        buffer: false
+                    }
+                    : undefined;
+                const refreshedConfiguration = await this.refreshSecurityCredentials(securityCredentials, integratedProductId, account, refreshCapabilityConfig);
+                response = await openApiExecutor.executeOperation(operationId, refreshedConfiguration, operationArgs, executeOperationOptions);
+            }
+            else {
+                throw error;
+            }
+        }
+        return response;
+    }
+    getHeadersFromRuntimeCredentials(runtimeCredentials) {
+        let returnValue = {};
+        if (runtimeCredentials.headers &&
+            typeof runtimeCredentials.headers === 'object' &&
+            Object.keys(runtimeCredentials.headers).length > 0 &&
+            !Array.isArray(runtimeCredentials.headers)) {
+            returnValue = runtimeCredentials.headers;
+        }
+        return returnValue;
+    }
+    getAuthorizationHeaderFromRuntimeCredentials(runtimeCredentials) {
+        const headers = this.getHeadersFromRuntimeCredentials(runtimeCredentials);
+        if (headers && 'Authorization' in headers) {
+            const authorizationHeader = headers.Authorization;
+            if (typeof authorizationHeader === 'string') {
+                return authorizationHeader;
+            }
+        }
+        return undefined;
+    }
+    async isInvalidTokenError(error, integratedProductId) {
+        const integrationInterface = await this.getIntegrationInterface(integratedProductId);
+        if (!integrationInterface) {
+            return false;
+        }
+        const errorMatcher = integrationInterface[constants_1.EngineConstants.prop.invalidTokenErrorMatcher];
+        const errorMatcherStatus = errorMatcher && (0, Util_1.getValueIfDefined)(errorMatcher[constants_1.EngineConstants.prop.invalidTokenErrorMatcherStatus]);
+        const errorMatcherRegex = errorMatcher &&
+            (0, Util_1.getValueIfDefined)(errorMatcher[constants_1.EngineConstants.prop.invalidTokenErrorMatcherMessageRegex]);
+        if (errorMatcher && error.response?.status === errorMatcherStatus) {
+            if (!errorMatcherRegex) {
+                return true;
+            }
+            if (error.response?.statusText && new RegExp(errorMatcherRegex, 'u').test(error.response?.statusText)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async refreshSecurityCredentials(securityCredentials, integrationId, account, capabilityConfig) {
+        const refreshCapability = await this.findRefreshCapabilityForIntegration(integrationId);
+        const mapping = await this.findCapabilityIntegrationMapping(refreshCapability[constants_1.PROP_ENTITY_ID], integrationId);
+        if (!mapping) {
+            throw new Error(`No mapping found for capability ${refreshCapability[constants_1.PROP_ENTITY_ID]} and integration ${integrationId}`);
+        }
+        const args = {
+            refreshToken: (0, Util_1.getValueIfDefined)(securityCredentials[constants_1.EngineConstants.prop.refreshToken]),
+            jwtBearerOptions: (0, Util_1.getValueIfDefined)(securityCredentials[constants_1.EngineConstants.prop.jwtBearerOptions]),
+            securityCredentials: securityCredentials,
+            account: account,
+            integrationId
+        };
+        const operationArgs = await this.performParameterMappingOnArgsIfDefined(args, mapping, capabilityConfig, true);
+        const operationInfoJsonLd = await this.performOperationMappingWithArgs({}, mapping, capabilityConfig);
+        const rawReturnValue = await this.performOperation(operationInfoJsonLd, operationArgs, args, account, capabilityConfig, securityCredentials);
+        const mappedReturnValue = await this.performReturnValueMappingWithFrameIfDefined(rawReturnValue, mapping, capabilityConfig);
+        await this.assertCapabilityReturnValueMatchesReturnTypeSchema(mappedReturnValue, refreshCapability);
+        const bearerToken = (0, Util_1.getValueIfDefined)(mappedReturnValue[constants_1.EngineConstants.prop.bearerToken]);
+        const accessToken = (0, Util_1.getValueIfDefined)(mappedReturnValue[constants_1.EngineConstants.prop.accessToken]);
+        const refreshToken = (0, Util_1.getValueIfDefined)(mappedReturnValue[constants_1.EngineConstants.prop.refreshToken]);
+        if (bearerToken) {
+            securityCredentials[constants_1.EngineConstants.prop.bearerToken] = bearerToken;
+        }
+        if (accessToken) {
+            securityCredentials[constants_1.EngineConstants.prop.accessToken] = accessToken;
+        }
+        if (refreshToken) {
+            securityCredentials[constants_1.EngineConstants.prop.refreshToken] = refreshToken;
+        }
+        await this.save(securityCredentials);
+        return { accessToken, bearerToken };
+    }
+    getOauthConfigurationFromSecurityCredentials(securityCredentialsSchema) {
+        const username = (0, Util_1.getValueIfDefined)(securityCredentialsSchema[constants_1.EngineConstants.prop.username]);
+        const password = (0, Util_1.getValueIfDefined)(securityCredentialsSchema[constants_1.EngineConstants.prop.password]);
+        const accessToken = (0, Util_1.getValueIfDefined)(securityCredentialsSchema[constants_1.EngineConstants.prop.accessToken]);
+        return { username, password, accessToken };
+    }
+    async assertCapabilityReturnValueMatchesReturnTypeSchema(returnValue, capability) {
+        let returnTypeSchemaObject = capability[constants_1.EngineConstants.prop.outputs];
+        if (returnTypeSchemaObject?.[constants_1.PROP_ENTITY_ID] && Object.keys(returnTypeSchemaObject).length === 1) {
+            returnTypeSchemaObject = await this.findBy({ id: returnTypeSchemaObject[constants_1.PROP_ENTITY_ID] });
+        }
+        let report;
+        if (returnValue && returnTypeSchemaObject) {
+            if (Array.isArray(returnValue)) {
+                if (returnValue.some((valueItem) => constants_1.PROP_ENTITY_ID in valueItem)) {
+                    returnTypeSchemaObject[constants_1.SHACL.targetNode] = returnValue.reduce((nodes, outputItem) => {
+                        if (outputItem[constants_1.PROP_ENTITY_ID]) {
+                            nodes.push({ [constants_1.PROP_ENTITY_ID]: outputItem[constants_1.PROP_ENTITY_ID] });
+                        }
+                        return nodes;
+                    }, []);
+                }
+                else {
+                    const targetClasses = returnValue.reduce((nodes, outputItem) => {
+                        if (outputItem[constants_1.PROP_ENTITY_TYPE]) {
+                            const type = Array.isArray(outputItem[constants_1.PROP_ENTITY_TYPE])
+                                ? outputItem[constants_1.PROP_ENTITY_TYPE][0]
+                                : outputItem[constants_1.PROP_ENTITY_TYPE];
+                            if (!nodes.includes({ [constants_1.PROP_ENTITY_ID]: type })) {
+                                nodes.push({ [constants_1.PROP_ENTITY_ID]: type });
+                            }
+                        }
+                        return nodes;
+                    }, []);
+                    if (targetClasses.length > 0) {
+                        returnTypeSchemaObject[constants_1.SHACL.targetClass] = targetClasses;
+                    }
+                }
+                report = await this.convertToQuadsAndValidateAgainstShape(returnValue, returnTypeSchemaObject);
+            }
+            else if (Object.keys(returnValue).length > 0) {
+                if (returnValue[constants_1.PROP_ENTITY_ID]) {
+                    returnTypeSchemaObject[constants_1.SHACL.targetNode] = { [constants_1.PROP_ENTITY_ID]: returnValue[constants_1.PROP_ENTITY_ID] };
+                }
+                else if (returnValue[constants_1.PROP_ENTITY_TYPE]) {
+                    returnTypeSchemaObject[constants_1.SHACL.targetClass] = {
+                        [constants_1.PROP_ENTITY_ID]: Array.isArray(returnValue[constants_1.PROP_ENTITY_TYPE])
+                            ? returnValue[constants_1.PROP_ENTITY_TYPE][0]
+                            : returnValue[constants_1.PROP_ENTITY_TYPE]
+                    };
+                }
+                report = await this.convertToQuadsAndValidateAgainstShape(returnValue, returnTypeSchemaObject);
+            }
+        }
+        if (report && !report?.conforms) {
+            throw new Error(`Return value ${Array.isArray(returnValue) ? 'array' : returnValue[constants_1.PROP_ENTITY_ID]} does not conform to the schema`);
+        }
+    }
+    async convertToQuadsAndValidateAgainstShape(value, shape) {
+        const valueAsQuads = await (0, Util_1.convertJsonLdToQuads)(Array.isArray(value) ? value : [value]);
+        const shapeQuads = await (0, Util_1.convertJsonLdToQuads)(shape);
+        const validator = new rdf_validate_shacl_1.default(shapeQuads);
+        return validator.validate(valueAsQuads);
+    }
+    async performOauthSecuritySchemeStageWithCredentials(operationInfo, operationParameters, account, securityCredentials) {
+        const integratedProductId = account[constants_1.EngineConstants.prop.integration][constants_1.PROP_ENTITY_ID];
+        const restAPIInterface = await this.getIntegrationInterface(integratedProductId);
+        if (!restAPIInterface) {
+            throw new Error(`No integration interface found for integrated product ${integratedProductId}`);
+        }
+        const openApiDescription = (0, Util_1.getValueIfDefined)(restAPIInterface[constants_1.EngineConstants.prop.declarativeApiDescription]);
+        securityCredentials || (securityCredentials = await this.findSecurityCredentialsForAccountIfDefined(account[constants_1.PROP_ENTITY_ID]));
+        let configuration;
+        if (securityCredentials) {
+            configuration = this.getOauthConfigurationFromSecurityCredentials(securityCredentials);
+            operationParameters.client_id = (0, Util_1.getValueIfDefined)(securityCredentials[constants_1.EngineConstants.prop.username]);
+        }
+        else {
+            configuration = {};
+        }
+        const openApiExecutor = await this.createOpenApiOperationExecutorWithSpec(openApiDescription);
+        const response = await openApiExecutor.executeSecuritySchemeStage((0, Util_1.getValueIfDefined)(operationInfo[constants_1.EngineConstants.prop.schemeName]), (0, Util_1.getValueIfDefined)(operationInfo[constants_1.EngineConstants.prop.oauthFlow]), (0, Util_1.getValueIfDefined)(operationInfo[constants_1.EngineConstants.prop.stage]), configuration, operationParameters);
+        if ('codeVerifier' in response && 'authorizationUrl' in response) {
+            return {
+                data: response,
+                operationParameters
+            };
+        }
+        return this.axiosResponseAndParamsToOperationResponse(response, operationParameters, operationParameters);
+    }
+    async getDataFromDataSource(dataSourceId, capabilityConfig) {
+        const dataSource = await this.findBy({ id: dataSourceId });
+        if (dataSource[constants_1.PROP_ENTITY_TYPE] === constants_1.EngineConstants.spec.jsonDataSource) {
+            const data = this.getDataFromJsonDataSource(dataSource, capabilityConfig);
+            return { data, operationParameters: {} };
+        }
+        throw new Error(`DataSource type ${dataSource[constants_1.PROP_ENTITY_TYPE]} is not supported.`);
+    }
+    getDataFromJsonDataSource(dataSource, capabilityConfig) {
+        if (dataSource[constants_1.EngineConstants.prop.source]) {
+            const sourceValue = (0, Util_1.getValueIfDefined)(dataSource[constants_1.EngineConstants.prop.source]);
+            return this.getJsonDataFromSource(sourceValue, capabilityConfig);
+        }
+        return (0, Util_1.getValueIfDefined)(dataSource[constants_1.EngineConstants.prop.data]);
+    }
+    getJsonDataFromSource(source, capabilityConfig) {
+        const inputFiles = {
+            ...this.inputFiles,
+            ...capabilityConfig?.inputFiles
+        };
+        if (source in inputFiles) {
+            const file = inputFiles[source];
+            if (typeof file === 'string') {
+                return JSON.parse(file);
+            }
+            return file;
+        }
+        // eslint-disable-next-line unicorn/expiring-todo-comments
+        // TODO add support for remote sources
+        throw new Error(`Failed to get data from source ${source}`);
+    }
+    throwValidationReportError(report, errorMessage) {
+        const reportMessages = this.validationReportToMessages(report);
+        throw new Error(`${errorMessage}\n\n${reportMessages.join('\n')}`);
+    }
+    validationReportToMessages(report) {
+        const reportMessages = [];
+        for (const result of report.results) {
+            const pathValue = result.path?.value;
+            if (result.message.length === 0) {
+                const message = `${pathValue}: Invalid due to ${result.sourceConstraintComponent?.value}`;
+                reportMessages.push(message);
+            }
+            else {
+                const resultMessages = result.message.map((message) => `${message.value}`).join(', ');
+                const message = `${pathValue}: ${resultMessages}`;
+                reportMessages.push(message);
+            }
+        }
+        return reportMessages;
+    }
+    ifCapabilityStreaming(capabilityConfig) {
+        return Boolean(capabilityConfig && 'stream' in capabilityConfig && capabilityConfig.stream);
+    }
+    ifCapabilityBuffering(capabilityConfig) {
+        return Boolean(capabilityConfig && 'buffer' in capabilityConfig && capabilityConfig.buffer);
+    }
+    isJavaScriptCode(text) {
+        if (!text) {
+            return false;
+        }
+        // Trim the text to handle leading/trailing whitespace
+        const trimmed = text.trim();
+        // First, quickly check if it looks like JSON (starts with { or [)
+        const looksLikeJson = /^\s*[[{]/.test(trimmed) && /[\]}]\s*$/.test(trimmed);
+        if (looksLikeJson) {
+            try {
+                // If it can be parsed as JSON, it's likely an RML mapping
+                JSON.parse(trimmed);
+                return false;
+            }
+            catch {
+                // If it looks like JSON but can't be parsed, it might be code
+                // Continue with other checks
+            }
+        }
+        // Check for common JavaScript patterns that wouldn't appear in JSON
+        const jsPatterns = [
+            /function\s+[$A-Z_a-z][\w$]*\s*\(/,
+            /const\s+[$A-Z_a-z][\w$]*/,
+            /let\s+[$A-Z_a-z][\w$]*/,
+            /var\s+[$A-Z_a-z][\w$]*/,
+            /if\s*\(/,
+            /for\s*\(/,
+            /while\s*\(/,
+            /=>|return |console\./,
+            /import\s+|export\s+/,
+            /class\s+[$A-Z_a-z][\w$]*/,
+            /\/\/|\/\*|\*\// // Comments
+        ];
+        // If it matches any JS pattern, it's likely code
+        return jsPatterns.some(pattern => pattern.test(trimmed));
+    }
+    ensureNodeObject(result) {
+        // Handle null/undefined results
+        if (result === null || result === undefined) {
+            return {};
+        }
+        // If it's already a NodeObject with proper formatting, return as is
+        if (typeof result === 'object' &&
+            !Array.isArray(result) &&
+            (result[constants_1.PROP_ENTITY_ID] !== undefined ||
+                result[constants_1.PROP_ENTITY_TYPE] !== undefined ||
+                result['@context'] !== undefined ||
+                result['@graph'] !== undefined)) {
+            return result;
+        }
+        // Handle arrays - convert to @graph
+        if (Array.isArray(result)) {
+            // Check if items in array are already objects
+            const convertedItems = result.map(item => {
+                if (typeof item === 'object' && item !== null) {
+                    // Already object, but ensure it has @type if not present
+                    if (!item[constants_1.PROP_ENTITY_TYPE] && !item[constants_1.PROP_ENTITY_ID] && !item[constants_1.PROP_ENTITY_VALUE]) {
+                        return { [constants_1.PROP_ENTITY_TYPE]: 'skl:Result', ...item };
+                    }
+                    return item;
+                }
+                // Convert primitives to objects with @value
+                return { [constants_1.PROP_ENTITY_VALUE]: item };
+            });
+            return {
+                '@context': {
+                    skl: Vocabularies_1.SKL_NAMESPACE
+                },
+                '@graph': convertedItems
+            };
+        }
+        // Handle primitive values (string, number, boolean)
+        if (typeof result !== 'object') {
+            return {
+                [constants_1.PROP_ENTITY_VALUE]: result
+            };
+        }
+        // Handle plain objects (not arrays, not null)
+        // If it's a plain object but not in NodeObject format, add @type
+        return {
+            [constants_1.PROP_ENTITY_TYPE]: 'skl:Result',
+            '@context': {
+                skl: Vocabularies_1.SKL_NAMESPACE
+            },
+            ...result
+        };
+    }
+    async executeCodeBlocks(codeBlocks, args, executionOptions) {
+        const results = [];
+        let updatedArgs = args || {};
+        for (const codeBlock of codeBlocks) {
+            const code = (0, Util_1.getValueIfDefined)(codeBlock[constants_1.EngineConstants.prop.codeBody]);
+            if (code) {
+                const result = await this.executeJavaScriptMapping(updatedArgs, code, executionOptions);
+                updatedArgs = {
+                    ...updatedArgs,
+                    ...result
+                };
+                results.push(result);
+            }
+        }
+        return results.length > 0 ? results[results.length - 1] : {};
+    }
+    async executeJavaScriptMapping(args, code, _executionOptions) {
+        try {
+            // Configure execution options
+            const executionOptions = {
+                timeout: 60 * 60 * 1000,
+                functionName: 'main',
+                allowNetwork: true,
+                allowedDomains: [],
+                allowEnv: true,
+                debugMode: true,
+                allowRead: true,
+                ..._executionOptions
+            };
+            if (!this.codeExecutor) {
+                throw new Error('Code executor not set. Please set a code executor using setCodeExecutor()');
+            }
+            // Execute the code
+            const executionResult = await this.codeExecutor.execute(code, args, executionOptions);
+            // Handle execution errors
+            if (executionResult?.error) {
+                throw new Error(`Code execution error: ${executionResult.error?.message ?? 'Unknown error'}`);
+            }
+            // This is a patch to return the output as it is without converting to NodeObject
+            // This is needed for some api inputs.  We can try doing this using the frame.
+            if (executionResult?.result?.rawOutput) {
+                return executionResult?.result?.rawOutput;
+            }
+            // Convert the result to a NodeObject
+            return this.ensureNodeObject(executionResult?.result ?? executionResult);
+        }
+        catch (error) {
+            throw new Error(`Failed to execute JavaScript mapping: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Expose global hooks to users
+    // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
+    get hooks() {
+        return globalHooks_1.globalHooks;
+    }
+    async prepareContextForType(typeSpecOrId) {
+        const typeSpecs = [];
+        if (typeof typeSpecOrId === 'string') {
+            typeSpecs.push(await this.getSuperClassesOfObject(typeSpecOrId), await this.findBy({ id: typeSpecOrId }));
+        }
+        else {
+            typeSpecs.push(typeSpecOrId);
+        }
+        const context = {};
+        for (const typeSpec of typeSpecs) {
+            const properties = typeSpec[constants_1.SHACL.property] ?? [];
+            for (const property of (0, Util_1.ensureArray)(properties)) {
+                const dataType = property[constants_1.SHACL.datatype]?.['@id'];
+                const nodeKind = property[constants_1.SHACL.nodeKind]?.['@id'];
+                const path = property[constants_1.SHACL.path]?.['@id'];
+                if (nodeKind === constants_1.SHACL.IRI) {
+                    context[path] = {
+                        '@type': '@id'
+                    };
+                }
+                else {
+                    context[path] = {
+                        '@type': dataType
+                    };
+                }
+            }
+        }
+        return context;
+    }
+}
+exports.SKLEngine = SKLEngine;
+//# sourceMappingURL=SklEngine.js.map