Partial Caching

partial caching is particularly useful when an operation combined with cacheable and not cacheable jobs

// let's say SomeService have three methods: taskA, taskB, taskC
// assume that taskA and taskC can be cached, but taskB not
// each of task takes 1 second to complete

// in this scenario, @Nestjs/cache-manager can't handle caching because it's stick with interceptor
// but we can cover this case using partial caching
@Injectable()
class SomeService {

    @InMemoryCache(...)
    taskA() {} // originally takes 1 second

    // not cacheable
    taskB() {} // takes 1 second

    @InMemoryCache(...)
    taskC() {} // originally takes 1 second
}


@Controller()
class SomeController {
    constructor(
        private someService: SomeService
    ) {}

    // this route can take slightest time because taskA and taskC is partially cached
    // execution time can be reduced 3 seconds to 1 second
    @Get()
    route1() {
        someService.taskA(); // takes no time
        someService.taskB(); // still takes 1 second
        someService.taskC(); // takes no time
    }
}

Cache Busting

// we need to set same key to set & unset cache
// keep in mind that cache control by parameters is supported for temporal cache only
@Controller()
class SomeController {
    @Get()
    @InMemoryCache({
        key: 'hello',
        kind: 'persistent',
    })
    getSomethingHeavy() {
        ...
    }

    @Put()
    // in this case, we are busting persistent cache
    // after busting persistent cache, when busting method is done,
    // persistent cached method(getSomethingHeavy in this case) will invoked immediately
    // so you can still get the updated cache from persistent cache route!
    @InMemoryCache({
        key: 'hello',
        kind: 'bust',
    })
    updateSomethingHeavy() {
        ...
    }


    // this route sets cache for key 'some'
    @Get('/some')
    @InMemoryCache({
        key: 'some',
        kind:'temporal',
        ttl: 30 * SECOND, // 30 seconds
    })
    getSome() {
        ...
    }

    // and this route will unset cache for key 'some', before the 'some' cache's ttl expires
    @Patch('/some')
    @InMemoryCache({
        key: 'some',
        kind: 'bust',
    })
    updateSome() {
        ...
    }

    // above operation also can handle parameter based cache
    @Get('/:p1/:p2')
    @ExternalCache({
        key: 'some',
        kind:'temporal',
        ttl: 30 * SECOND, // 30 seconds
        paramIndex: [0, 1]
    })
    getSomeOther(@Param('p1') p1: string, @Param('p2') p2: string) {
        ...
    }

    // will unset cache of some + p1 + p2
    @Patch('/:p1/:p2')
    @ExternalCache({
        key: 'some',
        kind: 'bust',
        paramIndex: [0, 1]
    })
    updateSomeOther(@Param('p1') p1: string, @Param('p2') p2: string) {
        ...
    }

    // if you want to unset all cache based on a key, you can use bustAllChildren option.
    // this will only work for temporal cache.
    @Get('/foo')
    @ExternalCache({
        key: 'foo',
        kind: 'temporal',
        ttl: 30 * SECOND,
    })
    getFoo() {
        ...
    }

    @Get('foo/:p1/:p2')
    @ExternalCache({
        key: 'foo',
        kind: 'temporal',
        ttl: 30 * SECOND,
        paramIndex: [0, 1]
    })
    getFooOther(@Param('p1') p1: string, @Param('p2') p2: string) {
        ...
    }

    @Patch('/foo')
    @ExternalCache({
        key: 'foo',
        kind: 'bust',
        bustAllChildren: true
    })
    updateFoo() {
        ...
    }
}

Additional Busting within one route

In many cases, change to a single data affects multiple outputs. For example, if you modify "User" data, you have to remove caches of "User", "MyPage", "Friends". So, Omacache provide capability to remove all related caches at once.

@Put("/users/:userId")
@InMemoryCache({
    kind: "bust",
    key: "user",
    paramIndex:[0],
    // additional bustings
    // It's same type of "bust" but except kind & addition
    addition: [
        {
            key: "my_page",
            // this would not remove cache if
            // route that sets "my_page" cache construct cache key with different parameter poisition
            paramIndex:[0]
        },
        {
            key: "friends",
            bustAllChildren: true
        }
    ]
})
modifyUser(@Param("userId") userId: string, @Body() body: any) {
    ...
}

Caution

1. persistent cache must used on method without parameters, otherwise, it will throw error that presents persistent cache cannot applied to method that have parameters.
2. cache set does not awaited internally for not interrupting business logics. only when integrity matters, it awaits(i.e. 'has' method). If you implemented all ICacheStorage signatures synchronously, you don't have to concern about it.