@raclettejs/core 0.0.1

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/index.ts

@@ -0,0 +1,59 @@
+import { PluginFastifyInstance } from "types"
+import registerRoutes from "./routes"
+import { createUserService } from "./user.service"
+import { registerPayload } from "./helpers/payload"
+import { registerCrud } from "./helpers/crud"
+import { createModels } from "./user.model"
+import { registerSchemas } from "./user.schema"
+
+const registerUser = async (fastify: PluginFastifyInstance) => {
+  /*
+   * ---------------------------------------------------------------------
+   * CREATE AND REGISTER ALL YOUR MODELS
+   * ---------------------------------------------------------------------
+   */
+  const userModel = createModels(fastify)
+
+  // create and pass in the model to your service
+  const userService = createUserService(userModel)
+
+  // decorate the service to the instance, so we can easily call it everywhere
+  fastify.custom.userService = userService
+
+  // because the user has more than the standard routes, we need to decorate the model to the instance
+  fastify.custom.userModel = userModel
+
+  /*
+   * ---------------------------------------------------------------------
+   * REGISTER ALL YOUR ROUTES
+   * ---------------------------------------------------------------------
+   */
+  try {
+    await fastify.register((instance) => registerRoutes(instance))
+  } catch (error) {
+    fastify.log.error(`Failed to register routes.`, error)
+    throw error // Let the application handle the error
+  }
+
+  registerPayload(fastify)
+  registerCrud(fastify)
+  registerSchemas(fastify)
+
+  return {
+    user: {
+      operations: {
+        read: userService._readUser.bind(userService),
+        readByMail: userService._readUserByEmail.bind(userService),
+        readAll: userService._readUsers.bind(userService),
+        readCount: userService._readCount.bind(userService),
+        create: userService._createUser.bind(userService),
+      },
+      keywords: ["user", "auth", "identity", "account"],
+      metadata: {
+        description: "User management and authentication",
+      },
+    },
+  }
+}
+
+export default registerUser

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/index.ts

@@ -0,0 +1,21 @@
+import { PluginFastifyInstance } from "types"
+import get from "./route.user.get"
+import getAll from "./route.user.getAll"
+import patch from "./route.user.patch"
+import patchLastProject from "./route.user.patchLastProject"
+import post from "./route.user.post"
+import remove from "./route.user.remove"
+
+const registerRoutes = async (fastify: PluginFastifyInstance) => {
+  await fastify.get("/user/all", getAll(fastify))
+  await fastify.get("/user/:_id", get(fastify))
+  await fastify.patch("/user/:_id", patch(fastify))
+  await fastify.post("/user", post(fastify))
+  await fastify.delete("/user/:_id", remove(fastify))
+  await fastify.patch(
+    "/user/last-project/:projectId",
+    patchLastProject(fastify),
+  )
+}
+
+export default registerRoutes

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.get.ts

