@mapcreator/api 3.3.1 → 5.0.0-alpha.13

package/src/api/user.ts

@@ -0,0 +1,280 @@
+import { type ApiFontFamilyData, type FontFamily, fontFamilyRevivers } from './fontFamily.js';
+import { type ApiSvgSetData, type SvgSet, svgSetRevivers } from './svgSet.js';
+import { type ApiLayerData, type Layer, layerRevivers } from './layer.js';
+import { type JobSearchResult, listJobs } from './apiCommon.js';
+import type { ApiJobShareArray, JobShare } from './jobShare.js';
+import type { RequireAtLeastOne } from 'type-fest';
+import {
+  type ApiCommon,
+  type ApiCommonData,
+  type ApiError,
+  type ApiSuccess,
+  type Flatten,
+  type Revivers,
+  defaultListHeader,
+  deletedNoneParam,
+  getSearchParams,
+  myUser,
+  request,
+  toApiType,
+} from '../utils.js';
+
+type ApiPermission = {
+  id: number;                   // The id of the permission
+  name: string;                 // The name of the permission (searchable, sortable)
+} & ApiCommonData;
+
+type ApiRole = {
+  id: number;
+  name: string;
+  description: string;
+  pivot: {
+    model_type: string;
+    model_id: number;
+    role_id: number;
+  };
+} & ApiCommonData;
+
+export type User = {
+  id: number;
+  languageCode: string;
+  hideMessages: boolean;
+  videoNotifications: boolean;
+  name: string;
+  email: string;
+  propagated: boolean;
+  trialExpiresAt: string | undefined;
+  stripeId: number | undefined;
+  intercomIdentityToken?: string;
+};
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+export type ApiUser = {
+  data: {
+    id: number;                 // The id of the user (searchable, sortable)
+    organisation_id: number;    // The id of the organisation related to a user (searchable)
+    language_code: string;      // The language of the user
+    hide_messages: boolean;     // If the what's new notifications should be shown
+    video_notifications: boolean; // TODO: not present in API specification!
+    name: string;               // The name of the user (searchable, sortable)
+    email: string;              // The email of the user (searchable, sortable)
+    phone: string | null;       // The phone of the user (searchable, sortable)
+    profession: string | null;  // The user's profession (searchable, sortable)
+    company: string | null;     // The user's company (sortable)
+    country: string | null;     // The user's country (sortable)
+    city: string | null;        // The user's city (sortable)
+    address: string | null;     // The user's address (sortable)
+    tips: boolean;              // If the user wishes to see tips
+    tags: string[] | null;      // The tags related to a user (searchable, sortable)
+    confirmed: boolean;         // Whether the user is verified
+    propagated: boolean;        // TODO: not present in API specification!
+    newsletter_consent: boolean; // TODO: not present in API specification!
+    registration_complete: boolean; // Whether the user has completed their registration
+    notifications_checked_at: string | null; // The datetime when the user checked the notifications
+    referral: string | null;    // The referral code that the user used during their registration
+    trial_expires_at: string | null; // The datetime when the user's trial expires
+    stripe_id: number | null;   // TODO: not present in API specification!
+    stripe_ref: unknown | null; // TODO: not present in API specification!
+    pm_type: unknown | null;    // TODO: not present in API specification!
+    pm_last_four: unknown | null; // TODO: not present in API specification!
+    trial_ends_at: string | null; // TODO: not present in API specification!
+    settings: string | null;    // TODO: not present in API specification!
+    intercom_identity_token?: string; // TODO: not present in API specification!
+    permissions: ApiPermission[]; // TODO: not present in API specification!
+    roles: ApiRole[];           // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+/* eslint-enable @typescript-eslint/no-redundant-type-constituents */
+export type ApiUserData = Flatten<Exclude<ApiUser, ApiError>['data']>;
+
+export type JobFolder = {
+  id: number;
+  jobsCount: number;
+  name: string;
+  userId: number;
+};
+
+export type ApiJobFolder = {
+  data: {
+    id: number;
+    jobsCount: number;
+    name: string;
+    userId: number;
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiJobFolderData = Flatten<Exclude<ApiJobFolder, ApiError>['data']>;
+
+export const userRevivers: Revivers<ApiUser, User> = {
+  organisation_id: undefined,
+  phone: undefined,
+  profession: undefined,
+  company: undefined,
+  country: undefined,
+  city: undefined,
+  address: undefined,
+  tips: undefined,
+  tags: undefined,
+  confirmed: undefined,
+  newsletter_consent: undefined,
+  registration_complete: undefined,
+  notifications_checked_at: undefined,
+  referral: undefined,
+  stripe_ref: undefined,
+  pm_type: undefined,
+  pm_last_four: undefined,
+  trial_ends_at: undefined,
+  settings: undefined,
+  permissions: undefined,
+  roles: undefined,
+
+  trialExpiresAt: (data: ApiUserData) => data.trial_expires_at ?? undefined,
+  stripeId: (data: ApiUserData) => data.stripe_id ?? undefined,
+};
+
+export async function getUser(): Promise<User> {
+  const path = `/v1/users/${myUser}`;
+  const options = { revivers: userRevivers };
+
+  return request<ApiUser, User>(path, null, null, options);
+}
+
+export async function updateUser(
+  userId: number,
+  fields: RequireAtLeastOne<Pick<User, 'hideMessages' | 'videoNotifications'>>,
+): Promise<Record<string, never>> {
+  const path = `/v1/users/${userId}`;
+  const body = toApiType(fields);
+
+  return request<ApiCommon, Record<string, never>>(path, body, null, { method: 'PATCH' });
+}
+
+export async function listUserFontFamilies(): Promise<FontFamily[]> {
+  const pathname = `/v1/users/${myUser}/font-families`;
+  const query = getSearchParams({ sort: 'order' });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: fontFamilyRevivers };
+
+  type ApiFontFamilyArray = {
+    data: ApiFontFamilyData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiFontFamilyArray, FontFamily>(path, null, defaultListHeader, options);
+}
+
+export async function listUserJobs(
+  userId: number,
+  title: string,
+  page: number,
+  options?: Record<string, unknown>
+): Promise<JobSearchResult> {
+  return listJobs(`/v1/users/${userId}/jobs`, title, page, options);
+}
+
+export async function listUserFolders(): Promise<JobFolder[]> {
+  const path = `/v1/users/${myUser}/folders`;
+
+  type ApiJobFolderArray = {
+    data: ApiJobFolderData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiJobFolderArray, JobFolder>(path);
+}
+
+export async function createUserFolder(name: string): Promise<JobFolder> {
+  const path = `/v1/users/${myUser}/folders`;
+  const body = { name };
+
+  return request<ApiCommon, JobFolder>(path, body);
+}
+
+export async function deleteUserFolder(folderId: number): Promise<Record<string, never>> {
+  const path = `/v1/users/${myUser}/folders/${folderId}`;
+
+  return request<ApiCommon, Record<string, never>>(path, null, null, { method: 'DELETE' });
+}
+
+export async function renameUserFolder(folderId: number, name: string): Promise<Record<string, never>> {
+  const path = `/v1/users/${myUser}/folders/${folderId}`;
+  const body = { name };
+
+  return request<ApiCommon, Record<string, never>>(path, body, null, { method: 'PATCH' });
+}
+
+export async function listUserLayers(): Promise<Layer[]> {
+  const pathname = `/v1/users/${myUser}/layers`;
+  const query = getSearchParams({
+    search: {
+      pangaea_ready: '1',
+    },
+    sort: 'order',
+  });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: layerRevivers };
+
+  type ApiLayerArray = {
+    data: ApiLayerData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiLayerArray, Layer>(path, null, defaultListHeader, options);
+}
+
+export async function listUserSvgSets(): Promise<SvgSet[]> {
+  const pathname = `/v1/users/${myUser}/svg-sets`;
+  const query = getSearchParams({
+    search: {
+      supports_mapcreator: '1',
+      type: '!:sprite',
+    },
+    sort: 'order',
+  });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: svgSetRevivers };
+
+  type ApiSvgSetArray = {
+    data: ApiSvgSetData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiSvgSetArray, SvgSet>(path, null, defaultListHeader, options);
+}
+
+export async function findJobShares(jobId: number): Promise<JobShare[]> {
+  const pathname = `/v1/users/${myUser}/job-shares`;
+  const query = getSearchParams({ search: { job_id: jobId } });
+  const path = `${pathname}?${query}`;
+
+  return request<ApiJobShareArray, JobShare>(path);
+}
+
+export async function createUserTrial(
+  userId: number,
+  data: Record<string, unknown>,
+): Promise<Record<string, never>> {
+  const pathname = `/v1/users/${userId}/trial`;
+  const path = `${pathname}?${deletedNoneParam}`;
+  const body = toApiType(data);
+
+  return request<ApiCommon, Record<string, never>>(path, body);
+}
+
+// export async function confirmUser(userId: number): Promise<Record<string, never>> {
+//   const path = `/v1/users/${userId}/confirm`;
+//
+//   return request<ApiCommon, Record<string, never>>(path, null, null, { method: 'POST' });
+// }
+
+type BillingPortal = {
+  billingPortalUrl: string;
+};
+type ApiBillingPortal = {
+  data: {
+    billing_portal_url: string;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export async function getUserBillingPortalUrl(userId: number): Promise<string> {
+  const path = `/v1/users/${userId}/billing-portal-url`;
+
+  return request<ApiBillingPortal, BillingPortal>(path).then(
+    ({ billingPortalUrl }) => billingPortalUrl,
+  );
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+export * from './api/choropleth.js';
+export * from './api/color.js';
+export * from './api/dimension.js';
+export * from './api/dimensionSet.js';
+export * from './api/feature.js';
+export * from './api/font.js';
+export * from './api/fontFamily.js';
+export * from './api/highlight.js';
+export * from './api/job.js';
+export * from './api/jobResult.js';
+export * from './api/jobRevision.js';
+export * from './api/jobShare.js';
+export * from './api/jobType.js';
+export * from './api/language.js';
+export * from './api/layer.js';
+export * from './api/layerFaq.js';
+export * from './api/layerGroup.js';
+export * from './api/mapstyleSet.js';
+export * from './api/message.js';
+export * from './api/organisation.js';
+export * from './api/resources.js';
+export * from './api/svg.js';
+export * from './api/svgSet.js';
+export * from './api/user.js';
+
+export {
+  type ApiCommon,
+  type ApiCommonData,
+  type ApiError,
+  type ApiSuccess,
+  type ExtraOptions,
+  type Flatten,
+  type Revivers,
+  lastJobRevision,
+  myOrganisations,
+  myUser,
+  APIError,
+  HTTPError,
+  NetworkError,
+  getSearchParams,
+  request,
+} from './utils.js';

package/src/oauth.ts

@@ -0,0 +1,292 @@
+export let apiHost = '';
+
+export let token: {
+  type: string;
+  token: string;
+  expires: Date;
+
+  toString: () => string;
+} | null = null;
+
+let apiClientId = '';
+let callbackUrl = '';
+let oauthScopes = ['*'];
+
+const anchorParams = ['access_token', 'token_type', 'expires_in', 'state'];
+
+const storagePrefix = '_m4n_';
+const statePrefix = 'oauth_state_';
+const storageName = 'api_token';
+
+interface AnchorToken {
+  access_token: string;
+  token_type: string;
+  expires_in: string;
+  state: string;
+}
+
+const titleCase = (str: unknown): string => String(str).toLowerCase().replace(/\b\w/g, c => c.toUpperCase());
+
+/**
+ * Setup internal structures to use implicit authentication flow
+ *
+ * @param {string} apiUrl - Full API URL
+ * @param {string} clientId - OAuth client id
+ * @param {string} [redirectUrl] - Callback URL
+ * @param {string[]} [scopes] - A list of required scopes
+ */
+export function initImplicitFlow(apiUrl: string, clientId: string, redirectUrl = '', scopes = ['*']): void {
+  apiHost = apiUrl.replace(/\/+$/, '');
+
+  apiClientId = String(clientId);
+  callbackUrl = String(redirectUrl || window.location.href.split('#')[0]);
+  oauthScopes = scopes;
+
+  {
+    const key = `${storagePrefix}${storageName}`;
+    const data = window.localStorage.getItem(key);
+
+    if (data) {
+      try {
+        const obj = JSON.parse(data) as { type?: unknown; token?: unknown; expires?: unknown };
+
+        if (
+          typeof obj.type === 'string' &&
+          typeof obj.token === 'string' &&
+          typeof obj.expires === 'string' &&
+          new Date(obj.expires) > new Date()
+        ) {
+          token = {
+            type: titleCase(obj.type),
+            token: obj.token,
+            expires: new Date(obj.expires),
+
+            toString(): string {
+              return `${this.type} ${this.token}`;
+            },
+          };
+        } else {
+          window.localStorage.removeItem(key);
+        }
+      } catch (e) {
+        /* */
+      }
+    }
+  }
+
+  {
+    const obj = getAnchorToken();
+
+    if (isAnchorToken(obj)) {
+      // We'll not go there if anchor contains error and/or message
+      // This means that anchor parameters will be preserved for the next processing
+      cleanAnchorParams();
+
+      const expires = new Date(Date.now() + Number(obj.expires_in) * 1000);
+
+      if (isValidState(obj.state) && expires > new Date()) {
+        token = {
+          type: titleCase(obj.token_type),
+          token: obj.access_token,
+          expires,
+
+          toString(): string {
+            return `${this.type} ${this.token}`;
+          },
+        };
+
+        const key = `${storagePrefix}${storageName}`;
+        const data = { type: token.type, token: token.token, expires: expires.toUTCString() };
+
+        window.localStorage.setItem(key, JSON.stringify(data));
+      } else {
+        // TODO: add some logic to handle this
+        // throw Error('Invalid state in url');
+      }
+    }
+  }
+
+  if (authenticated()) {
+    const href = sessionStorage.getItem('redirect-url');
+
+    if (href) {
+      sessionStorage.removeItem('redirect-url');
+      window.history.replaceState(null, document.title, href);
+    }
+  }
+}
+
+export function authenticate(): string | never {
+  if (token && authenticated()) {
+    return token.toString();
+  } else if (anchorContainsError()) {
+    const err = getError();
+
+    cleanAnchorParams();
+    throw err;
+  } else {
+    forget();
+  }
+
+  sessionStorage.setItem('redirect-url', window.location.href);
+
+  // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+  return window.location.assign(buildRedirectUrl()) as never;
+}
+
+export function authenticated(): boolean {
+  return token != null && token.expires > new Date();
+}
+
+export async function logout(): Promise<void> {
+  if (token) {
+    await fetch(`${apiHost}/oauth/logout`, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        Authorization: token.toString(),
+      },
+    });
+  }
+
+  forget();
+}
+
+function forget(): void {
+  for (let i = 0; i < window.localStorage.length; ++i) {
+    const key = window.localStorage.key(i);
+
+    if (key?.startsWith(storagePrefix)) {
+      window.localStorage.removeItem(key);
+    }
+  }
+
+  token = null;
+}
+
+function buildRedirectUrl(): string {
+  const queryParams = new URLSearchParams({
+    client_id: apiClientId,
+    redirect_uri: callbackUrl,
+    response_type: 'token',
+    scope: oauthScopes.join(' '),
+    state: generateState(),
+  });
+
+  return `${apiHost}/oauth/authorize?${queryParams}`;
+}
+
+function getAnchorQuery(): string {
+  return window.location.hash.replace(/^#\/?/, '');
+}
+
+function getAnchorParams(): Record<string, unknown> {
+  const query = getAnchorQuery();
+  // eslint-disable-next-line @stylistic/padding-line-between-statements,@typescript-eslint/no-unsafe-return
+  return Object.fromEntries(query.split('&').map(pair => pair.split('=').map(decodeURIComponent)));
+}
+
+function getAnchorToken(): Partial<AnchorToken> {
+  const params = getAnchorParams();
+
+  return Object.fromEntries(Object.entries(params).filter(([key]) => anchorParams.includes(key)));
+}
+
+function isAnchorToken(anchorToken: Partial<AnchorToken>): anchorToken is AnchorToken {
+  const queryKeys = Object.keys(anchorToken);
+
+  return anchorParams.every(key => queryKeys.includes(key));
+}
+
+function cleanAnchorParams(): void {
+  const query = window.location.hash.replace(/^#\/?/, '');
+  const targets = [...anchorParams, 'error', 'message'];
+  const newHash = query
+    .split('&')
+    .filter(pair => !targets.includes(decodeURIComponent(pair.split('=')[0])))
+    .join('&');
+
+  if (newHash) {
+    window.location.hash = newHash;
+  } else {
+    const { origin, pathname, search } = window.location;
+
+    window.history.replaceState(null, document.title, `${origin}${pathname}${search}`);
+  }
+}
+
+function isValidState(state: string): boolean {
+  const key = `${storagePrefix}${statePrefix}${state}`;
+  const found = window.localStorage.getItem(key) != null;
+
+  if (found) {
+    window.localStorage.removeItem(key);
+  }
+
+  return found;
+}
+
+function anchorContainsError(): boolean {
+  return 'error' in getAnchorParams();
+}
+
+function generateState(): string {
+  // @ts-expect-error TS2365
+  // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+  const state = (([1e7] + -1e3 + -4e3 + -8e3 + -1e11) as string).replace(
+    /[018]/g, // @ts-expect-error TS2362
+    c => (c ^ ((Math.random() * 256) & (0x0f >>> (c >>> 2)))).toString(16),
+  );
+  const key = `${storagePrefix}${statePrefix}${state}`;
+
+  window.localStorage.setItem(key, `${Date.now()}`);
+
+  return state;
+}
+
+class OAuthError extends Error {
+  error: string;
+
+  constructor(message: string, error: unknown) {
+    super(message);
+
+    this.error = String(error);
+  }
+
+  toString(): string {
+    let error = this.error;
+
+    if (error.includes('_')) {
+      error = error.replace('_', ' ').replace(/^./, c => c.toUpperCase());
+    }
+
+    return this.message ? `${error}: ${this.message}` : error;
+  }
+}
+
+function getError(): OAuthError {
+  const params = getAnchorParams();
+
+  return params.message
+    ? new OAuthError(params.message as string, params.error)
+    : new OAuthError(titleCase(params.error), params.error);
+}
+
+/**
+ * Our goal is to support even obsolete platforms (ES2017+ / Node.js 8.10+).
+ * This is a small polyfill for possibly missing method used in our codebase.
+ */
+if (!Object.fromEntries) { // eslint-disable-next-line arrow-body-style
+  Object.fromEntries = <T = never>(entries: Iterable<readonly [string | number, T]>): { [k: string]: T } => {
+    return Array.from(entries).reduce<{ [k: string]: T }>(
+      (object, entry) => {
+        if (!Array.isArray(entry)) {
+          throw new TypeError(`Iterator value ${entry as unknown as string} is not an entry object.`);
+        }
+        object[`${entry[0]}`] = entry[1];
+
+        return object;
+      }, {}
+    );
+  };
+}