Model Layer Refactor

.eslintrc.json

@@ -24,6 +24,7 @@
   "rules": {
     "@typescript-eslint/lines-between-class-members": "off",
     "no-underscore-dangle": "off",
-    "import/prefer-default-export": "off"
+    "import/prefer-default-export": "off",
+    "max-len": ["warn", 120]
   }
 }

src/@types/Entities.ts

@@ -6,12 +6,23 @@ import {
 
 export type Entity = z.infer<typeof entityZodType>;
 
-export type User = z.infer<typeof userZodType>;
+export type User = Omit<z.infer<typeof userZodType>, 'company'> & {
+  company: string | Record<string, unknown>;
+};
 
-export type Company = z.infer<typeof companyZodType>;
+export type Company = Omit<z.infer<typeof companyZodType>, 'employees' | 'assets' | 'units'> & {
+  employees: string[] | Record<string, unknown>[];
+  assets: string[] | Record<string, unknown>[];
+  units: string[] | Record<string, unknown>[];
+};
 
-export type Unit = z.infer<typeof unitZodType>;
+export type Unit = Omit<z.infer<typeof unitZodType>, 'assets' | 'owner'> & {
+  assets: string[] | Record<string, unknown>[];
+  owner: string | Record<string, unknown>;
+};
 
-export type Asset = z.infer<typeof assetZodType>;
+export type Asset = Omit<z.infer<typeof assetZodType>, 'owner'> & {
+  owner: string | Record<string, unknown>;
+};
 
 export type Archive = z.infer<typeof archiveZodType>;

src/database/models/index.ts

@@ -0,0 +1,12 @@
+import { model } from 'mongoose';
+import archiveSchema from '../schemas/archiveSchema';
+import assetSchema from '../schemas/assetSchema';
+import companySchema from '../schemas/companySchema';
+import unitSchema from '../schemas/unitSchema';
+import userSchema from '../schemas/userSchema';
+
+export const User = model('User', userSchema);
+export const Asset = model('Asset', assetSchema);
+export const Company = model('Company', companySchema);
+export const Unit = model('Unit', unitSchema);
+export const Archive = model('Archive', archiveSchema);

src/database/schemas/assetSchema.ts

@@ -1,11 +1,7 @@
-import { ObjectId, Schema } from 'mongoose';
+import { Schema } from 'mongoose';
 import { Asset } from '../../@types/Entities';
 
-type SchemaCompatibleAsset = Omit<Asset, 'owner'> & {
-  owner: ObjectId;
-};
-
-const assetSchema = new Schema<SchemaCompatibleAsset>({
+const assetSchema = new Schema<Asset>({
   name: {
     type: String,
     require: [true, 'Asset name field is required.'],

src/database/schemas/companySchema.ts

@@ -1,13 +1,7 @@
-import { ObjectId, Schema } from 'mongoose';
+import { Schema } from 'mongoose';
 import { Company } from '../../@types/Entities';
 
-type SchemaCompatibleCompany = Omit<Company, 'assets' | 'employees' | 'units'> & {
-  assets: ObjectId[];
-  employees: ObjectId[];
-  units: ObjectId[];
-};
-
-const companySchema = new Schema<SchemaCompatibleCompany>({
+const companySchema = new Schema<Company>({
   name: {
     type: String,
     required: [true, 'Company name field is required.'],

src/database/schemas/unitSchema.ts

@@ -1,12 +1,7 @@
-import { ObjectId, Schema } from 'mongoose';
+import { Schema } from 'mongoose';
 import { Unit } from '../../@types/Entities';
 
-type SchemaCompatibleUnit = Omit<Unit, 'owner' | 'assets'> & {
-  assets: ObjectId[];
-  owner: ObjectId;
-};
-
-const unitSchema = new Schema<SchemaCompatibleUnit>({
+const unitSchema = new Schema<Unit>({
   name: {
     type: String,
     required: [true, 'Unit name field is required.'],

src/database/schemas/userSchema.ts

@@ -1,11 +1,7 @@
-import { ObjectId, Schema } from 'mongoose';
+import { Schema } from 'mongoose';
 import { User } from '../../@types/Entities';
 
-type SchemaCompatibleUser = Omit<User, 'company'> & {
-  company: ObjectId;
-};
-
-const userSchema = new Schema<SchemaCompatibleUser>({
+const userSchema = new Schema<User>({
   name: {
     type: String,
     required: [true, 'User name is required.'],

src/database/seeders/index.ts

@@ -1,34 +1,28 @@
 /* eslint-disable no-console */
-import AssetModel from '../models/AssetModel';
-import CompanyModel from '../models/CompanyModel';
-import UnitModel from '../models/UnitModel';
-import UserModel from '../models/UserModel';
 import assets from './Assets';
 import companies from './Companies';
 import units from './Units';
 import users from './Users';
 import { connect, disconnect, MONGO_URI_DEV } from '..';
+import {
+  Asset, Company, User, Unit,
+} from '../models';
 
 const seed = async (mongoURI = MONGO_URI_DEV) => {
-  const userModel = new UserModel();
-  const companyModel = new CompanyModel();
-  const assetModel = new AssetModel();
-  const unitModel = new UnitModel();
-
   try {
     await connect(mongoURI);
 
     console.log('Seeding users collection.');
-    await userModel.seed(users);
+    await User.insertMany(users);
 
     console.log('Seeding companies collection.');
-    await companyModel.seed(companies);
+    await Company.insertMany(companies);
 
     console.log('Seeding assets collection.');
-    await assetModel.seed(assets);
+    await Asset.insertMany(assets);
 
     console.log('Seeding units collection.');
-    await unitModel.seed(units);
+    await Unit.insertMany(units);
 
     console.log('Database seeding completed successfully.');
     await disconnect();

src/models/AssetModel.ts

@@ -0,0 +1,14 @@
+import { Asset as AssetType } from '../@types/Entities';
+import { IAssetModel } from '../interfaces/IAssetModel';
+import Model from './Model';
+import { Asset } from '../database/models';
+
+class AssetModel extends Model<AssetType> implements IAssetModel<AssetType> {
+  protected _populate = 'owner';
+
+  constructor() {
+    super(Asset);
+  }
+}
+
+export default AssetModel;

src/database/models/CompanyModel.ts → src/models/CompanyModel.ts

@@ -1,16 +1,16 @@
-import { Company } from '../../@types/Entities';
-import { ICompanyModel } from '../../interfaces/ICompanyModel';
-import companySchema from '../schemas/companySchema';
+import { Company as CompanyType } from '../@types/Entities';
+import { Company } from '../database/models';
+import { ICompanyModel } from '../interfaces/ICompanyModel';
 import Model from './Model';
 
-class CompanyModel extends Model<Company> implements ICompanyModel<Company> {
+class CompanyModel extends Model<CompanyType> implements ICompanyModel<CompanyType> {
   protected _populate = 'employees assets units';
 
   constructor() {
-    super('Company', companySchema);
+    super(Company);
   }
 
-  async editEmployeeList(id: string, employeeId: string, add: boolean): Promise<Company | null> {
+  async editEmployeeList(id: string, employeeId: string, add: boolean): Promise<CompanyType | null> {
     const edited = add
       ? await this._model.findByIdAndUpdate(id, {
         $push: { employees: employeeId },
@@ -19,10 +19,10 @@ class CompanyModel extends Model<Company> implements ICompanyModel<Company> {
         $pull: { employees: employeeId },
       }, { new: true });
 
-    return edited?.toObject() as Company;
+    return edited?.toObject() as CompanyType;
   }
 
-  async editAssetList(id: string, assetId: string, add: boolean): Promise<Company | null> {
+  async editAssetList(id: string, assetId: string, add: boolean): Promise<CompanyType | null> {
     const edited = add
       ? await this._model.findByIdAndUpdate(id, {
         $push: { assets: assetId },
@@ -31,10 +31,10 @@ class CompanyModel extends Model<Company> implements ICompanyModel<Company> {
         $pull: { assets: assetId },
       }, { new: true });
 
-    return edited?.toObject() as Company;
+    return edited?.toObject() as CompanyType;
   }
 
-  async editUnitList(id: string, unitId: string, add: boolean): Promise<Company | null> {
+  async editUnitList(id: string, unitId: string, add: boolean): Promise<CompanyType | null> {
     const edited = add
       ? await this._model.findByIdAndUpdate(id, {
         $push: { units: unitId },
@@ -43,7 +43,7 @@ class CompanyModel extends Model<Company> implements ICompanyModel<Company> {
         $pull: { units: unitId },
       }, { new: true });
 
-    return edited?.toObject() as Company;
+    return edited?.toObject() as CompanyType;
   }
 }
 

src/database/models/Model.ts → src/models/Model.ts

@@ -1,16 +1,14 @@
-import { model, Schema } from 'mongoose';
-import { IModel } from '../../interfaces/IModel';
-import { Entity, Archive } from '../../@types/Entities';
-import archiveSchema from '../schemas/archiveSchema';
+import { Model as MongoModel } from 'mongoose';
+import { IModel } from '../interfaces/IModel';
+import { Entity, Archive as ArchiveType } from '../@types/Entities';
+import { Archive } from '../database/models';
 
 abstract class Model<T extends Entity> implements IModel<T> {
   protected abstract _populate: string;
-  private _archive;
   protected _model;
 
-  constructor(entityName: string, schema: Schema) {
-    this._model = model(entityName, schema);
-    this._archive = model('Archive', archiveSchema);
+  constructor(model: MongoModel<T>) {
+    this._model = model;
   }
 
   async createOne(object: T): Promise<T> {
@@ -51,20 +49,15 @@ abstract class Model<T extends Entity> implements IModel<T> {
 
     // This saves the object in an archive that is only accessible by the database admins.
     // With this, data is not lost forever and can be consulted if necessary.
-    const archived: Archive = {
+    const archived: ArchiveType = {
       collectionName: this._model.collection.collectionName,
       document: deleted,
     };
 
-    await this._archive.create(archived);
+    await Archive.create(archived);
 
     return deleted as T;
   }
-
-  async seed(objects: T[], reset = true): Promise<void> {
-    if (reset) await this._model.deleteMany();
-    await this._model.insertMany(objects);
-  }
 }
 
 export default Model;

src/database/models/UnitModel.ts → src/models/UnitModel.ts

@@ -1,16 +1,16 @@
-import { Unit } from '../../@types/Entities';
-import { IUnitModel } from '../../interfaces/IUnitModel';
-import unitSchema from '../schemas/unitSchema';
+import { Unit as UnitType } from '../@types/Entities';
+import { IUnitModel } from '../interfaces/IUnitModel';
 import Model from './Model';
+import { Unit } from '../database/models';
 
-class UnitModel extends Model<Unit> implements IUnitModel<Unit> {
+class UnitModel extends Model<UnitType> implements IUnitModel<UnitType> {
   protected _populate = 'owner assets';
 
   constructor() {
-    super('Unit', unitSchema);
+    super(Unit);
   }
 
-  async editAssetList(id: string, assetId: string, add: boolean): Promise<Unit | null> {
+  async editAssetList(id: string, assetId: string, add: boolean): Promise<UnitType | null> {
     const edited = add
       ? await this._model.findByIdAndUpdate(id, {
         $push: { assets: assetId },
@@ -19,7 +19,7 @@ class UnitModel extends Model<Unit> implements IUnitModel<Unit> {
         $pull: { assets: assetId },
       }, { new: true });
 
-    return edited?.toObject() as Unit;
+    return edited?.toObject() as UnitType;
   }
 }
 

src/database/models/UserModel.ts → src/models/UserModel.ts

@@ -1,33 +1,33 @@
-import { User } from '../../@types/Entities';
-import { IUserModel } from '../../interfaces/IUserModel';
-import userSchema from '../schemas/userSchema';
+import { User as UserType } from '../@types/Entities';
+import { IUserModel } from '../interfaces/IUserModel';
 import Model from './Model';
+import { User } from '../database/models';
 
-class UserModel extends Model<User> implements IUserModel<User> {
+class UserModel extends Model<UserType> implements IUserModel<UserType> {
   protected _populate = 'company';
   constructor() {
-    super('User', userSchema);
+    super(User);
   }
 
   // Override for deleting the user password.
-  async createOne(user: User): Promise<User> {
+  async createOne(user: UserType): Promise<UserType> {
     const created = await (await this._model.create(user)).toObject();
     delete created.password;
-    return created as User;
+    return created as UserType;
   }
 
   /**
    * Finds a user with matching email in the database.
    * @param email The user's email.
    * @returns The user with the passed email. Null if no user found.
    */
-  async findByEmail(email: string, login = false): Promise<User | null> {
+  async findByEmail(email: string, login = false): Promise<UserType | null> {
     const select = login ? '+password' : '';
     const found = await this._model.findOne({ email })
       .populate(this._populate)
       .select(select);
 
-    return found as User | null;
+    return found as UserType | null;
   }
 }
 

src/services/AssetService.ts

@@ -1,6 +1,6 @@
 import { AssetStatus } from '../@types/AssetStatus';
 import { Asset } from '../@types/Entities';
-import AssetModel from '../database/models/AssetModel';
+import AssetModel from '../models/AssetModel';
 import Service from './Service';
 
 class AssetService extends Service<Asset> {