@raclettejs/core 0.0.1

package/services/backend/dist/src/core/sockets/socketTypes.d.ts

@@ -0,0 +1,32 @@
+import type { DefaultEventsMap, EventsMap } from "socket.io/dist/typed-events";
+import { VerifyPayloadType } from "@fastify/jwt";
+declare module "socket.io" {
+    interface Socket<ListenEvents extends EventsMap = DefaultEventsMap, EmitEvents extends EventsMap = ListenEvents, ServerSideEvents extends EventsMap = DefaultEventsMap, SocketData = any> {
+        decoded_token?: VerifyPayloadType;
+        user?: {
+            _id: string;
+            account: any;
+            [key: string]: any;
+        };
+    }
+}
+export type StreamTypes = {
+    ticket?: {
+        all: boolean;
+    };
+    user?: {
+        all: boolean;
+    };
+    tag?: {
+        all: boolean;
+    };
+    content?: {
+        all: boolean;
+    };
+};
+export type StreamConfig = {
+    ticket: boolean;
+    user: boolean;
+    tag: boolean;
+    content: boolean;
+};

package/services/backend/dist/src/core/sockets/socketTypes.js

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

package/services/backend/dist/src/core/validation/schemaGenerator.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaDefinition } from "../validation/schemaTypes.js";
+import type { FastifyInstance } from "fastify";
+declare const generateRegisteredSchemas: (fastify: FastifyInstance) => Promise<void>;
+export declare const generateSharedSchemas: (sharedDir: string) => Promise<void>;
+export declare const registerSchemaDefinition: (options: SchemaDefinition) => void;
+export default generateRegisteredSchemas;

package/services/backend/dist/src/core/validation/schemaGenerator.js

