@graphql-yoga/subscription 0.0.0

package/createPubSub.d.ts

@@ -0,0 +1,35 @@
+import { Repeater } from '@repeaterjs/repeater';
+import { TypedEventTarget } from './typed-event-target';
+declare type PubSubPublishArgsByKey = {
+    [key: string]: [] | [any] | [number | string, any];
+};
+declare type EventAPI = {
+    Event: typeof Event;
+    EventTarget: typeof EventTarget;
+};
+export declare type PubSubEvent<TPubSubPublishArgsByKey extends PubSubPublishArgsByKey, TKey extends Extract<keyof TPubSubPublishArgsByKey, string>> = Event & {
+    data?: TPubSubPublishArgsByKey[TKey][1] extends undefined ? TPubSubPublishArgsByKey[TKey][0] : TPubSubPublishArgsByKey[TKey][1];
+};
+export declare type PubSubEventTarget<TPubSubPublishArgsByKey extends PubSubPublishArgsByKey> = TypedEventTarget<PubSubEvent<TPubSubPublishArgsByKey, Extract<keyof TPubSubPublishArgsByKey, string>>>;
+export declare type ChannelPubSubConfig<TPubSubPublishArgsByKey extends PubSubPublishArgsByKey> = {
+    /**
+     * The event target. If not specified an (in-memory) EventTarget will be created.
+     * For multiple server replica or serverless environments a distributed EventTarget is recommended.
+     *
+     * An event dispatched on the event target MUST have a `data` property.
+     */
+    eventTarget?: PubSubEventTarget<TPubSubPublishArgsByKey>;
+    /**
+     * Event and EventTarget implementation.
+     * Providing this is mandatory for a Node.js versions below 16.
+     */
+    event?: EventAPI;
+};
+/**
+ * Utility for publishing and subscribing to events.
+ */
+export declare const createPubSub: <TPubSubPublishArgsByKey extends PubSubPublishArgsByKey>(config?: ChannelPubSubConfig<TPubSubPublishArgsByKey> | undefined) => {
+    publish<TKey extends Extract<keyof TPubSubPublishArgsByKey, string>>(routingKey: TKey, ...args: TPubSubPublishArgsByKey[TKey]): void;
+    subscribe<TKey_1 extends Extract<keyof TPubSubPublishArgsByKey, string>>(...[routingKey, id]: TPubSubPublishArgsByKey[TKey_1][1] extends undefined ? [TKey_1] : [TKey_1, TPubSubPublishArgsByKey[TKey_1][0]]): Repeater<TPubSubPublishArgsByKey[TKey_1][1] extends undefined ? TPubSubPublishArgsByKey[TKey_1][0] : TPubSubPublishArgsByKey[TKey_1][1], any, unknown>;
+};
+export {};

package/index.d.ts

@@ -0,0 +1,4 @@
+export { createPubSub } from './createPubSub';
+export type { PubSubEventTarget, PubSubEvent } from './createPubSub';
+export { map } from './operator/map';
+export { filter } from './operator/filter';

package/index.js

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const repeater = require('@repeaterjs/repeater');
+
+const resolveGlobalConfig = (api = globalThis) => {
+    if (!api.Event || !api.EventTarget) {
+        throw new Error(`
+[@graphql-yoga/subscription] 'createPubSub' uses the Event and EventTarget APIs.
+
+In modern JavaScript environments those are part of the global scope. However, if you are using an older version of Node.js (<= 16.x.x), those APIs must be polyfilled.
+You can provide polyfills to the 'createPubSub' function:
+
+\`\`\`
+// yarn install @ungap/event @ungap/event-target
+import Event from '@ungap/event'
+import EventTarget from '@ungap/event-target'
+
+const pubSub = createPubSub({
+event: {
+    Event,
+    EventTarget,
+}
+})
+\`\`\`
+`);
+    }
+    return globalThis;
+};
+/**
+ * Utility for publishing and subscribing to events.
+ */
+const createPubSub = (config) => {
+    var _a;
+    const { Event, EventTarget } = resolveGlobalConfig(config === null || config === void 0 ? void 0 : config.event);
+    const target = (_a = config === null || config === void 0 ? void 0 : config.eventTarget) !== null && _a !== void 0 ? _a : new EventTarget();
+    return {
+        publish(routingKey, ...args) {
+            const event = new Event(routingKey);
+            event.data = args[0];
+            target.dispatchEvent(event);
+        },
+        subscribe(...[routingKey, id]) {
+            const topic = id === undefined ? routingKey : `${routingKey}:${id}`;
+            return new repeater.Repeater(function subscriptionRepeater(next, stop) {
+                stop.then(function subscriptionRepeaterStopHandler() {
+                    target.removeEventListener(topic, pubsubEventListener);
+                });
+                target.addEventListener(topic, pubsubEventListener);
+                function pubsubEventListener(event) {
+                    next(event.data);
+                }
+            });
+        },
+    };
+};
+
+/**
+ * Utility for mapping an event stream.
+ */
+const map = (mapper) => (source) => new repeater.Repeater(async (push, stop) => {
+    stop.then(() => {
+        source.return();
+    });
+    for await (const value of source) {
+        push(await mapper(value));
+    }
+});
+
+function filter(filter) {
+    return (source) => new repeater.Repeater(async (push, stop) => {
+        stop.then(() => {
+            source.return();
+        });
+        for await (const value of source) {
+            if (filter(value)) {
+                push(value);
+            }
+        }
+    });
+}
+
+exports.createPubSub = createPubSub;
+exports.filter = filter;
+exports.map = map;

