@abyss-project/console 1.0.28 → 1.0.30

package/dist/expressions/pipes/string-pipes.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringPipes = void 0;
+exports.stringPipes = {
+    upper: {
+        name: 'upper',
+        description: 'Converts to uppercase',
+        category: 'string',
+        signature: 'upper',
+        examples: ['{{trigger.name | upper}}'],
+        execute: (value) => String(value).toUpperCase(),
+    },
+    lower: {
+        name: 'lower',
+        description: 'Converts to lowercase',
+        category: 'string',
+        signature: 'lower',
+        examples: ['{{trigger.email | lower}}'],
+        execute: (value) => String(value).toLowerCase(),
+    },
+    capitalize: {
+        name: 'capitalize',
+        description: 'Capitalizes the first letter',
+        category: 'string',
+        signature: 'capitalize',
+        examples: ['{{trigger.name | capitalize}}'],
+        execute: (value) => {
+            const str = String(value);
+            return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+        },
+    },
+    trim: {
+        name: 'trim',
+        description: 'Removes whitespace from both ends',
+        category: 'string',
+        signature: 'trim',
+        examples: ['{{trigger.input | trim}}'],
+        execute: (value) => String(value).trim(),
+    },
+    truncate: {
+        name: 'truncate',
+        description: 'Truncates a string to a specified length',
+        category: 'string',
+        signature: 'truncate(length)',
+        examples: ['{{trigger.description | truncate(100)}}'],
+        execute: (value, length) => {
+            const str = String(value);
+            const len = Number(length);
+            return str.length > len ? str.substring(0, len) + '...' : str;
+        },
+    },
+    replace: {
+        name: 'replace',
+        description: 'Replaces occurrences of a pattern',
+        category: 'string',
+        signature: 'replace(search, replacement)',
+        examples: ['{{trigger.text | replace("old", "new")}}'],
+        execute: (value, search, replacement) => {
+            const searchStr = String(search);
+            const replaceStr = String(replacement);
+            return String(value).replace(new RegExp(searchStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), replaceStr);
+        },
+    },
+    split: {
+        name: 'split',
+        description: 'Splits a string into an array',
+        category: 'string',
+        signature: 'split(separator)',
+        examples: ['{{trigger.tags | split(",")}}'],
+        execute: (value, separator) => {
+            return String(value).split(String(separator));
+        },
+    },
+    substring: {
+        name: 'substring',
+        description: 'Extracts a substring',
+        category: 'string',
+        signature: 'substring(start, end?)',
+        examples: ['{{trigger.id | substring(0, 8)}}'],
+        execute: (value, start, end) => {
+            return String(value).substring(Number(start), end !== undefined ? Number(end) : undefined);
+        },
+    },
+    padStart: {
+        name: 'padStart',
+        description: 'Pads a string from the start',
+        category: 'string',
+        signature: 'padStart(length, padString?)',
+        examples: ['{{trigger.id | padStart(10, "0")}}'],
+        execute: (value, length, padString) => {
+            return String(value).padStart(Number(length), padString !== undefined ? String(padString) : ' ');
+        },
+    },
+    padEnd: {
+        name: 'padEnd',
+        description: 'Pads a string from the end',
+        category: 'string',
+        signature: 'padEnd(length, padString?)',
+        examples: ['{{trigger.code | padEnd(5, "X")}}'],
+        execute: (value, length, padString) => {
+            return String(value).padEnd(Number(length), padString !== undefined ? String(padString) : ' ');
+        },
+    },
+    repeat: {
+        name: 'repeat',
+        description: 'Repeats a string n times',
+        category: 'string',
+        signature: 'repeat(count)',
+        examples: ['{{trigger.char | repeat(3)}}'],
+        execute: (value, count) => {
+            return String(value).repeat(Number(count));
+        },
+    },
+    reverse: {
+        name: 'reverse',
+        description: 'Reverses a string',
+        category: 'string',
+        signature: 'reverse',
+        examples: ['{{trigger.text | reverse}}'],
+        execute: (value) => {
+            return String(value).split('').reverse().join('');
+        },
+    },
+    slugify: {
+        name: 'slugify',
+        description: 'Converts to URL-friendly slug',
+        category: 'string',
+        signature: 'slugify',
+        examples: ['{{trigger.title | slugify}}'],
+        execute: (value) => {
+            return String(value)
+                .toLowerCase()
+                .trim()
+                .replace(/[^\w\s-]/g, '')
+                .replace(/[\s_-]+/g, '-')
+                .replace(/^-+|-+$/g, '');
+        },
+    },
+    camelCase: {
+        name: 'camelCase',
+        description: 'Converts to camelCase',
+        category: 'string',
+        signature: 'camelCase',
+        examples: ['{{trigger.text | camelCase}}'],
+        execute: (value) => {
+            return String(value)
+                .replace(/[^\w\s]/g, '')
+                .replace(/\s+(.)/g, (_, char) => char.toUpperCase())
+                .replace(/^\w/, (char) => char.toLowerCase());
+        },
+    },
+    kebabCase: {
+        name: 'kebabCase',
+        description: 'Converts to kebab-case',
+        category: 'string',
+        signature: 'kebabCase',
+        examples: ['{{trigger.text | kebabCase}}'],
+        execute: (value) => {
+            return String(value)
+                .replace(/([a-z])([A-Z])/g, '$1-$2')
+                .replace(/[\s_]+/g, '-')
+                .toLowerCase();
+        },
+    },
+    snakeCase: {
+        name: 'snakeCase',
+        description: 'Converts to snake_case',
+        category: 'string',
+        signature: 'snakeCase',
+        examples: ['{{trigger.text | snakeCase}}'],
+        execute: (value) => {
+            return String(value)
+                .replace(/([a-z])([A-Z])/g, '$1_$2')
+                .replace(/[\s-]+/g, '_')
+                .toLowerCase();
+        },
+    },
+};

