@smarthome.exchange/integrations 1.0.0 → 2.0.0

package/ts/integrations/yamaha/yamaha.validation.ts

@@ -0,0 +1,86 @@
+import * as plugins from '../../plugins.js';
+import { NoSqlConfigStore } from '../../core/classes.configstore.js';
+import type { IYamahaConfig, TYamahaControl, TYamahaModel } from './yamaha.types.js';
+
+export function yamahaRecord(value: unknown, allowed?: readonly string[]): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+    throw new TypeError('Yamaha input must be a plain data object.');
+  }
+  const result: Record<string, unknown> = {};
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== 'string' || (allowed && !allowed.includes(key)) || !descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+      throw new TypeError('Yamaha input contains an unsupported field or accessor.');
+    }
+    Object.defineProperty(result, key, { value: descriptor.value, enumerable: true });
+  }
+  return result;
+}
+
+export function yamahaText(value: unknown, label: string, maximum = 256): string {
+  if (typeof value !== 'string' || !value || value.length > maximum || value !== value.trim() || /[\p{Cc}\p{Cs}]/u.test(value)) {
+    throw new TypeError(`Yamaha ${label} must be bounded text without control characters.`);
+  }
+  return value;
+}
+
+export function yamahaOrigin(value: unknown): string {
+  const text = yamahaText(value, 'selected origin', 256);
+  const match = /^http:\/\/([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(?::([0-9]+))?\/?$/.exec(text);
+  if (!match || plugins.net.isIP(match[1]) !== 4) throw new TypeError('Yamaha requires a canonical literal private IPv4 HTTP origin.');
+  const octets = match[1].split('.').map(Number);
+  const [first, second] = octets;
+  if (!(first === 10 || first === 127 || (first === 172 && second >= 16 && second <= 31) ||
+    (first === 192 && second === 168) || (first === 169 && second === 254))) {
+    throw new TypeError('Yamaha requires a selected private, link-local or loopback IPv4 host.');
+  }
+  if (match[2] !== undefined && (!/^[1-9][0-9]{0,4}$/.test(match[2]) || Number(match[2]) > 65535)) {
+    throw new TypeError('Yamaha HTTP origin port is invalid.');
+  }
+  return new URL(text).origin;
+}
+
+export function yamahaDeviceId(value: unknown): string {
+  if (typeof value !== 'string' || !/^[\x21-\x7e]{12}$/.test(value)) throw new TypeError('Yamaha requires the exact 12-character device_id.');
+  return value;
+}
+
+export function yamahaModel(value: unknown): TYamahaModel {
+  if (value !== 'RX-V485') throw new TypeError('Yamaha model has no selected native profile.');
+  return value;
+}
+
+export function yamahaInteger(value: unknown, fallback?: number, minimum = Number.MIN_SAFE_INTEGER, maximum = Number.MAX_SAFE_INTEGER): number {
+  const result = value === undefined ? fallback : value;
+  if (typeof result !== 'number' || !Number.isSafeInteger(result) || result < minimum || result > maximum) throw new RangeError('Yamaha integer bound is invalid.');
+  return result;
+}
+
+export function normalizeYamahaConfig(value: unknown): Readonly<Required<Omit<IYamahaConfig, 'name'>> & Pick<IYamahaConfig, 'name'>> {
+  const config = yamahaRecord(value, ['homeId', 'origin', 'expectedDeviceId', 'model', 'allowUnencryptedHttp', 'maxVolume', 'name', 'timeoutMs', 'maxResponseBytes', 'maxPendingOperations']);
+  if (config.allowUnencryptedHttp !== true) throw new TypeError('Yamaha plaintext LAN trust must be acknowledged explicitly.');
+  return Object.freeze({
+    homeId: yamahaText(config.homeId, 'home ID'), origin: yamahaOrigin(config.origin), expectedDeviceId: yamahaDeviceId(config.expectedDeviceId),
+    model: yamahaModel(config.model), allowUnencryptedHttp: true, maxVolume: yamahaInteger(config.maxVolume),
+    ...(config.name === undefined ? {} : { name: yamahaText(config.name, 'display name', 128) }),
+    timeoutMs: yamahaInteger(config.timeoutMs, 5000, 1, 60000), maxResponseBytes: yamahaInteger(config.maxResponseBytes, 65536, 256, 1048576),
+    maxPendingOperations: yamahaInteger(config.maxPendingOperations, 16, 1, 128),
+  });
+}
+
+/** The authorized host owns the optional store and its immutable home/domain declaration. */
+export function assertYamahaScope(store: NoSqlConfigStore | undefined, homeId: string): void {
+  if (store === undefined) return;
+  if (!(store instanceof NoSqlConfigStore)) throw new TypeError('Yamaha config store must be an actual NoSqlConfigStore.');
+  const scope = NoSqlConfigStore.prototype.getScope.call(store);
+  if (scope.homeId !== homeId || scope.integrationDomain !== 'yamaha') throw new Error('Yamaha config store must match the exact home and integration.');
+}
+
+export function validateYamahaControl(value: unknown): TYamahaControl {
+  const control = yamahaRecord(value, ['feature', 'value']);
+  if (control.feature === 'power' && typeof control.value === 'boolean') return { feature: 'power', value: control.value };
+  if (control.feature === 'muted' && typeof control.value === 'boolean') return { feature: 'muted', value: control.value };
+  if (control.feature === 'volume_raw') return { feature: 'volume_raw', value: yamahaInteger(control.value) };
+  if (control.feature === 'input' && typeof control.value === 'string' && /^[a-z][a-z0-9_]{0,63}$/.test(control.value)) return { feature: 'input', value: control.value };
+  throw new TypeError('Yamaha supports explicit power, mute, raw integer volume and current advertised input controls.');
+}