@transai/connector-runner-otto-fleet-manager-v2 0.6.1

package/libs/types/src/lib/management-api/workflow/action.interface.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { ConnectorOrigin } from '../type-enums';
+export interface LegacyOutputParameterInterface {
+    [key: string]: string;
+}
+export type SupportedOutputTypes = 'string' | 'number' | 'boolean' | 'array' | 'null';
+export interface OutputItemParameterInterface {
+    type: SupportedOutputTypes | SupportedOutputTypes[];
+    description?: string;
+    required?: boolean;
+}
+export interface ArrayOutputParameterInterface extends OutputItemParameterInterface {
+    type: 'array';
+    items: OutputParameterInterface;
+}
+export interface NumberOutputParameterInterface extends OutputItemParameterInterface {
+    type: 'number' | ('number' | 'null')[];
+    minimum?: number;
+    maximum?: number;
+}
+export interface OutputParameterInterface {
+    [key: string]: OutputItemParameterInterface | ArrayOutputParameterInterface | NumberOutputParameterInterface;
+}
+export interface InputParameterInterface {
+    name: string;
+    description?: string;
+    type: 'string' | 'number' | 'boolean' | 'array';
+    required?: boolean;
+    items?: Array<InputParameterInterface>;
+}
+export interface ActionInterface {
+    identifier: string;
+    version: string;
+    tenantIdentifier: string;
+    name: string;
+    description?: string;
+    connectorIdentifier: string;
+    config: {
+        [key: string]: {
+            [key: string]: string | object;
+        } | string | object;
+    };
+    inputParameters: Array<InputParameterInterface>;
+    outputParameters: LegacyOutputParameterInterface | OutputParameterInterface;
+    mode?: ConnectorOrigin;
+    createdAt: Date;
+}
+export type CreateActionInterface = Omit<ActionInterface, 'mode' | 'createdAt'>;
+export declare const ActionSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    config: z.ZodRecord<z.ZodString, z.ZodAny>;
+    inputParameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            array: "array";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        items: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    }, z.core.$strip>>;
+    outputParameters: z.ZodRecord<z.ZodString, z.ZodAny>;
+    mode: z.ZodOptional<z.ZodEnum<typeof ConnectorOrigin>>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;

package/libs/types/src/lib/management-api/workflow/index.d.ts

@@ -0,0 +1,6 @@
+export * from './action.interface';
+export * from './offset.interface';
+export * from './workflow-definition.interface';
+export * from './workflow-run';
+export * from './workflow.drawing';
+export * from './trigger-types.interface';

package/libs/types/src/lib/management-api/workflow/offset.interface.d.ts

@@ -0,0 +1,14 @@
+export interface ExtendedOffsetStore {
+    timestamp: number;
+    id: number | string;
+    date?: string;
+    rawTimestamp: number | string;
+    [key: string]: string | number | undefined;
+}
+export interface OffsetInterface {
+    identifier: string;
+    tenantIdentifier: string;
+    offset: ExtendedOffsetStore;
+    connectorIdentifier: string;
+    userOverwrite: boolean;
+}

package/libs/types/src/lib/management-api/workflow/trigger-types.interface.d.ts

@@ -0,0 +1,14 @@
+export declare enum TriggerType {
+    DASHBOARD_VISUALIZATION = "dashboard_visualization",
+    FORM = "form",
+    SEMANTIC_TRIGGER = "semantic_trigger",
+    CUSTOM_CRON = "custom_cron",
+    /**
+     * @deprecated Use SEMANTIC_TRIGGER instead
+     */
+    SEMANTIC = "SEMANTIC",
+    /**
+     * @deprecated Use DASHBOARD_VISUALIZATION instead
+     */
+    DASHBOARD = "DASHBOARD"
+}

package/libs/types/src/lib/management-api/workflow/workflow-definition.interface.d.ts

