chainflow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 - present Edwin Lim (edwinlzs)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,414 @@
+<h1 align="center" style="border-bottom: none;">🌊hainflow</h1>
+<h3 align="center">Create dynamic and composable API call workflows.</h3>
+
+## Not Released Yet
+
+Hi! If you are here, you're a bit early. I'm still setting up some stuff for the first release. Check back in later!
+
+## Use Cases
+
+1. Insert demo data via your app's APIs
+2. Simulate frontend interactions with backend APIs
+3. Test edge cases on endpoints with input variations
+
+## Basic Usage
+
+```console
+npm install --save-dev chainflow
+```
+
+Use `originServer` to define your endpoints and their request/response signatures with the `endpoint` method.
+
+```typescript
+import { originServer } from chainflow;
+
+const origin = originServer('127.0.0.1:5000');
+
+const createUser = origin.post('/user').body({
+  name: 'Tom',
+  details: {
+    age: 40,
+  },
+});
+
+const createRole = origin.post('/role').body({
+  type: 'Engineer',
+  userId: createUser.resp.body.id,
+});
+
+const getUser = origin.get('/user').query({
+  roleType: createRole.resp.body.type,
+});
+```
+
+Use a `chainflow` to define a sequence of endpoint calls that take advantage of the values and links provided above.
+
+```typescript
+import { chainflow } from Chainflow;
+
+const flow = chainflow()
+  .call(createUser)
+  .call(createRole)
+  .call(getUser);
+
+flow.run();
+```
+
+---
+
+\
+The above setup will result in the following API calls:
+
+1. `POST` Request to `/user` with body:
+
+   ```json
+   {
+     "name": "Tom",
+     "details": {
+       "age": 40
+     }
+   }
+   ```
+
+2. `POST` Request to `/role` with body:
+
+   ```json
+   {
+     "type": "Engineer",
+     "userId": "['userId' from response to step 1]"
+   }
+   ```
+
+3. `GET` Request to `/user?roleType=['type' from response to step 2]`
+
+&nbsp;
+
+## More Features
+
+### Path params
+
+Define path params by wrapping a param name with `{}` in the endpoint path.
+
+```typescript
+const getGroupsWithUser = origin.get('/groups/{userId}');
+```
+
+### Query params
+
+Define query params with the `query` method on an endpoint.
+
+```typescript
+const getUsersInGroup = origin.get('/user').query({ groupId: 'some-id' });
+```
+
+### Headers
+
+Specify headers with `headers` method on endpoints.
+
+```typescript
+const getInfo = origin.get('/info').headers({ token: 'some-token' });
+```
+
+You can also use `headers` on an `OriginServer` to have all endpoints made for that origin bear those headers.
+
+```typescript
+const origin = originServer('127.0.0.1:3001').headers({ token: 'some-token' });
+
+const getInfo = origin.get('/info'); // getInfo endpoint will have the headers defined above
+```
+
+The request payloads under `Basic Usage` are defined with only _default_ values - i.e. the values which a Chainflow use if there are no response values from other endpoint calls linked to it.
+
+However, you can also use the following features to more flexibly define the values used in a request.
+
+### `required`
+
+Marks a value as required but without a default. The chainflow will expect this value to be sourced from another node. If no such source is available, the endpoint call will throw an error.
+
+```typescript
+const createUser = origin.post('/user').body({
+  name: required(),
+});
+```
+
+### [_EXPERIMENTAL_] - `pool`
+
+Provide a pool of values to take from when building requests. By default, Chainflow will randomly choose a value from the pool for each call in a non-exhaustive manner.
+
+```typescript
+const createUser = origin.post('/user').body({
+  name: pool(['Tom', 'Harry', 'Jane']),
+  details: {
+    age: 40,
+  },
+});
+```
+
+### `gen`
+
+Provide a callback that generates values for building requests.
+
+```typescript
+const randAge = () => Math.floor(Math.random() * 100);
+
+const createUser = origin.post('/user').body({
+  name: 'Tom',
+  details: {
+    age: gen(randAge),
+  },
+});
+```
+
+### `source`
+
+Specify a source node with a callback.
+
+```typescript
+const addGreeting = (name: string) => `Hello ${name}`;
+
+createNotification.body({
+  msg: source(getUser.resp.body.name, addGreeting);
+});
+```
+
+### `sources`
+
+Specify multiple source nodes that a value can be taken from, with an optional callback.
+
+```typescript
+createNotification.body({
+  msg: sources([getUser.resp.body.name, createUser.resp.body.name], addGreeting);
+});
+```
+
+### `link`
+
+Link a response values to a single request node.
+
+```typescript
+createNotification.set(({ body: { msg } }) => {
+  link(msg, getUser.resp.body.name);
+});
+```
+
+Optionally, you can pass a callback to transform the response value before it is passed to the node.
+
+```typescript
+createNotification.set(({ body: { msg } }) => {
+  link(msg, getUser.resp.body.name, addGreeting);
+});
+```
+
+### `linkMany`
+
+Link multiple response values to a single request node, providing a callback to transform the values into a single output.
+
+```typescript
+const mergeValues = ({ userName, favAnimal }: { userName: string; favAnimal: string }) =>
+  `${userName} likes ${favAnimal}.`;
+
+createNotification.set(({ body: { msg } }) => {
+  linkMany(
+    msg, // the request node
+    // specify which response nodes to take values from and assigns them to a key
+    {
+      userName: getUser.resp.body.name,
+      favAnimal: getFavAnimal.resp.body.favAnimal,
+    },
+    // callback that takes the response values as its argument
+    // and returns a single output value for the request node
+    mergeValues,
+  );
+});
+```
+
+### Call Options
+
+You can declare manual values for an endpoint call in the chainflow itself, should you need to do so, by passing in a Call Options object as a second argument in the `call` method.
+
+`body`, `pathParams`, `query` and `headers` can be set this way.
+
+```typescript
+const createUser = origin.post('/user').body({
+  name: 'Tom',
+});
+
+chainflow()
+  .call(createUser, { body: { name: 'Harry' } })
+  .run();
+```
+
+### `seed`
+
+You can specify request nodes to take values from the chainflow 'seed' by importing the `seed` object and linking nodes to it. Provide actual seed values by calling the `seed` method on a chainflow before you `run` it, like below.
+
+```typescript
+import { chainflow, link seed, } from 'chainflow';
+
+const createUser = origin.post('/user').body({
+  name: required(),
+});
+
+createUser.set(({ body: { name }}) => {
+  link(name, seed.username);
+});
+
+chainflow()
+  .call()
+  .seed({ username: 'Tom' })
+  .run();
+```
+
+### Allow Undefined Sources Values
+
+By default, an input node will reject and skip a source node's value if it is unavailable or `undefined`. However, you can change this by passing a source node into the `allowUndefined` function, which modifies its properties to inform an input node to use its value regardless of whether the value is `undefined` or not.
+
+```typescript
+import { allowUndefined } from 'chainflow';
+
+createUser.set(({ body: { name } }) => {
+  link(name, allowUndefined(seed.username));
+});
+```
+
+This has important implications - it means that as long as the source (e.g. a response from an endpoint call) is available, then the linked source node's value will be taken and used (even if that value is unavailable, which would be taken as `undefined`). Therefore, any other linked sources will not be used UNLESS 1. they have a higher priority or 2. the source providing the linked node that allows `undefined` is unavailable.
+
+&nbsp;
+
+### `clone`
+
+You can create chainflow "templates" with the use of `clone` to create a copy of a chainflow and its endpoint callqueue. The clone can have endpoint calls added to it without modifying the initial flow.
+
+```typescript
+const initialFlow = chainflow().call(endpoint1).call(endpoint2);
+
+const clonedFlow = initialFlow.clone();
+
+clonedFlow.call(endpoint3).run(); // calls endpoint 1, 2 and 3
+initialFlow.call(endpoint4).run(); // calls endpoint 1, 2 and 4
+```
+
+### `extend`
+
+You can connect multiple different chainflows together into a longer chainflow using `extend`.
+
+```typescript
+const flow1 = chainflow().call(endpoint1).call(endpoint2);
+const flow2 = chainflow().call(endpoint3);
+
+flow1.extend(flow2).run(); // calls endpoint 1, 2 and 3
+```
+
+### `config`
+
+`respParser`  
+By default, Chainflows will parse response bodies as JSON objects. To change this, you can call `.config` to change that configuration on an `endpoint` (or on an `OriginServer`, to apply it to all endpoints created from it) like so:
+
+```typescript
+import { RespParser } from 'chainflow';
+
+const getUser = origin.get('/user').config({
+  respParser: RespParser.Text,
+});
+```
+
+or with camelcase in JavaScript:
+
+```javascript
+const getUser = origin.get('/user').config({
+  respParser: 'text',
+});
+```
+
+There are 4 supported ways to parse response bodies (as provided by the underlying HTTP client, `undici`): `arrayBuffer`, `blob`, `json` and `text`.
+
+`respValidator`  
+Another configuration option is how to validate the response to an endpoint. By default, Chainflow only accepts responses that have HTTP status codes in the 200-299 range, and rejects responses otherwise (meaning their values will not be stored). You can pass in a custom `respValidator` to change this behaviour.
+
+```typescript
+const testEndpoint = origin.get('/user').config({
+  respValidator: (resp) => {
+    if (resp.statusCode !== 201) return { valid: false, msg: 'Failed to retrieve users.' };
+    return { valid: true };
+  },
+});
+```
+
+### `store`
+
+Instead of direct links between endpoints, you can use a central store to keep values from some endpoints and have other endpoints take from it via the special `store` object.
+
+```typescript
+import { store } from 'chainflow';
+
+const createUser = origin.post('/user').body({
+  name: 'Tom',
+}).store((resp) => ({
+  // this endpoint will store `id` from a response to `userId` in the store
+  userId: resp.body.id,
+}));
+
+const addRole = origin.post('/role').body({
+  // this endpoint will take `userId` from the store, if available
+  userId: store.userId,
+  role: 'Engineer',
+});
+
+chainflow().call(createUser).call(addRole).run();
+```
+
+This is usually useful when you have endpoints that could take a value from any one of many other endpoints for the same input node. Having a store to centralise these many-to-many relationships (like an API Gateway) can improve the developer experience.
+
+### `continuesFrom` - transferring Chainflow states
+
+Say we have 2 endpoints, `login` and `createGroup`. We want to login as a user once, then proceed to proceed 3 groups as that same user without having to login 3 times.
+
+```typescript
+const createGroup = origin.post('/group').headers({
+  Authorization: login.resp.body.authToken,
+}).body({
+  groupName: seed.groupName,
+})
+
+// loggedInFlow will contain a response from the `login` endpoint
+const loggedInFlow = chainflow()
+  .call(login)
+  .run();
+
+// createGroupFlow will take the response that
+// loggedInFlow received and carry on from there
+const createGroupFlow = chainflow()
+  .call(createGroup)
+  .continuesFrom(loggedInFlow);
+
+const groupNames = ['RapGPT', 'Averageexpedition', 'Shaky Osmosis'];
+for (const groupName in groupNames) {
+  createGroupFlow.seed({ groupName }).run();
+}
+```
+
+We run a chainflow that calls `login` first to get a response from the login endpoint.
+
+Using the `continuesFrom` method, `createGroupFlow` will copy the state of source values (i.e. responses) from `loggedInFlow`. This means `createGroupFlow` will now have the logged in user's `authToken` received from calling `login`, and will use it when calling `createGroup` thrice for each group name in the `groupNames` array.
+
+### `logging`
+
+Enable logs from Chainflow by setting `ENABLE_CHAINFLOW_LOGS=true` in your environment variables.
+
+## Future Updates
+
+Below features are currently not yet supported but are planned in future releases.
+
+1. More flexibility to log and return responses
+2. API performance testing
+3. (Exploratory) Possibly some sort of UI/diagram generation
+
+## Development
+
+Run specific test files:
+
+`pnpm run test:file ./src/**/chainflow.test.ts`
+
+### Trivia
+
+> You probably noticed that I enjoy using the Builder pattern for its clarity.

