lucid-extension-sdk 0.0.296 → 0.0.297

package/core/data/datasource/semanticrelationships.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Semantic Relationships serve as standardized categories of relationships which exist in multiple data sources but potentially under different names.
+ * For instance, regardless of the data source, relationships that pertains to parent/child structures can be categorized under the Semantic Relationship "IsParentOf" and "IsChildOf".
+ *
+ * Benefits of Semantic Relationships:
+ * Uniformity: Ensures that data from diverse sources is referenced consistently within Lucid.
+ * Integration Simplicity: Simplifies the process of integrating new data sources into Lucid by mapping to an established set of Semantic Relationships.
+ * Feature Compatibility: Allows for seamless use of Lucid’s intelligent features across all data, regardless of its origin.
+ * Data Organization: Provides a structured approach to organizing and grouping data within the Lucid ecosystem.
+ */
+export declare enum SemanticRelationships {
+    RelatesTo = "RelatesTo",
+    Duplicates = "Duplicates",
+    IsDuplicatedBy = "IsDuplicatedBy",
+    Blocks = "Blocks",
+    IsBlockedBy = "IsBlockedBy",
+    Clones = "Clones",
+    IsClonedBy = "IsClonedBy",
+    IsParentOf = "IsParentOf",
+    IsChildOf = "IsChildOf"
+}
+export declare function getInverseSemanticRelationship(relationship: SemanticRelationships): SemanticRelationships;
+export declare const isSemanticRelationship: (x: unknown) => x is SemanticRelationships;

package/core/data/datasource/semanticrelationships.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSemanticRelationship = exports.getInverseSemanticRelationship = exports.SemanticRelationships = void 0;
+const validators_1 = require("../../validators/validators");
+/**
+ * Semantic Relationships serve as standardized categories of relationships which exist in multiple data sources but potentially under different names.
+ * For instance, regardless of the data source, relationships that pertains to parent/child structures can be categorized under the Semantic Relationship "IsParentOf" and "IsChildOf".
+ *
+ * Benefits of Semantic Relationships:
+ * Uniformity: Ensures that data from diverse sources is referenced consistently within Lucid.
+ * Integration Simplicity: Simplifies the process of integrating new data sources into Lucid by mapping to an established set of Semantic Relationships.
+ * Feature Compatibility: Allows for seamless use of Lucid’s intelligent features across all data, regardless of its origin.
+ * Data Organization: Provides a structured approach to organizing and grouping data within the Lucid ecosystem.
+ */
+var SemanticRelationships;
+(function (SemanticRelationships) {
+    SemanticRelationships["RelatesTo"] = "RelatesTo";
+    SemanticRelationships["Duplicates"] = "Duplicates";
+    SemanticRelationships["IsDuplicatedBy"] = "IsDuplicatedBy";
+    SemanticRelationships["Blocks"] = "Blocks";
+    SemanticRelationships["IsBlockedBy"] = "IsBlockedBy";
+    SemanticRelationships["Clones"] = "Clones";
+    SemanticRelationships["IsClonedBy"] = "IsClonedBy";
+    SemanticRelationships["IsParentOf"] = "IsParentOf";
+    SemanticRelationships["IsChildOf"] = "IsChildOf";
+})(SemanticRelationships || (exports.SemanticRelationships = SemanticRelationships = {}));
+function getInverseSemanticRelationship(relationship) {
+    switch (relationship) {
+        case SemanticRelationships.Duplicates:
+            return SemanticRelationships.IsDuplicatedBy;
+        case SemanticRelationships.IsDuplicatedBy:
+            return SemanticRelationships.Duplicates;
+        case SemanticRelationships.Blocks:
+            return SemanticRelationships.IsBlockedBy;
+        case SemanticRelationships.IsBlockedBy:
+            return SemanticRelationships.Blocks;
+        case SemanticRelationships.Clones:
+            return SemanticRelationships.IsClonedBy;
+        case SemanticRelationships.IsClonedBy:
+            return SemanticRelationships.Clones;
+        case SemanticRelationships.IsParentOf:
+            return SemanticRelationships.IsChildOf;
+        case SemanticRelationships.IsChildOf:
+            return SemanticRelationships.IsParentOf;
+        default:
+            return relationship;
+    }
+}
+exports.getInverseSemanticRelationship = getInverseSemanticRelationship;
+exports.isSemanticRelationship = (0, validators_1.stringEnumValidator)(SemanticRelationships);

package/core/data/datasource/serializeddatasourceproperties.d.ts

