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

package/src/plugins/schema.ts

@@ -0,0 +1,472 @@
+import { isEqual } from '@camera.ui/common/utils';
+import * as zod from 'zod';
+
+import type {
+  JsonNumberSchema,
+  JsonSchema,
+  JsonSchemaArray,
+  JsonSchemaBoolean,
+  JsonSchemaButton,
+  JsonSchemaEnum,
+  JsonSchemaNumber,
+  JsonSchemaString,
+  JsonSchemaSubmit,
+  JsonSchemaWithoutCallbacks,
+  JsonSchemaWithoutKey,
+  JsonStringSchema,
+} from '@camera.ui/types';
+
+// Type guards for schema identification
+export const isStringType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaString => {
+  return schema.type === 'string' && !('enum' in schema);
+};
+
+export const isNumberType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaNumber => {
+  return schema.type === 'number';
+};
+
+export const isBooleanType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaBoolean => {
+  return schema.type === 'boolean';
+};
+
+export const isEnumType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaEnum => {
+  return schema.type === 'string' && 'enum' in schema;
+};
+
+export const isArrayType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaArray => {
+  return schema.type === 'array';
+};
+
+export const isButtonType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaButton => {
+  return schema.type === 'button';
+};
+
+export const isSubmitType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaSubmit => {
+  return schema.type === 'submit';
+};
+
+export const isValidableStringType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaString => {
+  return isStringType(schema) && (!schema.format || (schema.format !== 'qrCode' && schema.format !== 'image'));
+};
+
+export const isConfigDefault = (config: Record<string, any>, schemas: JsonSchema[]): boolean => {
+  // Early exit for empty config
+  if (!config || Object.keys(config).length === 0) {
+    return true; // Empty config is considered default
+  }
+
+  // Filter out button and submit types as they don't have values
+  const validSchemas = schemas.filter((schema) => !isButtonType(schema) && !isSubmitType(schema));
+
+  // Check each schema field
+  for (const schema of validSchemas) {
+    const currentValue = getValueByKey(config, schema.key);
+    const defaultValue = generateDefaultValue(schema);
+
+    // Skip comparison if the field is not in the config
+    if (currentValue === undefined) continue;
+
+    // Compare values based on type
+    if (!isEqual(currentValue, defaultValue, true)) {
+      return false; // Found a non-default value
+    }
+  }
+
+  return true; // All values match defaults
+};
+
+// Generate default value for a schema field
+export const generateDefaultValue = (schema: JsonSchema): any => {
+  // Return explicit default if provided
+  if ('defaultValue' in schema && schema.defaultValue !== undefined) {
+    return schema.defaultValue;
+  }
+
+  // Generate default based on type
+  switch (schema.type) {
+    case 'string':
+      if (isEnumType(schema)) {
+        return schema.multiple ? [] : schema.required ? schema.enum[0] : '';
+      }
+      return '';
+    case 'number':
+      return 0;
+    case 'boolean':
+      return false;
+    case 'array':
+      return [];
+    default:
+      return undefined;
+  }
+};
+
+// Generate a config object from schema definitions
+export const generateConfigFromSchemas = (schemas: JsonSchema[]): Record<string, any> => {
+  const config: Record<string, any> = {};
+
+  for (const schema of schemas) {
+    // Skip button and submit types as they don't have values
+    if (isButtonType(schema) || isSubmitType(schema)) continue;
+
+    config[schema.key] = generateDefaultValue(schema);
+  }
+
+  return config;
+};
+
+// Get value from config by key
+export const getValueByKey = (config: Record<string, any> = {}, key: string): any => {
+  // For simple keys without nesting
+  if (!key.includes('.') && !key.includes('[')) {
+    return config[key];
+  }
+
+  // For nested keys or array access
+  const keys = key.split('.').reduce<string[]>((acc, part) => {
+    if (part.includes('[')) {
+      const [keyPart, indexPart] = part.split('[');
+      acc.push(keyPart, indexPart.slice(0, -1)); // Remove closing bracket
+    } else {
+      acc.push(part);
+    }
+    return acc;
+  }, []);
+
+  let current = config;
+  for (const k of keys) {
+    if (current === undefined || current === null) {
+      return undefined;
+    }
+    current = current[k];
+  }
+
+  return current;
+};
+
+// Set value in config by key
+export const setValueByKey = (config: Record<string, any>, key: string, value: any): void => {
+  // For simple keys without nesting
+  if (!key.includes('.') && !key.includes('[')) {
+    config[key] = value;
+    return;
+  }
+
+  // For nested keys or array access
+  const keys = key.split('.').reduce<string[]>((acc, part) => {
+    if (part.includes('[')) {
+      const [keyPart, indexPart] = part.split('[');
+      acc.push(keyPart, indexPart.slice(0, -1)); // Remove closing bracket
+    } else {
+      acc.push(part);
+    }
+    return acc;
+  }, []);
+
+  const lastKey = keys.pop();
+  if (!lastKey) return;
+
+  let current = config;
+  for (const k of keys) {
+    if (current[k] === undefined || current[k] === null) {
+      // Create object or array as needed
+      const nextKey = keys[keys.indexOf(k) + 1];
+      current[k] = !isNaN(Number(nextKey)) ? [] : {};
+    }
+    current = current[k];
+  }
+
+  current[lastKey] = value;
+};
+
+// Find schema by key
+export const findSchemaByKey = (schemas: JsonSchema[], key: string): JsonSchema | undefined => {
+  return schemas.find((schema) => schema.key === key);
+};
+
+// Remove callback functions from schema - useful for serialization
+export const removeCallbacksFromSchema = (schema: JsonSchemaWithoutKey): JsonSchemaWithoutCallbacks => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { onSet, onGet, onClick, ...rest } = schema as any;
+
+  if (isArrayType(rest) && rest.items) {
+    rest.items = removeCallbacksFromSchema(rest.items);
+  }
+
+  return rest as JsonSchemaWithoutCallbacks;
+};
+
+// Remove callbacks from all schemas
+export const removeCallbacksFromSchemas = (schemas: JsonSchema[]): JsonSchemaWithoutCallbacks[] => {
+  return schemas.map((schema) => removeCallbacksFromSchema(schema));
+};
+
+// Generate storable config (only include fields with store: true)
+export const generateStorableConfig = (schemas: JsonSchema[], config: Record<string, any>): Record<string, any> => {
+  const storableConfig: Record<string, any> = {};
+
+  for (const schema of schemas) {
+    if ('store' in schema && schema.store && !isButtonType(schema) && !isSubmitType(schema)) {
+      const value = getValueByKey(config, schema.key);
+      if (value !== undefined) {
+        storableConfig[schema.key] = value;
+      }
+    }
+  }
+
+  return storableConfig;
+};
+
+// Check if schema fields have a specific group
+export const getSchemasByGroup = (schemas: JsonSchema[], group: string): JsonSchema[] => {
+  if (!group) return schemas;
+  return schemas.filter((schema) => 'group' in schema && schema.group === group);
+};
+
+// Check if all schemas in a group are readonly
+export const schemaGroupIsReadonly = (schemas: JsonSchema[], group: string): boolean => {
+  const groupSchemas = getSchemasByGroup(schemas, group);
+  return groupSchemas.length > 0 && groupSchemas.every((schema) => 'readonly' in schema && schema.readonly);
+};
+
+// Check if any schema in a group is storable
+export const schemaGroupIsStorable = (schemas: JsonSchema[], group: string): boolean => {
+  const groupSchemas = getSchemasByGroup(schemas, group);
+  return groupSchemas.length > 0 && groupSchemas.some((schema) => 'store' in schema && schema.store);
+};
+
+// Format validation for string types
+export const isValidFormat = (value: string, format?: string): boolean => {
+  if (!format) return true;
+
+  const validations: Record<string, (val: string) => boolean> = {
+    'date-time': (val) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d+)?(Z|[+-]\d{2}:\d{2})?$/.test(val),
+    date: (val) => /^\d{4}-\d{2}-\d{2}$/.test(val),
+    time: (val) => /^([01]?[0-9]|2[0-3]):([0-5][0-9])(:([0-5][0-9]))?$/.test(val),
+    email: (val) => /^\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b$/.test(val),
+    uuid: (val) => /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/.test(val),
+    ipv4: (val) => /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(val),
+    ipv6: (val) => /^\s*([0-9a-fA-F]{1,4}:){7}([0-9a-fA-F]{1,4})\s*$/.test(val),
+    // Add more validations as needed
+  };
+
+  return format in validations ? validations[format](value) : true;
+};
+
+// Validate a value against a schema
+export const validateValue = (value: any, schema: JsonSchemaWithoutKey): boolean => {
+  if (isButtonType(schema) || isSubmitType(schema)) return true;
+
+  // Check required fields
+  if ('required' in schema && schema.required && (value === undefined || value === null || value === '')) {
+    return false;
+  }
+
+  switch (schema.type) {
+    case 'string':
+      if (isEnumType(schema)) {
+        if (schema.multiple) {
+          return Array.isArray(value) && value.every((v) => schema.enum.includes(v));
+        } else {
+          return schema.enum.includes(value);
+        }
+      } else {
+        if (typeof value !== 'string') return false;
+        if ((schema as JsonStringSchema).minLength !== undefined && value.length < (schema as JsonStringSchema).minLength!) return false;
+        if ((schema as JsonStringSchema).maxLength !== undefined && value.length > (schema as JsonStringSchema).maxLength!) return false;
+        if ((schema as JsonStringSchema).format) return isValidFormat(value, (schema as JsonStringSchema).format);
+        return true;
+      }
+
+    case 'number':
+      if (typeof value !== 'number') return false;
+      if ((schema as JsonNumberSchema).minimum !== undefined && value < (schema as JsonNumberSchema).minimum!) return false;
+      if ((schema as JsonNumberSchema).maximum !== undefined && value > (schema as JsonNumberSchema).maximum!) return false;
+      return true;
+
+    case 'boolean':
+      return typeof value === 'boolean';
+
+    case 'array':
+      if (!Array.isArray(value)) return false;
+      return value.every((item) => validateValue(item, (schema as JsonSchemaArray).items));
+
+    default:
+      return true;
+  }
+};
+
+// Validate entire config against schema
+export const validateConfig = (config: Record<string, any>, schemas: JsonSchema[]): Record<string, string[]> => {
+  const errors: Record<string, string[]> = {};
+
+  for (const schema of schemas) {
+    // Skip button and submit types
+    if (isButtonType(schema) || isSubmitType(schema)) continue;
+
+    const value = getValueByKey(config, schema.key);
+    const fieldErrors: string[] = [];
+
+    // Required field check
+    if ('required' in schema && schema.required && (value === undefined || value === null || value === '')) {
+      fieldErrors.push('This field is required');
+    }
+
+    // Type-specific validation
+    if (value !== undefined && value !== null) {
+      if (isStringType(schema)) {
+        if (typeof value !== 'string') {
+          fieldErrors.push('Value must be a string');
+        } else {
+          if (schema.minLength !== undefined && value.length < schema.minLength) {
+            fieldErrors.push(`Minimum length is ${schema.minLength}`);
+          }
+          if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+            fieldErrors.push(`Maximum length is ${schema.maxLength}`);
+          }
+          if (schema.format && !isValidFormat(value, schema.format)) {
+            fieldErrors.push(`Invalid ${schema.format} format`);
+          }
+        }
+      } else if (isNumberType(schema)) {
+        if (typeof value !== 'number') {
+          fieldErrors.push('Value must be a number');
+        } else {
+          if (schema.minimum !== undefined && value < schema.minimum) {
+            fieldErrors.push(`Minimum value is ${schema.minimum}`);
+          }
+          if (schema.maximum !== undefined && value > schema.maximum) {
+            fieldErrors.push(`Maximum value is ${schema.maximum}`);
+          }
+        }
+      } else if (isBooleanType(schema)) {
+        if (typeof value !== 'boolean') {
+          fieldErrors.push('Value must be a boolean');
+        }
+      } else if (isEnumType(schema)) {
+        if (schema.multiple) {
+          if (!Array.isArray(value)) {
+            fieldErrors.push('Value must be an array');
+          } else if (!value.every((v) => schema.enum.includes(v))) {
+            fieldErrors.push('Invalid selection');
+          }
+        } else if (!schema.enum.includes(value)) {
+          fieldErrors.push('Invalid selection');
+        }
+      } else if (isArrayType(schema)) {
+        if (!Array.isArray(value)) {
+          fieldErrors.push('Value must be an array');
+        } else {
+          value.forEach((item, index) => {
+            if (!validateValue(item, schema.items)) {
+              fieldErrors.push(`Invalid item at index ${index}`);
+            }
+          });
+        }
+      }
+    }
+
+    if (fieldErrors.length > 0) {
+      errors[schema.key] = fieldErrors;
+    }
+  }
+
+  return errors;
+};
+
+// Generate a Zod schema for a single JSON schema field
+export const generateZodSchemaField = (schema: JsonSchema): zod.ZodTypeAny => {
+  // Skip validation for button and submit types
+  if (isButtonType(schema) || isSubmitType(schema)) {
+    return zod.any();
+  }
+
+  // Build schema based on type
+  switch (schema.type) {
+    case 'string':
+      // Handle enum type
+      if (isEnumType(schema)) {
+        if (schema.multiple) {
+          // Multiple selection
+          let arraySchema = zod.array(zod.string().refine((val) => schema.enum.includes(val), { message: 'Invalid selection' }));
+
+          if (schema.required) {
+            arraySchema = arraySchema.min(1, { message: 'Required' });
+          }
+
+          return schema.required ? arraySchema : arraySchema.optional();
+        } else {
+          // Single selection
+          const enumSchema = zod.enum(schema.enum as [string, ...string[]]);
+          return schema.required ? enumSchema : enumSchema.optional();
+        }
+      }
+
+      // Regular string
+      let strSchema: zod.ZodString | zod.ZodEffects<any, any, any> = zod.string();
+
+      // Add validation for required fields
+      if (schema.required) {
+        strSchema = strSchema.nonempty('Required');
+      }
+
+      // Add length validations
+      if (schema.minLength !== undefined) {
+        strSchema = strSchema.min(schema.minLength);
+      }
+
+      if (schema.maxLength !== undefined) {
+        strSchema = strSchema.max(schema.maxLength);
+      }
+
+      // Add validation for format
+      if (schema.format) {
+        strSchema = strSchema.refine((val) => !val || val.trim() === '' || isValidFormat(val, schema.format), {
+          message: `Invalid ${schema.format} format`,
+        });
+      }
+
+      return schema.required ? strSchema : strSchema.optional();
+
+    case 'number':
+      let numSchema: zod.ZodNumber | zod.ZodEffects<any, any, any> = zod.number();
+
+      if (schema.minimum !== undefined) {
+        numSchema = numSchema.min(schema.minimum);
+      }
+
+      if (schema.maximum !== undefined) {
+        numSchema = numSchema.max(schema.maximum);
+      }
+
+      if (schema.required) {
+        numSchema = numSchema.refine((val) => val !== undefined && val !== null, { message: 'Required' });
+      }
+
+      return schema.required ? numSchema : numSchema.optional();
+
+    case 'boolean':
+      return schema.required ? zod.boolean() : zod.boolean().optional();
+
+    case 'array':
+      const schemaItems = generateZodSchemaField(schema.items as any);
+      const arraySchema = zod.array(schemaItems);
+      return schema.required ? arraySchema : arraySchema.optional();
+
+    default:
+      return (schema as any).required ? zod.any() : zod.any().optional();
+  }
+};
+
+// // Generate a complete Zod schema from an array of JSON schemas
+export const generateZodSchema = (schemas: JsonSchema[]): zod.ZodObject<any> => {
+  const zodSchemaObj: Record<string, zod.ZodTypeAny> = {};
+
+  schemas.forEach((schema) => {
+    // Skip button and submit types as they don't need validation
+    if (!isButtonType(schema) && !isSubmitType(schema)) {
+      zodSchemaObj[schema.key] = generateZodSchemaField(schema);
+    }
+  });
+
+  return zod.object(zodSchemaObj);
+};

