@vishalsharma7nov/react-native-proto 0.2.2

package/src/client-factory.ts

@@ -0,0 +1,109 @@
+import { ProtoClientError } from './errors';
+import { streamCall } from './streaming';
+import { resolveConfig, unaryCall } from './transport';
+import type {
+  ClientServices,
+  CodecRegistry,
+  MethodMap,
+  MethodMapEntry,
+  ProtoClient,
+  ProtoClientConfig,
+} from './types';
+
+const MAX_METHODS = 2_000;
+
+function toCamelServiceName(serviceName: string): string {
+  if (!serviceName) {
+    return serviceName;
+  }
+  return serviceName.charAt(0).toLowerCase() + serviceName.slice(1);
+}
+
+function assertMethodMap(methodMap: MethodMap): void {
+  if (!Array.isArray(methodMap)) {
+    throw new ProtoClientError({
+      code: 'INVALID_CONFIG',
+      message: 'methodMap must be an array',
+    });
+  }
+  if (methodMap.length === 0) {
+    throw new ProtoClientError({
+      code: 'INVALID_CONFIG',
+      message: 'methodMap is empty — generate from your .proto files first',
+    });
+  }
+  if (methodMap.length > MAX_METHODS) {
+    throw new ProtoClientError({
+      code: 'INVALID_CONFIG',
+      message: `methodMap exceeds max methods (${MAX_METHODS})`,
+    });
+  }
+}
+
+function createMethodHandler(
+  entry: MethodMapEntry,
+  config: ReturnType<typeof resolveConfig>,
+  codecs: CodecRegistry
+) {
+  if (entry.kind === 'unary') {
+    return async (
+      request: Record<string, unknown> = {},
+      options?: { signal?: AbortSignal }
+    ) =>
+      unaryCall(config, codecs, {
+        entry,
+        request,
+        signal: options?.signal,
+      });
+  }
+
+  return (
+    request: Record<string, unknown> = {},
+    options?: { signal?: AbortSignal }
+  ) =>
+    streamCall(config, codecs, {
+      entry,
+      request,
+      signal: options?.signal,
+    });
+}
+
+/**
+ * Builds a dynamic client from a generated method map and message codecs.
+ * Apps typically call `createClient(config)` which uses the package defaults.
+ */
+export function createClientFromMap(
+  config: ProtoClientConfig,
+  methodMap: MethodMap,
+  codecs: CodecRegistry
+): ProtoClient {
+  const resolved = resolveConfig(config);
+  assertMethodMap(methodMap);
+
+  const services: ClientServices = {};
+
+  for (let i = 0; i < methodMap.length; i += 1) {
+    const entry = methodMap[i];
+    if (!entry) {
+      continue;
+    }
+
+    const serviceKey = toCamelServiceName(entry.serviceName);
+    const existing = services[serviceKey] ?? {};
+    const methodKey =
+      entry.methodName.charAt(0).toLowerCase() + entry.methodName.slice(1);
+
+    existing[methodKey] = createMethodHandler(entry, resolved, codecs);
+    services[serviceKey] = existing;
+  }
+
+  return Object.assign(services, {
+    config: {
+      ...config,
+      baseUrl: resolved.baseUrl,
+      timeoutMs: resolved.timeoutMs,
+      maxResponseBytes: resolved.maxResponseBytes,
+      transport: resolved.transport,
+    },
+  }) as ProtoClient;
+}

package/src/codecs.ts

@@ -0,0 +1,42 @@
+import type { Type } from 'protobufjs';
+import type { CodecRegistry, MessageCodec, ProtobufTypeLike } from './types';
+
+export function codecFromType(type: ProtobufTypeLike): MessageCodec {
+  return {
+    encode(message: Record<string, unknown>) {
+      const value = type.fromObject
+        ? type.fromObject(message)
+        : type.create(message);
+      return type.encode(value).finish();
+    },
+    decode(bytes: Uint8Array) {
+      return type.decode(bytes) as unknown as Record<string, unknown>;
+    },
+  };
+}
+
+export function createCodecRegistry(
+  types: Record<string, ProtobufTypeLike | Type>
+): CodecRegistry {
+  const map = new Map<string, MessageCodec>();
+  const keys = Object.keys(types);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    if (!key) {
+      continue;
+    }
+    const type = types[key];
+    if (type) {
+      map.set(key, codecFromType(type));
+    }
+  }
+
+  return {
+    get(typeName: string) {
+      return map.get(typeName);
+    },
+    has(typeName: string) {
+      return map.has(typeName);
+    },
+  };
+}

