Merge pull request #17 from code0-tech/update-tucana-again

Knerio · web-flow · commit b2a8bd7b7d6e · 2026-04-05T15:43:51.000+02:00
Update to tucana 0.0.67
diff --git a/ts/examples/simple-example-ts/index.ts b/ts/examples/simple-example-ts/index.ts
@@ -23,7 +23,7 @@ sdk.registerDataTypes({
     type: "any",
 })
 
-sdk.registerFunctionDefinitions({
+sdk.registerRuntimeFunctionDefinitionsAndFunctionDefinitions({
         definition: {
             signature: "(n: NUMBER) => NUMBER",
             linkedDataTypes: ["NUMBER"],
@@ -55,8 +55,9 @@ sdk.registerFunctionDefinitions({
 
 sdk.registerFlowTypes(
     {
+        signature: "(): TEXT",
+        linkedDataTypes: ["TEXT"],
         editable: false,
-        inputType: "STRING",
         identifier: "test_flow",
     }
 )
diff --git a/ts/examples/simple-example-ts/package-lock.json b/ts/examples/simple-example-ts/package-lock.json
diff --git a/ts/package-lock.json b/ts/package-lock.json
diff --git a/ts/package.json b/ts/package.json
@@ -30,7 +30,7 @@
   "license": "ISC",
   "type": "module",
   "dependencies": {
-    "@code0-tech/tucana": "^0.0.66",
+    "@code0-tech/tucana": "^0.0.67",
     "@grpc/grpc-js": "^1.14.3",
     "@protobuf-ts/grpc-backend": "^2.11.1",
     "@protobuf-ts/grpc-transport": "^2.11.1",
diff --git a/ts/src/action_sdk.ts b/ts/src/action_sdk.ts
@@ -3,7 +3,8 @@ import {ChannelCredentials} from "@grpc/grpc-js";
 import {RpcOptions} from "@protobuf-ts/runtime-rpc";
 import {
     ActionSdk, HerculesActionConfigurationDefinition,
-    HerculesActionProjectConfiguration, HerculesFunctionContext, SdkState, RuntimeErrorException
+    HerculesActionProjectConfiguration, HerculesFunctionContext, SdkState, RuntimeErrorException,
+    HerculesRegisterRuntimeFunctionParameter, HerculesRegisterFunctionDefinition
 } from "./types.js";
 import {
     ActionTransferServiceClient,
@@ -52,6 +53,73 @@ const createSdk = (config: ActionSdk["config"], configDefinitions?: HerculesActi
         fullyConnected: false
     }
 
+    const registerFunctionDefinitions = async (...functionDefinitions: Array<HerculesRegisterFunctionDefinition>) => {
+        for (const functionDefinition of functionDefinitions) {
+            state.functions.push({
+                identifier: functionDefinition.runtimeName,
+                definition: {
+                    displayMessage: functionDefinition.displayMessage || [],
+                    name: functionDefinition.name || [],
+                    documentation: functionDefinition.documentation || [],
+                    description: functionDefinition.description || [],
+                    deprecationMessage: functionDefinition.deprecationMessage || [],
+                    displayIcon: functionDefinition.displayIcon || "",
+                    alias: functionDefinition.alias || [],
+                    linkedDataTypeIdentifiers: functionDefinition.linkedDataTypes || [],
+                    definitionSource: "action",
+                    version: functionDefinition.version || config.version,
+                    runtimeName: functionDefinition.runtimeName,
+                    parameterDefinitions: (functionDefinition.parameters || []).map(param => ({
+                        runtimeName: param.runtimeName,
+                        name: param.name || [],
+                        description: param.description || [],
+                        documentation: param.documentation || [],
+                        defaultValue: constructValue(param.defaultValue || null),
+                        hidden: param.hidden || false,
+                        optional: param.hidden || false,
+                        runtimeDefinitionName: param.runtimeDefinitionName || param.runtimeName
+                    })),
+                    signature: functionDefinition.signature,
+                    throwsError: functionDefinition.throwsError || false,
+                    runtimeDefinitionName: functionDefinition.runtimeDefinitionName
+                }
+            });
+        }
+        return Promise.resolve()
+    };
+    const registerRuntimeFunctionDefinitions = async (...runtimeFunctionDefinitions: HerculesRegisterRuntimeFunctionParameter[]) => {
+        for (const registeredFunction of runtimeFunctionDefinitions) {
+            const handler = registeredFunction.handler;
+            const functionDefinition = registeredFunction.definition;
+            state.runtimeFunctions.push({
+                identifier: functionDefinition.runtimeName,
+                definition: {
+                    displayMessage: functionDefinition.displayMessage || [],
+                    name: functionDefinition.name || [],
+                    documentation: functionDefinition.documentation || [],
+                    description: functionDefinition.description || [],
+                    deprecationMessage: functionDefinition.deprecationMessage || [],
+                    displayIcon: functionDefinition.displayIcon || "",
+                    alias: functionDefinition.alias || [],
+                    linkedDataTypeIdentifiers: functionDefinition.linkedDataTypes || [],
+                    definitionSource: "action",
+                    version: functionDefinition.version || config.version,
+                    runtimeName: functionDefinition.runtimeName,
+                    runtimeParameterDefinitions: (functionDefinition.parameters || []).map(param => ({
+                        runtimeName: param.runtimeName,
+                        name: param.name || [],
+                        description: param.description || [],
+                        documentation: param.documentation || [],
+                        defaultValue: constructValue(param.defaultValue || null),
+                    })),
+                    signature: functionDefinition.signature,
+                    throwsError: functionDefinition.throwsError || false,
+                },
+                handler: handler,
+            });
+        }
+        return Promise.resolve()
+    };
     return {
         fullyConnected(): boolean {
             return state.fullyConnected;
@@ -140,69 +208,29 @@ const createSdk = (config: ActionSdk["config"], configDefinitions?: HerculesActi
             })
             return Promise.resolve()
         },
-        registerRuntimeFunctionDefinitions: async (...runtimeFunctionDefinitions) => {
-            for (const registeredFunction of runtimeFunctionDefinitions) {
-                const handler = registeredFunction.handler;
-                const functionDefinition = registeredFunction.definition;
-                state.runtimeFunctions.push({
-                    identifier: functionDefinition.runtimeName,
-                    definition: {
-                        displayMessage: functionDefinition.displayMessage || [],
-                        name: functionDefinition.name || [],
-                        documentation: functionDefinition.documentation || [],
-                        description: functionDefinition.description || [],
-                        deprecationMessage: functionDefinition.deprecationMessage || [],
-                        displayIcon: functionDefinition.displayIcon || "",
-                        alias: functionDefinition.alias || [],
-                        linkedDataTypeIdentifiers: functionDefinition.linkedDataTypes || [],
-                        definitionSource: "action",
-                        version: functionDefinition.version || config.version,
-                        runtimeName: functionDefinition.runtimeName,
-                        runtimeParameterDefinitions: (functionDefinition.parameters || []).map(param => ({
-                            runtimeName: param.runtimeName,
-                            name: param.name || [],
-                            description: param.description || [],
-                            documentation: param.documentation || [],
-                            defaultValue: constructValue(param.defaultValue || null),
-                        })),
-                        signature: functionDefinition.signature,
-                        throwsError: functionDefinition.throwsError || false,
-                    },
-                    handler: handler,
-                });
-            }
-            return Promise.resolve()
-        },
-        registerFunctionDefinitions: async (...functionDefinitions) => {
-            for (const functionDefinition of functionDefinitions) {
-                state.functions.push({
-                    identifier: functionDefinition.runtimeName,
-                    definition: {
-                        displayMessage: functionDefinition.displayMessage || [],
-                        name: functionDefinition.name || [],
-                        documentation: functionDefinition.documentation || [],
-                        description: functionDefinition.description || [],
-                        deprecationMessage: functionDefinition.deprecationMessage || [],
-                        displayIcon: functionDefinition.displayIcon || "",
-                        alias: functionDefinition.alias || [],
-                        linkedDataTypeIdentifiers: functionDefinition.linkedDataTypes || [],
-                        definitionSource: "action",
-                        version: functionDefinition.version || config.version,
-                        runtimeName: functionDefinition.runtimeName,
-                        parameterDefinitions: (functionDefinition.parameters || []).map(param => ({
-                            runtimeName: param.runtimeName,
-                            name: param.name || [],
-                            description: param.description || [],
-                            documentation: param.documentation || [],
-                            defaultValue: constructValue(param.defaultValue || null),
-                        })),
-                        signature: functionDefinition.signature,
-                        throwsError: functionDefinition.throwsError || false,
-                    }
-                });
-            }
-            return Promise.resolve()
+        registerRuntimeFunctionDefinitionsAndFunctionDefinitions: async (...runtimeFunctionDefinitions) => {
+            await Promise.all(runtimeFunctionDefinitions.map(async (register) => {
+                await Promise.all([
+                    registerRuntimeFunctionDefinitions(
+                        register
+                    ),
+                    registerFunctionDefinitions(
+                        {
+                            ...register.definition,
+                            runtimeDefinitionName: register.definition.runtimeName,
+                            parameters: register.definition.parameters?.map(param => {
+                                return {
+                                    ...param,
+                                    runtimeDefinitionName: param.runtimeName,
+                                }
+                            })
+                        }
+                    )
+                ])
+            }));
         },
+        registerRuntimeFunctionDefinitions: registerRuntimeFunctionDefinitions,
+        registerFunctionDefinitions: registerFunctionDefinitions,
         dispatchEvent: async (eventType, projectId, payload) => {
             if (!state.stream) {
                 return Promise.reject("SDK is not connected. Call connect() before dispatching events.");
diff --git a/ts/src/types.ts b/ts/src/types.ts
@@ -12,7 +12,6 @@ import {PlainValue} from "@code0-tech/tucana/helpers";
 import {ActionTransferServiceClient, TransferRequest, TransferResponse} from "@code0-tech/tucana/aquila";
 
 
-
 export interface HerculesFunctionContext {
     projectId: number | bigint,
     executionId: string,
@@ -65,6 +64,8 @@ export interface HerculesRuntimeFunctionDefinition {
         name?: Translation[],
         description?: Translation[],
         documentation?: Translation[],
+        hidden?: boolean,
+        optional?: boolean
     }[],
     signature: string,
     throwsError?: boolean,
@@ -79,7 +80,31 @@ export interface HerculesRuntimeFunctionDefinition {
     displayIcon?: string,
 }
 
-export type HerculesRegisterFunctionDefinition = HerculesRuntimeFunctionDefinition
+export interface HerculesRegisterFunctionDefinition {
+    runtimeDefinitionName: string,
+    runtimeName: string,
+    parameters?: {
+        runtimeName: string,
+        defaultValue?: PlainValue,
+        name?: Translation[],
+        description?: Translation[],
+        documentation?: Translation[],
+        hidden?: boolean,
+        optional?: boolean,
+        runtimeDefinitionName?: string
+    }[],
+    signature: string,
+    throwsError?: boolean,
+    name?: Translation[],
+    description?: Translation[],
+    documentation?: Translation[],
+    deprecationMessage?: Translation[],
+    displayMessage?: Translation[],
+    alias?: Translation[],
+    linkedDataTypes?: string[],
+    version?: string,
+    displayIcon?: string,
+}
 
 export interface HerculesActionProjectConfiguration {
     projectId: number | bigint,
@@ -120,6 +145,7 @@ export interface ActionSdk {
     registerConfigDefinitions: (...actionConfigurations: Array<HerculesActionConfigurationDefinition>) => Promise<void>,
     registerDataTypes: (...dataType: Array<HerculesDataType>) => Promise<void>,
     registerFlowTypes: (...flowTypes: Array<HerculesFlowType>) => Promise<void>,
+    registerRuntimeFunctionDefinitionsAndFunctionDefinitions: (...runtimeFunctionDefinitions: Array<HerculesRegisterRuntimeFunctionParameter>) => Promise<void>,
     registerFunctionDefinitions: (...functionDefinitions: Array<HerculesRegisterFunctionDefinition>) => Promise<void>,
     registerRuntimeFunctionDefinitions: (...runtimeFunctionDefinitions: Array<HerculesRegisterRuntimeFunctionParameter>) => Promise<void>,
     dispatchEvent: (eventType: string, projectId: number | bigint, payload: PlainValue) => Promise<void>,

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ sdk.registerDataTypes({`
`23`	`23`	`type: "any",`
`24`	`24`	`})`
`25`	`25`
`26`		`-sdk.registerFunctionDefinitions({`
	`26`	`+sdk.registerRuntimeFunctionDefinitionsAndFunctionDefinitions({`
`27`	`27`	`definition: {`
`28`	`28`	`signature: "(n: NUMBER) => NUMBER",`
`29`	`29`	`linkedDataTypes: ["NUMBER"],`
`@@ -55,8 +55,9 @@ sdk.registerFunctionDefinitions({`
`55`	`55`
`56`	`56`	`sdk.registerFlowTypes(`
`57`	`57`	`{`
	`58`	`+ signature: "(): TEXT",`
	`59`	`+ linkedDataTypes: ["TEXT"],`
`58`	`60`	`editable: false,`
`59`		`- inputType: "STRING",`
`60`	`61`	`identifier: "test_flow",`
`61`	`62`	`}`
`62`	`63`	`)`