Merge pull request #49 from jeswr/feat/custom-logger

feat: enable users to pass a custom logger

Author: Dexagod

package.json

@@ -9,6 +9,7 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "rm -rf dist/ && tsc",
+    "prepare": "npm run build",
     "release": "release-it"
   },
   "author": "",

src/authentication/AuthenticationInteractive.ts

@@ -40,7 +40,7 @@ export default async function authenticateInteractive(options: IInteractiveAuthO
       }
     }
   } catch (e) {
-    if (options?.verbose) writeErrorString('Could not load existing session', e);
+    if (options?.verbose) writeErrorString('Could not load existing session', e, options);
   }
 
 
@@ -68,7 +68,7 @@ export default async function authenticateInteractive(options: IInteractiveAuthO
   try {
     return await createFetchWithNewAccessToken(options.idp, appName, port)
   } catch (e) {
-    if (options?.verbose) writeErrorString('Error creating new session', e);
+    if (options?.verbose) writeErrorString('Error creating new session', e, options);
     return { fetch: crossfetch }
   }
 

src/authentication/AuthenticationToken.ts

@@ -43,12 +43,12 @@ export async function authenticateToken(options?: IClientCredentialsTokenAuthOpt
       }
     }
   } catch (e) {
-    if (options?.verbose) writeErrorString('Could not load existing session', e);
+    if (options?.verbose) writeErrorString('Could not load existing session', e, options);
   }
   try {
     return createFetchWithNewAccessToken(options);
   } catch (e) {
-    if (options?.verbose) writeErrorString('Could not create new session', e);
+    if (options?.verbose) writeErrorString('Could not create new session', e, options);
     return { fetch: crossfetch }
   }
 }

src/authentication/CreateFetch.ts

@@ -1,5 +1,6 @@
 import authenticateInteractive from "./AuthenticationInteractive";
 import { authenticateToken } from "./AuthenticationToken";
+import type { Logger } from '../logger';
 
 export const DEFAULTPORT = 3435
 export const APPNAME = "Solid-cli"
