@mostajs/net 1.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,20 @@
+// @mostajs/net — Multi-protocol transport layer for @mostajs/orm
+// Author: Dr Hamid MADANI drmdh@msn.com
+// Config
+export { loadNetConfig, getEnabledTransports, TRANSPORT_NAMES } from './core/config.js';
+// Factory
+export { getTransport, getActiveTransports, stopAllTransports } from './core/factory.js';
+// Middleware
+export { composeMiddleware, loggingMiddleware } from './core/middleware.js';
+// Transports
+export { RestTransport } from './transports/rest.transport.js';
+export { SSETransport } from './transports/sse.transport.js';
+export { GraphQLTransport } from './transports/graphql.transport.js';
+export { WebSocketTransport } from './transports/ws.transport.js';
+export { JsonRpcTransport } from './transports/jsonrpc.transport.js';
+export { McpTransport } from './transports/mcp.transport.js';
+// Auth / API Keys
+export { readApiKeys, writeApiKeys, generateApiKey, hashApiKey, createSubscription, revokeSubscription, validateApiKey, checkPermission, } from './auth/apikeys.js';
+export { apiKeyMiddleware } from './auth/apikey-middleware.js';
+// Server
+export { startServer } from './server.js';

package/dist/server.d.ts

@@ -0,0 +1,18 @@
+import type { FastifyInstance } from 'fastify';
+import { EntityService } from '@mostajs/orm';
+export interface NetServer {
+    app: FastifyInstance;
+    entityService: EntityService;
+    stop: () => Promise<void>;
+}
+/**
+ * Start the @mostajs/net server.
+ *
+ * 1. Load config from .env.local (MOSTA_NET_*)
+ * 2. Connect to ORM via @mostajs/orm (reads MOSTA_ORM_* / DB_DIALECT + SGBD_URI)
+ * 3. Create EntityService
+ * 4. Load and start enabled transports
+ * 5. Wire transports to EntityService
+ * 6. Listen on MOSTA_NET_PORT
+ */
+export declare function startServer(): Promise<NetServer>;

package/dist/server.js

