@veloxts/events 0.6.86 → 0.6.88

package/GUIDE.md

@@ -1,81 +1,197 @@
 # @veloxts/events Guide
 
-## Drivers
+Real-time event broadcasting for VeloxTS applications using WebSocket or Server-Sent Events (SSE).
+
+## Installation
+
+```bash
+pnpm add @veloxts/events
+```
 
-### WebSocket Driver
+## Quick Start
 
-Real-time broadcasting via WebSocket. Supports Redis pub/sub for horizontal scaling.
+### Single Instance (Development)
 
 ```typescript
+import { veloxApp } from '@veloxts/core';
 import { eventsPlugin } from '@veloxts/events';
 
-// Basic setup (single instance)
-app.use(eventsPlugin({
+const app = veloxApp();
+
+app.register(eventsPlugin({
   driver: 'ws',
-  config: {
-    path: '/ws',
-    pingInterval: 30000,
-  },
+  path: '/ws',
 }));
 
-// With Redis for horizontal scaling
-app.use(eventsPlugin({
+await app.start();
+```
+
+### Multiple Instances (Production with Redis)
+
+For horizontal scaling across multiple server instances, enable Redis pub/sub:
+
+```typescript
+import { veloxApp } from '@veloxts/core';
+import { eventsPlugin } from '@veloxts/events';
+
+const app = veloxApp();
+
+app.register(eventsPlugin({
   driver: 'ws',
-  config: {
-    path: '/ws',
-    redis: process.env.REDIS_URL,
+  path: '/ws',
+  redis: process.env.REDIS_URL,
+  authSecret: process.env.EVENTS_SECRET,
+  authorizer: async (channel, request) => {
+    if (channel.type === 'public') {
+      return { authorized: true };
+    }
+
+    const user = request.user;
+    if (!user) {
+      return { authorized: false, error: 'Authentication required' };
+    }
+
+    if (channel.type === 'presence') {
+      return {
+        authorized: true,
+        member: { id: user.id, info: { name: user.name } },
+      };
+    }
+
+    return { authorized: true };
   },
 }));
+
+await app.start();
+```
+
+**Environment Variables:**
+
+```bash
+# .env
+REDIS_URL=redis://localhost:6379
+EVENTS_SECRET=your-32-char-secret-for-signing-tokens
+```
+
+## Drivers
+
+### WebSocket Driver (Recommended)
+
+Real-time bidirectional communication. Supports Redis pub/sub for horizontal scaling.
+
+```typescript
+app.register(eventsPlugin({
+  driver: 'ws',
+  path: '/ws',
+  redis: process.env.REDIS_URL,     // Optional: for horizontal scaling
+  authSecret: process.env.EVENTS_SECRET,  // Required for private/presence channels
+  pingInterval: 30000,               // Keep-alive interval (default: 30s)
+  maxPayloadSize: 1048576,           // Max message size (default: 1MB)
+}));
+```
+
+### SSE Driver (Fallback)
+
+Unidirectional server-to-client streaming. Use when WebSocket isn't available.
+
+```typescript
+app.register(eventsPlugin({
+  driver: 'sse',
+  path: '/events',
+  heartbeatInterval: 15000,  // Keep-alive interval (default: 15s)
+  retryInterval: 3000,       // Client reconnect delay (default: 3s)
+}));
 ```
 
 ## Broadcasting Events
 
+### In Procedures
+
 ```typescript
-// Broadcast to a channel
-await ctx.broadcast({
-  channel: 'orders.123',
-  event: 'order.shipped',
-  data: { trackingNumber: 'TRACK123' },
+import { procedure, procedures } from '@veloxts/router';
+import { z } from 'zod';
+
+export const orderProcedures = procedures('orders', {
+  createOrder: procedure()
+    .input(z.object({ productId: z.string(), quantity: z.number() }))
+    .mutation(async ({ input, ctx }) => {
+      const order = await ctx.db.order.create({ data: input });
+
+      // Broadcast to public channel
+      await ctx.events.broadcast('orders', 'order.created', {
+        orderId: order.id,
+        total: order.total,
+      });
+
+      // Broadcast to user's private channel
+      await ctx.events.broadcast(
+        `private-user.${ctx.user.id}`,
+        'order.confirmed',
+        order
+      );
+
+      return order;
+    }),
 });
+```
 
