@vrplatform/api 1.3.0-stage.1301 → 1.3.1

package/src/index.ts

@@ -1,8 +1,11 @@
+import type { useIngest } from './ingest';
 import type { ApiClient } from './types';
 
 export * from './client';
 export * from './error';
 export * from './generated/v1';
+export * from './ingest';
 export * from './types';
 
+export type ApiIngest = ReturnType<typeof useIngest>;
 export type VRPlatformApi = ApiClient;

package/src/ingest/index.ts

@@ -0,0 +1,227 @@
+import { throwIfError } from '../error';
+import type { ApiClient, RequestBody } from '../types';
+import type * as t from './types';
+
+export * from './types';
+
+function mergeConfig(
+  body: any,
+  config: t.IngestArg,
+  configOverwrites?: t.IngestFnArg
+) {
+  const headers: Record<string, string> = {};
+  if (configOverwrites) {
+    const { correlationId, ...restOverwrites } = configOverwrites;
+    for (const [key, value] of Object.entries(restOverwrites))
+      if (value) body[key] = value;
+    if (correlationId) headers['X-Correlation-Id'] = correlationId;
+  }
+  if (config.sessionId) headers['X-Session-Id'] = config.sessionId;
+
+  return headers;
+}
+
+export function usePostSources(api: ApiClient, config: t.IngestArg) {
+  const { sessionId: _, ...restConfig } = config;
+  async function post<T = undefined>(
+    data: RequestBody<'post:/sources/batch'>['data'],
+    configOverwrites?: t.IngestFnArg
+  ): Promise<t.TypedResponseData<T>[]> {
+    const body: RequestBody<'post:/sources/batch'> = {
+      ...restConfig,
+      data,
+    };
+    const headers = mergeConfig(body, config, configOverwrites);
+    const response = throwIfError(
+      await api.POST('/sources/batch', { body, headers })
+    );
+    return response.data as any;
+  }
+  return post;
+}
+
+export function useIngest(api: ApiClient, config: t.IngestArg) {
+  const post = usePostSources(api, config);
+  return {
+    api,
+    get sessionId() {
+      return api.sessionId;
+    },
+    async sources(
+      changes: t.IngestSourceInput[],
+      configOverwrites?: t.IngestFnArg
+    ) {
+      if (!changes.length) return undefined;
+      return await post(changes, configOverwrites);
+    },
+    async updateSources(
+      data: RequestBody<'put:/sources/batch'>['data'],
+      configOverwrites?: t.IngestFnArg
+    ) {
+      const { sessionId: _, ...restConfig } = config;
+      const body: RequestBody<'put:/sources/batch'> = {
+        ...restConfig,
+        data,
+      };
+      const headers = mergeConfig(body, config, configOverwrites);
+      const response = throwIfError(
+        await api.PUT('/sources/batch', { body, headers })
+      );
+      return response.data;
+    },
+    async reservations(
+      changes: t.IngestReservationInput[],
+      configOverwrites?: t.IngestFnArg
+    ) {
+      if (!changes.length) return [];
+      return await post<t.ReservationParam>(
+        changes.map(({ source, ...transform }) => {
+          return {
+            ...source,
+            type: source.type || 'reservation',
+            description: source.description || transform.confirmationCode,
+            uniqueRef: source.uniqueRef || transform.uniqueRef!,
+            date: source.date || transform.bookedAt,
+            status: source.status || 'active',
+            transform: {
+              data: transform,
+              type: 'reservation',
+            },
+          };
+        }),
+        configOverwrites
+      );
+    },
+    async payments(
+      changes: t.IngestPaymentInput[],
+      configOverwrites?: t.IngestFnArg
+    ) {
+      if (!changes.length) return undefined;
+      return await post<t.PaymentParam>(
+        changes.map(({ source, ...transform }) => {
+          return {
+            ...source,
+            type: source.type || 'payment',
+            description: source.description || transform.description,
+            uniqueRef: source.uniqueRef || transform.uniqueRef!,
+            date: source.date || transform.paidAt,
+            status: source.status || 'active',
+            transform: {
+              data: transform,
+              type: 'payment',
+            },
+          };
+        }),
+        configOverwrites
+      );
+    },
+    async listings(
+      changes: t.IngestListingInput[],
+      configOverwrites?: t.IngestFnArg
+    ) {
+      if (!changes.length) return undefined;
+      return await post<t.ListingParam>(
+        changes.map(({ source, ...transform }) => {
+          return {
+            ...source,
+            type: source.type || 'listing',
+            description: source.description || transform.name,
+            uniqueRef: source.uniqueRef || transform.uniqueRef!,
+            status: source.status || 'active',
+            transform: {
+              data: transform,
+              type: 'listing',
+            },
+          };
+        }),
+        configOverwrites
+      );
+    },
+    async cleanup(
+      type: string | 'listing',
+      configOverwrites?: t.IngestFnArg & {
+        whereRange?: RequestBody<'put:/sources/cleanup'>['whereRange'];
+      }
+    ) {
+      const body: RequestBody<'put:/sources/cleanup'> = {
+        syncId: configOverwrites?.syncId || config.syncId,
+        connectionId: configOverwrites?.connectionId || config.connectionId,
+        type,
+      };
+      if (configOverwrites?.whereRange) {
+        body.whereRange = configOverwrites.whereRange;
+      }
+      const headers = mergeConfig(body, config, configOverwrites);
+      const response = throwIfError(
+        await api.PUT('/sources/cleanup', { body, headers })
+      );
+      return response.ok as any;
+    },
+    async bankRecords(
+      changes: t.IngestBankRecordInput[],
+      configOverwrites?: t.IngestFnArg
+    ) {
+      if (!changes.length) return undefined;
+      return await post<t.BankRecordParam>(
+        changes.map(({ source, ...transform }) => {
+          return {
+            ...source,
+            type: source.type || 'bankRecord',
+            description: source.description || transform.description,
+            uniqueRef: source.uniqueRef || transform.uniqueRef!,
+            status: source.status || 'active',
+            transform: {
+              data: transform,
+              type: 'bankRecord',
+            },
+          };
+        }),
+        configOverwrites
+      );
+    },
+    async transactions(
+      changes: t.IngestTransactionInput[],
+      configOverwrites?: t.IngestFnArg
+    ) {
+      if (!changes.length) return undefined;
+      return await post<t.TransactionParam>(
+        changes.map(({ source, ...transform }) => {
+          return {
+            ...source,
+            type: source.type || 'transaction',
+            description: source.description || transform.description,
+            uniqueRef: source.uniqueRef || transform.uniqueRef!,
+            status: source.status || 'active',
+            transform: {
+              data: transform,
+              type: 'transaction',
+            },
+          };
+        }),
+        configOverwrites
+      );
+    },
+    async contacts(
+      changes: t.IngestContactInput[],
+      configOverwrites?: t.IngestFnArg
+    ) {
+      if (!changes.length) return undefined;
+      return await post<t.ContactParam>(
+        changes.map(({ source, ...transform }) => {
+          return {
+            ...source,
+            type: source.type || 'contact',
+            description: source.description || transform.name,
+            uniqueRef: source.uniqueRef || transform.email!,
+            status: source.status || 'active',
+            transform: {
+              data: transform,
+              type: 'contact',
+            },
+          };
+        }),
+        configOverwrites
+      );
+    },
+  };
+}

