@raclettejs/core 0.0.1

package/services/backend/dist/src/core/events/eventEmitter.js

@@ -0,0 +1,120 @@
+/*
+ * EventEmiter
+ * @class
+ *
+ * This class mimicks the nodejs EventEmitter. It is primarily used as the
+ * global eventbus so different parts of the application can communicate with
+ * each other without being tightly coupled.
+ * e.g. store -> http client, component -> http client, component -> socket etc.
+ */
+class EventEmitter {
+    /*
+     * @type {object} events - container to hold key value pairs of events/functions
+     */
+    events;
+    /*
+     * @type {object} eventMap - map of available events
+     * For the default eventbus see ./lib/eventMap.ts
+     */
+    eventMap;
+    /*
+     * @param {array} eventMap
+     */
+    constructor(eventMap) {
+        /*
+         * @type {object} events - container to hold key value pairs of events/functions
+         */
+        this.events = {};
+        /*
+         * @type {object} eventMap - map of available events
+         */
+        this.eventMap = eventMap;
+    }
+    /*
+     * on
+     *
+     * @param {string} event - event name
+     * @param {function} listener - callback function
+     */
+    // eslint-disable-next-line id-length
+    on(event, listener) {
+        if (!this.isValid(event)) {
+            return () => { };
+        }
+        if (typeof this.events[event] !== "object") {
+            this.events[event] = [];
+        }
+        this.events[event].push(listener);
+        return () => this.removeListener(event, listener);
+    }
+    /*
+     * removeListener
+     *
+     * @param {string} event - event name
+     * @param {function} listener - callback function
+     */
+    removeListener(event, listener) {
+        if (typeof this.events[event] === "object") {
+            const idx = this.events[event].indexOf(listener);
+            if (idx > -1) {
+                this.events[event].splice(idx, 1);
+            }
+        }
+    }
+    /*
+     * emit
+     *
+     * @param {string} event - event name
+     * @param {string|object|boolean} - arbitrary arguments
+     */
+    emit(event, ...args) {
+        if (!this.isValid(event)) {
+            return false;
+        }
+        if (typeof this.events[event] === "object") {
+            this.events[event].forEach((listener) => listener.apply(this, args));
+            return true;
+        }
+        return false;
+    }
+    /*
+     * once
+     *
+     * @param {string} event - event name
+     * @param {function} listener - callback function
+     */
+    once(event, listener) {
+        if (!this.isValid(event)) {
+            return;
+        }
+        const remove = this.on(event, (...args) => {
+            remove();
+            listener.apply(this, args);
+        });
+    }
+    /*
+     * isValid
+     *
+     * If an eventMap is present this method checks if the given event exists as
+     * key in the map. This is only done for core events, not for plugins.
+     * @param {string} event - event name
+     */
+    isValid(event) {
+        // Skip validation for plugin-prefixed events
+        if (event.includes("__") && event.includes("--")) {
+            // assume plugin
+            return true;
+        }
+        // early return if we don't have an eventMap
+        if (!this.eventMap) {
+            return true;
+        }
+        // throw error if the event is unknown
+        if (!this.eventMap.hasOwnProperty(event)) {
+            throw new Error(`Unkown event passed to eventbus, please check or update: "${event}"`);
+        }
+        // return true if the event exists in the eventMap
+        return true;
+    }
+}
+export default EventEmitter;

package/services/backend/dist/src/core/http/headers.d.ts

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

package/services/backend/dist/src/core/http/headers.js

