dataverse-utils 2.2.10 → 2.2.13

package/README.md

@@ -0,0 +1,24 @@
+# dataverse-utils
+| NPM |
+| --- |
+| [![npm](https://img.shields.io/npm/v/dataverse-utils.svg?style=flat-square)](https://www.npmjs.com/package/dataverse-utils) |
+
+Utilities for interacting with Dataverse environments
+
+# Deploy
+
+Deployment configuration is stored in dataverse.config.json. Access token will be acquired via device-code flow.
+
+```sh
+dataverse-utils deploy webresource
+
+dataverse-utils deploy assembly
+```
+
+# Generate Early-Bound TS Files
+
+Generate early bound TypeScript files for tables. Access token will be acquired via device-code flow.
+
+```sh
+dataverse-utils generate account
+```

package/lib/assemblyDeploy.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployAssembly = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pluginAssembly_1 = require("./models/pluginAssembly");
+const logger_1 = require("./logger");
+async function deployAssembly(creds, apiConfig) {
+    const currentPath = '.';
+    const configFile = await fs_1.default.promises.readFile(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    if (configFile == null) {
+        logger_1.logger.warn('unable to find dataverse.config.json file');
+        return;
+    }
+    const config = JSON.parse(configFile);
+    logger_1.logger.info('deploy assembly');
+    try {
+        await (0, pluginAssembly_1.deploy)(config, apiConfig, creds.solution);
+    }
+    catch (error) {
+        logger_1.logger.error(error.message);
+        return;
+    }
+    logger_1.logger.done(`deployed assembly ${config.name}\r\n`);
+}
+exports.deployAssembly = deployAssembly;

package/lib/auth.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccessToken = void 0;
+const cachePlugin_1 = require("./cachePlugin");
+const msal_node_1 = require("@azure/msal-node");
+const logger_1 = require("./logger");
+const clientId = '51f81489-12ee-4a9e-aaae-a2591f45987d';
+const getAccessToken = async (tenant, url) => {
+    const config = {
+        auth: {
+            clientId: clientId,
+            authority: `https://login.microsoftonline.com/${tenant}/`
+        },
+        cache: {
+            cachePlugin: (0, cachePlugin_1.cachePlugin)(url)
+        }
+    };
+    const pca = new msal_node_1.PublicClientApplication(config);
+    const cache = pca.getTokenCache();
+    const accounts = await cache?.getAllAccounts().catch(ex => {
+        throw new Error(ex.message);
+    });
+    // Try to get token silently
+    if (accounts.length > 0) {
+        const silentToken = await pca.acquireTokenSilent({
+            account: accounts[0],
+            scopes: [`${url}/.default`]
+        }).catch(ex => {
+            throw new Error(ex.message);
+        });
+        if (silentToken) {
+            return silentToken;
+        }
+    }
+    // Acquire token by device code
+    const token = await pca.acquireTokenByDeviceCode({
+        scopes: [`${url}/.default`],
+        deviceCodeCallback: (response) => logger_1.logger.info(response.message)
+    }).catch(ex => {
+        throw new Error(ex.message);
+    });
+    return token;
+};
+exports.getAccessToken = getAccessToken;

package/lib/cachePlugin.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachePlugin = exports.deleteCache = exports.cacheExists = exports.getCachePath = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const cryptr_1 = __importDefault(require("cryptr"));
+const encrypt = (text) => {
+    const user = os_1.default.userInfo().username;
+    const cryptr = new cryptr_1.default(user);
+    const encrypted = cryptr.encrypt(text);
+    return encrypted;
+};
+const decrypt = (text) => {
+    const user = os_1.default.userInfo().username;
+    const cryptr = new cryptr_1.default(user);
+    const decrypted = cryptr.decrypt(text);
+    return decrypted;
+};
+const getCachePath = (url) => {
+    const org = url.replace('https://', '').split('.')[0];
+    if (!fs_1.default.existsSync(path_1.default.join(os_1.default.homedir(), './.dataverse-utils/'))) {
+        fs_1.default.mkdirSync(path_1.default.join(os_1.default.homedir(), './.dataverse-utils/'));
+    }
+    return path_1.default.join(os_1.default.homedir(), `./.dataverse-utils/${org}.json`);
+};
+exports.getCachePath = getCachePath;
+const cacheExists = (url) => {
+    const cacheLocation = (0, exports.getCachePath)(url);
+    return fs_1.default.existsSync(cacheLocation);
+};
+exports.cacheExists = cacheExists;
+const deleteCache = (url) => {
+    const cacheLocation = (0, exports.getCachePath)(url);
+    if (fs_1.default.existsSync(cacheLocation)) {
+        fs_1.default.unlinkSync(cacheLocation);
+        return true;
+    }
+    else {
+        return false;
+    }
+};
+exports.deleteCache = deleteCache;
+const cachePlugin = (url) => {
+    const cacheLocation = (0, exports.getCachePath)(url);
+    const beforeCacheAccess = (tokenCacheContext) => {
+        return new Promise((resolve, reject) => {
+            if (fs_1.default.existsSync(cacheLocation)) {
+                fs_1.default.readFile(cacheLocation, 'utf-8', (err, data) => {
+                    if (err) {
+                        reject();
+                    }
+                    else {
+                        const decrypted = decrypt(data);
+                        tokenCacheContext.tokenCache.deserialize(decrypted);
+                        resolve();
+                    }
+                });
+            }
+            else {
+                const encrypted = encrypt(tokenCacheContext.tokenCache.serialize());
+                fs_1.default.writeFile(cacheLocation, encrypted, (err) => {
+                    if (err) {
+                        reject();
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+        });
+    };
+    const afterCacheAccess = (tokenCacheContext) => {
+        return new Promise((resolve, reject) => {
+            if (tokenCacheContext.cacheHasChanged) {
+                const encrypted = encrypt(tokenCacheContext.tokenCache.serialize());
+                fs_1.default.writeFile(cacheLocation, encrypted, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    };
+    return {
+        beforeCacheAccess,
+        afterCacheAccess
+    };
+};
+exports.cachePlugin = cachePlugin;

package/lib/dataverse.service.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableMetadata = exports.publish = exports.addToSolution = exports.ComponentType = void 0;
+const node_1 = require("dataverse-webapi/lib/node");
+var ComponentType;
+(function (ComponentType) {
+    ComponentType[ComponentType["WebResource"] = 61] = "WebResource";
+    ComponentType[ComponentType["PluginType"] = 90] = "PluginType";
+    ComponentType[ComponentType["PluginAssembly"] = 91] = "PluginAssembly";
+    ComponentType[ComponentType["SDKMessageProcessingStep"] = 92] = "SDKMessageProcessingStep";
+    ComponentType[ComponentType["SDKMessageProcessingStepImage"] = 93] = "SDKMessageProcessingStepImage";
+})(ComponentType = exports.ComponentType || (exports.ComponentType = {}));
+async function addToSolution(id, solution, type, apiConfig) {
+    const data = {
+        ComponentId: id,
+        ComponentType: type,
+        SolutionUniqueName: solution,
+        AddRequiredComponents: false,
+        IncludedComponentSettingsValues: null
+    };
+    await (0, node_1.unboundAction)(apiConfig, 'AddSolutionComponent', data);
+}
+exports.addToSolution = addToSolution;
+async function publish(publishXml, apiConfig) {
+    const data = {
+        ParameterXml: `<importexportxml><webresources>${publishXml}</webresources></importexportxml>`
+    };
+    await (0, node_1.unboundAction)(apiConfig, 'PublishXml', data);
+}
+exports.publish = publish;
+async function getTableMetadata(table, apiConfig) {
+    const options = [
+        '?$select=DisplayName,LogicalName,EntitySetName,SchemaName',
+        '&$expand=Attributes($select=LogicalName,SchemaName)'
+    ].join('');
+    const metadata = await (0, node_1.retrieveMultiple)(apiConfig, `EntityDefinitions(LogicalName='${table}')`, options);
+    if (metadata == null) {
+        throw Error(`Table ${table} not found in metadata cache`);
+    }
+    const choiceOptions = [
+        '?$select=attributevalue,value,attributename',
+        `&$filter=objecttypecode eq '${table}'`
+    ].join('');
+    const choiceMetadata = await (0, node_1.retrieveMultiple)(apiConfig, 'stringmaps', choiceOptions);
+    const tableMetadata = {
+        logicalName: metadata.LogicalName,
+        schemaName: metadata.SchemaName,
+        entitySetName: metadata.EntitySetName,
+        choices: [],
+        fields: metadata.Attributes.map((a) => {
+            return {
+                logicalName: a.LogicalName,
+                schemaName: a.SchemaName
+            };
+        })
+    };
+    choiceMetadata.value.forEach((c) => {
+        const index = tableMetadata.choices.findIndex(x => x.column === c.attributename);
+        if (index === -1) {
+            tableMetadata.choices.push({ column: c.attributename, options: [{ text: c.value, value: c.attributevalue }] });
+        }
+        else {
+            tableMetadata.choices[index].options.push({ text: c.value, value: c.attributevalue });
+        }
+    });
+    return tableMetadata;
+}
+exports.getTableMetadata = getTableMetadata;

package/lib/deploy.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const assemblyDeploy_1 = require("./assemblyDeploy");
+const webResourceDeploy_1 = require("./webResourceDeploy");
+const node_1 = require("dataverse-webapi/lib/node");
+const auth_1 = require("./auth");
+const cachePlugin_1 = require("./cachePlugin");
+const onTokenFailure = async (url, error) => {
+    if (error) {
+        logger_1.logger.error(`failed to acquire access token: ${error}`);
+    }
+    else {
+        logger_1.logger.error('failed to acquire access token');
+    }
+    if ((0, cachePlugin_1.cacheExists)(url)) {
+        const { deleteToken } = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'deleteToken',
+            message: `delete current token cache for ${url}?`
+        });
+        if (deleteToken) {
+            (0, cachePlugin_1.deleteCache)(url);
+        }
+    }
+};
+async function deploy(type, files) {
+    if (!type || (type !== 'webresource' && type !== 'assembly')) {
+        const invalid = type !== undefined && type !== 'webresource' && type !== 'assembly';
+        const invalidMessage = invalid ? `${type} is not a valid project type.` : '';
+        const { typePrompt } = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'typePrompt',
+            message: `${invalidMessage} select project type to deploy`,
+            choices: [
+                { title: 'web resource', value: 'webresource' },
+                { title: 'plugin or workflow activity', value: 'assembly' }
+            ]
+        });
+        type = typePrompt;
+    }
+    const currentPath = '.';
+    const credsFile = await fs_1.default.promises.readFile(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    if (credsFile == null) {
+        logger_1.logger.warn('unable to find dataverse.config.json file');
+        return;
+    }
+    const creds = JSON.parse(credsFile).connection;
+    let token = null;
+    try {
+        token = await (0, auth_1.getAccessToken)(creds.tenant, creds.server);
+    }
+    catch (error) {
+        onTokenFailure(creds.server, error.message);
+        return;
+    }
+    if (token == null || token.accessToken == null) {
+        onTokenFailure(creds.server);
+        return;
+    }
+    const apiConfig = new node_1.WebApiConfig('8.2', token.accessToken, creds.server);
+    switch (type) {
+        case 'webresource':
+            await (0, webResourceDeploy_1.deployWebResource)(creds, apiConfig, files);
+            break;
+        case 'assembly':
+            await (0, assemblyDeploy_1.deployAssembly)(creds, apiConfig);
+            break;
+        default:
+            break;
+    }
+}
+exports.default = deploy;

package/lib/generate.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const dataverse_service_1 = require("./dataverse.service");
+const node_1 = require("dataverse-webapi/lib/node");
+const auth_1 = require("./auth");
+async function generate(table) {
+    while (!table) {
+        const { tablePrompt } = await (0, prompts_1.default)({
+            type: 'text',
+            name: 'tablePrompt',
+            message: `enter table to generate`
+        });
+        table = tablePrompt;
+    }
+    const currentPath = '.';
+    const credsFile = await fs_1.default.promises.readFile(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    if (credsFile == null) {
+        logger_1.logger.warn('unable to find dataverse.config.json file');
+        return;
+    }
+    const creds = JSON.parse(credsFile).connection;
+    let token = null;
+    try {
+        token = await (0, auth_1.getAccessToken)(creds.tenant, creds.server);
+    }
+    catch (error) {
+        logger_1.logger.error(`failed to acquire access token: ${error.message}`);
+        return;
+    }
+    if (token == null || token.accessToken == null) {
+        logger_1.logger.error('failed to acquire access token');
+        return;
+    }
+    const apiConfig = new node_1.WebApiConfig('8.2', token.accessToken, creds.server);
+    let metadata = {};
+    logger_1.logger.info('Retrieve table metadata');
+    try {
+        metadata = await (0, dataverse_service_1.getTableMetadata)(table, apiConfig);
+    }
+    catch (error) {
+        logger_1.logger.error(error.message);
+        return;
+    }
+    // Build code file from metadata
+    const codeFile = [
+        `class ${metadata.schemaName} {`,
+        '\r\n',
+        `  LogicalName = '${metadata.logicalName}';`,
+        '\r\n',
+        `  SchemaName = '${metadata.schemaName}';`,
+        '\r\n',
+        `  EntitySetName = '${metadata.entitySetName}';`,
+        '\r\n',
+        '\r\n',
+        '  Fields = {',
+        '\r\n',
+        metadata.fields.map(f => {
+            return `    '${f.schemaName}': '${f.logicalName}'`;
+        }).join(',\r\n'),
+        '\r\n',
+        '  }',
+        '\r\n',
+        '\r\n',
+        metadata.choices.map(c => {
+            const field = metadata.fields.find(f => f.logicalName === c.column);
+            return `  ${field?.schemaName ?? c.column} = ${metadata.schemaName}_${field?.schemaName ?? c.column};`;
+        }).join('\r\n'),
+        '\r\n',
+        '}',
+        '\r\n',
+        '\r\n',
+        metadata.choices.map(c => {
+            const field = metadata.fields.find(f => f.logicalName === c.column);
+            return [
+                `export enum ${metadata.schemaName}_${field?.schemaName ?? c.column} {`,
+                '\r\n',
+                c.options.map(x => `  '${x.text.replace(`'`, `\\'`)}' = ${x.value}`).join(',\r\n'),
+                '\r\n',
+                '}'
+            ].join('');
+        }).join('\r\n\r\n'),
+        '\r\n',
+        '\r\n',
+        `export default new ${metadata.schemaName}();`
+    ].join('');
+    if (!fs_1.default.existsSync(path_1.default.resolve(currentPath, 'src', 'scripts', 'models'))) {
+        fs_1.default.mkdirSync(path_1.default.resolve(currentPath, 'src', 'scripts', 'models'));
+    }
+    fs_1.default.writeFileSync(path_1.default.resolve(currentPath, 'src', 'scripts', 'models', `${metadata.schemaName}.ts`), codeFile);
+    logger_1.logger.done(`Table metadata output to models/${metadata.schemaName}.ts`);
+}
+exports.default = generate;

package/lib/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const deploy_1 = __importDefault(require("./deploy"));
+const generate_1 = __importDefault(require("./generate"));
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const packageJson = require('../package.json');
+commander_1.program
+    .version(packageJson.version)
+    .usage('<command> [options]');
+// Deploy command
+commander_1.program
+    .command('deploy')
+    .description('Deploy file(s) to dataverse (webresource, plugin, workflow)')
+    .argument('[type]', 'Type of project to deploy')
+    .argument('[files]', 'Comma separate list of files to deploy')
+    .action((type, files) => {
+    (0, deploy_1.default)(type, files);
+});
+// Generate command
+commander_1.program
+    .command('generate')
+    .description('Generate early-bound TypeScript file for specified table')
+    .argument('[table]', 'Table to generate')
+    .action((table) => {
+    (0, generate_1.default)(table);
+});
+// Show help on unknown command
+commander_1.program
+    .arguments('<command>')
+    .action((cmd) => {
+    commander_1.program.outputHelp();
+    console.log();
+    console.log(`Unknown command ${cmd}.`);
+    console.log();
+});
+commander_1.program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    commander_1.program.outputHelp();
+}

package/lib/logger.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.icons = void 0;
+const kleur_1 = __importDefault(require("kleur"));
+const figures_1 = __importDefault(require("figures"));
+const isTest = process.env.JEST_WORKER_ID !== undefined;
+exports.icons = {
+    done: kleur_1.default.green(figures_1.default.tick),
+    info: kleur_1.default.cyan(figures_1.default.pointer),
+    error: kleur_1.default.red(figures_1.default.cross),
+    warn: kleur_1.default.yellow(figures_1.default.warning)
+};
+exports.logger = {
+    info(...args) {
+        if (!isTest) {
+            console.info(exports.icons.info, ...args);
+        }
+    },
+    warn(...args) {
+        if (!isTest) {
+            console.warn(exports.icons.warn, ...args);
+        }
+    },
+    error(...args) {
+        if (!isTest) {
+            console.error(exports.icons.error, ...args);
+        }
+    },
+    done(...args) {
+        if (!isTest) {
+            console.info(exports.icons.done, ...args);
+        }
+    },
+};

package/lib/models/pluginAssembly.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = void 0;
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = __importDefault(require("glob"));
+const node_1 = require("dataverse-webapi/lib/node");
+const pluginType_1 = require("./pluginType");
+const dataverse_service_1 = require("../dataverse.service");
+const logger_1 = require("../logger");
+async function deploy(config, apiConfig, solution) {
+    const files = glob_1.default.sync(`**/${config.name}.dll`);
+    if (files.length === 0) {
+        logger_1.logger.warn(`assembly ${config.name}.dll not found`);
+        return;
+    }
+    const content = (await fs_1.default.promises.readFile(files[0])).toString('base64');
+    let assemblyId = '';
+    try {
+        assemblyId = await retrieveAssembly(config.name, apiConfig);
+    }
+    catch (error) {
+        logger_1.logger.error(`failed to retrieve assembly ${config.name}: ${error.message}`);
+        return;
+    }
+    if (assemblyId != '') {
+        try {
+            await updateAssembly(assemblyId, config, content, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update assembly: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            assemblyId = await createAssembly(config, content, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to create assembly: ${error.message}`);
+        }
+        if (solution != undefined) {
+            try {
+                await (0, dataverse_service_1.addToSolution)(assemblyId, solution, dataverse_service_1.ComponentType.PluginAssembly, apiConfig);
+            }
+            catch (error) {
+                logger_1.logger.error(`failed to add to solution: ${error.message}`);
+            }
+        }
+    }
+    if (config.types != null) {
+        try {
+            const promises = config.types.map(async (type) => {
+                type['pluginassemblyid@odata.bind'] = `/pluginassemblies(${assemblyId})`;
+                await (0, pluginType_1.deployType)(type, assemblyId, apiConfig, solution);
+            });
+            await Promise.all(promises);
+        }
+        catch (error) {
+            logger_1.logger.error(error.message);
+            return;
+        }
+    }
+}
+exports.deploy = deploy;
+async function retrieveAssembly(name, apiConfig) {
+    const options = `$select=pluginassemblyid&$filter=name eq '${name}'`;
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'pluginassemblies', options);
+    return result.value.length > 0 ? result.value[0].pluginassemblyid : '';
+}
+async function createAssembly(config, content, apiConfig) {
+    logger_1.logger.info(`create assembly ${config.name}`);
+    const assembly = {
+        name: config.name,
+        content: content,
+        isolationmode: config.isolationmode,
+        version: config.version,
+        publickeytoken: config.name,
+        sourcetype: 0,
+        culture: ''
+    };
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'pluginassemblies', assembly, '$select=pluginassemblyid');
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+    return result.pluginassemblyid;
+}
+async function updateAssembly(id, config, content, apiConfig) {
+    logger_1.logger.info(`update assembly ${config.name}`);
+    const assembly = {
+        content: content,
+        version: config.version
+    };
+    return (0, node_1.update)(apiConfig, 'pluginassemblies', id, assembly);
+}

package/lib/models/pluginImage.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployImage = void 0;
+const logger_1 = require("../logger");
+const node_1 = require("dataverse-webapi/lib/node");
+async function deployImage(stepId, image, message, apiConfig) {
+    image['sdkmessageprocessingstepid@odata.bind'] = `/sdkmessageprocessingsteps(${stepId})`;
+    switch (message) {
+        case 'Create':
+            image.messagepropertyname = 'Id';
+            break;
+        case 'SetState':
+        case 'SetStateDynamicEntity':
+            image.messagepropertyname = 'EntityMoniker';
+            break;
+        case 'Send':
+        case 'DeliverIncoming':
+        case 'DeliverPromote':
+            image.messagepropertyname = 'EmailId';
+            break;
+        default:
+            image.messagepropertyname = 'Target';
+            break;
+    }
+    let imageId = await retrieveImage(stepId, image, apiConfig);
+    if (imageId != '') {
+        try {
+            await updateImage(imageId, image, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update plugin image: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            imageId = await createImage(image, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to create plugin image: ${error.message}`);
+        }
+    }
+    return imageId;
+}
+exports.deployImage = deployImage;
+async function retrieveImage(stepId, image, apiConfig) {
+    const options = `$select=sdkmessageprocessingstepimageid&$filter=name eq '${image.name}' and _sdkmessageprocessingstepid_value eq ${stepId}`;
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessageprocessingstepimages', options);
+    return result.value.length > 0 ? result.value[0].sdkmessageprocessingstepimageid : '';
+}
+async function createImage(image, apiConfig) {
+    logger_1.logger.info(`create plugin image ${image.name}`);
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'sdkmessageprocessingstepimages', image, '$select=sdkmessageprocessingstepimageid');
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+    return result.sdkmessageprocessingstepimageid;
+}
+async function updateImage(id, image, apiConfig) {
+    logger_1.logger.info(`update plugin image ${image.name}`);
+    return (0, node_1.update)(apiConfig, 'sdkmessageprocessingstepimages', id, image);
+}

package/lib/models/pluginStep.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployStep = void 0;
+const node_1 = require("dataverse-webapi/lib/node");
+const dataverse_service_1 = require("../dataverse.service");
+const logger_1 = require("../logger");
+const pluginImage_1 = require("./pluginImage");
+async function deployStep(step, typeId, apiConfig, solution) {
+    let stepId = await retrieveStep(step.name, typeId, apiConfig);
+    const messageId = await getSdkMessageId(step.message ?? '', apiConfig);
+    if (messageId == '') {
+        logger_1.logger.warn(`sdk message ${step.message} not found`);
+        return;
+    }
+    const filterId = await getSdkMessageFilterId(messageId, step.entity ?? '', apiConfig);
+    if (filterId == '') {
+        logger_1.logger.warn(`sdk message ${step.message} for entity ${step.entity} not found`);
+        return;
+    }
+    step['sdkmessagefilterid@odata.bind'] = `/sdkmessagefilters(${filterId})`;
+    step['sdkmessageid@odata.bind'] = `/sdkmessages(${messageId})`;
+    if (step.mode === 1) {
+        step.asyncautodelete = true;
+    }
+    const images = step.images;
+    const message = step.message;
+    delete step.images;
+    delete step.message;
+    delete step.entity;
+    if (stepId != '') {
+        try {
+            await updateStep(stepId, step, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update plugin step: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            stepId = await createStep(step, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to create plugin step: ${error.message}`);
+        }
+        if (solution != undefined) {
+            try {
+                await (0, dataverse_service_1.addToSolution)(stepId, solution, dataverse_service_1.ComponentType.SDKMessageProcessingStep, apiConfig);
+            }
+            catch (error) {
+                throw new Error(`failed to add to solution: ${error.message}`);
+            }
+        }
+    }
+    if (images && images.length > 0) {
+        try {
+            const promises = images.map(image => (0, pluginImage_1.deployImage)(stepId, image, message, apiConfig));
+            await Promise.all(promises);
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+    return stepId;
+}
+exports.deployStep = deployStep;
+async function retrieveStep(name, typeId, apiConfig) {
+    const options = `$select=sdkmessageprocessingstepid&$filter=name eq '${name}' and _plugintypeid_value eq ${typeId}`;
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessageprocessingsteps', options);
+    return result.value.length > 0 ? result.value[0].sdkmessageprocessingstepid : '';
+}
+async function getSdkMessageFilterId(messageId, entityName, apiConfig) {
+    const options = [
+        `?$filter=primaryobjecttypecode eq '${entityName}' and _sdkmessageid_value eq ${messageId}`,
+        '&$select=sdkmessagefilterid'
+    ].join('');
+    const message = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessagefilters', options);
+    return message.value.length > 0 ? message.value[0].sdkmessagefilterid : '';
+}
+async function getSdkMessageId(name, apiConfig) {
+    const options = [
+        `?$filter=name eq '${name}'`,
+        '&$select=sdkmessageid'
+    ].join('');
+    const message = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessages', options);
+    return message.value.length > 0 ? message.value[0].sdkmessageid : '';
+}
+async function createStep(step, apiConfig) {
+    logger_1.logger.info(`create plugin step ${step.name}`);
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'sdkmessageprocessingsteps', step, '$select=sdkmessageprocessingstepid');
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+    return result.sdkmessageprocessingstepid;
+}
+async function updateStep(id, step, apiConfig) {
+    logger_1.logger.info(`update plugin step ${step.name}`);
+    return (0, node_1.update)(apiConfig, 'sdkmessageprocessingsteps', id, step);
+}

package/lib/models/pluginType.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployType = void 0;
+const node_1 = require("dataverse-webapi/lib/node");
+const pluginStep_1 = require("./pluginStep");
+const logger_1 = require("../logger");
+async function deployType(type, assemblyId, apiConfig, solution) {
+    let typeId = await retrieveType(type.typename, assemblyId, apiConfig);
+    const record = {
+        name: type.name,
+        friendlyname: type.friendlyname,
+        typename: type.typename,
+        'pluginassemblyid@odata.bind': type['pluginassemblyid@odata.bind'],
+        workflowactivitygroupname: type.workflowactivitygroupname
+    };
+    if (typeId != '') {
+        try {
+            await updateType(typeId, record, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update plugin type: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            typeId = await createType(record, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to create plugin type: ${error.message}`);
+        }
+    }
+    try {
+        if (type.steps) {
+            const promises = type.steps.map(async (step) => {
+                step['plugintypeid@odata.bind'] = `/plugintypes(${typeId})`;
+                await (0, pluginStep_1.deployStep)(step, typeId, apiConfig, solution);
+            });
+            await Promise.all(promises);
+        }
+    }
+    catch (error) {
+        throw new Error(error.message);
+    }
+    return typeId;
+}
+exports.deployType = deployType;
+async function retrieveType(name, assemblyId, apiConfig) {
+    const options = `$select=plugintypeid&$filter=typename eq '${name}' and _pluginassemblyid_value eq ${assemblyId}`;
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'plugintypes', options);
+    return result.value.length > 0 ? result.value[0].plugintypeid : '';
+}
+async function createType(type, apiConfig) {
+    logger_1.logger.info(`create assembly type ${type.name}`);
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'plugintypes', type, '$select=plugintypeid');
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+    return result.plugintypeid;
+}
+async function updateType(id, type, apiConfig) {
+    logger_1.logger.info(`update assembly type ${type.name}`);
+    return (0, node_1.update)(apiConfig, 'plugintypes', id, type);
+}

package/lib/models/webResource.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = void 0;
+const dataverse_service_1 = require("../dataverse.service");
+const node_1 = require("dataverse-webapi/lib/node");
+const logger_1 = require("../logger");
+const fs_1 = __importDefault(require("fs"));
+function getWebResourceType(type) {
+    switch (type) {
+        case 'HTML':
+            return 1;
+        case 'CSS':
+            return 2;
+        case 'JavaScript':
+            return 3;
+        case 'XML':
+            return 4;
+        case 'PNG':
+            return 5;
+        case 'JPG':
+            return 6;
+        case 'GIF':
+            return 7;
+        case 'XAP':
+            return 8;
+        case 'XSL':
+            return 9;
+        case 'ICO':
+            return 10;
+        case 'SVG':
+            return 11;
+        case 'RESX':
+            return 12;
+        default:
+            return 0;
+    }
+}
+async function deploy(webResources, apiConfig, solution, files) {
+    const publishXml = [];
+    let resources = webResources;
+    // Use list of files if provided
+    if (files) {
+        resources = [];
+        for (const file of files.split(',')) {
+            const resource = webResources.filter(r => r.path?.endsWith(file));
+            if (resource.length === 0) {
+                logger_1.logger.warn(`web resource ${file} not found in dataverse.config.json`);
+                continue;
+            }
+            resources.push(resource[0]);
+        }
+    }
+    const promises = resources.map(async (resource) => {
+        let resourceId = '';
+        try {
+            resourceId = await retrieveResource(resource.name, apiConfig);
+        }
+        catch (error) {
+            logger_1.logger.error(`failed to retrieve resource ${resource.name}: ${error.message}`);
+            return;
+        }
+        const fileContent = await fs_1.default.promises.readFile(resource.path, 'utf8');
+        const content = Buffer.from(fileContent).toString('base64');
+        if (resourceId != '') {
+            try {
+                const updated = await updateResource(resourceId, resource, content, apiConfig);
+                publishXml.push(updated);
+            }
+            catch (error) {
+                logger_1.logger.error(`failed to update resource: ${error.message}`);
+            }
+        }
+        else {
+            try {
+                resourceId = await createResource(resource, content, apiConfig);
+            }
+            catch (error) {
+                logger_1.logger.error(`failed to create resource: ${error.message}`);
+            }
+            if (solution != undefined) {
+                try {
+                    await (0, dataverse_service_1.addToSolution)(resourceId, solution, dataverse_service_1.ComponentType.WebResource, apiConfig);
+                }
+                catch (error) {
+                    logger_1.logger.error(`failed to add to solution: ${error.message}`);
+                }
+            }
+        }
+    });
+    await Promise.all(promises);
+    // publish resources
+    if (publishXml.length > 0) {
+        try {
+            await (0, dataverse_service_1.publish)(publishXml.join(''), apiConfig);
+        }
+        catch (error) {
+            logger_1.logger.error(error.message);
+        }
+    }
+}
+exports.deploy = deploy;
+async function retrieveResource(name, apiConfig) {
+    const options = `$select=webresourceid&$filter=name eq '${name}'`;
+    const result = await (0, node_1.retrieveMultiple)(apiConfig, 'webresourceset', options);
+    return result.value.length > 0 ? result.value[0].webresourceid : '';
+}
+async function createResource(resource, content, apiConfig) {
+    logger_1.logger.info(`create web resource ${resource.name}`);
+    const webResource = {
+        webresourcetype: getWebResourceType(resource.type),
+        name: resource.name,
+        displayname: resource.displayname || resource.name,
+        content: content
+    };
+    const result = await (0, node_1.createWithReturnData)(apiConfig, 'webresourceset', webResource, '$select=webresourceid');
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+    return result.webresourceid;
+}
+async function updateResource(id, resource, content, apiConfig) {
+    logger_1.logger.info(`update web resource ${resource.name}`);
+    const webResource = {
+        content: content
+    };
+    await (0, node_1.update)(apiConfig, 'webresourceset', id, webResource);
+    return `<webresource>{${id}}</webresource>`;
+}

package/lib/webResourceDeploy.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployWebResource = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const logger_1 = require("./logger");
+const webResource_1 = require("./models/webResource");
+async function deployWebResource(creds, apiConfig, files) {
+    const currentPath = '.';
+    const configFile = await fs_1.default.promises.readFile(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    if (configFile == null) {
+        logger_1.logger.warn('unable to find dataverse.config.json file');
+        return;
+    }
+    const config = JSON.parse(configFile).webResources;
+    logger_1.logger.info('deploy web resources');
+    try {
+        await (0, webResource_1.deploy)(config, apiConfig, creds.solution, files);
+    }
+    catch (error) {
+        logger_1.logger.error(error.message);
+        return;
+    }
+    logger_1.logger.done('deployed web resources');
+}
+exports.deployWebResource = deployWebResource;

package/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Derek Finlinson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataverse-utils",
-  "version": "2.2.10",
+  "version": "2.2.13",
   "license": "MIT",
   "description": "Utilities for interacting with Dataverse environments",
   "main": "lib/index.js",
@@ -20,14 +20,14 @@
     "clean": "rimraf lib"
   },
   "dependencies": {
-    "@azure/msal-node": "^1.3.1",
+    "@azure/msal-node": "^1.12.0",
     "commander": "^8.3.0",
-    "cryptr": "^6.0.2",
-    "dataverse-webapi": "^2.0.8",
+    "cryptr": "^6.0.3",
+    "dataverse-webapi": "^2.1.0",
     "envinfo": "^7.8.1",
     "figures": "^3.2.0",
     "glob": "^7.2.0",
-    "kleur": "^4.1.4",
+    "kleur": "^4.1.5",
     "prompts": "^2.4.2"
   },
   "devDependencies": {