@unchainedshop/events 1.1.5 → 1.2.0

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "@unchainedshop/events",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "main": "lib/events-index.js",
+  "exports": {
+    ".": "./lib/events-index.js",
+    "./*": "./lib/*"
+  },
   "types": "lib/events-index.d.ts",
   "type": "module",
   "scripts": {
+    "prepublishOnly": "npm install && npm run build || :",
     "clean": "rm -rf lib",
-    "build": "npm run clean && tsc -p tsconfig.build.json",
-    "watch": "tsc --watch",
-    "link:core": "npm link @unchainedshop/types",
+    "build": "npm run clean && tsc",
+    "watch": "tsc -w",
     "test": "jest --watch"
   },
   "repository": {
@@ -27,23 +31,15 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "redis": "^4.1.0",
-    "@unchainedshop/logger": "1.1.3"
+    "@unchainedshop/logger": "^1.1.9",
+    "redis": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.18.6",
-    "@babel/preset-env": "^7.18.6",
-    "@babel/preset-typescript": "^7.18.6",
-    "@types/chai": "^4.3.1",
     "@types/jest": "^28.1.3",
-    "@types/mocha": "^9.1.1",
-    "@unchainedshop/types": "^1.1.2",
-    "babel-jest": "^28.1.1",
-    "chai": "^4.3.6",
-    "cross-env": "^7.0.3",
-    "jest": "^28.1.1",
+    "@types/node": "^16.11.44",
+    "@unchainedshop/types": "^1.1.9",
+    "jest": "^28.1.2",
     "ts-jest": "^28.0.5",
-    "ts-node": "^10.8.1",
     "typescript": "^4.7.4"
   }
 }

package/src/EventDirector.ts

@@ -0,0 +1,89 @@
+import {
+  ContextNormalizerFunction,
+  EmitAdapter,
+  EventDirector as IEventDirector,
+} from '@unchainedshop/types/events';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:events');
+
+export const defaultNormalizer: ContextNormalizerFunction = (context) => {
+  return {
+    userAgent: context?.userAgent,
+    language: context?.localeContext?.code,
+    country: context?.localeContext?.country,
+    remoteAddress: context?.remoteAddress,
+    referer: context?.req?.headers?.referer,
+    origin: context?.req?.headers?.origin,
+    userId: context?.userId,
+  };
+};
+
+const RegisteredEventsSet = new Set();
+const RegisteredCallbacksSet = new Set();
+
+let Adapter: EmitAdapter; // Public (customizable)
+let HistoryAdapter: EmitAdapter; // (Per default: Core-events adapter to write into DB)
+let ContextNormalizer = defaultNormalizer;
+
+export const EventDirector: IEventDirector = {
+  registerEvents: (events: string[]): void => {
+    if (events.length) {
+      events.forEach((e) => RegisteredEventsSet.add(e));
+      logger.verbose(`EventDirector -> Registered ${JSON.stringify(events)}`);
+    }
+  },
+
+  getRegisteredEvents: (): string[] => {
+    return Array.from(RegisteredEventsSet) as string[];
+  },
+
+  setContextNormalizer: (fn: ContextNormalizerFunction): void => {
+    ContextNormalizer = fn;
+  },
+
+  setEmitAdapter: (adapter: EmitAdapter) => {
+    Adapter = adapter;
+  },
+
+  getEmitAdapter: (): EmitAdapter => Adapter,
+
+  setEmitHistoryAdapter: (adapter: EmitAdapter) => {
+    HistoryAdapter = adapter;
+  },
+
+  getEmitHistoryAdapter: (): EmitAdapter => HistoryAdapter,
+
+  emit: async (eventName: string, data: any): Promise<void> => {
+    const extractedContext = ContextNormalizer(null);
+
+    if (!RegisteredEventsSet.has(eventName))
+      throw new Error(`Event with ${eventName} is not registered`);
+
+    Adapter?.publish(eventName, {
+      payload: { ...data },
+      context: extractedContext,
+    });
+
+    HistoryAdapter?.publish(eventName, {
+      payload: { ...data },
+      context: extractedContext,
+    });
+
+    logger.verbose(`EventDirector -> Emitted ${eventName} with ${JSON.stringify(data)}`);
+  },
+
+  subscribe: (eventName: string, callback: () => void): void => {
+    const currentSubscription = `${eventName}${callback?.toString()}`; // used to avaoid registering the same event handler callback
+
+    if (!RegisteredEventsSet.has(eventName))
+      throw new Error(`Event with ${eventName} is not registered`);
+
+    if (!RegisteredCallbacksSet.has(currentSubscription)) {
+      Adapter?.subscribe(eventName, callback);
+      HistoryAdapter?.subscribe(eventName, callback);
+      RegisteredCallbacksSet.add(currentSubscription);
+      logger.verbose(`EventDirector -> Subscribed to ${eventName}`);
+    }
+  },
+};