@@ -1,22 +1,6 @@
 import { isString } from '../../checks';
+import { SerializedSourceForeignKey } from './serializedsourceforeignkey';
 import { SerializedUpstreamConfig } from './serializedupstreamconfig';
-export declare enum Direction {
-    Inward = "inward",
-    Outward = "outward"
-}
-export type DirectionType = Direction | null | undefined;
-export type SerializedSourceForeignKey = {
-    'Id': string;
-    'SourceFields': string[];
-    'RelationshipType': string;
-    'Represents'?: string | null | undefined;
-    'Direction'?: DirectionType;
-};
-export declare const isSerializedSourceForeignKey: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
-    Id: typeof isString;
-    SourceFields: (p1: unknown) => p1 is string[];
-    RelationshipType: typeof isString;
-}>;
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export interface SerializedDataSourceProperties {
     'Name': string;

package/core/data/datasource/serializeddatasourceproperties.js

@@ -1,22 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSerializedDataSourceProperties = exports.isSerializedSourceForeignKey = exports.Direction = void 0;
+exports.isSerializedDataSourceProperties = void 0;
 const checks_1 = require("../../checks");
 const validators_1 = require("../../validators/validators");
+const serializedsourceforeignkey_1 = require("./serializedsourceforeignkey");
 const serializedupstreamconfig_1 = require("./serializedupstreamconfig");
-var Direction;
-(function (Direction) {
-    Direction["Inward"] = "inward";
-    Direction["Outward"] = "outward";
-})(Direction || (exports.Direction = Direction = {}));
-exports.isSerializedSourceForeignKey = (0, validators_1.objectValidator)({
-    'Id': checks_1.isString,
-    'SourceFields': (0, validators_1.arrayValidator)(checks_1.isString),
-    'RelationshipType': checks_1.isString,
-});
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 exports.isSerializedDataSourceProperties = (0, validators_1.strictObjectValidator)({
     'Name': checks_1.isString,
     'UpstreamConfig': (0, validators_1.nullableOption)(serializedupstreamconfig_1.isSerializedUpstreamConfig),
-    'SourceForeignKeys': (0, validators_1.nullableOption)((0, validators_1.arrayValidator)(exports.isSerializedSourceForeignKey)),
+    'SourceForeignKeys': (0, validators_1.nullableOption)((0, validators_1.arrayValidator)(serializedsourceforeignkey_1.isSerializedSourceForeignKey)),
 });

package/core/data/datasource/serializedimporteddatasource.d.ts

@@ -56,7 +56,6 @@ export declare const isSerializedImportedDataSource: (subject: unknown) => subje
             SourceConfig: typeof isObject;
         }> | null | undefined;
         SourceForeignKeys: (x: unknown) => x is import("../../guards").DestructureGuardedTypeObj<{
-            /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
             Id: typeof isString;
             SourceFields: (p1: unknown) => p1 is string[];
             RelationshipType: typeof isString;
@@ -93,7 +92,6 @@ export declare const isSerializedPreviewData: (subject: unknown) => subject is i
             SourceConfig: typeof isObject;
         }> | null | undefined;
         SourceForeignKeys: (x: unknown) => x is import("../../guards").DestructureGuardedTypeObj<{
-            /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
             Id: typeof isString;
             SourceFields: (p1: unknown) => p1 is string[];
             RelationshipType: typeof isString;

package/core/data/datasource/serializedsourceforeignkey.d.ts

@@ -0,0 +1,19 @@
+import { isString } from '../../checks';
+import { SemanticRelationships } from './semanticrelationships';
+export declare enum Direction {
+    Inward = "inward",
+    Outward = "outward"
+}
+export type DirectionType = Direction | null | undefined;
+export type SerializedSourceForeignKey = {
+    'Id': string;
+    'SourceFields': string[];
+    'RelationshipType': SemanticRelationships | string;
+    'Represents'?: string | null | undefined;
+    'Direction'?: DirectionType;
+};
+export declare const isSerializedSourceForeignKey: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
+    Id: typeof isString;
+    SourceFields: (p1: unknown) => p1 is string[];
+    RelationshipType: typeof isString;
+}>;

