@transcend-io/cli 6.9.0 → 6.11.0

package/build/preference-management/codecs.d.ts

@@ -0,0 +1,369 @@
+import * as t from 'io-ts';
+export declare const PurposeRowMapping: t.TypeC<{
+    /**
+     * The slug or trackingType of the purpose to map to
+     *
+     * e.g. `Marketing`
+     */
+    purpose: t.StringC;
+    /**
+     * If the column maps to a preference instead of a purpose
+     * this is the slug of the purpose.
+     *
+     * null value indicates that this column maps to the true/false
+     * value of the purpose
+     */
+    preference: t.UnionC<[t.StringC, t.NullC]>;
+    /**
+     * The mapping between each row value and purpose/preference value.
+     *
+     * e.g. for a boolean preference or purpose
+     * {
+     *  'true': true,
+     *  'false': false,
+     *   '': true,
+     * }
+     *
+     * or for a single or multi select preference
+     * {
+     *   '': true,
+     *   'value1': 'Value1',
+     *   'value2': 'Value2',
+     * }
+     */
+    valueMapping: t.RecordC<t.StringC, t.UnionC<[t.StringC, t.BooleanC, t.NullC]>>;
+}>;
+/** Override type */
+export type PurposeRowMapping = t.TypeOf<typeof PurposeRowMapping>;
+export declare const FileMetadataState: t.IntersectionC<[t.TypeC<{
+    /**
+     * Definition of how to map each column in the CSV to
+     * the relevant purpose and preference definitions in transcend
+     */
+    columnToPurposeName: t.RecordC<t.StringC, t.TypeC<{
+        /**
+         * The slug or trackingType of the purpose to map to
+         *
+         * e.g. `Marketing`
+         */
+        purpose: t.StringC;
+        /**
+         * If the column maps to a preference instead of a purpose
+         * this is the slug of the purpose.
+         *
+         * null value indicates that this column maps to the true/false
+         * value of the purpose
+         */
+        preference: t.UnionC<[t.StringC, t.NullC]>;
+        /**
+         * The mapping between each row value and purpose/preference value.
+         *
+         * e.g. for a boolean preference or purpose
+         * {
+         *  'true': true,
+         *  'false': false,
+         *   '': true,
+         * }
+         *
+         * or for a single or multi select preference
+         * {
+         *   '': true,
+         *   'value1': 'Value1',
+         *   'value2': 'Value2',
+         * }
+         */
+        valueMapping: t.RecordC<t.StringC, t.UnionC<[t.StringC, t.BooleanC, t.NullC]>>;
+    }>>;
+    /** Last time the file was last parsed at */
+    lastFetchedAt: t.StringC;
+    /**
+     * Mapping of userId to the rows in the file that need to be uploaded
+     * These uploads are overwriting non-existent preferences and are safe
+     */
+    pendingSafeUpdates: t.RecordC<t.StringC, t.RecordC<t.StringC, t.StringC>>;
+    /**
+     * Mapping of userId to the rows in the file that need to be uploaded
+     * these records have conflicts with existing consent preferences
+     */
+    pendingConflictUpdates: t.RecordC<t.StringC, t.TypeC<{
+        record: t.IntersectionC<[t.TypeC<{
+            userId: t.StringC;
+            partition: t.StringC;
+            timestamp: t.StringC;
+        }>, t.TypeC<{
+            system: t.IntersectionC<[t.TypeC<{
+                decryptionStatus: t.KeyofC<{
+                    ERROR: unknown;
+                    DECRYPTED: unknown;
+                }>;
+            }>, t.PartialC<{
+                updatedAt: t.StringC;
+            }>]>;
+            consentManagement: t.PartialC<{
+                usp: t.UnionC<[t.StringC, t.NullC]>;
+                gpp: t.UnionC<[t.StringC, t.NullC]>;
+                tcf: t.UnionC<[t.StringC, t.NullC]>;
+                airgapVersion: t.UnionC<[t.StringC, t.NullC]>;
+            }>;
+            purposes: t.ArrayC<t.IntersectionC<[t.TypeC<{
+                purpose: t.StringC;
+                enabled: t.BooleanC;
+            }>, t.PartialC<{
+                preferences: t.ArrayC<t.TypeC<{
+                    topic: t.StringC;
+                    choice: t.PartialC<{
+                        booleanValue: t.UnionC<[t.BooleanC, t.NullC]>;
+                        selectValue: t.UnionC<[t.StringC, t.NullC]>;
+                        selectValues: t.UnionC<[t.ArrayC<t.StringC>, t.NullC]>;
+                    }>;
+                }>>;
+            }>]>>;
+        }>, t.PartialC<{
+            metadata: t.ArrayC<t.TypeC<{
+                key: t.StringC;
+                value: t.StringC;
+            }>>;
+            metadataTimestamp: t.StringC;
+        }>]>;
+        row: t.RecordC<t.StringC, t.StringC>;
+    }>>;
+    /**
+     * Mapping of userId to the rows in the file that can be skipped because
+     * their preferences are already in the store
+     */
+    skippedUpdates: t.RecordC<t.StringC, t.RecordC<t.StringC, t.StringC>>;
+}>, t.PartialC<{
+    /** Determine which column name in file maps to consent record identifier to upload on  */
+    identifierColumn: t.StringC;
+    /** Determine which column name in file maps to the timestamp  */
+    timestampColum: t.StringC;
+}>]>;
+/** Override type */
+export type FileMetadataState = t.TypeOf<typeof FileMetadataState>;
+/** Persist this data between runs of the script */
+export declare const PreferenceState: t.TypeC<{
+    /**
+     * Store a cache of previous files read in
+     */
+    fileMetadata: t.RecordC<t.StringC, t.IntersectionC<[t.TypeC<{
+        /**
+         * Definition of how to map each column in the CSV to
+         * the relevant purpose and preference definitions in transcend
+         */
+        columnToPurposeName: t.RecordC<t.StringC, t.TypeC<{
+            /**
+             * The slug or trackingType of the purpose to map to
+             *
+             * e.g. `Marketing`
+             */
+            purpose: t.StringC;
+            /**
+             * If the column maps to a preference instead of a purpose
+             * this is the slug of the purpose.
+             *
+             * null value indicates that this column maps to the true/false
+             * value of the purpose
+             */
+            preference: t.UnionC<[t.StringC, t.NullC]>;
+            /**
+             * The mapping between each row value and purpose/preference value.
+             *
+             * e.g. for a boolean preference or purpose
+             * {
+             *  'true': true,
+             *  'false': false,
+             *   '': true,
+             * }
+             *
+             * or for a single or multi select preference
+             * {
+             *   '': true,
+             *   'value1': 'Value1',
+             *   'value2': 'Value2',
+             * }
+             */
+            valueMapping: t.RecordC<t.StringC, t.UnionC<[t.StringC, t.BooleanC, t.NullC]>>;
+        }>>;
+        /** Last time the file was last parsed at */
+        lastFetchedAt: t.StringC;
+        /**
+         * Mapping of userId to the rows in the file that need to be uploaded
+         * These uploads are overwriting non-existent preferences and are safe
+         */
+        pendingSafeUpdates: t.RecordC<t.StringC, t.RecordC<t.StringC, t.StringC>>;
+        /**
+         * Mapping of userId to the rows in the file that need to be uploaded
+         * these records have conflicts with existing consent preferences
+         */
+        pendingConflictUpdates: t.RecordC<t.StringC, t.TypeC<{
+            record: t.IntersectionC<[t.TypeC<{
+                userId: t.StringC;
+                partition: t.StringC;
+                timestamp: t.StringC;
+            }>, t.TypeC<{
+                system: t.IntersectionC<[t.TypeC<{
+                    decryptionStatus: t.KeyofC<{
+                        ERROR: unknown;
+                        DECRYPTED: unknown;
+                    }>;
+                }>, t.PartialC<{
+                    updatedAt: t.StringC;
+                }>]>;
+                consentManagement: t.PartialC<{
+                    usp: t.UnionC<[t.StringC, t.NullC]>;
+                    gpp: t.UnionC<[t.StringC, t.NullC]>;
+                    tcf: t.UnionC<[t.StringC, t.NullC]>;
+                    airgapVersion: t.UnionC<[t.StringC, t.NullC]>;
+                }>;
+                purposes: t.ArrayC<t.IntersectionC<[t.TypeC<{
+                    purpose: t.StringC;
+                    enabled: t.BooleanC;
+                }>, t.PartialC<{
+                    preferences: t.ArrayC<t.TypeC<{
+                        topic: t.StringC;
+                        choice: t.PartialC<{
+                            booleanValue: t.UnionC<[t.BooleanC, t.NullC]>;
+                            selectValue: t.UnionC<[t.StringC, t.NullC]>;
+                            selectValues: t.UnionC<[t.ArrayC<t.StringC>, t.NullC]>;
+                        }>;
+                    }>>;
+                }>]>>;
+            }>, t.PartialC<{
+                metadata: t.ArrayC<t.TypeC<{
+                    key: t.StringC;
+                    value: t.StringC;
+                }>>;
+                metadataTimestamp: t.StringC;
+            }>]>;
+            row: t.RecordC<t.StringC, t.StringC>;
+        }>>;
+        /**
+         * Mapping of userId to the rows in the file that can be skipped because
+         * their preferences are already in the store
+         */
+        skippedUpdates: t.RecordC<t.StringC, t.RecordC<t.StringC, t.StringC>>;
+    }>, t.PartialC<{
+        /** Determine which column name in file maps to consent record identifier to upload on  */
+        identifierColumn: t.StringC;
+        /** Determine which column name in file maps to the timestamp  */
+        timestampColum: t.StringC;
+    }>]>>;
+    /**
+     * The set of successful uploads to Transcend
+     * Mapping from userId to the upload metadata
+     */
+    failingUpdates: t.RecordC<t.StringC, t.TypeC<{
+        /** Time upload ran at */
+        uploadedAt: t.StringC;
+        /** Attempts to upload that resulted in an error */
+        error: t.StringC;
+        /** The update body */
+        update: t.IntersectionC<[t.TypeC<{
+            userId: t.StringC;
+            partition: t.StringC;
+            timestamp: t.StringC;
+        }>, t.PartialC<{
+            purposes: t.ArrayC<t.IntersectionC<[t.IntersectionC<[t.TypeC<{
+                purpose: t.StringC;
+                enabled: t.BooleanC;
+            }>, t.PartialC<{
+                preferences: t.ArrayC<t.TypeC<{
+                    topic: t.StringC;
+                    choice: t.PartialC<{
+                        booleanValue: t.UnionC<[t.BooleanC, t.NullC]>;
+                        selectValue: t.UnionC<[t.StringC, t.NullC]>;
+                        selectValues: t.UnionC<[t.ArrayC<t.StringC>, t.NullC]>;
+                    }>;
+                }>>;
+            }>]>, t.PartialC<{
+                attributes: t.ArrayC<t.TypeC<{
+                    key: t.StringC;
+                    values: t.ArrayC<t.StringC>;
+                }>>;
+                workflowSettings: t.PartialC<{
+                    attributes: t.ArrayC<t.TypeC<{
+                        key: t.StringC;
+                        values: t.ArrayC<t.StringC>;
+                    }>>;
+                    dataSiloIds: t.ArrayC<t.StringC>;
+                    emailReceiptTemplateId: t.StringC;
+                    ignoreDataSiloIds: t.ArrayC<t.StringC>;
+                    isSilent: t.BooleanC;
+                    isTest: t.BooleanC;
+                    skipSendingReceipt: t.BooleanC;
+                    skipWaitingPeriod: t.BooleanC;
+                    skipWorkflowTrigger: t.BooleanC;
+                }>;
+                locale: t.StringC;
+            }>]>>;
+            consentManagement: t.PartialC<{
+                usp: t.UnionC<[t.StringC, t.NullC]>;
+                gpp: t.UnionC<[t.StringC, t.NullC]>;
+                tcf: t.UnionC<[t.StringC, t.NullC]>;
+                airgapVersion: t.UnionC<[t.StringC, t.NullC]>;
+            }>;
+            locale: t.StringC;
+            metadata: t.ArrayC<t.TypeC<{
+                key: t.StringC;
+                value: t.UnionC<[t.StringC, t.NullC]>;
+            }>>;
+        }>]>;
+    }>>;
+    /**
+     * The set of pending uploads to Transcend
+     * Mapping from userId to the upload metadata
+     */
+    pendingUpdates: t.RecordC<t.StringC, t.IntersectionC<[t.TypeC<{
+        userId: t.StringC;
+        partition: t.StringC;
+        timestamp: t.StringC;
+    }>, t.PartialC<{
+        purposes: t.ArrayC<t.IntersectionC<[t.IntersectionC<[t.TypeC<{
+            purpose: t.StringC;
+            enabled: t.BooleanC;
+        }>, t.PartialC<{
+            preferences: t.ArrayC<t.TypeC<{
+                topic: t.StringC;
+                choice: t.PartialC<{
+                    booleanValue: t.UnionC<[t.BooleanC, t.NullC]>;
+                    selectValue: t.UnionC<[t.StringC, t.NullC]>;
+                    selectValues: t.UnionC<[t.ArrayC<t.StringC>, t.NullC]>;
+                }>;
+            }>>;
+        }>]>, t.PartialC<{
+            attributes: t.ArrayC<t.TypeC<{
+                key: t.StringC;
+                values: t.ArrayC<t.StringC>;
+            }>>;
+            workflowSettings: t.PartialC<{
+                attributes: t.ArrayC<t.TypeC<{
+                    key: t.StringC;
+                    values: t.ArrayC<t.StringC>;
+                }>>;
+                dataSiloIds: t.ArrayC<t.StringC>;
+                emailReceiptTemplateId: t.StringC;
+                ignoreDataSiloIds: t.ArrayC<t.StringC>;
+                isSilent: t.BooleanC;
+                isTest: t.BooleanC;
+                skipSendingReceipt: t.BooleanC;
+                skipWaitingPeriod: t.BooleanC;
+                skipWorkflowTrigger: t.BooleanC;
+            }>;
+            locale: t.StringC;
+        }>]>>;
+        consentManagement: t.PartialC<{
+            usp: t.UnionC<[t.StringC, t.NullC]>;
+            gpp: t.UnionC<[t.StringC, t.NullC]>;
+            tcf: t.UnionC<[t.StringC, t.NullC]>;
+            airgapVersion: t.UnionC<[t.StringC, t.NullC]>;
+        }>;
+        locale: t.StringC;
+        metadata: t.ArrayC<t.TypeC<{
+            key: t.StringC;
+            value: t.UnionC<[t.StringC, t.NullC]>;
+        }>>;
+    }>]>>;
+}>;
+/** Override type */
+export type PreferenceState = t.TypeOf<typeof PreferenceState>;
+//# sourceMappingURL=codecs.d.ts.map

