yoto-nodejs-client 0.0.1

package/lib/api-endpoints/content.test.js

@@ -0,0 +1,250 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import { getContent, getUserMyoContent } from './content.js'
+import { YotoAPIError } from './helpers.js'
+import { loadTestTokens, logResponse } from './test-helpers.js'
+
+const { accessToken } = loadTestTokens()
+
+test('getUserMyoContent', async (t) => {
+  await t.test('should fetch user MYO cards', async () => {
+    const response = await getUserMyoContent({
+      accessToken
+    })
+
+    // Log response for type verification and documentation
+    logResponse('GET /content/mine', response)
+
+    // Validate response structure matches YotoMyoContentResponse
+    assert.ok(response, 'Response should exist')
+    assert.ok(Array.isArray(response.cards), 'Response should have cards array')
+    assert.ok(response.cards.length > 0, 'User should have at least one card')
+
+    // Validate card structure
+    const card = response.cards[0]
+    assert.ok(card, 'Card should exist')
+    assert.ok(typeof card.cardId === 'string', 'Card should have cardId string')
+    assert.ok(typeof card.title === 'string', 'Card should have title string')
+    assert.ok(typeof card.createdAt === 'string', 'Card should have createdAt string')
+    assert.ok(typeof card.updatedAt === 'string', 'Card should have updatedAt string')
+    assert.ok(typeof card.userId === 'string', 'Card should have userId string')
+    assert.ok(card.content, 'Card should have content object')
+    assert.ok(card.metadata, 'Card should have metadata object')
+    assert.ok(card.metadata.media, 'Metadata should have media object')
+    assert.ok(typeof card.metadata.media.duration === 'number', 'Media should have duration number')
+
+    // Validate metadata category enum if present and non-empty
+    if (card.metadata.category && card.metadata.category.length > 0) {
+      const validCategories = ['none', 'stories', 'music', 'radio', 'podcast', 'sfx', 'activities', 'alarms']
+      assert.ok(validCategories.includes(card.metadata.category), `Metadata category should be valid: ${card.metadata.category}`)
+    }
+
+    // Validate optional metadata fields if present
+    if (card.metadata.languages) {
+      const validLanguages = ['en', 'en-gb', 'en-us', 'fr', 'fr-fr', 'es', 'es-es', 'es-419', 'de', 'it']
+      assert.ok(Array.isArray(card.metadata.languages), 'Metadata languages should be array')
+      card.metadata.languages.forEach(lang => {
+        assert.ok(validLanguages.includes(lang), `Language should be valid: ${lang}`)
+      })
+    }
+
+    if (card.metadata.status) {
+      const validStatuses = ['new', 'inprogress', 'complete', 'live', 'archived']
+      assert.ok(validStatuses.includes(card.metadata.status.name), `Status name should be valid: ${card.metadata.status.name}`)
+      assert.ok(typeof card.metadata.status.updatedAt === 'string', 'Status should have updatedAt string')
+    }
+
+    if (card.metadata.playbackDirection) {
+      assert.ok(['DESC', 'ASC'].includes(card.metadata.playbackDirection), 'Playback direction should be DESC or ASC')
+    }
+  })
+
+  await t.test('should accept showDeleted parameter', async () => {
+    const response = await getUserMyoContent({
+      accessToken,
+      showDeleted: true
+    })
+
+    assert.ok(response, 'Response should exist')
+    assert.ok(Array.isArray(response.cards), 'Response should have cards array')
+  })
+
+  await t.test('should fail with invalid token', async () => {
+    await assert.rejects(
+      async () => {
+        await getUserMyoContent({
+          accessToken: 'invalid-token'
+        })
+      },
+      (err) => {
+        assert.ok(err instanceof YotoAPIError, 'Should throw YotoAPIError')
+        assert.ok(err.statusCode === 401 || err.statusCode === 403, 'Should return 401 or 403 for invalid token')
+        assert.ok(err.body, 'Error should have body')
+        return true
+      }
+    )
+  })
+})
+
+test('getContent', async (t) => {
+  /** @type {string[]} */
+  let testCardIds = []
+
+  // Get real card IDs to test with
+  await t.test('setup - get card IDs from user content', async () => {
+    const response = await getUserMyoContent({
+      accessToken
+    })
+
+    assert.ok(response.cards.length > 0, 'User should have at least one card for getContent tests')
+
+    testCardIds = response.cards.slice(0, 3).map(card => card.cardId).filter(Boolean)
+    assert.ok(testCardIds.length > 0, 'Should have extracted at least one card ID')
+  })
+
+  await t.test('should fetch content for valid card IDs', async () => {
+    // Test with multiple cards to ensure consistency
+    for (const cardId of testCardIds) {
+      const content = await getContent({
+        accessToken,
+        cardId
+      })
+
+      // Log response for type verification and documentation
+      logResponse(`GET /content/${cardId}`, content)
+
+      // Validate response structure matches YotoContentResponse
+      assert.ok(content, 'Response should exist')
+      assert.ok(content.card, 'Response should have card property')
+      assert.strictEqual(content.card.cardId, cardId, 'Returned card ID should match requested ID')
+      assert.ok(typeof content.card.title === 'string', 'Card should have title')
+      assert.ok(typeof content.card.createdAt === 'string', 'Card should have createdAt')
+      assert.ok(typeof content.card.updatedAt === 'string', 'Card should have updatedAt')
+      assert.ok(content.card.content, 'Card should have content property')
+      assert.ok(Array.isArray(content.card.content.chapters), 'Content should have chapters array')
+      assert.ok(content.card.metadata, 'Card should have metadata')
+
+      // Validate metadata category enum if present and non-empty
+      if (content.card.metadata.category && content.card.metadata.category.length > 0) {
+        const validCategories = ['none', 'stories', 'music', 'radio', 'podcast', 'sfx', 'activities', 'alarms']
+        assert.ok(validCategories.includes(content.card.metadata.category), `Metadata category should be valid: ${content.card.metadata.category}`)
+      }
+
+      // Validate optional playbackType if present
+      if (content.card.content.playbackType) {
+        const validPlaybackTypes = ['linear', 'interactive']
+        assert.ok(validPlaybackTypes.includes(content.card.content.playbackType), `Playback type should be valid: ${content.card.content.playbackType}`)
+      }
+    }
+  })
+
+  await t.test('should include chapters in content', async () => {
+    const cardId = testCardIds[0]
+    assert.ok(cardId, 'Card ID should exist')
+
+    const content = await getContent({
+      accessToken,
+      cardId
+    })
+
+    // Chapters array should exist (may be empty for some cards)
+    assert.ok(Array.isArray(content.card.content.chapters), 'Should have chapters array')
+
+    // If chapters exist, validate their structure matches YotoChapter type
+    if (content.card.content.chapters.length > 0) {
+      const chapter = content.card.content.chapters[0]
+      assert.ok(chapter, 'Chapter should exist')
+
+      // Validate chapter structure
+      assert.ok(typeof chapter.key === 'string', 'Chapter should have key string')
+      assert.ok(typeof chapter.title === 'string', 'Chapter should have title string')
+      assert.ok(typeof chapter.overlayLabel === 'string', 'Chapter should have overlayLabel string')
+      assert.ok(Array.isArray(chapter.tracks), 'Chapter should have tracks array')
+      assert.ok(chapter.display, 'Chapter should have display object')
+      assert.ok(typeof chapter.display.icon16x16 === 'string', 'Chapter display should have icon16x16 string')
+      assert.ok(typeof chapter.duration === 'number', 'Chapter should have duration number')
+      assert.ok(typeof chapter.fileSize === 'number', 'Chapter should have fileSize number')
+      assert.ok('availableFrom' in chapter, 'Chapter should have availableFrom property')
+      assert.ok('ambient' in chapter, 'Chapter should have ambient property')
+      assert.ok('defaultTrackDisplay' in chapter, 'Chapter should have defaultTrackDisplay property')
+      assert.ok('defaultTrackAmbient' in chapter, 'Chapter should have defaultTrackAmbient property')
+
+      // If tracks exist, validate their structure matches YotoTrack type
+      if (chapter.tracks.length > 0) {
+        const track = chapter.tracks[0]
+        assert.ok(track, 'Track should exist')
+
+        // Validate track structure
+        assert.ok(typeof track.key === 'string', 'Track should have key string')
+        assert.ok(typeof track.title === 'string', 'Track should have title string')
+        assert.ok(typeof track.trackUrl === 'string', 'Track should have trackUrl string')
+        assert.ok(track.trackUrl.startsWith('yoto:#'), 'Track URL should start with "yoto:#"')
+        assert.ok(typeof track.format === 'string', 'Track should have format string')
+
+        // Validate audio format enum
+        const validFormats = ['mp3', 'aac', 'opus', 'ogg']
+        assert.ok(validFormats.includes(track.format), `Track format should be valid: ${track.format}`)
+
+        assert.ok(track.type === 'audio' || track.type === 'stream', 'Track type should be "audio" or "stream"')
+        assert.ok(typeof track.overlayLabel === 'string', 'Track should have overlayLabel string')
+        assert.ok(typeof track.duration === 'number', 'Track should have duration number')
+        assert.ok(typeof track.fileSize === 'number', 'Track should have fileSize number')
+        assert.ok(track.channels === 'stereo' || track.channels === 'mono', 'Track channels should be "stereo" or "mono"')
+        assert.ok('ambient' in track, 'Track should have ambient property')
+        assert.ok(track.display, 'Track should have display object')
+        assert.ok(typeof track.display.icon16x16 === 'string', 'Track display should have icon16x16 string')
+        assert.ok(track.display.icon16x16.startsWith('yoto:#'), 'Track display icon should start with "yoto:#"')
+      }
+    }
+  })
+
+  await t.test('should accept timezone parameter for podcast content', async () => {
+    const cardId = testCardIds[0]
+    assert.ok(cardId, 'Card ID should exist')
+
+    const content = await getContent({
+      accessToken,
+      cardId,
+      timezone: 'Pacific/Auckland'
+    })
+
+    // Log response with timezone parameter
+    logResponse('GET /content/{cardId}?timezone=Pacific/Auckland', content)
+
+    assert.ok(content.card, 'Should return content with timezone parameter')
+    assert.strictEqual(content.card.cardId, cardId, 'Should return correct card')
+  })
+
+  await t.test('should accept playable parameter for signed URLs', async () => {
+    const cardId = testCardIds[0]
+    assert.ok(cardId, 'Card ID should exist')
+
+    const content = await getContent({
+      accessToken,
+      cardId,
+      playable: true,
+      signingType: 's3'
+    })
+
+    // Log response with playable URLs
+    logResponse('GET /content/{cardId}?playable=true&signingType=s3', content)
+
+    assert.ok(content.card, 'Should return content with playable URLs')
+    assert.strictEqual(content.card.cardId, cardId, 'Should return correct card')
+  })
+})
+
+// TODO: Add tests for createOrUpdateContent
+// - should create new content without cardId
+// - should return created card with generated cardId
+// - should update existing content with cardId
+// - should validate response structure matches YotoCreateOrUpdateContentResponse
+// - should fail with invalid token
+// - should accept all content fields (chapters, config, metadata)
+
+// TODO: Add tests for deleteContent
+// - should delete content successfully
+// - should return status 'ok'
+// - should fail with 404 for non-existent cardId
+// - should fail with 404 when trying to delete content user didn't create
+// - should fail with invalid token