@@ -0,0 +1,221 @@
+// @mostajs/net — Main server orchestrator
+// Loads config, connects ORM, starts transports, wires everything together
+// Author: Dr Hamid MADANI drmdh@msn.com
+import Fastify from 'fastify';
+import { EntityService, getAllSchemas, getDialect } from '@mostajs/orm';
+import { loadNetConfig, getEnabledTransports } from './core/config.js';
+import { getTransport, stopAllTransports } from './core/factory.js';
+import { loggingMiddleware } from './core/middleware.js';
+import { RestTransport } from './transports/rest.transport.js';
+import { SSETransport } from './transports/sse.transport.js';
+import { GraphQLTransport } from './transports/graphql.transport.js';
+import { WebSocketTransport } from './transports/ws.transport.js';
+import { JsonRpcTransport } from './transports/jsonrpc.transport.js';
+import { McpTransport } from './transports/mcp.transport.js';
+/**
+ * Start the @mostajs/net server.
+ *
+ * 1. Load config from .env.local (MOSTA_NET_*)
+ * 2. Connect to ORM via @mostajs/orm (reads MOSTA_ORM_* / DB_DIALECT + SGBD_URI)
+ * 3. Create EntityService
+ * 4. Load and start enabled transports
+ * 5. Wire transports to EntityService
+ * 6. Listen on MOSTA_NET_PORT
+ */
+export async function startServer() {
+    // 1. Load net config
+    const config = loadNetConfig();
+    // 2. Connect ORM
+    const dialect = await getDialect();
+    // 3. Create EntityService
+    const entityService = new EntityService(dialect);
+    // 4. Get schemas
+    const schemas = getAllSchemas();
+    // 5. Create shared Fastify instance
+    const app = Fastify({ logger: false });
+    // 6. ORM handler (OrmRequest → EntityService → OrmResponse)
+    const ormHandler = async (req, _ctx) => {
+        return entityService.execute(req);
+    };
+    // 7. Load and start enabled transports
+    const enabledNames = getEnabledTransports(config);
+    for (const name of enabledNames) {
+        const transportConfig = config.transports[name];
+        const transport = await getTransport(name, transportConfig);
+        if (!transport)
+            continue;
+        // Register all schemas
+        for (const schema of schemas) {
+            transport.registerEntity(schema);
+        }
+        // Add logging middleware
+        transport.use(loggingMiddleware);
+        // Wire ORM handler
+        if (transport instanceof RestTransport) {
+            transport.setHandler(ormHandler);
+        }
+        // Start the transport
+        await transport.start(transportConfig);
+        // Mount REST routes directly on the shared Fastify instance
+        if (transport instanceof RestTransport) {
+            for (const schema of schemas) {
+                registerRestRoutes(app, schema, ormHandler);
+            }
+        }
+        // Mount SSE route and wire EntityService events → broadcast
+        if (transport instanceof SSETransport) {
+            const sseTransport = transport;
+            const ssePath = sseTransport.getPath();
+            // SSE endpoint: GET /events
+            app.get(ssePath, async (req, reply) => {
+                // Use raw Node.js response for SSE streaming
+                reply.hijack();
+                sseTransport.addClient(reply.raw);
+            });
+            // Wire EntityService change events → SSE broadcast
+            entityService.on('entity.created', (data) => sseTransport.broadcast('entity.created', data));
+            entityService.on('entity.updated', (data) => sseTransport.broadcast('entity.updated', data));
+            entityService.on('entity.deleted', (data) => sseTransport.broadcast('entity.deleted', data));
+            entityService.on('entity.upserted', (data) => sseTransport.broadcast('entity.upserted', data));
+        }
+        // Mount GraphQL via mercurius
+        if (transport instanceof GraphQLTransport) {
+            const gqlTransport = transport;
+            gqlTransport.setHandler(ormHandler);
+            const schema = gqlTransport.generateSchema();
+            const resolvers = gqlTransport.generateResolvers();
+            const mercurius = (await import('mercurius')).default;
+            await app.register(mercurius, {
+                schema,
+                resolvers,
+                path: gqlTransport.getInfo().url || '/graphql',
+                graphiql: true, // Enable GraphiQL IDE at the same path
+            });
+        }
+        // Mount JSON-RPC endpoint
+        if (transport instanceof JsonRpcTransport) {
+            const rpcTransport = transport;
+            rpcTransport.setHandler(ormHandler);
+            const rpcPath = rpcTransport.getPath();
+            app.post(rpcPath, async (req, reply) => {
+                const result = await rpcTransport.handleBody(req.body);
+                return result;
+            });
+            // Discovery: list available methods
+            app.get(rpcPath, async () => ({
+                jsonrpc: '2.0',
+                methods: rpcTransport.listMethods(),
+            }));
+        }
+        // Mount MCP endpoint (Streamable HTTP)
+        if (transport instanceof McpTransport) {
+            const mcpTransport = transport;
+            mcpTransport.setHandler(ormHandler);
+            const mcpPath = mcpTransport.getPath();
+            // MCP uses raw Node.js request/response for streaming
+            app.all(mcpPath, async (req, reply) => {
+                reply.hijack();
+                await mcpTransport.handleRequest(req.raw, reply.raw, req.body);
+            });
+        }
+        const info = transport.getInfo();
+        console.log(`  \x1b[32m●\x1b[0m ${info.name.charAt(0).toUpperCase() + info.name.slice(1)}Transport${info.url ? '  ' + info.url : ''}${info.port ? '  :' + info.port : ''}`);
+    }
+    // 8. Health check
+    app.get('/health', async () => ({ status: 'ok', transports: enabledNames, entities: schemas.map(s => s.name) }));
+    // 9. Listen
+    await app.listen({ port: config.port, host: '0.0.0.0' });
+    // 10. Attach WebSocket to the HTTP server (must be after listen)
+    for (const name of enabledNames) {
+        const transport = (await import('./core/factory.js')).getActiveTransports().find(t => t.name === name);
+        if (transport instanceof WebSocketTransport) {
+            const wsTransport = transport;
+            wsTransport.setHandler(ormHandler);
+            wsTransport.attachToServer(app.server);
+            // Wire change events → WS broadcast
+            entityService.on('entity.created', (data) => wsTransport.broadcast('entity.created', data));
+            entityService.on('entity.updated', (data) => wsTransport.broadcast('entity.updated', data));
+            entityService.on('entity.deleted', (data) => wsTransport.broadcast('entity.deleted', data));
+        }
+    }
+    console.log(`\n  \x1b[36mReady.\x1b[0m ${schemas.length} entities × ${enabledNames.length} transports = ${schemas.length * enabledNames.length} endpoints\n`);
+    return {
+        app,
+        entityService,
+        stop: async () => {
+            await stopAllTransports();
+            await app.close();
+        },
+    };
+}
+/**
+ * Register REST routes directly on the main Fastify instance.
+ * This avoids the complexity of merging two Fastify instances.
+ */
+function registerRestRoutes(app, schema, ormHandler) {
+    const prefix = '/api/v1';
+    const col = schema.collection;
+    const handle = async (ormReq, reply) => {
+        const ctx = { transport: 'rest' };
+        const res = await ormHandler(ormReq, ctx);
+        if (res.status === 'error') {
+            reply.status(res.error?.code === 'ENTITY_NOT_FOUND' || res.error?.code === 'EntityNotFoundError' ? 404 :
+                res.error?.code?.startsWith('MISSING') ? 400 : 500);
+        }
+        return res;
+    };
+    // GET /api/v1/{collection}
+    app.get(`${prefix}/${col}`, async (req, reply) => {
+        const q = req.query;
+        return handle({
+            op: 'findAll', entity: schema.name,
+            filter: q.filter ? JSON.parse(q.filter) : {},
+            options: {
+                sort: q.sort ? JSON.parse(q.sort) : undefined,
+                limit: q.limit ? parseInt(q.limit, 10) : undefined,
+                skip: q.skip ? parseInt(q.skip, 10) : undefined,
+            },
+        }, reply);
+    });
+    // GET /api/v1/{collection}/count
+    app.get(`${prefix}/${col}/count`, async (req, reply) => {
+        const q = req.query;
+        return handle({ op: 'count', entity: schema.name, filter: q.filter ? JSON.parse(q.filter) : {} }, reply);
+    });
+    // GET /api/v1/{collection}/:id
+    app.get(`${prefix}/${col}/:id`, async (req, reply) => {
+        const { id } = req.params;
+        const q = req.query;
+        return handle({
+            op: 'findById', entity: schema.name, id,
+            relations: q.include ? q.include.split(',') : undefined,
+        }, reply);
+    });
+    // POST /api/v1/{collection}
+    app.post(`${prefix}/${col}`, async (req, reply) => {
+        const res = await handle({ op: 'create', entity: schema.name, data: req.body }, reply);
+        if (reply.statusCode < 400)
+            reply.status(201);
+        return res;
+    });
+    // PUT /api/v1/{collection}/:id
+    app.put(`${prefix}/${col}/:id`, async (req, reply) => {
+        const { id } = req.params;
+        return handle({ op: 'update', entity: schema.name, id, data: req.body }, reply);
+    });
+    // DELETE /api/v1/{collection}/:id
+    app.delete(`${prefix}/${col}/:id`, async (req, reply) => {
+        const { id } = req.params;
+        return handle({ op: 'delete', entity: schema.name, id }, reply);
+    });
+    // POST /api/v1/{collection}/search
+    app.post(`${prefix}/${col}/search`, async (req, reply) => {
+        const body = req.body;
+        return handle({
+            op: 'search', entity: schema.name,
+            query: body.query,
+            searchFields: body.fields,
+            options: body.options,
+        }, reply);
+    });
+}

