camstreamerlib 4.0.0-beta.80 → 4.0.0-beta.81

package/cjs/types/CamStreamerAPI/sdCardSchema.d.ts

@@ -1,5 +1,6 @@
 import z from 'zod';
 export declare const sdCardSchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
@@ -8,11 +9,13 @@ export declare const sdCardSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "sd_card";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     type: "sd_card";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/cjs/types/CamStreamerAPI/streamCommonTypes.d.ts

@@ -2,15 +2,18 @@ import { z } from 'zod';
 export declare const streamTypeSchema: z.ZodUnion<[z.ZodLiteral<"youtube">, z.ZodLiteral<"facebook">, z.ZodLiteral<"sd_card">, z.ZodLiteral<"windy">, z.ZodLiteral<"mpeg_dvb">, z.ZodLiteral<"hls">, z.ZodLiteral<"rtmp">]>;
 export type TStreamType = z.infer<typeof streamTypeSchema>;
 export declare const streamCommonSchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/cjs/types/CamStreamerAPI/streamCommonTypes.js

@@ -12,6 +12,7 @@ exports.streamTypeSchema = zod_1.z.union([
     zod_1.z.literal('rtmp'),
 ]);
 exports.streamCommonSchema = zod_1.z.object({
+    id: zod_1.z.number(),
     enabled: zod_1.z.boolean(),
     active: zod_1.z.boolean(),
     title: zod_1.z.string(),

package/cjs/types/CamStreamerAPI/windySchema.d.ts

@@ -1,5 +1,6 @@
 import z from 'zod';
 export declare const windySchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
@@ -8,11 +9,13 @@ export declare const windySchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "windy";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     type: "windy";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/cjs/types/CamStreamerAPI/youtubeSchema.d.ts

@@ -1,5 +1,6 @@
 import z from 'zod';
 export declare const youtubeSchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
@@ -8,11 +9,13 @@ export declare const youtubeSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "youtube";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     type: "youtube";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/esm/CamStreamerAPI.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { ProxyClient } from './internal/ProxyClient';
 import { streamSchema } from './types/CamStreamerAPI/CamStreamerAPI';
 import { ErrorWithResponse, UtcTimeFetchError, WsAuthorizationError, MigrationError } from './errors/errors';
-import { oldStringStreamSchema } from './types/CamStreamerAPI/oldStreamSchema';
+import { oldStringStreamSchema, oldStringStreamSchemaWithId, } from './types/CamStreamerAPI/oldStreamSchema';
 const BASE_PATH = '/local/camstreamer';
 export class CamStreamerAPI {
     client;
@@ -28,56 +28,62 @@ export class CamStreamerAPI {
         return z.number().parse(res.data);
     }
     async getStreamList(options) {
-        const res = await this._getJson(`${BASE_PATH}/stream/list.cgi`, undefined, options);
-        const streamList = {};
-        const invalidList = {};
-        for (const [key, value] of Object.entries(res.data)) {
-            const id = parseInt(key);
-            try {
-                const parsed = streamSchema.parse(value);
-                streamList[id] = parsed;
+        const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get' }, options);
+        const oldStreamListRecord = z.record(z.string(), oldStringStreamSchema).safeParse(res.data);
+        if (oldStreamListRecord.success) {
+            const data = Object.entries(oldStreamListRecord.data).map(([id, streamData]) => ({
+                id: parseInt(id),
+                ...parseCameraStreamResponse(streamData),
+            }));
+            throw new MigrationError([], data);
+        }
+        const newStreamData = [];
+        const oldStreamData = [];
+        for (const streamData of res.data.streamList) {
+            const newStreamParse = streamSchema.safeParse(streamData);
+            if (newStreamParse.success) {
+                newStreamData.push(newStreamParse.data);
+                continue;
             }
-            catch (err) {
-                const oldStream = oldStringStreamSchema.parse(value);
-                const parsedOldStream = parseCameraStreamResponse(oldStream);
-                invalidList[id] = parsedOldStream;
+            const oldStreamParse = oldStringStreamSchemaWithId.safeParse(streamData);
+            if (oldStreamParse.success) {
+                oldStreamData.push({
+                    id: parseInt(oldStreamParse.data.id),
+                    ...parseCameraStreamResponse(oldStreamParse.data),
+                });
+                continue;
             }
+            throw new Error('Failed to parse some stream entries');
         }
-        if (Object.keys(invalidList).length > 0) {
-            throw new MigrationError(streamList, invalidList);
+        if (oldStreamData.length > 0) {
+            throw new MigrationError(newStreamData, oldStreamData);
         }
-        return streamList;
+        return newStreamData;
+    }
+    async setStreamList(streamList, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify({ streamList }), {
+            action: 'set',
+        }, options);
     }
     async getStream(streamId, options) {
-        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
-        try {
-            return streamSchema.parse(res.data);
-        }
-        catch (err) {
-            const oldStream = oldStringStreamSchema.parse(res.data);
-            const parsedOldStream = parseCameraStreamResponse(oldStream);
-            throw new MigrationError({}, { [streamId]: parsedOldStream });
+        const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get', stream_id: streamId }, options);
+        const newStream = streamSchema.safeParse(res.data);
+        if (newStream.success) {
+            return newStream.data;
         }
+        const oldStream = oldStringStreamSchema.passthrough().parse(res.data);
+        throw new MigrationError([], [{ id: streamId, ...parseCameraStreamResponse(oldStream) }]);
     }
     async setStream(streamId, streamData, options) {
-        const agent = this.getClient(options?.proxyParams);
-        await agent.post({
-            path: `${BASE_PATH}/stream/set.cgi`,
-            data: JSON.stringify(streamData),
-            parameters: {
-                stream_id: streamId,
-            },
-            timeout: options?.timeout,
-        });
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify(streamData), {
+            action: 'set',
+            stream_id: streamId,
+        }, options);
     }
     async isStreaming(streamId, options) {
         const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);
         return res.data.is_streaming === 1;
     }
-    async deleteStream(streamId, options) {
-        const res = await this._getJson(`${BASE_PATH}/stream/remove.cgi`, { stream_id: streamId }, options);
-        return res.data.status === 200;
-    }
     async _getJson(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);
         const res = await agent.get({ path, parameters, timeout: options?.timeout });
@@ -88,6 +94,17 @@ export class CamStreamerAPI {
             throw new ErrorWithResponse(res);
         }
     }
+    async _postJsonEncoded(path, data, parameters, options, headers) {
+        const agent = this.getClient(options?.proxyParams);
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        return agent.post({
+            path,
+            data,
+            parameters,
+            timeout: options?.timeout,
+            headers: { ...baseHeaders, ...headers },
+        });
+    }
 }
 export const parseCameraStreamResponse = (cameraStreamData) => {
     return {

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -15,6 +15,7 @@ export const streamSchema = z.discriminatedUnion('type', [
     windySchema,
     youtubeSchema,
 ]);
+export const streamListSchema = z.object({ streamList: z.array(streamSchema) });
 export const isFacebookStream = (stream) => {
     return stream.type === 'facebook';
 };

package/esm/types/CamStreamerAPI/oldStreamSchema.js

@@ -22,6 +22,9 @@ export const oldStringStreamSchema = z.object({
     startTime: z.string(),
     stopTime: z.string(),
 });
+export const oldStringStreamSchemaWithId = oldStringStreamSchema.extend({
+    id: z.string(),
+});
 export const oldStreamSchema = z.object({
     enabled: z.union([z.literal(0), z.literal(1)]),
     active: z.union([z.literal(0), z.literal(1)]),

package/esm/types/CamStreamerAPI/streamCommonTypes.js

@@ -9,6 +9,7 @@ export const streamTypeSchema = z.union([
     z.literal('rtmp'),
 ]);
 export const streamCommonSchema = z.object({
+    id: z.number(),
     enabled: z.boolean(),
     active: z.boolean(),
     title: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.80",
+    "version": "4.0.0-beta.81",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/CamStreamerAPI.d.ts

@@ -1,6 +1,6 @@
 import { ProxyClient } from './internal/ProxyClient';
 import { IClient, TResponse } from './internal/types';
-import { TStream } from './types/CamStreamerAPI/CamStreamerAPI';
+import { TStream, TStreamList } from './types/CamStreamerAPI/CamStreamerAPI';
 import { THttpRequestOptions, TProxyParams } from './types/common';
 import { TOldStream, TOldStringStream } from './types/CamStreamerAPI/oldStreamSchema';
 export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
@@ -10,21 +10,84 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
     getUtcTime(options?: THttpRequestOptions): Promise<number>;
-    getStreamList(options?: THttpRequestOptions): Promise<Record<number, TStream>>;
+    getStreamList(options?: THttpRequestOptions): Promise<({
+        type: "facebook";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "hls";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "mpeg_dvb";
+        port: number;
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+        ipAddress: string;
+        standard: "DVB" | "ATSC";
+        nullPacketsPaddingEnabled: boolean;
+        nullPacketsPaddingKbps: number;
+        videoPid: number;
+        audioPid: number;
+        mpegtsStreamId: number;
+        pmtPid: number;
+        pcrPid: number;
+        pcrPeriodMs: number;
+        providerName: string;
+        serviceName: string;
+        triggerType: "manual" | "onetime" | "recurrent" | "io" | "nonstop";
+        statusCameraLed: boolean;
+        statusCameraOutput: string;
+        saveToSdCard: boolean;
+    } | {
+        type: "rtmp";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "sd_card";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "windy";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "youtube";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    })[]>;
+    setStreamList(streamList: TStreamList['streamList'], options?: THttpRequestOptions): Promise<void>;
     getStream(streamId: number, options?: THttpRequestOptions): Promise<{
         type: "facebook";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "hls";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "mpeg_dvb";
         port: number;
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
         ipAddress: string;
@@ -46,27 +109,31 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
     } | {
         type: "rtmp";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "sd_card";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "windy";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "youtube";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     }>;
     setStream(streamId: number, streamData: Partial<TStream>, options?: THttpRequestOptions): Promise<void>;
     isStreaming(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
-    deleteStream(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
     private _getJson;
+    private _postJsonEncoded;
 }
 export declare const parseCameraStreamResponse: (cameraStreamData: TOldStringStream) => TOldStream;

package/types/errors/errors.d.ts

@@ -91,8 +91,12 @@ export declare class BadRequestError<T extends TResponse> extends ErrorWithRespo
     constructor(res: T);
 }
 export declare class MigrationError extends Error {
-    readonly valid: Record<number, TStream>;
-    readonly invalid: Record<number, TOldStream>;
-    constructor(valid: Record<number, TStream>, invalid: Record<number, TOldStream>);
+    readonly valid: TStream[];
+    readonly invalid: (TOldStream & {
+        id: number;
+    })[];
+    constructor(valid: TStream[], invalid: (TOldStream & {
+        id: number;
+    })[]);
 }
 export {};