@raclettejs/core 0.0.1

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/interactionLink/index.js

@@ -0,0 +1,48 @@
+import registerRoutes from "./routes/index.js";
+import { createModels } from "./interactionLink.model.js";
+import { createInteractionLinkService } from "./interactionLink.service.js";
+import { registerCrud } from "./helpers/crud.js";
+import { registerPayload } from "./helpers/payload.js";
+import { registerSchemas } from "./interactionLink.schema.js";
+const registerInteractionLink = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const interactionLinkModel = createModels(fastify);
+    // create and pass in the model to your service
+    const interactionLinkService = createInteractionLinkService(interactionLinkModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.interactionLinkService = interactionLinkService;
+    /*
+     * ---------------------------------------------------------------------
+     * 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 {
+        interactionLink: {
+            operations: {
+                readAll: interactionLinkService._readAllInteractionLinks.bind(interactionLinkService),
+                read: interactionLinkService._readInteractionLink.bind(interactionLinkService),
+                create: interactionLinkService._createInteractionLink.bind(interactionLinkService),
+                delete: interactionLinkService._removeInteractionLink.bind(interactionLinkService),
+            },
+            keywords: ["interaction", "link", "connection", "relation"],
+            metadata: {
+                description: "Links between interactive elements",
+            },
+        },
+    };
+};
+export default registerInteractionLink;

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

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

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

@@ -0,0 +1,61 @@
+import mongoose from "mongoose";
+import { v4 as uuidv4 } from "uuid";
+const { Schema } = mongoose;
+export const MODEL_BASENAME = "interactionLink";
+const triggerSchema = new Schema({
+    type: {
+        type: String,
+        required: true,
+    },
+    settings: {
+        type: Schema.Types.Mixed,
+    },
+}, { _id: false });
+const interactionLinkSchema = new Schema({
+    _id: {
+        type: String,
+        default: () => uuidv4(),
+        required: true,
+    },
+    composition: {
+        type: Schema.Types.String,
+        ref: "raclette__core-composition",
+        required: true,
+    },
+    slotType: {
+        type: String,
+        required: true,
+    },
+    triggers: {
+        type: [triggerSchema],
+        default: [],
+    },
+    queryParameters: {
+        type: Schema.Types.Array,
+        of: Schema.Types.String,
+    },
+    description: {
+        type: String,
+    },
+    tags: [
+        {
+            type: Schema.Types.String,
+            ref: "raclette__core-tag",
+        },
+    ],
+    author: {
+        type: Schema.Types.String,
+        ref: "raclette__core-user",
+        required: true,
+    },
+    lastEditor: {
+        type: Schema.Types.String,
+        ref: "raclette__core-user",
+        required: true,
+    },
+    isLandingPage: { type: Boolean, default: false },
+    isDeleted: { type: Boolean, default: false },
+}, { timestamps: true });
+export const createModels = (fastify) => {
+    return fastify.createModel(MODEL_BASENAME, interactionLinkSchema);
+};

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

@@ -0,0 +1,86 @@
+import type { Static } from "@sinclair/typebox";
+import type { Document } from "mongoose";
+import { PluginFastifyInstance } from "../../../../../../types/index.js";
+/**
+ * Trigger Schema
+ */
+export declare const triggerSchema: import("@sinclair/typebox").TObject<{
+    type: import("@sinclair/typebox").TString;
+    settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+}>;
+/**
+ * Full InteractionLink Schema - Used for response serialization and database model
+ */
+export declare const interactionLinkSchema: 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;
+    composition: import("@sinclair/typebox").TString;
+    slotType: import("@sinclair/typebox").TString;
+    triggers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        type: import("@sinclair/typebox").TString;
+        settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+    }>>;
+    queryParameters: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    isLandingPage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    _id: import("@sinclair/typebox").TString;
+}>;
+/**
+ * InteractionLink Create Schema - For POST operations
+ */
+export declare const interactionLinkCreateSchema: import("@sinclair/typebox").TObject<{
+    composition: import("@sinclair/typebox").TString;
+    slotType: import("@sinclair/typebox").TString;
+    triggers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        type: import("@sinclair/typebox").TString;
+        settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+    }>>;
+    queryParameters: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    isLandingPage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+/**
+ * InteractionLink Update Schema - For PATCH operations
+ */
+export declare const interactionLinkUpdateSchema: import("@sinclair/typebox").TObject<{
+    composition: import("@sinclair/typebox").TString;
+    slotType: import("@sinclair/typebox").TString;
+    triggers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        type: import("@sinclair/typebox").TString;
+        settings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+    }>>;
+    queryParameters: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    isLandingPage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+/**
+ * Type Utilities
+ */
+type DateTimeFields = {
+    createdAt: Date;
+    updatedAt: Date;
+};
+type RawTrigger = Static<typeof triggerSchema>;
+export type Trigger = RawTrigger;
+type RawInteractionLink = Static<typeof interactionLinkSchema>;
+export type InteractionLink = Omit<RawInteractionLink, keyof DateTimeFields> & DateTimeFields;
+export interface InteractionLinkDoc extends Document<string, unknown, InteractionLink>, InteractionLink {
+    _id: string;
+}
+export type AnyInteractionLink = InteractionLink | InteractionLinkDoc;
+export { interactionLinkSchema as default };
+/**
+ * Types for create and update operations
+ */
+export type InteractionLinkCreate = Static<typeof interactionLinkCreateSchema>;
+export type InteractionLinkUpdate = Static<typeof interactionLinkUpdateSchema>;
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export declare const registerSchemas: (fastify: PluginFastifyInstance) => void;

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

