npm uninstall ocpp-protocol-proxy
npm install ocpp-ws-io@beta

import {
  OCPPProtocolProxy,
  OcppWsIoAdapter,
  presets,
} from "ocpp-ws-io/proxy";

async function main() {
  // 1. Create the proxy targeting your 2.1 CSMS
  const proxy = new OCPPProtocolProxy({
    upstreamEndpoint: "ws://csms.example.com:9000/ocpp",
    upstreamProtocol: "ocpp2.1",
  });

  // 2. Load all built-in translation presets
  proxy.translate(presets.ocpp16_to_ocpp21);

  // 3. Create a transport adapter that accepts 1.6 chargers
  const adapter = new OcppWsIoAdapter({
    port: 9001,
    protocols: ["ocpp1.6"],
  });

  // 4. Wire up event listeners
  proxy.on("connection", (identity, protocol) => {
    console.log(`✅ ${identity} connected (${protocol})`);
  });

  proxy.on("disconnect", (identity) => {
    console.log(`❌ ${identity} disconnected`);
  });

  proxy.on("translationError", (err, _msg, ctx) => {
    console.error(`⚠️ Translation error [${ctx.identity}]:`, err.message);
  });

  // 5. Start listening
  await proxy.listenOnAdapter(adapter);
  console.log("🔌 OCPP Protocol Proxy running on port 9001");
}

main().catch(console.error);

npx tsx main.ts

import {
  corePreset,         // Core profile (mandatory) — 16 messages
  smartChargingPreset, // Smart Charging — 3 messages
  firmwarePreset,      // Firmware Management — 4 messages
  reservationPreset,   // Reservation — 2 messages
  localAuthPreset,     // Local Auth List — 2 messages
} from "ocpp-ws-io/proxy";

// Register only the profiles you need
proxy.translate(corePreset);
proxy.translate(smartChargingPreset);

proxy.translate({
  // Spread all preset mappings
  ...presets.ocpp16_to_ocpp21,

  // Override specific upstream actions
  upstream: {
    ...presets.ocpp16_to_ocpp21.upstream,

    // Custom StartTransaction handler with business logic
    "ocpp1.6:StartTransaction": async (params, ctx) => {
      // Access the session store for stateful logic
      const customData = await ctx.session.get(ctx.identity, "myCustomKey");

      console.log(`Custom StartTx for ${ctx.identity}`, params);

      return {
        action: "TransactionEvent",
        payload: {
          eventType: "Started",
          timestamp: new Date().toISOString(),
          triggerReason: "Authorized",
          seqNo: 0,
          transactionInfo: {
            transactionId: crypto.randomUUID(),
          },
          // ... your custom field mapping
        },
      };
    },
  },
});

type TranslationResult = {
  action?: string; // Target action name (optional — keeps original if omitted)
  payload: object; // Translated payload, sent as JSON
};

import type { ProxyMiddleware } from "ocpp-ws-io/proxy";

const loggingMiddleware: ProxyMiddleware = async (
  message,
  context,
  direction,
  phase,
) => {
  console.log(
    `[${new Date().toISOString()}] [${phase}] [${direction}] ` +
    `[${context.identity}] ` +
    `${context.sourceProtocol} → ${context.targetProtocol}`,
    JSON.stringify(message, null, 2),
  );

  // Return undefined to pass the message through unchanged
  return undefined;
};

const proxy = new OCPPProtocolProxy({
  upstreamEndpoint: "ws://csms:9000",
  upstreamProtocol: "ocpp2.1",
  middlewares: [loggingMiddleware],
});

const validationMiddleware: ProxyMiddleware = async (
  message,
  context,
  direction,
  phase,
) => {
  if (phase !== "post") return undefined; // only validate after translation

  // Reject messages missing required fields
  if (message.type === 2 && !message.action) {
    throw new Error(`Translated message for ${context.identity} has no action`);
  }

  return undefined;
};

import { createTelemetryMiddleware } from "ocpp-ws-io/proxy";

const proxy = new OCPPProtocolProxy({
  upstreamEndpoint: "ws://csms:9000",
  upstreamProtocol: "ocpp2.1",
  middlewares: [
    createTelemetryMiddleware({
      onLatency: (action, ms, ctx, direction) =>
        metrics.histogram("proxy.translation_ms", ms, { action, direction }),
    }),
  ],
});

