feat: ready for release

Author: SgtPooki

.envrc renamed to .envrc-copy

@@ -1,6 +1,5 @@
 use asdf
 
 export PATH=$(npm bin):${PATH}
-export MOCK_PINNING_SERVER_PORT=3000
 export MOCK_PINNING_SERVER_SECRET=secret
 export DEBUG=0

.gitignore

@@ -11,3 +11,4 @@ test/tsconfig.tsbuildinfo
 package-lock.json
 *.bak
 .swc
+.envrc

npm-scripts/fix/gen.sh

@@ -5,6 +5,7 @@ main() {
   # local FILES
   # FILES=()
   local SED_BACKUPS=()
+  local SED_ERROR=0
 
   # remove openapi-generator's package and tsconfig json files
   for PKG_JSON in generated/*/package.json; do
@@ -24,14 +25,22 @@ main() {
       if test -e $FILE_PATH; then
         # Replace all occurrances of "&lt;" with "<"
         # Replace all occurrances of "&gt;" with ">"
-        sed -i .bak -e 's/&lt\;/\</g' -e 's/&gt\;/\>/g' $FILE_PATH
+        sed -i .bak -e 's/&lt\;/\</g' -e 's/&gt\;/\>/g' $FILE_PATH || SED_ERROR=1
         SED_BACKUPS+=( $FILE_PATH.bak )
       fi
     done
   done
 
+  echo -e "\$SED_ERROR: $SED_ERROR \n"
+  if ((SED_ERROR)); then
+    echo "Error when replacing text, not deleting the backup files, please investigate: ${SED_BACKUPS[@]}"
+    return 1
+  else
+    rm ${SED_BACKUPS[@]}
+  fi
 
-  echo "SED_BACKUPS = ${SED_BACKUPS[@]}"
+
+  # echo "SED_BACKUPS = ${SED_BACKUPS[@]}"
   # test build.. if build succeeds, remove backup file.
 
 }

package.json

@@ -183,7 +183,8 @@
     "portscanner": "^2.2.0",
     "regenerator-runtime": "^0.13.9",
     "ts-node": "^10.5.0",
-    "tsc-silent": "^1.2.1"
+    "tsc-silent": "^1.2.1",
+    "winston": "^3.6.0"
   },
   "exports": {
     ".": {

test/MockServer.ts

@@ -3,19 +3,16 @@ import type { Application } from 'express'
 import type { Server } from 'http'
 import portscanner from 'portscanner'
 import cors from 'cors'
+import { logger } from './logger'
 
 import('dotenvrc')
 
 export class MockServer {
   private _server: Server | undefined = undefined
 
-  private port = Number(process.env.MOCK_PINNING_SERVER_PORT ?? 3000)
+  private port: string = '3001'
   private _service: Application | undefined = undefined
 
-  /**
-   * This set helps us support parallel tests by not attempting to start up multiple MockServer's on the same port
-   */
-
   public basePath: string = ''
 
   constructor (private readonly config: Parameters<typeof import('mock-ipfs-pinning-service')['setup']>[0] = { token: process.env.MOCK_PINNING_SERVER_SECRET }) {
@@ -27,7 +24,7 @@ export class MockServer {
     try {
       server = await this.server(port)
     } catch (err) {
-      MockServer.error('start error', err)
+      logger.error('start error', err)
     }
 
     if (server == null) {
@@ -53,26 +50,39 @@ export class MockServer {
     await this.cleanup()
   }
 
-  private setBasePath (): void {
-    this.basePath = `http://127.0.0.1:${this.port}`
+  private async server (port = this.port): Promise<Server> {
+    if (this._server !== undefined) {
+      return this._server
+    }
+    if (port != null && port !== this.port) {
+      this.port = port
+      this.setBasePath()
+    } else {
+      port = await this.getAvailablePort()
+    }
+    const service = await this.service()
+
+    service.on('error', (err) => {
+      logger.error('service error', err)
+    })
+    this._server = service.listen(port, () => {
+      logger.debug(`${Date.now()}: MockServer running on port ${port}`)
+    })
+
+    return this._server
   }
 
   /**
    * Ensure the port set for this instance is not already in use by another MockServer
    */
-  private async getAvailablePort (): Promise<number> {
-    // this.port = 3000
-
-    // this.setBasePath()
-
-    // return this.port
+  private async getAvailablePort (): Promise<string> {
     return await new Promise((resolve, reject) => portscanner.findAPortNotInUse(3000, 3099, '127.0.0.1', (error, port) => {
       if (error != null) {
         return reject(error)
       }
-      this.port = port
+      this.port = port.toString()
       this.setBasePath()
-      resolve(port)
+      resolve(this.port)
     }))
   }
 
@@ -81,38 +91,22 @@ export class MockServer {
       return this._service
     }
     this._service = await setup(this.config)
-    // this._service = await setup({
-    //   token: process.env.MOCK_PINNING_SERVER_SECRET,
-    //   loglevel: 'debug'
-    // })
+
     this._service.use(cors())
 
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-    return this._service as Application
+    return this._service
   }
 
-  private async server (port = this.port): Promise<Server> {
-    if (this._server !== undefined) {
-      return this._server
-    }
-    if (port !== this.port) {
-      this.port = port
+  private setBasePath (): void {
+    if (this.port == null) {
+      throw new Error('Attempted to set basePath before setting this.port.')
     }
-    const service = await this.service()
-
-    service.on('error', (err) => {
-      MockServer.error('service error', err)
-    })
-    this._server = service.listen(await this.getAvailablePort(), () => {
-      MockServer.debug(`${Date.now()}: MockServer running on port ${this.port}`)
-    })
-
-    return this._server
+    this.basePath = `http://127.0.0.1:${this.port}`
   }
 
   private cleanupSync (): void {
     void this.cleanup().then(() => {
-      MockServer.debug('cleaned up')
+      logger.debug('cleaned up')
     })
   }
 
@@ -123,43 +117,24 @@ export class MockServer {
     server.close((err) => {
       if ((err == null) || (err as Error & { code: string })?.code === 'ERR_SERVER_NOT_RUNNING') {
         // MockServer.portsInUse.remove(this.port)
-        MockServer.debug(`${Date.now()}: MockServer stopped listening on port ${port}`)
+        logger.debug(`${Date.now()}: MockServer stopped listening on port ${port}`)
         delete this._server
       } else if (err != null) {
-        MockServer.error(err.name)
-        MockServer.error(err.message)
-        MockServer.error(err.stack)
+        throw err
       }
     })
   }
 
   private static onEADDRINUSE (err: Error & { code: string }) {
     if (err.code === 'EADDRINUSE') {
-      this.error('Unexpected conflict with port usage')
+      logger.error('Unexpected conflict with port usage')
     } else {
-      this.error('CAUGHT UNKNOWN ERROR')
-      this.error(err.name)
-      this.error(err.code)
-      this.error(err.message)
-      this.error(err.stack)
-    }
-    process.exit(233)
-  }
-
-  private static debug (...logObjects: unknown[]) {
-    if (process.env.DEBUG != null && Number(process.env.DEBUG) !== 0) {
-      MockServer.log('debug', ...logObjects)
+      logger.error('CAUGHT UNKNOWN ERROR')
+      logger.error(err.name)
+      logger.error(err.code)
+      logger.error(err.message)
+      logger.error(err.stack)
     }
-  }
-
-  private static error (...logObjects: unknown[]) {
-    if (process.env.DEBUG != null) {
-      MockServer.log('error', ...logObjects)
-    }
-  }
-
-  private static log (type: keyof typeof console & 'log' | 'debug' | 'error' | 'warn' | 'info' | 'trace', ...logObjects: unknown[]) {
-    // eslint-disable-next-line no-console
-    console[type](...logObjects)
+    process.exit(1)
   }
 }

test/MockServerController.ts

@@ -1,11 +1,12 @@
-#!/usr/bin/env ts-node
-
-/* eslint-disable no-console */
 import express from 'express'
 import { MockServer } from './MockServer'
 import Router from 'express-promise-router'
 import cors from 'cors'
+import { logger } from './logger'
 
+/**
+ * MockServerController stands up a server on port 3000
+ */
 class MockServerController {
   private readonly mockServers: MockServer[] = []
   private readonly app = express()
@@ -53,7 +54,7 @@ class MockServerController {
           next(error)
         }
       } else {
-        console.log('Could not get mockserver')
+        logger.error('Could not get mockserver')
         throw new Error(`MockServer at port ${port} could not be found`)
       }
     })
@@ -62,7 +63,7 @@ class MockServerController {
     this.app.use(this.router)
 
     this.server = this.app.listen(this.port, () => {
-      console.log(`MockServerController listening on port ${this.port}`)
+      logger.debug(`MockServerController listening on port ${this.port}`)
     })
 
     // And you'll want to make sure you close the server when your process exits
@@ -71,29 +72,30 @@ class MockServerController {
     process.on('SIGINT', this.shutdownSync)
     process.on('SIGHUP', this.shutdownSync)
 
-    // To prevent duplicated cleanup, remove the process listeners on server close.
     this.server.on('close', () => {
+      logger.debug(`MockServerController stopped listening on ${this.port}`)
     })
   }
 
   private shutdownSync () {
     this.shutdown().catch((err) => {
-      console.error(err)
+      logger.error(err)
     })
   }
 
   async shutdown () {
+    // To prevent duplicated cleanup, remove the process listeners on server close.
     process.off('beforeExit', this.shutdownSync)
     process.off('SIGTERM', this.shutdownSync)
     process.off('SIGINT', this.shutdownSync)
     process.off('SIGHUP', this.shutdownSync)
     await new Promise<void>((resolve, reject) => {
       this.server.close((err) => {
         if (err != null) {
-          console.error('Unexpected error when shutting down the MockServerController')
-          console.error(err)
+          logger.error('Unexpected error when shutting down the MockServerController')
+          logger.error(err)
         } else {
-          console.log(`MockServerController stopped listening on port ${this.port}`)
+          logger.debug(`MockServerController stopped listening on port ${this.port}`)
         }
         resolve()
       })
@@ -102,22 +104,17 @@ class MockServerController {
       try {
         await mockS.stop()
       } catch (err) {
-        console.error(`Unexpected error when attempting to shutdown mock server at ${mockS.basePath}`)
-        console.error(err)
+        logger.error(`Unexpected error when attempting to shutdown mock server at ${mockS.basePath}`)
+        logger.error(err)
       }
     }
   }
 
-  // async startMockServer (req: {params: { port: number}}, res: {basePath: string, accessToken: string}, next: unknown) {
-
-  // }
-
   private async startIpfsPinningServer (port?: string) {
     const mockServer = new MockServer({
       token: process.env.MOCK_PINNING_SERVER_SECRET
-      // loglevel: 'info'
     })
-    await mockServer.start(Number(port))
+    await mockServer.start(port)
 
     return mockServer
   }

test/browser.ts

@@ -5,11 +5,10 @@ import { Configuration, PinsApi, Status } from '../src'
 import type { Pin } from '../src'
 import fetchPonyfill from 'fetch-ponyfill'
 
-// export default async (setup: () => Promise<{fetch: GlobalFetch['fetch']}>) => {
 const { fetch } = fetchPonyfill()
 
 let Config = new Configuration({
-  basePath: `http://127.0.0.1:${process.env.MOCK_PINNING_SERVER_PORT ?? '3000'}`,
+  basePath: 'http://127.0.0.1:3000',
   // fetchApi: fetch,
   accessToken: process.env.MOCK_PINNING_SERVER_SECRET
 })

test/client.spec.ts

@@ -0,0 +1,19 @@
+import winston from 'winston'
+
+const logLevel = process.env.LOG_LEVEL ?? 'error'
+
+const transports = {
+  console: new winston.transports.Console({ level: logLevel })
+}
+
+const logger = winston.createLogger({
+  transports: [
+    transports.console
+  ]
+})
+
+if (process.env.LOG_LEVEL == null) {
+  logger.silent = true
+}
+
+export { logger }