package/core/data/datasource/serializedsourceforeignkey.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedSourceForeignKey = exports.Direction = void 0;
+const checks_1 = require("../../checks");
+const validators_1 = require("../../validators/validators");
+var Direction;
+(function (Direction) {
+    Direction["Inward"] = "inward";
+    Direction["Outward"] = "outward";
+})(Direction || (exports.Direction = Direction = {}));
+exports.isSerializedSourceForeignKey = (0, validators_1.objectValidator)({
+    'Id': checks_1.isString,
+    'SourceFields': (0, validators_1.arrayValidator)(checks_1.isString),
+    'RelationshipType': checks_1.isString,
+});

package/core/data/datasource/sourceforeignkeys.d.ts

@@ -0,0 +1,11 @@
+import { SemanticRelationships } from './semanticrelationships';
+import { DirectionType, SerializedSourceForeignKey } from './serializedsourceforeignkey';
+export type SourceForeignKey = {
+    'id': string;
+    'sourceFields': string[];
+    'relationshipType': SemanticRelationships | string;
+    'represents'?: string | undefined;
+    'direction'?: DirectionType;
+};
+export declare function serializeSourceForeignKey(foreignKey: SourceForeignKey): SerializedSourceForeignKey;
+export declare function deserializeSourceForeignKey(foreignKey: SerializedSourceForeignKey): SourceForeignKey;

package/core/data/datasource/sourceforeignkeys.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeSourceForeignKey = exports.serializeSourceForeignKey = void 0;
+function serializeSourceForeignKey(foreignKey) {
+    return {
+        'Id': foreignKey.id,
+        'SourceFields': foreignKey.sourceFields,
+        'RelationshipType': foreignKey.relationshipType,
+        'Represents': foreignKey.represents,
+        'Direction': foreignKey.direction,
+    };
+}
+exports.serializeSourceForeignKey = serializeSourceForeignKey;
+function deserializeSourceForeignKey(foreignKey) {
+    return {
+        'id': foreignKey['Id'],
+        'sourceFields': foreignKey['SourceFields'],
+        'relationshipType': foreignKey['RelationshipType'],
+        'represents': foreignKey['Represents'] === null ? undefined : foreignKey['Represents'],
+        'direction': foreignKey['Direction'],
+    };
+}
+exports.deserializeSourceForeignKey = deserializeSourceForeignKey;

package/dataconnector/actions/patchresponsebody.d.ts

@@ -1,7 +1,9 @@
-import { ItemsPatch, SerializedItemsPatch } from '../datasourceupdatetypes';
+import { SchemaDefinition } from '../../data/schemadefinition';
+import { ItemsPatch, SerializedItemsPatch, SerializedSchemaForApi } from '../datasourceupdatetypes';
 export type PatchChangeCollection = {
     collectionId: string;
     itemsPatch: ItemsPatch;
+    schema?: SchemaDefinition;
 };
 /**
  * Reports a completed change back to Lucid
@@ -27,6 +29,7 @@ export type SerializedPatchChange = {
     'collections': {
         'collectionId': string;
         'itemsPatch': SerializedItemsPatch;
+        'schema'?: SerializedSchemaForApi;
     }[];
 };
 /** Wire format for "Patch" Action responses */

package/dataconnector/actions/patchresponsebody.js

@@ -34,10 +34,7 @@ function serializePatchResponse(patchChange) {
     return {
         'syncId': patchChange.syncId,
         'collections': patchChange.collections.map((c) => {
-            return {
-                'collectionId': c.collectionId,
-                'itemsPatch': (0, datasourceupdatetypes_1.serializeItemsPatch)(c.itemsPatch),
-            };
+            return Object.assign({ 'collectionId': c.collectionId, 'itemsPatch': (0, datasourceupdatetypes_1.serializeItemsPatch)(c.itemsPatch) }, (c.schema != null ? { 'schema': (0, datasourceupdatetypes_1.serializeSchemaForApi)(c.schema) } : undefined));
         }),
     };
 }

package/dataconnector/dataconnector.d.ts

@@ -4,7 +4,7 @@ import { ItemPatch, Patch, PatchParser } from './actions/patch';
 import { PatchChange } from './actions/patchresponsebody';
 import { DataConnectorClient } from './dataconnectorclient';
 import { ExpressAppLike, RunDebugServerOptions } from './debugserver';
