@raclettejs/core 0.1.0 → 0.1.1

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

@@ -1,32 +0,0 @@
-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

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,242 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,304 +0,0 @@
-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;