lucid-extension-sdk 0.0.147 → 0.0.149

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

@@ -0,0 +1 @@
+export declare const alphabet: string[];

package/core/data/datasource/alphabet.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alphabet = void 0;
+exports.alphabet = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+];

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

@@ -0,0 +1,26 @@
+import { SerializedFields } from '../serializedfield/serializedfields';
+import { DataSourceType } from './datasourcetype';
+import { SerializedImportedCollection } from './serializedimporteddatasource';
+import { UpstreamUpdateType } from './upstreamupdatetype';
+/** @ignore */
+export declare function alphabetize(n: number): string;
+/** @ignore */
+export declare const MetadataPK = "__PK__";
+/** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
+export declare function makeSerializedImportedCollection(id: string, name: string, rawSchema: string[], data: SerializedFields[], metadata?: {
+    [key: string]: SerializedFields[];
+}): SerializedImportedCollection;
+/** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
+export declare function makeSerializedImportedDataSource(id: string, name: string, collections: SerializedImportedCollection[]): {
+    Properties: {
+        Name: string;
+        UpstreamConfig: {
+            SourceType: DataSourceType;
+            UpdateType: UpstreamUpdateType;
+            SourceConfig: {
+                spreadsheetId: string;
+            };
+        };
+    };
+    Collections: SerializedImportedCollection[];
+};

package/core/data/datasource/datasourceutils.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSerializedImportedDataSource = exports.makeSerializedImportedCollection = exports.MetadataPK = exports.alphabetize = void 0;
+const scalarfieldtype_1 = require("../fieldtypedefinition/scalarfieldtype");
+const alphabet_1 = require("./alphabet");
+const datasourcetype_1 = require("./datasourcetype");
+const upstreamupdatetype_1 = require("./upstreamupdatetype");
+/** @ignore */
+function _alphabetize(n) {
+    if (n == undefined || n < 0) {
+        return '';
+    }
+    else if (n < alphabet_1.alphabet.length) {
+        return alphabet_1.alphabet[n];
+    }
+    else {
+        return alphabetize(Math.floor(n / alphabet_1.alphabet.length) - 1) + alphabetize(n % alphabet_1.alphabet.length);
+    }
+}
+/** @ignore */
+const memoize = new Map();
+/** @ignore */
+function alphabetize(n) {
+    const stored = memoize.get(n);
+    if (stored != null) {
+        return stored;
+    }
+    const value = _alphabetize(n);
+    memoize.set(n, value);
+    return value;
+}
+exports.alphabetize = alphabetize;
+/** @ignore */
+function normalizeName(name) {
+    return name.trim().toLowerCase();
+}
+/** @ignore */
+exports.MetadataPK = '__PK__';
+/** @ignore */
+function makeSchema(schemaFields) {
+    const fields = [];
+    const oldToNewFields = new Map();
+    const usedFieldsNormalized = new Set([normalizeName(exports.MetadataPK)]);
+    schemaFields.forEach((field, index) => {
+        // don't add duplicates
+        if (!usedFieldsNormalized.has(normalizeName(field))) {
+            usedFieldsNormalized.add(normalizeName(field));
+            // for now we're changing all schema to the alphabet until preview data can be skipped
+            fields.push({ 'Name': alphabetize(index), 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.ANY });
+            oldToNewFields.set(field, alphabetize(index));
+        }
+    });
+    return { sheetSchema: { 'Fields': fields, 'PrimaryKey': [] }, oldToNewFields };
+}
+/** @ignore */
+function makeMetadataCollection(metadataType, sheetName, dataItems, sheetSchema) {
+    return {
+        'Name': sheetName + '|' + metadataType,
+        'Schema': sheetSchema,
+        'Items': dataItems,
+    };
+}
+/** @ignore */
+function makeItemOrderCollection(sheetLength, sheetName) {
+    const itemOrderItems = {};
+    for (let i = 1; i <= sheetLength; ++i) {
+        const rowIndex = i;
+        itemOrderItems[`${rowIndex}`] = { 'Key': `${rowIndex}`, 'Order': rowIndex };
+    }
+    const itemOrderSchema = {
+        'Fields': [
+            { 'Name': 'Key', 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.STRING },
+            { 'Name': 'Order', 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.NUMBER },
+        ],
+        'PrimaryKey': ['Order'],
+    };
+    return makeMetadataCollection('ItemOrder', sheetName, itemOrderItems, itemOrderSchema);
+}
+/** @ignore */
+function makeSerializedItems(rawItems, oldToNewFields, isMetadata = false) {
+    const serializedItems = {};
+    rawItems.forEach((rawItem, rowIndex) => {
+        const dataItem = {};
+        for (const [key, field] of Object.entries(rawItem)) {
+            const newKey = oldToNewFields.get(key);
+            if (newKey) {
+                dataItem[newKey] = field;
+            }
+        }
+        const primaryKey = rowIndex + 1;
+        if (isMetadata && Object.keys(dataItem).length > 0) {
+            dataItem[exports.MetadataPK] = `${primaryKey}`;
+            serializedItems[`"${primaryKey}"`] = dataItem;
+        }
+        else if (!isMetadata) {
+            serializedItems[primaryKey] = dataItem;
+        }
+    });
+    return serializedItems;
+}
+/** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
+function makeSerializedImportedCollection(id, name, rawSchema, data, metadata) {
+    const { sheetSchema, oldToNewFields } = makeSchema(rawSchema);
+    const metadataCollections = {};
+    const itemOrderCollection = makeItemOrderCollection(data.length, name);
+    metadataCollections['ItemOrder'] = itemOrderCollection;
+    if (metadata) {
+        const metadataFields = [{ 'Name': exports.MetadataPK, 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.STRING }];
+        sheetSchema['Fields'].forEach((field) => metadataFields.push({ 'Name': field['Name'], 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.STRING }));
+        const metadataSchema = { 'Fields': metadataFields, 'PrimaryKey': [exports.MetadataPK] };
+        for (const [type, data] of Object.entries(metadata)) {
+            metadataCollections[type] = makeMetadataCollection(type, name, makeSerializedItems(data, oldToNewFields, true), metadataSchema);
+        }
+    }
+    return {
+        'Name': name,
+        'Schema': sheetSchema,
+        'Items': makeSerializedItems(data, oldToNewFields),
+        'UpstreamConfig': {
+            'properties': {
+                'UpstreamType': upstreamupdatetype_1.UpstreamUpdateType.EVENTPULL,
+                'sheetId': id,
+            },
+        },
+        'Metadata': metadataCollections,
+    };
+}
+exports.makeSerializedImportedCollection = makeSerializedImportedCollection;
+/** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
+function makeSerializedImportedDataSource(id, name, collections) {
+    return {
+        'Properties': {
+            'Name': name,
+            'UpstreamConfig': {
+                'SourceType': datasourcetype_1.DataSourceType.DataService,
+                'UpdateType': upstreamupdatetype_1.UpstreamUpdateType.EVENTPULL,
+                'SourceConfig': { 'spreadsheetId': id },
+            },
+        },
+        'Collections': collections,
+    };
+}
+exports.makeSerializedImportedDataSource = makeSerializedImportedDataSource;

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

@@ -17,7 +17,7 @@ export declare const isSerializedImportedMetadataCollection: (subject: unknown)
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export interface SerializedImportedCollection {
     'Name': string;
-    'Id': string;
+    'Id'?: string;
     'Schema': SerializedSchema;
     'Items': SerializedDataItems;
     'UpstreamConfig': {
@@ -30,7 +30,6 @@ export interface SerializedImportedCollection {
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export declare const isSerializedImportedCollection: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Name: typeof isString;
-    Id: typeof isString;
     Schema: typeof isSerializedSchema;
     Items: typeof isSerializedDataItems;
     UpstreamConfig: typeof isObject;
@@ -58,7 +57,6 @@ export declare const isSerializedImportedDataSource: (subject: unknown) => subje
     }>;
     Collections: (val: unknown) => val is import("../../guards").DestructureGuardedTypeObj<{
         Name: typeof isString;
-        Id: typeof isString;
         Schema: typeof isSerializedSchema;
         Items: typeof isSerializedDataItems;
         UpstreamConfig: typeof isObject;

package/core/data/datasource/serializedimporteddatasource.js

@@ -15,7 +15,6 @@ exports.isSerializedImportedMetadataCollection = (0, validators_1.strictObjectVa
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 exports.isSerializedImportedCollection = (0, validators_1.strictObjectValidator)({
     'Name': checks_1.isString,
-    'Id': checks_1.isString,
     'Schema': serializedschema_1.isSerializedSchema,
     'Items': serializeddataitems_1.isSerializedDataItems,
     'UpstreamConfig': checks_1.isObject,

package/dataconnector/cryptodependencies.d.ts

@@ -0,0 +1,11 @@
+export declare interface BufferSingleton {
+    from(str: string, encoding?: string): unknown;
+}
+export declare interface CryptoModule {
+    createPublicKey(key: string): unknown;
+    verify(algorithm: string, data: unknown, publicKey: unknown, signature: unknown): boolean;
+}
+export declare type CryptoDependencies = {
+    Buffer: BufferSingleton;
+    crypto: CryptoModule;
+};

package/dataconnector/cryptodependencies.js

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

package/dataconnector/dataconnectorclient.d.ts

@@ -1,5 +1,6 @@
 import { JsonObject } from '../core/jsonserializable';
 import { DataConnectorAction } from './actions/action';
+import { CryptoDependencies } from './cryptodependencies';
 import { DataSourceClient, MockDataSourceClient } from './datasourceclient';
 import { SignatureValidator } from './signaturevalidator';
 /** @ignore */
