@currentjs/gen 0.5.3 → 0.5.5

package/dist/utils/typeUtils.js

@@ -5,6 +5,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ROW_TYPE_MAPPING = exports.TYPE_MAPPING = void 0;
 exports.capitalize = capitalize;
+exports.parseFieldType = parseFieldType;
+exports.isValueObjectFieldType = isValueObjectFieldType;
+exports.getReferencedValueObjects = getReferencedValueObjects;
 exports.mapType = mapType;
 exports.isAggregateReference = isAggregateReference;
 exports.mapRowType = mapRowType;
@@ -33,28 +36,119 @@ exports.ROW_TYPE_MAPPING = {
     datetime: 'string',
     date: 'string',
     id: 'number',
-    json: 'string',
-    array: 'string',
-    object: 'string',
+    json: 'any',
+    array: 'any[]',
+    object: 'any',
     enum: 'string'
 };
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
+/**
+ * Parse a YAML field type string into its structural components.
+ * Handles simple types ("Money"), array types ("Money[]"), union types ("Foo | Bar"),
+ * and array-of-union types ("(Foo | Bar)[]").
+ */
+function parseFieldType(typeStr) {
+    const trimmed = typeStr.trim();
+    // Array of union: "(Foo | Bar)[]"
+    if (trimmed.startsWith('(') && trimmed.endsWith(')[]')) {
+        const inner = trimmed.slice(1, -3).trim();
+        const parts = inner.split('|').map(p => p.trim()).filter(Boolean);
+        return { baseTypes: parts, isArray: true, isUnion: true };
+    }
+    if (trimmed.endsWith('[]')) {
+        const base = trimmed.slice(0, -2).trim();
+        return { baseTypes: [base], isArray: true, isUnion: false };
+    }
+    if (trimmed.includes('|')) {
+        const parts = trimmed.split('|').map(p => p.trim()).filter(Boolean);
+        return { baseTypes: parts, isArray: false, isUnion: true };
+    }
+    return { baseTypes: [trimmed], isArray: false, isUnion: false };
+}
+/**
+ * Returns true when any base type in the (possibly compound) type expression is a known value object.
+ */
+function isValueObjectFieldType(typeStr, valueObjects) {
+    const { baseTypes } = parseFieldType(typeStr);
+    return baseTypes.some(bt => {
+        const cap = capitalize(bt);
+        return valueObjects instanceof Set ? valueObjects.has(cap) : valueObjects.has(cap);
+    });
+}
+/**
+ * Returns the set of value object names referenced in a (possibly compound) type expression.
+ */
+function getReferencedValueObjects(typeStr, valueObjects) {
+    const { baseTypes } = parseFieldType(typeStr);
+    const result = new Set();
+    for (const bt of baseTypes) {
+        const cap = capitalize(bt);
+        const has = valueObjects instanceof Set ? valueObjects.has(cap) : valueObjects.has(cap);
+        if (has)
+            result.add(cap);
+    }
+    return result;
+}
 /**
  * Map a YAML field type to TypeScript type, resolving aggregates and value objects by name.
+ * Supports compound types: "Foo[]" -> "Foo[]", "Foo | Bar" -> "Foo | Bar".
  */
 function mapType(yamlType, aggregates, valueObjects) {
-    var _a;
+    var _a, _b;
+    // Simple aggregate reference (no compound syntax)
     if (aggregates === null || aggregates === void 0 ? void 0 : aggregates.has(yamlType))
         return yamlType;
+    const parsed = parseFieldType(yamlType);
+    // Array of union of value objects: "(Foo | Bar)[]"
+    if (parsed.isArray && parsed.isUnion) {
+        const resolvedParts = parsed.baseTypes.map(bt => {
+            var _a;
+            const cap = capitalize(bt);
+            if (valueObjects) {
+                const has = valueObjects instanceof Set ? valueObjects.has(cap) : valueObjects.has(cap);
+                if (has)
+                    return cap;
+            }
+            return (_a = exports.TYPE_MAPPING[bt]) !== null && _a !== void 0 ? _a : 'any';
+        });
+        return `(${resolvedParts.join(' | ')})[]`;
+    }
+    // Array of value objects: "Foo[]"
+    if (parsed.isArray) {
+        const [base] = parsed.baseTypes;
+        const capitalizedBase = capitalize(base);
+        if (valueObjects) {
+            const has = valueObjects instanceof Set ? valueObjects.has(capitalizedBase) : valueObjects.has(capitalizedBase);
+            if (has)
+                return `${capitalizedBase}[]`;
+        }
+        // Fall back: treat as plain mapped type array
+        return `${(_a = exports.TYPE_MAPPING[base]) !== null && _a !== void 0 ? _a : 'any'}[]`;
+    }
+    // Union of value objects: "Foo | Bar"
+    if (parsed.isUnion) {
+        const resolvedParts = parsed.baseTypes.map(bt => {
+            var _a;
+            const cap = capitalize(bt);
+            if (valueObjects) {
+                const has = valueObjects instanceof Set ? valueObjects.has(cap) : valueObjects.has(cap);
+                if (has)
+                    return cap;
+            }
+            return (_a = exports.TYPE_MAPPING[bt]) !== null && _a !== void 0 ? _a : 'any';
+        });
+        return resolvedParts.join(' | ');
+    }
+    // Simple type
     const capitalizedType = capitalize(yamlType);
     if (valueObjects) {
         const has = valueObjects instanceof Set ? valueObjects.has(capitalizedType) : valueObjects.has(capitalizedType);
         if (has)
             return capitalizedType;
     }
-    return (_a = exports.TYPE_MAPPING[yamlType]) !== null && _a !== void 0 ? _a : 'any';
+    return (_b = exports.TYPE_MAPPING[yamlType]) !== null && _b !== void 0 ? _b : 'any';
 }
 /**
  * Check if a YAML field type references another aggregate entity.
@@ -63,14 +157,14 @@ function isAggregateReference(yamlType, aggregates) {
     return !!(aggregates === null || aggregates === void 0 ? void 0 : aggregates.has(yamlType));
 }
 /**
- * Map a YAML type to the store row TypeScript type (value objects become string).
+ * Map a YAML type to the store row TypeScript type.
+ * Value objects (including compound types) become "string" (stored as JSON).
  */
 function mapRowType(yamlType, valueObjects) {
     var _a;
     if (valueObjects) {
-        const capitalizedType = capitalize(yamlType);
-        const has = valueObjects instanceof Set ? valueObjects.has(capitalizedType) : valueObjects.has(capitalizedType);
-        if (has)
+        // Any compound type containing a VO name is stored as JSON string
+        if (isValueObjectFieldType(yamlType, valueObjects))
             return 'string';
     }
     return (_a = exports.ROW_TYPE_MAPPING[yamlType]) !== null && _a !== void 0 ? _a : 'string';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@currentjs/gen",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "CLI code generator",
   "license": "LGPL-3.0",
   "author": "Konstantin Zavalny",