package/src/events-index.ts

@@ -0,0 +1,26 @@
+import { EventDirector } from './EventDirector';
+
+const {
+  emit,
+  getEmitAdapter,
+  getEmitHistoryAdapter,
+  getRegisteredEvents,
+  registerEvents,
+  setEmitAdapter,
+  setEmitHistoryAdapter,
+  subscribe,
+} = EventDirector;
+
+const GLOBAL_EVENTS = ['PAGE_VIEW'];
+registerEvents(GLOBAL_EVENTS);
+
+export {
+  emit,
+  getEmitAdapter,
+  getEmitHistoryAdapter,
+  getRegisteredEvents,
+  registerEvents,
+  setEmitAdapter,
+  setEmitHistoryAdapter,
+  subscribe,
+};

package/tests/events-index.test.ts

@@ -0,0 +1,78 @@
+import { assert } from 'chai';
+import {
+  emit,
+  getEmitAdapter,
+  getEmitHistoryAdapter,
+  getRegisteredEvents,
+  registerEvents,
+  setEmitAdapter,
+  setEmitHistoryAdapter,
+} from '../src/events-index';
+import { log } from '@unchainedshop/logger';
+import { EmitAdapter } from '@unchainedshop/types/events';
+
+const subscribedEvents = new Set();
+
+const TestEventEmitter: EmitAdapter = {
+  publish: (eventName, payload) => log(eventName),
+  subscribe: (eventName, callback) => {
+    if (!subscribedEvents.has(eventName)) {
+      log(`Subscribe event: ${eventName}`);
+      subscribedEvents.add(eventName);
+    }
+  },
+};
+
+describe('Test exports', () => {
+  it('Check registered events', () => {
+    let registeredEvents = getRegisteredEvents();
+    const NEW_TEST_EVENT_1 = 'new test event 1';
+    const NEW_TEST_EVENT_2 = 'new test event 2';
+
+    assert.isTrue(registeredEvents.length === 1);
+    assert.isFalse(registeredEvents.includes(NEW_TEST_EVENT_1));
+    assert.isFalse(registeredEvents.includes(NEW_TEST_EVENT_2));
+
+    registerEvents([NEW_TEST_EVENT_1, NEW_TEST_EVENT_2]);
+
+    registeredEvents = getRegisteredEvents();
+
+    assert.isTrue(registeredEvents.length === 3);
+    assert.isTrue(registeredEvents.includes(NEW_TEST_EVENT_1));
+    assert.isTrue(registeredEvents.includes(NEW_TEST_EVENT_2));
+  });
+
+  it('Check set Adapter', () => {
+    assert.isUndefined(getEmitAdapter());
+    assert.isFunction(setEmitAdapter);
+    assert.isFunction(getEmitHistoryAdapter);
+    assert.isFunction(setEmitHistoryAdapter);
+
+    setEmitAdapter(TestEventEmitter);
+  });
+
+  it('Check emit global page event', () => {
+    assert.isFunction(emit);
+
+    emit('PAGE_VIEW');
+  });
+
+  it('Check emit event', () => {
+    assert.isFunction(registerEvents);
+
+    registerEvents(['TEST_EVENT', 'TEST_EVENT_2']);
+    emit('TEST_EVENT');
+  });
+
+  it('Check emit non-existing event', (done) => {
+    emit('I_AM_NOT_REGISTERED_EVENT').then(() => {
+      assert(false, 'Non-existing event should not be emittable')
+      done()
+    }).catch(error => {
+      assert.equal(error.message, 'Event with I_AM_NOT_REGISTERED_EVENT is not registered')
+      done()
+    });
+  });
+
+  
+});

package/{tsconfig.build.json → tsconfig.json}

@@ -6,7 +6,9 @@
     "esModuleInterop": true,
     "experimentalDecorators": true,
     "forceConsistentCasingInFileNames": true,
-    "lib": ["esnext"],
+    "lib": [
+      "esnext"
+    ],
     "module": "esnext",
     "moduleResolution": "node",
     "noImplicitReturns": true,
@@ -16,11 +18,12 @@
     "skipLibCheck": true,
     "sourceMap": true,
     "target": "esnext",
-    "types": ["node"],
-    "baseUrl": ".", // This must be specified if "paths" is.
-    "paths": {
-      "meteor/unchained:*": ["node_modules/@unchainedshop/types/index.d.ts"]
-    }
+    "types": [
+      "node",
+      "jest"
+    ]
   },
-  "include": ["src"]
+  "include": [
+    "src"
+  ]
 }

package/babel.config.js

@@ -1,3 +0,0 @@
-export default {
-  presets: [['@babel/preset-env', { targets: { node: 'current' } }], '@babel/preset-typescript'],
-};