@kenji71089/evaluation 0.0.1

package/lib/proto/gateway/service_pb_service.mjs

@@ -0,0 +1,461 @@
+// package: bucketeer.gateway
+// file: proto/gateway/service.proto
+
+var proto_gateway_service_pb = require("../../proto/gateway/service_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var Gateway = (function () {
+  function Gateway() {}
+  Gateway.serviceName = "bucketeer.gateway.Gateway";
+  return Gateway;
+}());
+
+Gateway.GetEvaluations = {
+  methodName: "GetEvaluations",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetEvaluationsRequest,
+  responseType: proto_gateway_service_pb.GetEvaluationsResponse
+};
+
+Gateway.GetEvaluation = {
+  methodName: "GetEvaluation",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetEvaluationRequest,
+  responseType: proto_gateway_service_pb.GetEvaluationResponse
+};
+
+Gateway.GetFeatureFlags = {
+  methodName: "GetFeatureFlags",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetFeatureFlagsRequest,
+  responseType: proto_gateway_service_pb.GetFeatureFlagsResponse
+};
+
+Gateway.GetSegmentUsers = {
+  methodName: "GetSegmentUsers",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetSegmentUsersRequest,
+  responseType: proto_gateway_service_pb.GetSegmentUsersResponse
+};
+
+Gateway.RegisterEvents = {
+  methodName: "RegisterEvents",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.RegisterEventsRequest,
+  responseType: proto_gateway_service_pb.RegisterEventsResponse
+};
+
+Gateway.Track = {
+  methodName: "Track",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.TrackRequest,
+  responseType: proto_gateway_service_pb.TrackResponse
+};
+
+Gateway.CreateFeature = {
+  methodName: "CreateFeature",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.CreateFeatureRequest,
+  responseType: proto_gateway_service_pb.CreateFeatureResponse
+};
+
+Gateway.GetFeature = {
+  methodName: "GetFeature",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetFeatureRequest,
+  responseType: proto_gateway_service_pb.GetFeatureResponse
+};
+
+Gateway.ListFeatures = {
+  methodName: "ListFeatures",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.ListFeaturesRequest,
+  responseType: proto_gateway_service_pb.ListFeaturesResponse
+};
+
+Gateway.UpdateFeature = {
+  methodName: "UpdateFeature",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.UpdateFeatureRequest,
+  responseType: proto_gateway_service_pb.UpdateFeatureResponse
+};
+
+Gateway.Ping = {
+  methodName: "Ping",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.PingRequest,
+  responseType: proto_gateway_service_pb.PingResponse
+};
+
+exports.Gateway = Gateway;
+
+function GatewayClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+GatewayClient.prototype.getEvaluations = function getEvaluations(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetEvaluations, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.getEvaluation = function getEvaluation(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetEvaluation, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.getFeatureFlags = function getFeatureFlags(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetFeatureFlags, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.getSegmentUsers = function getSegmentUsers(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetSegmentUsers, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.registerEvents = function registerEvents(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.RegisterEvents, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.track = function track(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.Track, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.createFeature = function createFeature(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.CreateFeature, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.getFeature = function getFeature(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetFeature, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.listFeatures = function listFeatures(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.ListFeatures, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.updateFeature = function updateFeature(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.UpdateFeature, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+GatewayClient.prototype.ping = function ping(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.Ping, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+exports.GatewayClient = GatewayClient;
+

package/lib/proto/user/user_pb.d.ts

@@ -0,0 +1,58 @@
+// package: bucketeer.user
+// file: proto/user/user.proto
+
+import * as jspb from 'google-protobuf';
+
+export class User extends jspb.Message {
+  getId(): string;
+  setId(value: string): void;
+
+  getDataMap(): jspb.Map<string, string>;
+  clearDataMap(): void;
+  getTaggedDataMap(): jspb.Map<string, User.Data>;
+  clearTaggedDataMap(): void;
+  getLastSeen(): number;
+  setLastSeen(value: number): void;
+
+  getCreatedAt(): number;
+  setCreatedAt(value: number): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): User.AsObject;
+  static toObject(includeInstance: boolean, msg: User): User.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: User, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): User;
+  static deserializeBinaryFromReader(message: User, reader: jspb.BinaryReader): User;
+}
+
+export namespace User {
+  export type AsObject = {
+    id: string,
+    dataMap: Array<[string, string]>,
+    taggedDataMap: Array<[string, User.Data.AsObject]>,
+    lastSeen: number,
+    createdAt: number,
+  }
+
+  export class Data extends jspb.Message {
+    getValueMap(): jspb.Map<string, string>;
+    clearValueMap(): void;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Data.AsObject;
+    static toObject(includeInstance: boolean, msg: Data): Data.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Data, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Data;
+    static deserializeBinaryFromReader(message: Data, reader: jspb.BinaryReader): Data;
+  }
+
+  export namespace Data {
+    export type AsObject = {
+      valueMap: Array<[string, string]>,
+    }
+  }
+}
+