@contrail/flexplm 1.4.0 → 1.5.0-alpha.14a4f1b

package/lib/interfaces/mapping-file.d.ts

@@ -0,0 +1,460 @@
+import { FunctionTransformers, RekeyTransformers, TransformDefinition, TransformTask } from "@contrail/transform-data";
+/**
+ * One direction of a {@link MappingSection} (either `vibe2flex` or `flex2vibe`).
+ *
+ * Holds the per-direction transform pipeline plus the named lookup tables
+ * (`rekey`, `removeKey`, `valueTransform`) that the tasks in
+ * {@link DirectionalSection.transformOrder} reference by key. A REKEY task
+ * configured with `rekeyTransformersKey: 'rekey'` resolves to
+ * {@link DirectionalSection.rekey} on the same directional section.
+ *
+ * The named members below cover the conventional shape, but the section
+ * is open: each task in a pipeline resolves its config by reading the
+ * sibling property whose name is supplied by the matching `*Key` pointer
+ * on the task. That means a directional section can hold:
+ *  - additional `TransformTask[]` pipelines under names other than
+ *    `transformOrder` (selected by passing a non-default `orderKey` to
+ *    `MapFileUtil.getTransformTasks`)
+ *  - additional REKEY / REMOVE / MORPH / VALUE_TRANSFORM / CONDITIONAL
+ *    lookup tables under arbitrary names referenced by the task's
+ *    `rekeyTransformersKey`, `removeKeysKey`, `functionTransformersKey`,
+ *    or `conditionalTransformDefinitionsKey`.
+ *
+ * @example
+ * vibe2flex: {
+ *   transformOrder: [
+ *     { processor: 'VALUE_TRANSFORM', functionTransformersKey: 'valueTransform' },
+ *     { processor: 'REKEY', rekeyDelete: true, rekeyKeepEmptyValues: true, rekeyTransformersKey: 'rekey' },
+ *     { processor: 'REMOVE', removeKeysKey: 'removeKey' },
+ *   ],
+ *   rekey: { productName: 'name', custBrand: 'brand' },
+ *   valueTransform: {
+ *     itemNumber: (row) => '' + row['itemNumber'],
+ *   },
+ *   removeKey: ['patternReference', 'vibeOnlyProp'],
+ * }
+ */
+export interface DirectionalSection {
+    /**
+     * Ordered pipeline of transforms applied to each row in this direction.
+     *
+     * Each task is dispatched by its `processor` discriminator
+     * (REKEY, REMOVE, VALUE_TRANSFORM, MORPH, CONDITIONAL) and reads its
+     * configuration from the corresponding sibling property on this section
+     * (e.g. a REKEY task with `rekeyTransformersKey: 'rekey'` reads
+     * {@link DirectionalSection.rekey}).
+     *
+     * @example
+     * transformOrder: [
+     *   { processor: 'REKEY', rekeyDelete: true, rekeyKeepEmptyValues: true, rekeyTransformersKey: 'rekey' },
+     *   { processor: 'REMOVE', removeKeysKey: 'removeKey' },
+     * ]
+     */
+    transformOrder?: TransformTask[];
+    /**
+     * Resolves the FlexPLM object class (vibe2flex) or VibeIQ entity class
+     * (flex2vibe) for a row when it cannot be derived from the row itself.
+     *
+     * Consulted by `TypeConversionUtils.getObjectClass` /
+     * `getEntityClassFromObject` after the explicit `flexPLMObjectClass` /
+     * `vibeIQEntityClass` property and before the `TypeDefaults` fallback.
+     *
+     * @example
+     * // vibe2flex
+     * getClass: () => 'LCSRevisableEntity'
+     * // flex2vibe
+     * getClass: () => 'custom-entity'
+     */
+    getClass?: (entity: Record<string, unknown>) => string;
+    /**
+     * Resolves the FlexPLM type path (vibe2flex) or VibeIQ type path
+     * (flex2vibe) for a row when it cannot be derived from the row itself.
+     *
+     * Consulted by `TypeConversionUtils.getObjectTypePath` /
+     * `getEntityTypePathFromObject` after the explicit `flexPLMTypePath` /
+     * `vibeIQTypePath` property and before the `TypeDefaults` fallback.
+     *
+     * @example
+     * // vibe2flex
+     * getSoftType: () => 'Revisable Entity\\Product Concept'
+     * // flex2vibe
+     * getSoftType: () => 'custom-entity:styleConcept'
+     */
+    getSoftType?: (entity: Record<string, unknown>) => string;
+    /**
+     * Lookup table consumed by REKEY tasks in {@link DirectionalSection.transformOrder}.
+     *
+     * **Read each entry as `destination: 'source'`** — the property name (left)
+     * is the key written onto the row, the string value (right) is the
+     * existing key whose value is read. Each entry copies (or moves, when the
+     * task sets `rekeyDelete: true`) the value at the source key onto the
+     * destination key. Referenced by `rekeyTransformersKey` on the REKEY task.
+     *
+     * Because REKEY runs on the row in its **input** shape, the source side
+     * matches the direction's input system and the destination side matches
+     * its output system:
+     *  - Inside `vibe2flex.rekey`: `flexKey: 'vibeKey'` (vibe in → flex out).
+     *  - Inside `flex2vibe.rekey`: `vibeKey: 'flexKey'` (flex in → vibe out).
+     *
+     * @example
+     * // vibe2flex — left side is the FlexPLM key, right side is the VibeIQ key
+     * rekey: {
+     *   productName:    'name',         // flex 'productName'   ← vibe 'name'
+     *   custBrand:      'brand',        // flex 'custBrand'     ← vibe 'brand'
+     *   custStyleNumber: 'styleNumber', // flex 'custStyleNumber' ← vibe 'styleNumber'
+     * }
+     *
+     * @example
+     * // flex2vibe — left side is the VibeIQ key, right side is the FlexPLM key
+     * rekey: {
+     *   name:        'productName',     // vibe 'name'        ← flex 'productName'
+     *   brand:       'custBrand',       // vibe 'brand'       ← flex 'custBrand'
+     *   styleNumber: 'custStyleNumber', // vibe 'styleNumber' ← flex 'custStyleNumber'
+     * }
+     */
+    rekey?: RekeyTransformers;
+    /**
+     * Lookup table consumed by REMOVE tasks in {@link DirectionalSection.transformOrder}.
+     *
+     * Names of keys to delete from each row. Referenced by `removeKeysKey`
+     * on the REMOVE task.
+     *
+     * @example
+     * removeKey: ['patternReference', 'vibeOnlyProp']
+     */
+    removeKey?: string[];
+    /**
+     * Lookup table consumed by VALUE_TRANSFORM tasks in
+     * {@link DirectionalSection.transformOrder}.
+     *
+     * Each entry's key is the property the function's return value is written
+     * to on the row; the function receives the full row plus optional
+     * dependencies. Referenced by `functionTransformersKey` on the
+     * VALUE_TRANSFORM task.
+     *
+     * @example
+     * valueTransform: {
+     *   itemNumber: (row) => {
+     *     const numValue = parseInt(row['itemNumber'], 10);
+     *     return isNaN(numValue) ? row['itemNumber'] : numValue;
+     *   },
+     * }
+     */
+    valueTransform?: Record<string, (row: Record<string, unknown>, dependencies?: unknown) => unknown>;
+    /**
+     * Lookup table consumed by MORPH tasks in {@link DirectionalSection.transformOrder}.
+     *
+     * Each entry's function receives the full row plus optional dependencies
+     * and may rewrite/augment it in place; unlike {@link DirectionalSection.valueTransform},
+     * the function key is just an identifier and is not the destination
+     * property. Referenced by `functionTransformersKey` on the MORPH task.
+     *
+     * @example
+     * morphTransform: {
+     *   morph1: (row) => {
+     *     const val = row['productStatus'];
+     *     if (val && Object.keys(val).length === 0) {
+     *       delete row['productStatus'];
+     *     }
+     *   },
+     * }
+     */
+    morphTransform?: Record<string, (row: Record<string, unknown>, dependencies?: unknown) => unknown>;
+    /**
+     * Catch-all for additional pipelines and per-processor lookup tables
+     * referenced by sibling `*Key` pointers on tasks. Each entry should be
+     * one of:
+     *  - {@link TransformTask}[] — alternate pipeline (read it by passing
+     *    its property name as `orderKey` to `MapFileUtil.getTransformTasks`)
+     *  - {@link RekeyTransformers} — `newKey` → `existingKey` map for REKEY
+     *  - `string[]` — keys to delete for REMOVE
+     *  - {@link FunctionTransformers} — Record<string, Function> for MORPH or VALUE_TRANSFORM
+     *  - {@link TransformDefinition}[] — conditional rules for CONDITIONAL
+     */
+    [key: string]: TransformTask[] | TransformDefinition[] | RekeyTransformers | FunctionTransformers | Record<string, unknown> | string[] | ((entity: Record<string, unknown>) => string) | ((entity: Record<string, unknown>) => string[]) | ((row: Record<string, unknown>, dependencies?: unknown) => unknown) | undefined;
+}
+/**
+ * Per-entity-type configuration block, keyed in the {@link MappingFile}
+ * by the section key returned from
+ * {@link TypeConversionEntry.getMapKey} (e.g. `LCSProduct`,
+ * `'Exchange Rate'`).
+ *
+ * Holds direction-agnostic settings (ownership, identifier/informational
+ * properties, creation and image-sync gates) plus the two
+ * {@link DirectionalSection}s that drive the actual data transforms.
+ *
+ * @example
+ * LCSProduct: {
+ *   vibeOwningKeys: ['itemNumber', 'lifecycleStage'],
+ *   getIdentifierProperties: () => ['styleNumber'],
+ *   vibe2flex: {
+ *     transformOrder: [
+ *       { processor: 'REKEY', rekeyDelete: true, rekeyKeepEmptyValues: true, rekeyTransformersKey: 'rekey' },
+ *     ],
+ *     // destination: source -> flexKey: 'vibeKey'
+ *     rekey: { productName: 'name' },
+ *   },
+ *   flex2vibe: {
+ *     transformOrder: [
+ *       { processor: 'REKEY', rekeyDelete: true, rekeyKeepEmptyValues: true, rekeyTransformersKey: 'rekey' },
+ *     ],
+ *     // destination: source -> vibeKey: 'flexKey'
+ *     rekey: { name: 'productName' },
+ *   },
+ * }
+ */
+export interface MappingSection {
+    /**
+     * These are the slugs of the properties that the VibeIQ system owns.  So
+     * even if data comes in from an external source, it is ignored and the
+     * values are not overwritten.
+     *
+     * @example
+     * vibeOwningKeys: ['itemNumber', 'lifecycleStage']
+     */
+    vibeOwningKeys?: string[];
+    /**
+     * Tag identifying which identity service uniqueness pool this entity participates in.
+     * There can only be one entity with a given value for the property(defined by `getIdentifierProperties`) within the same uniqueness pool.
+     *
+     * @example
+     * uniquenessPool: 'item'
+     */
+    uniquenessPool?: string;
+    /**
+     * Gate controlling whether an inbound FlexPLM object is allowed to
+     * create a new VibeIQ entity. When the function returns `false`, the
+     * inbound row may still update an existing entity but will not create
+     * one. Consulted by `TypeConversionUtils.isInboundCreatableFromObject`;
+     * defaults to `false` when the function is absent.
+     *
+     * @example
+     * isInboundCreatable: () => true
+     */
+    isInboundCreatable?: (entity: Record<string, unknown>, context?: unknown) => boolean;
+    /**
+     * Gate controlling whether an outbound VibeIQ entity is allowed to
+     * create a new FlexPLM object. When the function returns `false`, the
+     * outbound publish becomes an update-only operation. Consulted by
+     * `TypeConversionUtils.isOutboundCreatableFromEntity`; defaults to
+     * `true` when the function is absent.
+     *
+     * @example
+     * isOutboundCreatable: () => false
+     */
+    isOutboundCreatable?: (entity: Record<string, unknown>, context?: unknown) => boolean;
+    /**
+     * Gate controlling whether image/thumbnail content should be synced
+     * from FlexPLM into VibeIQ for this entity type. Consulted by
+     * `TypeConversionUtils.syncInboundImages`; defaults to `false` when
+     * the function is absent. Typically aligned with whichever system
+     * owns creation of the entity.
+     *
+     * @example
+     * syncInboundImages: () => true
+     */
+    syncInboundImages?: (entity: Record<string, unknown>, context?: unknown) => boolean;
+    /**
+     * Gate controlling whether image/thumbnail content should be synced
+     * from VibeIQ out to FlexPLM for this entity type. Consulted by
+     * `TypeConversionUtils.syncOutboundImages`; defaults to `true` when
+     * the function is absent. Typically aligned with whichever system
+     * owns creation of the entity.
+     *
+     * @example
+     * syncOutboundImages: () => false
+     */
+    syncOutboundImages?: (entity: Record<string, unknown>, context?: unknown) => boolean;
+    /**
+     * Returns the property names that uniquely identify this entity. Used
+     * by `TypeConversionUtils.getIdentifierProperties` to drive lookup and
+     * matching when an explicit `flexPLMIdentifierProperties` /
+     * `vibeIQIdentifierProperties` is not present on the row, falling
+     * back to `TypeDefaults` when this is absent.
+     *
+     * @example
+     * getIdentifierProperties: () => ['itemNumber']
+     */
+    getIdentifierProperties?: (entity: Record<string, unknown>) => string[];
+    /**
+     * Returns supplemental property names that should be carried alongside
+     * identifiers (e.g. display names) but do not participate in identity.
+     * Consulted by `TypeConversionUtils.getInformationalProperties` with
+     * the same lookup precedence as {@link MappingSection.getIdentifierProperties}.
+     *
+     * @example
+     * getInformationalProperties: () => ['longName']
+     */
+    getInformationalProperties?: (entity: Record<string, unknown>) => string[];
+    /**
+     * Transform configuration applied when sending data from VibeIQ to FlexPLM.
+     * Pipeline runs on rows in their VibeIQ shape and produces rows in their
+     * FlexPLM shape, so inside `rekey` the destination (left) is the FlexPLM
+     * key and the source (right) is the VibeIQ key — see
+     * {@link DirectionalSection.rekey}.
+     */
+    vibe2flex?: DirectionalSection;
+    /**
+     * Transform configuration applied when receiving data from FlexPLM into VibeIQ.
+     * Pipeline runs on rows in their FlexPLM shape and produces rows in their
+     * VibeIQ shape, so inside `rekey` the destination (left) is the VibeIQ
+     * key and the source (right) is the FlexPLM key — see
+     * {@link DirectionalSection.rekey}.
+     */
+    flex2vibe?: DirectionalSection;
+}
+/**
+ * Entry in the {@link TypeConversionSection} that maps a single source
+ * type onto the {@link MappingSection} key that should handle it.
+ *
+ * Useful for fanning a single VibeIQ `entityType` (e.g. `'custom-entity'`)
+ * out to multiple sections based on the row's `typePath`.
+ */
+export interface TypeConversionEntry {
+    /**
+     * Returns the {@link MappingFile} key whose {@link MappingSection}
+     * should be used to transform `entity`. Returning an empty string
+     * signals that no section applies and the row should be skipped.
+     *
+     * @example
+     * getMapKey: (entity) => {
+     *   switch (entity['typePath']) {
+     *     case 'custom-entity:exchangeRate': return 'Exchange Rate';
+     *     case 'custom-entity:styleConcept': return 'Style Concept Master';
+     *     default: return '';
+     *   }
+     * }
+     */
+    getMapKey: (entity: Record<string, unknown>) => string;
+}
+/**
+ * One direction of {@link TypeConversion}, keyed by the source-system
+ * type:
+ * - In `vibe2flex`, keys are VibeIQ entity types (e.g. `'custom-entity'`,
+ *   `'size-range-template'`) — see `TypeConversionUtils.getEntityType`.
+ * - In `flex2vibe`, keys are FlexPLM object classes (e.g. `LCSProduct`) —
+ *   see `TypeConversionUtils.getObjectType`.
+ */
+export interface TypeConversionSection {
+    [type: string]: TypeConversionEntry;
+}
+/**
+ * Top-level routing table that resolves a row to its
+ * {@link MappingSection} key for each direction.
+ *
+ * `TypeConversionUtils.getMapKey` / `getMapKeyFromObject` look up the
+ * row's type in the appropriate side, invoke
+ * {@link TypeConversionEntry.getMapKey}, and use the returned string
+ * as the key into the rest of the {@link MappingFile}.
+ *
+ * @example
+ * typeConversion: {
+ *   vibe2flex: {
+ *     'custom-entity': {
+ *       getMapKey: (entity) => {
+ *         switch (entity['typePath']) {
+ *           case 'custom-entity:exchangeRate': return 'Exchange Rate';
+ *           default: return '';
+ *         }
+ *       },
+ *     },
+ *     'size-range-template': {
+ *       getMapKey: () => 'size-range-template',
+ *     },
+ *   },
+ *   flex2vibe: {
+ *     LCSRevisableEntity: {
+ *       getMapKey: (object) => {
+ *         switch (object['flexPLMTypePath']) {
+ *           case 'Revisable Entity\\Exchange Rate': return 'Exchange Rate';
+ *           default: return '';
+ *         }
+ *       },
+ *     },
+ *   },
+ * }
+ */
+export interface TypeConversion {
+    /** Routes outbound VibeIQ entities to their FlexPLM mapping sections. */
+    vibe2flex: TypeConversionSection;
+    /** Routes inbound FlexPLM objects to their VibeIQ mapping sections. */
+    flex2vibe: TypeConversionSection;
+}
+/** Identifies the application and tenant that owns a {@link MappingFile}. */
+export interface OrgInfo {
+    /** This is the identifier for the application, and is used to set the owner of the mapping file */
+    appIdentifier: '@vibeiq/flexplm-connector';
+    /** The name of the organization using the mapping file. */
+    orgName: string;
+}
+interface MappingFileBase {
+    /** The information about the organization using the mapping file */
+    orgInfo: OrgInfo;
+    /** The type conversion information for the mapping file. */
+    typeConversion: TypeConversion;
+}
+/**
+ * Full mapping file driving bidirectional sync between VibeIQ and FlexPLM
+ * for a single tenant.
+ *
+ * Combines the fixed {@link MappingFileBase} fields (`orgInfo`,
+ * `typeConversion`) with an open set of {@link MappingSection} entries
+ * keyed by the strings returned from
+ * {@link TypeConversionEntry.getMapKey} (e.g. `LCSProduct`, `LCSSKU`,
+ * `'Exchange Rate'`).
+ *
+ * @example
+ * export const mapping: MappingFile = {
+ *   orgInfo: {
+ *     appIdentifier: '@vibeiq/flexplm-connector',
+ *     orgName: 'acme',
+ *   },
+ *   typeConversion: {
+ *     vibe2flex: {
+ *       'custom-entity': {
+ *         getMapKey: (entity) => {
+ *           switch (entity['typePath']) {
+ *             case 'custom-entity:exchangeRate': return 'Exchange Rate';
+ *             default: return '';
+ *           }
+ *         },
+ *       },
+ *       'size-range-template': {
+ *         getMapKey: () => 'size-range-template',
+ *       },
+ *     },
+ *     flex2vibe: {
+ *       LCSRevisableEntity: {
+ *         getMapKey: (object) => {
+ *           switch (object['flexPLMTypePath']) {
+ *             case 'Revisable Entity\\Exchange Rate': return 'Exchange Rate';
+ *             default: return '';
+ *           }
+ *         },
+ *       },
+ *     },
+ *   },
+ *   'Exchange Rate': {
+ *     vibe2flex: {
+ *       transformOrder: [
+ *         { processor: 'REKEY', rekeyDelete: true, rekeyKeepEmptyValues: true, rekeyTransformersKey: 'rekey' },
+ *       ],
+ *       rekey: { exchangeRateDescription: 'name' },
+ *       getClass: () => 'LCSRevisableEntity',
+ *       getSoftType: () => 'Revisable Entity\\Exchange Rate',
+ *     },
+ *     flex2vibe: {
+ *       transformOrder: [
+ *         { processor: 'REKEY', rekeyDelete: true, rekeyKeepEmptyValues: true, rekeyTransformersKey: 'rekey' },
+ *       ],
+ *       rekey: { name: 'exchangeRateDescription' },
+ *       getClass: () => 'custom-entity',
+ *       getSoftType: () => 'custom-entity:exchangeRate',
+ *     },
+ *   },
+ * };
+ */
+export type MappingFile = MappingFileBase & {
+    [mapKey: string]: MappingSection | MappingFileBase[keyof MappingFileBase];
+};
+export {};

