@vishalsharma7nov/react-native-proto 0.2.2

package/src/generated/messages.ts

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any */
+import type { Type } from 'protobufjs';
+import { createCodecRegistry } from '../codecs';
+// Auto-generated wrapper. Do not edit by hand.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pb = require('./messages.pb.js');
+
+function isType(value: unknown): value is Type {
+  if (!value) return false;
+  if (typeof value !== 'object' && typeof value !== 'function') return false;
+  return typeof (value as Type).encode === 'function' && typeof (value as Type).decode === 'function';
+}
+
+function collectTypes(obj: any, prefix = '', acc: Record<string, Type> = {}) {
+  if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) return acc;
+  if (isType(obj) && prefix) acc[prefix] = obj;
+  for (const key of Object.keys(obj)) {
+    if (['encode','decode','create','fromObject','toObject','encodeDelimited','decodeDelimited','verify','getTypeUrl'].includes(key)) continue;
+    const next = obj[key];
+    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    if (isType(next)) {
+      acc[nextPrefix] = next;
+      continue;
+    }
+    if (next && typeof next === 'object') collectTypes(next, nextPrefix, acc);
+  }
+  return acc;
+}
+
+export const messageTypes = collectTypes(pb);
+export const defaultCodecs = createCodecRegistry(messageTypes);
+
+export const demo = pb.demo;
+export const AddUserRequest = pb?.demo?.AddUserRequest as Type;
+export const DeleteUserRequest = pb?.demo?.DeleteUserRequest as Type;
+export const DeleteUserResponse = pb?.demo?.DeleteUserResponse as Type;
+export const GetUserByEmailRequest = pb?.demo?.GetUserByEmailRequest as Type;
+export const GetUserByPhoneRequest = pb?.demo?.GetUserByPhoneRequest as Type;
+export const GetUserRequest = pb?.demo?.GetUserRequest as Type;
+export const ListUsersRequest = pb?.demo?.ListUsersRequest as Type;
+export const ListUsersResponse = pb?.demo?.ListUsersResponse as Type;
+export const UpdateUserRequest = pb?.demo?.UpdateUserRequest as Type;
+export const User = pb?.demo?.User as Type;
+
+export default pb;

package/src/generated/method-map.ts

@@ -0,0 +1,71 @@
+import type { MethodMap } from '../types';
+
+/**
+ * Auto-generated method map. Do not edit by hand.
+ * Sources: user.proto
+ */
+export const methodMap: MethodMap = [
+  {
+    "serviceName": "UserService",
+    "methodName": "AddUser",
+    "packageName": "demo",
+    "rpcPath": "demo.UserService/AddUser",
+    "requestType": "demo.AddUserRequest",
+    "responseType": "demo.User",
+    "kind": "unary"
+  },
+  {
+    "serviceName": "UserService",
+    "methodName": "GetUser",
+    "packageName": "demo",
+    "rpcPath": "demo.UserService/GetUser",
+    "requestType": "demo.GetUserRequest",
+    "responseType": "demo.User",
+    "kind": "unary"
+  },
+  {
+    "serviceName": "UserService",
+    "methodName": "GetUserByEmail",
+    "packageName": "demo",
+    "rpcPath": "demo.UserService/GetUserByEmail",
+    "requestType": "demo.GetUserByEmailRequest",
+    "responseType": "demo.User",
+    "kind": "unary"
+  },
+  {
+    "serviceName": "UserService",
+    "methodName": "ListUsers",
+    "packageName": "demo",
+    "rpcPath": "demo.UserService/ListUsers",
+    "requestType": "demo.ListUsersRequest",
+    "responseType": "demo.ListUsersResponse",
+    "kind": "unary"
+  },
+  {
+    "serviceName": "UserService",
+    "methodName": "UpdateUser",
+    "packageName": "demo",
+    "rpcPath": "demo.UserService/UpdateUser",
+    "requestType": "demo.UpdateUserRequest",
+    "responseType": "demo.User",
+    "kind": "unary"
+  },
+  {
+    "serviceName": "UserService",
+    "methodName": "DeleteUser",
+    "packageName": "demo",
+    "rpcPath": "demo.UserService/DeleteUser",
+    "requestType": "demo.DeleteUserRequest",
+    "responseType": "demo.DeleteUserResponse",
+    "kind": "unary"
+  },
+  {
+    "serviceName": "UserService",
+    "methodName": "GetUserByPhone",
+    "packageName": "demo",
+    "rpcPath": "demo.UserService/GetUserByPhone",
+    "requestType": "demo.GetUserByPhoneRequest",
+    "responseType": "demo.User",
+    "kind": "unary"
+  }
+];