package/dist/transports/graphql.transport.d.ts

@@ -0,0 +1,29 @@
+import type { EntitySchema, OrmRequest, OrmResponse } from '@mostajs/orm';
+import type { ITransport, TransportConfig, TransportInfo, TransportMiddleware, TransportContext } from '../core/types.js';
+type OrmHandler = (req: OrmRequest, ctx: TransportContext) => Promise<OrmResponse>;
+export declare class GraphQLTransport implements ITransport {
+    readonly name = "graphql";
+    private config;
+    private schemas;
+    private middlewares;
+    private ormHandler;
+    private stats;
+    setHandler(handler: OrmHandler): void;
+    use(mw: TransportMiddleware): void;
+    registerEntity(schema: EntitySchema): void;
+    start(config: TransportConfig): Promise<void>;
+    stop(): Promise<void>;
+    getInfo(): TransportInfo;
+    /**
+     * Generate the GraphQL SDL schema string from registered EntitySchemas.
+     */
+    generateSchema(): string;
+    /**
+     * Generate resolvers that call OrmHandler.
+     */
+    generateResolvers(): Record<string, Record<string, Function>>;
+    private callOrm;
+}
+/** Factory */
+export declare function createTransport(): ITransport;
+export {};

package/dist/transports/graphql.transport.js

