@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/src/api/schemas/backup.schema.ts

@@ -0,0 +1,112 @@
+import * as zod from 'zod';
+
+import type { MultipartFile } from '@fastify/multipart';
+
+export const ACCEPTED_BACKUP_TYPES = ['application/x-tar'];
+export const MAX_BACKUP_FILE_SIZE = 1024 * 1024 * 200; // 200mb
+
+const supportedThemesSchema = zod.union([zod.literal('light'), zod.literal('dark')]);
+
+const supportedLanguageAbbreviatonsSchema = zod.union([zod.literal('de'), zod.literal('en')]);
+
+const themeLocalStorageSchema = zod
+  .object({
+    theme: supportedThemesSchema,
+    autoMode: zod.boolean(),
+  })
+  .strict();
+
+const camerasSchema = zod
+  .object({
+    showEvents: zod.boolean(),
+  })
+  .strict();
+
+const camviewSchema = zod
+  .object({
+    dragDisabled: zod.boolean().optional(),
+    viewid: zod.string().optional(),
+  })
+  .strict();
+
+const configSchema = zod
+  .object({
+    zoom: zod.number().min(8).max(20),
+  })
+  .strict();
+
+const consoleSchema = zod
+  .object({
+    zoom: zod.number().min(8).max(20),
+  })
+
+  .strict();
+
+const interfaceSchema = zod.object({
+  showBottomBarOnMobile: zod.boolean(),
+  selectedSettingsView: zod.string(),
+});
+
+const uiSettingsLocalStorageSchema = zod
+  .object({
+    cameras: camerasSchema,
+    camview: camviewSchema,
+    config: configSchema,
+    console: consoleSchema,
+    interface: interfaceSchema,
+  })
+  .strict();
+
+const uiLocalStorageSchema = zod
+  .object({
+    ui: uiSettingsLocalStorageSchema
+      .partial()
+      .optional()
+      .default({
+        config: {
+          zoom: 12,
+        },
+        console: {
+          zoom: 12,
+        },
+      }),
+
+    theme: themeLocalStorageSchema.partial().optional().default({
+      theme: 'light',
+      autoMode: false,
+    }),
+    locale: supportedLanguageAbbreviatonsSchema.optional().default('en'),
+  })
+  .strict();
+
+export const downloadBackupSchema = zod
+  .object({
+    localStorage: uiLocalStorageSchema.partial().optional(),
+  })
+  .strict();
+
+export const restoreBackupSchema = zod.object({
+  upload: zod
+    .custom<MultipartFile | File>()
+    .refine((file) => {
+      const isMultipartFile = (x: any): x is MultipartFile => x.mimetype !== undefined;
+
+      if (isMultipartFile(file)) {
+        return Buffer.byteLength((file as any)._buf) <= MAX_BACKUP_FILE_SIZE;
+      } else {
+        return file.size <= MAX_BACKUP_FILE_SIZE;
+      }
+    }, 'Max file size is 50MB')
+    .refine((file) => {
+      const isMultipartFile = (x: any): x is MultipartFile => x.mimetype !== undefined;
+
+      if (isMultipartFile(file)) {
+        return ACCEPTED_BACKUP_TYPES.includes(file.mimetype);
+      } else {
+        return ACCEPTED_BACKUP_TYPES.includes(file.type);
+      }
+    }, '.tar.* files are accepted') as zod.ZodType<MultipartFile>,
+});
+
+export type DownloadBackupInput = zod.TypeOf<typeof downloadBackupSchema>;
+export type RestoreBackupInput = zod.TypeOf<typeof restoreBackupSchema>;

package/src/api/schemas/cameras.schema.ts