package/src/connect/envelope.ts

@@ -0,0 +1,112 @@
+/**
+ * Connect protocol envelope framing (unary streaming / server streaming).
+ * Spec: 1 flag byte + 4-byte big-endian length + payload.
+ *
+ * Flag bits:
+ * - 0x01 compressed
+ * - 0x02 end-stream (JSON trailer / error)
+ */
+
+export const CONNECT_FLAG_COMPRESSED = 0x01;
+export const CONNECT_FLAG_END_STREAM = 0x02;
+
+export type ConnectEnvelope = {
+  flags: number;
+  data: Uint8Array;
+};
+
+export function encodeConnectEnvelope(
+  data: Uint8Array,
+  flags = 0
+): Uint8Array {
+  const out = new Uint8Array(5 + data.byteLength);
+  out[0] = flags & 0xff;
+  const len = data.byteLength;
+  out[1] = (len >>> 24) & 0xff;
+  out[2] = (len >>> 16) & 0xff;
+  out[3] = (len >>> 8) & 0xff;
+  out[4] = len & 0xff;
+  out.set(data, 5);
+  return out;
+}
+
+export function decodeConnectEnvelopes(buffer: Uint8Array): ConnectEnvelope[] {
+  const envelopes: ConnectEnvelope[] = [];
+  let offset = 0;
+  while (offset + 5 <= buffer.byteLength) {
+    const flags = buffer[offset]!;
+    const len =
+      ((buffer[offset + 1]! << 24) |
+        (buffer[offset + 2]! << 16) |
+        (buffer[offset + 3]! << 8) |
+        buffer[offset + 4]!) >>>
+      0;
+    offset += 5;
+    if (offset + len > buffer.byteLength) {
+      break;
+    }
+    envelopes.push({
+      flags,
+      data: buffer.subarray(offset, offset + len),
+    });
+    offset += len;
+  }
+  return envelopes;
+}
+
+export async function* readConnectEnvelopeStream(
+  body: ReadableStream<Uint8Array> | null,
+  maxBytes: number
+): AsyncGenerator<ConnectEnvelope, void, undefined> {
+  if (!body) {
+    return;
+  }
+
+  const reader = body.getReader();
+  let pending = new Uint8Array(0);
+  let total = 0;
+
+  const append = (chunk: Uint8Array) => {
+    total += chunk.byteLength;
+    if (total > maxBytes) {
+      throw new Error(`Connect stream exceeded maxResponseBytes (${maxBytes})`);
+    }
+    const next = new Uint8Array(pending.byteLength + chunk.byteLength);
+    next.set(pending, 0);
+    next.set(chunk, pending.byteLength);
+    pending = next;
+  };
+
+  try {
+    while (true) {
+      while (pending.byteLength >= 5) {
+        const len =
+          ((pending[1]! << 24) |
+            (pending[2]! << 16) |
+            (pending[3]! << 8) |
+            pending[4]!) >>>
+          0;
+        if (pending.byteLength < 5 + len) {
+          break;
+        }
+        const flags = pending[0]!;
+        const data = pending.subarray(5, 5 + len);
+        pending = pending.subarray(5 + len);
+        yield { flags, data };
+        if (flags & CONNECT_FLAG_END_STREAM) {
+          return;
+        }
+      }
+
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value) {
+        append(value);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

package/src/connect/errors.ts

@@ -0,0 +1,86 @@
+import { ProtoClientError, type ProtoErrorCode } from '../errors';
+
+/** Connect / gRPC-like code strings → client error codes */
+const CONNECT_CODE_MAP: Record<string, ProtoErrorCode> = {
+  canceled: 'ABORTED',
+  unknown: 'RPC',
+  invalid_argument: 'INVALID_ARGUMENT',
+  deadline_exceeded: 'TIMEOUT',
+  not_found: 'RPC',
+  already_exists: 'RPC',
+  permission_denied: 'RPC',
+  resource_exhausted: 'RPC',
+  failed_precondition: 'RPC',
+  aborted: 'ABORTED',
+  out_of_range: 'INVALID_ARGUMENT',
+  unimplemented: 'UNSUPPORTED',
+  internal: 'INTERNAL',
+  unavailable: 'NETWORK',
+  data_loss: 'DECODE',
+  unauthenticated: 'RPC',
+};
+
+export type ConnectErrorBody = {
+  code?: string;
+  message?: string;
+  details?: unknown[];
+};
+
+export function mapConnectCode(code: string | undefined): ProtoErrorCode {
+  if (!code) return 'RPC';
+  return CONNECT_CODE_MAP[code.toLowerCase()] ?? 'RPC';
+}
+
+export function connectErrorFromJson(
+  body: ConnectErrorBody,
+  rpcPath: string,
+  status?: number
+): ProtoClientError {
+  const connectCode = (body.code ?? 'unknown').toLowerCase();
+  const retryable =
+    connectCode === 'unavailable' ||
+    connectCode === 'resource_exhausted' ||
+    connectCode === 'deadline_exceeded';
+
+  return new ProtoClientError({
+    code: mapConnectCode(connectCode),
+    message: body.message
+      ? `Connect ${connectCode}: ${body.message}`
+      : `Connect error ${connectCode} for ${rpcPath}`,
+    status,
+    rpcPath,
+    retryable,
+    cause: body,
+  });
+}
+
+export function tryParseConnectError(
+  text: string,
+  rpcPath: string,
+  status?: number
+): ProtoClientError | null {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('{')) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed) as ConnectErrorBody;
+    if (parsed && (parsed.code || parsed.message)) {
+      return connectErrorFromJson(parsed, rpcPath, status);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+export function bytesToUtf8(bytes: Uint8Array): string {
+  if (typeof TextDecoder !== 'undefined') {
+    return new TextDecoder('utf-8').decode(bytes);
+  }
+  let out = '';
+  for (let i = 0; i < bytes.byteLength; i += 1) {
+    out += String.fromCharCode(bytes[i]!);
+  }
+  return out;
+}

package/src/errors.ts

@@ -0,0 +1,81 @@
+export type ProtoErrorCode =
+  | 'INVALID_CONFIG'
+  | 'INVALID_ARGUMENT'
+  | 'TIMEOUT'
+  | 'NETWORK'
+  | 'HTTP'
+  | 'RPC'
+  | 'DECODE'
+  | 'PAYLOAD_TOO_LARGE'
+  | 'ABORTED'
+  | 'INTERNAL'
+  | 'UNSUPPORTED';
+
+export type ProtoClientErrorOptions = {
+  code: ProtoErrorCode;
+  message: string;
+  status?: number;
+  rpcPath?: string;
+  cause?: unknown;
+  retryable?: boolean;
+};
+
+export class ProtoClientError extends Error {
+  readonly code: ProtoErrorCode;
+  readonly status?: number;
+  readonly rpcPath?: string;
+  readonly cause?: unknown;
+  readonly retryable: boolean;
+
+  constructor(options: ProtoClientErrorOptions) {
+    super(options.message);
+    this.name = 'ProtoClientError';
+    this.code = options.code;
+    this.status = options.status;
+    this.rpcPath = options.rpcPath;
+    this.cause = options.cause;
+    this.retryable = options.retryable === true;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export function isProtoClientError(value: unknown): value is ProtoClientError {
+  return value instanceof ProtoClientError;
+}
+
+export function getErrorCode(value: unknown): ProtoErrorCode | undefined {
+  if (isProtoClientError(value)) {
+    return value.code;
+  }
+  return undefined;
+}
+
+export function wrapUnknownError(
+  value: unknown,
+  rpcPath?: string
+): ProtoClientError {
+  if (isProtoClientError(value)) {
+    return value;
+  }
+
+  if (value instanceof Error && value.name === 'AbortError') {
+    return new ProtoClientError({
+      code: 'ABORTED',
+      message: 'Request was aborted',
+      rpcPath,
+      cause: value,
+      retryable: false,
+    });
+  }
+
+  const message =
+    value instanceof Error ? value.message : 'Unexpected client failure';
+
+  return new ProtoClientError({
+    code: 'INTERNAL',
+    message,
+    rpcPath,
+    cause: value,
+    retryable: false,
+  });
+}

package/src/generated/create-api.ts

@@ -0,0 +1,40 @@
+/**
+ * Auto-generated typed API factory. Do not edit by hand.
+ */
+import { createClientFromMap } from '../client-factory';
+import type { ProtoClientConfig } from '../types';
+import { methodMap } from './method-map';
+import { defaultCodecs } from './messages';
+import type {
+  AddUserRequest,
+  DeleteUserRequest,
+  DeleteUserResponse,
+  GetUserByEmailRequest,
+  GetUserByPhoneRequest,
+  GetUserRequest,
+  ListUsersRequest,
+  ListUsersResponse,
+  UpdateUserRequest,
+  User,
+} from './message-types';
+
+export type UserServiceApi = {
+  addUser: (request?: AddUserRequest, options?: { signal?: AbortSignal }) => Promise<User>;
+  getUser: (request?: GetUserRequest, options?: { signal?: AbortSignal }) => Promise<User>;
+  getUserByEmail: (request?: GetUserByEmailRequest, options?: { signal?: AbortSignal }) => Promise<User>;
+  listUsers: (request?: ListUsersRequest, options?: { signal?: AbortSignal }) => Promise<ListUsersResponse>;
+  updateUser: (request?: UpdateUserRequest, options?: { signal?: AbortSignal }) => Promise<User>;
+  deleteUser: (request?: DeleteUserRequest, options?: { signal?: AbortSignal }) => Promise<DeleteUserResponse>;
+  getUserByPhone: (request?: GetUserByPhoneRequest, options?: { signal?: AbortSignal }) => Promise<User>;
+};
+
+export type GeneratedApi = {
+  userService: UserServiceApi;
+  readonly config: ProtoClientConfig;
+};
+
+export function createApi(config: ProtoClientConfig): GeneratedApi {
+  return createClientFromMap(config, methodMap, defaultCodecs) as unknown as GeneratedApi;
+}
+
+export { methodMap, defaultCodecs };

package/src/generated/message-types.ts

@@ -0,0 +1,63 @@
+/**
+ * Auto-generated TypeScript message types. Do not edit by hand.
+ * Parsed from .proto message field definitions (simple regex parser).
+ */
+
+export type AddUserRequest = {
+  name?: string;
+  email?: string;
+  age?: number;
+  phone?: string;
+};
+
+export type DeleteUserRequest = {
+  id?: string;
+};
+
+export type DeleteUserResponse = {
+  success?: boolean;
+  id?: string;
+};
+
+export type GetUserByEmailRequest = {
+  email?: string;
+};
+
+export type GetUserByPhoneRequest = {
+  phone?: string;
+};
+
+export type GetUserRequest = {
+  id?: string;
+};
+
+export type ListUsersRequest = {
+  page?: number;
+  page_size?: number;
+  page_token?: string;
+  query?: string;
+};
+
+export type ListUsersResponse = {
+  users?: User[];
+  next_page_token?: string;
+  total_count?: number;
+};
+
+export type UpdateUserRequest = {
+  id?: string;
+  name?: string;
+  email?: string;
+  age?: number;
+  phone?: string;
+};
+
+export type User = {
+  id?: string;
+  name?: string;
+  email?: string;
+  age?: number;
+  phone?: string;
+  created_at?: number;
+  updated_at?: number;
+};