@@ -0,0 +1,74 @@
+import { Type } from "@sinclair/typebox";
+/**
+ * Trigger Schema
+ */
+export const triggerSchema = Type.Object({
+    type: Type.String(),
+    settings: Type.Optional(Type.Record(Type.String(), Type.Any())),
+}, {
+    $id: "#trigger/base",
+    title: "core/trigger",
+});
+/**
+ * Base InteractionLink Schema - Fields common to all operations
+ */
+const baseInteractionLinkSchema = {
+    composition: Type.String(),
+    slotType: Type.String(),
+    triggers: Type.Array(triggerSchema, { default: [] }),
+    queryParameters: Type.Optional(Type.Array(Type.String())),
+    description: Type.Optional(Type.String()),
+    tags: Type.Array(Type.String(), { default: [] }),
+    isLandingPage: Type.Optional(Type.Boolean({ default: false })),
+};
+/**
+ * Full InteractionLink Schema - Used for response serialization and database model
+ */
+export const interactionLinkSchema = Type.Object({
+    _id: Type.String(),
+    ...baseInteractionLinkSchema,
+    author: Type.String(),
+    lastEditor: Type.String(),
+    createdAt: Type.String({ format: "date-time" }),
+    updatedAt: Type.String({ format: "date-time" }),
+    isDeleted: Type.Boolean({ default: false }),
+}, {
+    $id: "#interactionLink/base",
+    title: "core/interactionLink",
+});
+/**
+ * InteractionLink Create Schema - For POST operations
+ */
+export const interactionLinkCreateSchema = Type.Object(baseInteractionLinkSchema, {
+    $id: "#interactionLink/create",
+    title: "core/interactionLink-create",
+});
+/**
+ * InteractionLink Update Schema - For PATCH operations
+ */
+export const interactionLinkUpdateSchema = Type.Object(baseInteractionLinkSchema, {
+    $id: "#interactionLink/update",
+    title: "core/interactionLink-update",
+});
+export { interactionLinkSchema as default };
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export const registerSchemas = (fastify) => {
+    fastify.registerSchema({
+        schema: interactionLinkSchema,
+        name: "InteractionLink",
+    });
+    fastify.registerSchema({
+        schema: interactionLinkCreateSchema,
+        name: "InteractionLinkCreate",
+    });
+    fastify.registerSchema({
+        schema: interactionLinkUpdateSchema,
+        name: "InteractionLinkUpdate",
+    });
+    fastify.registerSchema({
+        schema: triggerSchema,
+        name: "Trigger",
+    });
+};

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

