@tryfinch/finch-api 1.0.0

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

@@ -0,0 +1,66 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource individuals', () => {
+  test('enrollMany', async () => {
+    const response = await finch.hris.benefits.individuals.enrollMany('string', [{}, {}, {}]);
+  });
+
+  test('enrolledIds', async () => {
+    const response = await finch.hris.benefits.individuals.enrolledIds('string');
+  });
+
+  test('enrolledIds: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      finch.hris.benefits.individuals.enrolledIds('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(Finch.NotFoundError);
+  });
+
+  test('retrieveManyBenefits', async () => {
+    const response = await finch.hris.benefits.individuals.retrieveManyBenefits('string');
+  });
+
+  test('retrieveManyBenefits: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      finch.hris.benefits.individuals.retrieveManyBenefits('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(Finch.NotFoundError);
+  });
+
+  test('retrieveManyBenefits: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      finch.hris.benefits.individuals.retrieveManyBenefits(
+        'string',
+        { individual_ids: 'd675d2b7-6d7b-41a8-b2d3-001eb3fb88f6,d02a6346-1f08-4312-a064-49ff3cafaa7a' },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Finch.NotFoundError);
+  });
+
+  test('unenroll', async () => {
+    const response = await finch.hris.benefits.individuals.unenroll('string');
+  });
+
+  test('unenroll: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      finch.hris.benefits.individuals.unenroll('string', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(Finch.NotFoundError);
+  });
+
+  test('unenroll: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      finch.hris.benefits.individuals.unenroll(
+        'string',
+        { individual_ids: ['string', 'string', 'string'] },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Finch.NotFoundError);
+  });
+});

package/tests/api-resources/hris/company.test.ts

@@ -0,0 +1,18 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource company', () => {
+  test('retrieve', async () => {
+    const response = await finch.hris.company.retrieve();
+  });
+
+  test('retrieve: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(finch.hris.company.retrieve({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Finch.NotFoundError,
+    );
+  });
+});

package/tests/api-resources/hris/directory.test.ts

@@ -0,0 +1,25 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource directory', () => {
+  test('listIndividuals', async () => {
+    const response = await finch.hris.directory.listIndividuals();
+  });
+
+  test('listIndividuals: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(finch.hris.directory.listIndividuals({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Finch.NotFoundError,
+    );
+  });
+
+  test('listIndividuals: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      finch.hris.directory.listIndividuals({ limit: 0, offset: 0 }, { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(Finch.NotFoundError);
+  });
+});

package/tests/api-resources/hris/individuals/employment-data.test.ts

@@ -0,0 +1,19 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource employmentData', () => {
+  test('retrieveMany: only required params', async () => {
+    const response = await finch.hris.individuals.employmentData.retrieveMany({
+      requests: [{ individual_id: 'string' }, { individual_id: 'string' }, { individual_id: 'string' }],
+    });
+  });
+
+  test('retrieveMany: required and optional params', async () => {
+    const response = await finch.hris.individuals.employmentData.retrieveMany({
+      requests: [{ individual_id: 'string' }, { individual_id: 'string' }, { individual_id: 'string' }],
+    });
+  });
+});

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

@@ -0,0 +1,31 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource individuals', () => {
+  test('retrieveMany', async () => {
+    const response = await finch.hris.individuals.retrieveMany();
+  });
+
+  test('retrieveMany: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(finch.hris.individuals.retrieveMany({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Finch.NotFoundError,
+    );
+  });
+
+  test('retrieveMany: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      finch.hris.individuals.retrieveMany(
+        {
+          options: { include: ['string', 'string', 'string'] },
+          requests: [{ individual_id: 'string' }, { individual_id: 'string' }, { individual_id: 'string' }],
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Finch.NotFoundError);
+  });
+});

package/tests/api-resources/hris/pay-statements.test.ts

@@ -0,0 +1,27 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource payStatements', () => {
+  test('retrieveMany: only required params', async () => {
+    const response = await finch.hris.payStatements.retrieveMany({
+      requests: [
+        { payment_id: 'e8b90071-0c11-471c-86e8-e303ef2f6782' },
+        { payment_id: 'e8b90071-0c11-471c-86e8-e303ef2f6782' },
+        { payment_id: 'e8b90071-0c11-471c-86e8-e303ef2f6782' },
+      ],
+    });
+  });
+
+  test('retrieveMany: required and optional params', async () => {
+    const response = await finch.hris.payStatements.retrieveMany({
+      requests: [
+        { payment_id: 'e8b90071-0c11-471c-86e8-e303ef2f6782', limit: 0, offset: 0 },
+        { payment_id: 'e8b90071-0c11-471c-86e8-e303ef2f6782', limit: 0, offset: 0 },
+        { payment_id: 'e8b90071-0c11-471c-86e8-e303ef2f6782', limit: 0, offset: 0 },
+      ],
+    });
+  });
+});

package/tests/api-resources/hris/payments.test.ts

