@bunworks/inngest-realtime 0.1.0

package/eslint.config.mjs

@@ -0,0 +1,19 @@
+import pluginJs from "@eslint/js";
+import eslintPluginPrettierRecommended from "eslint-plugin-prettier/recommended";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  { files: ["**/*.{js,mjs,cjs,ts}"] },
+  { languageOptions: { globals: globals.browser } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  eslintPluginPrettierRecommended,
+  {
+    rules: {
+      "@typescript-eslint/no-namespace": "off",
+      "@typescript-eslint/ban-types": "off",
+    },
+  },
+];

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@bunworks/inngest-realtime",
+  "version": "0.1.0",
+  "description": "Realtime messaging для @bunworks",
+  "main": "./index.js",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.build.json && tsdown --config tsdown.config.ts",
+    "postversion": "pnpm run build",
+    "release": "cross-env DIST_DIR=dist node ../../scripts/release/publish.js",
+    "pack": "pnpm run build && mv $(npm pack ./dist --pack-destination . --silent) inngest-realtime.tgz"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.mts",
+        "default": "./index.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      }
+    },
+    "./hooks": {
+      "import": {
+        "types": "./hooks.d.mts",
+        "default": "./hooks.mjs"
+      },
+      "require": {
+        "types": "./hooks.d.ts",
+        "default": "./hooks.js"
+      }
+    },
+    "./middleware": {
+      "import": {
+        "types": "./middleware.d.mts",
+        "default": "./middleware.mjs"
+      },
+      "require": {
+        "types": "./middleware.d.ts",
+        "default": "./middleware.js"
+      }
+    }
+  },
+  "keywords": [
+    "bunworks",
+    "realtime",
+    "websocket",
+    "messaging"
+  ],
+  "homepage": "https://github.com/bunworks/bunworks#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bunworks/bunworks.git",
+    "directory": "external/realtime"
+  },
+  "author": "Bunworks Team",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/debug": "^4.1.12",
+    "@types/node": "^25.2.2",
+    "@types/react": "^19.2.13",
+    "eslint": "^10.0.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.3.0",
+    "react": "^19.2.4",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "valibot": "1.2.0",
+    "vite-tsconfig-paths": "^6.1.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "debug": "^4.4.3",
+    "zod": "^4.3.6"
+  }
+}

package/src/api.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { getEnvVar } from "./env";
+import { fetchWithAuthFallback, parseAsBoolean } from "./util";
+
+const tokenSchema = z.object({ jwt: z.string() });
+
+export const api = {
+  async getSubscriptionToken({
+    channel,
+    topics,
+    signingKey,
+    signingKeyFallback,
+    apiBaseUrl,
+  }: {
+    channel: string;
+    topics: string[];
+    signingKey: string | undefined;
+    signingKeyFallback: string | undefined;
+    apiBaseUrl: string | undefined;
+  }): Promise<string> {
+    let url: URL;
+    const path = "/v1/realtime/token";
+    const inputBaseUrl =
+      apiBaseUrl ||
+      getEnvVar("BUNWORKS_BASE_URL") ||
+      getEnvVar("BUNWORKS_API_BASE_URL");
+
+    const devEnvVar = getEnvVar("BUNWORKS_DEV");
+
+    if (inputBaseUrl) {
+      url = new URL(path, inputBaseUrl);
+    } 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.inngest.com/");
+        }
+      }
+    } else {
+      url = new URL(
+        path,
+        getEnvVar("NODE_ENV") === "production"
+          ? "https://api.inngest.com/"
+          : "http://localhost:8288/",
+      );
+    }
+
+    const body = topics.map((topic) => ({
+      channel,
+      name: topic,
+      kind: "run",
+    }));
+
+    const res = await fetchWithAuthFallback({
+      authToken: signingKey,
+      authTokenFallback: signingKeyFallback,
+      fetch,
+      url,
+      options: {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    });
+
+    if (!res.ok) {
+      throw new Error(
+        `Не удалось получить токен подписки: ${res.status} ${
+          res.statusText
+        } - ${await res.text()}`,
+      );
+    }
+
+    const data = await res.json();
+    return tokenSchema.parse(data).jwt;
+  },
+};

package/src/channel.ts

