Mission Layer Content

api/Dockerfile

@@ -1,11 +1,11 @@
-FROM nginx:alpine3.18
+FROM nginx:alpine3.19
 
 EXPOSE 5000
 
 ENV HOME=/home/etl
 WORKDIR $HOME
 
-RUN apk add nodejs npm memcached python3 make bash g++ openssl postgresql-client
+RUN apk add nodejs-current npm memcached python3 make bash g++ openssl postgresql-client
 
 WORKDIR $HOME/api
 

api/lib/api/mission.ts

@@ -113,6 +113,10 @@ export const UnsubscribeInput = Type.Object({
     disconnectOnly: Type.Optional(Type.Boolean())
 })
 
+export const SubscriptionInput = Type.Object({
+    uid: Type.String(),
+});
+
 export const SubscribeInput = Type.Object({
     uid: Type.String(),
     password: Type.Optional(Type.String()),
@@ -133,7 +137,6 @@ export const GetInput = Type.Object({
     secago: Type.Optional(Type.Integer()),
     start: Type.Optional(Type.String()),
     end: Type.Optional(Type.String())
-
 });
 
 export const SetRoleInput = Type.Object({
@@ -229,7 +232,6 @@ export default class {
         let partial = {
             event: '',
             remainder: await this.latestCots(name, opts),
-            discard: ''
         };
 
         do {
@@ -431,12 +433,14 @@ export default class {
      */
     async subscription(
         name: string,
+        query: Static<typeof SubscriptionInput>,
         opts?: Static<typeof MissionOptions>
     ): Promise<Static<typeof MissionSubscriber>> {
         if (this.#isGUID(name)) name = (await this.getGuid(name, {})).name;
 
         const url = new URL(`/Marti/api/missions/${this.#encodeName(name)}/subscription`, this.api.url);
 
+        for (const q in query) url.searchParams.append(q, String(query[q]));
         const res = await this.api.fetch(url, {
             method: 'GET',
             headers: this.#headers(opts),
@@ -523,6 +527,40 @@ export default class {
         return missions.data[0];
     }
 
+    /**
+     * Check if you have access to a given mission
+     */
+    async access(
+        name: string,
+        opts?: Static<typeof MissionOptions>
+    ): Promise<boolean> {
+        try {
+            if (this.#isGUID(name)) {
+                const url = new URL(`/Marti/api/missions/guid/${encodeURIComponent(name)}`, this.api.url);
+
+                const missions: TAKList<Static<typeof Mission>> = await this.api.fetch(url, {
+                    method: 'GET',
+                    headers: this.#headers(opts),
+                });
+
+                if (!missions.data.length) return false;
+                return true;
+            } else {
+                const url = new URL(`/Marti/api/missions/${this.#encodeName(name)}`, this.api.url);
+
+                const missions: TAKList<Static<typeof Mission>> = await this.api.fetch(url, {
+                    method: 'GET',
+                    headers: this.#headers(opts),
+                });
+
+                if (!missions.data.length) return false;
+                return true;
+            }
+        } catch (err) {
+            return false;
+        }
+    }
+
     /**
      * Get mission by its Name
      *

api/lib/auth.ts

@@ -1,5 +1,4 @@
 import { Request } from 'express';
-import { TSchema } from '@sinclair/typebox';
 import Err from '@openaddresses/batch-error';
 import jwt from 'jsonwebtoken';
 import Config from './config.js';

api/lib/aws/alarm.ts

@@ -12,11 +12,11 @@ export default class Alarm {
         this.stack = stack;
     }
 
-    async list() {
+    async list(): Promise<Map<number, string>> {
         const cw = new CloudWatch.CloudWatchClient({ region: process.env.AWS_DEFAULT_REGION });
 
         try {
-            const map = new Map();
+            const map: Map<number, string>  = new Map();
             const res = await cw.send(new CloudWatch.DescribeAlarmsCommand({
                 AlarmNamePrefix: `${this.stack}-layer-`
             }));
@@ -37,7 +37,7 @@ export default class Alarm {
         }
     }
 
-    async get(layer: number) {
+    async get(layer: number): Promise<string> {
         const cw = new CloudWatch.CloudWatchClient({ region: process.env.AWS_DEFAULT_REGION });
 
         try {

api/lib/aws/dynamo.ts

@@ -71,13 +71,13 @@ export default class Dynamo {
         }
     }
 
-    #expiry(feature: any) {
+    #expiry(feature: any): number {
         const time = new Date(feature.properties.stale || feature.properties.time || Date.now());
         time.setHours(time.getHours() + 24);
         return Math.round(time.getTime() / 1000);
     }
 
-    async put(feature: any) {
+    async put(feature: any): Promise<void> {
         try {
             const ddb = new DynamoDB.DynamoDBClient({region: process.env.AWS_DEFAULT_REGION });
             const ddbdoc = DynamoDBDoc.DynamoDBDocumentClient.from(ddb);
@@ -97,7 +97,7 @@ export default class Dynamo {
         }
     }
 
-    async puts(features: any[]) {
+    async puts(features: any[]): Promise<void> {
         try {
             const ddb = new DynamoDB.DynamoDBClient({region: process.env.AWS_DEFAULT_REGION });
             const ddbdoc = DynamoDBDoc.DynamoDBDocumentClient.from(ddb);

api/lib/aws/hooks.ts

@@ -12,7 +12,7 @@ export default class HookQueue {
         this.sqs = new SQS.SQSClient({ region: process.env.AWS_DEFAULT_REGION });
     }
 
-    async submit(connectionid: number | string, MessageBody: string) {
+    async submit(connectionid: number | string, MessageBody: string): Promise<SQS.SendMessageCommandOutput> {
         try {
             const res = await this.sqs.send(new SQS.SendMessageCommand({
                 QueueUrl: process.env.HookURL,

api/lib/cacher.ts

@@ -43,12 +43,10 @@ export default class Cacher {
 
             try {
                 if (key && !this.nocache) {
-                    if (isJSON) {
-                        await this.cache.set(key, JSON.stringify(fresh), {
-                            expires: 604800
-                        });
-                    } else {
-                        await this.cache.set(key, fresh, {
+                    const buff = Buffer.from(isJSON ? JSON.stringify(fresh) : fresh);
+
+                    if (buff.length < 1000000) {
+                        await this.cache.set(key, buff, {
                             expires: 604800
                         });
                     }

api/lib/connection-config.ts

@@ -1,4 +1,5 @@
 import { Connection } from './schema.js';
+import { X509Certificate } from 'crypto';
 import { InferSelectModel, sql } from 'drizzle-orm';
 import Config from './config.js';
 
@@ -21,6 +22,8 @@ export default interface ConnectionConfig {
 
     subscription: (name: string) => Promise<null | MissionSub>;
     subscriptions: () => Promise<Array<MissionSub>>;
+
+    uid(): string;
 }
 
 export class MachineConnConfig implements ConnectionConfig {
@@ -38,6 +41,14 @@ export class MachineConnConfig implements ConnectionConfig {
         this.auth = connection.auth;
     }
 
+    uid(): string {
+        const cert = new X509Certificate(this.auth.cert);
+
+        const subject = cert.subject.split('\n').reverse().join(',');
+
+        return subject;
+    }
+
     async subscription(name: string): Promise<null | MissionSub> {
         const missions = await this.config.models.Data.list({
             where: sql`
@@ -90,6 +101,10 @@ export class ProfileConnConfig implements ConnectionConfig {
         this.auth = auth;
     }
 
+    uid(): string {
+        return `ANDROID-CloudTAK-${this.id}`;
+    }
+
     async subscription(name: string): Promise<null | MissionSub> {
         const missions = await this.config.models.ProfileOverlay.list({
             where: sql`

api/lib/connection-pool.ts

@@ -134,7 +134,6 @@ export default class ConnectionPool extends Map<number | string, ConnectionClien
 
             for (const client of (this.config.wsClients.get(String(conn.id)) || [])) {
                 if (client.format == 'geojson') {
-
                     if (feat.properties && feat.properties.chat) {
                         client.ws.send(JSON.stringify({ type: 'chat', connection: conn.id, data: feat }));
                     } else {
@@ -171,10 +170,16 @@ export default class ConnectionPool extends Map<number | string, ConnectionClien
         }).on('secureConnect', async () => {
             for (const sub of await connConfig.subscriptions()) {
                 try {
-                    await api.Mission.subscribe(sub.name, { uid: String(connConfig.id) });
+
+                    await api.Mission.subscribe(sub.name, {
+                        uid: connConfig.uid()
+                    },{
+                        token: sub.token
+                    });
+
                     console.log(`Connection: ${connConfig.id} - Sync: ${sub.name}: Subscribed!`);
                 } catch (err) {
-                    console.warn(`Connection: ${connConfig.id} - Sync: ${sub.name}: ${err.message}`);
+                    console.warn(`Connection: ${connConfig.id} (${connConfig.uid()}) - Sync: ${sub.name}: ${err.message}`);
                 }
             }
         }).on('end', async () => {
@@ -203,13 +208,13 @@ export default class ConnectionPool extends Map<number | string, ConnectionClien
         if (connClient.initial) {
             if (connClient.retry >= 5) return; // These are considered stalled connections
             connClient.retry++
-            console.log(`not ok - ${connClient.config.id} - ${connClient.config.name} - retrying in ${connClient.retry * 1000}ms`)
+            console.log(`not ok - ${connClient.config.uid()} - ${connClient.config.name} - retrying in ${connClient.retry * 1000}ms`)
             await sleep(connClient.retry * 1000);
             await connClient.tak.reconnect();
         } else {
             // For now allow infinite retry if a client has connected once
             const retryms = Math.min(connClient.retry * 1000, 15000);
-            console.log(`not ok - ${connClient.config.id} - ${connClient.config.name} - retrying in ${retryms}ms`)
+            console.log(`not ok - ${connClient.config.uid()} - ${connClient.config.name} - retrying in ${retryms}ms`)
             await sleep(retryms);
             await connClient.tak.reconnect();
         }

api/lib/esri.ts

@@ -89,7 +89,7 @@ export class EsriBase {
             let json: { [k: string]: unknown; } = await res.json()
 
             if (json.error) {
-                // @ts-expect-error
+                // @ts-expect-error No Typing on JSON Body
                 throw new Err(400, null, `ESRI Server Error: ${json.error.message} - ${json.error.details.join(', ')}`);
             }
 

api/lib/geocode.ts

@@ -1,6 +1,5 @@
 import fetch from './fetch.js';
 import Err from '@openaddresses/batch-error';
-import Config from './config.js';
 import { Static, Type } from "@sinclair/typebox";
 
 export const FetchReverse = Type.Object({
@@ -37,7 +36,7 @@ export default class Geocode {
         return body.address;
     }
 
-    async forward(search: string): Promise<Static<typeof FetchForward>> {
+    async forward(): Promise<Static<typeof FetchForward>> {
         throw new Err(400, null, 'Unimplemented');
     }
 }

api/lib/jobs/lambda.js

@@ -1,3 +1,4 @@
+/* global console, Buffer, process */
 import AWSLambda from '@aws-sdk/client-lambda';
 import { workerData } from 'node:worker_threads';
 

api/lib/provider.ts

@@ -1,5 +1,4 @@
 import Config from './config.js';
-import { Type } from '@sinclair/typebox'
 import Err from '@openaddresses/batch-error';
 import moment from 'moment';
 import fetch from './fetch.js';

api/lib/schema.ts

@@ -5,7 +5,7 @@ import { geometry, GeometryType } from '@openaddresses/batch-generic';
 import { ConnectionAuth } from './connection-config.js';
 import { TAKGroup, TAKRole } from  './api/types.js';
 import { Layer_Priority, Profile_Stale, Profile_Speed, Profile_Elevation, Profile_Distance } from  './enums.js';
-import { json, boolean, integer, timestamp, pgTable, serial, varchar, text, unique } from 'drizzle-orm/pg-core';
+import { json, boolean, integer, timestamp, pgTable, serial, varchar, text, unique, index } from 'drizzle-orm/pg-core';
 
 /** Internal Tables for Postgis for use with drizzle-kit push:pg */
 export const SpatialRefSys = pgTable('spatial_ref_sys', {
@@ -73,7 +73,11 @@ export const Basemap = pgTable('basemaps', {
     format: text('format').notNull().default('png'),
     style: text('style').notNull().default('zxy'),
     type: text('type').notNull().default('raster')
-});
+}, (table) => {
+    return {
+        username_idx: index("basemaps_username_idx").on(table.username),
+    }
+})
 
 export const Import = pgTable('imports', {
     id: text('id').primaryKey(),
@@ -102,8 +106,13 @@ export const Iconset = pgTable('iconsets', {
     default_neutral: text('default_neutral'),
     default_unknown: text('default_unknown'),
     skip_resize: boolean('skip_resize').notNull().default(false)
+}, (table) => {
+    return {
+        username_idx: index("iconsets_username_idx").on(table.username),
+    }
 });
 
+
 export const Icon = pgTable('icons', {
     id: serial('id').primaryKey(),
     created: timestamp('created', { withTimezone: true, mode: 'string' }).notNull().default(sql`Now()`),

api/lib/sinks.ts

@@ -47,7 +47,7 @@ export default class Sinks extends Map<string, typeof SinkInterface> {
             };
 
             try {
-                this.queue.submit(conn.id, JSON.stringify({
+                await this.queue.submit(conn.id, JSON.stringify({
                     id: sink.id,
                     type: sink.type,
                     body: sink.body,

api/lib/sprites.ts

@@ -14,16 +14,14 @@ export default async function(icons: Array<InferSelectModel<typeof Icon>>, confi
     const doc = await SpriteSmith({
         src: icons.map((icon) => {
             return new Vinyl({
-                // @ts-ignore
                 path: config.name ? icon[config.name] + '.png' : icon.path.replace(/.*?\//, ''),
                 contents: Buffer.from(icon.data, 'base64'),
             })
         })
     });
 
-    const coords = {};
+    const coords: Record<string, any> = {};
     for (const key in doc.coordinates) {
-        // @ts-ignore
         coords[key.replace(/.png/, '')] = {
             ...doc.coordinates[key],
             pixelRatio: 1

api/lib/types.ts

@@ -179,6 +179,7 @@ export const ConnectionResponse = Type.Object({
     status: Type.String(),
     agency: Type.Optional(Type.Union([Type.Integer(), Type.Null()])),
     certificate: Type.Object({
+        subject: Type.String(),
         validFrom: Type.String(),
         validTo: Type.String()
     }),

api/migrations/0046_premium_newton_destine.sql

@@ -0,0 +1,3 @@
+ALTER TABLE "layers" ALTER COLUMN "stale" SET DEFAULT 20;--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "basemaps_username_idx" ON "basemaps" USING btree ("username");--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "iconsets_username_idx" ON "iconsets" USING btree ("username");