lucid-extension-sdk 0.0.278 → 0.0.283

package/dataconnector/actions/action.d.ts

@@ -1,6 +1,6 @@
 import { DataUpdateFilterType } from '../../data/dataupdatefiltertype';
 import { DataSourceClient } from '../datasourceclient';
-import { PatchChange, PatchChangeCollection } from './patchresponsebody';
+import { ItemPatch, Patch } from './patch';
 export type CollectionId = string;
 export type ItemPrimaryKey = string;
 /**
@@ -68,49 +68,15 @@ export type PatchItems = {
         [fieldName: string]: unknown;
     };
 };
-/** A patch to be applied against the 3rd party datasource with changes coming from Lucid */
-export declare class Patch {
-    /** The id of the patch */
-    id: string;
-    /** Mapping of item primary keys to new items introduced by Lucid */
-    itemsAdded: PatchItems;
-    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
-    itemsChanged: PatchItems;
-    /** List of item primary keys deleted by Lucid */
-    itemsDeleted: string[];
-    /** */
-    itemOrderChanged: [string, string | null][] | undefined;
-    /** The syncSourceId of the changed data source */
-    syncSourceId: string;
-    /** The syncCollectionId of the changed collection */
-    syncCollectionId: CollectionId;
-    constructor(
-    /** The id of the patch */
-    id: string, 
-    /** Mapping of item primary keys to new items introduced by Lucid */
-    itemsAdded: PatchItems, 
-    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
-    itemsChanged: PatchItems, 
-    /** List of item primary keys deleted by Lucid */
-    itemsDeleted: string[], 
-    /** */
-    itemOrderChanged: [string, string | null][] | undefined, 
-    /** The syncSourceId of the changed data source */
-    syncSourceId: string, 
-    /** The syncCollectionId of the changed collection */
-    syncCollectionId: CollectionId);
-    getChange(collections?: PatchChangeCollection[]): PatchChange;
-    toJSON(): object;
-}
 /**
  * A patch action is a kind of synchronous style action. It occurs when data is changed in the Lucid editor. All the
  * changes are collected in the patches field.
  **/
-export declare class DataConnectorPatchAction extends DataConnectorAction {
-    /** changes applied by Lucid */ patches: Patch[];
+export declare class DataConnectorPatchAction<P extends Patch = ItemPatch> extends DataConnectorAction {
+    /** changes applied by Lucid */ patches: P[];
     client: DataSourceClient;
     constructor(context: DataConnectorActionContext, 
-    /** changes applied by Lucid */ patches: Patch[], client: DataSourceClient, name?: string);
+    /** changes applied by Lucid */ patches: P[], client: DataSourceClient, name?: string);
 }
 /**
  * A description of an existing webhook that Lucid is keeping track of.

package/dataconnector/actions/action.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataConnectorManageWebhookAction = exports.Webhook = exports.DataConnectorPatchAction = exports.Patch = exports.DataConnectorSynchronousAction = exports.DataConnectorAsynchronousAction = exports.DataConnectorAction = exports.DataConnectorActionContext = void 0;
+exports.DataConnectorManageWebhookAction = exports.Webhook = exports.DataConnectorPatchAction = exports.DataConnectorSynchronousAction = exports.DataConnectorAsynchronousAction = exports.DataConnectorAction = exports.DataConnectorActionContext = void 0;
 const dataconnectoractionkeys_1 = require("./dataconnectoractionkeys");
-const patchresponsebody_1 = require("./patchresponsebody");
 /**
  * This holds all the contextual information about a give data action.
  */
@@ -62,47 +61,6 @@ class DataConnectorSynchronousAction extends DataConnectorAction {
     }
 }
 exports.DataConnectorSynchronousAction = DataConnectorSynchronousAction;
