@raclettejs/core 0.1.18 → 0.1.20

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

@@ -0,0 +1,39 @@
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+
+const permissions = ["user.isAdmin"]
+
+export default (fastify: PluginFastifyInstance) => {
+  const workSessionService = fastify.custom.workSessionService
+
+  const handler = async (req: FastifyRequest<{}>, reply: FastifyReply) => {
+    try {
+      const payload = await workSessionService.readWorkSessions(
+        fastify,
+        req.requestParams,
+      )
+
+      if (!payload) {
+        return reply.code(204)
+      }
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
+    config: {
+      type: "dataRead",
+    },
+    schema: {
+      summary: "Get all workSessions",
+      tags: ["core/workSession"],
+      params: {},
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/routes/route.workSession.hardDelete.ts

@@ -0,0 +1,53 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+
+const permissions = ["user.isAdmin"]
+
+const ParamsSchema = Type.Object({
+  _id: Type.String(),
+})
+type Params = Static<typeof ParamsSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const workSessionService = fastify.custom.workSessionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payload = await workSessionService.hardDeleteWorkSession(
+        fastify,
+        req.requestParams,
+        _id,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
+    config: {
+      type: "dataHardDeleted",
+      broadcastChannels: ["workSessionHardDeleted"],
+    },
+    schema: {
+      summary: "Hard delete a workSession by id",
+      description: "Permanently removes a workSession",
+      tags: ["core/workSession"],
+
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -0,0 +1,58 @@
+import type { WorkSessionBody } from "../workSession.service"
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+import { workSessionUpdateSchema } from "../workSession.schema"
+
+const permissions = ["user.isAdmin"]
+
+const ParamsSchema = Type.Object({
+  _id: Type.String(),
+})
+type Params = Static<typeof ParamsSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const workSessionService = fastify.custom.workSessionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+      Body: WorkSessionBody
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payload = await workSessionService.updateWorkSession(
+        fastify,
+        req.requestParams,
+        _id,
+        req.body,
+        req.user._id,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
+    config: {
+      type: "dataUpdate",
+      broadcastChannels: ["workSessionUpdated"],
+    },
+    schema: {
+      summary: "Update a workSession",
+      tags: ["core/workSession"],
+
+      params: ParamsSchema,
+      body: workSessionUpdateSchema,
+    },
+  }
+}

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

@@ -0,0 +1,53 @@
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import {
+  workSessionCreateSchema,
+  type WorkSessionCreate,
+} from "../workSession.schema"
+
+const permissions = ["user.isAdmin"]
+
+export default (fastify: PluginFastifyInstance) => {
+  const workSessionService = fastify.custom.workSessionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Body: WorkSessionCreate
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      // Set userId from authenticated user if not provided
+      const workSessionBody = {
+        ...req.body,
+        userId: req.body.userId || req.user?._id,
+      }
+
+      const payload = await workSessionService.createWorkSession(
+        fastify,
+        req.requestParams,
+        workSessionBody,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
+    config: {
+      type: "dataCreate",
+      broadcastChannels: ["workSessionCreated"],
+    },
+    schema: {
+      summary: "Create a new workSession",
+      tags: ["core/workSession"],
+
+      body: workSessionCreateSchema,
+    },
+  }
+}

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

@@ -0,0 +1,52 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+
+const permissions = ["user.isAdmin"]
+
+const ParamsSchema = Type.Object({
+  _id: Type.String(),
+})
+type Params = Static<typeof ParamsSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const workSessionService = fastify.custom.workSessionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payload = await workSessionService.removeWorkSession(
+        fastify,
+        req.requestParams,
+        _id,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
+    config: {
+      type: "dataUpdate",
+      broadcastChannels: ["workSessionDeleted"],
+    },
+    schema: {
+      summary: "Soft delete a workSession by id",
+      tags: ["core/workSession"],
+
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -0,0 +1,65 @@
+import { PluginFastifyInstance } from "types"
+import mongoose from "mongoose"
+const { Schema } = mongoose
+
+export const MODEL_BASENAME = "workSession"
+
+const workSessionSchema = new Schema(
+  {
+    _id: {
+      type: String,
+    },
+
+    userId: {
+      type: String,
+      required: true,
+    },
+
+    accessType: {
+      type: String,
+      required: true,
+      default: "anonymous",
+      enum: ["anonymous"],
+    },
+
+    compositionId: {
+      type: String,
+      required: true,
+    },
+
+    project: {
+      type: String,
+      required: false,
+    },
+
+    expiryDate: {
+      type: Date,
+      required: true,
+    },
+
+    isActive: {
+      type: Boolean,
+      default: true,
+    },
+
+    permissions: {
+      type: Number,
+      default: 6, // read+write
+    },
+
+    pluginData: {
+      type: Schema.Types.Mixed,
+      default: {},
+    },
+
+    composition: {
+      type: Schema.Types.Mixed,
+      required: false,
+    },
+  },
+  { timestamps: true },
+)
+
+export const createModels = (fastify: PluginFastifyInstance) => {
+  return fastify.createModel(MODEL_BASENAME, workSessionSchema)
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/workSession.schema.ts

@@ -0,0 +1,125 @@
+import type { Static } from "@sinclair/typebox"
+import type { Document } from "mongoose"
+import { Type } from "@sinclair/typebox"
+import type { PluginFastifyInstance } from "types"
+
+/**
+ * Base WorkSession Schema - Fields common to all operations
+ */
+const baseWorkSessionSchema = {
+  userId: Type.Optional(Type.String()),
+  accessType: Type.Optional(
+    Type.String({ default: "anonymous", enum: ["anonymous"] }),
+  ),
+  compositionId: Type.Optional(Type.String()),
+  project: Type.String(), // Project ID for payload wrapper (temporary solution)
+  expiryDate: Type.Optional(Type.String({ format: "date-time" })),
+  isActive: Type.Optional(Type.Boolean({ default: true })),
+  permissions: Type.Optional(Type.Number({ default: 6 })),
+  pluginData: Type.Optional(
+    Type.Record(Type.String(), Type.Any(), { default: {} }),
+  ),
+  composition: Type.Optional(Type.Any()),
+}
+
+/**
+ * Full WorkSession Schema - Used for response serialization and database model
+ */
+export const workSessionSchema = Type.Object(
+  {
+    _id: Type.String(),
+    ...baseWorkSessionSchema,
+    createdAt: Type.String({ format: "date-time" }),
+    updatedAt: Type.String({ format: "date-time" }),
+  },
+  {
+    $id: "#workSession/base",
+    title: "core/workSession",
+  },
+)
+
+/**
+ * WorkSession Create Schema - For POST operations
+ */
+export const workSessionCreateSchema = Type.Object(
+  {
+    _id: Type.Optional(Type.String()),
+    ...baseWorkSessionSchema,
+  },
+  {
+    $id: "#workSession/create",
+    title: "core/workSession-create",
+  },
+)
+
+/**
+ * WorkSession Update Schema - For PATCH operations
+ */
+export const workSessionUpdateSchema = Type.Object(
+  {
+    _id: Type.Optional(Type.String()),
+    ...baseWorkSessionSchema,
+  },
+  {
+    $id: "#workSession/update",
+    title: "core/workSession-update",
+  },
+)
+
+/**
+ * Type Utilities
+ */
+
+type DateTimeFields = {
+  createdAt: Date
+  updatedAt: Date
+}
+
+type RawWorkSession = Static<typeof workSessionSchema>
+export type WorkSession = Omit<RawWorkSession, keyof DateTimeFields> &
+  DateTimeFields
+
+type RawWorkSessionCreate = Static<typeof workSessionCreateSchema>
+export type WorkSessionCreate = RawWorkSessionCreate
+
+type RawWorkSessionUpdate = Static<typeof workSessionUpdateSchema>
+export type WorkSessionUpdate = RawWorkSessionUpdate
+
+export interface WorkSessionDoc extends Document, WorkSession {
+  _id: string
+}
+export type AnyWorkSession = WorkSession | WorkSessionDoc
+
+/** Shape of work session attached to req by authenticatedOrWorksession */
+export interface RequestWorkSession {
+  _id: string
+  userId: string
+  accessType: string
+  compositionId: string
+  project?: string
+  expiryDate: Date
+  isActive: boolean
+  permissions?: number
+  pluginData?: Record<string, unknown>
+  composition?: unknown
+}
+
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export const registerSchemas = (fastify: PluginFastifyInstance) => {
+  fastify.registerSchema({
+    schema: workSessionSchema,
+    name: "WorkSession",
+  })
+
+  fastify.registerSchema({
+    schema: workSessionCreateSchema,
+    name: "WorkSessionCreate",
+  })
+
+  fastify.registerSchema({
+    schema: workSessionUpdateSchema,
+    name: "WorkSessionUpdate",
+  })
+}