package/dist/core/chainflow.d.ts

@@ -0,0 +1,44 @@
+import { SourceValues } from './inputNode';
+import { IStore } from './store';
+export interface CallResult {
+    resp: any;
+    store: IStore<unknown>;
+}
+/** Defines an endpoint that a chainflow can call upon. */
+export interface IEndpoint {
+    hash: string;
+    call: (sources: SourceValues, opts?: CallOpts) => Promise<CallResult>;
+}
+/** Options for configuring an endpoint call.
+ * @todo to decouple from chainflow in future versions. */
+export interface CallOpts {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    body?: Record<string, any>;
+}
+/** Special object used to link an InputNode to a chainflow seed. */
+export declare const seed: import("./sourceNode").SourceNode;
+/** Special object that acts as a central "gateway" between input and source values. */
+export declare const store: import("./sourceNode").SourceNode;
+export declare class Chainflow {
+    #private;
+    /** Run the set up chain */
+    run(): Promise<this>;
+    /** Adds a seed to this chainflow. */
+    seed(seed: Record<string, any>): this;
+    /** Adds an endpoint call to the callchain. */
+    call(endpoint: IEndpoint, opts?: CallOpts): this;
+    /** Resets the chainflow's state by clearing its accumulated sources. */
+    reset(): void;
+    /** Creates a clone of this chainflow's callqueue and initial sources
+     *  which can be extended and run independently. */
+    clone(): Chainflow;
+    /** Extends this chainflow's callqueue with that of another flow. */
+    extend(cf: Chainflow): this;
+    /** Causes this chainflow to continue from the state of
+     * sources values of another chainflow. */
+    continuesFrom(cf: Chainflow): this;
+    /** @todo Returns the accumulated responses of this chainflow. */ responses(): void;
+}
+export declare const chainflow: () => Chainflow;

