@tak-ps/node-tak 8.2.1 → 8.4.0

package/lib/auth.ts

@@ -0,0 +1,117 @@
+import fetch from './fetch.js';
+import { CookieJar, Cookie } from 'tough-cookie';
+import { CookieAgent } from 'http-cookie-agent/undici';
+import { Client } from 'undici';
+import TAKAPI from './api.js';
+import stream2buffer  from './stream.js';
+
+export class APIAuth {
+    async init(api: TAKAPI) { // eslint-disable-line @typescript-eslint/no-unused-vars
+
+    }
+
+    async fetch(api: TAKAPI, url: URL, opts: any): Promise<any> {
+        return await fetch(url, opts);
+    }
+}
+
+export class APIAuthPassword extends APIAuth {
+    username: string;
+    password: string;
+    jwt: string;
+
+    constructor(username: string, password: string) {
+        super();
+        this.username = username;
+        this.password = password;
+        this.jwt = '';
+    }
+
+    async init(api: TAKAPI) {
+        const { token } = await api.OAuth.login({
+            username: this.username,
+            password: this.password
+        })
+
+        this.jwt = token;
+    }
+
+    async fetch(api: TAKAPI, url: URL, opts: any): Promise<any> {
+        const jar = new CookieJar();
+
+        await jar.setCookie(new Cookie({ key: 'access_token', value: this.jwt }), String(api.url));
+
+        opts.credentials = 'include';
+
+        if (!opts.nocookies) {
+            const agent = new CookieAgent({ cookies: { jar } });
+            opts.dispatcher = agent;
+        }
+
+        return await fetch(url, opts);
+    }
+}
+
+export class APIAuthToken extends APIAuth {
+    jwt?: string;
+
+    constructor(jwt: string) {
+        super();
+        this.jwt = jwt;
+    }
+
+    async fetch(api: TAKAPI, url: URL, opts: any): Promise<any> {
+        const jar = new CookieJar();
+
+        await jar.setCookie(new Cookie({ key: 'access_token', value: this.jwt }), String(api.url));
+
+
+        opts.credentials = 'include';
+        if (!opts.nocookies) {
+            const agent = new CookieAgent({ cookies: { jar } });
+            opts.dispatcher = agent;
+        }
+
+        return await fetch(url, opts);
+    }
+}
+
+export class APIAuthCertificate extends APIAuth {
+    cert: string;
+    key: string;
+
+    constructor(cert: string, key: string) {
+        super();
+        this.cert = cert;
+        this.key = key;
+    }
+
+    async fetch(api: TAKAPI, url: URL, opts: any): Promise<any> {
+        const client = new Client(api.url.origin, {
+            connect: {
+                key: this.key,
+                cert: this.cert,
+                rejectUnauthorized: false,
+            }
+        });
+
+        const res = await client.request({
+            path: String(url).replace(api.url.origin, ''),
+            ...opts
+        });
+
+        return {
+            status: res.statusCode,
+            body: res.body,
+            // Make this similiar to the fetch standard
+            headers: new Map(Object.entries(res.headers)),
+            text: async () => {
+                return String(await stream2buffer(res.body));
+            },
+            json: async () => {
+                return JSON.parse(String(await stream2buffer(res.body)));
+            },
+        };
+    }
+}
+

package/lib/fetch.ts

@@ -0,0 +1,38 @@
+import Err from '@openaddresses/batch-error';
+import { Static, TSchema, TUnknown } from "@sinclair/typebox";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+import { fetch, Response } from 'undici';
+import type { RequestInfo, RequestInit } from 'undici';
+
+export class TypedResponse extends Response {
+    constructor(response: Response) {
+        super(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+    }
+
+    typed<T extends TSchema>(type: T): Promise<Static<T>>;
+
+    async typed<T extends TSchema = TUnknown>(type: T): Promise<Static<T>> {
+        const body = await this.json();
+
+        const typeChecker = TypeCompiler.Compile(type)
+        const result = typeChecker.Check(body);
+
+        if (result) return body;
+
+        const errors = typeChecker.Errors(body);
+        const firstError = errors.First();
+
+        throw new Err(500, null, `Internal Validation Error: ${JSON.stringify(firstError)}`);
+    }
+}
+
+export default async function(
+    input: RequestInfo,
+    init?: RequestInit
+): Promise<TypedResponse> {
+    return new TypedResponse(await fetch(input, init));
+}

package/lib/stream.ts

@@ -0,0 +1,10 @@
+import { Stream } from 'node:stream';
+
+export default async function stream2buffer(stream: Stream): Promise<Buffer> {
+    return new Promise<Buffer>((resolve, reject) => {
+        const _buf = Array<Buffer>(); 
+        stream.on("data", chunk => _buf.push(chunk));
+        stream.on("end", () => resolve(Buffer.concat(_buf)));
+        stream.on("error", (err: Error) => reject(`error converting stream - ${err}`));
+    });
+}

package/package.json

@@ -1,27 +1,40 @@
 {
     "name": "@tak-ps/node-tak",
     "type": "module",
-    "version": "8.2.1",
+    "version": "8.4.0",
     "description": "Lightweight JavaScript library for communicating with TAK Server",
     "author": "Nick Ingalls <nick@ingalls.ca>",
     "main": "dist/index.js",
     "types": "index.ts",
+    "engines": {
+        "node": ">= 22"
+    },
     "scripts": {
-        "test": "ts-node-test test/",
-        "lint": "eslint *.ts test/*.ts",
+        "test": "c8 --reporter=lcov ts-node-test test/",
+        "lint": "eslint *.ts test/ lib/",
         "doc": "typedoc index.ts",
         "build": "tsc --build",
         "pretest": "npm run lint"
     },
     "dependencies": {
-        "ajv": "^8.12.0"
+        "ajv": "^8.12.0",
+        "form-data": "^4.0.2",
+        "http-cookie-agent": "^7.0.1",
+        "mime": "^4.0.7",
+        "pem": "^1.14.8",
+        "tough-cookie": "^5.1.2",
+        "undici": "^7.8.0",
+        "xml2js": "^0.6.2"
     },
     "peerDependencies": {
         "@tak-ps/node-cot": "^12.0.0"
     },
     "devDependencies": {
         "@types/node": "^22.0.0",
+        "@types/pem": "^1.14.4",
         "@types/tape": "^5.6.0",
+        "@types/xml2js": "^0.4.14",
+        "c8": "^10.1.3",
         "eslint": "^9.0.0",
         "tape": "^5.6.1",
         "ts-node": "^10.9.1",