-import { ItemRekeyer } from './itemrekeyer';
+import { ItemRekeyerAndRelabeler } from './itemrekeyerandrelabeler';
 /** Type to define an action request handler. That is a function that can fulfil an incoming action */
 type ActionRequest<ArgType, BodyType = unknown> = (args: ArgType, dataConnectorRequestState: DataConnectorRequestState) => Promise<BodyType>;
 /** Type to define an arbitrary non-action request to this server. Useful for handling webhook responses in the same
@@ -35,8 +35,8 @@ export declare class DataConnectorRequestError extends Error {
     toString(): string;
 }
 export declare class DataConnectorRequestState {
-    itemRekeyer: ItemRekeyer;
-    constructor(itemRekeyer: ItemRekeyer);
+    itemRekeyer: ItemRekeyerAndRelabeler;
+    constructor(itemRekeyer: ItemRekeyerAndRelabeler);
 }
 /** Thrown by any APIs the client didn't recognize when parsing */
 export declare class DataConnectorResponseError extends Error {

package/dataconnector/dataconnector.js

@@ -9,7 +9,7 @@ const managewebhookresponsebody_1 = require("./actions/managewebhookresponsebody
 const patch_1 = require("./actions/patch");
 const patchresponsebody_1 = require("./actions/patchresponsebody");
 const debugserver_1 = require("./debugserver");
-const itemrekeyer_1 = require("./itemrekeyer");
+const itemrekeyerandrelabeler_1 = require("./itemrekeyerandrelabeler");
 /** Throw this from an action request handler to produce a non-200 response code and not have to return the expected
  * result type */
 class DataConnectorRunError extends Error {
@@ -74,7 +74,7 @@ class DataConnector {
     }
     /** Call a defined action handler and gather its serialized response */
     async runAction(url, headers, body) {
-        const state = new DataConnectorRequestState(new itemrekeyer_1.ItemRekeyer());
+        const state = new DataConnectorRequestState(new itemrekeyerandrelabeler_1.ItemRekeyerAndRelabeler());
         const actions = await this.client.parseActions(url, headers, body, this.patchParser);
         if (!actions) {
             console.warn('Received bad request', url, headers, body);

package/dataconnector/datasourceclient.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockDataSourceClient = exports.DataSourceClient = void 0;
 const checks_1 = require("../core/checks");
 const datasourcetype_1 = require("../core/data/datasource/datasourcetype");
+const sourceforeignkeys_1 = require("../core/data/datasource/sourceforeignkeys");
 const upstreamconfig_1 = require("../core/data/datasource/upstreamconfig");
 const upstreamupdatetype_1 = require("../core/data/datasource/upstreamupdatetype");
 const result_1 = require("../core/result");
@@ -24,7 +25,7 @@ class DataSourceClient {
         const dataSyncUrl = urls.dataSync;
         this.metadataUrl = (0, checks_1.isString)(dataSyncUrl) ? `${dataSyncUrl}dataSource/metadata` : undefined;
     }
-    formatBody({ dataSourceName, collections, updateFilterType, dataSourceConfiguration }) {
+    formatBody({ dataSourceName, collections, updateFilterType, dataSourceConfiguration, sourceForeignKeys, }) {
         const updateData = {};
         for (const collectionId in collections) {
             updateData[collectionId] = (0, datasourceupdatetypes_1.serializeCollectionPatch)(collections[collectionId]);
@@ -36,10 +37,12 @@ class DataSourceClient {
             patchType: dataSourceConfiguration === null || dataSourceConfiguration === void 0 ? void 0 : dataSourceConfiguration.patchType,
             sourceConfig: Object.assign({}, updateFilterTypeObj),
         };
+        const foreignKeys = sourceForeignKeys ? sourceForeignKeys.map(sourceforeignkeys_1.serializeSourceForeignKey) : [];
         return {
             'updateData': updateData,
             'name': dataSourceName,
             'upstreamConfig': (0, upstreamconfig_1.serializeUpstreamConfig)(upstreamConfig),
+            'sourceForeignKeys': foreignKeys,
         };
     }
     /** Create or update a datasource. If you create a new collection it must be fully specified in terms of schema and

package/dataconnector/datasourceupdatetypes.d.ts

@@ -1,4 +1,5 @@
 import { SemanticCollection } from '../core/data/datasource/semanticcollection';
+import { SourceForeignKey } from '../core/data/datasource/sourceforeignkeys';
 import { UpstreamPatchType } from '../core/data/datasource/upstreampatchtype';
 import { SerializedFieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
 import { SemanticFields } from '../core/data/fieldtypedefinition/semanticfields';
@@ -24,6 +25,8 @@ export type DataSourceRequest = {
         /** Configures how changes made to the data are pushed to the external source */
         patchType: UpstreamPatchType;
     };
+    /** Configuration for relationships between collections in the data source */
+    sourceForeignKeys?: SourceForeignKey[];
 };
 type SerializedFieldConstraintForApi = {
     'type': FieldConstraintType;
@@ -36,7 +39,7 @@ type SerializedFieldDefinitionForApi = {
     'syncSchema'?: string;
     'mapping'?: readonly SemanticKind[] | readonly SemanticFields[];
 };
-type SerializedSchemaForApi = {
+export type SerializedSchemaForApi = {
     'fields': SerializedFieldDefinitionForApi[];
     'primaryKey': string[];
     'fieldLabelOverrides'?: SerializedLabelOverrides | undefined;
@@ -124,6 +127,7 @@ export interface CollectionPatch {
 }
 /** @ignore */
 export declare function serializeFieldDefinitionForApi(field: FieldDefinition): SerializedFieldDefinitionForApi;
+export declare function serializeSchemaForApi(schema: SchemaDefinition): SerializedSchemaForApi;
 export declare function serializeCollectionPatch(patch: CollectionPatch): SerializedCollectionPatch;
 /**
  * For the moment, when the upstream Google Sheet is changed in such a way that the schema has changed, we simply

package/dataconnector/datasourceupdatetypes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaOKStatus = exports.schemaOutOfSyncStatus = exports.serializeCollectionPatch = exports.serializeFieldDefinitionForApi = exports.serializeItemsPatch = exports.ItemsPatchExhaustive = exports.ItemsPatchInexhaustive = void 0;
+exports.schemaOKStatus = exports.schemaOutOfSyncStatus = exports.serializeCollectionPatch = exports.serializeSchemaForApi = exports.serializeFieldDefinitionForApi = exports.serializeItemsPatch = exports.ItemsPatchExhaustive = exports.ItemsPatchInexhaustive = void 0;
 const checks_1 = require("../core/checks");
 const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
 const object_1 = require("../core/object");
@@ -74,6 +74,7 @@ function serializeSchemaForApi(schema) {
         'fieldLabelOverrides': schema.fieldLabels,
     };
 }
+exports.serializeSchemaForApi = serializeSchemaForApi;
 function serializeRepresentsAsPropertyForApi(represents) {
     return {
         'Represents': represents, // key needs to match 'Represents' key in cake/app/webroot/ts/property/collection/collectionproperties.ts

package/dataconnector/itemrekeyerandrelabeler.d.ts

@@ -0,0 +1,20 @@
+import { FormattedPrimaryKey } from '../core/data/fieldspecification';
+import { Patch } from './actions/patch';
+import { ItemsPatch } from './datasourceupdatetypes';
+export declare class RekeyingRelabelingMap {
+    readonly keyMap: Map<string, string | null>;
+    readonly labelMap: Map<string, string | null>;
+    constructor(keyMap: Map<string, string | null>, labelMap: Map<string, string | null>);
+    private getNewKey;
+    private getNewLabel;
+    private getRelabeledItem;
+    private getRecordWithNewKeysAndLabels;
+    private getRelabeledThirdPartyColumn;
+    private getRelabeledThirdPartyColumnPatches;
+    getRekeyedRelabeledPatch(patch: Patch): Patch;
+}
+export declare class ItemRekeyerAndRelabeler {
+    private rekeyingRelabelingMaps;
+    addRekeyingsRelabelingsFor(collectionId: string, itemsPatch: ItemsPatch, primaryKey?: FormattedPrimaryKey<any, string>): void;
+    getRekeyingRelabelingMap(patch: Patch): RekeyingRelabelingMap | undefined;
+}

package/dataconnector/itemrekeyerandrelabeler.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemRekeyerAndRelabeler = exports.RekeyingRelabelingMap = void 0;
+const fieldspecification_1 = require("../core/data/fieldspecification");
+const object_1 = require("../core/object");
+const patch_1 = require("./actions/patch");
+const datasourceupdatetypes_1 = require("./datasourceupdatetypes");
+function calculateRekeyingMap(itemsPatch, primaryKey) {
+    var _a, _b;
+    if (itemsPatch instanceof datasourceupdatetypes_1.ItemsPatchExhaustive) {
+        return itemsPatch.rekeyingMap;
+    }
+    else {
+        if (!primaryKey) {
+            return undefined;
+        }
+        const constPrimaryKey = primaryKey;
+        function primaryKeyIfChanged(oldPrimaryKey, item) {
+            const changedParts = constPrimaryKey.elements.map((field) => item[field]);
+            if (changedParts.find((x) => x !== undefined) === undefined) {
+                // this patch didn't touch the primary key
+                return undefined;
+            }
+            // we might need parts of the old primary key if only some of the primary key fields changed.
+            // As an optimization we could only compute this if at least one of the changedParts is
+            // undefined.
+            const oldParts = JSON.parse(`[${oldPrimaryKey}]`);
+            const newParts = changedParts.map((part, index) => (part !== undefined ? part : oldParts[index]));
+            const newPrimaryKey = fieldspecification_1.FormattedPrimaryKey.serializeList(newParts);
+            if (newPrimaryKey !== oldPrimaryKey) {
+                return newPrimaryKey;
+            }
+            else {
+                return undefined;
+            }
+        }
+        const itemsMap = [...itemsPatch.items.entries()]
+            .map(([key, value]) => [key, primaryKeyIfChanged(key, value)])
+            .filter((x) => x[1] !== undefined);
+        const deletedMap = (_b = (_a = itemsPatch.itemsDeleted) === null || _a === void 0 ? void 0 : _a.map((key) => [key, null])) !== null && _b !== void 0 ? _b : [];
+        const theMap = new Map([...itemsMap, ...deletedMap]);
+        return theMap.size > 0 ? theMap : undefined;
+    }
+}
+function calculateRelabelingMap(itemsPatch) {
+    if (itemsPatch instanceof datasourceupdatetypes_1.ItemsPatchExhaustive) {
+        return itemsPatch.fieldNamesChanged;
+    }
+    else {
+        return undefined;
+    }
+}
+class RekeyingRelabelingMap {
+    constructor(keyMap, labelMap) {
+        this.keyMap = keyMap;
+        this.labelMap = labelMap;
+    }
+    getNewKey(key) {
+        var _a;
+        return (_a = this.keyMap.get(key)) !== null && _a !== void 0 ? _a : key;
+    }
+    getNewLabel(label) {
+        var _a;
+        return (_a = this.labelMap.get(label)) !== null && _a !== void 0 ? _a : label;
+    }
+    getRelabeledItem(item) {
+        const newItem = {};
+        for (const key in item) {
+            newItem[this.getNewLabel(key)] = item[key];
+        }
+        return newItem;
+    }
+    getRecordWithNewKeysAndLabels(items) {
+        return (0, object_1.fromEntries)(Object.entries(items).map(([key, value]) => [this.getNewKey(key), this.getRelabeledItem(value)]));
+    }
+    getRelabeledThirdPartyColumn(thirdPartyColumn) {
+        return new patch_1.ThirdPartyColumn(this.getNewLabel(thirdPartyColumn.name), thirdPartyColumn.fieldType);
+    }
+    getRelabeledThirdPartyColumnPatches(thirdPartyColumnPatch) {
+        const newRecord = {};
+        for (const label in thirdPartyColumnPatch) {
+            newRecord[this.getNewLabel(label)] = thirdPartyColumnPatch[label];
+        }
+        return newRecord;
+    }
+    getRekeyedRelabeledPatch(patch) {
+        var _a, _b;
+        if (patch instanceof patch_1.ItemPatch) {
+            return new patch_1.ItemPatch(patch.id, this.getRecordWithNewKeysAndLabels(patch.itemsAdded), this.getRecordWithNewKeysAndLabels(patch.itemsChanged), patch.itemsDeleted.map((key) => this.getNewKey(key)), (_a = patch.itemOrderChanged) === null || _a === void 0 ? void 0 : _a.map(([a, b]) => [this.getNewKey(a), b && this.getNewKey(b)]), patch.syncSourceId, patch.syncCollectionId);
+        }
+        if (patch instanceof patch_1.SchemaPatch) {
+            return new patch_1.SchemaPatch(patch.id, patch.columnsAdded.map((column) => this.getRelabeledThirdPartyColumn(column)), this.getRelabeledThirdPartyColumnPatches(patch.columnsChanged), patch.columnsDeleted.map((columnName) => this.getNewLabel(columnName)), (_b = patch.columnOrdering) === null || _b === void 0 ? void 0 : _b.map(([movedColumn, anchorColumn]) => [
+                this.getNewLabel(movedColumn),
+                anchorColumn != null ? this.getNewLabel(anchorColumn) : anchorColumn,
+            ]), patch.syncSourceId, patch.syncCollectionId);
+        }
+        return patch.clone();
+    }
+}
+exports.RekeyingRelabelingMap = RekeyingRelabelingMap;
+class ItemRekeyerAndRelabeler {
+    constructor() {
+        this.rekeyingRelabelingMaps = new Map();
+    }
+    addRekeyingsRelabelingsFor(collectionId, itemsPatch, primaryKey) {
+        var _a, _b, _c, _d;
+        const rekeyingMap = calculateRekeyingMap(itemsPatch, primaryKey);
+        const relabelingMap = calculateRelabelingMap(itemsPatch);
+        const existingKeyAndLabelMap = this.rekeyingRelabelingMaps.get(collectionId);
+        const rekeyedExisting = rekeyingMap &&
+            [...((_a = existingKeyAndLabelMap === null || existingKeyAndLabelMap === void 0 ? void 0 : existingKeyAndLabelMap.keyMap.entries()) !== null && _a !== void 0 ? _a : [])].map(([key, value]) => {
+                var _a;
+                return [
+                    key,
+                    value && ((_a = rekeyingMap.get(value)) !== null && _a !== void 0 ? _a : value),
+                ];
+            });
+        const relabeledExisting = relabelingMap &&
+            [...((_b = existingKeyAndLabelMap === null || existingKeyAndLabelMap === void 0 ? void 0 : existingKeyAndLabelMap.labelMap.entries()) !== null && _b !== void 0 ? _b : [])].map(([key, value]) => {
+                var _a;
+                return [
+                    key,
+                    value && ((_a = relabelingMap.get(value)) !== null && _a !== void 0 ? _a : value),
+                ];
+            });
+        this.rekeyingRelabelingMaps.set(collectionId, new RekeyingRelabelingMap(new Map([...((_c = rekeyingMap === null || rekeyingMap === void 0 ? void 0 : rekeyingMap.entries()) !== null && _c !== void 0 ? _c : []), ...(rekeyedExisting !== null && rekeyedExisting !== void 0 ? rekeyedExisting : [])]), new Map([...((_d = relabelingMap === null || relabelingMap === void 0 ? void 0 : relabelingMap.entries()) !== null && _d !== void 0 ? _d : []), ...(relabeledExisting !== null && relabeledExisting !== void 0 ? relabeledExisting : [])])));
+    }
+    getRekeyingRelabelingMap(patch) {
+        return this.rekeyingRelabelingMaps.get(patch.syncCollectionId);
+    }
+}
+exports.ItemRekeyerAndRelabeler = ItemRekeyerAndRelabeler;

package/index.d.ts

@@ -11,6 +11,7 @@ export * from './core/data/datasource/datasourceutils';
 export * from './core/data/datasource/metadatatypes';
 export * from './core/data/datasource/serializeddatasourceproperties';
 export * from './core/data/datasource/serializedimporteddatasource';
+export * from './core/data/datasource/serializedsourceforeignkey';
 export * from './core/data/datasource/serializedupstreamconfig';
 export * from './core/data/datasource/upstreamconfig';
 export * from './core/data/datasource/upstreampatchtype';

package/index.js

@@ -27,6 +27,7 @@ __exportStar(require("./core/data/datasource/datasourceutils"), exports);
 __exportStar(require("./core/data/datasource/metadatatypes"), exports);
 __exportStar(require("./core/data/datasource/serializeddatasourceproperties"), exports);
 __exportStar(require("./core/data/datasource/serializedimporteddatasource"), exports);
+__exportStar(require("./core/data/datasource/serializedsourceforeignkey"), exports);
 __exportStar(require("./core/data/datasource/serializedupstreamconfig"), exports);
 __exportStar(require("./core/data/datasource/upstreamconfig"), exports);
 __exportStar(require("./core/data/datasource/upstreampatchtype"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.296",
+    "version": "0.0.297",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "index.js",
     "types": "index.d.ts",

package/dataconnector/itemrekeyer.d.ts

@@ -1,16 +0,0 @@
-import { FormattedPrimaryKey } from '../core/data/fieldspecification';
-import { PatchItems } from './actions/action';
-import { Patch } from './actions/patch';
-import { ItemsPatch } from './datasourceupdatetypes';
-export declare class RekeyingMap {
-    map: Map<string, string | null>;
-    constructor(map: Map<string, string | null>);
-    getNewKey(key: string): string;
-    getRecordWithNewKeys(items: PatchItems): PatchItems;
-    getRekeyedPatch(patch: Patch): Patch;
-}
-export declare class ItemRekeyer {
-    private rekeyingMaps;
-    addRekeyingsFor(collectionId: string, itemsPatch: ItemsPatch, primaryKey?: FormattedPrimaryKey<any, string>): void;
-    getRekeyingMap(patch: Patch): RekeyingMap | undefined;
-}

package/dataconnector/itemrekeyer.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ItemRekeyer = exports.RekeyingMap = void 0;
-const fieldspecification_1 = require("../core/data/fieldspecification");
-const object_1 = require("../core/object");
-const patch_1 = require("./actions/patch");
-const datasourceupdatetypes_1 = require("./datasourceupdatetypes");
-function calculateRekeyingMap(itemsPatch, primaryKey) {
-    var _a, _b;
-    if (itemsPatch instanceof datasourceupdatetypes_1.ItemsPatchExhaustive) {
-        return itemsPatch.rekeyingMap;
-    }
-    else {
-        if (!primaryKey) {
-            return undefined;
-        }
-        const constPrimaryKey = primaryKey;
-        function primaryKeyIfChanged(oldPrimaryKey, item) {
-            const changedParts = constPrimaryKey.elements.map((field) => item[field]);
-            if (changedParts.find((x) => x !== undefined) === undefined) {
-                // this patch didn't touch the primary key
-                return undefined;
-            }
-            // we might need parts of the old primary key if only some of the primary key fields changed.
-            // As an optimization we could only compute this if at least one of the changedParts is
-            // undefined.
-            const oldParts = JSON.parse(`[${oldPrimaryKey}]`);
-            const newParts = changedParts.map((part, index) => (part !== undefined ? part : oldParts[index]));
-            const newPrimaryKey = fieldspecification_1.FormattedPrimaryKey.serializeList(newParts);
-            if (newPrimaryKey !== oldPrimaryKey) {
-                return newPrimaryKey;
-            }
-            else {
-                return undefined;
-            }
-        }
-        const itemsMap = [...itemsPatch.items.entries()]
-            .map(([key, value]) => [key, primaryKeyIfChanged(key, value)])
-            .filter((x) => x[1] !== undefined);
-        const deletedMap = (_b = (_a = itemsPatch.itemsDeleted) === null || _a === void 0 ? void 0 : _a.map((key) => [key, null])) !== null && _b !== void 0 ? _b : [];
-        const theMap = new Map([...itemsMap, ...deletedMap]);
-        return theMap.size > 0 ? theMap : undefined;
-    }
-}
-class RekeyingMap {
-    constructor(map) {
-        this.map = map;
-    }
-    getNewKey(key) {
-        var _a;
-        return (_a = this.map.get(key)) !== null && _a !== void 0 ? _a : key;
-    }
-    getRecordWithNewKeys(items) {
-        return (0, object_1.fromEntries)(Object.entries(items).map(([key, value]) => [this.getNewKey(key), value]));
-    }
-    getRekeyedPatch(patch) {
-        var _a;
-        if (patch instanceof patch_1.ItemPatch) {
-            return new patch_1.ItemPatch(patch.id, this.getRecordWithNewKeys(patch.itemsAdded), this.getRecordWithNewKeys(patch.itemsChanged), patch.itemsDeleted.map((key) => this.getNewKey(key)), (_a = patch.itemOrderChanged) === null || _a === void 0 ? void 0 : _a.map(([a, b]) => [this.getNewKey(a), b && this.getNewKey(b)]), patch.syncSourceId, patch.syncCollectionId);
-        }
-        return patch.clone();
-    }
-}
-exports.RekeyingMap = RekeyingMap;
-class ItemRekeyer {
-    constructor() {
-        this.rekeyingMaps = new Map();
-    }
-    addRekeyingsFor(collectionId, itemsPatch, primaryKey) {
-        var _a;
-        const rekeyingMap = calculateRekeyingMap(itemsPatch, primaryKey);
-        if (rekeyingMap) {
-            const existingMap = this.rekeyingMaps.get(collectionId);
-            const rekeyedExisting = [...((_a = existingMap === null || existingMap === void 0 ? void 0 : existingMap.map.entries()) !== null && _a !== void 0 ? _a : [])].map(([key, value]) => { var _a; return [key, value && ((_a = rekeyingMap.get(value)) !== null && _a !== void 0 ? _a : value)]; });
-            this.rekeyingMaps.set(collectionId, new RekeyingMap(new Map([...rekeyingMap.entries(), ...rekeyedExisting])));
-        }
-    }
-    getRekeyingMap(patch) {
-        return this.rekeyingMaps.get(patch.syncCollectionId);
-    }
-}
-exports.ItemRekeyer = ItemRekeyer;