pdc-api.ts

import { client } from './client';
import type { AccessTokenSet } from './oidc';
import type {
  BaseField, ProposalBundle, ChangemakerBundle, SourceBundle, Source,
  BaseFieldBundle,
} from '@pdc/sdk';

const callPdcApi = async <T>(
  baseUrl: string,
  path: string,
  params: Record<string, string>,
  method: 'get' | 'post',
  token?: AccessTokenSet,
  data?: unknown,
): Promise<T> => {
  const url = new URL(path, baseUrl);
  url.search = new URLSearchParams(params).toString();
  const headers = token ? { authorization: `Bearer ${token.access_token}` } : {};
  const response = await client.request<T>(
    {
      method,
      url: url.toString(),
      headers,
      data,
    },
  );
  return response.data;
};

const getBaseFields = (baseUrl: string, token: AccessTokenSet) => (
  callPdcApi<BaseFieldBundle>(
    baseUrl,
    '/baseFields',
    {
      _page: '1',
      _count: '2147483647',
    },
    'get',
    token,
  )
);

const getProposals = (baseUrl: string, token: AccessTokenSet) => (
  callPdcApi<ProposalBundle>(
    baseUrl,
    '/proposals',
    {
      _page: '1',
      _count: '1000',
    },
    'get',
    token,
  )
);

/**
 * Get all (up to 10m) changemakers. Avoids authentication to get only direct attributes (shallow).
 * The `fields` and `fiscalSponsors` (deep) attributes will be present but empty in this case.
 */
const getChangemakers = (baseUrl: string) => (
  callPdcApi<ChangemakerBundle>(
    baseUrl,
    '/changemakers',
    {
      _page: '1',
      _count: '10000000',
    },
    'get',
  )
);

/**
 * Get all (up to 1m) sources.
 */
const getSources = (baseUrl: string, token: AccessTokenSet) => (
  callPdcApi<SourceBundle>(
    baseUrl,
    '/sources',
    {
      _page: '1',
      _count: '1000000',
    },
    'get',
    token,
  )
);

/** A corrected WritableSource (the SDK's is a bit off as of this writing) */
export interface WritableSource {
  label: string;
  dataProviderShortCode: string;
}

const postSource = (baseUrl: string, token: AccessTokenSet, data: WritableSource) => (
  callPdcApi<Source>(
    baseUrl,
    '/sources',
    {},
    'post',
    token,
    data,
  )
);

// TODO: use the SDK, delete these temp types copied from the service repo
interface ChangemakerFieldValueBatch {
  readonly id: number;
  sourceId: number;
  notes: string | null;
  readonly createdAt: string;
  readonly source: Source;
}
interface ChangemakerFieldValue {
  readonly id: number;
  changemakerId: number;
  baseFieldShortCode: string;
  batchId: number;
  value: string;
  readonly file: File | null;
  goodAsOf: string | null;
  readonly createdAt: string;
  readonly baseField: BaseField;
  readonly batch: ChangemakerFieldValueBatch;
  readonly isValid: boolean;
}

interface WritableChangemakerFieldValueBatch {
  sourceId: number;
  notes: string | null;
}
interface WritableChangemakerFieldValue {
  changemakerId: number;
  baseFieldShortCode: string;
  batchId: number;
  value: string;
  goodAsOf: string | null;
}

const postChangemakerFieldValueBatch = (
  baseUrl: string,
  token: AccessTokenSet,
  data: WritableChangemakerFieldValueBatch,
) => (
  callPdcApi<ChangemakerFieldValueBatch>(
    baseUrl,
    '/changemakerFieldValueBatches',
    {},
    'post',
    token,
    data,
  )
);

const postChangemakerFieldValue = (
  baseUrl: string,
  token: AccessTokenSet,
  data: WritableChangemakerFieldValue,
) => (
  callPdcApi<ChangemakerFieldValue>(
    baseUrl,
    '/changemakerFieldValues',
    {},
    'post',
    token,
    data,
  )
);

const postPlatformProviderData = (
  baseUrl: string,
  token: AccessTokenSet,
  externalId: string,
  platformProvider: string,
  data: object,
) => (
  callPdcApi(
    baseUrl,
    '/platformProviderResponses',
    {},
    'post',
    token,
    {
      externalId,
      platformProvider,
      data,
    },
  )
);

export {
  ChangemakerFieldValue,
  ChangemakerFieldValueBatch,
  getBaseFields,
  getChangemakers,
  getProposals,
  getSources,
  postChangemakerFieldValueBatch,
  postChangemakerFieldValue,
  postPlatformProviderData,
  postSource,
};