Fce 1631 Run type checking against TS code snippets

.github/workflows/docs.yaml

@@ -33,6 +33,8 @@ jobs:
       # 👇 Build steps
       - name: Set up Node.js
         uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
       - name: Use corepack
         run: corepack enable
       - name: Install dependencies

.github/workflows/static_check.yml

@@ -7,8 +7,18 @@ jobs:
     steps:
       - name: checkout
         uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+      - name: init and update submodules
+        run: git submodule update --init --recursive
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
       - name: Use corepack
         run: corepack enable
+      - name: Run prepare
+        run: scripts/prepare.sh
       - name: Install node dependencies
         run: yarn --immutable
       - name: Spellcheck
@@ -17,7 +27,5 @@ jobs:
         run: yarn format:check
       - name: Check types
         run: yarn typecheck
-      - name: Fetch packages
-        run: yarn prepare
       - name: Check build
         run: yarn build

docs/audio-calls.mdx

@@ -27,6 +27,12 @@ Using this feature is as easy as setting the `roomType` field to `audio_only` wh
   <TabItem value="ts" label="Typescript">
 
     ```ts
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
+    const fishjamClient = new FishjamClient({
+        fishjamUrl: "aaa",
+        managementToken: "bbb",
+    });
+    // ---cut---
     const createdRoom = await fishjamClient.createRoom({ roomType: 'audio_only' });
     ```
 

docs/livestreaming.mdx

@@ -29,6 +29,12 @@ https://fishjam.io/api/v1/connect/${ROOM_MANAGER_ID}/room-manager?roomName=foo&p
   <TabItem value="ts" label="Typescript">
 
     ```ts
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
+    const fishjamClient = new FishjamClient({
+        fishjamUrl: "aaa",
+        managementToken: "bbb",
+    });
+    // ---cut---
     const createdRoom = await fishjamClient.createRoom({ roomType: 'livestream' });
 
     const peer = await fishjamClient.createPeer(createdRoom.id)
@@ -71,6 +77,14 @@ https://fishjam.io/api/v1/connect/${ROOM_MANAGER_ID}/room-manager/<ROOM_NAME>/li
   <TabItem value="ts" label="Typescript">
 
     ```ts
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk'; 
+    const fishjamClient = new FishjamClient({
+        fishjamUrl: "aaa",
+        managementToken: "bbb",
+    });
+    const room = await fishjamClient.createRoom({ roomType: 'livestream' });
+    // ---cut---
+
     const viewerToken = await fishjamClient.createLivestreamViewerToken(room.id)
     ```
 

docs/production/examples/fastify.mdx

@@ -16,7 +16,7 @@ If you wish to see more general info, visit [**set up your server**](/production
 Use [`@fastify/env` package](https://github.com/fastify/fastify-env) to load and set environment variables in your Fastify instance.
 
 ```ts title='main.ts'
-import { Fastify } from "fastify";
+import Fastify from "fastify";
 import fastifyEnv from "@fastify/env";
 
 const fastify = Fastify();
