@kong-ui-public/entities-plugins 9.44.2 → 9.45.0

package/dist/types/components/free-form/Datakit/flow-editor/store/store.d.ts

@@ -0,0 +1,441 @@
+import type { ConfigNode, ConfigNodeType, EdgeData, EdgeInstance, EdgeId, EditorState, FieldId, FieldName, NodePhase, NodeInstance, NodeId, NodeName, UINode } from '../../types';
+export declare const provideEditorState: (configNodes: ConfigNode[], uiNodes: UINode[]) => {
+    state: import("vue").Ref<{
+        nodes: {
+            id: NodeId;
+            type: import("../../types").NodeType;
+            name: NodeName;
+            phase: NodePhase;
+            position: {
+                x: number;
+                y: number;
+            };
+            expanded: {
+                input?: boolean | undefined;
+                output?: boolean | undefined;
+            };
+            fields: {
+                input: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+                output: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+            };
+            config?: Record<string, unknown> | undefined;
+        }[];
+        edges: {
+            id: EdgeId;
+            source: NodeId;
+            sourceField?: FieldId | undefined;
+            target: NodeId;
+            targetField?: FieldId | undefined;
+        }[];
+    }, EditorState | {
+        nodes: {
+            id: NodeId;
+            type: import("../../types").NodeType;
+            name: NodeName;
+            phase: NodePhase;
+            position: {
+                x: number;
+                y: number;
+            };
+            expanded: {
+                input?: boolean | undefined;
+                output?: boolean | undefined;
+            };
+            fields: {
+                input: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+                output: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+            };
+            config?: Record<string, unknown> | undefined;
+        }[];
+        edges: {
+            id: EdgeId;
+            source: NodeId;
+            sourceField?: FieldId | undefined;
+            target: NodeId;
+            targetField?: FieldId | undefined;
+        }[];
+    }>;
+    selection: import("vue").Ref<`node:${number}` | undefined, `node:${number}` | undefined>;
+    nodeMapById: import("vue").ComputedRef<Map<`node:${number}`, NodeInstance>>;
+    nodeMapByName: import("vue").ComputedRef<Map<NodeName, NodeInstance>>;
+    edgeMapById: import("vue").ComputedRef<Map<`edge:${number}`, EdgeInstance>>;
+    getNodeById: (id: NodeId) => NodeInstance | undefined;
+    getNodeByName: (name: NodeName) => NodeInstance | undefined;
+    getEdgeById: (id: EdgeId) => EdgeInstance | undefined;
+    selectedNode: import("vue").ComputedRef<NodeInstance | undefined>;
+    selectNode: (id?: NodeId) => void;
+    addNode: (payload: {
+        type: ConfigNodeType;
+        name?: NodeName;
+        phase?: NodePhase;
+        position?: {
+            x: number;
+            y: number;
+        };
+        fields?: {
+            input?: FieldName[];
+            output?: FieldName[];
+        };
+        config?: Record<string, unknown>;
+    }, commitNow?: boolean) => `node:${number}` | undefined;
+    removeNode: (nodeId: NodeId, commitNow?: boolean) => void;
+    renameNode: (nodeId: NodeId, newName: NodeName, commitNow?: boolean) => void;
+    moveNode: (nodeId: NodeId, position: {
+        x: number;
+        y: number;
+    }, commitNow?: boolean) => void;
+    toggleExpanded: (nodeId: NodeId, io: "input" | "output", value?: boolean, commitNow?: boolean) => void;
+    replaceConfig: (nodeId: NodeId, next: Record<string, unknown>, commitNow?: boolean) => void;
+    addField: (nodeId: NodeId, io: "input" | "output", name: FieldName, commitNow?: boolean) => void;
+    renameField: (nodeId: NodeId, fieldId: FieldId, newName: FieldName, commitNow?: boolean) => void;
+    removeField: (nodeId: NodeId, fieldId: FieldId, cascade?: boolean, commitNow?: boolean) => void;
+    connectEdge: (payload: EdgeData, commitNow?: boolean) => `edge:${number}` | undefined;
+    replaceConnection: (edgeId: EdgeId, next: EdgeData, commitNow?: boolean) => void;
+    disconnectEdge: (edgeId: EdgeId, commitNow?: boolean) => void;
+    toConfigNodes: () => ConfigNode[];
+    toUINodes: () => UINode[];
+    load: (nextConfig: ConfigNode[], nextUI: UINode[]) => void;
+    commit: (tag?: string, opts?: {
+        replace?: boolean;
+    } | undefined) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    clear: () => void;
+    reset: () => void;
+    requestNodes: import("vue").ComputedRef<{
+        id: `node:${number}`;
+        type: import("../../types").NodeType;
+        position: {
+            x: number;
+            y: number;
+        };
+        data: {
+            id: NodeId;
+            type: import("../../types").NodeType;
+            name: NodeName;
+            phase: NodePhase;
+            position: {
+                x: number;
+                y: number;
+            };
+            expanded: {
+                input?: boolean | undefined;
+                output?: boolean | undefined;
+            };
+            fields: {
+                input: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+                output: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+            };
+            config?: Record<string, unknown> | undefined;
+        };
+    }[]>;
+    requestEdges: import("vue").ComputedRef<{
+        id: `edge:${number}`;
+        source: `node:${number}`;
+        target: `node:${number}`;
+        sourceHandle: `field:${number}` | undefined;
+        targetHandle: `field:${number}` | undefined;
+        data: {
+            id: EdgeId;
+            source: NodeId;
+            sourceField?: FieldId | undefined;
+            target: NodeId;
+            targetField?: FieldId | undefined;
+        };
+    }[]>;
+    responseNodes: import("vue").ComputedRef<{
+        id: `node:${number}`;
+        type: import("../../types").NodeType;
+        position: {
+            x: number;
+            y: number;
+        };
+        data: {
+            id: NodeId;
+            type: import("../../types").NodeType;
+            name: NodeName;
+            phase: NodePhase;
+            position: {
+                x: number;
+                y: number;
+            };
+            expanded: {
+                input?: boolean | undefined;
+                output?: boolean | undefined;
+            };
+            fields: {
+                input: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+                output: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+            };
+            config?: Record<string, unknown> | undefined;
+        };
+    }[]>;
+    responseEdges: import("vue").ComputedRef<{
+        id: `edge:${number}`;
+        source: `node:${number}`;
+        target: `node:${number}`;
+        sourceHandle: `field:${number}` | undefined;
+        targetHandle: `field:${number}` | undefined;
+        data: {
+            id: EdgeId;
+            source: NodeId;
+            sourceField?: FieldId | undefined;
+            target: NodeId;
+            targetField?: FieldId | undefined;
+        };
+    }[]>;
+    isValidConnection: (edge: EdgeData) => boolean;
+    isValidVueFlowConnection: (conn: {
+        source?: string | null;
+        sourceHandle?: string | null;
+        target?: string | null;
+        targetHandle?: string | null;
+    }) => boolean;
+    validateGraph: () => import("./validation").ValidationResult;
+}, useEditorState: () => {
+    state: import("vue").Ref<{
+        nodes: {
+            id: NodeId;
+            type: import("../../types").NodeType;
+            name: NodeName;
+            phase: NodePhase;
+            position: {
+                x: number;
+                y: number;
+            };
+            expanded: {
+                input?: boolean | undefined;
+                output?: boolean | undefined;
+            };
+            fields: {
+                input: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+                output: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+            };
+            config?: Record<string, unknown> | undefined;
+        }[];
+        edges: {
+            id: EdgeId;
+            source: NodeId;
+            sourceField?: FieldId | undefined;
+            target: NodeId;
+            targetField?: FieldId | undefined;
+        }[];
+    }, EditorState | {
+        nodes: {
+            id: NodeId;
+            type: import("../../types").NodeType;
+            name: NodeName;
+            phase: NodePhase;
+            position: {
+                x: number;
+                y: number;
+            };
+            expanded: {
+                input?: boolean | undefined;
+                output?: boolean | undefined;
+            };
+            fields: {
+                input: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+                output: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+            };
+            config?: Record<string, unknown> | undefined;
+        }[];
+        edges: {
+            id: EdgeId;
+            source: NodeId;
+            sourceField?: FieldId | undefined;
+            target: NodeId;
+            targetField?: FieldId | undefined;
+        }[];
+    }>;
+    selection: import("vue").Ref<`node:${number}` | undefined, `node:${number}` | undefined>;
+    nodeMapById: import("vue").ComputedRef<Map<`node:${number}`, NodeInstance>>;
+    nodeMapByName: import("vue").ComputedRef<Map<NodeName, NodeInstance>>;
+    edgeMapById: import("vue").ComputedRef<Map<`edge:${number}`, EdgeInstance>>;
+    getNodeById: (id: NodeId) => NodeInstance | undefined;
+    getNodeByName: (name: NodeName) => NodeInstance | undefined;
+    getEdgeById: (id: EdgeId) => EdgeInstance | undefined;
+    selectedNode: import("vue").ComputedRef<NodeInstance | undefined>;
+    selectNode: (id?: NodeId) => void;
+    addNode: (payload: {
+        type: ConfigNodeType;
+        name?: NodeName;
+        phase?: NodePhase;
+        position?: {
+            x: number;
+            y: number;
+        };
+        fields?: {
+            input?: FieldName[];
+            output?: FieldName[];
+        };
+        config?: Record<string, unknown>;
+    }, commitNow?: boolean) => `node:${number}` | undefined;
+    removeNode: (nodeId: NodeId, commitNow?: boolean) => void;
+    renameNode: (nodeId: NodeId, newName: NodeName, commitNow?: boolean) => void;
+    moveNode: (nodeId: NodeId, position: {
+        x: number;
+        y: number;
+    }, commitNow?: boolean) => void;
+    toggleExpanded: (nodeId: NodeId, io: "input" | "output", value?: boolean, commitNow?: boolean) => void;
+    replaceConfig: (nodeId: NodeId, next: Record<string, unknown>, commitNow?: boolean) => void;
+    addField: (nodeId: NodeId, io: "input" | "output", name: FieldName, commitNow?: boolean) => void;
+    renameField: (nodeId: NodeId, fieldId: FieldId, newName: FieldName, commitNow?: boolean) => void;
+    removeField: (nodeId: NodeId, fieldId: FieldId, cascade?: boolean, commitNow?: boolean) => void;
+    connectEdge: (payload: EdgeData, commitNow?: boolean) => `edge:${number}` | undefined;
+    replaceConnection: (edgeId: EdgeId, next: EdgeData, commitNow?: boolean) => void;
+    disconnectEdge: (edgeId: EdgeId, commitNow?: boolean) => void;
+    toConfigNodes: () => ConfigNode[];
+    toUINodes: () => UINode[];
+    load: (nextConfig: ConfigNode[], nextUI: UINode[]) => void;
+    commit: (tag?: string, opts?: {
+        replace?: boolean;
+    } | undefined) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    clear: () => void;
+    reset: () => void;
+    requestNodes: import("vue").ComputedRef<{
+        id: `node:${number}`;
+        type: import("../../types").NodeType;
+        position: {
+            x: number;
+            y: number;
+        };
+        data: {
+            id: NodeId;
+            type: import("../../types").NodeType;
+            name: NodeName;
+            phase: NodePhase;
+            position: {
+                x: number;
+                y: number;
+            };
+            expanded: {
+                input?: boolean | undefined;
+                output?: boolean | undefined;
+            };
+            fields: {
+                input: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+                output: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+            };
+            config?: Record<string, unknown> | undefined;
+        };
+    }[]>;
+    requestEdges: import("vue").ComputedRef<{
+        id: `edge:${number}`;
+        source: `node:${number}`;
+        target: `node:${number}`;
+        sourceHandle: `field:${number}` | undefined;
+        targetHandle: `field:${number}` | undefined;
+        data: {
+            id: EdgeId;
+            source: NodeId;
+            sourceField?: FieldId | undefined;
+            target: NodeId;
+            targetField?: FieldId | undefined;
+        };
+    }[]>;
+    responseNodes: import("vue").ComputedRef<{
+        id: `node:${number}`;
+        type: import("../../types").NodeType;
+        position: {
+            x: number;
+            y: number;
+        };
+        data: {
+            id: NodeId;
+            type: import("../../types").NodeType;
+            name: NodeName;
+            phase: NodePhase;
+            position: {
+                x: number;
+                y: number;
+            };
+            expanded: {
+                input?: boolean | undefined;
+                output?: boolean | undefined;
+            };
+            fields: {
+                input: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+                output: {
+                    id: FieldId;
+                    name: FieldName;
+                }[];
+            };
+            config?: Record<string, unknown> | undefined;
+        };
+    }[]>;
+    responseEdges: import("vue").ComputedRef<{
+        id: `edge:${number}`;
+        source: `node:${number}`;
+        target: `node:${number}`;
+        sourceHandle: `field:${number}` | undefined;
+        targetHandle: `field:${number}` | undefined;
+        data: {
+            id: EdgeId;
+            source: NodeId;
+            sourceField?: FieldId | undefined;
+            target: NodeId;
+            targetField?: FieldId | undefined;
+        };
+    }[]>;
+    isValidConnection: (edge: EdgeData) => boolean;
+    isValidVueFlowConnection: (conn: {
+        source?: string | null;
+        sourceHandle?: string | null;
+        target?: string | null;
+        targetHandle?: string | null;
+    }) => boolean;
+    validateGraph: () => import("./validation").ValidationResult;
+} | undefined;
+//# sourceMappingURL=store.d.ts.map

