init commit

Author: igor-vorontsov-ew

.babelrc

@@ -0,0 +1,7 @@
+{
+  "presets": [
+    ['@babel/preset-env', {targets: {node: 'current'}}],
+    '@babel/preset-typescript',
+  ],
+  "plugins": []
+}

.eslintrc.js

@@ -0,0 +1,14 @@
+module.exports = {
+  extends: [
+    'airbnb',
+    'airbnb-typescript'
+  ],
+  parserOptions: {
+    project: './tsconfig.json'
+  },
+  rules: {
+    "import/prefer-default-export": 0,
+    "@typescript-eslint/indent": 0,
+    "max-len": "warn"
+  }
+};

.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: "publish npm"
+
+on:
+  release:
+    types: [ created ]
+
+jobs:
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout
+        uses: actions/checkout@v3
+      - name: node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org
+      - name: publish
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.idea

.npmignore

@@ -0,0 +1 @@
+dist/

README.md

@@ -0,0 +1,113 @@
+![Maintaner](https://img.shields.io/badge/maintainer-extrawest.com-blue)
+# Extrawest OCPP 2.0.1 package
+
+Typescript package implementing the JSON version of the Open Charge Point Protocol (OCPP). Currently OCPP 2.0.1 is
+supported.
+
+Open Charge Point Protocol (OCPP, <http://www.openchargealliance.org/>) is a communication protocol between multiple
+charging stations ("charge points") and a single management software ("central system").
+
+## Installation
+
+```
+npm i @extrawest/node-ts-ocpp
+```
+
+## Usage
+
+### Central System
+
+```ts
+import {
+    OcppServer, OcppClientConnection, BootNotificationRequest, BootNotificationResponse,
+} from 'ocpp-ts';
+
+const centralSystemSimple = new OcppServer();
+centralSystemSimple.listen(9220);
+centralSystemSimple.on('connection', (client: OcppClientConnection) => {
+    console.log(`Client ${client.getCpId()} connected`);
+    client.on('close', (code: number, reason: Buffer) => {
+        console.log(`Client ${client.getCpId()} closed connection`, code, reason.toString());
+    });
+
+    client.on('BootNotification', (request: BootNotificationRequest, cb: (response: BootNotificationResponse) => void) => {
+        const response: BootNotificationResponse = {
+            status: 'Accepted',
+            currentTime: new Date().toISOString(),
+            interval: 60,
+        };
+        cb(response);
+    });
+});
+```
+
+### Charging Point
+
+```ts
+import {
+    BootNotificationRequest,
+    BootNotificationResponse,
+    OcppClient, OcppError,
+} from 'ocpp-ts';
+
+const chargingPointSimple = new OcppClient('CP1111');
+chargingPointSimple.on('error', (err: Error) => {
+    console.log(err.message);
+});
+chargingPointSimple.on('close', () => {
+    console.log('Connection closed');
+});
+
+chargingPointSimple.on('connect', async () => {
+    const boot: BootNotificationRequest = {
+        chargingStation: {
+            model: "eParking",
+            vendorName: "NECU-T2"
+        },
+        reason: "Unknown"
+    };
+
+    try {
+        const bootResp: BootNotificationResponse = await chargingPointSimple.callRequest('BootNotification', boot);
+        if (bootResp.status === 'Accepted') {
+            console.log('Bootnotification accepted');
+        }
+    } catch (e) {
+        if (e instanceof Error || e instanceof OcppError) {
+            console.error(e.message);
+        }
+    }
+});
+chargingPointSimple.connect('ws://localhost:9220/');
+```
+
+## Security
+
+Add required certificates for Central System, note from OCPP protocol:
+
+*As some Charge Point implementations are using embedded systems with limited computing
+resources, we impose an additional restriction on the TLS configuration on the server side:*
+
+* The TLS certificate SHALL be an RSA certificate with a size no greater than 2048 bytes
+
+```ts
+centralSystemSimple.on('authorization', (cbId: string, req: IncomingMessage, cb: (err?: Error) => void) => {
+    console.log('authorization', cbId, req.headers.authorization);
+    // validate authorization header
+    // cb(new Error('Unathorized')); // Deny
+    cb(); // Accept
+});
+centralSystemSimple.listen(9220, {
+    cert: fs.readFileSync('cert.pem'),
+    key: fs.readFileSync('key.pem'),
+});
+```
+
+If the central system requires authorization, an authorization header can be placed as the second parameter.
+
+```ts
+chargingPointSimple.connect('wss://eparking.fi/ocpp/', {
+    Authorization: getBasicAuth(),
+});
+```
+

__tests__/OcppProtocolTest.ts

@@ -0,0 +1,25 @@
+import { Protocol } from '../src/impl/Protocol';
+import { OcppServer } from "../src";
+import { Server } from '../src/impl/Server';
+
+describe('OcppProtocol', () => {
+  it('should extract cp id from the url', () => {
+    const cpId = Server.getCpIdFromUrl('ws://localhost/ocpp/service/CP5612')
+    expect(cpId).toBe('CP5612');
+  });
+
+  it('should extract cp and decode correctly', () => {
+    const cpId = Server.getCpIdFromUrl('ws://eparking.fi/ocpp/service/CP%205612')
+    expect(cpId).toBe('CP 5612');
+  });
+
+  it('should strip query parameters from uri', () => {
+    const cpId = Server.getCpIdFromUrl('ws://sub.eparking.fi/ocpp/service/CP%205612?foo=bar')
+    expect(cpId).toBe('CP 5612');
+  });
+
+  it('should return undefined cp id if provided with undefined input', () => {
+    const cpId = Server.getCpIdFromUrl(undefined)
+    expect(cpId).toBe(undefined);
+  });
+});

__tests__/OcppSchemaTest.ts

@@ -0,0 +1,74 @@
+import { Server } from "../src/impl/Server";
+import { SchemaValidator } from "../src/impl/SchemaValidator";
+import BootNotification from "../src/schemas/BootNotification.json"
+
+import {
+  ERROR_FORMATIONVIOLATION,
+  ERROR_PROPERTYCONSTRAINTVIOLATION, ERROR_PROTOCOLERROR, ERROR_TYPECONSTRAINTVIOLATION,
+  OcppError,
+} from "../src/impl/OcppError";
+
+describe('OcppSchema', () => {
+  it('should throw format violation', () => {
+    const validator = new SchemaValidator(BootNotification);
+    const t = () => {
+      validator.validate({test: 'foo'})
+    }
+    expect(t).toThrow(ERROR_FORMATIONVIOLATION)
+  });
+
+  it('should throw type contstrain violation', () => {
+    const validator = new SchemaValidator(BootNotification);
+    const t = () => {
+      validator.validate({
+        chargingStation: {
+          model: 90,
+          vendorName: "sad"
+        },
+        reason: "sdfsdf"
+      })
+    }
+    expect(t).toThrow(ERROR_TYPECONSTRAINTVIOLATION)
+  });
+
+  it('should throw property constrain violation for long string', () => {
+    const validator = new SchemaValidator(BootNotification);
+    const t = () => {
+      validator.validate({
+        chargingStation: {
+          model: "sdassssssssssssssssssssssssssssssssssssssssssssssssss",
+          vendorName: "sad"
+        },
+        reason: "sdfsdf"
+      })
+    }
+    expect(t).toThrow(ERROR_PROPERTYCONSTRAINTVIOLATION)
+  });
+
+  it('should throw protocol error for missing required attribute', () => {
+    const validator = new SchemaValidator(BootNotification);
+    const t = () => {
+      validator.validate({
+        chargingStation: {
+          model: "sda",
+          vendorName: "sad"
+        }
+      })
+    }
+    expect(t).toThrow(ERROR_PROTOCOLERROR)
+  });
+
+  it('should throw property violation for invalid enum value', () => {
+    const validator = new SchemaValidator(BootNotification);
+    const t = () => {
+      validator.validate({
+        chargingStation: {
+          model: "sda",
+          vendorName: "sad"
+        },
+        reason: "sdfsdf"
+      })
+    }
+    expect(t).toThrow(ERROR_PROPERTYCONSTRAINTVIOLATION)
+  });
+});

dist/examples/CentralSystemSecure.d.ts

@@ -0,0 +1 @@
+export {};

dist/examples/CentralSystemSecure.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
+var src_1 = require("../src/");
+var cs = new src_1.OcppServer();
+cs.on('connection', function (client) {
+    console.log("Client ".concat(client.getCpId(), " connected"));
+    client.on('close', function (code, reason) {
+        console.log("Client ".concat(client.getCpId(), " closed connection"), code, reason.toString());
+    });
+    client.on('BootNotification', function (request, cb) {
+        var response = {
+            status: 'Accepted',
+            currentTime: new Date().toISOString(),
+            interval: 60,
+        };
+        cb(response);
+    });
+});
+cs.on('authorization', function (cbId, req, cb) {
+    console.log('authorization', cbId, req.headers.authorization);
+    // validate authorization header
+    // cb(new Error('Unathorized')); // Deny
+    cb(); // Accept
+});
+cs.listen(9220, {
+    cert: fs_1.default.readFileSync('cert.pem'),
+    key: fs_1.default.readFileSync('key.pem'),
+});