@alis-build/common-ts 1.0.2

package/alis/open/validation/v1/validation_grpc_pb.d.ts

@@ -0,0 +1,29 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// package: alis.open.validation.v1
+// file: alis/open/validation/v1/validation.proto
+
+import * as alis_open_validation_v1_validation_pb from "../../../../alis/open/validation/v1/validation_pb";
+import * as grpc from "grpc";
+
+interface IValidationServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  retrieveRules: grpc.MethodDefinition<alis_open_validation_v1_validation_pb.RetrieveRulesRequest, alis_open_validation_v1_validation_pb.RetrieveRulesResponse>;
+  validateMessage: grpc.MethodDefinition<alis_open_validation_v1_validation_pb.ValidateMessageRequest, alis_open_validation_v1_validation_pb.ValidateMessageResponse>;
+}
+
+export const ValidationServiceService: IValidationServiceService;
+
+export interface IValidationServiceServer extends grpc.UntypedServiceImplementation {
+  retrieveRules: grpc.handleUnaryCall<alis_open_validation_v1_validation_pb.RetrieveRulesRequest, alis_open_validation_v1_validation_pb.RetrieveRulesResponse>;
+  validateMessage: grpc.handleUnaryCall<alis_open_validation_v1_validation_pb.ValidateMessageRequest, alis_open_validation_v1_validation_pb.ValidateMessageResponse>;
+}
+
+export class ValidationServiceClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  retrieveRules(argument: alis_open_validation_v1_validation_pb.RetrieveRulesRequest, callback: grpc.requestCallback<alis_open_validation_v1_validation_pb.RetrieveRulesResponse>): grpc.ClientUnaryCall;
+  retrieveRules(argument: alis_open_validation_v1_validation_pb.RetrieveRulesRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<alis_open_validation_v1_validation_pb.RetrieveRulesResponse>): grpc.ClientUnaryCall;
+  retrieveRules(argument: alis_open_validation_v1_validation_pb.RetrieveRulesRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<alis_open_validation_v1_validation_pb.RetrieveRulesResponse>): grpc.ClientUnaryCall;
+  validateMessage(argument: alis_open_validation_v1_validation_pb.ValidateMessageRequest, callback: grpc.requestCallback<alis_open_validation_v1_validation_pb.ValidateMessageResponse>): grpc.ClientUnaryCall;
+  validateMessage(argument: alis_open_validation_v1_validation_pb.ValidateMessageRequest, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<alis_open_validation_v1_validation_pb.ValidateMessageResponse>): grpc.ClientUnaryCall;
+  validateMessage(argument: alis_open_validation_v1_validation_pb.ValidateMessageRequest, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<alis_open_validation_v1_validation_pb.ValidateMessageResponse>): grpc.ClientUnaryCall;
+}

package/alis/open/validation/v1/validation_grpc_pb.js