-/** A patch to be applied against the 3rd party datasource with changes coming from Lucid */
-class Patch {
-    constructor(
-    /** The id of the patch */
-    id, 
-    /** Mapping of item primary keys to new items introduced by Lucid */
-    itemsAdded, 
-    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
-    itemsChanged, 
-    /** List of item primary keys deleted by Lucid */
-    itemsDeleted, 
-    /** */
-    itemOrderChanged, 
-    /** The syncSourceId of the changed data source */
-    syncSourceId, 
-    /** The syncCollectionId of the changed collection */
-    syncCollectionId) {
-        this.id = id;
-        this.itemsAdded = itemsAdded;
-        this.itemsChanged = itemsChanged;
-        this.itemsDeleted = itemsDeleted;
-        this.itemOrderChanged = itemOrderChanged;
-        this.syncSourceId = syncSourceId;
-        this.syncCollectionId = syncCollectionId;
-    }
-    getChange(collections = []) {
-        return new patchresponsebody_1.PatchChange(this.id, this.syncSourceId, collections);
-    }
-    toJSON() {
-        return {
-            'Id': this.id,
-            'ItemsAdded': this.itemsAdded,
-            'ItemsChanged': this.itemsChanged,
-            'ItemsDeleted': this.itemsDeleted,
-            'ItemOrderChanged': this.itemOrderChanged,
-            'SyncSourceId': this.syncSourceId,
-            'SyncCollectionId': this.syncCollectionId,
-        };
-    }
-}
-exports.Patch = Patch;
 /**
  * A patch action is a kind of synchronous style action. It occurs when data is changed in the Lucid editor. All the
  * changes are collected in the patches field.

package/dataconnector/actions/patch.d.ts

@@ -0,0 +1,101 @@
+import { FieldTypeDefinition } from '../../core/data/fieldtypedefinition/fieldtypedefinition';
+import { CollectionId, PatchItems } from './action';
+import { PatchChange, PatchChangeCollection } from './patchresponsebody';
+import { SerializedThirdPartyColumn, SerializedThirdPartyColumnPatch } from './serializedpatchtypes';
+export type PatchParser<P extends Patch> = (id: string, x: unknown) => P | undefined;
+/** A patch to be applied against the 3rd party datasource with changes coming from Lucid */
+export declare abstract class Patch {
+    /** The id of the patch */
+    id: string;
+    /** The syncSourceId of the changed data source */
+    syncSourceId: string;
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId: CollectionId;
+    constructor(
+    /** The id of the patch */
+    id: string, 
+    /** The syncSourceId of the changed data source */
+    syncSourceId: string, 
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId: CollectionId);
+    getChange(collections?: PatchChangeCollection[]): PatchChange;
+    abstract toJSON(): object;
+    abstract clone(): this;
+}
+export declare const genericPatchParser: PatchParser<Patch>;
+export declare class ItemPatch extends Patch {
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    itemsAdded: PatchItems;
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    itemsChanged: PatchItems;
+    /** List of item primary keys deleted by Lucid */
+    itemsDeleted: string[];
+    /** */
+    itemOrderChanged: [string, string | null][] | undefined;
+    constructor(
+    /** The id of the patch */
+    id: string, 
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    itemsAdded: PatchItems, 
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    itemsChanged: PatchItems, 
+    /** List of item primary keys deleted by Lucid */
+    itemsDeleted: string[], 
+    /** */
+    itemOrderChanged: [string, string | null][] | undefined, 
+    /** The syncSourceId of the changed data source */
+    syncSourceId: string, 
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId: CollectionId);
+    toJSON(): object;
+    clone(): this;
+}
+export declare const itemPatchParser: PatchParser<ItemPatch>;
+export declare class ThirdPartyColumn {
+    readonly name: string;
+    readonly fieldType: FieldTypeDefinition;
+    constructor(name: string, fieldType: FieldTypeDefinition);
+    clone(): ThirdPartyColumn;
+    toJSON(): object;
+    static deserialize(data: SerializedThirdPartyColumn): ThirdPartyColumn;
+}
+export declare class ThirdPartyColumnPatch {
+    readonly name?: string | undefined;
+    readonly fieldType?: FieldTypeDefinition | undefined;
+    constructor(name?: string | undefined, fieldType?: FieldTypeDefinition | undefined);
+    clone(): ThirdPartyColumnPatch;
+    toJSON(): object;
+    static deserialize(data: SerializedThirdPartyColumnPatch): ThirdPartyColumnPatch;
+}
+export declare class SchemaPatch extends Patch {
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    columnsAdded: ThirdPartyColumn[];
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    columnsChanged: Record<string, ThirdPartyColumnPatch>;
+    /** List of item primary keys deleted by Lucid */
+    columnsDeleted: string[];
+    /** */
+    columnOrdering: [string, string | null][] | undefined;
+    /** Changes to the primary key */
+    primaryKey: string[] | undefined;
+    constructor(
+    /** The id of the patch */
+    id: string, 
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    columnsAdded: ThirdPartyColumn[], 
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    columnsChanged: Record<string, ThirdPartyColumnPatch>, 
+    /** List of item primary keys deleted by Lucid */
+    columnsDeleted: string[], 
+    /** */
+    columnOrdering: [string, string | null][] | undefined, 
+    /** Changes to the primary key */
+    primaryKey: string[] | undefined, 
+    /** The syncSourceId of the changed data source */
+    syncSourceId: string, 
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId: CollectionId);
+    toJSON(): object;
+    clone(): this;
+}
+export declare const schemaPatchParser: PatchParser<SchemaPatch>;

