chore: initial commit

Author: diogoazevedos

.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = tab
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.yml]
+indent_style = space
+indent_size = 2

.github/workflows/main.yml

@@ -0,0 +1,24 @@
+name: CI
+on:
+  - push
+  - pull_request
+permissions:
+  contents: read
+jobs:
+  test:
+    name: Node.js ${{ matrix.node-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version:
+          - 18
+          - 20
+          - 22
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm install
+      - run: npm test

.gitignore

@@ -0,0 +1,3 @@
+node_modules
+coverage
+distribution

.husky/commit-msg

@@ -0,0 +1 @@
+npx --no -- commitlint --edit ${1}

.husky/pre-commit

@@ -0,0 +1 @@
+npx --no -- lint-staged

.npmrc

@@ -0,0 +1 @@
+package-lock=false

CONTRIBUTING.md

@@ -0,0 +1,23 @@
+# Contributing
+
+First time contributing, **please note we enforce** [commit message conventions](#commit-message).
+
+### Commit message
+
+```
+feat(example): migrate S3 URL to virtual hosted-style
+^--^ ^-----^   ^------------------------------------^
+|    |         |
+|    |         +-> Summary in present tense.
+|    |
+|    +-----------> Optional scope.
+|
++----------------> Type: build, ci, chore, docs, feat, fix, perf, refactor, style, or test.
+```
+
+For more info about message body, see:
+
+- [Writing git commit messages](http://365git.tumblr.com/post/3308646748/writing-git-commit-messages)
+- [A note about git commit messages](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
+
+More examples at [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/).

LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2023 Diogo Azevedo <diogoazevedos@gmail.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,20 @@
+# pipe-fun
+
+> Build and compose pipelines with ease
+
+## Install
+
+```sh
+npm install -S pipe-fun
+```
+
+## Usage
+
+```ts
+import {_, pipe} from 'pipe-fun';
+
+const pipeline = pipe(() => ({name: 'John Smith'}), user => user.name);
+
+await pipeline(_);
+//=> John Smith
+```

main.ts

@@ -0,0 +1,194 @@
+type Awaitable<T> = T | Promise<T>;
+export type Pipe<Output, Input> = (input: Input) => Awaitable<Output>;
+export type Step<Output, T> = <Input extends T>(input: Input) => Awaitable<Output>;
+
+/**
+ * Special step that assign the input and output.
+ *
+ * @example
+ * ```
+ * const addHobby = middleware(() => ({hobby: 'Coding'}));
+ *
+ * await addHobby({name: 'John Smith'});
+ * //=> {name: 'John Smith', hobby: 'Coding'}
+ * ```
+ */
+export function middleware<Output, T>(step: Pipe<Output, T>) {
+	return async <Input extends T>(input: Input) => ({...input, ...(await step(input))});
+}
+
+/**
+ * Compose multiple steps.
+ *
+ * @example
+ * ```
+ * const getUser = async () => ({name: 'John Smith'});
+ * const addHobby = middleware(() => ({hobby: 'Coding'}));
+ *
+ * const pipeline = pipe(getUser, addHobby);
+ *
+ * await pipeline();
+ * //=> {name: 'John Smith', hobby: 'Coding'}
+ * ```
+ */
+export function pipe<Output, A, Input>(
+	s1: Pipe<A, Input>,
+	s2: Pipe<Output, A>
+): Pipe<Output, Input>;
+export function pipe<Output, B, A, Input>(
+	s1: Pipe<A, Input>,
+	s2: Pipe<B, A>,
+	s3: Pipe<Output, B>
+): Pipe<Output, Input>;
+export function pipe<Output, C, B, A, Input>(
+	s1: Pipe<A, Input>,
+	s2: Pipe<B, A>,
+	s3: Pipe<C, B>,
+	s4: Pipe<Output, C>
+): Pipe<Output, Input>;
+export function pipe<Output, D, C, B, A, Input>(
+	s1: Pipe<A, Input>,
+	s2: Pipe<B, A>,
+	s3: Pipe<C, B>,
+	s4: Pipe<D, C>,
+	s5: Pipe<Output, D>
+): Pipe<Output, Input>;
+export function pipe<Output, E, D, C, B, A, Input>(
+	s1: Pipe<A, Input>,
+	s2: Pipe<B, A>,
+	s3: Pipe<C, B>,
+	s4: Pipe<D, C>,
+	s5: Pipe<E, D>,
+	s6: Pipe<Output, E>
+): Pipe<Output, Input>;
+export function pipe<Output, F, E, D, C, B, A, Input>(
+	s1: Pipe<A, Input>,
+	s2: Pipe<B, A>,
+	s3: Pipe<C, B>,
+	s4: Pipe<D, C>,
+	s5: Pipe<E, D>,
+	s6: Pipe<F, E>,
+	s7: Pipe<Output, F>
+): Pipe<Output, Input>;
+export function pipe<Input>(
+	init: Pipe<unknown, Input>,
+	...steps: Array<Pipe<unknown, unknown>>
+): Pipe<unknown, Input> {
+	// eslint-disable-next-line unicorn/no-array-reduce
+	return input => steps.reduce(async (promise, step) => step(await promise), init(input));
+}
+
+/**
+ * Execute steps in parallel.
+ *
+ * @example
+ * ```
+ * const getUser = async () => ({name: 'John Smith'});
+ * const getSession = async () => ({id: '4a53'});
+ *
+ * const pipeline = parallel(getUser, getSession);
+ *
+ * await pipeline();
+ * //=> [{name: 'John Smith'}, {id: '4a53'}]
+ * ```
+ */
+export function parallel<D, C, B, A>(
+	s1: Pipe<B, A>,
+	s2: Pipe<D, C>
+): Pipe<[B, D], A & C>;
+export function parallel<F, E, D, C, B, A>(
+	s1: Pipe<B, A>,
+	s2: Pipe<D, C>,
+	s3: Pipe<F, E>
+): Pipe<[B, D, F], A & C & E>;
+export function parallel<H, G, F, E, D, C, B, A>(
+	s1: Pipe<B, A>,
+	s2: Pipe<D, C>,
+	s3: Pipe<F, E>,
+	s4: Pipe<H, G>
+): Pipe<[B, D, F, H], A & C & E & G>;
+export function parallel<J, I, H, G, F, E, D, C, B, A>(
+	s1: Pipe<B, A>,
+	s2: Pipe<D, C>,
+	s3: Pipe<F, E>,
+	s4: Pipe<H, G>,
+	s5: Pipe<J, I>
+): Pipe<[B, D, F, H, J], A & C & E & G & I>;
+export function parallel<L, K, J, I, H, G, F, E, D, C, B, A>(
+	s1: Pipe<B, A>,
+	s2: Pipe<D, C>,
+	s3: Pipe<F, E>,
+	s4: Pipe<H, G>,
+	s5: Pipe<J, I>,
+	s6: Pipe<L, K>
+): Pipe<[B, D, F, H, J, L], A & C & E & G & I & K>;
+export function parallel<N, M, L, K, J, I, H, G, F, E, D, C, B, A>(
+	s1: Pipe<B, A>,
+	s2: Pipe<D, C>,
+	s3: Pipe<F, E>,
+	s4: Pipe<H, G>,
+	s5: Pipe<J, I>,
+	s6: Pipe<L, K>,
+	s7: Pipe<N, M>
+): Pipe<[B, D, F, H, J, L, N], A & C & E & G & I & K & M>;
+export function parallel<Input>(...steps: Array<Pipe<unknown, Input>>): Pipe<unknown[], Input> {
+	return async input => Promise.all(steps.map(step => step(input)));
+}
+
+type Assign<T extends unknown[]> = T extends [infer Head, ...infer Tail]
+	? Head & Assign<Tail>
+	: unknown;
+
+/**
+ * Assign the output of a parallel step.
+ *
+ * @example
+ * ```
+ * const getUser = async () => ({name: 'John Smith'});
+ * const addHobby = middleware(() => ({hobby: 'Coding'}));
+ *
+ * const pipeline = assign(parallel(getUser, addHobby));
+ *
+ * await pipeline();
+ * //=> {name: 'John Smith', hobby: 'Coding'}
+ * ```
+ */
+export function assign<Output extends unknown[], Input>(
+	step: Step<Output, Input>,
+): Pipe<Assign<Output>, Input> {
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	return async input => Object.assign({}, ...(await step(input)));
+}
+
+/**
+ * Special step that passthrough the input.
+ *
+ * @example
+ * ```
+ * type User = {name: string};
+ *
+ * const notifyLogin = (user: User) => console.log(`User ${user.name} logged in`);
+ *
+ * const pipeline = passthrough(notifyLogin);
+ *
+ * await pipeline({name: 'John Smith'});
+ * //=> {name: 'John Smith'}
+ * ```
+ */
+export function passthrough<T>(step: Pipe<unknown, T>) {
+	// eslint-disable-next-line no-sequences
+	return async <Input extends T>(input: Input) => (await step(input), input);
+}
+
+/**
+ * Placeholder for step without input.
+ *
+ * @example
+ * ```
+ * const pipeline = pipe(() => ({name: 'John Smith'}), user => user.name);
+ *
+ * await pipeline(_);
+ * //=> 'John Smith'
+ * ```
+ */
+export const _ = {};