@unito/integration-sdk 1.8.5 → 2.0.1

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') {
@@ -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);

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';
@@ -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/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/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "1.8.5",
+  "version": "2.0.1",
   "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": "3.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';
@@ -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/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,
+    });
+  });
+});