@mapcreator/api 0.0.0-mc2896.0 → 0.0.0-mc2896.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapcreator/api",
-  "version": "0.0.0-mc2896.0",
+  "version": "0.0.0-mc2896.1",
   "description": "Mapcreator JavaScript API",
   "license": "BSD-3-Clause",
   "main": "./cjs/index.js",

package/src/api/choropleth.ts

@@ -10,6 +10,8 @@ export const boundingBoxRevivers: Revivers<
   boundingBox: (data: { bounding_box: string }) => JSON.parse(data.bounding_box) as Polygon,
 };
 
+export type SAGALanguage = 'en' | 'da' | 'nl' | 'fi' | 'fr' | 'de' | 'it' | 'no' | 'pl' | 'pt' | 'es' | 'sv' | 'ja' | 'zh' | 'ru' | 'uk' | 'lv' | 'kk' | '';
+
 export type ApiSearchPoint = {
   lat: number;
   lng: number;
@@ -30,12 +32,10 @@ type SingleOrGroupedAreaBase = {
   boundingBox: Polygon;
 };
 
-// TODO don't export this once search on click is out
 export type GroupedArea = SingleOrGroupedAreaBase & {
   isGroup: true;
 };
 
-// TODO don't export this once search on click is out
 export type SingleArea = SingleOrGroupedAreaBase & {
   isGroup: false;
   properties: Record<string, string>;
@@ -44,70 +44,100 @@ export type SingleArea = SingleOrGroupedAreaBase & {
   featureId: number;
 };
 
-export type SingleOrGroupedArea = {
-  id: number;
-  title: string;
-  subtitle: string;
-  svgPreview: string;
-  boundingBox: Polygon;
-  isGroup: boolean;
-  properties: Record<string, string> | null;
-  vectorSource: string | null;
-  sourceLayer: string | null;
-  featureId: number | null;
-};
+type ApiSingleArea = {
+  data: {
+    id: number;
+    title: string;
+    subtitle: string;
+    svg_preview: string;
+    bounding_box: string;
+    is_group: false;
+    properties: string;
+    vector_source: string;
+    source_layer: string;
+    feature_id: number;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiSingleAreaData = Flatten<Exclude<ApiSingleArea, ApiError>['data']>;
+
+export type ApiSingleAreaArray = {
+  data: ApiSingleAreaData[];
+} & Omit<ApiSuccess, 'data'> | ApiError;
 
-export type ApiSingleOrGroupedArea = {
+type ApiGroupedArea = {
   data: {
     id: number;
     title: string;
     subtitle: string;
     svg_preview: string;
     bounding_box: string;
-    is_group: boolean;
-    properties: string | null;
-    vector_source: string | null;
-    source_layer: string | null;
-    feature_id: number | null;
+    is_group: true;
+    properties: null;
+    vector_source: null;
+    source_layer: null;
+    feature_id: null;
   };
 } & Omit<ApiSuccess, 'data'> | ApiError;
 
-export type ApiSingleOrGroupedAreaData = Flatten<Exclude<ApiSingleOrGroupedArea, ApiError>['data']>;
+export type ApiGroupedAreaData = Flatten<Exclude<ApiGroupedArea, ApiError>['data']>;
+
+export type ApiGroupedAreaArray = {
+  data: ApiGroupedAreaData[];
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export const singleAreaRevivers: Revivers<ApiSingleArea, SingleArea> = {
+  ...boundingBoxRevivers,
+  properties: (data: ApiSingleAreaData) =>
+    JSON.parse(data.properties) as Record<string, string>,
+};
 
-export const singleOrGroupedAreaRevivers: Revivers<ApiSingleOrGroupedArea, SingleOrGroupedArea> = {
+export const groupedAreaRevivers: Revivers<ApiGroupedArea, GroupedArea> = {
   ...boundingBoxRevivers,
-  properties: (data: ApiSingleOrGroupedAreaData) =>
-    (data.properties != null ? JSON.parse(data.properties) as Record<string, string> : null),
 };
 
-/**
- * TODO When SAGA search on click is implemented, remove mode and make searchBounds required
- */
-export async function searchSingleOrGroupedAreas(
-  language: string,
+export async function searchSingleAreas(
+  language: SAGALanguage,
   search: RequireAtLeastOne<{
-    searchBounds?: ApiSearchBounds;
+    searchBounds: ApiSearchBounds;
     query?: string;
     searchPoint?: ApiSearchPoint;
   }>,
-  mode: 'polygon' | 'group' | 'both' = 'both',
-): Promise<SingleOrGroupedArea[]> {
+): Promise<SingleArea[]> {
   const pathname = '/v1/choropleth/polygons/search';
   const query = getSearchParams({
     language,
     ...search.searchBounds,
     ...(search.query && { query: search.query }),
     ...(search.searchPoint && { point: search.searchPoint }),
-    mode,
+    mode: 'polygon',
   });
   const path = `${pathname}?${query}`;
-  const options = { revivers: singleOrGroupedAreaRevivers };
+  const options = { revivers: singleAreaRevivers };
 
-  type ApiSingleOrGroupedAreaArray = {
-    data: ApiSingleOrGroupedAreaData[];
-  } & Omit<ApiSuccess, 'data'> | ApiError;
+  return request<ApiSingleAreaArray, SingleArea>(path, null, null, options);
+}
+
+export async function searchGroupedAreas(
+  language: SAGALanguage,
+  search: RequireAtLeastOne<{
+    searchBounds: ApiSearchBounds;
+    query?: string;
+    searchPoint?: ApiSearchPoint;
+  }>,
+): Promise<GroupedArea[]> {
+  const pathname = '/v1/choropleth/polygons/search';
+  const query = getSearchParams({
+    language,
+    ...search.searchBounds,
+    ...(search.query && { query: search.query }),
+    ...(search.searchPoint && { point: search.searchPoint }),
+    mode: 'group',
+  });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: groupedAreaRevivers };
 
-  return request<ApiSingleOrGroupedAreaArray, SingleOrGroupedArea>(path, null, null, options);
+  return request<ApiGroupedAreaArray, GroupedArea>(path, null, null, options);
 }
 
 export type GroupedAreaChild = {
@@ -139,7 +169,7 @@ export const groupedAreaChildRevivers: Revivers<ApiGroupedAreaChild, GroupedArea
   properties: (data: ApiGroupedAreaChildData) => JSON.parse(data.properties) as Record<string, string>,
 };
 
-export async function groupedAreaChildren(groupId: number, language: string): Promise<GroupedAreaChild[]> {
+export async function groupedAreaChildren(groupId: number, language: SAGALanguage): Promise<GroupedAreaChild[]> {
   const pathname = `/v1/choropleth/groups/${groupId}/children-optimized`;
   const query = getSearchParams({ language });
   const path = `${pathname}?${query}`;
@@ -178,7 +208,7 @@ export type ApiMatchedGroupData = Flatten<Exclude<ApiMatchedGroup, ApiError>['da
 
 export async function getGroupsByDataSample(
   sample: Record<string, string[]>,
-  language: string,
+  language: SAGALanguage,
   rowCount: number,
 ): Promise<MatchedGroup[]> {
   const path = `/v1/choropleth/groups/sample`;
@@ -215,7 +245,7 @@ export async function getBoundPolygons(
   groupId: number,
   property: string,
   data: string[],
-  language: string,
+  language: SAGALanguage,
 ): Promise<BoundPolygon[]> {
   const path = `/v1/choropleth/groups/bind`;
   const body = { group_id: groupId, property, data, language };

package/src/api/insetMap.ts

@@ -7,6 +7,9 @@ import {
   type Flatten,
   HTTPError,
   NetworkError,
+  TimeoutError,
+  defaultTimeout,
+  makeTimeoutSignal,
   request,
 } from '../utils.js';
 
@@ -63,9 +66,22 @@ export async function getInsetMap(insetMapId: number): Promise<InsetMap> {
 
 export async function getInsetMapTopoJson<TopoJSON>(insetMapId: number): Promise<TopoJSON> {
   const href = `${apiHost}/v1/inset-maps/${insetMapId}/json`;
-  const headers = getAuthorizationHeaders('GET');
-  const response = await fetch(href, { headers, ...!token && { credentials: 'include' } })
-    .catch((error: Error) => { throw new NetworkError(error?.message ?? error) });
+  const headers = getAuthorizationHeaders();
+
+  const timeout = defaultTimeout;
+  const { signal, cleanup } = makeTimeoutSignal(timeout);
+
+  const response = await fetch(href, { headers, signal, ...!token && { credentials: 'include' } })
+    .catch((error: Error) => {
+      if (error instanceof TimeoutError) throw error;
+
+      if (error?.name === 'TimeoutError' || error?.name === 'AbortError') {
+        throw new TimeoutError(timeout, error);
+      }
+
+      throw new NetworkError(error);
+    })
+    .finally(cleanup);
 
   if (response.ok) {
     return response.json().catch(() => {
@@ -83,6 +99,7 @@ export async function getInsetMapTopoJson<TopoJSON>(insetMapId: number): Promise
       case 403:
       case 404:
       case 406:
+      case 422:
       case 429:
         throw new APIError({
           success: false,

package/src/api/jobRevision.ts

@@ -12,9 +12,12 @@ import {
   HTTPError,
   NetworkError,
   type Revivers,
+  TimeoutError,
   defaultListHeader,
+  defaultTimeout,
   deletedNoneParam,
   lastJobRevision,
+  makeTimeoutSignal,
   request,
 } from '../utils.js';
 
@@ -227,9 +230,22 @@ export async function getJobRevisionOutput(jobId: number): Promise<JobRevisionOu
 
 async function fetchOutput(jobId: number): Promise<JobRevisionOutput> {
   const href = `${apiHost}/v1/jobs/${jobId}/revisions/${lastJobRevision}/result/output`;
-  const headers = getAuthorizationHeaders('GET');
-  const response = await fetch(href, { headers, ...!token && { credentials: 'include' } })
-    .catch((error: Error) => { throw new NetworkError(error?.message ?? error) });
+  const headers = getAuthorizationHeaders();
+
+  const timeout = defaultTimeout;
+  const { signal, cleanup } = makeTimeoutSignal(timeout);
+
+  const response = await fetch(href, { headers, signal, ...!token && { credentials: 'include' } })
+    .catch((error: Error) => {
+      if (error instanceof TimeoutError) throw error;
+
+      if (error?.name === 'TimeoutError' || error?.name === 'AbortError') {
+        throw new TimeoutError(timeout, error);
+      }
+
+      throw new NetworkError(error);
+    })
+    .finally(cleanup);
 
   if (response.ok) {
     const blob = await response.blob().catch(() => {
@@ -263,6 +279,7 @@ async function fetchOutput(jobId: number): Promise<JobRevisionOutput> {
       case 403:
       case 404:
       case 406:
+      case 422:
       case 429:
         throw new APIError(
           (await response.json().catch(() => ({

package/src/api/resources.ts

@@ -6,19 +6,18 @@ import { type ApiDimensionData, type Dimension, dimensionRevivers } from './dime
 import { type ApiFeatureData, type Feature, featureRevivers } from './feature.js';
 import { type ApiJobTypeData, type JobType, jobTypeRevivers } from './jobType.js';
 import { type ApiMessageData, type Message, messageRevivers } from './message.js';
-import { type ApiSvg, type ApiSvgData, type Svg, svgRevivers } from './svg.js';
 import { type ApiSvgSetData, type SvgSet, svgSetRevivers } from './svgSet.js';
 import { type ApiLayerData, type Layer, layerRevivers } from './layer.js';
 import { type ApiColorData, type Color, colorRevivers } from './color.js';
 import { type ApiUserData, type User, userRevivers } from './user.js';
 import { type ApiFontData, type Font, fontRevivers } from './font.js';
+import { type ApiSvgData, type Svg, svgRevivers } from './svg.js';
 import type { CamelCasedProperties } from 'type-fest';
 import {
   type ApiCommon,
   type ApiCommonData,
   type ApiError,
   type ApiSuccess,
-  type Revivers,
   getContext,
   myUser,
   processData,
@@ -112,11 +111,6 @@ export async function loadResources(): Promise<Resources> {
 
   allMessages.sort((m1, m2) => m2.date.localeCompare(m1.date));
 
-  const mcSvgRevivers: Revivers<ApiSvg, Svg> = {
-    ...svgRevivers,
-    name: (data: ApiSvgData) => `mc-image-${data.name}`,
-  };
-
   return {
     // @ts-expect-error TS2345
     user: processData.call(getContext(userRevivers), user) as User,
@@ -127,7 +121,7 @@ export async function loadResources(): Promise<Resources> {
       feature => feature.name,
     ) as CustomFeature[],
     colors: raw.colors.map(processData, getContext(colorRevivers)) as Color[],
-    svgs: raw.svgs.map(processData, getContext(mcSvgRevivers)) as Svg[],
+    svgs: raw.svgs.map(processData, getContext(svgRevivers)) as Svg[],
     dimensions: raw.dimensions.map(processData, getContext(dimensionRevivers)) as Dimension[],
     dimensionSets: raw.dimensionSets.map(processData, getContext(dimensionSetRevivers)) as DimensionSet[],
     mapstyleSets: raw.mapstyleSets.map(processData, getContext(mapstyleSetRevivers)) as MapstyleSet[],

package/src/index.ts

@@ -39,6 +39,7 @@ export {
   APIError,
   HTTPError,
   NetworkError,
+  TimeoutError,
   getSearchParams,
   request,
 } from './utils.js';

package/src/oauth.ts

@@ -69,18 +69,10 @@ export async function authenticate(): Promise<never> {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-type AuthHeaders = { Authorization: string } | { 'X-XSRF-Token': string } | undefined;
-
-export function getAuthorizationHeaders(method: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'): AuthHeaders {
-  const cookie = !token && method !== 'GET' && method !== 'HEAD'
-    ? document.cookie.split(/ *; */).find(pair => pair.startsWith('XSRF-TOKEN'))?.split('=')[1]
-    : undefined;
-
-  return token
-    ? { Authorization: token.toString() }
-    : cookie
-      ? { 'X-XSRF-Token': decodeURIComponent(cookie) }
-      : undefined;
+type AuthHeaders = { Authorization: string } | undefined;
+
+export function getAuthorizationHeaders(): AuthHeaders {
+  return token ? { Authorization: token.toString() } : undefined;
 }
 
 export async function logout(): Promise<never> {

package/src/utils.ts

@@ -39,12 +39,20 @@ export const staticContext = { keysToRemove: new Set(keysToRemove), keysToAdd: [
 export const defaultTimeout = 30000;
 
 // class AuthorizationError extends Error {}
-export class NetworkError extends Error {}
+export class NetworkError extends Error {
+  constructor(error: unknown) {
+    super((error as Error)?.message ?? 'Network Error', error instanceof Error ? { cause: error } : {});
+    this.name = 'NetworkError';
+  }
+}
 
 export class TimeoutError extends Error {
   readonly timeout: number;
-  constructor(timeout: number, message?: string) {
-    super(message ?? `Request timed out after ${timeout}ms`);
+  constructor(timeout: number, error?: unknown) {
+    super(
+      (error as Error)?.message ?? `Request timed out after ${timeout}ms`,
+      error instanceof Error ? { cause: error } : {},
+    );
     this.name = 'TimeoutError';
     this.timeout = timeout;
   }
@@ -54,15 +62,19 @@ export class HTTPError extends Error {
   readonly statusCode: number;
   constructor(response: Response) {
     super(response.statusText);
+    this.name = 'HTTPError';
     this.statusCode = response.status;
   }
 }
 
 export class APIError extends Error {
-  readonly code: string;
+  readonly code: string | undefined;
+  readonly validationErrors: Record<string, string[]> | undefined;
   constructor(apiError: ApiError) {
-    super(apiError.error.message);
-    this.code = apiError.error.type;
+    super(apiError?.error?.message ?? 'API Error');
+    this.name = 'APIError';
+    this.code = apiError?.error?.type;
+    this.validationErrors = apiError?.error?.validation_errors;
   }
 }
 
@@ -159,10 +171,10 @@ export async function request<
       if (error instanceof TimeoutError) throw error;
 
       if (error?.name === 'TimeoutError' || error?.name === 'AbortError') {
-        throw new TimeoutError(timeout);
+        throw new TimeoutError(timeout, error);
       }
 
-      throw new NetworkError(error?.message ?? error);
+      throw new NetworkError(error);
     })
     .finally(cleanup);
 
@@ -237,6 +249,7 @@ export async function request<
       case 403:
       case 404:
       case 406:
+      case 422:
         throw new APIError(
           (await response.json().catch(() => ({
             success: false,
@@ -288,7 +301,7 @@ function getRequestInit<I extends ApiCommon, O extends Record<string, unknown>>(
   }
 
   const method = extraOptions?.method ?? (body != null ? 'POST' : 'GET'); // don't touch `!=` please
-  const authorization = getAuthorizationHeaders(method);
+  const authorization = getAuthorizationHeaders();
   const headers = { Accept: 'application/json', ...authorization, ...contentType, ...extraHeaders };
 
   return { body, headers, method, ...!token && { credentials: 'include' } } as RequestInit;
@@ -334,7 +347,7 @@ export function processData<I extends ApiCommon, O extends Record<string, unknow
   return result as O;
 } /* eslint-enable @typescript-eslint/prefer-for-of */
 
-function makeTimeoutSignal(timeout: number): { signal: AbortSignal; cleanup: () => void } {
+export function makeTimeoutSignal(timeout: number): { signal: AbortSignal; cleanup: () => void } {
   if (typeof AbortSignal.timeout === 'function') {
     return {
       signal: AbortSignal.timeout(timeout),
@@ -351,7 +364,7 @@ function makeTimeoutSignal(timeout: number): { signal: AbortSignal; cleanup: ()
   }
 }
 
-function combineSignals(a: AbortSignal, b: AbortSignal): AbortSignal {
+export function combineSignals(a: AbortSignal, b: AbortSignal): AbortSignal {
   if (typeof AbortSignal.any === 'function') {
     return AbortSignal.any([a, b]);
   } else {