@@ -0,0 +1,15 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource payments', () => {
+  test('list: only required params', async () => {
+    const response = await finch.hris.payments.list({ end_date: '2021-01-01', start_date: '2021-01-01' });
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await finch.hris.payments.list({ end_date: '2021-01-01', start_date: '2021-01-01' });
+  });
+});

package/tests/api-resources/providers.test.ts

@@ -0,0 +1,18 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource providers', () => {
+  test('list', async () => {
+    const response = await finch.providers.list();
+  });
+
+  test('list: request options instead of params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(finch.providers.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Finch.NotFoundError,
+    );
+  });
+});

package/tests/api-resources/top-level.test.ts

@@ -0,0 +1,15 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '~/index';
+
+const finch = new Finch({ accessToken: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('top level methods', () => {
+  test('getAccessToken', async () => {
+    // TODO
+  });
+
+  test('getAuthUrl', async () => {
+    // TODO
+  });
+});

package/tests/form.test.ts

@@ -0,0 +1,27 @@
+import { multipartFormRequestOptions } from '~/core';
+import { Blob } from 'formdata-node';
+import { fileFromPath } from 'formdata-node/file-from-path';
+
+describe('form data validation', () => {
+  test('valid values do not error', async () => {
+    multipartFormRequestOptions({
+      body: {
+        foo: 'foo',
+        string: 1,
+        bool: true,
+        file: await fileFromPath('README.md'),
+        blob: new Blob(['Some content'], { type: 'text/plain' }),
+      },
+    });
+  });
+
+  test('null', async () => {
+    expect(() =>
+      multipartFormRequestOptions({
+        body: {
+          null: null,
+        },
+      }),
+    ).toThrow(TypeError);
+  });
+});

package/tests/index.test.ts

@@ -0,0 +1,34 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Finch from '../index';
+
+describe('instantiate client', () => {
+  const env = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...env };
+
+    console.warn = jest.fn();
+  });
+
+  afterEach(() => {
+    process.env = env;
+  });
+
+  test('with accessToken argument', () => {
+    const client = new Finch({ accessToken: 'another access token' });
+    expect(client.accessToken).toBe('another access token');
+  });
+
+  test('with options argument', () => {
+    // accessToken
+    const client = new Finch({ accessToken: 'my access token' });
+    expect(client.accessToken).toBe('my access token');
+  });
+
+  test('with disabled authentication', () => {
+    const client = new Finch({ accessToken: null });
+    expect(client.accessToken).toBeNull();
+  });
+});

package/tests/responses.test.ts

@@ -0,0 +1,25 @@
+import { createResponseHeaders } from '~/core';
+import { Headers } from 'node-fetch';
+
+describe('response parsing', () => {
+  // TODO: test unicode characters
+  test('headers are case agnostic', async () => {
+    const headers = createResponseHeaders(new Headers({ 'Content-Type': 'foo', Accept: 'text/plain' }));
+    expect(headers['content-type']).toEqual('foo');
+    expect(headers['Content-type']).toEqual('foo');
+    expect(headers['Content-Type']).toEqual('foo');
+    expect(headers['accept']).toEqual('text/plain');
+    expect(headers['Accept']).toEqual('text/plain');
+    expect(headers['Hello-World']).toBeUndefined();
+  });
+
+  test('duplicate headers are concatenated', () => {
+    const headers = createResponseHeaders(
+      new Headers([
+        ['Content-Type', 'text/xml'],
+        ['Content-Type', 'application/json'],
+      ]),
+    );
+    expect(headers['content-type']).toBe('text/xml, application/json');
+  });
+});

package/tsconfig.cjs.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "commonjs",
+    "outDir": "dist/cjs/"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "compilerOptions": {
+    "target": "es2019",
+    "lib": ["es2020"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "rootDir": "./",
+    "baseUrl": "./",
+    "paths": {
+      "~/*": ["*"],
+      "digest-fetch": ["./typings/digest-fetch"]
+    },
+
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "pretty": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+
+    "forceConsistentCasingInFileNames": true,
+
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "exactOptionalPropertyTypes": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+
+    "skipLibCheck": true
+  }
+}

package/typings/digest-fetch/index.d.ts

@@ -0,0 +1,33 @@
+declare module 'digest-fetch';
+
+import type { RequestInfo, RequestInit, Response } from 'node-fetch';
+
+type Algorithm = 'MD5' | 'MD5-sess';
+
+type Options = {
+  algorithm?: Algorithm;
+  statusCode?: number;
+  cnonceSize?: number;
+  basic?: boolean;
+  precomputeHash?: boolean;
+  logger?: typeof console;
+};
+
+class DigestClient {
+  user: string;
+  password: string;
+
+  private nonceRaw: string;
+  private logger?: typeof console;
+  private precomputedHash?: boolean;
+  private statusCode?: number;
+  private basic: boolean;
+  private cnonceSize: number;
+  private hasAuth: boolean;
+  private digest: { nc: number; algorithm: Algorithm; realm: string };
+
+  constructor(user: string, password: string, options: Options = {});
+  async fetch(url: RequestInfo, options: RequestInit = {}): Promise<Response>;
+}
+
+export default DigestClient;

package/version.ts

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