chore: add logic to create/update on service instead of crudservice

packages/nestjs-cache/src/controllers/cache-crud.controller.e2e-spec.ts

@@ -111,7 +111,7 @@ describe('CacheAssignmentController (e2e)', () => {
       });
   });
 
-  it('POST /cache/user', async () => {
+  it('POST /cache/user creating user with success', async () => {
     const payload: CacheCreatableInterface = {
       key: 'dashboard-1',
       type: 'filter',
@@ -265,6 +265,71 @@ describe('CacheAssignmentController (e2e)', () => {
         expect(res.body.data).toBe(payload.data);
         expect(res.body.assignee.id).toBe(user.id);
       });
+
+    const url =
+      `/cache/user/` +
+      `?filter[0]=key||$eq||${payload.key}` +
+      `&filter[1]=type||$eq||${payload.type}` +
+      `&filter[2]=assignee.id||$eq||${payload.assignee.id}`;
+    // Assuming your endpoint can filter by key and type
+    await supertest(app.getHttpServer())
+      .get(url)
+      .expect(200)
+      .then((res) => {
+        const response = res.body[0];
+        assert.strictEqual(response.assignee.id, user.id);
+        assert.strictEqual(response.key, payload.key);
+        assert.strictEqual(response.type, payload.type);
+        assert.strictEqual(response.data, payload.data);
+      });
+  });
+
+  it.only('PUT /cache/user replace', async () => {
+    const payload: CacheCreatableInterface = {
+      key: 'dashboard-1',
+      type: 'filter',
+      data: '{}',
+      expiresIn: '1d',
+      assignee: { id: user.id },
+    };
+    let cacheId = '';
+    await supertest(app.getHttpServer())
+      .put('/cache/user')
+      .send(payload)
+      .expect(200)
+      .then((res) => {
+        cacheId = res.body.id;
+        expect(res.body.key).toBe(payload.key);
+        expect(res.body.assignee.id).toBe(user.id);
+      });
+    payload.data = '{ "name": "John Doe" }';
+    payload.expiresIn = null;
+    await supertest(app.getHttpServer())
+      .put(`/cache/user/${cacheId}`)
+      .send(payload)
+      .expect(200)
+      .then((res) => {
+        expect(res.body.key).toBe(payload.key);
+        expect(res.body.data).toBe(payload.data);
+        expect(res.body.assignee.id).toBe(user.id);
+      });
+
+    const url =
+      `/cache/user/` +
+      `?filter[0]=key||$eq||${payload.key}` +
+      `&filter[1]=type||$eq||${payload.type}` +
+      `&filter[2]=assignee.id||$eq||${payload.assignee.id}`;
+    // Assuming your endpoint can filter by key and type
+    await supertest(app.getHttpServer())
+      .get(url)
+      .expect(200)
+      .then((res) => {
+        const response = res.body[0];
+        assert.strictEqual(response.assignee.id, user.id);
+        assert.strictEqual(response.key, payload.key);
+        assert.strictEqual(response.type, payload.type);
+        assert.strictEqual(response.data, payload.data);
+      });
   });
 
   it('DELETE /cache/user/:id', async () => {

packages/nestjs-cache/src/controllers/cache-crud.controller.ts

@@ -1,5 +1,5 @@
-import { Inject, Param } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
+import { Inject, Param, Put } from '@nestjs/common';
+import { ApiOkResponse, ApiTags } from '@nestjs/swagger';
 import {
   AccessControlCreateOne,
   AccessControlDeleteOne,
@@ -14,6 +14,7 @@ import {
   CrudDeleteOne,
   CrudReadMany,
   CrudReadOne,
+  CrudReplaceOne,
   CrudRequest,
   CrudRequestInterface,
   CrudUpdateOne,
@@ -64,7 +65,7 @@ export class CacheCrudController
       CacheInterface,
       CacheCreatableInterface,
       CacheUpdatableInterface,
-      never
+      CacheCreatableInterface
     >
 {
   /**
@@ -130,42 +131,18 @@ export class CacheCrudController
       cacheCreateDto.expiresIn ?? this.settings.expiresIn,
     );
 
-    const existingCache = await this.cacheService.get(
-      assignment,
-      cacheCreateDto,
-    );
-
-    // update or create
-    if (existingCache) {
-      crudRequest.parsed.search.$and?.push({
-        id: {
-          $eq: existingCache.id,
-        },
-      });
-      // call crud service to create
-      const response = await this.getCrudService(assignment).updateOne(
-        crudRequest,
-        {
-          id: existingCache.id,
-          ...cacheCreateDto,
-          expirationDate,
-        },
-      );
-      return response;
-    } else {
-      // call crud service to create
-      return this.getCrudService(assignment).createOne(crudRequest, {
-        ...cacheCreateDto,
-        expirationDate,
-      });
-    }
+    // call crud service to create
+    return this.getCrudService(assignment).createOne(crudRequest, {
+      ...cacheCreateDto,
+      expirationDate,
+    });
   }
 
   /**
    * Create one
    *
    * @param crudRequest - the CRUD request object
-   * @param cacheUpdateDto - cache create dto
+   * @param cacheUpdateDto - cache update dto
    * @param assignment - The cache assignment
    */
   @CrudUpdateOne()
@@ -219,6 +196,46 @@ export class CacheCrudController
     }
   }
 
+  /**
+   * Do a Upsert operation for cache
+   *
+   * @param crudRequest - the CRUD request object
+   * @param cacheUpdateDto - cache update dto
+   * @param assignment - The cache assignment
+   */
+  @Put(':id?')
+  @ApiOkResponse({
+    type: CacheDto,
+  })
+  @CrudReplaceOne()
+  @AccessControlCreateOne(CacheResource.One)
+  async replaceOne(
+    @CrudRequest() crudRequest: CrudRequestInterface,
+    @CrudBody() cacheUpdateDto: CacheUpdateDto,
+    @Param('assignment') assignment: ReferenceAssignment,
+  ) {
+    let cache;
+    try {
+      cache = await this.getOne(crudRequest, assignment);
+    } catch (error) {
+      // TODO: find a better aproach
+      // getOne throws and error if id does not match
+    }
+    if (cache && cache?.id) {
+      const expirationDate = getExpirationDate(
+        cacheUpdateDto.expiresIn ?? this.settings.expiresIn,
+      );
+
+      // call crud service to create
+      return this.getCrudService(assignment).replaceOne(crudRequest, {
+        ...cacheUpdateDto,
+        expirationDate,
+      });
+    } else {
+      return this.createOne(crudRequest, cacheUpdateDto, assignment);
+    }
+  }
+
   /**
    * Get the entity key for the given assignment.
    *

packages/nestjs-cache/src/interfaces/cache-service.interface.ts

@@ -2,6 +2,7 @@ import { ReferenceAssignment } from '@concepta/ts-core';
 import { QueryOptionsInterface } from '@concepta/typeorm-common';
 import {
   CacheClearInterface,
+  CacheCreatableInterface,
   CacheCreateInterface,
   CacheDeleteInterface,
   CacheGetOneInterface,
@@ -15,6 +16,12 @@ export interface CacheServiceInterface
     CacheUpdateInterface<QueryOptionsInterface>,
     CacheGetOneInterface<QueryOptionsInterface>,
     CacheClearInterface<QueryOptionsInterface> {
+  updateOrCreate(
+    assignment: ReferenceAssignment,
+    cache: CacheCreatableInterface,
+    options?: QueryOptionsInterface,
+  ): Promise<CacheInterface>;
+
   getAssignedCaches(
     assignment: ReferenceAssignment,
     cache: Pick<CacheInterface, 'assignee'>,

packages/nestjs-cache/src/services/cache.service.ts

@@ -239,6 +239,19 @@ export class CacheService implements CacheServiceInterface {
     }
   }
 
+  async updateOrCreate(
+    assignment: ReferenceAssignment,
+    cache: CacheCreateDto,
+    queryOptions?: QueryOptionsInterface,
+  ): Promise<CacheInterface> {
+    const existingCache = await this.get(assignment, cache, queryOptions);
+    if (existingCache) {
+      return await this.update(assignment, cache, queryOptions);
+    } else {
+      return await this.create(assignment, cache, queryOptions);
+    }
+  }
+
   // Should this be on nestjs-common?
   protected async validateDto<T extends DeepPartial<CacheInterface>>(
     type: Type<T>,