@nice-code/action 0.2.5 → 0.2.6

package/build/index.js

@@ -3310,7 +3310,7 @@ var err_nice_action = err_nice.createChildDomain({
       message: ({ context, clientStringId }) => `No runtime registered${context?.domain ? ` on domain "${context.domain}"` : ""} for client [${clientStringId}].`
     }),
     ["no_client_runtimes_registered" /* no_client_runtimes_registered */]: err({
-      message: ({ context }) => `No runtimes registered${context?.domain ? ` on domain "${context.domain}"` : ""}. Register at least one runtime via addActionRuntime() before executing actions.`
+      message: ({ context }) => `No runtimes registered${context?.domain ? ` on domain "${context.domain}"` : ""}. Add handlers to a runtime via runtime.addHandlers([handler]) before executing actions.`
     }),
     ["action_input_validation_failed" /* action_input_validation_failed */]: err({
       message: ({ domain, actionId, validationMessage }) => `Input validation failed for action "${actionId}" in domain "${domain}":
@@ -3618,6 +3618,7 @@ class ActionRuntime {
   actionRouter;
   _pendingRunningActions = new Map;
   _registeredExternalHandlers = [];
+  _applied = false;
   static getDefault() {
     return getDefaultActionRuntime();
   }
@@ -3639,6 +3640,7 @@ class ActionRuntime {
       throw new Error(`Can't update Runtime Coordinate with different "envId" properties (static environment id). "${this.coordinate.envId}" (current) !== ${newCoordinate.envId}`);
     }
     this._coordinate = newCoordinate;
+    this.apply();
   }
   registerRunningAction(ra) {
     this._pendingRunningActions.set(ra.cuid, ra);
@@ -3741,6 +3743,9 @@ class ActionRuntime {
       }
       const handlerRouter = handler.getActionRouter();
       this.actionRouter.addDomainsFromOther(handlerRouter);
+      if (this._applied) {
+        this.apply();
+      }
       for (const key of handlerRouter.getRegisteredKeys()) {
         const alreadyRegistered = this.actionRouter.getForKey(key).some((h2) => h2.cuid === handler.cuid);
         if (!alreadyRegistered) {
@@ -3750,6 +3755,19 @@ class ActionRuntime {
     }
     return this;
   }
+  applyRuntimeForDomain(domain) {
+    const rootDomain = domain.rootDomain;
+    if (!rootDomain._hasRuntime(this)) {
+      rootDomain._registerRuntime(this);
+    }
+  }
+  apply() {
+    this._applied = true;
+    for (const domain of this.actionRouter.getDomains()) {
+      this.applyRuntimeForDomain(domain);
+    }
+    return this;
+  }
   getReturnHandlerForOrigin(originClient) {
     if (originClient.envId === UNSET_RUNTIME_ENV_ID)
       return;
@@ -3949,6 +3967,9 @@ class ActionDomain extends ActionDomainBase {
   get rootDomain() {
     return this._rootDomain;
   }
+  _registerRuntime(runtime2) {
+    this._rootDomain._registerRuntime(runtime2);
+  }
   createChildDomain(subDomainDef) {
     if (this.allDomains.includes(subDomainDef.domain)) {
       throw err_nice_action.fromId("domain_already_exists_in_hierarchy" /* domain_already_exists_in_hierarchy */, {
@@ -4166,6 +4187,9 @@ class ActionRuntimeManager {
   getBestRuntime(clientSpecifier) {
     return clientSpecifier != null ? this.getBestRuntimeForSpecifier(clientSpecifier) : this.getPreferredRuntime();
   }
+  hasRuntime(runtime2) {
+    return this._runtimes.has(runtime2.coordinate.stringId);
+  }
   getBestRuntimeOrThrow(specifier) {
     const runtime2 = this.getBestRuntime(specifier);
     if (!runtime2) {
@@ -4211,9 +4235,11 @@ class ActionRootDomain extends ActionDomainBase {
       actionSchema: subDomainDef.actions
     }, { rootDomain: this });
   }
-  addActionRuntime(runtime2) {
+  _registerRuntime(runtime2) {
     this._actionRuntimeManager.registerRuntime(runtime2);
-    return this;
+  }
+  _hasRuntime(runtime2) {
+    return this._actionRuntimeManager.hasRuntime(runtime2);
   }
   getRuntime(clientSpecifier) {
     return this._actionRuntimeManager.getBestRuntimeForSpecifier(clientSpecifier);
@@ -6924,7 +6950,11 @@ class ConnectionTransportManager {
       if (cacheKey != null) {
         const cached = this._cache.get(cacheKey);
         if (cached != null) {
-          return cached instanceof Promise ? await cached : { ...cached, transport };
+          if (cached instanceof Promise) {
+            initializingWaiters.push(cached);
+            continue;
+          }
+          return { ...cached, transport };
         }
       }
       const statusInfo = transport.getTransport(routeActionParams);
@@ -7241,8 +7271,10 @@ class TransportWebSocket extends Transport {
       const ws = transportStatusInfo.readyData.ws;
       if (ws.readyState !== WebSocket.OPEN) {
         const initialization = async () => {
-          await new Promise((resolve) => {
-            ws.addEventListener("open", resolve, { once: true });
+          await new Promise((resolve, reject) => {
+            ws.addEventListener("open", () => resolve(), { once: true });
+            ws.addEventListener("error", (event) => reject(event), { once: true });
+            ws.addEventListener("close", (event) => reject(new Error(`WebSocket closed before open: code=${event.code}`)), { once: true });
           });
           return {
             status: "ready" /* ready */,
@@ -7260,8 +7292,10 @@ class TransportWebSocket extends Transport {
       const promiseForReadyData = transportStatusInfo.initializationPromise.then(async (result) => {
         if (result.status === "ready" /* ready */) {
           const ws = result.readyData.ws;
-          await new Promise((resolve) => {
-            ws.addEventListener("open", resolve, { once: true });
+          await new Promise((resolve, reject) => {
+            ws.addEventListener("open", () => resolve(), { once: true });
+            ws.addEventListener("error", (event) => reject(event), { once: true });
+            ws.addEventListener("close", (event) => reject(new Error(`WebSocket closed before open: code=${event.code}`)), { once: true });
           });
           return {
             status: "ready" /* ready */,

package/build/react-query/index.js

@@ -3114,12 +3114,20 @@ function actionQueryKey(action, input) {
   }
   return ["nice-action", action.domain, action.allDomains, action.id, input];
 }
-function useActionQuery(action, input, options) {
+function useActionQuery(action, ...args) {
+  const hasInputSchema = action.schema.inputSchema != null;
+  let input;
+  let options;
+  if (hasInputSchema) {
+    [input, options] = args;
+  } else {
+    [options] = args;
+  }
   const { enabled, ...queryOptions2 } = options ?? {};
   return useQuery({
     queryKey: input != null ? actionQueryKey(action, input) : actionQueryKey(action),
     queryFn: () => action.request(input).runToOutput(),
-    enabled: input != null && (enabled ?? true),
+    enabled: hasInputSchema ? input != null && (enabled ?? true) : enabled ?? true,
     ...queryOptions2
   });
 }

package/build/types/ActionDefinition/Domain/ActionDomain.d.ts

@@ -1,5 +1,6 @@
 import type { IExecuteActionOptions } from "../../ActionRuntime/Handler/ActionHandler.types";
 import { ActionLocalHandler } from "../../ActionRuntime/Handler/Local/ActionLocalHandler";
+import type { ActionRuntime } from "../../ActionRuntime/ActionRuntime";
 import type { TAction_Any_JsonObject, TDistributeActionPayload_Request, TDistributeActionPayload_Result, TDistributedDomainActions, TNarrowActionJsonTypeToActionInstanceType } from "../Action/Action.combined.types";
 import { type IActionBase } from "../Action/ActionBase.types";
 import { ActionContext } from "../Action/Context/ActionContext";
@@ -21,6 +22,7 @@ export declare class ActionDomain<ACT_DOM extends IActionDomain = IActionDomain>
         rootDomain: ActionRootDomain<any>;
     });
     get rootDomain(): ActionRootDomain<any>;
+    _registerRuntime(runtime: ActionRuntime): void;
     createChildDomain<SUB_DOM extends IActionDomainChildOptions>(subDomainDef: SUB_DOM & {
         [K in Exclude<keyof SUB_DOM, keyof IActionDomainChildOptions>]: never;
     }): ActionDomain<TActionDomainChildDef<ACT_DOM, SUB_DOM>>;

package/build/types/ActionDefinition/Domain/ActionRootDomain.d.ts

@@ -17,7 +17,8 @@ export declare class ActionRootDomain<ROOT_DOM extends IActionRootDomain = IActi
     createChildDomain<SUB_DOM extends IActionDomainChildOptions>(subDomainDef: SUB_DOM & {
         [K in Exclude<keyof SUB_DOM, keyof IActionDomainChildOptions>]: never;
     }): ActionDomain<TActionDomainChildDef<ROOT_DOM, SUB_DOM>>;
-    addActionRuntime(runtime: ActionRuntime): this;
+    _registerRuntime(runtime: ActionRuntime): void;
+    _hasRuntime(runtime: ActionRuntime): boolean;
     getRuntime(clientSpecifier: IRuntimeCoordinate): ActionRuntime | undefined;
     _runAction<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string, ACT extends ActionPayload_Request<DOM, ID> = ActionPayload_Request<DOM, ID>>(actionPayload: ACT, options?: IExecuteActionOptions<DOM, ID>): Promise<RunningAction<DOM, ID>>;
 }

package/build/types/ActionRuntime/ActionRuntime.d.ts

@@ -13,6 +13,7 @@ export declare class ActionRuntime {
     private readonly actionRouter;
     private readonly _pendingRunningActions;
     private readonly _registeredExternalHandlers;
+    private _applied;
     static getDefault(): ActionRuntime;
     constructor(coordinate: RuntimeCoordinate);
     get coordinate(): RuntimeCoordinate;
@@ -35,6 +36,13 @@ export declare class ActionRuntime {
      * Duplicate registrations (same handler cuid for the same key) are skipped.
      */
     addHandlers(handlers: TActionRuntimeHandler[]): this;
+    private applyRuntimeForDomain;
+    /**
+     * Register this runtime with all root domains covered by its currently-added handlers,
+     * making it eligible to execute actions dispatched from those domains.
+     * After apply() is called, any subsequent addHandlers() calls also auto-register.
+     */
+    apply(): this;
     /**
      * Find the best registered external handler that can reach `originClient` directly.
      * Used to locate the return-path channel for dispatching results back to the action origin.

package/build/types/ActionRuntime/ActionRuntimeManager.d.ts

@@ -15,5 +15,6 @@ export declare class ActionRuntimeManager {
     getPreferredRuntime(): ActionRuntime | undefined;
     getBestRuntimeForSpecifier(clientSpecifier: IRuntimeCoordinate): ActionRuntime | undefined;
     getBestRuntime(clientSpecifier?: IRuntimeCoordinate): ActionRuntime | undefined;
+    hasRuntime(runtime: ActionRuntime): boolean;
     getBestRuntimeOrThrow(specifier?: IRuntimeCoordinate): ActionRuntime;
 }

package/build/types/ActionRuntime/RuntimeCoordinate.d.ts

@@ -13,7 +13,8 @@ export interface IRuntimeCoordinate {
      */
     insId?: string;
 }
-export type TRuntimeCoordinateStringId = `envId[${string}]perId[${string | "_"}]:insId[${string | "_"}]`;
+export type TRuntimeCoordinateEnvId = `envId[${string}]`;
+export type TRuntimeCoordinateStringId = `${TRuntimeCoordinateEnvId}perId[${string | "_"}]:insId[${string | "_"}]`;
 export interface IRuntimeFullCoordinates extends Required<IRuntimeCoordinate> {
 }
 export declare class RuntimeCoordinate implements IRuntimeCoordinate {

package/build/types/react-query/hooks/useActionQuery.d.ts

@@ -8,8 +8,10 @@ export declare function actionQueryKey<DOM extends IActionDomain, ID extends key
     DOM["domain"],
     DOM["allDomains"],
     ID,
-    TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"],
-    string | undefined
+    TInferInputFromSchema<DOM["actionSchema"][ID]>["Input"]
 ];
 export type TUseActionQueryOptions<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, SCH extends DOM["actionSchema"][ID] = DOM["actionSchema"][ID], TSelect = TInferOutputFromSchema<SCH>["Output"]> = Omit<UseQueryOptions<TInferOutputFromSchema<SCH>["Output"], TInferActionError<SCH>, TSelect, QueryKey>, "queryKey" | "queryFn">;
-export declare function useActionQuery<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, SCH extends DOM["actionSchema"][ID], TSelect = TInferOutputFromSchema<SCH>["Output"]>(action: ActionCore<DOM, ID>, input: TInferInputFromSchema<SCH>["Input"] | null | undefined, options?: TUseActionQueryOptions<DOM, ID, SCH, TSelect>): UseQueryResult<TSelect, TInferActionError<SCH>>;
+export declare function useActionQuery<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, SCH extends DOM["actionSchema"][ID], TSelect = TInferOutputFromSchema<SCH>["Output"]>(action: ActionCore<DOM, ID>, ...args: [TInferInputFromSchema<SCH>["Input"]] extends [never] ? [options?: TUseActionQueryOptions<DOM, ID, SCH, TSelect>] : [
+    input: TInferInputFromSchema<SCH>["Input"] | null | undefined,
+    options?: TUseActionQueryOptions<DOM, ID, SCH, TSelect>
+]): UseQueryResult<TSelect, TInferActionError<SCH>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice-code/action",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "private": false,
   "type": "module",
   "exports": {