@actor-system/receptionist 0.0.1

package/dist/behavior.d.ts

@@ -0,0 +1,8 @@
+import { Behavior } from '@actor-system/core';
+import { Command } from './command.js';
+
+declare const behavior: {
+    <T>(): Behavior<Command<T>>;
+};
+
+export { behavior };

package/dist/behavior.internal.d.ts

@@ -0,0 +1,13 @@
+import { Behavior } from '@actor-system/core/internal';
+import { Command } from './command.internal.js';
+import { State } from './state.internal.js';
+
+declare const behavior: {
+    /** @internal */
+    <T>(state: State): Behavior<Command.Internal<T>>;
+    /** @internal */
+    <T>(): Behavior<Command.Internal<T>>;
+    <T>(): Behavior<Command<T>>;
+};
+
+export { behavior };

package/dist/behavior.js

@@ -0,0 +1,85 @@
+import * as behaviors from '@actor-system/behaviors';
+import { signal } from '@actor-system/core';
+import { isCommand, $flushNotifications, $subscribe, $lookup, $unregister, $register, flushNotifications } from './command.js';
+import { listing, unregistered, registered } from './reply.js';
+import { create } from './state.js';
+
+const behavior = (state = create()) => behaviors.setup(({ self, watch }) => {
+    const pendingNotifications = new Map();
+    const scheduleNotify = (key, subscriber) => {
+        if (state.subscribers(key).size === 0)
+            return;
+        let existing = pendingNotifications.get(key);
+        if (existing === "all")
+            return;
+        existing = existing ?? new Set();
+        existing.add(subscriber);
+        pendingNotifications.set(key, existing);
+        if (pendingNotifications.size === 1) {
+            self.tell(flushNotifications);
+        }
+    };
+    const scheduleNotifyAll = (key) => {
+        if (state.subscribers(key).size === 0)
+            return;
+        pendingNotifications.set(key, "all");
+        if (pendingNotifications.size === 1) {
+            self.tell(flushNotifications);
+        }
+    };
+    return behaviors
+        .receiveMessage((post) => {
+        if (!isCommand(post))
+            return behaviors.same;
+        switch (post.label) {
+            case $register: {
+                state.addActor(post.key, post.ref);
+                post.replyTo?.tell(registered(post.key, post.ref));
+                scheduleNotifyAll(post.key);
+                return behaviors.same;
+            }
+            case $unregister: {
+                if (state.removeActor(post.key, post.ref)) {
+                    post.replyTo?.tell(unregistered(post.key, post.ref));
+                    scheduleNotifyAll(post.key);
+                }
+                return behaviors.same;
+            }
+            case $lookup: {
+                post.replyTo.tell(listing(post.key, state.actors(post.key)));
+                return behaviors.same;
+            }
+            case $subscribe: {
+                watch(post.subscriber);
+                state.addSubscriber(post.key, post.subscriber);
+                scheduleNotify(post.key, post.subscriber);
+                return behaviors.same;
+            }
+            case $flushNotifications: {
+                for (const [serviceKey, subscribers] of pendingNotifications) {
+                    const actors = state.actors(serviceKey);
+                    const notifiedSubscribers = subscribers === "all"
+                        ? state.subscribers(serviceKey)
+                        : subscribers;
+                    for (const subscriber of notifiedSubscribers) {
+                        subscriber.tell(listing(serviceKey, actors));
+                    }
+                }
+                pendingNotifications.clear();
+                return behaviors.same;
+            }
+        }
+    })
+        .receiveSignal((post) => {
+        switch (post.label) {
+            case signal.$terminated:
+                state.removeSubscriber(post.ref);
+                break;
+            case signal.$postStop:
+                state.clear();
+                break;
+        }
+    });
+});
+
+export { behavior };

package/dist/command.d.ts

