@hahnpro/flow-sdk 9.6.4 → 2025.2.0-beta.1

package/src/lib/FlowElement.ts

@@ -0,0 +1,220 @@
+import { API } from '@hahnpro/hpc-api';
+import { plainToInstance } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import { Options, PythonShell } from 'python-shell';
+
+import { ClassType, DeploymentMessage, FlowContext, FlowElementContext } from './flow.interface';
+import { Context, FlowApplication } from './FlowApplication';
+import { FlowEvent } from './FlowEvent';
+import { FlowLogger } from './FlowLogger';
+import { fillTemplate, handleApiError } from './utils';
+
+export abstract class FlowElement<T = any> {
+  public readonly functionFqn: string;
+  protected readonly api?: API;
+  protected readonly logger: FlowLogger;
+  protected metadata: FlowElementContext;
+  protected properties: T;
+  private propertiesWithPlaceholders: T;
+  private readonly app?: FlowApplication;
+  private readonly rpcRoutingKey: string;
+
+  private stopPropagateStream: Map<string, boolean> = new Map<string, boolean>();
+
+  constructor(
+    { app, logger, ...metadata }: Context,
+    properties?: unknown,
+    private readonly propertiesClassType?: ClassType<T>,
+    private readonly whitelist = false,
+  ) {
+    this.app = app;
+    this.api = this.app?.api;
+    this.metadata = { ...metadata, functionFqn: this.functionFqn };
+    this.logger = new FlowLogger(this.metadata, logger || undefined, this.app?.publishNatsEventFlowlogs);
+    this.rpcRoutingKey = (this.metadata.flowId || '') + (this.metadata.deploymentId || '') + this.metadata.id;
+    if (properties) {
+      this.setProperties(properties as T);
+    }
+  }
+
+  /**
+   * Sets the placeholder properties for this flow element
+   * @param propertiesWithPlaceholders
+   */
+  public setPropertiesWithPlaceholders(propertiesWithPlaceholders: T) {
+    this.propertiesWithPlaceholders = propertiesWithPlaceholders;
+  }
+
+  /**
+   * Returns the placeholder properties for this flow element
+   */
+  public getPropertiesWithPlaceholders() {
+    return this.propertiesWithPlaceholders;
+  }
+
+  get flowProperties() {
+    return this.app?.getProperties?.() || {};
+  }
+
+  get natsConnection() {
+    return this.app?.natsConnection;
+  }
+
+  public onDestroy?: () => void;
+
+  public onMessage?: (message: DeploymentMessage) => void;
+
+  /**
+   * Replace all placeholder properties with their explicit updated value and set them as the properties of the element
+   */
+  public replacePlaceholderAndSetProperties() {
+    const placeholderProperties = this.propertiesWithPlaceholders;
+    if (this.propertiesWithPlaceholders) {
+      this.setProperties(this.app.getContextManager?.()?.replaceAllPlaceholderProperties(placeholderProperties));
+    }
+  }
+
+  public onFlowPropertiesChanged?: (properties: Record<string, any>) => void;
+
+  public onContextChanged = (context: Partial<FlowContext>): void => {
+    this.metadata = { ...this.metadata, ...context };
+  };
+
+  public onPropertiesChanged = (properties: T): void => {
+    this.setProperties(properties);
+  };
+
+  public getMetadata = () => this.metadata;
+
+  protected setProperties = (properties: T): void => {
+    if (this.propertiesClassType) {
+      this.properties = this.validateProperties(this.propertiesClassType, properties, this.whitelist);
+    } else {
+      this.properties = properties;
+    }
+  };
+
+  public handleApiError = (error: any) => handleApiError(error, this.logger);
+
+  /**
+   * @deprecated since version 4.8.0, will be removed in 5.0.0, use emitEvent(...) instead
+   */
+  protected emitOutput(data: any = {}, outputId = 'default', time = new Date()): FlowEvent {
+    return this.emitEvent(data, null, outputId, time);
+  }
+
+  protected emitEvent(data: Record<string, any>, inputEvent: FlowEvent, outputId = 'default', time = new Date()): FlowEvent {
+    const partialEvent = new FlowEvent(this.metadata, data, outputId, time);
+    const completeEvent = new FlowEvent(this.metadata, { ...(inputEvent?.getData() || {}), ...data }, outputId, time);
+
+    const streamID = inputEvent?.getMetadata()?.inputStreamId || '';
+    if ((this.stopPropagateStream.has(streamID) && this.stopPropagateStream.get(streamID)) || !this.stopPropagateStream.has(streamID)) {
+      this.app?.emit(partialEvent);
+      return partialEvent;
+    } else {
+      this.app?.emitPartial(completeEvent, partialEvent);
+      return completeEvent;
+    }
+  }
+
+  protected validateProperties<P>(classType: ClassType<P>, properties: any = {}, whitelist = false): P {
+    const props: P = plainToInstance<P, any>(classType, properties);
+    const errors = validateSync(props as any, { forbidUnknownValues: false, whitelist });
+    if (Array.isArray(errors) && errors.length > 0) {
+      for (const e of errors) {
+        this.logValidationErrors(e);
+      }
+      throw new Error('Properties Validation failed');
+    } else {
+      return props;
+    }
+  }
+
+  protected logValidationErrors(error: any, parent?: string) {
+    const { children, constraints, property, value } = error;
+    const name = parent ? parent + '.' + property : property;
+    if (constraints) {
+      this.logger.error(`Validation for property "${name}" failed:\n${JSON.stringify(constraints || {})}\nvalue: ${value}`);
+    } else if (Array.isArray(children)) {
+      for (const child of children) {
+        this.logValidationErrors(child, name);
+      }
+    }
+  }
+
+  protected validateEventData<E>(classType: ClassType<E>, event: FlowEvent, whitelist = false): E {
+    return this.validateProperties(classType, event.getData(), whitelist);
+  }
+
+  protected interpolate = (value: any, ...templateVariables: any) =>
+    fillTemplate(value, ...templateVariables, { flow: this.app?.getContextManager?.().getProperties?.().flow ?? {} });
+
+  protected async callRpcFunction(functionName: string, ...args: any[]) {
+    return this.app?.rpcClient.callFunction(this.rpcRoutingKey, functionName, ...args);
+  }
+
+  protected runPyRpcScript(scriptPath: string, ...args: (string | boolean | number)[]) {
+    const options: Options = {
+      mode: 'text',
+      pythonOptions: ['-u'],
+      args: [__dirname, this.rpcRoutingKey, ...args.map((v) => v.toString())],
+    };
+
+    const pyshell = new PythonShell(scriptPath, options);
+    pyshell.on('message', (message) => {
+      this.logger.debug(message);
+    });
+    pyshell.end((err) => {
+      if (err) {
+        this.logger.error(err);
+      }
+    });
+    return pyshell;
+  }
+}
+
+export function InputStream(id = 'default', options?: { concurrent?: number; stopPropagation?: boolean }): MethodDecorator {
+  return (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => {
+    Reflect.defineMetadata(`stream:${id}`, propertyKey, target.constructor);
+    if (options) {
+      Reflect.defineMetadata(`stream:options:${id}`, options, target.constructor);
+    }
+
+    const method = propertyDescriptor.value;
+
+    propertyDescriptor.value = function (event: FlowEvent) {
+      if (!this.stopPropagateStream.has(id)) {
+        this.stopPropagateStream.set(id, options?.stopPropagation ?? false);
+      }
+
+      // add input stream to data to later determine if data should be propagated
+      return method.call(
+        this,
+        new FlowEvent(
+          { id: event.getMetadata().elementId, ...event.getMetadata(), inputStreamId: id },
+          event.getData(),
+          event.getType(),
+          new Date(event.getTime()),
+        ),
+      );
+    };
+  };
+}
+
+export function FlowFunction(fqn: string): ClassDecorator {
+  const fqnRegExp = /^([a-zA-Z][a-zA-Z\d]*[.-])*[a-zA-Z][a-zA-Z\d]*$/;
+  if (!fqnRegExp.test(fqn)) {
+    throw new Error(`Flow Function FQN (${fqn}) is not valid`);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  return <TFunction extends Function>(target: TFunction): TFunction | void => {
+    Reflect.defineMetadata('element:functionFqn', fqn, target);
+    target.prototype.functionFqn = fqn;
+  };
+}
+
+export abstract class FlowResource<T = any> extends FlowElement<T> {}
+export abstract class FlowTask<T = any> extends FlowElement<T> {}
+export abstract class FlowTrigger<T = any> extends FlowElement<T> {}
+export abstract class FlowDashboard<T = any> extends FlowResource<T> {}

package/src/lib/FlowEvent.ts

@@ -0,0 +1,73 @@
+import { CloudEvent } from 'cloudevents';
+import { cloneDeep } from 'lodash';
+
+import { FlowElementContext } from './flow.interface';
+
+export class FlowEvent {
+  private event: CloudEvent;
+  private metadata: { deploymentId: string; elementId: string; flowId: string; functionFqn: string; inputStreamId: string };
+
+  constructor(metadata: FlowElementContext, data: any, outputId = 'default', time = new Date(), dataType?: string) {
+    const { id: elementId, deploymentId, flowId, functionFqn, inputStreamId } = metadata;
+    if (data instanceof Error) {
+      const error = { message: data.message, stack: data.stack };
+      data = error;
+    } else {
+      data = cloneDeep(data);
+    }
+
+    if (data == null) {
+      data = {};
+    }
+    if (dataType == null) {
+      if (typeof data === 'string') {
+        try {
+          JSON.parse(data);
+          dataType = 'application/json';
+        } catch (err) {
+          dataType = 'text/plain';
+        }
+      } else if (typeof data === 'object') {
+        dataType = 'application/json';
+      } else {
+        data = String(data);
+        dataType = 'text/plain';
+      }
+    }
+
+    this.metadata = { deploymentId, elementId, flowId, functionFqn, inputStreamId };
+    this.event = new CloudEvent({
+      source: `flows/${flowId}/deployments/${deploymentId}/elements/${elementId}`,
+      type: outputId,
+      subject: functionFqn,
+      datacontenttype: dataType,
+      data,
+      time: time.toISOString(),
+    });
+  }
+
+  public format = (): any => {
+    const event = this.event.toJSON();
+    if (event.datacontenttype === 'application/json') {
+      try {
+        event.data = JSON.parse(event.data as string);
+      } catch (err) {
+        /* ignore error */
+      }
+    }
+    return event;
+  };
+
+  public getData = (): any => cloneDeep(this.event.data || {});
+  public getDataContentType = (): string => this.event.datacontenttype;
+  public getDataschema = (): string => this.event.dataschema;
+  public getId = (): string => this.event.id;
+  public getMetadata = () => this.metadata;
+  public getSource = (): string => this.event.source;
+  public getStreamId = (): string => `${this.metadata.elementId}.${this.event.type}`;
+  public getSubject = (): string => this.event.subject;
+  public getTime = (): Date => new Date(this.event.time);
+  public getType = (): string => this.event.type;
+  public toJSON = (): any => this.event.toJSON();
+  public toString = (): string => this.event.toString();
+}

package/src/lib/FlowLogger.ts

@@ -0,0 +1,131 @@
+import { FlowElementContext } from './flow.interface';
+import { FlowEvent } from './FlowEvent';
+
+export interface Logger {
+  debug(message, metadata?): void;
+  error(message, metadata?): void;
+  log(message, metadata?): void;
+  warn(message, metadata?): void;
+  verbose(message, metadata?): void;
+}
+
+/* eslint-disable no-console */
+export const defaultLogger: Logger = {
+  debug: (msg, metadata?) => console.debug(msg),
+  error: (msg, metadata?) => console.error(msg),
+  log: (msg, metadata?) => console.log(msg),
+  warn: (msg, metadata?) => console.warn(msg),
+  verbose: (msg, metadata?) => console.log(msg, metadata),
+};
+/* eslint-enable no-console */
+
+export enum STACK_TRACE {
+  FULL = 'full',
+  ONLY_LOG_CALL = 'only-log-call',
+}
+
+export interface LoggerOptions {
+  truncate: boolean;
+  stackTrace?: STACK_TRACE;
+}
+
+interface FlowLog {
+  message: string;
+  stackTrace?: string;
+}
+
+export class FlowLogger implements Logger {
+  private static getStackTrace(stacktrace: STACK_TRACE = STACK_TRACE.FULL) {
+    // get stacktrace without extra dependencies
+    let stack;
+
+    try {
+      throw new Error('');
+    } catch (error) {
+      stack = error.stack || '';
+    }
+
+    // cleanup stacktrace and remove calls within this file
+    stack = stack
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((value) => value.includes('at ') && !value.includes('Logger'));
+
+    if (stacktrace === STACK_TRACE.ONLY_LOG_CALL && stack.length > 0) {
+      stack = stack[0];
+    } else {
+      stack = stack.splice(1).join('\n');
+    }
+    return stack;
+  }
+
+  constructor(
+    private readonly metadata: FlowElementContext,
+    private readonly logger: Logger = defaultLogger,
+    private readonly publishEvent?: (event: FlowEvent) => void,
+  ) {}
+
+  public debug = (message, options?: LoggerOptions) => this.publish(message, 'debug', options);
+  public error = (message, options?: LoggerOptions) => this.publish(message, 'error', options);
+  public log = (message, options?: LoggerOptions) => this.publish(message, 'info', options);
+  public warn = (message, options?: LoggerOptions) => this.publish(message, 'warn', options);
+  public verbose = (message, options?: LoggerOptions) => this.publish(message, 'verbose', options);
+
+  /**
+   * Parses a message into a FlowLog object, including optional stack trace information.
+   *
+   * @details Requirements for the output format of messages:
+   * - Necessary for consistent logging and event publishing, because the OpenSearch index expects a specific structure: flat_object.
+   * - The current UI expects a `message` property to be present, so we ensure it is always set.
+   *
+   * @param {any} message - The message to be logged. Can be a string, an object with a `message` property, or any other type.
+   * @param {string} level - The log level (e.g., 'error', 'debug', 'warn', 'verbose').
+   * @param {LoggerOptions} options - Additional options for logging, such as whether to include a stack trace.
+   * @returns {FlowLog} - An object containing the parsed log message and optional stack trace.
+   */
+  private parseMessageToFlowLog(message: any, level: string, options: LoggerOptions): FlowLog {
+    let flowLogMessage: string;
+    if (!message) {
+      flowLogMessage = 'No message provided!';
+    } else if (typeof message.message === 'string') {
+      flowLogMessage = message.message;
+    } else if (typeof message === 'string') {
+      flowLogMessage = message;
+    } else {
+      try {
+        flowLogMessage = JSON.stringify(message.message ?? message);
+      } catch (e) {
+        flowLogMessage = 'Error: Could not stringify the message.';
+      }
+    }
+
+    const flowLog: FlowLog = { message: flowLogMessage };
+    if (['error', 'debug', 'warn', 'verbose'].includes(level) || options?.stackTrace) {
+      flowLog.stackTrace = FlowLogger.getStackTrace(options?.stackTrace ?? STACK_TRACE.ONLY_LOG_CALL);
+    }
+    return flowLog;
+  }
+
+  private publish(message, level: string, options: LoggerOptions) {
+    const flowLogData: FlowLog = this.parseMessageToFlowLog(message, level, options);
+
+    if (this.publishEvent) {
+      const event = new FlowEvent(this.metadata, flowLogData, `flow.log.${level}`);
+      this.publishEvent(event);
+    }
+
+    const messageWithStackTrace = flowLogData.stackTrace ? `${flowLogData.message}\n${flowLogData.stackTrace}` : flowLogData.message;
+    switch (level) {
+      case 'debug':
+        return this.logger.debug(messageWithStackTrace, { ...this.metadata, ...options });
+      case 'error':
+        return this.logger.error(messageWithStackTrace, { ...this.metadata, ...options });
+      case 'warn':
+        return this.logger.warn(messageWithStackTrace, { ...this.metadata, ...options });
+      case 'verbose':
+        return this.logger.verbose(messageWithStackTrace, { ...this.metadata, ...options });
+      default:
+        this.logger.log(messageWithStackTrace, { ...this.metadata, ...options });
+    }
+  }
+}

package/src/lib/FlowModule.ts

@@ -0,0 +1,18 @@
+import { FlowElement } from './FlowElement';
+
+export function FlowModule(metadata: { name: string; declarations: Array<ClassType<FlowElement>> }): ClassDecorator {
+  const validateNameRegExp = new RegExp(/^(@[a-z][a-z0-9-]*\/)?[a-z][a-z0-9-]*$/);
+  if (!validateNameRegExp.test(metadata.name)) {
+    throw new Error(
+      `Flow Module name (${metadata.name}) is not valid. Name must be all lowercase and not contain any special characters except for hyphens. Can optionally start with a scope "@scopename/"`,
+    );
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  return <TFunction extends Function>(target: TFunction): TFunction | void => {
+    Reflect.defineMetadata('module:name', metadata.name, target);
+    Reflect.defineMetadata('module:declarations', metadata.declarations, target);
+  };
+}
+
+type ClassType<T> = new (...args: any[]) => T;

package/src/lib/RpcClient.ts

@@ -0,0 +1,99 @@
+import { randomUUID } from 'crypto';
+
+import type { AmqpConnectionManager, Channel, ChannelWrapper } from 'amqp-connection-manager';
+import type { ConsumeMessage } from 'amqplib';
+import sizeof from 'object-sizeof';
+
+import { FlowLogger } from './FlowLogger';
+
+const MAX_MSG_SIZE = +process.env.MAX_RPC_MSG_SIZE_BYTES;
+const WARN_MSG_SIZE = +process.env.WARN_RPC_MSG_SIZE_BYTES;
+
+export class RpcClient {
+  private readonly channel: ChannelWrapper;
+  private openRequests: Map<string, { resolve; reject; trace: string }> = new Map<string, { resolve; reject; trace: string }>();
+
+  constructor(
+    amqpConnection: AmqpConnectionManager,
+    private readonly logger?: FlowLogger,
+  ) {
+    if (!amqpConnection) {
+      throw new Error('currently no amqp connection available');
+    }
+    this.channel = amqpConnection.createChannel({
+      json: true,
+      setup: async (channel: Channel) => {
+        await channel.assertExchange('rpc_direct_exchange', 'direct', { durable: false });
+        await channel.consume('amq.rabbitmq.reply-to', this.onMessage, { noAck: true });
+      },
+    });
+  }
+
+  private onMessage = (msg: ConsumeMessage) => {
+    if (this.openRequests.has(msg.properties.correlationId)) {
+      const { resolve, reject, trace } = this.openRequests.get(msg.properties.correlationId);
+      const response = JSON.parse(msg.content.toString());
+      switch (response.type) {
+        case 'reply':
+          resolve(response.value);
+          break;
+        case 'error': {
+          const err = new Error(response.message);
+          if (response.stack) {
+            const stack: string = RpcClient.formatTrace(response.stack);
+            err.stack = 'Remote Stack\n'.concat(stack, '\nLocal Stack\n', trace);
+          } else {
+            err.stack = trace;
+          }
+          reject(err);
+          break;
+        }
+        default:
+          reject(response);
+          break;
+      }
+    } else {
+      const message = `received unexpected response correlationID: ${msg.properties.correlationId}`;
+      /* eslint-disable-next-line no-console */
+      console.warn(message);
+    }
+  };
+
+  public callFunction = (routingKey: string, functionName: string, ...args: any[]) => {
+    // in case remote returns error add this to the trace
+    const stack = new Error('test').stack;
+    return new Promise((resolve, reject) => {
+      // save to correlationId-> resolve/reject map
+      // on return resolve or reject promise
+
+      if (MAX_MSG_SIZE || WARN_MSG_SIZE) {
+        const messageSize = sizeof(args);
+        if (messageSize > MAX_MSG_SIZE) {
+          throw new Error(`Max RPC message size exceeded: ${messageSize} bytes / ${MAX_MSG_SIZE} bytes`);
+        }
+        if (messageSize > WARN_MSG_SIZE) {
+          this.logger?.warn(`Large RPC message size detected: ${messageSize} bytes`);
+        }
+      }
+
+      const call = { functionName, arguments: args };
+      const correlationId = randomUUID();
+      this.openRequests.set(correlationId, { resolve, reject, trace: RpcClient.formatTrace(stack) });
+      this.channel
+        .publish('rpc_direct_exchange', routingKey, call, { correlationId, replyTo: 'amq.rabbitmq.reply-to' })
+        .catch((err) => reject(err));
+    });
+  };
+
+  public declareFunction = (routingKey: string, name: string) => {
+    return (...args) => this.callFunction(routingKey, name, ...args);
+  };
+
+  public close() {
+    return this.channel.close();
+  }
+
+  public static formatTrace(stack = '') {
+    return stack.split('\n').splice(1).join('\n');
+  }
+}

package/src/lib/TestModule.ts

@@ -0,0 +1,14 @@
+import { FlowFunction, FlowTask, InputStream } from './FlowElement';
+import { FlowEvent } from './FlowEvent';
+import { FlowModule } from './FlowModule';
+
+@FlowFunction('test.task.Trigger')
+class TestTrigger extends FlowTask {
+  @InputStream('default')
+  public async onDefault(event: FlowEvent) {
+    return this.emitEvent({}, event);
+  }
+}
+
+@FlowModule({ name: 'test', declarations: [TestTrigger] })
+export class TestModule {}

package/src/lib/amqp.ts

@@ -0,0 +1,32 @@
+import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
+
+export interface AmqpConnection {
+  managedChannel: ChannelWrapper;
+  managedConnection: AmqpConnectionManager;
+}
+
+export interface AmqpConnectionConfig {
+  protocol?: string;
+  hostname?: string;
+  vhost?: string;
+  user?: string;
+  password?: string;
+  port?: number;
+}
+
+export function createAmqpConnection(config: AmqpConnectionConfig): AmqpConnectionManager {
+  if (!config) {
+    return null;
+  }
+
+  const {
+    protocol = process.env.RABBIT_PROTOCOL || 'amqp',
+    hostname = process.env.RABBIT_HOST || 'localhost',
+    port = +process.env.RABBIT_PORT || 5672,
+    user = process.env.RABBIT_USER || 'guest',
+    password = process.env.RABBIT_PASSWORD || 'guest',
+    vhost = process.env.RABBIT_VHOST || '',
+  } = config;
+  const uri = `${protocol}://${user}:${password}@${hostname}:${port}${vhost ? '/' + vhost : ''}`;
+  return connect(uri);
+}

package/src/lib/extra-validators.ts

@@ -0,0 +1,62 @@
+import {
+  isDefined,
+  registerDecorator,
+  ValidateIf,
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+
+@ValidatorConstraint({ async: false })
+class IsNotSiblingOfConstraint implements ValidatorConstraintInterface {
+  validate(value: any, args: ValidationArguments) {
+    if (isDefined(value)) {
+      return this.getFailedConstraints(args).length === 0;
+    } else {
+      return !args.constraints.every((prop) => !isDefined(args.object[prop]));
+    }
+  }
+
+  defaultMessage(args: ValidationArguments) {
+    if (args.value) {
+      return `${args.property} cannot exist alongside the following defined properties: ${this.getFailedConstraints(args).join(', ')}`;
+    } else {
+      return `at least one of the properties must be defined`;
+    }
+  }
+
+  getFailedConstraints(args: ValidationArguments) {
+    return args.constraints.filter((prop) => isDefined(args.object[prop]));
+  }
+}
+
+// Create Decorator for the constraint that was just created
+function IsNotSiblingOf(props: string[], validationOptions?: ValidationOptions) {
+  return (object: any, propertyName: string) => {
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      constraints: props,
+      validator: IsNotSiblingOfConstraint,
+    });
+  };
+}
+
+// Helper function for determining if a prop should be validated
+function incompatibleSiblingsNotPresent(incompatibleSiblings: string[]) {
+  return (o, v) =>
+    Boolean(
+      isDefined(v) || incompatibleSiblings.every((prop) => !isDefined(o[prop])), // Validate if all incompatible siblings are not defined
+    );
+}
+
+export function IncompatableWith(incompatibleSiblings: string[]) {
+  const notSibling = IsNotSiblingOf(incompatibleSiblings);
+  const validateIf = ValidateIf(incompatibleSiblingsNotPresent(incompatibleSiblings));
+  return (target: any, key: string) => {
+    notSibling(target, key);
+    validateIf(target, key);
+  };
+}