package/lib/api-endpoints/devices.d.ts

@@ -0,0 +1,202 @@
+export function getDevices({ accessToken, userAgent, requestOptions }: {
+    accessToken: string;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoDevicesResponse>;
+export function getDeviceStatus({ accessToken, userAgent, deviceId, requestOptions }: {
+    accessToken: string;
+    deviceId: string;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoDeviceStatusResponse>;
+export function getDeviceConfig({ accessToken, userAgent, deviceId, requestOptions }: {
+    accessToken: string;
+    deviceId: string;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoDeviceConfigResponse>;
+export function updateDeviceConfig({ accessToken, userAgent, deviceId, configUpdate, requestOptions }: {
+    accessToken: string;
+    deviceId: string;
+    configUpdate: YotoUpdateDeviceConfigRequest;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoUpdateDeviceConfigResponse>;
+export function updateDeviceShortcuts({ accessToken, userAgent, deviceId, shortcutsUpdate, requestOptions }: {
+    accessToken: string;
+    deviceId: string;
+    shortcutsUpdate: YotoUpdateShortcutsRequest;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoUpdateShortcutsResponse>;
+export function sendDeviceCommand({ accessToken, userAgent, deviceId, command, requestOptions }: {
+    accessToken: string;
+    deviceId: string;
+    command: YotoDeviceCommand;
+    userAgent?: string | undefined;
+    requestOptions?: ({
+        dispatcher?: import("undici").Dispatcher;
+    } & Omit<import("undici").Dispatcher.RequestOptions<unknown>, "origin" | "path" | "method"> & Partial<Pick<import("undici").Dispatcher.RequestOptions<null>, "method">>) | undefined;
+}): Promise<YotoDeviceCommandResponse>;
+export type YotoDevicesResponse = {
+    devices: YotoDevice[];
+};
+export type YotoDevice = {
+    deviceId: string;
+    name: string;
+    description: string;
+    online: boolean;
+    releaseChannel: string;
+    deviceType: string;
+    deviceFamily: string;
+    deviceGroup: string;
+    generation?: string;
+    formFactor?: string;
+};
+export type YotoDeviceStatusResponse = {
+    deviceId: string;
+    activeCard?: string;
+    ambientLightSensorReading?: number;
+    averageDownloadSpeedBytesSecond?: number;
+    batteryLevelPercentage?: number;
+    batteryLevelPercentageRaw?: number;
+    buzzErrors?: number;
+    cardInsertionState?: 0 | 1 | 2;
+    dayMode?: -1 | 0 | 1;
+    errorsLogged?: number;
+    firmwareVersion?: string;
+    freeDiskSpaceBytes?: number;
+    isAudioDeviceConnected?: boolean;
+    isBackgroundDownloadActive?: boolean;
+    isBluetoothAudioConnected?: boolean;
+    isCharging?: boolean;
+    isNfcLocked?: number;
+    isOnline?: boolean;
+    networkSsid?: string;
+    nightlightMode?: string;
+    playingSource?: number;
+    powerCapabilities?: string | null;
+    powerSource?: 0 | 1 | 2 | 3;
+    systemVolumePercentage?: number;
+    taskWatchdogTimeoutCount?: number;
+    temperatureCelcius?: number | string;
+    totalDiskSpaceBytes?: number;
+    updatedAt?: string;
+    uptime?: number;
+    userVolumePercentage?: number;
+    utcOffsetSeconds?: number;
+    utcTime?: number;
+    wifiStrength?: number;
+};
+export type YotoDeviceConfigResponse = {
+    device: YotoDeviceConfigDevice;
+};
+export type YotoDeviceConfigDevice = {
+    config: YotoDeviceConfig;
+    deviceFamily: string;
+    deviceGroup: string;
+    deviceId: string;
+    deviceType: string;
+    errorCode: any;
+    geoTimezone: string;
+    getPosix: string;
+    mac: string;
+    name: string;
+    online: boolean;
+    registrationCode: string;
+    activationPopCode: string;
+    popCode: string;
+    releaseChannelId: string;
+    releaseChannelVersion: string;
+    fwVersion: string;
+    status?: any;
+    shortcuts?: YotoDeviceShortcuts;
+};
+export type YotoDeviceConfig = {
+    alarms?: string[];
+    ambientColour: string;
+    bluetoothEnabled: string;
+    btHeadphonesEnabled: boolean;
+    clockFace?: string;
+    dayDisplayBrightness: string;
+    dayTime: string;
+    dayYotoDaily: string;
+    dayYotoRadio: string;
+    daySoundsOff?: string;
+    displayDimBrightness?: string;
+    displayDimTimeout: string;
+    headphonesVolumeLimited: boolean;
+    hourFormat?: string;
+    logLevel?: string;
+    locale?: string;
+    maxVolumeLimit: string;
+    nightAmbientColour: string;
+    nightDisplayBrightness: string;
+    nightMaxVolumeLimit: string;
+    nightTime: string;
+    nightYotoDaily: string;
+    nightYotoRadio: string;
+    nightSoundsOff?: string;
+    pausePowerButton?: boolean;
+    pauseVolumeDown?: boolean;
+    repeatAll: boolean;
+    showDiagnostics?: boolean;
+    shutdownTimeout: string;
+    systemVolume?: string;
+    timezone?: string;
+    volumeLevel?: string;
+};
+export type YotoDeviceShortcuts = {
+    modes: YotoShortcutModes;
+    versionId: string;
+};
+export type YotoShortcutModes = {
+    day: YotoShortcutMode;
+    night: YotoShortcutMode;
+};
+export type YotoShortcutMode = {
+    content: YotoShortcutContent[];
+};
+export type YotoShortcutContent = {
+    cmd: string;
+    params: YotoShortcutParams;
+};
+export type YotoShortcutParams = {
+    card: string;
+    chapter: string;
+    track: string;
+};
+export type YotoUpdateDeviceConfigRequest = {
+    name?: string;
+    config: Partial<YotoDeviceConfig>;
+};
+export type YotoUpdateDeviceConfigResponse = {
+    status: string;
+};
+export type YotoUpdateShortcutsRequest = {
+    shortcuts: YotoDeviceShortcuts;
+};
+export type YotoUpdateShortcutsResponse = {
+    status: string;
+};
+export type YotoDeviceCommandResponse = {
+    status: string;
+};
+export type YotoDeviceCommand = YotoVolumeCommand | YotoAmbientCommand | YotoSleepTimerCommand | YotoCardStartCommand | YotoBluetoothCommand | YotoDisplayPreviewCommand | {};
+import type { YotoVolumeCommand } from '../mqtt/commands.js';
+import type { YotoAmbientCommand } from '../mqtt/commands.js';
+import type { YotoSleepTimerCommand } from '../mqtt/commands.js';
+import type { YotoCardStartCommand } from '../mqtt/commands.js';
+import type { YotoBluetoothCommand } from '../mqtt/commands.js';
+import type { YotoDisplayPreviewCommand } from '../mqtt/commands.js';
+//# sourceMappingURL=devices.d.ts.map

package/lib/api-endpoints/devices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devices.d.ts","sourceRoot":"","sources":["devices.js"],"names":[],"mappings":"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"}