@@ -0,0 +1,242 @@
+import fs from "fs/promises";
+import path from "path";
+const generateRegisteredSchemas = async (fastify) => {
+    try {
+        const sharedDir = path.join(__dirname, "shared");
+        await generateSharedSchemas(sharedDir);
+        fastify.log.info("Successfully generated shared schema files");
+    }
+    catch (error) {
+        fastify.log.error("Failed to generate shared schema files:", error);
+        // Don't throw - we don't want to prevent server startup
+    }
+};
+// Main generation function
+export const generateSharedSchemas = async (sharedDir) => {
+    const schemas = schemaRegistry.getAll();
+    // Group schemas by type (core vs plugin)
+    const pluginSchemas = new Map();
+    const coreSchemas = [];
+    schemas.forEach((schema) => {
+        if (schema.isCore) {
+            coreSchemas.push(schema);
+        }
+        else if (schema.pluginKey) {
+            const schemas = pluginSchemas.get(schema.pluginKey) || [];
+            schemas.push(schema);
+            pluginSchemas.set(schema.pluginKey, schemas);
+        }
+    });
+    // Create base directories
+    await fs.mkdir(path.join(sharedDir, "types/core"), { recursive: true });
+    await fs.mkdir(path.join(sharedDir, "types/plugins"), { recursive: true });
+    await fs.mkdir(path.join(sharedDir, "schemas/core"), { recursive: true });
+    await fs.mkdir(path.join(sharedDir, "schemas/plugins"), { recursive: true });
+    // Generate core schemas
+    for (const schema of coreSchemas) {
+        const schemaContent = generateSchemaFile(schema);
+        const typesContent = generateTypesFile(schema);
+        await fs.writeFile(path.join(sharedDir, `schemas/core/${schema.name}.schema.ts`), schemaContent);
+        await fs.writeFile(path.join(sharedDir, `types/core/${schema.name}.types.ts`), typesContent);
+    }
+    // Generate plugin schemas
+    for (const [pluginKey, schemas] of pluginSchemas.entries()) {
+        // Create plugin-specific directories
+        const pluginDir = path.join(sharedDir, `types/plugins/${pluginKey}`);
+        const pluginSchemaDir = path.join(sharedDir, `schemas/plugins/${pluginKey}`);
+        await fs.mkdir(pluginDir, { recursive: true });
+        await fs.mkdir(pluginSchemaDir, { recursive: true });
+        // Generate index file with namespace
+        const indexContent = generatePluginIndexFile(pluginKey, schemas);
+        await fs.writeFile(path.join(pluginDir, "index.ts"), indexContent);
+        // Generate individual schema files
+        for (const schema of schemas) {
+            const schemaContent = generateSchemaFile(schema);
+            await fs.writeFile(path.join(pluginSchemaDir, `${schema.name}.schema.ts`), schemaContent);
+        }
+    }
+    // Generate index files
+    await generateCoreTypesIndex(sharedDir);
+    await generatePluginTypesIndex(sharedDir);
+    await generateMainTypesIndex(sharedDir);
+};
+const createSchemaRegistry = () => {
+    const definitions = new Map();
+    return {
+        register: (def) => {
+            definitions.set(def.name, def);
+        },
+        getAll: () => {
+            return Array.from(definitions.values());
+        },
+    };
+};
+const schemaRegistry = createSchemaRegistry();
+// Registration function
+export const registerSchemaDefinition = (options) => {
+    const { schema, publicSchema, name, isCore, pluginKey } = options;
+    // For plugins, pluginKey is required
+    if (!isCore && !pluginKey) {
+        throw new Error("Plugin schemas must provide a pluginKey");
+    }
+    schemaRegistry.register({
+        schema,
+        publicSchema,
+        name,
+        isCore,
+        pluginKey,
+    });
+};
+const formatAsObjectLiteral = (obj, indent = 0) => {
+    // TODO: make this more stable
+    if (!obj.required) {
+        obj.required = [];
+    }
+    return JSON.stringify(obj, null, indent)
+        .replace(/"Type\.(\w+)\((.*?)\)"/g, "Type.$1($2)") // Convert Type functions back to actual calls
+        .replace(/"(\$id|title)":/g, "$1:") // Fix $id and title properties
+        .replace(/"([a-zA-Z_$][a-zA-Z0-9_$]*)"\s*:/g, "$1:") // Remove quotes from object keys
+        .replace(/(\n\s*)}/g, ",$1}") // Add trailing comma before closing braces
+        .replace(/(\n\s*)]/g, ",$1]"); // Add trailing comma before closing brackets
+};
+// Generation helper functions
+const generateWarningHeader = () => `/**
+ * ⚠️ WARNING: THIS FILE IS AUTO-GENERATED ⚠️
+ * 
+ * This file is generated by the type generation system.
+ * Any manual changes will be overwritten on next server start and should always be committed.
+ * 
+ */`;
+const generateSchemaFile = (schema) => {
+    const schemaJson = formatAsObjectLiteral(schema.schema, 2);
+    return `${generateWarningHeader()}
+
+import { Type } from "@sinclair/typebox"
+
+export const ${schema.name}Schema = ${schemaJson}
+
+${schema.publicSchema ? `export const Public${schema.name}Schema = ${formatAsObjectLiteral(schema.publicSchema, 2)}` : ""}
+
+export default ${schema.name}Schema
+`;
+};
+const schemaToTS = (schema) => {
+    if (schema.type === "object" && schema.properties) {
+        const properties = Object.entries(schema.properties)
+            .map(([key, prop]) => {
+            const optional = !schema.required?.includes(key);
+            const type = propertyToTS(prop);
+            return `  ${key}${optional ? "?" : ""}: ${type}`;
+        })
+            .join("\n");
+        return `{\n${properties}\n}`;
+    }
+    return "any";
+};
+const propertyToTS = (prop) => {
+    switch (prop.type) {
+        case "string":
+            return prop.format === "date-time" ? "Date" : "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "array":
+            return `${propertyToTS(prop.items)}[]`;
+        case "object":
+            return schemaToTS(prop);
+        case "null":
+            return "null";
+        default:
+            if (prop.anyOf || prop.oneOf) {
+                const types = (prop.anyOf || prop.oneOf).map(propertyToTS);
+                return types.join(" | ");
+            }
+            return "any";
+    }
+};
+const generateTypesFile = (schema) => {
+    const tsInterface = schemaToTS(schema.schema);
+    const publicTsInterface = schema.publicSchema
+        ? schemaToTS(schema.publicSchema)
+        : null;
+    return `${generateWarningHeader()}
+
+export type ${schema.name} = ${tsInterface}
+
+${publicTsInterface ? `export type Public${schema.name} = ${publicTsInterface}` : ""}
+`;
+};
+const generatePluginIndexFile = (pluginKey, schemas) => {
+    const imports = schemas
+        .map((schema) => `import { ${schema.name}Schema${schema.publicSchema ? `, Public${schema.name}Schema` : ""} } from '../../../schemas/plugins/${pluginKey}/${schema.name}.schema'`)
+        .join("\n");
+    const types = schemas
+        .map((schema) => {
+        const tsInterface = schemaToTS(schema.schema);
+        const publicTsInterface = schema.publicSchema
+            ? schemaToTS(schema.publicSchema)
+            : null;
+        return ` export interface ${schema.name} ${tsInterface}
+
+${publicTsInterface ? `export interface Public${schema.name} ${publicTsInterface}` : ""}`;
+    })
+        .join("\n\n");
+    return `${generateWarningHeader()}
+
+import type { Static } from '@sinclair/typebox'
+${imports}
+
+export namespace ${pluginKey} {
+${types}
+}
+`;
+};
+// Helper function to generate the core types index.ts
+const generateCoreTypesIndex = async (sharedDir) => {
+    const coreDir = path.join(sharedDir, "types/core");
+    const typeFiles = await fs.readdir(coreDir);
+    // Filter for type files only
+    const coreTypeFiles = typeFiles.filter((file) => file.endsWith(".types.ts") && file !== "index.ts");
+    // Create export statements
+    const exportStatements = coreTypeFiles
+        .map((file) => {
+        const moduleName = path.basename(file, ".types.ts");
+        return `export type * from './${moduleName}.types'`;
+    })
+        .join("\n");
+    // Write index file
+    await fs.writeFile(path.join(coreDir, "index.ts"), `${generateWarningHeader()}\n\n${exportStatements}\n`);
+};
+// Helper function to generate the plugins index.ts
+const generatePluginTypesIndex = async (sharedDir) => {
+    const pluginsDir = path.join(sharedDir, "types/plugins");
+    const pluginDirs = await fs.readdir(pluginsDir);
+    // Filter for directories only
+    const pluginFolders = await Promise.all(pluginDirs.map(async (dir) => {
+        const stat = await fs.stat(path.join(pluginsDir, dir));
+        return { dir, isDir: stat.isDirectory() };
+    }));
+    const validPluginDirs = pluginFolders
+        .filter(({ isDir }) => isDir)
+        .map(({ dir }) => dir);
+    // Create export statements
+    const exportStatements = validPluginDirs
+        .map((pluginKey) => `export type * from './${pluginKey}'`)
+        .join("\n");
+    // Write index file
+    await fs.writeFile(path.join(pluginsDir, "index.ts"), `${generateWarningHeader()}\n\n${exportStatements}\n`);
+};
+// Helper function to generate the main types/index.ts
+const generateMainTypesIndex = async (sharedDir) => {
+    const content = `${generateWarningHeader()}
+
+// Import and re-export all core types
+export type * from './core'
+
+// Import and re-export all plugin types
+export type * from './plugins'
+`;
+    await fs.writeFile(path.join(sharedDir, "types/index.ts"), content);
+};
+export default generateRegisteredSchemas;

