Testing CI

backend/connection.ts

@@ -1,5 +1,5 @@
-import mongoose from 'mongoose';
-import dotenv from 'dotenv';
+import mongoose from "mongoose";
+import dotenv from "dotenv";
 
 dotenv.config();
 
@@ -12,9 +12,9 @@ let connection: typeof mongoose;
  * @returns {Promise<typeof mongoose>}
  */
 const connectDB = async () => {
-  console.log('Checking database connection...');
+  console.log("Checking database connection...");
   if (!connection) {
-    console.log('Connecting to database...');
+    console.log("Connecting to database...");
     console.log(url);
     try {
       connection = await mongoose.connect(url);

backend/eslint.config.cjs

@@ -0,0 +1,30 @@
+const tsParser = require("@typescript-eslint/parser");
+const tsPlugin = require("@typescript-eslint/eslint-plugin");
+
+module.exports = [
+  {
+    files: ["**/*.ts", "**/*.js"],
+    languageOptions: {
+      ecmaVersion: 2021,
+      sourceType: "module",
+      parser: {
+        parse: tsParser.parse.bind(tsParser),
+        parseForESLint: tsParser.parseForESLint.bind(tsParser),
+      },
+      globals: {
+        browser: true,
+        node: true,
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tsPlugin,
+    },
+    rules: {
+      semi: ["error", "always"],
+      quotes: ["error", "double"],
+    },
+    linterOptions: {
+      reportUnusedDisableDirectives: true,
+    },
+  },
+];

backend/index.ts

@@ -3,15 +3,17 @@ import { userEndpoints } from "./routes/userRoutes";
 import { groupEndpoints } from "./routes/groupRoutes";
 import { basketEndpoints } from "./routes/basketRoutes";
 import { itemEndpoints } from "./routes/itemRoutes";
-import connectDB from "./connection";
 
 const app: Express = express();
 app.use(express.json());
 
 // Enable CORS
 app.use((req: Request, res: Response, next: NextFunction) => {
   res.header("Access-Control-Allow-Origin", "*");
-  res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+  res.header(
+    "Access-Control-Allow-Headers",
+    "Origin, X-Requested-With, Content-Type, Accept",
+  );
   res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS, DELETE, PUT");
   next();
 });
@@ -34,9 +36,6 @@ app.get("/", async (req: Request, res: Response) => {
   res.send(result);
 });
 
-
-
-
 // Error handling middleware
 app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
   console.error(err.stack);

backend/models/basketSchema.ts

@@ -1,22 +1,23 @@
 import mongoose, { Schema } from "mongoose";
 
 export type IBasket = {
-    _id: Schema.Types.ObjectId;
-    basketName: string;
-    description: string;
-    members: Schema.Types.ObjectId[] | null;
-    items: Schema.Types.ObjectId[] | null;
-    created: Date;
+  _id: Schema.Types.ObjectId;
+  basketName: string;
+  description: string;
+  members: Schema.Types.ObjectId[] | null;
+  items: Schema.Types.ObjectId[] | null;
+  created: Date;
 };
 
 const BasketSchema = new Schema<IBasket>({
-    basketName: { type: String, required: true },
-    description: { type: String, required: true },
-    members: { type: [Schema.Types.ObjectId], required: true, default: [] },
-    items: { type: [Schema.Types.ObjectId], required: true, default: [] },
-    created: { type: Date, required: true, default: Date.now },
+  basketName: { type: String, required: true },
+  description: { type: String, required: true },
+  members: { type: [Schema.Types.ObjectId], required: true, default: [] },
+  items: { type: [Schema.Types.ObjectId], required: true, default: [] },
+  created: { type: Date, required: true, default: Date.now },
 });
 
-const Basket = mongoose.models["basket"] || mongoose.model("basket", BasketSchema);
+const Basket =
+  mongoose.models["basket"] || mongoose.model("basket", BasketSchema);
 
-export default Basket;
+export default Basket;

backend/models/groupSchema.ts

@@ -1,24 +1,25 @@
 import mongoose, { Schema } from "mongoose";
 
 export type IGroup = {
-    _id: Schema.Types.ObjectId;
-    groupName: string;
-    privateGroup: boolean;
-    description: string;
-    members: Schema.Types.ObjectId[] | null;
-    baskets: Schema.Types.ObjectId[] | null;
-    created: Date;
+  _id: Schema.Types.ObjectId;
+  groupName: string;
+  privateGroup: boolean;
+  description: string;
+  members: Schema.Types.ObjectId[] | null;
+  baskets: Schema.Types.ObjectId[] | null;
+  created: Date;
 };
 
 const GroupSchema = new Schema<IGroup>({
-    groupName: { type: String, required: true },
-    privateGroup: { type: Boolean, required: true },
-    description: { type: String, required: true },
-    members: { type: [Schema.Types.ObjectId], required: true, default: [] },
-    baskets: { type: [Schema.Types.ObjectId], required: true, default: [] },
-    created: { type: Date, required: true, default: Date.now },
+  groupName: { type: String, required: true },
+  privateGroup: { type: Boolean, required: true },
+  description: { type: String, required: true },
+  members: { type: [Schema.Types.ObjectId], required: true, default: [] },
+  baskets: { type: [Schema.Types.ObjectId], required: true, default: [] },
+  created: { type: Date, required: true, default: Date.now },
 });
 
-const Group = mongoose.models["groups"] || mongoose.model("groups", GroupSchema);
+const Group =
+  mongoose.models["groups"] || mongoose.model("groups", GroupSchema);
 
 export default Group;

backend/models/itemSchema.ts

@@ -1,31 +1,31 @@
 import mongoose, { Schema } from "mongoose";
 
 export type IItem = {
-    _id: Schema.Types.ObjectId,
-    name: string,
-    toShare: boolean,
-    isPrivate: boolean,
-    type: string,
-    basket: Schema.Types.ObjectId,
-    notes: string,
-    price: number,
-    quantity: number,
-    created: Date,
-    lastModified: Date,
+  _id: Schema.Types.ObjectId;
+  name: string;
+  toShare: boolean;
+  isPrivate: boolean;
+  type: string;
+  basket: Schema.Types.ObjectId;
+  notes: string;
+  price: number;
+  quantity: number;
+  created: Date;
+  lastModified: Date;
 };
 
 // Mongoose schema
 const itemSchema = new Schema({
-    name: { type: String, required: true },
-    toShare: { type: Boolean, required: true },
-    isPrivate: { type: Boolean, required: true },
-    type: { type: String, required: true },
-    basket: { type: Schema.Types.ObjectId, required: true },
-    notes: { type: String, required: true },
-    price: { type: Number, required: true },
-    quantity: { type: Number, required: true },
-    created: { type: Date, required: true, default: Date.now },
-    lastModified: { type: Date, required: true, default: Date.now },
+  name: { type: String, required: true },
+  toShare: { type: Boolean, required: true },
+  isPrivate: { type: Boolean, required: true },
+  type: { type: String, required: true },
+  basket: { type: Schema.Types.ObjectId, required: true },
+  notes: { type: String, required: true },
+  price: { type: Number, required: true },
+  quantity: { type: Number, required: true },
+  created: { type: Date, required: true, default: Date.now },
+  lastModified: { type: Date, required: true, default: Date.now },
 });
 
 const Event = mongoose.models["items"] || mongoose.model("items", itemSchema);

backend/models/userSchema.ts

@@ -1,29 +1,29 @@
 import mongoose, { Schema } from "mongoose";
 
 export type IUser = {
-    _id: Schema.Types.ObjectId;
-    username: string;
-    email: string;
-    firstName: string;
-    lastName: string;
-    groups: Schema.Types.ObjectId[] | null;
-    friends: Schema.Types.ObjectId[] | null;
-    wishlist: string[] | null;
-    joined: Date;
+  _id: Schema.Types.ObjectId;
+  username: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  groups: Schema.Types.ObjectId[] | null;
+  friends: Schema.Types.ObjectId[] | null;
+  wishlist: string[] | null;
+  joined: Date;
 };
 
 //groupId and digitalWaiver seem to require a schema
 //currently there is no schema for them so I am leaving them as null for now
 //can groupId just be a string and digitalWaiver be a boolean?
 const UserSchema = new Schema<IUser>({
-    username: { type: String, required: true },
-    email: {type: String, required: true},
-    firstName: {type: String, required: true},
-    lastName: {type: String, required: true},
-    groups: { type: [Schema.Types.ObjectId], required: true, default: [] },
-    friends: { type: [Schema.Types.ObjectId], required: true, default: [] },
-    wishlist: { type: [String], required: true, default: [] },
-    joined: { type: Date, required: true, default: Date.now }
+  username: { type: String, required: true },
+  email: { type: String, required: true },
+  firstName: { type: String, required: true },
+  lastName: { type: String, required: true },
+  groups: { type: [Schema.Types.ObjectId], required: true, default: [] },
+  friends: { type: [Schema.Types.ObjectId], required: true, default: [] },
+  wishlist: { type: [String], required: true, default: [] },
+  joined: { type: Date, required: true, default: Date.now },
 });
 
 const User = mongoose.models["users"] || mongoose.model("users", UserSchema);