-// Broadcast to all except sender
-await ctx.broadcast({
-  channel: 'chat.room-1',
-  event: 'message',
-  data: { text: 'Hello!' },
-  except: ctx.socketId,  // Exclude sender
-});
+### Broadcasting Methods
+
+```typescript
+// Basic broadcast
+await ctx.events.broadcast('channel', 'event-name', { data: 'value' });
+
+// Broadcast to multiple channels
+await ctx.events.broadcastToMany(
+  ['user.1', 'user.2', 'user.3'],
+  'notification',
+  { message: 'System maintenance scheduled' }
+);
+
+// Broadcast to all except sender (e.g., chat messages)
+await ctx.events.broadcastExcept(
+  'chat.room-1',
+  'message.sent',
+  { text: 'Hello!' },
+  senderSocketId
+);
 ```
 
 ## Channel Types
 
 ### Public Channels
 
-Anyone can subscribe.
+Anyone can subscribe. No prefix required.
 
 ```typescript
 // Server
-await ctx.broadcast({
-  channel: 'announcements',
-  event: 'new-feature',
-  data: { title: 'New Feature!' },
+await ctx.events.broadcast('announcements', 'new-feature', {
+  title: 'Dark Mode Released!',
 });
 
 // Client
-socket.subscribe('announcements');
+socket.send(JSON.stringify({
+  type: 'subscribe',
+  channel: 'announcements',
+}));
 ```
 
 ### Private Channels
 
-Require authorization. Prefix with `private-`.
+Require authentication. Prefix with `private-`.
 
 ```typescript
-// Server - requires authorization middleware
-await ctx.broadcast({
-  channel: 'private-user.123',
-  event: 'notification',
-  data: { message: 'You have a new message' },
+// Server - only authorized users receive
+await ctx.events.broadcast('private-user.123', 'notification', {
+  message: 'You have a new message',
 });
+
+// Client - subscription requires auth token
+socket.send(JSON.stringify({
+  type: 'subscribe',
+  channel: 'private-user.123',
+  auth: authToken,  // Obtained from /ws/auth endpoint
+}));
 ```
 
 ### Presence Channels
@@ -84,64 +200,158 @@ Track who's online. Prefix with `presence-`.
 
 ```typescript
 // Server
-await ctx.broadcast({
-  channel: 'presence-chat.room-1',
-  event: 'typing',
-  data: { userId: '123' },
+await ctx.events.broadcast('presence-chat.room-1', 'typing', {
+  userId: '123',
+  userName: 'Alice',
 });
 
-// Client receives member_added/member_removed events automatically
+// Get who's online
+const members = await ctx.events.presenceMembers('presence-chat.room-1');
+// [{ id: '123', info: { name: 'Alice' } }, { id: '456', info: { name: 'Bob' } }]
+
+// Client - receives member_added/member_removed automatically
+socket.send(JSON.stringify({
+  type: 'subscribe',
+  channel: 'presence-chat.room-1',
+  data: { id: 'user-123', name: 'Alice' },
+  auth: authToken,
+}));
+```
+
+## Channel Authorization
+
+Configure the `authorizer` callback to control channel access:
+
+```typescript
+app.register(eventsPlugin({
+  driver: 'ws',
+  path: '/ws',
+  authSecret: process.env.EVENTS_SECRET,
+  authorizer: async (channel, request) => {
+    // Public channels - allow all
+    if (channel.type === 'public') {
+      return { authorized: true };
+    }
+
+    // Get user from request (set by @veloxts/auth)
+    const user = request.user;
+    if (!user) {
+      return { authorized: false, error: 'Not authenticated' };
+    }
+
+    // Private user channels - only owner can subscribe
+    if (channel.name.startsWith('private-user.')) {
+      const channelUserId = channel.name.replace('private-user.', '');
+      if (channelUserId !== user.id) {
+        return { authorized: false, error: 'Access denied' };
+      }
+    }
+
+    // Presence channels - include member info
+    if (channel.type === 'presence') {
+      return {
+        authorized: true,
+        member: {
+          id: user.id,
+          info: { name: user.name, avatar: user.avatar },
+        },
+      };
+    }
+
+    return { authorized: true };
+  },
+}));
 ```
 
 ## Client Integration
 
