@mostajs/net 1.0.0-alpha.1

package/dist/auth/apikey-middleware.d.ts

@@ -0,0 +1,12 @@
+import type { TransportMiddleware } from '../core/types.js';
+/**
+ * API key authentication middleware.
+ *
+ * Extracts the API key from:
+ *   - Header: Authorization: Bearer msk_live_...
+ *   - Query: ?apikey=msk_live_...
+ *
+ * If .mosta/apikeys.json has no subscriptions, all requests are allowed (open mode).
+ * If subscriptions exist, a valid API key is required.
+ */
+export declare const apiKeyMiddleware: TransportMiddleware;

package/dist/auth/apikey-middleware.js

@@ -0,0 +1,62 @@
+// @mostajs/net — API Key authentication middleware
+// Validates Bearer token against .mosta/apikeys.json
+// Checks permissions against the 3D matrix (API key × SGBD × transport)
+// Author: Dr Hamid MADANI drmdh@msn.com
+import { validateApiKey, checkPermission, opToPermission } from './apikeys.js';
+import { getCurrentDialectType } from '@mostajs/orm';
+/**
+ * API key authentication middleware.
+ *
+ * Extracts the API key from:
+ *   - Header: Authorization: Bearer msk_live_...
+ *   - Query: ?apikey=msk_live_...
+ *
+ * If .mosta/apikeys.json has no subscriptions, all requests are allowed (open mode).
+ * If subscriptions exist, a valid API key is required.
+ */
+export const apiKeyMiddleware = async (req, ctx, next) => {
+    const key = ctx.apiKey;
+    // If no key provided, check if we're in open mode (no subscriptions configured)
+    if (!key) {
+        const { readApiKeys } = await import('./apikeys.js');
+        const data = readApiKeys();
+        if (data.subscriptions.length === 0) {
+            // Open mode: no API keys configured, allow everything
+            return next();
+        }
+        return {
+            status: 'error',
+            error: {
+                code: 'UNAUTHORIZED',
+                message: 'API key required. Pass it via Authorization: Bearer <key> header',
+            },
+        };
+    }
+    // Validate key
+    const sub = validateApiKey(key);
+    if (!sub) {
+        return {
+            status: 'error',
+            error: {
+                code: 'UNAUTHORIZED',
+                message: 'Invalid or revoked API key',
+            },
+        };
+    }
+    // Check permission: dialect × transport × operation
+    const dialect = getCurrentDialectType();
+    const perm = opToPermission(req.op);
+    if (!checkPermission(sub, dialect, ctx.transport, perm)) {
+        return {
+            status: 'error',
+            error: {
+                code: 'FORBIDDEN',
+                message: `Subscription "${sub.name}" does not have ${perm} permission for ${dialect}/${ctx.transport}`,
+            },
+        };
+    }
+    // Enrich context
+    ctx.subscription = sub.name;
+    ctx.permissions = sub.permissions[dialect] || sub.permissions['*'] || {};
+    return next();
+};

package/dist/auth/apikeys.d.ts

@@ -0,0 +1,34 @@
+export interface Subscription {
+    name: string;
+    key: string | null;
+    hash: string;
+    created: string;
+    status: 'active' | 'revoked';
+    permissions: Record<string, Record<string, string>>;
+}
+export interface ApiKeysFile {
+    subscriptions: Subscription[];
+}
+/** Read .mosta/apikeys.json — returns empty if not found */
+export declare function readApiKeys(): ApiKeysFile;
+/** Write .mosta/apikeys.json */
+export declare function writeApiKeys(data: ApiKeysFile): void;
+/** Generate a new API key with prefix msk_live_ or msk_test_ */
+export declare function generateApiKey(mode?: 'live' | 'test'): string;
+/** Hash a key with SHA-256 */
+export declare function hashApiKey(key: string): string;
+/** Create a new subscription, returns the clear-text key (shown once) */
+export declare function createSubscription(name: string, permissions?: Record<string, Record<string, string>>, mode?: 'live' | 'test'): {
+    subscription: Subscription;
+    clearKey: string;
+};
+/** Revoke a subscription by name */
+export declare function revokeSubscription(name: string): boolean;
+/** Validate an API key and return the matching subscription (or null) */
+export declare function validateApiKey(key: string): Subscription | null;
+/** Check if a subscription has permission for a given dialect + transport + operation */
+export declare function checkPermission(sub: Subscription, dialect: string, transport: string, operation: 'r' | 'c' | 'u' | 'd'): boolean;
+/**
+ * Map ORM operation to permission check letter
+ */
+export declare function opToPermission(op: string): 'r' | 'c' | 'u' | 'd';