package/index.mjs

@@ -0,0 +1,80 @@
+import { Repeater } from '@repeaterjs/repeater';
+
+const resolveGlobalConfig = (api = globalThis) => {
+    if (!api.Event || !api.EventTarget) {
+        throw new Error(`
+[@graphql-yoga/subscription] 'createPubSub' uses the Event and EventTarget APIs.
+
+In modern JavaScript environments those are part of the global scope. However, if you are using an older version of Node.js (<= 16.x.x), those APIs must be polyfilled.
+You can provide polyfills to the 'createPubSub' function:
+
+\`\`\`
+// yarn install @ungap/event @ungap/event-target
+import Event from '@ungap/event'
+import EventTarget from '@ungap/event-target'
+
+const pubSub = createPubSub({
+event: {
+    Event,
+    EventTarget,
+}
+})
+\`\`\`
+`);
+    }
+    return globalThis;
+};
+/**
+ * Utility for publishing and subscribing to events.
+ */
+const createPubSub = (config) => {
+    var _a;
+    const { Event, EventTarget } = resolveGlobalConfig(config === null || config === void 0 ? void 0 : config.event);
+    const target = (_a = config === null || config === void 0 ? void 0 : config.eventTarget) !== null && _a !== void 0 ? _a : new EventTarget();
+    return {
+        publish(routingKey, ...args) {
+            const event = new Event(routingKey);
+            event.data = args[0];
+            target.dispatchEvent(event);
+        },
+        subscribe(...[routingKey, id]) {
+            const topic = id === undefined ? routingKey : `${routingKey}:${id}`;
+            return new Repeater(function subscriptionRepeater(next, stop) {
+                stop.then(function subscriptionRepeaterStopHandler() {
+                    target.removeEventListener(topic, pubsubEventListener);
+                });
+                target.addEventListener(topic, pubsubEventListener);
+                function pubsubEventListener(event) {
+                    next(event.data);
+                }
+            });
+        },
+    };
+};
+
+/**
+ * Utility for mapping an event stream.
+ */
+const map = (mapper) => (source) => new Repeater(async (push, stop) => {
+    stop.then(() => {
+        source.return();
+    });
+    for await (const value of source) {
+        push(await mapper(value));
+    }
+});
+
+function filter(filter) {
+    return (source) => new Repeater(async (push, stop) => {
+        stop.then(() => {
+            source.return();
+        });
+        for await (const value of source) {
+            if (filter(value)) {
+                push(value);
+            }
+        }
+    });
+}
+
+export { createPubSub, filter, map };

package/operator/filter.d.ts

@@ -0,0 +1,6 @@
+import { Repeater } from '@repeaterjs/repeater';
+/**
+ * Utility for filtering an event stream.
+ */
+export declare function filter<T, U extends T>(filter: (input: T) => input is U): (source: Repeater<T>) => Repeater<U, void, unknown>;
+export declare function filter<T>(filter: (input: T) => boolean): (source: Repeater<T>) => Repeater<T, void, unknown>;

package/operator/map.d.ts

@@ -0,0 +1,5 @@
+import { Repeater } from '@repeaterjs/repeater';
+/**
+ * Utility for mapping an event stream.
+ */
+export declare const map: <T, O>(mapper: (input: T) => O | Promise<O>) => (source: Repeater<T, any, unknown>) => Repeater<O, any, unknown>;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@graphql-yoga/subscription",
+  "version": "0.0.0",
+  "description": "",
+  "dependencies": {
+    "@repeaterjs/repeater": "^3.0.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dotansimha/graphql-yoga.git",
+    "directory": "packages/subscription"
+  },
+  "keywords": [
+    "pubsub",
+    "graphql",
+    "event",
+    "subscription"
+  ],
+  "author": "Laurin Quast <laurinquast@googlemail.com>",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "typescript": {
+    "definition": "index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    }
+  }
+}

package/typed-event-target.d.ts

@@ -0,0 +1,12 @@
+export interface TypedEventListener<TEvent extends Event> extends EventListener {
+    (evt: TEvent): void;
+}
+export interface TypedEventListenerObject<TEvent extends Event> extends EventListener {
+    handleEvent(object: TEvent): void;
+}
+export declare type TypedEventListenerOrEventListenerObject<TEvent extends Event> = TypedEventListener<TEvent> | TypedEventListenerObject<TEvent> | null;
+export interface TypedEventTarget<TEvent extends Event> extends EventTarget {
+    addEventListener(type: string, callback: TypedEventListenerOrEventListenerObject<TEvent>, options?: AddEventListenerOptions | boolean): void;
+    dispatchEvent(event: TEvent): boolean;
+    removeEventListener(type: string, callback: TypedEventListenerOrEventListenerObject<TEvent>, options?: EventListenerOptions | boolean): void;
+}