@mapcreator/api 0.0.0-co-edit.0

package/src/README.md

@@ -0,0 +1,126 @@
+### Used type system
+
+We use type declarations for both the data coming over the wire and the data used by the application. In general, these types differ only in the presence of additional fields in the data arriving over the network (like `created_at`), and used naming convention. Data over the network uses the so-called snake case.
+
+All in all, we can use TypeScript's native mechanisms to convert one type to another and fully define just one type:
+
+```typescript
+import type { CamelCasedProperties } from 'type-fest';
+
+type ApiType =
+  | ({
+      data: {
+        prop: unknown;
+      } & ApiCommonData;
+    } & Omit<ApiSuccess, 'data'>)
+  | ApiError;
+
+type AppType = CamelCasedProperties<Omit<Exclude<ApiType, ApiError>['data'], keyof ApiCommonData>>;
+```
+
+or in reverse order:
+
+```typescript
+import type { SnakeCasedProperties } from 'type-fest';
+
+type AppType = {
+  prop: unknown;
+};
+
+type ApiType =
+  | ({
+      data: SnakeCasedProperties<AppType> & ApiCommonData;
+    } & Omit<ApiSuccess, 'data'>)
+  | ApiError;
+```
+
+But the decision was made not to do this, since it may be more difficult for the developer to make the conversion in their head than to see it in front of their eyes.
+
+### Using a `request()`
+
+The function has the following signature:
+
+```typescript
+async function request<I extends ApiCommon, O extends Record<string, unknown> | string>(
+  path: string,
+  body?: XMLHttpRequestBodyInit | Record<string | number, unknown> | null,
+  extraHeaders?: Record<string, string> | null,
+  extraOptions?: ExtraOptions<I, O>,
+): Promise<O | O[]> { /* ... */ }
+```
+
+Let's take it step by step.
+
+`I extends ApiCommon` - represents the type of data we receive over the network.
+
+`O extends Record<string, unknown> | string` - represents the data type that will be used in the application.
+
+Ideally you should describe and convey both types. This will help to check the data types in the arguments passed.
+See current data types for an example.
+
+`path: string` - the path to the resource, must include the API version, but must not include the schema or authority.
+Example: `/v1/jobs/12345`
+
+`body?: XMLHttpRequestBodyInit | Record<string | number, unknown> | null` - any meaningful body type. In general,
+the presence of an JSON object is assumed (or the absence of one for methods that only request data), but you can
+also pass `Blob`, `FormData`, `URLSearchParams` or just `ArrayBuffer`. The required content type will be added to
+the headers automatically.
+
+`extraHeaders?: Record<string, string> | null` - the object with additional headers.
+
+`extraOptions?: ExtraOptions<I, O>` - where `ExtraOptions<I, O>` is defined like this:
+
+```typescript
+interface ExtraOptions<I extends ApiCommon, O extends Record<string, unknown> | string> {
+  method?: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  revivers?: O extends Record<string, unknown> ? Revivers<I, O> : never;
+  sendNull?: boolean;
+  withMeta?: boolean;
+}
+```
+
+Most fields are self-explanatory.
+
+`sendNull` can be used if you really want to pass `null` as body content.
+
+`revivers` is used to specify an object that can modify the behavior of the internal handler of data coming over
+the network. Let's take a closer look at this moment.
+
+#### Revivers
+
+By default, the `request()` function does the following things with data coming over the network:
+
+- It removes `created_at`, `updated_at`, `deleted_at` fields from the output objects.
+- It preserves all the remaining fields but converts their names into camelCase.
+
+When passing an object with revivers you can a couple of things:
+
+- You can list the fields that you want **to exclude** from the result object. To do this, the field must be assigned an
+`undefined` value.
+- You can **add** new fields or **modify** the type of existing ones. To do this, you need to pass a function as a field
+value, which will receive the original object as input.
+
+Example:
+
+```typescript
+const jobRevivers: Revivers<ApiJob, Job> = {
+  user_id: undefined,
+  description: undefined,
+  share_token: undefined,
+  autosave_preview_path: undefined,
+  job_folder_id: undefined,
+
+  jobTypeId: () => 9,
+  createdAt: (data: ApiJobData) => data.created_at as string,
+  previewPath: (data: ApiJobData) => data.autosave_preview_path ?? undefined,
+};
+```
+
+`user_id`, `description`, `share_token`, `autosave_preview_path`, `job_folder_id` fields will be excluded from the
+result object.
+
+`jobTypeId` will be always **9**.
+
+`createdAt` will be returned (please note that that field is excluded by default)
+
+`previewPath` - some actions will be performed with the source data.

