starpc 0.50.0 → 0.52.0

package/srpc/schema-ownership_test.go

@@ -1,115 +0,0 @@
-package srpc
-
-import (
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"os"
-	"strings"
-	"testing"
-)
-
-// handwrittenTerminalConst names the parallel iota constants the receipt
-// post-mortem removed. Their reappearance signals a second handwritten owner of
-// the cross-language terminal vocabulary.
-var handwrittenTerminalConst = map[string]bool{
-	"TerminalCommitted": true,
-	"TerminalCanceled":  true,
-	"TerminalLost":      true,
-	"TerminalClosed":    true,
-	"TerminalAbandoned": true,
-}
-
-// handwrittenTerminalKindOwners returns the source files that declare the shared
-// TerminalKind vocabulary by hand instead of consuming the generated rpcproto
-// owner. The cross-language terminal noun has exactly one schema owner; a
-// handwritten type or iota constant reintroduces the parallel owner.
-func handwrittenTerminalKindOwners(t *testing.T, files map[string]string) []string {
-	t.Helper()
-	var owners []string
-	for name, src := range files {
-		fset := token.NewFileSet()
-		file, err := parser.ParseFile(fset, name, src, 0)
-		if err != nil {
-			t.Fatalf("parse %s: %v", name, err)
-		}
-		if declaresTerminalKindByHand(file) {
-			owners = append(owners, name)
-		}
-	}
-	return owners
-}
-
-// declaresTerminalKindByHand reports whether a file declares the TerminalKind
-// type or one of its removed iota constants.
-func declaresTerminalKindByHand(file *ast.File) bool {
-	for _, decl := range file.Decls {
-		gen, ok := decl.(*ast.GenDecl)
-		if !ok {
-			continue
-		}
-		for _, spec := range gen.Specs {
-			switch s := spec.(type) {
-			case *ast.TypeSpec:
-				if s.Name.Name == "TerminalKind" {
-					return true
-				}
-			case *ast.ValueSpec:
-				for _, id := range s.Names {
-					if handwrittenTerminalConst[id.Name] {
-						return true
-					}
-				}
-			}
-		}
-	}
-	return false
-}
-
-// packageSourceFiles reads the non-generated, non-test Go sources of the current
-// package directory.
-func packageSourceFiles(t *testing.T) map[string]string {
-	t.Helper()
-	entries, err := os.ReadDir(".")
-	if err != nil {
-		t.Fatalf("read package dir: %v", err)
-	}
-	files := map[string]string{}
-	for _, entry := range entries {
-		name := entry.Name()
-		if !strings.HasSuffix(name, ".go") {
-			continue
-		}
-		if strings.HasSuffix(name, ".pb.go") || strings.HasSuffix(name, "_test.go") {
-			continue
-		}
-		data, err := os.ReadFile(name)
-		if err != nil {
-			t.Fatalf("read %s: %v", name, err)
-		}
-		files[name] = string(data)
-	}
-	return files
-}
-
-// TestTerminalKindHasSingleSchemaOwner proves no handwritten srpc source owns
-// the cross-language TerminalKind vocabulary alongside the generated owner.
-func TestTerminalKindHasSingleSchemaOwner(t *testing.T) {
-	owners := handwrittenTerminalKindOwners(t, packageSourceFiles(t))
-	if len(owners) != 0 {
-		t.Fatalf("TerminalKind must come from generated rpcproto; handwritten owners: %v", owners)
-	}
-}
-
-// TestTerminalKindGuardDetectsHandwrittenOwner proves the guard fires when a
-// parallel handwritten TerminalKind owner regresses into the package.
-func TestTerminalKindGuardDetectsHandwrittenOwner(t *testing.T) {
-	bad := map[string]string{
-		"server-invocation.go": "package srpc\n\n" +
-			"type TerminalKind int\n\n" +
-			"const (\n\tTerminalCommitted TerminalKind = iota\n)\n",
-	}
-	if owners := handwrittenTerminalKindOwners(t, bad); len(owners) == 0 {
-		t.Fatal("guard failed to flag a handwritten TerminalKind owner")
-	}
-}