package/build/preference-management/codecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../src/preference-management/codecs.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAE3B,eAAO,MAAM,iBAAiB;IAC5B;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;;;;;;;;;;;;OAgBG;;EAEH,CAAC;AAEH,oBAAoB;AACpB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEnE,eAAO,MAAM,iBAAiB;IAE1B;;;OAGG;;QA1CL;;;;WAIG;;QAEH;;;;;;WAMG;;QAEH;;;;;;;;;;;;;;;;WAgBG;;;IAcD,4CAA4C;;IAE5C;;;OAGG;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQH;;;OAGG;;;IAIH,0FAA0F;;IAE1F,iEAAiE;;IAGnE,CAAC;AAEH,oBAAoB;AACpB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEnE,mDAAmD;AACnD,eAAO,MAAM,eAAe;IAC1B;;OAEG;;QA5CD;;;WAGG;;YA1CL;;;;eAIG;;YAEH;;;;;;eAMG;;YAEH;;;;;;;;;;;;;;;;eAgBG;;;QAcD,4CAA4C;;QAE5C;;;WAGG;;QAEH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAQH;;;WAGG;;;QAIH,0FAA0F;;QAE1F,iEAAiE;;;IAcnE;;;OAGG;;QAIC,yBAAyB;;QAEzB,mDAAmD;;QAEnD,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI1B;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,oBAAoB;AACpB,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/build/preference-management/codecs.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreferenceState = exports.FileMetadataState = exports.PurposeRowMapping = void 0;
+const privacy_types_1 = require("@transcend-io/privacy-types");
+const t = __importStar(require("io-ts"));
+exports.PurposeRowMapping = t.type({
+    /**
+     * The slug or trackingType of the purpose to map to
+     *
+     * e.g. `Marketing`
+     */
+    purpose: t.string,
+    /**
+     * If the column maps to a preference instead of a purpose
+     * this is the slug of the purpose.
+     *
+     * null value indicates that this column maps to the true/false
+     * value of the purpose
+     */
+    preference: t.union([t.string, t.null]),
+    /**
+     * The mapping between each row value and purpose/preference value.
+     *
+     * e.g. for a boolean preference or purpose
+     * {
+     *  'true': true,
+     *  'false': false,
+     *   '': true,
+     * }
+     *
+     * or for a single or multi select preference
+     * {
+     *   '': true,
+     *   'value1': 'Value1',
+     *   'value2': 'Value2',
+     * }
+     */
+    valueMapping: t.record(t.string, t.union([t.string, t.boolean, t.null])),
+});
+exports.FileMetadataState = t.intersection([
+    t.type({
+        /**
+         * Definition of how to map each column in the CSV to
+         * the relevant purpose and preference definitions in transcend
+         */
+        columnToPurposeName: t.record(t.string, exports.PurposeRowMapping),
+        /** Last time the file was last parsed at */
+        lastFetchedAt: t.string,
+        /**
+         * Mapping of userId to the rows in the file that need to be uploaded
+         * These uploads are overwriting non-existent preferences and are safe
+         */
+        pendingSafeUpdates: t.record(t.string, t.record(t.string, t.string)),
+        /**
+         * Mapping of userId to the rows in the file that need to be uploaded
+         * these records have conflicts with existing consent preferences
+         */
+        pendingConflictUpdates: t.record(t.string, t.type({
+            record: privacy_types_1.PreferenceQueryResponseItem,
+            row: t.record(t.string, t.string),
+        })),
+        /**
+         * Mapping of userId to the rows in the file that can be skipped because
+         * their preferences are already in the store
+         */
+        skippedUpdates: t.record(t.string, t.record(t.string, t.string)),
+    }),
+    t.partial({
+        /** Determine which column name in file maps to consent record identifier to upload on  */
+        identifierColumn: t.string,
+        /** Determine which column name in file maps to the timestamp  */
+        timestampColum: t.string,
+    }),
+]);
+/** Persist this data between runs of the script */
+exports.PreferenceState = t.type({
+    /**
+     * Store a cache of previous files read in
+     */
+    fileMetadata: t.record(t.string, exports.FileMetadataState),
+    /**
+     * The set of successful uploads to Transcend
+     * Mapping from userId to the upload metadata
+     */
+    failingUpdates: t.record(t.string, t.type({
+        /** Time upload ran at */
+        uploadedAt: t.string,
+        /** Attempts to upload that resulted in an error */
+        error: t.string,
+        /** The update body */
+        update: privacy_types_1.PreferenceUpdateItem,
+    })),
+    /**
+     * The set of pending uploads to Transcend
+     * Mapping from userId to the upload metadata
+     */
+    pendingUpdates: t.record(t.string, privacy_types_1.PreferenceUpdateItem),
+});
+//# sourceMappingURL=codecs.js.map

