@bunworks/inngest-realtime 0.1.0 → 0.1.5

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from './channel';
-export * from './subscribe';
-export * from './topic';
-export * from './types';

package/src/middleware.ts

@@ -1,68 +0,0 @@
-import type { Realtime } from "./types";
-
-export interface BunworksMiddleware {
-  name: string;
-  init: (config: { client: any }) => {
-    onFunctionRun: (config: { ctx: { runId: string } }) => {
-      transformInput: (config: { ctx: { step: any } }) => {
-        ctx: {
-          publish: Realtime.PublishFn;
-        };
-      };
-    };
-  };
-}
-
-export const realtimeMiddleware = () => {
-  return {
-    name: "publish",
-    init({ client }: { client: any }) {
-      return {
-        onFunctionRun({ ctx: { runId } }: { ctx: { runId: string } }) {
-          return {
-            transformInput({ ctx: { step } }: { ctx: { step: any } }) {
-              const publish: Realtime.PublishFn = async (input) => {
-                const { topic, channel, data } = await input;
-
-                const publishOpts = {
-                  topics: [topic],
-                  channel,
-                  runId,
-                };
-
-                const action = async () => {
-                  const result = await client["api"].publish(
-                    publishOpts,
-                    data,
-                  );
-
-                  if (!result.ok) {
-                    throw new Error(
-                      `Не удалось опубликовать событие: ${result.error?.error}`,
-                    );
-                  }
-                };
-
-                return step.run(`publish:${publishOpts.channel}`, action).then(() => {
-                  return data;
-                });
-              };
-
-              return {
-                ctx: {
-                  /**
-                   * Функция для публикации сообщений в realtime канал
-                   */
-                  publish,
-                },
-              };
-            },
-          };
-        },
-      };
-    },
-  } as BunworksMiddleware;
-};
-
-// Re-export types from here, as this is used as a separate entrypoint now
-export * from "./types";

package/src/subscribe/StreamFanout.ts