@@ -9,6 +10,7 @@ export type IInteractiveAuthOptions = {
   sessionInfoStorageLocation?: string, // Storage location of session information to reuse in subsequent runs of the application.
   port?: number, // Used for redirect url of Solid login sequence
   verbose?: boolean,
+  logger?: Logger,
 }
 
 export type IUserCredentialsAuthOptions = {
@@ -17,13 +19,15 @@ export type IUserCredentialsAuthOptions = {
   password: string,
   port?: number, // Used for redirect url of Solid login sequence
   verbose?: boolean,
+  logger?: Logger,
 }
 
 export type IClientCredentialsTokenAuthOptions = {
   idp?: string, // This value is stored with the created client credentials token.
   sessionInfoStorageLocation?: string, // Storage location of session information to reuse in subsequent runs of the application.
   clientCredentialsTokenStorageLocation?: string,  // Storage location of the stored client credentials token.
   verbose?: boolean,
+  logger?: Logger,
 }
 
 export type IClientCredentialsTokenGenerationOptions = {
@@ -32,6 +36,7 @@ export type IClientCredentialsTokenGenerationOptions = {
   password: string,
   idp: string,
   clientCredentialsTokenStorageLocation?: string // Storage location of the output client credentials token.
+  logger?: Logger,
 }
 
 export type SessionInfo = {

src/authentication/authenticate.ts

@@ -2,6 +2,7 @@ import SolidFetchBuilder from './CreateFetch';
 import { getWebIDIdentityProvider, writeErrorString } from '../utils/util';
 import inquirer from 'inquirer';
 import { getConfigCurrentWebID, getConfigCurrentToken } from '../utils/configoptions';
+import type { Logger } from '../logger';
 import crossfetch from 'cross-fetch';
 
 export type ILoginOptions = {
@@ -13,7 +14,8 @@ export type ILoginOptions = {
   config?: string, 
   clientCredentialsTokenStorageLocation?: string,  // Storage location of the stored client credentials token.
   sessionInfoStorageLocation?: string, 
-  verbose?: boolean, 
+  verbose?: boolean,
+  logger?: Logger,
 }
 
 
@@ -34,15 +36,15 @@ export default async function authenticate(options: ILoginOptions): Promise<{ fe
     try {
       await builder.buildFromClientCredentialsToken(options)
     } catch (e) {
-      if (options.verbose) writeErrorString(`Could not authenticate using client credentials token`, e);
+      if (options.verbose) writeErrorString(`Could not authenticate using client credentials token`, e, options);
     }
 
   } else if (authType === 'interactive') {
 
     try {
       await builder.buildInteractive(options);
     } catch (e) {
-      if (options.verbose) writeErrorString(`Could not authenticate interactively`, e);
+      if (options.verbose) writeErrorString(`Could not authenticate interactively`, e, options);
     }
   } 
 

src/commands/solid-copy.ts

@@ -6,6 +6,7 @@ import Blob from 'fetch-blob'
 import { requestUserCLIConfirmation } from '../utils/userInteractions';
 import BashlibError from '../utils/errors/BashlibError';
 import { BashlibErrorMessage } from '../utils/errors/BashlibError';
+import type { Logger } from '../logger';
 
 const mime = require('mime-types');
 
@@ -24,6 +25,7 @@ type CopyOptions = {
   all?: boolean,
   interactiveOverride?: boolean,
   noOverride?: boolean,
+  logger?: Logger
 }
 
 export default async function copy(src: string, dst: string, options: CopyOptions) : Promise<{
@@ -69,15 +71,15 @@ export default async function copy(src: string, dst: string, options: CopyOption
    **********************/
 
   if (source.isDir && !destination.isDir) {
-    console.error('Cannot copy a directory to a file')
+    (options.logger || console).error('Cannot copy a directory to a file')
     process.exit(1);
   } 
 
   let resourcesToTransfer : { files: FileInfo[], directories: FileInfo[], aclfiles: FileInfo[] };
   if (source.isRemote) {
-    resourcesToTransfer = await getRemoteSourceFiles(source, fetch, options.verbose, options.all)
+    resourcesToTransfer = await getRemoteSourceFiles(source, fetch, options.verbose, options.all, options)
   } else {
-    resourcesToTransfer = await getLocalSourceFiles(source, options.verbose, options.all)
+    resourcesToTransfer = await getLocalSourceFiles(source, options.verbose, options.all, options)
   }  
 
   let destinationInfo: { files: FileInfo[], directories: FileInfo[], aclfiles: FileInfo[] } = {
@@ -169,41 +171,41 @@ export default async function copy(src: string, dst: string, options: CopyOption
  * UTILITY FUNCTIONS *
  *********************/
 
-async function getLocalSourceFiles(source: srcOptions, verbose: boolean, all: boolean): Promise<{files: FileInfo[], directories: FileInfo[], aclfiles: FileInfo[]}> {
+async function getLocalSourceFiles(source: srcOptions, verbose: boolean, all: boolean, options?: { logger?: Logger }): Promise<{files: FileInfo[], directories: FileInfo[], aclfiles: FileInfo[]}> {
   if (source.isDir) {
     let filePathInfos = readLocalDirectoryRecursively(source.path, undefined, {verbose, all} )
     let files = await Promise.all(filePathInfos.files.map(async fileInfo => {
-      fileInfo.loadFile = async () => readLocalFile(fileInfo.absolutePath, verbose) 
+      fileInfo.loadFile = async () => readLocalFile(fileInfo.absolutePath, verbose, options) 
       return fileInfo
     }))
     let aclfiles = await Promise.all(filePathInfos.aclfiles.map(async fileInfo => {
-      fileInfo.loadFile = async () => readLocalFile(fileInfo.absolutePath, verbose) 
+      fileInfo.loadFile = async () => readLocalFile(fileInfo.absolutePath, verbose, options) 
       return fileInfo
     }))
     return { files, aclfiles, directories: filePathInfos.directories }
   } else {
     return { files: [ {
       absolutePath: source.path,
       relativePath: '',
-      loadFile: async () => readLocalFile(source.path, verbose)
+      loadFile: async () => readLocalFile(source.path, verbose, options)
     } ], aclfiles: [], directories: [] }
   }
 }
 
-async function getRemoteSourceFiles(source: srcOptions, fetch: Function, verbose: boolean, all: boolean) : Promise<{files: FileInfo[], directories: FileInfo[], aclfiles: FileInfo[]}> {
+async function getRemoteSourceFiles(source: srcOptions, fetch: Function, verbose: boolean, all: boolean, options?: { logger?: Logger }) : Promise<{files: FileInfo[], directories: FileInfo[], aclfiles: FileInfo[]}> {
   if (source.isDir) {
     let discoveredResources = await readRemoteDirectoryRecursively(source.path, { fetch, verbose, all})
 
     // Filter out files that return errors (e.g no authentication privileges)
     let files = (await Promise.all(discoveredResources.files.map(async fileInfo => {
-      fileInfo.loadFile = async () => readRemoteFile(fileInfo.absolutePath, fetch, verbose) 
+      fileInfo.loadFile = async () => readRemoteFile(fileInfo.absolutePath, fetch, verbose, options) 
       return fileInfo
     }))).filter(f => f) as FileInfo[]
 
     let aclfiles : FileInfo[] = []
     if (all) {
       aclfiles = (await Promise.all(discoveredResources.aclfiles.map(async fileInfo => {
-        fileInfo.loadFile = async () => readRemoteFile(fileInfo.absolutePath, fetch, verbose) 
+        fileInfo.loadFile = async () => readRemoteFile(fileInfo.absolutePath, fetch, verbose, options) 
         return fileInfo
       }))).filter(f => f) as FileInfo[]
     }
@@ -212,39 +214,39 @@ async function getRemoteSourceFiles(source: srcOptions, fetch: Function, verbose
     return { files: [ {
       absolutePath: source.path,
       relativePath: '',
-      loadFile: async () => readRemoteFile(source.path, fetch, verbose) 
+      loadFile: async () => readRemoteFile(source.path, fetch, verbose, options) 
     }] , aclfiles: [], directories: [] }
   }
 
 }
 
-function readLocalFile(path: string, verbose: boolean): { buffer: Buffer, contentType: string} {
-  if (verbose) console.log('Reading local file:', path)
+function readLocalFile(path: string, verbose: boolean, options?: { logger?: Logger }): { buffer: Buffer, contentType: string} {
+  if (verbose) (options?.logger || console).log('Reading local file:', path)
   const file = fs.readFileSync(path)
   let contentType = path.endsWith('.acl') || path.endsWith('.meta') ? 'text/turtle' : mime.lookup(path)
   return { buffer: file, contentType };
 }
 
-async function readRemoteFile(path: string, fetch: any, verbose: boolean) : Promise<{ blob: any, contentType: string}> {
-  if (verbose) console.log('Reading remote file:', path)
+async function readRemoteFile(path: string, fetch: any, verbose: boolean, options?: { logger?: Logger }) : Promise<{ blob: any, contentType: string}> {
+  if (verbose) (options?.logger || console).log('Reading remote file:', path)
   const file = await getFile(path, { fetch })
   const contentType = await getContentType(file) as string // TODO:: error handling?
   return { blob: file as any, contentType };
 
 }
 
 async function writeLocalDirectory(path: string, fileInfo: FileInfo, options: CopyOptions): Promise<any> {
-  if (options.verbose) console.log('Writing local directory:', path)
+  if (options.verbose) (options.logger || console).log('Writing local directory:', path)
   fs.mkdirSync(path, { recursive: true })
   return true;
 }
 
 async function writeRemoteDirectory(path: string, fileInfo: FileInfo, fetch: any, options: CopyOptions): Promise<any> {
-  if (options.verbose) console.log('Writing remote directory:', path)
+  if (options.verbose) (options.logger || console).log('Writing remote directory:', path)
   try {
     await createContainerAt(path, { fetch })
   } catch (e) {
-    if (options.verbose) writeErrorString(`Could not write directory for ${path}`, e);
+    if (options.verbose) writeErrorString(`Could not write directory for ${path}`, e, options);
   }
 }
 
@@ -262,11 +264,11 @@ async function writeLocalFile(resourcePath: string, fileInfo: FileInfo, options:
     }
   }
   if (!executeWrite) {
-    if (options.verbose) console.log('Skipping existing local file:', resourcePath)
+    if (options.verbose) (options.logger || console).log('Skipping existing local file:', resourcePath)
     return undefined;
   }
 
-  if (options.verbose) console.log('processing local file:', resourcePath)
+  if (options.verbose) (options.logger || console).log('processing local file:', resourcePath)
   try {
     if (!fileInfo.loadFile) throw new Error(`Could not load file at location: ${fileInfo.absolutePath}`)
     let fileData = await fileInfo.loadFile();
@@ -287,11 +289,11 @@ async function writeLocalFile(resourcePath: string, fileInfo: FileInfo, options:
       let buffer = Buffer.from(await fileData.blob.arrayBuffer())
       fs.writeFileSync(resourcePath, buffer)
     } else {
-      console.error('No content to write for:', resourcePath)
+      (options.logger || console).error('No content to write for:', resourcePath)
     }
     return resourcePath;
   } catch (e) {
-    if (options.verbose) writeErrorString(`Could not save local file ${resourcePath}`, e);
+    if (options.verbose) writeErrorString(`Could not save local file ${resourcePath}`, e, options);
     return undefined;
   }
 }
@@ -310,7 +312,7 @@ async function writeRemoteFile(resourcePath: string, fileInfo: FileInfo, fetch:
     }
   }
   if (!executeWrite) {
-    if (options.verbose) console.log('Skipping existing local file:', resourcePath)
+    if (options.verbose) (options.logger || console).log('Skipping existing local file:', resourcePath)
     return undefined;
   }
 

src/commands/solid-edit.ts

@@ -3,6 +3,8 @@ import path from "path"
 import copy from "./solid-copy";
 import fs from 'fs';
 import { checkRemoteFileAccess, checkRemoteFileExists, getPodRoot } from "../utils/util";
+import type { Logger } from '../logger';
+
 const md5 = require('md5');
 const child_process = require('child_process')
 
@@ -11,6 +13,7 @@ type CommandOptionEdit = {
   editor?: string,
   touch?: boolean,
   verbose?: boolean,
+  logger?: Logger,
 }
 
 export default async function edit(url: string, options: CommandOptionEdit) { 
@@ -49,10 +52,10 @@ async function editRemoteFile(url: string, options: CommandOptionEdit) {
       child.on('exit', function (e: any, code: any) {
         resolve();
       });
-    })
+    });
 
     // Wait for the user to finish editing the
-    console.log('Press any key to continue');
+    (options.logger || console).log('Press any key to continue');
     await new Promise<void>((resolve, reject) => {
       process.stdin.setRawMode(true);
       process.stdin.resume();
@@ -64,7 +67,7 @@ async function editRemoteFile(url: string, options: CommandOptionEdit) {
     let updateChanges = true;
     // Request user update -> required for editors that leave the terminal and continue the program.
     if (oldMd5 === newMd5) {
-      console.log('Update without changes? [y/N] ');
+      (options.logger || console).log('Update without changes? [y/N] ');
       updateChanges = await new Promise((resolve, reject) => {
         process.stdin.setRawMode(true);
         process.stdin.resume();
@@ -80,17 +83,17 @@ async function editRemoteFile(url: string, options: CommandOptionEdit) {
 
     if (updateChanges) {
       await copy(tmpFilePath, remoteFileUrl, options)
-      if (options.verbose) console.log('Remote file updated!');
+      if (options.verbose) (options.logger || console).log('Remote file updated!');
     }
     else {
-      if (options.verbose) console.log('Remote file untouched');
+      if (options.verbose) (options.logger || console).log('Remote file untouched');
     }
   } catch (e) { 
     throw e
     // TODO::
   } finally { 
     if(tmpFilePath) fs.unlinkSync(tmpFilePath);
-    if (options.verbose) console.log(`Removing local file file ${tmpFilePath}!`);
+    if (options.verbose) (options.logger || console).log(`Removing local file file ${tmpFilePath}!`);
   }
 }
 
@@ -114,24 +117,24 @@ async function editNewFile(url: string, options: CommandOptionEdit) {
       child.on('exit', function (e: any, code: any) {
         resolve();
       });
-    })
+    });
 
     // Wait for the user to finish editing the
-    console.log('Press any key to continue');
+    (options.logger || console).log('Press any key to continue');
     await new Promise<void>((resolve, reject) => {
       process.stdin.setRawMode(true);
       process.stdin.resume();
       process.stdin.on('data', () => resolve());
     })
 
     await copy(tmpFilePath, url, options)
-    if (options.verbose) console.log('Remote file updated!');
+    if (options.verbose) (options.logger || console).log('Remote file updated!');
   } catch (e) { 
     throw e
     // TODO::
   } finally { 
     if(tmpFilePath) fs.unlinkSync(tmpFilePath);
-    if (options.verbose) console.log(`Removing local file file ${tmpFilePath}!`);
+    if (options.verbose) (options.logger || console).log(`Removing local file file ${tmpFilePath}!`);
   }
 }