package/dist/core/chainflow.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Chainflow_sources, _Chainflow_initSources, _Chainflow_callqueue;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainflow = exports.Chainflow = exports.store = exports.seed = void 0;
+const sourceNode_1 = require("./sourceNode");
+const deepmerge_1 = __importDefault(require("@fastify/deepmerge"));
+const logger_1 = require("./logger");
+const constants_1 = require("./utils/constants");
+const deepmerge = (0, deepmerge_1.default)();
+/** Special object used to link an InputNode to a chainflow seed. */
+exports.seed = (0, sourceNode_1.sourceNode)(constants_1.SEED_HASH);
+/** Special object that acts as a central "gateway" between input and source values. */
+exports.store = (0, sourceNode_1.sourceNode)(constants_1.STORE_HASH);
+class Chainflow {
+    constructor() {
+        /** Stores sources such as the seed or values accumulated from
+         * endpoint calls in the current flow. */
+        _Chainflow_sources.set(this, {});
+        /** Stores the sources that this chainflow was initialized with. */
+        _Chainflow_initSources.set(this, {});
+        _Chainflow_callqueue.set(this, []);
+    }
+    /** Run the set up chain */
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, logger_1.log)(`Running chainflow...`);
+            this.reset();
+            __classPrivateFieldSet(this, _Chainflow_sources, __classPrivateFieldGet(this, _Chainflow_initSources, "f"), "f");
+            __classPrivateFieldGet(this, _Chainflow_sources, "f")[constants_1.STORE_HASH] = [{}];
+            for (const { endpoint, opts } of __classPrivateFieldGet(this, _Chainflow_callqueue, "f")) {
+                // call endpoint
+                const hash = endpoint.hash;
+                (0, logger_1.log)(`Calling endpoint with hash "${hash}"`);
+                try {
+                    const { resp, store } = yield endpoint.call(__classPrivateFieldGet(this, _Chainflow_sources, "f"), opts);
+                    if (Object.keys(store).length > 0)
+                        __classPrivateFieldGet(this, _Chainflow_sources, "f")[constants_1.STORE_HASH][0] = deepmerge(__classPrivateFieldGet(this, _Chainflow_sources, "f")[constants_1.STORE_HASH][0], store);
+                    __classPrivateFieldGet(this, _Chainflow_sources, "f")[hash] = [resp];
+                }
+                catch (e) {
+                    (0, logger_1.warn)(`Chainflow stopped at endpoint with hash "${hash}" and error: ${e}`);
+                    throw e;
+                }
+            }
+            (0, logger_1.log)('Finished running chainflow.');
+            return this;
+        });
+    }
+    /** Adds a seed to this chainflow. */
+    seed(seed) {
+        __classPrivateFieldGet(this, _Chainflow_initSources, "f")[constants_1.SEED_HASH] = [seed];
+        return this;
+    }
+    /** Adds an endpoint call to the callchain. */
+    call(endpoint, opts) {
+        __classPrivateFieldGet(this, _Chainflow_callqueue, "f").push({ endpoint, opts });
+        return this;
+    }
+    /** Resets the chainflow's state by clearing its accumulated sources. */
+    reset() {
+        __classPrivateFieldSet(this, _Chainflow_sources, {}, "f");
+    }
+    /** Creates a clone of this chainflow's callqueue and initial sources
+     *  which can be extended and run independently. */
+    clone() {
+        const clone = new Chainflow();
+        __classPrivateFieldSet(clone, _Chainflow_initSources, structuredClone(__classPrivateFieldGet(this, _Chainflow_initSources, "f")), "f");
+        __classPrivateFieldSet(clone, _Chainflow_callqueue, [...__classPrivateFieldGet(this, _Chainflow_callqueue, "f")], "f");
+        return clone;
+    }
+    /** Extends this chainflow's callqueue with that of another flow. */
+    extend(cf) {
+        __classPrivateFieldGet(this, _Chainflow_callqueue, "f").push(...__classPrivateFieldGet(cf, _Chainflow_callqueue, "f"));
+        return this;
+    }
+    /** Causes this chainflow to continue from the state of
+     * sources values of another chainflow. */
+    continuesFrom(cf) {
+        __classPrivateFieldSet(this, _Chainflow_initSources, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Chainflow_initSources, "f")), __classPrivateFieldGet(cf, _Chainflow_sources, "f")), "f");
+        return this;
+    }
+    /** @todo Returns the accumulated responses of this chainflow. */ responses() { }
+}
+exports.Chainflow = Chainflow;
+_Chainflow_sources = new WeakMap(), _Chainflow_initSources = new WeakMap(), _Chainflow_callqueue = new WeakMap();
+const chainflow = () => {
+    return new Chainflow();
+};
+exports.chainflow = chainflow;
+//# sourceMappingURL=chainflow.js.map

