akanjs 3.0.0-alpha.90 → 3.0.0-alpha.91

package/common/types.ts

@@ -6,6 +6,13 @@ export interface FetchPolicy<Returns = unknown> {
   token?: string;
   partial?: string[];
   timeout?: number;
+  /**
+   * A `pubsub` subscription only: called after the room has been resubscribed following a dropped connection.
+   *
+   * Whatever was published while the socket was down is gone, and a room cannot say which messages those were, so
+   * a subscriber that has to stay correct reloads here instead of carrying on from a gap it cannot see.
+   */
+  onResync?: () => void;
 }
 
 export type SnakeCase<S extends string> = S extends `${infer T}_${infer U}` ? `${Lowercase<T>}_${SnakeCase<U>}` : S;

package/fetch/client/fetchClient.ts

@@ -373,12 +373,15 @@ export class FetchClient {
             };
             wrappedListeners.set(handleEvent, wrapped);
             const ws = this.#resolveWs(fetchPolicy?.origin);
-            ws.subscribe({
-              key,
-              data,
-              handleEvent: wrapped,
-            });
-            return () => ws.unsubscribe({ key, data, handleEvent: wrappedListeners.get(handleEvent) ?? handleEvent });
+            const handleResync = fetchPolicy?.onResync;
+            ws.subscribe({ key, data, handleEvent: wrapped, handleResync });
+            return () =>
+              ws.unsubscribe({
+                key,
+                data,
+                handleEvent: wrappedListeners.get(handleEvent) ?? handleEvent,
+                handleResync,
+              });
           };
         });
         return;
@@ -624,6 +627,7 @@ export class FetchClient {
     const names = {
       list: `${refName}List${capSuffix}`,
       insight: `${refName}Insight${capSuffix}`,
+      live: `${refName}Live${capSuffix}`,
     };
 
     const mcp = slice.mcp === false ? { mcp: false as const } : {};
@@ -643,6 +647,15 @@ export class FetchClient {
         ...mcp,
       },
     };
+
+    if (slice.live)
+      endpoint[names.live] = {
+        type: "pubsub",
+        args: slice.args.map((arg) => ({ ...arg, type: "room" as const })),
+        returns: { refName: "Any" },
+        guards: slice.guards,
+        mcp: false,
+      };
     return endpoint;
   }
   #registerSlice(refName: string, suffix: string, slice: SerializedSlice, prefix?: string) {
@@ -657,8 +670,9 @@ export class FetchClient {
     };
 
     const endpoint = FetchClient.getEndpointFromSlice(refName, suffix, slice);
+
     Object.entries(endpoint).forEach(([key, value]) => {
-      this.#setHandlerFactory(key, () => this.#makeHttpFn(key, value, prefix));
+      this.#registerEndpoint(key, value, prefix);
     });
 
     const argLength = slice.args.length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.90",
+  "version": "3.0.0-alpha.91",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/di/diLifecycle.ts

@@ -662,7 +662,7 @@ export class DiLifecycle {
         },
       })),
     );
-    if (liveKeys.length) this.logger.info(`Live sync: ${liveKeys.length} rooms — ${liveKeys.join(", ")}`);
+    if (liveKeys.length) this.logger.info(`Live sync: ${liveKeys.length} live slice(s) — ${liveKeys.join(", ")}`);
     return { routes, wsRoutes, routeOptions };
   }
 

package/server/resolver/signal.resolver.ts

@@ -375,7 +375,7 @@ export class SignalResolver {
             );
           SignalResolver.#assertLiveSort(refName, key, sliceInfo);
           const liveKey = `${refName}Live${capitalizedKey}`;