@@ -0,0 +1,42 @@
+import { ActorRef } from '@actor-system/core';
+import { ServiceKey } from './service-key.js';
+import { Letter } from '@actor-system/mail';
+import { Registered, Unregistered, Listing } from './reply.js';
+
+declare const $register = "@@receptionist.cmd.register";
+interface Register<T = unknown> extends Letter<typeof $register> {
+    readonly ref: ActorRef<T>;
+    readonly key: ServiceKey<T>;
+    readonly replyTo?: ActorRef<Registered<T>>;
+}
+declare const register: <T = unknown>(key: ServiceKey<T>, ref: NoInfer<ActorRef<T>>) => Register<T>;
+declare const isRegister: <T>(message: unknown) => message is Register<T>;
+declare const $unregister = "@@receptionist.cmd.unregister";
+interface Unregister<T = unknown> extends Letter<typeof $unregister> {
+    readonly ref: ActorRef<T>;
+    readonly key: ServiceKey<T>;
+    readonly replyTo?: ActorRef<Unregistered<T>>;
+}
+declare const unregister: <T = unknown>(key: ServiceKey<T>, ref: NoInfer<ActorRef<T>>) => Unregister<T>;
+declare const isUnregister: <T>(message: unknown) => message is Unregister<T>;
+declare const $lookup = "@@receptionist.cmd.lookup";
+interface Lookup<T = unknown> extends Letter<typeof $lookup> {
+    readonly replyTo: ActorRef<Listing<T>>;
+    readonly key: ServiceKey<T>;
+}
+declare const lookup: <T = unknown>(key: ServiceKey<T>, replyTo: NoInfer<ActorRef<Listing<T>>>) => Lookup<T>;
+declare const isLookup: <T>(message: unknown) => message is Lookup<T>;
+declare const $subscribe = "@@receptionist.cmd.subscribe";
+interface Subscribe<T = unknown> extends Letter<typeof $subscribe> {
+    readonly subscriber: ActorRef<Listing<T>>;
+    readonly key: ServiceKey<T>;
+}
+declare const subscribe: <T = unknown>(key: ServiceKey<T>, subscriber: NoInfer<ActorRef<Listing<T>>>) => Subscribe<T>;
+declare const isSubscribe: <T>(message: unknown) => message is Subscribe<T>;
+type Command<T = unknown> = Register<T> | Unregister<T> | Lookup<T> | Subscribe<T>;
+declare const isCommand: {
+    <T>(input: unknown): input is Command<T>;
+};
+
+export { $lookup, $register, $subscribe, $unregister, isCommand, isLookup, isRegister, isSubscribe, isUnregister, lookup, register, subscribe, unregister };
+export type { Command, Lookup, Register, Subscribe, Unregister };

package/dist/command.internal.d.ts

