@raclettejs/core 0.0.1

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/account/routes/route.account.post.js

@@ -0,0 +1,27 @@
+import { accountSchema } from "../account.schema.js";
+export default (fastify) => {
+    const accountService = fastify.custom.accountService;
+    const handler = async (req, reply) => {
+        try {
+            const payload = await accountService.createAccount(fastify, req.requestParams, req.body, req.user._id);
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataCreate",
+            broadcastChannels: ["accountCreated"],
+        },
+        schema: {
+            summary: "Create a new account",
+            tags: ["core/account"],
+            body: accountSchema,
+        },
+    };
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/account/routes/route.account.remove.d.ts

@@ -0,0 +1,25 @@
+import type { Static } from "@sinclair/typebox";
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { PluginFastifyInstance } from "../../../../../../../types/index.js";
+declare const ParamsSchema: import("@sinclair/typebox").TObject<{
+    _id: import("@sinclair/typebox").TString;
+}>;
+type Params = Static<typeof ParamsSchema>;
+declare const _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Params: Params;
+    }>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+        broadcastChannels: string[];
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        params: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export default _default;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/account/routes/route.account.remove.js

@@ -0,0 +1,31 @@
+import { Type } from "@sinclair/typebox";
+const ParamsSchema = Type.Object({
+    _id: Type.String(),
+});
+export default (fastify) => {
+    const accountService = fastify.custom.accountService;
+    const handler = async (req, reply) => {
+        try {
+            const { _id } = req.params;
+            const payload = await accountService.removeAccount(fastify, req.requestParams, _id);
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataDeleted",
+            broadcastChannels: ["accountDeleted"],
+        },
+        schema: {
+            summary: "Soft delete an account",
+            tags: ["core/account"],
+            params: ParamsSchema,
+        },
+    };
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/composition/composition.model.d.ts

@@ -0,0 +1,3 @@
+import type { PluginFastifyInstance } from "../../../../../../types/index.js";
+export declare const MODEL_BASENAME = "composition";
+export declare const createModels: (fastify: PluginFastifyInstance) => any;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/composition/composition.model.js

@@ -0,0 +1,92 @@
+import mongoose from "mongoose";
+import { v4 as uuidv4 } from "uuid";
+const { Schema } = mongoose;
+export const MODEL_BASENAME = "composition";
+// TODO: in progress
+const widgetSchema = new Schema({
+    uuid: {
+        type: String,
+        required: true,
+    },
+    name: {
+        type: String,
+        required: true,
+    },
+    pluginKey: {
+        type: String,
+        required: true,
+    },
+    config: {
+        type: Object,
+        required: false,
+    },
+    public: {
+        type: Object,
+        required: false,
+    },
+}, { _id: false });
+// TODO: in progress
+const widgetLayoutSchema = new Schema({
+    column: {
+        type: Number,
+        required: true,
+    },
+    widget: {
+        type: widgetSchema,
+        required: true,
+    },
+}, { _id: false });
+const compositionSchema = new Schema({
+    _id: {
+        type: String,
+        default: () => uuidv4(),
+        required: true,
+    },
+    title: {
+        type: String,
+        required: true,
+        maxLength: 200,
+    },
+    description: {
+        type: String,
+        required: false,
+    },
+    tags: [
+        {
+            type: Schema.Types.String,
+            ref: "raclette__core-tag",
+        },
+    ],
+    icon: {
+        type: String,
+    },
+    pathname: {
+        type: Map,
+        of: String,
+        default: new Map(),
+    },
+    widgetsLayout: {
+        // TODO: in progress
+        type: [[widgetLayoutSchema]],
+        default: [],
+    },
+    status: {
+        type: String,
+        enum: ["live", "test", "inProgress"],
+        default: "inProgress",
+    },
+    author: {
+        type: Schema.Types.String,
+        ref: "raclette__core-user",
+        required: true,
+    },
+    lastEditor: {
+        type: Schema.Types.String,
+        ref: "raclette__core-user",
+        required: true,
+    },
+    isDeleted: { type: Boolean, default: false },
+}, { timestamps: true });
+export const createModels = (fastify) => {
+    return fastify.createModel(MODEL_BASENAME, compositionSchema);
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/composition/composition.schema.d.ts

@@ -0,0 +1,128 @@
+import type { Static } from "@sinclair/typebox";
+import type { Document } from "mongoose";
+import type { PluginFastifyInstance } from "../../../../../../types/index.js";
+/**
+ * Composition Schema
+ */
+/**
+ * Widget Schema
+ */
+export declare const widgetSchema: import("@sinclair/typebox").TObject<{
+    uuid: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    pluginKey: import("@sinclair/typebox").TString;
+    config: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    public: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+}>;
+/**
+ * Column Slot Schema
+ */
+export declare const widgetLayoutSchema: import("@sinclair/typebox").TObject<{
+    column: import("@sinclair/typebox").TNumber;
+    widget: import("@sinclair/typebox").TObject<{
+        uuid: import("@sinclair/typebox").TString;
+        name: import("@sinclair/typebox").TString;
+        pluginKey: import("@sinclair/typebox").TString;
+        config: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+        public: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+    }>;
+}>;
+/**
+ * Full Composition Schema - Used for response serialization and database model
+ */
+export declare const compositionSchema: import("@sinclair/typebox").TObject<{
+    author: import("@sinclair/typebox").TString;
+    lastEditor: import("@sinclair/typebox").TString;
+    createdAt: import("@sinclair/typebox").TString;
+    updatedAt: import("@sinclair/typebox").TString;
+    isDeleted: import("@sinclair/typebox").TBoolean;
+    title: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    pathname: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>;
+    status: import("@sinclair/typebox").TEnum<{
+        live: "live";
+        test: "test";
+        inProgress: "inProgress";
+    }>;
+    widgetsLayout: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        column: import("@sinclair/typebox").TNumber;
+        widget: import("@sinclair/typebox").TObject<{
+            uuid: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            pluginKey: import("@sinclair/typebox").TString;
+            config: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+            public: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+        }>;
+    }>>>;
+    _id: import("@sinclair/typebox").TString;
+}>;
+/**
+ * Composition Create Schema - For POST operations
+ */
+export declare const compositionCreateSchema: import("@sinclair/typebox").TObject<{
+    title: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    pathname: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>;
+    status: import("@sinclair/typebox").TEnum<{
+        live: "live";
+        test: "test";
+        inProgress: "inProgress";
+    }>;
+    widgetsLayout: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        column: import("@sinclair/typebox").TNumber;
+        widget: import("@sinclair/typebox").TObject<{
+            uuid: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            pluginKey: import("@sinclair/typebox").TString;
+            config: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+            public: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+        }>;
+    }>>>;
+}>;
+/**
+ * Composition Update Schema - For PATCH operations
+ */
+export declare const compositionUpdateSchema: import("@sinclair/typebox").TObject<{
+    title: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    pathname: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<{
+        live: "live";
+        test: "test";
+        inProgress: "inProgress";
+    }>>;
+    widgetsLayout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        column: import("@sinclair/typebox").TNumber;
+        widget: import("@sinclair/typebox").TObject<{
+            uuid: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            pluginKey: import("@sinclair/typebox").TString;
+            config: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+            public: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+        }>;
+    }>>>>;
+}>;
+/**
+ * Type Utilities
+ */
+type DateTimeFields = {
+    createdAt: Date;
+    updatedAt: Date;
+};
+type RawComposition = Static<typeof compositionSchema>;
+export type Composition = Omit<RawComposition, keyof DateTimeFields> & DateTimeFields;
+export interface CompositionDoc extends Document<string, unknown, Composition>, Composition {
+    _id: string;
+}
+export type AnyComposition = Composition | CompositionDoc;
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export declare const registerSchemas: (fastify: PluginFastifyInstance) => void;
+export {};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/composition/composition.schema.js