@@ -0,0 +1,80 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var alis_open_validation_v1_validation_pb = require('../../../../alis/open/validation/v1/validation_pb.js');
+
+function serialize_alis_open_validation_v1_RetrieveRulesRequest(arg) {
+  if (!(arg instanceof alis_open_validation_v1_validation_pb.RetrieveRulesRequest)) {
+    throw new Error('Expected argument of type alis.open.validation.v1.RetrieveRulesRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_alis_open_validation_v1_RetrieveRulesRequest(buffer_arg) {
+  return alis_open_validation_v1_validation_pb.RetrieveRulesRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_alis_open_validation_v1_RetrieveRulesResponse(arg) {
+  if (!(arg instanceof alis_open_validation_v1_validation_pb.RetrieveRulesResponse)) {
+    throw new Error('Expected argument of type alis.open.validation.v1.RetrieveRulesResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_alis_open_validation_v1_RetrieveRulesResponse(buffer_arg) {
+  return alis_open_validation_v1_validation_pb.RetrieveRulesResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_alis_open_validation_v1_ValidateMessageRequest(arg) {
+  if (!(arg instanceof alis_open_validation_v1_validation_pb.ValidateMessageRequest)) {
+    throw new Error('Expected argument of type alis.open.validation.v1.ValidateMessageRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_alis_open_validation_v1_ValidateMessageRequest(buffer_arg) {
+  return alis_open_validation_v1_validation_pb.ValidateMessageRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_alis_open_validation_v1_ValidateMessageResponse(arg) {
+  if (!(arg instanceof alis_open_validation_v1_validation_pb.ValidateMessageResponse)) {
+    throw new Error('Expected argument of type alis.open.validation.v1.ValidateMessageResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_alis_open_validation_v1_ValidateMessageResponse(buffer_arg) {
+  return alis_open_validation_v1_validation_pb.ValidateMessageResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+var ValidationServiceService = exports.ValidationServiceService = {
+  // Retrieve the validation rules for a given message type.
+retrieveRules: {
+    path: '/alis.open.validation.v1.ValidationService/RetrieveRules',
+    requestStream: false,
+    responseStream: false,
+    requestType: alis_open_validation_v1_validation_pb.RetrieveRulesRequest,
+    responseType: alis_open_validation_v1_validation_pb.RetrieveRulesResponse,
+    requestSerialize: serialize_alis_open_validation_v1_RetrieveRulesRequest,
+    requestDeserialize: deserialize_alis_open_validation_v1_RetrieveRulesRequest,
+    responseSerialize: serialize_alis_open_validation_v1_RetrieveRulesResponse,
+    responseDeserialize: deserialize_alis_open_validation_v1_RetrieveRulesResponse,
+  },
+  // Validates if the given bytes are valid for the given message type.
+// If the bytes cannot be marshalled into the message type, the rpc will return an error instead of the violations.
+validateMessage: {
+    path: '/alis.open.validation.v1.ValidationService/ValidateMessage',
+    requestStream: false,
+    responseStream: false,
+    requestType: alis_open_validation_v1_validation_pb.ValidateMessageRequest,
+    responseType: alis_open_validation_v1_validation_pb.ValidateMessageResponse,
+    requestSerialize: serialize_alis_open_validation_v1_ValidateMessageRequest,
+    requestDeserialize: deserialize_alis_open_validation_v1_ValidateMessageRequest,
+    responseSerialize: serialize_alis_open_validation_v1_ValidateMessageResponse,
+    responseDeserialize: deserialize_alis_open_validation_v1_ValidateMessageResponse,
+  },
+};
+
+exports.ValidationServiceClient = grpc.makeGenericClientConstructor(ValidationServiceService, 'ValidationService');

package/alis/open/validation/v1/validation_grpc_web_pb.d.ts

@@ -0,0 +1,43 @@
+import * as grpcWeb from 'grpc-web';
+
+import * as alis_open_validation_v1_validation_pb from '../../../../alis/open/validation/v1/validation_pb'; // proto import: "alis/open/validation/v1/validation.proto"
+
+
+export class ValidationServiceClient {
+  constructor (hostname: string,
+               credentials?: null | { [index: string]: string; },
+               options?: null | { [index: string]: any; });
+
+  retrieveRules(
+    request: alis_open_validation_v1_validation_pb.RetrieveRulesRequest,
+    metadata: grpcWeb.Metadata | undefined,
+    callback: (err: grpcWeb.RpcError,
+               response: alis_open_validation_v1_validation_pb.RetrieveRulesResponse) => void
+  ): grpcWeb.ClientReadableStream<alis_open_validation_v1_validation_pb.RetrieveRulesResponse>;
+
+  validateMessage(
+    request: alis_open_validation_v1_validation_pb.ValidateMessageRequest,
+    metadata: grpcWeb.Metadata | undefined,
+    callback: (err: grpcWeb.RpcError,
+               response: alis_open_validation_v1_validation_pb.ValidateMessageResponse) => void
+  ): grpcWeb.ClientReadableStream<alis_open_validation_v1_validation_pb.ValidateMessageResponse>;
+
+}
+
+export class ValidationServicePromiseClient {
+  constructor (hostname: string,
+               credentials?: null | { [index: string]: string; },
+               options?: null | { [index: string]: any; });
+
+  retrieveRules(
+    request: alis_open_validation_v1_validation_pb.RetrieveRulesRequest,
+    metadata?: grpcWeb.Metadata
+  ): Promise<alis_open_validation_v1_validation_pb.RetrieveRulesResponse>;
+
+  validateMessage(
+    request: alis_open_validation_v1_validation_pb.ValidateMessageRequest,
+    metadata?: grpcWeb.Metadata
+  ): Promise<alis_open_validation_v1_validation_pb.ValidateMessageResponse>;
+
+}
+

package/alis/open/validation/v1/validation_grpc_web_pb.js

@@ -0,0 +1,203 @@
+/**
+ * @fileoverview gRPC-Web generated client stub for alis.open.validation.v1
+ * @enhanceable
+ * @public
+ */
+
+// Code generated by protoc-gen-grpc-web. DO NOT EDIT.
+// versions:
+// 	protoc-gen-grpc-web v1.5.0
+// 	protoc              v4.24.4
+// source: alis/open/validation/v1/validation.proto
+
+
+/* eslint-disable */
+// @ts-nocheck
+
+
+
+const grpc = {};
+grpc.web = require('grpc-web');
+
+const proto = {};
+proto.alis = {};
+proto.alis.open = {};
+proto.alis.open.validation = {};
+proto.alis.open.validation.v1 = require('./validation_pb.js');
+
+/**
+ * @param {string} hostname
+ * @param {?Object} credentials
+ * @param {?grpc.web.ClientOptions} options
+ * @constructor
+ * @struct
+ * @final
+ */
+proto.alis.open.validation.v1.ValidationServiceClient =
+    function(hostname, credentials, options) {
+  if (!options) options = {};
+  options.format = 'text';
+
+  /**
+   * @private @const {!grpc.web.GrpcWebClientBase} The client
+   */
+  this.client_ = new grpc.web.GrpcWebClientBase(options);
+
+  /**
+   * @private @const {string} The hostname
+   */
+  this.hostname_ = hostname.replace(/\/+$/, '');
+
+};
+
+
+/**
+ * @param {string} hostname
+ * @param {?Object} credentials
+ * @param {?grpc.web.ClientOptions} options
+ * @constructor
+ * @struct
+ * @final
+ */
+proto.alis.open.validation.v1.ValidationServicePromiseClient =
+    function(hostname, credentials, options) {
+  if (!options) options = {};
+  options.format = 'text';
+
+  /**
+   * @private @const {!grpc.web.GrpcWebClientBase} The client
+   */
+  this.client_ = new grpc.web.GrpcWebClientBase(options);
+
+  /**
+   * @private @const {string} The hostname
+   */
+  this.hostname_ = hostname.replace(/\/+$/, '');
+
+};
+
+
+/**
+ * @const
+ * @type {!grpc.web.MethodDescriptor<
+ *   !proto.alis.open.validation.v1.RetrieveRulesRequest,
+ *   !proto.alis.open.validation.v1.RetrieveRulesResponse>}
+ */
+const methodDescriptor_ValidationService_RetrieveRules = new grpc.web.MethodDescriptor(
+  '/alis.open.validation.v1.ValidationService/RetrieveRules',
+  grpc.web.MethodType.UNARY,
+  proto.alis.open.validation.v1.RetrieveRulesRequest,
+  proto.alis.open.validation.v1.RetrieveRulesResponse,
+  /**
+   * @param {!proto.alis.open.validation.v1.RetrieveRulesRequest} request
+   * @return {!Uint8Array}
+   */
+  function(request) {
+    return request.serializeBinary();
+  },
+  proto.alis.open.validation.v1.RetrieveRulesResponse.deserializeBinary
+);
+
+
+/**
+ * @param {!proto.alis.open.validation.v1.RetrieveRulesRequest} request The
+ *     request proto
+ * @param {?Object<string, string>} metadata User defined
+ *     call metadata
+ * @param {function(?grpc.web.RpcError, ?proto.alis.open.validation.v1.RetrieveRulesResponse)}
+ *     callback The callback function(error, response)
+ * @return {!grpc.web.ClientReadableStream<!proto.alis.open.validation.v1.RetrieveRulesResponse>|undefined}
+ *     The XHR Node Readable Stream
+ */
+proto.alis.open.validation.v1.ValidationServiceClient.prototype.retrieveRules =
+    function(request, metadata, callback) {
+  return this.client_.rpcCall(this.hostname_ +
+      '/alis.open.validation.v1.ValidationService/RetrieveRules',
+      request,
+      metadata || {},
+      methodDescriptor_ValidationService_RetrieveRules,
+      callback);
+};
+
+
+/**
+ * @param {!proto.alis.open.validation.v1.RetrieveRulesRequest} request The
+ *     request proto
+ * @param {?Object<string, string>=} metadata User defined
+ *     call metadata
+ * @return {!Promise<!proto.alis.open.validation.v1.RetrieveRulesResponse>}
+ *     Promise that resolves to the response
+ */
+proto.alis.open.validation.v1.ValidationServicePromiseClient.prototype.retrieveRules =
+    function(request, metadata) {
+  return this.client_.unaryCall(this.hostname_ +
+      '/alis.open.validation.v1.ValidationService/RetrieveRules',
+      request,
+      metadata || {},
+      methodDescriptor_ValidationService_RetrieveRules);
+};
+
+
+/**
+ * @const
+ * @type {!grpc.web.MethodDescriptor<
+ *   !proto.alis.open.validation.v1.ValidateMessageRequest,
+ *   !proto.alis.open.validation.v1.ValidateMessageResponse>}
+ */
+const methodDescriptor_ValidationService_ValidateMessage = new grpc.web.MethodDescriptor(
+  '/alis.open.validation.v1.ValidationService/ValidateMessage',
+  grpc.web.MethodType.UNARY,
+  proto.alis.open.validation.v1.ValidateMessageRequest,
+  proto.alis.open.validation.v1.ValidateMessageResponse,
+  /**
+   * @param {!proto.alis.open.validation.v1.ValidateMessageRequest} request
+   * @return {!Uint8Array}
+   */
+  function(request) {
+    return request.serializeBinary();
+  },
+  proto.alis.open.validation.v1.ValidateMessageResponse.deserializeBinary
+);
+
+
+/**
+ * @param {!proto.alis.open.validation.v1.ValidateMessageRequest} request The
+ *     request proto
+ * @param {?Object<string, string>} metadata User defined
+ *     call metadata
+ * @param {function(?grpc.web.RpcError, ?proto.alis.open.validation.v1.ValidateMessageResponse)}
+ *     callback The callback function(error, response)
+ * @return {!grpc.web.ClientReadableStream<!proto.alis.open.validation.v1.ValidateMessageResponse>|undefined}
+ *     The XHR Node Readable Stream
+ */
+proto.alis.open.validation.v1.ValidationServiceClient.prototype.validateMessage =
+    function(request, metadata, callback) {
+  return this.client_.rpcCall(this.hostname_ +
+      '/alis.open.validation.v1.ValidationService/ValidateMessage',
+      request,
+      metadata || {},
+      methodDescriptor_ValidationService_ValidateMessage,
+      callback);
+};
+
+
+/**
+ * @param {!proto.alis.open.validation.v1.ValidateMessageRequest} request The
+ *     request proto
+ * @param {?Object<string, string>=} metadata User defined
+ *     call metadata
+ * @return {!Promise<!proto.alis.open.validation.v1.ValidateMessageResponse>}
+ *     Promise that resolves to the response
+ */
+proto.alis.open.validation.v1.ValidationServicePromiseClient.prototype.validateMessage =
+    function(request, metadata) {
+  return this.client_.unaryCall(this.hostname_ +
+      '/alis.open.validation.v1.ValidationService/ValidateMessage',
+      request,
+      metadata || {},
+      methodDescriptor_ValidationService_ValidateMessage);
+};
+
+
+module.exports = proto.alis.open.validation.v1;
+

package/alis/open/validation/v1/validation_pb.d.ts

@@ -0,0 +1,156 @@
+import * as jspb from 'google-protobuf'
+
+
+
+export class RetrieveRulesRequest extends jspb.Message {
+  getMsgType(): string;
+  setMsgType(value: string): RetrieveRulesRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RetrieveRulesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: RetrieveRulesRequest): RetrieveRulesRequest.AsObject;
+  static serializeBinaryToWriter(message: RetrieveRulesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RetrieveRulesRequest;
+  static deserializeBinaryFromReader(message: RetrieveRulesRequest, reader: jspb.BinaryReader): RetrieveRulesRequest;
+}
+
+export namespace RetrieveRulesRequest {
+  export type AsObject = {
+    msgType: string,
+  }
+}
+
+export class RetrieveRulesResponse extends jspb.Message {
+  getRulesList(): Array<Rule>;
+  setRulesList(value: Array<Rule>): RetrieveRulesResponse;
+  clearRulesList(): RetrieveRulesResponse;
+  addRules(value?: Rule, index?: number): Rule;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RetrieveRulesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: RetrieveRulesResponse): RetrieveRulesResponse.AsObject;
+  static serializeBinaryToWriter(message: RetrieveRulesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RetrieveRulesResponse;
+  static deserializeBinaryFromReader(message: RetrieveRulesResponse, reader: jspb.BinaryReader): RetrieveRulesResponse;
+}
+
+export namespace RetrieveRulesResponse {
+  export type AsObject = {
+    rulesList: Array<Rule.AsObject>,
+  }
+}
+
+export class ValidateMessageRequest extends jspb.Message {
+  getMsgType(): string;
+  setMsgType(value: string): ValidateMessageRequest;
+
+  getMsg(): Uint8Array | string;
+  getMsg_asU8(): Uint8Array;
+  getMsg_asB64(): string;
+  setMsg(value: Uint8Array | string): ValidateMessageRequest;
+
+  getFieldPathsList(): Array<string>;
+  setFieldPathsList(value: Array<string>): ValidateMessageRequest;
+  clearFieldPathsList(): ValidateMessageRequest;
+  addFieldPaths(value: string, index?: number): ValidateMessageRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ValidateMessageRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ValidateMessageRequest): ValidateMessageRequest.AsObject;
+  static serializeBinaryToWriter(message: ValidateMessageRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ValidateMessageRequest;
+  static deserializeBinaryFromReader(message: ValidateMessageRequest, reader: jspb.BinaryReader): ValidateMessageRequest;
+}
+
+export namespace ValidateMessageRequest {
+  export type AsObject = {
+    msgType: string,
+    msg: Uint8Array | string,
+    fieldPathsList: Array<string>,
+  }
+}
+
+export class ValidateMessageResponse extends jspb.Message {
+  getViolatedRulesList(): Array<Rule>;
+  setViolatedRulesList(value: Array<Rule>): ValidateMessageResponse;
+  clearViolatedRulesList(): ValidateMessageResponse;
+  addViolatedRules(value?: Rule, index?: number): Rule;
+
+  getViolatedFieldsList(): Array<FieldViolation>;
+  setViolatedFieldsList(value: Array<FieldViolation>): ValidateMessageResponse;
+  clearViolatedFieldsList(): ValidateMessageResponse;
+  addViolatedFields(value?: FieldViolation, index?: number): FieldViolation;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ValidateMessageResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ValidateMessageResponse): ValidateMessageResponse.AsObject;
+  static serializeBinaryToWriter(message: ValidateMessageResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ValidateMessageResponse;
+  static deserializeBinaryFromReader(message: ValidateMessageResponse, reader: jspb.BinaryReader): ValidateMessageResponse;
+}
+
+export namespace ValidateMessageResponse {
+  export type AsObject = {
+    violatedRulesList: Array<Rule.AsObject>,
+    violatedFieldsList: Array<FieldViolation.AsObject>,
+  }
+}
+
+export class Rule extends jspb.Message {
+  getId(): string;
+  setId(value: string): Rule;
+
+  getDescription(): string;
+  setDescription(value: string): Rule;
+
+  getFieldPathsList(): Array<string>;
+  setFieldPathsList(value: Array<string>): Rule;
+  clearFieldPathsList(): Rule;
+  addFieldPaths(value: string, index?: number): Rule;
+
+  getNestedRulesList(): Array<Rule>;
+  setNestedRulesList(value: Array<Rule>): Rule;
+  clearNestedRulesList(): Rule;
+  addNestedRules(value?: Rule, index?: number): Rule;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Rule.AsObject;
+  static toObject(includeInstance: boolean, msg: Rule): Rule.AsObject;
+  static serializeBinaryToWriter(message: Rule, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Rule;
+  static deserializeBinaryFromReader(message: Rule, reader: jspb.BinaryReader): Rule;
+}
+
+export namespace Rule {
+  export type AsObject = {
+    id: string,
+    description: string,
+    fieldPathsList: Array<string>,
+    nestedRulesList: Array<Rule.AsObject>,
+  }
+}
+
+export class FieldViolation extends jspb.Message {
+  getFieldPath(): string;
+  setFieldPath(value: string): FieldViolation;
+
+  getViolatedRulesList(): Array<Rule>;
+  setViolatedRulesList(value: Array<Rule>): FieldViolation;
+  clearViolatedRulesList(): FieldViolation;
+  addViolatedRules(value?: Rule, index?: number): Rule;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): FieldViolation.AsObject;
+  static toObject(includeInstance: boolean, msg: FieldViolation): FieldViolation.AsObject;
+  static serializeBinaryToWriter(message: FieldViolation, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): FieldViolation;
+  static deserializeBinaryFromReader(message: FieldViolation, reader: jspb.BinaryReader): FieldViolation;
+}
+
+export namespace FieldViolation {
+  export type AsObject = {
+    fieldPath: string,
+    violatedRulesList: Array<Rule.AsObject>,
+  }
+}
+