@motiadev/stream-client 0.13.0 → 0.13.1-beta.163-660633

package/LICENSE

@@ -1,21 +1,93 @@
-MIT License
-
-Copyright (c) 2025 Motia
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE. 
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject
+to the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor's trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+**control** means ownership of substantially all the assets of an entity, or the
+power to direct its management and policies by vote, contract, or otherwise.
+Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/__mocks__/uuid.ts

@@ -0,0 +1,10 @@
+let counter = 0
+
+export const v4 = (): string => {
+  counter++
+  return `00000000-0000-0000-0000-${counter.toString().padStart(12, '0')}`
+}
+
+export default {
+  v4,
+}

package/dist/index.d.ts

@@ -0,0 +1,167 @@
+//#region src/socket-adapter.d.ts
+interface SocketAdapter {
+  connect(): void;
+  close(): void;
+  send(message: string): void;
+  isOpen(): boolean;
+  onMessage(callback: (message: string) => void): void;
+  onOpen(callback: () => void): void;
+  onClose(callback: () => void): void;
+}
+//#endregion
+//#region src/adapter-factory.d.ts
+type SocketAdapterFactory = () => SocketAdapter;
+//#endregion
+//#region src/stream.types.d.ts
+type BaseMessage = {
+  streamName: string;
+  groupId: string;
+  id?: string;
+  timestamp: number;
+};
+type JoinMessage = Omit<BaseMessage, 'timestamp'> & {
+  subscriptionId: string;
+};
+type CustomEvent = {
+  type: string;
+  data: any;
+};
+type StreamEvent<TData extends {
+  id: string;
+}> = {
+  type: 'create';
+  data: TData;
+} | {
+  type: 'update';
+  data: TData;
+} | {
+  type: 'delete';
+  data: TData;
+} | {
+  type: 'event';
+  event: CustomEvent;
+};
+type ItemStreamEvent<TData extends {
+  id: string;
+}> = StreamEvent<TData> | {
+  type: 'sync';
+  data: TData;
+};
+type GroupStreamEvent<TData extends {
+  id: string;
+}> = StreamEvent<TData> | {
+  type: 'sync';
+  data: TData[];
+};
+type ItemEventMessage<TData extends {
+  id: string;
+}> = BaseMessage & {
+  event: ItemStreamEvent<TData>;
+};
+type GroupEventMessage<TData extends {
+  id: string;
+}> = BaseMessage & {
+  event: GroupStreamEvent<TData>;
+};
+type Message = {
+  type: 'join' | 'leave';
+  data: JoinMessage;
+};
+type Listener<TData> = (state: TData | null) => void;
+type CustomEventListener<TData> = (event: TData) => void;
+//#endregion
+//#region src/stream-subscription.d.ts
+type CustomEventListener$1 = (event: any) => void;
+declare abstract class StreamSubscription<TData = unknown, TEventData = unknown> {
+  private customEventListeners;
+  private closeListeners;
+  private onChangeListeners;
+  private state;
+  readonly sub: JoinMessage;
+  constructor(sub: JoinMessage, state: TData);
+  abstract listener(message: TEventData): void;
+  protected onEventReceived(event: CustomEvent): void;
+  /**
+   * Add a custom event listener. This listener will be called whenever the custom event is received.
+   */
+  onEvent(type: string, listener: CustomEventListener$1): void;
+  /**
+   * Remove a custom event listener.
+   */
+  offEvent(type: string, listener: CustomEventListener$1): void;
+  onClose(listener: () => void): void;
+  close(): void;
+  /**
+   * Add a change listener. This listener will be called whenever the state of the group changes.
+   */
+  addChangeListener(listener: Listener<TData>): void;
+  /**
+   * Remove a change listener.
+   */
+  removeChangeListener(listener: Listener<TData>): void;
+  /**
+   * Get the current state of the group.
+   */
+  getState(): TData;
+  protected setState(state: TData): void;
+}
+//#endregion
+//#region src/stream-group.d.ts
+declare class StreamGroupSubscription<TData extends {
+  id: string;
+}> extends StreamSubscription<TData[], GroupEventMessage<TData>> {
+  private sortKey?;
+  private lastTimestamp;
+  private lastTimestampMap;
+  constructor(sub: JoinMessage, sortKey?: keyof TData | undefined);
+  private sort;
+  protected setState(state: TData[]): void;
+  listener(message: GroupEventMessage<TData>): void;
+}
+//#endregion
+//#region src/stream-item.d.ts
+declare class StreamItemSubscription<TData extends {
+  id: string;
+}> extends StreamSubscription<TData | null, ItemEventMessage<TData>> {
+  private lastEventTimestamp;
+  constructor(sub: JoinMessage);
+  listener(message: ItemEventMessage<TData>): void;
+}
+//#endregion
+//#region src/stream.d.ts
+declare class Stream {
+  private adapterFactory;
+  private ws;
+  private listeners;
+  constructor(adapterFactory: SocketAdapterFactory);
+  createSocket(): SocketAdapter;
+  /**
+   * Subscribe to an item in a stream.
+   *
+   * @argument streamName - The name of the stream to subscribe to.
+   * @argument groupId - The id of the group to subscribe to.
+   * @argument id - The id of the item to subscribe to.
+   */
+  subscribeItem<TData extends {
+    id: string;
+  }>(streamName: string, groupId: string, id: string): StreamItemSubscription<TData>;
+  /**
+   * Subscribe to a group in a stream.
+   *
+   * @argument streamName - The name of the stream to subscribe to.
+   * @argument groupId - The id of the group to subscribe to.
+   */
+  subscribeGroup<TData extends {
+    id: string;
+  }>(streamName: string, groupId: string, sortKey?: keyof TData): StreamGroupSubscription<TData>;
+  close(): void;
+  private onSocketClose;
+  private onSocketOpen;
+  messageListener(event: string): void;
+  private subscribe;
+  private join;
+  private leave;
+  private roomName;
+}
+//#endregion
+export { BaseMessage, CustomEvent, CustomEventListener, GroupEventMessage, GroupStreamEvent, ItemEventMessage, ItemStreamEvent, JoinMessage, Listener, Message, type SocketAdapter, type SocketAdapterFactory, Stream, StreamEvent, StreamGroupSubscription, StreamItemSubscription, StreamSubscription };