@@ -0,0 +1,79 @@
+import type { InteractionLink as InteractionLinkType } from "./interactionLink.schema.js";
+import type { ClientPayload, ClientPayloadRequestData } from "../../../../../core/payload/payloadTypes.js";
+import { PluginFastifyInstance } from "../../../../../../types/index.js";
+import { Model } from "mongoose";
+export type InteractionLinkBody = Partial<Omit<InteractionLinkType, "_id">> & {
+    _id?: string;
+};
+export declare class InteractionLinkService {
+    private interactionLinkModel;
+    constructor(model: Model<InteractionLinkType>);
+    /**
+     * Core function to create an interaction link (returns raw data)
+     */
+    _createInteractionLink(fastify: PluginFastifyInstance, interactionLinkBody: InteractionLinkBody, userId: string): Promise<InteractionLinkType>;
+    /**
+     * Create a new interaction link with payload wrapping and event emission
+     */
+    createInteractionLink(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, interactionLinkBody: InteractionLinkBody, userId: string): Promise<ClientPayload<InteractionLinkType[]>>;
+    /**
+     * Core function to get all interaction links (returns raw data)
+     */
+    _readAllInteractionLinks(fastify: PluginFastifyInstance, filters?: Record<string, any>): Promise<InteractionLinkType[]>;
+    /**
+     * Get all interaction links with payload wrapping
+     */
+    getAllInteractionLinks(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, filters?: Record<string, any>): Promise<ClientPayload<InteractionLinkType[]>>;
+    /**
+     * Core function to get interaction links by composition ID (returns raw data)
+     */
+    _readInteractionLinksByComposition(fastify: PluginFastifyInstance, compositionId: string): Promise<InteractionLinkType[]>;
+    /**
+     * Get interaction links by composition ID with payload wrapping
+     */
+    readInteractionLinksByComposition(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, compositionId: string): Promise<ClientPayload<InteractionLinkType[]>>;
+    /**
+     * Core function to get a specific interaction link (returns raw data)
+     */
+    _readInteractionLink(fastify: PluginFastifyInstance, id: string): Promise<InteractionLinkType>;
+    /**
+     * Get a specific interaction link with payload wrapping
+     */
+    readInteractionLink(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<InteractionLinkType[]>>;
+    /**
+     * Core function to update an interaction link (returns raw data)
+     */
+    _updateInteractionLink(fastify: PluginFastifyInstance, id: string, interactionLinkBody: InteractionLinkBody, userId: string | undefined): Promise<{
+        updated: InteractionLinkType;
+        original: InteractionLinkType;
+    }>;
+    /**
+     * Update an interaction link with payload wrapping and event emission
+     */
+    updateInteractionLink(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string, interactionLinkBody: InteractionLinkBody): Promise<ClientPayload<InteractionLinkType[]>>;
+    /**
+     * Core function to soft delete an interaction link (returns raw data)
+     */
+    _removeInteractionLink(fastify: PluginFastifyInstance, id: string): Promise<InteractionLinkType>;
+    /**
+     * Soft delete an interaction link with payload wrapping and event emission
+     */
+    removeInteractionLink(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<InteractionLinkType[]>>;
+    /**
+     * Core function to hard delete an interaction link (returns raw data)
+     */
+    _hardDeleteInteractionLink(fastify: PluginFastifyInstance, id: string): Promise<InteractionLinkType>;
+    /**
+     * Hard delete an interaction link with payload wrapping and event emission
+     */
+    hardDeleteInteractionLink(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<InteractionLinkType[]>>;
+    /**
+     * Core function to get interaction links by trigger type and identifier (returns raw data)
+     */
+    _readInteractionLinksByTrigger(fastify: PluginFastifyInstance, triggerType: string, identifier: string): Promise<InteractionLinkType[]>;
+    /**
+     * Get interaction links by trigger type and identifier with payload wrapping
+     */
+    readInteractionLinksByTrigger(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, triggerType: string, identifier: string): Promise<ClientPayload<InteractionLinkType[]>>;
+}
+export declare const createInteractionLinkService: (model: Model<InteractionLinkType>) => InteractionLinkService;

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

@@ -0,0 +1,272 @@
+import { v4 as uuidv4, validate } from "uuid";
+import { createInteractionLinkPayload } from "./helpers/payload.js";
+// InteractionLink Service class
+export class InteractionLinkService {
+    interactionLinkModel;
+    constructor(model) {
+        this.interactionLinkModel = model;
+    }
+    /**
+     * Core function to create an interaction link (returns raw data)
+     */
+    async _createInteractionLink(fastify, interactionLinkBody, userId) {
+        try {
+            if (interactionLinkBody._id) {
+                const uuidValid = validate(interactionLinkBody._id);
+                if (!uuidValid) {
+                    throw new Error("Invalid ID - not a valid uuid v4");
+                }
+                const duplicate = await this.interactionLinkModel.findOne({
+                    _id: interactionLinkBody._id,
+                });
+                if (duplicate) {
+                    throw new Error("An entry with this id already exists");
+                }
+            }
+            else {
+                interactionLinkBody._id = uuidv4();
+            }
+            const interactionLink = new this.interactionLinkModel({
+                ...interactionLinkBody,
+                author: userId,
+                lastEditor: userId,
+            });
+            await interactionLink.save();
+            fastify.log.info(`[API] Created interaction link #${interactionLink.id}`);
+            return interactionLink.toObject
+                ? interactionLink.toObject()
+                : interactionLink;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Create a new interaction link with payload wrapping and event emission
+     */
+    async createInteractionLink(fastify, requestData, interactionLinkBody, userId) {
+        const interactionLink = await this._createInteractionLink(fastify, interactionLinkBody, userId);
+        const payload = await createInteractionLinkPayload(fastify, [interactionLink], requestData);
+        fastify.emit("interactionLinkCreated", payload);
+        return payload;
+    }
+    /**
+     * Core function to get all interaction links (returns raw data)
+     */
+    async _readAllInteractionLinks(fastify, filters = {}) {
+        try {
+            return await this.interactionLinkModel
+                .find({
+                isDeleted: false,
+                ...filters,
+            })
+                .lean();
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get all interaction links with payload wrapping
+     */
+    async getAllInteractionLinks(fastify, requestData, filters = {}) {
+        const interactionLinks = await this._readAllInteractionLinks(fastify, filters);
+        return createInteractionLinkPayload(fastify, interactionLinks, requestData);
+    }
+    /**
+     * Core function to get interaction links by composition ID (returns raw data)
+     */
+    async _readInteractionLinksByComposition(fastify, compositionId) {
+        try {
+            return await this.interactionLinkModel
+                .find({
+                composition: compositionId,
+                isDeleted: false,
+            })
+                .lean();
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get interaction links by composition ID with payload wrapping
+     */
+    async readInteractionLinksByComposition(fastify, requestData, compositionId) {
+        const interactionLinks = await this._readInteractionLinksByComposition(fastify, compositionId);
+        return createInteractionLinkPayload(fastify, interactionLinks, requestData);
+    }
+    /**
+     * Core function to get a specific interaction link (returns raw data)
+     */
+    async _readInteractionLink(fastify, id) {
+        try {
+            const interactionLink = await this.interactionLinkModel
+                .findOne({ _id: id })
+                .lean();
+            if (!interactionLink) {
+                throw new Error(`InteractionLink with ID ${id} not found`);
+            }
+            return interactionLink;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get a specific interaction link with payload wrapping
+     */
+    async readInteractionLink(fastify, requestData, id) {
+        const interactionLink = await this._readInteractionLink(fastify, id);
+        return createInteractionLinkPayload(fastify, [interactionLink], requestData);
+    }
+    /**
+     * Core function to update an interaction link (returns raw data)
+     */
+    async _updateInteractionLink(fastify, id, interactionLinkBody, userId) {
+        try {
+            const originalInteractionLink = await this.interactionLinkModel.findOne({
+                _id: id,
+            });
+            if (!originalInteractionLink) {
+                throw new Error(`InteractionLink with ID ${id} not found`);
+            }
+            // Remove protected fields
+            delete interactionLinkBody._id;
+            if (userId) {
+                interactionLinkBody.lastEditor = userId;
+            }
+            const updatedInteractionLink = await this.interactionLinkModel
+                .findOneAndUpdate({ _id: id }, {
+                ...interactionLinkBody,
+            }, { new: true })
+                .lean();
+            if (!updatedInteractionLink) {
+                throw new Error(`Failed to update interaction link with ID ${id}`);
+            }
+            fastify.log.info(`[API] Updated interaction link #${updatedInteractionLink._id}`);
+            return {
+                updated: updatedInteractionLink,
+                original: originalInteractionLink.toObject
+                    ? originalInteractionLink.toObject()
+                    : originalInteractionLink,
+            };
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Update an interaction link with payload wrapping and event emission
+     */
+    async updateInteractionLink(fastify, requestData, id, interactionLinkBody) {
+        const { updated, original } = await this._updateInteractionLink(fastify, id, interactionLinkBody, requestData.userId || "");
+        const payload = await createInteractionLinkPayload(fastify, [updated], requestData);
+        payload.body.prevVersion = original;
+        if (requestData.broadcast) {
+            fastify.emit("interactionLinkUpdated", payload);
+        }
+        return payload;
+    }
+    /**
+     * Core function to soft delete an interaction link (returns raw data)
+     */
+    async _removeInteractionLink(fastify, id) {
+        try {
+            const interactionLink = await this.interactionLinkModel
+                .findOneAndUpdate({ _id: id }, { isDeleted: true }, { new: true })
+                .lean();
+            if (!interactionLink) {
+                throw new Error(`InteractionLink with ID ${id} not found`);
+            }
+            return interactionLink;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Soft delete an interaction link with payload wrapping and event emission
+     */
+    async removeInteractionLink(fastify, requestData, id) {
+        const interactionLink = await this._removeInteractionLink(fastify, id);
+        const payload = await createInteractionLinkPayload(fastify, [interactionLink], {
+            ...requestData,
+            type: "dataDeleted",
+        });
+        payload.body.deleted = [interactionLink._id];
+        fastify.emit("interactionLinkDeleted", payload);
+        return payload;
+    }
+    /**
+     * Core function to hard delete an interaction link (returns raw data)
+     */
+    async _hardDeleteInteractionLink(fastify, id) {
+        try {
+            const interactionLink = await this.interactionLinkModel.findOne({
+                _id: id,
+                isDeleted: true,
+            });
+            if (!interactionLink) {
+                throw new Error(`InteractionLink with ID ${id} not found or not marked for deletion`);
+            }
+            await this.interactionLinkModel.deleteOne({ id });
+            return interactionLink.toObject
+                ? interactionLink.toObject()
+                : interactionLink;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Hard delete an interaction link with payload wrapping and event emission
+     */
+    async hardDeleteInteractionLink(fastify, requestData, id) {
+        const interactionLink = await this._hardDeleteInteractionLink(fastify, id);
+        const payload = await createInteractionLinkPayload(fastify, [interactionLink], {
+            ...requestData,
+            type: "dataHardDeleted",
+        });
+        payload.body.deleted = [interactionLink._id];
+        fastify.emit("interactionLinkHardDeleted", payload);
+        return payload;
+    }
+    /**
+     * Core function to get interaction links by trigger type and identifier (returns raw data)
+     */
+    async _readInteractionLinksByTrigger(fastify, triggerType, identifier) {
+        try {
+            return await this.interactionLinkModel
+                .find({
+                isDeleted: false,
+                triggers: {
+                    $elemMatch: {
+                        type: triggerType,
+                        identifier: identifier,
+                    },
+                },
+            })
+                .lean();
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get interaction links by trigger type and identifier with payload wrapping
+     */
+    async readInteractionLinksByTrigger(fastify, requestData, triggerType, identifier) {
+        const interactionLinks = await this._readInteractionLinksByTrigger(fastify, triggerType, identifier);
+        return createInteractionLinkPayload(fastify, interactionLinks, requestData);
+    }
+}
+export const createInteractionLinkService = (model) => new InteractionLinkService(model);

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/interactionLink/routes/index.d.ts

@@ -0,0 +1,3 @@
+import { PluginFastifyInstance } from "../../../../../../../types/index.js";
+declare const registerRoutes: (fastify: PluginFastifyInstance) => Promise<void>;
+export default registerRoutes;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/interactionLink/routes/index.js

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

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/interactionLink/routes/route.interactionLink.get.d.ts

@@ -0,0 +1,24 @@
+import type { Static } from "@sinclair/typebox";
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { 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;
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        params: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export default _default;