package/dist/types/components/free-form/Datakit/flow-editor/store/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/free-form/Datakit/flow-editor/store/store.ts"],"names":[],"mappings":"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"}

package/dist/types/components/free-form/Datakit/flow-editor/store/validation.d.ts

@@ -0,0 +1,25 @@
+import type { Ref } from 'vue';
+import type { EditorState, EdgeData } from '../../types';
+export type ValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Validators bound to a reactive EditorState.
+ * Always reads the latest state through computed getters.
+ */
+export declare function useValidators(stateRef: Ref<EditorState>): {
+    canonicalizeConnection: (edge: EdgeData) => EdgeData;
+    validateConnection: (raw: EdgeData) => ValidationResult;
+    validateGraph: () => ValidationResult;
+    isValidConnection: (edge: EdgeData) => boolean;
+    isValidVueFlowConnection: (conn: {
+        source?: string | null;
+        sourceHandle?: string | null;
+        target?: string | null;
+        targetHandle?: string | null;
+    }) => boolean;
+};
+//# sourceMappingURL=validation.d.ts.map

package/dist/types/components/free-form/Datakit/flow-editor/store/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/free-form/Datakit/flow-editor/store/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAE9B,OAAO,KAAK,EACV,WAAW,EAEX,QAAQ,EAIT,MAAM,aAAa,CAAA;AAGpB,MAAM,MAAM,gBAAgB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAE7E;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,GAAG,CAAC,WAAW,CAAC;mCAchB,QAAQ,KAAG,QAAQ;8BAuDxB,QAAQ,KAAG,gBAAgB;yBAsElC,gBAAgB;8BA8BT,QAAQ,KAAG,OAAO;qCAIX;QACtC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACtB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACtB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAC7B;EAiBF"}