package/dist/index.js

@@ -0,0 +1,230 @@
+import { v4 } from "uuid";
+
+//#region src/stream-subscription.ts
+var StreamSubscription = class {
+	constructor(sub, state) {
+		this.customEventListeners = /* @__PURE__ */ new Map();
+		this.closeListeners = /* @__PURE__ */ new Set();
+		this.onChangeListeners = /* @__PURE__ */ new Set();
+		this.sub = sub;
+		this.state = state;
+	}
+	onEventReceived(event) {
+		const customEventListeners = this.customEventListeners.get(event.type);
+		if (customEventListeners) {
+			const eventData = event.data;
+			customEventListeners.forEach((listener) => listener(eventData));
+		}
+	}
+	/**
+	* Add a custom event listener. This listener will be called whenever the custom event is received.
+	*/
+	onEvent(type, listener) {
+		const listeners = this.customEventListeners.get(type) || [];
+		this.customEventListeners.set(type, [...listeners, listener]);
+	}
+	/**
+	* Remove a custom event listener.
+	*/
+	offEvent(type, listener) {
+		const listeners = this.customEventListeners.get(type) || [];
+		this.customEventListeners.set(type, listeners.filter((l) => l !== listener));
+	}
+	onClose(listener) {
+		this.closeListeners.add(listener);
+	}
+	close() {
+		this.closeListeners.forEach((listener) => listener());
+		this.closeListeners.clear();
+	}
+	/**
+	* Add a change listener. This listener will be called whenever the state of the group changes.
+	*/
+	addChangeListener(listener) {
+		this.onChangeListeners.add(listener);
+	}
+	/**
+	* Remove a change listener.
+	*/
+	removeChangeListener(listener) {
+		this.onChangeListeners.delete(listener);
+	}
+	/**
+	* Get the current state of the group.
+	*/
+	getState() {
+		return this.state;
+	}
+	setState(state) {
+		this.state = state;
+		this.onChangeListeners.forEach((listener) => listener(state));
+	}
+};
+
+//#endregion
+//#region src/stream-group.ts
+var StreamGroupSubscription = class extends StreamSubscription {
+	constructor(sub, sortKey) {
+		super(sub, []);
+		this.sortKey = sortKey;
+		this.lastTimestamp = 0;
+		this.lastTimestampMap = /* @__PURE__ */ new Map();
+	}
+	sort(state) {
+		const sortKey = this.sortKey;
+		if (sortKey) return state.sort((a, b) => {
+			const aValue = a[sortKey];
+			const bValue = b[sortKey];
+			if (aValue && bValue) return aValue.toString().localeCompare(bValue.toString());
+			return 0;
+		});
+		return state;
+	}
+	setState(state) {
+		super.setState(this.sort(state));
+	}
+	listener(message) {
+		if (message.event.type === "sync") {
+			if (message.timestamp < this.lastTimestamp) return;
+			this.lastTimestampMap = /* @__PURE__ */ new Map();
+			this.lastTimestamp = message.timestamp;
+			this.setState(message.event.data);
+		} else if (message.event.type === "create") {
+			const id = message.event.data.id;
+			const state = this.getState();
+			if (!state.find((item) => item.id === id)) this.setState([...state, message.event.data]);
+		} else if (message.event.type === "update") {
+			const messageData = message.event.data;
+			const messageDataId = messageData.id;
+			const state = this.getState();
+			const currentItemTimestamp = this.lastTimestampMap.get(messageDataId);
+			if (currentItemTimestamp && currentItemTimestamp >= message.timestamp) return;
+			this.lastTimestamp = message.timestamp;
+			this.lastTimestampMap.set(messageDataId, message.timestamp);
+			this.setState(state.map((item) => item.id === messageDataId ? messageData : item));
+		} else if (message.event.type === "delete") {
+			const messageDataId = message.event.data.id;
+			const state = this.getState();
+			this.lastTimestamp = message.timestamp;
+			this.lastTimestampMap.set(messageDataId, message.timestamp);
+			this.setState(state.filter((item) => item.id !== messageDataId));
+		} else if (message.event.type === "event") this.onEventReceived(message.event.event);
+	}
+};
+
+//#endregion
+//#region src/stream-item.ts
+var StreamItemSubscription = class extends StreamSubscription {
+	constructor(sub) {
+		super(sub, null);
+		this.lastEventTimestamp = 0;
+	}
+	listener(message) {
+		if (message.timestamp <= this.lastEventTimestamp) return;
+		this.lastEventTimestamp = message.timestamp;
+		if (message.event.type === "sync" || message.event.type === "create" || message.event.type === "update") this.setState(message.event.data);
+		else if (message.event.type === "delete") this.setState(null);
+		else if (message.event.type === "event") this.onEventReceived(message.event.event);
+	}
+};
+
+//#endregion
+//#region src/stream.ts
+var Stream = class {
+	constructor(adapterFactory) {
+		this.adapterFactory = adapterFactory;
+		this.listeners = {};
+		this.ws = this.createSocket();
+	}
+	createSocket() {
+		this.ws = this.adapterFactory();
+		this.ws.onMessage((message) => this.messageListener(message));
+		this.ws.onOpen(() => this.onSocketOpen());
+		this.ws.onClose(() => this.onSocketClose());
+		return this.ws;
+	}
+	/**
+	* Subscribe to an item in a stream.
+	*
+	* @argument streamName - The name of the stream to subscribe to.
+	* @argument groupId - The id of the group to subscribe to.
+	* @argument id - The id of the item to subscribe to.
+	*/
+	subscribeItem(streamName, groupId, id) {
+		const subscription = new StreamItemSubscription({
+			streamName,
+			groupId,
+			id,
+			subscriptionId: v4()
+		});
+		this.subscribe(subscription);
+		return subscription;
+	}
+	/**
+	* Subscribe to a group in a stream.
+	*
+	* @argument streamName - The name of the stream to subscribe to.
+	* @argument groupId - The id of the group to subscribe to.
+	*/
+	subscribeGroup(streamName, groupId, sortKey) {
+		const subscription = new StreamGroupSubscription({
+			streamName,
+			groupId,
+			subscriptionId: v4()
+		}, sortKey);
+		this.subscribe(subscription);
+		return subscription;
+	}
+	close() {
+		this.listeners = {};
+		this.ws.close();
+	}
+	onSocketClose() {
+		setTimeout(() => this.createSocket(), 2e3);
+	}
+	onSocketOpen() {
+		Object.values(this.listeners).forEach((listeners) => {
+			listeners.forEach((subscription) => this.join(subscription));
+		});
+	}
+	messageListener(event) {
+		const message = JSON.parse(event);
+		const room = this.roomName(message);
+		this.listeners[room]?.forEach((listener) => listener.listener(message));
+		if (message.id && message.event.type !== "sync") {
+			const groupRoom = this.roomName({
+				streamName: message.streamName,
+				groupId: message.groupId
+			});
+			this.listeners[groupRoom]?.forEach((listener) => listener.listener(message));
+		}
+	}
+	subscribe(subscription) {
+		const room = this.roomName(subscription.sub);
+		if (!this.listeners[room]) this.listeners[room] = /* @__PURE__ */ new Set();
+		this.listeners[room].add(subscription);
+		this.join(subscription);
+		subscription.onClose(() => {
+			this.listeners[room]?.delete(subscription);
+			this.leave(subscription);
+		});
+	}
+	join(subscription) {
+		if (this.ws.isOpen()) this.ws.send(JSON.stringify({
+			type: "join",
+			data: subscription.sub
+		}));
+	}
+	leave(subscription) {
+		if (this.ws.isOpen()) this.ws.send(JSON.stringify({
+			type: "leave",
+			data: subscription.sub
+		}));
+	}
+	roomName(message) {
+		return message.id ? `${message.streamName}:group:${message.groupId}:item:${message.id}` : `${message.streamName}:group:${message.groupId}`;
+	}
+};
+
+//#endregion
+export { Stream, StreamGroupSubscription, StreamItemSubscription, StreamSubscription };

