ogx-client 0.7.2-rc1 → 0.7.2

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

@@ -0,0 +1,88 @@
+// Copyright (c) The OGX Contributors.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+//
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource shields', () => {
+  test('retrieve', async () => {
+    const responsePromise = client.shields.retrieve('identifier');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  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(client.shields.retrieve('identifier', { path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('list', async () => {
+    const responsePromise = client.shields.list();
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  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(client.shields.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('delete', async () => {
+    const responsePromise = client.shields.delete('identifier');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('delete: 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(client.shields.delete('identifier', { path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.NotFoundError,
+    );
+  });
+
+  test('register: only required params', async () => {
+    const responsePromise = client.shields.register({ shield_id: 'shield_id' });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('register: required and optional params', async () => {
+    const response = await client.shields.register({
+      shield_id: 'shield_id',
+      params: { foo: 'bar' },
+      provider_id: 'provider_id',
+      provider_shield_id: 'provider_shield_id',
+    });
+  });
+});

package/tests/api-resources/vector-io.test.ts

@@ -0,0 +1,84 @@
+// Copyright (c) The OGX Contributors.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+//
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource vectorIo', () => {
+  test('insert: only required params', async () => {
+    const responsePromise = client.vectorIo.insert({
+      chunks: [
+        {
+          chunk_id: 'chunk_id',
+          chunk_metadata: {},
+          content: 'string',
+          embedding: [0],
+          embedding_dimension: 0,
+          embedding_model: 'embedding_model',
+        },
+      ],
+      vector_store_id: 'vector_store_id',
+    });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('insert: required and optional params', async () => {
+    const response = await client.vectorIo.insert({
+      chunks: [
+        {
+          chunk_id: 'chunk_id',
+          chunk_metadata: {
+            chunk_id: 'chunk_id',
+            chunk_tokenizer: 'chunk_tokenizer',
+            chunk_window: 'chunk_window',
+            content_token_count: 0,
+            created_timestamp: 0,
+            document_id: 'document_id',
+            metadata_token_count: 0,
+            source: 'source',
+            updated_timestamp: 0,
+          },
+          content: 'string',
+          embedding: [0],
+          embedding_dimension: 0,
+          embedding_model: 'embedding_model',
+          metadata: { foo: 'bar' },
+        },
+      ],
+      vector_store_id: 'vector_store_id',
+      ttl_seconds: 0,
+    });
+  });
+
+  test('query: only required params', async () => {
+    const responsePromise = client.vectorIo.query({ query: 'string', vector_store_id: 'vector_store_id' });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('query: required and optional params', async () => {
+    const response = await client.vectorIo.query({
+      query: 'string',
+      vector_store_id: 'vector_store_id',
+      params: { foo: 'bar' },
+    });
+  });
+});

package/tests/api-resources/vector-stores/file-batches.test.ts

@@ -0,0 +1,103 @@
+// Copyright (c) The OGX Contributors.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+//
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource fileBatches', () => {
+  test('create', async () => {
+    const responsePromise = client.vectorStores.fileBatches.create('vector_store_id', {});
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('retrieve', async () => {
+    const responsePromise = client.vectorStores.fileBatches.retrieve('vector_store_id', 'batch_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  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(
+      client.vectorStores.fileBatches.retrieve('vector_store_id', 'batch_id', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('cancel', async () => {
+    const responsePromise = client.vectorStores.fileBatches.cancel('vector_store_id', 'batch_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  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(
+      client.vectorStores.fileBatches.cancel('vector_store_id', 'batch_id', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('listFiles', async () => {
+    const responsePromise = client.vectorStores.fileBatches.listFiles('vector_store_id', 'batch_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('listFiles: 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(
+      client.vectorStores.fileBatches.listFiles('vector_store_id', 'batch_id', {
+        path: '/_stainless_unknown_path',
+      }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('listFiles: 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(
+      client.vectorStores.fileBatches.listFiles(
+        'vector_store_id',
+        'batch_id',
+        {
+          after: 'after',
+          before: 'before',
+          filter: 'filter',
+          limit: 1,
+          order: 'order',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+});

package/tests/api-resources/vector-stores/files.test.ts

@@ -0,0 +1,153 @@
+// Copyright (c) The OGX Contributors.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+//
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource files', () => {
+  test('create: only required params', async () => {
+    const responsePromise = client.vectorStores.files.create('vector_store_id', { file_id: 'file_id' });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('create: required and optional params', async () => {
+    const response = await client.vectorStores.files.create('vector_store_id', {
+      file_id: 'file_id',
+      attributes: { foo: 'string' },
+      chunking_strategy: { type: 'auto' },
+    });
+  });
+
+  test('retrieve', async () => {
+    const responsePromise = client.vectorStores.files.retrieve('vector_store_id', 'file_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  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(
+      client.vectorStores.files.retrieve('vector_store_id', 'file_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('update: only required params', async () => {
+    const responsePromise = client.vectorStores.files.update('vector_store_id', 'file_id', {
+      attributes: { foo: 'bar' },
+    });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('update: required and optional params', async () => {
+    const response = await client.vectorStores.files.update('vector_store_id', 'file_id', {
+      attributes: { foo: 'bar' },
+    });
+  });
+
+  test('list', async () => {
+    const responsePromise = client.vectorStores.files.list('vector_store_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  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(
+      client.vectorStores.files.list('vector_store_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.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(
+      client.vectorStores.files.list(
+        'vector_store_id',
+        {
+          after: 'after',
+          before: 'before',
+          filter: 'in_progress',
+          limit: 1,
+          order: 'order',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('delete', async () => {
+    const responsePromise = client.vectorStores.files.delete('vector_store_id', 'file_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('delete: 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(
+      client.vectorStores.files.delete('vector_store_id', 'file_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('content', async () => {
+    const responsePromise = client.vectorStores.files.content('vector_store_id', 'file_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('content: 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(
+      client.vectorStores.files.content('vector_store_id', 'file_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('content: 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(
+      client.vectorStores.files.content(
+        'vector_store_id',
+        'file_id',
+        { include_embeddings: true, include_metadata: true },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+});

package/tests/api-resources/vector-stores/vector-stores.test.ts

@@ -0,0 +1,134 @@
+// Copyright (c) The OGX Contributors.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+//
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import OgxClient from 'ogx-client';
+import { Response } from 'node-fetch';
+
+const client = new OgxClient({ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010' });
+
+describe('resource vectorStores', () => {
+  test('create', async () => {
+    const responsePromise = client.vectorStores.create({});
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('retrieve', async () => {
+    const responsePromise = client.vectorStores.retrieve('vector_store_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  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(
+      client.vectorStores.retrieve('vector_store_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('update', async () => {
+    const responsePromise = client.vectorStores.update('vector_store_id', {});
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('list', async () => {
+    const responsePromise = client.vectorStores.list();
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  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(client.vectorStores.list({ path: '/_stainless_unknown_path' })).rejects.toThrow(
+      OgxClient.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(
+      client.vectorStores.list(
+        {
+          after: 'after',
+          before: 'before',
+          limit: 1,
+          order: 'order',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('delete', async () => {
+    const responsePromise = client.vectorStores.delete('vector_store_id');
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('delete: 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(
+      client.vectorStores.delete('vector_store_id', { path: '/_stainless_unknown_path' }),
+    ).rejects.toThrow(OgxClient.NotFoundError);
+  });
+
+  test('search: only required params', async () => {
+    const responsePromise = client.vectorStores.search('vector_store_id', { query: 'string' });
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('search: required and optional params', async () => {
+    const response = await client.vectorStores.search('vector_store_id', {
+      query: 'string',
+      filters: { foo: 'bar' },
+      max_num_results: 1,
+      ranking_options: {
+        alpha: 0,
+        impact_factor: 0,
+        model: 'model',
+        ranker: 'ranker',
+        score_threshold: 0,
+        weights: { foo: 0 },
+      },
+      rewrite_query: true,
+      search_mode: 'search_mode',
+    });
+  });
+});

package/tests/form.test.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+// All rights reserved.
+//
+// This source code is licensed under the terms described in the LICENSE file in
+// the root directory of this source tree.
+
+import { multipartFormRequestOptions, createForm } from 'ogx-client/core';
+import { Blob } from 'ogx-client/_shims/index';
+import { toFile } from 'ogx-client';
+
+describe('form data validation', () => {
+  test('valid values do not error', async () => {
+    await multipartFormRequestOptions({
+      body: {
+        foo: 'foo',
+        string: 1,
+        bool: true,
+        file: await toFile(Buffer.from('some-content')),
+        blob: new Blob(['Some content'], { type: 'text/plain' }),
+      },
+    });
+  });
+
+  test('null', async () => {
+    await expect(() =>
+      multipartFormRequestOptions({
+        body: {
+          null: null,
+        },
+      }),
+    ).rejects.toThrow(TypeError);
+  });
+
+  test('undefined is stripped', async () => {
+    const form = await createForm({
+      foo: undefined,
+      bar: 'baz',
+    });
+    expect(form.has('foo')).toBe(false);
+    expect(form.get('bar')).toBe('baz');
+  });
+
+  test('nested undefined property is stripped', async () => {
+    const form = await createForm({
+      bar: {
+        baz: undefined,
+      },
+    });
+    expect(Array.from(form.entries())).toEqual([]);
+
+    const form2 = await createForm({
+      bar: {
+        foo: 'string',
+        baz: undefined,
+      },
+    });
+    expect(Array.from(form2.entries())).toEqual([['bar[foo]', 'string']]);
+  });
+
+  test('nested undefined array item is stripped', async () => {
+    const form = await createForm({
+      bar: [undefined, undefined],
+    });
+    expect(Array.from(form.entries())).toEqual([]);
+
+    const form2 = await createForm({
+      bar: [undefined, 'foo'],
+    });
+    expect(Array.from(form2.entries())).toEqual([['bar[]', 'foo']]);
+  });
+});