package/src/index.ts

@@ -0,0 +1,113 @@
+import { createClientFromMap } from "./client-factory";
+import { getErrorCode, isProtoClientError, ProtoClientError } from "./errors";
+import { methodMap } from "./generated/method-map";
+import { defaultCodecs } from "./generated/messages";
+import { isNativeGrpcAvailable } from "./native-grpc";
+import type {
+  CodecRegistry,
+  MethodMap,
+  ProtoClient,
+  ProtoClientConfig,
+} from "./types";
+
+export type {
+  CodecRegistry,
+  HeaderMap,
+  MethodKind,
+  MethodMap,
+  MethodMapEntry,
+  ProtoClient,
+  ProtoClientConfig,
+  TransportKind,
+} from "./types";
+
+export type { CallContext, Interceptor, UnaryHandler } from "./interceptors";
+export type { PathTemplatePreset } from "./path-templates";
+export type { AuthInterceptorOptions } from "./auth";
+export type { LoggingOptions } from "./logging";
+export type { OfflineQueueOptions, QueuedMutation } from "./offline-queue";
+export type { VersionCheckOptions } from "./version-check";
+export type { ZodLikeSchema } from "./validation/zod";
+
+export { getErrorCode, isProtoClientError, ProtoClientError };
+
+export { createClientFromMap } from "./client-factory";
+export { createCodecRegistry, codecFromType } from "./codecs";
+export { composeInterceptors } from "./interceptors";
+export { createAuthInterceptor, createBearerTokenHeaders } from "./auth";
+export { createLoggingInterceptor } from "./logging";
+export { OfflineMutationQueue } from "./offline-queue";
+export { createPathForMethod, pathFromTemplate } from "./path-templates";
+export {
+  CLIENT_VERSION_HEADER,
+  SERVER_MIN_CLIENT_HEADER,
+  METHOD_MAP_HASH_HEADER,
+  compareDottedVersions,
+  versionHeaders,
+  createVersionInterceptor,
+  createVersionAwareFetch,
+  assertServerMinClient,
+} from "./version-check";
+export { withZodValidation, wrapCodecRegistryWithZod } from "./validation/zod";
+export {
+  encodeConnectEnvelope,
+  decodeConnectEnvelopes,
+} from "./connect/envelope";
+export { methodMap } from "./generated/method-map";
+export {
+  AddUserRequest,
+  defaultCodecs,
+  DeleteUserRequest,
+  DeleteUserResponse,
+  GetUserByEmailRequest,
+  GetUserRequest,
+  ListUsersRequest,
+  ListUsersResponse,
+  UpdateUserRequest,
+  User,
+} from "./generated/messages";
+export {
+  isNativeGrpcAvailable,
+  installNativeGrpcBridgeFromNativeModule,
+} from "./native-grpc";
+
+export type CreateClientOptions = ProtoClientConfig & {
+  /** Override generated method map (advanced / tests) */
+  methodMap?: MethodMap;
+  /** Override message codecs (advanced / tests) */
+  codecs?: CodecRegistry;
+};
+
+/**
+ * Create a dynamic API client from package method metadata + your app config.
+ *
+ * @example
+ * const api = createClient({
+ *   baseUrl: 'https://api.example.com',
+ *   getHeaders: () => ({ Authorization: `Bearer ${token}` }),
+ * });
+ * const user = await api.userService.getUser({ id: '1' });
+ */
+export function createClient(config: CreateClientOptions): ProtoClient {
+  const map = config.methodMap ?? methodMap;
+  const codecs = config.codecs ?? defaultCodecs;
+  return createClientFromMap(config, map, codecs);
+}
+
+/** Alias preferred in generated `create-api.ts` drop-ins. */
+export const createApi = createClient;
+
+export function getDefaultMethodMap(): MethodMap {
+  return methodMap;
+}
+
+export function getTransportCapabilities() {
+  return {
+    http: true,
+    connect: true,
+    connectStreaming: true,
+    nativeGrpc: isNativeGrpcAvailable(),
+    interceptors: true,
+    mockServer: true,
+  };
+}

package/src/interceptors.ts

