prool 0.0.25 → 0.1.1

package/{instance.ts → src/Instance.ts}

@@ -1,5 +1,9 @@
 import { EventEmitter } from 'eventemitter3'
 
+export { alto } from './instances/alto.js'
+export { anvil } from './instances/anvil.js'
+export { tempo, tempoDocker } from './instances/tempo.js'
+
 type EventTypes = {
   exit: [code: number | null, signal: NodeJS.Signals | null]
   listening: []
@@ -8,34 +12,6 @@ type EventTypes = {
   stdout: [message: string]
 }
 
-export type InstanceStartOptions_internal = {
-  emitter: EventEmitter<EventTypes>
-  status: Instance['status']
-}
-export type InstanceStopOptions_internal = {
-  emitter: EventEmitter<EventTypes>
-  status: Instance['status']
-}
-
-export type InstanceStartOptions = {
-  /**
-   * Port to start the instance on.
-   */
-  port?: number | undefined
-}
-
-export type DefineInstanceFn<
-  parameters,
-  _internal extends object | undefined = object | undefined,
-> = (parameters: parameters) => Pick<Instance, 'host' | 'name' | 'port'> & {
-  _internal?: _internal | undefined
-  start(
-    options: InstanceStartOptions,
-    options_internal: InstanceStartOptions_internal,
-  ): Promise<void>
-  stop(options_internal: InstanceStopOptions_internal): Promise<void>
-}
-
 export type Instance<
   _internal extends object | undefined = object | undefined,
 > = Pick<
@@ -111,15 +87,6 @@ export type InstanceOptions = {
   timeout?: number
 }
 
-export type DefineInstanceReturnType<
-  _internal extends object | undefined = object | undefined,
-  parameters = undefined,
-> = (
-  ...parameters: parameters extends undefined
-    ? [options?: InstanceOptions]
-    : [parameters: parameters, options?: InstanceOptions]
-) => Instance<_internal>
-
 /**
  * Creates an instance definition.
  *
@@ -127,7 +94,7 @@ export type DefineInstanceReturnType<
  *
  * @example
  * ```ts
- * const foo = defineInstance((parameters: FooParameters) => {
+ * const foo = Instance.define((parameters: FooParameters) => {
  *  return {
  *    name: 'foo',
  *    host: 'localhost',
@@ -142,20 +109,22 @@ export type DefineInstanceReturnType<
  * })
  * ```
  */
-export function defineInstance<
+export function define<
   _internal extends object | undefined,
   parameters = undefined,
 >(
-  fn: DefineInstanceFn<parameters, _internal>,
-): DefineInstanceReturnType<_internal, parameters> {
+  fn: define.DefineFn<parameters, _internal>,
+): define.ReturnType<_internal, parameters> {
   return (...[parametersOrOptions, options_]) => {
     function create(createParameters: Parameters<Instance['create']>[0] = {}) {
       const parameters = parametersOrOptions as parameters
       const options = options_ || parametersOrOptions || {}
 
+      const instance = fn(parameters)
       const { _internal, host, name, port, start, stop } = {
-        ...fn(parameters),
+        ...instance,
         ...createParameters,
+        port: createParameters.port ?? instance.port,
       }
       const { messageBuffer = 20, timeout } = options
 
@@ -308,3 +277,43 @@ export function defineInstance<
     return Object.assign(create(), { create })
   }
 }
+
+export declare namespace define {
+  export type DefineFn<
+    parameters,
+    _internal extends object | undefined = object | undefined,
+  > = (parameters: parameters) => Pick<Instance, 'host' | 'name' | 'port'> & {
+    _internal?: _internal | undefined
+    start(
+      options: InstanceStartOptions,
+      options_internal: InstanceStartOptions_internal,
+    ): Promise<void>
+    stop(options_internal: InstanceStopOptions_internal): Promise<void>
+  }
+
+  export type ReturnType<
+    _internal extends object | undefined = object | undefined,
+    parameters = undefined,
+  > = (
+    ...parameters: parameters extends undefined
+      ? [options?: InstanceOptions]
+      : [parameters: parameters, options?: InstanceOptions]
+  ) => Instance<_internal>
+
+  export type InstanceStartOptions_internal = {
+    emitter: EventEmitter<EventTypes>
+    status: Instance['status']
+  }
+
+  export type InstanceStopOptions_internal = {
+    emitter: EventEmitter<EventTypes>
+    status: Instance['status']
+  }
+
+  export type InstanceStartOptions = {
+    /**
+     * Port to start the instance on.
+     */
+    port?: number | undefined
+  }
+}

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()