@@ -0,0 +1,164 @@
+// GraphQLTransport — Auto-generates GraphQL schema from EntitySchemas
+// Queries and mutations call EntityService via OrmRequest/OrmResponse
+// Author: Dr Hamid MADANI drmdh@msn.com
+export class GraphQLTransport {
+    name = 'graphql';
+    config = null;
+    schemas = [];
+    middlewares = [];
+    ormHandler = null;
+    stats = { requests: 0, errors: 0, startedAt: 0 };
+    setHandler(handler) { this.ormHandler = handler; }
+    use(mw) { this.middlewares.push(mw); }
+    registerEntity(schema) { this.schemas.push(schema); }
+    async start(config) {
+        this.config = config;
+        this.stats.startedAt = Date.now();
+    }
+    async stop() { this.config = null; }
+    getInfo() {
+        return {
+            name: this.name,
+            status: this.config ? 'running' : 'stopped',
+            url: this.config?.path || '/graphql',
+            entities: this.schemas.map(s => s.name),
+            stats: { ...this.stats },
+        };
+    }
+    /**
+     * Generate the GraphQL SDL schema string from registered EntitySchemas.
+     */
+    generateSchema() {
+        const types = [];
+        const queries = [];
+        const mutations = [];
+        for (const schema of this.schemas) {
+            const name = schema.name;
+            const fields = Object.entries(schema.fields);
+            // Type definition
+            const fieldDefs = [
+                '  id: ID!',
+                ...fields.map(([fname, fdef]) => `  ${fname}: ${gqlType(fdef.type, fdef.required)}`),
+                ...(schema.timestamps ? ['  createdAt: String', '  updatedAt: String'] : []),
+            ];
+            types.push(`type ${name} {\n${fieldDefs.join('\n')}\n}`);
+            // Input type for create/update
+            const inputFields = fields.map(([fname, fdef]) => `  ${fname}: ${gqlInputType(fdef.type, fdef.required && fname !== 'id')}`);
+            types.push(`input ${name}Input {\n${inputFields.join('\n')}\n}`);
+            // Queries
+            queries.push(`  ${lcfirst(name)}s(filter: String, limit: Int, skip: Int, sort: String): [${name}!]!`);
+            queries.push(`  ${lcfirst(name)}(id: ID!): ${name}`);
+            queries.push(`  ${lcfirst(name)}Count(filter: String): Int!`);
+            // Mutations
+            mutations.push(`  create${name}(input: ${name}Input!): ${name}!`);
+            mutations.push(`  update${name}(id: ID!, input: ${name}Input!): ${name}`);
+            mutations.push(`  delete${name}(id: ID!): Boolean!`);
+        }
+        return [
+            ...types,
+            `type Query {\n${queries.join('\n')}\n}`,
+            `type Mutation {\n${mutations.join('\n')}\n}`,
+        ].join('\n\n');
+    }
+    /**
+     * Generate resolvers that call OrmHandler.
+     */
+    generateResolvers() {
+        const Query = {};
+        const Mutation = {};
+        for (const schema of this.schemas) {
+            const name = schema.name;
+            // Query: users(filter, limit, skip, sort)
+            Query[`${lcfirst(name)}s`] = async (_, args) => {
+                this.stats.requests++;
+                const req = {
+                    op: 'findAll',
+                    entity: name,
+                    filter: args.filter ? JSON.parse(args.filter) : {},
+                    options: {
+                        limit: args.limit,
+                        skip: args.skip,
+                        sort: args.sort ? JSON.parse(args.sort) : undefined,
+                    },
+                };
+                const res = await this.callOrm(req);
+                return res.data || [];
+            };
+            // Query: user(id)
+            Query[lcfirst(name)] = async (_, args) => {
+                this.stats.requests++;
+                const res = await this.callOrm({ op: 'findById', entity: name, id: args.id });
+                return res.data;
+            };
+            // Query: userCount(filter)
+            Query[`${lcfirst(name)}Count`] = async (_, args) => {
+                this.stats.requests++;
+                const res = await this.callOrm({
+                    op: 'count', entity: name,
+                    filter: args.filter ? JSON.parse(args.filter) : {},
+                });
+                return res.data || 0;
+            };
+            // Mutation: createUser(input)
+            Mutation[`create${name}`] = async (_, args) => {
+                this.stats.requests++;
+                const res = await this.callOrm({ op: 'create', entity: name, data: args.input });
+                if (res.status === 'error')
+                    throw new Error(res.error?.message);
+                return res.data;
+            };
+            // Mutation: updateUser(id, input)
+            Mutation[`update${name}`] = async (_, args) => {
+                this.stats.requests++;
+                const res = await this.callOrm({ op: 'update', entity: name, id: args.id, data: args.input });
+                if (res.status === 'error')
+                    throw new Error(res.error?.message);
+                return res.data;
+            };
+            // Mutation: deleteUser(id)
+            Mutation[`delete${name}`] = async (_, args) => {
+                this.stats.requests++;
+                const res = await this.callOrm({ op: 'delete', entity: name, id: args.id });
+                return res.data === true;
+            };
+        }
+        return { Query, Mutation };
+    }
+    async callOrm(req) {
+        if (!this.ormHandler) {
+            return { status: 'error', error: { code: 'NO_HANDLER', message: 'ORM handler not initialized' } };
+        }
+        const ctx = { transport: this.name };
+        return this.ormHandler(req, ctx);
+    }
+}
+// ============================================================
+// Helpers
+// ============================================================
+function gqlType(type, required) {
+    const base = fieldTypeToGql(type);
+    return required ? `${base}!` : base;
+}
+function gqlInputType(type, required) {
+    const base = fieldTypeToGql(type);
+    return required ? `${base}!` : base;
+}
+function fieldTypeToGql(type) {
+    switch (type) {
+        case 'string':
+        case 'text': return 'String';
+        case 'number': return 'Float';
+        case 'boolean': return 'Boolean';
+        case 'date': return 'String';
+        case 'json': return 'String';
+        case 'array': return '[String]';
+        default: return 'String';
+    }
+}
+function lcfirst(s) {
+    return s.charAt(0).toLowerCase() + s.slice(1);
+}
+/** Factory */
+export function createTransport() {
+    return new GraphQLTransport();
+}

