HN 日本語サマリー

← 一覧へ戻る
プログラミング

Show HN: Frond – アプリケーションの依存グラフのためのフロントエンドランタイム

Show HN: Frond – a frontend runtime for your app's dependency graph (frondruntime.dev)

4 pointsby romanonthego2 コメント

要約

Frondは、アプリケーションの依存グラフを管理するためのフロントエンドランタイムです。既存のステート管理ツールが「値はどこにあるのか?」に答えるのに対し、Frondは「ステートはいつ存在を許されるのか?」という問いに答えます。これにより、ステートのライフサイクル、依存関係、キャンセレーション、リソース管理などを統合的に扱うことができます。

全文翻訳

Reactはあなたのランタイムではない。Frondがそうである。

あなたのアプリにはすでにランタイムが存在します。それはプロバイダー、エフェクト、クリーンアップスクリプトのあちこちに散らばっています。Frondはそれをグラフ化します。エフェクトがそれを実行します。Reactはレンダラーのままでいられます。

成長するあらゆるフロントエンドアプリは、同じ問題に直面します。サービスが互いにどのように依存しているか、そして現在のユーザーが変わったときに何をクリーンアップすべきかということです。成長するフロントエンドアプリのほとんどは、同じ形状にたどり着きます。その実装は、手作業で維持するチェックリストなのです。

Frondなしの場合

today / sign-out checklist

async function signOut() {
  await session.end();

  // ↓ ユーザーごとのあらゆるものを手動でリストアップ。
  localStorage.removeItem("token");
  queryClient.clear();          // キャッシュされたクエリ
  abortInFlightRequests();      // 実行中のフェッチ
  presenceChannel.leave();      // リアルタイムプレゼンス
  socket.disconnect();          // リアルタイムトランスポート
  billingStore.reset();         // ドメインストア
  navigate("/login");

  // ユーザーごとの新しいサービスを追加しましたか?
  // ここにも行を追加するのを忘れないでください。
}

手動によるメモリリーク
新しいユーザーごとのサービスを追加するたびに、覚えるべき行が1つ増えます。1つでも漏らすと、古いユーザーがストア、ソケット、分析ID、古い更新、実行中のリクエストなどを通じて漏れ出す可能性があります。

Frondの場合

frond / auth action

type SessionSpec = Frond.NodeSpec<{
  readonly args: Frond.Args.None;
  readonly key: Frond.Key.Singleton;
  readonly result: Session;
}>;

export class SessionNode extends Frond.NodeBase<SessionSpec> {
  static readonly spec = Frond.serviceSpec<SessionSpec>({
    tag: Frond.tag("app/session"),
    key: () => Frond.Key.singleton(),
    driver: Frond.Driver.Async<SessionSpec>({
      acquire: Frond.Driver.Acquire(({ signal }) =>
        restoreSession(signal)
      ),
    }),
  });
}

// 1回の呼び出し — 依存するすべてのノードが
// エビクトされ、中断され、解放されます。
function useSignOut() {
  const controls = FrondReact.useNodeControls(SessionNode, {});
  return () => controls.evict("selfAndDependents", "sign-out");
}

frond / user-scoped resource

type PresenceSpec = Frond.NodeSpec<{
  readonly args: Frond.Args.None;
  readonly key: Frond.Key.Singleton;
  readonly deps: {
    readonly socket: Frond.Dep<typeof SocketNode>;
    readonly session: Frond.Dep<typeof SessionNode>;
  };
  readonly result: PresenceChannel;
}>;