package/lib/interfaces/mapping-file.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/publish/base-process-publish-assortment.d.ts

@@ -32,6 +32,15 @@ export declare class BaseProcessPublishAssortment {
         skip_await?: undefined;
     }>;
     getPublishInfo(assortmentId: string, assortmentPublishChangeId: string, apcHistory: any, publisher: any): Promise<any>;
+    /** Gets the version number of the snapshot that was created for the publish change.
+     * But if no snapshot was found for the publish change, and the last snapshot was
+     * created before the publish change, then it returns 'after: versionNumber' where
+     * versionNumber is the version number of the last snapshot.
+     * If no snapshot was found for the publish change, and the last snapshot was
+     * created after the publish change, then it returns 'unknown'.
+     *
+     * @returns versionNumber or 'unknown' or 'after: versionNumber'
+     */
     getSnapshotVersion(assortment: any, apc: any): Promise<number | string>;
     getSeasonFederation(assortmentId: any): Promise<SeasonFederation>;
     getAssortment(assortmentId: any): Promise<any>;
@@ -82,6 +91,22 @@ export declare class BaseProcessPublishAssortment {
     private getCurrentDateString;
     getItemFamilyChanges(pcd: PublishChangeData, changeDetail: any, assortmentItemFullChangeMap: Map<string, any>, assortmentItemDeleteMap: Map<string, any>): Map<string, ItemFamilyChanges>;
     getEventsForPublishChangeData(publishChangeData: PublishChangeData): Promise<SeasonalPayload[]>;
+    /**Returns the events for a given ItemFamilyChanges object
+     *
+     * Cases:
+     * Add just family:
+     * Add option to family (with existing option):
+     * Add option to family (no options on assortment):
+     * Remove family and option:
+     * Remove only option and leave family:
+     * Remove one option of multiple for family:
+     *
+     * @param itemFamilyChanges
+     * @param assortmentId
+     * @param assortmentFederationId
+     * @param itemToFederatedIdMapping
+     * @returns
+     */
     getEventsForItemFamilyChanges(itemFamilyChanges: ItemFamilyChanges, assortmentId: string, seasonFed: SeasonFederation, itemToFederatedIdMapping: Map<string, string>): Promise<SeasonalPayload[]>;
     getProjectItem(itemFamilyChanges: ItemFamilyChanges, id: string): any;
     getSeasonalData(projectItem: any): Promise<object>;

package/lib/publish/base-process-publish-assortment.js

@@ -13,7 +13,7 @@ const app_framework_1 = require("@contrail/app-framework");
 const event_short_message_status_1 = require("../util/event-short-message-status");
 class BaseProcessPublishAssortment {
     constructor(_config, _dc, _mapFileUtil) {
-        this.TTL = 30 * 24 * 60 * 60 * 1000;
+        this.TTL = 30 * 24 * 60 * 60 * 1000; // 30 days
         this.cache = {
             carriedFromSeason: {}
         };
@@ -52,13 +52,14 @@ class BaseProcessPublishAssortment {
             }
             apcHistory = await this.getApcHistory(assortmentId);
             const sinceDate = await this.getSinceDate(assortmentId, assortmentPublishChangeId, apcHistory);
+            //Get detail information
             const assortmentPublishChange = await this.downloadAssortmentPublishChange(assortmentId, assortmentPublishChangeId);
             publisher = this.getPublisher(assortmentPublishChange);
             const changeDetail = await this.downloadHydratedChangeDetail(assortmentPublishChange);
             const assortmentBaseline = await this.downloadAssortmentBaseline(assortmentPublishChange);
             const deleteChanges = await this.getDeleteChanges(assortmentPublishChange, apcHistory, assortmentBaseline, sinceDate);
             const releasedForDevelopmentItemIds = this.getReleasedForDevelopmentItemAndFamilyIds(assortmentBaseline, deleteChanges);
-            const itemToFederatedIdMapping = await this.getItemFederatedIds();
+            const itemToFederatedIdMapping = await this.getItemFederatedIds( /*allItemIds*/);
             const pcd = new publish_change_data_1.PublishChangeData(assortmentId, seasonFed, assortmentPublishChangeId, sinceDate, publisher);
             pcd.itemToFederatedIdMapping = itemToFederatedIdMapping;
             pcd.releasedForDevelopmentItemIds = releasedForDevelopmentItemIds;
@@ -94,6 +95,15 @@ class BaseProcessPublishAssortment {
         };
         return publishInfo;
     }
+    /** Gets the version number of the snapshot that was created for the publish change.
+     * But if no snapshot was found for the publish change, and the last snapshot was
+     * created before the publish change, then it returns 'after: versionNumber' where
+     * versionNumber is the version number of the last snapshot.
+     * If no snapshot was found for the publish change, and the last snapshot was
+     * created after the publish change, then it returns 'unknown'.
+     *
+     * @returns versionNumber or 'unknown' or 'after: versionNumber'
+     */
     async getSnapshotVersion(assortment, apc) {
         const entityReference = assortment?.createdForReference;
         const createdOnString = apc?.createdOn;
@@ -101,7 +111,7 @@ class BaseProcessPublishAssortment {
             return 'unknown';
         }
         const createdOnDate = new Date(createdOnString);
-        createdOnDate.setMonth(createdOnDate.getMonth() - 1);
+        createdOnDate.setMonth(createdOnDate.getMonth() - 1); //subtract 1 month
         const createdOnStringMinus1 = createdOnDate.toISOString();
         const createdOn = 'ISGREATERTHAN ' + createdOnStringMinus1;
         const snapshots = await new sdk_1.Entities().get({
@@ -348,6 +358,7 @@ class BaseProcessPublishAssortment {
             console.info('sinceDateMilliseconds: ' + sinceDateMilliseconds);
             console.info('apcDateMilliseconds: ' + previousApcDate);
         }
+        //if only 1 apc, no processing needed
         if (sinceDateMilliseconds !== previousApcDate) {
             console.info('sinceDateMilliseconds !== apcDateMilliseconds');
             const currentAssortmentItemIds = this.getBaselineItemIds(assortmentBaseline);
@@ -433,12 +444,27 @@ class BaseProcessPublishAssortment {
             previousBaseline = await this.downloadAssortmentBaseline(previousApc);
         }
         const deleteIds = apc?.detail?.deletes.map(dItem => dItem?.id);
+        //building deletes based on previous baseline; because some APCs don't have delete data
         const deleteArray = previousBaseline?.assortmentItems.filter(aItem => deleteIds.includes(aItem?.itemId));
         console.info('deleteArray.length: ' + deleteArray.length);
         return deleteArray;
     }
-    async getItemFederatedIds() {
+    async getItemFederatedIds( /*itemIds*/) {
         const itemFederatedIds = new Map();
+        // const expandedItemIds = itemIds.map(id => 'item:' + id);
+        // const fedRecords = await new Federation(this.logger).getFederationRecordsFromIdsBulk(expandedItemIds);
+        // for (let i = 0; i < fedRecords.length; i++) {
+        //   const federationRecord = fedRecords[i];
+        //   // console.log('federationRecord: ' + JSON.stringify(federationRecord));
+        //   // console.log('federationRecord.reference: ' + federationRecord.reference);
+        //   // console.log('federationRecord.mappedReference: ' + federationRecord.mappedReference);
+        //   let vibeId = federationRecord.reference;
+        //   if (vibeId && vibeId.startsWith('item:')) {
+        //     vibeId = vibeId.substring(5);
+        //   }
+        //   itemFederatedIds.set(vibeId, federationRecord.mappedReference);
+        // }
+        // console.log('itemFederatedIds: ' + JSON.stringify(Object.fromEntries(itemFederatedIds)));
         return itemFederatedIds;
     }
     getFullChangeAssortmentMap(fullChange) {
@@ -565,7 +591,7 @@ class BaseProcessPublishAssortment {
             case 'vibeiqfile-dontsendtoflexplm':
                 return this.handleVibeIQFile(events, eventType, sendMode);
             default:
-                return {};
+                return {}; // Or handle other cases as required
         }
     }
     async sendToFlexPLM(events, eventType) {
@@ -735,7 +761,7 @@ class BaseProcessPublishAssortment {
             else {
                 ifc.colorDeletes.push(itemId);
             }
-        }
+        } //End deletes for loop
         if (app_framework_1.Logger.isDebugOn()) {
             console.debug('returning size: ' + itemFamilyChanges.size);
             for (const [key, value] of itemFamilyChanges) {
@@ -755,6 +781,22 @@ class BaseProcessPublishAssortment {
         }
         return seasonalPayloads;
     }
+    /**Returns the events for a given ItemFamilyChanges object
+     *
+     * Cases:
+     * Add just family:
+     * Add option to family (with existing option):
+     * Add option to family (no options on assortment):
+     * Remove family and option:
+     * Remove only option and leave family:
+     * Remove one option of multiple for family:
+     *
+     * @param itemFamilyChanges
+     * @param assortmentId
+     * @param assortmentFederationId
+     * @param itemToFederatedIdMapping
+     * @returns
+     */
     async getEventsForItemFamilyChanges(itemFamilyChanges, assortmentId, seasonFed, itemToFederatedIdMapping) {
         console.info('getEventsForItemFamilyChanges()');
         const events = [];
@@ -764,7 +806,10 @@ class BaseProcessPublishAssortment {
         const familyAssortmentItem = itemFamilyChanges.familyAdd || itemFamilyChanges.familyUpdate || itemFamilyChanges.familyDelete
             || itemFamilyChanges.colorAdds.length > 0 || itemFamilyChanges.colorUpdates.length > 0 || itemFamilyChanges.colorDeletes.length > 0
             || (projectItem && this.updatedSinceDate(projectItem, itemFamilyChanges.sinceDate));
+        //familyItemRemoved is used when adding the first option to an assortment
+        //and will have updates for the family item.
         if (familyAssortmentItem) {
+            //Product-season add
             const entityReference = itemFamilyChanges.itemFamilyId;
             const prodEntityData = (itemFamilyChanges.assortmentItemFullChangeMap.has(entityReference))
                 ? itemFamilyChanges.assortmentItemFullChangeMap.get(entityReference)?.item
@@ -790,6 +835,9 @@ class BaseProcessPublishAssortment {
             }
             events.push(psUpsert);
         }
+        //colorway-season adds
+        //colorAdds
+        //colorUpdates
         const colorwayChanges = [];
         colorwayChanges.push(...itemFamilyChanges.colorAdds);
         colorwayChanges.push(...itemFamilyChanges.colorUpdates);
@@ -830,6 +878,9 @@ class BaseProcessPublishAssortment {
             const aItem = itemFamilyChanges?.assortmentItemFullChangeMap.get(id);
             projectItem = aItem?.projectItem;
         }
+        /////////////////////////////////////////////////////////////////////////////
+        //Get from option assortmentItem because family not in assortmentItemFullChangeMap:start
+        /////////////////////////////////////////////////////////////////////////////
         if (id === itemFamilyChanges.itemFamilyId && Object.keys(projectItem).length == 0) {
             for (const asstItem of itemFamilyChanges.assortmentItemFullChangeMap.values()) {
                 if (asstItem?.familyProjectItem) {
@@ -838,6 +889,9 @@ class BaseProcessPublishAssortment {
                 }
             }
         }
+        /////////////////////////////////////////////////////////////////////////////
+        //Get from option assortmentItem because family not in assortmentItemFullChangeMap:end
+        /////////////////////////////////////////////////////////////////////////////
         return projectItem;
     }
     async getSeasonalData(projectItem) {