@@ -0,0 +1,58 @@
+import { ActorRef } from '@actor-system/core/internal';
+import { ServiceKey } from './service-key.internal.js';
+import { Letter } from '@actor-system/mail/internal';
+import { Registered, Unregistered, Listing } from './reply.internal.js';
+
+declare const $register = "@@receptionist.cmd.register";
+interface Register<T = unknown> extends Letter<typeof $register> {
+    readonly ref: ActorRef<T>;
+    readonly key: ServiceKey<T>;
+    readonly replyTo?: ActorRef<Registered<T>>;
+}
+declare const register: <T = unknown>(key: ServiceKey<T>, ref: NoInfer<ActorRef<T>>) => Register<T>;
+declare const isRegister: <T>(message: unknown) => message is Register<T>;
+declare const $unregister = "@@receptionist.cmd.unregister";
+interface Unregister<T = unknown> extends Letter<typeof $unregister> {
+    readonly ref: ActorRef<T>;
+    readonly key: ServiceKey<T>;
+    readonly replyTo?: ActorRef<Unregistered<T>>;
+}
+declare const unregister: <T = unknown>(key: ServiceKey<T>, ref: NoInfer<ActorRef<T>>) => Unregister<T>;
+declare const isUnregister: <T>(message: unknown) => message is Unregister<T>;
+declare const $lookup = "@@receptionist.cmd.lookup";
+interface Lookup<T = unknown> extends Letter<typeof $lookup> {
+    readonly replyTo: ActorRef<Listing<T>>;
+    readonly key: ServiceKey<T>;
+}
+declare const lookup: <T = unknown>(key: ServiceKey<T>, replyTo: NoInfer<ActorRef<Listing<T>>>) => Lookup<T>;
+declare const isLookup: <T>(message: unknown) => message is Lookup<T>;
+declare const $subscribe = "@@receptionist.cmd.subscribe";
+interface Subscribe<T = unknown> extends Letter<typeof $subscribe> {
+    readonly subscriber: ActorRef<Listing<T>>;
+    readonly key: ServiceKey<T>;
+}
+declare const subscribe: <T = unknown>(key: ServiceKey<T>, subscriber: NoInfer<ActorRef<Listing<T>>>) => Subscribe<T>;
+declare const isSubscribe: <T>(message: unknown) => message is Subscribe<T>;
+/** @internal */
+declare const $flushNotifications = "@@receptionist.cmd.flush-notifications";
+/** @internal */
+interface FlushNotifications extends Letter<typeof $flushNotifications> {
+}
+/** @internal */
+declare const flushNotifications: FlushNotifications;
+/** @internal */
+declare const isFlushNotifications: (message: unknown) => message is FlushNotifications;
+type Command<T = unknown> = Register<T> | Unregister<T> | Lookup<T> | Subscribe<T>;
+/** @internal */
+declare namespace Command {
+    /** @internal */
+    type Internal<T = unknown> = Register<T> | Unregister<T> | Lookup<T> | Subscribe<T> | FlushNotifications;
+}
+declare const isCommand: {
+    /** @internal */
+    <T>(input: unknown): input is Command.Internal<T>;
+    <T>(input: unknown): input is Command<T>;
+};
+
+export { $flushNotifications, $lookup, $register, $subscribe, $unregister, Command, flushNotifications, isCommand, isFlushNotifications, isLookup, isRegister, isSubscribe, isUnregister, lookup, register, subscribe, unregister };
+export type { FlushNotifications, Lookup, Register, Subscribe, Unregister };

package/dist/command.js

@@ -0,0 +1,25 @@
+import { letterGuard, isLetter } from '@actor-system/mail';
+
+const $register = "@@receptionist.cmd.register";
+const register = (key, ref) => ({ label: $register, key, ref });
+const isRegister = letterGuard($register);
+const $unregister = "@@receptionist.cmd.unregister";
+const unregister = (key, ref) => ({ label: $unregister, key, ref });
+const isUnregister = letterGuard($unregister);
+const $lookup = "@@receptionist.cmd.lookup";
+const lookup = (key, replyTo) => ({ label: $lookup, key, replyTo });
+const isLookup = letterGuard($lookup);
+const $subscribe = "@@receptionist.cmd.subscribe";
+const subscribe = (key, subscriber) => ({ label: $subscribe, key, subscriber });
+const isSubscribe = letterGuard($subscribe);
+/** @internal */
+const $flushNotifications = "@@receptionist.cmd.flush-notifications";
+/** @internal */
+const flushNotifications = {
+    label: $flushNotifications,
+};
+/** @internal */
+const isFlushNotifications = letterGuard($flushNotifications);
+const isCommand = (input) => isLetter(input, $lookup, $register, $subscribe, $unregister, $flushNotifications);
+
+export { $flushNotifications, $lookup, $register, $subscribe, $unregister, flushNotifications, isCommand, isFlushNotifications, isLookup, isRegister, isSubscribe, isUnregister, lookup, register, subscribe, unregister };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { behavior } from './behavior.js';
+import * as command_d from './command.js';
+export { command_d as cmd };
+export { Command } from './command.js';
+import * as reply_d from './reply.js';
+export { reply_d as reply };
+export { Listing, Registered, Unregistered } from './reply.js';
+export { ServiceKey } from './service-key.js';

