typescript 64 lines · 9 steps

Streaming JSON parsing with a depth counter

A ReadableStream transform that emits complete JSON values as they arrive, tracking brace depth to find object boundaries.

Explained by highlit

Advanced streams parsing state-machine backpressure generics

1type JsonValue = Record<string, unknown> | unknown[];
2 
3export function parseJsonStream<T = JsonValue>(
stream: ReadableStream<Uint8Array>,
5): ReadableStream<T> {
const decoder = new TextDecoder();
let buffer = "";
8 
return new ReadableStream<T>({
  async start(controller) {
    const reader = stream.getReader();
    try {
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        buffer += decoder.decode(value, { stream: true });
        buffer = drain(buffer, controller);
      }
      buffer += decoder.decode();
      drain(buffer, controller, true);
      controller.close();
    } catch (err) {
      controller.error(err);
    } finally {
      reader.releaseLock();
    }
  },
});
29 
function drain(input: string, controller: ReadableStreamDefaultController<T>, final = false): string {
  let depth = 0;
  let inString = false;
  let escaped = false;
  let start = -1;
35 
  for (let i = 0; i < input.length; i++) {
    const ch = input[i];
    if (inString) {
      if (escaped) escaped = false;
      else if (ch === "\\") escaped = true;
      else if (ch === '"') inString = false;
      continue;
    }
    if (ch === '"') inString = true;
    else if (ch === "{" || ch === "[") {
      if (depth === 0) start = i;
      depth++;
    } else if (ch === "}" || ch === "]") {
      depth--;
      if (depth === 0 && start !== -1) {
        controller.enqueue(JSON.parse(input.slice(start, i + 1)) as T);
        input = input.slice(i + 1);
        i = -1;
        start = -1;
      }
    }
  }
58 
  if (final && input.trim().length > 0) {
    throw new SyntaxError("Trailing incomplete JSON in stream");
  }
  return input;
}
64}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Tracking nesting depth lets you split a byte stream into complete values without buffering everything.
2String and escape state must be tracked separately so braces inside quoted strings don't corrupt the count.
3Passing { stream: true } to TextDecoder handles multi-byte characters split across chunk boundaries.

Related explainers

ruby

class Order
  class InvalidTransition < StandardError; end
 
  TRANSITIONS = {

A state machine for order transitions in Ruby

state-machine data-driven error-handling

Intermediate 8 steps

typescript

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { ConfigService } from '@nestjs/config';

How a JWT strategy authenticates in NestJS

authentication jwt passport

Intermediate 7 steps

python

import time
import threading
from enum import Enum
from functools import wraps

Building a circuit breaker in Python

circuit-breaker resilience decorators

Advanced 7 steps

typescript

import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpErrorResponse } from '@angular/common/http';
import { BehaviorSubject, Observable, throwError } from 'rxjs';
import { catchError, filter, take, switchMap } from 'rxjs/operators';

Refreshing auth tokens in an Angular interceptor

http-interceptor token-refresh rxjs

Advanced 8 steps

rust

use std::cmp::Ordering;
use std::str::FromStr;
 
#[derive(Debug, Clone, PartialEq, Eq)]

Parsing and ordering semantic versions in Rust

parsing trait-implementation ordering

Intermediate 8 steps

typescript

import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
import { GqlExecutionContext } from '@nestjs/graphql';
import { Reflector } from '@nestjs/core';
import { JwtService } from '@nestjs/jwt';