@raclettejs/core 0.0.1

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

@@ -0,0 +1,242 @@
+import { v4 as uuidv4, validate } from "uuid";
+import { createAccountPayload } from "./helpers/payload.js";
+export class AccountService {
+    accountModel;
+    constructor(model) {
+        this.accountModel = model;
+    }
+    /**
+     * Core function to create an account (returns raw data)
+     */
+    async _createAccount(fastify, accountBody, userId) {
+        try {
+            if (accountBody._id) {
+                const uuidValid = validate(accountBody._id);
+                if (!uuidValid) {
+                    throw new Error("Invalid ID - not a valid uuid v4");
+                }
+                const duplicate = await this.accountModel.findById(accountBody._id);
+                if (duplicate) {
+                    throw new Error("An entry with this id already exists");
+                }
+            }
+            else {
+                accountBody._id = uuidv4();
+            }
+            const account = new this.accountModel({
+                ...accountBody,
+                owner: userId,
+            });
+            await account.save();
+            fastify.log.info(`[API] Created account #${account._id}`);
+            return account.toObject ? account.toObject() : account;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Create a new account with payload wrapping and event emission
+     */
+    async createAccount(fastify, requestData, accountBody, userId) {
+        const account = await this._createAccount(fastify, accountBody, userId);
+        const payload = await createAccountPayload(fastify, [account], requestData);
+        if (requestData.broadcast) {
+            fastify.emit("accountCreated", payload);
+        }
+        return payload;
+    }
+    /**
+     * Core function to get all accounts (returns raw data)
+     */
+    async _readAccounts(fastify) {
+        try {
+            return await this.accountModel.find({ isDeleted: false }).lean();
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get all accounts with payload wrapping
+     */
+    async readAccounts(fastify, requestData) {
+        const accounts = await this._readAccounts(fastify);
+        return createAccountPayload(fastify, accounts, requestData);
+    }
+    /**
+     * Core function to get a specific account (returns raw data)
+     */
+    async _readAccount(fastify, id) {
+        try {
+            const account = await this.accountModel.findById(id).lean();
+            if (!account) {
+                throw new Error(`Account with ID ${id} not found`);
+            }
+            return account;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get a specific account with payload wrapping
+     */
+    async readAccount(fastify, requestData, id) {
+        const account = await this._readAccount(fastify, id);
+        return createAccountPayload(fastify, [account], requestData);
+    }
+    /**
+     * Core function to update an account (returns raw data)
+     */
+    async _updateAccount(fastify, id, accountBody, userId) {
+        try {
+            const originalAccount = await this.accountModel.findById(id);
+            if (!originalAccount) {
+                throw new Error(`Account with ID ${id} not found`);
+            }
+            // Remove protected fields
+            delete accountBody._id;
+            const updatedAccount = await this.accountModel
+                .findByIdAndUpdate(id, {
+                ...accountBody,
+                updatedBy: userId,
+            }, { new: true })
+                .lean();
+            if (!updatedAccount) {
+                throw new Error(`Failed to update account with ID ${id}`);
+            }
+            fastify.log.info(`[API] Updated account #${updatedAccount._id}`);
+            return {
+                updated: updatedAccount,
+                original: originalAccount.toObject
+                    ? originalAccount.toObject()
+                    : originalAccount,
+            };
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Update an account with payload wrapping and event emission
+     */
+    async updateAccount(fastify, requestData, id, accountBody, userId) {
+        const { updated, original } = await this._updateAccount(fastify, id, accountBody, userId);
+        const payload = await createAccountPayload(fastify, [updated], requestData);
+        payload.body.prevVersion = original;
+        if (requestData.broadcast) {
+            fastify.emit("accountUpdated", payload);
+        }
+        return payload;
+    }
+    /**
+     * Core function to soft delete an account (returns raw data)
+     */
+    async _removeAccount(fastify, id) {
+        try {
+            const account = await this.accountModel
+                .findByIdAndUpdate(id, { isDeleted: true }, { new: true })
+                .lean();
+            if (!account) {
+                throw new Error(`Account with ID ${id} not found`);
+            }
+            return account;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Soft delete an account with payload wrapping and event emission
+     */
+    async removeAccount(fastify, requestData, id) {
+        const account = await this._removeAccount(fastify, id);
+        const payload = await createAccountPayload(fastify, [account], {
+            ...requestData,
+            type: "dataDeleted",
+        });
+        payload.body.deleted = [account._id];
+        fastify.emit("accountDeleted", payload);
+        return payload;
+    }
+    /**
+     * Core function to hard delete an account (returns raw data)
+     */
+    async _hardDeleteAccount(fastify, id) {
+        try {
+            const account = await this.accountModel.findOne({
+                _id: id,
+                isDeleted: true,
+            });
+            if (!account) {
+                throw new Error(`Account with ID ${id} not found or not marked for deletion`);
+            }
+            await this.accountModel.deleteOne({ _id: id });
+            return account.toObject ? account.toObject() : account;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Hard delete an account with payload wrapping and event emission
+     */
+    async hardDeleteAccount(fastify, requestData, id) {
+        const account = await this._hardDeleteAccount(fastify, id);
+        const payload = await createAccountPayload(fastify, [account], {
+            ...requestData,
+            type: "dataHardDeleted",
+        });
+        payload.body.deleted = [account._id];
+        fastify.emit("accountHardDeleted", payload);
+        return payload;
+    }
+    /**
+     * Core function to toggle block status of an account (returns raw data)
+     */
+    async _toggleBlockAccount(fastify, id, blocked, userId) {
+        try {
+            const originalAccount = await this.accountModel.findById(id);
+            if (!originalAccount) {
+                throw new Error(`Account with ID ${id} not found`);
+            }
+            const updatedAccount = await this.accountModel
+                .findByIdAndUpdate(id, {
+                blocked,
+                updatedBy: userId,
+            }, { new: true })
+                .lean();
+            if (!updatedAccount) {
+                throw new Error(`Failed to update account with ID ${id}`);
+            }
+            return {
+                updated: updatedAccount,
+                original: originalAccount.toObject
+                    ? originalAccount.toObject()
+                    : originalAccount,
+            };
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Toggle block status of an account with payload wrapping and event emission
+     */
+    async toggleBlockAccount(fastify, requestData, id, blocked, userId) {
+        const { updated, original } = await this._toggleBlockAccount(fastify, id, blocked, userId);
+        const payload = await createAccountPayload(fastify, [updated], requestData);
+        payload.body.prevVersion = original;
+        fastify.emit("accountUpdated", payload);
+        return payload;
+    }
+}
+export const createAccountService = (model) => new AccountService(model);

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/account/events/index.d.ts

@@ -0,0 +1,3 @@
+import { type FastifyInstance } from "fastify";
+declare const registerEvents: (fastify: FastifyInstance) => void;
+export default registerEvents;

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

@@ -0,0 +1,31 @@
+const registerEvents = (fastify) => {
+    /**
+     * Account created
+     */
+    const created = (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.eventbus.emit("broadcastAccountCreated", payload);
+        fastify.log.info(`[eventbus] account broadcast created ${payload.appSessionId}`);
+    };
+    /**
+     * Account updated
+     */
+    const updated = (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.log.info(`[eventbus] account broadcast updated ${payload.appSessionId}`);
+    };
+    /**
+     * Account deleted
+     */
+    const deleted = (payload) => {
+        fastify.eventbus.emit("broadcastAccountDeleted", payload);
+        fastify.log.info(`[eventbus] account broadcast deleted ${payload.appSessionId}`);
+    };
+    /**
+     * Register event handlers
+     */
+    fastify.eventbus.on("coreAccountCreated", created);
+    fastify.eventbus.on("coreAccountUpdated", updated);
+    fastify.eventbus.on("coreAccountDeleted", deleted);
+};
+export default registerEvents;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/account/helpers/crud.d.ts

@@ -0,0 +1,2 @@
+import type { PluginFastifyInstance } from "../../../../../../types/index.js";
+export declare const registerCrud: (fastify: PluginFastifyInstance) => void;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/account/helpers/crud.js

@@ -0,0 +1,9 @@
+export const registerCrud = (fastify) => {
+    const accountService = fastify.custom.accountService;
+    fastify.registerCrudHandlers("account", {
+        create: accountService.createAccount,
+        read: accountService.readAccount,
+        update: accountService.updateAccount,
+        delete: accountService.removeAccount,
+    });
+};

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/account/helpers/payload.d.ts

@@ -0,0 +1,4 @@
+import type { Account } from "../account.schema.js";
+import type { ClientPayloadRequestData, PluginFastifyInstance } from "../../../../../../types/index.js";
+export declare const registerPayload: (fastify: PluginFastifyInstance) => void;
+export declare const createAccountPayload: (fastify: PluginFastifyInstance, items: Account[], requestData: ClientPayloadRequestData) => Promise<import("../../../../../../types/index.js").ClientPayload<Account[]>>;

package/services/backend/dist/src/corePlugins/raclette__core/server/datatypes/account/helpers/payload.js

@@ -0,0 +1,13 @@
+export const registerPayload = (fastify) => {
+    fastify.registerPayloadHandler("account", {
+        type: "account",
+        displayName: (account) => account.name || "",
+        completion: (account) => account.name || "",
+        createMeta: (account) => ({
+            isActive: account.active,
+            isBlocked: account.blocked,
+            hasExpiration: !!account.expires,
+        }),
+    });
+};
+export const createAccountPayload = async (fastify, items, requestData) => await fastify.createPayload("account", items, requestData);

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

@@ -0,0 +1,16 @@
+import type { PluginFastifyInstance } from "../../../../../../types/index.js";
+declare const registerAccount: (fastify: PluginFastifyInstance) => Promise<{
+    account: {
+        operations: {
+            readAll: any;
+            read: any;
+            create: any;
+            update: any;
+        };
+        keywords: string[];
+        metadata: {
+            description: string;
+        };
+    };
+}>;
+export default registerAccount;

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

@@ -0,0 +1,48 @@
+import registerRoutes from "./routes/index.js";
+import { createModels } from "./account.model.js";
+import { createAccountService } from "./account.service.js";
+import { registerPayload } from "./helpers/payload.js";
+import { registerCrud } from "./helpers/crud.js";
+import { registerSchemas } from "./account.schema.js";
+const registerAccount = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const accountModel = createModels(fastify);
+    // create and pass in the model to your service
+    const accountService = createAccountService(accountModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.accountService = accountService;
+    /*
+     * ---------------------------------------------------------------------
+     * 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 {
+        account: {
+            operations: {
+                readAll: accountService._readAccounts.bind(accountService),
+                read: accountService._readAccount.bind(accountService),
+                create: accountService._createAccount.bind(accountService),
+                update: accountService._updateAccount.bind(accountService),
+            },
+            keywords: ["account"],
+            metadata: {
+                description: "An account handles users and projects",
+            },
+        },
+    };
+};
+export default registerAccount;

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

@@ -0,0 +1,3 @@
+import type { 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/account/routes/index.js

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

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

@@ -0,0 +1,24 @@
+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;
+    };
+    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.get.js

@@ -0,0 +1,33 @@
+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.readAccount(fastify, req.requestParams, _id);
+            if (!payload) {
+                return reply.notFound("Account not found");
+            }
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataPush",
+        },
+        schema: {
+            summary: "Get an account by id",
+            tags: ["core/account"],
+            params: ParamsSchema,
+        },
+    };
+};

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

@@ -0,0 +1,15 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { PluginFastifyInstance } from "../../../../../../../types/index.js";
+declare const _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        params: {};
+    };
+};
+export default _default;

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

@@ -0,0 +1,25 @@
+export default (fastify) => {
+    const accountService = fastify.custom.accountService;
+    const handler = async (req, reply) => {
+        try {
+            const payload = await accountService.readAccounts(fastify, req.requestParams);
+            return payload;
+        }
+        catch (error) {
+            fastify.log.error(error.message);
+            return reply.internalServerError(error.message);
+        }
+    };
+    return {
+        handler,
+        onRequest: [fastify.authenticate],
+        config: {
+            type: "dataPush",
+        },
+        schema: {
+            summary: "Get all accounts. Only available to admins.",
+            tags: ["core/account"],
+            params: {},
+        },
+    };
+};

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

@@ -0,0 +1,26 @@
+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;
+        description: 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.hardDelete.js

@@ -0,0 +1,32 @@
+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.hardDeleteAccount(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: "dataHardDeleted",
+            broadcastChannels: ["accountHardDeleted"],
+        },
+        schema: {
+            summary: "Hard delete an account",
+            description: "Permanently removes an account that has been soft deleted",
+            tags: ["core/account"],
+            params: ParamsSchema,
+        },
+    };
+};

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

@@ -0,0 +1,39 @@
+import type { AccountBody } from "../account.service.js";
+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;
+        Body: AccountBody;
+    }>, 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;
+        }>;
+        body: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            active: import("@sinclair/typebox").TBoolean;
+            blocked: import("@sinclair/typebox").TBoolean;
+            expires: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>>;
+            owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            isDeleted: import("@sinclair/typebox").TBoolean;
+            createdAt: import("@sinclair/typebox").TString;
+            updatedAt: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export default _default;

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

@@ -0,0 +1,33 @@
+import { Type } from "@sinclair/typebox";
+import { accountSchema } from "../account.schema.js";
+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.updateAccount(fastify, req.requestParams, _id, 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: "dataUpdate",
+            broadcastChannels: ["accountUpdated", "broadcastDataUpdated"],
+        },
+        schema: {
+            summary: "Update an account",
+            tags: ["core/account"],
+            params: ParamsSchema,
+            body: accountSchema,
+        },
+    };
+};

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

@@ -0,0 +1,30 @@
+import type { AccountBody } from "../account.service.js";
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { PluginFastifyInstance } from "../../../../../../../types/index.js";
+declare const _default: (fastify: PluginFastifyInstance) => {
+    handler: (req: FastifyRequest<{
+        Body: AccountBody;
+    }>, reply: FastifyReply) => Promise<any>;
+    onRequest: any[];
+    config: {
+        type: string;
+        broadcastChannels: string[];
+    };
+    schema: {
+        summary: string;
+        tags: string[];
+        body: import("@sinclair/typebox").TObject<{
+            _id: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            active: import("@sinclair/typebox").TBoolean;
+            blocked: import("@sinclair/typebox").TBoolean;
+            expires: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>>;
+            owner: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            isDeleted: import("@sinclair/typebox").TBoolean;
+            createdAt: import("@sinclair/typebox").TString;
+            updatedAt: import("@sinclair/typebox").TString;
+        }>;
+    };
+};
+export default _default;