package/dist/expressions/resolver.d.ts

@@ -0,0 +1,12 @@
+export interface ExpressionContext {
+    [key: string]: unknown;
+}
+export interface ResolverOptions {
+    strict?: boolean;
+    functions?: Record<string, (...args: unknown[]) => unknown>;
+    allowNested?: boolean;
+    maxDepth?: number;
+}
+export declare function resolveExpression(expression: string, context: ExpressionContext, options?: ResolverOptions): unknown;
+export declare function isDynamicExpression(expression: string): boolean;
+export declare function extractPaths(expression: string): string[];

package/dist/expressions/resolver.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPaths = exports.isDynamicExpression = exports.resolveExpression = void 0;
+const parser_1 = require("./parser");
+function resolveExpression(expression, context, options = {}) {
+    const opts = {
+        strict: false,
+        functions: {},
+        allowNested: true,
+        maxDepth: 10,
+        ...options,
+    };
+    if (!expression) {
+        return expression;
+    }
+    const parsed = (0, parser_1.parseExpression)(expression);
+    if (!parsed.isDynamic) {
+        return expression;
+    }
+    if (parsed.tokens.length === 1 && parsed.tokens[0].type === 'expression') {
+        return evaluateExpression(parsed.tokens[0].value, context, opts);
+    }
+    return parsed.tokens
+        .map((token) => {
+        if (token.type === 'text') {
+            return token.value;
+        }
+        if (token.type === 'expression') {
+            const value = evaluateExpression(token.value, context, opts);
+            return value === undefined || value === null ? '' : String(value);
+        }
+        return '';
+    })
+        .join('');
+}
+exports.resolveExpression = resolveExpression;
+function evaluateExpression(expression, context, options) {
+    try {
+        const value = resolvePath(expression, context, options);
+        return value;
+    }
+    catch (error) {
+        if (options.strict) {
+            throw error;
+        }
+        return undefined;
+    }
+}
+function resolvePath(path, context, options, depth = 0) {
+    if (depth > options.maxDepth) {
+        throw new Error(`Maximum depth exceeded for path: ${path}`);
+    }
+    const bracketMatch = path.match(/^([^[]+)\[['"]([^'"]+)['"]\](.*)$/);
+    if (bracketMatch) {
+        const [, base, key, rest] = bracketMatch;
+        const baseValue = resolvePath(base, context, options, depth + 1);
+        if (baseValue === undefined || baseValue === null) {
+            return undefined;
+        }
+        const value = baseValue[key];
+        if (rest && rest.length > 0) {
+            return resolvePath(rest.replace(/^\./, ''), { _: value }, options, depth + 1);
+        }
+        return value;
+    }
+    const parts = path.split('.');
+    let current = context;
+    for (const part of parts) {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function isDynamicExpression(expression) {
+    const parsed = (0, parser_1.parseExpression)(expression);
+    return parsed.isDynamic;
+}
+exports.isDynamicExpression = isDynamicExpression;
+function extractPaths(expression) {
+    const parsed = (0, parser_1.parseExpression)(expression);
+    return parsed.references.map((ref) => `${ref.source}.${ref.path}`);
+}
+exports.extractPaths = extractPaths;

package/dist/expressions/types.d.ts

@@ -0,0 +1,36 @@
+export interface ResourceMapping<TSource = string> {
+    source: TSource;
+    displayPath: string;
+    savePath: string;
+    resourceId: string;
+    resourceName: string;
+}
+export type ExpressionToken = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'expression';
+    value: string;
+    raw: string;
+} | {
+    type: 'reference';
+    source: string;
+    path: string;
+};
+export interface ExpressionParserConfig {
+    openDelimiter?: string;
+    closeDelimiter?: string;
+    trimExpressions?: boolean;
+}
+export interface ParsedExpression {
+    tokens: ExpressionToken[];
+    isDynamic: boolean;
+    references: Array<{
+        source: string;
+        path: string;
+    }>;
+}
+export interface ExpressionMappingOptions {
+    strict?: boolean;
+    preserveUnknown?: boolean;
+}

package/dist/expressions/types.js

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

package/dist/index.d.ts

@@ -13,6 +13,10 @@ import * as secretPublicApi from './api/secret-public.api';
 export * from './utils/cidr.util';
 export * from './types';
 export * from './utils';
+import * as GenericExpression from './expressions';
+export { GenericExpression };
+import * as WorkflowExpression from './workflow-expressions';
+export { WorkflowExpression };
 export declare const API_KEY_APPLICATION_HEADER = "abyss-console-api-key-application";
 export declare const ADMIN_TOKEN_HEADER = "abyss-admin-token";
 export declare const HEADER_WEBHOOK_SIGNATURE_NAME = "abyss-console-webhook-signature";
@@ -97,6 +101,7 @@ type AbyssConsoleCoreSDK = {
         };
         connection: {
             list: typeof workflowApi.listWorkflowStepConnections;
+            update: typeof workflowApi.updateWorkflowStepConnection;
         };
         execution: {
             paginate: typeof workflowApi.paginateWorkflowExecution;

package/dist/index.js

@@ -29,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbyssConsoleCore = exports.WEBHOOK_SIGNATURE_ALGORITHM = exports.HEADER_WEBHOOK_SIGNATURE_NAME = exports.ADMIN_TOKEN_HEADER = exports.API_KEY_APPLICATION_HEADER = void 0;
+exports.AbyssConsoleCore = exports.WEBHOOK_SIGNATURE_ALGORITHM = exports.HEADER_WEBHOOK_SIGNATURE_NAME = exports.ADMIN_TOKEN_HEADER = exports.API_KEY_APPLICATION_HEADER = exports.WorkflowExpression = exports.GenericExpression = void 0;
 const axios_1 = __importDefault(require("axios"));
 const axios_retry_1 = __importStar(require("axios-retry"));
 const domainVerificationApi = __importStar(require("./api/domain-verification.api"));
@@ -46,6 +46,10 @@ const secretPublicApi = __importStar(require("./api/secret-public.api"));
 __exportStar(require("./utils/cidr.util"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
+const GenericExpression = __importStar(require("./expressions"));
+exports.GenericExpression = GenericExpression;
+const WorkflowExpression = __importStar(require("./workflow-expressions"));
+exports.WorkflowExpression = WorkflowExpression;
 const MONITOR_DEFAULT_BASE_URL = 'https://console-api.abyss-project.fr/api/';
 exports.API_KEY_APPLICATION_HEADER = 'abyss-console-api-key-application';
 exports.ADMIN_TOKEN_HEADER = 'abyss-admin-token';
@@ -91,6 +95,7 @@ class AbyssConsoleCore {
             },
             connection: {
                 list: workflowApi.listWorkflowStepConnections,
+                update: workflowApi.updateWorkflowStepConnection,
             },
             execution: {
                 paginate: workflowApi.paginateWorkflowExecution,

package/dist/types/interface/api/requests/workflow.request.d.ts

@@ -101,6 +101,16 @@ export interface IListWorkflowStepConnectionsParams {
     projectId: string;
     workflowId: string;
 }
+export interface IUpdateWorkflowStepConnectionParams {
+    projectId: string;
+    workflowId: string;
+    connectionId: string;
+}
+export interface IUpdateWorkflowStepConnectionBody {
+    label?: string | null;
+    expression?: string | null;
+    order?: number;
+}
 export interface IPaginateWorkflowExecutionParams {
     projectId: string;
     workflowId: string;

package/dist/types/interface/api/responses/workflow.response.d.ts

@@ -45,6 +45,10 @@ export interface IListWorkflowStepConnectionData {
     connections: IWorkflowStepConnection[];
 }
 export type IListWorkflowStepConnectionResponse = IResponse<IListWorkflowStepConnectionData>;
+export interface IUpdateWorkflowStepConnectionData {
+    connection: IWorkflowStepConnection;
+}
+export type IUpdateWorkflowStepConnectionResponse = IResponse<IUpdateWorkflowStepConnectionData>;
 export type IPaginateWorkflowExecutionResponse = IResponse<BasePaginate<IWorkflowExecution>>;
 export interface IGetWorkflowExecutionData {
     workflowExecution: IWorkflowExecution;

package/dist/utils/webhook-trigger.utils.js

@@ -72,7 +72,7 @@ const tokenizeExpression = (expression, context) => {
             }
             const path = expression.slice(pos + 2, endIdx).trim();
             if (path.includes('|')) {
-                const [refPath, ...pipes] = path.split('|').map(s => s.trim());
+                const [refPath, ...pipes] = path.split('|').map((s) => s.trim());
                 let value = (0, exports.getNestedValue)(context, refPath);
                 for (const pipe of pipes) {
                     value = applyPipeOperator(value, pipe);
@@ -174,11 +174,15 @@ const applyPipeOperator = (value, pipe) => {
         case 'endsWith':
             return strValue.endsWith(args || '');
         case 'isEmpty':
-            return value === null || value === undefined || value === '' ||
-                (Array.isArray(value) && value.length === 0);
+            return (value === null ||
+                value === undefined ||
+                value === '' ||
+                (Array.isArray(value) && value.length === 0));
         case 'isNotEmpty':
-            return value !== null && value !== undefined && value !== '' &&
-                (!Array.isArray(value) || value.length > 0);
+            return (value !== null &&
+                value !== undefined &&
+                value !== '' &&
+                (!Array.isArray(value) || value.length > 0));
         case 'length':
             return Array.isArray(value) ? value.length : strValue.length;
         case 'lower':
@@ -200,7 +204,7 @@ const evaluateTokens = (tokens) => {
     if (tokens.length === 1) {
         return tokens[0].value;
     }
-    const questionIdx = tokens.findIndex(t => t.type === 'operator' && t.value === '?');
+    const questionIdx = tokens.findIndex((t) => t.type === 'operator' && t.value === '?');
     if (questionIdx !== -1) {
         const colonIdx = tokens.findIndex((t, i) => i > questionIdx && t.type === 'operator' && t.value === ':');
         if (colonIdx !== -1) {

package/dist/workflow-expressions/functions/array.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltInFunction } from '../types';
+export declare const arrayFunctions: Record<string, BuiltInFunction>;

package/dist/workflow-expressions/functions/array.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayFunctions = void 0;
+exports.arrayFunctions = {
+    length: {
+        name: 'length',
+        description: 'Returns the length of a string or array',
+        category: 'array',
+        signature: 'length(value)',
+        args: [
+            {
+                name: 'value',
+                type: 'string|array',
+                required: true,
+                description: 'String or array',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.length(trigger.items)}}'],
+        execute: (value) => {
+            if (typeof value === 'string') {
+                return value.length;
+            }
+            if (Array.isArray(value)) {
+                return value.length;
+            }
+            return 0;
+        },
+    },
+    first: {
+        name: 'first',
+        description: 'Returns the first element of an array',
+        category: 'array',
+        signature: 'first(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'any',
+        examples: ['{{fn.first(trigger.items)}}'],
+        execute: (arr) => {
+            if (Array.isArray(arr) && arr.length > 0) {
+                return arr[0];
+            }
+            return undefined;
+        },
+    },
+    last: {
+        name: 'last',
+        description: 'Returns the last element of an array',
+        category: 'array',
+        signature: 'last(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'any',
+        examples: ['{{fn.last(trigger.items)}}'],
+        execute: (arr) => {
+            if (Array.isArray(arr) && arr.length > 0) {
+                return arr[arr.length - 1];
+            }
+            return undefined;
+        },
+    },
+    join: {
+        name: 'join',
+        description: 'Joins array elements into a string',
+        category: 'array',
+        signature: 'join(arr, separator)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+            {
+                name: 'separator',
+                type: 'string',
+                required: false,
+                description: 'Separator (default: ",")',
+            },
+        ],
+        returnType: 'string',
+        examples: ['{{fn.join(trigger.tags, ", ")}}'],
+        execute: (arr, separator) => {
+            if (!Array.isArray(arr)) {
+                return '';
+            }
+            return arr.join(separator !== undefined ? String(separator) : ',');
+        },
+    },
+    slice: {
+        name: 'slice',
+        description: 'Extracts a section of an array',
+        category: 'array',
+        signature: 'slice(arr, start, end?)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+            {
+                name: 'start',
+                type: 'number',
+                required: true,
+                description: 'Start index',
+            },
+            {
+                name: 'end',
+                type: 'number',
+                required: false,
+                description: 'End index',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.slice(trigger.items, 0, 3)}}'],
+        execute: (arr, start, end) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return arr.slice(Number(start), end !== undefined ? Number(end) : undefined);
+        },
+    },
+    includes: {
+        name: 'includes',
+        description: 'Checks if an array includes a value',
+        category: 'array',
+        signature: 'includes(arr, value)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+            {
+                name: 'value',
+                type: 'any',
+                required: true,
+                description: 'Value to search for',
+            },
+        ],
+        returnType: 'boolean',
+        examples: ['{{fn.includes(trigger.roles, "admin")}}'],
+        execute: (arr, value) => {
+            if (!Array.isArray(arr)) {
+                return false;
+            }
+            return arr.includes(value);
+        },
+    },
+    reverse: {
+        name: 'reverse',
+        description: 'Reverses the order of array elements',
+        category: 'array',
+        signature: 'reverse(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.reverse(trigger.items)}}'],
+        execute: (arr) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return [...arr].reverse();
+        },
+    },
+    unique: {
+        name: 'unique',
+        description: 'Returns unique elements from an array',
+        category: 'array',
+        signature: 'unique(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.unique(trigger.tags)}}'],
+        execute: (arr) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return Array.from(new Set(arr));
+        },
+    },
+    flatten: {
+        name: 'flatten',
+        description: 'Flattens a nested array by one level',
+        category: 'array',
+        signature: 'flatten(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.flatten([[1, 2], [3, 4]])}}'],
+        execute: (arr) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return arr.flat();
+        },
+    },
+    compact: {
+        name: 'compact',
+        description: 'Removes falsy values from an array',
+        category: 'array',
+        signature: 'compact(arr)',
+        args: [
+            {
+                name: 'arr',
+                type: 'array',
+                required: true,
+                description: 'Input array',
+            },
+        ],
+        returnType: 'array',
+        examples: ['{{fn.compact([0, 1, false, 2, "", 3])}}'],
+        execute: (arr) => {
+            if (!Array.isArray(arr)) {
+                return [];
+            }
+            return arr.filter(Boolean);
+        },
+    },
+};