@@ -0,0 +1,22 @@
+import fastifyPlugin from "fastify-plugin";
+import { CommonHeadersSchema } from "../validation/sharedSchemas.js";
+export default fastifyPlugin(async (fastify) => {
+    // Add shared schemas
+    fastify.addSchema({
+        $id: "commonHeaders",
+        ...CommonHeadersSchema,
+    });
+    // Add hook to validate headers for all routes
+    fastify.addHook("onRoute", (routeOptions) => {
+        // Skip if route explicitly opts out of header validation
+        if (routeOptions.skipHeaderValidation)
+            return;
+        // Merge existing schema with common headers
+        const routeSchema = (routeOptions.schema || {});
+        routeSchema.headers = {
+            ...(routeSchema.headers || {}),
+            ...CommonHeadersSchema.properties, // Use .properties to get the actual schema object
+        };
+        routeOptions.schema = routeSchema;
+    });
+});

package/services/backend/dist/src/core/http/httpService.d.ts

@@ -0,0 +1,4 @@
+import type { HttpPluginOptions } from "../http/httpTypes.js";
+import type { FastifyInstance } from "fastify";
+declare const _default: (fastify: FastifyInstance, options?: HttpPluginOptions) => Promise<void>;
+export default _default;

package/services/backend/dist/src/core/http/httpService.js

@@ -0,0 +1,28 @@
+import axios from "axios";
+import fastifyPlugin from "fastify-plugin";
+import https from "https";
+export default fastifyPlugin(async (fastify, options = {}) => {
+    const client = axios.create({
+        timeout: options.timeout || 30000,
+        headers: {
+            "Content-Type": "application/json",
+            ...options.defaultHeaders,
+        },
+    });
+    const createConfig = (config = {}) => {
+        if (config.ignoreSSL) {
+            return {
+                ...config,
+                httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+            };
+        }
+        return config;
+    };
+    const httpService = {
+        get: async (url, config) => client.get(url, createConfig(config)),
+        post: async (url, data, config) => client.post(url, data, createConfig(config)),
+        put: async (url, data, config) => client.put(url, data, createConfig(config)),
+        delete: async (url, config) => client.delete(url, createConfig(config)),
+    };
+    fastify.decorate("http", httpService);
+});

package/services/backend/dist/src/core/http/httpTypes.d.ts

@@ -0,0 +1,15 @@
+import type { AxiosRequestConfig, AxiosResponse } from "axios";
+export interface HttpRequestConfig extends AxiosRequestConfig {
+    ignoreSSL?: boolean;
+    timeout?: number;
+}
+export type HttpService = {
+    get<T = any>(url: string, config?: HttpRequestConfig): Promise<AxiosResponse<T>>;
+    post<T = any>(url: string, data?: any, config?: HttpRequestConfig): Promise<AxiosResponse<T>>;
+    put<T = any>(url: string, data?: any, config?: HttpRequestConfig): Promise<AxiosResponse<T>>;
+    delete<T = any>(url: string, config?: HttpRequestConfig): Promise<AxiosResponse<T>>;
+};
+export interface HttpPluginOptions {
+    timeout?: number;
+    defaultHeaders?: Record<string, string>;
+}

package/services/backend/dist/src/core/http/httpTypes.js

@@ -0,0 +1 @@
+export {};

package/services/backend/dist/src/core/http/request-params.plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (fastify: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>) => Promise<void>;
+export default _default;

package/services/backend/dist/src/core/http/request-params.plugin.js

@@ -0,0 +1,34 @@
+import fastifyPlugin from "fastify-plugin";
+import { createRequestParams } from "../../utils/request.utils.js";
+const isExcluded = (url) => {
+    const excludedPaths = ["/health", "/metrics"];
+    return excludedPaths.includes(url);
+};
+export default fastifyPlugin(async (fastify) => {
+    fastify.addHook("preHandler", async (request) => {
+        const routeOptions = request.routeOptions.config;
+        request.requestParams = createRequestParams(request, routeOptions || {});
+    });
+    fastify.addHook("onRequest", (request, reply, done) => {
+        done();
+    });
+    fastify.addHook("onRequest", (request, reply, done) => {
+        const url = request.raw.url || "";
+        if (!isExcluded(url)) {
+            request.log.info({ url: request.raw.url, id: request.id }, "Received request");
+        }
+        done();
+    });
+    fastify.addHook("onResponse", (request, reply, done) => {
+        const url = request.raw.url || "";
+        if (!isExcluded(url)) {
+            request.log.info({
+                url: request.raw.url,
+                statusCode: reply.statusCode,
+                responseTime: reply.elapsedTime(),
+                id: request.id,
+            }, "Request completed");
+        }
+        done();
+    });
+});