package/dist/index.internal.d.ts

@@ -0,0 +1,11 @@
+export { behavior } from './behavior.internal.js';
+import * as command_d from './command.internal.js';
+export { command_d as cmd };
+export { Command } from './command.internal.js';
+import * as reply_d from './reply.internal.js';
+export { reply_d as reply };
+export { Listing, Registered, Unregistered } from './reply.internal.js';
+export { ServiceKey } from './service-key.internal.js';
+import * as state_d from './state.internal.js';
+export { state_d as state };
+export { State } from './state.internal.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { behavior } from './behavior.js';
+import * as command from './command.js';
+export { command as cmd };
+import * as reply from './reply.js';
+export { reply };
+export { ServiceKey } from './service-key.js';
+import * as state from './state.js';
+export { state };

package/dist/reply.d.ts

@@ -0,0 +1,28 @@
+import { ActorRef } from '@actor-system/core';
+import { Letter } from '@actor-system/mail';
+import { ServiceKey } from './service-key.js';
+
+declare const $listing = "@@receptionist.reply.listing";
+declare const $registered = "@@receptionist.reply.registered";
+declare const $unregistered = "@@receptionist.reply.unregistered";
+interface Listing<T = unknown> extends Letter<typeof $listing> {
+    readonly refs: ReadonlySet<ActorRef<T>>;
+    readonly key: ServiceKey<T>;
+}
+interface Registered<T = unknown> extends Letter<typeof $registered> {
+    readonly ref: ActorRef<T>;
+    readonly key: ServiceKey<T>;
+}
+interface Unregistered<T = unknown> extends Letter<typeof $unregistered> {
+    readonly ref: ActorRef<T>;
+    readonly key: ServiceKey<T>;
+}
+declare const listing: <T = unknown>(key: ServiceKey<T>, refs: ReadonlySet<ActorRef<T>>) => Listing<T>;
+declare const registered: <T = unknown>(key: ServiceKey<T>, ref: ActorRef<T>) => Registered<T>;
+declare const unregistered: <T = unknown>(key: ServiceKey<T>, ref: ActorRef<T>) => Unregistered<T>;
+declare const isListing: <T = unknown>(msg: unknown) => msg is Listing<T>;
+declare const isRegistered: <T = unknown>(msg: unknown) => msg is Registered<T>;
+declare const isUnregistered: <T = unknown>(msg: unknown) => msg is Unregistered<T>;
+
+export { $listing, $registered, $unregistered, isListing, isRegistered, isUnregistered, listing, registered, unregistered };
+export type { Listing, Registered, Unregistered };

package/dist/reply.internal.d.ts

@@ -0,0 +1,28 @@
+import { ActorRef } from '@actor-system/core/internal';
+import { Letter } from '@actor-system/mail/internal';
+import { ServiceKey } from './service-key.internal.js';
+
+declare const $listing = "@@receptionist.reply.listing";
+declare const $registered = "@@receptionist.reply.registered";
+declare const $unregistered = "@@receptionist.reply.unregistered";
+interface Listing<T = unknown> extends Letter<typeof $listing> {
+    readonly refs: ReadonlySet<ActorRef<T>>;
+    readonly key: ServiceKey<T>;
+}
+interface Registered<T = unknown> extends Letter<typeof $registered> {
+    readonly ref: ActorRef<T>;
+    readonly key: ServiceKey<T>;
+}
+interface Unregistered<T = unknown> extends Letter<typeof $unregistered> {
+    readonly ref: ActorRef<T>;
+    readonly key: ServiceKey<T>;
+}
+declare const listing: <T = unknown>(key: ServiceKey<T>, refs: ReadonlySet<ActorRef<T>>) => Listing<T>;
+declare const registered: <T = unknown>(key: ServiceKey<T>, ref: ActorRef<T>) => Registered<T>;
+declare const unregistered: <T = unknown>(key: ServiceKey<T>, ref: ActorRef<T>) => Unregistered<T>;
+declare const isListing: <T = unknown>(msg: unknown) => msg is Listing<T>;
+declare const isRegistered: <T = unknown>(msg: unknown) => msg is Registered<T>;
+declare const isUnregistered: <T = unknown>(msg: unknown) => msg is Unregistered<T>;
+
+export { $listing, $registered, $unregistered, isListing, isRegistered, isUnregistered, listing, registered, unregistered };
+export type { Listing, Registered, Unregistered };

