dataverse-utils 5.0.2 → 5.0.3

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,50 @@
+import fs from 'fs';
+import path from 'path';
+import { deployAssembly } from './models/pluginAssembly.js';
+import { deployPluginPackage } from './models/pluginPackage.js';
+import { deployApi } from './models/customApi.js';
+import { logger } from './logger.js';
+export async function assemblyDeploy(creds, apiConfig) {
+    const currentPath = '.';
+    const configFile = await fs.promises.readFile(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    if (configFile == null) {
+        logger.warn('unable to find dataverse.config.json file');
+        return;
+    }
+    const config = JSON.parse(configFile);
+    if (config.assembly) {
+        logger.info('deploy plugin package');
+        try {
+            await deployPluginPackage(config, apiConfig, creds.solution);
+        }
+        catch (error) {
+            logger.error(error.message);
+            return;
+        }
+        logger.done(`deployed plugin package ${config.prefix}_${config.name}\r\n`);
+    }
+    else {
+        logger.info(`deploy assembly to ${creds.server}`);
+        try {
+            await deployAssembly(config, apiConfig, creds.solution);
+        }
+        catch (error) {
+            logger.error(error.message);
+            return;
+        }
+        logger.done(`deployed assembly ${config.name}`);
+    }
+    if (config.customapis?.length > 0 && (config.pluginassemblyid || config.assembly?.pluginassemblyid)) {
+        logger.info('deploy custom api');
+        const assemblyId = config.pluginassemblyid ?? config.assembly.pluginassemblyid;
+        try {
+            const promises = config.customapis.map((a) => deployApi(a, assemblyId, apiConfig, creds.solution));
+            await Promise.all(promises);
+        }
+        catch (error) {
+            logger.error(error.message);
+        }
+        logger.done('deployed custom api');
+    }
+    await fs.promises.writeFile(path.resolve(currentPath, 'dataverse.config.json'), JSON.stringify(config, null, 4), 'utf8');
+}

package/lib/auth.js

@@ -0,0 +1,67 @@
+import prompts from 'prompts';
+import { cacheExists, cachePlugin, deleteCache } from './cachePlugin.js';
+import { PublicClientApplication } from '@azure/msal-node';
+import { logger } from './logger.js';
+const clientId = '51f81489-12ee-4a9e-aaae-a2591f45987d';
+export const onTokenFailure = async (url, error) => {
+    if (error) {
+        logger.error(`failed to acquire access token: ${error}`);
+    }
+    else {
+        logger.error('failed to acquire access token');
+    }
+    if (cacheExists(url)) {
+        const { deleteToken } = await prompts({
+            type: 'confirm',
+            name: 'deleteToken',
+            message: `delete current token cache for ${url}?`
+        });
+        if (deleteToken) {
+            deleteCache(url);
+        }
+    }
+};
+export const getAccessToken = async (authEndpoint, url) => {
+    const config = {
+        auth: {
+            clientId: clientId,
+            authority: authEndpoint
+        },
+        cache: {
+            cachePlugin: cachePlugin(url)
+        }
+    };
+    const pca = new 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) {
+        try {
+            const silentToken = await pca.acquireTokenSilent({
+                account: accounts[0],
+                scopes: [`${url}/.default`]
+            });
+            if (silentToken) {
+                return silentToken;
+            }
+        }
+        catch (ex) {
+            if (ex.message.indexOf('The refresh token has expired due to inactivity') === -1) {
+                throw new Error(ex.message);
+            }
+        }
+    }
+    // Acquire token by device code
+    try {
+        const token = await pca.acquireTokenByDeviceCode({
+            scopes: [`${url}/.default`],
+            deviceCodeCallback: (response) => logger.info(response.message)
+        });
+        return token;
+    }
+    catch (ex) {
+        throw new Error(ex.message);
+    }
+};

package/lib/cachePlugin.js

