@magek/server 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { ProviderLibrary } from '@magek/common';
+export * from './paths';
+export * from './services';
+export * from './library/graphql-adapter';
+export { createServer, getWebSocketRegistry, sendWebSocketMessage } from './server';
+export type { ServerOptions } from './server';
+export declare const Provider: () => ProviderLibrary;

package/dist/index.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Provider = exports.sendWebSocketMessage = exports.getWebSocketRegistry = exports.createServer = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@magek/common");
+const api_adapter_1 = require("./library/api-adapter");
+const graphql_adapter_1 = require("./library/graphql-adapter");
+const scheduled_adapter_1 = require("./library/scheduled-adapter");
+const health_adapter_1 = require("./library/health-adapter");
+tslib_1.__exportStar(require("./paths"), exports);
+tslib_1.__exportStar(require("./services"), exports);
+tslib_1.__exportStar(require("./library/graphql-adapter"), exports);
+var server_1 = require("./server");
+Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
+Object.defineProperty(exports, "getWebSocketRegistry", { enumerable: true, get: function () { return server_1.getWebSocketRegistry; } });
+Object.defineProperty(exports, "sendWebSocketMessage", { enumerable: true, get: function () { return server_1.sendWebSocketMessage; } });
+const Provider = () => ({
+    // ProviderGraphQLLibrary
+    graphQL: {
+        rawToEnvelope: graphql_adapter_1.rawGraphQLRequestToEnvelope,
+        handleResult: api_adapter_1.requestSucceeded,
+    },
+    // ProviderAPIHandling
+    api: {
+        requestSucceeded: api_adapter_1.requestSucceeded,
+        requestFailed: api_adapter_1.requestFailed,
+        healthRequestResult: api_adapter_1.healthRequestResult,
+    },
+    // ProviderMessagingLibrary
+    messaging: {
+        sendMessage: async (config, connectionID, data) => {
+            // Use the global WebSocket registry for message sending
+            const globalRegistry = global.webSocketRegistry;
+            if (globalRegistry && typeof globalRegistry.sendMessage === 'function') {
+                globalRegistry.sendMessage(connectionID, data);
+            }
+            else {
+                const logger = (0, common_1.getLogger)(config, 'ServerProvider');
+                logger.warn(`WebSocket registry not available. Message not sent to connection ${connectionID}`);
+            }
+        },
+    },
+    // ScheduledCommandsLibrary
+    scheduled: {
+        rawToEnvelope: scheduled_adapter_1.rawScheduledInputToEnvelope,
+    },
+    sensor: {
+        databaseEventsHealthDetails: (config) => {
+            var _a;
+            // Delegate to event store adapter health check if available
+            if ((_a = config.eventStoreAdapter) === null || _a === void 0 ? void 0 : _a.healthCheck) {
+                return config.eventStoreAdapter.healthCheck.details(config);
+            }
+            throw new Error('No event store adapter configured for health checks');
+        },
+        databaseReadModelsHealthDetails: (config) => {
+            var _a;
+            // Delegate to read model store adapter health check if available
+            if ((_a = config.readModelStoreAdapter) === null || _a === void 0 ? void 0 : _a.healthCheck) {
+                return config.readModelStoreAdapter.healthCheck.details(config);
+            }
+            throw new Error('No read model store adapter configured for health checks');
+        },
+        isDatabaseEventUp: (config) => {
+            var _a;
+            // Delegate to event store adapter health check if available
+            if ((_a = config.eventStoreAdapter) === null || _a === void 0 ? void 0 : _a.healthCheck) {
+                return config.eventStoreAdapter.healthCheck.isUp(config);
+            }
+            return Promise.resolve(false);
+        },
+        areDatabaseReadModelsUp: (config) => {
+            var _a;
+            // Delegate to read model store adapter health check if available
+            if ((_a = config.readModelStoreAdapter) === null || _a === void 0 ? void 0 : _a.healthCheck) {
+                return config.readModelStoreAdapter.healthCheck.isUp(config);
+            }
+            return Promise.resolve(false);
+        },
+        databaseUrls: (config) => {
+            var _a, _b, _c, _d, _e, _f;
+            // Get URLs from both event store and read model store adapters
+            const eventUrls = (_c = (_b = (_a = config.eventStoreAdapter) === null || _a === void 0 ? void 0 : _a.healthCheck) === null || _b === void 0 ? void 0 : _b.urls(config)) !== null && _c !== void 0 ? _c : Promise.resolve([]);
+            const readModelUrls = (_f = (_e = (_d = config.readModelStoreAdapter) === null || _d === void 0 ? void 0 : _d.healthCheck) === null || _e === void 0 ? void 0 : _e.urls(config)) !== null && _f !== void 0 ? _f : Promise.resolve([]);
+            return Promise.all([eventUrls, readModelUrls]).then(([events, readModels]) => [
+                ...events,
+                ...readModels
+            ]);
+        },
+        isGraphQLFunctionUp: health_adapter_1.isGraphQLFunctionUp,
+        graphQLFunctionUrl: health_adapter_1.graphqlFunctionUrl,
+        rawRequestToHealthEnvelope: health_adapter_1.rawRequestToSensorHealth,
+    },
+});
+exports.Provider = Provider;

package/dist/infrastructure/controllers/graphql.d.ts

