prool 0.0.3 → 0.0.4

package/pool.ts

@@ -13,6 +13,7 @@ export type Pool<key = number> = Pick<
   }
   destroy(key: key): Promise<void>
   destroyAll(): Promise<void>
+  restart(key: key): Promise<void>
   start(key: key, options?: { port?: number }): Promise<Instance_>
   stop(key: key): Promise<void>
   stopAll(): Promise<void>
@@ -56,6 +57,7 @@ export function definePool<key = number>(
   const promises = {
     destroy: new Map<key, Promise<void>>(),
     destroyAll: undefined as Promise<void> | undefined,
+    restart: new Map<key, Promise<void>>(),
     start: new Map<key, Promise<Instance_>>(),
     stop: new Map<key, Promise<void>>(),
     stopAll: undefined as Promise<void> | undefined,
@@ -71,16 +73,14 @@ export function definePool<key = number>(
 
       const resolver = Promise.withResolvers<void>()
 
-      try {
-        promises.destroy.set(key, resolver.promise)
+      promises.destroy.set(key, resolver.promise)
 
-        await this.stop(key)
-        instances.delete(key)
-
-        resolver.resolve()
-      } catch (error) {
-        resolver.reject(error)
-      }
+      this.stop(key)
+        .then(() => {
+          instances.delete(key)
+          resolver.resolve()
+        })
+        .catch(resolver.reject)
 
       return resolver.promise
     },
@@ -89,17 +89,35 @@ export function definePool<key = number>(
 
       const resolver = Promise.withResolvers<void>()
 
-      try {
-        promises.destroyAll = resolver.promise
+      promises.destroyAll = resolver.promise
 
-        await Promise.all([...instances.keys()].map((key) => this.destroy(key)))
+      Promise.all([...instances.keys()].map((key) => this.destroy(key)))
+        .then(() => {
+          promises.destroyAll = undefined
+          resolver.resolve()
+        })
+        .catch(resolver.reject)
 
-        promises.destroyAll = undefined
+      return resolver.promise
+    },
+    async restart(key) {
+      const restartPromise = promises.restart.get(key)
+      if (restartPromise) return restartPromise
 
-        resolver.resolve()
-      } catch (error) {
-        resolver.reject(error)
-      }
+      const resolver = Promise.withResolvers<void>()
+
+      const instance_ = instances.get(key)
+      if (!instance_) return
+
+      promises.restart.set(key, resolver.promise)
+
+      instance_
+        .restart()
+        .then(resolver.resolve)
+        .catch(resolver.reject)
+        .finally(() => promises.restart.delete(key))
+
+      return resolver.promise
     },
     async start(key, options = {}) {
       const startPromise = promises.start.get(key)
@@ -107,24 +125,21 @@ export function definePool<key = number>(
 
       const resolver = Promise.withResolvers<Instance_>()
 
-      try {
-        promises.start.set(key, resolver.promise)
+      if (limit && instances.size >= limit)
+        throw new Error(`Instance limit of ${limit} reached.`)
 
-        if (limit && instances.size >= limit)
-          throw new Error(`Instance limit of ${limit} reached.`)
+      promises.start.set(key, resolver.promise)
 
-        const { port = await getPort() } = options
-
-        const instance_ = instances.get(key) || instance.create({ port })
-        await instance_.start()
-
-        instances.set(key, instance_)
-        resolver.resolve(instance_)
-      } catch (error) {
-        resolver.reject(error)
-      } finally {
-        promises.start.delete(key)
-      }
+      const { port = await getPort() } = options
+      const instance_ = instances.get(key) || instance.create({ port })
+      instance_
+        .start()
+        .then(() => {
+          instances.set(key, instance_)
+          resolver.resolve(instance_)
+        })
+        .catch(resolver.reject)
+        .finally(() => promises.start.delete(key))
 
       return resolver.promise
     },
@@ -132,42 +147,35 @@ export function definePool<key = number>(
       const stopPromise = promises.stop.get(key)
       if (stopPromise) return stopPromise
 
-      const resolver = Promise.withResolvers<void>()
+      const instance_ = instances.get(key)
+      if (!instance_) return
 
-      try {
-        promises.stop.set(key, resolver.promise)
-
-        const instance_ = instances.get(key)
-        if (!instance_) {
-          resolver.resolve()
-          return
-        }
+      const resolver = Promise.withResolvers<void>()
 
-        await instance_.stop()
+      promises.stop.set(key, resolver.promise)
+      instance_
+        .stop()
+        .then(resolver.resolve)
+        .catch(resolver.reject)
+        .finally(() => promises.stop.delete(key))
 
-        resolver.resolve()
-      } catch (error) {
-        resolver.reject(error)
-      } finally {
-        promises.stop.delete(key)
-      }
+      return resolver.promise
     },
     async stopAll() {
       if (promises.stopAll) return promises.stopAll
 
       const resolver = Promise.withResolvers<void>()
 
-      try {
-        promises.stopAll = resolver.promise
-
-        await Promise.all([...instances.keys()].map((key) => this.stop(key)))
+      promises.stopAll = resolver.promise
 
-        promises.stopAll = undefined
+      Promise.all([...instances.keys()].map((key) => this.stop(key)))
+        .then(() => {
+          promises.stopAll = undefined
+          resolver.resolve()
+        })
+        .catch(resolver.reject)
 
-        resolver.resolve()
-      } catch (error) {
-        resolver.reject(error)
-      }
+      return resolver.promise
     },
 
     get size() {

package/server.test.ts

@@ -7,49 +7,49 @@ describe.each([{ instance: anvil() }])(
   'instance: $instance.name',
   ({ instance }) => {
     test('default', async () => {
-      const pool = createServer({
+      const server = createServer({
         instance,
       })
-      expect(pool).toBeDefined()
+      expect(server).toBeDefined()
 
-      await pool.start()
-      expect(pool.address()).toBeDefined()
+      await server.start()
+      expect(server.address()).toBeDefined()
 
       // Stop via instance method.
-      await pool.stop()
-      expect(pool.address()).toBeNull()
+      await server.stop()
+      expect(server.address()).toBeNull()
 
-      const stop = await pool.start()
-      expect(pool.address()).toBeDefined()
+      const stop = await server.start()
+      expect(server.address()).toBeDefined()
 
       // Stop via return value.
       await stop()
-      expect(pool.address()).toBeNull()
+      expect(server.address()).toBeNull()
     })
 
     test('args: port', async () => {
-      const pool = createServer({
+      const server = createServer({
         instance,
         port: 3000,
       })
-      expect(pool).toBeDefined()
+      expect(server).toBeDefined()
 
-      const stop = await pool.start()
-      expect(pool.address()?.port).toBe(3000)
+      const stop = await server.start()
+      expect(server.address()?.port).toBe(3000)
       await stop()
     })
 
     test('args: host', async () => {
-      const pool = createServer({
+      const server = createServer({
         instance,
         host: 'localhost',
         port: 3000,
       })
-      expect(pool).toBeDefined()
+      expect(server).toBeDefined()
 
-      const stop = await pool.start()
-      expect(pool.address()?.address).toBe('::1')
-      expect(pool.address()?.port).toBe(3000)
+      const stop = await server.start()
+      expect(server.address()?.address).toBe('::1')
+      expect(server.address()?.port).toBe(3000)
       await stop()
     })
 
@@ -95,6 +95,19 @@ describe.each([{ instance: anvil() }])(
       await stop()
     })
 
+    test('request: /restart', async () => {
+      const server = createServer({
+        instance,
+      })
+
+      const stop = await server.start()
+      const { port } = server.address()!
+      const response = await fetch(`http://localhost:${port}/1/restart`)
+      expect(response.status).toBe(200)
+
+      await stop()
+    })
+
     test('ws', async () => {
       const server = createServer({
         instance,
@@ -224,6 +237,76 @@ describe("instance: 'anvil'", () => {
     await stop()
   })
 
+  test('request: /restart', async () => {
+    const server = createServer({
+      instance: anvil(),
+    })
+
+    const stop = await server.start()
+    const { port } = server.address()!
+
+    // Mine block number
+    await fetch(`http://localhost:${port}/1`, {
+      body: JSON.stringify({
+        method: 'anvil_mine',
+        params: ['0x69', '0x0'],
+        id: 0,
+        jsonrpc: '2.0',
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      method: 'POST',
+    })
+
+    // Check block numbers
+    expect(
+      await fetch(`http://localhost:${port}/1`, {
+        body: JSON.stringify({
+          method: 'eth_blockNumber',
+          id: 0,
+          jsonrpc: '2.0',
+        }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+      }).then((x) => x.json()),
+    ).toMatchInlineSnapshot(`
+      {
+        "id": 0,
+        "jsonrpc": "2.0",
+        "result": "0x69",
+      }
+    `)
+
+    // Restart
+    await fetch(`http://localhost:${port}/1/restart`)
+
+    // Check block numbers
+    expect(
+      await fetch(`http://localhost:${port}/1`, {
+        body: JSON.stringify({
+          method: 'eth_blockNumber',
+          id: 0,
+          jsonrpc: '2.0',
+        }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+      }).then((x) => x.json()),
+    ).toMatchInlineSnapshot(`
+      {
+        "id": 0,
+        "jsonrpc": "2.0",
+        "result": "0x0",
+      }
+    `)
+
+    await stop()
+  })
+
   test('request: /messages', async () => {
     const server = createServer({
       instance: anvil(),

package/server.ts

@@ -56,44 +56,46 @@ export function createServer(
 
       const { id, path } = extractPath(url)
 
-      if (typeof id === 'number' && path === '/') {
-        const { host, port } = pool.get(id) || (await pool.start(id))
-        return proxy.web(request, response, {
-          target: `http://${host}:${port}`,
-        })
-      }
-      if (typeof id === 'number' && path === '/start') {
-        const { host, port } = await pool.start(id)
-        response
-          .writeHead(200, { 'Content-Type': 'application/json' })
-          .end(JSON.stringify({ host, port }))
-        return
-      }
-      if (typeof id === 'number' && path === '/stop') {
-        await pool.stop(id)
-        response.writeHead(200, { 'Content-Type': 'application/json' }).end()
-        return
-      }
-      if (typeof id === 'number' && path === '/messages') {
-        const messages = pool.get(id)?.messages.get() || []
-        response
-          .writeHead(200, { 'Content-Type': 'application/json' })
-          .end(JSON.stringify(messages))
-        return
+      if (typeof id === 'number') {
+        if (path === '/') {
+          const { host, port } = pool.get(id) || (await pool.start(id))
+          return proxy.web(request, response, {
+            target: `http://${host}:${port}`,
+          })
+        }
+        if (path === '/start') {
+          const { host, port } = await pool.start(id)
+          return done(response, 200, { host, port })
+        }
+        if (path === '/stop') {
+          await pool.stop(id)
+          return done(response, 200)
+        }
+        if (path === '/restart') {
+          await pool.restart(id)
+          return done(response, 200)
+        }
+        if (path === '/messages') {
+          const messages = pool.get(id)?.messages.get() || []
+          return done(response, 200, messages)
+        }
       }
 
-      if (path === '/healthcheck') {
-        response.writeHead(200, { 'Content-Type': 'application/json' }).end()
-        return
-      }
+      if (path === '/healthcheck') return done(response, 200)
 
-      response.writeHead(404, { 'Content-Type': 'application/json' }).end()
-      return
+      return done(response, 404)
     } catch (error) {
-      response
-        .writeHead(400, { 'Content-Type': 'application/json' })
-        .end(JSON.stringify({ message: (error as Error).message }))
-      return
+      return done(response, 400, { message: (error as Error).message })
+    }
+  })
+
+  proxy.on('proxyReq', (proxyReq, req) => {
+    ;(req as any)._proxyReq = proxyReq
+  })
+
+  proxy.on('error', (err, req) => {
+    if (req.socket.destroyed && (err as any).code === 'ECONNRESET') {
+      ;(req as any)._proxyReq.abort()
     }
   })
 
@@ -135,3 +137,9 @@ export function createServer(
     },
   })
 }
+
+function done(res: ServerResponse, statusCode: number, json?: unknown) {
+  return res
+    .writeHead(statusCode, { 'Content-Type': 'application/json' })
+    .end(json ? JSON.stringify(json) : undefined)
+}