package/build/preference-management/codecs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.js","sourceRoot":"","sources":["../../src/preference-management/codecs.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+DAGqC;AACrC,yCAA2B;AAEd,QAAA,iBAAiB,GAAG,CAAC,CAAC,IAAI,CAAC;IACtC;;;;OAIG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM;IACjB;;;;;;OAMG;IACH,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;IACvC;;;;;;;;;;;;;;;;OAgBG;IACH,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;CACzE,CAAC,CAAC;AAKU,QAAA,iBAAiB,GAAG,CAAC,CAAC,YAAY,CAAC;IAC9C,CAAC,CAAC,IAAI,CAAC;QACL;;;WAGG;QACH,mBAAmB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,yBAAiB,CAAC;QAC1D,4CAA4C;QAC5C,aAAa,EAAE,CAAC,CAAC,MAAM;QACvB;;;WAGG;QACH,kBAAkB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;QACpE;;;WAGG;QACH,sBAAsB,EAAE,CAAC,CAAC,MAAM,CAC9B,CAAC,CAAC,MAAM,EACR,CAAC,CAAC,IAAI,CAAC;YACL,MAAM,EAAE,2CAA2B;YACnC,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;SAClC,CAAC,CACH;QACD;;;WAGG;QACH,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;KACjE,CAAC;IACF,CAAC,CAAC,OAAO,CAAC;QACR,0FAA0F;QAC1F,gBAAgB,EAAE,CAAC,CAAC,MAAM;QAC1B,iEAAiE;QACjE,cAAc,EAAE,CAAC,CAAC,MAAM;KACzB,CAAC;CACH,CAAC,CAAC;AAKH,mDAAmD;AACtC,QAAA,eAAe,GAAG,CAAC,CAAC,IAAI,CAAC;IACpC;;OAEG;IACH,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,yBAAiB,CAAC;IACnD;;;OAGG;IACH,cAAc,EAAE,CAAC,CAAC,MAAM,CACtB,CAAC,CAAC,MAAM,EACR,CAAC,CAAC,IAAI,CAAC;QACL,yBAAyB;QACzB,UAAU,EAAE,CAAC,CAAC,MAAM;QACpB,mDAAmD;QACnD,KAAK,EAAE,CAAC,CAAC,MAAM;QACf,sBAAsB;QACtB,MAAM,EAAE,oCAAoB;KAC7B,CAAC,CACH;IACD;;;OAGG;IACH,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,oCAAoB,CAAC;CACzD,CAAC,CAAC"}