package/dist/core/chainflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chainflow.js","sourceRoot":"","sources":["../../src/core/chainflow.ts"],"names":[],"mappings":"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"}

package/dist/core/inputNode.d.ts

@@ -0,0 +1,41 @@
+import { SourceNode } from './sourceNode';
+import { getNodeValue, setSource, setSources, setValuePool } from './utils/symbols';
+/** @experimental How a value pool should choose its values. */
+export declare enum VALUE_POOL_SELECT {
+    UNIFORM = 0
+}
+export declare enum NodeValue {
+    ValuePool = 0,
+    Generator = 1,
+    Required = 2,
+    Source = 3,
+    SourceWithCallback = 4,
+    Sources = 5
+}
+type SourceValue = any;
+export type SourceValues = {
+    [hash: string]: SourceValue[];
+};
+/** A data node for constructing an input object. */
+export declare class InputNode {
+    #private;
+    /** Key-values under this node, if this node represents an object. */
+    [key: string]: any;
+    constructor(val: any);
+    /** Sets a source node for this input node. */
+    [setSource](source: SourceNode, callback?: (val: any) => any): void;
+    /** Sets multiple source nodes to be combined into a single value for this input node */
+    [setSources](sources: {
+        [key: string]: SourceNode;
+    }, callback: (val: any) => any): void;
+    /** Sets the pool of values for this input node. */
+    [setValuePool](valuePool: any[]): void;
+    /** Retrieve value of a node. */
+    [getNodeValue](sourceValues: SourceValues, missingValues: string[][], currentPath: string[]): any;
+    /**
+     * Builds a key-value object from input node values and
+     * any available linked sources.
+     */
+    buildKvObject(currentPath: string[], missingValues: string[][], sourceValues: SourceValues): any;
+}
+export {};