package/package.json

@@ -1,35 +1,30 @@
 {
   "name": "@motiadev/stream-client",
   "description": "Motia Stream Client Package – Responsible for managing streams of data.",
-  "version": "0.13.0",
-  "license": "MIT",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/types/index.d.ts",
-  "exports": {
-    ".": {
-      "require": "./dist/cjs/index.js",
-      "import": "./dist/esm/index.js",
-      "types": "./dist/types/index.d.ts"
-    },
-    "./workbench": {
-      "require": "./dist/cjs/workbench.js",
-      "import": "./dist/esm/workbench.js",
-      "types": "./dist/types/workbench.d.ts"
-    }
-  },
+  "version": "0.13.1-beta.163-660633",
+  "license": "Elastic-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "uuid": "^11.1.0"
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^30.0.0",
     "@types/ws": "^8.18.1",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.3.2",
-    "typescript": "^5.7.2"
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.5",
+    "tsdown": "^0.16.6",
+    "typescript": "^5.9.3"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "sh scripts/build.sh",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "lint": "eslint --config ../../eslint.config.js",
     "test": "jest"
   }

package/tsdown.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: {
+    index: './index.ts',
+  },
+  format: 'esm',
+  platform: 'neutral',
+  external: ['uuid'],
+  dts: {
+    build: true,
+  },
+  clean: true,
+  outDir: 'dist',
+  exports: {
+    devExports: 'development',
+  },
+})

package/dist/cjs/__tests__/stream-group.spec.d.ts

@@ -1 +0,0 @@
-export {};