@unito/integration-sdk 2.0.0 → 2.0.2

package/dist/src/handler.js

@@ -92,6 +92,7 @@ export class Handler {
                 const collection = await handler({
                     credentials: res.locals.credentials,
                     secrets: res.locals.secrets,
+                    search: res.locals.search,
                     selects: res.locals.selects,
                     filters: res.locals.filters,
                     logger: res.locals.logger,

package/dist/src/index.cjs

@@ -523,6 +523,7 @@ class Handler {
                 const collection = await handler({
                     credentials: res.locals.credentials,
                     secrets: res.locals.secrets,
+                    search: res.locals.search,
                     selects: res.locals.selects,
                     filters: res.locals.filters,
                     logger: res.locals.logger,
@@ -828,7 +829,7 @@ function onError(err, _req, res, next) {
 // a subset of the symbol of another operator.
 //
 // For example, the symbol "=" (EQUAL) is a subset of the symbol "!=" (NOT_EQUAL).
-const ORDERED_OPERATORS = Object.values(integrationApi.OperatorType).sort((o1, o2) => o2.length - o1.length);
+const ORDERED_OPERATORS = Object.values(integrationApi.OperatorTypes).sort((o1, o2) => o2.length - o1.length);
 function extractFilters(req, res, next) {
     const rawFilters = req.query.filter;
     res.locals.filters = [];
@@ -929,6 +930,17 @@ function extractSecrets(req, res, next) {
     next();
 }
 
+function extractSearch(req, res, next) {
+    const rawSearch = req.query.search;
+    if (typeof rawSearch === 'string') {
+        res.locals.search = rawSearch;
+    }
+    else {
+        res.locals.search = null;
+    }
+    next();
+}
+
 function extractSelects(req, res, next) {
     const rawSelect = req.query.select;
     if (typeof rawSelect === 'string') {
@@ -1061,7 +1073,7 @@ class Integration {
         // Express Server initialization
         const app = express();
         // Parse query strings with https://github.com/ljharb/qs.
-        app.set('query parser', 'extended');
+        app.set('query parser', 'simple');
         app.use(express.json());
         // Must be one of the first handlers (to catch all the errors).
         app.use(onFinish);
@@ -1081,6 +1093,7 @@ class Integration {
         app.use(extractCredentials);
         app.use(extractSecrets);
         app.use(extractFilters);
+        app.use(extractSearch);
         app.use(extractSelects);
         app.use(extractRelations);
         app.use(extractOperationDeadline);
@@ -1393,11 +1406,11 @@ class Provider {
                 // When we expect octet-stream, we accept any Content-Type the provider sends us, we just want to stream it
                 body = response.body;
             }
-            else if (headers.Accept === 'application/json') {
+            else if (headers.Accept?.match(/application\/.*json/)) {
                 // Validate that the response content type is at least similar to what we expect
                 // (Provider's response Content-Type might be more specific, e.g. application/json;charset=utf-8)
                 // Default to application/json if no Content-Type header is provided
-                if (responseContentType && !responseContentType.includes('application/json')) {
+                if (responseContentType && !responseContentType.match(/application\/.*json/)) {
                     const textResult = await response.text();
                     throw this.handleError(500, `Unsupported content-type, expected 'application/json' but got '${responseContentType}'.
              Original response (${response.status}): "${textResult}"`, options);

package/dist/src/integration.js

@@ -10,6 +10,7 @@ import notFoundMiddleware from './middlewares/notFound.js';
 import loggerMiddleware from './middlewares/logger.js';
 import startMiddleware from './middlewares/start.js';
 import secretsMiddleware from './middlewares/secrets.js';
+import searchMiddleware from './middlewares/search.js';
 import selectsMiddleware from './middlewares/selects.js';
 import relationsMiddleware from './middlewares/relations.js';
 import signalMiddleware from './middlewares/signal.js';
@@ -111,7 +112,7 @@ export default class Integration {
         // Express Server initialization
         const app = express();
         // Parse query strings with https://github.com/ljharb/qs.
-        app.set('query parser', 'extended');
+        app.set('query parser', 'simple');
         app.use(express.json());
         // Must be one of the first handlers (to catch all the errors).
         app.use(finishMiddleware);
@@ -131,6 +132,7 @@ export default class Integration {
         app.use(credentialsMiddleware);
         app.use(secretsMiddleware);
         app.use(filtersMiddleware);
+        app.use(searchMiddleware);
         app.use(selectsMiddleware);
         app.use(relationsMiddleware);
         app.use(signalMiddleware);

package/dist/src/middlewares/filters.js

@@ -1,10 +1,10 @@
-import { OperatorType } from '@unito/integration-api';
+import { OperatorTypes } from '@unito/integration-api';
 // The operators are ordered by their symbol length, in descending order.
 // This is necessary because the symbol of an operator can be
 // a subset of the symbol of another operator.
 //
 // For example, the symbol "=" (EQUAL) is a subset of the symbol "!=" (NOT_EQUAL).
-const ORDERED_OPERATORS = Object.values(OperatorType).sort((o1, o2) => o2.length - o1.length);
+const ORDERED_OPERATORS = Object.values(OperatorTypes).sort((o1, o2) => o2.length - o1.length);
 function extractFilters(req, res, next) {
     const rawFilters = req.query.filter;
     res.locals.filters = [];

package/dist/src/middlewares/search.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response, NextFunction } from 'express';
+declare global {
+    namespace Express {
+        interface Locals {
+            search: string | null;
+        }
+    }
+}
+declare function extractSearch(req: Request, res: Response, next: NextFunction): void;
+export default extractSearch;

package/dist/src/middlewares/search.js

@@ -0,0 +1,11 @@
+function extractSearch(req, res, next) {
+    const rawSearch = req.query.search;
+    if (typeof rawSearch === 'string') {
+        res.locals.search = rawSearch;
+    }
+    else {
+        res.locals.search = null;
+    }
+    next();
+}
+export default extractSearch;

package/dist/src/resources/context.d.ts

@@ -90,6 +90,16 @@ export type GetCollectionContext<P extends Maybe<Params> = Empty, Q extends Quer
      * @see {@link Filter}
      */
     filters: Filter[];
+    /**
+     * Parsed search query param yielding a free-text search query.
+     *
+     *  Given a search query param:
+     *  `search=John`
+     *
+     *  Context.search will be:
+     *  'John'
+     */
+    search: string | null;
     /**
      * Parsed select query param yielding a list of fields to select.
      *

package/dist/src/resources/provider.js

@@ -286,11 +286,11 @@ export class Provider {
                 // When we expect octet-stream, we accept any Content-Type the provider sends us, we just want to stream it
                 body = response.body;
             }
-            else if (headers.Accept === 'application/json') {
+            else if (headers.Accept?.match(/application\/.*json/)) {
                 // Validate that the response content type is at least similar to what we expect
                 // (Provider's response Content-Type might be more specific, e.g. application/json;charset=utf-8)
                 // Default to application/json if no Content-Type header is provided
-                if (responseContentType && !responseContentType.includes('application/json')) {
+                if (responseContentType && !responseContentType.match(/application\/.*json/)) {
                     const textResult = await response.text();
                     throw this.handleError(500, `Unsupported content-type, expected 'application/json' but got '${responseContentType}'.
              Original response (${response.status}): "${textResult}"`, options);

package/dist/test/helpers.test.js

@@ -1,4 +1,4 @@
-import { FieldValueType, OperatorType, Semantic } from '@unito/integration-api';
+import { FieldValueTypes, OperatorTypes, Semantics } from '@unito/integration-api';
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import { getApplicableFilters } from '../src/helpers.js';
@@ -7,48 +7,48 @@ describe('Helpers', () => {
         it('returns only filters for defined fields', () => {
             const actual = getApplicableFilters({
                 filters: [
-                    { field: 'status', operator: OperatorType.EQUAL, values: ['active', 'pending'] },
-                    { field: 'email', operator: OperatorType.IS_NOT_NULL, values: [] },
+                    { field: 'status', operator: OperatorTypes.EQUAL, values: ['active', 'pending'] },
+                    { field: 'email', operator: OperatorTypes.IS_NOT_NULL, values: [] },
                 ],
             }, [
                 {
                     name: 'status',
                     label: 'Status',
-                    type: FieldValueType.STRING,
+                    type: FieldValueTypes.STRING,
                 },
             ]);
-            const expected = [{ field: 'status', operator: OperatorType.EQUAL, values: ['active', 'pending'] }];
+            const expected = [{ field: 'status', operator: OperatorTypes.EQUAL, values: ['active', 'pending'] }];
             assert.deepEqual(actual, expected);
         });
         it('translates semantics into field names', () => {
             const actual = getApplicableFilters({
                 filters: [
-                    { field: 'semantic:displayName', operator: OperatorType.START_WITH, values: ['Bob'] },
-                    { field: 'semantic:createdAt', operator: OperatorType.EQUAL, values: ['2021-01-01'] },
+                    { field: 'semantic:displayName', operator: OperatorTypes.START_WITH, values: ['Bob'] },
+                    { field: 'semantic:createdAt', operator: OperatorTypes.EQUAL, values: ['2021-01-01'] },
                 ],
             }, [
                 {
                     name: 'name',
                     label: 'Name',
-                    type: FieldValueType.STRING,
-                    semantic: Semantic.DISPLAY_NAME,
+                    type: FieldValueTypes.STRING,
+                    semantic: Semantics.DISPLAY_NAME,
                 },
             ]);
-            const expected = [{ field: 'name', operator: OperatorType.START_WITH, values: ['Bob'] }];
+            const expected = [{ field: 'name', operator: OperatorTypes.START_WITH, values: ['Bob'] }];
             assert.deepEqual(actual, expected);
         });
         it('gracefully handle garbage', () => {
             const actual = getApplicableFilters({
                 filters: [
-                    { field: '...', operator: OperatorType.EQUAL, values: [] },
-                    { field: ':', operator: OperatorType.EQUAL, values: [] },
-                    { field: '', operator: OperatorType.EQUAL, values: [] },
+                    { field: '...', operator: OperatorTypes.EQUAL, values: [] },
+                    { field: ':', operator: OperatorTypes.EQUAL, values: [] },
+                    { field: '', operator: OperatorTypes.EQUAL, values: [] },
                 ],
             }, [
                 {
                     name: 'status',
                     label: 'Status',
-                    type: FieldValueType.STRING,
+                    type: FieldValueTypes.STRING,
                 },
             ]);
             assert.deepEqual(actual, []);

package/dist/test/middlewares/filters.test.js

@@ -1,10 +1,10 @@
-import { OperatorType } from '@unito/integration-api';
+import { OperatorTypes } from '@unito/integration-api';
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import extractFilters from '../../src/middlewares/filters.js';
 describe('filters middleware', () => {
     it('properly parse operators', () => {
-        Object.values(OperatorType).forEach(operator => {
+        Object.values(OperatorTypes).forEach(operator => {
             const request = {
                 query: { filter: `aKey${operator}value` },
             };
@@ -20,7 +20,7 @@ describe('filters middleware', () => {
         const response = { locals: {} };
         extractFilters(request, response, () => { });
         assert.deepEqual(response.locals, {
-            filters: [{ field: 'aKey', operator: OperatorType.IS_NULL, values: [] }],
+            filters: [{ field: 'aKey', operator: OperatorTypes.IS_NULL, values: [] }],
         });
     });
     it('decodes URI components', () => {
@@ -28,7 +28,7 @@ describe('filters middleware', () => {
         const response = { locals: {} };
         extractFilters(request, response, () => { });
         assert.deepEqual(response.locals, {
-            filters: [{ field: 'status', operator: OperatorType.EQUAL, values: ['foo,bar!!,?baz=!>qux'] }],
+            filters: [{ field: 'status', operator: OperatorTypes.EQUAL, values: ['foo,bar!!,?baz=!>qux'] }],
         });
     });
     it('no data', () => {

package/dist/test/middlewares/search.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/middlewares/search.test.js

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import extractSearch from '../../src/middlewares/search.js';
+describe('search middleware', () => {
+    it('data', () => {
+        const request = { query: { search: 'foo bar spam baz' } };
+        const response = { locals: {} };
+        extractSearch(request, response, () => { });
+        assert.deepEqual(response.locals, {
+            search: 'foo bar spam baz',
+        });
+    });
+    it('no data', () => {
+        const request = { query: {} };
+        const response = { locals: {} };
+        extractSearch(request, response, () => { });
+        assert.deepEqual(response.locals, {
+            search: null,
+        });
+    });
+});

package/dist/test/resources/provider.test.js

@@ -79,6 +79,93 @@ describe('Provider', () => {
         ]);
         assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: '' });
     });
+    it('should accept application/schema+json type response', async (context) => {
+        const response = new Response('{"data": "value"}', {
+            status: 200,
+            headers: { 'Content-Type': 'application/schema+json; charset=UTF-8' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const actualResponse = await provider.get('/endpoint', {
+            credentials: { apiKey: 'apikey#1111' },
+            logger: logger,
+            signal: new AbortController().signal,
+            additionnalheaders: { 'X-Additional-Header': 'value1', Accept: 'application/schema+json; charset=UTF-8' },
+        });
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint',
+            {
+                method: 'GET',
+                body: null,
+                signal: new AbortController().signal,
+                headers: {
+                    Accept: 'application/schema+json; charset=UTF-8',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+    });
+    it('should accept application/swagger+json type response', async (context) => {
+        const response = new Response('{"data": "value"}', {
+            status: 200,
+            headers: { 'Content-Type': 'application/swagger+json; charset=UTF-8' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const actualResponse = await provider.get('/endpoint', {
+            credentials: { apiKey: 'apikey#1111' },
+            logger: logger,
+            signal: new AbortController().signal,
+            additionnalheaders: { 'X-Additional-Header': 'value1', Accept: 'application/swagger+json; charset=UTF-8' },
+        });
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint',
+            {
+                method: 'GET',
+                body: null,
+                signal: new AbortController().signal,
+                headers: {
+                    Accept: 'application/swagger+json; charset=UTF-8',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+    });
+    it('should accept application/vnd.oracle.resource+json type response', async (context) => {
+        const response = new Response('{"data": "value"}', {
+            status: 200,
+            headers: { 'Content-Type': 'application/vnd.oracle.resource+json; type=collection; charset=UTF-8' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const actualResponse = await provider.get('/endpoint', {
+            credentials: { apiKey: 'apikey#1111' },
+            logger: logger,
+            signal: new AbortController().signal,
+            additionnalheaders: { 'X-Additional-Header': 'value1' },
+        });
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint',
+            {
+                method: 'GET',
+                body: null,
+                signal: new AbortController().signal,
+                headers: {
+                    Accept: 'application/json',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+    });
     it('should return the raw response body if specified', async (context) => {
         const response = new Response(`IMAGINE A HUGE PAYLOAD`, {
             status: 200,

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": "./dist/src/index.js",
-      "require": "./dist/src/index.cjs"
+      "import": {
+        "types": "./dist/src/index.d.ts",
+        "default": "./dist/src/index.js"
+      },
+      "require": {
+        "types": "./dist/src/index.d.ts",
+        "default": "./dist/src/index.cjs"
+      }
     }
   },
   "license": "LicenseRef-LICENSE",
@@ -46,7 +52,7 @@
     "typescript": "5.x"
   },
   "dependencies": {
-    "@unito/integration-api": "1.x",
+    "@unito/integration-api": "4.x",
     "busboy": "^1.6.0",
     "cachette": "2.x",
     "express": "^5.x",

package/src/handler.ts

@@ -297,6 +297,7 @@ export class Handler {
         const collection = await handler({
           credentials: res.locals.credentials,
           secrets: res.locals.secrets,
+          search: res.locals.search,
           selects: res.locals.selects,
           filters: res.locals.filters,
           logger: res.locals.logger,

package/src/integration.ts

@@ -12,6 +12,7 @@ import notFoundMiddleware from './middlewares/notFound.js';
 import loggerMiddleware from './middlewares/logger.js';
 import startMiddleware from './middlewares/start.js';
 import secretsMiddleware from './middlewares/secrets.js';
+import searchMiddleware from './middlewares/search.js';
 import selectsMiddleware from './middlewares/selects.js';
 import relationsMiddleware from './middlewares/relations.js';
 import signalMiddleware from './middlewares/signal.js';
@@ -124,7 +125,7 @@ export default class Integration {
     const app: express.Application = express();
 
     // Parse query strings with https://github.com/ljharb/qs.
-    app.set('query parser', 'extended');
+    app.set('query parser', 'simple');
 
     app.use(express.json());
 
@@ -149,6 +150,7 @@ export default class Integration {
     app.use(credentialsMiddleware);
     app.use(secretsMiddleware);
     app.use(filtersMiddleware);
+    app.use(searchMiddleware);
     app.use(selectsMiddleware);
     app.use(relationsMiddleware);
     app.use(signalMiddleware);

package/src/middlewares/filters.ts

@@ -1,4 +1,4 @@
-import { OperatorType } from '@unito/integration-api';
+import { OperatorType, OperatorTypes } from '@unito/integration-api';
 import { Request, Response, NextFunction } from 'express';
 
 declare global {
@@ -32,7 +32,7 @@ export type Filter = {
 // a subset of the symbol of another operator.
 //
 // For example, the symbol "=" (EQUAL) is a subset of the symbol "!=" (NOT_EQUAL).
-const ORDERED_OPERATORS = Object.values(OperatorType).sort((o1, o2) => o2.length - o1.length);
+const ORDERED_OPERATORS = Object.values(OperatorTypes).sort((o1, o2) => o2.length - o1.length);
 
 function extractFilters(req: Request, res: Response, next: NextFunction) {
   const rawFilters = req.query.filter;

package/src/middlewares/search.ts

@@ -0,0 +1,31 @@
+import { Request, Response, NextFunction } from 'express';
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace Express {
+    interface Locals {
+      // When the query params contains...
+      //
+      //   search=foo
+      //
+      // ... it becomes available as follow in handlers:
+      //
+      //   'foo'
+      search: string | null;
+    }
+  }
+}
+
+function extractSearch(req: Request, res: Response, next: NextFunction) {
+  const rawSearch = req.query.search;
+
+  if (typeof rawSearch === 'string') {
+    res.locals.search = rawSearch;
+  } else {
+    res.locals.search = null;
+  }
+
+  next();
+}
+
+export default extractSearch;

package/src/resources/context.ts

@@ -96,6 +96,16 @@ export type GetCollectionContext<P extends Maybe<Params> = Empty, Q extends Quer
    * @see {@link Filter}
    */
   filters: Filter[];
+  /**
+   * Parsed search query param yielding a free-text search query.
+   *
+   *  Given a search query param:
+   *  `search=John`
+   *
+   *  Context.search will be:
+   *  'John'
+   */
+  search: string | null;
   /**
    * Parsed select query param yielding a list of fields to select.
    *

package/src/resources/provider.ts

@@ -402,11 +402,11 @@ export class Provider {
       if (options.rawBody || headers.Accept === 'application/octet-stream') {
         // When we expect octet-stream, we accept any Content-Type the provider sends us, we just want to stream it
         body = response.body as T;
-      } else if (headers.Accept === 'application/json') {
+      } else if (headers.Accept?.match(/application\/.*json/)) {
         // Validate that the response content type is at least similar to what we expect
         // (Provider's response Content-Type might be more specific, e.g. application/json;charset=utf-8)
         // Default to application/json if no Content-Type header is provided
-        if (responseContentType && !responseContentType.includes('application/json')) {
+        if (responseContentType && !responseContentType.match(/application\/.*json/)) {
           const textResult = await response.text();
           throw this.handleError(
             500,

package/test/helpers.test.ts

@@ -1,4 +1,4 @@
-import { FieldValueType, OperatorType, Semantic } from '@unito/integration-api';
+import { FieldValueTypes, OperatorTypes, Semantics } from '@unito/integration-api';
 
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
@@ -10,20 +10,20 @@ describe('Helpers', () => {
       const actual = getApplicableFilters(
         {
           filters: [
-            { field: 'status', operator: OperatorType.EQUAL, values: ['active', 'pending'] },
-            { field: 'email', operator: OperatorType.IS_NOT_NULL, values: [] },
+            { field: 'status', operator: OperatorTypes.EQUAL, values: ['active', 'pending'] },
+            { field: 'email', operator: OperatorTypes.IS_NOT_NULL, values: [] },
           ],
         },
         [
           {
             name: 'status',
             label: 'Status',
-            type: FieldValueType.STRING,
+            type: FieldValueTypes.STRING,
           },
         ],
       );
 
-      const expected = [{ field: 'status', operator: OperatorType.EQUAL, values: ['active', 'pending'] }];
+      const expected = [{ field: 'status', operator: OperatorTypes.EQUAL, values: ['active', 'pending'] }];
 
       assert.deepEqual(actual, expected);
     });
@@ -32,21 +32,21 @@ describe('Helpers', () => {
       const actual = getApplicableFilters(
         {
           filters: [
-            { field: 'semantic:displayName', operator: OperatorType.START_WITH, values: ['Bob'] },
-            { field: 'semantic:createdAt', operator: OperatorType.EQUAL, values: ['2021-01-01'] },
+            { field: 'semantic:displayName', operator: OperatorTypes.START_WITH, values: ['Bob'] },
+            { field: 'semantic:createdAt', operator: OperatorTypes.EQUAL, values: ['2021-01-01'] },
           ],
         },
         [
           {
             name: 'name',
             label: 'Name',
-            type: FieldValueType.STRING,
-            semantic: Semantic.DISPLAY_NAME,
+            type: FieldValueTypes.STRING,
+            semantic: Semantics.DISPLAY_NAME,
           },
         ],
       );
 
-      const expected = [{ field: 'name', operator: OperatorType.START_WITH, values: ['Bob'] }];
+      const expected = [{ field: 'name', operator: OperatorTypes.START_WITH, values: ['Bob'] }];
 
       assert.deepEqual(actual, expected);
     });
@@ -55,16 +55,16 @@ describe('Helpers', () => {
       const actual = getApplicableFilters(
         {
           filters: [
-            { field: '...', operator: OperatorType.EQUAL, values: [] },
-            { field: ':', operator: OperatorType.EQUAL, values: [] },
-            { field: '', operator: OperatorType.EQUAL, values: [] },
+            { field: '...', operator: OperatorTypes.EQUAL, values: [] },
+            { field: ':', operator: OperatorTypes.EQUAL, values: [] },
+            { field: '', operator: OperatorTypes.EQUAL, values: [] },
           ],
         },
         [
           {
             name: 'status',
             label: 'Status',
-            type: FieldValueType.STRING,
+            type: FieldValueTypes.STRING,
           },
         ],
       );

package/test/middlewares/filters.test.ts

@@ -1,4 +1,4 @@
-import { OperatorType } from '@unito/integration-api';
+import { OperatorTypes } from '@unito/integration-api';
 import express from 'express';
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
@@ -6,7 +6,7 @@ import extractFilters from '../../src/middlewares/filters.js';
 
 describe('filters middleware', () => {
   it('properly parse operators', () => {
-    Object.values(OperatorType).forEach(operator => {
+    Object.values(OperatorTypes).forEach(operator => {
       const request = {
         query: { filter: `aKey${operator}value` },
       } as express.Request<
@@ -41,7 +41,7 @@ describe('filters middleware', () => {
     extractFilters(request, response, () => {});
 
     assert.deepEqual(response.locals, {
-      filters: [{ field: 'aKey', operator: OperatorType.IS_NULL, values: [] }],
+      filters: [{ field: 'aKey', operator: OperatorTypes.IS_NULL, values: [] }],
     });
   });
 
@@ -58,7 +58,7 @@ describe('filters middleware', () => {
     extractFilters(request, response, () => {});
 
     assert.deepEqual(response.locals, {
-      filters: [{ field: 'status', operator: OperatorType.EQUAL, values: ['foo,bar!!,?baz=!>qux'] }],
+      filters: [{ field: 'status', operator: OperatorTypes.EQUAL, values: ['foo,bar!!,?baz=!>qux'] }],
     });
   });
 

package/test/middlewares/search.test.ts

@@ -0,0 +1,34 @@
+import express from 'express';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import extractSearch from '../../src/middlewares/search.js';
+
+describe('search middleware', () => {
+  it('data', () => {
+    const request = { query: { search: 'foo bar spam baz' } } as express.Request<
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      any,
+      object,
+      object,
+      { search: string }
+    >;
+    const response = { locals: {} } as express.Response;
+
+    extractSearch(request, response, () => {});
+
+    assert.deepEqual(response.locals, {
+      search: 'foo bar spam baz',
+    });
+  });
+
+  it('no data', () => {
+    const request = { query: {} } as express.Request;
+    const response = { locals: {} } as express.Response;
+
+    extractSearch(request, response, () => {});
+
+    assert.deepEqual(response.locals, {
+      search: null,
+    });
+  });
+});

package/test/resources/provider.test.ts

@@ -94,6 +94,111 @@ describe('Provider', () => {
     assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: '' });
   });
 
+  it('should accept application/schema+json type response', async context => {
+    const response = new Response('{"data": "value"}', {
+      status: 200,
+      headers: { 'Content-Type': 'application/schema+json; charset=UTF-8' },
+    });
+
+    const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+
+    const actualResponse = await provider.get('/endpoint', {
+      credentials: { apiKey: 'apikey#1111' },
+      logger: logger,
+      signal: new AbortController().signal,
+      additionnalheaders: { 'X-Additional-Header': 'value1', Accept: 'application/schema+json; charset=UTF-8' },
+    });
+
+    assert.equal(fetchMock.mock.calls.length, 1);
+
+    assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+      'www.myApi.com/endpoint',
+      {
+        method: 'GET',
+        body: null,
+        signal: new AbortController().signal,
+        headers: {
+          Accept: 'application/schema+json; charset=UTF-8',
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': 'apikey#1111',
+          'X-Additional-Header': 'value1',
+        },
+      },
+    ]);
+
+    assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+  });
+
+  it('should accept application/swagger+json type response', async context => {
+    const response = new Response('{"data": "value"}', {
+      status: 200,
+      headers: { 'Content-Type': 'application/swagger+json; charset=UTF-8' },
+    });
+
+    const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+
+    const actualResponse = await provider.get('/endpoint', {
+      credentials: { apiKey: 'apikey#1111' },
+      logger: logger,
+      signal: new AbortController().signal,
+      additionnalheaders: { 'X-Additional-Header': 'value1', Accept: 'application/swagger+json; charset=UTF-8' },
+    });
+
+    assert.equal(fetchMock.mock.calls.length, 1);
+
+    assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+      'www.myApi.com/endpoint',
+      {
+        method: 'GET',
+        body: null,
+        signal: new AbortController().signal,
+        headers: {
+          Accept: 'application/swagger+json; charset=UTF-8',
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': 'apikey#1111',
+          'X-Additional-Header': 'value1',
+        },
+      },
+    ]);
+
+    assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+  });
+
+  it('should accept application/vnd.oracle.resource+json type response', async context => {
+    const response = new Response('{"data": "value"}', {
+      status: 200,
+      headers: { 'Content-Type': 'application/vnd.oracle.resource+json; type=collection; charset=UTF-8' },
+    });
+
+    const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+
+    const actualResponse = await provider.get('/endpoint', {
+      credentials: { apiKey: 'apikey#1111' },
+      logger: logger,
+      signal: new AbortController().signal,
+      additionnalheaders: { 'X-Additional-Header': 'value1' },
+    });
+
+    assert.equal(fetchMock.mock.calls.length, 1);
+
+    assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+      'www.myApi.com/endpoint',
+      {
+        method: 'GET',
+        body: null,
+        signal: new AbortController().signal,
+        headers: {
+          Accept: 'application/json',
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': 'apikey#1111',
+          'X-Additional-Header': 'value1',
+        },
+      },
+    ]);
+
+    assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+  });
+
   it('should return the raw response body if specified', async context => {
     const response = new Response(`IMAGINE A HUGE PAYLOAD`, {
       status: 200,