@@ -0,0 +1,32 @@
+import type { HeaderMap, MethodMapEntry } from './types';
+
+export type CallContext = {
+  entry: MethodMapEntry;
+  request: Record<string, unknown>;
+  headers: HeaderMap;
+  signal?: AbortSignal;
+};
+
+export type UnaryHandler = (
+  ctx: CallContext
+) => Promise<Record<string, unknown>>;
+
+/**
+ * Interceptor around a unary RPC. Call `next(ctx)` to continue the chain.
+ */
+export type Interceptor = (
+  ctx: CallContext,
+  next: UnaryHandler
+) => Promise<Record<string, unknown>>;
+
+/**
+ * Compose interceptors left-to-outer (first runs first on the way in).
+ */
+export function composeInterceptors(
+  interceptors: Interceptor[],
+  core: UnaryHandler
+): UnaryHandler {
+  return interceptors.reduceRight<UnaryHandler>((next, interceptor) => {
+    return (ctx) => interceptor(ctx, next);
+  }, core);
+}

package/src/logging.ts

@@ -0,0 +1,67 @@
+import type { Interceptor } from './interceptors';
+
+export type LoggingOptions = {
+  /** Log function (default console.debug) */
+  log?: (message: string, meta?: Record<string, unknown>) => void;
+  /** Redact these header names (case-insensitive). Default: authorization, cookie. */
+  redactHeaders?: string[];
+  /** Include request object in logs (default false — can contain PII). */
+  logRequestBody?: boolean;
+  /** Include response object in logs (default false). */
+  logResponseBody?: boolean;
+};
+
+function redact(
+  headers: Record<string, string>,
+  names: string[]
+): Record<string, string> {
+  const blocked = new Set(names.map((n) => n.toLowerCase()));
+  const out: Record<string, string> = {};
+  const keys = Object.keys(headers);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    if (!key) continue;
+    out[key] = blocked.has(key.toLowerCase()) ? '[redacted]' : headers[key]!;
+  }
+  return out;
+}
+
+/**
+ * Request/response logging interceptor for debug builds.
+ */
+export function createLoggingInterceptor(
+  options: LoggingOptions = {}
+): Interceptor {
+  const log = options.log ?? ((msg, meta) => console.debug(msg, meta));
+  const redactHeaders = options.redactHeaders ?? [
+    'authorization',
+    'cookie',
+    'set-cookie',
+  ];
+
+  return async (ctx, next) => {
+    const started = Date.now();
+    log('proto:request', {
+      rpcPath: ctx.entry.rpcPath,
+      headers: redact(ctx.headers, redactHeaders),
+      ...(options.logRequestBody ? { request: ctx.request } : {}),
+    });
+
+    try {
+      const response = await next(ctx);
+      log('proto:response', {
+        rpcPath: ctx.entry.rpcPath,
+        durationMs: Date.now() - started,
+        ...(options.logResponseBody ? { response } : {}),
+      });
+      return response;
+    } catch (error) {
+      log('proto:error', {
+        rpcPath: ctx.entry.rpcPath,
+        durationMs: Date.now() - started,
+        error,
+      });
+      throw error;
+    }
+  };
+}

package/src/metro/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Metro helper: treat .proto files as raw text assets for tooling/debug.
+ * Prefer `react-native-proto generate` for production clients.
+ */
+export function createProtoMetroConfig(baseConfig: {
+  resolver?: { sourceExts?: string[]; assetExts?: string[] };
+  transformer?: { babelTransformerPath?: string };
+}): typeof baseConfig {
+  const resolver = baseConfig.resolver ?? {};
+  const sourceExts = new Set([...(resolver.sourceExts ?? []), 'proto']);
+  const assetExts = (resolver.assetExts ?? []).filter((ext) => ext !== 'proto');
+
+  return {
+    ...baseConfig,
+    resolver: {
+      ...resolver,
+      sourceExts: Array.from(sourceExts),
+      assetExts,
+    },
+    transformer: {
+      ...baseConfig.transformer,
+      babelTransformerPath: require.resolve('./transformer'),
+    },
+  };
+}
+
+export { transform } from './transformer';

package/src/metro/transformer.ts

@@ -0,0 +1,38 @@
+type TransformArgs = {
+  filename: string;
+  src: string;
+  options?: Record<string, unknown>;
+};
+
+type TransformResult = {
+  code: string;
+  map?: null;
+};
+
+/**
+ * Minimal Metro transformer for .proto files.
+ * Non-proto files fall through to the upstream Babel transformer when present.
+ */
+export async function transform(
+  args: TransformArgs
+): Promise<TransformResult> {
+  const { filename, src } = args;
+
+  if (!filename.endsWith('.proto')) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const upstream = require('@react-native/metro-babel-transformer');
+      if (upstream && typeof upstream.transform === 'function') {
+        return upstream.transform(args);
+      }
+    } catch {
+      // Fall through to identity JS export of source text
+    }
+  }
+
+  const escaped = JSON.stringify(src);
+  return {
+    code: `module.exports = ${escaped};`,
+    map: null,
+  };
+}