package/services/backend/dist/src/core/payload/payloadRegistrar.d.ts

@@ -0,0 +1,45 @@
+import type { ClientPayloadRequestData, ClientPayload, ClientPayloadBody } from "../payload/payloadTypes.js";
+interface RequiredPayloadFields {
+    _id: string;
+    owner: string;
+    project: string;
+    updatedAt: string | Date;
+    createdAt: string | Date;
+    tags: string[];
+}
+interface OptionalPayloadFields {
+    deleted?: boolean;
+}
+interface DocumentLike {
+    toObject(): any;
+}
+type RequestDataFallbackFields = "project";
+type DataItem<T extends object> = T | (T & DocumentLike);
+type MissingFields<T extends object> = Exclude<keyof RequiredPayloadFields, keyof T>;
+type RequiredMissingFields<T extends object> = Exclude<MissingFields<T>, RequestDataFallbackFields>;
+type RequiredMappings<T extends object> = Partial<RequiredPayloadFields> & {
+    [K in RequiredMissingFields<T>]: RequiredPayloadFields[K];
+};
+interface PayloadHandlerConfig<T extends object, TMeta = any> {
+    type: string;
+    displayName: (item: T) => string;
+    completion: (item: T) => string;
+    sanitize?: (item: T) => Partial<T>;
+    fields?: (item: T, requestData: ClientPayloadRequestData) => RequiredMappings<T> & OptionalPayloadFields;
+    createMeta?: (item: T) => Promise<TMeta> | TMeta;
+    beforePayload?: (item: T) => Promise<T> | T;
+}
+export declare const registerPayloadHandler: <T extends object, TMeta = any>(type: string, config: PayloadHandlerConfig<T, TMeta>, scope?: string) => void;
+export declare const createPayloadBody: <T extends object>(type: string, item: DataItem<T>, requestData: ClientPayloadRequestData, scope?: string) => Promise<ClientPayloadBody<T>>;
+export declare const createPayloadBodies: <T extends object>(type: string, items: DataItem<T>[], requestData: ClientPayloadRequestData, scope?: string) => Promise<ClientPayloadBody<T>[]>;
+export declare const createPayload: <T extends object>(type: string, items: DataItem<T> | DataItem<T>[], requestData: ClientPayloadRequestData, scope?: string) => Promise<ClientPayload<T[]>>;
+export declare const createMultiTypePayload: <T extends object>(itemsByType: {
+    type: string;
+    items: DataItem<T> | DataItem<T>[];
+    scope?: string;
+}[], requestData: ClientPayloadRequestData) => Promise<ClientPayload<T>>;
+export declare const getPayloadHandler: <T extends object>(type: string, scope?: string) => PayloadHandlerConfig<T> | undefined;
+export declare const getPayloadHandlersByScope: (scope?: string) => PayloadHandlerConfig<any>[];
+export declare const getAllPayloadTypes: (scope?: string) => string[];
+export declare const getAllScopes: () => string[];
+export {};

package/services/backend/dist/src/core/payload/payloadRegistrar.js

