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:

  1$ npm install velona

• Using Yarn:

  1$ yarn add velona

Usage

index.ts

1import { depend } from 'velona'
2
3const add = (a: number, b: number) => a + b
4
5export const basicFn = depend(
6  { add },
7  ({ add }, a: number, b: number, c: number) => add(a, b) * c
8)

sample.ts

1import { basicFn } from './'
2
3console.log(basicFn(2, 3, 4)) // 20

index.spec.ts

1import { basicFn } from './'
2
3const injectedFn = basicFn.inject({ add: (a, b) => a * b })
4
5expect(injectedFn(2, 3, 4)).toBe(2 * 3 * 4) // pass
6expect(basicFn(2, 3, 4)).toBe((2 + 3) * 4) // pass

DI to browser API callback

handler.ts

1import { depend } from 'velona'
2
3export const handler = depend(
4  { print: (text: string) => alert(text) },
5  ({ print }, e: Pick<MouseEvent, 'type' | 'x' | 'y'>) => print(`type: ${e.type}, x: ${e.x}, y: ${e.y}`)
6)

index.ts

1import { handler } from './handler'
2
3document.body.addEventListener('click', handler, false)
4document.body.click() // alert('type: click, x: 0, y: 0')

index.spec.ts

1import { handler } from './handler'
2
3const event = { type: 'click', x: 1, y: 2 }
4
5expect(() => handler(event)).toThrow() // ReferenceError: alert is not defined (on Node.js)
6
7const injectedHandler = handler.inject({ print: text => text })
8
9expect(injectedHandler(event)).toBe(
10  `type: ${event.type}, x: ${event.x}, y: ${event.y}`
11) // pass

Comparison with no DI

add.ts

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

noDI.ts

1import { add } from './add'
2
3export const noDIFn = (a: number, b: number, c: number) => add(a, b) * c

index.ts

1import { depend } from 'velona'
2import { add } from './add'
3
4export const basicFn = depend(
5  { add },
6  ({ add }, a: number, b: number, c: number) => add(a, b) * c
7)

sample.ts

1import { basicFn } from './'
2import { noDIFn } from './noDI'
3
4console.log(basicFn(2, 3, 4)) // 20
5console.log(noDIFn(2, 3, 4)) // 20

index.spec.ts

1import { basicFn } from './'
2import { noDIFn } from './noDI'
3
4const injectedFn = basicFn.inject({ add: (a, b) => a * b })
5
6expect(injectedFn(2, 3, 4)).toBe(2 * 3 * 4) // pass
7expect(basicFn(2, 3, 4)).toBe((2 + 3) * 4) // pass
8expect(noDIFn(2, 3, 4)).toBe((2 + 3) * 4) // pass

Usage with fs

index.ts

1import fs from 'fs'
2import { depend } from 'velona'
3
4type FS = {
5  readFile(path: string, option: 'utf8'): Promise<string>
6  writeFile(path: string, text: string, option: 'utf8'): Promise<void>
7}
8
9export const basicFn = depend(
10  fs.promises as FS, // downcast for injection
11  async (dependencies, path: string, text: string) => {
12    await dependencies.writeFile(path, text, 'utf8')
13    return dependencies.readFile(path, 'utf8')
14  }
15)

sample.ts

1import { basicFn } from './'
2
3const text = await basicFn('sample.txt', 'Hello world!') // create sample.txt
4console.log(text) // 'Hello world!'

index.spec.ts

1import { basicFn } from './'
2
3const data: Record<string, string> = {}
4const injectedFn = basicFn.inject({
5  readFile: path => Promise.resolve(data[path]),
6  writeFile: (path, text) => {
7    data[path] = text
8    return Promise.resolve()
9  }
10})
11
12const text = 'Hello world!'
13await expect(injectedFn('test.txt', text)).resolves.toBe(text)

Usage with prisma

tasks.ts

1import { depend } from 'velona'
2import { PrismaClient } from '@prisma/client'
3
4type Task = {
5  id: number
6  label: string
7  done: boolean
8}
9
10const prisma = new PrismaClient()
11
12export const getTasks = depend(
13  { prisma: prisma as { task: { findMany(): Promise<Task[]> } } }, // inject prisma
14  ({ prisma }) => prisma.task.findMany() // prisma is injected object
15)

tasks.spec.ts

1import { getTasks } from '$/service/tasks'
2
3const injectedGetTasks = getTasks.inject({
4  prisma: {
5    task: {
6      findMany: () =>
7        Promise.resolve([
8          { id: 0, label: 'task1', done: false },
9          { id: 1, label: 'task2', done: false },
10          { id: 2, label: 'task3', done: true },
11          { id: 3, label: 'task4', done: true },
12          { id: 4, label: 'task5', done: false }
13        ])
14    }
15  }
16})
17
18await expect(injectedGetTasks()).resolves.toHaveLength(5)

Integration test

add.ts

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

grandchild.ts

1import { depend } from 'velona'
2import { add } from './add'
3
4export const grandchild = depend(
5  { add },
6  ({ add }, a: number, b: number) => add(a, b)
7)

child.ts

1import { depend } from 'velona'
2import { grandchild } from './grandchild'
3
4export const child = depend(
5  { grandchild },
6  ({ grandchild }, a: number, b: number, c: number) => grandchild(a, b) * c
7)

parentFn.ts

1import { depend } from 'velona'
2import { child } from './child'
3
4export const parentFn = depend(
5  { child, print: (data: number) => alert(data) },
6  ({ child, print }, a: number, b: number, c: number) => print(child(a, b, c))
7)

index.ts

1import { parentFn } from './parentFn'
2
3parentFn(2, 3, 4) // alert(20)

parentFn.spec.ts

1import { parentFn } from './parentFn'
2
3const injectedFn = parentFn.inject((parentDeps) => ({
4  child: parentDeps.child.inject((childDeps) => ({
5    grandchild: clildDeps.grandchild.inject({
6      add: (a, b) => a * b
7    }))
8  })),
9  print: data => data
10})
11
12expect(injectedFn(2, 3, 4)).toBe(2 * 3 * 4) // pass

License

Velona is licensed under a MIT License.