-### Browser Client
+### WebSocket Client (Browser)
 
 ```typescript
 const socket = new WebSocket('ws://localhost:3030/ws');
 
+// Connection established
 socket.onopen = () => {
-  // Subscribe to channel
+  console.log('Connected');
+
+  // Subscribe to public channel
   socket.send(JSON.stringify({
     type: 'subscribe',
-    channel: 'orders.123',
+    channel: 'orders',
   }));
 };
 
+// Receive messages
 socket.onmessage = (event) => {
   const message = JSON.parse(event.data);
 
-  if (message.type === 'event') {
-    console.log(`${message.event}:`, message.data);
+  switch (message.type) {
+    case 'event':
+      console.log(`${message.event}:`, message.data);
+      break;
+    case 'subscription_succeeded':
+      console.log(`Subscribed to ${message.channel}`);
+      break;
+    case 'subscription_error':
+      console.error(`Failed to subscribe: ${message.error}`);
+      break;
   }
 };
 
 // Unsubscribe
 socket.send(JSON.stringify({
   type: 'unsubscribe',
-  channel: 'orders.123',
+  channel: 'orders',
 }));
+
+// Handle reconnection
+socket.onclose = () => {
+  console.log('Disconnected, reconnecting...');
+  setTimeout(() => reconnect(), 3000);
+};
 ```
 
-### Presence Channels (Client)
+### Private Channel Authentication (Browser)
 
 ```typescript
-// Join with user info
-socket.send(JSON.stringify({
-  type: 'subscribe',
-  channel: 'presence-chat.room-1',
-  data: { id: '123', name: 'John' },
-}));
+async function subscribeToPrivateChannel(socket, channel) {
+  // Get auth token from server
+  const response = await fetch('/ws/auth', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    credentials: 'include',  // Send session cookie
+    body: JSON.stringify({
+      socketId: socket.socketId,
+      channel,
+    }),
+  });
+
+  const { auth, channel_data } = await response.json();
+
+  // Subscribe with auth
+  socket.send(JSON.stringify({
+    type: 'subscribe',
+    channel,
+    auth,
+    channel_data,
+  }));
+}
+```
+
+### Presence Channel Events
 
-// Handle presence events
+```typescript
 socket.onmessage = (event) => {
   const message = JSON.parse(event.data);
 
   if (message.event === 'member_added') {
     console.log('User joined:', message.data);
+    // { id: '123', info: { name: 'Alice' } }
   }
+
   if (message.event === 'member_removed') {
     console.log('User left:', message.data);
+    // { id: '123' }
   }
 };
 ```