@@ -0,0 +1,64 @@
+import { TriggerType } from './trigger-types.interface';
+import { NodeTypes, WorkflowDrawing } from './workflow.drawing';
+export interface ValueMapper {
+    selector: string;
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+}
+export interface ArrayMapper {
+    selector: string;
+    type: 'array';
+    required?: boolean;
+    items: MessageMapper;
+}
+export type MessageMapper = {
+    [key: string]: ValueMapper | ArrayMapper;
+};
+export interface ConditionMapper {
+    selector: string;
+    [key: string]: string | {
+        id: string;
+        value: string;
+    };
+}
+export type NodeMapper = MessageMapper | ConditionMapper;
+export interface TriggerInterface {
+    name: string;
+    type: TriggerType;
+    identifier: string;
+    expression?: string;
+}
+export interface CreateWorkflowDefinitionStep {
+    name: string;
+    identifier: string;
+    requires: Array<string>;
+    type: NodeTypes;
+    operationIdentifier: string;
+    operationVersion?: string;
+    with: NodeMapper;
+}
+export interface WorkflowDefinitionStep extends CreateWorkflowDefinitionStep {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface CreateWorkflowDefinition {
+    identifier: string;
+    name: string;
+    ttl: number;
+    triggerName: string;
+    triggerType: TriggerType;
+    triggerIdentifier: string;
+    semanticIdentifier: string;
+    steps: Array<CreateWorkflowDefinitionStep>;
+    enabled: boolean;
+    workflowDrawing?: WorkflowDrawing;
+    trigger?: TriggerInterface;
+}
+export interface WorkflowDefinition extends CreateWorkflowDefinition {
+    steps: Array<WorkflowDefinitionStep>;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tenantIdentifier: string;
+}

package/libs/types/src/lib/management-api/workflow/workflow-run.d.ts

@@ -0,0 +1,66 @@
+import { EventInterface } from '../event-origin.interface';
+import { ConditionMapper, MessageMapper, NodeMapper, WorkflowDefinition, WorkflowDefinitionStep } from './workflow-definition.interface';
+import { NodeTypes, WorkflowDrawing } from './workflow.drawing';
+export declare enum WorkflowRunStatusStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SUCCESS = "SUCCESS",
+    FAILED = "FAILED"
+}
+export declare enum WorkflowJobStatusStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SUCCESS = "SUCCESS",
+    SKIPPED = "SKIPPED",
+    BAD_REQUEST = "BAD_REQUEST",// input validation errors
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR",
+    ABORTED = "ABORTED"
+}
+export interface WorkflowRunInterface {
+    id: string;
+    tenantIdentifier: string;
+    semanticIdentifier: string;
+    status: WorkflowRunStatusStatus;
+    ttl: number;
+    workflow: WorkflowDefinition;
+    drawing?: WorkflowDrawing;
+    trigger: EventInterface;
+    jobs: Array<ActionJob | ConditionalJob | ValidationJob>;
+    createdAt: Date;
+    updatedAt: Date;
+    testRun?: boolean;
+    restartOf?: string;
+}
+export interface WorkflowJobInterface {
+    id: string;
+    identifier: string;
+    run: WorkflowRunInterface;
+    status: WorkflowJobStatusStatus;
+    operationIdentifier: string;
+    operationVersion?: string;
+    payload?: Record<string, unknown> | undefined;
+    log?: string;
+    result?: unknown;
+    type: NodeTypes;
+    with: NodeMapper;
+    requires: Array<string>;
+    step: WorkflowDefinitionStep;
+    testRun?: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ActionJob extends WorkflowJobInterface {
+    type: NodeTypes.ACTION;
+    with: MessageMapper;
+}
+export interface ConditionalJob extends WorkflowJobInterface {
+    type: NodeTypes.CONDITIONAL;
+    with: ConditionMapper;
+}
+export interface ValidationJob extends WorkflowJobInterface {
+    type: NodeTypes.VALIDATION;
+    with: ConditionMapper;
+}
+export interface PlaceholderJob extends WorkflowJobInterface {
+    type: NodeTypes.PLACEHOLDER;
+}

package/libs/types/src/lib/management-api/workflow/workflow.drawing.d.ts

@@ -0,0 +1,94 @@
+import { TriggerType } from './trigger-types.interface';
+import { ConditionMapper, MessageMapper } from './workflow-definition.interface';
+export declare enum NodeTypes {
+    TRIGGER = "TRIGGER",
+    ACTION = "ACTION",
+    CONDITIONAL = "CONDITIONAL",
+    VALIDATION = "VALIDATION",
+    ANNOTATION = "ANNOTATION",
+    PLACEHOLDER = "PLACEHOLDER",
+    INVISIBLE = "INVISIBLE",
+    END = "END"
+}
+export declare enum ConditionalTypes {
+    TRUE_FALSE = "TRUE_FALSE",
+    CASE = "CASE"
+}
+export interface Conditional {
+    type: ConditionalTypes;
+}
+export interface Node {
+    id: string;
+    type: NodeTypes;
+    position: {
+        x: number;
+        y: number;
+    };
+    meta?: Record<string, string | Array<string>>;
+    name: string;
+}
+export interface ActionNode extends Node {
+    type: NodeTypes.ACTION;
+    action: {
+        identifier: string;
+        version: string;
+    };
+    with: MessageMapper;
+}
+export interface TriggerNode extends Node {
+    type: NodeTypes.TRIGGER;
+    trigger: {
+        name: string;
+        type: TriggerType;
+        identifier: string;
+    };
+}
+export interface ConditionalNode extends Node {
+    type: NodeTypes.CONDITIONAL;
+    condition: Conditional;
+    with: ConditionMapper;
+}
+export interface ValidationNode extends Node {
+    type: NodeTypes.VALIDATION;
+    with: ConditionMapper;
+}
+export interface AnnotationNode extends Node {
+    type: NodeTypes.ANNOTATION;
+}
+export interface EndNode extends Node {
+    type: NodeTypes.END;
+}
+export interface PlaceholderNode extends Node {
+    type: NodeTypes.PLACEHOLDER;
+}
+export interface InvisibleNode extends Node {
+    type: NodeTypes.INVISIBLE;
+}
+export type WorkflowNode = ActionNode | ConditionalNode | AnnotationNode | PlaceholderNode | ValidationNode | EndNode | InvisibleNode;
+export interface Edge {
+    id: string;
+    source: {
+        nodeId: string;
+    };
+    target: {
+        nodeId: string;
+    };
+    type: string;
+    meta?: Record<string, string | Array<string>>;
+}
+export interface CreateWorkflowDrawingInterface {
+    name: string;
+    description: string;
+    identifier: string;
+    ttl: number;
+    trigger: TriggerNode;
+    nodes: Array<WorkflowNode>;
+    edges: Array<Edge>;
+    enabled: boolean;
+}
+export interface WorkflowDrawing extends CreateWorkflowDrawingInterface {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    version: number;
+}

package/libs/types/src/lib/message.types.d.ts

@@ -0,0 +1,59 @@
+export interface XodBaseMessageType {
+    type: 'ACTION' | 'EVENT' | 'SOURCE' | 'JOB';
+    eventId: string;
+    eventType: string;
+    eventTopic?: string;
+    created: number;
+    payload: object;
+    ttl: number;
+    tenantIdentifier: string;
+    testRun?: boolean;
+    meta?: {
+        [key: string]: unknown;
+    };
+}
+export interface EventPayload {
+    tenantId: string;
+    data?: {
+        [key: string]: unknown;
+    };
+}
+export interface XodEventType extends XodBaseMessageType {
+    type: 'EVENT';
+    payload: EventPayload;
+}
+export interface XodActionPayloadType {
+    content?: string;
+    destination?: string;
+}
+export interface XodActionType extends XodBaseMessageType {
+    type: 'ACTION';
+    payload: XodActionPayloadType;
+}
+export interface XodJobType extends XodBaseMessageType {
+    type: 'JOB';
+    actionIdentifier: string;
+    actionVersion: string;
+    payload: Record<string, unknown>;
+}
+export interface XodSourcePayloadType {
+    keyField?: string;
+    incrementalField?: string;
+    collection?: string;
+    indexes?: Array<string>;
+    body: {
+        [key: string]: unknown;
+    };
+    metadata?: {
+        [key: string]: unknown;
+    };
+    priority?: boolean;
+    endOfBatch?: boolean;
+}
+export interface XodSourceMessageType extends XodBaseMessageType {
+    type: 'SOURCE';
+    payload: XodSourcePayloadType;
+}
+export declare function isXodBaseMessageType(obj: XodBaseMessageType): obj is XodBaseMessageType;
+export declare function isXodEventType(obj: XodEventType): obj is XodEventType;
+export declare function isXodActionType(obj: XodActionType): obj is XodActionType;

package/libs/types/src/lib/response.types.d.ts

@@ -0,0 +1,27 @@
+import { XodActionType, XodBaseMessageType, XodEventType, XodJobType } from './message.types';
+export interface KafkaCallbackResponse<T = unknown> {
+    success: boolean;
+    statusCode: number;
+    message: string;
+    payload?: T;
+}
+export type KafkaCallbackResponseType<T = string> = (additionalMessage?: T) => (message: XodBaseMessageType) => Promise<KafkaCallbackResponse>;
+export interface XodResponseType {
+    type: 'ACTION' | 'EVENT' | 'JOB';
+    message: XodActionType | XodEventType | XodJobType;
+    result: KafkaCallbackResponse;
+    responseSource: string;
+}
+export interface XodEventResponseType extends XodResponseType {
+    type: 'EVENT';
+    message: XodEventType;
+}
+export interface XodActionResponseType extends XodResponseType {
+    type: 'ACTION';
+    message: XodActionType;
+}
+export interface XodJobResponseType extends XodResponseType {
+    type: 'JOB';
+    message: XodJobType;
+}
+export declare function isXodResponseType(obj: any): obj is XodResponseType;

package/libs/types/src/lib/types.d.ts

@@ -0,0 +1,134 @@
+export interface MessageMonitorConfig {
+    type: 'in-memory' | 'redis' | 'disabled';
+}
+export declare enum ConfiguredConnectorTypes {
+    API = "api",
+    API_SINK = "api-sink",
+    API_SOURCE = "api-source",
+    DUMMY_NODE = "dummy-node",
+    FILE_COPY = "file-copy",
+    FILE = "file",
+    FILE_SINK = "file-sink",
+    FILE_SOURCE = "file-source",
+    SAMBA_SINK = "samba-sink",
+    SAMBA_SOURCE = "samba-source",
+    SQL_SINK = "sql-sink",
+    SQL_SOURCE = "sql-source",
+    MQTT = "mqtt",
+    CUBE_QUERY_RUNNER = "cube-query-runner",
+    FACTORY_NEBULA_SOURCE = "factory-nebula-source",
+    BYSTRONIC = "bystronic",
+    IMAP_SOURCE = "imap-source",
+    IMAP_SINK = "imap-sink",
+    OPCUA_SOURCE = "opcua-source",
+    OPCUA_SINK = "opcua-sink",
+    AI_AGENT = "ai-agent",
+    MICROSOFT_OFFICE365_EMAIL = "microsoft-office365-email",
+    MKG = "mkg",
+    EZ_MES = "ez-mes",
+    OTTO_FLEET_MANAGER_V2 = "otto-fleet-manager-v2",
+    FRAUNHOFER_BATTERY_ASSEMBLY_CELLS = "fraunhofer-battery-assembly-cells",
+    PDF_GENERATE = "pdf-generate",
+    ONSHAPE = "onshape"
+}
+export interface ConnectorConfig {
+    type: ConfiguredConnectorTypes;
+    identifier: string;
+}
+export interface RedisMessageMonitorConfig extends MessageMonitorConfig {
+    type: 'redis';
+    url: string;
+    ttl?: number;
+}
+export interface InMemoryMessageMonitorConfig extends MessageMonitorConfig {
+    type: 'in-memory';
+    messagesToKeep: number;
+}
+export interface DisabledMessageMonitorConfig extends MessageMonitorConfig {
+    type: 'disabled';
+}
+export interface TopicRegex {
+    pattern: string;
+    flags: string;
+}
+export interface FileRegex {
+    pattern: string;
+    flags: string;
+}
+export declare function isTopicRegex(obj: TopicRegex | string): obj is TopicRegex;
+export interface CubeConfigHeaders {
+    Authorization: string;
+}
+export interface CubeConfig {
+    auth0_client_secret?: string;
+    auth0_client_id?: string;
+    auth0_audience?: string;
+    auth0_token_url?: string;
+    authorization?: string;
+    apiUrl: string;
+    headers?: CubeConfigHeaders;
+    redis_url?: string;
+}
+export declare function isCubeConfigType(obj: CubeConfig): obj is CubeConfig;
+export interface AwsKafkaSaslConfig {
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    mechanism: 'aws';
+}
+export declare function isAwsKafkaSalsConfig(obj: AwsKafkaSaslConfig): obj is AwsKafkaSaslConfig;
+export interface DatabaseConfig {
+    uri: string;
+    ssl?: boolean;
+    tenantPassword?: string;
+}
+export interface ActionConfig {
+    timeSensitive: boolean;
+}
+export interface KafkaBrokerConfig {
+    groupId: string;
+    clientId: string;
+    brokers: Array<string>;
+    consumerTopics?: Array<string | TopicRegex>;
+    sasl?: AwsKafkaSaslConfig;
+    intervalCheckForNewTopics?: number;
+    disableLogs?: boolean;
+    autoCommitThreshold?: number;
+    autoCommitInterval?: number;
+    partitionsConsumedConcurrently?: number;
+    messageMonitor?: RedisMessageMonitorConfig | InMemoryMessageMonitorConfig | DisabledMessageMonitorConfig;
+    useConfluentLibrary?: boolean;
+    newConsumerProtocol?: boolean;
+}
+export declare function isKafkaBrokerConfigType(obj: KafkaBrokerConfig): obj is KafkaBrokerConfig;
+export declare function isActionConfigType(obj: any): obj is ActionConfig;
+export declare function isDatabaseConfigType(obj: DatabaseConfig): obj is DatabaseConfig;
+export interface BaseConnectorConfig {
+    processIdentifier: string;
+    tenantIdentifier: string;
+    datasourceIdentifier: string;
+    kafka: KafkaBrokerConfig;
+    action?: ActionConfig;
+}
+export declare function isBaseConnectorConfigType(obj: BaseConnectorConfig): obj is BaseConnectorConfig;
+export declare const OPENAI_MODELS: readonly ["gpt-3.5-turbo", "gpt-4", "gpt-4-turbo", "gpt-4o", "gpt-4o-mini", "gpt-5-nano", "gpt-5-mini", "gpt-5", "o1-preview", "o1-mini"];
+export declare const ANTHROPIC_MODELS: readonly ["claude-2", "claude-2-100k", "claude-instant-100k", "claude-sonnet-4-5"];
+export declare const MISTRAL_MODELS: readonly ["mistral-large-2512", "mistral-medium-2508", "mistral-small-2506"];
+export type OpenAiModel = (typeof OPENAI_MODELS)[number];
+export type AnthropicModel = (typeof ANTHROPIC_MODELS)[number];
+export type MistralModel = (typeof MISTRAL_MODELS)[number];
+export interface AiAgentModel {
+    apiKey: string;
+    provider: 'openai' | 'anthropic' | 'aws' | 'mistral';
+    model: OpenAiModel | AnthropicModel | MistralModel;
+    region?: string;
+    credentials?: {
+        secretAccessKey: string;
+        accessKeyId: string;
+    };
+    temperature?: number;
+    timeout?: number;
+}
+export interface AiAgentConfig extends BaseConnectorConfig {
+    model: AiAgentModel;
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@transai/connector-runner-otto-fleet-manager-v2",
+  "version": "0.6.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "LGPL-3.0-or-later",
+  "author": {
+    "name": "transAI",
+    "email": "samen@transai.com",
+    "url": "https://transai.com"
+  },
+  "type": "commonjs",
+  "main": "./index.cjs",
+  "typings": "./index.d.ts"
+}