@onehat/data 1.22.26 → 1.22.28

package/cypress/e2e/Property/Mixed.cy.js

@@ -0,0 +1,105 @@
+import PropertyTypes from '../../../src/Property/index.js';
+import _ from 'lodash';
+
+describe('MixedProperty', function() {
+
+	beforeEach(function() {
+		const
+			definition = {
+				type: 'mixed',
+				types: [
+					'int',
+					'string',
+				],
+			},
+			Property = PropertyTypes[definition.type];
+		this.property = new Property(definition);
+	});
+
+	it('className', function() {
+		const className = this.property.getClassName();
+		expect(className).to.be.eq('Mixed');
+	});
+
+	it('events are handled properly', function() {
+		this.property.on('change', (property, oldValue, newValue) => {
+			if (property.getCurrentType() === 'int') {
+				expect(oldValue).to.be.eq(null);
+				expect(newValue).to.be.eq(42);
+			} else {
+				expect(oldValue).to.be.eq(null);
+				expect(newValue).to.be.eq('here');
+			}
+		});
+
+		this.property.setValue(42);
+		this.property.setValue('here');
+	});
+
+	describe('direct methods', function() {
+
+		it('getCurrentType', function() {
+			const currentType = this.property.getCurrentType();
+			expect(currentType).to.be.eq('int');
+
+			// switch type
+			this.property.setValue('Hello');
+			const newCurrentType = this.property.getCurrentType();
+			expect(newCurrentType).to.be.eq('string');
+		});
+
+		it('getInternalProperty', function() {
+			const intProperty = this.property.getInternalProperty('int');
+			expect(intProperty).to.be.not.undefined;
+			expect(intProperty.constructor.type).to.be.eq('int');
+
+			// switch type
+			this.property.setValue('Hello');
+			const stringProperty = this.property.getInternalProperty('string');
+			expect(stringProperty).to.be.not.undefined;
+			expect(stringProperty.constructor.type).to.be.eq('string');
+		});
+
+		it('destroy', function() {
+			this.property.destroy();
+			expect(this.property.internalProperties).to.be.empty;
+		});
+
+	});
+
+	it('passes methods to currentProperty', function() {
+		
+		this.property.setValue(42);
+		expect(this.property.getSubmitValue()).to.be.eq(42);
+		expect(this.property.getCurrentType()).to.be.eq('int');
+
+		this.property.setValue('here');
+		expect(this.property.getSubmitValue()).to.be.eq('here');
+		expect(this.property.getCurrentType()).to.be.eq('string');
+
+	});
+
+	it('passes configs to internal properties', function() {
+		const
+			definition = {
+				type: 'mixed',
+				types: [
+					{
+						type: 'date',
+						readFormat: 'YYYY-MM-DD',
+						displayFormat: 'YYYY',
+						submitFormat: 'YYYY-MM',
+					},
+					'string',
+				],
+			},
+			Property = PropertyTypes[definition.type],
+			property = new Property(definition);
+		
+		property.setValue('2025-10-17');
+		expect(property.getSubmitValue()).to.be.eq('2025-10');
+		expect(property.getDisplayValue()).to.be.eq('2025');
+		expect(property.getCurrentType()).to.be.eq('date');
+	});
+
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@onehat/data",
-	"version": "1.22.26",
+	"version": "1.22.28",
 	"description": "JS data modeling package with adapters for many storage mediums.",
 	"main": "src/index.js",
 	"type": "module",
@@ -38,11 +38,11 @@
 	"dependencies": {
 		"@onehat/events": "^1.6.6",
 		"accounting-js": "^2.0.3",
-		"async-wait-until": "^2.0.27",
-		"axios": "^1.11.0",
-		"chrono-node": "^2.8.3",
+		"async-wait-until": "^2.0.31",
+		"axios": "^1.13.0",
+		"chrono-node": "^2.9.0",
 		"he": "^1.2.0",
-		"js-base64": "^3.7.7",
+		"js-base64": "^3.7.8",
 		"lodash": "^4.17.21",
 		"moment": "^2.30.1",
 		"natsort": "^2.0.3",
@@ -50,7 +50,7 @@
 		"object-hash": "^3.0.0",
 		"qs": "^6.14.0",
 		"relative-time-parser": "^1.0.15",
-		"uuid": "^11.1.0"
+		"uuid": "^13.0.0"
 	},
 	"peerDependencies": {
 		"fast-xml-parser": "^4.4.1",

package/src/Property/Mixed.js

@@ -0,0 +1,408 @@
+/** @module Property */
+
+import EventEmitter from '@onehat/events';
+import Base64Property from './Base64.js';
+import BooleanProperty from './Boolean.js';
+import CurrencyProperty from './Currency.js';
+import DateProperty from './Date.js';
+import DateTimeProperty from './DateTime.js';
+import FileProperty from './File.js';
+import FloatProperty from './Float.js';
+import IntegerProperty from './Integer.js';
+import JsonProperty, { TagProperty } from './Json.js';
+import PercentProperty from './Percent.js';
+import PercentIntProperty from './PercentInt.js';
+import StringProperty from './String.js';
+import TimeProperty from './Time.js';
+import UuidProperty from './Uuid.js';
+import _ from 'lodash';
+
+/**
+ * Class represents a Property that can store values of multiple types.
+ * The actual type is determined dynamically based on the value being set.
+ * 
+ * Usage: { name: 'date', title: 'Date', types: ['date', 'string'], },
+ * This is primarily used to allow a field that's normally one PropertyType
+ * to also accept string values (e.g. values like '2025-01-01' or 'N/A').
+ * 
+ * @extends Property
+ */
+export default class MixedProperty extends EventEmitter {
+
+	constructor(config = {}, entity) {
+		config = _.merge({}, MixedProperty.defaults, config);
+
+		if (!config.types || !Array.isArray(config.types) || config.types.length < 2) {
+			throw Error('MixedProperty requires a types array with at least two types in its configuration.');
+		}
+
+		super(config, entity);
+
+		this.registerEvents([
+			'change',
+			'changeValidity',
+			'destroy',
+		]);
+
+		this.types = config.types;
+		this.currentType = this.types[0].type || this.types[0];
+		this.internalProperties = new Map();
+
+		this._createInternalProperties();
+		
+		this.currentProperty = this.internalProperties.get(this.currentType);
+
+		this._proxy = new Proxy(this, {
+			get(mixedProperty, prop, receiver) {
+				if (prop in mixedProperty) {
+					const value = mixedProperty[prop];
+					if (typeof value === 'function') {
+						return value.bind(mixedProperty);
+					}
+					return value;
+				}
+				if (mixedProperty.currentProperty && prop in mixedProperty.currentProperty) {
+					const value = mixedProperty.currentProperty[prop];
+					if (typeof value === 'function') {
+						return value.bind(mixedProperty.currentProperty);
+					}
+					return value;
+				}
+				return undefined;
+			},
+			has(mixedProperty, prop) {
+				if (prop in mixedProperty) {
+					return true;
+				}
+				return mixedProperty.currentProperty ? prop in mixedProperty.currentProperty : false;
+			}
+		});
+	
+		return this._proxy;
+	}
+
+	/**
+	 * Creates internal Property instances for each configured type
+	 * @private
+	 */
+	_createInternalProperties() {
+		_.each(this.types, (typeConfig) => {
+			let typeName,
+				propertyConfig;
+			if (typeof typeConfig === 'string') {
+				typeName = typeConfig;
+				propertyConfig = {};
+			} else {
+				typeName = typeConfig.type;
+				propertyConfig = _.omit(typeConfig, 'type');
+			}
+			
+			const
+				PropertyClass = this._getPropertyClass(typeName),
+
+				// Create a clean config for this internal property
+				baseConfig = _.omit(this.config, ['types', 'defaultType']), // Start with base config but exclude Mixed-specific settings
+				mergedConfig = _.merge({}, baseConfig, propertyConfig, { // Merge with type-specific config, giving precedence to type-specific settings
+					name: this.name,
+				}),
+				property = new PropertyClass(mergedConfig, this.entity);
+			
+			this._setupEventForwarding(property);
+
+			this.internalProperties.set(typeName, property);
+		});
+	}
+
+	/**
+	 * Gets the Property class for a given type name
+	 * @param {string} typeName - Name of the property type
+	 * @returns {Class} Property class
+	 * @private
+	 */
+	_getPropertyClass(typeName) {
+		const
+			typeMap = {
+				base64: Base64Property,
+				bool: BooleanProperty,
+				currency: CurrencyProperty,
+				date: DateProperty,
+				datetime: DateTimeProperty,
+				file: FileProperty,
+				float: FloatProperty,
+				int: IntegerProperty,
+				json: JsonProperty,
+				percent: PercentProperty,
+				percentint: PercentIntProperty,
+				string: StringProperty,
+				tag: TagProperty,
+				time: TimeProperty,
+				uuid: UuidProperty,
+			},
+			PropertyClass = typeMap[typeName.toLowerCase()];
+		
+		if (!PropertyClass) {
+			const availableTypes = Object.keys(typeMap).join(', ');
+			throw new Error(`Unknown property type: '${typeName}'. Available types are: ${availableTypes}`);
+		}
+
+		return typeMap[typeName.toLowerCase()];
+	}
+
+	/**
+	 * Sets up event forwarding from an internal property to this MixedProperty
+	 * @param {Property} property - Internal property to forward events from
+	 * @private
+	 */
+	_setupEventForwarding(property) {
+		// Forward all events from internal property to MixedProperty
+		const forwardEvent = (eventName, ...args) => {
+			if (property === this.currentProperty) {
+				// Replace the property reference in args with this MixedProperty
+				const modifiedArgs = args.map(arg => arg === property ? this : arg);
+				this.emit(eventName, ...modifiedArgs);
+			}
+		};
+
+		// Listen to all registered events on the internal property
+		property.getRegisteredEvents().forEach((eventName) => {
+			property.on(eventName, (...args) => forwardEvent(eventName, ...args));
+		});
+	}
+
+	/**
+	 * Detects the appropriate property type for a given value
+	 * @param {any} value - Value to analyze
+	 * @returns {string} Detected type name
+	 * @private
+	 */
+	_detectType(value) {
+		if (_.isNil(value)) {
+			return this.currentType || this.defaultType || (typeof this.types[0] === 'string' ? this.types[0] : this.types[0].type);
+		}
+
+		// Get available type names from config
+		const availableTypes = this.types.map(typeConfig => 
+			typeof typeConfig === 'string' ? typeConfig : typeConfig.type
+		);
+
+		// Define precedence order - more specific types first
+		const precedenceOrder = [
+			'bool',      // Most specific - only true/false/1/0
+			'int',       // Integers
+			'float',     // Floating point numbers
+			'currency',  // Currency values
+			'percent',   // Percentage values
+			'percentint',// Integer percentages
+			'date',      // Date values
+			'datetime',  // DateTime values  
+			'time',      // Time values
+			'uuid',      // UUID format
+			'base64',    // Base64 encoded data
+			'json',      // JSON objects/arrays
+			'tag',       // Tag format
+			'file',      // File data
+			'string'     // Most general - accepts anything
+		];
+
+		// Try types in precedence order, but only if they're in the available types
+		let typeName;
+		for(typeName of precedenceOrder) {
+			if (availableTypes.includes(typeName)) {
+				const property = this.internalProperties.get(typeName);
+				if (property && this._canParseValue(property, value)) {
+					return typeName;
+				}
+			}
+		}
+
+		throw new Error(`No configured property type could handle value: ${value}. Available types: ${availableTypes.join(', ')}`);
+	}
+
+	/**
+	 * Tests if a property can successfully parse a value
+	 * @param {Property} property - Property to test
+	 * @param {any} value - Value to test
+	 * @returns {boolean} Whether the property can parse the value
+	 * @private
+	 */
+	_canParseValue(property, value) {
+		try {
+			switch(property.constructor.type) {
+				case 'bool':
+					return this._isBooleanValue(value);
+				case 'int':
+					return this._isIntegerValue(value);
+				case 'float':
+					return this._isFloatValue(value);
+			}
+			
+			property.parse(value);
+			return true;
+		} catch (error) {
+			return false;
+		}
+	}
+
+	/**
+	 * Checks if a value represents a boolean
+	 * @param {any} value - Value to check
+	 * @returns {boolean} Whether the value is boolean-like
+	 * @private
+	 */
+	_isBooleanValue(value) {
+		switch(typeof value) {
+			case 'boolean':
+				return true;
+			case 'number':
+				return value === 0 || value === 1;
+			case 'string':
+				const lower = value.toLowerCase().trim();
+				return ['true', 'false', '1', '0'].includes(lower);
+			default:
+				return false;
+		}
+	}
+
+	/**
+	 * Checks if a value represents an integer
+	 * @param {any} value - Value to check
+	 * @returns {boolean} Whether the value is integer-like
+	 * @private
+	 */
+	_isIntegerValue(value) {
+		switch(typeof value) {
+			case 'bigint':
+				return true;
+			case 'number':
+				return Number.isInteger(value);
+			case 'string':
+				const trimmed = value.trim();
+				if (trimmed === '') {
+					return false;
+				}
+				const num = Number(trimmed);
+				return !isNaN(num) && Number.isInteger(num) && String(num) === trimmed;
+		}
+		return false;
+	}
+
+	/**
+	 * Checks if a value represents a float
+	 * @param {any} value - Value to check
+	 * @returns {boolean} Whether the value is float-like
+	 * @private
+	 */
+	_isFloatValue(value) {
+		switch(typeof value) {
+			case 'number':
+				return !Number.isInteger(value) && isFinite(value);
+			case 'string':
+				const trimmed = value.trim();
+				if (trimmed === '') return false;
+				const num = Number(trimmed);
+				return !isNaN(num) && isFinite(num) && !Number.isInteger(num);
+		}
+		return false;
+	}
+
+	/**
+	 * Sets the value and determines the appropriate type
+	 * @param {any} value - Value to set
+	 */
+	setValue(value) {
+		const detectedType = this._detectType(value);
+		if (this.currentType !== detectedType) {
+			this.currentType = detectedType;
+			this.currentProperty = this.internalProperties.get(this.currentType);
+		}
+		this.currentProperty.setValue(value);
+	}
+
+	/**
+	 * Gets the current type name
+	 * @returns {string} Current type name
+	 */
+	getCurrentType() {
+		return this.currentProperty.constructor.type;
+	}
+
+	/**
+	 * Gets the className of this Property type.
+	 * @return {string} className
+	 */
+	getClassName() {
+		return this.constructor.className;
+	}
+
+	/**
+	 * Gets the internal property for a specific type
+	 * @param {string} typeName - Type name
+	 * @returns {Property} Internal property
+	 */
+	getInternalProperty(typeName) {
+		return this.internalProperties.get(typeName);
+	}
+
+	//     ______                 __
+	//    / ____/   _____  ____  / /______
+	//   / __/ | | / / _ \/ __ \/ __/ ___/
+	//  / /___ | |/ /  __/ / / / /_(__  )
+	// /_____/ |___/\___/_/ /_/\__/____/
+	//
+	// (Override the EventEmitter methods to forward listener management to internal properties)
+
+
+	/**
+	 * Add event listener to MixedProperty only
+	 * Events from internal properties are forwarded via _setupEventForwarding
+	 */
+	on(eventName, listener) {
+		return super.on(eventName, listener);
+	}
+
+	/**
+	 * Add one-time event listener to MixedProperty only
+	 */
+	once(eventName, listener) {
+		return super.once(eventName, listener);
+	}
+
+	/**
+	 * Remove event listener from MixedProperty only
+	 */
+	off(eventName, listener) {
+		return super.off(eventName, listener);
+	}
+
+	/**
+	 * Remove all event listeners from MixedProperty and all internal properties
+	 */
+	removeAllListeners(eventName) {
+		// Remove all listeners from this MixedProperty
+		super.removeAllListeners(eventName);
+		
+		// Remove all listeners from internal properties
+		this.internalProperties.forEach(property => {
+			property.removeAllListeners(eventName);
+		});
+		
+		return this;
+	}
+
+	/**
+	 * Destroys all internal properties
+	 */
+	destroy() {
+		// Clean up listener mappings
+		if (this._listenerMappings) {
+			this._listenerMappings.clear();
+			this._listenerMappings = null;
+		}
+
+		this.internalProperties.forEach((property) => property.destroy());
+		this.internalProperties.clear();
+	}
+}
+
+MixedProperty.className = 'Mixed';
+MixedProperty.type = 'mixed';

package/src/Property/index.js

@@ -9,6 +9,7 @@ import FileProperty from './File.js';
 import FloatProperty from './Float.js';
 import IntegerProperty from './Integer.js';
 import JsonProperty, { TagProperty } from './Json.js';
+import MixedProperty from './Mixed.js';
 import PercentProperty from './Percent.js';
 import PercentIntProperty from './PercentInt.js';
 import Property from './Property.js';
@@ -26,6 +27,7 @@ const PropertyTypes = {
 	[FloatProperty.type]: FloatProperty,
 	[IntegerProperty.type]: IntegerProperty,
 	[JsonProperty.type]: JsonProperty,
+	[MixedProperty.type]: MixedProperty,
 	[PercentProperty.type]: PercentProperty,
 	[PercentIntProperty.type]: PercentIntProperty,
 	[Property.type]: Property,

package/src/Repository/OneBuild.js

@@ -544,20 +544,30 @@ class OneBuildRepository extends AjaxRepository {
 		}
 
 		return this.axios(data)
-			.then((result) => {
-				if (this.debugMode) {
-					console.log('login response', result);
-				}
+					.catch((error) => {
 
-				const response = result.data;
-				if (!response.success) {
-					this.throwError(response.data); // TODO: Fix back-end, so OneBuild submits the error message on response.message, not response.data
-					return false;
-				}
+						if (this.debugMode) {
+							console.log(data.url + ' error', error);
+							console.log('response:', error.response);
+						}
+						
+						this.throwError(error);
+						return;
+					})
+					.then((result) => {
+						if (this.debugMode) {
+							console.log('login response', result);
+						}
 
-				const userData = response.data;
-				return userData;
-			});
+						const response = result.data;
+						if (!response.success) {
+							this.throwError(response.data); // TODO: Fix back-end, so OneBuild submits the error message on response.message, not response.data
+							return false;
+						}
+
+						const userData = response.data;
+						return userData;
+					});
 	}
 
 	/**