@unito/integration-sdk 0.1.1 → 0.1.3

package/README.md

@@ -6,7 +6,7 @@ This SDK can be used to produce integrations that are compliant with the Integra
 ## Getting started
 
 ```sh
-npm install --save @unitoio/integration-sdk
+npm install --save @unito/integration-sdk
 ```
 
 ## Terms and Conditions

package/dist/src/handler.js

@@ -9,6 +9,17 @@ function assertValidPath(path) {
         throw new InvalidHandler(`The provided path '${path}' is invalid. Paths must not end with a '/'.`);
     }
 }
+function assertValidConfiguration(path, pathWithIdentifier, handlers) {
+    if (path === pathWithIdentifier) {
+        const individualHandlers = ['getItem', 'updateItem', 'deleteItem'];
+        const collectionHandlers = ['getCollection', 'createItem'];
+        const hasIndividualHandlers = individualHandlers.some(handler => handler in handlers);
+        const hasCollectionHandlers = collectionHandlers.some(handler => handler in handlers);
+        if (hasIndividualHandlers && hasCollectionHandlers) {
+            throw new InvalidHandler(`The provided path '${path}' doesn't differentiate between individual and collection level operation, so you cannot define both. `);
+        }
+    }
+}
 function parsePath(path) {
     const pathParts = path.split('/');
     const lastPart = pathParts.at(-1);
@@ -60,9 +71,9 @@ export class Handler {
     pathWithIdentifier;
     handlers;
     constructor(inputPath, handlers) {
-        // Build paths.
         assertValidPath(inputPath);
         const { pathWithIdentifier, path } = parsePath(inputPath);
+        assertValidConfiguration(path, pathWithIdentifier, handlers);
         this.pathWithIdentifier = pathWithIdentifier;
         this.path = path;
         this.handlers = handlers;

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

@@ -28,7 +28,7 @@ export interface RequestOptions {
     };
 }
 export interface Response<T> {
-    data: T | undefined;
+    data: T;
     status: number;
     headers: Headers;
 }
@@ -54,6 +54,6 @@ export declare class Provider {
     post<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
     put<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
     patch<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
-    delete<T>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
+    delete<T = undefined>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
     private fetchWrapper;
 }

package/dist/test/handler.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { afterEach, beforeEach, describe, it, mock } from 'node:test';
-import { Handler } from '../src/handler.js';
+import { Handler, } from '../src/handler.js';
 import { BadRequestError } from '../src/httpErrors.js';
 describe('Handler', () => {
     beforeEach(() => {
@@ -36,6 +36,30 @@ describe('Handler', () => {
                 }
             }
         });
+        it('validates configuration', () => {
+            const getItem = (() => { });
+            const updateItem = (() => { });
+            const deleteItem = (() => { });
+            const getCollection = (() => { });
+            const createItem = (() => { });
+            const paths = [
+                ['/foo', { getItem }, true],
+                ['/foo', { getCollection }, true],
+                ['/foo', { getItem, getCollection }, false],
+                ['/foo', { updateItem, createItem }, false],
+                ['/foo', { deleteItem, createItem }, false],
+                ['/foo/:bar', { getItem, getCollection }, true],
+                ['/foo/:bar', { getItem, updateItem, deleteItem, createItem, getCollection }, true],
+            ];
+            for (const [path, handlers, valid] of paths) {
+                if (valid) {
+                    assert.doesNotThrow(() => new Handler(path, handlers));
+                }
+                else {
+                    assert.throws(() => new Handler(path, handlers));
+                }
+            }
+        });
     });
     describe('generate', () => {
         async function executeHandler(handler, request = {}) {

package/package.json

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

package/src/handler.ts

@@ -118,6 +118,22 @@ function assertValidPath(path: string): asserts path is Path {
   }
 }
 
+function assertValidConfiguration(path: Path, pathWithIdentifier: Path, handlers: Handlers) {
+  if (path === pathWithIdentifier) {
+    const individualHandlers = ['getItem', 'updateItem', 'deleteItem'];
+    const collectionHandlers = ['getCollection', 'createItem'];
+
+    const hasIndividualHandlers = individualHandlers.some(handler => handler in handlers);
+    const hasCollectionHandlers = collectionHandlers.some(handler => handler in handlers);
+
+    if (hasIndividualHandlers && hasCollectionHandlers) {
+      throw new InvalidHandler(
+        `The provided path '${path}' doesn't differentiate between individual and collection level operation, so you cannot define both. `,
+      );
+    }
+  }
+}
+
 function parsePath(path: Path) {
   const pathParts = path.split('/');
 
@@ -185,11 +201,12 @@ export class Handler {
   private handlers: Handlers;
 
   constructor(inputPath: string, handlers: HandlersInput) {
-    // Build paths.
     assertValidPath(inputPath);
 
     const { pathWithIdentifier, path } = parsePath(inputPath);
 
+    assertValidConfiguration(path, pathWithIdentifier, handlers);
+
     this.pathWithIdentifier = pathWithIdentifier;
     this.path = path;
 

package/src/resources/provider.ts

@@ -29,7 +29,7 @@ export interface RequestOptions {
 }
 
 export interface Response<T> {
-  data: T | undefined;
+  data: T;
   status: number;
   headers: Headers;
 }
@@ -100,7 +100,7 @@ export class Provider {
     });
   }
 
-  public async delete<T>(endpoint: string, options: RequestOptions): Promise<Response<T>> {
+  public async delete<T = undefined>(endpoint: string, options: RequestOptions): Promise<Response<T>> {
     return this.fetchWrapper<T>(endpoint, null, {
       ...options,
       method: 'DELETE',
@@ -149,8 +149,7 @@ export class Provider {
       }
 
       try {
-        const data: T | undefined = response.body ? await response.json() : undefined;
-
+        const data: T = response.body ? await response.json() : undefined;
         return { status: response.status, headers: response.headers, data };
       } catch {
         throw buildHttpError(400, 'Invalid JSON response');

package/test/handler.test.ts

@@ -1,7 +1,15 @@
 import { Request, Response } from 'express';
 import assert from 'node:assert/strict';
 import { afterEach, beforeEach, describe, it, mock } from 'node:test';
-import { Handler } from '../src/handler.js';
+import {
+  Handler,
+  HandlersInput,
+  GetItemHandler,
+  GetCollectionHandler,
+  UpdateItemHandler,
+  DeleteItemHandler,
+  CreateItemHandler,
+} from '../src/handler.js';
 import { BadRequestError } from '../src/httpErrors.js';
 
 describe('Handler', () => {
@@ -42,6 +50,32 @@ describe('Handler', () => {
         }
       }
     });
+
+    it('validates configuration', () => {
+      const getItem = (() => {}) as unknown as GetItemHandler;
+      const updateItem = (() => {}) as unknown as UpdateItemHandler;
+      const deleteItem = (() => {}) as unknown as DeleteItemHandler;
+      const getCollection = (() => {}) as unknown as GetCollectionHandler;
+      const createItem = (() => {}) as unknown as CreateItemHandler;
+
+      const paths: [string, HandlersInput, boolean][] = [
+        ['/foo', { getItem }, true],
+        ['/foo', { getCollection }, true],
+        ['/foo', { getItem, getCollection }, false],
+        ['/foo', { updateItem, createItem }, false],
+        ['/foo', { deleteItem, createItem }, false],
+        ['/foo/:bar', { getItem, getCollection }, true],
+        ['/foo/:bar', { getItem, updateItem, deleteItem, createItem, getCollection }, true],
+      ];
+
+      for (const [path, handlers, valid] of paths) {
+        if (valid) {
+          assert.doesNotThrow(() => new Handler(path, handlers));
+        } else {
+          assert.throws(() => new Handler(path, handlers));
+        }
+      }
+    });
   });
 
   describe('generate', () => {