-          let liveBuilder = (builder as any).pubsub(Any, {
+          const liveBuilder = (builder as any).pubsub(Any, {
             guards: sliceCls.getGuards,
             mcp: false,
             live: {
@@ -386,18 +386,17 @@ export class SignalResolver {
               payload: sliceInfo.liveOption.payload,
             } satisfies LiveEndpointOption,
           });
-          for (const arg of sliceInfo.args) liveBuilder = liveBuilder.room(arg.name, arg.argRef, arg.option);
-          endpointObj[liveKey] = liveBuilder._addInternalArgs(sliceInfo.internalArgs).exec(async function (
-            this: any,
-            ...requestArgs: any
-          ) {
-            const args = requestArgs.slice(0, argLength);
-            const internalArgs = requestArgs.slice(argLength);
-            return assertSliceQuery(
-              await sliceInfo.execFn?.apply(this, [...args, ...internalArgs, documentQueryHelper]),
-              key,
-            );
-          });
+          endpointObj[liveKey] = liveBuilder
+            ._addRoomArgs(sliceInfo.args)
+            ._addInternalArgs(sliceInfo.internalArgs)
+            .exec(async function (this: any, ...requestArgs: any) {
+              const args = requestArgs.slice(0, argLength);
+              const internalArgs = requestArgs.slice(argLength);
+              return assertSliceQuery(
+                await sliceInfo.execFn?.apply(this, [...args, ...internalArgs, documentQueryHelper]),
+                key,
+              );
+            });
         }
 
         const insightKey = `${refName}Insight${capitalizedKey}`;

package/signal/endpointInfo.ts

@@ -299,6 +299,22 @@ export class EndpointInfo<
       Nullable
     >;
   }
+  /**
+   * Retypes a slice's own arguments as this room's arguments, keeping each one's nullability.
+   *
+   * Not `_addArgs`, which would route a `search` argument back to `.search()`. And not `.room()` per argument:
+   * that refuses a nullable argument in anything but the last position, which is the right rule for a URL and a
+   * meaningless one for a room — the arguments travel as a positional array with explicit nulls, so a missing one
+   * is unambiguous. Nullability is preserved because dropping it would make an absent optional argument fail to
+   * deserialize on the way in.
+   */
+  _addRoomArgs(args: ArgInfo<EndpointArgProps<boolean>>[]) {
+    for (const arg of args) {
+      this.argNames.push(arg.name);
+      this.args.push({ ...arg, type: "room" });
+    }
+    return this;
+  }
   _addInternalArgs(args: InternalArgInfo<boolean>[]) {
     for (const arg of args) this.with(arg.argRef, arg.option);
     return this;

package/store/action.ts

@@ -1017,12 +1017,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
 
     const requests = new SliceRequest();
 
-    let liveWatch: {
-      key: string;
-      data: unknown[];
-      handleEvent: (data: unknown) => void;
-      handleResync: () => void;
-    } | null = null;
+    let liveWatch: { signature: string; dispose: () => void } | null = null;
     const namesOfSlice: { [key in SliceActionKey | SliceStateKey | "modelList"]: string } = {
       defaultModel: SliceName.replace(names.Model, names.defaultModel),
       modelInsight: sliceName.replace(names.model, names.modelInsight),
@@ -1399,24 +1394,27 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
        */
       [namesOfSlice.watchLiveModel]: function (this: SetGet, queryArgs: unknown[] | null) {
         if (!slice.live) return;
-        const roomKey = sliceName.replace(names.model, `${names.model}Live`);
-        const data = queryArgs ? expandQueryArgs(normalizeQueryArgs(queryArgs, slice.args), slice.args) : null;
-        if (liveWatch && (!data || JSON.stringify(data) !== JSON.stringify(liveWatch.data))) {
-          fetch.instance.unsubscribe(liveWatch);
+        const args = queryArgs ? expandQueryArgs(normalizeQueryArgs(queryArgs, slice.args), slice.args) : null;
+        const signature = args ? JSON.stringify(args) : null;
+        if (liveWatch && signature !== liveWatch.signature) {
+          liveWatch.dispose();
           liveWatch = null;
         }
-        if (!data || liveWatch) return;
+        if (!args || liveWatch) return;
         const self = this as unknown as DynamicRecord;
         const apply = self[namesOfSlice.applyLiveModel] as (event: unknown) => void;
         const refresh = self[namesOfSlice.refreshModel] as (form: object) => Promise<void>;
-        liveWatch = {
-          key: roomKey,
-          data,
-          handleEvent: (event: unknown) => apply(event),
+
+        const subscribe = fetch[`subscribe${capitalize(sliceName.replace(names.model, `${names.model}Live`))}`] as
+          | ((...args: unknown[]) => () => void)
+          | undefined;
+        if (!subscribe) return;
+        const dispose = subscribe(...args, (event: unknown) => apply(event), {
+          crystalize: false,
           
-          handleResync: () => void refresh({ invalidate: true }),
-        };
-        fetch.instance.subscribe(liveWatch);
+          onResync: () => void refresh({ invalidate: true }),
+        });
+        liveWatch = { signature: signature ?? "", dispose };
       },
     };
     return Object.assign(acc, singleSliceAction);

package/types/common/types.d.ts

@@ -6,6 +6,13 @@ export interface FetchPolicy<Returns = unknown> {
     token?: string;
     partial?: string[];
     timeout?: number;
+    /**
+     * A `pubsub` subscription only: called after the room has been resubscribed following a dropped connection.
+     *
+     * Whatever was published while the socket was down is gone, and a room cannot say which messages those were, so
+     * a subscriber that has to stay correct reloads here instead of carrying on from a gap it cannot see.
+     */
+    onResync?: () => void;
 }
 export type SnakeCase<S extends string> = S extends `${infer T}_${infer U}` ? `${Lowercase<T>}_${SnakeCase<U>}` : S;
 export type SnakeCaseObj<T> = {

package/types/signal/endpointInfo.d.ts

@@ -64,6 +64,16 @@ export declare class EndpointInfo<ReqType extends EndpointType = EndpointType, S
     search<ArgName extends string, ExplicitType = unknown, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType, _ClientArg = PurifiedModel<_ArgType>, _ServerArg = DocumentModel<_ArgType>>(name: string, arg: Arg, option?: Omit<EndpointArgProps, "nullable">): EndpointInfo<ReqType, Srvs, [...ArgNames, ArgName], [...Args, arg?: _ClientArg | null], InternalArgs, [...ServerArgs, arg: _ServerArg | undefined], Returns, ClientReturns, ServerReturns, Nullable>;
     _addArgs(args: ArgInfo<EndpointArgProps<boolean>>[]): this;
     with<ArgType, Optional extends boolean = false>(argRef: InternalArgCls<ArgType>, option?: InternalArgProps<Optional>): EndpointInfo<ReqType, Srvs, ArgNames, Args, [...InternalArgs, arg: NonNullable<ArgType> | (Optional extends true ? null : never)], ServerArgs, Returns, ClientReturns, ServerReturns, Nullable>;
+    /**
+     * Retypes a slice's own arguments as this room's arguments, keeping each one's nullability.
+     *
+     * Not `_addArgs`, which would route a `search` argument back to `.search()`. And not `.room()` per argument:
+     * that refuses a nullable argument in anything but the last position, which is the right rule for a URL and a
+     * meaningless one for a room — the arguments travel as a positional array with explicit nulls, so a missing one
+     * is unambiguous. Nullability is preserved because dropping it would make an absent optional argument fail to
+     * deserialize on the way in.
+     */
+    _addRoomArgs(args: ArgInfo<EndpointArgProps<boolean>>[]): this;
     _addInternalArgs(args: InternalArgInfo<boolean>[]): this;
     exec<ExecFn extends (this: Srvs, ...args: [...ServerArgs, ...InternalArgs]) => ReqType extends "pubsub" ? Promise<void> | void : ReqType extends "prompt" ? PromiseOrObject<PromptResult> : PromiseOrObject<DocumentModel<FieldToValue<Returns>> | (Nullable extends true ? null | undefined : never)>>(execFn: ExecFn): EndpointInfo<ReqType, Srvs, ArgNames, Args, InternalArgs, ServerArgs, Returns, FieldToValue<Returns>, ReturnType<ExecFn>, Nullable>;
     getPath(key: string): string;