@@ -0,0 +1,121 @@
+// Store handlers by scope, then by type
+const handlers = {
+    core: {},
+};
+const isDocument = (item) => {
+    return typeof item?.toObject === "function";
+};
+const toPlainObject = (item) => {
+    if (isDocument(item)) {
+        return item.toObject();
+    }
+    return item;
+};
+export const registerPayloadHandler = (type, config, scope = "core") => {
+    // Ensure the scope exists
+    if (!handlers[scope]) {
+        handlers[scope] = {};
+    }
+    if (handlers[scope][type]) {
+        throw new Error(`Payload handler for type "${type}" in scope "${scope}" already registered`);
+    }
+    handlers[scope][type] = config;
+};
+export const createPayloadBody = async (type, item, requestData, scope = "core") => {
+    // Check if the scope exists
+    if (!handlers[scope]) {
+        throw new Error(`No scope registered with name "${scope}"`);
+    }
+    const handler = handlers[scope][type];
+    if (!handler) {
+        throw new Error(`No payload handler registered for type "${type}" in scope "${scope}"`);
+    }
+    let plainItem = toPlainObject(item);
+    const sanitizedItem = handler.sanitize
+        ? handler.sanitize(plainItem)
+        : plainItem;
+    const meta = handler.createMeta
+        ? await handler.createMeta(plainItem)
+        : undefined;
+    const fields = handler.fields ? handler.fields(plainItem, requestData) : {};
+    if (handler.beforePayload) {
+        plainItem = await handler.beforePayload(plainItem);
+    }
+    const basePayload = {
+        _id: fields._id ?? plainItem._id ?? "",
+        _type: handler.type,
+        _offline: 0,
+        _owner: fields.owner ?? plainItem.owner,
+        _tags: fields.tags ?? plainItem.tags,
+        _displayName: handler.displayName(plainItem) ?? "",
+        _completion: handler.completion(plainItem) ?? "",
+        _project: fields.project ?? plainItem.project ?? requestData.project,
+        _updatedAt: fields.updatedAt ?? plainItem.updatedAt,
+        _createdAt: fields.createdAt ?? plainItem.createdAt,
+        _deleted: fields.deleted ?? plainItem.deleted ?? false,
+        _source: sanitizedItem,
+        _meta: meta,
+    };
+    return basePayload;
+};
+// New function to process multiple items of the same type
+export const createPayloadBodies = async (type, items, requestData, scope = "core") => {
+    return await Promise.all(items.map((item) => createPayloadBody(type, item, requestData, scope)));
+};
+// Updated function to handle arrays of items
+export const createPayload = async (type, items, requestData, scope = "core") => {
+    // Convert single item to array if needed
+    const itemsArray = Array.isArray(items) ? items : [items];
+    // Create payload bodies for all items
+    const bodies = await createPayloadBodies(type, itemsArray, requestData, scope);
+    return {
+        appSessionId: requestData?.appSessionId || "",
+        appRequestCode: requestData?.appRequestCode || "",
+        requestId: requestData?.requestId || "",
+        type: requestData?.type || type,
+        ...(requestData?.project ? { project: requestData?.project } : {}),
+        body: {
+            items: bodies,
+        },
+    };
+};
+// New function to create payloads for multiple items of different types
+export const createMultiTypePayload = async (itemsByType, requestData) => {
+    const allItems = [];
+    // Process each type group
+    await Promise.all(itemsByType.map(async ({ type, items, scope = "core" }) => {
+        const itemsArray = Array.isArray(items) ? items : [items];
+        const bodies = await createPayloadBodies(type, itemsArray, requestData, scope);
+        allItems.push(...bodies);
+    }));
+    return {
+        appSessionId: requestData.appSessionId || "",
+        appRequestCode: requestData.appRequestCode || "",
+        requestId: requestData.requestId || "",
+        type: requestData.type || "multi",
+        body: {
+            items: allItems,
+        },
+    };
+};
+export const getPayloadHandler = (type, scope = "core") => {
+    if (!handlers[scope]) {
+        return undefined;
+    }
+    return handlers[scope][type];
+};
+export const getPayloadHandlersByScope = (scope = "core") => {
+    if (!handlers[scope]) {
+        return [];
+    }
+    return Object.values(handlers[scope]);
+};
+export const getAllPayloadTypes = (scope = "core") => {
+    if (!handlers[scope]) {
+        return [];
+    }
+    return Object.keys(handlers[scope]);
+};
+export const getAllScopes = () => {
+    return Object.keys(handlers);
+};

