@darco2903/altv-web-api 1.6.0 → 2.0.0

package/dist/contract/room.js

@@ -0,0 +1,155 @@
+import { initContract, ZodErrorSchema } from "@ts-rest/core";
+import { z } from "zod";
+import { apiError, apiSuccess, authResponses } from "../types.js";
+import { roomNameSchema, roomStateSchema, roomSummarySchema, } from "../types/room.js";
+import { sceneActionSchema } from "../types/scene.js";
+const c = initContract();
+const notFound = {
+    404: apiError(z.literal("ROOM_NOT_FOUND"), z.literal("The requested room was not found")),
+};
+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 invalidVideoId = apiError(z.literal("INVALID_VIDEO_ID"), z.literal("The provided video ID is invalid"));
+export default c.router({
+    create: {
+        method: "POST",
+        path: "/room",
+        description: "Create a room owned by the logged in user",
+        body: z.object({
+            name: roomNameSchema.nullable(),
+        }),
+        responses: {
+            200: apiSuccess(z.object({
+                roomId: z.string(),
+            })),
+            400: ZodErrorSchema,
+            ...authResponses,
+            409: apiError(z.literal("TOO_MANY_ROOMS"), z.literal("You can't own more rooms")),
+            ...internalError,
+        },
+    },
+    list: {
+        method: "GET",
+        path: "/room",
+        description: "Rooms owned by the logged in user",
+        responses: {
+            200: apiSuccess(z.object({
+                rooms: z.array(roomSummarySchema),
+            })),
+            ...authResponses,
+            ...internalError,
+        },
+    },
+    get: {
+        method: "GET",
+        path: "/room/:roomId",
+        description: "Get the state of a room",
+        responses: {
+            200: apiSuccess(roomStateSchema),
+            ...notFound,
+            ...internalError,
+        },
+    },
+    rename: {
+        method: "PATCH",
+        path: "/room/:roomId",
+        description: "Rename a room, owner only, listeners get the name through the roomName socket event",
+        body: z.object({
+            name: roomNameSchema.nullable(),
+        }),
+        responses: {
+            200: c.noBody(),
+            400: ZodErrorSchema,
+            ...authResponses,
+            ...notFound,
+            ...internalError,
+        },
+    },
+    delete: {
+        method: "DELETE",
+        path: "/room/:roomId",
+        description: "Delete a room, owner only",
+        body: z.undefined(),
+        responses: {
+            200: c.noBody(),
+            ...authResponses,
+            ...notFound,
+            ...internalError,
+        },
+    },
+    track: {
+        method: "POST",
+        path: "/room/:roomId/track",
+        description: "Play a YouTube video in a room, listeners switch through the roomTrack socket event. Resolves once it plays, a cache miss downloads the whole video first",
+        body: z.object({
+            videoId: z.string(),
+        }),
+        responses: {
+            200: c.noBody(),
+            400: z.union([ZodErrorSchema, invalidVideoId]),
+            ...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",
+        body: z.undefined(),
+        responses: {
+            200: c.noBody(),
+            400: z.union([noTrack, invalidVideoId]),
+            ...authResponses,
+            ...notFound,
+            ...internalError,
+        },
+    },
+    pause: {
+        method: "POST",
+        path: "/room/:roomId/pause",
+        description: "Pause a room",
+        body: z.undefined(),
+        responses: {
+            200: c.noBody(),
+            ...authResponses,
+            ...notFound,
+            ...internalError,
+        },
+    },
+    seek: {
+        method: "POST",
+        path: "/room/:roomId/seek",
+        description: "Seek the track of a room",
+        query: z.object({
+            time: z.coerce.number().min(0),
+        }),
+        body: z.undefined(),
+        responses: {
+            200: c.noBody(),
+            400: z.union([ZodErrorSchema, noTrack]),
+            ...authResponses,
+            ...notFound,
+            ...internalError,
+        },
+    },
+    scene: {
+        method: "POST",
+        path: "/room/:roomId/scene",
+        description: "Change the scene of a room, listeners get the new scene through the roomScene socket event",
+        body: sceneActionSchema,
+        responses: {
+            200: c.noBody(),
+            400: z.union([
+                ZodErrorSchema,
+                apiError(z.literal("SCENE_FULL"), z.literal("The scene can't have more of this object")),
+                apiError(z.literal("SCENE_OBJECT_NOT_FOUND"), z.literal("The scene object was not found")),
+            ]),
+            ...authResponses,
+            ...notFound,
+            ...internalError,
+        },
+    },
+});

package/dist/socket/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./mediaStream.js";
+export * from "./room.js";
 export * from "./types.js";

package/dist/socket/index.js

@@ -1,2 +1,2 @@
-export * from "./mediaStream.js";
+export * from "./room.js";
 export * from "./types.js";

package/dist/socket/room.d.ts

@@ -0,0 +1,28 @@
+import type { 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 */
+    roomJoin: (roomId: string, callback: (state: RoomState | null) => void) => void;
+    roomLeave: (roomId: string, callback: (success: boolean) => void) => void;
+}
+/**
+ * - `ended`: the track played to the end, clients still have the last seconds buffered
+ * - `idle`: nobody listened, or the room stayed paused, for a while
+ * - `error`: the media couldn't be read
+ * - `shutdown`: the server is stopping
+ */
+export type RoomEndReason = "ended" | "idle" | "error" | "shutdown";
+export interface SocketServerToClientRoom {
+    roomPlay: (roomId: string, startTime: number) => void;
+    roomPause: (roomId: string) => void;
+    roomSeek: (roomId: string, startTime: number) => void;
+    /** A new stream started, for a new track or to resume one: the audio url changed */
+    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 scene changed, the whole new scene */
+    roomScene: (roomId: string, scene: MediaStreamScene) => void;
+    roomName: (roomId: string, name: string | null) => void;
+    /** The room is gone, every request about it now returns 404 */
+    roomDeleted: (roomId: string) => void;
+}

package/dist/socket/types.d.ts

@@ -1,5 +1,5 @@
-import { SocketClientToServerMediaStream, SocketServerToClientMediaStream } from "./mediaStream.js";
-export interface ClientToServerEvents extends SocketClientToServerMediaStream {
+import { SocketClientToServerRoom, SocketServerToClientRoom } from "./room.js";
+export interface ClientToServerEvents extends SocketClientToServerRoom {
 }
-export interface ServerToClientEvents extends SocketServerToClientMediaStream {
+export interface ServerToClientEvents extends SocketServerToClientRoom {
 }

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./youtube.js";
+export * from "./room.js";
 export * from "./scene.js";

package/dist/types/index.js

@@ -1,2 +1,3 @@
 export * from "./youtube.js";
+export * from "./room.js";
 export * from "./scene.js";

package/dist/types/room.d.ts

@@ -0,0 +1,241 @@
+import { z } from "zod";
+export declare const ROOM_ID_PATTERN: RegExp;
+export declare const ROOM_NAME_MAX_LENGTH = 64;
+export declare const roomNameSchema: z.ZodString;
+export declare const roomTrackSchema: z.ZodObject<{
+    videoId: z.ZodString;
+    title: z.ZodString;
+    /** seconds */
+    duration: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    videoId: string;
+    title: string;
+    duration: number;
+}, {
+    videoId: string;
+    title: string;
+    duration: number;
+}>;
+export declare const roomStateSchema: z.ZodObject<{
+    roomId: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    /** public_id of the owner */
+    ownerId: z.ZodString;
+    track: z.ZodNullable<z.ZodObject<{
+        videoId: z.ZodString;
+        title: z.ZodString;
+        /** seconds */
+        duration: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        videoId: string;
+        title: string;
+        duration: number;
+    }, {
+        videoId: string;
+        title: string;
+        duration: number;
+    }>>;
+    /** 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;
+    /** Server timestamp (ms) at which the media was at 0 */
+    startTime: z.ZodNumber;
+    /** seconds, media position when the state was sent */
+    currentTime: z.ZodNumber;
+    scene: z.ZodObject<{
+        speakers: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            z: z.ZodNumber;
+            yaw: z.ZodNumber;
+            pitch: z.ZodNumber;
+            directional: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            x: number;
+            y: number;
+            z: number;
+            yaw: number;
+            pitch: number;
+            directional: boolean;
+        }, {
+            id: string;
+            x: number;
+            y: number;
+            z: number;
+            yaw: number;
+            pitch: number;
+            directional: boolean;
+        }>, "many">;
+        cars: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            x: z.ZodNumber;
+            z: z.ZodNumber;
+            yaw: z.ZodNumber;
+            doors: z.ZodArray<z.ZodBoolean, "many">;
+            windows: z.ZodArray<z.ZodBoolean, "many">;
+            radio: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            x: number;
+            z: number;
+            yaw: number;
+            doors: boolean[];
+            windows: boolean[];
+            radio: boolean;
+        }, {
+            id: string;
+            x: number;
+            z: number;
+            yaw: number;
+            doors: boolean[];
+            windows: boolean[];
+            radio: boolean;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        speakers: {
+            id: string;
+            x: number;
+            y: number;
+            z: number;
+            yaw: number;
+            pitch: number;
+            directional: boolean;
+        }[];
+        cars: {
+            id: string;
+            x: number;
+            z: number;
+            yaw: number;
+            doors: boolean[];
+            windows: boolean[];
+            radio: boolean;
+        }[];
+    }, {
+        speakers: {
+            id: string;
+            x: number;
+            y: number;
+            z: number;
+            yaw: number;
+            pitch: number;
+            directional: boolean;
+        }[];
+        cars: {
+            id: string;
+            x: number;
+            z: number;
+            yaw: number;
+            doors: boolean[];
+            windows: boolean[];
+            radio: boolean;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string | null;
+    roomId: string;
+    ownerId: string;
+    track: {
+        videoId: string;
+        title: string;
+        duration: number;
+    } | null;
+    url: string | null;
+    paused: boolean;
+    startTime: number;
+    currentTime: number;
+    scene: {
+        speakers: {
+            id: string;
+            x: number;
+            y: number;
+            z: number;
+            yaw: number;
+            pitch: number;
+            directional: boolean;
+        }[];
+        cars: {
+            id: string;
+            x: number;
+            z: number;
+            yaw: number;
+            doors: boolean[];
+            windows: boolean[];
+            radio: boolean;
+        }[];
+    };
+}, {
+    name: string | null;
+    roomId: string;
+    ownerId: string;
+    track: {
+        videoId: string;
+        title: string;
+        duration: number;
+    } | null;
+    url: string | null;
+    paused: boolean;
+    startTime: number;
+    currentTime: number;
+    scene: {
+        speakers: {
+            id: string;
+            x: number;
+            y: number;
+            z: number;
+            yaw: number;
+            pitch: number;
+            directional: boolean;
+        }[];
+        cars: {
+            id: string;
+            x: number;
+            z: number;
+            yaw: number;
+            doors: boolean[];
+            windows: boolean[];
+            radio: boolean;
+        }[];
+    };
+}>;
+export declare const roomSummarySchema: z.ZodObject<{
+    roomId: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    track: z.ZodNullable<z.ZodObject<{
+        videoId: z.ZodString;
+        title: z.ZodString;
+        /** seconds */
+        duration: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        videoId: string;
+        title: string;
+        duration: number;
+    }, {
+        videoId: string;
+        title: string;
+        duration: number;
+    }>>;
+    paused: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    name: string | null;
+    roomId: string;
+    track: {
+        videoId: string;
+        title: string;
+        duration: number;
+    } | null;
+    paused: boolean;
+}, {
+    name: string | null;
+    roomId: string;
+    track: {
+        videoId: string;
+        title: string;
+        duration: number;
+    } | null;
+    paused: boolean;
+}>;
+export type RoomTrack = z.infer<typeof roomTrackSchema>;
+export type RoomState = z.infer<typeof roomStateSchema>;
+export type RoomSummary = z.infer<typeof roomSummarySchema>;

package/dist/types/room.js

@@ -0,0 +1,36 @@
+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 roomNameSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(ROOM_NAME_MAX_LENGTH);
+export const roomTrackSchema = z.object({
+    videoId: z.string(),
+    title: z.string(),
+    /** seconds */
+    duration: z.number(),
+});
+export const roomStateSchema = z.object({
+    roomId: z.string(),
+    name: z.string().nullable(),
+    /** public_id of the owner */
+    ownerId: z.string(),
+    track: roomTrackSchema.nullable(),
+    /** 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(),
+    /** Server timestamp (ms) at which the media was at 0 */
+    startTime: z.number(),
+    /** seconds, media position when the state was sent */
+    currentTime: z.number(),
+    scene: mediaStreamSceneSchema,
+});
+export const roomSummarySchema = z.object({
+    roomId: z.string(),
+    name: z.string().nullable(),
+    track: roomTrackSchema.nullable(),
+    paused: z.boolean(),
+});

package/dist/types/scene.d.ts

@@ -43,7 +43,7 @@ export declare const sceneCarSchema: z.ZodObject<{
     doors: z.ZodArray<z.ZodBoolean, "many">;
     /** Open (lowered) windows, one per door */
     windows: z.ZodArray<z.ZodBoolean, "many">;
-    /** The radio plays the stream */
+    /** The radio plays the room */
     radio: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     id: string;
@@ -62,7 +62,7 @@ export declare const sceneCarSchema: z.ZodObject<{
     windows: boolean[];
     radio: boolean;
 }>;
-/** Where the stream is heard, shared by every listener of the stream */
+/** Where a room is heard, shared by every listener of the room */
 export declare const mediaStreamSceneSchema: z.ZodObject<{
     speakers: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -102,7 +102,7 @@ export declare const mediaStreamSceneSchema: z.ZodObject<{
         doors: z.ZodArray<z.ZodBoolean, "many">;
         /** Open (lowered) windows, one per door */
         windows: z.ZodArray<z.ZodBoolean, "many">;
-        /** The radio plays the stream */
+        /** The radio plays the room */
         radio: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
         id: string;
@@ -220,7 +220,7 @@ export declare const sceneActionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodOb
         doors: z.ZodArray<z.ZodBoolean, "many">;
         /** Open (lowered) windows, one per door */
         windows: z.ZodArray<z.ZodBoolean, "many">;
-        /** The radio plays the stream */
+        /** The radio plays the room */
         radio: z.ZodBoolean;
     }, "x" | "z" | "yaw">, "strip", z.ZodTypeAny, {
         x: number;

package/dist/types/scene.js

@@ -30,10 +30,10 @@ export const sceneCarSchema = z.object({
     doors: z.array(z.boolean()).length(CAR_DOORS),
     /** Open (lowered) windows, one per door */
     windows: z.array(z.boolean()).length(CAR_DOORS),
-    /** The radio plays the stream */
+    /** The radio plays the room */
     radio: z.boolean(),
 });
-/** Where the stream is heard, shared by every listener of the stream */
+/** Where a room is heard, shared by every listener of the room */
 export const mediaStreamSceneSchema = z.object({
     speakers: z.array(sceneSpeakerSchema),
     cars: z.array(sceneCarSchema),

package/package.json

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

package/dist/socket/mediaStream.d.ts

@@ -1,21 +0,0 @@
-import type { MediaStreamScene } from "../types/scene.js";
-export interface SocketClientToServerMediaStream {
-    mediaStreamListen: (streamId: string, callback: (success: boolean) => void) => void;
-    mediaStreamUnlisten: (streamId: string, callback: (success: boolean) => void) => void;
-}
-/**
- * - `ended`: the media played to the end, clients still have the last seconds buffered
- * - `idle`: nobody listened for a while
- * - `error`: the media couldn't be read
- * - `shutdown`: the server is stopping
- */
-export type MediaStreamEndReason = "ended" | "idle" | "error" | "shutdown";
-export interface SocketServerToClientMediaStream {
-    mediaStreamPlay: (streamId: string, startTime: number) => void;
-    mediaStreamPause: (streamId: string) => void;
-    mediaStreamSeek: (streamId: string, startTime: number) => void;
-    /** The stream is gone, every request about it now returns 404 */
-    mediaStreamEnd: (streamId: string, reason: MediaStreamEndReason) => void;
-    /** The scene changed, the whole new scene */
-    mediaStreamScene: (streamId: string, scene: MediaStreamScene) => void;
-}