@reptilestyle/grpc-js 1.9.14-compression.1

package/src/call.ts

@@ -0,0 +1,200 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { EventEmitter } from 'events';
+import { Duplex, Readable, Writable } from 'stream';
+
+import { StatusObject, MessageContext } from './call-interface';
+import { Status } from './constants';
+import { EmitterAugmentation1 } from './events';
+import { Metadata } from './metadata';
+import { ObjectReadable, ObjectWritable, WriteCallback } from './object-stream';
+import { InterceptingCallInterface } from './client-interceptors';
+
+/**
+ * A type extending the built-in Error object with additional fields.
+ */
+export type ServiceError = StatusObject & Error;
+
+/**
+ * A base type for all user-facing values returned by client-side method calls.
+ */
+export type SurfaceCall = {
+  call?: InterceptingCallInterface;
+  cancel(): void;
+  getPeer(): string;
+} & EmitterAugmentation1<'metadata', Metadata> &
+  EmitterAugmentation1<'status', StatusObject> &
+  EventEmitter;
+
+/**
+ * A type representing the return value of a unary method call.
+ */
+export type ClientUnaryCall = SurfaceCall;
+
+/**
+ * A type representing the return value of a server stream method call.
+ */
+export type ClientReadableStream<ResponseType> = {
+  deserialize: (chunk: Buffer) => ResponseType;
+} & SurfaceCall &
+  ObjectReadable<ResponseType>;
+
+/**
+ * A type representing the return value of a client stream method call.
+ */
+export type ClientWritableStream<RequestType> = {
+  serialize: (value: RequestType) => Buffer;
+} & SurfaceCall &
+  ObjectWritable<RequestType>;
+
+/**
+ * A type representing the return value of a bidirectional stream method call.
+ */
+export type ClientDuplexStream<RequestType, ResponseType> =
+  ClientWritableStream<RequestType> & ClientReadableStream<ResponseType>;
+
+/**
+ * Construct a ServiceError from a StatusObject. This function exists primarily
+ * as an attempt to make the error stack trace clearly communicate that the
+ * error is not necessarily a problem in gRPC itself.
+ * @param status
+ */
+export function callErrorFromStatus(
+  status: StatusObject,
+  callerStack: string
+): ServiceError {
+  const message = `${status.code} ${Status[status.code]}: ${status.details}`;
+  const error = new Error(message);
+  const stack = `${error.stack}\nfor call at\n${callerStack}`;
+  return Object.assign(new Error(message), status, { stack });
+}
+
+export class ClientUnaryCallImpl
+  extends EventEmitter
+  implements ClientUnaryCall
+{
+  public call?: InterceptingCallInterface;
+  constructor() {
+    super();
+  }
+
+  cancel(): void {
+    this.call?.cancelWithStatus(Status.CANCELLED, 'Cancelled on client');
+  }
+
+  getPeer(): string {
+    return this.call?.getPeer() ?? 'unknown';
+  }
+}
+
+export class ClientReadableStreamImpl<ResponseType>
+  extends Readable
+  implements ClientReadableStream<ResponseType>
+{
+  public call?: InterceptingCallInterface;
+  constructor(readonly deserialize: (chunk: Buffer) => ResponseType) {
+    super({ objectMode: true });
+  }
+
+  cancel(): void {
+    this.call?.cancelWithStatus(Status.CANCELLED, 'Cancelled on client');
+  }
+
+  getPeer(): string {
+    return this.call?.getPeer() ?? 'unknown';
+  }
+
+  _read(_size: number): void {
+    this.call?.startRead();
+  }
+}
+
+export class ClientWritableStreamImpl<RequestType>
+  extends Writable
+  implements ClientWritableStream<RequestType>
+{
+  public call?: InterceptingCallInterface;
+  constructor(readonly serialize: (value: RequestType) => Buffer) {
+    super({ objectMode: true });
+  }
+
+  cancel(): void {
+    this.call?.cancelWithStatus(Status.CANCELLED, 'Cancelled on client');
+  }
+
+  getPeer(): string {
+    return this.call?.getPeer() ?? 'unknown';
+  }
+
+  _write(chunk: RequestType, encoding: string, cb: WriteCallback) {
+    const context: MessageContext = {
+      callback: cb,
+    };
+    const flags = Number(encoding);
+    if (!Number.isNaN(flags)) {
+      context.flags = flags;
+    }
+    this.call?.sendMessageWithContext(context, chunk);
+  }
+
+  _final(cb: Function) {
+    this.call?.halfClose();
+    cb();
+  }
+}
+
+export class ClientDuplexStreamImpl<RequestType, ResponseType>
+  extends Duplex
+  implements ClientDuplexStream<RequestType, ResponseType>
+{
+  public call?: InterceptingCallInterface;
+  constructor(
+    readonly serialize: (value: RequestType) => Buffer,
+    readonly deserialize: (chunk: Buffer) => ResponseType
+  ) {
+    super({ objectMode: true });
+  }
+
+  cancel(): void {
+    this.call?.cancelWithStatus(Status.CANCELLED, 'Cancelled on client');
+  }
+
+  getPeer(): string {
+    return this.call?.getPeer() ?? 'unknown';
+  }
+
+  _read(_size: number): void {
+    this.call?.startRead();
+  }
+
+  _write(chunk: RequestType, encoding: string, cb: WriteCallback) {
+    const context: MessageContext = {
+      callback: cb,
+    };
+    const flags = Number(encoding);
+    if (!Number.isNaN(flags)) {
+      context.flags = flags;
+    }
+    this.call?.sendMessageWithContext(context, chunk);
+  }
+
+  _final(cb: Function) {
+    this.call?.halfClose();
+    cb();
+  }
+}