export class PresenceNode extends Frond.NodeBase<PresenceSpec> {
  static readonly spec = Frond.resourceSpec<PresenceSpec>({
    tag: Frond.tag("app/presence"),
    key: () => Frond.Key.singleton(),
    dependencies: Frond.dependencies(() => ({
      socket: Frond.dep(SocketNode, Frond.Args.none),
      session: Frond.dep(SessionNode, Frond.Args.none),
    })),
    driver: Frond.Driver.Async<PresenceSpec>({
      // 取得時にユーザーのプレゼンスチャネルに参加 —
      // ソケットは独自のペースでハートビートします。
      acquire: Frond.Driver.Acquire(({ deps }) =>
        deps.socket.result.join("presence", {
          userId: deps.session.result.userId,
          heartbeat: 5_000,
        })
      ),
      // 解放は取得とペアになります —
      // signOut() がプレゼンスについて知る必要はありません。
      release: Frond.Driver.Release(({ node }) =>
        node.result.leave({ reason: "sign-out" })
      ),
    }),
  });
}

ランタイム境界
クリーンアップはリソースを取得したノードに属します。エビクションは、エビクトされたグラフレコードに対して、解放を実行し、実行中の作業をキャンセルし、準備完了状態をクリアし、古いコミットを拒否します。

エビクションと解放について読む

状態ツールが回答

値はどこに存在するのか?

Redux / Zustand
値、ミューテーション、セレクター

React Query
サーバーキャッシュ、無効化、リトライ

MobX
オブザーバブルなドメイン状態

Context
Reactを通じた値の配線

モデルの外側にあるもの

ライフサイクルを所有するのは誰か?
  • この値がロードされる前に何が準備完了である必要があるか?
  • この状態はどのキー付きIDにアタッチされているか?
  • 依存関係が変わったときに実行中の作業をキャンセルするのは何か?
  • エビクション後に古いコミットを拒否するのは誰か?
  • 解放、テレメトリ、リセットはどこに存在するのか?

Frondが回答

いつ状態は存在することが許されるのか?
  • ID
  • オブザーバブルな状態
  • 依存関係
  • 準備完了
  • アクション
  • スコープ
  • 解放
  • エビクション

可視な状態
キャッシュ結果、オブザーバブルなフィールド、計算されたゲッターは可視です。Frondはこれらのエルゴノミクスを維持し、それらをグラフID、準備完了、キャンセル、解放、エビクションにアタッチします。

ランタイムライフサイクル
Reactはノードを読み取ります。MobXはそれをオブザーバブルにします。エフェクトは作業を実行します。Frondはノードがいつ生きているか、準備完了か、古いか、解放されたか、死んでいるかを所有します。

ランタイムとそのグラフ

  1. バックエンドスキーマ
  2. ドライバーの戻り値
  3. node.result
  4. deps.x.result
  5. useNode()

定義 / 型付きドライバー

type ProfileSpec = Frond.NodeSpec<{
  readonly args: Frond.Args.None;
  readonly key: Frond.Key.Singleton;
  readonly deps: {
    readonly auth: Frond.Dep<typeof AuthNode>;
    readonly api: Frond.Dep<typeof ApiNode>;
  };
  readonly result: Profile;
}>;

export class ProfileNode extends Frond.NodeBase<ProfileSpec> {
  static readonly spec = Frond.resourceSpec<ProfileSpec>({
    tag: Frond.tag("app/profile"),
    key: () => Frond.Key.singleton(),
    dependencies: Frond.dependencies(() => ({
      auth: Frond.dep(AuthNode, Frond.Args.none),
      api: Frond.dep(ApiNode, Frond.Args.none),
    })),
    driver: Frond.Driver.Async<ProfileSpec>({
      acquire: Frond.Driver.Acquire(async (ctx) => {
        // ctx.deps.auth.result → AuthState
        // ctx.deps.api.result  → ApiClient
        return await ctx.deps.api.result.user.profile.query({
          userId: ctx.deps.auth.result.userId,
          signal: ctx.signal,
        });
      }),
    }),
  });
}
// Profile はドライバーの戻り値から推論されます — 注釈なし。

依存 / 型の伝播

