dataverse-utils 2.0.10 → 2.1.1

package/lib/deploy.js

@@ -1,16 +1,21 @@
-import prompts from 'prompts';
-import fs from 'fs';
-import path from 'path';
-import { logger } from 'just-scripts-utils';
-import { deployAssembly } from './assemblyDeploy';
-import { deployWebResource } from './webResourceDeploy';
-import { WebApiConfig } from 'dataverse-webapi/lib/node';
-import { getAccessToken } from './auth';
-export default async function deploy(type, files) {
+"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");
+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 prompts({
+        const { typePrompt } = await (0, prompts_1.default)({
             type: 'select',
             name: 'typePrompt',
             message: `${invalidMessage} select project type to deploy`,
@@ -22,33 +27,34 @@ export default async function deploy(type, files) {
         type = typePrompt;
     }
     const currentPath = '.';
-    const credsFile = fs.readFileSync(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    const credsFile = fs_1.default.readFileSync(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
     if (credsFile == null) {
-        logger.warn('unable to find dataverse.config.json file');
+        logger_1.logger.warn('unable to find dataverse.config.json file');
         return;
     }
     const creds = JSON.parse(credsFile).connection;
     let token = null;
     try {
-        token = await getAccessToken(creds.tenant, creds.server);
+        token = await (0, auth_1.getAccessToken)(creds.tenant, creds.server);
     }
     catch (error) {
-        logger.error(`failed to acquire access token: ${error.message}`);
+        logger_1.logger.error(`failed to acquire access token: ${error.message}`);
         return;
     }
     if (token == null || token.accessToken == null) {
-        logger.error('failed to acquire access token');
+        logger_1.logger.error('failed to acquire access token');
         return;
     }
-    const apiConfig = new WebApiConfig('8.2', token.accessToken, creds.server);
+    const apiConfig = new node_1.WebApiConfig('8.2', token.accessToken, creds.server);
     switch (type) {
         case 'webresource':
-            await deployWebResource(creds, apiConfig, files);
+            await (0, webResourceDeploy_1.deployWebResource)(creds, apiConfig, files);
             break;
         case 'assembly':
-            await deployAssembly(creds, apiConfig);
+            await (0, assemblyDeploy_1.deployAssembly)(creds, apiConfig);
             break;
         default:
             break;
     }
 }
+exports.default = deploy;

package/lib/generate.js

@@ -1,13 +1,18 @@
-import prompts from 'prompts';
-import fs from 'fs';
-import path from 'path';
-import { logger } from 'just-scripts-utils';
-import { getTableMetadata } from './dataverse.service';
-import { WebApiConfig } from 'dataverse-webapi/lib/node';
-import { getAccessToken } from './auth';
-export default async function generate(table) {
+"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 prompts({
+        const { tablePrompt } = await (0, prompts_1.default)({
             type: 'text',
             name: 'tablePrompt',
             message: `enter table to generate`
@@ -15,32 +20,32 @@ export default async function generate(table) {
         table = tablePrompt;
     }
     const currentPath = '.';
-    const credsFile = fs.readFileSync(path.resolve(currentPath, 'dataverse.config.json'), 'utf8');
+    const credsFile = fs_1.default.readFileSync(path_1.default.resolve(currentPath, 'dataverse.config.json'), 'utf8');
     if (credsFile == null) {
-        logger.warn('unable to find dataverse.config.json file');
+        logger_1.logger.warn('unable to find dataverse.config.json file');
         return;
     }
     const creds = JSON.parse(credsFile).connection;
     let token = null;
     try {
-        token = await getAccessToken(creds.tenant, creds.server);
+        token = await (0, auth_1.getAccessToken)(creds.tenant, creds.server);
     }
     catch (error) {
-        logger.error(`failed to acquire access token: ${error.message}`);
+        logger_1.logger.error(`failed to acquire access token: ${error.message}`);
         return;
     }
     if (token == null || token.accessToken == null) {
-        logger.error('failed to acquire access token');
+        logger_1.logger.error('failed to acquire access token');
         return;
     }
-    const apiConfig = new WebApiConfig('8.2', token.accessToken, creds.server);
+    const apiConfig = new node_1.WebApiConfig('8.2', token.accessToken, creds.server);
     let metadata = {};
-    logger.info('Retrieve table metadata');
+    logger_1.logger.info('Retrieve table metadata');
     try {
-        metadata = await getTableMetadata(table, apiConfig);
+        metadata = await (0, dataverse_service_1.getTableMetadata)(table, apiConfig);
     }
     catch (error) {
-        logger.error(error.message);
+        logger_1.logger.error(error.message);
         return;
     }
     // Build code file from metadata
@@ -85,9 +90,10 @@ export default async function generate(table) {
         '\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'));
+    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.writeFileSync(path.resolve(currentPath, 'src', 'scripts', 'models', `${metadata.schemaName}.ts`), codeFile);
-    logger.info(`Table metadata output to models/${metadata.schemaName}.ts`);
+    fs_1.default.writeFileSync(path_1.default.resolve(currentPath, 'src', 'scripts', 'models', `${metadata.schemaName}.ts`), codeFile);
+    logger_1.logger.info(`Table metadata output to models/${metadata.schemaName}.ts`);
 }
+exports.default = generate;

package/lib/index.js

@@ -0,0 +1,45 @@
+#!/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
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    .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,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const kleur_1 = __importDefault(require("kleur"));
+const square = '\u25a0';
+const triangle = '\u25b2';
+const emptySquare = '\u25a1';
+const log = (method, symbol, ...args) => {
+    const now = new Date();
+    const timestamp = kleur_1.default.gray(`[${now.toLocaleTimeString()}]`);
+    console[method](timestamp, symbol, ...args);
+};
+exports.logger = {
+    info(...args) {
+        log('info', kleur_1.default.green(square), args);
+    },
+    warn(...args) {
+        log('warn', kleur_1.default.yellow(triangle), args);
+    },
+    error(...args) {
+        log('error', kleur_1.default.red(emptySquare), args);
+    }
+};

package/lib/models/pluginAssembly.js

@@ -1,22 +1,28 @@
-import fs from 'fs';
-import glob from 'glob';
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-import { deployType } from './pluginType';
-import { addToSolution, ComponentType } from '../dataverse.service';
-import { logger } from 'just-scripts-utils';
-export async function deploy(config, apiConfig, solution) {
-    const files = glob.sync(`**/${config.name}.dll`);
+"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.error(`assembly ${config.name}.dll not found`);
+        logger_1.logger.error(`assembly ${config.name}.dll not found`);
         return;
     }
-    const content = fs.readFileSync(files[0]).toString('base64');
+    const content = fs_1.default.readFileSync(files[0]).toString('base64');
     let assemblyId = '';
     try {
         assemblyId = await retrieveAssembly(config.name, apiConfig);
     }
     catch (error) {
-        logger.error(`failed to retrieve assembly ${config.name}: ${error.message}`);
+        logger_1.logger.error(`failed to retrieve assembly ${config.name}: ${error.message}`);
         return;
     }
     if (assemblyId != '') {
@@ -36,10 +42,10 @@ export async function deploy(config, apiConfig, solution) {
         }
         if (solution != undefined) {
             try {
-                await addToSolution(assemblyId, solution, ComponentType.PluginAssembly, apiConfig);
+                await (0, dataverse_service_1.addToSolution)(assemblyId, solution, dataverse_service_1.ComponentType.PluginAssembly, apiConfig);
             }
             catch (error) {
-                logger.error(`failed to add to solution: ${error.message}`);
+                logger_1.logger.error(`failed to add to solution: ${error.message}`);
             }
         }
     }
@@ -47,23 +53,24 @@ export async function deploy(config, apiConfig, solution) {
         try {
             const promises = config.types.map(async (type) => {
                 type['pluginassemblyid@odata.bind'] = `/pluginassemblies(${assemblyId})`;
-                await deployType(type, apiConfig, solution);
+                await (0, pluginType_1.deployType)(type, apiConfig, solution);
             });
             await Promise.all(promises);
         }
         catch (error) {
-            logger.error(error.message);
+            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 retrieveMultiple(apiConfig, 'pluginassemblies', options);
+    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.info(`create assembly ${config.name}`);
+    logger_1.logger.info(`create assembly ${config.name}`);
     const assembly = {
         name: config.name,
         content: content,
@@ -73,17 +80,17 @@ async function createAssembly(config, content, apiConfig) {
         sourcetype: 0,
         culture: ''
     };
-    const result = await createWithReturnData(apiConfig, 'pluginassemblies', assembly, '$select=pluginassemblyid');
+    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.info(`update assembly ${config.name}`);
+    logger_1.logger.info(`update assembly ${config.name}`);
     const assembly = {
         content: content,
         version: config.version
     };
-    return update(apiConfig, 'pluginassemblies', id, assembly);
+    return (0, node_1.update)(apiConfig, 'pluginassemblies', id, assembly);
 }

package/lib/models/pluginImage.js

@@ -1,6 +1,9 @@
-import { logger } from 'just-scripts-utils';
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-export async function deployImage(stepId, image, message, apiConfig) {
+"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':
@@ -38,20 +41,21 @@ export async function deployImage(stepId, image, message, apiConfig) {
     }
     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 retrieveMultiple(apiConfig, 'sdkmessageprocessingstepimages', options);
+    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.info(`create plugin image ${image.name}`);
-    const result = await createWithReturnData(apiConfig, 'sdkmessageprocessingstepimages', image, '$select=sdkmessageprocessingstepimageid');
+    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.info(`update plugin image ${image.name}`);
-    return update(apiConfig, 'sdkmessageprocessingstepimages', id, image);
+    logger_1.logger.info(`update plugin image ${image.name}`);
+    return (0, node_1.update)(apiConfig, 'sdkmessageprocessingstepimages', id, image);
 }

package/lib/models/pluginStep.js

@@ -1,17 +1,20 @@
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-import { addToSolution, ComponentType } from '../dataverse.service';
-import { logger } from 'just-scripts-utils';
-import { deployImage } from './pluginImage';
-export async function deployStep(step, apiConfig, solution) {
+"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, apiConfig, solution) {
     let stepId = await retrieveStep(step.name, apiConfig);
     const messageId = await getSdkMessageId(step.message ?? '', apiConfig);
     if (messageId == '') {
-        logger.error(`sdk message ${step.message} not found`);
+        logger_1.logger.error(`sdk message ${step.message} not found`);
         return;
     }
     const filterId = await getSdkMessageFilterId(messageId, step.entity ?? '', apiConfig);
     if (filterId == '') {
-        logger.error(`sdk message ${step.message} for entity ${step.entity} not found`);
+        logger_1.logger.error(`sdk message ${step.message} for entity ${step.entity} not found`);
         return;
     }
     step['sdkmessagefilterid@odata.bind'] = `/sdkmessagefilters(${filterId})`;
@@ -41,7 +44,7 @@ export async function deployStep(step, apiConfig, solution) {
         }
         if (solution != undefined) {
             try {
-                await addToSolution(stepId, solution, ComponentType.SDKMessageProcessingStep, apiConfig);
+                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}`);
@@ -50,7 +53,7 @@ export async function deployStep(step, apiConfig, solution) {
     }
     if (images && images.length > 0) {
         try {
-            const promises = images.map(image => deployImage(stepId, image, message, apiConfig));
+            const promises = images.map(image => (0, pluginImage_1.deployImage)(stepId, image, message, apiConfig));
             await Promise.all(promises);
         }
         catch (error) {
@@ -59,9 +62,10 @@ export async function deployStep(step, apiConfig, solution) {
     }
     return stepId;
 }
+exports.deployStep = deployStep;
 async function retrieveStep(name, apiConfig) {
     const options = `$select=sdkmessageprocessingstepid&$filter=name eq '${name}'`;
-    const result = await retrieveMultiple(apiConfig, 'sdkmessageprocessingsteps', options);
+    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) {
@@ -69,7 +73,7 @@ async function getSdkMessageFilterId(messageId, entityName, apiConfig) {
         `?$filter=primaryobjecttypecode eq '${entityName}' and _sdkmessageid_value eq ${messageId}`,
         '&$select=sdkmessagefilterid'
     ].join('');
-    const message = await retrieveMultiple(apiConfig, 'sdkmessagefilters', options);
+    const message = await (0, node_1.retrieveMultiple)(apiConfig, 'sdkmessagefilters', options);
     return message.value.length > 0 ? message.value[0].sdkmessagefilterid : '';
 }
 async function getSdkMessageId(name, apiConfig) {
@@ -77,18 +81,18 @@ async function getSdkMessageId(name, apiConfig) {
         `?$filter=name eq '${name}'`,
         '&$select=sdkmessageid'
     ].join('');
-    const message = await retrieveMultiple(apiConfig, 'sdkmessages', options);
+    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.info(`create plugin step ${step.name}`);
-    const result = await createWithReturnData(apiConfig, 'sdkmessageprocessingsteps', step, '$select=sdkmessageprocessingstepid');
+    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.info(`update plugin step ${step.name}`);
-    return update(apiConfig, 'sdkmessageprocessingsteps', id, step);
+    logger_1.logger.info(`update plugin step ${step.name}`);
+    return (0, node_1.update)(apiConfig, 'sdkmessageprocessingsteps', id, step);
 }

package/lib/models/pluginType.js

@@ -1,7 +1,10 @@
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-import { deployStep } from './pluginStep';
-import { logger } from 'just-scripts-utils';
-export async function deployType(type, apiConfig, solution) {
+"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, apiConfig, solution) {
     let typeId = await retrieveType(type.typename, apiConfig);
     const record = {
         name: type.name,
@@ -30,7 +33,7 @@ export async function deployType(type, apiConfig, solution) {
         if (type.steps) {
             const promises = type.steps.map(async (step) => {
                 step['plugintypeid@odata.bind'] = `/plugintypes(${typeId})`;
-                await deployStep(step, apiConfig, solution);
+                await (0, pluginStep_1.deployStep)(step, apiConfig, solution);
             });
             await Promise.all(promises);
         }
@@ -40,20 +43,21 @@ export async function deployType(type, apiConfig, solution) {
     }
     return typeId;
 }
+exports.deployType = deployType;
 async function retrieveType(name, apiConfig) {
     const options = `$select=plugintypeid&$filter=typename eq '${name}'`;
-    const result = await retrieveMultiple(apiConfig, 'plugintypes', options);
+    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.info(`create assembly type ${type.name}`);
-    const result = await createWithReturnData(apiConfig, 'plugintypes', type, '$select=plugintypeid');
+    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.info(`update assembly type ${type.name}`);
-    return update(apiConfig, 'plugintypes', id, type);
+    logger_1.logger.info(`update assembly type ${type.name}`);
+    return (0, node_1.update)(apiConfig, 'plugintypes', id, type);
 }

package/lib/models/webResource.js

@@ -1,7 +1,13 @@
-import { addToSolution, ComponentType, publish } from '../dataverse.service';
-import { retrieveMultiple, createWithReturnData, update } from 'dataverse-webapi/lib/node';
-import { logger } from 'just-scripts-utils';
-import fs from 'fs';
+"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':
@@ -32,7 +38,7 @@ function getWebResourceType(type) {
             return 0;
     }
 }
-export async function deploy(webResources, apiConfig, solution, files) {
+async function deploy(webResources, apiConfig, solution, files) {
     const publishXml = [];
     let resources = webResources;
     // Use list of files if provided
@@ -41,7 +47,7 @@ export async function deploy(webResources, apiConfig, solution, files) {
         for (const file of files.split(',')) {
             const resource = webResources.filter(r => r.path?.endsWith(file));
             if (resource.length === 0) {
-                logger.error(`web resource ${file} not found in dataverse.config.json`);
+                logger_1.logger.error(`web resource ${file} not found in dataverse.config.json`);
                 continue;
             }
             resources.push(resource[0]);
@@ -53,10 +59,10 @@ export async function deploy(webResources, apiConfig, solution, files) {
             resourceId = await retrieveResource(resource.name, apiConfig);
         }
         catch (error) {
-            logger.error(`failed to retrieve resource ${resource.name}: ${error.message}`);
+            logger_1.logger.error(`failed to retrieve resource ${resource.name}: ${error.message}`);
             return;
         }
-        const fileContent = fs.readFileSync(resource.path, 'utf8');
+        const fileContent = fs_1.default.readFileSync(resource.path, 'utf8');
         const content = Buffer.from(fileContent).toString('base64');
         if (resourceId != '') {
             try {
@@ -64,7 +70,7 @@ export async function deploy(webResources, apiConfig, solution, files) {
                 publishXml.push(updated);
             }
             catch (error) {
-                logger.error(`failed to update resource: ${error.message}`);
+                logger_1.logger.error(`failed to update resource: ${error.message}`);
             }
         }
         else {
@@ -72,14 +78,14 @@ export async function deploy(webResources, apiConfig, solution, files) {
                 resourceId = await createResource(resource, content, apiConfig);
             }
             catch (error) {
-                logger.error(`failed to create resource: ${error.message}`);
+                logger_1.logger.error(`failed to create resource: ${error.message}`);
             }
             if (solution != undefined) {
                 try {
-                    await addToSolution(resourceId, solution, ComponentType.WebResource, apiConfig);
+                    await (0, dataverse_service_1.addToSolution)(resourceId, solution, dataverse_service_1.ComponentType.WebResource, apiConfig);
                 }
                 catch (error) {
-                    logger.error(`failed to add to solution: ${error.message}`);
+                    logger_1.logger.error(`failed to add to solution: ${error.message}`);
                 }
             }
         }
@@ -88,37 +94,38 @@ export async function deploy(webResources, apiConfig, solution, files) {
     // publish resources
     if (publishXml.length > 0) {
         try {
-            await publish(publishXml.join(''), apiConfig);
+            await (0, dataverse_service_1.publish)(publishXml.join(''), apiConfig);
         }
         catch (error) {
-            logger.error(error.message);
+            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 retrieveMultiple(apiConfig, 'webresourceset', options);
+    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.info(`create web resource ${resource.name}`);
+    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 createWithReturnData(apiConfig, 'webresourceset', webResource, '$select=webresourceid');
+    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.info(`update web resource ${resource.name}`);
+    logger_1.logger.info(`update web resource ${resource.name}`);
     const webResource = {
         content: content
     };
-    await update(apiConfig, 'webresourceset', id, webResource);
+    await (0, node_1.update)(apiConfig, 'webresourceset', id, webResource);
     return `<webresource>{${id}}</webresource>`;
 }