package/services/backend/dist/src/core/payload/payloadTypes.d.ts

@@ -0,0 +1,42 @@
+export type ClientPayloadRequestData = {
+    appSessionId: string;
+    requestId: string;
+    appRequestCode: string;
+    project?: string;
+    type: string;
+    broadcast?: string[] | boolean;
+    broadcastChannels?: string[];
+    format?: string;
+    userId?: string;
+};
+export type ClientPayloadBody<T> = {
+    _id: string;
+    _type: string;
+    _offline: number;
+    _owner: string;
+    _tags: string[];
+    _displayName: string;
+    _completion: string;
+    _project: string;
+    _updatedAt: string | Date;
+    _createdAt: string | Date;
+    _deleted: boolean;
+    _source?: Partial<any> | T;
+    _meta?: Record<string, any>;
+};
+export type FileType = File | {
+    [x: string]: any;
+};
+export type BodyContent<T> = {
+    items: ClientPayloadBody<T>[];
+    hits?: any;
+    prevVersion?: any;
+    deleted?: string[];
+    restored?: string[];
+    file?: FileType;
+    parent?: T;
+    oldParent?: T;
+};
+export type ClientPayload<T> = ClientPayloadRequestData & {
+    body: BodyContent<T>;
+};

package/services/backend/dist/src/core/payload/payloadTypes.js

@@ -0,0 +1 @@
+export {};

package/services/backend/dist/src/core/pluginSystem/configGenerator/generatorTypes.d.ts

@@ -0,0 +1,49 @@
+export type TrackedRoute = {
+    method: string;
+    url: string;
+    routePath: string;
+    config?: any;
+    schema?: any;
+    handler?: any;
+    routePrefix?: string;
+};
+export type PluginRegistration = {
+    pluginName: string;
+    author: string;
+    pluginKey: string;
+    pluginPath: string;
+    routePrefix: string;
+    entityMapping?: Record<string, string>;
+    customConfig?: {
+        broadcast?: boolean;
+        channels?: Record<string, string>;
+        operationMapping?: Record<string, string>;
+    };
+    registeredAt: number;
+};
+export type CrudOperation = {
+    target: string | ((payload: any) => string);
+    method?: string;
+    broadcast?: boolean;
+    channels?: {
+        channel: string;
+        core: boolean;
+        prefix?: string;
+    };
+};
+export type GeneratedDataType = {
+    type: string;
+    operations: {
+        [operationName: string]: CrudOperation;
+    };
+};
+export type ParsedRouteInfo = {
+    method: string;
+    url: string;
+    entityName: string;
+    operationName: string;
+    pathParams: string[];
+    registration?: PluginRegistration | null;
+    config: any;
+    schema: any;
+};

package/services/backend/dist/src/core/pluginSystem/configGenerator/generatorTypes.js

@@ -0,0 +1 @@
+export {};

package/services/backend/dist/src/core/pluginSystem/configGenerator/index.d.ts

@@ -0,0 +1,14 @@
+import type { FastifyInstance } from "fastify";
+import type { PluginOptions } from "../../../../types/index.js";
+export declare const registerPluginForFrontendGeneration: (pluginOptions: PluginOptions, options?: {
+    routePrefix?: string;
+    entityMapping?: Record<string, string>;
+    customConfig?: {
+        broadcast?: boolean;
+        channels?: Record<string, string>;
+        operationMapping?: Record<string, string>;
+    };
+}) => void;
+export declare const setFastifyInstanceForGeneration: (fastify: FastifyInstance) => void;
+export declare const generateAllFrontendConfigs: () => Promise<void>;
+export declare const triggerGenerationIfReady: () => Promise<void>;