package/dist/reply.js

@@ -0,0 +1,13 @@
+import { letterGuard } from '@actor-system/mail';
+
+const $listing = "@@receptionist.reply.listing";
+const $registered = "@@receptionist.reply.registered";
+const $unregistered = "@@receptionist.reply.unregistered";
+const listing = (key, refs) => ({ label: $listing, key, refs });
+const registered = (key, ref) => ({ label: $registered, key, ref });
+const unregistered = (key, ref) => ({ label: $unregistered, key, ref });
+const isListing = letterGuard($listing);
+const isRegistered = letterGuard($registered);
+const isUnregistered = letterGuard($unregistered);
+
+export { $listing, $registered, $unregistered, isListing, isRegistered, isUnregistered, listing, registered, unregistered };

package/dist/service-key.d.ts

@@ -0,0 +1,8 @@
+import { $type } from '@actor-system/core';
+
+type ServiceKey<T = unknown> = string & {
+    [$type]: T;
+};
+declare const ServiceKey: <T = unknown>(key: string) => ServiceKey<T>;
+
+export { ServiceKey };

package/dist/service-key.internal.d.ts

@@ -0,0 +1,8 @@
+import { $type } from '@actor-system/core/internal';
+
+type ServiceKey<T = unknown> = string & {
+    [$type]: T;
+};
+declare const ServiceKey: <T = unknown>(key: string) => ServiceKey<T>;
+
+export { ServiceKey };

package/dist/service-key.js

@@ -0,0 +1,5 @@
+import '@actor-system/core';
+
+const ServiceKey = (key) => key;
+
+export { ServiceKey };

package/dist/state.internal.d.ts

@@ -0,0 +1,21 @@
+import { ActorRef } from '@actor-system/core/internal';
+import { ServiceKey } from './service-key.internal.js';
+import { Listing } from './reply.internal.js';
+
+interface State {
+    keys(): MapIterator<ServiceKey>;
+    subscribers<T>(key: ServiceKey<T>): ReadonlySet<ActorRef<Listing<T>>>;
+    actors<T>(key: ServiceKey<T>): ReadonlySet<ActorRef<T>>;
+    addSubscriber<T>(key: ServiceKey<T>, ref: ActorRef<Listing<T>>): void;
+    removeSubscriber<T>(ref: ActorRef<Listing<T>>): boolean;
+    addActor<T>(key: ServiceKey<T>, ref: ActorRef<T>): void;
+    removeActor<T>(key: ServiceKey<T>, ref: ActorRef<T>): boolean;
+    apply(nextRegistry: ReadonlyRegistry): Set<ServiceKey>;
+    clear(): void;
+}
+type Registry = Map<ServiceKey, Set<ActorRef>>;
+type ReadonlyRegistry = ReadonlyMap<ServiceKey, ReadonlySet<ActorRef>>;
+declare const create: (registry?: Registry) => State;
+
+export { create };
+export type { ReadonlyRegistry, Registry, State };

package/dist/state.js