@@ -0,0 +1,122 @@
+import { topic } from "./topic";
+import { type Realtime } from "./types";
+
+/**
+ * TODO
+ */
+export const channel: Realtime.Channel.Builder = (
+  /**
+   * TODO
+   */
+  id,
+) => {
+  // eslint-disable-next-line prefer-const, @typescript-eslint/no-explicit-any
+  let channelDefinition: any;
+  const topics: Record<string, Realtime.Topic.Definition> = {};
+
+  const builder = (...args: unknown[]) => {
+    const finalId: string = typeof id === "string" ? id : id(...args);
+
+    const topicsFns = Object.entries(topics).reduce<
+      Record<string, (data: unknown) => Promise<Realtime.Message.Input>>
+    >((acc, [name, topic]) => {
+      acc[name] = createTopicFn(finalId, topic);
+
+      return acc;
+    }, {});
+
+    const channel: Realtime.Channel = {
+      name: finalId,
+      topics,
+      ...topicsFns,
+    };
+
+    return channel;
+  };
+
+  const extras: Record<string, unknown> = {
+    topics,
+    addTopic: (topic: Realtime.Topic.Definition) => {
+      topics[topic.name] = topic;
+
+      return channelDefinition;
+    },
+  };
+
+  channelDefinition = Object.assign(builder, extras);
+
+  return channelDefinition;
+};
+
+/**
+ * TODO
+ */
+export const typeOnlyChannel = <
+  TChannelDef extends Realtime.Channel.Definition,
+  TId extends string = Realtime.Channel.Definition.InferId<TChannelDef>,
+  TTopics extends Record<
+    string,
+    Realtime.Topic.Definition
+  > = Realtime.Channel.Definition.InferTopics<TChannelDef>,
+  TOutput extends Realtime.Channel = Realtime.Channel<TId, TTopics>,
+>(
+  /**
+   * TODO
+   */
+  id: TId,
+) => {
+  const blankChannel = {
+    ...channel(id),
+    topics: new Proxy(
+      {},
+      {
+        get: (target, prop) => {
+          if (prop in target) {
+            return target[prop as keyof typeof target];
+          }
+
+          if (typeof prop === "string") {
+            return topic(prop);
+          }
+        },
+      },
+    ),
+  };
+
+  const ch = new Proxy(blankChannel, {
+    get: (target, prop) => {
+      if (prop in target) {
+        return target[prop as keyof typeof target];
+      }
+
+      if (typeof prop === "string") {
+        return createTopicFn(id, topic(prop));
+      }
+    },
+  });
+
+  return ch as unknown as TOutput;
+};
+
+const createTopicFn = (channelId: string, topic: Realtime.Topic.Definition) => {
+  return async (data: unknown) => {
+    const schema = topic.getSchema();
+    if (schema) {
+      try {
+        await schema["~standard"].validate(data);
+      } catch (err) {
+        console.error(
+          `Failed schema validation for channel "${channelId}" topic "${topic.name}":`,
+          err,
+        );
+        throw new Error("Failed schema validation");
+      }
+    }
+
+    return {
+      channel: channelId,
+      topic: topic.name,
+      data,
+    };
+  };
+};

package/src/env.d.ts

@@ -0,0 +1,15 @@
+// For Vite
+interface ImportMeta {
+  env: {
+    INNGEST_DEV?: string;
+    VITE_INNGEST_DEV?: string;
+    MODE: "development" | "production";
+    VITE_MODE: "development" | "production";
+    INNGEST_BASE_URL?: string;
+    VITE_INNGEST_BASE_URL?: string;
+    INNGEST_API_BASE_URL?: string;
+    VITE_INNGEST_API_BASE_URL?: string;
+    INNGEST_SIGNING_KEY?: string;
+    INNGEST_SIGNING_KEY_FALLBACK?: string;
+  };
+}

package/src/env.ts