package/dist/transports/jsonrpc.transport.d.ts

@@ -0,0 +1,41 @@
+import type { EntitySchema, OrmRequest, OrmResponse } from '@mostajs/orm';
+import type { ITransport, TransportConfig, TransportInfo, TransportMiddleware, TransportContext } from '../core/types.js';
+type OrmHandler = (req: OrmRequest, ctx: TransportContext) => Promise<OrmResponse>;
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    id: string | number | null;
+}
+export declare class JsonRpcTransport implements ITransport {
+    readonly name = "jsonrpc";
+    private config;
+    private schemas;
+    private middlewares;
+    private ormHandler;
+    private stats;
+    setHandler(handler: OrmHandler): void;
+    use(mw: TransportMiddleware): void;
+    registerEntity(schema: EntitySchema): void;
+    start(config: TransportConfig): Promise<void>;
+    stop(): Promise<void>;
+    getInfo(): TransportInfo;
+    getPath(): string;
+    /**
+     * Handle a JSON-RPC 2.0 request body.
+     * Supports single requests and batch (array of requests).
+     */
+    handleBody(body: unknown): Promise<JsonRpcResponse | JsonRpcResponse[]>;
+    private handleSingleRequest;
+    /**
+     * List available methods (for discovery).
+     */
+    listMethods(): string[];
+}
+/** Factory */
+export declare function createTransport(): ITransport;
+export {};

package/dist/transports/jsonrpc.transport.js