package/build/preference-management/getPreferenceUpdatesFromRow.d.ts

@@ -0,0 +1,37 @@
+import { PreferenceStorePurposeResponse } from '@transcend-io/privacy-types';
+import { PurposeRowMapping } from './codecs';
+import { PreferenceTopic } from '../graphql';
+/**
+ * Parse an arbitrary object to the Transcend PUT /v1/preference update shape
+ * by using a mapping of column names to purpose/preference slugs.
+ *
+ * columnToPurposeName looks like:
+ * {
+ *   'my_purpose': 'Marketing',
+ *   'has_topic_1': 'Marketing->BooleanPreference1',
+ *   'has_topic_2': 'Marketing->BooleanPreference2'
+ * }
+ *
+ * row looks like:
+ * {
+ *  'my_purpose': 'true',
+ *  'has_topic_1': 'true',
+ *  'has_topic_2': 'false'
+ * }
+ *
+ * @param options - Options
+ * @returns The parsed row
+ */
+export declare function getPreferenceUpdatesFromRow({ row, columnToPurposeName, purposeSlugs, preferenceTopics, }: {
+    /** Row to parse */
+    row: Record<string, string>;
+    /** Mapping from column name ot row */
+    columnToPurposeName: Record<string, PurposeRowMapping>;
+    /** The set of allowed purpose slugs */
+    purposeSlugs: string[];
+    /** The preference topics */
+    preferenceTopics: PreferenceTopic[];
+}): {
+    [k in string]: Omit<PreferenceStorePurposeResponse, 'purpose'>;
+};
+//# sourceMappingURL=getPreferenceUpdatesFromRow.d.ts.map

