alepha 0.13.0 → 0.13.2

package/src/websocket/interfaces/WebSocketInterfaces.ts

@@ -1,5 +1,5 @@
 import type { Static } from "alepha";
-import type { ChannelDescriptor, TWSObject } from "../descriptors/$channel.ts";
+import type { ChannelPrimitive, TWSObject } from "../primitives/$channel.ts";
 
 /**
  * WebSocket connection interface
@@ -54,14 +54,14 @@ export enum WebSocketState {
 /**
  * WebSocket endpoint configuration (server-side)
  */
-export interface WebSocketDescriptorOptions<
+export interface WebSocketPrimitiveOptions<
   TClient extends TWSObject,
   TServer extends TWSObject,
 > {
   /**
    * Channel definition with schema and path
    */
-  channel: ChannelDescriptor<TClient, TServer>;
+  channel: ChannelPrimitive<TClient, TServer>;
 
   /**
    * Handler for incoming messages from clients

package/src/websocket/{descriptors → primitives}/$channel.ts

@@ -1,7 +1,7 @@
 import {
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type TObject,
   type TString,
   type TUnion,
@@ -10,9 +10,9 @@ import {
 export type TWSObject = TObject | TUnion;
 
 /**
- * Channel descriptor options
+ * Channel primitive options
  */
-export interface ChannelDescriptorOptions<
+export interface ChannelPrimitiveOptions<
   TClient extends TWSObject,
   TServer extends TWSObject,
 > {
@@ -114,18 +114,18 @@ export interface ChannelDescriptorOptions<
  * ```
  */
 export const $channel = <TClient extends TWSObject, TServer extends TWSObject>(
-  options: ChannelDescriptorOptions<TClient, TServer>,
-): ChannelDescriptor<TClient, TServer> => {
-  return createDescriptor(ChannelDescriptor<TClient, TServer>, options);
+  options: ChannelPrimitiveOptions<TClient, TServer>,
+): ChannelPrimitive<TClient, TServer> => {
+  return createPrimitive(ChannelPrimitive<TClient, TServer>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class ChannelDescriptor<
+export class ChannelPrimitive<
   TClient extends TWSObject,
   TServer extends TWSObject,
-> extends Descriptor<ChannelDescriptorOptions<TClient, TServer>> {
+> extends Primitive<ChannelPrimitiveOptions<TClient, TServer>> {
   // Channels are just schema definitions - no initialization logic needed
 }
 
-$channel[KIND] = ChannelDescriptor;
+$channel[KIND] = ChannelPrimitive;

package/src/websocket/{descriptors → primitives}/$websocket.ts

@@ -1,7 +1,7 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import type {
   EmitOptions,
-  WebSocketDescriptorOptions,
+  WebSocketPrimitiveOptions,
 } from "../interfaces/WebSocketInterfaces.ts";
 import { WebSocketServerProvider } from "../providers/WebSocketServerProvider.ts";
 import type { TWSObject } from "./$channel.ts";
@@ -51,17 +51,17 @@ export const $websocket = <
   TClient extends TWSObject,
   TServer extends TWSObject,
 >(
-  options: WebSocketDescriptorOptions<TClient, TServer>,
-): WebSocketDescriptor<TClient, TServer> => {
-  return createDescriptor(WebSocketDescriptor<TClient, TServer>, options);
+  options: WebSocketPrimitiveOptions<TClient, TServer>,
+): WebSocketPrimitive<TClient, TServer> => {
+  return createPrimitive(WebSocketPrimitive<TClient, TServer>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class WebSocketDescriptor<
+export class WebSocketPrimitive<
   TClient extends TWSObject,
   TServer extends TWSObject,
-> extends Descriptor<WebSocketDescriptorOptions<TClient, TServer>> {
+> extends Primitive<WebSocketPrimitiveOptions<TClient, TServer>> {
   protected readonly webSocketServerProvider = $inject(WebSocketServerProvider);
 
   protected onInit() {
@@ -104,4 +104,4 @@ export class WebSocketDescriptor<
   }
 }
 
-$websocket[KIND] = WebSocketDescriptor;
+$websocket[KIND] = WebSocketPrimitive;

package/src/websocket/providers/NodeWebSocketServerProvider.ts

@@ -10,15 +10,15 @@ import {
 } from "alepha";
 import { $logger } from "alepha/logger";
 import { WebSocket, WebSocketServer } from "ws";
-import type { TWSObject } from "../descriptors/$channel.ts";
 import { WebSocketValidationError } from "../errors/WebSocketError.ts";
 import type {
   EmitOptions,
   WebSocketConnection,
-  WebSocketDescriptorOptions,
   WebSocketHandlerContext,
+  WebSocketPrimitiveOptions,
   WebSocketState,
 } from "../interfaces/WebSocketInterfaces.ts";
+import type { TWSObject } from "../primitives/$channel.ts";
 import { RoomManager } from "../services/RoomManager.ts";
 import { WebSocketTopicService } from "../services/WebSocketTopicService.ts";
 import { WebSocketServerProvider } from "./WebSocketServerProvider.ts";
@@ -46,7 +46,7 @@ export class NodeWebSocketServerProvider extends WebSocketServerProvider {
   protected readonly env = $env(envSchema);
 
   protected wss?: WebSocketServer;
-  protected endpoints = new Map<string, WebSocketDescriptorOptions<any, any>>();
+  protected endpoints = new Map<string, WebSocketPrimitiveOptions<any, any>>();
   protected connections = new Map<string, WebSocketConnection>();
   protected userConnections = new Map<string, Set<string>>(); // userId → Set<connectionId>
   protected nextConnectionId = 1;
@@ -54,7 +54,7 @@ export class NodeWebSocketServerProvider extends WebSocketServerProvider {
   // -------------------------------------------------------------------------------------------------------------------
 
   public registerEndpoint<TClient extends TWSObject, TServer extends TWSObject>(
-    config: WebSocketDescriptorOptions<TClient, TServer>,
+    config: WebSocketPrimitiveOptions<TClient, TServer>,
   ): void {
     const path = config.channel.options.path;
     this.endpoints.set(path, config);
@@ -157,7 +157,7 @@ export class NodeWebSocketServerProvider extends WebSocketServerProvider {
     TServer extends TWSObject,
   >(
     ws: WebSocket,
-    endpoint: WebSocketDescriptorOptions<TClient, TServer>,
+    endpoint: WebSocketPrimitiveOptions<TClient, TServer>,
     request: IncomingMessage,
   ): void {
     const connectionId = `ws-${this.nextConnectionId++}`;
@@ -405,7 +405,7 @@ export class NodeWebSocketServerProvider extends WebSocketServerProvider {
       }
 
       // Attach upgrade handler to the HTTP server (must be done after HTTP server starts)
-      const httpServer = this.alepha.state.get("alepha.node.server");
+      const httpServer = this.alepha.store.get("alepha.node.server");
       if (httpServer) {
         httpServer.on("upgrade", (request, socket, head) => {
           this.handleUpgrade(request, socket, head);
@@ -458,7 +458,7 @@ export class NodeWebSocketConnection implements WebSocketConnection {
     public readonly roomIds: string[],
     protected readonly ws: WebSocket,
     protected readonly provider: NodeWebSocketServerProvider,
-    protected readonly endpoint: WebSocketDescriptorOptions<any, any>,
+    protected readonly endpoint: WebSocketPrimitiveOptions<any, any>,
   ) {}
 
   public get readyState(): WebSocketState {

package/src/websocket/providers/WebSocketServerProvider.ts

@@ -1,9 +1,9 @@
-import type { TWSObject } from "../descriptors/$channel.ts";
 import type {
   EmitOptions,
   WebSocketConnection,
-  WebSocketDescriptorOptions,
+  WebSocketPrimitiveOptions,
 } from "../interfaces/WebSocketInterfaces.ts";
+import type { TWSObject } from "../primitives/$channel.ts";
 
 /**
  * Abstract WebSocket server provider
@@ -18,7 +18,7 @@ export abstract class WebSocketServerProvider {
   abstract registerEndpoint<
     TClient extends TWSObject,
     TServer extends TWSObject,
-  >(config: WebSocketDescriptorOptions<TClient, TServer>): void;
+  >(config: WebSocketPrimitiveOptions<TClient, TServer>): void;
 
   /**
    * Emit a message to clients based on targeting criteria

package/src/websocket/services/WebSocketClient.ts

@@ -8,7 +8,7 @@ import {
   t,
 } from "alepha";
 import { $logger } from "alepha/logger";
-import type { ChannelDescriptor, TWSObject } from "../descriptors/$channel.ts";
+import type { ChannelPrimitive, TWSObject } from "../primitives/$channel.ts";
 
 const envSchema = t.object({
   WEBSOCKET_URL: t.text({
@@ -75,7 +75,7 @@ export class WebSocketChannelConnection<
   protected onErrorCallbacks = new Set<(error: Error) => void>();
 
   constructor(
-    protected readonly channel: ChannelDescriptor<TClient, TServer>,
+    protected readonly channel: ChannelPrimitive<TClient, TServer>,
     protected readonly options: {
       url?: string;
       autoReconnect?: boolean;
@@ -472,7 +472,7 @@ export class WebSocketClient {
    */
   public subscribe<TClient extends TWSObject, TServer extends TWSObject>(
     roomId: string,
-    channel: ChannelDescriptor<TClient, TServer>,
+    channel: ChannelPrimitive<TClient, TServer>,
     handler: (message: Static<TClient>) => void,
     options: {
       url?: string;
@@ -547,7 +547,7 @@ export class WebSocketClient {
    */
   public async send<TClient extends TWSObject, TServer extends TWSObject>(
     roomId: string,
-    channel: ChannelDescriptor<TClient, TServer>,
+    channel: ChannelPrimitive<TClient, TServer>,
     message: Static<TServer>,
   ): Promise<void> {
     const channelPath = channel.options.path;
@@ -574,7 +574,7 @@ export class WebSocketClient {
    * Get connection for a channel
    */
   public getConnection<TClient extends TWSObject, TServer extends TWSObject>(
-    channel: ChannelDescriptor<TClient, TServer>,
+    channel: ChannelPrimitive<TClient, TServer>,
   ): WebSocketChannelConnection<TClient, TServer> | undefined {
     const channelPath = channel.options.path;
     const connection = this.connections.get(channelPath) as