simplify user model; adjust email auth output

Author: DylanBulmer

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codrjs/core",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "An open-sourced customizable annotation tool",
   "main": "./cjs/index.js",
   "module": "./esm/index.js",

src/models/Profile.ts

@@ -3,15 +3,18 @@ import {
   AccessibleModel,
   accessibleRecordsPlugin,
 } from "@casl/mongoose";
-import { Schema, model, Document } from "mongoose";
+import { Schema, model, Document, ObjectId } from "mongoose";
 
-export interface IProfile extends Document {
+export interface Profile {
   avatarUrl?: string;
   username: string;
   user: Schema.Types.ObjectId;
 }
 
-const ProfileSchema = new Schema<IProfile>(
+type IProfileSchema = IProfile & Document
+export type IProfile = Profile & { _id: ObjectId }
+
+const ProfileSchema = new Schema<Profile>(
   {
     username: { type: String, required: true, unique: true },
     avatarUrl: { type: String },
@@ -29,7 +32,7 @@ const ProfileSchema = new Schema<IProfile>(
 // exports User model.
 ProfileSchema.plugin(accessibleFieldsPlugin);
 ProfileSchema.plugin(accessibleRecordsPlugin);
-const Profile = model<IProfile, AccessibleModel<IProfile>>(
+const Profile = model<IProfileSchema, AccessibleModel<IProfileSchema>>(
   "Profile",
   ProfileSchema,
 );

src/models/User.ts

@@ -4,56 +4,34 @@ import {
   AccessibleModel,
   accessibleRecordsPlugin,
 } from "@casl/mongoose";
-import { Schema, model, Document } from "mongoose";
+import { Schema, model, Document, ObjectId } from "mongoose";
 
 type Role = "admin" | "researcher" | "annotator";
 export type UserRoleType = `codr:${Role}`;
 
-interface IUserProvider {
-  photo?: string;
-  phone?: string;
-  email: string;
-  uid: string;
-}
-
-export interface IUserName {
-  first: string;
-  last: string;
-  preferred: string;
-}
-
-export interface IUser extends Document {
-  name?: IUserName;
+interface User {
+  name?: {
+    first: string;
+    last: string;
+    preferred?: string;
+  };
   email: string;
   accessToken: string;
   refreshToken: string;
-  providers?: IUserProvider;
-  isAdmin: boolean;
   role: UserRoleType;
-  disabled: boolean;
-  anonymous: boolean;
+  flags: {
+    isDisabled: boolean;
+    isAnonymous: boolean;
+  };
 }
 
-const UserProvider = new Schema<IUserProvider>({
-  photo: { type: String },
-  phone: { type: String },
-  email: { type: String, required: true },
-  uid: {
-    type: String,
-    required: [true, "Provider's unique identifier is required"],
-  },
-});
-
-const UserName = new Schema<IUserName>({
-  first: { type: String },
-  last: { type: String },
-  preferred: { type: String },
-});
+type IUserSchema = User & Document;
+export type IUser = User & { _id: ObjectId }
 
-const UserSchema = new Schema<IUser>(
+const UserSchema = new Schema<User>(
   {
     name: {
-      type: UserName,
+      type: Object,
     },
     email: {
       type: String,
@@ -69,33 +47,23 @@ const UserSchema = new Schema<IUser>(
     },
     accessToken: { type: String },
     refreshToken: { type: String },
-    providers: {
-      type: [UserProvider],
-    },
     role: {
       type: String,
       required: [true, "Please specify the user's role."],
     },
-    disabled: {
-      type: Boolean,
-      default: false,
-    },
-    anonymous: {
-      type: Boolean,
-      default: false,
+    flags: {
+      type: Object,
+      required: true,
+      default: { isAnonymous: false, isDisabled: false },
     },
   },
   {
     timestamps: true,
   },
 );
 
-UserSchema.virtual("fullName").get(function get() {
-  return this.name?.preferred + " " + this.name?.last;
-});
-
 // exports User model.
 UserSchema.plugin(accessibleFieldsPlugin);
 UserSchema.plugin(accessibleRecordsPlugin);
-const User = model<IUser, AccessibleModel<IUser>>("User", UserSchema);
+const User = model<IUserSchema, AccessibleModel<IUserSchema>>("User", UserSchema);
 export default User;

src/services/admin.ts

@@ -3,9 +3,8 @@
  */
 
 import { MailTemplate, Response, Error } from "../classes/index.js";
-import { Types } from "mongoose";
 import { UserToken } from "../classes/JWT.js";
-import User, { IUser, IUserName, UserRoleType } from "../models/User.js";
+import User, { IUser, UserRoleType } from "../models/User.js";
 import App from "./app.js";
 import Mail from "./mail/index.js";
 
@@ -24,7 +23,7 @@ class Administration {
 
   async addUser(
     user: UserToken,
-    newUser: { email: string; role: UserRoleType; name?: IUserName },
+    newUser: { email: string; role: UserRoleType; name?: IUser["name"], isAnonymous: boolean; },
   ) {
     if (this.app.mongoIsConnected) {
       // check if user is admin; will throw an error if not.
@@ -83,9 +82,9 @@ class Administration {
    */
   async addUsers(
     user: UserToken,
-    newUsers: { email: string; role: UserRoleType }[],
+    newUsers: { email: string; role: UserRoleType, isAnonymous: boolean }[],
   ) {
-    const users: (IUser & { _id: Types.ObjectId })[] = [];
+    const users: (IUser)[] = [];
     const errors: Error<
       { email: string; role: UserRoleType } | { connectionStatus: string }
     >[] = [];

src/services/auth.ts

@@ -9,7 +9,7 @@ import Email from "../classes/Email.js";
 import SigninTemplate from "../classes/MailTemplate/Signin.js";
 import User, { IUser } from "../models/User.js";
 import Response from "../classes/Response.js";
-import { generateToken, UserToken, verifyToken } from "../classes/JWT.js";
+import * as JWT from "../classes/JWT.js";
 import Error from "../classes/Error.js";
 import AccessToken from "../classes/AccessToken.js";
 import { decrypt, encrypt } from "../utils/AccessToken";
@@ -32,7 +32,7 @@ class Authentication {
 
   async signinWithEmail(
     accessCode: string,
-  ): Promise<Response<undefined | { token: string }>> {
+  ): Promise<Response<undefined | { user: IUser }>> {
     const { email, token } = decrypt<IAccessCode>(accessCode);
     if (!email) {
       throw new Error({
@@ -113,13 +113,10 @@ class Authentication {
         }
 
         try {
-          // generate JWT token
-          const token = generateToken({ ...user.toJSON(), ...update } as IUser);
-
           // send response
-          return new Response<{ token: string }>({
+          return new Response<{ user: IUser }>({
             message: `Login successful.`,
-            details: { token },
+            details: { user: {...user.toObject(), ...update} },
           });
         } catch (e: any) {
           throw new Error({
@@ -145,10 +142,10 @@ class Authentication {
   }
 
   updateJWT(oldJWT: string, payload: IUser) {
-    verifyToken(oldJWT);
+    JWT.verifyToken(oldJWT);
 
-    const jwt = generateToken(payload);
-    return { jwt, user: decode(jwt) as UserToken };
+    const jwt = JWT.generateToken(payload);
+    return { jwt, user: decode(jwt) as JWT.UserToken };
   }
 }