grpc-dc 0.0.0-stage → 0.30.0

package/src/codec.js

@@ -0,0 +1,220 @@
+// @generated by grpc-dc codegen. DO NOT EDIT.
+// SPDX-License-Identifier: Apache-2.0
+// Frame codec: one DataChannel message == one frame (SPEC.md).
+// type:u8 | stream_id:u32be | payload_len:u32be | payload
+
+import { FrameType, StatusCode, StatusName } from "../wire_gen.js";
+
+export { FrameType, StatusCode, StatusName };
+
+export const HEADER_LEN = 9;
+export const MAX_DATA_PAYLOAD = 16 * 1024 * 1024;
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+export class StatusError extends Error {
+  constructor(code, message = "") {
+    super(`${StatusName[code] ?? `CODE_${code}`}: ${message}`);
+    this.name = "StatusError";
+    this.code = code;
+  }
+  static ok() {
+    return new StatusError(StatusCode.OK, "");
+  }
+  static unimplemented(message) {
+    return new StatusError(StatusCode.UNIMPLEMENTED, message);
+  }
+  static internal(message) {
+    return new StatusError(StatusCode.INTERNAL, message);
+  }
+  static unavailable(message) {
+    return new StatusError(StatusCode.UNAVAILABLE, message);
+  }
+  static invalidArgument(message) {
+    return new StatusError(StatusCode.INVALID_ARGUMENT, message);
+  }
+}
+
+export function encodeFrame(type, streamId, payload = new Uint8Array(0)) {
+  if (!(type in FrameTypeByValue)) {
+    throw StatusError.invalidArgument(`unknown frame type ${type}`);
+  }
+  if (type === FrameType.DATA && payload.length > MAX_DATA_PAYLOAD) {
+    throw new StatusError(StatusCode.RESOURCE_EXHAUSTED, "DATA payload exceeds 16 MiB");
+  }
+  const out = new Uint8Array(HEADER_LEN + payload.length);
+  const view = new DataView(out.buffer);
+  view.setUint8(0, type);
+  view.setUint32(1, streamId, false);
+  view.setUint32(5, payload.length, false);
+  out.set(payload, HEADER_LEN);
+  return out;
+}
+
+const FrameTypeByValue = Object.fromEntries(
+  Object.entries(FrameType).map(([k, v]) => [v, k]),
+);
+
+export function decodeFrame(data) {
+  const bytes = asUint8Array(data);
+  if (bytes.length < HEADER_LEN) {
+    throw StatusError.invalidArgument(`frame shorter than 9-byte header: ${bytes.length} bytes`);
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const type = view.getUint8(0);
+  const streamId = view.getUint32(1, false);
+  const len = view.getUint32(5, false);
+  if (len !== bytes.length - HEADER_LEN) {
+    throw StatusError.invalidArgument(
+      `payload length ${len} does not match message size ${bytes.length}`,
+    );
+  }
+  return { type, streamId, payload: bytes.slice(HEADER_LEN) };
+}
+
+export function asUint8Array(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  throw StatusError.internal("data channel message is not binary");
+}
+
+export function headersFrame(streamId, path, metadata = {}) {
+  const body = path === null ? {} : { path, metadata };
+  return encodeFrame(FrameType.HEADERS, streamId, textEncoder.encode(JSON.stringify(body)));
+}
+
+// gRPC timeout grammar (grpc-timeout metadata): <digits><unit>,
+// units H/M/S/m/u/n (at most 8 digits). Encoding uses
+// milliseconds (seconds past the digit limit), rounded up so a
+// deadline never shrinks in propagation.
+const TIMEOUT_UNITS_MS = { H: 3600000, M: 60000, S: 1000, m: 1, u: 0.001, n: 0.000001 };
+
+export function encodeTimeout(timeoutMs) {
+  const ms = Math.ceil(timeoutMs);
+  if (ms <= 99999999) return `${ms}m`;
+  return `${Math.ceil(timeoutMs / 1000)}S`;
+}
+
+export function parseTimeout(text) {
+  if (typeof text !== "string" || text.length < 2) return null;
+  const unit = TIMEOUT_UNITS_MS[text[text.length - 1]];
+  const digits = text.slice(0, -1);
+  if (unit === undefined || digits.length > 8 || !/^\d+$/.test(digits)) return null;
+  return Number(digits) * unit;
+}
+
+export function statusFrame(frameType, streamId, status) {
+  const body = JSON.stringify({ code: status.code, message: status.message ?? "" });
+  return encodeFrame(frameType, streamId, textEncoder.encode(body));
+}
+
+export function parseHeaders(payload) {
+  try {
+    const parsed = JSON.parse(textDecoder.decode(payload));
+    return { path: parsed.path ?? null, metadata: parsed.metadata ?? {} };
+  } catch {
+    throw StatusError.invalidArgument("malformed HEADERS payload");
+  }
+}
+
+export function parseStatus(payload) {
+  try {
+    const parsed = JSON.parse(textDecoder.decode(payload));
+    return new StatusError(parsed.code ?? 2, parsed.message ?? "");
+  } catch {
+    return StatusError.internal("malformed status payload");
+  }
+}
+
+export function toHex(bytes) {
+  return [...asUint8Array(bytes)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+export function fromHex(hex) {
+  const clean = hex.replace(/\s+/g, "");
+  const out = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+
+// --- Homegrown tracing (W3C traceparent propagation) -------------
+// Dormant until setTracer() registers an observer with
+// onStart(kind, method, traceId, spanId, parentSpanId) and
+// onEnd(kind, method, traceId, spanId, statusName). Generated code
+// stays dependency-free: sampling and export are the app's problem.
+
+let tracer = null;
+
+export function setTracer(t) {
+  tracer = t;
+}
+
+export function getTracer() {
+  return tracer;
+}
+
+let traceFilter = [];
+
+// Restrict traced methods: ';'-separated paths, a trailing '*'
+// means prefix match ('/echo.Echo/*'). Empty = trace all.
+export function setTraceFilter(patterns) {
+  traceFilter = patterns.split(";").filter(Boolean);
+}
+
+function traceAllowed(method) {
+  if (traceFilter.length === 0) return true;
+  return traceFilter.some((p) =>
+    p.endsWith("*") ? method.startsWith(p.slice(0, -1)) : method === p
+  );
+}
+
+function randomHex(bytes) {
+  const buf = new Uint8Array(bytes);
+  if (globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(buf);
+  } else {
+    for (let i = 0; i < bytes; i++) buf[i] = Math.floor(Math.random() * 256);
+  }
+  return toHex(buf);
+}
+
+export function formatTraceparent(traceId, spanId) {
+  return `00-${traceId}-${spanId}-01`;
+}
+
+export function parseTraceparent(value) {
+  if (typeof value !== "string") return null;
+  const parts = value.split("-");
+  if (parts.length !== 4) return null;
+  const [, traceId, spanId] = parts;
+  if (!/^[0-9a-f]{32}$/.test(traceId) || !/^[0-9a-f]{16}$/.test(spanId)) return null;
+  return { traceId, spanId };
+}
+
+export function traceStart(kind, method, parent) {
+  if (tracer === null || !traceAllowed(method)) return null;
+  const ctx = {
+    traceId: parent ? parent.traceId : randomHex(16),
+    spanId: randomHex(8),
+    parentSpanId: parent ? parent.spanId : "",
+  };
+  try {
+    tracer.onStart?.(kind, method, ctx.traceId, ctx.spanId, ctx.parentSpanId);
+  } catch {
+    // observers must never break the call
+  }
+  return ctx;
+}
+
+export function traceEnd(kind, method, ctx, status) {
+  if (ctx === null || tracer === null) return;
+  try {
+    tracer.onEnd?.(kind, method, ctx.traceId, ctx.spanId, status);
+  } catch {
+    // observers must never break the call
+  }
+}

package/src/dynamic.js

@@ -0,0 +1,426 @@
+// @generated by grpc-dc codegen. DO NOT EDIT.
+// SPDX-License-Identifier: Apache-2.0
+// Dynamic, descriptor-driven client and server.
+//
+// Parses a FileDescriptorSet (as produced by
+// `protoc --descriptor_set_out`) at runtime and builds clients and
+// servers whose messages are generic field maps — no generated stubs
+// required. Schemas arrive as data (descriptor.proto), not as code.
+//
+// Generic values by field type: varint family -> number, string ->
+// string, bytes -> Uint8Array, message -> Map, fixed/float -> number,
+// bool -> boolean. GenericMessage wraps Map<number, values[]>.
+
+import { StatusError } from "./codec.js";
+import { StatusCode } from "../wire_gen.js";
+
+export const FieldType = {
+  DOUBLE: 1, FLOAT: 2, INT64: 3, UINT64: 4, INT32: 5, FIXED64: 6,
+  FIXED32: 7, BOOL: 8, STRING: 9, GROUP: 10, MESSAGE: 11, BYTES: 12,
+  UINT32: 13, ENUM: 14, SFIXED32: 15, SFIXED64: 16, SINT32: 17,
+  SINT64: 18,
+};
+
+const VARINT_TYPES = new Set([3, 4, 5, 8, 13, 14, 17, 18]);
+const WIRE_TYPE = new Map();
+for (const t of VARINT_TYPES) WIRE_TYPE.set(t, 0);
+for (const t of [6, 16, 1]) WIRE_TYPE.set(t, 1);
+for (const t of [9, 11, 12, 10]) WIRE_TYPE.set(t, 2);
+for (const t of [7, 15, 2]) WIRE_TYPE.set(t, 5);
+
+const LABEL_REPEATED = 3;
+
+class PbReader {
+  constructor(buf) {
+    this.buf = buf;
+    this.pos = 0;
+  }
+
+  varint() {
+    let result = 0n;
+    let shift = 0n;
+    for (;;) {
+      if (this.pos >= this.buf.length) throw new Error("truncated varint");
+      const b = this.buf[this.pos++];
+      result |= BigInt(b & 0x7f) << shift;
+      if ((b & 0x80) === 0) return result;
+      shift += 7n;
+      if (shift >= 70n) throw new Error("varint too long");
+    }
+  }
+
+  bytesField() {
+    const n = Number(this.varint());
+    if (this.pos + n > this.buf.length) throw new Error("truncated bytes field");
+    const out = this.buf.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+
+  *fields() {
+    while (this.pos < this.buf.length) {
+      const start = this.pos;
+      const tag = this.varint();
+      const number = Number(tag >> 3n);
+      const wire = Number(tag & 7n);
+      if (wire === 0) {
+        const v = this.varint();
+        yield [number, wire, v, this.buf.slice(start, this.pos)];
+      } else if (wire === 2) {
+        const v = this.bytesField();
+        yield [number, wire, v, this.buf.slice(start, this.pos)];
+      } else if (wire === 1) {
+        if (this.pos + 8 > this.buf.length) throw new Error("truncated fixed64");
+        const value = this.buf.subarray(this.pos, this.pos + 8);
+        this.pos += 8;
+        yield [number, wire, value, this.buf.slice(start, this.pos)];
+      } else if (wire === 5) {
+        if (this.pos + 4 > this.buf.length) throw new Error("truncated fixed32");
+        const value = this.buf.subarray(this.pos, this.pos + 4);
+        this.pos += 4;
+        yield [number, wire, value, this.buf.slice(start, this.pos)];
+      } else {
+        throw new Error(`unsupported wire type ${wire}`);
+      }
+    }
+  }
+}
+
+function pbString(fields, number) {
+  for (const [num, , value] of fields) {
+    if (num === number) return new TextDecoder().decode(value);
+  }
+  return "";
+}
+
+function pbUint(fields, number) {
+  for (const [num, , value] of fields) {
+    if (num === number) return value;
+  }
+  return 0n;
+}
+
+export class GenericMessage {
+  constructor(model = null) {
+    this.model = model;
+    this.values = new Map();
+    // Raw encoded chunks of fields not in the model (protobuf
+    // unknown-field retention); re-emitted after known fields.
+    this.unknown = [];
+  }
+
+  set(number, value) {
+    this.values.set(number, [value]);
+    return this;
+  }
+
+  add(number, value) {
+    if (!this.values.has(number)) this.values.set(number, []);
+    this.values.get(number).push(value);
+    return this;
+  }
+
+  getAll(number) {
+    return [...(this.values.get(number) ?? [])];
+  }
+
+  get(number, fallback = undefined) {
+    const items = this.values.get(number);
+    return items && items.length ? items[0] : fallback;
+  }
+
+  getString(number, fallback = "") {
+    const value = this.get(number);
+    return typeof value === "string" ? value : fallback;
+  }
+
+  getInt(number, fallback = 0) {
+    const value = this.get(number);
+    return typeof value === "number" ? value : fallback;
+  }
+}
+
+function encodeVarint(value) {
+  let v = BigInt(value) & 0xffffffffffffffffn;
+  const out = [];
+  while (v > 0x7fn) {
+    out.push(Number((v & 0x7fn) | 0x80n));
+    v >>= 7n;
+  }
+  out.push(Number(v));
+  return Uint8Array.from(out);
+}
+
+function concatBytes(parts) {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+
+function encodeValue(field, value, fileModel) {
+  const wire = WIRE_TYPE.get(field.type);
+  const parts = [encodeVarint(BigInt((field.number << 3) | wire))];
+  if (wire === 0) {
+    if (field.type === FieldType.SINT32 || field.type === FieldType.SINT64) {
+      const v = BigInt(value);
+      parts.push(encodeVarint((v << 1n) ^ (v >> 63n)));
+    } else if (field.type === FieldType.BOOL) {
+      parts.push(encodeVarint(value ? 1 : 0));
+    } else {
+      parts.push(encodeVarint(BigInt(value)));
+    }
+  } else if (wire === 1) {
+    const buf = new Uint8Array(8);
+    const view = new DataView(buf.buffer);
+    if (field.type === FieldType.DOUBLE) view.setFloat64(0, value, true);
+    else view.setBigUint64(0, BigInt(value), true);
+    parts.push(buf);
+  } else if (wire === 5) {
+    const buf = new Uint8Array(4);
+    const view = new DataView(buf.buffer);
+    if (field.type === FieldType.FLOAT) view.setFloat32(0, value, true);
+    else view.setUint32(0, value, true);
+    parts.push(buf);
+  } else {
+    let data;
+    if (field.type === FieldType.STRING) data = new TextEncoder().encode(value);
+    else if (field.type === FieldType.MESSAGE) {
+      data = encodeGeneric(fileModel.messages.get(field.typeName), value, fileModel);
+    } else data = value;
+    parts.push(encodeVarint(data.length), data);
+  }
+  return concatBytes(parts);
+}
+
+export function encodeGeneric(model, message, fileModel) {
+  const parts = [];
+  const numbers = [...message.values.keys()].sort((a, b) => a - b);
+  for (const number of numbers) {
+    const field = model.fields.get(number);
+    if (!field) {
+      throw new StatusError(StatusCode.INVALID_ARGUMENT, `unknown field ${number} for ${model.fullName}`);
+    }
+    const values = message.values.get(number);
+    if (field.repeated) {
+      for (const value of values) parts.push(encodeValue(field, value, fileModel));
+    } else if (values.length) {
+      parts.push(encodeValue(field, values[0], fileModel));
+    }
+  }
+  for (const chunk of message.unknown ?? []) parts.push(chunk);
+  return concatBytes(parts);
+}
+
+function decodeValue(field, wire, raw, fileModel) {
+  if (wire === 0) {
+    if (field.type === FieldType.BOOL) return raw !== 0n;
+    if (field.type === FieldType.SINT32 || field.type === FieldType.SINT64) {
+      return Number((raw >> 1n) ^ -(raw & 1n));
+    }
+    if (field.type === FieldType.INT32 || field.type === FieldType.ENUM) {
+      return Number(BigInt.asIntN(32, raw));
+    }
+    if (field.type === FieldType.INT64) return Number(BigInt.asIntN(64, raw));
+    return Number(raw);
+  }
+  if (wire === 1) {
+    const view = new DataView(raw.buffer, raw.byteOffset, 8);
+    if (field.type === FieldType.DOUBLE) return view.getFloat64(0, true);
+    return Number(view.getBigUint64(0, true));
+  }
+  if (wire === 5) {
+    const view = new DataView(raw.buffer, raw.byteOffset, 4);
+    if (field.type === FieldType.FLOAT) return view.getFloat32(0, true);
+    return view.getUint32(0, true);
+  }
+  if (field.type === FieldType.STRING) return new TextDecoder().decode(raw);
+  if (field.type === FieldType.MESSAGE) {
+    return decodeGeneric(fileModel.messages.get(field.typeName), raw, fileModel);
+  }
+  return new Uint8Array(raw);
+}
+
+export function decodeGeneric(model, data, fileModel) {
+  const message = new GenericMessage(model);
+  for (const [number, wire, raw, chunk] of new PbReader(data).fields()) {
+    const field = model.fields.get(number);
+    if (!field) {
+      // Unknown field: retain the raw encoded chunk verbatim.
+      message.unknown.push(chunk);
+      continue;
+    }
+    if (!message.values.has(number)) message.values.set(number, []);
+    message.values.get(number).push(decodeValue(field, wire, raw, fileModel));
+  }
+  return message;
+}
+
+export function parseDescriptorSet(data) {
+  const fileModel = { messages: new Map(), services: new Map() };
+  const pending = [];
+  for (const [number, , fileBytes] of new PbReader(data).fields()) {
+    if (number !== 1) continue;
+    const fields = [...new PbReader(fileBytes).fields()];
+    const pkg = pbString(fields, 2);
+    for (const [fnum, , fval] of fields) {
+      if (fnum === 4) parseMessage(pkg, "", fval, fileModel);
+      else if (fnum === 6) pending.push([pkg, fval]);
+    }
+  }
+  for (const [pkg, serviceBytes] of pending) {
+    parseService(pkg, serviceBytes, fileModel);
+  }
+  return fileModel;
+}
+
+function parseMessage(pkg, outer, data, fileModel) {
+  const fields = [...new PbReader(data).fields()];
+  const name = pbString(fields, 1);
+  const full = (pkg ? pkg + "." : "") + (outer ? outer + "." : "") + name;
+  const model = { fullName: full, fields: new Map() };
+  fileModel.messages.set("." + full, model);
+  for (const [fnum, , fval] of fields) {
+    if (fnum === 2) {
+      const field = parseField(fval);
+      model.fields.set(field.number, field);
+    } else if (fnum === 3) {
+      parseMessage(pkg, full.slice(pkg ? pkg.length + 1 : 0), fval, fileModel);
+    }
+  }
+  return model;
+}
+
+function parseField(data) {
+  const fields = [...new PbReader(data).fields()];
+  return {
+    number: Number(pbUint(fields, 3)),
+    name: pbString(fields, 1),
+    type: Number(pbUint(fields, 5)),
+    repeated: Number(pbUint(fields, 4)) === LABEL_REPEATED,
+    typeName: pbString(fields, 6),
+  };
+}
+
+function methodKind(clientStreaming, serverStreaming) {
+  if (clientStreaming && serverStreaming) return "bidi";
+  if (serverStreaming) return "server-streaming";
+  if (clientStreaming) return "client-streaming";
+  return "unary";
+}
+
+function parseService(pkg, data, fileModel) {
+  const fields = [...new PbReader(data).fields()];
+  const name = pbString(fields, 1);
+  const full = pkg ? `${pkg}.${name}` : name;
+  const service = { fullName: full, methods: new Map() };
+  fileModel.services.set(full, service);
+  for (const [fnum, , fval] of fields) {
+    if (fnum !== 2) continue;
+    const mf = [...new PbReader(fval).fields()];
+    const mname = pbString(mf, 1);
+    service.methods.set(mname, {
+      name: mname,
+      path: `/${full}/${mname}`,
+      kind: methodKind(pbUint(mf, 5) !== 0n, pbUint(mf, 6) !== 0n),
+      input: fileModel.messages.get(pbString(mf, 2)),
+      output: fileModel.messages.get(pbString(mf, 3)),
+    });
+  }
+  return service;
+}
+
+function boundType(model, fileModel) {
+  return {
+    encode: (generic) => encodeGeneric(model, generic ?? new GenericMessage(model), fileModel),
+    decode: (bytes) => decodeGeneric(model, bytes, fileModel),
+  };
+}
+
+/** Runtime-built client: methods resolve from the file model. */
+export class DynamicClient {
+  #channel;
+  #model;
+
+  constructor(channel, fileModel) {
+    this.#channel = channel;
+    this.#model = fileModel;
+  }
+
+  #method(serviceName, methodName) {
+    const service = this.#model.services.get(serviceName);
+    if (!service) throw new StatusError(StatusCode.INVALID_ARGUMENT, `unknown service ${serviceName}`);
+    const method = service.methods.get(methodName);
+    if (!method) throw new StatusError(StatusCode.INVALID_ARGUMENT, `unknown method ${methodName}`);
+    return method;
+  }
+
+  async unary(serviceName, methodName, request, { metadata } = {}) {
+    const method = this.#method(serviceName, methodName);
+    return this.#channel.unary(method.path, request,
+      boundType(method.input, this.#model), boundType(method.output, this.#model), { metadata });
+  }
+
+  async serverStream(serviceName, methodName, request, { metadata } = {}) {
+    const method = this.#method(serviceName, methodName);
+    return this.#channel.serverStream(method.path, request,
+      boundType(method.input, this.#model), boundType(method.output, this.#model), { metadata });
+  }
+
+  async clientStream(serviceName, methodName, requests, { metadata } = {}) {
+    const method = this.#method(serviceName, methodName);
+    return this.#channel.clientStream(method.path, requests,
+      boundType(method.input, this.#model), boundType(method.output, this.#model), { metadata });
+  }
+
+  async bidi(serviceName, methodName, requests, { metadata } = {}) {
+    const method = this.#method(serviceName, methodName);
+    return this.#channel.bidi(method.path, requests,
+      boundType(method.input, this.#model), boundType(method.output, this.#model), { metadata });
+  }
+}
+
+/**
+ * Build a Server service definition from descriptors + a handler
+ * object with methods by kind:
+ *   unary(ctx, method, request) -> GenericMessage
+ *   serverStream(ctx, method, request) -> iterable/async iterable of GenericMessage
+ *   clientStream(ctx, method, requests) -> GenericMessage
+ *   bidi(ctx, method, requests) -> iterable/async iterable of GenericMessage
+ * (requests are async iterables of GenericMessage.) Pass the result
+ * to server.addService(definition).
+ */
+export function createDynamicService(fileModel, serviceName, handler) {
+  const service = fileModel.services.get(serviceName);
+  if (!service) throw new StatusError(StatusCode.INVALID_ARGUMENT, `unknown service ${serviceName}`);
+  const methods = {};
+  for (const method of service.methods.values()) {
+    methods[method.name] = {
+      path: method.path,
+      kind: method.kind,
+      requestType: boundType(method.input, fileModel),
+      responseType: boundType(method.output, fileModel),
+      handler: async (...args) => {
+        if (method.kind === "unary") {
+          const [req, ctx] = args;
+          return handler.unary(ctx, method, req);
+        }
+        if (method.kind === "server-streaming") {
+          const [req, ctx] = args;
+          return handler.serverStream(ctx, method, req);
+        }
+        if (method.kind === "client-streaming") {
+          const [requests, ctx] = args;
+          return handler.clientStream(ctx, method, requests);
+        }
+        const [requests, ctx] = args;
+        return handler.bidi(ctx, method, requests);
+      },
+    };
+  }
+  return { name: service.fullName, methods };
+}