meadow-integration 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "meadow-integration",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "description": "Meadow Data Integration",
     "retoldBeacon": {
         "displayName": "Meadow Integration",

package/source/services/guid/Meadow-Integration-GUIDStrategy.js

@@ -50,12 +50,29 @@ function abbreviationFor(pEntityName, pContext)
 	return _deriveAbbreviation(pEntityName);
 }
 
-/** The GUID column width for an entity (from the live schema), or 0 (unbounded) if unknown. */
+/**
+ * The GUID column width for an entity, or 0 (unbounded) if unknown.
+ *
+ * Prefers the live schema width (`SchemaSizes`, populated for the entity actually being imported), then
+ * falls back to the host catalog's declared `GUIDSize`. The fallback is LOAD-BEARING for JOIN compose:
+ * when a child references a parent (e.g. Product → Material), only the CHILD's schema is loaded, so
+ * `SchemaSizes` has no entry for the parent. Without the catalog width the parent's foreign-key GUID is
+ * composed unbounded (never hashed) while the parent's OWN GUID was hashed to fit its column — so a long
+ * key makes the two diverge and the cross-session match silently breaks. The catalog `GUIDSize` MUST
+ * therefore match the parent's real GUID column width for long keys to resolve.
+ */
 function _maxLengthFor(pEntityName, pContext)
 {
 	const tmpSizes = (pContext && pContext.SchemaSizes) || {};
-	const tmpSize = Number(tmpSizes[pEntityName] || 0);
-	return (tmpSize > 0) ? tmpSize : 0;
+	const tmpSchemaSize = Number(tmpSizes[pEntityName] || 0);
+	if (tmpSchemaSize > 0)
+	{
+		return tmpSchemaSize;
+	}
+	const tmpCatalog = (pContext && pContext.Catalog) || {};
+	const tmpEntry = tmpCatalog[pEntityName];
+	const tmpCatalogSize = tmpEntry ? Number(tmpEntry.GUIDSize || 0) : 0;
+	return (tmpCatalogSize > 0) ? tmpCatalogSize : 0;
 }
 
 /** Build a compose spec (prefix + ordered segments + length budget) for an entity's fullGUID. */

package/test/Meadow-Integration-GUIDStrategyTransform_test.js

@@ -129,6 +129,38 @@ suite
 			}
 		);
 		test
+		(
+			'a long parent key hashes IDENTICALLY for the own GUID and a cross-session FK (catalog GUIDSize fallback)',
+			() =>
+			{
+				// Mirrors the live failure: a parent key long enough to overflow the parent's GUID column.
+				// The parent's OWN GUID is hashed to fit (its schema width is loaded during the parent import);
+				// the child is imported SEPARATELY, so only the CHILD's schema width is loaded — the parent's
+				// width has to come from the host catalog, or the FK is composed unbounded and never matches.
+				const tmpCatalog = { Material: { Abbrev: 'M', GUIDSize: 36 }, Product: { Abbrev: 'PR', GUIDSize: 96 } };
+				const tmpLongKey = 'ZZHASHKEY_' + 'A'.repeat(32); // UI_M + 42 chars overflows 36 -> must hash
+
+				// Parent import — Material's 36-char column width is present in SchemaSizes.
+				const tmpMaterialStrategy = libEngine.compileGUIDStrategy(
+					{ Prefix: 'UI', Entities: { Material: { Mode: 'prefixed', OwnKeyColumn: 'MaterialKey' } } },
+					{ Catalog: tmpCatalog, SchemaSizes: { Material: 36 } }).Strategies.Material;
+				const tmpMaterialComp = runOneEntity(newTransform(), { Entity: 'Material', GUIDName: 'GUIDMaterial', GUIDStrategy: tmpMaterialStrategy, Mappings: {} }, { MaterialKey: tmpLongKey });
+				const tmpMaterialGUID = Object.keys(tmpMaterialComp)[0];
+				Expect(tmpMaterialGUID.length, 'parent own GUID fits its 36-char column').to.be.at.most(36);
+				Expect(tmpMaterialGUID.indexOf('AAAA'), 'parent own GUID was hashed, not raw').to.equal(-1);
+
+				// Child import (separate session) — ONLY Product's width is in SchemaSizes; Material's width must
+				// come from the catalog for the FK to hash the same way.
+				const tmpProductStrategy = libEngine.compileGUIDStrategy(
+					{ Prefix: 'UI', Entities: { Product: { Mode: 'prefixed', OwnKeyColumn: 'ProductKey', Joins: [ { ParentEntity: 'Material', Mode: 'prefixed', KeyColumn: 'MaterialKey', CrossSession: true } ] } } },
+					{ Catalog: tmpCatalog, SchemaSizes: { Product: 96 } }).Strategies.Product;
+				const tmpProductComp = runOneEntity(newTransform(), { Entity: 'Product', GUIDName: 'GUIDProduct', GUIDStrategy: tmpProductStrategy, Mappings: {} }, { ProductKey: 'PRLONG1', MaterialKey: tmpLongKey });
+				const tmpProductGUID = Object.keys(tmpProductComp)[0];
+
+				Expect(tmpProductComp[tmpProductGUID]._GUIDMaterial, 'long-key FK hashes identically to the parent own GUID').to.equal(tmpMaterialGUID);
+			}
+		);
+		test
 		(
 			'a non-strategy mapping still uses the flat GUIDTemplate (no behavior change)',
 			() =>