@@ -149,51 +359,92 @@ socket.onmessage = (event) => {
 ## Server API
 
 ```typescript
-// Get subscribers for a channel
-const subscribers = await ctx.events.getSubscribers('orders.123');
+// Get subscriber count
+const count = await ctx.events.subscriberCount('orders');
+
+// Check if channel has subscribers
+const hasSubscribers = await ctx.events.hasSubscribers('orders');
+
+// Get all active channels
+const channels = await ctx.events.channels();
 
 // Get presence members
-const members = await ctx.events.getPresenceMembers('presence-chat.room-1');
+const members = await ctx.events.presenceMembers('presence-chat.room-1');
+```
 
-// Get connection count
-const count = await ctx.events.getConnectionCount('orders.123');
+## Scaling with Redis
 
-// Get all active channels
-const channels = await ctx.events.getChannels();
+For multi-instance deployments behind a load balancer:
+
+```
+┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
+│   Instance 1    │     │   Instance 2    │     │   Instance 3    │
+│   WebSocket     │     │   WebSocket     │     │   WebSocket     │
+│   Driver        │     │   Driver        │     │   Driver        │
+└────────┬────────┘     └────────┬────────┘     └────────┬────────┘
+         │                       │                       │
+         └───────────────────────┼───────────────────────┘
+                                 │
+                    ┌────────────▼────────────┐
+                    │         Redis           │
+                    │       (pub/sub)         │
+                    └─────────────────────────┘
 ```
 
-## HTTP Upgrade (Manual Setup)
+When you call `ctx.events.broadcast()`:
+1. Event is sent to local WebSocket clients
+2. Event is published to Redis
+3. Other instances receive from Redis
+4. Each instance delivers to its local clients
 
-If not using the plugin, handle WebSocket upgrade manually:
+**Configuration:**
 
 ```typescript
-import { createWsDriver } from '@veloxts/events';
+app.register(eventsPlugin({
+  driver: 'ws',
+  path: '/ws',
+  redis: process.env.REDIS_URL,  // e.g., "redis://localhost:6379"
+}));
+```
 
-const events = await createWsDriver({ path: '/ws' });
+## Standalone Usage
 
-// In your HTTP server
-server.on('upgrade', (request, socket, head) => {
-  if (request.url === '/ws') {
-    events.handleUpgrade(request, socket, head);
-  }
+Use events outside of Fastify request context (background jobs, CLI, scripts):
+
+```typescript
+import { getEvents, closeEvents } from '@veloxts/events';
+
+// Get standalone instance
+const events = await getEvents({
+  driver: 'ws',
+  redis: process.env.REDIS_URL,
 });
+
+// Broadcast from background job
+await events.broadcast('jobs', 'job.completed', { jobId: '123' });
+
+// Clean up on shutdown
+await closeEvents();
 ```
 
-## Scaling with Redis
+## Testing
 
-For multi-instance deployments, events are broadcast via Redis pub/sub:
+For integration tests with Redis pub/sub, use testcontainers:
 
 ```typescript
-app.use(eventsPlugin({
+import { startRedisContainer } from '@veloxts/testing';
+import { createWsDriver } from '@veloxts/events';
+
+const redis = await startRedisContainer();
+
+const driver = await createWsDriver({
   driver: 'ws',
-  config: {
-    path: '/ws',
-    redis: process.env.REDIS_URL,
-  },
-}));
-```
+  path: '/ws',
+  redis: redis.url,
+});
 
-All instances subscribe to a shared Redis channel. When you broadcast:
-1. Event is sent to local WebSocket clients
-2. Event is published to Redis
-3. Other instances receive from Redis and broadcast to their clients
+// Run tests...
+
+await driver.close();
+await redis.stop();
+```

package/dist/index.d.ts

@@ -40,7 +40,7 @@ export { type ChannelAuthSigner, createChannelAuthSigner } from './auth.js';
 export { createSseDriver, DRIVER_NAME as SSE_DRIVER } from './drivers/sse.js';
 export { createWsDriver, DRIVER_NAME as WS_DRIVER } from './drivers/ws.js';
 export { createEventsManager, createManagerFromDriver, type EventsManager, events, } from './manager.js';
-export { _resetStandaloneEvents, eventsPlugin, getEvents, getEventsFromInstance, } from './plugin.js';
+export { _resetStandaloneEvents, closeEvents, eventsPlugin, getEvents, getEventsFromInstance, } from './plugin.js';
 export { ClientMessageSchema, formatValidationErrors, PresenceMemberSchema, SseSubscribeBodySchema, SseUnsubscribeBodySchema, type ValidationResult, validateBody, WsAuthBodySchema, } from './schemas.js';
 export type { BroadcastDriver, BroadcastEvent, Channel, ChannelAuthorizer, ChannelAuthResult, ChannelType, ClientConnection, ClientMessage, EventsBaseOptions, EventsDefaultOptions, EventsManagerOptions, EventsPluginOptions, EventsSseOptions, EventsWsOptions, PresenceMember, ServerMessage, Subscription, } from './types.js';
 /**

package/dist/index.js

@@ -44,7 +44,7 @@ export { createWsDriver, DRIVER_NAME as WS_DRIVER } from './drivers/ws.js';
 // Manager
 export { createEventsManager, createManagerFromDriver, events, } from './manager.js';
 // Plugin
-export { _resetStandaloneEvents, eventsPlugin, getEvents, getEventsFromInstance, } from './plugin.js';
+export { _resetStandaloneEvents, closeEvents, eventsPlugin, getEvents, getEventsFromInstance, } from './plugin.js';
 // Schemas (for validation)
 export { ClientMessageSchema, formatValidationErrors, PresenceMemberSchema, SseSubscribeBodySchema, SseUnsubscribeBodySchema, validateBody, WsAuthBodySchema, } from './schemas.js';
 // ============================================================================

package/dist/plugin.d.ts

@@ -7,6 +7,22 @@
 import type { FastifyInstance } from 'fastify';
 import '@veloxts/core';
 import type { EventsManager, EventsPluginOptions } from './types.js';
+/**
+ * Symbol for accessing events manager from Fastify instance.
+ * Using a symbol prevents naming conflicts with other plugins.
+ */
+declare const EVENTS_KEY: unique symbol;
+/**
+ * Extend Fastify types with events manager.
+ */
+declare module 'fastify' {
+    interface FastifyInstance {
+        [EVENTS_KEY]?: EventsManager;
+    }
+    interface FastifyRequest {
+        events?: EventsManager;
+    }
+}
 /**
  * Extend BaseContext with events manager.
  *
@@ -98,8 +114,25 @@ export declare function getEventsFromInstance(fastify: FastifyInstance): EventsM
  * ```
  */
 export declare function getEvents(options?: EventsPluginOptions): Promise<EventsManager>;
+/**
+ * Close the standalone events instance.
+ *
+ * Call this when shutting down your application to close all connections.
+ *
+ * @example
+ * ```typescript
+ * import { closeEvents } from '@veloxts/events';
+ *
+ * // On shutdown
+ * await closeEvents();
+ * ```
+ */
+export declare function closeEvents(): Promise<void>;
 /**
  * Reset the standalone events instance.
  * Primarily used for testing.
+ *
+ * @deprecated Use `closeEvents()` instead. Will be removed in v2.0.
  */
 export declare function _resetStandaloneEvents(): Promise<void>;
+export {};

package/dist/plugin.js

@@ -14,6 +14,7 @@ import { createManagerFromDriver } from './manager.js';
 import { formatValidationErrors, SseSubscribeBodySchema, SseUnsubscribeBodySchema, validateBody, WsAuthBodySchema, } from './schemas.js';
 /**
  * Symbol for accessing events manager from Fastify instance.
+ * Using a symbol prevents naming conflicts with other plugins.
  */
 const EVENTS_KEY = Symbol.for('velox.events');
 /**
@@ -149,13 +150,18 @@ export function eventsPlugin(options = {}) {
         }
         // Create events manager
         const events = createManagerFromDriver(driver);
-        // Store on fastify instance
-        fastify[EVENTS_KEY] = events;
-        // Decorate request with events accessor
-        fastify.decorateRequest('events', {
-            getter() {
-                return events;
-            },
+        // Store on fastify instance using Object.defineProperty for type safety
+        Object.defineProperty(fastify, EVENTS_KEY, {
+            value: events,
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+        // Decorate request with events accessor (matching cache/mail/queue/storage pattern)
+        fastify.decorateRequest('events', undefined);
+        // Add events to request context
+        fastify.addHook('onRequest', async (request) => {
+            request.events = events;
         });
         // Register cleanup hook
         fastify.addHook('onClose', async () => {
@@ -192,7 +198,9 @@ function parseChannel(name) {
  * ```
  */
 export function getEventsFromInstance(fastify) {
-    const events = fastify[EVENTS_KEY];
+    // Type-safe property access using Object.getOwnPropertyDescriptor
+    const descriptor = Object.getOwnPropertyDescriptor(fastify, EVENTS_KEY);
+    const events = descriptor?.value;
     if (!events) {
         throw new Error('Events plugin not registered. Register it with: app.register(eventsPlugin, { ... })');
     }
@@ -231,12 +239,30 @@ export async function getEvents(options) {
     return standaloneEvents;
 }
 /**
- * Reset the standalone events instance.
- * Primarily used for testing.
+ * Close the standalone events instance.
+ *
+ * Call this when shutting down your application to close all connections.
+ *
+ * @example
+ * ```typescript
+ * import { closeEvents } from '@veloxts/events';
+ *
+ * // On shutdown
+ * await closeEvents();
+ * ```
  */
-export async function _resetStandaloneEvents() {
+export async function closeEvents() {
     if (standaloneEvents) {
         await standaloneEvents.close();
         standaloneEvents = null;
     }
 }
+/**
+ * Reset the standalone events instance.
+ * Primarily used for testing.
+ *
+ * @deprecated Use `closeEvents()` instead. Will be removed in v2.0.
+ */
+export async function _resetStandaloneEvents() {
+    await closeEvents();
+}

package/dist/schemas.d.ts

@@ -35,15 +35,15 @@ export declare const SseSubscribeBodySchema: z.ZodObject<{
         info?: Record<string, unknown> | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    channel: string;
     connectionId: string;
+    channel: string;
     member?: {
         id: string;
         info?: Record<string, unknown> | undefined;
     } | undefined;
 }, {
-    channel: string;
     connectionId: string;
+    channel: string;
     member?: {
         id: string;
         info?: Record<string, unknown> | undefined;
@@ -58,11 +58,11 @@ export declare const SseUnsubscribeBodySchema: z.ZodObject<{
     connectionId: z.ZodString;
     channel: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    channel: string;
     connectionId: string;
-}, {
     channel: string;
+}, {
     connectionId: string;
+    channel: string;
 }>;
 export type SseUnsubscribeBody = z.infer<typeof SseUnsubscribeBodySchema>;
 /**
@@ -100,32 +100,32 @@ export declare const ClientMessageSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
         info?: Record<string, unknown> | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    type: "subscribe";
     channel: string;
+    type: "subscribe";
+    auth?: string | undefined;
     data?: {
         id: string;
         info?: Record<string, unknown> | undefined;
     } | undefined;
-    auth?: string | undefined;
     channelData?: string | undefined;
 }, {
-    type: "subscribe";
     channel: string;
+    type: "subscribe";
+    auth?: string | undefined;
     data?: {
         id: string;
         info?: Record<string, unknown> | undefined;
     } | undefined;
-    auth?: string | undefined;
     channelData?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"unsubscribe">;
     channel: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    type: "unsubscribe";
     channel: string;
-}, {
     type: "unsubscribe";
+}, {
     channel: string;
+    type: "unsubscribe";
 }>, z.ZodObject<{
     type: z.ZodLiteral<"ping">;
 }, "strip", z.ZodTypeAny, {
@@ -138,14 +138,14 @@ export declare const ClientMessageSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
     event: z.ZodString;
     data: z.ZodOptional<z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
-    event: string;
-    type: "message";
     channel: string;
+    type: "message";
+    event: string;
     data?: unknown;
 }, {
-    event: string;
-    type: "message";
     channel: string;
+    type: "message";
+    event: string;
     data?: unknown;
 }>]>;
 export type ValidatedClientMessage = z.infer<typeof ClientMessageSchema>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/events",
-  "version": "0.6.86",
+  "version": "0.6.88",
   "description": "Real-time event broadcasting for VeloxTS framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,7 +30,7 @@
     "superjson": "2.2.2",
     "ws": "8.18.2",
     "zod": "3.24.4",
-    "@veloxts/core": "0.6.86"
+    "@veloxts/core": "0.6.88"
   },
   "peerDependencies": {
     "fastify": "^5.0.0",
@@ -42,18 +42,19 @@
     }
   },
   "devDependencies": {
-    "@types/node": "22.15.29",
+    "@types/node": "25.0.3",
     "@types/ws": "8.18.1",
     "@vitest/coverage-v8": "4.0.16",
     "fastify": "5.6.2",
     "ioredis": "5.6.1",
-    "typescript": "5.8.3",
+    "typescript": "5.9.3",
     "vitest": "4.0.16",
-    "@veloxts/testing": "0.6.86"
+    "@veloxts/testing": "0.6.88"
   },
   "publishConfig": {
     "access": "public"
   },
+  "homepage": "https://veloxts.dev/",
   "repository": {
     "type": "git",
     "url": "https://github.com/veloxts/velox-ts-framework.git",