@omnitron-dev/omnitron 0.1.3 → 0.3.0

package/dist/orchestrator/bootstrap-process.d.ts

@@ -13,6 +13,68 @@
  * queryInterface() to get transparent proxies to sibling services.
  */
 import 'reflect-metadata';
+import type { AppHealthAnswer } from '../config/types.js';
+import type { IProcessTraffic } from '@omnitron-dev/titan-pm';
+/**
+ * A topology proxy for a service that was not there yet.
+ *
+ * When the first `queryInterface` fails, this process used to register a
+ * proxy that THROWS on every call for the life of the process — so a service
+ * that appeared a second later was never seen. For a pool that is rare: pools
+ * register in step 1, before any consumer starts. For a sibling child it is
+ * the normal case, because provider and consumer are children of one
+ * supervisor and the provider can only be asked for its services after they
+ * have all started.
+ *
+ * Measured on priceverse: `CollectorWorker` registered on the daemon 7
+ * seconds after the server process asked for it, and the server's health
+ * check answered
+ *
+ *     Topology service 'CollectorWorker' unavailable: Service 'CollectorWorker' not found
+ *
+ * to every call for the rest of that process's life — while the same service,
+ * queried from a fresh client, answered `6 exchanges, 6 connected`.
+ *
+ * So: ask again on use. Once the query succeeds, hand over to the
+ * reconnecting proxy, which is what keeps it alive afterwards. A call made
+ * while it is still absent raises the same sentence as before, naming the
+ * service and the reason it could not be had THIS time — not the one from
+ * start-up.
+ *
+ * @internal exported for tests
+ */
+export declare function createDeferredTopologyProxy(netron: {
+    connect(url: string): Promise<{
+        queryInterface(name: string): Promise<unknown>;
+    }>;
+}, serviceName: string, daemonSocketUrl: string): unknown;
+/**
+ * A topology proxy that survives losing its connection.
+ *
+ * The interface `queryInterface` returns is bound to one socket. When that
+ * socket goes — a daemon restart, a transport hiccup, anything — every later
+ * call rejects with "Socket closed during RPC", forever, because nothing
+ * reconnects and the consumer is holding the same dead object. Consumers
+ * resolve this token once at construction, so the feature stays broken until
+ * the process is restarted.
+ *
+ * Observed exactly that way: pricing's OHLCV aggregation failed on every
+ * five-minute tick with that message while the service on the daemon was
+ * healthy and answering a freshly connected client immediately, and the app
+ * process held zero open connections to the daemon socket.
+ *
+ * So: on a call that fails because the connection is gone, reconnect, ask for
+ * the interface again, and retry once. One reconnect at a time, and a failure
+ * to reconnect surfaces the ORIGINAL error rather than a second one about the
+ * reconnect — the caller asked about their call.
+ *
+ * @internal exported for tests
+ */
+export declare function createReconnectingTopologyProxy(netron: {
+    connect(url: string): Promise<{
+        queryInterface(name: string): Promise<unknown>;
+    }>;
+}, serviceName: string, daemonSocketUrl: string, initial: unknown): unknown;
 declare class BootstrapProcess {
     private definition;
     private entry;
@@ -34,15 +96,30 @@ declare class BootstrapProcess {
         __topologyConnects?: string[];
     }): Promise<void>;
     /**
-     * Health check — delegates to definition hook if present.
+     * Health check — the app's own hook, handed the running Application so it
+     * has something to ask. Without an Application there is nothing to be
+     * healthy: the hook is not called, and the answer says why.
      */
-    checkHealth(): Promise<{
-        status: 'healthy' | 'degraded' | 'unhealthy';
-    }>;
+    checkHealth(): Promise<AppHealthAnswer>;
     /**
      * Graceful shutdown — runs lifecycle hooks and stops the Application.
      */
     shutdown(): Promise<void>;
+    /**
+     * What this process's own transports answered — the app's traffic.
+     *
+     * The process manager asks this inside `__getProcessMetrics`
+     * (`IProcessTrafficReporter`). Before, it reported the call counters of
+     * THIS wrapper's methods, which the supervisor calls for health and
+     * metrics: `omnitron metrics` counted its own questions as the app's
+     * requests and never saw one real one.
+     *
+     * HTTP servers answer a traffic snapshot; a process with several sums the
+     * counts and reports the latency of its busiest server. A process with no
+     * HTTP server (a queue worker) has no traffic to report: `null`, which the
+     * daemon shows as «not reported», not as zero.
+     */
+    reportTraffic(): IProcessTraffic | null;
     /**
      * Returns the resolved HTTP port (useful for pool instances on offset ports).
      */
