@specific.dev/spectest 0.92.0 → 0.93.0

package/src/harness/service-graph.test.ts

@@ -1,9 +1,39 @@
 import { describe, expect, test } from "bun:test";
 
-import { topologicalOrder, validateServiceGraph } from "./service-graph";
+import { startServices, topologicalOrder, validateServiceGraph } from "./service-graph";
 
 const svc = (name: string, dependsOn?: string[]) => ({ name, dependsOn });
 
+test("bootstrap waits for sibling hooks after a failure and never starts failed dependents", async () => {
+  let release!: () => void;
+  const gate = new Promise<void>(resolve => { release = resolve; });
+  const started: string[] = [];
+  let completed = false;
+  let settled = false;
+  const failed = new Error("setup failed");
+  const result = startServices([svc("bad"), svc("slow"), svc("child", ["bad"])], async ({ name }) => {
+    started.push(name);
+    if (name === "bad") throw failed;
+    if (name === "slow") { await gate; completed = true; }
+  }).then(() => { settled = true; return undefined; }, error => { settled = true; return error; });
+  await new Promise(resolve => setTimeout(resolve, 0));
+  expect(started).toEqual(["bad", "slow"]);
+  expect(settled).toBe(false);
+  release();
+  const error = await result;
+  expect(completed).toBe(true);
+  expect(error instanceof AggregateError ? error.errors : [error]).toContain(failed);
+});
+
+test("shared dependencies complete setup once before either dependent starts", async () => {
+  const started: string[] = [];
+  await startServices([svc("a", ["db"]), svc("b", ["db"]), svc("db")], async ({ name }) => {
+    await Promise.resolve();
+    started.push(name);
+  });
+  expect(started).toEqual(["db", "a", "b"]);
+});
+
 describe("validateServiceGraph", () => {
   test("returns a name→service map for a clean graph", () => {
     const map = validateServiceGraph([svc("db"), svc("api", ["db"])]);

package/src/harness/service-graph.ts

@@ -1,3 +1,5 @@
+import { waitForAll } from "./concurrency.js";
+
 /**
  * The `dependsOn` graph: validation, and the traversal order bring-up
  * uses.
@@ -95,3 +97,24 @@ export function topologicalOrder<T extends GraphNode>(services: readonly T[]): T
   for (const s of services) visit(s.name);
   return out;
 }
+
+/** Start each service after its dependencies finish setup. Drain all branches
+ * before reporting failure so teardown cannot race containers or hooks. */
+export async function startServices<T extends GraphNode>(
+  services: readonly T[],
+  startOne: (svc: T) => Promise<void>,
+): Promise<void> {
+  const byName = validateServiceGraph(services);
+  const started = new Map<string, Promise<void>>();
+  const start = (svc: T): Promise<void> => {
+    const existing = started.get(svc.name);
+    if (existing) return existing;
+    const pending = (async () => {
+      await Promise.all((svc.dependsOn ?? []).map(name => start(byName.get(name)!)));
+      await startOne(svc);
+    })();
+    started.set(svc.name, pending);
+    return pending;
+  };
+  await waitForAll(services.map(start));
+}

package/src/index.ts

@@ -796,13 +796,16 @@ export interface ServiceDefinition<
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type ServicesMap = Record<string, ServiceDefinition<any>>;
 
-/** Awaited return type of a service's `helpers` factory, or `never` if
- * the service doesn't ship one. */
-type HelpersOf<D> = D extends {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  helpers: (...args: any) => infer R;
-}
-  ? Awaited<R>
+/** Awaited return type of a service's helpers factory. Check key presence
+ * before removing optionality: annotations keep `helpers?`, while plain
+ * service literals with no factory must stay out of ctx.svc. */
+type HelpersOf<D> = "helpers" extends keyof D
+  ? [NonNullable<D["helpers"]>] extends [never]
+    ? never
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    : NonNullable<D["helpers"]> extends (...args: any[]) => infer R
+      ? Awaited<R>
+      : never
   : never;
 
 /**
@@ -1247,7 +1250,8 @@ export type BuildImage = (
 ) & {
   /** Full image reference, e.g. "k8s.internal:5000/runtime:spectest".
    * Optional for a service; required for a Kubernetes build. This names a
-   * local image and does not publish it to a registry. */
+   * local image. In k3s, builds targeting `registry.host` are also published
+   * to that component's registry; other references are only preloaded. */
   reference?: string;
 };