@@ -13,13 +14,14 @@ export declare type WebhookValidationSecret = {
  * Client for requests to and from Lucid
  */
 export declare class DataConnectorClient {
+    private readonly cryptoDependencies;
     urls: {
         main: string;
         api: string;
     };
     private fetchMethod;
     private cachedPublicKey;
-    constructor(urls?: {
+    constructor(cryptoDependencies: CryptoDependencies, urls?: {
         main: string;
         api: string;
     }, fetchMethod?: import("./defaultfetchfunction").GlobalFetchType);
@@ -43,6 +45,7 @@ export declare class DataConnectorClient {
 export declare class MockDataConnectorClient extends DataConnectorClient {
     /** set properties on this to modify how data source updates are mocked */
     readonly dataSourceClient: MockDataSourceClient;
+    constructor();
     /** @ignore */
     getDataSourceClient(updateToken: string): DataSourceClient;
     /** Mocked version just always returns successful */

package/dataconnector/dataconnectorclient.js

@@ -12,7 +12,8 @@ const LUCID_URLS = { main: 'https://lucid.app/', api: 'https://api.lucid.co/' };
  * Client for requests to and from Lucid
  */
 class DataConnectorClient {
-    constructor(urls = LUCID_URLS, fetchMethod = defaultfetchfunction_1.globalFetch) {
+    constructor(cryptoDependencies, urls = LUCID_URLS, fetchMethod = defaultfetchfunction_1.globalFetch) {
+        this.cryptoDependencies = cryptoDependencies;
         this.urls = urls;
         this.fetchMethod = fetchMethod;
         this.cachedPublicKey = undefined;
@@ -23,7 +24,7 @@ class DataConnectorClient {
     }
     /** Get a validator to prove a given request came from Lucid */
     async getSignatureValidator() {
-        return new signaturevalidator_1.SignatureValidator(await this.getPublicKey());
+        return new signaturevalidator_1.SignatureValidator(this.cryptoDependencies, await this.getPublicKey());
     }
     /** Get Lucid's public key to verify requests came from Lucid if you don't want to use the SignatureValidator. Maybe
      * you're not running in a NodeJS environment */
@@ -92,7 +93,7 @@ exports.DataConnectorClient = DataConnectorClient;
 /** Use this for writing automated tests for your data connector */
 class MockDataConnectorClient extends DataConnectorClient {
     constructor() {
-        super(...arguments);
+        super(undefined);
         /** set properties on this to modify how data source updates are mocked */
         this.dataSourceClient = new datasourceclient_1.MockDataSourceClient();
     }

package/dataconnector/debugserver.js

@@ -10,6 +10,17 @@ function routeDebugServer(dataConnector, options) {
     // We can't use Express's JSON parsing because we need to send the string of the request body
     // directly for the route style flows. Some extensions compute a HMAC of from this data
     app.use(express.raw({ type: () => true }));
+    // CORS
+    app.use((req, res, next) => {
+        var _a, _b;
+        if ((_b = (_a = req.headers) === null || _a === void 0 ? void 0 : _a.origin) === null || _b === void 0 ? void 0 : _b.match(/.lucid(dev|staging|preprod|).app$/)) {
+            res.header('Access-Control-Allow-Origin', req.headers.origin);
+            res.header('Vary', 'Origin');
+            res.header('Access-Control-Allow-Methods', 'GET, OPTIONS');
+            res.header('Access-Control-Allow-Headers', '*');
+        }
+        next();
+    });
     const prefix = (_b = options.prefix) !== null && _b !== void 0 ? _b : '/';
     console.log(`Routing ${prefix}?kind=action (${Object.keys(dataConnector.actions).join(', ')})`);
     if (dataConnector.routes) {

package/dataconnector/signaturevalidator.d.ts

@@ -1,16 +1,13 @@
-/** @ignore */
-export declare const signatureValidatorImportedNode: {
-    Buffer: any;
-    crypto: any;
-};
+import { CryptoDependencies } from './cryptodependencies';
 /**
  * Allows validation that requests originated from Lucid. This class can only be instanciated in a NodeJS environment.
  * Technically any environment that provides NodeJS compatible implementations of `globalThis.Buffer` and
  * `globalThis.require('crypto')` will work.
  */
 export declare class SignatureValidator {
+    private readonly dependencies;
     private readonly publicKey;
-    constructor(publicKey: string);
+    constructor(dependencies: CryptoDependencies, publicKey: string);
     /**
      * Validate a given request came from Lucid.
      * @param body The body of the request as a plain JavaScript object. This should be JSON.parse called on exactly the

package/dataconnector/signaturevalidator.js

@@ -1,35 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockSignatureValidator = exports.SignatureValidator = exports.signatureValidatorImportedNode = void 0;
-// Don't import these normally, so they're resolved at runtime.
-// This is so the lucid-extension-sdk can be used from a browser.
-// This class only is implemented for NodeJS environments, so
-// it will fail at runtime if you try to instanciate it in a browser.
-// It's also exported and mutable because while this compiles and
-// works in the lambda environment, for some reason it doesn't work
-// in the debug server environment, so from there we import it and
-// patch it up with imports that do work.
-/** @ignore */
-exports.signatureValidatorImportedNode = (() => {
-    const Buffer = globalThis['Buffer'];
-    const require = globalThis['require'];
-    const crypto = require && require('crypto');
-    return { 'Buffer': Buffer, 'crypto': crypto };
-})();
+exports.MockSignatureValidator = exports.SignatureValidator = void 0;
 /**
  * Allows validation that requests originated from Lucid. This class can only be instanciated in a NodeJS environment.
  * Technically any environment that provides NodeJS compatible implementations of `globalThis.Buffer` and
  * `globalThis.require('crypto')` will work.
  */
 class SignatureValidator {
-    constructor(publicKey) {
-        if (!exports.signatureValidatorImportedNode['Buffer']) {
-            throw new Error('Expect `Buffer` class to be defined');
-        }
-        if (!exports.signatureValidatorImportedNode['crypto']) {
-            throw new Error("Expect `require('crypto')` to be defined");
-        }
-        this.publicKey = exports.signatureValidatorImportedNode['crypto']['createPublicKey'](publicKey);
+    constructor(dependencies, publicKey) {
+        this.dependencies = dependencies;
+        this.publicKey = dependencies.crypto.createPublicKey(publicKey);
     }
     /**
      * Validate a given request came from Lucid.
@@ -44,9 +24,9 @@ class SignatureValidator {
         const parts = url.split('?');
         const params = parts.length > 0 ? parts[1] : '';
         const nonce = headers['x-lucid-rsa-nonce'];
-        const signature = exports.signatureValidatorImportedNode['Buffer']['from'](headers['x-lucid-signature'], 'base64');
-        const data = exports.signatureValidatorImportedNode['Buffer']['from'](JSON.stringify(body) + nonce + params);
-        const verified = exports.signatureValidatorImportedNode['crypto']['verify']('SHA384', data, this.publicKey, signature);
+        const signature = this.dependencies.Buffer.from(headers['x-lucid-signature'], 'base64');
+        const data = this.dependencies.Buffer.from(JSON.stringify(body) + nonce + params);
+        const verified = this.dependencies.crypto.verify('SHA384', data, this.publicKey, signature);
         return verified;
     }
 }

package/index.d.ts

@@ -7,6 +7,7 @@ export * from './core/cardintegration/lucidcardintegration';
 export * from './core/cardintegration/lucidcardintegrationregistry';
 export * from './core/checks';
 export * from './core/data/datasource/datasourcetype';
+export * from './core/data/datasource/datasourceutils';
 export * from './core/data/datasource/metadatatypes';
 export * from './core/data/datasource/serializeddatasourceproperties';
 export * from './core/data/datasource/serializedimporteddatasource';

package/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./core/cardintegration/lucidcardintegration"), exports);
 __exportStar(require("./core/cardintegration/lucidcardintegrationregistry"), exports);
 __exportStar(require("./core/checks"), exports);
 __exportStar(require("./core/data/datasource/datasourcetype"), exports);
+__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);

package/package.json

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