@solidstarters/solid-core 1.2.13 → 1.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.13",
+  "version": "1.2.15",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/controllers/google-authentication.controller.ts

@@ -74,8 +74,7 @@ export class GoogleAuthenticationController {
     }
 
     /**
-     * This is just a dummy endpoint where we are passing in the accessCode, this will be configured in the .env as an environment variable and 
-     * will be passed the accessCode, using the accessCode the UI code on this page will mostly invoke the /iam/google/auth endpoint which will finally generate the JWT token.
+     * Use this endpoint to authenticate using an accessCode with Google.
      * 
      * @param accessCode 
      * @returns 

package/src/services/authentication.service.ts

@@ -925,7 +925,19 @@ export class AuthenticationService {
         await this.validateUserUsingGoogle(user);
 
         // finally we simply generate the tokens. 
-        return await this.generateTokens(user);
+        const tokens = this.generateTokens(user);
+        return {
+            user: {
+                email: user.email,
+                mobile: user.mobile,
+                username: user.username,
+                forcePasswordChange: user.forcePasswordChange,
+                id: user.id,
+                roles: user.roles.map((role, idx, roles) => role.name)
+            },
+            ...tokens
+        }
+
     }
 
     private isPasswordlessRegistrationEnabled() {

package/src/services/crud.service.ts

@@ -1,7 +1,7 @@
 import { BadRequestException } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { DiscoveryService } from "@nestjs/core";
-import { EntityManager, QueryFailedError, SelectQueryBuilder } from "typeorm";
+import { EntityManager, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
 import { Repository } from "typeorm/repository/Repository";
 import { BasicFilterDto } from "../dtos/basic-filters.dto";
 import { ComputedFieldValueType, RelationType, SelectionValueType, SolidFieldType } from "../dtos/create-field-metadata.dto";
@@ -649,4 +649,77 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         // return removedEntities
     }
 
+    async recover(id: number) {
+        try {
+          const softDeletedRows = await this.repo.findOne({
+            where: { 
+                //@ts-ignore
+                id, deletedAt: Not(IsNull()) 
+            },
+            withDeleted: true,
+          });
+      
+          if (!softDeletedRows) {
+            throw new Error('No soft-deleted record found with the given ID.');
+          }
+      
+          await this.repo.update(id, {
+                //@ts-ignore
+                deletedAt: null, deletedTracker: "not-deleted" 
+            });
+      
+          return { message: 'Record successfully recovered', data: softDeletedRows };
+        } catch (error) {
+          if (error instanceof QueryFailedError) {
+            if ((error as any).code === '23505') {
+              throw new Error('Another record is conflicting with the record you are attempting to Un-Archive, either delete or change the other record so as to avoid this conflict.');
+            }
+          }
+    
+          throw new Error(error);
+        }
+    }
+    
+    async recoverMany(ids: number[]) {
+        try {
+            if (!ids || ids.length === 0) {
+                throw new Error("No IDs provided for recovery.");
+            }
+    
+            // Find soft-deleted records matching the given IDs
+            const softDeletedRows = await this.repo.find({
+                where: {
+                    //@ts-ignore
+                    id: In(ids),
+                    deletedAt: Not(IsNull()),
+                },
+                withDeleted: true,
+            });
+    
+            if (softDeletedRows.length === 0) {
+                throw new Error("No matching soft-deleted records found.");
+            }
+    
+            // Recover the specific records by setting deletedAt to null
+            await this.repo.update(
+                //@ts-ignore
+                { id: In(ids) },
+                { deletedAt: null, deletedTracker: "not-deleted" }
+            );
+    
+            return { message: "Selected records successfully recovered", recoveredIds: ids };
+        } catch (error) {
+            if (error instanceof QueryFailedError) {
+                if ((error as any).code === "23505") {
+                    throw new Error(
+                        "Another record is conflicting with the record you are attempting to Un-Archive, either delete or change the other record to avoid this conflict."
+                    );
+                }
+            }
+    
+            throw new Error(error);
+        }
+    }
+    
+
 }

package/src/workflow.readme.md

@@ -10,7 +10,7 @@ Let's say that:
 3. The backend redirects the tab to the Google login page where the user logs in.
 4. Once done, Google redirects the tab to the backend URL: https://solid.website.com/api/iam/google/connect/callback. When this callback comes, it comes with the users profile & access token.
 5. Then, the backend redirects the tab to the url of your choice with the param accessCode (example: http://website.com/connect/google/dummy-redirect?accessCode=eyfvg).
-6. The frontend (http://website.com/connect/google/dummy-redirect) calls the backend with https://solid.website.com/api/iam/google/auth?accessCode=eyfvg that returns the Solid user profile with its jwt.
+6. The frontend (http://website.com/connect/google/dummy-redirect) calls the backend with https://solid.website.com/api/iam/google/authenticate?accessCode=eyfvg that returns the Solid user profile with its jwt.
    (Under the hood, the backend asks Google for the user's profile and a match is done on Google user's email address and Solid user's email address).
 7. The frontend now possesses the user's jwt, which means the user is connected and the frontend can make authenticated requests to the backend!