package/src/api/apiCommon.ts

@@ -0,0 +1,70 @@
+import { type ApiJobData, type Job, jobRevivers } from './job.js';
+import {
+  APIMeta,
+  type ApiError,
+  type ApiSuccess,
+  type Revivers,
+  defaultListHeader,
+  getSearchParams,
+  request,
+} from '../utils.js';
+
+export interface JobSearchResult {
+  pageCount: number;
+  data: Job[];
+}
+
+export async function listJobs(
+  pathname: string,
+  title: string,
+  page: number,
+  searchOptions?: Record<string, unknown>,
+): Promise<JobSearchResult> {
+  const defaultSearchOptions = {
+    sort: '-updated',
+    only_downloaded: false,
+  };
+
+  const search = { ...defaultSearchOptions, ...searchOptions };
+
+  const query = getSearchParams({
+    only_with_revisions: true,
+    search: {
+      job_type_id: '9',
+      ...(title.length > 0 && { title: `~:${title}` }),
+    },
+    ...search,
+  });
+
+  const path = `${pathname}?${query}`;
+
+  const headers = {
+    ...defaultListHeader,
+    'X-Page': `${page}`,
+  };
+  const options = {
+    revivers: jobRevivers as Revivers<ApiJobArray, Job>,
+    withMeta: true,
+  };
+
+  type ApiJobArray = {
+    data: ApiJobData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  const result = (await request<ApiJobArray, Job>(path, null, headers, options).catch(
+    (error: Error) => {
+      if (error instanceof APIMeta) {
+        const { data, headers, status } = error as APIMeta<ApiJobArray, Job>;
+
+        return { data, headers, status };
+      }
+
+      throw error;
+    },
+  )) as APIMeta<ApiJobArray, Job>;
+
+  return {
+    data: result.data,
+    pageCount: Number(result.headers.get('X-Paginate-Pages')),
+  };
+}

package/src/api/choropleth.ts

@@ -0,0 +1,228 @@
+import { type ApiError, type ApiSuccess, type Flatten, type Revivers, getSearchParams, request } from '../utils.js';
+
+import type { RequireAtLeastOne } from 'type-fest';
+import type { Polygon } from 'geojson';
+
+export const boundingBoxRevivers: Revivers<
+  { data: { bounding_box: string } } & Omit<ApiSuccess, 'data'> | ApiError,
+  { boundingBox: Polygon }
+> = {
+  boundingBox: (data: { bounding_box: string }) => JSON.parse(data.bounding_box) as Polygon,
+};
+
+export type ApiSearchPoint = {
+  lat: number;
+  lng: number;
+};
+
+export type ApiSearchBounds = {
+  min_lat: number;
+  min_lng: number;
+  max_lat: number;
+  max_lng: number;
+};
+
+type SingleOrGroupedAreaBase = {
+  id: number;
+  title: string;
+  subtitle: string;
+  svgPreview: string;
+  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>;
+  vectorSource: string;
+  sourceLayer: string;
+  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;
+};
+
+export type ApiSingleOrGroupedArea = {
+  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;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiSingleOrGroupedAreaData = Flatten<Exclude<ApiSingleOrGroupedArea, ApiError>['data']>;
+
+export const singleOrGroupedAreaRevivers: Revivers<ApiSingleOrGroupedArea, SingleOrGroupedArea> = {
+  ...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,
+  search: RequireAtLeastOne<{
+    searchBounds?: ApiSearchBounds;
+    query?: string;
+    searchPoint?: ApiSearchPoint;
+  }>,
+  mode: 'polygon' | 'group' | 'both' = 'both',
+): Promise<SingleOrGroupedArea[]> {
+  const pathname = '/v1/choropleth/polygons/search';
+  const query = getSearchParams({
+    language,
+    ...search.searchBounds,
+    ...(search.query && { query: search.query }),
+    ...(search.searchPoint && { point: search.searchPoint }),
+    mode,
+  });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: singleOrGroupedAreaRevivers };
+
+  type ApiSingleOrGroupedAreaArray = {
+    data: ApiSingleOrGroupedAreaData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiSingleOrGroupedAreaArray, SingleOrGroupedArea>(path, null, null, options);
+}
+
+export type GroupedAreaChild = {
+  id: number;
+  title: string;
+  vectorSource: string;
+  sourceLayer: string;
+  featureId: number;
+  boundingBox: Polygon;
+  properties: Record<string, string>;
+};
+
+type ApiGroupedAreaChild = {
+  data: {
+    id: number;
+    title: string;
+    vector_source: string;
+    source_layer: string;
+    feature_id: number;
+    bounding_box: string;
+    properties: string;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiGroupedAreaChildData = Flatten<Exclude<ApiGroupedAreaChild, ApiError>['data']>;
+
+export const groupedAreaChildRevivers: Revivers<ApiGroupedAreaChild, GroupedAreaChild> = {
+  ...boundingBoxRevivers,
+  properties: (data: ApiGroupedAreaChildData) => JSON.parse(data.properties) as Record<string, string>,
+};
+
+export async function groupedAreaChildren(groupId: number, language: string): Promise<GroupedAreaChild[]> {
+  const pathname = `/v1/choropleth/groups/${groupId}/children-optimized`;
+  const query = getSearchParams({ language });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: groupedAreaChildRevivers };
+
+  type ApiGroupedAreaChildArray = {
+    data: ApiGroupedAreaChildData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiGroupedAreaChildArray, GroupedAreaChild>(path, null, null, options);
+}
+
+export type MatchedGroup = {
+  id: number;
+  sml: number;
+  childrenCount: number;
+  matchField: string;
+  boundingBox: Polygon;
+  property: string;
+  name: string;
+};
+
+export type ApiMatchedGroup = {
+  data: {
+    id: number;
+    sml: number;
+    children_count: number;
+    match_field: string;
+    bounding_box: string;
+    property: string;
+    name: string;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiMatchedGroupData = Flatten<Exclude<ApiMatchedGroup, ApiError>['data']>;
+
+export async function getGroupsByDataSample(
+  sample: Record<string, string[]>,
+  language: string,
+  rowCount: number,
+): Promise<MatchedGroup[]> {
+  const path = `/v1/choropleth/groups/sample`;
+  const options = { revivers: boundingBoxRevivers };
+
+  type ApiMatchedGroupArray = {
+    data: ApiMatchedGroupData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiMatchedGroupArray, MatchedGroup>(path, { sample, language, row_count: rowCount }, null, options);
+}
+
+export type BoundPolygon = {
+  index: number;
+  inputName: string;
+  id: number;
+  sml: number;
+  name: string;
+};
+
+export type ApiBoundPolygon = {
+  data: {
+    index: number;
+    input_name: string;
+    id: number;
+    sml: number;
+    name: string;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiBoundPolygonData = Flatten<Exclude<ApiBoundPolygon, ApiError>['data']>;
+
+export async function getBoundPolygons(
+  groupId: number,
+  property: string,
+  data: string[],
+  language: string,
+): Promise<BoundPolygon[]> {
+  const path = `/v1/choropleth/groups/bind`;
+  const body = { group_id: groupId, property, data, language };
+
+  type ApiBoundPolygonArray = {
+    data: ApiBoundPolygonData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiBoundPolygonArray, BoundPolygon>(path, body);
+}

package/src/api/color.ts

@@ -0,0 +1,22 @@
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type Color = {
+  id: number;
+  hex: string;
+};
+
+export type ApiColor = {
+  data: {
+    id: number;                 // The color id (sortable)
+    name: string;               // The name of the color (searchable, sortable)
+    hex: string;                // The hex value of the color (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiColorData = Flatten<Exclude<ApiColor, ApiError>['data']>;
+
+export const colorRevivers: Revivers<ApiColor, Color> = {
+  name: undefined,
+  order: undefined,
+};

package/src/api/dimension.ts

@@ -0,0 +1,44 @@
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type OutputUnit =
+  | 'millimeter'
+  | 'centimeter'
+  | 'inch'
+  | 'pixel'
+  | 'pica';
+
+export type Dimension = {
+  id: number;
+  dimensionSetId: number;
+  name: string;
+  width: number;
+  height: number;
+  dpi: number;
+  unit: OutputUnit;
+};
+
+export type ApiDimension = {
+  data: {
+    id: number;                 // The dimension id (sortable)
+    dimension_set_id: number;   // The id of the dimension set
+    name: string;               // The name of dimension (searchable, sortable)
+    width: number;              // The width of the dimension (searchable, sortable)
+    height: number;             // The height of the dimension (searchable, sortable)
+    dpi: number;                // The dpi of the dimension
+    unit: string;               // The unit of this dimension
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiDimensionData = Flatten<Exclude<ApiDimension, ApiError>['data']>;
+
+const keyToUnit: { [key: string]: OutputUnit } = {
+  MM: 'millimeter',
+  CM: 'centimeter',
+  IN: 'inch',
+  PX: 'pixel',
+  PICA: 'pica',
+};
+
+export const dimensionRevivers: Revivers<ApiDimension, Dimension> = {
+  unit: (data: ApiDimensionData) => keyToUnit[data.unit],
+};

package/src/api/dimensionSet.ts

@@ -0,0 +1,20 @@
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type DimensionSet = {
+  id: number;
+  name: string;
+};
+
+export type ApiDimensionSet = {
+  data: {
+    id: number;                 // The dimension set id (sortable)
+    name: string;               // The dimension set name (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiDimensionSetData = Flatten<Exclude<ApiDimensionSet, ApiError>['data']>;
+
+export const dimensionSetRevivers: Revivers<ApiDimensionSet, DimensionSet> = {
+  order: undefined,
+};

package/src/api/feature.ts

@@ -0,0 +1,22 @@
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type Feature = {
+  id: number;
+  name: string;
+};
+
+export type ApiFeature = {
+  data: {
+    id: number;                 // The feature id
+    name: string;               // The feature name (searchable, sortable)
+    description: string;        // The description of the feature (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiFeatureData = Flatten<Exclude<ApiFeature, ApiError>['data']>;
+
+export const featureRevivers: Revivers<ApiFeature, Feature> = {
+  description: undefined,
+  order: undefined,
+};

package/src/api/font.ts

@@ -0,0 +1,57 @@
+import {
+  type ApiCommonData,
+  type ApiError,
+  type ApiSuccess,
+  type Flatten,
+  type Revivers,
+  getSearchParams,
+  request,
+} from '../utils.js';
+
+export type Font = {
+  id: number;
+  fontFamilyId: number;
+  name: string;
+  label: string;
+  weight: number;
+  style: string;
+  stretch: string;
+};
+
+export type ApiFont = {
+  data: {
+    id: number;                 // The id of the font (sortable)
+    font_family_id: number;     // The id of the font family
+    name: string;               // The name of the font (searchable, sortable)
+    style: string;              // The font style (searchable, sortable)
+    stretch: string;            // The font stretch (searchable, sortable)
+    weight: number;             // The font weight (searchable, sortable)
+    label: string;              // The label of the font (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiFontData = Flatten<Exclude<ApiFont, ApiError>['data']>;
+
+type FontSearchOptions = {
+  family?: string;
+  style?: string;
+  weight?: string;
+};
+
+export const fontRevivers: Revivers<ApiFont, Font> = {
+  order: undefined,
+};
+
+export async function getFonts(searchOptions: FontSearchOptions): Promise<Font[] | Font> {
+  const pathname = `/v1/fonts/search`;
+  const query = getSearchParams(searchOptions);
+
+  const path = `${pathname}?${query}`;
+
+  type ApiFontArray = {
+    data: ApiFontData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiFontArray, Font>(path);
+}

package/src/api/fontFamily.ts

@@ -0,0 +1,43 @@
+import { type ApiFontData, type Font, fontRevivers } from './font.js';
+import {
+  type ApiCommonData,
+  type ApiError,
+  type ApiSuccess,
+  type Flatten,
+  type Revivers,
+  defaultListHeader,
+  getSearchParams,
+  request,
+} from '../utils.js';
+
+export type FontFamily = {
+  id: number;
+  name: string;
+};
+
+export type ApiFontFamily = {
+  data: {
+    id: number;                 // The id of the font family (sortable)
+    name: string;               // The name of the font family (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiFontFamilyData = Flatten<Exclude<ApiFontFamily, ApiError>['data']>;
+
+export const fontFamilyRevivers: Revivers<ApiFontFamily, FontFamily> = {
+  order: undefined,
+};
+
+export async function listFontFamilyFonts(fontFamilyId: number): Promise<Font[]> {
+  const pathname = `/v1/fonts/families/${fontFamilyId}/items`;
+  const query = getSearchParams({ sort: 'order' });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: fontRevivers };
+
+  type ApiFontArray = {
+    data: ApiFontData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiFontArray, Font>(path, null, defaultListHeader, options);
+}

package/src/api/geocode.ts

@@ -0,0 +1,17 @@
+import { type ApiError, type ApiSuccess, request } from '../utils.js';
+
+export type GeocodeResult = {
+  index: number;
+  lat: number | undefined;
+  lng: number | undefined;
+};
+
+export async function bulkGeocode(addresses: Array<{ index: number; address: string }>): Promise<GeocodeResult[]> {
+  const pathname = `/v1/geocode`;
+
+  type GeocodeResultArray = {
+    data: GeocodeResult[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<GeocodeResultArray, GeocodeResult>(pathname, { items: addresses });
+}