@@ -0,0 +1,97 @@
+import { Type } from "@sinclair/typebox";
+/**
+ * Composition Schema
+ */
+/**
+ * Widget Schema
+ */
+// TODO: in progress
+export const widgetSchema = Type.Object({
+    uuid: Type.String(),
+    name: Type.String(),
+    pluginKey: Type.String(),
+    config: Type.Optional(Type.Any()),
+    public: Type.Optional(Type.Any()),
+});
+/**
+ * Column Slot Schema
+ */
+// TODO: in progress
+export const widgetLayoutSchema = Type.Object({
+    column: Type.Number(),
+    widget: widgetSchema,
+});
+/**
+ * Base Composition Schema - Fields common to all operations
+ */
+const baseCompositionSchema = {
+    title: Type.String({ maxLength: 200 }),
+    description: Type.Optional(Type.String()),
+    tags: Type.Array(Type.String(), { default: [] }),
+    icon: Type.Optional(Type.String()),
+    pathname: Type.Record(Type.String(), Type.String(), { default: {} }),
+    status: Type.Enum({ live: "live", test: "test", inProgress: "inProgress" }, { default: "inProgress" }),
+    widgetsLayout: Type.Array(Type.Array(widgetLayoutSchema), { default: [] }),
+};
+/**
+ * Full Composition Schema - Used for response serialization and database model
+ */
+export const compositionSchema = Type.Object({
+    _id: Type.String(),
+    ...baseCompositionSchema,
+    author: Type.String(),
+    lastEditor: Type.String(),
+    createdAt: Type.String({ format: "date-time" }),
+    updatedAt: Type.String({ format: "date-time" }),
+    isDeleted: Type.Boolean({ default: false }),
+}, {
+    $id: "#composition/base",
+    title: "core/composition",
+});
+/**
+ * Composition Create Schema - For POST operations
+ */
+export const compositionCreateSchema = Type.Object(baseCompositionSchema, {
+    $id: "#composition/create",
+    title: "core/composition-create",
+});
+/**
+ * Composition Update Schema - For PATCH operations
+ */
+export const compositionUpdateSchema = Type.Object({
+    title: Type.Optional(Type.String({ maxLength: 200 })),
+    description: Type.Optional(Type.String()),
+    tags: Type.Optional(Type.Array(Type.String())),
+    icon: Type.Optional(Type.String()),
+    pathname: Type.Optional(Type.Record(Type.String(), Type.String())),
+    status: Type.Optional(Type.Enum({ live: "live", test: "test", inProgress: "inProgress" })),
+    widgetsLayout: Type.Optional(Type.Array(Type.Array(widgetLayoutSchema))),
+}, {
+    $id: "#composition/update",
+    title: "core/composition-update",
+});
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export const registerSchemas = (fastify) => {
+    fastify.registerSchema({
+        schema: compositionSchema,
+        name: "Composition",
+    });
+    fastify.registerSchema({
+        schema: compositionCreateSchema,
+        name: "CompositionCreate",
+    });
+    fastify.registerSchema({
+        schema: compositionUpdateSchema,
+        name: "CompositionUpdate",
+    });
+    fastify.registerSchema({
+        schema: widgetSchema,
+        name: "Widget",
+    });
+    fastify.registerSchema({
+        schema: widgetLayoutSchema,
+        name: "WidgetLayout",
+    });
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/composition/composition.service.d.ts

@@ -0,0 +1,63 @@
+import type { Composition as CompositionType } from "./composition.schema.js";
+import type { ClientPayload, ClientPayloadRequestData } from "../../../../../core/payload/payloadTypes.js";
+import type { PluginFastifyInstance } from "../../../../../../types/index.js";
+import { Model } from "mongoose";
+export type CompositionBody = Partial<Omit<CompositionType, "_id">> & {
+    _id?: string;
+};
+export declare class CompositionService {
+    private compositionModel;
+    constructor(model: Model<CompositionType>);
+    /**
+     * Core function to create a composition (returns raw data)
+     */
+    _createComposition(fastify: PluginFastifyInstance, compositionBody: CompositionBody, userId: string): Promise<CompositionType>;
+    /**
+     * Create a new composition with payload wrapping and event emission
+     */
+    createComposition(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, compositionBody: CompositionBody, userId: string): Promise<ClientPayload<CompositionType[]>>;
+    /**
+     * Core function to get all compositions (returns raw data)
+     */
+    _readAllCompositions(fastify: PluginFastifyInstance): Promise<CompositionType[]>;
+    /**
+     * Get all compositions with payload wrapping
+     */
+    getAllCompositions(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData): Promise<ClientPayload<CompositionType[]>>;
+    /**
+     * Core function to get a specific composition (returns raw data)
+     */
+    _readComposition(fastify: PluginFastifyInstance, id: string): Promise<CompositionType>;
+    /**
+     * Get a specific composition with payload wrapping
+     */
+    readComposition(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<CompositionType[]>>;
+    /**
+     * Core function to update a composition (returns raw data)
+     */
+    _updateComposition(fastify: PluginFastifyInstance, id: string, compositionBody: CompositionBody, userId: string): Promise<{
+        updated: CompositionType;
+        original: CompositionType;
+    }>;
+    /**
+     * Update a composition with payload wrapping and event emission
+     */
+    updateComposition(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string, compositionBody: CompositionBody, userId: string): Promise<ClientPayload<CompositionType[]>>;
+    /**
+     * Core function to soft delete a composition (returns raw data)
+     */
+    _removeComposition(fastify: PluginFastifyInstance, id: string): Promise<CompositionType>;
+    /**
+     * Soft delete a composition with payload wrapping and event emission
+     */
+    removeComposition(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<CompositionType[]>>;
+    /**
+     * Core function to hard delete a composition (returns raw data)
+     */
+    _hardDeleteComposition(fastify: PluginFastifyInstance, id: string): Promise<CompositionType>;
+    /**
+     * Hard delete a composition with payload wrapping and event emission
+     */
+    hardDeleteComposition(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<CompositionType[]>>;
+}
+export declare const createCompositionService: (model: Model<CompositionType>) => CompositionService;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/composition/composition.service.js

@@ -0,0 +1,212 @@
+import { v4 as uuidv4, validate } from "uuid";
+import { createCompositionPayload } from "./helpers/payload.js";
+// Using a class to preserve 'this' context
+export class CompositionService {
+    compositionModel;
+    constructor(model) {
+        this.compositionModel = model;
+    }
+    /**
+     * Core function to create a composition (returns raw data)
+     */
+    async _createComposition(fastify, compositionBody, userId) {
+        try {
+            if (compositionBody._id) {
+                const uuidValid = validate(compositionBody._id);
+                if (!uuidValid) {
+                    throw new Error("Invalid ID - not a valid uuid v4");
+                }
+                const duplicate = await this.compositionModel.findOne({
+                    id: compositionBody._id,
+                });
+                if (duplicate) {
+                    throw new Error("An entry with this id already exists");
+                }
+            }
+            else {
+                compositionBody._id = uuidv4();
+            }
+            const composition = new this.compositionModel({
+                ...compositionBody,
+                author: userId,
+                lastEditor: userId,
+            });
+            await composition.save();
+            fastify.log.info(`[API] Created composition #${composition._id}`);
+            return composition.toObject ? composition.toObject() : composition;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Create a new composition with payload wrapping and event emission
+     */
+    async createComposition(fastify, requestData, compositionBody, userId) {
+        const composition = await this._createComposition(fastify, compositionBody, userId);
+        const payload = await createCompositionPayload(fastify, [composition], requestData);
+        fastify.emit("compositionCreated", payload);
+        return payload;
+    }
+    /**
+     * Core function to get all compositions (returns raw data)
+     */
+    async _readAllCompositions(fastify) {
+        try {
+            return await this.compositionModel
+                .find({
+                isDeleted: false,
+            })
+                .lean();
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get all compositions with payload wrapping
+     */
+    async getAllCompositions(fastify, requestData) {
+        const compositions = await this._readAllCompositions(fastify);
+        return createCompositionPayload(fastify, compositions, requestData);
+    }
+    /**
+     * Core function to get a specific composition (returns raw data)
+     */
+    async _readComposition(fastify, id) {
+        try {
+            const composition = await this.compositionModel
+                .findOne({ _id: id })
+                .lean();
+            if (!composition) {
+                throw new Error(`Composition with ID ${id} not found`);
+            }
+            return composition;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get a specific composition with payload wrapping
+     */
+    async readComposition(fastify, requestData, id) {
+        const composition = await this._readComposition(fastify, id);
+        return createCompositionPayload(fastify, [composition], requestData);
+    }
+    /**
+     * Core function to update a composition (returns raw data)
+     */
+    async _updateComposition(fastify, id, compositionBody, userId) {
+        try {
+            const originalComposition = await this.compositionModel.findOne({
+                _id: id,
+            });
+            if (!originalComposition) {
+                throw new Error(`Composition with ID ${id} not found`);
+            }
+            // Remove protected fields
+            delete compositionBody._id;
+            const updatedComposition = await this.compositionModel
+                .findOneAndUpdate({ _id: id }, {
+                ...compositionBody,
+                lastEditor: userId,
+            }, { new: true })
+                .lean();
+            if (!updatedComposition) {
+                throw new Error(`Failed to update composition with ID ${id}`);
+            }
+            fastify.log.info(`[API] Updated composition #${updatedComposition._id}`);
+            return {
+                updated: updatedComposition,
+                original: originalComposition.toObject
+                    ? originalComposition.toObject()
+                    : originalComposition,
+            };
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Update a composition with payload wrapping and event emission
+     */
+    async updateComposition(fastify, requestData, id, compositionBody, userId) {
+        const { updated, original } = await this._updateComposition(fastify, id, compositionBody, userId);
+        const payload = await createCompositionPayload(fastify, [updated], requestData);
+        payload.body.prevVersion = original;
+        if (requestData.broadcast) {
+            fastify.emit("compositionUpdated", payload);
+        }
+        return payload;
+    }
+    /**
+     * Core function to soft delete a composition (returns raw data)
+     */
+    async _removeComposition(fastify, id) {
+        try {
+            const composition = await this.compositionModel
+                .findOneAndUpdate({ _id: id }, { isDeleted: true }, { new: true })
+                .lean();
+            if (!composition) {
+                throw new Error(`Composition with ID ${id} not found`);
+            }
+            return composition;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Soft delete a composition with payload wrapping and event emission
+     */
+    async removeComposition(fastify, requestData, id) {
+        const composition = await this._removeComposition(fastify, id);
+        const payload = await createCompositionPayload(fastify, [composition], {
+            ...requestData,
+            type: "dataDeleted",
+        });
+        payload.body.deleted = [composition._id];
+        fastify.emit("compositionDeleted", payload);
+        return payload;
+    }
+    /**
+     * Core function to hard delete a composition (returns raw data)
+     */
+    async _hardDeleteComposition(fastify, id) {
+        try {
+            const composition = await this.compositionModel.findOne({
+                id,
+                isDeleted: true,
+            });
+            if (!composition) {
+                throw new Error(`Composition with ID ${id} not found or not marked for deletion`);
+            }
+            await this.compositionModel.deleteOne({ _id: id });
+            return composition.toObject ? composition.toObject() : composition;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Hard delete a composition with payload wrapping and event emission
+     */
+    async hardDeleteComposition(fastify, requestData, id) {
+        const composition = await this._hardDeleteComposition(fastify, id);
+        const payload = await createCompositionPayload(fastify, [composition], {
+            ...requestData,
+            type: "dataHardDeleted",
+        });
+        payload.body.deleted = [composition._id];
+        fastify.emit("compositionHardDeleted", payload);
+        return payload;
+    }
+}
+export const createCompositionService = (model) => new CompositionService(model);