@@ -0,0 +1,7 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { GraphQLService } from '../../services';
+export declare class GraphQLController {
+    readonly graphQLService: GraphQLService;
+    constructor(graphQLService: GraphQLService);
+    handleGraphQL(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+}

package/dist/infrastructure/controllers/graphql.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLController = void 0;
+const http_1 = require("../http");
+class GraphQLController {
+    constructor(graphQLService) {
+        this.graphQLService = graphQLService;
+    }
+    async handleGraphQL(request, reply) {
+        try {
+            const response = await this.graphQLService.handleGraphQLRequest(request);
+            reply.status(http_1.HttpCodes.Ok).send(response.result);
+        }
+        catch (e) {
+            await (0, http_1.requestFailed)(e, reply);
+            throw e;
+        }
+    }
+}
+exports.GraphQLController = GraphQLController;

package/dist/infrastructure/controllers/health-controller.d.ts

@@ -0,0 +1,7 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { HealthService } from '../../services';
+export declare class HealthController {
+    readonly healthService: HealthService;
+    constructor(healthService: HealthService);
+    handleHealth(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+}

package/dist/infrastructure/controllers/health-controller.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthController = void 0;
+const http_1 = require("../http");
+class HealthController {
+    constructor(healthService) {
+        this.healthService = healthService;
+    }
+    async handleHealth(request, reply) {
+        try {
+            const response = await this.healthService.handleHealthRequest(request);
+            if (response.status === 'success') {
+                reply.status(http_1.HttpCodes.Ok).send(response.result);
+            }
+            else {
+                reply.status(response.code).send({
+                    title: response.title,
+                    reason: response.message,
+                });
+            }
+        }
+        catch (e) {
+            await (0, http_1.requestFailed)(e, reply);
+            throw e;
+        }
+    }
+}
+exports.HealthController = HealthController;

package/dist/infrastructure/http.d.ts

@@ -0,0 +1,8 @@
+import { FastifyReply } from 'fastify';
+export declare enum HttpCodes {
+    Ok = 200,
+    BadRequest = 400,
+    NotAuthorized = 403,
+    InternalError = 500
+}
+export declare function requestFailed(error: Error, reply: FastifyReply): Promise<void>;

package/dist/infrastructure/http.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCodes = void 0;
+exports.requestFailed = requestFailed;
+const common_1 = require("@magek/common");
+var HttpCodes;
+(function (HttpCodes) {
+    HttpCodes[HttpCodes["Ok"] = 200] = "Ok";
+    HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
+    HttpCodes[HttpCodes["NotAuthorized"] = 403] = "NotAuthorized";
+    HttpCodes[HttpCodes["InternalError"] = 500] = "InternalError";
+})(HttpCodes || (exports.HttpCodes = HttpCodes = {}));
+// Wrapper to return a failed request through GraphQL
+async function requestFailed(error, reply) {
+    const statusCode = (0, common_1.httpStatusCodeFor)(error);
+    await reply.status(statusCode).send({
+        title: (0, common_1.toClassTitle)(error),
+        reason: error.message,
+    });
+}

package/dist/infrastructure/scheduler.d.ts

@@ -0,0 +1,2 @@
+import { MagekConfig } from '@magek/common';
+export declare function configureScheduler(config: MagekConfig, userProject: any): void;

package/dist/infrastructure/scheduler.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureScheduler = configureScheduler;
+const scheduler = require("node-schedule");
+function configureScheduler(config, userProject) {
+    const triggerScheduledCommands = userProject['triggerScheduledCommands'];
+    Object.keys(config.scheduledCommandHandlers)
+        .map((scheduledCommandName) => buildScheduledCommandInfo(config, scheduledCommandName))
+        .filter((scheduledCommandInfo) => scheduledCommandInfo.metadata.scheduledOn)
+        .forEach((scheduledCommandInfo) => {
+        scheduler.scheduleJob(scheduledCommandInfo.name, createCronExpression(scheduledCommandInfo.metadata), () => {
+            triggerScheduledCommands({ typeName: scheduledCommandInfo.name });
+        });
+    });
+}
+function createCronExpression(scheduledCommandMetadata) {
+    const { minute = '*', hour = '*', day = '*', month = '*', weekDay = '*' } = scheduledCommandMetadata.scheduledOn;
+    return `${minute} ${hour} ${day} ${month} ${weekDay}`;
+}
+function buildScheduledCommandInfo(config, scheduledCommandName) {
+    return {
+        name: scheduledCommandName,
+        metadata: config.scheduledCommandHandlers[scheduledCommandName],
+    };
+}

package/dist/infrastructure/test-helper/local-queries.d.ts

@@ -0,0 +1,5 @@
+export declare class LocalQueries {
+    constructor();
+    events(primaryKey: string, latestFirst?: boolean): Promise<Array<unknown>>;
+    readModels(primaryKey: string, readModelName: string, latestFirst?: boolean): Promise<Array<unknown>>;
+}

package/dist/infrastructure/test-helper/local-queries.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalQueries = void 0;
+class LocalQueries {
+    constructor() { }
+    async events(primaryKey, latestFirst = true) {
+        // TODO implement method
+        return [];
+    }
+    async readModels(primaryKey, readModelName, latestFirst = true) {
+        // TODO implement method
+        return [];
+    }
+}
+exports.LocalQueries = LocalQueries;

package/dist/infrastructure/test-helper/local-test-helper.d.ts

@@ -0,0 +1,17 @@
+import { LocalQueries } from './local-queries';
+interface ApplicationOutputs {
+    graphqlURL: string;
+    websocketURL: string;
+    healthURL: string;
+}
+export declare class LocalTestHelper {
+    readonly outputs: ApplicationOutputs;
+    readonly queries: LocalQueries;
+    private constructor();
+    static build(appName: string): Promise<LocalTestHelper>;
+    private static ensureProviderIsReady;
+    private static graphqlURL;
+    private static healthURL;
+    private static websocketURL;
+}
+export {};

package/dist/infrastructure/test-helper/local-test-helper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalTestHelper = void 0;
+const local_queries_1 = require("./local-queries");
+class LocalTestHelper {
+    constructor(outputs, queries) {
+        this.outputs = outputs;
+        this.queries = queries;
+    }
+    static async build(appName) {
+        await this.ensureProviderIsReady();
+        return new LocalTestHelper({
+            graphqlURL: await this.graphqlURL(),
+            websocketURL: await this.websocketURL(),
+            healthURL: await this.healthURL(),
+        }, new local_queries_1.LocalQueries());
+    }
+    static async ensureProviderIsReady() {
+        const url = await this.healthURL();
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Provider is not ready: ${response.status} ${response.statusText}`);
+        }
+    }
+    static async graphqlURL() {
+        const url = 'http://localhost:3000/graphql';
+        return url;
+    }
+    static async healthURL() {
+        return 'http://localhost:3000/sensor/health/';
+    }
+    static async websocketURL() {
+        const url = 'ws://localhost:3000/websocket';
+        return url;
+    }
+}
+exports.LocalTestHelper = LocalTestHelper;

package/dist/infrastructure/websocket-registry.d.ts

@@ -0,0 +1,27 @@
+import type { WebSocket } from '@fastify/websocket';
+/**
+ * Registry to manage active WebSocket connections
+ */
+export declare class WebSocketRegistry {
+    private connections;
+    /**
+     * Add a connection to the registry
+     */
+    addConnection(connectionId: string, socket: WebSocket): void;
+    /**
+     * Remove a connection from the registry
+     */
+    removeConnection(connectionId: string): void;
+    /**
+     * Send a message to a specific connection
+     */
+    sendMessage(connectionId: string, data: unknown): void;
+    /**
+     * Check if a connection exists
+     */
+    hasConnection(connectionId: string): boolean;
+    /**
+     * Get the number of active connections
+     */
+    getConnectionCount(): number;
+}

package/dist/infrastructure/websocket-registry.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketRegistry = void 0;
+/**
+ * Registry to manage active WebSocket connections
+ */
+class WebSocketRegistry {
+    constructor() {
+        this.connections = new Map();
+    }
+    /**
+     * Add a connection to the registry
+     */
+    addConnection(connectionId, socket) {
+        this.connections.set(connectionId, socket);
+        // Clean up when connection closes
+        socket.on('close', () => {
+            this.connections.delete(connectionId);
+        });
+    }
+    /**
+     * Remove a connection from the registry
+     */
+    removeConnection(connectionId) {
+        this.connections.delete(connectionId);
+    }
+    /**
+     * Send a message to a specific connection
+     */
+    sendMessage(connectionId, data) {
+        const connection = this.connections.get(connectionId);
+        if (connection && connection.readyState === connection.OPEN) {
+            connection.send(JSON.stringify(data));
+        }
+    }
+    /**
+     * Check if a connection exists
+     */
+    hasConnection(connectionId) {
+        return this.connections.has(connectionId);
+    }
+    /**
+     * Get the number of active connections
+     */
+    getConnectionCount() {
+        return this.connections.size;
+    }
+}
+exports.WebSocketRegistry = WebSocketRegistry;

package/dist/library/api-adapter.d.ts

@@ -0,0 +1,13 @@
+export type APIResult = {
+    status: 'success';
+    result: unknown;
+    headers?: Record<string, number | string | ReadonlyArray<string>>;
+} | {
+    status: 'failure';
+    code: number;
+    title: string;
+    reason: string;
+};
+export declare function requestSucceeded(body?: any, headers?: Record<string, number | string | ReadonlyArray<string>>): Promise<APIResult>;
+export declare function requestFailed(error: Error): Promise<APIResult>;
+export declare function healthRequestResult(body: unknown, isHealthy: boolean): Promise<APIResult>;

package/dist/library/api-adapter.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestSucceeded = requestSucceeded;
+exports.requestFailed = requestFailed;
+exports.healthRequestResult = healthRequestResult;
+const common_1 = require("@magek/common");
+async function requestSucceeded(body, headers) {
+    return {
+        status: 'success',
+        result: body,
+        headers: {
+            ...headers,
+        },
+    };
+}
+async function requestFailed(error) {
+    const statusCode = (0, common_1.httpStatusCodeFor)(error);
+    return {
+        status: 'failure',
+        code: statusCode,
+        title: (0, common_1.toClassTitle)(error),
+        reason: error.message,
+    };
+}
+async function healthRequestResult(body, isHealthy) {
+    return {
+        status: 'success',
+        result: body,
+        headers: {
+            'status-code': isHealthy ? 200 : 503,
+        },
+    };
+}

package/dist/library/graphql-adapter.d.ts

@@ -0,0 +1,11 @@
+import { MagekConfig, GraphQLRequestEnvelope, GraphQLRequestEnvelopeError } from '@magek/common';
+import { FastifyRequest } from 'fastify';
+export interface WebSocketMessage {
+    connectionContext: {
+        connectionId: string;
+        eventType: 'CONNECT' | 'MESSAGE' | 'DISCONNECT';
+    };
+    data?: any;
+    incomingMessage?: any;
+}
+export declare function rawGraphQLRequestToEnvelope(config: MagekConfig, request: FastifyRequest | WebSocketMessage): Promise<GraphQLRequestEnvelope | GraphQLRequestEnvelopeError>;

package/dist/library/graphql-adapter.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawGraphQLRequestToEnvelope = rawGraphQLRequestToEnvelope;
+const common_1 = require("@magek/common");
+async function rawGraphQLRequestToEnvelope(config, request) {
+    const requestID = common_1.UUID.generate();
+    return isWebSocketMessage(request)
+        ? webSocketMessageToEnvelope(config, request, requestID)
+        : httpMessageToEnvelope(config, request, requestID);
+}
+function webSocketMessageToEnvelope(config, webSocketRequest, requestID) {
+    const logger = (0, common_1.getLogger)(config, 'graphql-adapter#webSocketMessageToEnvelope');
+    logger.debug('Received  WebSocket GraphQL request: ', webSocketRequest);
+    let eventType = 'MESSAGE';
+    const incomingMessage = webSocketRequest.incomingMessage;
+    const headers = incomingMessage === null || incomingMessage === void 0 ? void 0 : incomingMessage.headers;
+    const data = webSocketRequest.data;
+    try {
+        const connectionContext = webSocketRequest.connectionContext;
+        eventType = connectionContext === null || connectionContext === void 0 ? void 0 : connectionContext.eventType;
+        return {
+            requestID,
+            eventType,
+            connectionID: connectionContext === null || connectionContext === void 0 ? void 0 : connectionContext.connectionId.toString(),
+            token: Array.isArray(headers === null || headers === void 0 ? void 0 : headers.authorization) ? headers.authorization[0] : headers === null || headers === void 0 ? void 0 : headers.authorization,
+            value: data,
+            context: {
+                request: {
+                    headers: headers,
+                    body: data,
+                },
+                rawContext: webSocketRequest,
+            },
+        };
+    }
+    catch (e) {
+        return {
+            error: e,
+            requestID,
+            connectionID: undefined,
+            eventType: eventType,
+            context: {
+                request: {
+                    headers: headers,
+                    body: data,
+                },
+                rawContext: webSocketRequest,
+            },
+        };
+    }
+}
+function httpMessageToEnvelope(config, httpRequest, requestId) {
+    const logger = (0, common_1.getLogger)(config, 'graphql-adapter#httpMessageToEnvelope');
+    const eventType = 'MESSAGE';
+    const headers = httpRequest.headers;
+    const data = httpRequest.body;
+    try {
+        logger.debug('Received GraphQL request: \n- Headers: ', headers, '\n- Body: ', data);
+        return {
+            connectionID: undefined,
+            requestID: requestId,
+            eventType: eventType,
+            token: Array.isArray(headers === null || headers === void 0 ? void 0 : headers.authorization) ? headers.authorization[0] : headers === null || headers === void 0 ? void 0 : headers.authorization,
+            value: data,
+            context: {
+                request: {
+                    headers: headers,
+                    body: data,
+                },
+                rawContext: httpRequest,
+            },
+        };
+    }
+    catch (e) {
+        return {
+            error: e,
+            requestID: requestId,
+            connectionID: undefined,
+            eventType: eventType,
+            context: {
+                request: {
+                    headers: headers,
+                    body: data,
+                },
+                rawContext: httpRequest,
+            },
+        };
+    }
+}
+function isWebSocketMessage(request) {
+    return 'connectionContext' in request;
+}

package/dist/library/health-adapter.d.ts

@@ -0,0 +1,9 @@
+import { HealthEnvelope } from '@magek/common';
+import { FastifyRequest } from 'fastify';
+import Nedb from '@seald-io/nedb';
+export declare function databaseUrl(): Promise<Array<string>>;
+export declare function countAll(database: Nedb): Promise<number>;
+export declare function graphqlFunctionUrl(): Promise<string>;
+export declare function areDatabaseReadModelsUp(): Promise<boolean>;
+export declare function isGraphQLFunctionUp(): Promise<boolean>;
+export declare function rawRequestToSensorHealth(rawRequest: FastifyRequest): HealthEnvelope;

package/dist/library/health-adapter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.databaseUrl = databaseUrl;
+exports.countAll = countAll;
+exports.graphqlFunctionUrl = graphqlFunctionUrl;
+exports.areDatabaseReadModelsUp = areDatabaseReadModelsUp;
+exports.isGraphQLFunctionUp = isGraphQLFunctionUp;
+exports.rawRequestToSensorHealth = rawRequestToSensorHealth;
+const paths_1 = require("../paths");
+const common_1 = require("@magek/common");
+const fs_1 = require("fs");
+async function databaseUrl() {
+    return [paths_1.eventsDatabase, paths_1.readModelsDatabase];
+}
+async function countAll(database) {
+    await database.loadDatabaseAsync();
+    const count = await database.countAsync({});
+    return count !== null && count !== void 0 ? count : 0;
+}
+async function graphqlFunctionUrl() {
+    try {
+        const port = (0, common_1.localPort)();
+        return `http://localhost:${port}/graphql`;
+    }
+    catch (e) {
+        return '';
+    }
+}
+async function areDatabaseReadModelsUp() {
+    return (0, fs_1.existsSync)(paths_1.readModelsDatabase);
+}
+async function isGraphQLFunctionUp() {
+    try {
+        const url = await graphqlFunctionUrl();
+        const response = await (0, common_1.request)(url, 'POST', JSON.stringify({
+            query: 'query { __typename }',
+        }));
+        return response.status === 200;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function rawRequestToSensorHealthComponentPath(rawRequest) {
+    // For health requests, the component path is typically in the URL path
+    // Since we don't have a direct url property, we'll construct it from params
+    const params = rawRequest.params;
+    if (params && Object.keys(params).length > 0) {
+        // If there are path parameters, join them to create the component path
+        return Object.values(params).filter(Boolean).join('/');
+    }
+    return '';
+}
+function rawRequestToSensorHealth(rawRequest) {
+    const componentPath = rawRequestToSensorHealthComponentPath(rawRequest);
+    const requestID = common_1.UUID.generate();
+    const headers = rawRequest.headers;
+    return {
+        requestID: requestID,
+        context: {
+            request: {
+                headers: headers,
+                body: rawRequest.body || {},
+            },
+            rawContext: rawRequest,
+        },
+        componentPath: componentPath,
+        token: Array.isArray(headers === null || headers === void 0 ? void 0 : headers.authorization) ? headers.authorization[0] : headers === null || headers === void 0 ? void 0 : headers.authorization,
+    };
+}

package/dist/library/rocket-adapter.d.ts

@@ -0,0 +1,2 @@
+import { MagekConfig, RocketEnvelope } from '@magek/common';
+export declare function rawRocketInputToEnvelope(config: MagekConfig, request: unknown): RocketEnvelope;

package/dist/library/rocket-adapter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawRocketInputToEnvelope = rawRocketInputToEnvelope;
+const common_1 = require("@magek/common");
+function rawRocketInputToEnvelope(config, request) {
+    const idFromRequest = request[common_1.rocketFunctionIDEnvVar];
+    const id = idFromRequest !== null && idFromRequest !== void 0 ? idFromRequest : process.env[common_1.rocketFunctionIDEnvVar];
+    return {
+        rocketId: id,
+    };
+}

package/dist/library/scheduled-adapter.d.ts

@@ -0,0 +1,6 @@
+import { MagekConfig, ScheduledCommandEnvelope } from '@magek/common';
+interface LocalScheduleCommandEnvelope {
+    typeName: string;
+}
+export declare function rawScheduledInputToEnvelope(config: MagekConfig, input: Partial<LocalScheduleCommandEnvelope>): Promise<ScheduledCommandEnvelope>;
+export {};

package/dist/library/scheduled-adapter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawScheduledInputToEnvelope = rawScheduledInputToEnvelope;
+const common_1 = require("@magek/common");
+async function rawScheduledInputToEnvelope(config, input) {
+    const logger = (0, common_1.getLogger)(config, 'rawScheduledInputToEnvelope');
+    logger.debug('Received LocalScheduleCommand request: ', input);
+    if (!input.typeName)
+        throw new Error(`typeName is not defined or empty, scheduled command envelope should have the structure {typeName: string }, but you gave ${JSON.stringify(input)}`);
+    return {
+        requestID: common_1.UUID.generate(),
+        typeName: input.typeName,
+    };
+}

package/dist/library/searcher-adapter.d.ts

@@ -0,0 +1,17 @@
+import { FilterFor } from '@magek/common';
+/**
+ * Creates a query record out of the read mode name and
+ * the GraphQL filters, ready to be passed into the `query`
+ * method of the read model registry.
+ */
+export declare function queryRecordFor(filters: FilterFor<any>, nested?: string, queryFromFilters?: Record<string, object>): Record<string, QueryOperation<QueryValue>>;
+export type QueryValue = number | string | boolean;
+export type QueryOperation<TValue> = TValue | {
+    [TKey in '$lt' | '$lte' | '$gt' | '$gte' | '$ne' | '$exists']?: TValue;
+} | {
+    [TKey in '$in' | '$nin']?: Array<TValue>;
+} | {
+    [TKey in '$regex' | '$nin']?: RegExp;
+} | {
+    [TKey in '$elemMatch']?: TValue;
+};

package/dist/library/searcher-adapter.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRecordFor = queryRecordFor;
+/**
+ * Creates a query record out of the read mode name and
+ * the GraphQL filters, ready to be passed into the `query`
+ * method of the read model registry.
+ */
+function queryRecordFor(filters, nested, queryFromFilters = {}) {
+    if (Object.keys(filters).length != 0) {
+        for (const key in filters) {
+            const propName = nested ? `${nested}.${key}` : key;
+            const filter = filters[key];
+            switch (key) {
+                case 'not':
+                    queryFromFilters[`$${propName}`] = queryRecordFor(filter);
+                    break;
+                case 'or':
+                case 'and':
+                    queryFromFilters[`$${propName}`] = filters[key].map((filter) => queryRecordFor(filter));
+                    break;
+                default:
+                    if (!Object.keys(queryOperatorTable).includes(Object.keys(filter)[0])) {
+                        queryRecordFor(filter, propName, queryFromFilters);
+                    }
+                    else {
+                        queryFromFilters[`value.${propName}`] = filterToQuery(filter);
+                    }
+                    break;
+            }
+        }
+    }
+    return { ...queryFromFilters };
+}
+/**
+ * Transforms a GraphQL Magek filter into an neDB query
+ */
+function filterToQuery(filter) {
+    const [query] = Object.entries(filter).map(([propName, filter]) => {
+        const query = queryOperatorTable[propName];
+        const queryFilter = Array.isArray(filter) ? filter : [filter];
+        return query(queryFilter);
+    });
+    return query;
+}
+/**
+ * Table of equivalences between a GraphQL operation and the NeDB
+ * query operator.
+ *
+ * It is needed that we pass the values, because of the special case
+ * of `=`, in which the operator is the value itself.
+ */
+const queryOperatorTable = {
+    eq: (values) => values[0],
+    ne: (values) => ({ $ne: values[0] }),
+    lt: (values) => ({ $lt: values[0] }),
+    gt: (values) => ({ $gt: values[0] }),
+    lte: (values) => ({ $lte: values[0] }),
+    gte: (values) => ({ $gte: values[0] }),
+    in: (values) => ({ $in: values }),
+    isDefined: (values) => ({ $exists: values[0] }),
+    contains: buildRegexQuery.bind(null, 'contains'),
+    beginsWith: buildRegexQuery.bind(null, 'begins-with'),
+    includes: buildIncludes.bind(null, 'contains'),
+    regex: buildRegexQuery.bind(null, 'regex'),
+    iRegex: buildRegexQuery.bind(null, 'iRegex'),
+};
+function buildIncludes(operation, values) {
+    const matcher = values[0];
+    if (typeof matcher === 'string') {
+        return { $regex: new RegExp(matcher) };
+    }
+    return { $elemMatch: matcher };
+}
+/**
+ * Builds a regex out of string GraphQL queries
+ */
+function buildRegexQuery(operation, values) {
+    const matcher = values[0];
+    if (typeof matcher != 'string') {
+        throw new Error(`Attempted to perform a ${operation} operation on a non-string`);
+    }
+    if (operation === 'begins-with') {
+        return { $regex: new RegExp(`^${matcher}`) };
+    }
+    if (operation === 'iRegex') {
+        return { $regex: new RegExp(matcher, 'i') };
+    }
+    return { $regex: new RegExp(matcher) };
+}

package/dist/paths.d.ts

@@ -0,0 +1,6 @@
+export declare const registeredUsersDatabase: string;
+export declare const authenticatedUsersDatabase: string;
+export declare const eventsDatabase: string;
+export declare const readModelsDatabase: string;
+export declare const connectionsDatabase: string;
+export declare const subscriptionDatabase: string;

package/dist/paths.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptionDatabase = exports.connectionsDatabase = exports.readModelsDatabase = exports.eventsDatabase = exports.authenticatedUsersDatabase = exports.registeredUsersDatabase = void 0;
+// Paths used by the local provider internally
+const path = require("path");
+exports.registeredUsersDatabase = internalPath('registered_users.json');
+exports.authenticatedUsersDatabase = internalPath('authenticated_users.json');
+exports.eventsDatabase = internalPath('events.json');
+exports.readModelsDatabase = internalPath('read_models.json');
+exports.connectionsDatabase = internalPath('connections.json');
+exports.subscriptionDatabase = internalPath('subscriptions.json');
+function internalPath(filename) {
+    return path.normalize(path.join('.', '.magek', filename));
+}

package/dist/server.d.ts

@@ -0,0 +1,44 @@
+import { FastifyInstance } from 'fastify';
+import { UserApp } from '@magek/common';
+import { WebSocketRegistry } from './infrastructure/websocket-registry';
+/**
+ * Get the global WebSocket registry instance
+ */
+export declare function getWebSocketRegistry(): WebSocketRegistry;
+/**
+ * Send a message to a WebSocket connection
+ */
+export declare function sendWebSocketMessage(connectionId: string, data: unknown): void;
+export interface ServerOptions {
+    /** Enable Fastify logging. Default: true */
+    logger?: boolean;
+    /** Maximum request body size in bytes. Default: 6MB */
+    bodyLimit?: number;
+}
+/**
+ * Creates a configured Fastify server instance for a Magek application.
+ *
+ * @param userApp - The user's Magek application module
+ * @param options - Optional server configuration
+ * @returns A configured Fastify instance ready to listen
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from '@magek/server'
+ * import * as myApp from './dist'
+ *
+ * const server = await createServer(myApp)
+ * await server.listen({ port: 3000 })
+ * ```
+ */
+export declare function createServer(userApp: UserApp, options?: ServerOptions): Promise<FastifyInstance>;
+declare module 'http' {
+    interface IncomingMessage {
+        rawBody: Buffer;
+    }
+}
+declare module 'fastify' {
+    interface FastifyRequest {
+        rawBody: Buffer;
+    }
+}

package/dist/server.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebSocketRegistry = getWebSocketRegistry;
+exports.sendWebSocketMessage = sendWebSocketMessage;
+exports.createServer = createServer;
+const fastify_1 = require("fastify");
+const websocket_1 = require("@fastify/websocket");
+const fastify_sse_v2_1 = require("fastify-sse-v2");
+const cors_1 = require("@fastify/cors");
+const services_1 = require("./services");
+const graphql_1 = require("./infrastructure/controllers/graphql");
+const health_controller_1 = require("./infrastructure/controllers/health-controller");
+const websocket_registry_1 = require("./infrastructure/websocket-registry");
+const http_1 = require("./infrastructure/http");
+const scheduler_1 = require("./infrastructure/scheduler");
+// Global WebSocket registry instance
+let globalWebSocketRegistry;
+/**
+ * Get the global WebSocket registry instance
+ */
+function getWebSocketRegistry() {
+    if (!globalWebSocketRegistry) {
+        throw new Error('WebSocket registry not initialized. Make sure the server is started.');
+    }
+    return globalWebSocketRegistry;
+}
+/**
+ * Send a message to a WebSocket connection
+ */
+function sendWebSocketMessage(connectionId, data) {
+    const registry = getWebSocketRegistry();
+    registry.sendMessage(connectionId, data);
+}
+/**
+ * Default error handling for Fastify requests.
+ */
+async function defaultErrorHandler(error, request, reply) {
+    if (reply.sent) {
+        return;
+    }
+    console.error(error);
+    const err = error instanceof Error ? error : new Error(String(error));
+    await (0, http_1.requestFailed)(err, reply);
+}
+/**
+ * Creates a configured Fastify server instance for a Magek application.
+ *
+ * @param userApp - The user's Magek application module
+ * @param options - Optional server configuration
+ * @returns A configured Fastify instance ready to listen
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from '@magek/server'
+ * import * as myApp from './dist'
+ *
+ * const server = await createServer(myApp)
+ * await server.listen({ port: 3000 })
+ * ```
+ */
+async function createServer(userApp, options = {}) {
+    const { logger = true, bodyLimit = 6 * 1024 * 1024 } = options;
+    // Initialize WebSocket registry
+    globalWebSocketRegistry = new websocket_registry_1.WebSocketRegistry();
+    global.webSocketRegistry = globalWebSocketRegistry;
+    const fastify = (0, fastify_1.default)({
+        logger,
+        bodyLimit,
+    });
+    // Register plugins
+    await fastify.register(cors_1.default, {
+        origin: true,
+        credentials: true,
+    });
+    await fastify.register(websocket_1.default);
+    await fastify.register(fastify_sse_v2_1.FastifySSEPlugin);
+    // Add raw body support for GraphQL requests
+    fastify.addContentTypeParser('application/json', { parseAs: 'buffer' }, (req, body, done) => {
+        try {
+            const rawBody = body;
+            req.rawBody = rawBody;
+            const json = JSON.parse(rawBody.toString());
+            done(null, json);
+        }
+        catch (err) {
+            done(err, undefined);
+        }
+    });
+    const graphQLService = new services_1.GraphQLService(userApp);
+    const healthService = new services_1.HealthService(userApp);
+    // Register GraphQL endpoint
+    const graphQLController = new graphql_1.GraphQLController(graphQLService);
+    await fastify.register((instance) => {
+        instance.post('/graphql', graphQLController.handleGraphQL.bind(graphQLController));
+    });
+    // Register Health endpoint
+    const healthController = new health_controller_1.HealthController(healthService);
+    await fastify.register((instance) => {
+        instance.get('/sensor/health/*', healthController.handleHealth.bind(healthController));
+    });
+    // Register WebSocket endpoint
+    await fastify.register((instance) => {
+        instance.get('/websocket', { websocket: true }, (connection, req) => {
+            const connectionId = req.connectionId || `conn_${Date.now()}_${Math.random()}`;
+            globalWebSocketRegistry.addConnection(connectionId, connection.socket);
+            connection.socket.on('message', async (message) => {
+                try {
+                    const data = JSON.parse(message.toString());
+                    const webSocketRequest = {
+                        connectionContext: {
+                            connectionId,
+                            eventType: 'MESSAGE',
+                        },
+                        data,
+                        incomingMessage: req.raw,
+                    };
+                    await graphQLService.handleGraphQLRequest(webSocketRequest);
+                }
+                catch (error) {
+                    console.error('WebSocket message error:', error);
+                    connection.socket.send(JSON.stringify({
+                        type: 'error',
+                        payload: { message: 'Failed to process message' },
+                    }));
+                }
+            });
+            connection.socket.on('close', async () => {
+                const webSocketRequest = {
+                    connectionContext: {
+                        connectionId,
+                        eventType: 'DISCONNECT',
+                    },
+                };
+                await graphQLService.handleGraphQLRequest(webSocketRequest);
+            });
+            const webSocketRequest = {
+                connectionContext: {
+                    connectionId,
+                    eventType: 'CONNECT',
+                },
+                incomingMessage: req.raw,
+            };
+            void graphQLService.handleGraphQLRequest(webSocketRequest);
+        });
+    });
+    // Register SSE endpoint
+    await fastify.register((instance) => {
+        instance.get('/sse', (request, reply) => {
+            const connectionId = `sse_${Date.now()}_${Math.random()}`;
+            reply.sse({
+                id: connectionId,
+                event: 'connection',
+                data: JSON.stringify({
+                    type: 'connection_init',
+                    payload: { connectionId },
+                }),
+            });
+            const webSocketRequest = {
+                connectionContext: {
+                    connectionId,
+                    eventType: 'CONNECT',
+                },
+                incomingMessage: request.raw,
+            };
+            void graphQLService.handleGraphQLRequest(webSocketRequest);
+            const pingInterval = setInterval(() => {
+                if (!reply.sent) {
+                    reply.sse({
+                        id: Date.now().toString(),
+                        event: 'ping',
+                        data: JSON.stringify({ type: 'ping', timestamp: Date.now() }),
+                    });
+                }
+            }, 30000);
+            request.raw.on('close', async () => {
+                clearInterval(pingInterval);
+                const disconnectRequest = {
+                    connectionContext: {
+                        connectionId,
+                        eventType: 'DISCONNECT',
+                    },
+                };
+                await graphQLService.handleGraphQLRequest(disconnectRequest);
+            });
+        });
+    });
+    fastify.setErrorHandler(async (error, request, reply) => {
+        await defaultErrorHandler(error, request, reply);
+    });
+    // Configure scheduled commands
+    const config = userApp.Magek.config;
+    if (config) {
+        (0, scheduler_1.configureScheduler)(config, userApp);
+    }
+    await fastify.ready();
+    return fastify;
+}

package/dist/services/graphql-service.d.ts

@@ -0,0 +1,9 @@
+import { ReadModelEnvelope, UserApp } from '@magek/common';
+import { FastifyRequest } from 'fastify';
+import { WebSocketMessage } from '../library/graphql-adapter';
+export declare class GraphQLService {
+    readonly userApp: UserApp;
+    constructor(userApp: UserApp);
+    handleGraphQLRequest(request: FastifyRequest | WebSocketMessage): Promise<any>;
+    handleNotificationSubscription(request: Array<ReadModelEnvelope>): Promise<unknown>;
+}

package/dist/services/graphql-service.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLService = void 0;
+class GraphQLService {
+    constructor(userApp) {
+        this.userApp = userApp;
+    }
+    async handleGraphQLRequest(request) {
+        return await this.userApp.graphQLDispatcher(request);
+    }
+    async handleNotificationSubscription(request) {
+        return await this.userApp.notifySubscribers(request);
+    }
+}
+exports.GraphQLService = GraphQLService;

package/dist/services/health-service.d.ts

@@ -0,0 +1,7 @@
+import { UserApp } from '@magek/common';
+import { FastifyRequest } from 'fastify';
+export declare class HealthService {
+    readonly userApp: UserApp;
+    constructor(userApp: UserApp);
+    handleHealthRequest(request: FastifyRequest): Promise<any>;
+}

package/dist/services/health-service.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthService = void 0;
+class HealthService {
+    constructor(userApp) {
+        this.userApp = userApp;
+    }
+    async handleHealthRequest(request) {
+        return await this.userApp.health(request);
+    }
+}
+exports.HealthService = HealthService;

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './graphql-service';
+export * from './health-service';

package/dist/services/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./graphql-service"), exports);
+tslib_1.__exportStar(require("./health-service"), exports);

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@magek/server",
+  "version": "0.0.1",
+  "description": "Debug your Magek projects locally",
+  "keywords": [
+    "server"
+  ],
+  "author": "Boosterin Labs SLU",
+  "homepage": "https://magek.ai",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theam/magek.git"
+  },
+  "engines": {
+    "node": ">=22.0.0 <23.0.0"
+  },
+  "dependencies": {
+    "@magek/common": "^0.0.1",
+    "@fastify/cors": "11.2.0",
+    "@fastify/websocket": "11.2.0",
+    "@seald-io/nedb": "4.1.2",
+    "fastify": "5.6.2",
+    "fastify-sse-v2": "4.2.1",
+    "node-schedule": "2.1.1",
+    "tslib": "2.8.1"
+  },
+  "bugs": {
+    "url": "https://github.com/theam/magek/issues"
+  },
+  "devDependencies": {
+    "@magek/eslint-config": "^0.0.1",
+    "@types/chai": "5.2.3",
+    "@types/chai-as-promised": "8.0.2",
+    "@types/mocha": "10.0.10",
+    "@types/node": "22.19.3",
+    "@types/node-schedule": "2.1.8",
+    "@types/sinon": "21.0.0",
+    "@types/sinon-chai": "4.0.0",
+    "chai": "6.2.2",
+    "chai-as-promised": "8.0.2",
+    "@faker-js/faker": "10.2.0",
+    "mocha": "11.7.5",
+    "c8": "^10.1.3",
+    "rimraf": "6.1.2",
+    "sinon": "21.0.1",
+    "sinon-chai": "4.0.1",
+    "tsx": "^4.19.2",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "format": "prettier --write --ext '.js,.ts' **/*.ts **/*/*.ts",
+    "lint:check": "eslint \"**/*.ts\"",
+    "lint:fix": "eslint --quiet --fix \"**/*.ts\"",
+    "build": "tsc -b tsconfig.json",
+    "clean": "rimraf ./dist tsconfig.tsbuildinfo",
+    "test:provider-local": "npm run test",
+    "test": "tsc --noEmit -p tsconfig.test.json && MAGEK_ENV=test c8 mocha --forbid-only \"test/**/*.test.ts\""
+  }
+}