@tryfinch/finch-api 1.0.0 → 1.1.0

package/streaming.ts

@@ -0,0 +1,122 @@
+import type { Response } from 'node-fetch';
+import { APIResponse, Headers, createResponseHeaders } from '~/core';
+
+type ServerSentEvent = {
+  event: string | null;
+  data: string;
+  raw: string[];
+};
+
+class SSEDecoder {
+  private data: string[];
+  private event: string | null;
+  private chunks: string[];
+
+  constructor() {
+    this.event = null;
+    this.data = [];
+    this.chunks = [];
+  }
+
+  decode(line: string) {
+    if (line.endsWith('\r')) {
+      line = line.substring(0, line.length - 1);
+    }
+
+    if (!line) {
+      // empty line and we didn't previously encounter any messages
+      if (!this.event && !this.data.length) return null;
+
+      const sse: ServerSentEvent = {
+        event: this.event,
+        data: this.data.join('\n'),
+        raw: this.chunks,
+      };
+
+      this.event = null;
+      this.data = [];
+      this.chunks = [];
+
+      return sse;
+    }
+
+    this.chunks.push(line);
+
+    if (line.startsWith(':')) {
+      return null;
+    }
+
+    let [fieldname, _, value] = partition(line, ':');
+
+    if (value.startsWith(' ')) {
+      value = value.substring(1);
+    }
+
+    if (fieldname === 'event') {
+      this.event = value;
+    } else if (fieldname === 'data') {
+      this.data.push(value);
+    }
+
+    return null;
+  }
+}
+
+export class Stream<Item> implements AsyncIterable<Item>, APIResponse<Stream<Item>> {
+  response: Response;
+  responseHeaders: Headers;
+  controller: AbortController;
+
+  private decoder: SSEDecoder;
+
+  constructor(response: Response, controller: AbortController) {
+    this.response = response;
+    this.controller = controller;
+    this.decoder = new SSEDecoder();
+    this.responseHeaders = createResponseHeaders(response.headers);
+  }
+
+  private async *iterMessages(): AsyncGenerator<ServerSentEvent, void, unknown> {
+    if (!this.response.body) {
+      this.controller.abort();
+      throw new Error(`Attempted to iterate over a response with no body`);
+    }
+
+    for await (const chunk of this.response.body) {
+      let text;
+      if (chunk instanceof Buffer) {
+        text = chunk.toString();
+      } else {
+        text = chunk;
+      }
+
+      for (let line of text.split('\n')) {
+        const sse = this.decoder.decode(line);
+        if (sse) yield sse;
+      }
+    }
+
+    this.controller.abort();
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterator<Item, any, undefined> {
+    for await (const sse of this.iterMessages()) {
+      try {
+        yield JSON.parse(sse.data);
+      } catch (e) {
+        console.error(`Could not parse message into JSON:`, sse.data);
+        console.error(`From chunk:`, sse.raw);
+        throw e;
+      }
+    }
+  }
+}
+
+function partition(str: string, delimiter: string): [string, string, string] {
+  const index = str.indexOf(delimiter);
+  if (index !== -1) {
+    return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+  }
+
+  return [str, '', ''];
+}

package/tests/api-resources/hris/benefits/individuals.test.ts

@@ -5,10 +5,18 @@ import Finch from '~/index';
 const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
 
 describe('resource individuals', () => {
-  test('enrollMany', async () => {
+  test('enrollMany: only required params', async () => {
     const response = await finch.hris.benefits.individuals.enrollMany('string', [{}, {}, {}]);
   });
 
+  test('enrollMany: required and optional params', async () => {
+    const response = await finch.hris.benefits.individuals.enrollMany('string', [
+      { individual_id: 'string' },
+      { individual_id: 'string' },
+      { individual_id: 'string' },
+    ]);
+  });
+
   test('enrolledIds', async () => {
     const response = await finch.hris.benefits.individuals.enrolledIds('string');
   });

package/tests/index.test.ts

@@ -1,5 +1,6 @@
 // File generated from our OpenAPI spec by Stainless.
 
+import { Headers } from '~/core';
 import Finch from '../index';
 
 describe('instantiate client', () => {
@@ -16,6 +17,43 @@ describe('instantiate client', () => {
     process.env = env;
   });
 
+  test('defaultHeaders are passed through', () => {
+    const client = new Finch({
+      defaultHeaders: { 'X-My-Default-Header': '2' },
+      accessToken: 'my access token',
+    });
+
+    const { req } = client.buildRequest({ path: '/foo', method: 'post' });
+    expect((req.headers as Headers)['X-My-Default-Header']).toEqual('2');
+  });
+
+  describe('baseUrl', () => {
+    test('trailing slash', () => {
+      const client = new Finch({
+        baseURL: 'http://localhost:5000/custom/path/',
+        accessToken: 'my access token',
+      });
+      expect(client.buildURL('/foo', null)).toEqual('http://localhost:5000/custom/path/foo');
+    });
+
+    test('no trailing slash', () => {
+      const client = new Finch({
+        baseURL: 'http://localhost:5000/custom/path',
+        accessToken: 'my access token',
+      });
+      expect(client.buildURL('/foo', null)).toEqual('http://localhost:5000/custom/path/foo');
+    });
+  });
+
+  test('maxRetries option is correctly set', () => {
+    const client = new Finch({ maxRetries: 1, accessToken: 'my access token' });
+    expect(client.maxRetries).toEqual(1);
+
+    // default
+    const client2 = new Finch({ accessToken: 'my access token' });
+    expect(client2.maxRetries).toEqual(2);
+  });
+
   test('with accessToken argument', () => {
     const client = new Finch({ accessToken: 'another access token' });
     expect(client.accessToken).toBe('another access token');

package/version.ts

@@ -1 +1 @@
-export const VERSION = '1.0.0'; // x-release-please-version
+export const VERSION = '1.1.0'; // x-release-please-version