16 replies

Making internal Service calls and improving modularisation, especially with dependencies

Whether using Context.Tag or Effect.Service to create a service for injection, I'm coming across cases where I want to make calls within the service. Take for example a service that provides a CRUD type interface, e.g.

create

create

read

read

update

update

del

del

methods.) There are instances where I need to

read

read

the existing entity in order to apply an update. If we define our service implementation along the lines of:

MyService.of({
  create: () => {/*...*/},
  read: () => {/*...*/},
  update: () => {/*...*/},
  del: () => {/*...*/},
})

MyService.of({
  create: () => {/*...*/},
  read: () => {/*...*/},
  update: () => {/*...*/},
  del: () => {/*...*/},
})

Then we can't call

read

read

from

update

update

. To do so, we need to extract the effectual function:

const read = () => {/*...*/}
MyService.of({
  read,
  update: () => {/* do something with read as its on outer scope */}
  // ... other methods
})

const read = () => {/*...*/}
MyService.of({
  read,
  update: () => {/* do something with read as its on outer scope */}
  // ... other methods
})

This gets more complex if we have any dependency that the effectual functions require:

declare const dep: typeof DepService
const read = () => {/* returned Effect with Dep requirement */}
MyService.of({
  read,
  update: () => Effect.gen(function* () {
    const entity = yield* read().pipe(Effect.provideService(Dep, dep))
    //...
  }
  // ... other methods
})

declare const dep: typeof DepService
const read = () => {/* returned Effect with Dep requirement */}
MyService.of({
  read,
  update: () => Effect.gen(function* () {
    const entity = yield* read().pipe(Effect.provideService(Dep, dep))
    //...
  }
  // ... other methods
})

Once we get this far, we also have the ability to extract the

read

read

function to a separate module.

Now we could go down the line of wrapping

read

read

into its own single purpose service that is then aggregated into

MyService

MyService

but this seems like a lot of overhead.

I can also see that we could make

read

read

a higher-order function that takes its dependency as an argument:

declare const dep: typeof DepService
const read = (dep: typeof DepService) => (id: number) => {/* use dep to satisfy*/}
MyService.of({
  read: read(dep),  // assigns the result of the HOF
  //...
})

declare const dep: typeof DepService
const read = (dep: typeof DepService) => (id: number) => {/* use dep to satisfy*/}
MyService.of({
  read: read(dep),  // assigns the result of the HOF
  //...
})

Am I missing a trick here? Is there a simpler way of extracting the member implementations of a service in a more modular way?

NB: My services aren't complex, example is around 250 lines, but I also need that internal reusability.

Making internal Service calls and improving modularisation, especially with dependencies

create

create

read

read

update

update

del

del

methods.) There are instances where I need to

read

read

the existing entity in order to apply an update. If we define our service implementation along the lines of:

MyService.of({
  create: () => {/*...*/},
  read: () => {/*...*/},
  update: () => {/*...*/},
  del: () => {/*...*/},
})

MyService.of({
  create: () => {/*...*/},
  read: () => {/*...*/},
  update: () => {/*...*/},
  del: () => {/*...*/},
})

Then we can't call

read

read

from

update

update

. To do so, we need to extract the effectual function:

const read = () => {/*...*/}
MyService.of({
  read,
  update: () => {/* do something with read as its on outer scope */}
  // ... other methods
})

const read = () => {/*...*/}
MyService.of({
  read,
  update: () => {/* do something with read as its on outer scope */}
  // ... other methods
})

This gets more complex if we have any dependency that the effectual functions require:

declare const dep: typeof DepService
const read = () => {/* returned Effect with Dep requirement */}
MyService.of({
  read,
  update: () => Effect.gen(function* () {
    const entity = yield* read().pipe(Effect.provideService(Dep, dep))
    //...
  }
  // ... other methods
})

declare const dep: typeof DepService
const read = () => {/* returned Effect with Dep requirement */}
MyService.of({
  read,
  update: () => Effect.gen(function* () {
    const entity = yield* read().pipe(Effect.provideService(Dep, dep))
    //...
  }
  // ... other methods
})

Once we get this far, we also have the ability to extract the

read

read

function to a separate module.

Now we could go down the line of wrapping

read

read

into its own single purpose service that is then aggregated into

MyService

MyService

but this seems like a lot of overhead.

I can also see that we could make

read

read

a higher-order function that takes its dependency as an argument:

declare const dep: typeof DepService
const read = (dep: typeof DepService) => (id: number) => {/* use dep to satisfy*/}
MyService.of({
  read: read(dep),  // assigns the result of the HOF
  //...
})

declare const dep: typeof DepService
const read = (dep: typeof DepService) => (id: number) => {/* use dep to satisfy*/}
MyService.of({
  read: read(dep),  // assigns the result of the HOF
  //...
})

Making internal Service calls and improving modularisation, especially with dependencies

Making internal Service calls and improving modularisation, especially with dependencies

Similar Threads

Similar Threads

Similar Threads