prool 0.0.24 → 0.1.0

package/{pool.test.ts → src/Pool.test.ts}

@@ -1,22 +1,17 @@
 import getPort from 'get-port'
+import { Instance, Pool, Server } from 'prool'
 import { afterEach, beforeAll, describe, expect, test } from 'vitest'
 
-import { altoOptions, rundlerOptions, stackupOptions } from '../test/utils.js'
-import { rundler } from './exports/instances.js'
-import { alto } from './instances/alto.js'
-import { anvil } from './instances/anvil.js'
-import { stackup } from './instances/stackup.js'
-import { definePool } from './pool.js'
-import { createServer } from './server.js'
+import { altoOptions } from '../test/utils.js'
 
-let pool: ReturnType<typeof definePool>
+let pool: ReturnType<typeof Pool.define>
 const port = await getPort()
 
 beforeAll(() =>
-  createServer({
-    instance: anvil({
+  Server.create({
+    instance: Instance.anvil({
       chainId: 1,
-      forkUrl: process.env.VITE_FORK_URL ?? 'https://eth.merkle.io',
+      forkUrl: process.env['VITE_FORK_URL'] ?? 'https://eth.merkle.io',
     }),
     port,
   }).start(),
@@ -31,19 +26,14 @@ afterEach(async () => {
 })
 
 describe.each([
-  { instance: anvil({ port: await getPort() }) },
+  { instance: Instance.anvil({ port: await getPort() }) },
+  { instance: Instance.tempo({ port: await getPort() }) },
   {
-    instance: alto(altoOptions({ port, pool: true })),
-  },
-  {
-    instance: stackup(stackupOptions({ port, pool: true })),
-  },
-  {
-    instance: rundler(rundlerOptions({ port, pool: true })),
+    instance: Instance.alto(altoOptions({ port, pool: true })),
   },
 ])('instance: $instance.name', ({ instance }) => {
   test('default', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -51,7 +41,7 @@ describe.each([
   })
 
   test('start', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -72,7 +62,7 @@ describe.each([
 
   test('callback instance', async () => {
     const keys: (number | string)[] = []
-    pool = definePool({
+    pool = Pool.define({
       instance(key) {
         keys.push(key)
         return instance
@@ -87,7 +77,7 @@ describe.each([
   })
 
   test('stop / destroy', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -124,32 +114,28 @@ describe.each([
     expect(pool.size).toEqual(0)
   })
 
-  test(
-    'restart',
-    async () => {
-      pool = definePool({
-        instance,
-      })
-
-      const instance_1 = await pool.start(1)
-      const instance_2 = await pool.start(2)
-      const instance_3 = await pool.start(3)
-
-      expect(instance_1.status).toBe('started')
-      expect(instance_2.status).toBe('started')
-      expect(instance_3.status).toBe('started')
-      expect(pool.size).toEqual(3)
-
-      const promise_1 = pool.restart(1)
-      expect(instance_1.status).toBe('restarting')
-      await promise_1
-      expect(instance_1.status).toBe('started')
-    },
-    { timeout: 10_000 },
-  )
+  test('restart', { timeout: 10_000 }, async () => {
+    pool = Pool.define({
+      instance,
+    })
+
+    const instance_1 = await pool.start(1)
+    const instance_2 = await pool.start(2)
+    const instance_3 = await pool.start(3)
+
+    expect(instance_1.status).toBe('started')
+    expect(instance_2.status).toBe('started')
+    expect(instance_3.status).toBe('started')
+    expect(pool.size).toEqual(3)
+
+    const promise_1 = pool.restart(1)
+    expect(instance_1.status).toBe('restarting')
+    await promise_1
+    expect(instance_1.status).toBe('started')
+  })
 
   test('start > stop > start', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -164,7 +150,7 @@ describe.each([
   })
 
   test('stopAll / destroyAll', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -182,7 +168,7 @@ describe.each([
   })
 
   test('get', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -196,7 +182,7 @@ describe.each([
   })
 
   test('behavior: start more than once', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -210,7 +196,7 @@ describe.each([
   })
 
   test('behavior: clear more than once', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -227,7 +213,7 @@ describe.each([
   })
 
   test('behavior: restart more than once', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -248,7 +234,7 @@ describe.each([
   })
 
   test('behavior: stop more than once', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -265,7 +251,7 @@ describe.each([
   test('error: start more than once on same port', async () => {
     const port = await getPort()
 
-    pool = definePool({
+    pool = Pool.define({
       instance,
     })
 
@@ -280,7 +266,7 @@ describe.each([
   })
 
   test('error: instance limit reached', async () => {
-    pool = definePool({
+    pool = Pool.define({
       instance,
       limit: 2,
     })

package/{pool.ts → src/Pool.ts}

@@ -1,6 +1,6 @@
 import getPort from 'get-port'
 
-import type { Instance } from './instance.js'
+import type { Instance } from './Instance.js'
 
 type Instance_ = Omit<Instance, 'create'>
 
@@ -14,30 +14,20 @@ export type Pool<key extends number | string = number | string> = Pick<
   destroy(key: key): Promise<void>
   destroyAll(): Promise<void>
   restart(key: key): Promise<void>
-  start(key: key, options?: { port?: number }): Promise<Instance_>
+  start(
+    key: key,
+    options?: { port?: number | undefined } | undefined,
+  ): Promise<Instance_>
   stop(key: key): Promise<void>
   stopAll(): Promise<void>
 }
 
-export type DefinePoolParameters<
-  key extends number | string = number | string,
-> = {
-  /** Instance for the pool. */
-  instance: Instance | ((key: key) => Instance)
-  /** The maximum number of instances that can be started. */
-  limit?: number | number
-}
-
-export type DefinePoolReturnType<
-  key extends number | string = number | string,
-> = Pool<key>
-
 /**
  * Defines an instance pool. Instances can be started, cached, and stopped against an identifier.
  *
  * @example
  * ```
- * const pool = definePool({
+ * const pool = Pool.define({
  *  instance: anvil(),
  * })
  *
@@ -46,9 +36,9 @@ export type DefinePoolReturnType<
  * const instance_3 = await pool.start(3)
  * ```
  */
-export function definePool<key extends number | string = number>(
-  parameters: DefinePoolParameters<key>,
-): DefinePoolReturnType<key> {
+export function define<key extends number | string = number>(
+  parameters: define.Parameters<key>,
+): define.ReturnType<key> {
   const { limit } = parameters
 
   type Instance_ = Omit<Instance, 'create'>
@@ -198,3 +188,15 @@ export function definePool<key extends number | string = number>(
     values: instances.values.bind(instances),
   }
 }
+
+export declare namespace define {
+  export type Parameters<key extends number | string = number | string> = {
+    /** Instance for the pool. */
+    instance: Instance | ((key: key) => Instance)
+    /** The maximum number of instances that can be started. */
+    limit?: number | undefined
+  }
+
+  export type ReturnType<key extends number | string = number | string> =
+    Pool<key>
+}

package/{server.test.ts → src/Server.test.ts}

@@ -1,44 +1,30 @@
 import getPort from 'get-port'
+import { Instance, Server } from 'prool'
 import { beforeAll, describe, expect, test } from 'vitest'
 import { type MessageEvent, WebSocket } from 'ws'
-import {
-  altoOptions,
-  rundlerOptions,
-  siliusOptions,
-  stackupOptions,
-} from '../test/utils.js'
-import { rundler, silius } from './exports/instances.js'
-import { alto } from './instances/alto.js'
-import { anvil } from './instances/anvil.js'
-import { stackup } from './instances/stackup.js'
-import { createServer } from './server.js'
+import { altoOptions } from '../test/utils.js'
 
 const port = await getPort()
 
 beforeAll(async () => {
-  await createServer({
-    instance: anvil({
+  await Server.create({
+    instance: Instance.anvil({
       chainId: 1,
-      forkUrl: process.env.VITE_FORK_URL ?? 'https://eth.merkle.io',
+      forkUrl: process.env['VITE_FORK_URL'] ?? 'https://eth.merkle.io',
     }),
     port,
   }).start()
 })
 
 describe.each([
-  { instance: anvil() },
+  { instance: Instance.anvil({ port: await getPort() }) },
+  { instance: Instance.tempo({ port: await getPort() }) },
   {
-    instance: alto(altoOptions({ port, pool: true })),
-  },
-  {
-    instance: stackup(stackupOptions({ port, pool: true })),
-  },
-  {
-    instance: rundler(rundlerOptions({ port, pool: true })),
+    instance: Instance.alto(altoOptions({ port, pool: true })),
   },
 ])('instance: $instance.name', ({ instance }) => {
   test('default', async () => {
-    const server = createServer({
+    const server = Server.create({
       instance,
     })
     expect(server).toBeDefined()
@@ -59,7 +45,7 @@ describe.each([
   })
 
   test('args: port', async () => {
-    const server = createServer({
+    const server = Server.create({
       instance,
       port: 3000,
     })
@@ -71,7 +57,7 @@ describe.each([
   })
 
   test('args: host', async () => {
-    const server = createServer({
+    const server = Server.create({
       instance,
       host: 'localhost',
       port: 3000,
@@ -85,7 +71,7 @@ describe.each([
   })
 
   test('request: /healthcheck', async () => {
-    const server = createServer({
+    const server = Server.create({
       instance,
     })
 
@@ -98,7 +84,7 @@ describe.each([
   })
 
   test('request: /start + /stop', async () => {
-    const server = createServer({
+    const server = Server.create({
       instance,
     })
 
@@ -127,7 +113,7 @@ describe.each([
   })
 
   test('request: /restart', async () => {
-    const server = createServer({
+    const server = Server.create({
       instance,
     })
 
@@ -142,8 +128,8 @@ describe.each([
 
 describe("instance: 'anvil'", () => {
   test('request: /{id}', async () => {
-    const server = createServer({
-      instance: anvil(),
+    const server = Server.create({
+      instance: Instance.anvil(),
     })
 
     const stop = await server.start()
@@ -253,8 +239,8 @@ describe("instance: 'anvil'", () => {
   })
 
   test('request: /restart', async () => {
-    const server = createServer({
-      instance: anvil(),
+    const server = Server.create({
+      instance: Instance.anvil(),
     })
 
     const stop = await server.start()
@@ -323,8 +309,8 @@ describe("instance: 'anvil'", () => {
   })
 
   test('request: /messages', async () => {
-    const server = createServer({
-      instance: anvil(),
+    const server = Server.create({
+      instance: Instance.anvil(),
     })
 
     const stop = await server.start()
@@ -352,8 +338,8 @@ describe("instance: 'anvil'", () => {
   })
 
   test('ws', async () => {
-    const server = createServer({
-      instance: anvil(),
+    const server = Server.create({
+      instance: Instance.anvil(),
     })
 
     const stop = await server.start()
@@ -380,8 +366,8 @@ describe("instance: 'anvil'", () => {
 
 describe("instance: 'alto'", () => {
   test('request: /{id}', async () => {
-    const server = createServer({
-      instance: alto(altoOptions({ port, pool: true })),
+    const server = Server.create({
+      instance: Instance.alto(altoOptions({ port, pool: true })),
     })
 
     const stop = await server.start()
@@ -413,118 +399,9 @@ describe("instance: 'alto'", () => {
   })
 })
 
-describe("instance: 'stackup'", () => {
-  test('request: /{id}', async () => {
-    const server = createServer({
-      instance: stackup(stackupOptions({ port, pool: true })),
-    })
-
-    const stop = await server.start()
-    const { port: port_2 } = server.address()!
-    const response = await fetch(`http://localhost:${port_2}/1`, {
-      body: JSON.stringify({
-        method: 'eth_supportedEntryPoints',
-        params: [],
-        id: 0,
-        jsonrpc: '2.0',
-      }),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      method: 'POST',
-    })
-    expect(response.status).toBe(200)
-    expect(await response.json()).toMatchInlineSnapshot(`
-        {
-          "id": 0,
-          "jsonrpc": "2.0",
-          "result": [
-            "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-          ],
-        }
-      `)
-
-    await stop()
-  })
-})
-
-describe("instance: 'rundler'", () => {
-  test('request: /{id}', async () => {
-    const server = createServer({
-      instance: rundler(rundlerOptions({ port, pool: true })),
-    })
-
-    const stop = await server.start()
-    const { port: port_2 } = server.address()!
-    const response = await fetch(`http://localhost:${port_2}/1`, {
-      body: JSON.stringify({
-        method: 'eth_supportedEntryPoints',
-        params: [],
-        id: 0,
-        jsonrpc: '2.0',
-      }),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      method: 'POST',
-    })
-    expect(response.status).toBe(200)
-    expect(await response.json()).toMatchInlineSnapshot(`
-      {
-        "id": 0,
-        "jsonrpc": "2.0",
-        "result": [
-          "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
-        ],
-      }
-    `)
-
-    await stop()
-  })
-})
-
-describe("instance: 'silius'", () => {
-  test(
-    'request: /{id}',
-    async () => {
-      const server = createServer({
-        instance: silius(siliusOptions({ port, pool: true })),
-      })
-
-      const stop = await server.start()
-      const { port: port_2 } = server.address()!
-      const response = await fetch(`http://localhost:${port_2}/1`, {
-        body: JSON.stringify({
-          method: 'eth_supportedEntryPoints',
-          params: [],
-          id: 0,
-          jsonrpc: '2.0',
-        }),
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        method: 'POST',
-      })
-      expect(response.status).toBe(200)
-      expect(await response.json()).toMatchInlineSnapshot(`
-      {
-        "id": 0,
-        "jsonrpc": "2.0",
-        "result": [
-          "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
-        ],
-      }
-    `)
-
-      await stop()
-    },
-    { timeout: 10_000 },
-  )
-})
-
 test('404', async () => {
-  const server = createServer({
-    instance: anvil(),
+  const server = Server.create({
+    instance: Instance.anvil(),
   })
 
   const stop = await server.start()

package/{server.ts → src/Server.ts}

@@ -1,18 +1,17 @@
 import {
+  createServer as createServer_,
   type IncomingMessage,
   type Server,
   type ServerResponse,
-  createServer as createServer_,
 } from 'node:http'
 import type { AddressInfo } from 'node:net'
 import httpProxy from 'http-proxy'
-
-import { type DefinePoolParameters, definePool } from './pool.js'
-import { extractPath } from './utils.js'
+import { extractPath } from './internal/utils.js'
+import * as Pool from './Pool.js'
 
 const { createProxyServer } = httpProxy
 
-export type CreateServerParameters = DefinePoolParameters<number> &
+export type CreateServerParameters = Pool.define.Parameters<number> &
   (
     | {
         /** Host to run the server on. */
@@ -40,11 +39,10 @@ export type CreateServerReturnType = Omit<
  *
  * @example
  * ```
- * import { createServer } from 'prool'
- * import { anvil } from 'prool/instances'
+ * import { Instance, Server } from 'prool'
  *
- * const server = createServer({
- *  instance: anvil(),
+ * const server = Server.create({
+ *  instance: Instance.anvil(),
  * })
  *
  * const server = await server.start()
@@ -59,12 +57,12 @@ export type CreateServerReturnType = Omit<
  * // "http://localhost:8545/healthcheck"
  * ```
  */
-export function createServer(
+export function create(
   parameters: CreateServerParameters,
 ): CreateServerReturnType {
   const { host = '::', instance, limit, port } = parameters
 
-  const pool = definePool({ instance, limit })
+  const pool = Pool.define({ instance, limit })
   const proxy = createProxyServer({
     ignorePath: true,
     ws: true,
@@ -72,6 +70,17 @@ export function createServer(
 
   const server = createServer_(async (request, response) => {
     try {
+      if (request.method === 'OPTIONS') {
+        response.writeHead(200, {
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+          'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+          'Access-Control-Max-Age': '86400',
+        })
+        response.end()
+        return
+      }
+
       const url = request.url
       if (!url) {
         response.end()
@@ -121,6 +130,14 @@ export function createServer(
     ;(req as any)._proxyReq = proxyReq
   })
 
+  proxy.on('proxyRes', (proxyRes) => {
+    proxyRes.headers['Access-Control-Allow-Origin'] = '*'
+    proxyRes.headers['Access-Control-Allow-Methods'] =
+      'GET, POST, PUT, DELETE, OPTIONS'
+    proxyRes.headers['Access-Control-Allow-Headers'] =
+      'Content-Type, Authorization'
+  })
+
   proxy.on('error', (err, req) => {
     if (req.socket.destroyed && (err as any).code === 'ECONNRESET') {
       ;(req as any)._proxyReq.abort()
@@ -168,6 +185,11 @@ export function createServer(
 
 function done(res: ServerResponse, statusCode: number, json?: unknown) {
   return res
-    .writeHead(statusCode, { 'Content-Type': 'application/json' })
+    .writeHead(statusCode, {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    })
     .end(json ? JSON.stringify(json) : undefined)
 }

package/src/index.ts

@@ -0,0 +1,3 @@
+export * as Instance from './Instance.js'
+export * as Pool from './Pool.js'
+export * as Server from './Server.js'

package/{instances → src/instances}/alto.test.ts

@@ -1,17 +1,14 @@
 import getPort from 'get-port'
+import { Instance } from 'prool'
 import { afterEach, beforeAll, expect, test } from 'vitest'
-
 import { altoOptions } from '../../test/utils.js'
-import type { Instance } from '../instance.js'
-import { type AltoParameters, alto } from './alto.js'
-import { anvil } from './anvil.js'
 
-const instances: Instance[] = []
+const instances: Instance.Instance[] = []
 
 const port = await getPort()
 
-const defineInstance = (parameters: Partial<AltoParameters> = {}) => {
-  const instance = alto({
+const defineInstance = (parameters: Partial<Instance.alto.Parameters> = {}) => {
+  const instance = Instance.alto({
     ...altoOptions({ port, pool: false }),
     ...parameters,
   })
@@ -20,8 +17,8 @@ const defineInstance = (parameters: Partial<AltoParameters> = {}) => {
 }
 
 beforeAll(() =>
-  anvil({
-    forkUrl: process.env.VITE_FORK_URL ?? 'https://eth.merkle.io',
+  Instance.anvil({
+    forkUrl: process.env['VITE_FORK_URL'] ?? 'https://eth.merkle.io',
     port,
   }).start(),
 )
@@ -64,7 +61,7 @@ test.skip('behavior: instance errored (duplicate ports)', async () => {
   await expect(() => instance_2.start()).rejects.toThrowError()
 })
 
-test('behavior: start and stop multiple times', async () => {
+test.skip('behavior: start and stop multiple times', async () => {
   const instance = defineInstance()
 
   await instance.start()
@@ -100,7 +97,7 @@ test.skip('behavior: can subscribe to stderr', async () => {
 test('behavior: exit', async () => {
   const instance = defineInstance()
 
-  let exitCode: number | null | undefined = undefined
+  let exitCode: number | null | undefined
   instance.on('exit', (code) => {
     exitCode = code
   })