@@ -1,82 +0,0 @@
-/**
- * TODO
- */
-export class StreamFanout<TInput = unknown> {
-  #writers = new Set<WritableStreamDefaultWriter<TInput>>();
-
-  /**
-   * TODO
-   */
-  createStream<TOutput = TInput>(
-    /**
-     * TODO
-     */
-    transform?: (
-      /**
-       * TODO
-       */
-      chunk: TInput,
-    ) => TOutput,
-  ): ReadableStream<TOutput> {
-    const { readable, writable } = new TransformStream<TInput, TOutput>({
-      transform: (chunk, controller) => {
-        controller.enqueue(
-          transform ? transform(chunk) : (chunk as unknown as TOutput),
-        );
-      },
-    });
-
-    const writer = writable.getWriter();
-    this.#writers.add(writer);
-
-    // Eagerly remove the writer is the stream is closed
-    writer.closed
-      .catch(() => {}) // Suppress unhandled promise rejection to avoid noisy logs
-      .finally(() => {
-        this.#writers.delete(writer);
-      });
-
-    return readable;
-  }
-
-  /**
-   * TODO
-   */
-  write(
-    /**
-     * TODO
-     */
-    chunk: TInput,
-  ) {
-    for (const writer of this.#writers) {
-      writer.ready
-        .then(() => writer.write(chunk))
-        // Dereference the writer if we fail, as this means it's closed
-        .catch(() => this.#writers.delete(writer));
-    }
-  }
-
-  /**
-   * TODO
-   */
-  close() {
-    for (const writer of this.#writers) {
-      try {
-        writer.close();
-      } catch {
-        // Ignore errors, as we are closing the stream and the writer may
-        // already be closed, especially if the stream is closed before the
-        // writer is closed or if the stream is cancelled.
-      }
-    }
-
-    this.#writers.clear();
-  }
-
-  /**
-   * TODO
-   */
-  size() {
-    return this.#writers.size;
-  }
-}

package/src/subscribe/TokenSubscription.ts

@@ -1,524 +0,0 @@
-import debug from "debug";
-import { api } from "../api";
-import { getEnvVar } from "../env";
-import { topic } from "../topic";
-import { Realtime } from "../types";
-import { createDeferredPromise, parseAsBoolean } from "../util";
-import { StreamFanout } from "./StreamFanout";
-
-/**
- * Подписка на realtime канал через WebSocket
- */
-export class TokenSubscription {
-  #apiBaseUrl?: string;
-  #channelId: string;
-  #debug = debug("bunworks:realtime");
-  #encoder = new TextEncoder();
-  #fanout = new StreamFanout<Realtime.Message>();
-  #running = false;
-  #topics: Map<string, Realtime.Topic.Definition>;
-  #ws: WebSocket | null = null;
-  #signingKey: string | undefined;
-  #signingKeyFallback: string | undefined;
-
-  /**
-   * Карта stream ID к их потокам и контроллерам
-   */
-  #chunkStreams = new Map<
-    string,
-    { stream: ReadableStream; controller: ReadableStreamDefaultController }
-  >();
-
-  constructor(
-    /**
-     * Токен подписки
-     */
-    public token: Realtime.Subscribe.Token,
-    apiBaseUrl: string | undefined,
-    signingKey: string | undefined,
-    signingKeyFallback: string | undefined,
-  ) {
-    this.#apiBaseUrl = apiBaseUrl;
-    this.#signingKey = signingKey;
-    this.#signingKeyFallback = signingKeyFallback;
-
-    if (typeof token.channel === "string") {
-      this.#channelId = token.channel;
-
-      this.#topics = this.token.topics.reduce<
-        Map<string, Realtime.Topic.Definition>
-      >((acc, name) => {
-        acc.set(name, topic(name));
-
-        return acc;
-      }, new Map<string, Realtime.Topic.Definition>());
-    } else {
-      this.#channelId = token.channel.name;
-
-      this.#topics = this.token.topics.reduce<
-        Map<string, Realtime.Topic.Definition>
-      >((acc, name) => {
-        acc.set(name, token.channel.topics[name] ?? topic(name));
-
-        return acc;
-      }, new Map<string, Realtime.Topic.Definition>());
-    }
-  }
-
-  private async getWsUrl(token: string): Promise<URL> {
-    let url: URL;
-    const path = "/v1/realtime/connect";
-    const devEnvVar = getEnvVar("BUNWORKS_DEV");
-
-    if (this.#apiBaseUrl) {
-      url = new URL(path, this.#apiBaseUrl);
-    } else if (devEnvVar) {
-      try {
-        const devUrl = new URL(devEnvVar);
-        url = new URL(path, devUrl);
-      } catch {
-        if (parseAsBoolean(devEnvVar)) {
-          url = new URL(path, "http://localhost:8288/");
-        } else {
-          url = new URL(path, "https://api.bunworks.com/");
-        }
-      }
-    } else {
-      url = new URL(
-        path,
-        getEnvVar("NODE_ENV") === "production"
-          ? "https://api.bunworks.com/"
-          : "http://localhost:8288/",
-      );
-    }
-
-    url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
-    url.searchParams.set("token", token);
-
-    return url;
-  }
-
-  /**
-   * Установка WebSocket соединения
-   */
-  public async connect() {
-    this.#debug(
-      `Establishing connection to channel "${
-        this.#channelId
-      }" with topics ${JSON.stringify([...this.#topics.keys()])}...`,
-    );
-
-    if (typeof WebSocket === "undefined") {
-      throw new Error("WebSocket не поддерживается в текущем окружении");
-    }
-
-    let key = this.token.key;
-    if (!key) {
-      this.#debug(
-        "No subscription token key passed; attempting to retrieve one automatically...",
-      );
-
-      key = (
-        await this.lazilyGetSubscriptionToken({
-          ...this.token,
-          signingKey: this.#signingKey,
-          signingKeyFallback: this.#signingKeyFallback,
-        })
-      ).key;
-
-      if (!key) {
-        throw new Error(
-          "Не передан ключ токена подписки и не удалось получить его автоматически",
-        );
-      }
-    }
-
-    const ret = createDeferredPromise<void>();
-
-    try {
-      this.#ws = new WebSocket(await this.getWsUrl(key));
-
-      this.#ws.onopen = () => {
-        this.#debug("WebSocket connection established");
-        ret.resolve();
-      };
-
-      this.#ws.onmessage = async (event) => {
-        const parseRes = await Realtime.messageSchema.safeParseAsync(
-          JSON.parse(event.data as string),
-        );
-
-        if (!parseRes.success) {
-          this.#debug("Received invalid message:", parseRes.error);
-          return;
-        }
-
-        const msg = parseRes.data;
-
-        if (!this.#running) {
-          this.#debug(
-            `Received message on channel "${msg.channel}" for topic "${msg.topic}" but stream is closed`,
-          );
-        }
-
-        switch (msg.kind) {
-          case "data": {
-            if (!msg.channel) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no channel`,
-              );
-              return;
-            }
-
-            if (!msg.topic) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no topic`,
-              );
-              return;
-            }
-
-            const topic = this.#topics.get(msg.topic);
-            if (!topic) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" for unknown topic "${msg.topic}"`,
-              );
-              return;
-            }
-
-            const schema = topic.getSchema();
-            if (schema) {
-              const validateRes = await schema["~standard"].validate(msg.data);
-              if (validateRes.issues) {
-                console.error(
-                  `Received message on channel "${msg.channel}" for topic "${msg.topic}" that failed schema validation:`,
-                  validateRes.issues,
-                );
-                return;
-              }
-
-              msg.data = validateRes.value;
-            }
-
-            this.#debug(
-              `Received message on channel "${msg.channel}" for topic "${msg.topic}":`,
-              msg.data,
-            );
-            return this.#fanout.write({
-              channel: msg.channel,
-              topic: msg.topic,
-              data: msg.data,
-              fnId: msg.fn_id,
-              createdAt: msg.created_at || new Date(),
-              runId: msg.run_id,
-              kind: "data",
-              envId: msg.env_id,
-            });
-          }
-
-          case "datastream-start": {
-            if (!msg.channel) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no channel`,
-              );
-              return;
-            }
-
-            if (!msg.topic) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no topic`,
-              );
-              return;
-            }
-
-            const streamId: unknown = msg.data;
-            if (typeof streamId !== "string" || !streamId) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no stream ID`,
-              );
-              return;
-            }
-
-            // `data` is a stream ID that we'll start receiving chunks with
-            if (this.#chunkStreams.has(streamId)) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" to create stream ID "${streamId}" that already exists`,
-              );
-              return;
-            }
-
-            const stream = new ReadableStream({
-              start: (controller) => {
-                this.#chunkStreams.set(streamId, { stream, controller });
-              },
-
-              cancel: () => {
-                this.#chunkStreams.delete(streamId);
-              },
-            });
-
-            this.#debug(
-              `Created stream ID "${streamId}" on channel "${msg.channel}"`,
-            );
-            return this.#fanout.write({
-              channel: msg.channel,
-              topic: msg.topic,
-              kind: "datastream-start",
-              data: streamId,
-              streamId,
-              fnId: msg.fn_id,
-              runId: msg.run_id,
-              stream,
-            });
-          }
-
-          case "datastream-end": {
-            if (!msg.channel) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no channel`,
-              );
-              return;
-            }
-
-            if (!msg.topic) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no topic`,
-              );
-              return;
-            }
-
-            const streamId: unknown = msg.data;
-            if (typeof streamId !== "string" || !streamId) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no stream ID`,
-              );
-              return;
-            }
-
-            // `data` is a stream ID that we'll stop receiving chunks with
-            const stream = this.#chunkStreams.get(streamId);
-            if (!stream) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" to close stream ID "${streamId}" that doesn't exist`,
-              );
-              return;
-            }
-
-            stream.controller.close();
-            this.#chunkStreams.delete(streamId);
-
-            this.#debug(
-              `Closed stream ID "${streamId}" on channel "${msg.channel}"`,
-            );
-            return this.#fanout.write({
-              channel: msg.channel,
-              topic: msg.topic,
-              kind: "datastream-end",
-              data: streamId,
-              streamId,
-              fnId: msg.fn_id,
-              runId: msg.run_id,
-              stream: stream.stream,
-            });
-          }
-
-          case "chunk": {
-            if (!msg.channel) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no channel`,
-              );
-              return;
-            }
-
-            if (!msg.topic) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no topic`,
-              );
-              return;
-            }
-
-            // `stream_id` is the ID of the stream we're receiving chunks for
-            if (!msg.stream_id) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" with no stream ID`,
-              );
-              return;
-            }
-
-            const stream = this.#chunkStreams.get(msg.stream_id);
-            if (!stream) {
-              this.#debug(
-                `Received message on channel "${msg.channel}" for unknown stream ID "${msg.stream_id}"`,
-              );
-              return;
-            }
-
-            this.#debug(
-              `Received chunk on channel "${msg.channel}" for stream ID "${msg.stream_id}":`,
-              msg.data,
-            );
-
-            stream.controller.enqueue(msg.data);
-
-            return this.#fanout.write({
-              channel: msg.channel,
-              topic: msg.topic,
-              kind: "chunk",
-              data: msg.data,
-              streamId: msg.stream_id,
-              fnId: msg.fn_id,
-              runId: msg.run_id,
-              stream: stream.stream,
-            });
-          }
-
-          default: {
-            this.#debug(
-              `Received message on channel "${msg.channel}" with unhandled kind "${msg.kind}"`,
-            );
-            return;
-          }
-        }
-      };
-
-      this.#ws.onerror = (event) => {
-        console.error("WebSocket error observed:", event);
-        ret.reject(event);
-      };
-
-      this.#ws.onclose = (event) => {
-        this.#debug("WebSocket closed:", event.reason);
-        this.close();
-      };
-
-      this.#running = true;
-    } catch (err) {
-      ret.reject(err);
-    }
-
-    return ret.promise;
-  }
-
-  /**
-   * TODO
-   */
-  private async lazilyGetSubscriptionToken<
-    const InputChannel extends Realtime.Channel | string,
-    const InputTopics extends (keyof Realtime.Channel.InferTopics<
-      Realtime.Channel.AsChannel<InputChannel>
-    > &
-      string)[],
-    const TToken extends Realtime.Subscribe.Token<
-      Realtime.Channel.AsChannel<InputChannel>,
-      InputTopics
-    >,
-  >(
-    /**
-     * TODO
-     */
-    args: {
-      /**
-       * TODO
-       */
-      channel: Realtime.Subscribe.InferChannelInput<InputChannel>;
-
-      /**
-       * TODO
-       */
-      topics: InputTopics;
-
-      /**
-       * TODO
-       */
-      signingKey: string | undefined;
-
-      /**
-       * TODO
-       */
-      signingKeyFallback: string | undefined;
-    },
-  ): Promise<TToken> {
-    const channelId =
-      typeof args.channel === "string" ? args.channel : args.channel.name;
-
-    if (!channelId) {
-      throw new Error("Channel ID is required to create a subscription token");
-    }
-
-    const key = await api.getSubscriptionToken({
-      channel: channelId,
-      topics: args.topics,
-      signingKey: args.signingKey,
-      signingKeyFallback: args.signingKeyFallback,
-      apiBaseUrl: this.#apiBaseUrl,
-    });
-
-    const token = {
-      channel: channelId,
-      topics: args.topics,
-      key,
-    } as TToken;
-
-    return token;
-  }
-
-  /**
-   * TODO
-   */
-  public close(
-    /**
-     * TODO
-     */
-    reason = "Userland closed connection",
-  ) {
-    if (!this.#running) {
-      return;
-    }
-
-    this.#debug("close() called; closing connection...");
-    this.#running = false;
-    this.#ws?.close(1000, reason);
-
-    this.#debug(`Closing ${this.#fanout.size()} streams...`);
-    this.#fanout.close();
-  }
-
-  /**
-   * TODO
-   */
-  public getJsonStream() {
-    return this.#fanout.createStream();
-  }
-
-  /**
-   * TODO
-   */
-  public getEncodedStream() {
-    return this.#fanout.createStream((chunk) => {
-      return this.#encoder.encode(`${JSON.stringify(chunk)}\n`);
-    });
-  }
-
-  /**
-   * TODO
-   */
-  public useCallback(
-    callback: Realtime.Subscribe.Callback,
-    stream: ReadableStream<Realtime.Message> = this.getJsonStream(),
-  ) {
-    void (async () => {
-      // Explicitly get and manage the reader so that we can manually release
-      // the lock if anything goes wrong or we're done with it.
-      const reader = stream.getReader();
-      try {
-        while (this.#running) {
-          const { done, value } = await reader.read();
-          if (done || !this.#running) break;
-
-          callback(value);
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    })();
-  }
-}