package/dist/auth/apikeys.js

@@ -0,0 +1,130 @@
+// @mostajs/net — API Key management
+// Reads .mosta/apikeys.json, validates keys, checks permissions
+// Author: Dr Hamid MADANI drmdh@msn.com
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { createHash, randomBytes } from 'crypto';
+// ============================================================
+// File I/O
+// ============================================================
+const APIKEYS_DIR = '.mosta';
+const APIKEYS_FILE = 'apikeys.json';
+function getApiKeysPath() {
+    return join(process.cwd(), APIKEYS_DIR, APIKEYS_FILE);
+}
+/** Read .mosta/apikeys.json — returns empty if not found */
+export function readApiKeys() {
+    const path = getApiKeysPath();
+    if (!existsSync(path)) {
+        return { subscriptions: [] };
+    }
+    const raw = readFileSync(path, 'utf-8');
+    return JSON.parse(raw);
+}
+/** Write .mosta/apikeys.json */
+export function writeApiKeys(data) {
+    const dir = join(process.cwd(), APIKEYS_DIR);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(getApiKeysPath(), JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+// ============================================================
+// Key generation
+// ============================================================
+/** Generate a new API key with prefix msk_live_ or msk_test_ */
+export function generateApiKey(mode = 'live') {
+    const prefix = mode === 'live' ? 'msk_live_' : 'msk_test_';
+    const random = randomBytes(24).toString('base64url');
+    return prefix + random;
+}
+/** Hash a key with SHA-256 */
+export function hashApiKey(key) {
+    return createHash('sha256').update(key).digest('hex');
+}
+// ============================================================
+// Subscription CRUD
+// ============================================================
+/** Create a new subscription, returns the clear-text key (shown once) */
+export function createSubscription(name, permissions = { '*': { '*': 'crud' } }, mode = 'live') {
+    const data = readApiKeys();
+    // Check duplicate name
+    if (data.subscriptions.some(s => s.name === name)) {
+        throw new Error(`Subscription "${name}" already exists`);
+    }
+    const clearKey = generateApiKey(mode);
+    const subscription = {
+        name,
+        key: clearKey,
+        hash: hashApiKey(clearKey),
+        created: new Date().toISOString().slice(0, 10),
+        status: 'active',
+        permissions,
+    };
+    data.subscriptions.push(subscription);
+    writeApiKeys(data);
+    return { subscription, clearKey };
+}
+/** Revoke a subscription by name */
+export function revokeSubscription(name) {
+    const data = readApiKeys();
+    const sub = data.subscriptions.find(s => s.name === name);
+    if (!sub)
+        return false;
+    sub.status = 'revoked';
+    sub.permissions = {};
+    writeApiKeys(data);
+    return true;
+}
+// ============================================================
+// Validation
+// ============================================================
+/** Validate an API key and return the matching subscription (or null) */
+export function validateApiKey(key) {
+    const hash = hashApiKey(key);
+    const data = readApiKeys();
+    return data.subscriptions.find(s => s.hash === hash && s.status === 'active') || null;
+}
+/** Check if a subscription has permission for a given dialect + transport + operation */
+export function checkPermission(sub, dialect, transport, operation) {
+    // Find matching permission entry (exact match or wildcard)
+    const dialectPerms = sub.permissions[dialect] || sub.permissions['*'];
+    if (!dialectPerms)
+        return false;
+    const rights = dialectPerms[transport] || dialectPerms['*'];
+    if (!rights)
+        return false;
+    // Check operation against rights string
+    switch (operation) {
+        case 'r': return rights.includes('r');
+        case 'c': return rights.includes('c') && rights.includes('r'); // 'cr' or 'crud'
+        case 'u': return rights.includes('crud');
+        case 'd': return rights.includes('crud');
+        default: return false;
+    }
+}
+/**
+ * Map ORM operation to permission check letter
+ */
+export function opToPermission(op) {
+    switch (op) {
+        case 'findAll':
+        case 'findOne':
+        case 'findById':
+        case 'count':
+        case 'search':
+        case 'aggregate':
+        case 'stream':
+            return 'r';
+        case 'create':
+        case 'upsert':
+            return 'c';
+        case 'update':
+            return 'u';
+        case 'delete':
+        case 'deleteMany':
+            return 'd';
+        default:
+            return 'r';
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+// @mostajs/net CLI — `npx @mostajs/net serve`
+// Author: Dr Hamid MADANI drmdh@msn.com
+import { loadNetConfig, getEnabledTransports, TRANSPORT_NAMES } from './core/config.js';
+const args = process.argv.slice(2);
+const command = args[0];
+const arg1 = args[1];
+const arg2 = args[2];
+async function main() {
+    switch (command) {
+        case 'generate-apikey': {
+            const { createSubscription } = await import('./auth/apikeys.js');
+            const name = arg1 || 'default';
+            const mode = (arg2 === 'test' ? 'test' : 'live');
+            const { subscription, clearKey } = createSubscription(name, { '*': { '*': 'crud' } }, mode);
+            console.log(`\n  API Key generated for "${subscription.name}":`);
+            console.log(`  Key:  ${clearKey}`);
+            console.log(`  Hash: ${subscription.hash}`);
+            console.log(`  Mode: ${mode}`);
+            console.log(`\n  Saved in .mosta/apikeys.json\n`);
+            break;
+        }
+        case 'hash-password': {
+            if (!arg1) {
+                console.log('Usage: mostajs-net hash-password <password>');
+                process.exit(1);
+            }
+            // Dynamic import to avoid requiring bcrypt if not used
+            // Use SHA-256 for password hashing (no bcrypt dependency required)
+            const { createHash } = await import('crypto');
+            const hash = createHash('sha256').update(arg1).digest('hex');
+            console.log(`\n  Password hash (SHA-256):`);
+            console.log(`  ${hash}\n`);
+            console.log(`  Add to .env.local:`);
+            console.log(`  MOSTA_ADMIN_PASS_HASH=${hash}\n`);
+            break;
+        }
+        case 'serve':
+        case undefined: {
+            console.log(`
+  \x1b[1m@mostajs/net\x1b[0m v1.0.0-alpha.1
+  ${'─'.repeat(35)}
+`);
+            const config = loadNetConfig();
+            const enabled = getEnabledTransports(config);
+            if (enabled.length === 0) {
+                console.log('  \x1b[33m⚠\x1b[0m No transports enabled.');
+                console.log(`  Set MOSTA_NET_{TRANSPORT}_ENABLED=true in .env.local`);
+                console.log(`  Available: ${TRANSPORT_NAMES.join(', ')}\n`);
+                process.exit(1);
+            }
+            console.log(`  Transports enabled: ${enabled.join(', ')}`);
+            console.log(`  Port: ${config.port}\n`);
+            // Dynamic import to avoid loading ORM at parse time
+            const { startServer } = await import('./server.js');
+            const server = await startServer();
+            // Graceful shutdown
+            const shutdown = async () => {
+                console.log('\n  Shutting down...');
+                await server.stop();
+                process.exit(0);
+            };
+            process.on('SIGINT', shutdown);
+            process.on('SIGTERM', shutdown);
+            break;
+        }
+        case 'info': {
+            const config = loadNetConfig();
+            const enabled = getEnabledTransports(config);
+            const { readApiKeys } = await import('./auth/apikeys.js');
+            const keys = readApiKeys();
+            console.log(JSON.stringify({
+                port: config.port,
+                transports: { enabled, all: [...TRANSPORT_NAMES] },
+                apikeys: keys.subscriptions.map(s => ({ name: s.name, status: s.status, created: s.created })),
+            }, null, 2));
+            break;
+        }
+        case 'list-keys': {
+            const { readApiKeys } = await import('./auth/apikeys.js');
+            const keys = readApiKeys();
+            if (keys.subscriptions.length === 0) {
+                console.log('\n  No API keys configured. Use: mostajs-net generate-apikey <name>\n');
+            }
+            else {
+                console.log(`\n  API Keys (${keys.subscriptions.length}):`);
+                for (const s of keys.subscriptions) {
+                    const icon = s.status === 'active' ? '\x1b[32m●\x1b[0m' : '\x1b[31m○\x1b[0m';
+                    console.log(`  ${icon} ${s.name} (${s.status}, ${s.created})`);
+                }
+                console.log('');
+            }
+            break;
+        }
+        case 'revoke-key': {
+            if (!arg1) {
+                console.log('Usage: mostajs-net revoke-key <name>');
+                process.exit(1);
+            }
+            const { revokeSubscription } = await import('./auth/apikeys.js');
+            if (revokeSubscription(arg1)) {
+                console.log(`\n  Subscription "${arg1}" revoked.\n`);
+            }
+            else {
+                console.log(`\n  Subscription "${arg1}" not found.\n`);
+                process.exit(1);
+            }
+            break;
+        }
+        default:
+            console.log(`Unknown command: ${command}`);
+            console.log('Usage: mostajs-net <command>');
+            console.log('');
+            console.log('Commands:');
+            console.log('  serve              Start the server');
+            console.log('  info               Show config and API keys');
+            console.log('  generate-apikey    Generate a new API key');
+            console.log('  list-keys          List all API keys');
+            console.log('  revoke-key <name>  Revoke an API key');
+            console.log('  hash-password <pw> Hash a password');
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error('\x1b[31mFatal:\x1b[0m', err.message || err);
+    process.exit(1);
+});

package/dist/core/config.d.ts

@@ -0,0 +1,15 @@
+import type { NetServerConfig } from './types.js';
+/** All known transport names */
+export declare const TRANSPORT_NAMES: readonly ["rest", "grpc", "graphql", "ws", "sse", "trpc", "mcp", "odata", "arrow", "jsonrpc", "nats"];
+export type TransportName = typeof TRANSPORT_NAMES[number];
+/**
+ * Load net configuration from environment variables.
+ *
+ * Convention: MOSTA_NET_{TRANSPORT}_ENABLED, MOSTA_NET_{TRANSPORT}_PORT, MOSTA_NET_{TRANSPORT}_PATH
+ * Example: MOSTA_NET_REST_ENABLED=true, MOSTA_NET_GRPC_PORT=50051
+ */
+export declare function loadNetConfig(): NetServerConfig;
+/**
+ * Get the list of enabled transport names from config.
+ */
+export declare function getEnabledTransports(config: NetServerConfig): TransportName[];

package/dist/core/config.js

@@ -0,0 +1,60 @@
+// @mostajs/net — Configuration loader
+// Reads MOSTA_NET_* from process.env (populated by .env.local)
+// Author: Dr Hamid MADANI drmdh@msn.com
+/** All known transport names */
+export const TRANSPORT_NAMES = [
+    'rest', 'grpc', 'graphql', 'ws', 'sse',
+    'trpc', 'mcp', 'odata', 'arrow', 'jsonrpc', 'nats',
+];
+/** Default port for the main HTTP server */
+const DEFAULT_PORT = 4488;
+/** Default ports for transports that need dedicated ports */
+const DEFAULT_TRANSPORT_PORTS = {
+    grpc: 50051,
+    arrow: 50052,
+};
+/** Default HTTP paths for transports mounted on the main server */
+const DEFAULT_TRANSPORT_PATHS = {
+    rest: '/api/v1',
+    graphql: '/graphql',
+    ws: '/ws',
+    sse: '/events',
+    trpc: '/trpc',
+    mcp: '/mcp',
+    odata: '/odata',
+    jsonrpc: '/rpc',
+};
+/**
+ * Load net configuration from environment variables.
+ *
+ * Convention: MOSTA_NET_{TRANSPORT}_ENABLED, MOSTA_NET_{TRANSPORT}_PORT, MOSTA_NET_{TRANSPORT}_PATH
+ * Example: MOSTA_NET_REST_ENABLED=true, MOSTA_NET_GRPC_PORT=50051
+ */
+export function loadNetConfig() {
+    const port = parseInt(process.env.MOSTA_NET_PORT || '', 10) || DEFAULT_PORT;
+    const transports = {};
+    for (const name of TRANSPORT_NAMES) {
+        const upper = name.toUpperCase();
+        const enabled = process.env[`MOSTA_NET_${upper}_ENABLED`] === 'true';
+        transports[name] = {
+            enabled,
+            port: parseInt(process.env[`MOSTA_NET_${upper}_PORT`] || '', 10) || DEFAULT_TRANSPORT_PORTS[name],
+            path: process.env[`MOSTA_NET_${upper}_PATH`] || DEFAULT_TRANSPORT_PATHS[name],
+            options: {},
+        };
+        // Transport-specific options
+        if (name === 'mcp') {
+            transports[name].options.mode = process.env.MOSTA_NET_MCP_MODE || 'http';
+        }
+        if (name === 'nats') {
+            transports[name].options.url = process.env.MOSTA_NET_NATS_URL || 'nats://localhost:4222';
+        }
+    }
+    return { port, transports };
+}
+/**
+ * Get the list of enabled transport names from config.
+ */
+export function getEnabledTransports(config) {
+    return TRANSPORT_NAMES.filter(name => config.transports[name]?.enabled);
+}

package/dist/core/factory.d.ts

@@ -0,0 +1,15 @@
+import type { ITransport, TransportConfig } from './types.js';
+import type { TransportName } from './config.js';
+/**
+ * Get or create a transport by name.
+ * Returns null if the transport is not enabled in config.
+ */
+export declare function getTransport(name: TransportName, config: TransportConfig): Promise<ITransport | null>;
+/**
+ * Get all active (started) transports.
+ */
+export declare function getActiveTransports(): ITransport[];
+/**
+ * Stop all active transports.
+ */
+export declare function stopAllTransports(): Promise<void>;

package/dist/core/factory.js

@@ -0,0 +1,60 @@
+// @mostajs/net — Transport Factory
+// Lazy-loads transport adapters (like getDialect() in @mostajs/orm)
+// Author: Dr Hamid MADANI drmdh@msn.com
+/**
+ * Dynamically load a transport module.
+ * Only the selected transport is loaded — no unused dependencies in memory.
+ * Mirror of loadDialectModule() in @mostajs/orm.
+ */
+async function loadTransportModule(name) {
+    switch (name) {
+        case 'rest': return import('../transports/rest.transport.js');
+        case 'sse': return import('../transports/sse.transport.js');
+        case 'graphql': return import('../transports/graphql.transport.js');
+        case 'ws': return import('../transports/ws.transport.js');
+        case 'jsonrpc': return import('../transports/jsonrpc.transport.js');
+        case 'mcp': return import('../transports/mcp.transport.js');
+        // Future transports:
+        // case 'sse':      return import('../transports/sse.transport.js');
+        // case 'trpc':     return import('../transports/trpc.transport.js');
+        // case 'mcp':      return import('../transports/mcp.transport.js');
+        // case 'odata':    return import('../transports/odata.transport.js');
+        // case 'arrow':    return import('../transports/arrow.transport.js');
+        // case 'jsonrpc':  return import('../transports/jsonrpc.transport.js');
+        // case 'nats':     return import('../transports/nats.transport.js');
+        default:
+            throw new Error(`Transport "${name}" is not yet implemented`);
+    }
+}
+/** Registry of active transport instances */
+const activeTransports = new Map();
+/**
+ * Get or create a transport by name.
+ * Returns null if the transport is not enabled in config.
+ */
+export async function getTransport(name, config) {
+    if (!config.enabled)
+        return null;
+    if (activeTransports.has(name)) {
+        return activeTransports.get(name);
+    }
+    const mod = await loadTransportModule(name);
+    const transport = mod.createTransport();
+    activeTransports.set(name, transport);
+    return transport;
+}
+/**
+ * Get all active (started) transports.
+ */
+export function getActiveTransports() {
+    return Array.from(activeTransports.values());
+}
+/**
+ * Stop all active transports.
+ */
+export async function stopAllTransports() {
+    for (const transport of activeTransports.values()) {
+        await transport.stop();
+    }
+    activeTransports.clear();
+}

package/dist/core/middleware.d.ts

@@ -0,0 +1,12 @@
+import type { OrmRequest, OrmResponse } from '@mostajs/orm';
+import type { TransportMiddleware, TransportContext } from './types.js';
+/**
+ * Compose an array of middlewares into a single execution chain.
+ * Each middleware calls next() to pass to the next one.
+ * The last function in the chain executes the actual ORM operation.
+ */
+export declare function composeMiddleware(middlewares: TransportMiddleware[], handler: (req: OrmRequest, ctx: TransportContext) => Promise<OrmResponse>): (req: OrmRequest, ctx: TransportContext) => Promise<OrmResponse>;
+/**
+ * Logging middleware — logs every request/response.
+ */
+export declare const loggingMiddleware: TransportMiddleware;

package/dist/core/middleware.js

@@ -0,0 +1,32 @@
+// @mostajs/net — Middleware pipeline
+// Composes middleware functions (auth, rate-limit, logging) into a chain
+// Author: Dr Hamid MADANI drmdh@msn.com
+/**
+ * Compose an array of middlewares into a single execution chain.
+ * Each middleware calls next() to pass to the next one.
+ * The last function in the chain executes the actual ORM operation.
+ */
+export function composeMiddleware(middlewares, handler) {
+    return async (req, ctx) => {
+        let index = 0;
+        const next = async () => {
+            if (index < middlewares.length) {
+                const mw = middlewares[index++];
+                return mw(req, ctx, next);
+            }
+            return handler(req, ctx);
+        };
+        return next();
+    };
+}
+/**
+ * Logging middleware — logs every request/response.
+ */
+export const loggingMiddleware = async (req, ctx, next) => {
+    const start = Date.now();
+    const res = await next();
+    const ms = Date.now() - start;
+    const status = res.status === 'ok' ? '\x1b[32mOK\x1b[0m' : '\x1b[31mERR\x1b[0m';
+    console.log(`[${ctx.transport}] ${req.op} ${req.entity}${req.id ? '/' + req.id : ''} → ${status} (${ms}ms)`);
+    return res;
+};

package/dist/core/types.d.ts

@@ -0,0 +1,62 @@
+import type { EntitySchema, OrmRequest, OrmResponse } from '@mostajs/orm';
+export interface TransportConfig {
+    /** Is this transport enabled? */
+    enabled: boolean;
+    /** Dedicated port (for transports that need their own port, e.g. gRPC) */
+    port?: number;
+    /** HTTP path prefix (for transports mounted on the main HTTP server) */
+    path?: string;
+    /** Transport-specific options */
+    options?: Record<string, unknown>;
+}
+export interface TransportInfo {
+    /** Transport identifier (e.g. 'rest', 'grpc', 'graphql') */
+    name: string;
+    /** Current status */
+    status: 'running' | 'stopped' | 'error';
+    /** Listening URL (e.g. "http://localhost:4488/api/v1") */
+    url?: string;
+    /** Dedicated port (e.g. 50051 for gRPC) */
+    port?: number;
+    /** Registered entity names */
+    entities: string[];
+    /** Runtime stats */
+    stats: {
+        requests: number;
+        errors: number;
+        startedAt: number;
+    };
+}
+export interface TransportContext {
+    /** Transport name that received the request */
+    transport: string;
+    /** API key (if present in the request) */
+    apiKey?: string;
+    /** Resolved subscription name (after API key validation) */
+    subscription?: string;
+    /** Resolved permissions for this request */
+    permissions?: Record<string, string>;
+    /** Extra metadata per transport */
+    meta?: Record<string, unknown>;
+}
+export type TransportMiddleware = (req: OrmRequest, ctx: TransportContext, next: () => Promise<OrmResponse>) => Promise<OrmResponse>;
+export interface ITransport {
+    /** Transport identifier (e.g. 'rest', 'grpc', 'graphql') */
+    readonly name: string;
+    /** Initialize and start the transport */
+    start(config: TransportConfig): Promise<void>;
+    /** Stop the transport gracefully */
+    stop(): Promise<void>;
+    /** Register an entity schema — generates endpoints for this entity */
+    registerEntity(schema: EntitySchema): void;
+    /** Add a middleware to the transport pipeline */
+    use(middleware: TransportMiddleware): void;
+    /** Get runtime info (for admin dashboard) */
+    getInfo(): TransportInfo;
+}
+export interface NetServerConfig {
+    /** Main HTTP port (shared by REST, GraphQL, SSE, etc.) */
+    port: number;
+    /** Transport configurations keyed by transport name */
+    transports: Record<string, TransportConfig>;
+}

package/dist/core/types.js

@@ -0,0 +1,4 @@
+// @mostajs/net — Core Types
+// ITransport interface (mirror of IDialect in @mostajs/orm)
+// Author: Dr Hamid MADANI drmdh@msn.com
+export {};

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export type { ITransport, TransportConfig, TransportInfo, TransportContext, TransportMiddleware, NetServerConfig, } from './core/types.js';
+export { loadNetConfig, getEnabledTransports, TRANSPORT_NAMES } from './core/config.js';
+export type { TransportName } from './core/config.js';
+export { getTransport, getActiveTransports, stopAllTransports } from './core/factory.js';
+export { composeMiddleware, loggingMiddleware } from './core/middleware.js';
+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';
+export { readApiKeys, writeApiKeys, generateApiKey, hashApiKey, createSubscription, revokeSubscription, validateApiKey, checkPermission, } from './auth/apikeys.js';
+export type { Subscription, ApiKeysFile } from './auth/apikeys.js';
+export { apiKeyMiddleware } from './auth/apikey-middleware.js';
+export { startServer } from './server.js';
+export type { NetServer } from './server.js';