package/build/preference-management/getPreferenceUpdatesFromRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPreferenceUpdatesFromRow.d.ts","sourceRoot":"","sources":["../../src/preference-management/getPreferenceUpdatesFromRow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAE/B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,2BAA2B,CAAC,EAC1C,GAAG,EACH,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,GACjB,EAAE;IACD,mBAAmB;IACnB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,sCAAsC;IACtC,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACvD,uCAAuC;IACvC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,4BAA4B;IAC5B,gBAAgB,EAAE,eAAe,EAAE,CAAC;CACrC,GAAG;KACD,CAAC,IAAI,MAAM,GAAG,IAAI,CAAC,8BAA8B,EAAE,SAAS,CAAC;CAC/D,CAqJA"}

package/build/preference-management/getPreferenceUpdatesFromRow.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPreferenceUpdatesFromRow = void 0;
+const privacy_types_1 = require("@transcend-io/privacy-types");
+const type_utils_1 = require("@transcend-io/type-utils");
+const requests_1 = require("../requests");
+/**
+ * Parse an arbitrary object to the Transcend PUT /v1/preference update shape
+ * by using a mapping of column names to purpose/preference slugs.
+ *
+ * columnToPurposeName looks like:
+ * {
+ *   'my_purpose': 'Marketing',
+ *   'has_topic_1': 'Marketing->BooleanPreference1',
+ *   'has_topic_2': 'Marketing->BooleanPreference2'
+ * }
+ *
+ * row looks like:
+ * {
+ *  'my_purpose': 'true',
+ *  'has_topic_1': 'true',
+ *  'has_topic_2': 'false'
+ * }
+ *
+ * @param options - Options
+ * @returns The parsed row
+ */
+function getPreferenceUpdatesFromRow({ row, columnToPurposeName, purposeSlugs, preferenceTopics, }) {
+    // Create a result object to store the parsed preferences
+    const result = {};
+    // Iterate over each column and map to the purpose or preference
+    Object.entries(columnToPurposeName).forEach(([columnName, { purpose, preference, valueMapping }]) => {
+        // Ensure the purpose is valid
+        if (!purposeSlugs.includes(purpose)) {
+            throw new Error(`Invalid purpose slug: ${purpose}, expected: ${purposeSlugs.join(', ')}`);
+        }
+        // CHeck if parsing a preference or just the top level purpose
+        if (preference) {
+            const preferenceTopic = preferenceTopics.find((x) => x.slug === preference && x.purpose.trackingType === purpose);
+            if (!preferenceTopic) {
+                const allowedTopics = preferenceTopics
+                    .filter((x) => x.purpose.trackingType === purpose)
+                    .map((x) => x.slug);
+                throw new Error(`Invalid preference slug: ${preference} for purpose: ${purpose}. ` +
+                    `Allowed preference slugs for purpose are: ${allowedTopics.join(',')}`);
+            }
+            // If parsing preferences, default to an empty array
+            if (!result[purpose]) {
+                result[purpose] = {
+                    preferences: [],
+                };
+            }
+            if (!result[purpose].preferences) {
+                result[purpose].preferences = [];
+            }
+            // The value to parse
+            const rawValue = row[columnName];
+            const rawMapping = valueMapping[rawValue];
+            const trimmedMapping = typeof rawMapping === 'string' ? rawMapping.trim() || null : null;
+            // handle each type of preference
+            switch (preferenceTopic.type) {
+                case privacy_types_1.PreferenceTopicType.Boolean:
+                    if (typeof rawMapping !== 'boolean') {
+                        throw new Error(`Invalid value for boolean preference: ${preference}, expected boolean, got: ${rawValue}`);
+                    }
+                    result[purpose].preferences.push({
+                        topic: preference,
+                        choice: {
+                            booleanValue: rawMapping,
+                        },
+                    });
+                    break;
+                case privacy_types_1.PreferenceTopicType.Select:
+                    if (typeof rawMapping !== 'string' && rawMapping !== null) {
+                        throw new Error(`Invalid value for select preference: ${preference}, expected string or null, got: ${rawValue}`);
+                    }
+                    if (trimmedMapping &&
+                        !preferenceTopic.preferenceOptionValues
+                            .map(({ slug }) => slug)
+                            .includes(trimmedMapping)) {
+                        throw new Error(`Invalid value for select preference: ${preference}, expected one of: ` +
+                            `${preferenceTopic.preferenceOptionValues
+                                .map(({ slug }) => slug)
+                                .join(', ')}, got: ${rawValue}`);
+                    }
+                    // Update preferences
+                    result[purpose].preferences.push({
+                        topic: preference,
+                        choice: {
+                            selectValue: trimmedMapping,
+                        },
+                    });
+                    break;
+                case privacy_types_1.PreferenceTopicType.MultiSelect:
+                    if (typeof rawValue !== 'string') {
+                        throw new Error(`Invalid value for multi select preference: ${preference}, expected string, got: ${rawValue}`);
+                    }
+                    // Update preferences
+                    result[purpose].preferences.push({
+                        topic: preference,
+                        choice: {
+                            selectValues: (0, requests_1.splitCsvToList)(rawValue)
+                                .map((val) => {
+                                const result = valueMapping[val];
+                                if (typeof result !== 'string') {
+                                    throw new Error(`Invalid value for multi select preference: ${preference}, ` +
+                                        `expected one of: ${preferenceTopic.preferenceOptionValues
+                                            .map(({ slug }) => slug)
+                                            .join(', ')}, got: ${val}`);
+                                }
+                                return result;
+                            })
+                                .sort((a, b) => a.localeCompare(b)),
+                        },
+                    });
+                    break;
+                default:
+                    throw new Error(`Unknown preference type: ${preferenceTopic.type}`);
+            }
+        }
+        else if (!result[purpose]) {
+            // Handle updating top level purpose for the first time
+            result[purpose] = {
+                enabled: valueMapping[row[columnName]] === true,
+            };
+        }
+        else {
+            // Handle updating top level purpose but preserve preference updates
+            result[purpose].enabled = valueMapping[row[columnName]] === true;
+        }
+    });
+    // Ensure that enabled is provided
+    return (0, type_utils_1.apply)(result, (x, purposeName) => {
+        if (typeof x.enabled !== 'boolean') {
+            throw new Error(`No mapping provided for purpose.enabled=true/false value: ${purposeName}`);
+        }
+        return {
+            ...x,
+            enabled: x.enabled,
+        };
+    });
+}
+exports.getPreferenceUpdatesFromRow = getPreferenceUpdatesFromRow;
+//# sourceMappingURL=getPreferenceUpdatesFromRow.js.map