@darco2903/altv-web-api 2.0.0 → 2.1.0

package/dist/contract/room.js

@@ -11,6 +11,7 @@ const internalError = {
     500: apiError(z.literal("INTERNAL_SERVER_ERROR"), z.string()),
 };
 const noTrack = apiError(z.literal("NO_TRACK"), z.literal("The room has no track"));
+const queueItemNotFound = apiError(z.literal("QUEUE_ITEM_NOT_FOUND"), z.literal("The queue doesn't have this track"));
 const invalidVideoId = apiError(z.literal("INVALID_VIDEO_ID"), z.literal("The provided video ID is invalid"));
 export default c.router({
     create: {
@@ -94,10 +95,66 @@ export default c.router({
             ...internalError,
         },
     },
+    queueAdd: {
+        method: "POST",
+        path: "/room/:roomId/queue",
+        description: "Add a YouTube video to the queue of a room, it plays right away if the room has nothing to play. Listeners get the queue through the roomQueue socket event",
+        body: z.object({
+            videoId: z.string(),
+        }),
+        responses: {
+            200: c.noBody(),
+            400: z.union([ZodErrorSchema, invalidVideoId]),
+            ...authResponses,
+            ...notFound,
+            409: apiError(z.literal("QUEUE_FULL"), z.literal("The queue of this room is full")),
+            ...internalError,
+        },
+    },
+    queueRemove: {
+        method: "DELETE",
+        path: "/room/:roomId/queue/:itemId",
+        description: "Remove a track from the queue of a room",
+        body: z.undefined(),
+        responses: {
+            200: c.noBody(),
+            ...authResponses,
+            404: z.union([notFound[404], queueItemNotFound]),
+            ...internalError,
+        },
+    },
+    queueMove: {
+        method: "POST",
+        path: "/room/:roomId/queue/:itemId/move",
+        description: "Move a track of the queue of a room to a new index",
+        body: z.object({
+            index: z.number().int().min(0),
+        }),
+        responses: {
+            200: c.noBody(),
+            400: ZodErrorSchema,
+            ...authResponses,
+            404: z.union([notFound[404], queueItemNotFound]),
+            ...internalError,
+        },
+    },
+    next: {
+        method: "POST",
+        path: "/room/:roomId/next",
+        description: "Skip to the next track of the queue of a room",
+        body: z.undefined(),
+        responses: {
+            200: c.noBody(),
+            400: apiError(z.literal("QUEUE_EMPTY"), z.literal("The queue of this room is empty")),
+            ...authResponses,
+            ...notFound,
+            ...internalError,
+        },
+    },
     play: {
         method: "POST",
         path: "/room/:roomId/play",
-        description: "Play the track of a room, from its position. A room without a stream starts a new one",
+        description: "Play the track of a room, from its position, or the next one of its queue if it has none. A room without a stream starts a new one",
         body: z.undefined(),
         responses: {
             200: c.noBody(),

package/dist/socket/room.d.ts

@@ -1,4 +1,4 @@
-import type { RoomState } from "../types/room.js";
+import type { RoomQueueItem, RoomState } from "../types/room.js";
 import type { MediaStreamScene } from "../types/scene.js";
 export interface SocketClientToServerRoom {
     /** Calls back with the state of the room, null if it doesn't exist */
@@ -20,6 +20,10 @@ export interface SocketServerToClientRoom {
     roomTrack: (roomId: string, state: RoomState) => void;
     /** The stream is gone, its url now returns 404. The room stays, with this state. */
     roomEnd: (roomId: string, reason: RoomEndReason, state: RoomState) => void;
+    /** The queue changed, the whole new queue */
+    roomQueue: (roomId: string, queue: RoomQueueItem[]) => void;
+    /** A track of the queue couldn't be played */
+    roomTrackFailed: (roomId: string, title: string) => void;
     /** The scene changed, the whole new scene */
     roomScene: (roomId: string, scene: MediaStreamScene) => void;
     roomName: (roomId: string, name: string | null) => void;

package/dist/types/room.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 export declare const ROOM_ID_PATTERN: RegExp;
 export declare const ROOM_NAME_MAX_LENGTH = 64;
+export declare const ROOM_QUEUE_MAX_LENGTH = 100;
 export declare const roomNameSchema: z.ZodString;
 export declare const roomTrackSchema: z.ZodObject<{
     videoId: z.ZodString;
@@ -16,6 +17,24 @@ export declare const roomTrackSchema: z.ZodObject<{
     title: string;
     duration: number;
 }>;
+export declare const roomQueueItemSchema: z.ZodObject<{
+    videoId: z.ZodString;
+    title: z.ZodString;
+    /** seconds */
+    duration: z.ZodNumber;
+} & {
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    videoId: string;
+    title: string;
+    duration: number;
+    id: string;
+}, {
+    videoId: string;
+    title: string;
+    duration: number;
+    id: string;
+}>;
 export declare const roomStateSchema: z.ZodObject<{
     roomId: z.ZodString;
     name: z.ZodNullable<z.ZodString>;
@@ -35,6 +54,25 @@ export declare const roomStateSchema: z.ZodObject<{
         title: string;
         duration: number;
     }>>;
+    /** Tracks after the current one, the next one first */
+    queue: z.ZodArray<z.ZodObject<{
+        videoId: z.ZodString;
+        title: z.ZodString;
+        /** seconds */
+        duration: z.ZodNumber;
+    } & {
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        videoId: string;
+        title: string;
+        duration: number;
+        id: string;
+    }, {
+        videoId: string;
+        title: string;
+        duration: number;
+        id: string;
+    }>, "many">;
     /** Audio of the current track, null while the room has no stream: nothing is playing, or it was paused for long */
     url: z.ZodNullable<z.ZodString>;
     paused: z.ZodBoolean;
@@ -141,6 +179,12 @@ export declare const roomStateSchema: z.ZodObject<{
         title: string;
         duration: number;
     } | null;
+    queue: {
+        videoId: string;
+        title: string;
+        duration: number;
+        id: string;
+    }[];
     url: string | null;
     paused: boolean;
     startTime: number;
@@ -174,6 +218,12 @@ export declare const roomStateSchema: z.ZodObject<{
         title: string;
         duration: number;
     } | null;
+    queue: {
+        videoId: string;
+        title: string;
+        duration: number;
+        id: string;
+    }[];
     url: string | null;
     paused: boolean;
     startTime: number;
@@ -237,5 +287,6 @@ export declare const roomSummarySchema: z.ZodObject<{
     paused: boolean;
 }>;
 export type RoomTrack = z.infer<typeof roomTrackSchema>;
+export type RoomQueueItem = z.infer<typeof roomQueueItemSchema>;
 export type RoomState = z.infer<typeof roomStateSchema>;
 export type RoomSummary = z.infer<typeof roomSummarySchema>;

package/dist/types/room.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { mediaStreamSceneSchema } from "./scene.js";
 export const ROOM_ID_PATTERN = /^[a-zA-Z0-9]{8}$/;
 export const ROOM_NAME_MAX_LENGTH = 64;
+export const ROOM_QUEUE_MAX_LENGTH = 100;
 export const roomNameSchema = z
     .string()
     .trim()
@@ -13,12 +14,17 @@ export const roomTrackSchema = z.object({
     /** seconds */
     duration: z.number(),
 });
+export const roomQueueItemSchema = roomTrackSchema.extend({
+    id: z.string(),
+});
 export const roomStateSchema = z.object({
     roomId: z.string(),
     name: z.string().nullable(),
     /** public_id of the owner */
     ownerId: z.string(),
     track: roomTrackSchema.nullable(),
+    /** Tracks after the current one, the next one first */
+    queue: z.array(roomQueueItemSchema),
     /** Audio of the current track, null while the room has no stream: nothing is playing, or it was paused for long */
     url: z.string().nullable(),
     paused: z.boolean(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darco2903/altv-web-api",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "",
   "main": "./dist/index.js",
   "keywords": [],