package/dataconnector/actions/patch.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaPatchParser = exports.SchemaPatch = exports.ThirdPartyColumnPatch = exports.ThirdPartyColumn = exports.itemPatchParser = exports.ItemPatch = exports.genericPatchParser = exports.Patch = void 0;
+const fieldtypedefinition_1 = require("../../core/data/fieldtypedefinition/fieldtypedefinition");
+const patchresponsebody_1 = require("./patchresponsebody");
+const serializedpatchtypes_1 = require("./serializedpatchtypes");
+function objMap(obj, f) {
+    const result = {};
+    for (const key in obj) {
+        result[key] = f(obj[key]);
+    }
+    return result;
+}
+/** A patch to be applied against the 3rd party datasource with changes coming from Lucid */
+class Patch {
+    constructor(
+    /** The id of the patch */
+    id, 
+    /** The syncSourceId of the changed data source */
+    syncSourceId, 
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId) {
+        this.id = id;
+        this.syncSourceId = syncSourceId;
+        this.syncCollectionId = syncCollectionId;
+    }
+    getChange(collections = []) {
+        return new patchresponsebody_1.PatchChange(this.id, this.syncSourceId, collections);
+    }
+}
+exports.Patch = Patch;
+const genericPatchParser = (id, x) => {
+    var _a;
+    return (_a = (0, exports.itemPatchParser)(id, x)) !== null && _a !== void 0 ? _a : (0, exports.schemaPatchParser)(id, x);
+};
+exports.genericPatchParser = genericPatchParser;
+class ItemPatch extends Patch {
+    constructor(
+    /** The id of the patch */
+    id, 
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    itemsAdded, 
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    itemsChanged, 
+    /** List of item primary keys deleted by Lucid */
+    itemsDeleted, 
+    /** */
+    itemOrderChanged, 
+    /** The syncSourceId of the changed data source */
+    syncSourceId, 
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId) {
+        super(id, syncSourceId, syncCollectionId);
+        this.itemsAdded = itemsAdded;
+        this.itemsChanged = itemsChanged;
+        this.itemsDeleted = itemsDeleted;
+        this.itemOrderChanged = itemOrderChanged;
+    }
+    toJSON() {
+        return {
+            'Id': this.id,
+            'ItemsAdded': this.itemsAdded,
+            'ItemsChanged': this.itemsChanged,
+            'ItemsDeleted': this.itemsDeleted,
+            'ItemOrderChanged': this.itemOrderChanged,
+            'SyncSourceId': this.syncSourceId,
+            'SyncCollectionId': this.syncCollectionId,
+        };
+    }
+    clone() {
+        return new ItemPatch(this.id, objMap(this.itemsAdded, (item) => objMap(item, (v) => v)), objMap(this.itemsChanged, (item) => objMap(item, (v) => v)), [...this.itemsDeleted], this.itemOrderChanged && [...this.itemOrderChanged], this.syncSourceId, this.syncCollectionId);
+    }
+}
+exports.ItemPatch = ItemPatch;
+function _itemPatchParser(id, patch) {
+    var _a;
+    return new ItemPatch(id, patch['itemsAdded'], patch['itemsChanged'], patch['itemsDeleted'], (_a = patch['itemOrderChanged']) !== null && _a !== void 0 ? _a : undefined, patch['syncSourceId'], patch['syncCollectionId']);
+}
+const itemPatchParser = (id, patch) => {
+    if ((0, serializedpatchtypes_1.patchItemValidator)(patch)) {
+        return _itemPatchParser(id, patch);
+    }
+    return undefined;
+};
+exports.itemPatchParser = itemPatchParser;
+class ThirdPartyColumn {
+    constructor(name, fieldType) {
+        this.name = name;
+        this.fieldType = fieldType;
+    }
+    clone() {
+        return new ThirdPartyColumn(this.name, this.fieldType);
+    }
+    toJSON() {
+        return { 'Name': this.name, 'FieldType': (0, fieldtypedefinition_1.serializeFieldTypeDefinition)(this.fieldType) };
+    }
+    static deserialize(data) {
+        return new ThirdPartyColumn(data['name'], (0, fieldtypedefinition_1.deserializeFieldTypeDefinition)(data['fieldType']));
+    }
+}
+exports.ThirdPartyColumn = ThirdPartyColumn;
+class ThirdPartyColumnPatch {
+    constructor(name, fieldType) {
+        this.name = name;
+        this.fieldType = fieldType;
+    }
+    clone() {
+        return new ThirdPartyColumnPatch(this.name, this.fieldType);
+    }
+    toJSON() {
+        return {
+            'Name': this.name,
+            'FieldType': this.fieldType != null ? (0, fieldtypedefinition_1.serializeFieldTypeDefinition)(this.fieldType) : undefined,
+        };
+    }
+    static deserialize(data) {
+        var _a;
+        const result = new ThirdPartyColumnPatch((_a = data['name']) !== null && _a !== void 0 ? _a : undefined, data['fieldType'] != null ? (0, fieldtypedefinition_1.deserializeFieldTypeDefinition)(data['fieldType']) : undefined);
+        console.log(`\n\nSerialization result: ${JSON.stringify(result.toJSON())}\n\n`);
+        return result;
+    }
+}
+exports.ThirdPartyColumnPatch = ThirdPartyColumnPatch;
+class SchemaPatch extends Patch {
+    constructor(
+    /** The id of the patch */
+    id, 
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    columnsAdded, 
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    columnsChanged, 
+    /** List of item primary keys deleted by Lucid */
+    columnsDeleted, 
+    /** */
+    columnOrdering, 
+    /** Changes to the primary key */
+    primaryKey, 
+    /** The syncSourceId of the changed data source */
+    syncSourceId, 
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId) {
+        super(id, syncSourceId, syncCollectionId);
+        this.columnsAdded = columnsAdded;
+        this.columnsChanged = columnsChanged;
+        this.columnsDeleted = columnsDeleted;
+        this.columnOrdering = columnOrdering;
+        this.primaryKey = primaryKey;
+    }
+    toJSON() {
+        return {
+            'Id': this.id,
+            'ColumnsAdded': this.columnsAdded.map((column) => column.toJSON()),
+            'ColumnsChanged': objMap(this.columnsChanged, (column) => column.toJSON()),
+            'ColumnsDeleted': this.columnsDeleted,
+            'ColumnOrdering': this.columnOrdering,
+            'SyncSourceId': this.syncSourceId,
+            'SyncCollectionId': this.syncCollectionId,
+        };
+    }
+    clone() {
+        return new SchemaPatch(this.id, this.columnsAdded.map((columnAdded) => columnAdded.clone()), objMap(this.columnsChanged, (columnChange) => columnChange.clone()), [...this.columnsDeleted], this.columnOrdering && [
+            ...this.columnOrdering.map(([base, target]) => [base, target]),
+        ], this.primaryKey && [...this.primaryKey], this.syncSourceId, this.syncCollectionId);
+    }
+}
+exports.SchemaPatch = SchemaPatch;
+function _schemaPatchParser(id, patch) {
+    var _a, _b;
+    return new SchemaPatch(id, patch['columnsAdded'].map(ThirdPartyColumn.deserialize), objMap(patch['columnsChanged'], ThirdPartyColumnPatch.deserialize), patch['columnsDeleted'], (_a = patch['columnOrdering']) !== null && _a !== void 0 ? _a : undefined, (_b = patch['primaryKey']) !== null && _b !== void 0 ? _b : undefined, patch['syncSourceId'], patch['syncCollectionId']);
+}
+const schemaPatchParser = (id, patch) => {
+    if ((0, serializedpatchtypes_1.patchSchemaValidator)(patch)) {
+        return _schemaPatchParser(id, patch);
+    }
+    return undefined;
+};
+exports.schemaPatchParser = schemaPatchParser;

