@raclettejs/core 0.1.19 → 0.1.21

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/helpers/payload.ts

@@ -0,0 +1,21 @@
+import type { WorkSession } from "../workSession.schema"
+import type { FrontendPayloadRequestData, PluginFastifyInstance } from "types"
+
+export const registerPayload = (fastify: PluginFastifyInstance) => {
+  fastify.registerPayloadHandler<WorkSession>("workSession", {
+    type: "workSession",
+    displayName: (workSession: WorkSession) => workSession._id || "",
+    completion: (workSession: WorkSession) => workSession._id || "",
+    fields: () => ({
+      owner: "NONE",
+    }),
+  })
+}
+
+export const createWorkSessionPayload = async (
+  fastify: PluginFastifyInstance,
+  items: WorkSession[],
+  requestData: FrontendPayloadRequestData,
+) => {
+  return await fastify.createPayload("workSession", items, requestData)
+}

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

@@ -0,0 +1,55 @@
+import { PluginFastifyInstance } from "types"
+import registerRoutes from "./routes"
+import { createModels } from "./workSession.model"
+import { createWorkSessionService } from "./workSession.service"
+import { registerPayload } from "./helpers/payload"
+import { registerCrud } from "./helpers/crud"
+import { registerSchemas } from "./workSession.schema"
+
+const registerWorkSession = async (fastify: PluginFastifyInstance) => {
+  /*
+   * ---------------------------------------------------------------------
+   * CREATE AND REGISTER ALL YOUR MODELS
+   * ---------------------------------------------------------------------
+   */
+  const workSessionModel = createModels(fastify)
+
+  // create and pass in the model to your service
+  const workSessionService = createWorkSessionService(workSessionModel)
+
+  // decorate the service to the instance, so we can easily call it everywhere
+  fastify.custom.workSessionService = workSessionService
+
+  /*
+   * ---------------------------------------------------------------------
+   * 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 {
+    workSession: {
+      operations: {
+        read: workSessionService._readWorkSession.bind(workSessionService),
+        readAll: workSessionService._readWorkSessions.bind(workSessionService),
+        create: workSessionService._createWorkSession.bind(workSessionService),
+        update: workSessionService._updateWorkSession.bind(workSessionService),
+      },
+      keywords: ["workSession", "session"],
+      metadata: {
+        description: "A work session for user interactions.",
+      },
+    },
+  }
+}
+
+export default registerWorkSession

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

@@ -0,0 +1,19 @@
+import { PluginFastifyInstance } from "types"
+import get from "./route.workSession.get"
+import getAll from "./route.workSession.getAll"
+import patch from "./route.workSession.patch"
+import post from "./route.workSession.post"
+import hardDelete from "./route.workSession.hardDelete"
+import remove from "./route.workSession.remove"
+
+const registerRoutes = async (fastify: PluginFastifyInstance) => {
+  await fastify.get("/workSession/all", getAll(fastify))
+  await fastify.get("/workSession/:_id", get(fastify))
+
+  await fastify.post("/workSession", post(fastify))
+  await fastify.patch("/workSession/:_id", patch(fastify))
+  await fastify.delete("/workSession/:_id", remove(fastify))
+  await fastify.delete("/workSession/:_id/hard", hardDelete(fastify))
+}
+
+export default registerRoutes

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/routes/route.workSession.get.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 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.readWorkSession(
+        fastify,
+        req.requestParams,
+        _id,
+      )
+
+      if (!payload) {
+        return reply.notFound("WorkSession not found")
+      }
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataRead",
+    },
+    schema: {
+      summary: "Get a workSession by id",
+      tags: ["core/workSession"],
+
+      params: ParamsSchema,
+    },
+  }
+}

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",
+  })
+}