Merge pull request #29 from code0-tech/feat/#28

Settings and params aren't correctly merged

Author: nicosammito

ts/scripts/build-definitions.ts

@@ -140,7 +140,7 @@ function buildSettingDecorators(settings: any[]): string[] {
     return settings.flatMap(s => {
         const props = [
             `identifier: ${JSON.stringify(s.identifier)},`,
-            ...(s.unique && s.unique !== "NONE" ? [`unique: ${JSON.stringify(s.unique)} as any,`] : []),
+            ...(s.unique && s.unique !== "NONE" ? [`unique: ${JSON.stringify(s.unique)},`] : []),
             ...(Array.isArray(s.name) && s.name.length ? [`name: [${renderTranslationsInline(s.name)}],`] : []),
             ...(Array.isArray(s.description) && s.description.length ? [`description: [${renderTranslationsInline(s.description)}],`] : []),
             ...(s.optional ? [`optional: true,`] : []),

ts/src/decorators/event.dec.ts

@@ -2,7 +2,9 @@ import {EventSettingProps} from "../models/event.model";
 
 export const EventSetting = (setting: EventSettingProps): ClassDecorator =>
     (target) => {
-        const settings = Reflect.getMetadata('hercules:flow_settings', target) || [];
+        // getOwnMetadata: getMetadata would return the parent class's array on subclasses,
+        // and unshift would mutate the parent's settings.
+        const settings = Reflect.getOwnMetadata('hercules:flow_settings', target) || [];
         settings.unshift(setting);
         Reflect.defineMetadata('hercules:flow_settings', settings, target);
     }

ts/src/decorators/function.dec.ts

@@ -11,7 +11,9 @@ export const ThrowsError = (throwsError: boolean = true): ClassDecorator =>
 
 export const Parameter = (parameter: FunctionParameterProps): ClassDecorator =>
     (target) => {
-        const parameters = Reflect.getMetadata('hercules:function_parameters', target) || [];
+        // getOwnMetadata: getMetadata would return the parent class's array on subclasses,
+        // and unshift would mutate the parent's parameters.
+        const parameters = Reflect.getOwnMetadata('hercules:function_parameters', target) || [];
         parameters.unshift(parameter);
         Reflect.defineMetadata('hercules:function_parameters', parameters, target);
     }

ts/src/internal/module-builder.ts

@@ -1,5 +1,5 @@
 import {constructValue} from "@code0-tech/tucana/helpers";
-import {DefinitionDataType, FlowType, FlowTypeSetting, Module, ModuleConfigurationDefinition, RuntimeFlowType, RuntimeFlowTypeSetting} from "@code0-tech/tucana/shared";
+import {DefinitionDataType, FlowType, FlowTypeSetting, FlowTypeSetting_UniquenessScope, Module, ModuleConfigurationDefinition, RuntimeFlowType, RuntimeFlowTypeSetting} from "@code0-tech/tucana/shared";
 import type {FunctionProps} from "../models/function.model";
 import type {RuntimeFunctionProps} from "../models/runtime_function.model";
 import type {ConfigurationDefinition, Translation} from "../types";
@@ -22,6 +22,18 @@ export interface ModuleBuildData {
     runtimeFunctions: RuntimeFunctionProps[];
 }
 
+// The protobuf field is an enum (int32); string names like "PROJECT" would fail binary serialization.
+// Returns number since FlowTypeSetting and RuntimeFlowTypeSetting each declare their own (identical) enum.
+function toUniquenessScope(unique: FlowTypeSetting_UniquenessScope | keyof typeof FlowTypeSetting_UniquenessScope | undefined): number {
+    if (unique == null) return FlowTypeSetting_UniquenessScope.NONE;
+    if (typeof unique === "string") {
+        const scope = FlowTypeSetting_UniquenessScope[unique];
+        if (typeof scope !== "number") throw new Error(`Invalid uniqueness scope: ${JSON.stringify(unique)}`);
+        return scope;
+    }
+    return unique;
+}
+
 export function buildModule(data: ModuleBuildData): Module {
     return {
         identifier: data.identifier,
@@ -57,7 +69,7 @@ export function buildModule(data: ModuleBuildData): Module {
             identifier: ft.identifier,
             settings: (ft.settings ?? []).map(s => ({
                 identifier: s.identifier,
-                unique: s.unique ?? 1,
+                unique: toUniquenessScope(s.unique),
                 linkedDataTypeIdentifiers: s.linkedDataTypeIdentifiers ?? [],
                 ...(s.defaultValue != null ? {defaultValue: constructValue(s.defaultValue)} : {}),
                 name: s.name ?? [],
@@ -82,7 +94,7 @@ export function buildModule(data: ModuleBuildData): Module {
             identifier: rft.identifier,
             runtimeSettings: (rft.settings ?? []).map(s => ({
                 identifier: s.identifier,
-                unique: s.unique ?? 1,
+                unique: toUniquenessScope(s.unique),
                 ...(s.defaultValue != null ? {defaultValue: constructValue(s.defaultValue)} : {}),
                 name: s.name ?? [],
                 description: s.description ?? [],

ts/src/map/event.map.ts

@@ -9,7 +9,7 @@ export const eventMap = <T extends RuntimeEventClass>(klass: EventClass<T>): Eve
 
     const identifier: string = Reflect.getMetadata('hercules:identifier', klass);
     const signature: string = Reflect.getMetadata('hercules:signature', klass);
-    const settings: EventSettingProps[] = Reflect.getMetadata('hercules:flow_settings', klass) || [];
+    const settings: EventSettingProps[] = Reflect.getOwnMetadata('hercules:flow_settings', klass) || [];
     const name: Translation[] = Reflect.getMetadata('hercules:name', klass);
     const description: Translation[] = Reflect.getMetadata('hercules:description', klass);
     const documentation: Translation[] = Reflect.getMetadata('hercules:documentation', klass);
@@ -26,12 +26,12 @@ export const eventMap = <T extends RuntimeEventClass>(klass: EventClass<T>): Eve
         }
     }
 
-    const mergedSettings: EventSettingProps[] = [...settings];
-    for (const rs of runtimeEvent.settings ?? []) {
-        if (!mergedSettings.find(s => s.identifier === rs.identifier)) {
-            mergedSettings.push({...rs});
-        }
-    }
+    // Settings come from the runtime event (in its order); the event class only overrides
+    // individual properties (e.g. defaultValue, hidden) per identifier.
+    const mergedSettings: EventSettingProps[] = (runtimeEvent.settings ?? []).map(rs => {
+        const override = settings.find(s => s.identifier === rs.identifier);
+        return override ? {...rs, ...override} : {...rs};
+    });
 
     return {
         runtimeIdentifier: runtimeEvent.identifier,

ts/src/models/event.model.ts

@@ -5,7 +5,7 @@ import {RuntimeEventClass} from "./runtime_event.model";
 
 export interface EventSettingProps {
     identifier: string,
-    unique?: FlowTypeSetting_UniquenessScope,
+    unique?: FlowTypeSetting_UniquenessScope | keyof typeof FlowTypeSetting_UniquenessScope,
     linkedDataTypeIdentifiers?: string[],
     defaultValue?: PlainValue,
     name?: Translation[],

ts/test/index.test.ts

@@ -2,6 +2,10 @@ import "reflect-metadata";
 import { describe, expect, it } from "vitest";
 import { Parameter } from "../src/decorators/function.dec";
 import { EventSetting } from "../src/decorators/event.dec";
+import { Identifier } from "../src/decorators/meta.dec";
+import { eventMap } from "../src/map/event.map";
+import { runtimeEventMap } from "../src/map/runtime_event.map";
+import { Rest } from "../src/definitions/draco_rest/runtime_flow_types/rest";
 
 describe("Parameter decorator", () => {
     it("preserves source order across multiple decorators", () => {
@@ -27,6 +31,52 @@ describe("Parameter decorator", () => {
     });
 });
 
+describe("eventMap", () => {
+    const restSettingOrder = [
+        "httpSchema",
+        "httpURL",
+        "httpMethod",
+        "httpAuth",
+        "httpAuthValue",
+        "input_schema",
+    ];
+
+    it("keeps the runtime event's setting order regardless of override order", () => {
+        @Identifier("ScrambledOverrides")
+        @EventSetting({ identifier: "input_schema", hidden: true, defaultValue: {} })
+        @EventSetting({ identifier: "httpAuthValue", hidden: true })
+        @EventSetting({ identifier: "httpSchema", hidden: true, defaultValue: "application/json" })
+        @EventSetting({ identifier: "httpMethod", hidden: true, defaultValue: "POST" })
+        class ScrambledOverrides extends Rest {}
+
+        const def = eventMap(ScrambledOverrides);
+        expect(def.settings?.map(s => s.identifier)).toEqual(restSettingOrder);
+    });
+
+    it("merges override properties into the runtime event's setting", () => {
+        @Identifier("MethodOverride")
+        @EventSetting({ identifier: "httpMethod", hidden: true, defaultValue: "POST" })
+        class MethodOverride extends Rest {}
+
+        const httpMethod = eventMap(MethodOverride).settings?.find(s => s.identifier === "httpMethod");
+        expect(httpMethod?.hidden).toBe(true);
+        expect(httpMethod?.defaultValue).toBe("POST");
+        expect(httpMethod?.name).toEqual([{ code: "en-US", content: "Method" }]);
+    });
+
+    it("does not pollute the runtime event's settings via subclass overrides", () => {
+        @Identifier("PollutionCheck")
+        @EventSetting({ identifier: "httpMethod", hidden: true, defaultValue: "POST" })
+        class PollutionCheck extends Rest {}
+
+        eventMap(PollutionCheck);
+
+        const restSettings = runtimeEventMap(Rest).settings ?? [];
+        expect(restSettings.map(s => s.identifier)).toEqual(restSettingOrder);
+        expect(restSettings.find(s => s.identifier === "httpMethod")?.hidden).toBeUndefined();
+    });
+});
+
 describe("EventSetting decorator", () => {
     it("preserves source order across multiple decorators", () => {
         @EventSetting({ identifier: "first" })