@tak-ps/node-tak 12.23.0 → 12.24.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@tak-ps/node-tak",
     "type": "module",
-    "version": "12.23.0",
+    "version": "12.24.0",
     "description": "Lightweight JavaScript library for communicating with TAK Server",
     "author": "Nick Ingalls <nick@ingalls.ca>",
     "main": "dist/index.js",
@@ -37,14 +37,14 @@
         "@tak-ps/xml-js": "^2.0.3"
     },
     "peerDependencies": {
-        "@tak-ps/node-cot": "^v14.30.1"
+        "@tak-ps/node-cot": "^14.52.0"
     },
     "devDependencies": {
         "@eslint/js": "^10.0.1",
         "@inquirer/prompts": "^8.0.1",
         "@types/node": "^26.0.0",
         "@types/pem": "^1.14.4",
-        "c8": "^11.0.0",
+        "c8": "^12.0.0",
         "eslint": "^10.0.0",
         "tsx": "^4.19.4",
         "typedoc": "^0.28.1",

package/test/mission-layer.test.ts

@@ -0,0 +1,137 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Readable } from 'node:stream';
+import { Client } from 'undici';
+import type { Dispatcher } from 'undici';
+import TAKAPI from '../lib/api.js';
+import { APIAuthCertificate } from '../lib/auth.js';
+
+type RequestArgs = Parameters<Client['request']>[0];
+
+function mockResponse(statusCode: number, contentType: string, body: string): Dispatcher.ResponseData {
+    return {
+        statusCode,
+        headers: { 'content-type': contentType },
+        body: Readable.from([Buffer.from(body)]),
+        trailers: {}
+    } as unknown as Dispatcher.ResponseData;
+}
+
+test('MissionLayer.attachUids files UIDs under a layer via the contents paths body', async () => {
+    const originalRequest = Client.prototype.request;
+
+    let captured: RequestArgs | undefined;
+
+    Client.prototype.request = async function(opts: RequestArgs): Promise<Dispatcher.ResponseData> {
+        captured = opts;
+        return mockResponse(200, 'text/plain', '');
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        await api.MissionLayer.attachUids('mission-1', 'layer-1', {
+            uids: ['uid-1', 'uid-2'],
+            creatorUid: 'alice'
+        });
+
+        assert.ok(captured);
+        assert.equal(captured.method, 'PUT');
+        assert.equal(captured.path, '/Marti/api/missions/mission-1/contents?creatorUid=alice');
+        assert.deepEqual(JSON.parse(String(captured.body)), {
+            paths: {
+                'layer-1': [{ uids: ['uid-1', 'uid-2'] }]
+            }
+        });
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});
+
+test('MissionLayer.attachUids uses the guid contents endpoint for GUID missions', async () => {
+    const originalRequest = Client.prototype.request;
+
+    let captured: RequestArgs | undefined;
+
+    Client.prototype.request = async function(opts: RequestArgs): Promise<Dispatcher.ResponseData> {
+        captured = opts;
+        return mockResponse(200, 'text/plain', '');
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        await api.MissionLayer.attachUids('11111111-2222-3333-4444-555555555555', 'layer-1', {
+            uids: ['uid-1'],
+            creatorUid: 'alice'
+        });
+
+        assert.ok(captured);
+        assert.equal(captured.method, 'PUT');
+        assert.equal(
+            captured.path,
+            '/Marti/api/missions/guid/11111111-2222-3333-4444-555555555555/contents?creatorUid=alice'
+        );
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});
+
+test('MissionLayer.setParent re-parents layers via query params', async () => {
+    const originalRequest = Client.prototype.request;
+
+    let captured: RequestArgs | undefined;
+
+    Client.prototype.request = async function(opts: RequestArgs): Promise<Dispatcher.ResponseData> {
+        captured = opts;
+        return mockResponse(200, 'text/plain', '');
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        await api.MissionLayer.setParent('mission-1', {
+            layerUids: ['uid-1', 'uid-2'],
+            parentUid: 'layer-2',
+            creatorUid: 'alice'
+        });
+
+        assert.ok(captured);
+        assert.equal(captured.method, 'PUT');
+        assert.equal(
+            captured.path,
+            '/Marti/api/missions/mission-1/layers/parent?layerUid=uid-1&layerUid=uid-2&parentUid=layer-2&creatorUid=alice'
+        );
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});
+
+test('MissionLayer.setParent omits parentUid to move a layer to the mission root', async () => {
+    const originalRequest = Client.prototype.request;
+
+    let captured: RequestArgs | undefined;
+
+    Client.prototype.request = async function(opts: RequestArgs): Promise<Dispatcher.ResponseData> {
+        captured = opts;
+        return mockResponse(200, 'text/plain', '');
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        await api.MissionLayer.setParent('11111111-2222-3333-4444-555555555555', {
+            layerUids: ['uid-1'],
+            creatorUid: 'alice'
+        });
+
+        assert.ok(captured);
+        assert.equal(captured.method, 'PUT');
+        assert.equal(
+            captured.path,
+            '/Marti/api/missions/guid/11111111-2222-3333-4444-555555555555/layers/parent?layerUid=uid-1&creatorUid=alice'
+        );
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});

package/test/mission.test.ts

@@ -0,0 +1,173 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Readable } from 'node:stream';
+import { Client } from 'undici';
+import type { Dispatcher } from 'undici';
+import TAKAPI from '../lib/api.js';
+import { APIAuthCertificate } from '../lib/auth.js';
+import { MissionSubscriberRole } from '../lib/api/mission.js';
+
+type RequestArgs = Parameters<Client['request']>[0];
+
+function mockResponse(statusCode: number, contentType: string, body: string): Dispatcher.ResponseData {
+    return {
+        statusCode,
+        headers: { 'content-type': contentType },
+        body: Readable.from([Buffer.from(body)]),
+        trailers: {}
+    } as unknown as Dispatcher.ResponseData;
+}
+
+test('Mission.setRole sends role as a bare query param and returns void', async () => {
+    const originalRequest = Client.prototype.request;
+
+    let captured: RequestArgs | undefined;
+
+    Client.prototype.request = async function(opts: RequestArgs): Promise<Dispatcher.ResponseData> {
+        captured = opts;
+        return mockResponse(200, 'text/plain', '');
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        const res = await api.Mission.setRole('mission-1', {
+            clientUid: 'client-1',
+            username: 'alice',
+            role: MissionSubscriberRole.MISSION_OWNER
+        });
+
+        assert.equal(res, undefined);
+        assert.ok(captured);
+        assert.equal(captured.method, 'PUT');
+        assert.equal(
+            captured.path,
+            '/Marti/api/missions/mission-1/role?clientUid=client-1&username=alice&role=MISSION_OWNER'
+        );
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});
+
+test('Mission.subscriptionRoles parses a list of subscribers with roles', async () => {
+    const originalRequest = Client.prototype.request;
+
+    Client.prototype.request = async function(): Promise<Dispatcher.ResponseData> {
+        return mockResponse(200, 'application/json', JSON.stringify({
+            data: [{
+                clientUid: 'client-1',
+                username: 'alice',
+                createTime: '2026-01-01T00:00:00.000Z',
+                role: {
+                    permissions: ['MISSION_READ', 'MISSION_WRITE'],
+                    type: 'MISSION_SUBSCRIBER'
+                }
+            }]
+        }));
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        const res = await api.Mission.subscriptionRoles('mission-1');
+
+        assert.equal(res.data.length, 1);
+        assert.equal(res.data[0].username, 'alice');
+        assert.equal(res.data[0].role.type, 'MISSION_SUBSCRIBER');
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});
+
+test('Mission.unsubscribe issues a DELETE with uid query param', async () => {
+    const originalRequest = Client.prototype.request;
+
+    let captured: RequestArgs | undefined;
+
+    Client.prototype.request = async function(opts: RequestArgs): Promise<Dispatcher.ResponseData> {
+        captured = opts;
+        return mockResponse(200, 'text/plain', '');
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        await api.Mission.unsubscribe('mission-1', { uid: 'client-1' });
+
+        assert.ok(captured);
+        assert.equal(captured.method, 'DELETE');
+        assert.equal(captured.path, '/Marti/api/missions/mission-1/subscription?uid=client-1');
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});
+
+test('Mission.latestFeats parses each CoT individually and isolates invalid CoTs', async () => {
+    const originalRequest = Client.prototype.request;
+
+    let captured: RequestArgs | undefined;
+
+    Client.prototype.request = async function(opts: RequestArgs): Promise<Dispatcher.ResponseData> {
+        captured = opts;
+        return mockResponse(200, 'application/xml', `
+            <events>
+                <event version="2.0" uid="uid-valid" type="a-f-G" time="2026-08-11T00:00:00.000Z" start="2026-08-11T00:00:00.000Z" stale="2026-08-11T00:05:00.000Z" how="h-g-i-g-o">
+                    <point lat="1.1" lon="2.2" hae="0.0" ce="9999999.0" le="9999999.0"/>
+                    <detail>
+                        <contact callsign="ALPHA"/>
+                    </detail>
+                </event>
+                <event version="2.0" uid="uid-poisoned" type="a-f-G" time="2026-08-11T00:00:00.000Z" start="2026-08-11T00:00:00.000Z" stale="2026-08-11T00:05:00.000Z" how="h-g-i-g-o">
+                    <detail>
+                        <contact callsign="BRAVO"/>
+                    </detail>
+                </event>
+            </events>
+        `);
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        const res = await api.Mission.latestFeats('mission-1');
+
+        assert.ok(captured);
+        assert.equal(captured.method, 'GET');
+        assert.equal(captured.path, '/Marti/api/missions/mission-1/cot');
+
+        assert.equal(res.features.length, 1);
+        assert.equal(res.features[0].id, 'uid-valid');
+        assert.equal(res.features[0].properties.callsign, 'ALPHA');
+
+        assert.equal(res.invalid.length, 1);
+        assert.ok(res.invalid[0].error.length > 0);
+
+        const event = res.invalid[0].feature as {
+            _attributes?: Record<string, unknown>;
+            detail?: { contact?: { _attributes?: Record<string, unknown> } };
+        };
+
+        assert.equal(event._attributes?.uid, 'uid-poisoned');
+        assert.equal(event.detail?.contact?._attributes?.callsign, 'BRAVO');
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});
+
+test('Mission.latestFeats returns empty results for an empty document', async () => {
+    const originalRequest = Client.prototype.request;
+
+    Client.prototype.request = async function(): Promise<Dispatcher.ResponseData> {
+        return mockResponse(200, 'application/xml', '<events></events>');
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        const res = await api.Mission.latestFeats('mission-1');
+
+        assert.deepEqual(res, { features: [], invalid: [] });
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});