@trayio/cdk-dsl 1.12.0 → 1.13.0

package/README.md

@@ -9,7 +9,6 @@ to execute a connector's operations.
 
 The [Tray.io Developer Portal](https://developer.tray.io) has the most up to date documentation including a [quick start guide](https://developer.tray.io/developer-portal/cdk/quickstart/) for building connectors with the CDK
 
-
 ## Project Structure
 
 A CDK project is just a regular npm typescript project, preconfigured with all the dependencies, linter rules and compiler options that will be used to build the connector during deployment, so it is not recommended to change those.
@@ -18,10 +17,10 @@ Other than the package.json, jest configuration and typescript configuration, a
 
 - A `connector.json` file that includes metadata about the connector, such as the name, version, title, etc
 - A `src` directory that has:
-    - An Authentication typescript file that contains the type of the `auth` property of the `ctx` context object that operations receive together with the input, this type is the same for all operation
-    - A `test.ctx.json` json file that contains a context value (including the auth) that can be used for tests.
+  - An Authentication typescript file that contains the type of the `auth` property of the `ctx` context object that operations receive together with the input, this type is the same for all operation
+  - A `test.ctx.json` json file that contains a context value (including the auth) that can be used for tests.
     **This file should not be committed to a repository as it will have sensitive information such as access tokens**
-    - One folder per operation
+  - One folder per operation
 
 ## Context and Authentication
 
@@ -50,7 +49,8 @@ This "successful value or failure error" result of running an operation is descr
 So, the core of what an operation handler describes can be summarised as a function:
 
 ```typescript
-(ctx: OperationHandlerContext<AuthType>, input: InputType) => OperationHandlerResult<OutputType>
+(ctx: OperationHandlerContext<AuthType>, input: InputType) =>
+	OperationHandlerResult<OutputType>;
 ```
 
 However, when defining a handler, we can also specify things like validation or whether or not the handler is private, and this is where the DSL comes in.
@@ -60,7 +60,7 @@ The `handler.ts` file needs to define a handler using the `OperationHandlerSetup
 The `OperationHandlerSetup.configureHandler()` function takes a callback that is used to configure the handler, it looks like this:
 
 ```typescript
-export const myOperationHandler = 
+export const myOperationHandler =
     OperationHandlerSetup.configureHandler<AuthType, InputType, OutputType>((handler) =>
         /* use the "handler" value to specify what implementation to use, validation, etc */
     );
@@ -73,17 +73,25 @@ Handlers can have input validation (which runs before the handler implementation
 To add validation just use the `handler` argument of the callback described in the previous section:
 
 ```typescript
-export const myOperationHandler = 
-    OperationHandlerSetup.configureHandler<AuthType, InputType, OutputType>((handler) =>
-        handler.addInputValidation((validation => 
-                    validation.condition((ctx, input) => input.id > 0)
-                              .errorMessage((ctx, input) => `Id ${input.id} is not positive`))
-                )
-                .addOutputValidation((validation => 
-                    validation.condition((ctx, input, output) => output.id === input.id)
-                              .errorMessage((ctx, input, output) => `Output and Input ids don't match`))
-                )
-    );
+export const myOperationHandler = OperationHandlerSetup.configureHandler<
+	AuthType,
+	InputType,
+	OutputType
+>((handler) =>
+	handler
+		.addInputValidation((validation) =>
+			validation
+				.condition((ctx, input) => input.id > 0)
+				.errorMessage((ctx, input) => `Id ${input.id} is not positive`)
+		)
+		.addOutputValidation((validation) =>
+			validation
+				.condition((ctx, input, output) => output.id === input.id)
+				.errorMessage(
+					(ctx, input, output) => `Output and Input ids don't match`
+				)
+		)
+);
 ```
 
 Note that validation is optional, the only thing that is necessary to define a handler is its implementation.
@@ -99,7 +107,7 @@ A handler can only have one implementation, it describes what the handler does w
 A very simple handler that makes an HTTP call can be configured in the following way:
 
 ```typescript