package/src/plugins/types.ts

@@ -0,0 +1,60 @@
+import type { Camera, CameraExtension } from '@camera.ui/types';
+
+export interface Context {
+  engines?: Record<string, string>;
+  dependencies?: Record<string, string>;
+}
+
+export const PLUGIN_IDENTIFIER_PATTERN = /^((@[\w-.]*)\/)?(camera-ui-[\w-]*)$/;
+
+export const CAMERA_EXTENSIONS: CameraExtension[] = ['cameraController', 'hub', 'motionDetection', 'objectDetection', 'audioDetection', 'ptz'];
+
+export interface ProcessLoadMessage {
+  cameras: Camera[];
+  plugin: PluginInfo;
+  storage: PluginStorage;
+}
+
+export interface ProcessMessage {
+  type: PLUGIN_COMMAND;
+  data?: ProcessLoadMessage;
+}
+
+export interface ProcessResponse {
+  type: PLUGIN_STATUS;
+  error?: string;
+}
+
+export enum PLUGIN_STATUS {
+  READY = 'ready',
+  STARTING = 'starting',
+  STARTED = 'started',
+  STOPPING = 'stopping',
+  STOPPED = 'stopped',
+  ERROR = 'error',
+  UNKNOWN = 'unknown',
+  DISABLED = 'disabled',
+}
+
+export enum PLUGIN_COMMAND {
+  START = 'start',
+  STOP = 'stop',
+}
+
+export interface PluginStorage {
+  installPath: string;
+  storagePath: string;
+}
+
+export interface PluginInfo {
+  id: string;
+  name: string;
+  contract: PluginContract;
+}
+
+export interface PluginContract {
+  extensions: CameraExtension[];
+  dependencies?: string[];
+  pythonVersion?: string;
+  bundled?: boolean;
+}