serverless-ircd 0.1.0

package/packages/irc-core/tests/state/connection.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type RegistrationState,
+  createConnection,
+  hostmaskOf,
+  toSnapshot,
+} from '../../src/state/connection';
+
+describe('createConnection', () => {
+  it('creates a pre-registration connection with empty caps and joined channels', () => {
+    const conn = createConnection({
+      id: 'c1',
+      connectedSince: 1_000,
+    });
+    expect(conn.id).toBe('c1');
+    expect(conn.registration).toBe('pre-registration');
+    expect(conn.caps.size).toBe(0);
+    expect(conn.joinedChannels.size).toBe(0);
+    expect(conn.userModes.invisible).toBe(false);
+    expect(conn.userModes.oper).toBe(false);
+    expect(conn.lastSeen).toBe(1_000);
+    expect(conn.connectedSince).toBe(1_000);
+  });
+
+  it('initializes lastSeen to connectedSince when not supplied', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 42 });
+    expect(conn.lastSeen).toBe(42);
+  });
+
+  it('honors an explicit lastSeen', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 10, lastSeen: 99 });
+    expect(conn.lastSeen).toBe(99);
+  });
+});
+
+describe('hostmaskOf', () => {
+  it('returns undefined when nick is missing', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    expect(hostmaskOf(conn)).toBeUndefined();
+  });
+
+  it('builds nick!user@host when all parts are present', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.nick = 'alice';
+    conn.user = 'alice';
+    conn.host = 'example.com';
+    expect(hostmaskOf(conn)).toBe('alice!alice@example.com');
+  });
+
+  it('builds nick@host when user is missing', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.nick = 'alice';
+    conn.host = 'example.com';
+    expect(hostmaskOf(conn)).toBe('alice@example.com');
+  });
+
+  it('builds nick!user when host is missing', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.nick = 'alice';
+    conn.user = 'alice';
+    expect(hostmaskOf(conn)).toBe('alice!alice');
+  });
+
+  it('returns just the nick when only nick is set', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.nick = 'alice';
+    expect(hostmaskOf(conn)).toBe('alice');
+  });
+});
+
+describe('toSnapshot', () => {
+  it('returns a read-only view of the connection state', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 100 });
+    conn.nick = 'bob';
+    conn.user = 'bob';
+    conn.host = 'h';
+    conn.realname = 'Bob';
+    conn.caps.add('server-time');
+    conn.joinedChannels.add('#foo');
+    conn.userModes.invisible = true;
+    conn.away = 'afk';
+
+    const snap = toSnapshot(conn);
+    expect(snap.id).toBe('c1');
+    expect(snap.nick).toBe('bob');
+    expect(snap.hostmask).toBe('bob!bob@h');
+    expect(snap.caps.has('server-time')).toBe(true);
+    expect(snap.joinedChannels.has('#foo')).toBe(true);
+    expect(snap.userModes.invisible).toBe(true);
+    expect(snap.away).toBe('afk');
+    expect(snap.registration).toBe('pre-registration');
+  });
+
+  it('omits hostmask when nick is absent', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const snap = toSnapshot(conn);
+    expect(snap.hostmask).toBeUndefined();
+  });
+
+  it('omits away when not set', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const snap = toSnapshot(conn);
+    expect(snap.away).toBeUndefined();
+  });
+
+  it('includes account in the snapshot when set', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.nick = 'a';
+    conn.account = 'alice';
+    const snap = toSnapshot(conn);
+    expect(snap.account).toBe('alice');
+  });
+
+  it('produces a snapshot whose registration matches the state', () => {
+    const states: RegistrationState[] = ['pre-registration', 'registering', 'registered'];
+    for (const registration of states) {
+      const conn = createConnection({ id: 'c', connectedSince: 0 });
+      conn.registration = registration;
+      expect(toSnapshot(conn).registration).toBe(registration);
+    }
+  });
+});

package/packages/irc-core/tests/state/registry.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { type Registry, createRegistry } from '../../src/state/registry';
+
+describe('createRegistry', () => {
+  it('returns an empty nick map', () => {
+    const r = createRegistry();
+    expect(r.nicks.size).toBe(0);
+  });
+});
+
+describe('Registry', () => {
+  it('accepts Map operations on the nicks field', () => {
+    const r: Registry = createRegistry();
+    r.nicks.set('alice', 'c1');
+    expect(r.nicks.get('alice')).toBe('c1');
+    expect(r.nicks.size).toBe(1);
+    r.nicks.delete('alice');
+    expect(r.nicks.size).toBe(0);
+  });
+});