package/src/channel-credentials.ts

@@ -0,0 +1,267 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import {
+  ConnectionOptions,
+  createSecureContext,
+  PeerCertificate,
+  SecureContext,
+} from 'tls';
+
+import { CallCredentials } from './call-credentials';
+import { CIPHER_SUITES, getDefaultRootsData } from './tls-helpers';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function verifyIsBufferOrNull(obj: any, friendlyName: string): void {
+  if (obj && !(obj instanceof Buffer)) {
+    throw new TypeError(`${friendlyName}, if provided, must be a Buffer.`);
+  }
+}
+
+/**
+ * A callback that will receive the expected hostname and presented peer
+ * certificate as parameters. The callback should return an error to
+ * indicate that the presented certificate is considered invalid and
+ * otherwise returned undefined.
+ */
+export type CheckServerIdentityCallback = (
+  hostname: string,
+  cert: PeerCertificate
+) => Error | undefined;
+
+/**
+ * Additional peer verification options that can be set when creating
+ * SSL credentials.
+ */
+export interface VerifyOptions {
+  /**
+   * If set, this callback will be invoked after the usual hostname verification
+   * has been performed on the peer certificate.
+   */
+  checkServerIdentity?: CheckServerIdentityCallback;
+}
+
+/**
+ * A class that contains credentials for communicating over a channel, as well
+ * as a set of per-call credentials, which are applied to every method call made
+ * over a channel initialized with an instance of this class.
+ */
+export abstract class ChannelCredentials {
+  protected callCredentials: CallCredentials;
+
+  protected constructor(callCredentials?: CallCredentials) {
+    this.callCredentials = callCredentials || CallCredentials.createEmpty();
+  }
+  /**
+   * Returns a copy of this object with the included set of per-call credentials
+   * expanded to include callCredentials.
+   * @param callCredentials A CallCredentials object to associate with this
+   * instance.
+   */
+  abstract compose(callCredentials: CallCredentials): ChannelCredentials;
+
+  /**
+   * Gets the set of per-call credentials associated with this instance.
+   */
+  _getCallCredentials(): CallCredentials {
+    return this.callCredentials;
+  }
+
+  /**
+   * Gets a SecureContext object generated from input parameters if this
+   * instance was created with createSsl, or null if this instance was created
+   * with createInsecure.
+   */
+  abstract _getConnectionOptions(): ConnectionOptions | null;
+
+  /**
+   * Indicates whether this credentials object creates a secure channel.
+   */
+  abstract _isSecure(): boolean;
+
+  /**
+   * Check whether two channel credentials objects are equal. Two secure
+   * credentials are equal if they were constructed with the same parameters.
+   * @param other The other ChannelCredentials Object
+   */
+  abstract _equals(other: ChannelCredentials): boolean;
+
+  /**
+   * Return a new ChannelCredentials instance with a given set of credentials.
+   * The resulting instance can be used to construct a Channel that communicates
+   * over TLS.
+   * @param rootCerts The root certificate data.
+   * @param privateKey The client certificate private key, if available.
+   * @param certChain The client certificate key chain, if available.
+   * @param verifyOptions Additional options to modify certificate verification
+   */
+  static createSsl(
+    rootCerts?: Buffer | null,
+    privateKey?: Buffer | null,
+    certChain?: Buffer | null,
+    verifyOptions?: VerifyOptions
+  ): ChannelCredentials {
+    verifyIsBufferOrNull(rootCerts, 'Root certificate');
+    verifyIsBufferOrNull(privateKey, 'Private key');
+    verifyIsBufferOrNull(certChain, 'Certificate chain');
+    if (privateKey && !certChain) {
+      throw new Error(
+        'Private key must be given with accompanying certificate chain'
+      );
+    }
+    if (!privateKey && certChain) {
+      throw new Error(
+        'Certificate chain must be given with accompanying private key'
+      );
+    }
+    const secureContext = createSecureContext({
+      ca: rootCerts ?? getDefaultRootsData() ?? undefined,
+      key: privateKey ?? undefined,
+      cert: certChain ?? undefined,
+      ciphers: CIPHER_SUITES,
+    });
+    return new SecureChannelCredentialsImpl(secureContext, verifyOptions ?? {});
+  }
+
+  /**
+   * Return a new ChannelCredentials instance with credentials created using
+   * the provided secureContext. The resulting instances can be used to
+   * construct a Channel that communicates over TLS. gRPC will not override
+   * anything in the provided secureContext, so the environment variables
+   * GRPC_SSL_CIPHER_SUITES and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH will
+   * not be applied.
+   * @param secureContext The return value of tls.createSecureContext()
+   * @param verifyOptions Additional options to modify certificate verification
+   */
+  static createFromSecureContext(
+    secureContext: SecureContext,
+    verifyOptions?: VerifyOptions
+  ): ChannelCredentials {
+    return new SecureChannelCredentialsImpl(secureContext, verifyOptions ?? {});
+  }
+
+  /**
+   * Return a new ChannelCredentials instance with no credentials.
+   */
+  static createInsecure(): ChannelCredentials {
+    return new InsecureChannelCredentialsImpl();
+  }
+}
+
+class InsecureChannelCredentialsImpl extends ChannelCredentials {
+  constructor(callCredentials?: CallCredentials) {
+    super(callCredentials);
+  }
+
+  compose(callCredentials: CallCredentials): never {
+    throw new Error('Cannot compose insecure credentials');
+  }
+
+  _getConnectionOptions(): ConnectionOptions | null {
+    return null;
+  }
+  _isSecure(): boolean {
+    return false;
+  }
+  _equals(other: ChannelCredentials): boolean {
+    return other instanceof InsecureChannelCredentialsImpl;
+  }
+}
+
+class SecureChannelCredentialsImpl extends ChannelCredentials {
+  connectionOptions: ConnectionOptions;
+
+  constructor(
+    private secureContext: SecureContext,
+    private verifyOptions: VerifyOptions
+  ) {
+    super();
+    this.connectionOptions = {
+      secureContext,
+    };
+    // Node asserts that this option is a function, so we cannot pass undefined
+    if (verifyOptions?.checkServerIdentity) {
+      this.connectionOptions.checkServerIdentity =
+        verifyOptions.checkServerIdentity;
+    }
+  }
+
+  compose(callCredentials: CallCredentials): ChannelCredentials {
+    const combinedCallCredentials =
+      this.callCredentials.compose(callCredentials);
+    return new ComposedChannelCredentialsImpl(this, combinedCallCredentials);
+  }
+
+  _getConnectionOptions(): ConnectionOptions | null {
+    // Copy to prevent callers from mutating this.connectionOptions
+    return { ...this.connectionOptions };
+  }
+  _isSecure(): boolean {
+    return true;
+  }
+  _equals(other: ChannelCredentials): boolean {
+    if (this === other) {
+      return true;
+    }
+    if (other instanceof SecureChannelCredentialsImpl) {
+      return (
+        this.secureContext === other.secureContext &&
+        this.verifyOptions.checkServerIdentity ===
+          other.verifyOptions.checkServerIdentity
+      );
+    } else {
+      return false;
+    }
+  }
+}
+
+class ComposedChannelCredentialsImpl extends ChannelCredentials {
+  constructor(
+    private channelCredentials: SecureChannelCredentialsImpl,
+    callCreds: CallCredentials
+  ) {
+    super(callCreds);
+  }
+  compose(callCredentials: CallCredentials) {
+    const combinedCallCredentials =
+      this.callCredentials.compose(callCredentials);
+    return new ComposedChannelCredentialsImpl(
+      this.channelCredentials,
+      combinedCallCredentials
+    );
+  }
+
+  _getConnectionOptions(): ConnectionOptions | null {
+    return this.channelCredentials._getConnectionOptions();
+  }
+  _isSecure(): boolean {
+    return true;
+  }
+  _equals(other: ChannelCredentials): boolean {
+    if (this === other) {
+      return true;
+    }
+    if (other instanceof ComposedChannelCredentialsImpl) {
+      return (
+        this.channelCredentials._equals(other.channelCredentials) &&
+        this.callCredentials._equals(other.callCredentials)
+      );
+    } else {
+      return false;
+    }
+  }
+}