@@ -60,6 +137,49 @@ declare class BootstrapProcess {
         version?: string;
         methods: string[];
     }>;
+    /**
+     * Invoke a method on one of the Application's own Netron services.
+     *
+     * The pool's PM service is THIS class — `BootstrapApp` — so `pool.execute(m)`
+     * can only reach the methods listed on it. `topology.expose` builds a daemon
+     * proxy out of the method names an app service reports through
+     * `getExposedServices()` above and used to route them straight into
+     * `pool.execute(name)`, which meant every such call asked `BootstrapApp` for
+     * a method it has never had. The daemon exposed the service, the consumer's
+     * `queryInterface` succeeded, and the first call came back "Unknown member" —
+     * from inside the pool, about a different service than the one the caller
+     * named. Nothing in the chain connects the two names, which is why the whole
+     * feature could be wired end to end and still never work.
+     *
+     * This is the hop that was missing: name the service, and the call lands on
+     * the Application's own stub for it.
+     */
+    callExposedService(serviceName: string, method: string, args?: unknown[]): Promise<unknown>;
+    /**
+     * Returns the DI dependency graph of the running Application's
+     * container — nodes per registered token, edges per declared
+     * dependency. Used by `omnitron inspect <app> --graph`.
+     *
+     * The graph is computed lazily from the live container state so it
+     * reflects whatever was actually wired up (post-`@Module`-imports,
+     * post-`registerProviders`). It does NOT include the parent
+     * container's registrations by default — the local module surface
+     * is what triage cares about.
+     */
+    getDependencyGraph(options?: {
+        includeParent?: boolean;
+    }): {
+        nodes: Array<{
+            id: string;
+            label?: string;
+            type?: string;
+        }>;
+        edges: Array<{
+            from: string;
+            to: string;
+            type?: 'dependency' | 'parent';
+        }>;
+    };
     /**
      * Connect to daemon's Netron and queryInterface() for sibling services.
      *
@@ -68,6 +188,30 @@ declare class BootstrapProcess {
      * Application.stop() handles disconnection automatically.
      */
     private injectTopologyProxies;
+    /**
+     * Verify that `Container` class imported by Titan modules in the app's
+     * dependency tree (titan-scheduler, titan-events, etc.) has the same
+     * physical identity as the daemon's `Container` class.
+     *
+     * The daemon resolves `@omnitron-dev/titan` from its own pnpm tree and
+     * uses that to construct `Application` (which auto-registers itself as
+     * the `Container` token). The app's bundled module imports titan-scheduler
+     * (etc.), which transitively imports `@omnitron-dev/titan/nexus`. If those
+     * two paths resolve to different physical files (e.g. monorepo dev vs
+     * published version), `Container` becomes two distinct classes —
+     * `Inject(Container)` then cannot find the auto-registered token and
+     * every consumer fails with the misleading "Dependency 'Container' not
+     * found" during module initialization.
+     *
+     * We detect this **before** Application.create() by resolving titan from
+     * both contexts (daemon-side via static import, app-side via dynamic
+     * import using the module's directory as the resolution base) and
+     * comparing the realpath. On mismatch we throw a self-explanatory error.
+     *
+     * Resolution is best-effort: if the app does not depend on titan
+     * transitively (rare for a Titan @Module bundle), we skip silently.
+     */
+    private assertContainerIdentity;
 }
 export default BootstrapProcess;
 //# sourceMappingURL=bootstrap-process.d.ts.map

package/dist/orchestrator/bootstrap-process.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap-process.d.ts","sourceRoot":"","sources":["../../src/orchestrator/bootstrap-process.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,kBAAkB,CAAC;AA0D1B,cACM,gBAAgB;IACpB,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,GAAG,CAA4B;IACvC,OAAO,CAAC,IAAI,CAAuB;IAEnC;;;;;;OAMG;IACG,IAAI,CAAC,IAAI,EAAE;QACf,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;KAC/B,GAAG,OAAO,CAAC,IAAI,CAAC;IA4JjB;;OAEG;IAEG,WAAW,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,CAAA;KAAE,CAAC;IAW9E;;OAEG;IAEG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IA4B/B;;OAEG;IACH,OAAO,IAAI,MAAM,GAAG,IAAI;IAIxB;;OAEG;IACH,OAAO,IAAI,MAAM,GAAG,IAAI;IAIxB;;;OAGG;IACH,kBAAkB,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAKlF;;;;;;OAMG;YACW,qBAAqB;CAiDpC;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"bootstrap-process.d.ts","sourceRoot":"","sources":["../../src/orchestrator/bootstrap-process.ts"],"names":[],"mappings":"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"}