package/src/ingest/types.ts

@@ -0,0 +1,91 @@
+import type { PartialBy } from '@vrplatform/utils';
+import type { RequestBody, ResponseData } from '../types';
+
+export type ReservationParam = Omit<
+  RequestBody<'post:/reservations/batch'>['data'][0],
+  'sourceId'
+>;
+export type PaymentParam = Omit<
+  RequestBody<'post:/payments/batch'>['data'][0],
+  'sourceId'
+>;
+export type ListingParam = Omit<
+  RequestBody<'post:/listings/batch'>['data'][0],
+  'sourceId'
+>;
+export type BankRecordParam = Omit<
+  RequestBody<'post:/bank-records/batch'>['data'][0],
+  'sourceId'
+>;
+export type TransactionParam = Omit<
+  RequestBody<'post:/transactions/batch'>['data'][0],
+  'sourceId'
+>;
+export type ContactParam = Omit<
+  RequestBody<'post:/contacts/batch'>['data'][0],
+  'sourceId'
+>;
+type _SourceWithoutTransform = Omit<
+  RequestBody<'post:/sources/batch'>['data'][number],
+  'transform'
+> & {
+  // this is ONLY for ecosystem ingestion, can be removed once ecosystem does not rely on ingest, but calls batch endpoints
+  fileStorageId?: string;
+};
+type _SourceWithTransform<T> = _SourceWithoutTransform & {
+  transform: { type: string; data: T };
+};
+export type Source<T = undefined> = T extends undefined
+  ? _SourceWithoutTransform
+  : _SourceWithTransform<T>;
+
+export type IngestArg = Omit<RequestBody<'post:/sources/batch'>, 'data'> & {
+  sessionId?: string;
+  tenantId: string;
+};
+export type IngestFnArg = Omit<Partial<IngestArg>, 'sessionId'> & {
+  correlationId?: string;
+};
+
+export type BatchResponseData = ResponseData<'post:/sources/batch'>['data'][0];
+export type TypedResponseData<T = undefined> = Omit<
+  BatchResponseData,
+  'transform'
+> &
+  (T extends undefined
+    ? { transform?: never }
+    : {
+        transform: Omit<BatchResponseData['transform'], 'data'> & {
+          data: T;
+        };
+      });
+
+export type Impossible<K extends keyof any> = {
+  [P in K]: never;
+};
+export type NoExtraProperties<T, U extends T = T> = U &
+  Impossible<Exclude<keyof U, keyof T>>;
+
+export type ObjectWithSource<T = undefined> = T & {
+  source: PartialBy<_SourceWithoutTransform, 'type'>;
+};
+
+export type IngestReservationInput = NoExtraProperties<
+  ObjectWithSource<ReservationParam>
+>;
+export type IngestPaymentInput = NoExtraProperties<
+  ObjectWithSource<PaymentParam>
+>;
+export type IngestListingInput = NoExtraProperties<
+  ObjectWithSource<ListingParam>
+>;
+export type IngestBankRecordInput = NoExtraProperties<
+  ObjectWithSource<BankRecordParam>
+>;
+export type IngestTransactionInput = NoExtraProperties<
+  ObjectWithSource<TransactionParam>
+>;
+export type IngestContactInput = NoExtraProperties<
+  ObjectWithSource<ContactParam>
+>;
+export type IngestSourceInput = NoExtraProperties<Source>;