@@ -55,13 +55,17 @@ import { FishjamClient } from "@fishjam-cloud/js-server-sdk";
 declare module "fastify" {
   interface FastifyInstance {
     fishjam: FishjamClient;
+    config: {
+      FISHJAM_URL: string;
+      FISHJAM_MANAGEMENT_TOKEN: string;
+    };
   }
 }
 
 export const fishjamPlugin = fastifyPlugin((fastify) => {
   const fishjamClient = new FishjamClient({
     fishjamUrl: fastify.config.FISHJAM_URL,
-    managementToken: fastify.config.FISHJAM_SERVER_TOKEN,
+    managementToken: fastify.config.FISHJAM_MANAGEMENT_TOKEN,
   });
 
   fastify.decorate("fishjam", fishjamClient);
@@ -71,13 +75,32 @@ export const fishjamPlugin = fastifyPlugin((fastify) => {
 Now, after registering the plugin, we will be able to use Fishjam client by accessing the `fastify.fishjam` property.
 
 ```ts title='main.ts'
-import { Fastify } from "fastify";
-import fastifyEnv from "@fastify/env";
+import fastifyPlugin from "fastify-plugin";
+import { FishjamClient } from "@fishjam-cloud/js-server-sdk";
+import Fastify from "fastify";
 
-import { fishjamPlugin } from "./fishjamPlugin";
+declare module "fastify" {
+  interface FastifyInstance {
+    fishjam: FishjamClient;
+    config: {
+      FISHJAM_URL: string;
+      FISHJAM_MANAGEMENT_TOKEN: string;
+    };
+  }
+}
+
+export const fishjamPlugin = fastifyPlugin((fastify) => {
+  const fishjamClient = new FishjamClient({
+    fishjamUrl: fastify.config.FISHJAM_URL,
+    managementToken: fastify.config.FISHJAM_MANAGEMENT_TOKEN,
+  });
+
+  fastify.decorate("fishjam", fishjamClient);
+});
 
 const fastify = Fastify();
-// ... skipping env loading code for convenience
+
+// ---cut---
 await fastify.register(fishjamPlugin);
 
 fastify.get("/rooms", () => fastify.fishjam.getAllRooms());
@@ -97,20 +120,21 @@ To receive and parse the Fishjam protobuf messages, add a content type parser to
 Then, you will be able to access the parsed message at `request.Body`.
 
 ```ts title='main.ts'
-import { Fastify } from "fastify";
+import Fastify, { FastifyRequest } from "fastify";
 import { ServerMessage } from "@fishjam-cloud/js-server-sdk/proto";
 
 const fastify = Fastify();
 
 fastify.addContentTypeParser(
   "application/x-protobuf",
   { parseAs: "buffer" },
-  async (_: FastifyRequest, body: Buffer) => ServerMessage.decode(body),
+  async (_: FastifyRequest, body: Buffer) =>
+    ServerMessage.decode(new Uint8Array(body)),
 );
 
 fastify.post<{ Body: ServerMessage }>("/fishjam-webhook", (request) => {
   // handle the message
-  console.log(request.Body);
+  console.log(request.body);
 });
 ```
 
@@ -122,6 +146,32 @@ Let's create another plugin in `fishjamNotifierPlugin.ts` file.
 In this case, we don't need to extend the Fastify instance type, because the plugin doesn't decorate the Fastify instance with any properties. It will work in the background.
 
 ```ts title='fishjamNotifierPlugin.ts'
+import fastifyPlugin from "fastify-plugin";
+import { FishjamClient } from "@fishjam-cloud/js-server-sdk";
+import Fastify from "fastify";
+
+declare module "fastify" {
+  interface FastifyInstance {
+    fishjam: FishjamClient;
+    config: {
+      FISHJAM_URL: string;
+      FISHJAM_MANAGEMENT_TOKEN: string;
+    };
+  }
+}
+
+export const fishjamPlugin = fastifyPlugin((fastify) => {
+  const fishjamClient = new FishjamClient({
+    fishjamUrl: fastify.config.FISHJAM_URL,
+    managementToken: fastify.config.FISHJAM_MANAGEMENT_TOKEN,
+  });
+
+  fastify.decorate("fishjam", fishjamClient);
+});
+
+const fastify = Fastify();
+
+// ---cut---
 import { type FastifyInstance } from "fastify";
 import fp from "fastify-plugin";
 import { FishjamWSNotifier } from "@fishjam-cloud/js-server-sdk";
@@ -132,31 +182,59 @@ export const fishjamNotifierPlugin = fp((fastify) => {
 
   const fishjamNotifier = new FishjamWSNotifier(
     { fishjamUrl, managementToken },
-    onError: (err) => fastify.log.error(err),
-    onClose: () => fastify.log.info("Websocket connection to Fishjam closed"),
-    onConnectionFailed: () => fastify.log.error("Failed to connect Fishjam notifier")
+    (err) => fastify.log.error(err),
+    () => fastify.log.info("Websocket connection to Fishjam closed"),
+    () => fastify.log.error("Failed to connect Fishjam notifier"),
   );
 
   // handle the messages
   const handleRoomCreated = console.log;
-  const handlePeerCreated = console.log;
+  const handlePeerAdded = console.log;
 
   fishjamNotifier.on("roomCreated", handleRoomCreated);
-  fishjamNotifier.on("peerCreated", handlePeerCreated);
+  fishjamNotifier.on("peerAdded", handlePeerAdded);
 });
 ```
 
 Don't forget to register your plugin.
 
 ```ts title='main.ts'
-import { Fastify } from "fastify";
-import fastifyEnv from "@fastify/env";
+import fastifyPlugin from "fastify-plugin";
+import { FishjamClient } from "@fishjam-cloud/js-server-sdk";
+import Fastify from "fastify";
+import { FishjamWSNotifier } from "@fishjam-cloud/js-server-sdk";
+
+declare module "fastify" {
+  interface FastifyInstance {
+    fishjam: FishjamClient;
+    config: {
+      FISHJAM_URL: string;
+      FISHJAM_MANAGEMENT_TOKEN: string;
+    };
+  }
+}
+
+export const fishjamPlugin = fastifyPlugin((fastify) => {
+  const fishjamClient = new FishjamClient({
+    fishjamUrl: "aaa",
+    managementToken: "bbb",
+  });
 
-import { fishjamPlugin } from "./fishjamPlugin";
-import { fishjamNotifierPlugin } from "./fishjamNotifierPlugin";
+  fastify.decorate("fishjam", fishjamClient);
+});
 
 const fastify = Fastify();
-// ...
+
+const fishjamNotifierPlugin = fastifyPlugin((fastify) => {
+  const fishjamNotifier = new FishjamWSNotifier(
+    { fishjamUrl: "aaa", managementToken: "bbb" },
+    (err) => fastify.log.error(err),
+    () => fastify.log.info("Websocket connection to Fishjam closed"),
+    () => fastify.log.error("Failed to connect Fishjam notifier"),
+  );
+});
+// ---cut---
+
 await fastify.register(fishjamPlugin);
 await fastify.register(fishjamNotifierPlugin);
 ```

docs/production/server.mdx

@@ -56,6 +56,10 @@ They are required to proceed. Now, we are ready to dive into the code.
   <TabItem value="ts" label="Typescript">
 
     ```ts
+    process.env.FISHJAM_URL = "https://fishjam.io";
+    process.env.FISHJAM_MANAGEMENT_TOKEN = "bbb";
+    // ---cut---
+
     import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
 
     const fishjamUrl = process.env.FISHJAM_URL;
@@ -89,6 +93,13 @@ Create a room to get the `roomId` and be able to start adding peers.
   <TabItem value="ts" label="Typescript">
 
     ```ts
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
+    const fishjamClient = new FishjamClient({
+
+        fishjamUrl: "https://fishjam.io",
+        managementToken: "bbb",
+    });
+    // ---cut---
     const createdRoom = await fishjamClient.createRoom();
 
     const theSameRoom = await fishjamClient.getRoom(createdRoom.id);
@@ -125,9 +136,16 @@ At any time you can terminate user's access by deleting the peer.
   <TabItem value="ts" label="Typescript">
 
     ```ts
-    const { peer, peerToken } = await fishjamClient.createPeer(roomId);
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
+    const fishjamClient = new FishjamClient({
+        fishjamUrl: "https://fishjam.io",
+        managementToken: "bbb",
+    });
+    const created_room = await fishjamClient.createRoom();
+    // ---cut---
+    const { peer, peerToken } = await fishjamClient.createPeer(created_room.id);
 
-    await fishjamClient.deletePeer(roomId, peer.id);
+    await fishjamClient.deletePeer(created_room.id, peer.id);
     ```
 
   </TabItem>
@@ -153,7 +171,14 @@ or [web SDK](/react/metadata). This metadata can be only set when creating the p
   <TabItem value="ts" label="Typescript">
 
     ```ts
-    const { peer, peerToken } = await fishjamClient.createPeer(roomId, {
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
+    const fishjamClient = new FishjamClient({
+        fishjamUrl: "https://fishjam.io",
+        managementToken: "bbb",
+    });
+    const created_room = await fishjamClient.createRoom();
+    // ---cut---
+    const { peer, peerToken } = await fishjamClient.createPeer(created_room.id, {
       metadata: { realName: 'Keanu Reeves' },
     });
     ```
@@ -186,6 +211,13 @@ Simply pass the your webhook url as a `webhookUrl` parameter when creating a roo
   <TabItem value="ts" label="Typescript">
 
     ```ts
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
+
+    const fishjamClient = new FishjamClient({
+        fishjamUrl: "https://fishjam.io",
+        managementToken: "bbb",
+    });
+    // ---cut---
     const webhookUrl = "https://example.com/";
     await fishjamClient.createRoom({ webhookUrl });
     ```
@@ -215,6 +247,9 @@ It sets up a websocket connection with a Fishjam instance and provides a simple
   <TabItem value="ts" label="Typescript">
 
     ```ts
+    const fishjamUrl = "https://fishjam.io";
+    const managementToken = "bbb";
+    // ---cut---
     import { FishjamWSNotifier } from '@fishjam-cloud/js-server-sdk';
 
     const onClose = console.log;

docs/react-native/background.mdx

@@ -61,17 +61,26 @@ You need to modify `AndroidManifest.xml` file and add below service:
 
   <TabItem value="android" label="Android">
 
-You can use [`useForegroundService`](/api/mobile/functions/useForegroundService) hook to handle how foreground service behaves on Android.
+You can use [`useForegroundService`](/api/mobile/variables/useForegroundService) hook to handle how foreground service behaves on Android.
 
 :::important[Permissions]
 
 If you want to use [`enableCamera`](/api/mobile/type-aliases/ForegroundServiceConfig#enablecamera) or [`enableMicrophone`](/api/mobile/type-aliases/ForegroundServiceConfig#enablemicrophone),
-user must first grant permission for this resource. [`useForegroundService`](/api/mobile/functions/useForegroundService) will check if permission is
+user must first grant permission for this resource. [`useForegroundService`](/api/mobile/variables/useForegroundService) will check if permission is
 granted and only then allow to start a service.
 
 :::
 
 ```tsx
+import {
+  useForegroundService,
+  useCamera,
+  useMicrophone,
+} from "@fishjam-cloud/react-native-client";
+
+const { isCameraOn } = useCamera();
+const { isMicrophoneOn } = useMicrophone();
+
 useForegroundService({
   channelId: "io.fishjam.example.fishjamchat.foregroundservice.channel",
   channelName: "Fishjam Chat Notifications",