Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
private shouldAttemptReconnect(status: grpc.StatusObject): boolean {
switch (status.code) {
case grpc.status.UNKNOWN: // stream disconnected
case grpc.status.UNAVAILABLE: // stream could not be established
return true;
default:
return false;
}
}
engineRef.getRootResource(req, (err: grpc.ServiceError, resp: any) => {
// Back-compat case - if the engine we're speaking to isn't aware that it can save and load root resources,
// fall back to the old behavior.
if (err && err.code === grpc.status.UNIMPLEMENTED) {
if (rootResource) {
rootResource.then(resolve);
return;
}
resolve(undefined);
}
if (err) {
return reject(err);
}
const urn = resp.getUrn();
if (urn) {
return resolve(urn);
}
function isUnauthenticatedError(err) {
var ec = errorCode(err);
return ec.valid && (ec.code === grpc.status.UNAUTHENTICATED);
}
exports.isUnauthenticatedError = isUnauthenticatedError;
import * as httpStatus from 'http-status';
import * as grpc from 'grpc';
export class MicroChassisError extends Error {
public readonly status?: number = httpStatus.INTERNAL_SERVER_ERROR;
public readonly grpcCode: number = grpc.status.INTERNAL;
get content(): string {
return this.message;
}
}
export class NotFoundError extends MicroChassisError {
public readonly status = httpStatus.NOT_FOUND;
public readonly grpcCode = grpc.status.NOT_FOUND;
}
export class ValidationError extends MicroChassisError {
public readonly status = httpStatus.BAD_REQUEST;
public readonly grpcCode = grpc.status.FAILED_PRECONDITION;
}
export class UnauthorizedError extends MicroChassisError {
public readonly status = httpStatus.UNAUTHORIZED;
public readonly grpcCode = grpc.status.UNAUTHENTICATED;
}
export class ForbiddenError extends MicroChassisError {
public readonly status = httpStatus.FORBIDDEN;
public readonly grpcCode = grpc.status.UNAUTHENTICATED;
}
import grpc from "grpc";
import Auth from "./auth";
import { GoogleAdsFailure, GoogleAdsError, ErrorCode } from "./types";
import {
formatCallResults,
getErrorLocationPath,
isMutationRequest,
safeguardMutationProtobufRequest,
} from "./utils";
const FAILURE_KEY = "google.ads.googleads.v2.errors.googleadsfailure-bin";
const REQUEST_ID_KEY = "request-id";
const RETRY_STATUS_CODES = [grpc.status.INTERNAL, grpc.status.RESOURCE_EXHAUSTED];
type NextCall = (options: grpc.CallOptions) => grpc.InterceptingCall | null;
export type InterceptorMethod = (options: grpc.CallOptions, nextCall: NextCall) => any;
export class MetadataInterceptor {
private developer_token: string;
private login_customer_id: string | undefined;
private access_token: string | undefined;
private auth: Auth | undefined;
private requestInterceptor: grpc.Requester;
constructor(
developer_token: string,
login_customer_id: string | undefined,
access_token: string | undefined,
auth: Auth | undefined
get: function(call, callback) {
for (var i = 0; i < books.length; i++)
if (books[i].id == call.request.id)
return callback(null, books[i]);
callback({
code: grpc.status.NOT_FOUND,
details: 'Not found'
});
},
delete: function(call, callback) {
function isConflictError(err) {
var ec = errorCode(err);
return ec.valid && (ec.code === grpc.status.ABORTED || ec.code === grpc.status.FAILED_PRECONDITION);
}
exports.isConflictError = isConflictError;
get(call) {
const personFound = people.find((element) => {
return element.id === call.request.id;
});
if (personFound) {
return Promise.resolve(personFound);
}
Promise.reject({
'code': grpc.status.NOT_FOUND,
'details': 'Not found',
});
}
delete: function(call, callback) {
for (var i = 0; i < books.length; i++) {
if (books[i].id == call.request.id) {
books.splice(i, 1);
return callback(null, {});
}
}
callback({
code: grpc.status.NOT_FOUND,
details: 'Not found'
});
},
watch: function(stream) {
private static requestToStatus(
request:
| showcaseV1Beta1.EchoRequest
| showcaseV1Beta1.ExpandRequest
| showcaseV1Beta1.WaitRequest
): google.rpc.Status {
const message =
request.error && request.error.message ? request.error.message : 'Error';
const code =
request.error && request.error.code
? request.error.code
: grpc.status.INVALID_ARGUMENT;
const details =
request.error && request.error.details ? request.error.details : [];
const error = new google.rpc.Status();
error.code = code;
error.message = message;
error.details = details;
return error;
}