lucid-extension-sdk 0.0.107 → 0.0.108

package/package.json

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

package/sdk/dataconnector/actions/patchresponsebody.js

@@ -48,16 +48,16 @@ function serializePatchChanges(changes) {
     const joinedErrors = {};
     for (const changeGroup of changes) {
         for (const change of changeGroup) {
-            if (!(change.patchId in joinedErrors)) {
-                joinedErrors[change.patchId] = {};
-            }
-            const patchErrors = joinedErrors[change.patchId];
             for (const [primaryKey, fieldNames] of Object.entries(change.getErrors())) {
-                if (!(primaryKey in patchErrors)) {
-                    patchErrors[primaryKey] = {};
-                }
-                const primaryKeyErrors = patchErrors[primaryKey];
                 for (const [fieldName, error] of Object.entries(fieldNames)) {
+                    if (!(change.patchId in joinedErrors)) {
+                        joinedErrors[change.patchId] = {};
+                    }
+                    const patchErrors = joinedErrors[change.patchId];
+                    if (!(primaryKey in patchErrors)) {
+                        patchErrors[primaryKey] = {};
+                    }
+                    const primaryKeyErrors = patchErrors[primaryKey];
                     primaryKeyErrors[fieldName] = error;
                 }
             }

package/sdk/dataconnector/actions/serializedactions.js

@@ -9,11 +9,11 @@ exports.actionsHeaderValidator = (0, validators_1.objectValidator)({ 'x-lucid-rs
 const serializedActionsBaseValidator = (0, validators_1.objectValidator)({
     'action': (0, validators_1.objectValidator)({ 'name': checks_1.isString, 'data': checks_1.isUnknown }),
     'packageId': checks_1.isString,
-    'packageVersion': (0, validators_1.option)(checks_1.isString),
+    'packageVersion': (0, validators_1.nullableOption)(checks_1.isString),
     'dataConnectorName': checks_1.isString,
-    'installationId': (0, validators_1.option)(checks_1.isString),
-    'userCredential': (0, validators_1.option)(checks_1.isString),
-    'documentUpdateToken': (0, validators_1.option)(checks_1.isString),
+    'installationId': (0, validators_1.nullableOption)(checks_1.isString),
+    'userCredential': (0, validators_1.nullableOption)(checks_1.isString),
+    'documentUpdateToken': (0, validators_1.nullableOption)(checks_1.isString),
     'documentCollections': (0, validators_1.objectOfValidator)((0, validators_1.arrayValidator)(checks_1.isString)),
     'updateFilterType': (0, validators_1.enumValidator)(dataupdatefiltertype_1.DataUpdateFilterType),
 });
@@ -36,7 +36,6 @@ const serializedPatchDataValidator = (0, validators_1.arrayValidator)((0, valida
 const serializedManageWebhookDataValidator = (0, validators_1.objectValidator)({
     'webhooks': (0, validators_1.arrayValidator)((0, validators_1.objectValidator)({
         'documentCollections': (0, validators_1.objectOfValidator)((0, validators_1.arrayValidator)(checks_1.isString)),
-        'updateFilterType': (0, validators_1.enumValidator)(dataupdatefiltertype_1.DataUpdateFilterType),
         'webhookData': (0, validators_1.option)(checks_1.isUnknown),
     })),
     'webhookToken': checks_1.isString,

package/sdk/dataconnector/dataconnector.js

@@ -43,62 +43,62 @@ class DataConnector {
     /** Call a defined action handler and gather its serialized response */
     async runAction(url, headers, body) {
         const actions = await this.client.parseActions(url, headers, body);
-        if (actions) {
-            try {
-                const responses = [];
-                for (const action of actions) {
-                    if (!(action.name in this.actions)) {
-                        throw DataConnectorRunError.withMessage(404, `Action ${action.name} is not implemented`);
-                    }
-                    const { actionResponder, asynchronous } = this.actions[action.name];
-                    const response = (() => {
-                        if (asynchronous) {
-                            if (!(action instanceof action_1.DataConnectorAsynchronousAction)) {
-                                throw DataConnectorRunError.withMessage(400, `Passing uncredentialed action to ${action.name} which is defined to be asynchronous`);
-                            }
-                            return actionResponder(action);
-                        }
-                        else {
-                            return actionResponder(action);
-                        }
-                    })();
-                    responses.push(await response);
-                }
-                if (actions[0].name === exports.DataConnectorActionKeys.ManageWebhook) {
-                    const response = responses[0];
-                    // leave the type on this variable because our return type isn't strict. This means that
-                    // changes to serializeManageWebhookResponse's return type will need to consider this point
-                    const body = (0, managewebhookresponsebody_1.serializeManageWebhookResponse)(response);
-                    return { status: 200, body };
-                }
-                if (actions[0].name === exports.DataConnectorActionKeys.Patch) {
-                    const responsesCasted = responses;
-                    // leave the type on this variable because our return type isn't strict. This means that
-                    // changes to serializePatchChanges's return type will need to consider this point
-                    const body = (0, patchresponsebody_1.serializePatchChanges)(responsesCasted);
-                    return { status: 200, body };
-                }
-                else if (responses.length === 1) {
-                    return { status: 200, body: responses[0] };
-                }
-                else {
-                    return { status: 200, body: responses };
+        if (!actions) {
+            console.warn('Received bad request', url, headers, body);
+            return { status: 404, body: { error: 'Bad request' } };
+        }
+        const actionName = actions[0].name;
+        try {
+            const responses = [];
+            for (const action of actions) {
+                if (!(action.name in this.actions)) {
+                    throw DataConnectorRunError.withMessage(404, `Action ${action.name} is not implemented`);
                 }
+                const { actionResponder, asynchronous } = this.actions[action.name];
+                const response = (() => {
+                    if (asynchronous) {
+                        if (!(action instanceof action_1.DataConnectorAsynchronousAction)) {
+                            throw DataConnectorRunError.withMessage(400, `Passing uncredentialed action to ${action.name} which is defined to be asynchronous`);
+                        }
+                        return actionResponder(action);
+                    }
+                    else {
+                        return actionResponder(action);
+                    }
+                })();
+                responses.push(await response);
             }
-            catch (e) {
-                const errorLogger = console.error ? console.error : console.log;
-                if (e instanceof DataConnectorRunError) {
-                    errorLogger('Error running action', e);
-                    return { status: e.status, body: e.body };
-                }
-                else {
-                    errorLogger('Error running action', e);
-                    return { status: 500, body: { error: `error running action ${actions[0].name}` } };
-                }
+            if (actionName === exports.DataConnectorActionKeys.ManageWebhook) {
+                const response = responses[0];
+                // leave the type on this variable because our return type isn't strict. This means that
+                // changes to serializeManageWebhookResponse's return type will need to consider this point
+                const body = (0, managewebhookresponsebody_1.serializeManageWebhookResponse)(response);
+                return { status: 200, body };
+            }
+            if (actionName === exports.DataConnectorActionKeys.Patch) {
+                const responsesCasted = responses;
+                // leave the type on this variable because our return type isn't strict. This means that
+                // changes to serializePatchChanges's return type will need to consider this point
+                const body = (0, patchresponsebody_1.serializePatchChanges)(responsesCasted);
+                return { status: 200, body };
+            }
+            else if (responses.length === 1) {
+                return { status: 200, body: responses[0] };
+            }
+            else {
+                return { status: 200, body: responses };
             }
         }
-        else {
-            return { status: 404, body: { error: 'Bad request' } };
+        catch (e) {
+            const errorLogger = console.error ? console.error : console.log;
+            if (e instanceof DataConnectorRunError) {
+                errorLogger(`Error running ${actionName} action`, e);
+                return { status: e.status, body: e.body };
+            }
+            else {
+                errorLogger(`Error running ${actionName} action`, e);
+                return { status: 500, body: { error: `error running ${actionName} action` } };
+            }
         }
     }
     /** Add a route to the given express app (or generate a new app) to serve this data connector */

package/sdk/dataconnector/dataconnectorclient.d.ts

@@ -1,6 +1,14 @@
+import { JsonObject } from '../core/jsonserializable';
 import { DataConnectorAction } from './actions/action';
 import { DataSourceClient, MockDataSourceClient } from './datasourceclient';
 import { SignatureValidator } from './signaturevalidator';
+/** @ignore */
+export declare type WebhookValidationSecret = {
+    'oauth2': {
+        'clientId': string;
+        'clientSecret': string;
+    };
+};
 /**
  * Client for requests to and from Lucid
  */
@@ -24,6 +32,15 @@ export declare class DataConnectorClient {
     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>;
+    /** @ignore */
+    getSecretFromWebhook(webhookUpdateToken: string, WebhookValidationSecret: WebhookValidationSecret): Promise<string | undefined>;
+    /** @ignore */
+    getCustomWebhookData(webhookUpdateToken: string): Promise<JsonObject>;
+    /** @ignore */
+    patchCustomWebhookData(webhookUpdateToken: string, patch: JsonObject): Promise<{
+        data: JsonObject;
+        status: number;
+    }>;
 }
 /** Use this for writing automated tests for your data connector */
 export declare class MockDataConnectorClient extends DataConnectorClient {

package/sdk/dataconnector/dataconnectorclient.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockDataConnectorClient = exports.DataConnectorClient = void 0;
+const checks_1 = require("../core/checks");
 const serializedactions_1 = require("./actions/serializedactions");
+const dataconnector_1 = require("./dataconnector");
 const datasourceclient_1 = require("./datasourceclient");
 const defaultfetchfunction_1 = require("./defaultfetchfunction");
 const signaturevalidator_1 = require("./signaturevalidator");
@@ -29,6 +31,9 @@ class DataConnectorClient {
         if (!this.cachedPublicKey) {
             const url = `${this.urls.main}.well-known/pem/TPCP`;
             const result = await this.fetchMethod(url);
+            if (Math.floor(result.status / 100) !== 2) {
+                throw new dataconnector_1.DataConnectorRunError(500, { text: await result.text(), message: 'Error getting public key' });
+            }
             this.cachedPublicKey = await result.text();
         }
         return this.cachedPublicKey;
@@ -43,6 +48,40 @@ class DataConnectorClient {
         }
         return (0, serializedactions_1.deserializeActions)(this, actions);
     }
+    /** @ignore */
+    async getSecretFromWebhook(webhookUpdateToken, WebhookValidationSecret) {
+        // todo: this should be using the public API
+        const result = await this.fetchMethod(`${this.urls.dataSync}/webhookAuthorization`, {
+            headers: {
+                'data-update-token': webhookUpdateToken,
+                'webhook-validation-secret': JSON.stringify(WebhookValidationSecret),
+            },
+        });
+        const responseBody = await result.json();
+        if ((0, checks_1.isString)(responseBody)) {
+            return responseBody;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /** @ignore */
+    async getCustomWebhookData(webhookUpdateToken) {
+        return (await // todo: this should be using the public API
+         (await this.fetchMethod(`${this.urls.dataSync}customWebhookData`, {
+            headers: { 'data-update-token': webhookUpdateToken },
+        })).json());
+    }
+    /** @ignore */
+    async patchCustomWebhookData(webhookUpdateToken, patch) {
+        // todo: this should be using the public API
+        const response = await this.fetchMethod(`${this.urls.dataSync}customWebhookData`, {
+            method: 'PATCH',
+            headers: { 'data-update-token': webhookUpdateToken },
+            body: patch,
+        });
+        return { status: response.status, data: (await response.json()) };
+    }
 }
 exports.DataConnectorClient = DataConnectorClient;
 /** Use this for writing automated tests for your data connector */

package/sdk/dataconnector/datasourceclient.d.ts

@@ -16,11 +16,6 @@ export declare type DataSourceRequest = {
     /** Collections to add or update to the data source */
     collections: Record<string, CollectionPatch>;
 };
-/** A response to a data source update. Basically just the HTTP response from the server with JSON.parse called on it */
-export declare type DataSourceResponse = {
-    data: unknown;
-    status: number;
-};
 declare type SerializedFieldConstraintForApi = {
     'type': FieldConstraintType;
     'details'?: JsonSerializable;
@@ -73,7 +68,7 @@ export declare class DataSourceClient {
     /** Create or update a datasource. If you create a new collection it must be fully specified in terms of schema and
      * and items. If it's just an update then the schema can be omitted (if unchanged) and items that already exist can
      * be partial.*/
-    update(request: DataSourceRequest): Promise<DataSourceResponse>;
+    update(request: DataSourceRequest): Promise<void>;
 }
 /**
  * A version of the DataSourceClient that you can use for any automated tests of your data connector.
@@ -81,9 +76,9 @@ export declare class DataSourceClient {
  **/
 export declare class MockDataSourceClient extends DataSourceClient {
     /** Assign this to your mocked update function */
-    gotUpdate: (request: DataSourceRequest) => DataSourceResponse;
+    gotUpdate: (request: DataSourceRequest) => void;
     constructor();
     /** @ignore */
-    update(request: DataSourceRequest): Promise<DataSourceResponse>;
+    update(request: DataSourceRequest): Promise<void>;
 }
 export {};

package/sdk/dataconnector/datasourceclient.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockDataSourceClient = exports.DataSourceClient = exports.serializeFieldDefinitionForApi = void 0;
 const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
 const object_1 = require("../core/object");
+const dataconnector_1 = require("./dataconnector");
 const defaultfetchfunction_1 = require("./defaultfetchfunction");
 function serializeFieldConstraintForApi(constraint) {
     return {
@@ -82,7 +83,18 @@ class DataSourceClient {
             },
             'body': JSON.stringify(this.formatBody(request)),
         });
-        return { status: response.status, data: await response.json() };
+        if (Math.floor(response.status / 100) !== 2) {
+            throw new dataconnector_1.DataConnectorRunError(500, { message: 'Error updating data source', json: await response.text() });
+        }
+        // webhooks return 200 with an empty body
+        // document updates return valid json
+        // we can't use .json because that will fail for webhooks
+        // if we update the response type for webhook updates
+        // we can handle that here too. We should probably unify the responses
+        // to be meaningful
+        // we could just:
+        // return await response.text();
+        // but lets avoid users trying to interpret the response
     }
 }
 exports.DataSourceClient = DataSourceClient;

package/sdk/dataconnector/debugserver.js

@@ -48,7 +48,7 @@ function routeDebugServer(dataConnector, options) {
             }
         }
         catch (e) {
-            console.log(`Error serving Connector: ${prefix} Flow: ${req.query['name']}, Exception:` + e);
+            console.log(`Error serving Connector: ${prefix} Flow: ${req.query['name']}, Exception:`, e);
             res.status(500).end();
         }
     });