@@ -0,0 +1,52 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+
+const ParamsSchema = Type.Object({
+  _id: Type.String(),
+})
+type Params = Static<typeof ParamsSchema>
+
+const QuerySchema = Type.Object({
+  account: Type.Optional(Type.String()),
+})
+type Query = Static<typeof QuerySchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const userService = fastify.custom.userService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+      Querystring: Query
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      return await userService.readUser(
+        fastify,
+        req.requestParams,
+        req.params._id,
+      )
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataPush",
+    },
+    schema: {
+      summary: "Get user",
+      description: "Retrieve a single user by ID ",
+      tags: ["core/user"],
+      params: ParamsSchema,
+      querystring: QuerySchema,
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.getAll.ts

@@ -0,0 +1,51 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+
+const QuerySchema = Type.Object({
+  account: Type.Optional(Type.String()),
+})
+type Query = Static<typeof QuerySchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const userService = fastify.custom.userService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Querystring: Query
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      //TODO rework this once we have permission system in place
+      const filter: any = { isDeleted: false }
+      if (req.query.account) {
+        filter.account = req.query.account
+      }
+      const payloads = await userService.readUsers(
+        fastify,
+        req.requestParams,
+        filter,
+      )
+      return payloads
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataPush",
+    },
+    schema: {
+      summary: "Get users",
+      description: "Retrieve multiple users by filter criteria",
+      tags: ["core/users"],
+      querystring: QuerySchema,
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.patch.ts

@@ -0,0 +1,58 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+import { userUpdateSchema } from "../user.schema"
+
+const ParamsSchema = Type.Object({
+  _id: Type.String(),
+})
+type Params = Static<typeof ParamsSchema>
+
+type UserBody = Static<typeof userUpdateSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const userService = fastify.custom.userService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+      Body: UserBody
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      let cleanBody = req.body
+      if (!req.user.isAdmin) {
+        delete cleanBody.tags
+      }
+      const payloadWithUser = await userService.updateUser(
+        fastify,
+        req.requestParams,
+        req.params._id,
+        cleanBody,
+      )
+
+      return payloadWithUser
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataUpdate",
+      broadcastChannels: ["userUpdated"],
+    },
+    schema: {
+      summary: "Update a user",
+      description: "Update specific fields of a user profile",
+      tags: ["core/user"],
+      params: ParamsSchema,
+      body: userUpdateSchema,
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.patchLastProject.ts

@@ -0,0 +1,44 @@
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+
+export default (fastify: PluginFastifyInstance) => {
+  const userService = fastify.custom.userService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: { projectId: string }
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      return await userService.updateLastProject(
+        fastify,
+        req.requestParams,
+        req.user._id,
+        req.params.projectId,
+      )
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataUpdate",
+      broadcastChannels: ["userUpdated"],
+    },
+    schema: {
+      summary: "Set last accessed project for given user",
+      description:
+        "Takes the user in the provided token and writes the given project id into the user's UX config",
+      tags: ["core/user"],
+      params: Type.Object({
+        projectId: Type.String(),
+      }),
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.post.ts

@@ -0,0 +1,40 @@
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { userCreateSchema, type UserCreate } from "../user.schema"
+
+export default (fastify: PluginFastifyInstance) => {
+  const userService = fastify.custom.userService
+
+  const handler = async (
+    req: FastifyRequest<{ Body: UserCreate }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const payloadWithUser = await userService.createUser(
+        fastify,
+        req.requestParams,
+        { ...req.body },
+      )
+
+      return payloadWithUser
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataCreate",
+      broadcastChannels: ["userCreated"],
+    },
+    schema: {
+      summary: "Create a new user",
+      description: "Create a new user with the provided details",
+      tags: ["core/user"],
+      body: userCreateSchema,
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.remove.ts

@@ -0,0 +1,54 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+import { ForbiddenError } from "@/utils/errors"
+
+const ParamsSchema = Type.Object({
+  _id: Type.String(),
+})
+type Params = Static<typeof ParamsSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const userService = fastify.custom.userService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      if (req.user._id === req.params._id) {
+        throw new ForbiddenError("A user cannot remove itself")
+      }
+
+      const payloadWithUser = await userService.removeUser(
+        fastify,
+        req.requestParams,
+        req.params._id,
+      )
+
+      return payloadWithUser
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataDelete",
+      broadcastChannels: ["userDeleted"],
+    },
+    schema: {
+      summary: "Delete a user",
+      description:
+        "Soft delete a user (marks as deleted but preserves the record)",
+      tags: ["core/user"],
+      params: ParamsSchema,
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/user.model.ts

@@ -0,0 +1,187 @@
+import type { IUserMethods, UserDoc } from "./user.schema"
+import bcrypt from "bcrypt"
+import { v4 as uuidv4 } from "uuid"
+import { randomIdGenerator } from "@/helpers"
+import { PluginFastifyInstance } from "types"
+import mongoose from "mongoose"
+
+export const MODEL_BASENAME = "user"
+
+const { Schema } = mongoose
+
+const randomId = randomIdGenerator(64)
+
+const SALT_FACTOR = 10
+
+const userSchema = new Schema<UserDoc, any, IUserMethods>(
+  {
+    _id: {
+      type: String,
+      default: () => uuidv4(),
+    },
+
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true,
+    },
+
+    account: {
+      type: Schema.Types.String,
+      ref: "raclette__core-account",
+      default: null,
+    },
+
+    // owner is a required field accross the app, the user usually own themselves
+    owner: {
+      type: Schema.Types.String,
+      ref: "raclette__core-user",
+      default: null,
+    },
+
+    title: { type: String, default: null },
+
+    firstname: { type: String, default: null },
+
+    lastname: { type: String, default: null },
+
+    email_verified: { type: Boolean, default: false },
+
+    active: { type: Boolean, default: true },
+
+    blocked: { type: Boolean, default: false },
+
+    /* hashed password field */
+    password: { type: String, trim: true },
+
+    /* keep track of last password update */
+    passwordUpdatedAt: { type: Date, default: null },
+
+    /* signed terms, we also keep track in the logs of this event */
+    signedTermsAt: { type: Date, default: null },
+
+    /* reset token, required when user needs to reset password */
+    resetToken: {
+      type: String,
+      index: true,
+      default: null,
+      unique: true,
+      sparse: true,
+    },
+
+    /*
+     * we need to keep track of last reset request, as the key should only be valid
+     * for a certain time
+     */
+    resetDate: { type: Date, default: null },
+
+    /* tags, note that tag and this have to belong to the same project */
+    tags: {
+      type: [Schema.Types.String],
+      ref: "raclette__core-tag",
+      default: [],
+    },
+
+    /* soft delete */
+    isDeleted: { type: Boolean, default: false },
+
+    /* settings */
+    settings: {
+      emailSignature: { type: String, default: null },
+    },
+
+    /* matches the configStore entry */
+    ux: {
+      lastProjectId: { type: String, default: null },
+      browser: { type: [Schema.Types.Mixed], default: [] },
+      project: { type: Schema.Types.Mixed, default: null },
+    },
+  },
+  {
+    timestamps: true,
+    optimisticConcurrency: true,
+  },
+)
+
+/*
+ * Pre save
+ *
+ * Before saving the object we need to hash the password
+ */
+userSchema.pre("save", async function (done) {
+  if (
+    !this.isModified("password") ||
+    this.password === undefined ||
+    !this.password ||
+    this.password === null
+  ) {
+    this.setResetToken()
+    return done()
+  }
+
+  if (!this.resetToken || this.resetToken === "") {
+    this.setResetToken()
+  }
+
+  try {
+    this.password = await this.hashPassword(this.password)
+    if (this.isModified("password")) {
+      this.passwordUpdatedAt = new Date() // Now this is type-safe
+    }
+    return done()
+  } catch (error) {
+    return done(error as Error)
+  }
+})
+
+// Index for common queries
+userSchema.index({ email: 1, isDeleted: 1 })
+userSchema.index({ isDeleted: 1 })
+
+/*
+ * Set Password method
+ */
+userSchema.methods.hashPassword = async (
+  password: string,
+): Promise<string | undefined> => {
+  if (!password) {
+    return undefined
+  }
+
+  try {
+    const salt = await bcrypt.genSalt(SALT_FACTOR)
+    return await bcrypt.hash(password, salt)
+  } catch (error) {
+    console.error("Error hashing password", error)
+    throw error
+  }
+}
+
+/*
+ * check password method
+ */
+userSchema.methods.checkPassword = async function (
+  guess: string,
+): Promise<boolean> {
+  if (!this.password) {
+    throw new Error("Password is not set on the user object")
+  }
+
+  return bcrypt.compare(guess, this.password)
+}
+
+/*
+ * set Reset Key
+ * In case the user needs to reset his password, we need a temporary key
+ */
+userSchema.methods.setResetToken = function (): string {
+  this.resetToken = randomId()
+  this.resetDate = new Date() // Now this is type-safe
+  return this.resetToken
+}
+
+export const createModels = (fastify: PluginFastifyInstance) => {
+  return fastify.createModel(MODEL_BASENAME, userSchema)
+}