@@ -0,0 +1,97 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import Cryptr from 'cryptr';
+const encrypt = (text) => {
+    const user = os.userInfo().username;
+    const cryptr = new Cryptr(user);
+    const encrypted = cryptr.encrypt(text);
+    return encrypted;
+};
+const decrypt = (text) => {
+    const user = os.userInfo().username;
+    const cryptr = new Cryptr(user);
+    const decrypted = cryptr.decrypt(text);
+    return decrypted;
+};
+export const getCachePath = (url) => {
+    const org = new URL(url).hostname.split('.')[0];
+    if (!fs.existsSync(path.join(os.homedir(), './.dataverse-utils/'))) {
+        fs.mkdirSync(path.join(os.homedir(), './.dataverse-utils/'));
+    }
+    return path.join(os.homedir(), `./.dataverse-utils/${org}.json`);
+};
+export const cacheExists = (url) => {
+    const cacheLocation = getCachePath(url);
+    return fs.existsSync(cacheLocation);
+};
+export const deleteCache = (url) => {
+    const cacheLocation = getCachePath(url);
+    if (fs.existsSync(cacheLocation)) {
+        fs.unlinkSync(cacheLocation);
+        return true;
+    }
+    else {
+        return false;
+    }
+};
+export const cachePlugin = (url) => {
+    const cacheLocation = getCachePath(url);
+    const beforeCacheAccess = (tokenCacheContext) => {
+        return new Promise((resolve, reject) => {
+            if (fs.existsSync(cacheLocation)) {
+                fs.readFile(cacheLocation, 'utf-8', (err, data) => {
+                    if (err) {
+                        reject();
+                    }
+                    else {
+                        try {
+                            const decrypted = decrypt(data);
+                            tokenCacheContext.tokenCache.deserialize(decrypted);
+                            resolve();
+                        }
+                        catch (ex) {
+                            reject(ex);
+                        }
+                    }
+                });
+            }
+            else {
+                try {
+                    const encrypted = encrypt(tokenCacheContext.tokenCache.serialize());
+                    fs.writeFile(cacheLocation, encrypted, (err) => {
+                        if (err) {
+                            reject();
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                }
+                catch (ex) {
+                    reject(ex);
+                }
+            }
+        });
+    };
+    const afterCacheAccess = (tokenCacheContext) => {
+        return new Promise((resolve, reject) => {
+            if (tokenCacheContext.cacheHasChanged) {
+                const encrypted = encrypt(tokenCacheContext.tokenCache.serialize());
+                fs.writeFile(cacheLocation, encrypted, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    };
+    return {
+        beforeCacheAccess,
+        afterCacheAccess
+    };
+};

package/lib/dataverse.service.js

@@ -0,0 +1,65 @@
+import { retrieveMultiple, unboundAction } from 'dataverse-webapi/lib/node';
+import { logger } from './logger.js';
+export 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[ComponentType["PluginPackage"] = 10865] = "PluginPackage";
+})(ComponentType || (ComponentType = {}));
+export async function addToSolution(id, solution, type, apiConfig) {
+    const data = {
+        ComponentId: id,
+        ComponentType: type,
+        SolutionUniqueName: solution,
+        AddRequiredComponents: false,
+        IncludedComponentSettingsValues: null
+    };
+    logger.info(`add component ${id} to solution ${solution}`);
+    await unboundAction(apiConfig, 'AddSolutionComponent', data);
+}
+export async function publish(publishXml, apiConfig) {
+    const data = {
+        ParameterXml: `<importexportxml><webresources>${publishXml}</webresources></importexportxml>`
+    };
+    await unboundAction(apiConfig, 'PublishXml', data);
+}
+export async function getTableMetadata(table, apiConfig) {
+    const options = [
+        '?$select=DisplayName,LogicalName,EntitySetName,SchemaName',
+        '&$expand=Attributes($select=LogicalName,SchemaName)'
+    ].join('');
+    const metadata = await 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 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;
+}

package/lib/deploy.js

@@ -0,0 +1,68 @@
+import prompts from 'prompts';
+import fs from 'fs';
+import path from 'path';
+import { logger } from './logger.js';
+import { assemblyDeploy } from './assemblyDeploy.js';
+import { webResourceDeploy } from './webResourceDeploy.js';
+import { WebApiConfig } from 'dataverse-webapi/lib/node';
+import { getAccessToken, onTokenFailure } from './auth.js';
+export default async function deploy(type, files) {
+    if (!type || (type !== 'webresource' && type !== 'assembly' && type !== 'pcf')) {
+        const invalid = type !== undefined && type !== 'webresource' && type !== 'assembly' && type !== 'pcf';
+        const invalidMessage = invalid ? `${type} is not a valid project type. ` : '';
+        const { typePrompt } = await prompts({
+            type: 'select',
+            name: 'typePrompt',
+            message: `${invalidMessage}select project type to deploy`,
+            choices: [
+                { title: 'web resource', value: 'webresource' },
+                { title: 'pcf', value: 'webresource' },
+                { title: 'plugin or workflow activity', value: 'assembly' }
+            ]
+        });
+        type = typePrompt;
+    }
+    const currentPath = '.';
+    const credsFile = await fs.promises.readFile(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    if (credsFile == null) {
+        logger.warn('unable to find dataverse.config.json file');
+        return;
+    }
+    const creds = JSON.parse(credsFile).connection;
+    if (!creds.authEndpoint) {
+        logger.error(('authEndpoint not found in dataverse.config.json. if you recently updated the package, please update the config file and replace tenant with authEndpoint with full authorization URL.'));
+        return;
+    }
+    let token = null;
+    // Check if token is available in environment
+    if (process.env.ACCESSTOKEN) {
+        token = { accessToken: process.env.ACCESSTOKEN };
+    }
+    else {
+        try {
+            token = await getAccessToken(creds.authEndpoint, creds.server);
+        }
+        catch (error) {
+            onTokenFailure(creds.server, error.message);
+            return;
+        }
+        if (token == null || token.accessToken == null) {
+            onTokenFailure(creds.server);
+            return;
+        }
+    }
+    const apiConfig = new WebApiConfig('8.2', token.accessToken, creds.server);
+    switch (type) {
+        case 'webresource':
+            await webResourceDeploy(creds, apiConfig, files);
+            break;
+        case 'assembly':
+            await assemblyDeploy(creds, apiConfig);
+            break;
+        case 'pcf':
+            logger.error('PCF deploy coming soon');
+            break;
+        default:
+            break;
+    }
+}

package/lib/generate.js

@@ -0,0 +1,97 @@
+import prompts from 'prompts';
+import fs from 'fs';
+import path from 'path';
+import { logger } from './logger.js';
+import { getTableMetadata } from './dataverse.service.js';
+import { WebApiConfig } from 'dataverse-webapi/lib/node';
+import { getAccessToken, onTokenFailure } from './auth.js';
+export default async function generate(table) {
+    while (!table) {
+        const { tablePrompt } = await prompts({
+            type: 'text',
+            name: 'tablePrompt',
+            message: `enter table to generate`
+        });
+        table = tablePrompt;
+    }
+    const currentPath = '.';
+    const credsFile = await fs.promises.readFile(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    if (credsFile == null) {
+        logger.warn('unable to find dataverse.config.json file');
+        return;
+    }
+    const creds = JSON.parse(credsFile).connection;
+    if (!creds.authEndpoint) {
+        logger.error(('authEndpoint not found in dataverse.config.json. if you recently updated the package, please update the config file and replace tenant with authEndpoint with full authorization URL.'));
+        return;
+    }
+    let token = null;
+    try {
+        token = await getAccessToken(creds.authEndpoint, creds.server);
+    }
+    catch (error) {
+        onTokenFailure(creds.server, error.message);
+        return;
+    }
+    if (token == null || token.accessToken == null) {
+        onTokenFailure(creds.server);
+        return;
+    }
+    const apiConfig = new WebApiConfig('8.2', token.accessToken, creds.server);
+    let metadata = {};
+    logger.info('Retrieve table metadata');
+    try {
+        metadata = await getTableMetadata(table, apiConfig);
+    }
+    catch (error) {
+        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.existsSync(path.resolve(currentPath, 'src', 'scripts', 'models'))) {
+        fs.mkdirSync(path.resolve(currentPath, 'src', 'scripts', 'models'));
+    }
+    fs.writeFileSync(path.resolve(currentPath, 'src', 'scripts', 'models', `${metadata.schemaName}.ts`), codeFile);
+    logger.done(`Table metadata output to models/${metadata.schemaName}.ts`);
+}

package/lib/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import deploy from './deploy.js';
+import generate from './generate.js';
+program
+    .usage('<command> [options]');
+// Deploy command
+program
+    .command('deploy')
+    .description('Deploy file(s) to dataverse (webresource, assembly, pcf)')
+    .argument('[type]', 'Type of project to deploy')
+    .argument('[files]', 'Comma separate list of files to deploy')
+    .action((type, files) => {
+    deploy(type, files);
+});
+// Generate command
+program
+    .command('generate')
+    .description('Generate early-bound TypeScript file for specified table')
+    .argument('[table]', 'Table to generate')
+    .action((table) => {
+    generate(table);
+});
+// Show help on unknown command
+program
+    .arguments('<command>')
+    .action((cmd) => {
+    program.outputHelp();
+    console.log();
+    console.log(`Unknown command ${cmd}.`);
+    console.log();
+});
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/lib/logger.js

@@ -0,0 +1,31 @@
+import kleur from 'kleur';
+import figures from 'figures';
+const isTest = process.env.JEST_WORKER_ID !== undefined;
+export const icons = {
+    done: kleur.green(figures.tick),
+    info: kleur.cyan(figures.pointer),
+    error: kleur.red(figures.cross),
+    warn: kleur.yellow(figures.warning)
+};
+export const logger = {
+    info(...args) {
+        if (!isTest) {
+            console.info(icons.info, ...args);
+        }
+    },
+    warn(...args) {
+        if (!isTest) {
+            console.warn(icons.warn, ...args);
+        }
+    },
+    error(...args) {
+        if (!isTest) {
+            console.error(icons.error, ...args);
+        }
+    },
+    done(...args) {
+        if (!isTest) {
+            console.info(icons.done, ...args);
+        }
+    },
+};

package/lib/models/customApi.js

@@ -0,0 +1,72 @@
+import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
+import { retrieveType } from './pluginType.js';
+import { logger } from '../logger.js';
+export async function deployApi(config, assemblyId, apiConfig, solution) {
+    const api = structuredClone(config);
+    if (!config.customapiid) {
+        config.customapiid = await retrieveApi(api.name, apiConfig);
+    }
+    if (config.plugintype && !config.plugintypeid) {
+        config.plugintypeid = await retrieveType(config.plugintype, assemblyId, apiConfig);
+        if (config.plugintypeid === '') {
+            logger.error(`unable to find plugin type ${api.plugintype}`);
+            return;
+        }
+    }
+    delete api.plugintype;
+    delete api.customapiid;
+    delete api.plugintypeid;
+    api['PluginTypeId@odata.bind'] = `plugintypes(${config.plugintypeid})`;
+    if (config.customapiid !== '') {
+        try {
+            await updateApi(config.customapiid, api, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update custom api: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            config.customapiid = await createApi(api, apiConfig, solution);
+        }
+        catch (error) {
+            throw new Error(`failed to create custom api: ${error.message}`);
+        }
+    }
+}
+export async function retrieveApi(name, apiConfig) {
+    const options = `$select=customapiid&$filter=name eq '${name}'`;
+    const result = await retrieveMultiple(apiConfig, 'customapis', options);
+    return result.value.length > 0 ? result.value[0].customapiid : '';
+}
+async function createApi(api, apiConfig, solution) {
+    logger.info(`create custom api ${api.name}`);
+    const options = {};
+    if (solution) {
+        options.customHeaders = { 'MSCRM.SolutionUniqueName': solution };
+    }
+    const result = await createWithReturnData(apiConfig, 'customapis', api, '$select=customapiid', options);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+    return result.customapiid;
+}
+async function updateApi(id, api, apiConfig) {
+    logger.info(`update custom api ${api.name}`);
+    const record = {
+        displayname: api.displayname,
+        description: api.description,
+        name: api.name,
+        executeprivilegename: api.executeprivilegename
+    };
+    if (api['PluginTypeId@odata.bind']) {
+        record['PluginTypeId@odata.bind'] = api['PluginTypeId@odata.bind'];
+    }
+    else {
+        record['PluginTypeId@odata.bind'] = null;
+    }
+    const result = await update(apiConfig, 'customapis', id, record);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+}

package/lib/models/pluginAssembly.js

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import fs from 'fs';
+import { glob } from 'glob';
+import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
+import { deployType } from './pluginType.js';
+import { logger } from '../logger.js';
+export async function deployAssembly(config, apiConfig, solution) {
+    const files = await glob(`bin/Debug/**/${config.name}.dll`);
+    if (files.length === 0) {
+        logger.warn(`assembly ${config.name}.dll not found`);
+        return;
+    }
+    const content = (await fs.promises.readFile(files[0])).toString('base64');
+    if (!config.pluginassemblyid) {
+        config.pluginassemblyid = await retrieveAssembly(config.name, apiConfig);
+    }
+    if (config.pluginassemblyid !== '') {
+        try {
+            await updateAssembly(config, content, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update assembly: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            config.pluginassemblyid = await createAssembly(config, content, apiConfig, solution);
+        }
+        catch (error) {
+            throw new Error(`failed to create assembly: ${error.message}`);
+        }
+    }
+    if (config.types != null) {
+        try {
+            const promises = config.types.map((type) => deployType(type, config.pluginassemblyid, apiConfig, solution));
+            await Promise.all(promises);
+        }
+        catch (error) {
+            logger.error(error.message);
+            return;
+        }
+    }
+}
+export async function retrieveAssembly(name, apiConfig) {
+    const options = `$select=pluginassemblyid&$filter=name eq '${name}'`;
+    const result = await retrieveMultiple(apiConfig, 'pluginassemblies', options);
+    return result.value.length > 0 ? result.value[0].pluginassemblyid : '';
+}
+async function createAssembly(config, content, apiConfig, solution) {
+    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 options = {};
+    if (solution) {
+        options.customHeaders = { 'MSCRM.SolutionUniqueName': solution };
+    }
+    const result = await createWithReturnData(apiConfig, 'pluginassemblies', assembly, '$select=pluginassemblyid', options);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+    return result.pluginassemblyid;
+}
+async function updateAssembly(config, content, apiConfig) {
+    logger.info(`update assembly ${config.name}`);
+    const assembly = {
+        content: content,
+        version: config.version
+    };
+    const result = await update(apiConfig, 'pluginassemblies', config.pluginassemblyid, assembly);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+}

package/lib/models/pluginImage.js

@@ -0,0 +1,64 @@
+import { logger } from '../logger.js';
+import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
+export async function deployImage(stepId, stepName, config, message, apiConfig) {
+    const image = structuredClone(config);
+    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;
+    }
+    if (!config.sdkmessageprocessingstepimageid) {
+        config.sdkmessageprocessingstepimageid = await retrieveImage(stepId, image, apiConfig);
+    }
+    if (config.sdkmessageprocessingstepimageid !== '') {
+        try {
+            await updateImage(config.sdkmessageprocessingstepimageid, image, stepName, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update plugin image: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            config.sdkmessageprocessingstepimageid = await createImage(image, stepName, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to create plugin image: ${error.message}`);
+        }
+    }
+}
+async function retrieveImage(stepId, image, apiConfig) {
+    const options = `$select=sdkmessageprocessingstepimageid&$filter=name eq '${image.name}' and _sdkmessageprocessingstepid_value eq ${stepId}`;
+    const result = await retrieveMultiple(apiConfig, 'sdkmessageprocessingstepimages', options);
+    return result.value.length > 0 ? result.value[0].sdkmessageprocessingstepimageid : '';
+}
+async function createImage(image, stepName, apiConfig) {
+    logger.info(`create plugin image ${image.name} for step ${stepName}`);
+    const result = await createWithReturnData(apiConfig, 'sdkmessageprocessingstepimages', image, '$select=sdkmessageprocessingstepimageid');
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+    return result.sdkmessageprocessingstepimageid;
+}
+async function updateImage(id, image, stepName, apiConfig) {
+    logger.info(`update plugin image ${image.name} for step ${stepName}`);
+    const entity = { ...image };
+    delete entity.sdkmessageprocessingstepimageid;
+    const result = await update(apiConfig, 'sdkmessageprocessingstepimages', id, entity);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+}

package/lib/models/pluginPackage.js

@@ -0,0 +1,86 @@
+import fs from 'fs';
+import { glob } from 'glob';
+import { createWithReturnData, retrieveMultiple, update } from 'dataverse-webapi/lib/node';
+import { retrieveAssembly } from './pluginAssembly.js';
+import { logger } from '../logger.js';
+import { retrieveType } from './pluginType.js';
+import { deployStep } from './pluginStep.js';
+export async function deployPluginPackage(config, apiConfig, solution) {
+    const files = await glob(`**/${config.name}.*.nupkg`);
+    if (files.length === 0) {
+        logger.warn(`package ${config.name}.nupkg not found`);
+        return;
+    }
+    const content = (await fs.promises.readFile(files[0])).toString('base64');
+    if (!config.pluginpackageid) {
+        config.pluginpackageid = await retrievePackage(config.prefix, config.name, apiConfig);
+    }
+    if (config.pluginpackageid) {
+        try {
+            await updatePackage(config, content, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update package: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            config.pluginpackageid = await createPackage(config, content, apiConfig, solution);
+        }
+        catch (error) {
+            throw new Error(`failed to create package: ${error.message}`);
+        }
+    }
+    if (config.assembly != null) {
+        try {
+            if (!config.assembly.pluginassemblyid) {
+                config.assembly.pluginassemblyid = await retrieveAssembly(config.assembly.name, apiConfig);
+            }
+            const promises = config.assembly.types?.map(async (t) => {
+                if (!t.plugintypeid && config.assembly?.pluginassemblyid) {
+                    t.plugintypeid = await retrieveType(t.typename, config.assembly.pluginassemblyid, apiConfig);
+                }
+                const stepPromises = t.steps?.map((s) => deployStep(s, t.plugintypeid, apiConfig, solution)) ?? [];
+                await Promise.all(stepPromises);
+            }) ?? [];
+            await Promise.all(promises);
+        }
+        catch (error) {
+            logger.error(error.message);
+            return;
+        }
+    }
+}
+async function retrievePackage(prefix, name, apiConfig) {
+    const options = `$select=pluginpackageid&$filter=contains(name, '${prefix}_${name}')`;
+    const result = await retrieveMultiple(apiConfig, 'pluginpackages', options);
+    return result.value.length > 0 ? result.value[0].pluginpackageid : '';
+}
+async function createPackage(config, content, apiConfig, solution) {
+    logger.info(`create package ${config.name}`);
+    const pluginPackage = {
+        name: `${config.prefix}_${config.name}`,
+        version: config.version,
+        content: content
+    };
+    const options = {};
+    if (solution) {
+        options.customHeaders = { 'MSCRM.SolutionUniqueName': solution };
+    }
+    const result = await createWithReturnData(apiConfig, 'pluginpackages', pluginPackage, '$select=pluginpackageid', options);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+    return result.pluginpackageid;
+}
+async function updatePackage(config, content, apiConfig) {
+    logger.info(`update package ${config.name}`);
+    const updated = {
+        content: content,
+        version: config.version
+    };
+    const result = await update(apiConfig, 'pluginpackages', config.pluginpackageid, updated);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+}

package/lib/models/pluginStep.js

@@ -0,0 +1,93 @@
+import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
+import { logger } from '../logger.js';
+import { deployImage } from './pluginImage.js';
+export async function deployStep(config, pluginTypeId, apiConfig, solution) {
+    const step = structuredClone(config);
+    step['plugintypeid@odata.bind'] = `/plugintypes(${pluginTypeId})`;
+    const messageId = await getSdkMessageId(step.message ?? '', apiConfig);
+    if (messageId == '') {
+        logger.warn(`sdk message ${step.message} not found`);
+        return;
+    }
+    if (step.entity !== '' && step.entity !== 'none') {
+        const filterId = await getSdkMessageFilterId(messageId, step.entity ?? '', apiConfig);
+        if (filterId == '') {
+            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})`;
+    step.asyncautodelete = step.mode === 1;
+    delete step.images;
+    delete step.message;
+    delete step.entity;
+    delete step.sdkmessageprocessingstepid;
+    if (!config.sdkmessageprocessingstepid) {
+        config.sdkmessageprocessingstepid = await retrieveStep(step.name, pluginTypeId, apiConfig);
+    }
+    if (config.sdkmessageprocessingstepid !== '') {
+        try {
+            await updateStep(config.sdkmessageprocessingstepid, step, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update plugin step: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            config.sdkmessageprocessingstepid = await createStep(step, apiConfig, solution);
+        }
+        catch (error) {
+            throw new Error(`failed to create plugin step: ${error.message}`);
+        }
+    }
+    if (config.images && config.images.length > 0) {
+        try {
+            const promises = config.images.map((image) => deployImage(config.sdkmessageprocessingstepid, step.name, image, config.message, apiConfig));
+            await Promise.all(promises);
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+}
+async function getSdkMessageFilterId(messageId, entityName, apiConfig) {
+    const options = [
+        `?$filter=primaryobjecttypecode eq '${entityName}' and _sdkmessageid_value eq ${messageId}`,
+        '&$select=sdkmessagefilterid'
+    ].join('');
+    const message = await 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 retrieveMultiple(apiConfig, 'sdkmessages', options);
+    return message.value.length > 0 ? message.value[0].sdkmessageid : '';
+}
+async function retrieveStep(name, typeId, apiConfig) {
+    const options = `$select=sdkmessageprocessingstepid&$filter=name eq '${name}' and _plugintypeid_value eq ${typeId}`;
+    const result = await retrieveMultiple(apiConfig, 'sdkmessageprocessingsteps', options);
+    return result.value.length > 0 ? result.value[0].sdkmessageprocessingstepid : '';
+}
+async function createStep(step, apiConfig, solution) {
+    logger.info(`create plugin step ${step.name}`);
+    const options = {};
+    if (solution) {
+        options.customHeaders = { 'MSCRM.SolutionUniqueName': solution };
+    }
+    const result = await createWithReturnData(apiConfig, 'sdkmessageprocessingsteps', step, '$select=sdkmessageprocessingstepid', options);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+    return result.sdkmessageprocessingstepid;
+}
+async function updateStep(id, step, apiConfig) {
+    logger.info(`update plugin step ${step.name}`);
+    const entity = { ...step };
+    delete entity.sdkmessageprocessingstepid;
+    const result = await update(apiConfig, 'sdkmessageprocessingsteps', id, entity);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+}

package/lib/models/pluginType.js

@@ -0,0 +1,62 @@
+import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
+import { deployStep } from './pluginStep.js';
+import { logger } from '../logger.js';
+export async function deployType(config, assemblyId, apiConfig, solution) {
+    const type = {
+        name: config.name,
+        friendlyname: config.friendlyname,
+        typename: config.typename,
+        'pluginassemblyid@odata.bind': `pluginassemblies(${assemblyId})`,
+        workflowactivitygroupname: config.workflowactivitygroupname
+    };
+    if (!config.plugintypeid) {
+        config.plugintypeid = await retrieveType(config.name, assemblyId, apiConfig);
+    }
+    if (config.plugintypeid !== '') {
+        try {
+            await updateType(config.plugintypeid, type, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to update plugin type: ${error.message}`);
+        }
+    }
+    else {
+        try {
+            config.plugintypeid = await createType(type, apiConfig);
+        }
+        catch (error) {
+            throw new Error(`failed to create plugin type: ${error.message}`);
+        }
+    }
+    try {
+        if (config.steps) {
+            const promises = config.steps.map((step) => deployStep(step, config.plugintypeid, apiConfig, solution));
+            await Promise.all(promises);
+        }
+    }
+    catch (error) {
+        throw new Error(error.message);
+    }
+}
+export async function retrieveType(name, assemblyId, apiConfig) {
+    const options = `$select=plugintypeid&$filter=typename eq '${name}' and _pluginassemblyid_value eq ${assemblyId}`;
+    const result = await retrieveMultiple(apiConfig, 'plugintypes', options);
+    return result.value.length > 0 ? result.value[0].plugintypeid : '';
+}
+async function createType(type, apiConfig) {
+    logger.info(`create assembly type ${type.name}`);
+    const result = await 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.info(`update assembly type ${type.name}`);
+    const entity = { ...type };
+    delete entity.plugintypeid;
+    const result = await update(apiConfig, 'plugintypes', id, entity);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+}

package/lib/models/webResource.js

@@ -0,0 +1,126 @@
+import { publish } from '../dataverse.service.js';
+import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
+import { logger } from '../logger.js';
+import fs from '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;
+    }
+}
+export 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.warn(`web resource ${file} not found in dataverse.config.json`);
+                continue;
+            }
+            resources.push(resource[0]);
+        }
+    }
+    const promises = resources.map(async (resource) => {
+        try {
+            if (!resource.webresourceid) {
+                resource.webresourceid = await retrieveResource(resource.name, apiConfig);
+            }
+        }
+        catch (error) {
+            logger.error(`failed to retrieve resource ${resource.name}: ${error.message}`);
+            return;
+        }
+        const fileContent = await fs.promises.readFile(resource.path, 'utf8');
+        const content = Buffer.from(fileContent).toString('base64');
+        if (resource.webresourceid !== '') {
+            try {
+                const updated = await updateResource(resource, content, apiConfig);
+                publishXml.push(updated);
+            }
+            catch (error) {
+                logger.error(`failed to update resource: ${error.message}`);
+            }
+        }
+        else {
+            try {
+                resource.webresourceid = await createResource(resource, content, apiConfig, solution);
+            }
+            catch (error) {
+                logger.error(`failed to create resource: ${error.message}`);
+            }
+        }
+    });
+    await Promise.all(promises);
+    // publish resources
+    if (publishXml.length > 0) {
+        try {
+            await publish(publishXml.join(''), apiConfig);
+        }
+        catch (error) {
+            logger.error(error.message);
+        }
+    }
+}
+async function retrieveResource(name, apiConfig) {
+    const options = `$select=webresourceid&$filter=name eq '${name}'`;
+    const result = await retrieveMultiple(apiConfig, 'webresourceset', options);
+    return result.value.length > 0 ? result.value[0].webresourceid : '';
+}
+async function createResource(resource, content, apiConfig, solution) {
+    logger.info(`create web resource ${resource.name}`);
+    const webResource = {
+        webresourcetype: getWebResourceType(resource.type),
+        name: resource.name,
+        displayname: resource.displayname || resource.name,
+        content: content
+    };
+    const options = {};
+    if (solution) {
+        options.customHeaders = { 'MSCRM.SolutionUniqueName': solution };
+    }
+    const result = await createWithReturnData(apiConfig, 'webresourceset', webResource, '$select=webresourceid', options);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+    return result.webresourceid;
+}
+async function updateResource(resource, content, apiConfig) {
+    logger.info(`update web resource ${resource.name}`);
+    const webResource = {
+        content: content,
+        name: resource.name,
+        displayname: resource.displayname || resource.name
+    };
+    const result = await update(apiConfig, 'webresourceset', resource.webresourceid, webResource);
+    if (result?.error) {
+        throw new Error(result.error.message);
+    }
+    return `<webresource>{${resource.webresourceid}}</webresource>`;
+}

package/lib/webResourceDeploy.js

@@ -0,0 +1,24 @@
+import path from 'path';
+import fs from 'fs';
+import { logger } from './logger.js';
+import { deploy } from './models/webResource.js';
+export async function webResourceDeploy(creds, apiConfig, files) {
+    const currentPath = '.';
+    const configFile = await fs.promises.readFile(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    if (configFile == null) {
+        logger.warn('unable to find dataverse.config.json file');
+        return;
+    }
+    const config = JSON.parse(configFile);
+    const resources = config.webResources;
+    logger.info('deploy web resources');
+    try {
+        await deploy(resources, apiConfig, creds.solution, files);
+    }
+    catch (error) {
+        logger.error(error.message);
+        return;
+    }
+    logger.done('deployed web resources');
+    await fs.promises.writeFile(path.resolve(currentPath, 'dataverse.config.json'), JSON.stringify(config, null, 4), 'utf8');
+}

package/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 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,13 +1,15 @@
 {
   "name": "dataverse-utils",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "license": "MIT",
   "description": "Utilities for interacting with Dataverse environments",
   "exports": "./lib/dataverse-utils.js",
   "engines": {
     "node": ">=20.0.0"
   },
-  "bin": "./lib/dataverse-utils.js",
+  "bin": {
+    "dataverse-utils": "lib/index.js"
+  },
   "files": [
     "/lib"
   ],
@@ -25,7 +27,7 @@
     "@azure/msal-node": "^3.5.0",
     "commander": "^13.1.0",
     "cryptr": "^6.3.0",
-    "dataverse-webapi": "^3.0.2",
+    "dataverse-webapi": "^3.0.0",
     "figures": "^6.1.0",
     "glob": "^11.0.1",
     "kleur": "^4.1.5",