type BillingSpec = Frond.NodeSpec<{
  readonly args: Frond.Args.None;
  readonly key: Frond.Key.Singleton;
  readonly deps: {
    readonly profile: Frond.Dep<typeof ProfileNode>;
    readonly api: Frond.Dep<typeof ApiNode>;
  };
  readonly result: Billing;
}>;

export class BillingNode extends Frond.NodeBase<BillingSpec> {
  static readonly spec = Frond.resourceSpec<BillingSpec>({
    tag: Frond.tag("app/billing"),
    key: () => Frond.Key.singleton(),
    dependencies: Frond.dependencies(() => ({
      profile: Frond.dep(ProfileNode, Frond.Args.none),
      api: Frond.dep(ApiNode, Frond.Args.none),
    })),
    driver: billingDriver,
  });

  // 注釈なし — dep(ProfileNode) から推論されます。
  get plan() {
    return this.deps.profile.result.plan;
    //                              ^? Plan
  }
}

消費 / 注釈ゼロ

function BillingPage() {
  // ランタイムは準備完了した BillingNode を渡します —
  // isLoading も fallback も guards もありません。
  const node = FrondReact.useNode(BillingNode, {});

  // node.plan は Plan として推論されます
  // dep(ProfileNode) チェーンを通じて。
  return <PlanBadge plan={node.plan} />;
}

コンシューマーキャストなし、手動の依存関係配線なし
グラフは型システムです。dep(ProfileNode) は結果の型を知っています。依存ノードはそれを継承します。Reactはそれを読み取ります。ドライバーの形状が変われば、コンパイラはすべてのコンシューマーを検出します。

Specとクラス — 型付きノードの仕組み

構造化

失敗は kind、tag、retryable、および原因チェーンを運びます。e: unknown はなく、null が何を意味するか推測する必要もありません。

ウォーク可能

ランタイムはチェーンをウォークしてシリアライズ可能なレポートを作成します — フィンガープリント、タグ、コンテキスト、依存関係集計、ランタイムイベントメタデータ。あなたはプロジェクションを書きません。

配線済み

一度だけランタイムにシンクをドロップします。すべての失敗がトラッカーにルーティングされ、グラフを意識したグルーピングが行われます。コンポーネントごとの try/catch や、キャプチャを忘れることはありません。

today / catch and reconstruct context

// すべてのフェッチ、フック、境界線に散らばっています —
// 各 catch は Sentry コンテキストを手動で構築します。
async function loadProfile(userId: string) {
  try {
    return await api.getProfile(userId);
  } catch (e) {
    Sentry.captureException(e, {
      tags: { feature: "profile" },
      // レディネスか?認証か?
      // フラット化された DependencyFailed か?
      // 我々が持っているのは `e: unknown` だけだ。
      // チェーンがない(3回の try/catch で失われた)
      // リトライ可能なフラグがない
      // 一貫したフィンガープリントがない
    });
    throw e;
  }
}

// billing.ts、
// feed.ts、dashboard.ts などでも繰り返します。

frond / 1つのシンク、ウォークされたチェーン

// 1つのシンク。すべてのノードのすべての失敗が
// グラフを意識したグルーピングで Sentry に流れます。
// (または任意のトラッカー — レポートの形状は汎用的です。)

const sentrySink = Frond.Diagnostics.createRuntimeReportSink({
  name: "sentry",
  handleReport: ({ report }) => {
    Sentry.captureException(report.error, {
      fingerprint: [...report.fingerprint],
      // ["frond", kind, rootTag, nodeTag]
      tags: report.tags,
      // { "frond.kind", "frond.retryable",
      //   "frond.root_tag", "frond.node_tag" }
      contexts: report.contexts,
      // { frond, causeChain, dependencyFailures,
      //   runtimeEvent }
      extra: report.extra,
    });
  },
});

const runtime = Frond.createRuntime({
  sinks: [sentrySink],
});