@@ -0,0 +1,116 @@
+// JsonRpcTransport — JSON-RPC 2.0 over HTTP
+// Implements the JSON-RPC 2.0 specification (jsonrpc.org)
+// Foundation for MCP transport (MCP uses JSON-RPC 2.0)
+// Author: Dr Hamid MADANI drmdh@msn.com
+// JSON-RPC 2.0 error codes
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const INTERNAL_ERROR = -32603;
+export class JsonRpcTransport {
+    name = 'jsonrpc';
+    config = null;
+    schemas = [];
+    middlewares = [];
+    ormHandler = null;
+    stats = { requests: 0, errors: 0, startedAt: 0 };
+    setHandler(handler) { this.ormHandler = handler; }
+    use(mw) { this.middlewares.push(mw); }
+    registerEntity(schema) { this.schemas.push(schema); }
+    async start(config) {
+        this.config = config;
+        this.stats.startedAt = Date.now();
+    }
+    async stop() { this.config = null; }
+    getInfo() {
+        return {
+            name: this.name,
+            status: this.config ? 'running' : 'stopped',
+            url: this.config?.path || '/rpc',
+            entities: this.schemas.map(s => s.name),
+            stats: { ...this.stats },
+        };
+    }
+    getPath() {
+        return this.config?.path || '/rpc';
+    }
+    /**
+     * Handle a JSON-RPC 2.0 request body.
+     * Supports single requests and batch (array of requests).
+     */
+    async handleBody(body) {
+        // Batch request
+        if (Array.isArray(body)) {
+            return Promise.all(body.map(req => this.handleSingleRequest(req)));
+        }
+        return this.handleSingleRequest(body);
+    }
+    async handleSingleRequest(raw) {
+        this.stats.requests++;
+        // Validate JSON-RPC envelope
+        const req = raw;
+        if (!req || req.jsonrpc !== '2.0' || typeof req.method !== 'string') {
+            this.stats.errors++;
+            return { jsonrpc: '2.0', error: { code: INVALID_REQUEST, message: 'Invalid JSON-RPC 2.0 request' }, id: req?.id ?? null };
+        }
+        // Parse method: "entity.{op}" or "{entityName}.{op}"
+        const parts = req.method.split('.');
+        if (parts.length < 2) {
+            this.stats.errors++;
+            return { jsonrpc: '2.0', error: { code: METHOD_NOT_FOUND, message: `Invalid method format: "${req.method}". Expected: "Entity.operation"` }, id: req.id ?? null };
+        }
+        const entityName = parts[0];
+        const op = parts[1];
+        const params = (req.params || {});
+        // Build OrmRequest
+        const ormReq = {
+            op: op,
+            entity: entityName,
+            id: params.id,
+            filter: params.filter,
+            data: params.data,
+            options: params.options,
+            relations: params.relations,
+            query: params.query,
+            searchFields: params.searchFields,
+            stages: params.stages,
+        };
+        if (!this.ormHandler) {
+            this.stats.errors++;
+            return { jsonrpc: '2.0', error: { code: INTERNAL_ERROR, message: 'ORM handler not initialized' }, id: req.id ?? null };
+        }
+        const ctx = { transport: this.name };
+        const res = await this.ormHandler(ormReq, ctx);
+        if (res.status === 'error') {
+            this.stats.errors++;
+            return {
+                jsonrpc: '2.0',
+                error: { code: INTERNAL_ERROR, message: res.error?.message || 'Unknown error', data: res.error },
+                id: req.id ?? null,
+            };
+        }
+        return {
+            jsonrpc: '2.0',
+            result: { data: res.data, metadata: res.metadata },
+            id: req.id ?? null,
+        };
+    }
+    /**
+     * List available methods (for discovery).
+     */
+    listMethods() {
+        const methods = [];
+        const ops = ['findAll', 'findOne', 'findById', 'create', 'update', 'delete', 'count', 'search'];
+        for (const schema of this.schemas) {
+            for (const op of ops) {
+                methods.push(`${schema.name}.${op}`);
+            }
+        }
+        return methods;
+    }
+}
+/** Factory */
+export function createTransport() {
+    return new JsonRpcTransport();
+}

package/dist/transports/mcp.transport.d.ts

@@ -0,0 +1,34 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { EntitySchema, OrmRequest, OrmResponse } from '@mostajs/orm';
+import type { ITransport, TransportConfig, TransportInfo, TransportMiddleware, TransportContext } from '../core/types.js';
+type OrmHandler = (req: OrmRequest, ctx: TransportContext) => Promise<OrmResponse>;
+export declare class McpTransport implements ITransport {
+    readonly name = "mcp";
+    private config;
+    private schemas;
+    private middlewares;
+    private ormHandler;
+    private stats;
+    setHandler(handler: OrmHandler): void;
+    use(mw: TransportMiddleware): void;
+    registerEntity(schema: EntitySchema): void;
+    start(config: TransportConfig): Promise<void>;
+    stop(): Promise<void>;
+    getInfo(): TransportInfo;
+    getPath(): string;
+    /**
+     * Handle an incoming MCP HTTP request.
+     * Called by the main Fastify server via route handler.
+     */
+    /**
+     * Handle an incoming MCP HTTP request.
+     * Creates a new McpServer + Transport per session for stateless mode.
+     */
+    handleRequest(req: IncomingMessage, res: ServerResponse, body?: unknown): Promise<void>;
+    private registerEntityToolsOn;
+    private registerEntityResourcesOn;
+    private callOrm;
+}
+/** Factory */
+export declare function createTransport(): ITransport;
+export {};