@transai/connector-runner-mkg 0.2.0 → 0.4.0

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

@@ -0,0 +1,8 @@
+export interface TenantInterface {
+    identifier: string;
+    name: string;
+    domain: string;
+    bi?: string;
+    isActive: boolean;
+    useApi: boolean;
+}

package/libs/types/src/lib/management-api/type-enums.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+export declare enum DatasetTypeEnum {
+    documents = "documents",
+    metrics = "metrics",
+    events = "events"
+}
+export declare enum FilterOperatorsEnum {
+    equals = "=",
+    notEquals = "<>",
+    greaterThan = ">",
+    greaterThanOrEqual = ">=",
+    lessThan = "<",
+    lessThanOrEqual = "<=",
+    in = "IN"
+}
+export declare const FilterValueType: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">]>;
+export type FilterValueType = z.infer<typeof FilterValueType>;
+export declare enum FilterGroupTypesEnum {
+    and = "AND",
+    or = "OR"
+}
+export declare const FieldValueType: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+export type FieldValueType = z.infer<typeof FieldValueType>;
+export declare enum DimensionTypesEnum {
+    string = "string",
+    number = "number",
+    boolean = "boolean",
+    time = "time"
+}
+export declare enum DimensionFormatsEnum {
+    id = "image_url",
+    imageUrl = "image_url",
+    link = "link",
+    percent = "percent",
+    currency = "currency"
+}
+export declare enum RelationTypesEnum {
+    oneToOne = "one_to_one",
+    oneToMany = "one_to_many",
+    manyToOne = "many_to_one",
+    manyToMany = "many_to_many"
+}
+export declare enum MeasureTypesEnum {
+    count = "count",
+    countDistinct = "count_distinct",
+    countDistinctApprox = "count_distinct_approx",
+    sum = "sum",
+    avg = "avg",
+    min = "min",
+    max = "max",
+    string = "string",
+    time = "time",
+    boolean = "boolean",
+    number = "number"
+}
+export declare enum MeasureFormatsEnum {
+    percent = "percent",
+    currency = "currency"
+}
+export declare enum SemanticTriggerFilterOperatorsEnum {
+    equals = "equals",
+    notEquals = "notEquals",
+    contains = "contains",
+    notContains = "notContains",
+    startsWith = "startsWith",
+    notStartsWith = "notStartsWith",
+    endsWith = "endsWith",
+    notEndsWith = "notEndsWith",
+    gt = "gt",
+    gte = "gte",
+    lt = "lt",
+    lte = "lte",
+    set = "set",
+    notSet = "notSet",
+    inDateRange = "inDateRange",
+    notInDateRange = "notInDateRange",
+    beforeDate = "beforeDate",
+    beforeOrOnDate = "beforeOrOnDate",
+    afterDate = "afterDate",
+    afterOrOnDate = "afterOrOnDate"
+}
+export declare enum ConnectorOrigin {
+    from_template = "from_template",
+    manual = "manual"
+}

package/libs/types/src/lib/management-api/web/generic-filter.dto.d.ts

@@ -0,0 +1,37 @@
+import { PaginationInterface } from './index';
+export declare const FilterOperator: {
+    readonly EQ: "eq";
+    readonly NEQ: "neq";
+    readonly CONTAINS: "ct";
+    readonly NOT_CONTAINS: "nct";
+    readonly STARTSWITH: "sw";
+    readonly ENDSWITH: "ew";
+    readonly NOT_STARTSWITH: "nsw";
+    readonly NOT_ENDSWITH: "new";
+    readonly BETWEEN: "bt";
+    readonly LT: "lt";
+    readonly LTE: "lte";
+    readonly GT: "gt";
+    readonly GTE: "gte";
+    readonly IN: "in";
+    readonly NOT_IN: "nin";
+    readonly LIKE: "like";
+};
+export type FilterOperator = (typeof FilterOperator)[keyof typeof FilterOperator];
+export type FilterValue = {
+    [operator in FilterOperator]?: string | number | boolean | string[];
+};
+export declare const SortDirection: {
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+};
+export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
+export type SortOrder<T> = {
+    [field in keyof T]?: (typeof SortDirection)[keyof typeof SortDirection];
+};
+export interface GenericFilterDto<T> extends PaginationInterface {
+    filter?: {
+        [field in keyof T]?: FilterValue;
+    };
+    sort?: SortOrder<T>;
+}

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

@@ -0,0 +1,2 @@
+export * from './generic-filter.dto';
+export * from './paginated-response.interface';

package/libs/types/src/lib/management-api/web/paginated-response.interface.d.ts

@@ -0,0 +1,17 @@
+export interface PaginationInterface {
+    page: number;
+    limit: number;
+}
+export interface QueryPaginationInterface {
+    skip: number;
+    take: number;
+}
+export interface PaginationMeta {
+    page: number;
+    limit: number;
+    total: number;
+}
+export interface PaginatedResponse<T> {
+    meta: PaginationMeta;
+    data: Array<T>;
+}

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

@@ -0,0 +1,85 @@
+import { ConnectorOrigin } from '@xip-online-data/types';
+import { z } from 'zod';
+export interface InputParameterInterface {
+    name: 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: unknown;
+    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;
+        type: z.ZodEnum<["string", "number", "boolean", "array"]>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        items: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean" | "array";
+        name: string;
+        required?: boolean | undefined;
+        items?: any[] | undefined;
+    }, {
+        type: "string" | "number" | "boolean" | "array";
+        name: string;
+        required?: boolean | undefined;
+        items?: any[] | undefined;
+    }>, "many">;
+    outputParameters: z.ZodAny;
+    mode: z.ZodOptional<z.ZodNativeEnum<typeof ConnectorOrigin>>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    identifier: string;
+    version: string;
+    name: string;
+    config: Record<string, any>;
+    inputParameters: {
+        type: "string" | "number" | "boolean" | "array";
+        name: string;
+        required?: boolean | undefined;
+        items?: any[] | undefined;
+    }[];
+    mode?: ConnectorOrigin | undefined;
+    createdAt?: Date | undefined;
+    description?: string | undefined;
+    outputParameters?: any;
+    updatedAt?: Date | undefined;
+}, {
+    identifier: string;
+    version: string;
+    name: string;
+    config: Record<string, any>;
+    inputParameters: {
+        type: "string" | "number" | "boolean" | "array";
+        name: string;
+        required?: boolean | undefined;
+        items?: any[] | undefined;
+    }[];
+    mode?: ConnectorOrigin | undefined;
+    createdAt?: Date | undefined;
+    description?: string | undefined;
+    outputParameters?: any;
+    updatedAt?: Date | undefined;
+}>;

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,57 @@
+import { TriggerType } from './trigger-types.interface';
+import { NodeTypes, WorkflowDrawing } from './workflow.drawing';
+export interface MessageMapper {
+    [key: string]: {
+        selector: string;
+        type?: string;
+        required?: boolean;
+    };
+}
+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,70 @@
+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 | AgentJob>;
+    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 AgentJob extends WorkflowJobInterface {
+    type: NodeTypes.AGENT;
+    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,102 @@
+import { TriggerType } from './trigger-types.interface';
+import { ConditionMapper, MessageMapper } from './workflow-definition.interface';
+export declare enum NodeTypes {
+    TRIGGER = "TRIGGER",
+    ACTION = "ACTION",
+    AGENT = "AGENT",
+    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 AgentNode extends Node {
+    type: NodeTypes.AGENT;
+    agent: {
+        identifier: 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 | AgentNode | 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;