creo-flow-extensions-base 1.2.0-dev.1 → 1.2.0-dev.11

package/README.md

@@ -0,0 +1,31 @@
+# creo-flow-extension-base
+
+[![CI](https://github.com/CloudDataHub/creo-flow-extension-base/workflows/CI/badge.svg)](https://github.com/CloudDataHub/creo-flow-extension-base/actions/workflows/ci.yml)
+
+Base library for Creo Flow extensions.
+
+## Installation
+
+```bash
+npm install creo-flow-extension-base
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build TypeScript
+npm run build
+
+# Run linter
+npm run lint
+
+# Format code
+npm run format
+```
+
+## License
+
+ISC

package/lib/connection/index.d.ts

@@ -3,6 +3,7 @@ import { FieldNameMap } from '../fields/interfaces';
 export interface IConnectionSchema<T extends readonly Field[]> {
     label: string;
     name: string;
+    description: string;
     fields: T;
     checkConnection?: (args: FieldNameMap<T>) => Promise<boolean> | boolean;
 }

package/lib/extension/enum/ContextMode.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Defines how the extension receives and processes context.
+ *
+ * - `SIMPLIFIED` — the platform automatically parses the context and passes
+ *   a pre-processed, small context payload to the extension.
+ *   This mode supports only small context sizes (less than 0.1 MB).
+ *   Use this mode when you want a simple setup and do not need to handle
+ *   large or highly customized context structures.
+ *
+ * - `MANUAL` — the context is delivered to the extension as a separate,
+ *   raw object and must be parsed manually inside the extension.
+ *   In this mode, the `context` object is also passed directly into the
+ *   extension method, giving you more flexibility and control over how the
+ *   context is interpreted, transformed, and used.
+ */
+export declare enum ContextMode {
+    SIMPLIFIED = "simplified",
+    MANUAL = "manual"
+}

package/lib/extension/enum/ContextMode.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextMode = void 0;
+/**
+ * Defines how the extension receives and processes context.
+ *
+ * - `SIMPLIFIED` — the platform automatically parses the context and passes
+ *   a pre-processed, small context payload to the extension.
+ *   This mode supports only small context sizes (less than 0.1 MB).
+ *   Use this mode when you want a simple setup and do not need to handle
+ *   large or highly customized context structures.
+ *
+ * - `MANUAL` — the context is delivered to the extension as a separate,
+ *   raw object and must be parsed manually inside the extension.
+ *   In this mode, the `context` object is also passed directly into the
+ *   extension method, giving you more flexibility and control over how the
+ *   context is interpreted, transformed, and used.
+ */
+var ContextMode;
+(function (ContextMode) {
+    ContextMode["SIMPLIFIED"] = "simplified";
+    ContextMode["MANUAL"] = "manual";
+})(ContextMode || (exports.ContextMode = ContextMode = {}));

package/lib/extension/index.d.ts

@@ -1,3 +1,5 @@
 import { ICreateExtensionParams } from './interfaces';
 export * from './enum/ExtensionTypes';
+export * from './enum/ContextMode';
+export * from './interfaces';
 export declare const createExtension: (extension: ICreateExtensionParams) => ICreateExtensionParams;

package/lib/extension/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createExtension = void 0;
 __exportStar(require("./enum/ExtensionTypes"), exports);
+__exportStar(require("./enum/ContextMode"), exports);
+__exportStar(require("./interfaces"), exports);
 const createExtension = (extension) => {
     return extension;
 };

package/lib/extension/interfaces/index.d.ts

@@ -2,6 +2,7 @@ import { IMethodSchema } from '../../method';
 import { Field } from '../../fields';
 import { IConnectionSchema } from '../../connection';
 import { ExtensionTypes } from '../enum/ExtensionTypes';
+import { ContextMode } from '../enum/ContextMode';
 export interface ICreateExtensionParams {
     methods: IMethodSchema<readonly Field[], readonly Field[]>[];
     connections?: IConnectionSchema<readonly Field[]>[];
@@ -11,4 +12,18 @@ export interface ICreateExtensionParams {
     version: string;
     icon: string;
     type: ExtensionTypes;
+    /**
+     * Context processing mode used by this extension.
+     *
+     * - `ContextMode.SIMPLIFIED` — the platform automatically parses the context
+     *   and passes a simplified, small context payload to the extension
+     *   (maximum size: less than 0.1 MB). Use this when you do not need to
+     *   handle large or highly customized context structures.
+     *
+     * - `ContextMode.MANUAL` — the context is passed as a separate raw object
+     *   and must be parsed manually inside the extension. In this mode, the
+     *   context object is also forwarded to the extension method, allowing more
+     *   flexible handling of complex or large context payloads.
+     */
+    contextMode: ContextMode;
 }

package/lib/fields/code/index.d.ts

@@ -1,6 +1,6 @@
 import { FieldTypes } from '../enum';
 import { IBaseField } from '../interfaces';
 export interface ICodeField extends IBaseField {
-    language: 'javascript' | 'python';
+    language: 'javascript' | 'python' | 'json';
     type: FieldTypes.CODE;
 }

package/lib/fields/enum/index.d.ts

@@ -6,7 +6,8 @@ export declare enum FieldTypes {
     AUTOCOMPLETE = "autocomplete",
     DYNAMIC_FIELDS_LIST = "dynamicFieldsList",
     FIELDS_GROUP = "fieldsListGroup",
-    COLLAPSIBLE_FIELDS_LIST = "collapsibleFieldsList"
+    COLLAPSIBLE_FIELDS_LIST = "collapsibleFieldsList",
+    TEXTAREA = "textarea"
 }
 export declare enum ContentType {
     STRING = "string",

package/lib/fields/enum/index.js

@@ -11,6 +11,7 @@ var FieldTypes;
     FieldTypes["DYNAMIC_FIELDS_LIST"] = "dynamicFieldsList";
     FieldTypes["FIELDS_GROUP"] = "fieldsListGroup";
     FieldTypes["COLLAPSIBLE_FIELDS_LIST"] = "collapsibleFieldsList";
+    FieldTypes["TEXTAREA"] = "textarea";
 })(FieldTypes || (exports.FieldTypes = FieldTypes = {}));
 var ContentType;
 (function (ContentType) {

package/lib/fields/index.d.ts

@@ -5,6 +5,7 @@ import { ICodeField } from './code';
 import { ICollapsibleFieldsList } from './collapsibleFieldsList';
 import { IDynamicFieldsList } from './dynamicFieldsList';
 import { IFieldsGroup } from './fieldsGroup';
+import { ITextareaField } from './textarea';
 export * from './enum';
-export type Field = IInputField | ISelectField | ICheckboxField | ICodeField | ICollapsibleFieldsList | IDynamicFieldsList | IFieldsGroup;
+export type Field = IInputField | ISelectField | ICheckboxField | ICodeField | ICollapsibleFieldsList | IDynamicFieldsList | IFieldsGroup | ITextareaField;
 export declare function createFields<const T extends readonly Field[]>(fields: T & Field[]): T;

package/lib/fields/textarea/index.d.ts

@@ -0,0 +1,5 @@
+import { FieldTypes } from '../enum';
+import { IBaseField } from '../interfaces';
+export interface ITextareaField extends IBaseField {
+    type: FieldTypes.TEXTAREA;
+}

package/lib/fields/textarea/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/logger/configure.d.ts

@@ -0,0 +1,8 @@
+import type { LoggerOptions } from './private';
+/**
+ * Configures the shared extension logger used by both the template (extension-service-base)
+ * and extensions. Call this once at container/bootstrap before loading extensions.
+ *
+ * @param options - Logger configuration (transport, storeInMemory, etc.)
+ */
+export declare function configureExtensionLogger(options: LoggerOptions): void;

package/lib/logger/configure.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureExtensionLogger = configureExtensionLogger;
+const private_1 = require("./private");
+/**
+ * Configures the shared extension logger used by both the template (extension-service-base)
+ * and extensions. Call this once at container/bootstrap before loading extensions.
+ *
+ * @param options - Logger configuration (transport, storeInMemory, etc.)
+ */
+function configureExtensionLogger(options) {
+    private_1.internalLogger.initialize(undefined, options);
+}

package/lib/logger/index.d.ts

@@ -1 +1,7 @@
 export * from './public';
+export { Logger, LogEntry } from './private';
+export type { LoggerOptions, LogTransport } from './private';
+export { runWithLogger } from './private/logger-executor';
+export { configureExtensionLogger } from './configure';
+export { LogType } from './enum/LogType';
+export type { ILogPayload } from './interfaces';

package/lib/logger/index.js

@@ -14,4 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogType = exports.configureExtensionLogger = exports.runWithLogger = exports.Logger = void 0;
 __exportStar(require("./public"), exports);
+var private_1 = require("./private");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return private_1.Logger; } });
+var logger_executor_1 = require("./private/logger-executor");
+Object.defineProperty(exports, "runWithLogger", { enumerable: true, get: function () { return logger_executor_1.runWithLogger; } });
+var configure_1 = require("./configure");
+Object.defineProperty(exports, "configureExtensionLogger", { enumerable: true, get: function () { return configure_1.configureExtensionLogger; } });
+var LogType_1 = require("./enum/LogType");
+Object.defineProperty(exports, "LogType", { enumerable: true, get: function () { return LogType_1.LogType; } });

package/lib/logger/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export interface ILogPayload {
+    message?: string;
+    payload?: Record<string, unknown>;
+}

package/lib/logger/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/logger/private/index.d.ts

@@ -1,13 +1,98 @@
 import { LogType } from '../enum/LogType';
+import { ILogPayload } from '../interfaces';
 export interface LogEntry {
     type: LogType;
-    payload: Record<string, SafeArray>;
+    payload: ILogPayload;
     timestamp: number;
 }
-declare class Logger {
+/**
+ * Transport function for forwarding logs to external systems (e.g., CloudWatch).
+ * Called asynchronously for each log entry.
+ */
+export type LogTransport = (entry: LogEntry) => void | Promise<void>;
+export interface LoggerOptions {
+    /**
+     * Whether to store logs in memory.
+     * If false, logs are only forwarded to transport (if configured) and not stored.
+     * Default: false
+     */
+    storeInMemory?: boolean;
+    /**
+     * Maximum number of log entries to keep in memory.
+     * When exceeded, oldest logs are removed (FIFO).
+     * Only applies if storeInMemory is true.
+     * Default: 1000
+     */
+    maxLogCount?: number;
+    /**
+     * Maximum total size of log entries in bytes (approximate).
+     * When exceeded, oldest logs are removed until under limit.
+     * Only applies if storeInMemory is true.
+     * Default: 10MB (10 * 1024 * 1024)
+     */
+    maxLogSizeBytes?: number;
+    /**
+     * Whether to warn when log limits are exceeded.
+     * Default: true
+     */
+    warnOnLimitExceeded?: boolean;
+    /**
+     * Optional transport function to forward logs to external systems (e.g., CloudWatch).
+     * This is called for each log entry asynchronously (fire-and-forget).
+     * Works independently of storeInMemory - logs are always forwarded if transport is set.
+     */
+    transport?: LogTransport;
+}
+export declare class Logger {
     private readonly storage;
+    private defaultStore;
+    private options;
+    private hasWarnedLimit;
+    /**
+     * Initialize the logger with a default store and optional configuration.
+     *
+     * @param defaultStore - Optional array to store logs in. If not provided and storeInMemory is true, creates a new array.
+     * @param options - Logger configuration options
+     */
+    initialize(defaultStore?: LogEntry[], options?: LoggerOptions): void;
+    /**
+     * Configure logger options.
+     */
+    configure(options: LoggerOptions): void;
+    /**
+     * Set or update the transport function for forwarding logs.
+     */
+    setTransport(transport: LogTransport | undefined): void;
+    /**
+     * Run a function with a specific logger store in async context.
+     */
     runWithLogger<T>(store: LogEntry[], fn: () => T): T;
-    log(type: LogType, payload: Record<string, SafeArray>): void;
+    /**
+     * Log an entry. Uses AsyncLocalStorage if available, otherwise falls back to default store.
+     * If storeInMemory is false, only forwards to transport (if configured).
+     * Automatically truncates logs if limits are exceeded (only if storing in memory).
+     * If a transport is configured, forwards the log entry to it asynchronously.
+     */
+    log(type: LogType, payload: ILogPayload): void;
+    /**
+     * Get the current log entries from the store.
+     * Returns empty array if storeInMemory is false.
+     */
+    getLogs(): ReadonlyArray<LogEntry>;
+    /**
+     * Get approximate total size of logs in bytes.
+     * Returns 0 if storeInMemory is false.
+     */
+    getLogsSize(): number;
+    /**
+     * Clear the current log entries.
+     */
+    clear(): void;
+    private getStore;
+    private estimateLogSize;
+    private truncateLogsIfNeeded;
+    private calculateTotalSize;
+    private warnLimitExceeded;
+    private forwardToTransport;
 }
 export declare const internalLogger: Logger;
-export {};

package/lib/logger/private/index.js

@@ -1,17 +1,182 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.internalLogger = void 0;
+exports.internalLogger = exports.Logger = void 0;
 const node_async_hooks_1 = require("node:async_hooks");
+const DEFAULT_MAX_LOG_COUNT = 1000;
+const DEFAULT_MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
+const FALLBACK_PAYLOAD_SIZE = 1024;
+const BYTES_PER_CHAR = 2;
 class Logger {
     storage = new node_async_hooks_1.AsyncLocalStorage();
+    defaultStore = null;
+    options = {
+        storeInMemory: false,
+        maxLogCount: DEFAULT_MAX_LOG_COUNT,
+        maxLogSizeBytes: DEFAULT_MAX_LOG_SIZE_BYTES,
+        warnOnLimitExceeded: true,
+    };
+    hasWarnedLimit = false;
+    /**
+     * Initialize the logger with a default store and optional configuration.
+     *
+     * @param defaultStore - Optional array to store logs in. If not provided and storeInMemory is true, creates a new array.
+     * @param options - Logger configuration options
+     */
+    initialize(defaultStore, options) {
+        const storeInMemory = options?.storeInMemory ?? this.options.storeInMemory;
+        this.defaultStore = storeInMemory ? (defaultStore ?? []) : null;
+        if (options) {
+            this.options = {
+                storeInMemory,
+                maxLogCount: options.maxLogCount ?? this.options.maxLogCount,
+                maxLogSizeBytes: options.maxLogSizeBytes ?? this.options.maxLogSizeBytes,
+                warnOnLimitExceeded: options.warnOnLimitExceeded ?? this.options.warnOnLimitExceeded,
+                transport: options.transport ?? this.options.transport,
+            };
+        }
+    }
+    /**
+     * Configure logger options.
+     */
+    configure(options) {
+        this.options = {
+            ...this.options,
+            ...options,
+            maxLogCount: options.maxLogCount ?? this.options.maxLogCount,
+            maxLogSizeBytes: options.maxLogSizeBytes ?? this.options.maxLogSizeBytes,
+        };
+    }
+    /**
+     * Set or update the transport function for forwarding logs.
+     */
+    setTransport(transport) {
+        this.options.transport = transport;
+    }
+    /**
+     * Run a function with a specific logger store in async context.
+     */
     runWithLogger(store, fn) {
         return this.storage.run(store, fn);
     }
+    /**
+     * Log an entry. Uses AsyncLocalStorage if available, otherwise falls back to default store.
+     * If storeInMemory is false, only forwards to transport (if configured).
+     * Automatically truncates logs if limits are exceeded (only if storing in memory).
+     * If a transport is configured, forwards the log entry to it asynchronously.
+     */
     log(type, payload) {
-        const store = this.storage.getStore();
-        if (!store)
-            throw new Error('Logger store not set');
-        store.push({ type, payload, timestamp: Date.now() });
+        const safePayload = payload ?? {};
+        const entry = { type, payload: safePayload, timestamp: Date.now() };
+        if (this.options.storeInMemory) {
+            const store = this.getStore();
+            store.push(entry);
+            this.truncateLogsIfNeeded(store);
+        }
+        this.forwardToTransport(entry);
+    }
+    /**
+     * Get the current log entries from the store.
+     * Returns empty array if storeInMemory is false.
+     */
+    getLogs() {
+        if (!this.options.storeInMemory) {
+            return [];
+        }
+        return this.getStore();
+    }
+    /**
+     * Get approximate total size of logs in bytes.
+     * Returns 0 if storeInMemory is false.
+     */
+    getLogsSize() {
+        if (!this.options.storeInMemory) {
+            return 0;
+        }
+        return this.calculateTotalSize(this.getStore());
+    }
+    /**
+     * Clear the current log entries.
+     */
+    clear() {
+        if (!this.options.storeInMemory) {
+            return;
+        }
+        const store = this.getStore();
+        store.length = 0;
+        this.hasWarnedLimit = false;
+    }
+    getStore() {
+        const store = this.storage.getStore() || this.defaultStore;
+        if (!store) {
+            throw new Error('Logger store not set. Call initialize() or runWithLogger() first.');
+        }
+        return store;
+    }
+    estimateLogSize(entry) {
+        let size = entry.type.length * BYTES_PER_CHAR + 8;
+        if (entry.payload.message) {
+            size += entry.payload.message.length * BYTES_PER_CHAR;
+        }
+        if (entry.payload.payload) {
+            try {
+                const serialized = JSON.stringify(entry.payload.payload);
+                size += serialized.length * BYTES_PER_CHAR;
+            }
+            catch {
+                size += FALLBACK_PAYLOAD_SIZE;
+            }
+        }
+        return size;
+    }
+    truncateLogsIfNeeded(store) {
+        const wasOverCountLimit = store.length > this.options.maxLogCount;
+        if (wasOverCountLimit) {
+            const removeCount = store.length - this.options.maxLogCount;
+            store.splice(0, removeCount);
+        }
+        let totalSize = this.calculateTotalSize(store);
+        const wasOverSizeLimit = totalSize > this.options.maxLogSizeBytes;
+        while (totalSize > this.options.maxLogSizeBytes && store.length > 0) {
+            const removed = store.shift();
+            if (removed) {
+                totalSize -= this.estimateLogSize(removed);
+            }
+        }
+        const shouldWarn = (wasOverCountLimit || wasOverSizeLimit) &&
+            this.options.warnOnLimitExceeded &&
+            !this.hasWarnedLimit;
+        if (shouldWarn) {
+            this.warnLimitExceeded(store.length, totalSize);
+        }
+    }
+    calculateTotalSize(store) {
+        return store.reduce((total, entry) => total + this.estimateLogSize(entry), 0);
+    }
+    warnLimitExceeded(entryCount, totalSize) {
+        console.warn(`[Logger] Log limits exceeded. Logs have been truncated. ` +
+            `Current: ${entryCount} entries, ~${Math.round(totalSize / 1024)}KB. ` +
+            `Limits: ${this.options.maxLogCount} entries, ${Math.round(this.options.maxLogSizeBytes / 1024 / 1024)}MB`);
+        this.hasWarnedLimit = true;
+    }
+    forwardToTransport(entry) {
+        const transport = this.options.transport;
+        if (!transport) {
+            return;
+        }
+        setImmediate(() => {
+            try {
+                const result = transport(entry);
+                if (result instanceof Promise) {
+                    result.catch((error) => {
+                        console.error('[Logger] Transport error:', error);
+                    });
+                }
+            }
+            catch (error) {
+                console.error('[Logger] Transport error:', error);
+            }
+        });
     }
 }
+exports.Logger = Logger;
 exports.internalLogger = new Logger();

package/lib/logger/private/logger-executor.d.ts

@@ -1,2 +1,9 @@
-import { SafeAny } from '../../common/interfaces';
-export declare function runWithLogger<T>(store: SafeAny[], fn: () => T): T;
+import { LogEntry } from '.';
+/**
+ * Run a function with a logger store in async context.
+ *
+ * @param store - Array to store log entries for this execution context
+ * @param fn - Function to execute within the logger context
+ * @returns The return value of the executed function
+ */
+export declare function runWithLogger<T>(store: LogEntry[], fn: () => T): T;

package/lib/logger/private/logger-executor.js

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runWithLogger = runWithLogger;
 const _1 = require(".");
+/**
+ * Run a function with a logger store in async context.
+ *
+ * @param store - Array to store log entries for this execution context
+ * @param fn - Function to execute within the logger context
+ * @returns The return value of the executed function
+ */
 function runWithLogger(store, fn) {
     return _1.internalLogger.runWithLogger(store, fn);
 }

package/lib/logger/public/index.d.ts

@@ -1,6 +1,11 @@
+import { ILogPayload } from '../interfaces';
+/**
+ * Public logger interface for convenient logging methods.
+ * Accepts ILogPayload, Error, string, or null/undefined.
+ */
 export declare const logger: {
-    info: (payload: Record<string, SafeArray>) => void;
-    error: (payload: Record<string, SafeArray>) => void;
-    warning: (payload: Record<string, SafeArray>) => void;
-    debug: (payload: Record<string, SafeArray>) => void;
+    info: (payload: ILogPayload | Error | string | null | undefined) => void;
+    error: (payload: ILogPayload | Error | string | null | undefined) => void;
+    warning: (payload: ILogPayload | Error | string | null | undefined) => void;
+    debug: (payload: ILogPayload | Error | string | null | undefined) => void;
 };

package/lib/logger/public/index.js

@@ -3,13 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const private_1 = require("../private");
 const LogType_1 = require("../enum/LogType");
-const logInfo = (payload) => private_1.internalLogger.log(LogType_1.LogType.INFO, payload);
-const logError = (payload) => private_1.internalLogger.log(LogType_1.LogType.ERROR, payload);
-const logWarning = (payload) => private_1.internalLogger.log(LogType_1.LogType.WARNING, payload);
-const logDebug = (payload) => private_1.internalLogger.log(LogType_1.LogType.DEBUG, payload);
+/**
+ * Normalizes input to ILogPayload. Handles null/undefined, Error, string, and ILogPayload.
+ */
+function normalizePayload(input) {
+    if (input == null) {
+        return {};
+    }
+    if (input instanceof Error) {
+        return {
+            message: input.message,
+            payload: { name: input.name, stack: input.stack },
+        };
+    }
+    if (typeof input === 'string') {
+        return { message: input };
+    }
+    return input;
+}
+/**
+ * Public logger interface for convenient logging methods.
+ * Accepts ILogPayload, Error, string, or null/undefined.
+ */
 exports.logger = {
-    info: logInfo,
-    error: logError,
-    warning: logWarning,
-    debug: logDebug,
+    info: (payload) => private_1.internalLogger.log(LogType_1.LogType.INFO, normalizePayload(payload)),
+    error: (payload) => private_1.internalLogger.log(LogType_1.LogType.ERROR, normalizePayload(payload)),
+    warning: (payload) => private_1.internalLogger.log(LogType_1.LogType.WARNING, normalizePayload(payload)),
+    debug: (payload) => private_1.internalLogger.log(LogType_1.LogType.DEBUG, normalizePayload(payload)),
 };

package/lib/method/index.d.ts

@@ -1,17 +1,28 @@
 import { Field } from '../fields';
 import { FieldNameMap } from '../fields/interfaces';
 import { SafeAny } from '../common/interfaces';
+import { IDefaultExecutionArgs } from './interfaces';
 export interface IMethodSchema<T extends readonly Field[], C extends readonly Field[] = [], S = SafeAny> {
     label: string;
     name: string;
     description: string;
     fields: T;
-    execute: (args: FieldNameMap<T> & FieldNameMap<C>) => S;
+    /**
+     * Executes the method logic.
+     *
+     * @param args - Aggregated field values and default execution arguments.
+     */
+    execute: (args: FieldNameMap<T> & FieldNameMap<C> & IDefaultExecutionArgs) => S;
 }
 export declare function createMethodSchema<const T extends readonly Field[], const C extends readonly Field[] = [], S = SafeAny>(schema: {
     label: string;
     name: string;
     description: string;
     fields: T;
-    execute: (args: FieldNameMap<T> & FieldNameMap<C>) => S;
+    /**
+     * Executes the method logic.
+     *
+     * @param args - Aggregated field values and default execution arguments.
+     */
+    execute: (args: FieldNameMap<T> & FieldNameMap<C> & IDefaultExecutionArgs) => S;
 }): IMethodSchema<T, C, S>;

package/lib/method/interfaces/index.d.ts

@@ -0,0 +1,7 @@
+export interface IDefaultExecutionArgs {
+    organizationId: string;
+    organizationUnitId: string;
+    flowId: string;
+    flowToken: string;
+    secrets: Record<string, string>;
+}

package/lib/method/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "creo-flow-extensions-base",
-  "version": "1.2.0-dev.1",
-  "main": "index.js",
+  "version": "1.2.0-dev.11",
+  "main": "lib/index.js",
   "repository": "git@github.com:CloudDataHub/creo-flow-extension-base.git",
   "author": "Naum Zakletskyi",
   "license": "ISC",