package/srpc/server-invocation.go

@@ -1,40 +0,0 @@
-package srpc
-
-import "context"
-
-// ServerInvocation exposes the terminal of a held unary server invocation.
-type ServerInvocation interface {
-	// WaitTerminal waits for a remote terminal or owner-context expiry. The
-	// owner context must outlive the invocation context.
-	WaitTerminal(ownerCtx context.Context) (TerminalKind, error)
-	// Done returns the invocation context cancellation channel for diagnostics.
-	Done() <-chan struct{}
-}
-
-type serverInvocationKey struct{}
-
-func withServerInvocation(ctx context.Context, invocation ServerInvocation) context.Context {
-	return context.WithValue(ctx, serverInvocationKey{}, invocation)
-}
-
-// GetServerInvocation returns the held unary invocation attached to a context.
-func GetServerInvocation(ctx context.Context) (ServerInvocation, bool) {
-	if ctx == nil {
-		return nil, false
-	}
-	invocation, ok := ctx.Value(serverInvocationKey{}).(ServerInvocation)
-	return invocation, ok
-}
-
-// WaitTerminal waits for and classifies the terminal of a held unary invocation.
-func (r *ServerRPC) WaitTerminal(ownerCtx context.Context) (TerminalKind, error) {
-	return r.commonRPC.WaitTerminal(ownerCtx)
-}
-
-// Done returns the invocation context cancellation channel for diagnostics.
-func (r *ServerRPC) Done() <-chan struct{} {
-	return r.ctx.Done()
-}
-
-// _ is a type assertion.
-var _ ServerInvocation = (*ServerRPC)(nil)

package/srpc/server-invocation.ts

@@ -1,76 +0,0 @@
-import type { TerminalKind } from './rpcproto.pb.js'
-
-// ServerInvocation exposes the invocation signal and terminal wait.
-export class ServerInvocation implements AbortSignal {
-  public constructor(
-    public readonly signal: AbortSignal,
-    private readonly waitFn: (
-      ownerSignal: AbortSignal,
-    ) => Promise<TerminalKind>,
-  ) {}
-
-  public get aborted(): boolean {
-    return this.signal.aborted
-  }
-
-  public get onabort() {
-    return this.signal.onabort
-  }
-
-  public set onabort(value: typeof this.signal.onabort) {
-    this.signal.onabort = value
-  }
-
-  public get reason() {
-    return this.signal.reason
-  }
-
-  public throwIfAborted(): void {
-    this.signal.throwIfAborted()
-  }
-
-  public addEventListener<K extends keyof AbortSignalEventMap>(
-    type: K,
-    listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => unknown,
-    options?: boolean | AddEventListenerOptions,
-  ): void
-  public addEventListener(
-    type: string,
-    listener: EventListenerOrEventListenerObject,
-    options?: boolean | AddEventListenerOptions,
-  ): void
-  public addEventListener(
-    type: string,
-    listener: EventListenerOrEventListenerObject,
-    options?: boolean | AddEventListenerOptions,
-  ): void {
-    this.signal.addEventListener(type, listener, options)
-  }
-
-  public removeEventListener<K extends keyof AbortSignalEventMap>(
-    type: K,
-    listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => unknown,
-    options?: boolean | EventListenerOptions,
-  ): void
-  public removeEventListener(
-    type: string,
-    listener: EventListenerOrEventListenerObject,
-    options?: boolean | EventListenerOptions,
-  ): void
-  public removeEventListener(
-    type: string,
-    listener: EventListenerOrEventListenerObject,
-    options?: boolean | EventListenerOptions,
-  ): void {
-    this.signal.removeEventListener(type, listener, options)
-  }
-
-  public dispatchEvent(event: Event): boolean {
-    return this.signal.dispatchEvent(event)
-  }
-
-  // waitTerminal waits for a remote terminal or owner-signal cancellation.
-  public waitTerminal(ownerSignal: AbortSignal): Promise<TerminalKind> {
-    return this.waitFn(ownerSignal)
-  }
-}