package/dataconnector/actions/serializedactions.d.ts

@@ -1,9 +1,10 @@
 import { isString } from '../../core/checks';
 import { DataConnectorClient } from '../dataconnectorclient';
 import { DataConnectorAction } from './action';
+import { Patch, PatchParser } from './patch';
 export declare const actionsHeaderValidator: (subject: unknown) => subject is import("../..").DestructureGuardedTypeObj<{
     'x-lucid-rsa-nonce': typeof isString;
     'x-lucid-signature': typeof isString;
 }>;
 /** Function to convert the lucid action wire format into a clean list of actions */
-export declare function deserializeActions(client: DataConnectorClient, actions: unknown): DataConnectorAction[] | undefined;
+export declare function deserializeActions<P extends Patch>(client: DataConnectorClient, actions: unknown, patchParser: PatchParser<P>): DataConnectorAction[] | undefined;

package/dataconnector/actions/serializedactions.js

@@ -24,27 +24,19 @@ const serializedActionsBaseValidator = (0, validators_1.objectValidator)({
 const serializedPatchDataValidator = (0, validators_1.objectValidator)({
     packageVersion: checks_1.isString,
     patches: (0, validators_1.arrayValidator)((0, validators_1.objectValidator)({
-        patch: (0, validators_1.objectValidator)({
-            itemsAdded: (0, validators_1.objectOfValidator)(checks_1.isObjectUnsafe),
-            itemsChanged: (0, validators_1.objectOfValidator)(checks_1.isObjectUnsafe),
-            itemsDeleted: (0, validators_1.arrayValidator)(checks_1.isString),
-            itemOrderChanged: (0, validators_1.nullableOption)((0, validators_1.arrayValidator)((0, validators_1.tupleValidator)(checks_1.isString, (0, validators_1.nullable)(checks_1.isString)))),
-            syncSourceId: checks_1.isString,
-            syncCollectionId: checks_1.isString,
-            adapterType: (0, checks_1.isLiteral)('EXTENSION_API'),
-            syncSchema: checks_1.isUnknown,
-        }),
+        patch: checks_1.isUnknown,
         id: checks_1.isString,
     })),
     userCredential: checks_1.isString,
     documentUpdateToken: checks_1.isString,
 });
-const parseSerializedPatches = (patches) => {
-    return patches.map((patch) => {
-        var _a;
+const parseSerializedPatches = (patches, patchParser) => {
+    return patches
+        .map((patch) => {
         const p = patch['patch'];
-        return new action_1.Patch(patch['id'], p['itemsAdded'], p['itemsChanged'], p['itemsDeleted'], (_a = p['itemOrderChanged']) !== null && _a !== void 0 ? _a : undefined, p['syncSourceId'], p['syncCollectionId']);
-    });
+        return patchParser(patch['id'], p);
+    })
+        .filter(checks_1.isDefAndNotNull);
 };
 const serializedManageWebhookDataValidator = (0, validators_1.objectValidator)({
     webhooks: (0, validators_1.arrayValidator)((0, validators_1.objectValidator)({
@@ -54,7 +46,7 @@ const serializedManageWebhookDataValidator = (0, validators_1.objectValidator)({
     webhookToken: checks_1.isString,
 });
 /** Function to convert the lucid action wire format into a clean list of actions */
-function deserializeActions(client, actions) {
+function deserializeActions(client, actions, patchParser) {
     const parsedActions = typeof actions === 'string' ? JSON.parse(actions) : actions;
     if (!serializedActionsBaseValidator(parsedActions)) {
         return;
@@ -66,11 +58,21 @@ function deserializeActions(client, actions) {
             console.log(`Failing validation step`);
             return;
         }
-        return data.map((item) => {
+        const parsedData = data
+            .map((item) => {
             const context = new action_1.DataConnectorActionContext(parsedActions['packageId'], item['packageVersion'], item['userCredential'], parsedActions['dataConnectorName'], parsedActions['dataConnectorName'], parsedActions['documentCollections'], parsedActions['updateFilterType']);
-            const patches = parseSerializedPatches(item['patches']);
+            const patches = parseSerializedPatches(item['patches'], patchParser);
+            if (patches.length < item['patches'].length) {
+                return undefined;
+            }
             return new action_1.DataConnectorPatchAction(context, patches, client.getDataSourceClient(item['documentUpdateToken']));
-        });
+        })
+            .filter(checks_1.isDefAndNotNull);
+        if (parsedData.length < data.length) {
+            console.log(`Failing validation step`);
+            return;
+        }
+        return parsedData;
     }
     if (!parsedActions['packageVersion'] || !parsedActions['userCredential']) {
         return;
@@ -80,8 +82,13 @@ function deserializeActions(client, actions) {
             return;
         }
         const context = new action_1.DataConnectorActionContext(parsedActions['packageId'], parsedActions['packageVersion'], parsedActions['userCredential'], parsedActions['dataConnectorName'], parsedActions['dataConnectorName'], parsedActions['documentCollections'], parsedActions['updateFilterType']);
+        const parsedPatches = parseSerializedPatches(data['patches'], patchParser);
+        if (parsedPatches.length < data['patches'].length) {
+            console.log(`Failing validation step`);
+            return;
+        }
         return [
-            new action_1.DataConnectorPatchAction(context, parseSerializedPatches(data['patches']), client.getDataSourceClient(data['documentUpdateToken']), dataconnectoractionkeys_1.DataConnectorActionKeys.UnbatchedPatch),
+            new action_1.DataConnectorPatchAction(context, parsedPatches, client.getDataSourceClient(data['documentUpdateToken']), dataconnectoractionkeys_1.DataConnectorActionKeys.UnbatchedPatch),
         ];
     }
     const context = new action_1.DataConnectorActionContext(parsedActions['packageId'], parsedActions['packageVersion'], parsedActions['userCredential'], parsedActions['dataConnectorName'], parsedActions['dataConnectorName'], parsedActions['documentCollections'], parsedActions['updateFilterType']);

package/dataconnector/actions/serializedpatchtypes.d.ts

@@ -0,0 +1,79 @@
+import { isString, isUnknown } from '../../core/checks';
+import { isSerializedFieldTypeDefinition } from '../../core/data/fieldtypedefinition/fieldtypedefinition';
+import { GuardToType } from '../../core/guards';
+export declare const patchItemValidator: (subject: unknown) => subject is import("../../core/guards").DestructureGuardedTypeObj<{
+    itemsAdded: (x: unknown) => x is Record<any, {
+        [key: string]: unknown;
+    }>;
+    itemsChanged: (x: unknown) => x is Record<any, {
+        [key: string]: unknown;
+    }>;
+    itemsDeleted: (p1: unknown) => p1 is string[];
+    itemOrderChanged: (x: unknown) => x is [string, string | null][] | null | undefined;
+    syncSourceId: typeof isString;
+    syncCollectionId: typeof isString;
+    adapterType: (x: unknown) => x is "EXTENSION_API";
+    syncSchema: typeof isUnknown;
+}>;
+export type SerializedItemPatch = GuardToType<typeof patchItemValidator>;
+export declare const thirdPartyColumnValidator: (subject: unknown) => subject is import("../../core/guards").DestructureGuardedTypeObj<{
+    name: typeof isString;
+    fieldType: typeof isSerializedFieldTypeDefinition;
+}>;
+export declare const thirdPartyColumnPatchValidator: (subject: unknown) => subject is import("../../core/guards").DestructureGuardedTypeObj<{
+    name: (x: unknown) => x is string | null | undefined;
+    fieldType: (x: unknown) => x is import("../../core/data/fieldtypedefinition/fieldtypedefinition").SerializedFieldTypeDefinition | null | undefined;
+}>;
+export declare const patchSchemaValidator: (subject: unknown) => subject is import("../../core/guards").DestructureGuardedTypeObj<{
+    columnsAdded: (p1: unknown) => p1 is import("../../core/guards").DestructureGuardedTypeObj<{
+        name: typeof isString;
+        fieldType: typeof isSerializedFieldTypeDefinition;
+    }>[];
+    columnsChanged: (x: unknown) => x is {
+        [key: string]: import("../../core/guards").DestructureGuardedTypeObj<{
+            name: (x: unknown) => x is string | null | undefined;
+            fieldType: (x: unknown) => x is import("../../core/data/fieldtypedefinition/fieldtypedefinition").SerializedFieldTypeDefinition | null | undefined;
+        }>;
+    };
+    columnsDeleted: (p1: unknown) => p1 is string[];
+    columnOrdering: (x: unknown) => x is [string, string | null][] | null | undefined;
+    primaryKey: (x: unknown) => x is string[] | null | undefined;
+    syncSourceId: typeof isString;
+    syncCollectionId: typeof isString;
+    adapterType: (x: unknown) => x is "EXTENSION_API";
+}>;
+export type SerializedSchemaPatch = GuardToType<typeof patchSchemaValidator>;
+export declare const patchValidator: (x: unknown) => x is import("../../core/guards").DestructureGuardedTypeObj<{
+    itemsAdded: (x: unknown) => x is Record<any, {
+        [key: string]: unknown;
+    }>;
+    itemsChanged: (x: unknown) => x is Record<any, {
+        [key: string]: unknown;
+    }>;
+    itemsDeleted: (p1: unknown) => p1 is string[];
+    itemOrderChanged: (x: unknown) => x is [string, string | null][] | null | undefined;
+    syncSourceId: typeof isString;
+    syncCollectionId: typeof isString;
+    adapterType: (x: unknown) => x is "EXTENSION_API";
+    syncSchema: typeof isUnknown;
+}> | import("../../core/guards").DestructureGuardedTypeObj<{
+    columnsAdded: (p1: unknown) => p1 is import("../../core/guards").DestructureGuardedTypeObj<{
+        name: typeof isString;
+        fieldType: typeof isSerializedFieldTypeDefinition;
+    }>[];
+    columnsChanged: (x: unknown) => x is {
+        [key: string]: import("../../core/guards").DestructureGuardedTypeObj<{
+            name: (x: unknown) => x is string | null | undefined;
+            fieldType: (x: unknown) => x is import("../../core/data/fieldtypedefinition/fieldtypedefinition").SerializedFieldTypeDefinition | null | undefined;
+        }>;
+    };
+    columnsDeleted: (p1: unknown) => p1 is string[];
+    columnOrdering: (x: unknown) => x is [string, string | null][] | null | undefined;
+    primaryKey: (x: unknown) => x is string[] | null | undefined;
+    syncSourceId: typeof isString;
+    syncCollectionId: typeof isString;
+    adapterType: (x: unknown) => x is "EXTENSION_API";
+}>;
+export type SerializedPatch = GuardToType<typeof patchValidator>;
+export type SerializedThirdPartyColumn = GuardToType<typeof thirdPartyColumnValidator>;
+export type SerializedThirdPartyColumnPatch = GuardToType<typeof thirdPartyColumnPatchValidator>;

package/dataconnector/actions/serializedpatchtypes.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchValidator = exports.patchSchemaValidator = exports.thirdPartyColumnPatchValidator = exports.thirdPartyColumnValidator = exports.patchItemValidator = void 0;
+const checks_1 = require("../../core/checks");
+const fieldtypedefinition_1 = require("../../core/data/fieldtypedefinition/fieldtypedefinition");
+const validators_1 = require("../../core/validators/validators");
+exports.patchItemValidator = (0, validators_1.objectValidator)({
+    itemsAdded: (0, validators_1.objectOfValidator)(checks_1.isObjectUnsafe),
+    itemsChanged: (0, validators_1.objectOfValidator)(checks_1.isObjectUnsafe),
+    itemsDeleted: (0, validators_1.arrayValidator)(checks_1.isString),
+    itemOrderChanged: (0, validators_1.nullableOption)((0, validators_1.arrayValidator)((0, validators_1.tupleValidator)(checks_1.isString, (0, validators_1.nullable)(checks_1.isString)))),
+    syncSourceId: checks_1.isString,
+    syncCollectionId: checks_1.isString,
+    adapterType: (0, checks_1.isLiteral)('EXTENSION_API'),
+    syncSchema: checks_1.isUnknown,
+});
+exports.thirdPartyColumnValidator = (0, validators_1.objectValidator)({
+    name: checks_1.isString,
+    fieldType: fieldtypedefinition_1.isSerializedFieldTypeDefinition,
+});
+exports.thirdPartyColumnPatchValidator = (0, validators_1.objectValidator)({
+    name: (0, validators_1.nullableOption)(checks_1.isString),
+    fieldType: (0, validators_1.nullableOption)(fieldtypedefinition_1.isSerializedFieldTypeDefinition),
+});
+exports.patchSchemaValidator = (0, validators_1.objectValidator)({
+    columnsAdded: (0, validators_1.arrayValidator)(exports.thirdPartyColumnValidator),
+    columnsChanged: (0, validators_1.mapValidator)(exports.thirdPartyColumnPatchValidator),
+    columnsDeleted: (0, validators_1.arrayValidator)(checks_1.isString),
+    columnOrdering: (0, validators_1.nullableOption)((0, validators_1.arrayValidator)((0, validators_1.tupleValidator)(checks_1.isString, (0, validators_1.nullable)(checks_1.isString)))),
+    primaryKey: (0, validators_1.nullableOption)((0, validators_1.arrayValidator)(checks_1.isString)),
+    syncSourceId: checks_1.isString,
+    syncCollectionId: checks_1.isString,
+    adapterType: (0, checks_1.isLiteral)('EXTENSION_API'),
+});
+exports.patchValidator = (0, validators_1.either)(exports.patchItemValidator, exports.patchSchemaValidator);

package/dataconnector/dataconnector.d.ts

@@ -1,5 +1,6 @@
 import { DataConnectorAction, DataConnectorAsynchronousAction, DataConnectorManageWebhookAction, DataConnectorPatchAction, Webhook } from './actions/action';
 import { DataConnectorActionKeys } from './actions/dataconnectoractionkeys';
+import { ItemPatch, Patch, PatchParser } from './actions/patch';
 import { PatchChange } from './actions/patchresponsebody';
 import { DataConnectorClient } from './dataconnectorclient';
 import { ExpressAppLike, RunDebugServerOptions } from './debugserver';
@@ -42,11 +43,13 @@ export declare class DataConnectorResponseError extends Error {
     response: string;
     constructor(message: string, response: string);
 }
-type ActionTypeForName<Name extends string, Asynchronous = boolean> = Name extends `${DataConnectorActionKeys.Patch}` ? ActionRequest<DataConnectorPatchAction, PatchChange[]> : Name extends `${DataConnectorActionKeys.UnbatchedPatch}` ? ActionRequest<DataConnectorPatchAction, PatchChange[]> : Name extends `${DataConnectorActionKeys.ManageWebhook}` ? ActionRequest<DataConnectorManageWebhookAction, Webhook> : ActionRequest<Asynchronous extends true ? DataConnectorAsynchronousAction : DataConnectorAction>;
+type ActionTypeForName<P extends Patch, Name extends string, Asynchronous = boolean> = Name extends `${DataConnectorActionKeys.Patch}` ? ActionRequest<DataConnectorPatchAction<P>, PatchChange[]> : Name extends `${DataConnectorActionKeys.UnbatchedPatch}` ? ActionRequest<DataConnectorPatchAction<P>, PatchChange[]> : Name extends `${DataConnectorActionKeys.ManageWebhook}` ? ActionRequest<DataConnectorManageWebhookAction, Webhook> : ActionRequest<Asynchronous extends true ? DataConnectorAsynchronousAction : DataConnectorAction>;
 /** Factory class to define a bunch of action handlers. */
-export declare class DataConnector {
+export declare class DataConnector<P extends Patch = ItemPatch> {
     private client;
+    private patchParser;
     constructor(client: DataConnectorClient);
+    constructor(client: DataConnectorClient, optPatchParser: P extends ItemPatch ? never : PatchParser<P>);
     actions: Record<string, {
         actionResponder: ActionRequest<DataConnectorAsynchronousAction>;
         asynchronous: true;
@@ -56,11 +59,11 @@ export declare class DataConnector {
     }>;
     routes: Record<string, DataConnectorRoute>;
     /** Factory to define an action request handler */
-    defineAction<T extends string>(name: T, request: ActionTypeForName<T>, asynchronous?: boolean): DataConnector;
+    defineAction<T extends string>(name: T, request: ActionTypeForName<P, T>, asynchronous?: boolean): DataConnector<P>;
     /** Factory to define an asynchronous action request handler */
-    defineAsynchronousAction<T extends string>(name: T, request: ActionTypeForName<T, true>): DataConnector;
+    defineAsynchronousAction<T extends string>(name: T, request: ActionTypeForName<P, T, true>): DataConnector<P>;
     /** Factory to define a route handler */
-    defineRoute(name: string, request: DataConnectorRoute): DataConnector;
+    defineRoute(name: string, request: DataConnectorRoute): DataConnector<P>;
     /** Call a defined action handler and gather its serialized response */
     runAction(url: string, headers: Record<string, string[] | string | undefined>, body: unknown): Promise<{
         status: number;

package/dataconnector/dataconnector.js

@@ -6,6 +6,7 @@ const validators_1 = require("../core/validators/validators");
 const action_1 = require("./actions/action");
 const dataconnectoractionkeys_1 = require("./actions/dataconnectoractionkeys");
 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");
@@ -51,10 +52,11 @@ class DataConnectorResponseError extends Error {
 exports.DataConnectorResponseError = DataConnectorResponseError;
 /** Factory class to define a bunch of action handlers. */
 class DataConnector {
-    constructor(client) {
+    constructor(client, optPatchParser) {
         this.client = client;
         this.actions = {};
         this.routes = {};
+        this.patchParser = optPatchParser !== null && optPatchParser !== void 0 ? optPatchParser : patch_1.itemPatchParser;
     }
     /** Factory to define an action request handler */
     defineAction(name, request, asynchronous = false) {
@@ -73,7 +75,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 actions = await this.client.parseActions(url, headers, body);
+        const actions = await this.client.parseActions(url, headers, body, this.patchParser);
         if (!actions) {
             console.warn('Received bad request', url, headers, body);
             return { status: 404, body: { error: 'Bad request' } };

package/dataconnector/dataconnectorclient.d.ts

@@ -1,5 +1,6 @@
 import { JsonObject } from '../core/jsonserializable';
 import { DataConnectorAction } from './actions/action';
+import { Patch, PatchParser } from './actions/patch';
 import { CryptoDependencies } from './cryptodependencies';
 import { DataSourceClient, MockDataSourceClient } from './datasourceclient';
 import { SignatureValidator } from './signaturevalidator';
@@ -33,7 +34,7 @@ export declare class DataConnectorClient {
      * you're not running in a NodeJS environment */
     getPublicKey(): Promise<string>;
     /** Validate and parse an action request from Lucid */
-    parseActions(url: string, headers: Record<string, string | string[] | unknown>, actions: unknown): Promise<DataConnectorAction[] | undefined>;
+    parseActions<P extends Patch>(url: string, headers: Record<string, string | string[] | unknown>, actions: unknown, patchParser: PatchParser<P>): Promise<DataConnectorAction[] | undefined>;
     /** @ignore */
     getSecretFromWebhook(webhookUpdateToken: string, WebhookValidationSecret: WebhookValidationSecret): Promise<string | undefined>;
     /** @ignore */

package/dataconnector/dataconnectorclient.js

@@ -38,14 +38,14 @@ class DataConnectorClient {
         return this.cachedPublicKey;
     }
     /** Validate and parse an action request from Lucid */
-    async parseActions(url, headers, actions) {
+    async parseActions(url, headers, actions, patchParser) {
         if (!(0, serializedactions_1.actionsHeaderValidator)(headers)) {
             return;
         }
         if (!(await this.getSignatureValidator()).validate(actions, headers, url)) {
             return;
         }
-        return (0, serializedactions_1.deserializeActions)(this, actions);
+        return (0, serializedactions_1.deserializeActions)(this, actions, patchParser);
     }
     /** @ignore */
     async getSecretFromWebhook(webhookUpdateToken, WebhookValidationSecret) {

package/dataconnector/datasourceupdatetypes.d.ts

@@ -72,9 +72,10 @@ export declare class ItemsPatchInexhaustive {
 export declare class ItemsPatchExhaustive {
     items: Map<string, SerializedFields>;
     rekeyingMap?: Map<string, string | null> | undefined;
+    fieldNamesChanged?: Map<string, string> | undefined;
     errors?: Map<string, SerializedLucidDictionary> | undefined;
     private readonly _brand;
-    constructor(items: Map<string, SerializedFields>, rekeyingMap?: Map<string, string | null> | undefined, errors?: Map<string, SerializedLucidDictionary> | undefined);
+    constructor(items: Map<string, SerializedFields>, rekeyingMap?: Map<string, string | null> | undefined, fieldNamesChanged?: Map<string, string> | undefined, errors?: Map<string, SerializedLucidDictionary> | undefined);
 }
 export type ItemsPatch = {
     /**
@@ -94,6 +95,7 @@ export type SerializedItemsPatch = {
 } | {
     'exhaustiveItems': Record<string, SerializedFields>;
     'rekeyingMap'?: Record<string, string | null>;
+    'fieldNamesChanged'?: Record<string, string>;
     'errors'?: Record<string, SerializedLucidDictionary>;
 };
 export declare function serializeItemsPatch(patch: ItemsPatch): SerializedItemsPatch;

package/dataconnector/datasourceupdatetypes.js

@@ -22,9 +22,10 @@ class ItemsPatchInexhaustive {
 }
 exports.ItemsPatchInexhaustive = ItemsPatchInexhaustive;
 class ItemsPatchExhaustive {
-    constructor(items, rekeyingMap, errors) {
+    constructor(items, rekeyingMap, fieldNamesChanged, errors) {
         this.items = items;
         this.rekeyingMap = rekeyingMap;
+        this.fieldNamesChanged = fieldNamesChanged;
         this.errors = errors;
         this._brand = ItemsPatchExhaustive;
     }
@@ -36,10 +37,13 @@ function serializeErrors(errors) {
 function serializeRekeyingMap(rekeyingMap) {
     return rekeyingMap && { 'rekeyingMap': (0, object_1.fromEntries)(rekeyingMap) };
 }
+function serializeFieldNamesChanged(fieldNamesChanged) {
+    return fieldNamesChanged && { 'fieldNamesChanged': (0, object_1.fromEntries)(fieldNamesChanged) };
+}
 function serializeItemsPatch(patch) {
     var _a;
     if (patch instanceof ItemsPatchExhaustive) {
-        return Object.assign(Object.assign({ 'exhaustiveItems': (0, object_1.fromEntries)(patch.items.entries()) }, serializeRekeyingMap(patch.rekeyingMap)), serializeErrors(patch.errors));
+        return Object.assign(Object.assign(Object.assign({ 'exhaustiveItems': (0, object_1.fromEntries)(patch.items.entries()) }, serializeRekeyingMap(patch.rekeyingMap)), serializeFieldNamesChanged(patch.fieldNamesChanged)), serializeErrors(patch.errors));
     }
     else {
         return Object.assign({ 'items': (0, object_1.fromEntries)(patch.items.entries()), 'itemsDeleted': (_a = patch.itemsDeleted) !== null && _a !== void 0 ? _a : [] }, serializeErrors(patch.errors));

package/dataconnector/debugserver.d.ts

@@ -1,3 +1,4 @@
+import { Patch } from './actions/patch';
 import { DataConnector } from './dataconnector';
 /** @ignore */
 export type ExpressLike = {
@@ -42,6 +43,6 @@ export type RunDebugServerOptions = {
     app?: ExpressAppLike;
 };
 /** @ignore */
-export declare function routeDebugServer(dataConnector: DataConnector, options: RunDebugServerOptions): ExpressAppLike;
+export declare function routeDebugServer<P extends Patch>(dataConnector: DataConnector<P>, options: RunDebugServerOptions): ExpressAppLike;
 /** @ignore */
-export declare function runDebugServer(dataConnector: DataConnector, options: RunDebugServerOptions): void;
+export declare function runDebugServer<P extends Patch>(dataConnector: DataConnector<P>, options: RunDebugServerOptions): void;

package/dataconnector/itemrekeyer.d.ts

@@ -1,5 +1,6 @@
 import { FormattedPrimaryKey } from '../core/data/fieldspecification';
-import { Patch, PatchItems } from './actions/action';
+import { PatchItems } from './actions/action';
+import { Patch } from './actions/patch';
 import { ItemsPatch } from './datasourceupdatetypes';
 export declare class RekeyingMap {
     map: Map<string, string | null>;

package/dataconnector/itemrekeyer.js

@@ -3,7 +3,7 @@ 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 action_1 = require("./actions/action");
+const patch_1 = require("./actions/patch");
 const datasourceupdatetypes_1 = require("./datasourceupdatetypes");
 function calculateRekeyingMap(itemsPatch, primaryKey) {
     var _a, _b;
@@ -55,7 +55,10 @@ class RekeyingMap {
     }
     getRekeyedPatch(patch) {
         var _a;
-        return new action_1.Patch(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);
+        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;

package/package.json

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