@unito/integration-sdk 1.0.4 → 1.0.5

package/dist/src/helpers.d.ts

@@ -0,0 +1,15 @@
+import { FieldSchema } from '@unito/integration-api';
+import { Filter } from './index.js';
+/**
+ * Use this helper function to retrieve the applicable filters from the context object. While using filters
+ * directly from context might work, it doesn't offer any guarantees about the shape of the filters nor the
+ * validity of the fields against which the filters are applied. On the other hand, this function ensures that
+ * all filters are valid and that the fields against which the filters are applied are present in the schema.
+ *
+ * @param context The object containing the raw filters
+ * @param fields The schema of the item against which the filters are applied
+ * @returns The validated filters
+ */
+export declare const getApplicableFilters: (context: {
+    filters: Filter[];
+}, fields: FieldSchema[]) => Filter[];

package/dist/src/helpers.js

@@ -0,0 +1,28 @@
+/**
+ * Use this helper function to retrieve the applicable filters from the context object. While using filters
+ * directly from context might work, it doesn't offer any guarantees about the shape of the filters nor the
+ * validity of the fields against which the filters are applied. On the other hand, this function ensures that
+ * all filters are valid and that the fields against which the filters are applied are present in the schema.
+ *
+ * @param context The object containing the raw filters
+ * @param fields The schema of the item against which the filters are applied
+ * @returns The validated filters
+ */
+export const getApplicableFilters = (context, fields) => {
+    const applicableFilters = [];
+    for (const filter of context.filters) {
+        let field = undefined;
+        const filterFieldParts = filter.field.split(':', 2);
+        switch (filterFieldParts[0]) {
+            case 'semantic':
+                field = fields.find(f => f.semantic === filterFieldParts[1]);
+                break;
+            default:
+                field = fields.find(f => f.name === filterFieldParts[0]);
+        }
+        if (field) {
+            applicableFilters.push({ ...filter, field: field.name });
+        }
+    }
+    return applicableFilters;
+};

package/dist/src/index.cjs

@@ -1115,9 +1115,39 @@ class Provider {
     }
 }
 
+/**
+ * Use this helper function to retrieve the applicable filters from the context object. While using filters
+ * directly from context might work, it doesn't offer any guarantees about the shape of the filters nor the
+ * validity of the fields against which the filters are applied. On the other hand, this function ensures that
+ * all filters are valid and that the fields against which the filters are applied are present in the schema.
+ *
+ * @param context The object containing the raw filters
+ * @param fields The schema of the item against which the filters are applied
+ * @returns The validated filters
+ */
+const getApplicableFilters = (context, fields) => {
+    const applicableFilters = [];
+    for (const filter of context.filters) {
+        let field = undefined;
+        const filterFieldParts = filter.field.split(':', 2);
+        switch (filterFieldParts[0]) {
+            case 'semantic':
+                field = fields.find(f => f.semantic === filterFieldParts[1]);
+                break;
+            default:
+                field = fields.find(f => f.name === filterFieldParts[0]);
+        }
+        if (field) {
+            applicableFilters.push({ ...filter, field: field.name });
+        }
+    }
+    return applicableFilters;
+};
+
 exports.Api = integrationApi__namespace;
 exports.Cache = Cache;
 exports.Handler = Handler;
 exports.HttpErrors = httpErrors;
 exports.Integration = Integration;
 exports.Provider = Provider;
+exports.getApplicableFilters = getApplicableFilters;

package/dist/src/index.d.ts

@@ -5,6 +5,8 @@ export * from './handler.js';
 export { Provider, type Response as ProviderResponse, type RequestOptions as ProviderRequestOptions, type RateLimiter, } from './resources/provider.js';
 export type { Secrets } from './middlewares/secrets.js';
 export type { Credentials } from './middlewares/credentials.js';
+export type { Filter } from './middlewares/filters.js';
 export * as HttpErrors from './httpErrors.js';
+export { getApplicableFilters } from './helpers.js';
 export * from './resources/context.js';
 export { type default as Logger } from './resources/logger.js';

package/dist/src/index.js

@@ -5,5 +5,6 @@ export { default as Integration } from './integration.js';
 export * from './handler.js';
 export { Provider, } from './resources/provider.js';
 export * as HttpErrors from './httpErrors.js';
