increase 0.1.0

package/tests/api-resources/wire-drawdown-requests.test.ts

@@ -0,0 +1,73 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource wire_drawdown_requests', () => {
+  // Prism tests are broken
+  test.skip('create: only required params', async () => {
+    const response = await increase.wireDrawdownRequests.create({
+      account_number_id: 'account_number_v18nkfqm6afpsrvy82b2',
+      amount: 10000,
+      message_to_recipient: 'Invoice 29582',
+      recipient_account_number: '987654321',
+      recipient_routing_number: '101050001',
+      recipient_name: 'Ian Crease',
+    });
+  });
+
+  // Prism tests are broken
+  test.skip('create: required and optional params', async () => {
+    const response = await increase.wireDrawdownRequests.create({
+      account_number_id: 'account_number_v18nkfqm6afpsrvy82b2',
+      amount: 10000,
+      message_to_recipient: 'Invoice 29582',
+      recipient_account_number: '987654321',
+      recipient_routing_number: '101050001',
+      recipient_name: 'Ian Crease',
+      recipient_address_line1: '33 Liberty Street',
+      recipient_address_line2: 'New York, NY, 10045',
+      recipient_address_line3: 'x',
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await increase.wireDrawdownRequests.retrieve(
+      'wire_drawdown_request_q6lmocus3glo0lr2bfv3',
+    );
+  });
+
+  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(
+      increase.wireDrawdownRequests.retrieve('wire_drawdown_request_q6lmocus3glo0lr2bfv3', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.wireDrawdownRequests.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.wireDrawdownRequests.list({ cursor: 'string', limit: 0 });
+  });
+
+  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(increase.wireDrawdownRequests.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: 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(
+      increase.wireDrawdownRequests.list(
+        { cursor: 'string', limit: 0 },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});

package/tests/api-resources/wire-transfers.test.ts

@@ -0,0 +1,147 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase from '~/index';
+const increase = new Increase({ apiKey: 'something1234', baseURL: 'http://127.0.0.1:4010' });
+
+describe('resource wire_transfers', () => {
+  test('create: only required params', async () => {
+    const response = await increase.wireTransfers.create({
+      account_id: 'account_in71c4amph0vgo2qllky',
+      amount: 100,
+      message_to_recipient: 'New account transfer',
+      beneficiary_name: 'Ian Crease',
+    });
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await increase.wireTransfers.create({
+      account_id: 'account_in71c4amph0vgo2qllky',
+      account_number: '987654321',
+      routing_number: '101050001',
+      external_account_id: 'string',
+      amount: 100,
+      message_to_recipient: 'New account transfer',
+      beneficiary_name: 'Ian Crease',
+      beneficiary_address_line1: '33 Liberty Street',
+      beneficiary_address_line2: 'New York',
+      beneficiary_address_line3: 'NY 10045',
+      require_approval: true,
+    });
+  });
+
+  test('retrieve', async () => {
+    const response = await increase.wireTransfers.retrieve('wire_transfer_5akynk7dqsq25qwk9q2u');
+  });
+
+  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(
+      increase.wireTransfers.retrieve('wire_transfer_5akynk7dqsq25qwk9q2u', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('list: only required params', async () => {
+    const response = await increase.wireTransfers.list();
+  });
+
+  test('list: required and optional params', async () => {
+    const response = await increase.wireTransfers.list({
+      cursor: 'string',
+      limit: 0,
+      account_id: 'string',
+      external_account_id: 'string',
+      created_at: {
+        after: '2019-12-27T18:11:19.117Z',
+        before: '2019-12-27T18:11:19.117Z',
+        on_or_after: '2019-12-27T18:11:19.117Z',
+        on_or_before: '2019-12-27T18:11:19.117Z',
+      },
+    });
+  });
+
+  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(increase.wireTransfers.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      Increase.NotFoundError,
+    );
+  });
+
+  test('list: 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(
+      increase.wireTransfers.list(
+        {
+          cursor: 'string',
+          limit: 0,
+          account_id: 'string',
+          external_account_id: 'string',
+          created_at: {
+            after: '2019-12-27T18:11:19.117Z',
+            before: '2019-12-27T18:11:19.117Z',
+            on_or_after: '2019-12-27T18:11:19.117Z',
+            on_or_before: '2019-12-27T18:11:19.117Z',
+          },
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('approve', async () => {
+    const response = await increase.wireTransfers.approve('wire_transfer_5akynk7dqsq25qwk9q2u');
+  });
+
+  test('approve: 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(
+      increase.wireTransfers.approve('wire_transfer_5akynk7dqsq25qwk9q2u', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  test('cancel', async () => {
+    const response = await increase.wireTransfers.cancel('wire_transfer_5akynk7dqsq25qwk9q2u');
+  });
+
+  test('cancel: 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(
+      increase.wireTransfers.cancel('wire_transfer_5akynk7dqsq25qwk9q2u', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  // Prism tests are broken
+  test.skip('reverse', async () => {
+    const response = await increase.wireTransfers.reverse('wire_transfer_5akynk7dqsq25qwk9q2u');
+  });
+
+  // Prism tests are broken
+  test.skip('reverse: 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(
+      increase.wireTransfers.reverse('wire_transfer_5akynk7dqsq25qwk9q2u', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+
+  // Prism tests are broken
+  test.skip('submit', async () => {
+    const response = await increase.wireTransfers.submit('wire_transfer_5akynk7dqsq25qwk9q2u');
+  });
+
+  // Prism tests are broken
+  test.skip('submit: 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(
+      increase.wireTransfers.submit('wire_transfer_5akynk7dqsq25qwk9q2u', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(Increase.NotFoundError);
+  });
+});

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,47 @@
+// File generated from our OpenAPI spec by Stainless.
+
+import Increase 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 minimal arguments', () => {
+    // set API Key via env var
+    process.env['INCREASE_API_KEY'] = 'env var api key';
+    const client = new Increase();
+    expect(client.apiKey).toBe('env var api key');
+  });
+
+  test('with apiKey argument', () => {
+    process.env['INCREASE_API_KEY'] = 'env var api key';
+
+    const client = new Increase({ apiKey: 'another api key' });
+    expect(client.apiKey).toBe('another api key');
+  });
+
+  test('with options argument', () => {
+    process.env['INCREASE_API_KEY'] = 'env var api key';
+
+    // apiKey
+    const client = new Increase({ apiKey: 'my api key' });
+    expect(client.apiKey).toBe('my api key');
+  });
+
+  test('with disabled authentication', () => {
+    // fails if no API Key provided
+    expect(() => {
+      new Increase();
+    }).toThrow();
+  });
+});

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,37 @@
+{
+  "compilerOptions": {
+    "target": "es2019",
+    "lib": ["es2020"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "rootDir": "./",
+    "baseUrl": "./",
+    "paths": {
+      "~/*": ["*"],
+      "digest-fetch": ["./typings/digest-fetch"]
+    },
+
+    "declaration": true,
+    "outDir": "dist",
+    "pretty": true,
+    "sourceMap": 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 = '0.1.0';