エラーはモデルの一部です
ランタイムは分類し、原因チェーンをウォークし、Sentryスタイルのトラッカー向けに整形されたレポートを作成します — フィンガープリントはグラフのトポロジーでグループ化され、タグは kind と retryable を運び、コンテキストは完全なチェーンを運びます。一度だけ配線します。

エラーがグラフを流れる仕組み

キャンセル

あらゆる場所でのシグナル

すべての取得とリフレッシュは、スコープに配線された signal を受け取ります。ノードがエビクトされると、実行中の作業が中断されます — フェッチは中止され、タイマーはクリアされ、ストリームは閉じられます。

スコープ付きリソース

クリーンアップは逆順に実行される

ソケット、サブスクリプション、インターバル — これらを disposers.add(...) で登録します。解放はそれらを逆順に、ランタイムパス上で実行します。

コンポーズ可能な失敗

スロー、伝播、構造化

ドライバーがスローします。ランタイムはそれをキャッチし、分類し、原因チェーンをアタッチし、すべての依存ノードに通知します。ランタイムは上記と同じ原因チェーンレポートを使用します。

オプトイン

あなたがそれでも書くだろうオーケストレーションを書く。

Frond.Driver.Async を Frond.Driver.Effect に切り替えると、リトライ、制限付き並行処理、タイムアウト、宣言的な失敗分類が得られます — 手作業ではなく、コンポーズされます。

リトライ

Schedule.exponential vs. あなた自身のバックオフループ。

並行処理

Effect.all({ concurrency }) vs. あなた自身の Promise ゲート。

分類

while: (e) => … vs. キャッチ内のネストされた if/else。

frond / effect-mode driver, retry + concurrency + classify

// DashboardSpec: ファサード、api依存関係、3パネルの結果。

export class DashboardNode extends Frond.NodeBase<DashboardSpec> {
  static readonly spec = Frond.facadeSpec<DashboardSpec>({
    tag: Frond.tag("app/dashboard"),
    key: () => Frond.Key.singleton(),
    dependencies: Frond.dependencies(() => ({
      api: Frond.dep(ApiNode, Frond.Args.none),
    })),
    driver: Frond.Driver.Effect<DashboardSpec>({
      acquire: Frond.Driver.Acquire((ctx) =>
        Effect.gen(function* () {
          const fetchPanel = (panel: PanelId) =>
            ctx.tryPromise((signal) =>
              ctx.deps.api.result.dashboard.panel(panel, signal)
            ).pipe(
              // 指数バックオフ、認証エラーの場合は即時失敗。
              Effect.retry({
                schedule: Schedule.exponential("100 millis"),
                times: 3,
                while: (e) => e._tag !== "AuthError",
              }),
              Effect.timeout("5 seconds"),
            );

          // 3つのパネルを並列に、同時に2つまで実行。
          const [activity, billing, feed] = yield* Effect.all(
            [fetchPanel("activity"), fetchPanel("billing"), fetchPanel("feed")],
            { concurrency: 2 }
          );

          return { activity, billing, feed };
        })
      ),
    }),
  });
}

EffectはAPIではなくエンジンです
あなたは Effect.gen を一行も書かずに、キャンセル、スコープ、構造化された失敗を得られます。必要であればエスケープハッチがあります。

ドライバーとEffectモード

おそらくそうではない

  • あなたのアプリはほとんど独立した画面を描画します。
  • データロードはページごとにローカルです。
  • ログアウトは1つのトークンと1つのキャッシュをクリアします。
  • React Query がほとんどの非同期状態を説明します。
  • あなたは長期間続くフロントエンドサービスを持っていません。

おそらくそうである

  • スタートアップに実際の準備完了ゲートがあります。
  • サービスは他のサービスに依存します。
  • ユーザーIDがアプリの半分を無効化します。
  • ソケット、SDK、分析、トランスポートのクリーンアップが必要です。
  • 画面は多くのリソースを集約します。
  • 何かが準備完了でない理由を知る必要があります。

最初のノードを記述する

1つのノードから始めましょう。