export class ValueType extends Type<string | number | Date | undefined, string> {
  convertToDatabaseValue(value: string | number | Date | undefined): string {
    if (value === undefined || value === null) {
      return JSON.stringify({ value: null, type: 'null' });
    }
    if (typeof value === 'string') {
      return JSON.stringify({ value, type: 'string' });
    }
    if (typeof value === 'number') {
      return JSON.stringify({ value, type: 'number' });
    }
    if (value instanceof Date) {
      return JSON.stringify({ value: value.toISOString(), type: 'date' });
    }
    throw ValidationError.invalidType(ValueType, value, 'JS');
  }

  convertToJSValue(
    value: string | { value: any; type: string } | null | undefined,
    plattform: Platform,
  ): string | number | Date | undefined {
    if (value === undefined || value === null) {
      return undefined;
    }
    if (typeof value === 'object' && 'type' in value && 'value' in value) {
      return this._fromJson(value);
    }
    if (typeof value === 'string') {
      try {
        const json = JSON.parse(value);
        return this._fromJson(json);
      } catch (e) {
        return value;
      }
    }
    throw ValidationError.invalidType(ValueType, value, 'database');
  }

  private _fromJson(json: { value: any; type: string }): string | number | Date | undefined {
    if (json.type === 'string') return json.value;
    if (json.type === 'number') return json.value;
    if (json.type === 'date') return json.value ? new Date(json.value) : undefined;
    if (json.type === 'null') return undefined;
    throw ValidationError.invalidType(ValueType, json, 'database');
  }

  getColumnType(prop: EntityProperty, platform: Platform) {
    return platform.getJsonDeclarationSQL?.() || 'jsonb';
  }
}

@Embeddable()export class OutputRuleCondition {
  @Property({ type: 'text', name: 'operator' })
  public operator!: string;

  @Property({
    type: ValueType,
    nullable: true,
  })
  public comparisonValue?: string | number | Date;
}


@Embeddable()
export class OutputRuleCalculation {
  @Property({ type: 'text' })
  public calculationType!: string;

  @Property({ type: ValueType, nullable: true })
  public constant?: string | number | Date;
}


@Entity({ tableName: 'example' })
export class OutputRule {
  @PrimaryKey({ type: 'uuid' })
  public id!: string;

  @Property({ type: 'boolean' })
  public isDefault!: boolean;

  @Embedded(() => OutputRuleCalculation, { object: true })
  public calculation!: OutputRuleCalculation;

  @Embedded(() => OutputRuleCondition, { array: true })
  public conditions: OutputRuleCondition[] = [];
}

const outputRule = new OutputRule();
outputRule.id = 'b2e1e6b2-1234-4c1a-9c2a-abcdefabcdef';
outputRule.isDefault = true;
outputRule.calculation = new OutputRuleCalculation();
outputRule.calculation.calculationType = 'constant';
outputRule.calculation.constant = 42; // could also be a string, Date or undefined
outputRule.conditions = [
  Object.assign(new OutputRuleCondition(), {
    operator: 'eq',
    comparisonValue: 'foo',
  }),
  Object.assign(new OutputRuleCondition(), {
    operator: 'gt',
    comparisonValue: new Date('2024-01-01T00:00:00Z'),
  }),
];
await em.persistAndFlush(outputRule);