@fsai-flow/core 0.0.4 → 0.1.0

package/dist/{src/lib → lib}/NodesLoader/constants.d.ts

@@ -1,4 +1,4 @@
-import type { INodeProperties } from '@fsai-flow/workflow';
+import type { INodeProperties } from "@fsai-flow/workflow";
 export declare const CUSTOM_NODES_CATEGORY = "Custom Nodes";
 export declare const commonPollingParameters: INodeProperties[];
 export declare const commonCORSParameters: INodeProperties[];

package/dist/lib/NodesLoader/constants.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonDeclarativeNodeOptionParameters = exports.commonCORSParameters = exports.commonPollingParameters = exports.CUSTOM_NODES_CATEGORY = void 0;
+const workflow_1 = require("@fsai-flow/workflow");
+exports.CUSTOM_NODES_CATEGORY = "Custom Nodes";
+exports.commonPollingParameters = [
+    {
+        displayName: "Poll Times",
+        name: "pollTimes",
+        type: "fixedCollection",
+        typeOptions: {
+            multipleValues: true,
+            multipleValueButtonText: "Add Poll Time",
+        },
+        default: { item: [{ mode: "everyMinute" }] },
+        description: "Time at which polling should occur",
+        placeholder: "Add Poll Time",
+        options: workflow_1.cronNodeOptions,
+    },
+];
+exports.commonCORSParameters = [
+    {
+        displayName: "Allowed Origins (CORS)",
+        name: "allowedOrigins",
+        type: "string",
+        default: "*",
+        description: "Comma-separated list of URLs allowed for cross-origin non-preflight requests. Use * (default) to allow all origins.",
+    },
+];
+exports.commonDeclarativeNodeOptionParameters = {
+    displayName: "Request Options",
+    name: "requestOptions",
+    type: "collection",
+    isNodeSetting: true,
+    placeholder: "Add Option",
+    default: {},
+    options: [
+        {
+            displayName: "Batching",
+            name: "batching",
+            placeholder: "Add Batching",
+            type: "fixedCollection",
+            typeOptions: {
+                multipleValues: false,
+            },
+            default: {
+                batch: {},
+            },
+            options: [
+                {
+                    displayName: "Batching",
+                    name: "batch",
+                    values: [
+                        {
+                            displayName: "Items per Batch",
+                            name: "batchSize",
+                            type: "number",
+                            typeOptions: {
+                                minValue: -1,
+                            },
+                            default: 50,
+                            description: "Input will be split in batches to throttle requests. -1 for disabled. 0 will be treated as 1.",
+                        },
+                        {
+                            displayName: "Batch Interval (ms)",
+                            name: "batchInterval",
+                            type: "number",
+                            typeOptions: {
+                                minValue: 0,
+                            },
+                            default: 1000,
+                            description: "Time (in milliseconds) between each batch of requests. 0 for disabled.",
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            displayName: "Ignore SSL Issues (Insecure)",
+            name: "allowUnauthorizedCerts",
+            type: "boolean",
+            noDataExpression: true,
+            default: false,
+            description: "Whether to accept the response even if SSL certificate validation is not possible",
+        },
+        {
+            displayName: "Proxy",
+            name: "proxy",
+            type: "string",
+            default: "",
+            placeholder: "e.g. http://myproxy:3128",
+            description: "HTTP proxy to use. If authentication is required it can be defined as follow: http://username:password@myproxy:3128",
+        },
+        {
+            displayName: "Timeout",
+            name: "timeout",
+            type: "number",
+            typeOptions: {
+                minValue: 1,
+            },
+            default: 10000,
+            description: "Time in ms to wait for the server to send response headers (and start the response body) before aborting the request",
+        },
+    ],
+};

package/dist/{src/lib → lib}/NodesLoader/custom-directory-loader.d.ts

@@ -1,4 +1,4 @@
-import { DirectoryLoader } from './directory-loader';
+import { DirectoryLoader } from "./directory-loader";
 /**
  * Loader for source files of nodes and credentials located in a custom dir,
  * e.g. `~/.n8n/custom`

package/dist/lib/NodesLoader/custom-directory-loader.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomDirectoryLoader = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const directory_loader_1 = require("./directory-loader");
+/**
+ * Loader for source files of nodes and credentials located in a custom dir,
+ * e.g. `~/.n8n/custom`
+ */
+class CustomDirectoryLoader extends directory_loader_1.DirectoryLoader {
+    constructor() {
+        super(...arguments);
+        this.packageName = "CUSTOM";
+    }
+    async loadAll() {
+        const nodes = await (0, fast_glob_1.default)("**/*.node.js", {
+            cwd: this.directory,
+            absolute: true,
+        });
+        for (const nodePath of nodes) {
+            this.loadNodeFromFile(nodePath);
+        }
+        const credentials = await (0, fast_glob_1.default)("**/*.credentials.js", {
+            cwd: this.directory,
+            absolute: true,
+        });
+        for (const credentialPath of credentials) {
+            this.loadCredentialFromFile(credentialPath);
+        }
+    }
+}
+exports.CustomDirectoryLoader = CustomDirectoryLoader;

package/dist/{src/lib → lib}/NodesLoader/directory-loader.d.ts

@@ -1,4 +1,4 @@
-import type { ICredentialType, ICredentialTypeData, INodeCredentialDescription, INodeType, INodeTypeBaseDescription, INodeTypeData, INodeTypeNameVersion, IVersionedNodeType, KnownNodesAndCredentials } from '@fsai-flow/workflow';
+import type { ICredentialType, ICredentialTypeData, INodeCredentialDescription, INodeType, INodeTypeBaseDescription, INodeTypeData, INodeTypeNameVersion, IVersionedNodeType, KnownNodesAndCredentials } from "@fsai-flow/workflow";
 export type Types = {
     nodes: INodeTypeBaseDescription[];
     credentials: ICredentialType[];

package/dist/{src/lib → lib}/NodesLoader/directory-loader.js

@@ -1,14 +1,52 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectoryLoader = void 0;
-const tslib_1 = require("tslib");
-const uniqBy_1 = tslib_1.__importDefault(require("lodash/uniqBy"));
+const path = __importStar(require("node:path"));
 const workflow_1 = require("@fsai-flow/workflow");
-const path = tslib_1.__importStar(require("path"));
+const uniqBy_1 = __importDefault(require("lodash/uniqBy"));
 const constants_1 = require("./constants");
 const load_class_in_isolation_1 = require("./load-class-in-isolation");
 function toJSON() {
-    return Object.assign(Object.assign({}, this), { authenticate: typeof this.authenticate === 'function' ? {} : this.authenticate });
+    return {
+        ...this,
+        authenticate: typeof this.authenticate === "function" ? {} : this.authenticate,
+    };
 }
 /**
  * Base class for loading n8n nodes and credentials from a directory.
@@ -45,13 +83,13 @@ class DirectoryLoader {
     }
     loadClass(sourcePath) {
         const filePath = this.resolvePath(sourcePath);
-        const [className] = path.parse(sourcePath).name.split('.');
+        const [className] = path.parse(sourcePath).name.split(".");
         try {
             return (0, load_class_in_isolation_1.loadClassInIsolation)(filePath, className);
         }
         catch (error) {
             throw error instanceof TypeError
-                ? new Error('Class could not be found. Please check if the class is named correctly.')
+                ? new Error("Class could not be found. Please check if the class is named correctly.")
                 : error;
         }
     }
@@ -68,7 +106,7 @@ class DirectoryLoader {
         }
         this.fixIconPaths(tempNode.description, filePath);
         let nodeVersion = 1;
-        if ('nodeVersions' in tempNode) {
+        if ("nodeVersions" in tempNode) {
             for (const versionNode of Object.values(tempNode.nodeVersions)) {
                 this.fixIconPaths(versionNode.description, filePath);
             }
@@ -79,7 +117,7 @@ class DirectoryLoader {
             const currentVersionNode = tempNode.nodeVersions[tempNode.currentVersion];
             this.addCodex(currentVersionNode, filePath);
             nodeVersion = tempNode.currentVersion;
-            if (currentVersionNode.hasOwnProperty('executeSingle')) {
+            if (Object.hasOwn(currentVersionNode, "executeSingle")) {
                 throw new Error('"executeSingle" has been removed. Please update the code of this node to use "execute" instead.');
             }
         }
@@ -103,9 +141,9 @@ class DirectoryLoader {
             name: nodeType,
             version: nodeVersion,
         });
-        this.getVersionedNodeTypeAll(tempNode).forEach(({ description }) => {
+        for (const { description } of this.getVersionedNodeTypeAll(tempNode)) {
             this.types.nodes.push(description);
-        });
+        }
         for (const credential of this.getCredentialsForNode(tempNode)) {
             if (!this.nodesByCredential[credential.name]) {
                 this.nodesByCredential[credential.name] = [];
@@ -163,12 +201,11 @@ class DirectoryLoader {
      * For versioned nodes, combines and deduplicates credentials from all versions.
      */
     getCredentialsForNode(object) {
-        var _a;
-        if ('nodeVersions' in object) {
-            const credentials = Object.values(object.nodeVersions).flatMap(({ description }) => { var _a; return (_a = description.credentials) !== null && _a !== void 0 ? _a : []; });
-            return (0, uniqBy_1.default)(credentials, 'name');
+        if ("nodeVersions" in object) {
+            const credentials = Object.values(object.nodeVersions).flatMap(({ description }) => description.credentials ?? []);
+            return (0, uniqBy_1.default)(credentials, "name");
         }
-        return (_a = object.description.credentials) !== null && _a !== void 0 ? _a : [];
+        return object.description.credentials ?? [];
     }
     /**
      * Returns an array of all versions of a node type.
@@ -176,7 +213,7 @@ class DirectoryLoader {
      * For versioned nodes, returns all available versions.
      */
     getVersionedNodeTypeAll(object) {
-        if ('nodeVersions' in object) {
+        if ("nodeVersions" in object) {
             const nodeVersions = Object.values(object.nodeVersions).map((element) => {
                 element.description.name = object.description.name;
                 element.description.codex = object.description.codex;
@@ -184,7 +221,7 @@ class DirectoryLoader {
             });
             return (0, uniqBy_1.default)(nodeVersions.reverse(), (node) => {
                 const { version } = node.description;
-                return Array.isArray(version) ? version.join(',') : version.toString();
+                return Array.isArray(version) ? version.join(",") : version.toString();
             });
         }
         return [object];
@@ -196,17 +233,22 @@ class DirectoryLoader {
     getCodex(filePath) {
         const codexFilePath = this.resolvePath(`${filePath}on`); // .js to .json
         const { categories, subcategories, resources: { primaryDocumentation, credentialDocumentation }, alias, } = module.require(codexFilePath);
-        return Object.assign(Object.assign(Object.assign(Object.assign({}, (categories && { categories })), (subcategories && { subcategories })), (alias && { alias })), { resources: {
+        return {
+            ...(categories && { categories }),
+            ...(subcategories && { subcategories }),
+            ...(alias && { alias }),
+            resources: {
                 primaryDocumentation,
                 credentialDocumentation,
-            } });
+            },
+        };
     }
     /**
      * Adds a node codex `categories` and `subcategories` (if defined)
      * to a node description `codex` property.
      */
     addCodex(node, filePath) {
-        const isCustom = this.packageName === 'CUSTOM';
+        const isCustom = this.packageName === "CUSTOM";
         try {
             let codex;
             if (!isCustom) {
@@ -222,7 +264,7 @@ class DirectoryLoader {
             }
             node.description.codex = codex;
         }
-        catch (_a) {
+        catch {
             console.debug(`No codex available for: ${node.description.name}`);
             if (isCustom) {
                 node.description.codex = {
@@ -232,8 +274,7 @@ class DirectoryLoader {
         }
     }
     addLoadOptionsMethods(node) {
-        var _a;
-        if ((_a = node === null || node === void 0 ? void 0 : node.methods) === null || _a === void 0 ? void 0 : _a.loadOptions) {
+        if (node?.methods?.loadOptions) {
             node.description.__loadOptionsMethods = Object.keys(node.methods.loadOptions);
         }
     }
@@ -243,7 +284,7 @@ class DirectoryLoader {
             properties.unshift(...constants_1.commonPollingParameters);
         }
         if (nodeType.webhook && supportsCORS) {
-            const optionsProperty = properties.find(({ name }) => name === 'options');
+            const optionsProperty = properties.find(({ name }) => name === "options");
             if (optionsProperty)
                 optionsProperty.options = [
                     ...constants_1.commonCORSParameters,
@@ -255,21 +296,21 @@ class DirectoryLoader {
         DirectoryLoader.applyDeclarativeNodeOptionParameters(nodeType);
     }
     getIconPath(icon, filePath) {
-        const iconPath = path.join(path.dirname(filePath), icon.replace('file:', ''));
+        const iconPath = path.join(path.dirname(filePath), icon.replace("file:", ""));
         return `icons/${this.packageName}/${iconPath}`;
     }
     fixIconPaths(obj, filePath) {
         const { icon } = obj;
         if (!icon)
             return;
-        if (typeof icon === 'string') {
-            if (icon.startsWith('file:')) {
+        if (typeof icon === "string") {
+            if (icon.startsWith("file:")) {
                 obj.iconUrl = this.getIconPath(icon, filePath);
                 obj.icon = undefined;
             }
         }
-        else if (icon.light.startsWith('file:') &&
-            icon.dark.startsWith('file:')) {
+        else if (icon.light.startsWith("file:") &&
+            icon.dark.startsWith("file:")) {
             obj.iconUrl = {
                 light: this.getIconPath(icon.light, filePath),
                 dark: this.getIconPath(icon.dark, filePath),
@@ -279,7 +320,6 @@ class DirectoryLoader {
     }
     /** Augments additional `Request Options` property on declarative node-type */
     static applyDeclarativeNodeOptionParameters(nodeType) {
-        var _a, _b, _c, _d;
         if (!!nodeType.execute ||
             !!nodeType.trigger ||
             !!nodeType.webhook ||
@@ -294,16 +334,19 @@ class DirectoryLoader {
         // Was originally under "options" instead of "requestOptions" so the chance
         // that that existed was quite high. With this name the chance is actually
         // very low that it already exists but lets leave it in anyway to be sure.
-        const existingRequestOptionsIndex = parameters.findIndex((parameter) => parameter.name === 'requestOptions');
+        const existingRequestOptionsIndex = parameters.findIndex((parameter) => parameter.name === "requestOptions");
         if (existingRequestOptionsIndex !== -1) {
-            parameters[existingRequestOptionsIndex] = Object.assign(Object.assign({}, constants_1.commonDeclarativeNodeOptionParameters), { options: [
-                    ...((_a = constants_1.commonDeclarativeNodeOptionParameters.options) !== null && _a !== void 0 ? _a : []),
-                    ...((_c = (_b = parameters[existingRequestOptionsIndex]) === null || _b === void 0 ? void 0 : _b.options) !== null && _c !== void 0 ? _c : []),
-                ] });
-            const options = (_d = parameters[existingRequestOptionsIndex]) === null || _d === void 0 ? void 0 : _d.options;
+            parameters[existingRequestOptionsIndex] = {
+                ...constants_1.commonDeclarativeNodeOptionParameters,
+                options: [
+                    ...(constants_1.commonDeclarativeNodeOptionParameters.options ?? []),
+                    ...(parameters[existingRequestOptionsIndex]?.options ?? []),
+                ],
+            };
+            const options = parameters[existingRequestOptionsIndex]?.options;
             if (options) {
                 options.sort((a, b) => {
-                    if ('displayName' in a && 'displayName' in b) {
+                    if ("displayName" in a && "displayName" in b) {
                         if (a.displayName < b.displayName) {
                             return -1;
                         }
@@ -322,4 +365,3 @@ class DirectoryLoader {
     }
 }
 exports.DirectoryLoader = DirectoryLoader;
-//# sourceMappingURL=directory-loader.js.map

package/dist/lib/NodesLoader/index.d.ts

@@ -0,0 +1,5 @@
+export { CustomDirectoryLoader } from "./custom-directory-loader";
+export { DirectoryLoader, type Types } from "./directory-loader";
+export { LazyPackageDirectoryLoader } from "./lazy-package-directory-loader";
+export { PackageDirectoryLoader } from "./package-directory-loader";
+export type { n8n } from "./types";

package/dist/{src/lib → lib}/NodesLoader/index.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LazyPackageDirectoryLoader = exports.PackageDirectoryLoader = exports.CustomDirectoryLoader = exports.DirectoryLoader = void 0;
-var directory_loader_1 = require("./directory-loader");
-Object.defineProperty(exports, "DirectoryLoader", { enumerable: true, get: function () { return directory_loader_1.DirectoryLoader; } });
+exports.PackageDirectoryLoader = exports.LazyPackageDirectoryLoader = exports.DirectoryLoader = exports.CustomDirectoryLoader = void 0;
 var custom_directory_loader_1 = require("./custom-directory-loader");
 Object.defineProperty(exports, "CustomDirectoryLoader", { enumerable: true, get: function () { return custom_directory_loader_1.CustomDirectoryLoader; } });
-var package_directory_loader_1 = require("./package-directory-loader");
-Object.defineProperty(exports, "PackageDirectoryLoader", { enumerable: true, get: function () { return package_directory_loader_1.PackageDirectoryLoader; } });
+var directory_loader_1 = require("./directory-loader");
+Object.defineProperty(exports, "DirectoryLoader", { enumerable: true, get: function () { return directory_loader_1.DirectoryLoader; } });
 var lazy_package_directory_loader_1 = require("./lazy-package-directory-loader");
 Object.defineProperty(exports, "LazyPackageDirectoryLoader", { enumerable: true, get: function () { return lazy_package_directory_loader_1.LazyPackageDirectoryLoader; } });
-//# sourceMappingURL=index.js.map
+var package_directory_loader_1 = require("./package-directory-loader");
+Object.defineProperty(exports, "PackageDirectoryLoader", { enumerable: true, get: function () { return package_directory_loader_1.PackageDirectoryLoader; } });

package/dist/{src/lib → lib}/NodesLoader/lazy-package-directory-loader.d.ts

@@ -1,4 +1,4 @@
-import { PackageDirectoryLoader } from './package-directory-loader';
+import { PackageDirectoryLoader } from "./package-directory-loader";
 /**
  * This loader extends PackageDirectoryLoader to load node and credentials lazily, if possible
  */

package/dist/lib/NodesLoader/lazy-package-directory-loader.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyPackageDirectoryLoader = void 0;
+const package_directory_loader_1 = require("./package-directory-loader");
+/**
+ * This loader extends PackageDirectoryLoader to load node and credentials lazily, if possible
+ */
+class LazyPackageDirectoryLoader extends package_directory_loader_1.PackageDirectoryLoader {
+    async loadAll() {
+        try {
+            this.known.nodes = await this.readJSON("dist/known/nodes.json");
+            this.known.credentials = await this.readJSON("dist/known/credentials.json");
+            this.types.nodes = await this.readJSON("dist/types/nodes.json");
+            this.types.credentials = await this.readJSON("dist/types/credentials.json");
+            if (this.includeNodes.length) {
+                const allowedNodes = {};
+                for (const nodeType of this.includeNodes) {
+                    if (nodeType in this.known.nodes) {
+                        allowedNodes[nodeType] = this.known.nodes[nodeType];
+                    }
+                }
+                this.known.nodes = allowedNodes;
+                this.types.nodes = this.types.nodes.filter((nodeType) => this.includeNodes.includes(nodeType.name));
+            }
+            if (this.excludeNodes.length) {
+                for (const nodeType of this.excludeNodes) {
+                    delete this.known.nodes[nodeType];
+                }
+                this.types.nodes = this.types.nodes.filter((nodeType) => !this.excludeNodes.includes(nodeType.name));
+            }
+            console.debug(`Lazy-loading nodes and credentials from ${this.packageJson.name}`, {
+                nodes: this.types.nodes?.length ?? 0,
+                credentials: this.types.credentials?.length ?? 0,
+            });
+            this.isLazyLoaded = true;
+            return; // We can load nodes and credentials lazily now
+        }
+        catch {
+            console.debug("Can't enable lazy-loading");
+            await super.loadAll();
+        }
+    }
+}
+exports.LazyPackageDirectoryLoader = LazyPackageDirectoryLoader;

package/dist/{src/lib → lib}/NodesLoader/load-class-in-isolation.js

@@ -1,22 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadClassInIsolation = void 0;
-const vm_1 = require("vm");
+const node_vm_1 = require("node:vm");
 const Constants_1 = require("../Constants");
-const context = (0, vm_1.createContext)({ require });
+const context = (0, node_vm_1.createContext)({ require });
 const loadClassInIsolation = (filePath, className) => {
-    if (process.platform === 'win32') {
-        filePath = filePath.replace(/\\/g, '/');
-    }
+    const normalizedPath = process.platform === "win32" ? filePath.replace(/\\/g, "/") : filePath;
     // Note: Skip the isolation because it breaks nock mocks in tests
     if (Constants_1.inTest) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-member-access
-        return new (require(filePath)[className])();
-    }
-    else {
-        const script = new vm_1.Script(`new (require('${filePath}').${className})()`);
-        return script.runInContext(context);
+        return new (require(normalizedPath)[className])();
     }
+    const script = new node_vm_1.Script(`new (require('${normalizedPath}').${className})()`);
+    return script.runInContext(context);
 };
 exports.loadClassInIsolation = loadClassInIsolation;
-//# sourceMappingURL=load-class-in-isolation.js.map

package/dist/{src/lib → lib}/NodesLoader/package-directory-loader.d.ts

@@ -1,5 +1,5 @@
-import { DirectoryLoader } from './directory-loader';
-import type { n8n } from './types';
+import { DirectoryLoader } from "./directory-loader";
+import type { n8n } from "./types";
 /**
  * Loader for source files of nodes and credentials located in a package dir,
  * e.g. /nodes-base or community packages.

package/dist/{src/lib → lib}/NodesLoader/package-directory-loader.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageDirectoryLoader = void 0;
-const tslib_1 = require("tslib");
-const workflow_1 = require("@fsai-flow/workflow");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
+const workflow_1 = require("@fsai-flow/workflow");
 const directory_loader_1 = require("./directory-loader");
 /**
  * Loader for source files of nodes and credentials located in a package dir,
@@ -13,53 +12,49 @@ const directory_loader_1 = require("./directory-loader");
 class PackageDirectoryLoader extends directory_loader_1.DirectoryLoader {
     constructor(directory, excludeNodes = [], includeNodes = []) {
         super(directory, excludeNodes, includeNodes);
-        this.packageJson = this.readJSONSync('package.json');
+        this.packageJson = this.readJSONSync("package.json");
         this.packageName = this.packageJson.name;
         this.excludeNodes = this.extractNodeTypes(excludeNodes);
         this.includeNodes = this.extractNodeTypes(includeNodes);
     }
     extractNodeTypes(fullNodeTypes) {
         return fullNodeTypes
-            .map((fullNodeType) => fullNodeType.split('.'))
+            .map((fullNodeType) => fullNodeType.split("."))
             .filter(([packageName]) => packageName === this.packageName)
             .map(([_, nodeType]) => nodeType);
     }
-    loadAll() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const { n8n } = this.packageJson;
-            if (!n8n)
-                return;
-            const { nodes, credentials } = n8n;
-            if (Array.isArray(nodes)) {
-                for (const nodePath of nodes) {
-                    this.loadNodeFromFile(nodePath);
-                }
+    async loadAll() {
+        const { n8n } = this.packageJson;
+        if (!n8n)
+            return;
+        const { nodes, credentials } = n8n;
+        if (Array.isArray(nodes)) {
+            for (const nodePath of nodes) {
+                this.loadNodeFromFile(nodePath);
             }
-            if (Array.isArray(credentials)) {
-                for (const credentialPath of credentials) {
-                    this.loadCredentialFromFile(credentialPath);
-                }
+        }
+        if (Array.isArray(credentials)) {
+            for (const credentialPath of credentials) {
+                this.loadCredentialFromFile(credentialPath);
             }
-            this.inferSupportedNodes();
-            console.debug(`Loaded all credentials and nodes from ${this.packageName}`, {
-                credentials: (_a = credentials === null || credentials === void 0 ? void 0 : credentials.length) !== null && _a !== void 0 ? _a : 0,
-                nodes: (_b = nodes === null || nodes === void 0 ? void 0 : nodes.length) !== null && _b !== void 0 ? _b : 0,
-            });
+        }
+        this.inferSupportedNodes();
+        console.debug(`Loaded all credentials and nodes from ${this.packageName}`, {
+            credentials: credentials?.length ?? 0,
+            nodes: nodes?.length ?? 0,
         });
     }
     inferSupportedNodes() {
-        var _a, _b;
         const knownCredentials = this.known.credentials;
         for (const { type: credentialType } of Object.values(this.credentialTypes)) {
-            const supportedNodes = (_a = knownCredentials[credentialType.name].supportedNodes) !== null && _a !== void 0 ? _a : [];
+            const supportedNodes = knownCredentials[credentialType.name].supportedNodes ?? [];
             if (supportedNodes.length > 0 && credentialType.httpRequestNode) {
                 credentialType.httpRequestNode.hidden = true;
             }
             credentialType.supportedNodes = supportedNodes;
             if (!credentialType.iconUrl && !credentialType.icon) {
                 for (const supportedNode of supportedNodes) {
-                    const nodeDescription = (_b = this.nodeTypes[supportedNode]) === null || _b === void 0 ? void 0 : _b.type.description;
+                    const nodeDescription = this.nodeTypes[supportedNode]?.type.description;
                     if (!nodeDescription)
                         continue;
                     if (nodeDescription.icon) {
@@ -79,22 +74,19 @@ class PackageDirectoryLoader extends directory_loader_1.DirectoryLoader {
         try {
             return (0, workflow_1.jsonParse)(fileString);
         }
-        catch (error) {
+        catch (_error) {
             throw new Error(`Failed to parse JSON, ${filePath}`);
         }
     }
     readJSONSync(file) {
         const filePath = this.resolvePath(file);
-        const fileString = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+        const fileString = (0, node_fs_1.readFileSync)(filePath, "utf8");
         return this.parseJSON(fileString, filePath);
     }
-    readJSON(file) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const filePath = this.resolvePath(file);
-            const fileString = yield (0, promises_1.readFile)(filePath, 'utf8');
-            return this.parseJSON(fileString, filePath);
-        });
+    async readJSON(file) {
+        const filePath = this.resolvePath(file);
+        const fileString = await (0, promises_1.readFile)(filePath, "utf8");
+        return this.parseJSON(fileString, filePath);
     }
 }
 exports.PackageDirectoryLoader = PackageDirectoryLoader;
-//# sourceMappingURL=package-directory-loader.js.map