package/packages/irc-core/tests/types.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest';
+import type { RawLine } from '../src/effects';
+import { Effect as EffectValue } from '../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../src/ports';
+import { createConnection } from '../src/state/connection';
+import {
+  type Ctx,
+  type Reducer,
+  type ReducerResult,
+  type ServerConfig,
+  buildCtx,
+} from '../src/types';
+
+function makeCtx(): Ctx {
+  const serverConfig: ServerConfig = {
+    serverName: 'irc.example.com',
+    networkName: 'ExampleNet',
+    maxChannelsPerUser: 30,
+    maxTargetsPerCommand: 10,
+    maxListEntries: 50,
+    nickLen: 30,
+    channelLen: 50,
+    topicLen: 390,
+    quitMessage: 'Client Quit',
+  };
+  return buildCtx({
+    serverConfig,
+    clock: new FakeClock(1_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: createConnection({ id: 'c1', connectedSince: 0 }),
+  });
+}
+
+interface NoopState {
+  n: number;
+}
+
+describe('Ctx / Reducer types', () => {
+  it('builds a Ctx from the required ports and config', () => {
+    const ctx = makeCtx();
+    expect(ctx.serverName).toBe('irc.example.com');
+    expect(ctx.networkName).toBe('ExampleNet');
+    expect(ctx.clock.now()).toBe(1_000);
+    expect(ctx.ids.batchId()).toBe('batch-0');
+    expect(ctx.connection.id).toBe('c1');
+  });
+
+  it('exposes the connection id directly on ctx', () => {
+    const ctx = makeCtx();
+    expect(ctx.connId).toBe('c1');
+  });
+
+  it('supports a pure reducer that emits no effects', () => {
+    const noop: Reducer<NoopState> = (state) => ({ state, effects: [] });
+    const out: ReducerResult<NoopState> = noop(
+      { n: 0 },
+      { command: 'PING', params: [], tags: {} },
+      makeCtx(),
+    );
+    expect(out.effects).toEqual([]);
+  });
+
+  it('supports a reducer that emits a Send effect', () => {
+    const pingBack: Reducer<NoopState> = (_state, msg, ctx) => {
+      const token = msg.params[0] ?? '';
+      const lines: RawLine[] = [{ text: `PONG :${token}` }];
+      return {
+        state: { n: 0 },
+        effects: [EffectValue.send(ctx.connId, lines)],
+      };
+    };
+    const out = pingBack({ n: 0 }, { command: 'PING', params: ['tok'], tags: {} }, makeCtx());
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]).toEqual({
+      tag: 'Send',
+      to: 'c1',
+      lines: [{ text: 'PONG :tok' }],
+    });
+  });
+
+  it('Reducer<S> preserves the supplied state type', () => {
+    interface MyState {
+      count: number;
+    }
+    const inc: Reducer<MyState> = (state, _msg, _ctx) => ({
+      state: { count: state.count + 1 },
+      effects: [],
+    });
+    const out = inc({ count: 1 }, { command: 'X', params: [], tags: {} }, makeCtx());
+    expect(out.state.count).toBe(2);
+  });
+
+  it('Ctx carries the IrcMessage being handled via the reducer call, not on ctx itself', () => {
+    // Sanity: the Reducer signature is (state, msg, ctx) — ctx itself is msg-free.
+    const ctx = makeCtx();
+    const keys = Object.keys(ctx) as Array<keyof Ctx>;
+    expect(keys).not.toContain('msg');
+  });
+});
+
+describe('ServerConfig shape', () => {
+  it('exposes every configured knob', () => {
+    const cfg: ServerConfig = {
+      serverName: 's',
+      networkName: 'n',
+      maxChannelsPerUser: 1,
+      maxTargetsPerCommand: 2,
+      maxListEntries: 3,
+      nickLen: 3,
+      channelLen: 4,
+      topicLen: 5,
+      quitMessage: 'bye',
+    };
+    expect(cfg.serverName).toBe('s');
+    expect(cfg.networkName).toBe('n');
+    expect(cfg.maxChannelsPerUser).toBe(1);
+    expect(cfg.maxTargetsPerCommand).toBe(2);
+    expect(cfg.maxListEntries).toBe(3);
+    expect(cfg.nickLen).toBe(3);
+    expect(cfg.channelLen).toBe(4);
+    expect(cfg.topicLen).toBe(5);
+    expect(cfg.quitMessage).toBe('bye');
+  });
+});
+
+// Importing Effect here just to confirm it round-trips through the public surface.

package/packages/irc-core/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "composite": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "./.tsbuildinfo",
+    "types": []
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "tests", "**/*.test.ts"]
+}

package/packages/irc-core/tsconfig.test.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": [],
+    "composite": false
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["dist"]
+}

package/packages/irc-core/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      all: false,
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/index.ts'],
+      reporter: ['text', 'html', 'json-summary'],
+      thresholds: {
+        lines: 100,
+        functions: 100,
+        branches: 100,
+        statements: 100,
+      },
+    },
+  },
+});

package/packages/irc-server/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@serverless-ircd/irc-server",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Orchestration layer: IrcRuntime port, dispatch interpreter, ConnectionActor",
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "clean": "rimraf dist coverage .tsbuildinfo .turbo"
+  },
+  "files": ["dist", "src", "README.md"],
+  "dependencies": {
+    "@serverless-ircd/irc-core": "workspace:*"
+  }
+}