@@ -0,0 +1,102 @@
+const create = (registry = new Map()) => {
+    const subscriberByService = new Map();
+    return {
+        clear() {
+            registry.clear();
+            subscriberByService.clear();
+        },
+        apply(nextRegistry) {
+            const changedKeys = new Set();
+            // remove actors that are not in the next registry
+            for (const [key, actors] of registry) {
+                const nextActors = nextRegistry.get(key);
+                if (!nextActors) {
+                    // all actors removed
+                    registry.delete(key);
+                    changedKeys.add(key);
+                    continue;
+                }
+                for (const actor of actors) {
+                    if (!nextActors.has(actor)) {
+                        actors.delete(actor);
+                        changedKeys.add(key);
+                    }
+                }
+                if (actors.size === 0) {
+                    registry.delete(key);
+                }
+            }
+            // add new actors from the next registry
+            for (const [key, nextActors] of nextRegistry) {
+                let actors = registry.get(key);
+                if (!actors) {
+                    actors = new Set();
+                    registry.set(key, actors);
+                    changedKeys.add(key);
+                }
+                for (const actor of nextActors) {
+                    if (!actors.has(actor)) {
+                        actors.add(actor);
+                        changedKeys.add(key);
+                    }
+                }
+            }
+            return changedKeys;
+        },
+        keys() {
+            return registry.keys();
+        },
+        subscribers(key) {
+            let subs = subscriberByService.get(key);
+            if (!subs) {
+                subs = new Set();
+                subscriberByService.set(key, subs);
+            }
+            return subs;
+        },
+        actors(key) {
+            return new Set(registry.get(key));
+        },
+        addSubscriber(key, ref) {
+            let set = subscriberByService.get(key);
+            if (!set) {
+                set = new Set();
+                subscriberByService.set(key, set);
+            }
+            set.add(ref);
+        },
+        removeSubscriber(ref) {
+            let existed = false;
+            for (const key of this.keys()) {
+                const set = subscriberByService.get(key);
+                if (!set)
+                    continue;
+                existed ||= set.delete(ref);
+                if (set.size === 0) {
+                    subscriberByService.delete(key);
+                }
+            }
+            return existed;
+        },
+        addActor(key, ref) {
+            let set = registry.get(key);
+            if (!set) {
+                set = new Set();
+                registry.set(key, set);
+            }
+            set.add(ref);
+        },
+        removeActor(key, ref) {
+            const set = registry.get(key);
+            if (!set)
+                return false;
+            const existed = set.delete(ref);
+            if (set.size === 0) {
+                registry.delete(key);
+            }
+            return existed;
+        },
+    };
+};
+
+export { create };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@actor-system/receptionist",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "type-check": "tsc -b src",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "publint": "publint",
+    "build:tsc:internal": "tsc -b src/tsconfig.lib.json",
+    "build:tsc:trimmed": "tsc -b src/tsconfig.lib.trimmed.json",
+    "build:rollup": "rollup -c node:config/rollup-config"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./command": {
+      "types": "./dist/command.d.ts",
+      "import": "./dist/command.js"
+    },
+    "./reply": {
+      "types": "./dist/reply.d.ts",
+      "import": "./dist/reply.js"
+    },
+    "./internal": {
+      "types": "./dist/index.internal.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./command/internal": {
+      "types": "./dist/command.internal.d.ts",
+      "import": "./dist/command.js"
+    },
+    "./reply/internal": {
+      "types": "./dist/reply.internal.d.ts",
+      "import": "./dist/reply.js"
+    },
+    "./state/internal": {
+      "types": "./dist/state.internal.d.ts",
+      "import": "./dist/state.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bundleDependencies": [
+    "@actor-system/shared"
+  ],
+  "dependencies": {
+    "@actor-system/behaviors": "0.0.1",
+    "@actor-system/core": "0.0.1",
+    "@actor-system/mail": "0.0.1"
+  },
+  "devDependencies": {
+    "@actor-system/testing": "0.0.1",
+    "@actor-system/shared": "0.0.1",
+    "config": "^1.0.0"
+  }
+}