velona

Velona is TypeScript DI helper for functional programming.

Table of Contents

- Installation
- Usage
- DI to browser API callback
- Comparison with no DI
- Usage with fs
- Usage with prisma
- Integration test

Installation

- Using npm:

``sh
$ npm install velona
`

- Using Yarn:

`sh
$ yarn add velona
`

Usage

index.ts

`ts
import { depend } from "velona";

const add = (a: number, b: number) => a + b;

export const basicFn = depend({ add }, ({ add }, a: number, b: number, c: number) => add(a, b) * c);
`

sample.ts

`ts
import { basicFn } from "./";

console.log(basicFn(2, 3, 4)); // 20
`

index.spec.ts

`ts
import { basicFn } from "./";

const injectedFn = basicFn.inject({ add: (a, b) => a * b });

expect(injectedFn(2, 3, 4)).toBe(2 3 4); // pass
expect(basicFn(2, 3, 4)).toBe((2 + 3) * 4); // pass
`

DI to browser API callback

handler.ts

`ts
import { depend } from "velona";

export const handler = depend(
{ print: (text: string) => alert(text) },
({ print }, e: Pick) =>
print(type: ${e.type}, x: ${e.x}, y: ${e.y})
);
`

index.ts

`ts
import { handler } from "./handler";

document.body.addEventListener("click", handler, false);
document.body.click(); // alert('type: click, x: 0, y: 0')
`

index.spec.ts

`ts
import { handler } from "./handler";

const event = { type: "click", x: 1, y: 2 };

expect(() => handler(event)).toThrow(); // ReferenceError: alert is not defined (on Node.js)

const injectedHandler = handler.inject({ print: text => text });

expect(injectedHandler(event)).toBe(type: ${event.type}, x: ${event.x}, y: ${event.y}); // pass
`

Comparison with no DI

add.ts

`ts
export const add = (a: number, b: number) => a + b;
`

noDI.ts

`ts
import { add } from "./add";

export const noDIFn = (a: number, b: number, c: number) => add(a, b) * c;
`

index.ts

`ts
import { depend } from "velona";
import { add } from "./add";

export const basicFn = depend({ add }, ({ add }, a: number, b: number, c: number) => add(a, b) * c);
`

sample.ts

`ts
import { basicFn } from "./";
import { noDIFn } from "./noDI";

console.log(basicFn(2, 3, 4)); // 20
console.log(noDIFn(2, 3, 4)); // 20
`

index.spec.ts

`ts
import { basicFn } from "./";
import { noDIFn } from "./noDI";

const injectedFn = basicFn.inject({ add: (a, b) => a * b });

expect(injectedFn(2, 3, 4)).toBe(2 3 4); // pass
expect(basicFn(2, 3, 4)).toBe((2 + 3) * 4); // pass
expect(noDIFn(2, 3, 4)).toBe((2 + 3) * 4); // pass
`

Usage with fs

index.ts

`ts
import fs from "fs";
import { depend } from "velona";

type FS = {
readFile(path: string, option: "utf8"): Promise;
writeFile(path: string, text: string, option: "utf8"): Promise;
};

export const basicFn = depend(
fs.promises as FS, // downcast for injection
async (dependencies, path: string, text: string) => {
await dependencies.writeFile(path, text, "utf8");
return dependencies.readFile(path, "utf8");
}
);
`

sample.ts

`ts
import { basicFn } from "./";

const text = await basicFn("sample.txt", "Hello world!"); // create sample.txt
console.log(text); // 'Hello world!'
`

index.spec.ts

`ts
import { basicFn } from "./";

const data: Record = {};
const injectedFn = basicFn.inject({
readFile: path => Promise.resolve(data[path]),
writeFile: (path, text) => {
data[path] = text;
return Promise.resolve();
},
});

const text = "Hello world!";
await expect(injectedFn("test.txt", text)).resolves.toBe(text);
`

Usage with prisma

tasks.ts

`ts
import { depend } from "velona";
import { PrismaClient } from "@prisma/client";

type Task = {
id: number;
label: string;
done: boolean;
};

const prisma = new PrismaClient();

export const getTasks = depend(
{ prisma: prisma as { task: { findMany(): Promise } } }, // inject prisma
({ prisma }) => prisma.task.findMany() // prisma is injected object
);
`

tasks.spec.ts

`ts
import { getTasks } from "$/service/tasks";

const injectedGetTasks = getTasks.inject({
prisma: {
task: {
findMany: () =>
Promise.resolve([
{ id: 0, label: "task1", done: false },
{ id: 1, label: "task2", done: false },
{ id: 2, label: "task3", done: true },
{ id: 3, label: "task4", done: true },
{ id: 4, label: "task5", done: false },
]),
},
},
});

await expect(injectedGetTasks()).resolves.toHaveLength(5);
`

Integration test

add.ts

`ts
export const add = (a: number, b: number) => a + b;
`

grandchild.ts

`ts
import { depend } from "velona";
import { add } from "./add";

export const grandchild = depend({ add }, ({ add }, a: number, b: number) => add(a, b));
`

child.ts

`ts
import { depend } from "velona";
import { grandchild } from "./grandchild";

export const child = depend(
{ grandchild },
({ grandchild }, a: number, b: number, c: number) => grandchild(a, b) * c
);
`

parentFn.ts

`ts
import { depend } from "velona";
import { child } from "./child";

export const parentFn = depend(
{ child, print: (data: number) => alert(data) },
({ child, print }, a: number, b: number, c: number) => print(child(a, b, c))
);
`

index.ts

`ts
import { parentFn } from "./parentFn";

parentFn(2, 3, 4); // alert(20)
`

parentFn.spec.ts

`ts
import { parentFn } from "./parentFn";

const injectedFn = parentFn.inject(parentDeps => ({
child: parentDeps.child.inject(childDeps => ({
grandchild: clildDeps.grandchild.inject({
add: (a, b) => a * b,
}),
})),
print: data => data,
}));

expect(injectedFn(2, 3, 4)).toBe(2 3 4); // pass
``

License

Velona is licensed under a MIT License.