package/src/channel-options.ts

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { CompressionAlgorithms } from './compression-algorithms';
+
+/**
+ * An interface that contains options used when initializing a Channel instance.
+ */
+export interface ChannelOptions {
+  'grpc.ssl_target_name_override'?: string;
+  'grpc.primary_user_agent'?: string;
+  'grpc.secondary_user_agent'?: string;
+  'grpc.default_authority'?: string;
+  'grpc.keepalive_time_ms'?: number;
+  'grpc.keepalive_timeout_ms'?: number;
+  'grpc.keepalive_permit_without_calls'?: number;
+  'grpc.service_config'?: string;
+  'grpc.max_concurrent_streams'?: number;
+  'grpc.initial_reconnect_backoff_ms'?: number;
+  'grpc.max_reconnect_backoff_ms'?: number;
+  'grpc.use_local_subchannel_pool'?: number;
+  'grpc.max_send_message_length'?: number;
+  'grpc.max_receive_message_length'?: number;
+  'grpc.enable_http_proxy'?: number;
+  /* http_connect_target and http_connect_creds are used for passing data
+   * around internally, and should not be documented as public-facing options
+   */
+  'grpc.http_connect_target'?: string;
+  'grpc.http_connect_creds'?: string;
+  'grpc.default_compression_algorithm'?: CompressionAlgorithms;
+  'grpc.enable_channelz'?: number;
+  'grpc.dns_min_time_between_resolutions_ms'?: number;
+  'grpc.enable_retries'?: number;
+  'grpc.per_rpc_retry_buffer_size'?: number;
+  /* This option is pattered like a core option, but the core does not have
+   * this option. It is closely related to the option
+   * grpc.per_rpc_retry_buffer_size, which is in the core. The core will likely
+   * implement this functionality using the ResourceQuota mechanism, so there
+   * will probably not be any collision or other inconsistency. */
+  'grpc.retry_buffer_size'?: number;
+  'grpc.max_connection_age_ms'?: number;
+  'grpc.max_connection_age_grace_ms'?: number;
+  'grpc-node.max_session_memory'?: number;
+  'grpc.service_config_disable_resolution'?: number;
+  'grpc.client_idle_timeout_ms'?: number;
+  /**
+   * Set the enableTrace option in TLS clients and servers
+   */
+  'grpc-node.tls_enable_trace'?: number;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any;
+}
+
+/**
+ * This is for checking provided options at runtime. This is an object for
+ * easier membership checking.
+ */
+export const recognizedOptions = {
+  'grpc.ssl_target_name_override': true,
+  'grpc.primary_user_agent': true,
+  'grpc.secondary_user_agent': true,
+  'grpc.default_authority': true,
+  'grpc.keepalive_time_ms': true,
+  'grpc.keepalive_timeout_ms': true,
+  'grpc.keepalive_permit_without_calls': true,
+  'grpc.service_config': true,
+  'grpc.max_concurrent_streams': true,
+  'grpc.initial_reconnect_backoff_ms': true,
+  'grpc.max_reconnect_backoff_ms': true,
+  'grpc.use_local_subchannel_pool': true,
+  'grpc.max_send_message_length': true,
+  'grpc.max_receive_message_length': true,
+  'grpc.enable_http_proxy': true,
+  'grpc.enable_channelz': true,
+  'grpc.dns_min_time_between_resolutions_ms': true,
+  'grpc.enable_retries': true,
+  'grpc.per_rpc_retry_buffer_size': true,
+  'grpc.retry_buffer_size': true,
+  'grpc.max_connection_age_ms': true,
+  'grpc.max_connection_age_grace_ms': true,
+  'grpc-node.max_session_memory': true,
+  'grpc.service_config_disable_resolution': true,
+  'grpc.client_idle_timeout_ms': true,
+  'grpc-node.tls_enable_trace': true,
+};
+
+export function channelOptionsEqual(
+  options1: ChannelOptions,
+  options2: ChannelOptions
+) {
+  const keys1 = Object.keys(options1).sort();
+  const keys2 = Object.keys(options2).sort();
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (let i = 0; i < keys1.length; i += 1) {
+    if (keys1[i] !== keys2[i]) {
+      return false;
+    }
+    if (options1[keys1[i]] !== options2[keys2[i]]) {
+      return false;
+    }
+  }
+  return true;
+}