package/src/mock-server/index.ts

@@ -0,0 +1,164 @@
+import http from "http";
+import { ProtoClientError } from "../errors";
+import type { CodecRegistry, MethodMap, MethodMapEntry } from "../types";
+
+export type MockHandler = (
+  request: Record<string, unknown>,
+  entry: MethodMapEntry,
+) =>
+  | Record<string, unknown>
+  | Promise<Record<string, unknown>>
+  | AsyncIterable<Record<string, unknown>>;
+
+export type MockServerOptions = {
+  methodMap: MethodMap;
+  codecs: CodecRegistry;
+  /** Map rpcPath or MethodName → handler. Fallback: echo empty response encode attempt. */
+  handlers?: Record<string, MockHandler>;
+  host?: string;
+  port?: number;
+  /** Default transport content-type behavior */
+  contentType?: "application/x-protobuf" | "application/proto";
+};
+
+function matchEntry(
+  methodMap: MethodMap,
+  urlPath: string,
+): MethodMapEntry | undefined {
+  const normalized = urlPath.replace(/^\//, "");
+  for (let i = 0; i < methodMap.length; i += 1) {
+    const entry = methodMap[i];
+    if (!entry) continue;
+    const connectPath = `${entry.packageName ? `${entry.packageName}.` : ""}${entry.serviceName}/${entry.methodName}`;
+    if (
+      normalized === connectPath ||
+      normalized === entry.rpcPath ||
+      urlPath.endsWith(`/${entry.methodName}`)
+    ) {
+      return entry;
+    }
+  }
+  return undefined;
+}
+
+async function readRequestBody(req: http.IncomingMessage): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+
+/**
+ * Tiny local protobuf HTTP mock driven by the same method map + codecs as the client.
+ * Useful for demos and integration tests.
+ */
+export function createMockServer(options: MockServerOptions): {
+  listen: () => Promise<{ host: string; port: number; baseUrl: string }>;
+  close: () => Promise<void>;
+  server: http.Server;
+} {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 0;
+  const contentType = options.contentType ?? "application/x-protobuf";
+  const handlers = options.handlers ?? {};
+
+  const server = http.createServer(async (req, res) => {
+    try {
+      if (req.method !== "POST" || !req.url) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+
+      const url = new URL(req.url, `http://${host}`);
+      const entry = matchEntry(options.methodMap, url.pathname);
+      if (!entry) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end(`Unknown RPC path: ${url.pathname}`);
+        return;
+      }
+
+      const requestCodec = options.codecs.get(entry.requestType);
+      const responseCodec = options.codecs.get(entry.responseType);
+      if (!requestCodec || !responseCodec) {
+        res.writeHead(500);
+        res.end("Missing codecs");
+        return;
+      }
+
+      const raw = await readRequestBody(req);
+      const decoded = requestCodec.decode(new Uint8Array(raw));
+
+      const handler =
+        handlers[entry.rpcPath] ||
+        handlers[entry.methodName] ||
+        handlers[`${entry.serviceName}/${entry.methodName}`];
+
+      let result: Record<string, unknown>;
+      if (handler) {
+        const maybe = await handler(decoded, entry);
+        const asyncIter = maybe as AsyncIterable<Record<string, unknown>>;
+        if (
+          maybe &&
+          typeof maybe === "object" &&
+          typeof asyncIter[Symbol.asyncIterator] === "function"
+        ) {
+          let first: Record<string, unknown> | undefined;
+          for await (const msg of asyncIter) {
+            first = msg;
+            break;
+          }
+          result = first ?? {};
+        } else {
+          result = (maybe as Record<string, unknown>) ?? {};
+        }
+      } else {
+        result = {};
+      }
+
+      const bytes = responseCodec.encode(result);
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Content-Length": String(bytes.byteLength),
+      });
+      res.end(Buffer.from(bytes));
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "Mock server error";
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end(message);
+    }
+  });
+
+  return {
+    server,
+    listen() {
+      return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+          const address = server.address();
+          if (!address || typeof address === "string") {
+            reject(
+              new ProtoClientError({
+                code: "INTERNAL",
+                message: "Failed to bind mock server",
+              }),
+            );
+            return;
+          }
+          resolve({
+            host: address.address,
+            port: address.port,
+            baseUrl: `http://${address.address}:${address.port}`,
+          });
+        });
+      });
+    },
+    close() {
+      return new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+      });
+    },
+  };
+}