@raclettejs/core 0.1.0 → 0.1.2

package/services/backend/dist/src/corePlugins/raclette__core/client/generated-config.js

@@ -1,359 +0,0 @@
-// Auto-generated frontend configuration for plugin: raclette__core
-// This file is generated from backend routes - do not edit manually
-// Entity mapping: {}
-export default {
-    pluginName: "core",
-    author: "raclette",
-    pluginKey: "raclette__core",
-    routePrefix: "/raclette__core",
-    pluginPath: "/app/src/corePlugins/raclette__core",
-    data: {
-        account: {
-            type: "account",
-            operations: {
-                getAll: {
-                    target: "/raclette__core/account/all",
-                    method: "get"
-                },
-                get: {
-                    target: (payload) => `/raclette__core/account/${payload._id}`,
-                    method: "get"
-                },
-                update: {
-                    target: (payload) => `/raclette__core/account/${payload._id}`,
-                    method: "patch",
-                    channels: [
-                        {
-                            channel: "raclette__core--accountUpdated",
-                            channelKey: "accountUpdated",
-                            prefix: "raclette__core"
-                        },
-                        {
-                            channel: "dataUpdated",
-                            channelKey: "broadcastDataUpdated",
-                            prefix: ""
-                        }
-                    ]
-                },
-                create: {
-                    target: "/raclette__core/account",
-                    method: "post",
-                    channels: [
-                        {
-                            channel: "raclette__core--accountCreated",
-                            channelKey: "accountCreated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                delete: {
-                    target: (payload) => `/raclette__core/account/${payload._id}`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--accountDeleted",
-                            channelKey: "accountDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                deleteHard: {
-                    target: (payload) => `/raclette__core/account/${payload._id}/hard`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--accountHardDeleted",
-                            channelKey: "accountHardDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                }
-            }
-        },
-        interactionLink: {
-            type: "interactionLink",
-            operations: {
-                getAll: {
-                    target: "/raclette__core/interactionLink/all",
-                    method: "get"
-                },
-                get: {
-                    target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
-                    method: "get"
-                },
-                update: {
-                    target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
-                    method: "patch",
-                    channels: [
-                        {
-                            channel: "raclette__core--interactionLinkUpdated",
-                            channelKey: "interactionLinkUpdated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                create: {
-                    target: "/raclette__core/interactionLink",
-                    method: "post",
-                    channels: [
-                        {
-                            channel: "raclette__core--interactionLinkCreated",
-                            channelKey: "interactionLinkCreated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                delete: {
-                    target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--interactionLinkDeleted",
-                            channelKey: "interactionLinkDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                deleteHard: {
-                    target: (payload) => `/raclette__core/interactionLink/${payload._id}/hard`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--interactionLinkHardDeleted",
-                            channelKey: "interactionLinkHardDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                }
-            }
-        },
-        project: {
-            type: "project",
-            operations: {
-                getAll: {
-                    target: "/raclette__core/project/all",
-                    method: "get"
-                },
-                get: {
-                    target: (payload) => `/raclette__core/project/${payload._id}`,
-                    method: "get"
-                },
-                create: {
-                    target: "/raclette__core/project",
-                    method: "post",
-                    channels: [
-                        {
-                            channel: "raclette__core--projectCreated",
-                            channelKey: "projectCreated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                update: {
-                    target: (payload) => `/raclette__core/project/${payload._id}`,
-                    method: "patch",
-                    channels: [
-                        {
-                            channel: "raclette__core--projectUpdated",
-                            channelKey: "projectUpdated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                delete: {
-                    target: (payload) => `/raclette__core/project/${payload._id}`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--projectDeleted",
-                            channelKey: "projectDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                deleteHard: {
-                    target: (payload) => `/raclette__core/project/${payload._id}/hard`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--projectHardDeleted",
-                            channelKey: "projectHardDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                }
-            }
-        },
-        tag: {
-            type: "tag",
-            operations: {
-                getAll: {
-                    target: "/raclette__core/tag/all",
-                    method: "get"
-                },
-                get: {
-                    target: (payload) => `/raclette__core/tag/${payload._id}`,
-                    method: "get"
-                },
-                update: {
-                    target: (payload) => `/raclette__core/tag/${payload._id}`,
-                    method: "patch",
-                    channels: [
-                        {
-                            channel: "raclette__core--tagUpdated",
-                            channelKey: "tagUpdated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                create: {
-                    target: (payload) => `/raclette__core/tag/${payload.project}/${payload._id}`,
-                    method: "post",
-                    channels: [
-                        {
-                            channel: "raclette__core--tagCreated",
-                            channelKey: "tagCreated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                delete: {
-                    target: (payload) => `/raclette__core/tag/${payload._id}`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--tagDeleted",
-                            channelKey: "tagDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                deleteHard: {
-                    target: (payload) => `/raclette__core/tag/${payload._id}/hard`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--tagHardDeleted",
-                            channelKey: "tagHardDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                }
-            }
-        },
-        user: {
-            type: "user",
-            operations: {
-                getAll: {
-                    target: "/raclette__core/user/all",
-                    method: "get"
-                },
-                get: {
-                    target: (payload) => `/raclette__core/user/${payload._id}`,
-                    method: "get"
-                },
-                update: {
-                    target: (payload) => `/raclette__core/user/${payload._id}`,
-                    method: "patch",
-                    channels: [
-                        {
-                            channel: "raclette__core--userUpdated",
-                            channelKey: "userUpdated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                create: {
-                    target: "/raclette__core/user",
-                    method: "post",
-                    channels: [
-                        {
-                            channel: "raclette__core--userCreated",
-                            channelKey: "userCreated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                delete: {
-                    target: (payload) => `/raclette__core/user/${payload._id}`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--userDeleted",
-                            channelKey: "userDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                updateLastProject: {
-                    target: (payload) => `/raclette__core/user/last-project/${payload.projectId}`,
-                    method: "patch",
-                    channels: [
-                        {
-                            channel: "raclette__core--userUpdated",
-                            channelKey: "userUpdated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                }
-            }
-        },
-        composition: {
-            type: "composition",
-            operations: {
-                getAll: {
-                    target: "/raclette__core/composition/all",
-                    method: "get"
-                },
-                get: {
-                    target: (payload) => `/raclette__core/composition/${payload._id}`,
-                    method: "get"
-                },
-                update: {
-                    target: (payload) => `/raclette__core/composition/${payload._id}`,
-                    method: "patch",
-                    channels: [
-                        {
-                            channel: "raclette__core--compositionUpdated",
-                            channelKey: "compositionUpdated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                create: {
-                    target: "/raclette__core/composition",
-                    method: "post",
-                    channels: [
-                        {
-                            channel: "raclette__core--compositionCreated",
-                            channelKey: "compositionCreated",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                delete: {
-                    target: (payload) => `/raclette__core/composition/${payload._id}`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--compositionDeleted",
-                            channelKey: "compositionDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                },
-                deleteHard: {
-                    target: (payload) => `/raclette__core/composition/${payload._id}/hard`,
-                    method: "delete",
-                    channels: [
-                        {
-                            channel: "raclette__core--compositionHardDeleted",
-                            channelKey: "compositionHardDeleted",
-                            prefix: "raclette__core"
-                        }
-                    ]
-                }
-            }
-        }
-    }
-};

package/services/backend/dist/src/corePlugins/raclette__core/client/index.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/services/backend/dist/src/corePlugins/raclette__core/client/index.js

@@ -1,2 +0,0 @@
-import { defineRaclettePluginClient } from "@raclettejs/raclette-core/client";
-export default defineRaclettePluginClient({});

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

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

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

@@ -1,33 +0,0 @@
-import mongoose from "mongoose";
-import { v4 as uuidv4 } from "uuid";
-const { Schema } = mongoose;
-export const MODEL_BASENAME = "account";
-const accountSchema = new Schema({
-    _id: {
-        type: String,
-        default: () => uuidv4(),
-    },
-    name: {
-        type: String,
-        required: true,
-        unique: true,
-        maxLength: 200,
-    },
-    active: { type: Boolean, default: true },
-    blocked: { type: Boolean, default: false },
-    expires: { type: Date, default: null },
-    owner: {
-        type: Schema.Types.String,
-        ref: "raclette__core-user",
-        default: null,
-    },
-    tags: {
-        type: [Schema.Types.String],
-        ref: "raclette__core-tag",
-        default: [],
-    },
-    isDeleted: { type: Boolean, default: false },
-}, { timestamps: true });
-export const createModels = (fastify) => {
-    return fastify.createModel(MODEL_BASENAME, accountSchema);
-};

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

@@ -1,36 +0,0 @@
-import type { Static } from "@sinclair/typebox";
-import type { Document } from "mongoose";
-import type { PluginFastifyInstance } from "../../../../../../types/index.js";
-/**
- * Account Schema
- */
-export declare const accountSchema: 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;
-}>;
-/**
- * Type Utilities
- */
-type DateTimeFields = {
-    createdAt: Date;
-    updatedAt: Date;
-};
-type RawAccount = Static<typeof accountSchema>;
-export type Account = Omit<RawAccount, keyof DateTimeFields> & DateTimeFields;
-export interface AccountDoc extends Document, Account {
-    _id: string;
-}
-export type AnyAccount = Account | AccountDoc;
-export { accountSchema as default };
-/**
- * Register Schema/Type Generation for Shared Folder
- */
-export declare const registerSchemas: (fastify: PluginFastifyInstance) => void;

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

@@ -1,29 +0,0 @@
-import { Type } from "@sinclair/typebox";
-/**
- * Account Schema
- */
-export const accountSchema = Type.Object({
-    _id: Type.String(),
-    name: Type.String({ maxLength: 200 }),
-    active: Type.Boolean({ default: true }),
-    blocked: Type.Boolean({ default: false }),
-    expires: Type.Optional(Type.Union([Type.String({ format: "date-time" }), Type.Null()])),
-    owner: Type.Optional(Type.String({ default: null })),
-    tags: Type.Array(Type.String(), { default: [] }),
-    isDeleted: Type.Boolean({ default: false }),
-    createdAt: Type.String({ format: "date-time" }),
-    updatedAt: Type.String({ format: "date-time" }),
-}, {
-    $id: "#account/base",
-    title: "core/account",
-});
-export { accountSchema as default };
-/**
- * Register Schema/Type Generation for Shared Folder
- */
-export const registerSchemas = (fastify) => {
-    fastify.registerSchema({
-        schema: accountSchema,
-        name: "Account",
-    });
-};

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

@@ -1,74 +0,0 @@
-import type { Account as AccountType } from "./account.schema.js";
-import type { ClientPayload, ClientPayloadRequestData } from "../../../../../core/payload/payloadTypes.js";
-import type { PluginFastifyInstance } from "../../../../../../types/index.js";
-import { Model } from "mongoose";
-export type AccountBody = Partial<Omit<AccountType, "_id">> & {
-    _id?: string;
-};
-export declare class AccountService {
-    private accountModel;
-    constructor(model: Model<AccountType>);
-    /**
-     * Core function to create an account (returns raw data)
-     */
-    _createAccount(fastify: PluginFastifyInstance, accountBody: AccountBody, userId: string): Promise<AccountType>;
-    /**
-     * Create a new account with payload wrapping and event emission
-     */
-    createAccount(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, accountBody: AccountBody, userId: string): Promise<ClientPayload<AccountType[]>>;
-    /**
-     * Core function to get all accounts (returns raw data)
-     */
-    _readAccounts(fastify: PluginFastifyInstance): Promise<AccountType[]>;
-    /**
-     * Get all accounts with payload wrapping
-     */
-    readAccounts(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData): Promise<ClientPayload<AccountType[]>>;
-    /**
-     * Core function to get a specific account (returns raw data)
-     */
-    _readAccount(fastify: PluginFastifyInstance, id: string): Promise<AccountType>;
-    /**
-     * Get a specific account with payload wrapping
-     */
-    readAccount(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<AccountType[]>>;
-    /**
-     * Core function to update an account (returns raw data)
-     */
-    _updateAccount(fastify: PluginFastifyInstance, id: string, accountBody: AccountBody, userId: string): Promise<{
-        updated: AccountType;
-        original: AccountType;
-    }>;
-    /**
-     * Update an account with payload wrapping and event emission
-     */
-    updateAccount(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string, accountBody: AccountBody, userId: string): Promise<ClientPayload<AccountType[]>>;
-    /**
-     * Core function to soft delete an account (returns raw data)
-     */
-    _removeAccount(fastify: PluginFastifyInstance, id: string): Promise<AccountType>;
-    /**
-     * Soft delete an account with payload wrapping and event emission
-     */
-    removeAccount(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<AccountType[]>>;
-    /**
-     * Core function to hard delete an account (returns raw data)
-     */
-    _hardDeleteAccount(fastify: PluginFastifyInstance, id: string): Promise<AccountType>;
-    /**
-     * Hard delete an account with payload wrapping and event emission
-     */
-    hardDeleteAccount(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string): Promise<ClientPayload<AccountType[]>>;
-    /**
-     * Core function to toggle block status of an account (returns raw data)
-     */
-    _toggleBlockAccount(fastify: PluginFastifyInstance, id: string, blocked: boolean, userId: string): Promise<{
-        updated: AccountType;
-        original: AccountType;
-    }>;
-    /**
-     * Toggle block status of an account with payload wrapping and event emission
-     */
-    toggleBlockAccount(fastify: PluginFastifyInstance, requestData: ClientPayloadRequestData, id: string, blocked: boolean, userId: string): Promise<ClientPayload<AccountType[]>>;
-}
-export declare const createAccountService: (model: Model<AccountType>) => AccountService;