@unchainedshop/core-events 1.1.3 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/core-events",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "main": "lib/events-index.js",
   "types": "lib/events-index.d.ts",
   "type": "module",
@@ -27,14 +27,17 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/events": "latest",
-    "@unchainedshop/utils": "latest",
+    "@unchainedshop/utils": "1.1.3",
     "simpl-schema": "^1.12.2"
   },
+  "peerDependencies": {
+    "@unchainedshop/events": "1.1.3"
+  },
   "devDependencies": {
     "@types/chai": "^4.3.1",
     "@types/mocha": "^9.1.1",
-    "@unchainedshop/types": "latest",
+    "@unchainedshop/events": "1.1.3",
+    "@unchainedshop/types": "^1.1.2",
     "chai": "^4.3.6",
     "cross-env": "^7.0.3",
     "isomorphic-unfetch": "^3.1.0",

package/src/db/EventsCollection.ts

@@ -0,0 +1,29 @@
+import { Db } from '@unchainedshop/types/common';
+import { Event } from '@unchainedshop/types/events';
+import { buildDbIndexes } from '@unchainedshop/utils';
+
+const TWO_DAYS_SEC = 172800;
+
+export const EventsCollection = async (db: Db) => {
+  const Events = db.collection<Event>('events');
+
+  await buildDbIndexes(Events, [
+    {
+      index: { created: -1 },
+      options: { expireAfterSeconds: TWO_DAYS_SEC, name: 'created' },
+    },
+    { index: { type: 1 }, options: { name: 'type' } },
+    {
+      index: { _id: 'text', type: 'text' },
+      options: {
+        weights: {
+          _id: 8,
+          type: 4,
+        },
+        name: 'events_fulltext_search',
+      },
+    },
+  ]);
+
+  return Events;
+};

package/src/db/EventsSchema.js

@@ -0,0 +1,12 @@
+import { Schemas } from '@unchainedshop/utils';
+import SimpleSchema from 'simpl-schema';
+
+export const EventsSchema = new SimpleSchema(
+  {
+    type: { type: String, required: true },
+    payload: { type: Object, blackbox: true },
+    context: { type: Object, blackbox: true },
+    ...Schemas.timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/events-index.ts

@@ -0,0 +1 @@
+export { configureEventsModule } from './module/configureEventsModule';

package/src/module/configureEventHistoryAdapter.ts

@@ -0,0 +1,21 @@
+import { ModuleMutations } from '@unchainedshop/types/common';
+import { Event, EmitAdapter } from '@unchainedshop/types/events';
+import { getEmitHistoryAdapter, setEmitHistoryAdapter } from '@unchainedshop/events';
+
+export const configureEventHistoryAdapter = (mutations: ModuleMutations<Event>) => {
+  if (!getEmitHistoryAdapter()) {
+    const adapter: EmitAdapter = {
+      subscribe: () => {
+        // Do nothing
+      },
+      publish: async (eventName, { payload, context = {} }) => {
+        await mutations.create({
+          type: eventName,
+          payload,
+          context,
+        });
+      },
+    };
+    setEmitHistoryAdapter(adapter);
+  }
+};

package/src/module/configureEventsModule.ts

@@ -0,0 +1,56 @@
+import { generateDbFilterById, generateDbMutations, buildSortOptions } from '@unchainedshop/utils';
+import { ModuleInput, ModuleMutations, Filter } from '@unchainedshop/types/common';
+import { Event, EventQuery, EventsModule } from '@unchainedshop/types/events';
+import { getRegisteredEvents } from '@unchainedshop/events';
+import { EventsCollection } from '../db/EventsCollection';
+import { EventsSchema } from '../db/EventsSchema';
+import { configureEventHistoryAdapter } from './configureEventHistoryAdapter';
+
+const buildFindSelector = ({ types, queryString, created }: EventQuery) => {
+  const selector: { type?: any; $text?: any; created?: any } = {};
+
+  if (types && Array.isArray(types)) selector.type = { $in: types };
+  if (queryString) selector.$text = { $search: queryString };
+  if (created) selector.created = { $gte: created };
+  return selector;
+};
+
+export const configureEventsModule = async ({
+  db,
+}: ModuleInput<Record<string, never>>): Promise<EventsModule> => {
+  const Events = await EventsCollection(db);
+
+  const mutations = generateDbMutations<Event>(Events, EventsSchema, {
+    hasCreateOnly: true,
+  }) as ModuleMutations<Event>;
+
+  configureEventHistoryAdapter(mutations);
+
+  return {
+    ...mutations,
+    findEvent: async ({ eventId, ...rest }, options) => {
+      const selector = eventId ? generateDbFilterById(eventId) : rest;
+      return Events.findOne(selector as unknown as Filter<Event>, options);
+    },
+
+    findEvents: async ({ limit, offset, sort, ...query }) => {
+      return Events.find(buildFindSelector(query), {
+        skip: offset,
+        limit,
+        sort: buildSortOptions(sort || [{ key: 'created', value: 'DESC' }]),
+      }).toArray();
+    },
+
+    type: (event) => {
+      if (getRegisteredEvents().includes(event.type)) {
+        return event.type;
+      }
+      return 'UNKNOWN';
+    },
+
+    count: async (query) => {
+      const count = await Events.countDocuments(buildFindSelector(query));
+      return count;
+    },
+  };
+};