package/services/backend/dist/src/core/validation/schemaTypes.d.ts

@@ -0,0 +1,15 @@
+import type { TSchema } from "@sinclair/typebox";
+export interface BaseSchemaDefinition {
+    schema: TSchema;
+    publicSchema?: TSchema;
+    name: string;
+}
+export interface SchemaDefinition extends BaseSchemaDefinition {
+    isCore: boolean;
+    pluginKey?: string;
+}
+export type PluginSchemaDefinition = BaseSchemaDefinition;
+export type SchemaRegistry = {
+    register: (def: SchemaDefinition) => void;
+    getAll: () => SchemaDefinition[];
+};

package/services/backend/dist/src/core/validation/schemaTypes.js

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

package/services/backend/dist/src/core/validation/sharedSchemas.d.ts

@@ -0,0 +1,8 @@
+import type { Static } from "@sinclair/typebox";
+export declare const CommonHeadersSchema: import("@sinclair/typebox").TObject<{
+    "app-session-id": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    "app-request-code": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    "current-project": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    "app-broadcast-channels": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>;
+export type CommonHeaders = Static<typeof CommonHeadersSchema>;

package/services/backend/dist/src/core/validation/sharedSchemas.js

@@ -0,0 +1,7 @@
+import { Type } from "@sinclair/typebox";
+export const CommonHeadersSchema = Type.Object({
+    "app-session-id": Type.Optional(Type.String()),
+    "app-request-code": Type.Optional(Type.String()),
+    "current-project": Type.Optional(Type.String()),
+    "app-broadcast-channels": Type.Optional(Type.Array(Type.String())),
+});

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

@@ -0,0 +1,304 @@
+declare const _default: {
+    pluginName: string;
+    author: string;
+    pluginKey: string;
+    routePrefix: string;
+    pluginPath: string;
+    data: {
+        account: {
+            type: string;
+            operations: {
+                getAll: {
+                    target: string;
+                    method: string;
+                };
+                get: {
+                    target: (payload: any) => string;
+                    method: string;
+                };
+                update: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                create: {
+                    target: string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                delete: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                deleteHard: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+            };
+        };
+        interactionLink: {
+            type: string;
+            operations: {
+                getAll: {
+                    target: string;
+                    method: string;
+                };
+                get: {
+                    target: (payload: any) => string;
+                    method: string;
+                };
+                update: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                create: {
+                    target: string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                delete: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                deleteHard: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+            };
+        };
+        project: {
+            type: string;
+            operations: {
+                getAll: {
+                    target: string;
+                    method: string;
+                };
+                get: {
+                    target: (payload: any) => string;
+                    method: string;
+                };
+                create: {
+                    target: string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                update: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                delete: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                deleteHard: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+            };
+        };
+        tag: {
+            type: string;
+            operations: {
+                getAll: {
+                    target: string;
+                    method: string;
+                };
+                get: {
+                    target: (payload: any) => string;
+                    method: string;
+                };
+                update: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                create: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                delete: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                deleteHard: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+            };
+        };
+        user: {
+            type: string;
+            operations: {
+                getAll: {
+                    target: string;
+                    method: string;
+                };
+                get: {
+                    target: (payload: any) => string;
+                    method: string;
+                };
+                update: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                create: {
+                    target: string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                delete: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                updateLastProject: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+            };
+        };
+        composition: {
+            type: string;
+            operations: {
+                getAll: {
+                    target: string;
+                    method: string;
+                };
+                get: {
+                    target: (payload: any) => string;
+                    method: string;
+                };
+                update: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                create: {
+                    target: string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                delete: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+                deleteHard: {
+                    target: (payload: any) => string;
+                    method: string;
+                    channels: {
+                        channel: string;
+                        channelKey: string;
+                        prefix: string;
+                    }[];
+                };
+            };
+        };
+    };
+};
+export default _default;