@@ -0,0 +1,152 @@
+export type EnvValue = string | undefined;
+export type Env = Record<string, EnvValue>;
+
+export type ExpectedEnv = {
+  BUNWORKS_DEV: string | undefined;
+  NODE_ENV: string | undefined;
+  BUNWORKS_BASE_URL: string | undefined;
+  BUNWORKS_API_BASE_URL: string | undefined;
+  BUNWORKS_SIGNING_KEY: string | undefined;
+  BUNWORKS_SIGNING_KEY_FALLBACK: string | undefined;
+};
+
+/**
+ * The environment variables that we wish to access in the environment.
+ *
+ * Due to the way that some environment variables are exposed across different
+ * runtimes and bundling tools, we need to be careful about how we access them.
+ *
+ * The most basic annoyance is that environment variables are exposed in
+ * different locations (e.g. `process.env`, `Deno.env`, `Netlify.env`,
+ * `import.meta.env`).
+ *
+ * Bundling can be more disruptive though, where some will literally
+ * find/replace `process.env.MY_VAR` with the value of `MY_VAR` at build time,
+ * which requires us to ensure that the full env var is used in code instead of
+ * dynamically building it.
+ */
+const env: ExpectedEnv | undefined = (() => {
+  // Pure vite
+  try {
+    // @ts-expect-error - import.meta only available in some environments
+    const viteEnv = import.meta.env;
+
+    if (viteEnv) {
+      return {
+        BUNWORKS_DEV: viteEnv.BUNWORKS_DEV ?? viteEnv.VITE_BUNWORKS_DEV,
+        NODE_ENV: viteEnv.NODE_ENV,
+        BUNWORKS_BASE_URL:
+          viteEnv.BUNWORKS_BASE_URL ?? viteEnv.VITE_BUNWORKS_BASE_URL,
+        BUNWORKS_API_BASE_URL:
+          viteEnv.BUNWORKS_API_BASE_URL ?? viteEnv.VITE_BUNWORKS_API_BASE_URL,
+        BUNWORKS_SIGNING_KEY: viteEnv.BUNWORKS_SIGNING_KEY,
+        BUNWORKS_SIGNING_KEY_FALLBACK: viteEnv.BUNWORKS_SIGNING_KEY_FALLBACK,
+      };
+    }
+  } catch {
+    // noop
+  }
+
+  try {
+    // Node-like environments (sometimes polyfilled Vite)
+    if (process.env) {
+      return {
+        BUNWORKS_DEV:
+          process.env.BUNWORKS_DEV ??
+          process.env.NEXT_PUBLIC_BUNWORKS_DEV ??
+          process.env.REACT_APP_BUNWORKS_DEV ??
+          process.env.NUXT_PUBLIC_BUNWORKS_DEV ??
+          process.env.VUE_APP_BUNWORKS_DEV ??
+          process.env.VITE_BUNWORKS_DEV,
+
+        NODE_ENV:
+          process.env.NODE_ENV ??
+          process.env.NEXT_PUBLIC_NODE_ENV ??
+          process.env.REACT_APP_NODE_ENV ??
+          process.env.NUXT_PUBLIC_NODE_ENV ??
+          process.env.VUE_APP_NODE_ENV ??
+          process.env.VITE_NODE_ENV ??
+          process.env.VITE_MODE,
+
+        BUNWORKS_BASE_URL:
+          process.env.BUNWORKS_BASE_URL ??
+          process.env.NEXT_PUBLIC_BUNWORKS_BASE_URL ??
+          process.env.REACT_APP_BUNWORKS_BASE_URL ??
+          process.env.NUXT_PUBLIC_BUNWORKS_BASE_URL ??
+          process.env.VUE_APP_BUNWORKS_BASE_URL ??
+          process.env.VITE_BUNWORKS_BASE_URL,
+
+        BUNWORKS_API_BASE_URL:
+          process.env.BUNWORKS_API_BASE_URL ??
+          process.env.NEXT_PUBLIC_BUNWORKS_API_BASE_URL ??
+          process.env.REACT_APP_BUNWORKS_API_BASE_URL ??
+          process.env.NUXT_PUBLIC_BUNWORKS_API_BASE_URL ??
+          process.env.VUE_APP_BUNWORKS_API_BASE_URL ??
+          process.env.VITE_BUNWORKS_API_BASE_URL,
+
+        BUNWORKS_SIGNING_KEY: process.env.BUNWORKS_SIGNING_KEY,
+
+        BUNWORKS_SIGNING_KEY_FALLBACK: process.env.BUNWORKS_SIGNING_KEY_FALLBACK,
+      };
+    }
+  } catch {
+    // noop
+  }
+
+  // Deno
+  try {
+    const denoEnv = Deno.env.toObject();
+
+    if (denoEnv) {
+      return {
+        BUNWORKS_DEV: denoEnv.BUNWORKS_DEV,
+        NODE_ENV: denoEnv.NODE_ENV,
+        BUNWORKS_BASE_URL: denoEnv.BUNWORKS_BASE_URL,
+        BUNWORKS_API_BASE_URL: denoEnv.BUNWORKS_API_BASE_URL,
+        BUNWORKS_SIGNING_KEY: denoEnv.BUNWORKS_SIGNING_KEY,
+        BUNWORKS_SIGNING_KEY_FALLBACK: denoEnv.BUNWORKS_SIGNING_KEY_FALLBACK,
+      };
+    }
+  } catch {
+    // noop
+  }
+
+  // Netlify
+  try {
+    const netlifyEnv = Netlify.env.toObject();
+
+    if (netlifyEnv) {
+      return {
+        BUNWORKS_DEV: netlifyEnv.BUNWORKS_DEV,
+        NODE_ENV: netlifyEnv.NODE_ENV,
+        BUNWORKS_BASE_URL: netlifyEnv.BUNWORKS_BASE_URL,
+        BUNWORKS_API_BASE_URL: netlifyEnv.BUNWORKS_API_BASE_URL,
+        BUNWORKS_SIGNING_KEY: netlifyEnv.BUNWORKS_SIGNING_KEY,
+        BUNWORKS_SIGNING_KEY_FALLBACK: netlifyEnv.BUNWORKS_SIGNING_KEY_FALLBACK,
+      };
+    }
+  } catch {
+    // noop
+  }
+})();
+
+/**
+ * The Deno environment, which is not always available.
+ */
+declare const Deno: {
+  env: { toObject: () => Env };
+};
+
+/**
+ * The Netlify environment, which is not always available.
+ */
+declare const Netlify: {
+  env: { toObject: () => Env };
+};
+
+/**
+ * Given a `key`, get the environment variable under that key.
+ */
+export const getEnvVar = (key: keyof ExpectedEnv): string | undefined => {
+  return env?.[key];
+};