@@ -0,0 +1,479 @@
+import { v4 as uuidv4 } from 'uuid';
+import * as zod from 'zod';
+
+function hasCloudProtocol(urls: string[]): boolean {
+  const cloudProtocols = ['kasa://', 'nest:', 'ring:', 'tapo://'];
+  return urls.some((url) => cloudProtocols.some((protocol) => url.startsWith(protocol)));
+}
+
+export const recordingsSettingsSchema = zod
+  .object({
+    enabled: zod.boolean().default(false),
+  })
+  .strict();
+
+export const objectClassesSchema = zod.union([zod.literal('animal'), zod.literal('person'), zod.literal('vehicle'), zod.literal('other'), zod.literal('motion')]);
+
+export const pointsSchema = zod.tuple([zod.number(), zod.number()]);
+
+export const detectionZoneSchema = zod
+  .object({
+    name: zod.string().min(1, 'Zone Name is required'),
+    points: pointsSchema.array().min(3, 'At least 3 points are required'),
+    type: zod.union([zod.literal('intersect'), zod.literal('contain')]),
+    filter: zod.union([zod.literal('include'), zod.literal('exclude')]),
+    classes: objectClassesSchema.array(),
+    isPrivacyMask: zod.boolean(),
+    color: zod
+      .string()
+      .regex(/^#([0-9A-Fa-f]{3}){1,2}$/, 'Must be a valid hex color (e.g. #FF0000 or #F00)')
+      .default('#df2a4c'),
+  })
+  .array();
+
+export const detectionSettingsSchema = zod.object({
+  motion: zod.object({
+    timeout: zod.number().min(10, 'Minimum 10 seconds'),
+  }),
+  object: zod.object({
+    confidence: zod.number().min(0.3, 'Minimum 0.3').max(1, 'Maximum 1'),
+  }),
+});
+
+export const inputRoleSchema = zod.union([zod.literal('high-resolution'), zod.literal('mid-resolution'), zod.literal('low-resolution'), zod.literal('snapshot')]);
+
+export const streamingSourceRole = zod.union([zod.literal('high-resolution'), zod.literal('mid-resolution'), zod.literal('low-resolution'), zod.literal('auto')]);
+
+export const inputProtocolSchema = zod.union([
+  zod.literal('bubble://'),
+  zod.literal('cui://'),
+  zod.literal('doorbird://'),
+  zod.literal('dvrip://'),
+  zod.literal('echo:'),
+  zod.literal('eseecloud://'),
+  zod.literal('exec:'),
+  zod.literal('expr:'),
+  zod.literal('ffmpeg:'),
+  zod.literal('flussonic://'),
+  zod.literal('gopro://'),
+  zod.literal('hass:'),
+  zod.literal('homekit://'),
+  zod.literal('http://'),
+  zod.literal('https://'),
+  zod.literal('httpx://'),
+  zod.literal('isapi://'),
+  zod.literal('ivideon:'),
+  zod.literal('kasa://'),
+  zod.literal('nest:'),
+  zod.literal('onvif://'),
+  zod.literal('ring:'),
+  zod.literal('roborock://'),
+  zod.literal('rtmp://'),
+  zod.literal('rtsp://'),
+  zod.literal('rtspx://'),
+  zod.literal('tapo://'),
+  zod.literal('tcp://'),
+  zod.literal('webrtc:'),
+  zod.literal('webtorrent:'),
+]);
+
+const protocolList = inputProtocolSchema.options.map((option) => option.value);
+const protocolRegex = new RegExp(`^(${protocolList.join('|')})`);
+
+const urlSchema = zod.string().refine(
+  (val) => {
+    if (!protocolRegex.test(val)) return false;
+
+    try {
+      new URL(val);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: 'Invalid URL format or unsupported protocol',
+  },
+);
+
+export const inputSchema = zod
+  .object({
+    _id: zod
+      .string()
+      .default(uuidv4())
+      .transform(() => uuidv4()),
+    name: zod
+      .string()
+      .min(1, 'Camera Source Name is required')
+      .transform((val) => val.replace(/ /g, '_').toLowerCase()),
+    role: inputRoleSchema,
+    useForSnapshot: zod.boolean().default(false),
+    hotMode: zod.boolean().default(false),
+    urls: urlSchema.array().min(1, 'At least one valid URL is required'),
+  })
+  .strict();
+
+export const patchInputSchema = zod
+  .object({
+    _id: zod
+      .string()
+      .default(uuidv4())
+      .transform(() => uuidv4()),
+    name: zod
+      .string()
+      .min(1, 'Camera Source Name is required')
+      .transform((val) => val.replace(/ /g, '_').toLowerCase()),
+    role: inputRoleSchema,
+    useForSnapshot: zod.boolean().default(false),
+    hotMode: zod.boolean().default(false),
+    urls: urlSchema.array().min(1, 'At least one valid URL is required'),
+  })
+  .strict();
+
+export const extensionSchema = zod.object({
+  id: zod.string(),
+  name: zod.string(),
+});
+
+export const extensionsSettingsSchema = zod
+  .object({
+    hub: extensionSchema.array().optional(),
+    cameraController: extensionSchema.optional(),
+    motionDetection: extensionSchema.optional(),
+    audioDetection: extensionSchema.optional(),
+    objectDetection: extensionSchema.optional(),
+    ptz: extensionSchema.optional(),
+    plugins: extensionSchema.array(),
+  })
+  .strict();
+
+export const streamingModeSchema = zod.union([zod.literal('auto'), zod.literal('mse'), zod.literal('webrtc'), zod.literal('webrtc/tcp')]);
+
+export const aspectRatioSchema = zod.union([zod.literal('16:9'), zod.literal('8:3'), zod.literal('4:3'), zod.literal('auto')]);
+
+export const frameWorkerSettingsSchema = zod.object({
+  decoder: zod.union([zod.literal('pillow'), zod.literal('wasm'), zod.literal('rust'), zod.literal('gpu')]),
+  fps: zod.number().min(0, 'Minimum 0 fps').max(30, 'Maximum 30 fps'),
+  resolution: zod.union([zod.literal('640x480'), zod.literal('640x360'), zod.literal('320x240'), zod.literal('320x180')]),
+});
+
+export const cameraTypeSchema = zod.union([zod.literal('camera'), zod.literal('doorbell')]);
+
+export const interfaceSettingsSchema = zod.object({
+  streamingMode: streamingModeSchema,
+  streamingSource: streamingSourceRole,
+  aspectRatio: aspectRatioSchema,
+});
+
+export const cameraInfoSchema = zod.object({
+  model: zod.string().optional(),
+  manufacturer: zod.string().optional(),
+  hardware: zod.string().optional(),
+  serialNumber: zod.string().optional(),
+  firmwareVersion: zod.string().optional(),
+  supportUrl: zod.string().optional(),
+});
+
+export const pairCameraSchema = zod
+  .object({
+    name: zod.string().min(1, 'Camera name is required'),
+    url: zod.string().url().min(1, 'Camera URL is required'),
+    type: zod.union([
+      zod.literal('Google'),
+      zod.literal('Ring'),
+      zod.literal('HomeKit'),
+      zod.literal('Onvif'),
+      zod.literal('Hass'),
+      zod.literal('GoPro'),
+      zod.literal('Roborock'),
+      zod.literal('FFmpeg'),
+      zod.literal('DVRip'),
+      zod.literal('Webtorrent'),
+    ]),
+    // onvif (optional)/roborock
+    username: zod.string().optional(),
+    // ring
+    email: zod.string().email().optional(),
+    // onvif (optional)/roborock/ring
+    password: zod.string().optional(),
+    // homekit
+    pin: zod.string().length(8, { message: 'PIN must be 8 characters long' }).optional(),
+    // google nest
+    clientId: zod.string().optional(),
+    clientSecret: zod.string().optional(),
+    refreshToken: zod.string().optional(),
+    projectId: zod.string().optional(),
+  })
+  .strict()
+  .refine(
+    (data) => {
+      if (data.type === 'HomeKit') {
+        return !!data.pin;
+      }
+      return true;
+    },
+    {
+      message: 'PIN is required for HomeKit cameras',
+      path: ['pin'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.type === 'Google') {
+        return !!data.clientId;
+      }
+      return true;
+    },
+    {
+      message: 'Client ID is required for Google cameras',
+      path: ['clientId'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.type === 'Google') {
+        return !!data.clientSecret;
+      }
+      return true;
+    },
+    {
+      message: 'Client Secret is required for Google cameras',
+      path: ['clientSecret'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.type === 'Google') {
+        return !!data.projectId;
+      }
+      return true;
+    },
+    {
+      message: 'Project ID is required for Google cameras',
+      path: ['projectId'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.type === 'Google') {
+        return !!data.refreshToken;
+      }
+      return true;
+    },
+    {
+      message: 'Refresh Token is required for Google cameras',
+      path: ['refreshToken'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.type === 'Ring') {
+        return !!data.email;
+      }
+      return true;
+    },
+    {
+      message: 'Email is required',
+      path: ['email'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.type === 'Roborock') {
+        return !!data.username;
+      }
+      return true;
+    },
+    {
+      message: 'Username is required',
+      path: ['username'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.type === 'Roborock' || data.type === 'Ring') {
+        return !!data.password;
+      }
+      return true;
+    },
+    {
+      message: 'Password is required',
+      path: ['password'],
+    },
+  );
+
+export const createCameraSchema = zod
+  .object({
+    _id: zod
+      .string()
+      .default(uuidv4())
+      .transform(() => uuidv4()),
+    nativeId: zod.string().optional(),
+    pluginId: zod.string().default('native'),
+    disabled: zod.boolean().default(false),
+    name: zod.string().min(1, 'Camera name is required'),
+    type: cameraTypeSchema.default('camera'),
+    isCloud: zod.boolean().default(false),
+    snapshotTTL: zod.number().min(30, 'Minimum cache time must be 30').default(600),
+    info: cameraInfoSchema.default({
+      model: 'IP Camera',
+      manufacturer: 'camera.ui',
+      hardware: 'Camera',
+      serialNumber: 'Unknown',
+      firmwareVersion: 'Unknown',
+      supportUrl: 'Unknown',
+    }),
+    sources: inputSchema
+      .array()
+      .refine((sources) => sources.some((source) => source.role === 'high-resolution' || source.role === 'mid-resolution' || source.role === 'low-resolution'), {
+        path: ['sources[].role'],
+        message: 'One of the roles "high-resolution", "mid-resolution" or "low-resolution" is required',
+      })
+      .refine(
+        (sources) => {
+          const snapshotSources = sources.filter((source) => source.useForSnapshot);
+          return snapshotSources.length <= 1;
+        },
+        {
+          message: 'Only one source can be used for snapshot',
+          path: ['sources'],
+        },
+      )
+      .refine(
+        (sources) => {
+          const snapshotSources = sources.filter((source) => source.role === 'snapshot');
+          return snapshotSources.every((source) => !source.useForSnapshot);
+        },
+        {
+          message: 'Snapshot source can not be used with useForSnapshot',
+          path: ['sources'],
+        },
+      )
+      .refine(
+        (sources) => {
+          const snapshotSources = sources.filter((source) => source.role === 'snapshot');
+          return snapshotSources.every((source) => !source.hotMode);
+        },
+        {
+          message: 'Snapshot source can not be used with hotMode',
+        },
+      ),
+    extensions: extensionsSettingsSchema.default({
+      hub: [],
+      plugins: [],
+    }),
+    recording: recordingsSettingsSchema.default({
+      enabled: false,
+    }),
+    interface: interfaceSettingsSchema.default({
+      streamingMode: 'auto',
+      streamingSource: 'auto',
+      aspectRatio: '16:9',
+    }),
+    detectionZones: detectionZoneSchema.default([]),
+    detectionSettings: detectionSettingsSchema.default({
+      motion: {
+        timeout: 60,
+      },
+      object: {
+        confidence: 0.7,
+      },
+    }),
+    frameWorkerSettings: frameWorkerSettingsSchema.default({
+      decoder: 'rust',
+      fps: 10,
+      resolution: '320x180',
+    }),
+  })
+  .strict()
+  .transform((data) => {
+    const allUrls = data.sources.flatMap((source) => source.urls);
+    if (data.isCloud || hasCloudProtocol(allUrls)) {
+      return {
+        ...data,
+        isCloud: true,
+      };
+    }
+
+    return data;
+  });
+
+export const patchCameraSchema = zod
+  .object({
+    disabled: zod.boolean().optional(),
+    type: cameraTypeSchema.optional(),
+    name: zod.string().min(1, 'Camera name is required').optional(),
+    isCloud: zod.boolean().optional(),
+    snapshotTTL: zod.number().min(30, 'Minimum cache time must be 30').optional(),
+    info: cameraInfoSchema.partial().optional(),
+    sources: patchInputSchema
+      .array()
+      .refine((sources) => sources.some((source) => source.role === 'high-resolution' || source.role === 'mid-resolution' || source.role === 'low-resolution'), {
+        path: ['sources[].role'],
+        message: 'One of the roles "high-resolution", "mid-resolution" or "low-resolution" is required',
+      })
+      .refine(
+        (sources) => {
+          const snapshotSources = sources.filter((source) => source.useForSnapshot);
+          return snapshotSources.length <= 1;
+        },
+        {
+          message: 'Only one source can be used for snapshot',
+          path: ['sources'],
+        },
+      )
+      .refine(
+        (sources) => {
+          const snapshotSources = sources.filter((source) => source.role === 'snapshot');
+          return snapshotSources.every((source) => !source.useForSnapshot);
+        },
+        {
+          message: 'Snapshot source can not be used with useForSnapshot',
+          path: ['sources'],
+        },
+      )
+      .refine(
+        (sources) => {
+          const snapshotSources = sources.filter((source) => source.role === 'snapshot');
+          return snapshotSources.every((source) => !source.hotMode);
+        },
+        {
+          message: 'Snapshot source can not be used with hotMode',
+        },
+      )
+      .optional(),
+    extensions: extensionsSettingsSchema.partial().optional(),
+    interface: interfaceSettingsSchema.partial().optional(),
+    recording: recordingsSettingsSchema.partial().optional(),
+    detectionZones: detectionZoneSchema.optional(),
+    detectionSettings: detectionSettingsSchema.partial().optional(),
+    frameWorkerSettings: frameWorkerSettingsSchema.partial().optional(),
+  })
+  .strict()
+  // Ähnliche Transformation wie oben
+  .transform((data) => {
+    if (data.sources) {
+      const allUrls = data.sources.flatMap((source) => source.urls);
+
+      // Wenn isCloud schon auf true gesetzt wurde oder eine der URLs ein Cloud-Protokoll hat
+      if (data.isCloud === true || hasCloudProtocol(allUrls)) {
+        return {
+          ...data,
+          isCloud: true,
+        };
+      }
+    }
+
+    return data;
+  });
+
+export const previewCameraSchema = zod
+  .object({
+    url: zod.string(),
+  })
+  .strict();
+
+export type PreviewCameraInput = zod.TypeOf<typeof previewCameraSchema>;
+export type CreateCameraInput = zod.TypeOf<typeof createCameraSchema>;
+export type PairCameraInput = zod.TypeOf<typeof pairCameraSchema>;
+export type PatchCameraInput = zod.TypeOf<typeof patchCameraSchema>;

package/src/api/schemas/config.schema.ts

@@ -0,0 +1,38 @@
+import * as zod from 'zod';
+
+import { DEFAULT_CONFIG_LOGGER, DEFAULT_CONFIG_PLUGINS, DEFAULT_CONFIG_PORT, DEFAULT_CONFIG_SSL } from '../../services/config/defaults.js';
+
+export const logLevelSchema = zod.union([zod.literal('info'), zod.literal('debug'), zod.literal('warn'), zod.literal('error'), zod.literal('trace')]);
+
+export const loggerSchema = zod
+  .object({
+    level: logLevelSchema.optional().default(DEFAULT_CONFIG_LOGGER.level),
+    disableTimestamps: zod.boolean().optional().default(DEFAULT_CONFIG_LOGGER.disableTimestamps!),
+  })
+  .strict();
+
+export const iConfigSSLSchema = zod
+  .object({
+    certFile: zod.string(),
+    keyFile: zod.string(),
+    caFile: zod.string(),
+    addresses: zod.string().array().optional().default(DEFAULT_CONFIG_SSL.addresses!),
+  })
+  .strict();
+
+export const pluginsSchema = zod
+  .object({
+    disabledPlugins: zod.string().array().default(DEFAULT_CONFIG_PLUGINS.disabledPlugins),
+  })
+  .strict();
+
+export const patchConfigSchema = zod
+  .object({
+    port: zod.number().min(1024, 'Min port range').max(49151, 'Max port range').default(DEFAULT_CONFIG_PORT),
+    ssl: iConfigSSLSchema,
+    logger: loggerSchema,
+    plugins: pluginsSchema,
+  })
+  .strict();
+
+export type PatchConfigInput = zod.TypeOf<typeof patchConfigSchema>;