-export const myOperationHandler = 
+export const myOperationHandler =
     OperationHandlerSetup.configureHandler<AuthType, InputType, OutputType>((handler) =>
         handler.addInputValidation(...)
                .addOutputValidation(...)
@@ -120,12 +128,12 @@ The previous handler makes a `GET` http request, which is defined by the `http.g
 - `withBearerToken(token)`: Adds an `Authorization` header with a `Bearer` token
 - `addQueryString(name, value)`: Adds a query string to the request, the value will be url encoded
 - `withBodyAsJson(body)`: Adds a body to the request that will be sent as json.
-
+- `withBodyAsText(body)`: Adds a body to the request that will be sent as a plain text.
 
 A handler with an authenticated POST request would look like this:
 
 ```typescript
-export const myOperationHandler = 
+export const myOperationHandler =
     OperationHandlerSetup.configureHandler<AuthType, InputType, OutputType>((handler) =>
         handler.addInputValidation(...)
                .addOutputValidation(...)
@@ -143,26 +151,26 @@ export const myOperationHandler =
 The input does not have to match what is sent as the body, if for example the input has other flags that specify how the connector needs to behave and only part of it contains the body, the `withBodyAsJson` method can be called in the following way:
 
 ```typescript
-    request.withBodyAsJson({name: input.name, title: input.title})
+request.withBodyAsJson({ name: input.name, title: input.title });
 ```
 
 So the `handlerRequest` function can transform the input in any way it needs to before sending the HTTP request and the same is true for the `handleResponse`, in the previous examples, the `handleResponse` simply read the response body as json and returned it, but it can be more complex if necessary.
 
-The `parseWithBodyAsJson<T>()` function on the `response` argument returns a value of type `OperationHandlerResult<T>`, which can be a successful response or a failure based on the status code or if something went wrong executing the call.
+The `parseWithBodyAsJson<T>() and parseWithBodyAsText()` functions on the `response` argument returns a value of type `OperationHandlerResult<T>`, which can be a successful response or a failure based on the status code or if something went wrong executing the call.
 
 Just like with the input type and the request, the type of the json body in the response can be different from the output type.
 
 This is an example of a handler that transforms the response body into the output type:
 
 ```typescript
-export const myOperationHandler = 
+export const myOperationHandler =
     OperationHandlerSetup.configureHandler<AuthType, InputType, OutputType>((handler) =>
         handler.addInputValidation(...)
                .addOutputValidation(...)
                .usingHttp((http) =>
                     http.post('https://someapi.com/someresource')
                         .handleRequest(...)
-                        .handleResponse((response) => { 
+                        .handleResponse((response) => {
                             const httpResponseBody = response.parseWithBodyAsJson<{message: string}>()
                             if (httpResponseBody.isSuccess) {
                                 const originalMessage = httpResponseBody.value.message
@@ -180,14 +188,14 @@ Instead of using an `if` in the previous case, there is also a `OperationHandler
 The handler can also return successful responses for some failure cases or viceversa, this is an example of a handler that "recovers" from errors to always return a successful response:
 
 ```typescript
-export const myOperationHandler = 
+export const myOperationHandler =
     OperationHandlerSetup.configureHandler<AuthType, InputType, OutputType>((handler) =>
         handler.addInputValidation(...)
                .addOutputValidation(...)
                .usingHttp((http) =>
                     http.post('https://someapi.com/someresource')
                         .handleRequest(...)
-                        .handleResponse((response) => { 
+                        .handleResponse((response) => {
                             const httpResponseBody = response.withBodyAsJson()
                             if (httpResponseBody.isFailure) {
                                 return OperationHandlerResult.success({ completed: false })
@@ -198,7 +206,6 @@ export const myOperationHandler =
     );
 ```
 
-
 ## Composite Implementation
 
 Composite handlers are used to define behaviours by invoking zero or more operations as part of their behaviour.
@@ -209,7 +216,7 @@ like an "upsert" that combines more granular "read, create and update" operation
 A very simple composite handler, that just concatenates the `firstName` and `lastName` arguments it gets from the input into one string:
 
 ```typescript
-export const myOperationHandler = 
+export const myOperationHandler =
     OperationHandlerSetup.configureHandler<AuthType, InputType, OutputType>((handler) =>
         handler.addInputValidation(...)
                .addOutputValidation(...)
@@ -222,11 +229,10 @@ export const myOperationHandler =
 
 As an example of more complex behaviour, this handler reads a list of products using another operation and converts the result into a simple list of text and value pairs, this is known as a Dynamic Data List (DDL) operation used to help users select values as part of configuring workflows within the tray builder.
 
-
 To do this, the handler needs to invoke the regular `getProducts` operation, this is accomplished by using the `invoke` functions that composite handlers have access to, and passing it a **handler reference** and an input (no need to pass the auth value as it will be passed automatically), the handler reference passed to the `invoke` function is the result of the `OperationHandlerSetup.configureHandler()` function, which is why they are saved into a constant and exported like this:
 
 ```typescript
-export const getProductsHandler = 
+export const getProductsHandler =
     OperationHandlerSetup.configureHandler<AuthType, GetProductsInput, GetProductsOutput>((handler) =>
         handler.usingHttp(...)
     );
@@ -237,7 +243,9 @@ The `getProductsHandler` constant contains the handler reference, which also has
 To invoke the handler it is a simple call to the `invoke` function that takes the handler reference as an argument, and returns another function that takes the input type of that handler and returns a `Promise<OperationHandlerResult<T>>` where `T` is the output type of the handler and `OperationHandlerResult` contains a failure response if the call failed or a success response with a value of type `T` if the call was successful:
 
 ```typescript
-const productsResult: OperationHandlerResult<GetProductsOutput> = await invoke(getProductsHandler)({ storeId: input.storeId })
+const productsResult: OperationHandlerResult<GetProductsOutput> = await invoke(
+	getProductsHandler
+)({ storeId: input.storeId });
 ```
 
 The output type of a DDL operation is defined by the `DDLOperationOutput<T>` type, where `T` is the type of the values and can be a string or a number, that type has one field called `results` which is an array of objects of type `{text: string, value: T}`.
@@ -247,46 +255,47 @@ To use it as the output, it is recommended to define a custom type for the opera
 ```typescript
 import { DDLOperationOutput } from '@trayio/cdk-dsl/connector/operation/OperationHandler';
 
-export type GetProductListDdlOutput = DDLOperationOutput<number> //the values of the elements of the DDL are of type number
+export type GetProductListDdlOutput = DDLOperationOutput<number>; //the values of the elements of the DDL are of type number
 ```
 
-
 With that in mind, this is what the DDL handler would look like:
 
-
 ```typescript
-export const getProductsDDLHandler = 
-    OperationHandlerSetup.configureHandler<AuthType, GetProductsDDLInput, GetProductsDDLOutput>((handler) =>
-        handler.usingComposite(async (auth, input, invoke) => {
-                    //invoke the products operation
-                    const productsResult: OperationHandlerResult<GetProductsOutput> = 
-                        await invoke(getProductsHandler)({ storeId: input.storeId })
-
-                    //if the invocation failed, propagate the failure
-                    if (productsResult.isFailure) {
-                        return productsResult
-                    }
-
-                    //productsResult is of type `OperationHandlerSuccess` now, because we handled the failure case above, so we can get the value
-                    const products = productsResult.value
-
-                    //converts a product list into a list of text (label) and values (identifiers) for the DDL
-                    const productsDDL = products.map((product) => {
-                        return {
-                            text: product.title,
-                            value: product.id
-                        }
-                    })
-
-                    //returns the DDL list in an object with a "result" value to match the GetProductsDDLOutput type
-                    return OperationHandlerResult.success({
-                        result: productsDDL
-                    })
-               })
-    );
+export const getProductsDDLHandler = OperationHandlerSetup.configureHandler<
+	AuthType,
+	GetProductsDDLInput,
+	GetProductsDDLOutput
+>((handler) =>
+	handler.usingComposite(async (auth, input, invoke) => {
+		//invoke the products operation
+		const productsResult: OperationHandlerResult<GetProductsOutput> =
+			await invoke(getProductsHandler)({ storeId: input.storeId });
+
+		//if the invocation failed, propagate the failure
+		if (productsResult.isFailure) {
+			return productsResult;
+		}
+
+		//productsResult is of type `OperationHandlerSuccess` now, because we handled the failure case above, so we can get the value
+		const products = productsResult.value;
+
+		//converts a product list into a list of text (label) and values (identifiers) for the DDL
+		const productsDDL = products.map((product) => {
+			return {
+				text: product.title,
+				value: product.id,
+			};
+		});
+
+		//returns the DDL list in an object with a "result" value to match the GetProductsDDLOutput type
+		return OperationHandlerResult.success({
+			result: productsDDL,
+		});
+	})
+);
 ```
 
-There are several things to note about the handler, both the DDL handler and the `getProductsHandler` expect a `storeId` in the input to return a list of products for that store. 
+There are several things to note about the handler, both the DDL handler and the `getProductsHandler` expect a `storeId` in the input to return a list of products for that store.
 
 The `getProductsHandler` is invoked using the `invoke` function that composite handlers receive as an argument, passing the handler reference, and then calling the result as a function passing the input that handler expects, in this case, just an object with a `storeId`
 
@@ -295,6 +304,7 @@ The result of that invocation is of type `Promise<OperationHandlerResult<GetProd
 The `await` keyword unwraps the promise, and we are left with a `OperationHandlerResult<GetProductsOutput>`, which forces the handler to deal with both the failure case as well as the success case.
 
 There are multiple ways to do this
+
 - Using `if` or `switch` statements to narrow down the type as shown in the example
 - Using the `OperationHandlerResult.getSuccessfulValueOrFail()` function which unwraps the value if successful or terminates the function propagating the error if it is not
 - Using the `OperationHandlerResult.map()` function, which takes an `OperationHandlerResult<T>` as an argument and a function to convert `T` to another type in case it is successful, propagating the failure if it is not (works in the same way it works for the map function in `Array<T>`)
@@ -305,10 +315,10 @@ Finally, for DDL operations, we need to add an extra `type` property in the `ope
 
 ```json
 {
-    "name": "get_products_ddl",
-    "title": "Get Products DDL",
-    "description": "Returns a DDL with product ids as values and product titles as labels",
-    "type": "ddl"
+	"name": "get_products_ddl",
+	"title": "Get Products DDL",
+	"description": "Returns a DDL with product ids as values and product titles as labels",
+	"type": "ddl"
 }
 ```
 
@@ -356,16 +366,14 @@ The structure of a test is well defined, and the type safe declarative DSL will
 - Add a test case using the `testCase()` function.
 - Run one or more operations (doesn't have to be the one being tested) after all test cases using the `afterAll()` function, or don't do anything after all test cases using the `nothingAfterAll()` function, these functions can only be used after defining test cases, and no test cases can be added after this (this is enforced by the type system)
 
-
 As for the test cases, they use a BDD style Given/When/Then convention, in particular a test case has:
 
 - An optional `usingHandlerContext()` function at the beginning of the test case to use a different context than the default for all test cases
-- A `given()` function to run one or more operations at the beginning of the test case or `givenNothing()` to go straight to running the operation under test 
+- A `given()` function to run one or more operations at the beginning of the test case or `givenNothing()` to go straight to running the operation under test
 - A `when()` function to create an input value that will be used to run the operation under test, that value needs to match the input type of the operation
 - A `then()` function that gets the output, input, auth and optionally the result of `beforeAll()` and `given()` if present, which can be used to do the assertions of the test case using jest-style matchers
 - A `finally()` function to run one or more operations at the end of the test case, usually for cleanup, or `finallyDoNothing()` to don't do anything else after the assertions.
 
-
 Both the `beforeAll()` and `given()` functions allow to run multiple operations before all test cases or before a single test case, they receive the `invoke` function as an argument just like composite handlers and they return an object that can contain some of relevant information about the operations that ran if necessary (like ids of things created) in a value that can be accessed by the `when()`, `then()`, `finally()` and `afterAll()` functions, they receive them as arguments.
 
 As an example, the following test is for an `updateProduct` operation, it creates a store for all test cases, and a product for every test case to test the update on, using `beforeAll` and `given` respectively, and accessing the identities of the created objects from the `testContext` (the output of `beforeAll`) and the `testCaseContext` (the output of `given`):
@@ -376,37 +384,52 @@ OperationHandlerTestSetup.configureHandlerTest(
 	(handlerTest) =>
 		handlerTest
 			.usingHandlerContext('test')
-			.beforeAll<{storeId: string}>(async (auth, invoke) => {
+			.beforeAll<{ storeId: string }>(async (auth, invoke) => {
 				//Creates an store that will be used by all tests
-				const createdStoreResult = invoke(createStoreHandler)({name: 'something'})
+				const createdStoreResult = invoke(createStoreHandler)({
+					name: 'something',
+				});
 				return OperationHandlerResult.map(
-					createdStoreResult, 
-					createdStoreOutput => { storeId: createdStoreOutput.id}
-				)
+					createdStoreResult,
+					(createdStoreOutput) => {
+						storeId: createdStoreOutput.id;
+					}
+				);
 			})
 			.testCase('should do something', (testCase) =>
 				testCase
-					.given<{ productId: string}>((auth, testContext, invoke) => {
+					.given<{ productId: string }>((auth, testContext, invoke) => {
 						//Creates an product in the store to be used by the test
-						const createdProductResult = invoke(createProductHandler)({name: 'some product', storeId: testContext.storeId})
+						const createdProductResult = invoke(createProductHandler)({
+							name: 'some product',
+							storeId: testContext.storeId,
+						});
 						return OperationHandlerResult.map(
-							createdProductResult, 
-							createdProductOutput => { productId: createdProductOutput.id}
-						)
+							createdProductResult,
+							(createdProductOutput) => {
+								productId: createdProductOutput.id;
+							}
+						);
 					})
-					.when((auth, testContext, testCaseContext) => ({ productId: testCaseContext.productId, name: 'updated name' }))
+					.when((auth, testContext, testCaseContext) => ({
+						productId: testCaseContext.productId,
+						name: 'updated name',
+					}))
 					.then(({ output }) => {
-						const outputValue = OperationHandlerResult.getSuccessfulValueOrFail(output)
+						const outputValue =
+							OperationHandlerResult.getSuccessfulValueOrFail(output);
 						expect(outputValue.name).toEqual('updated name');
 					})
 					.finally(({ testCaseContext }) => {
 						//Deletes the product created for the test
-						return invoke(deleteProductHandler)({productId: testCaseContext.productId})
+						return invoke(deleteProductHandler)({
+							productId: testCaseContext.productId,
+						});
 					})
 			)
 			.afterAll(({ testContext }) => {
 				//Deletes the store created for all test cases
-				return invoke(deleteStoreHandler)({storeId: testContext.storeId})
+				return invoke(deleteStoreHandler)({ storeId: testContext.storeId });
 			})
 );
 ```

package/dist/connector/operation/HttpOperationHandler.d.ts

@@ -7,6 +7,7 @@ export declare class HttpOperationRequest {
     readonly request: HttpRequest;
     constructor(method: HttpMethod, path: string, request: HttpRequest);
     withBodyAsJson<T>(body: T): HttpOperationRequest;
+    withBodyAsText(body: string): HttpOperationRequest;
     addPathParameter(name: string, value: string): HttpOperationRequest;
     addQueryString(name: string, value: string): HttpOperationRequest;
     withBearerToken(token: string): HttpOperationRequest;
@@ -20,6 +21,7 @@ export declare class HttpOperationResponse {
     getStatusCode(): number;
     getHeader(name: string): HttpHeaderValue | undefined;
     parseWithEmptyBody(): OperationHandlerResult<undefined>;
+    parseWithBodyAsText(): OperationHandlerResult<string>;
     parseWithBodyAsJson<T>(): OperationHandlerResult<T>;
 }
 export type HttpOperationResponseHandler<OUT> = (response: HttpOperationResponse) => OperationHandlerResult<OUT>;

package/dist/connector/operation/HttpOperationHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HttpOperationHandler.d.ts","sourceRoot":"","sources":["../../../src/connector/operation/HttpOperationHandler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"HttpOperationHandler.d.ts","sourceRoot":"","sources":["../../../src/connector/operation/HttpOperationHandler.ts"],"names":[],"mappings":"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"}

package/dist/connector/operation/HttpOperationHandler.js

@@ -51,6 +51,9 @@ class HttpOperationRequest {
         const serializedBody = this.jsonSerialization.serialize(body);
         return new HttpOperationRequest(this.method, this.path, Object.assign(Object.assign({}, this.request), { body: BufferExtensions_1.BufferExtensions.arrayBufferToReadable(serializedBody) })).addHeader(Http_1.HttpHeader.ContentType, Http_1.HttpContentType.Json);
     }
+    withBodyAsText(body) {
+        return new HttpOperationRequest(this.method, this.path, Object.assign(Object.assign({}, this.request), { body: BufferExtensions_1.BufferExtensions.arrayBufferToReadable(new TextEncoder().encode(body)) })).addHeader(Http_1.HttpHeader.ContentType, Http_1.HttpContentType.Text);
+    }
     addPathParameter(name, value) {
         return new HttpOperationRequest(this.method, this.path, Object.assign(Object.assign({}, this.request), { pathParams: Object.assign(Object.assign({}, this.request.pathParams), { [name]: value }) }));
     }
@@ -84,6 +87,14 @@ class HttpOperationResponse {
         }
         return OperationHandler_1.OperationHandlerResult.success(undefined);
     }
+    parseWithBodyAsText() {
+        if (this.response.statusCode >= 300) {
+            return OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.apiError(`API returned a status code of ${this.response.statusCode}`, {
+                statusCode: this.response.statusCode,
+            }));
+        }
+        return OperationHandler_1.OperationHandlerResult.success(new TextDecoder().decode(this.response.body));
+    }
     parseWithBodyAsJson() {
         const deserializedBodyE = this.jsonSerialization.deserialize(this.response.body);
         const result = E.match((error) => OperationHandler_1.OperationHandlerResult.failure(OperationHandler_1.OperationHandlerError.connectorError(`Could not deserialise the body of the response: ${error.message}`)), (deserializedBody) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/cdk-dsl",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "A DSL for connector development",
   "exports": {
     "./*": "./dist/*.js"
@@ -14,7 +14,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@trayio/commons": "1.12.0"
+    "@trayio/commons": "1.13.0"
   },
   "typesVersions": {
     "*": {