interface ISessionStore {
  set(identity: string, key: string, value: ProxyValue): Promise<void>;
  get<T extends ProxyValue = ProxyValue>(identity: string, key: string): Promise<T | undefined>;
  delete(identity: string, key: string): Promise<void>;
  clear(identity: string): Promise<void>;
}

import { InMemorySessionStore } from "ocpp-ws-io/proxy";

// This is the default — you don't need to pass it explicitly
const proxy = new OCPPProtocolProxy({
  upstreamEndpoint: "ws://csms:9000",
  upstreamProtocol: "ocpp2.1",
  sessionStore: new InMemorySessionStore(),
});

import type { ISessionStore, ProxyValue } from "ocpp-ws-io/proxy";
import Redis from "ioredis";

class RedisSessionStore implements ISessionStore {
  private redis = new Redis();

  private key(identity: string, key: string) {
    return `ocpp-proxy:${identity}:${key}`;
  }

  async set(identity: string, key: string, value: ProxyValue): Promise<void> {
    await this.redis.set(this.key(identity, key), JSON.stringify(value));
  }

  async get<T extends ProxyValue = ProxyValue>(identity: string, key: string): Promise<T | undefined> {
    const raw = await this.redis.get(this.key(identity, key));
    return raw ? JSON.parse(raw) as T : undefined;
  }

  async delete(identity: string, key: string): Promise<void> {
    await this.redis.del(this.key(identity, key));
  }

  async clear(identity: string): Promise<void> {
    const keys = await this.redis.keys(`ocpp-proxy:${identity}:*`);
    if (keys.length) await this.redis.del(...keys);
  }
}

import type { ITransportAdapter, IConnection, OCPPMessage } from "ocpp-ws-io/proxy";

class MyCustomAdapter implements ITransportAdapter {
  async listen(onConnection: (connection: IConnection) => void): Promise<void> {
    // Set up your transport (MQTT, HTTP polling, gRPC, etc.)
    // When a new client connects, create an IConnection and call:
    onConnection({
      identity: "CP-001",
      protocol: "ocpp1.6",
      async send(message: OCPPMessage) {
        // Send the translated message to the client
        return undefined;
      },
      onMessage(handler) {
        // Register the handler for incoming messages
      },
      onClose(handler) {
        // Register the handler for disconnections
      },
    });
  }

  async close(): Promise<void> {
    // Clean up transport resources
  }
}

process.on("SIGTERM", async () => {
  console.log("Shutting down proxy...");

  // Disconnects all clients and closes all transport adapters
  await proxy.close();

  console.log("Proxy shut down cleanly.");
  process.exit(0);
});

ocpp-ws-io/
├── src/proxy/
│   ├── core/
│   │   ├── types.ts          # OCPPMessage, TranslationMap, ITransportAdapter, IConnection
│   │   ├── translator.ts     # Pure translation engine (no side effects)
│   │   └── session.ts        # ISessionStore interface + InMemorySessionStore
│   ├── presets/
│   │   ├── index.ts          # mergePresets() + combined presets.ocpp16_to_ocpp21
│   │   ├── core.ts           # Core profile — 16 messages
│   │   ├── smart-charging.ts # Smart Charging — 3 messages
│   │   ├── firmware.ts       # Firmware Management — 4 messages
│   │   ├── reservation.ts    # Reservation — 2 messages
│   │   ├── local-auth.ts     # Local Auth List — 2 messages
│   │   └── status-enums.ts   # StatusNotification enum mapping tables
│   ├── adapters/
│   │   └── ocpp-ws-io.adapter.ts  # WebSocket adapter via ocpp-ws-io
│   ├── middlewares/
│   │   └── telemetry.ts      # Latency tracking middleware
│   ├── proxy.ts              # OCPPProtocolProxy orchestrator
│   └── index.ts              # Public API exports (ocpp-ws-io/proxy)
└── test/proxy/
    ├── proxy.test.ts         # Integration tests
    └── presets/              # Unit tests for every preset module