chore(internal): restore custom code

Author: meorphis

.tool-versions

@@ -0,0 +1,2 @@
+nodejs 18.17.0
+yarn 1.22.22

CHANGELOG.md

@@ -4,6 +4,9 @@
 
 This library provides convenient access to the Mux REST API from server-side TypeScript or JavaScript.
 
+> [!NOTE]
+> In February 2024 this SDK was updated to Version 8.0. For upgrading to 8.x see [UPGRADE_8.x.md](https://github.com/muxinc/mux-node-sdk/blob/master/UPGRADE_8.x.md)
+
 The REST API documentation can be found on [docs.mux.com](https://docs.mux.com). The full API of this library can be found in [api.md](api.md).
 
 ## Installation
@@ -63,6 +66,215 @@ main();
 
 Documentation for each method, request param, and response field are available in docstrings and will appear on hover in most modern editors.
 
+## JWT Helpers ([API Reference](https://github.com/muxinc/mux-node-sdk/blob/master/api.md#jwt))
+
+You can use any JWT-compatible library, but we've included some light helpers in the SDK to make it easier to get up and running.
+
+```js
+// Assuming you have your signing key specified in your environment variables:
+// Signing token ID: process.env.MUX_SIGNING_KEY
+// Signing token secret: process.env.MUX_PRIVATE_KEY
+
+// Most simple request, defaults to type video and is valid for 7 days.
+const token = mux.jwt.signPlaybackId('some-playback-id');
+// https://stream.mux.com/some-playback-id.m3u8?token=${token}
+
+// If you wanted to sign a thumbnail
+const thumbParams = { time: 14, width: 100 };
+const thumbToken = mux.jwt.signPlaybackId('some-playback-id', {
+  type: 'thumbnail',
+  params: thumbParams,
+});
+// https://image.mux.com/some-playback-id/thumbnail.jpg?token=${token}
+
+// If you wanted to sign a gif
+const gifToken = mux.jwt.signPlaybackId('some-playback-id', { type: 'gif' });
+// https://image.mux.com/some-playback-id/animated.gif?token=${token}
+
+// Here's an example for a storyboard
+const storyboardToken = mux.jwt.signPlaybackId('some-playback-id', {
+  type: 'storyboard',
+});
+
+// https://image.mux.com/some-playback-id/storyboard.jpg?token=${token}
+
+// You can also use `signViewerCounts` to get a token
+// used for requests to the Mux Engagement Counts API
+// https://docs.mux.com/guides/see-how-many-people-are-watching
+const statsToken = mux.jwt.signViewerCounts('some-live-stream-id', {
+  type: 'live_stream',
+});
+
+// https://stats.mux.com/counts?token={statsToken}
+```
+
+### Signing multiple JWTs at once
+In cases you need multiple tokens, like when using Mux Player, things can get unwieldy pretty quickly. For example,
+```tsx
+const playbackToken = await mux.jwt.signPlaybackId(id, {
+  expiration: "1d",
+  type: "playback"
+})
+const thumbnailToken = await mux.jwt.signPlaybackId(id, {
+  expiration: "1d",
+  type: "thumbnail",
+})
+const storyboardToken = await mux.jwt.signPlaybackId(id, {
+  expiration: "1d",
+  type: "storyboard"
+})
+const drmToken = await mux.jwt.signPlaybackId(id, {
+  expiration: "1d",
+  type: "drm_license"
+})
+
+<mux-player
+  playback-token={playbackToken}
+  thumbanil-token={thumbnailToken}
+  storyboard-token={storyboardToken}
+  drm-token={drmToken}
+  playbackId={id}
+></mux-player>
+```
+
+To simplify this use-case, you can provide multiple types to `signPlaybackId` to recieve multiple tokens. These tokens are provided in a format that Mux Player can take as props:
+```tsx
+// { "playback-token", "thumbnail-token", "storyboard-token", "drm-token" }
+const tokens = await mux.jwt.signPlaybackId(id, {
+  expiration: "1d",
+  type: ["playback", "thumbnail", "storyboard", "drm_license"]
+})
+
+<mux-player
+  {...tokens}
+  playbackId={id}
+></mux-player>
+```
+
+If you would like to provide params to a single token (e.g., if you would like to have a thumbnail `time`), you can provide `[type, typeParams]` instead of `type`:
+```tsx
+const tokens = await mux.jwt.signPlaybackId(id, {
+  expiration: "1d",
+  type: ["playback", ["thumbnail", { time: 2 }], "storyboard", "drm_license"]
+})
+```
+
+## Parsing Webhook payloads
+
+To validate that the given payload was sent by Mux and parse the webhook payload for use in your application,
+you can use the `mux.webhooks.unwrap` utility method.
+
+This method accepts a raw `body` string and a list of headers. As long as you have set your `webhookSecret` in the
+appropriate configuration property when instantiating the library, all webhooks will be verified for authenticity automatically.
+
+The following example shows how you can handle a webhook using a Next.js app directory API route:
+
+```js
+// app/api/mux/webhooks/route.ts
+import { revalidatePath } from 'next/cache';
+import { headers } from 'next/headers';
+
+import Mux from '@mux/mux-node';
+
+const mux = new Mux({
+  webhookSecret: process.env.MUX_WEBHOOK_SECRET,
+});
+
+export async function POST(request: Request) {
+  const headersList = headers();
+  const body = await request.text();
+  const event = mux.webhooks.unwrap(body, headersList);
+
+  switch (event.type) {
+    case 'video.live_stream.active':
+    case 'video.live_stream.idle':
+    case 'video.live_stream.disabled':
+      /**
+       * `event` is now understood to be one of the following types:
+       *
+       *   | Mux.Webhooks.VideoLiveStreamActiveWebhookEvent
+       *   | Mux.Webhooks.VideoLiveStreamIdleWebhookEvent
+       *   | Mux.Webhooks.VideoLiveStreamDisabledWebhookEvent
+       */
+      if (event.data.id === 'MySpecialTVLiveStreamID') {
+        revalidatePath('/tv');
+      }
+      break;
+    default:
+      break;
+  }
+
+  return Response.json({ message: 'ok' });
+}
+```
+
+## Verifying Webhook Signatures
+
+Verifying Webhook Signatures is _optional but encouraged_. Learn more in our [Webhook Security Guide](https://docs.mux.com/docs/webhook-security)
+
+```js
+/*
+  If the header is valid, this function will not throw an error and will not return a value.
+  If the header is invalid, this function will throw one of the following errors:
+    - new Error(
+      "The webhook secret must either be set using the env var, MUX_WEBHOOK_SECRET, on the client class, Mux({ webhookSecret: '123' }), or passed to this function",
+    );
+    - new Error('Could not find a mux-signature header');
+    - new Error(
+      'Webhook body must be passed as the raw JSON string sent from the server (do not parse it first).',
+    );
+    - new Error('Unable to extract timestamp and signatures from header')
+    - new Error('No v1 signatures found');
+    - new Error('No signatures found matching the expected signature for payload.')
+    - new Error('Webhook timestamp is too old')
+*/
+
+/*
+  `body` is the raw request body. It should be a string representation of a JSON object.
+  `headers` is the value in request.headers
+  `secret` is the signing secret for this configured webhook. You can find that in your webhooks dashboard
+          (note that this secret is different than your API Secret Key)
+*/
+
+mux.webhooks.verifySignature(body, headers, secret);
+```
+
+Note that when passing in the payload (body) you want to pass in the raw un-parsed request body, not the parsed JSON. Here's an example if you are using express.
+
+```js
+const Mux = require('@mux/mux-node');
+const mux = new Mux();
+const express = require('express');
+const bodyParser = require('body-parser');
+
+/**
+ * You'll need to make sure this is externally accessible.  ngrok (https://ngrok.com/)
+ * makes this really easy.
+ */
+
+const webhookSecret = process.env.WEBHOOK_SECRET;
+const app = express();
+
+app.post('/webhooks', bodyParser.raw({ type: 'application/json' }), async (req, res) => {
+  try {
+    // will raise an exception if the signature is invalid
+    const isValidSignature = mux.webhooks.verifySignature(req.body, req.headers, webhookSecret);
+    console.log('Success:', isValidSignature);
+    // convert the raw req.body to JSON, which is originally Buffer (raw)
+    const jsonFormattedBody = JSON.parse(req.body);
+    // await doSomething();
+    res.json({ received: true });
+  } catch (err) {
+    // On error, return the error message
+    return res.status(400).send(`Webhook Error: ${err.message}`);
+  }
+});
+
+app.listen(3000, () => {
+  console.log('Example app listening on port 3000!');
+});
+```
+
 ## Handling errors
 
 When the library is unable to connect to the API,
@@ -222,7 +434,7 @@ await client.post('/some/path', {
 });
 ```
 
-#### Undocumented request params
+#### Undocumented params
 
 To make requests using undocumented parameters, you may use `// @ts-expect-error` on the undocumented
 parameter. This library doesn't validate at runtime that the request matches the type, so any extra values you
@@ -243,7 +455,7 @@ extra param in the body.
 If you want to explicitly send an extra argument, you can do so with the `query`, `body`, and `headers` request
 options.
 
-#### Undocumented response properties
+#### Undocumented properties
 
 To access undocumented response properties, you may access the response object with `// @ts-expect-error` on
 the response object, or cast the response object to the requisite type. Like the request params, we do not

README.md

@@ -0,0 +1,23 @@
+# Upgrading to 8.x
+
+If you're coming a version of this SDK before 8.0 then a lot has changed.
+
+For context & background see the [announcement issue](https://github.com/muxinc/mux-node-sdk/issues/327).
+
+## Codemod
+
+There is a codemod script you can run which will modify the old function calls to the new 8.0 syntax:
+
+```
+npx @getgrit/launcher apply mux_v8
+```
+
+This will edit the files in your project in a way that converts your existing code to the new v8 syntax. The codemod script is working well for us, but you should still verify your code changes and make sure it works as expected before deploying the new code to production.
+
+This codemod script was tested and run against code running 7.x versions of the SDK. If you're on a version before 7.x you can still run it, but it might not work as reliably and if you're running into issues you may want to upgrade to 7.3.5 before running the codemod.
+
+## Documentation
+
+The current [README](https://github.com/muxinc/mux-node-sdk/blob/master/README.md) has everything else to get started with version 8.
+
+You also may want to look at [api.md](https://github.com/muxinc/mux-node-sdk/blob/master/api.md) for a full API reference.

UPGRADE_8.x.md

@@ -24,7 +24,7 @@ Methods:
 - <code title="post /video/v1/assets">client.video.assets.<a href="./src/resources/video/assets.ts">create</a>({ ...params }) -> Asset</code>
 - <code title="get /video/v1/assets/{ASSET_ID}">client.video.assets.<a href="./src/resources/video/assets.ts">retrieve</a>(assetId) -> Asset</code>
 - <code title="patch /video/v1/assets/{ASSET_ID}">client.video.assets.<a href="./src/resources/video/assets.ts">update</a>(assetId, { ...params }) -> Asset</code>
-- <code title="get /video/v1/assets">client.video.assets.<a href="./src/resources/video/assets.ts">list</a>({ ...params }) -> AssetsCursorPage</code>
+- <code title="get /video/v1/assets">client.video.assets.<a href="./src/resources/video/assets.ts">list</a>({ ...params }) -> AssetsBasePage</code>
 - <code title="delete /video/v1/assets/{ASSET_ID}">client.video.assets.<a href="./src/resources/video/assets.ts">delete</a>(assetId) -> void</code>
 - <code title="post /video/v1/assets/{ASSET_ID}/playback-ids">client.video.assets.<a href="./src/resources/video/assets.ts">createPlaybackId</a>(assetId, { ...params }) -> PlaybackID</code>
 - <code title="post /video/v1/assets/{ASSET_ID}/tracks">client.video.assets.<a href="./src/resources/video/assets.ts">createTrack</a>(assetId, { ...params }) -> Track</code>
@@ -370,4 +370,13 @@ Types:
 
 Methods:
 
-- <code>client.webhooks.<a href="./src/resources/webhooks.ts">unwrap</a>(body) -> void</code>
+- <code>client.webhooks.<a href="./src/resources/webhooks.ts">unwrap</a>(body, headers, secret) -> UnwrapWebhookEvent</code>
+- <code>client.webhooks.<a href="./src/resources/webhooks.ts">verifySignature</a>(body, headers, secret) -> void</code>
+
+# JWT
+
+Methods:
+
+- <code>client.jwt.<a href="./src/resources/jwt.ts">signPlaybackId</a>(playbackId, config) -> Promise&lt;string&gt;</code>
+- <code>client.jwt.<a href="./src/resources/jwt.ts">signSpaceId</a>(spaceId, config) -> Promise&lt;string&gt;</code>
+- <code>client.jwt.<a href="./src/resources/jwt.ts">signViewerCounts</a>(id, config) -> Promise&lt;string&gt;</code>