package/dist/types/components/free-form/Datakit/types.d.ts

@@ -3,10 +3,14 @@ import type { ButtonProps } from '@kong/kongponents';
 import type { FreeFormPluginData } from '../../../types/plugins/free-form';
 import type { HttpMethod } from './constants';
 export type { HttpMethod };
-export type EditorMode = 'code' | 'flow';
 type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Keys extends any ? Omit<T, Keys> & {
     [K in Keys]-?: T[K];
 } : never;
+declare const brand: unique symbol;
+type Brand<T, Brand extends string> = T & {
+    [brand]: Brand;
+};
+export type EditorMode = 'code' | 'flow';
 interface EditorModalNavItemBase {
     label: string;
     icon: Component;
@@ -20,9 +24,9 @@ export type EditorModalNavItem = RequireAtLeastOne<EditorModalNavItemBase, 'to'
 /**
  * All explicit node types recognised by Datakit.
  */
-export type UserNodeType = 'call' | 'jq' | 'exit' | 'property' | 'static';
+export type ConfigNodeType = 'call' | 'jq' | 'exit' | 'property' | 'static';
 export type ImplicitNodeType = 'request' | 'service_request' | 'service_response' | 'response';
-export type NodeType = UserNodeType | ImplicitNodeType;
+export type NodeType = ConfigNodeType | ImplicitNodeType;
 export interface NodeMeta {
     type: NodeType;
     summary?: string;
@@ -32,8 +36,8 @@ export interface NodeMeta {
      * Well-known fields for the node.
      */
     fields?: {
-        input?: string[];
-        output?: string[];
+        input?: FieldName[];
+        output?: FieldName[];
     };
 }
 /************************************************
@@ -49,7 +53,7 @@ export interface DatakitConfig {
      *
      * * Must contain at least one element.
      */
-    nodes: UserNode[];
+    nodes: ConfigNode[];
     /**
      * Enable verbose debug logging.
      *
@@ -81,7 +85,8 @@ export type ImplicitNodeName = 'request' | 'service_request' | 'service_response
  * @example 'filter_01'
  * @example 'filter_02'
  */
-export type NodeName = string & {};
+export type ConfigNodeName = Brand<string, 'ConfigNodeName'>;
+export type NodeName = ConfigNodeName | ImplicitNodeName;
 /**
  * The phase of the node in the request/response cycle.
  *
@@ -91,20 +96,36 @@ export type NodePhase = 'request' | 'response';
 /**
  * Base shape shared by every concrete node type.
  */
-interface BaseNode {
+interface BaseConfigNode {
     /**
      * Unique label for referencing the node in connections.
      */
-    name: NodeName | ImplicitNodeName;
+    name: NodeName;
     /**
      * The type of the node.
      */
     type: NodeType;
+    /**
+     * node input (`NODE` or `NODE.FIELD`)
+     */
+    input?: string;
+    /**
+     * node inputs
+     */
+    inputs?: Record<FieldName, string>;
+    /**
+     * node output (`NODE` or `NODE.FIELD`)
+     */
+    output?: string;
+    /**
+     * node inputs
+     */
+    outputs?: Record<FieldName, string>;
 }
 /**
  * Make an external HTTP request.
  */
-export interface CallNode extends BaseNode {
+export interface CallNode extends BaseConfigNode {
     type: 'call';
     /**
      * A string representing an HTTP method, such as GET, POST, PUT, or
@@ -157,7 +178,7 @@ export interface CallNode extends BaseNode {
 /**
  * Terminate the request and send a response to the client.
  */
-export interface ExitNode extends BaseNode {
+export interface ExitNode extends BaseConfigNode {
     type: 'exit';
     /**
      * HTTP status code.
@@ -185,7 +206,7 @@ export interface ExitNode extends BaseNode {
 /**
  * Process data using `jq` syntax.
  */
-export interface JqNode extends BaseNode {
+export interface JqNode extends BaseConfigNode {
     type: 'jq';
     /**
      * The jq filter text. Refer to https://jqlang.org/manual/ for full
@@ -199,14 +220,14 @@ export interface JqNode extends BaseNode {
     /**
      * filter input(s)
      */
-    inputs?: Record<string, string>;
+    inputs?: Record<FieldName, string>;
     /** filter output (`NODE` or `NODE.FIELD`) */
     output?: string;
 }
 /**
  * Get or set a property.
  */
-export interface PropertyNode extends BaseNode {
+export interface PropertyNode extends BaseConfigNode {
     type: 'property';
     /**
      * The expected MIME type of the property value. When set to
@@ -234,7 +255,7 @@ export interface PropertyNode extends BaseNode {
 /**
  * Produce reusable outputs from statically-configured values.
  */
-export interface StaticNode extends BaseNode {
+export interface StaticNode extends BaseConfigNode {
     type: 'static';
     /**
      * An object with string keys and free-form values.
@@ -247,17 +268,24 @@ export interface StaticNode extends BaseNode {
     /**
      * Individual items from `.values`, referenced by key.
      */
-    outputs?: Record<string, string>;
+    outputs?: Record<FieldName, string>;
 }
 /**
  * Discriminated union of all node types.
  */
-export type UserNode = CallNode | ExitNode | JqNode | PropertyNode | StaticNode;
+export type ConfigNode = CallNode | ExitNode | JqNode | PropertyNode | StaticNode;
 /************************************************
  *             Editor global store              *
  ************************************************/
-export interface NodeData {
-    type: NodeType;
+export type NodeId = `node:${number}`;
+export type EdgeId = `edge:${number}`;
+export type FieldId = `field:${number}`;
+export type FieldName = Brand<string, 'FieldName'>;
+export interface NodeField {
+    id: FieldId;
+    name: FieldName;
+}
+export type UINode = {
     name: NodeName;
     phase: NodePhase;
     position: {
@@ -265,17 +293,50 @@ export interface NodeData {
         y: number;
     };
     fields: {
-        input?: string[];
-        output?: string[];
+        input?: FieldName[];
+        output?: FieldName[];
     };
     expanded: {
         input?: boolean;
         output?: boolean;
     };
-    inputs?: string | Record<string, string>;
+};
+export interface NodeInstance {
+    id: NodeId;
+    type: NodeType;
+    name: NodeName;
+    phase: NodePhase;
+    position: {
+        x: number;
+        y: number;
+    };
+    expanded: {
+        input?: boolean;
+        output?: boolean;
+    };
+    fields: {
+        input: NodeField[];
+        output: NodeField[];
+    };
     config?: Record<string, unknown>;
 }
+export interface ConfigEdge {
+    source: NodeName;
+    sourceField?: FieldName;
+    target: NodeName;
+    targetField?: FieldName;
+}
+export interface EdgeData {
+    source: NodeId;
+    sourceField?: FieldId;
+    target: NodeId;
+    targetField?: FieldId;
+}
+export interface EdgeInstance extends EdgeData {
+    id: EdgeId;
+}
 export interface EditorState {
-    nodes: NodeData[];
+    nodes: NodeInstance[];
+    edges: EdgeInstance[];
 }
 //# sourceMappingURL=types.d.ts.map