rivetkit/dist/tsup/chunk-R2S45MO6.js

Lightweight libraries for building stateful actors on edge platforms

import {
  createFileSystemOrMemoryDriver,
  createManagerRouter
} from "./chunk-VJRXZPTT.js";
import {
  configureInspectorAccessToken
} from "./chunk-KL4V2ULR.js";
import {
  createClientWithDriver
} from "./chunk-H7E2UU23.js";
import {
  RunnerConfigSchema
} from "./chunk-QRFXXTLG.js";
import {
  getLogger
} from "./chunk-7E5K3375.js";

// src/test/mod.ts
import { createServer } from "net";
import { serve as honoServe } from "@hono/node-server";
import { createNodeWebSocket } from "@hono/node-ws";
import { vi } from "vitest";

// src/test/config.ts
import { z } from "zod";
var ConfigSchema = RunnerConfigSchema.removeDefault().extend({
  hostname: z.string().optional().default(process.env.HOSTNAME ?? "127.0.0.1"),
  port: z.number().optional().default(Number.parseInt(process.env.PORT ?? "8080"))
}).default({});

// src/test/log.ts
function logger() {
  return getLogger("test");
}

// src/test/mod.ts
function serve(registry, inputConfig) {
  inputConfig ??= {};
  const config = ConfigSchema.parse(inputConfig);
  let upgradeWebSocket;
  if (!config.getUpgradeWebSocket) {
    config.getUpgradeWebSocket = () => upgradeWebSocket;
  }
  const runConfig = RunnerConfigSchema.parse(inputConfig);
  const driver = inputConfig.driver ?? createFileSystemOrMemoryDriver(false);
  const managerDriver = driver.manager(registry.config, config);
  const client = createClientWithDriver(managerDriver);
  configureInspectorAccessToken(config, managerDriver);
  const { router } = createManagerRouter(
    registry.config,
    runConfig,
    managerDriver,
    driver,
    client
  );
  const nodeWebSocket = createNodeWebSocket({ app: router });
  upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
  const server = honoServe({
    fetch: router.fetch,
    hostname: config.hostname,
    port: config.port
  });
  nodeWebSocket.injectWebSocket(server);
  logger().info({
    msg: "rivetkit started",
    hostname: config.hostname,
    port: config.port,
    definitions: Object.keys(registry.config.use).length
  });
  return server;
}
async function setupTest(c, registry) {
  vi.useFakeTimers();
  const mockDriverContext = {};
  const setDriverContextFn = (ctx) => {
    mockDriverContext.current = ctx;
  };
  const port = await getPort();
  const server = serve(registry, { port });
  c.onTestFinished(
    async () => await new Promise((resolve) => server.close(() => resolve()))
  );
  throw "TODO: Fix engine port";
}
async function getPort() {
  const MIN_PORT = 1e4;
  const MAX_PORT = 65535;
  const getRandomPort = () => Math.floor(Math.random() * (MAX_PORT - MIN_PORT + 1)) + MIN_PORT;
  let port = getRandomPort();
  let maxAttempts = 10;
  while (maxAttempts > 0) {
    try {
      const server = await new Promise((resolve, reject) => {
        const server2 = createServer();
        server2.once("error", (err) => {
          if (err.code === "EADDRINUSE") {
            reject(new Error(`Port ${port} is in use`));
          } else {
            reject(err);
          }
        });
        server2.once("listening", () => {
          resolve(server2);
        });
        server2.listen(port);
      });
      await new Promise((resolve) => {
        server.close(() => resolve());
      });
      return port;
    } catch (err) {
      maxAttempts--;
      if (maxAttempts <= 0) {
        break;
      }
      port = getRandomPort();
    }
  }
  throw new Error("Could not find an available port after multiple attempts");
}

export {
  setupTest,
  getPort
};
//# sourceMappingURL=chunk-R2S45MO6.js.map