+export { getApplicableFilters } from './helpers.js';
 export * from './resources/context.js';
 /* c8 ignore stop */

package/dist/test/helpers.test.d.ts

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

package/dist/test/helpers.test.js

@@ -0,0 +1,57 @@
+import { FieldValueType, OperatorType, Semantic } from '@unito/integration-api';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { getApplicableFilters } from '../src/helpers.js';
+describe('Helpers', () => {
+    describe('getApplicableFilters', () => {
+        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: [] },
+                ],
+            }, [
+                {
+                    name: 'status',
+                    label: 'Status',
+                    type: FieldValueType.STRING,
+                },
+            ]);
+            const expected = [{ field: 'status', operator: OperatorType.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'] },
+                ],
+            }, [
+                {
+                    name: 'name',
+                    label: 'Name',
+                    type: FieldValueType.STRING,
+                    semantic: Semantic.DISPLAY_NAME,
+                },
+            ]);
+            const expected = [{ field: 'name', operator: OperatorType.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: [] },
+                ],
+            }, [
+                {
+                    name: 'status',
+                    label: 'Status',
+                    type: FieldValueType.STRING,
+                },
+            ]);
+            assert.deepEqual(actual, []);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/helpers.ts

@@ -0,0 +1,37 @@
+import { FieldSchema } from '@unito/integration-api';
+
+import { Filter } from './index.js';
+
+/**
+ * Use this helper function to retrieve the applicable filters from the context object. While using filters
+ * directly from context might work, it doesn't offer any guarantees about the shape of the filters nor the
+ * validity of the fields against which the filters are applied. On the other hand, this function ensures that
+ * all filters are valid and that the fields against which the filters are applied are present in the schema.
+ *
+ * @param context The object containing the raw filters
+ * @param fields The schema of the item against which the filters are applied
+ * @returns The validated filters
+ */
+export const getApplicableFilters = (context: { filters: Filter[] }, fields: FieldSchema[]): Filter[] => {
+  const applicableFilters: Filter[] = [];
+
+  for (const filter of context.filters) {
+    let field: FieldSchema | undefined = undefined;
+
+    const filterFieldParts = filter.field.split(':', 2);
+
+    switch (filterFieldParts[0]) {
+      case 'semantic':
+        field = fields.find(f => f.semantic === filterFieldParts[1]);
+        break;
+      default:
+        field = fields.find(f => f.name === filterFieldParts[0]);
+    }
+
+    if (field) {
+      applicableFilters.push({ ...filter, field: field.name });
+    }
+  }
+
+  return applicableFilters;
+};

package/src/index.ts

@@ -11,7 +11,9 @@ export {
 } from './resources/provider.js';
 export type { Secrets } from './middlewares/secrets.js';
 export type { Credentials } from './middlewares/credentials.js';
+export type { Filter } from './middlewares/filters.js';
 export * as HttpErrors from './httpErrors.js';
+export { getApplicableFilters } from './helpers.js';
 export * from './resources/context.js';
 export { type default as Logger } from './resources/logger.js';
 /* c8 ignore stop */

package/test/helpers.test.ts

@@ -0,0 +1,75 @@
+import { FieldValueType, OperatorType, Semantic } from '@unito/integration-api';
+
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { getApplicableFilters } from '../src/helpers.js';
+
+describe('Helpers', () => {
+  describe('getApplicableFilters', () => {
+    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: [] },
+          ],
+        },
+        [
+          {
+            name: 'status',
+            label: 'Status',
+            type: FieldValueType.STRING,
+          },
+        ],
+      );
+
+      const expected = [{ field: 'status', operator: OperatorType.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'] },
+          ],
+        },
+        [
+          {
+            name: 'name',
+            label: 'Name',
+            type: FieldValueType.STRING,
+            semantic: Semantic.DISPLAY_NAME,
+          },
+        ],
+      );
+
+      const expected = [{ field: 'name', operator: OperatorType.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: [] },
+          ],
+        },
+        [
+          {
+            name: 'status',
+            label: 'Status',
+            type: FieldValueType.STRING,
+          },
+        ],
+      );
+
+      assert.deepEqual(actual, []);
+    });
+  });
+});