From 0a7ebf250a0663bf922532a007cd88c05eb016cc Mon Sep 17 00:00:00 2001 From: ci core model Date: Fri, 28 Aug 2026 09:16:46 +0000 Subject: [PATCH] Latest generation --- clickhouse.ts | 331 +++++++++++++++++++++++++++++++++++++++++++ kpi.client.ts | 29 ++-- kpi.ts | 210 +++++++++++++++++++++++++++ package.json | 2 +- stockQuery.client.ts | 21 ++- stockQuery.ts | 3 + 6 files changed, 583 insertions(+), 13 deletions(-) diff --git a/clickhouse.ts b/clickhouse.ts index c276746..8e11534 100644 --- a/clickhouse.ts +++ b/clickhouse.ts @@ -282,6 +282,102 @@ export interface GetKPIDataResult { */ Series: KpiDataSerie[]; } +/** + * GetKPIDataSimpleJSONQuery is the request for GetKPIDataSimpleJSON. + * Unlike GetKPIDataQuery it has no ChartType (irrelevant for a datasource) + * and exposes top-level DateRangeStart/DateRangeEnd for easy Grafana integration. + * + * @generated from protobuf message api.GetKPIDataSimpleJSONQuery + */ +export interface GetKPIDataSimpleJSONQuery { + /** + * @generated from protobuf field: api.QueryProjectHeader Header = 1 + */ + Header?: QueryProjectHeader; + /** + * @generated from protobuf field: api.CHQueryType QueryType = 2 + */ + QueryType: CHQueryType; + /** + * @generated from protobuf field: string QueryBlock = 3 + */ + QueryBlock: string; + /** + * @generated from protobuf field: api.CHFilter Filter = 4 + */ + Filter?: CHFilter; + /** + * @generated from protobuf field: repeated api.CHDimension Dimensions = 5 + */ + Dimensions: CHDimension[]; + /** + * @generated from protobuf field: repeated api.CHMetric Metrics = 6 + */ + Metrics: CHMetric[]; + /** + * @generated from protobuf field: string TargetTimeZone = 7 + */ + TargetTimeZone: string; + /** + * @generated from protobuf field: string KpiGroupName = 8 + */ + KpiGroupName: string; + /** + * DateRangeStart / DateRangeEnd are the Grafana time-picker range (ISO 8601). + * When set, they are applied as StartDate/EndDate on every date-type filter + * dimension that does not already define explicit date bounds. + * + * @generated from protobuf field: string DateRangeStart = 9 + */ + DateRangeStart: string; + /** + * @generated from protobuf field: string DateRangeEnd = 10 + */ + DateRangeEnd: string; +} +/** + * SimpleJSONColumn is a column header in the SimpleJSON table format (Grafana-compatible). + * + * @generated from protobuf message api.SimpleJSONColumn + */ +export interface SimpleJSONColumn { + /** + * Text is the column label displayed in Grafana. + * + * @generated from protobuf field: string Text = 1 + */ + Text: string; + /** + * Type is the column value type: "string", "number", or "time". + * + * @generated from protobuf field: string Type = 2 + */ + Type: string; +} +/** + * GetKPIDataSimpleJSONResult returns KPI data as a SimpleJSON table, compatible with + * Grafana's SimpleJSON datasource and the Infinity datasource (table mode). + * + * @generated from protobuf message api.GetKPIDataSimpleJSONResult + */ +export interface GetKPIDataSimpleJSONResult { + /** + * @generated from protobuf field: repeated api.SimpleJSONColumn Columns = 1 + */ + Columns: SimpleJSONColumn[]; + /** + * RowsJSON is a JSON-encoded array of arrays: each inner array is one data row + * whose values align positionally with Columns. + * Example: [[\"J006-tbu-B191\",100.0],[\"J007-abc\",50.0]] + * + * @generated from protobuf field: string RowsJSON = 2 + */ + RowsJSON: string; + /** + * @generated from protobuf field: string Type = 3 + */ + Type: string; +} /** * @generated from protobuf message api.EntityBlockFilter */ @@ -1271,6 +1367,241 @@ class GetKPIDataResult$Type extends MessageType { */ export const GetKPIDataResult = new GetKPIDataResult$Type(); // @generated message type with reflection information, may provide speed optimized methods +class GetKPIDataSimpleJSONQuery$Type extends MessageType { + constructor() { + super("api.GetKPIDataSimpleJSONQuery", [ + { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => QueryProjectHeader }, + { no: 2, name: "QueryType", kind: "enum", localName: "QueryType", jsonName: "QueryType", T: () => ["api.CHQueryType", CHQueryType] }, + { no: 3, name: "QueryBlock", kind: "scalar", localName: "QueryBlock", jsonName: "QueryBlock", T: 9 /*ScalarType.STRING*/ }, + { no: 4, name: "Filter", kind: "message", localName: "Filter", jsonName: "Filter", T: () => CHFilter }, + { no: 5, name: "Dimensions", kind: "message", localName: "Dimensions", jsonName: "Dimensions", repeat: 2 /*RepeatType.UNPACKED*/, T: () => CHDimension }, + { no: 6, name: "Metrics", kind: "message", localName: "Metrics", jsonName: "Metrics", repeat: 2 /*RepeatType.UNPACKED*/, T: () => CHMetric }, + { no: 7, name: "TargetTimeZone", kind: "scalar", localName: "TargetTimeZone", jsonName: "TargetTimeZone", T: 9 /*ScalarType.STRING*/ }, + { no: 8, name: "KpiGroupName", kind: "scalar", localName: "KpiGroupName", jsonName: "KpiGroupName", T: 9 /*ScalarType.STRING*/ }, + { no: 9, name: "DateRangeStart", kind: "scalar", localName: "DateRangeStart", jsonName: "DateRangeStart", T: 9 /*ScalarType.STRING*/ }, + { no: 10, name: "DateRangeEnd", kind: "scalar", localName: "DateRangeEnd", jsonName: "DateRangeEnd", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): GetKPIDataSimpleJSONQuery { + const message = globalThis.Object.create((this.messagePrototype!)); + message.QueryType = 0; + message.QueryBlock = ""; + message.Dimensions = []; + message.Metrics = []; + message.TargetTimeZone = ""; + message.KpiGroupName = ""; + message.DateRangeStart = ""; + message.DateRangeEnd = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetKPIDataSimpleJSONQuery): GetKPIDataSimpleJSONQuery { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* api.QueryProjectHeader Header */ 1: + message.Header = QueryProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header); + break; + case /* api.CHQueryType QueryType */ 2: + message.QueryType = reader.int32(); + break; + case /* string QueryBlock */ 3: + message.QueryBlock = reader.string(); + break; + case /* api.CHFilter Filter */ 4: + message.Filter = CHFilter.internalBinaryRead(reader, reader.uint32(), options, message.Filter); + break; + case /* repeated api.CHDimension Dimensions */ 5: + message.Dimensions.push(CHDimension.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* repeated api.CHMetric Metrics */ 6: + message.Metrics.push(CHMetric.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* string TargetTimeZone */ 7: + message.TargetTimeZone = reader.string(); + break; + case /* string KpiGroupName */ 8: + message.KpiGroupName = reader.string(); + break; + case /* string DateRangeStart */ 9: + message.DateRangeStart = reader.string(); + break; + case /* string DateRangeEnd */ 10: + message.DateRangeEnd = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: GetKPIDataSimpleJSONQuery, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* api.QueryProjectHeader Header = 1; */ + if (message.Header) + QueryProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* api.CHQueryType QueryType = 2; */ + if (message.QueryType !== 0) + writer.tag(2, WireType.Varint).int32(message.QueryType); + /* string QueryBlock = 3; */ + if (message.QueryBlock !== "") + writer.tag(3, WireType.LengthDelimited).string(message.QueryBlock); + /* api.CHFilter Filter = 4; */ + if (message.Filter) + CHFilter.internalBinaryWrite(message.Filter, writer.tag(4, WireType.LengthDelimited).fork(), options).join(); + /* repeated api.CHDimension Dimensions = 5; */ + for (let i = 0; i < message.Dimensions.length; i++) + CHDimension.internalBinaryWrite(message.Dimensions[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join(); + /* repeated api.CHMetric Metrics = 6; */ + for (let i = 0; i < message.Metrics.length; i++) + CHMetric.internalBinaryWrite(message.Metrics[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join(); + /* string TargetTimeZone = 7; */ + if (message.TargetTimeZone !== "") + writer.tag(7, WireType.LengthDelimited).string(message.TargetTimeZone); + /* string KpiGroupName = 8; */ + if (message.KpiGroupName !== "") + writer.tag(8, WireType.LengthDelimited).string(message.KpiGroupName); + /* string DateRangeStart = 9; */ + if (message.DateRangeStart !== "") + writer.tag(9, WireType.LengthDelimited).string(message.DateRangeStart); + /* string DateRangeEnd = 10; */ + if (message.DateRangeEnd !== "") + writer.tag(10, WireType.LengthDelimited).string(message.DateRangeEnd); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.GetKPIDataSimpleJSONQuery + */ +export const GetKPIDataSimpleJSONQuery = new GetKPIDataSimpleJSONQuery$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class SimpleJSONColumn$Type extends MessageType { + constructor() { + super("api.SimpleJSONColumn", [ + { no: 1, name: "Text", kind: "scalar", localName: "Text", jsonName: "Text", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "Type", kind: "scalar", localName: "Type", jsonName: "Type", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): SimpleJSONColumn { + const message = globalThis.Object.create((this.messagePrototype!)); + message.Text = ""; + message.Type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SimpleJSONColumn): SimpleJSONColumn { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string Text */ 1: + message.Text = reader.string(); + break; + case /* string Type */ 2: + message.Type = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: SimpleJSONColumn, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string Text = 1; */ + if (message.Text !== "") + writer.tag(1, WireType.LengthDelimited).string(message.Text); + /* string Type = 2; */ + if (message.Type !== "") + writer.tag(2, WireType.LengthDelimited).string(message.Type); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.SimpleJSONColumn + */ +export const SimpleJSONColumn = new SimpleJSONColumn$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class GetKPIDataSimpleJSONResult$Type extends MessageType { + constructor() { + super("api.GetKPIDataSimpleJSONResult", [ + { no: 1, name: "Columns", kind: "message", localName: "Columns", jsonName: "Columns", repeat: 2 /*RepeatType.UNPACKED*/, T: () => SimpleJSONColumn, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Column definitions with inferred types (string / number)" } } }, + { no: 2, name: "RowsJSON", kind: "scalar", localName: "RowsJSON", jsonName: "RowsJSON", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "JSON-encoded rows array (array of arrays aligned with Columns)" } } }, + { no: 3, name: "Type", kind: "scalar", localName: "Type", jsonName: "Type", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Always \"table\"" } } } + ]); + } + create(value?: PartialMessage): GetKPIDataSimpleJSONResult { + const message = globalThis.Object.create((this.messagePrototype!)); + message.Columns = []; + message.RowsJSON = ""; + message.Type = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetKPIDataSimpleJSONResult): GetKPIDataSimpleJSONResult { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated api.SimpleJSONColumn Columns */ 1: + message.Columns.push(SimpleJSONColumn.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* string RowsJSON */ 2: + message.RowsJSON = reader.string(); + break; + case /* string Type */ 3: + message.Type = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: GetKPIDataSimpleJSONResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* repeated api.SimpleJSONColumn Columns = 1; */ + for (let i = 0; i < message.Columns.length; i++) + SimpleJSONColumn.internalBinaryWrite(message.Columns[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* string RowsJSON = 2; */ + if (message.RowsJSON !== "") + writer.tag(2, WireType.LengthDelimited).string(message.RowsJSON); + /* string Type = 3; */ + if (message.Type !== "") + writer.tag(3, WireType.LengthDelimited).string(message.Type); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.GetKPIDataSimpleJSONResult + */ +export const GetKPIDataSimpleJSONResult = new GetKPIDataSimpleJSONResult$Type(); +// @generated message type with reflection information, may provide speed optimized methods class EntityBlockFilter$Type extends MessageType { constructor() { super("api.EntityBlockFilter", [ diff --git a/kpi.client.ts b/kpi.client.ts index 4c40c8d..ca4bb09 100644 --- a/kpi.client.ts +++ b/kpi.client.ts @@ -20,6 +20,8 @@ import type { UpdateKpiTableStructureResult } from "./kpi"; import type { UpdateKpiTableStructureRequest } from "./kpi"; import type { GetKpiTableStructureResult } from "./kpi"; import type { GetKpiTableStructureRequest } from "./kpi"; +import type { GetKpisWithSelectionResult } from "./kpi"; +import type { GetKpisWithSelectionRequest } from "./kpi"; import { stackIntercept } from "@protobuf-ts/runtime-rpc"; import type { GetKpisResult } from "./kpi"; import type { GetKpisRequest } from "./kpi"; @@ -33,6 +35,10 @@ export interface IKpiServiceClient { * @generated from protobuf rpc: GetKpis */ getKpis(input: GetKpisRequest, options?: RpcOptions): UnaryCall; + /** + * @generated from protobuf rpc: GetKpisWithSelection + */ + getKpisWithSelection(input: GetKpisWithSelectionRequest, options?: RpcOptions): UnaryCall; /** * @generated from protobuf rpc: GetKpiTableStructure */ @@ -82,60 +88,67 @@ export class KpiServiceClient implements IKpiServiceClient, ServiceInfo { const method = this.methods[0], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } + /** + * @generated from protobuf rpc: GetKpisWithSelection + */ + getKpisWithSelection(input: GetKpisWithSelectionRequest, options?: RpcOptions): UnaryCall { + const method = this.methods[1], opt = this._transport.mergeOptions(options); + return stackIntercept("unary", this._transport, method, opt, input); + } /** * @generated from protobuf rpc: GetKpiTableStructure */ getKpiTableStructure(input: GetKpiTableStructureRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[1], opt = this._transport.mergeOptions(options); + const method = this.methods[2], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: UpdateKpiTableStructure */ updateKpiTableStructure(input: UpdateKpiTableStructureRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[2], opt = this._transport.mergeOptions(options); + const method = this.methods[3], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: DropKpiTableStructure */ dropKpiTableStructure(input: DropKpiTableStructureRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[3], opt = this._transport.mergeOptions(options); + const method = this.methods[4], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: GetKpiEntities */ getKpiEntities(input: GetKpiEntitiesRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[4], opt = this._transport.mergeOptions(options); + const method = this.methods[5], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: ClearKpiEntity */ clearKpiEntity(input: ClearKpiEntityRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[5], opt = this._transport.mergeOptions(options); + const method = this.methods[6], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: CreateMV */ createMV(input: CreateMVRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[6], opt = this._transport.mergeOptions(options); + const method = this.methods[7], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: DropMV */ dropMV(input: DropMVRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[7], opt = this._transport.mergeOptions(options); + const method = this.methods[8], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: PopulateMV */ populateMV(input: PopulateMVRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[8], opt = this._transport.mergeOptions(options); + const method = this.methods[9], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } } diff --git a/kpi.ts b/kpi.ts index 8cdacdf..301b980 100644 --- a/kpi.ts +++ b/kpi.ts @@ -135,6 +135,58 @@ export interface GetKpisResult { */ Kpis: Kpi[]; } +/** + * @generated from protobuf message api.GetKpisWithSelectionRequest + */ +export interface GetKpisWithSelectionRequest { + /** + * @generated from protobuf field: api.RequestProjectHeader Header = 1 + */ + Header?: RequestProjectHeader; + /** + * @generated from protobuf field: string Domain = 2 + */ + Domain: string; + /** + * Widget analysis criterion, executionflow for Order and stock for Stock + * + * @generated from protobuf field: string Group = 3 + */ + Group: string; + /** + * @generated from protobuf field: bool isMetric = 4 + */ + isMetric: boolean; + /** + * @generated from protobuf field: bool isDimension = 5 + */ + isDimension: boolean; + /** + * @generated from protobuf field: bool isDate = 6 + */ + isDate: boolean; + /** + * @generated from protobuf field: bool isCount = 7 + */ + isCount: boolean; + /** + * @generated from protobuf field: bool OnlyQueryable = 8 + */ + OnlyQueryable: boolean; + /** + * @generated from protobuf field: repeated string SelectedKpis = 9 + */ + SelectedKpis: string[]; +} +/** + * @generated from protobuf message api.GetKpisWithSelectionResult + */ +export interface GetKpisWithSelectionResult { + /** + * @generated from protobuf field: repeated api.Kpi Kpis = 1 + */ + Kpis: Kpi[]; +} /** * @generated from protobuf message api.GetKpiTableStructureRequest */ @@ -690,6 +742,163 @@ class GetKpisResult$Type extends MessageType { */ export const GetKpisResult = new GetKpisResult$Type(); // @generated message type with reflection information, may provide speed optimized methods +class GetKpisWithSelectionRequest$Type extends MessageType { + constructor() { + super("api.GetKpisWithSelectionRequest", [ + { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } }, + { no: 2, name: "Domain", kind: "scalar", localName: "Domain", jsonName: "Domain", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { default: "trade" }, "n1validate.rules": { string: { in: ["trade", "collab"] } } } }, + { no: 3, name: "Group", kind: "scalar", localName: "Group", jsonName: "Group", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Widget analysis criterion, executionflow, stock, movement or handlingunit", example: "\"executionflow\"" }, "n1validate.rules": { string: { in: ["executionflow", "stock", "movement", "handlingunit", "actor", "item", "stock_extended", "claim", "appointment"] } } } }, + { no: 4, name: "isMetric", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 5, name: "isDimension", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 6, name: "isDate", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 7, name: "isCount", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 8, name: "OnlyQueryable", kind: "scalar", localName: "OnlyQueryable", jsonName: "OnlyQueryable", T: 8 /*ScalarType.BOOL*/ }, + { no: 9, name: "SelectedKpis", kind: "scalar", localName: "SelectedKpis", jsonName: "SelectedKpis", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "List of already selected KPI names" } } } + ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } }); + } + create(value?: PartialMessage): GetKpisWithSelectionRequest { + const message = globalThis.Object.create((this.messagePrototype!)); + message.Domain = ""; + message.Group = ""; + message.isMetric = false; + message.isDimension = false; + message.isDate = false; + message.isCount = false; + message.OnlyQueryable = false; + message.SelectedKpis = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetKpisWithSelectionRequest): GetKpisWithSelectionRequest { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* api.RequestProjectHeader Header */ 1: + message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header); + break; + case /* string Domain */ 2: + message.Domain = reader.string(); + break; + case /* string Group */ 3: + message.Group = reader.string(); + break; + case /* bool isMetric */ 4: + message.isMetric = reader.bool(); + break; + case /* bool isDimension */ 5: + message.isDimension = reader.bool(); + break; + case /* bool isDate */ 6: + message.isDate = reader.bool(); + break; + case /* bool isCount */ 7: + message.isCount = reader.bool(); + break; + case /* bool OnlyQueryable */ 8: + message.OnlyQueryable = reader.bool(); + break; + case /* repeated string SelectedKpis */ 9: + message.SelectedKpis.push(reader.string()); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: GetKpisWithSelectionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* api.RequestProjectHeader Header = 1; */ + if (message.Header) + RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* string Domain = 2; */ + if (message.Domain !== "") + writer.tag(2, WireType.LengthDelimited).string(message.Domain); + /* string Group = 3; */ + if (message.Group !== "") + writer.tag(3, WireType.LengthDelimited).string(message.Group); + /* bool isMetric = 4; */ + if (message.isMetric !== false) + writer.tag(4, WireType.Varint).bool(message.isMetric); + /* bool isDimension = 5; */ + if (message.isDimension !== false) + writer.tag(5, WireType.Varint).bool(message.isDimension); + /* bool isDate = 6; */ + if (message.isDate !== false) + writer.tag(6, WireType.Varint).bool(message.isDate); + /* bool isCount = 7; */ + if (message.isCount !== false) + writer.tag(7, WireType.Varint).bool(message.isCount); + /* bool OnlyQueryable = 8; */ + if (message.OnlyQueryable !== false) + writer.tag(8, WireType.Varint).bool(message.OnlyQueryable); + /* repeated string SelectedKpis = 9; */ + for (let i = 0; i < message.SelectedKpis.length; i++) + writer.tag(9, WireType.LengthDelimited).string(message.SelectedKpis[i]); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.GetKpisWithSelectionRequest + */ +export const GetKpisWithSelectionRequest = new GetKpisWithSelectionRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class GetKpisWithSelectionResult$Type extends MessageType { + constructor() { + super("api.GetKpisWithSelectionResult", [ + { no: 1, name: "Kpis", kind: "message", localName: "Kpis", jsonName: "Kpis", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Kpi } + ]); + } + create(value?: PartialMessage): GetKpisWithSelectionResult { + const message = globalThis.Object.create((this.messagePrototype!)); + message.Kpis = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetKpisWithSelectionResult): GetKpisWithSelectionResult { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated api.Kpi Kpis */ 1: + message.Kpis.push(Kpi.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: GetKpisWithSelectionResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* repeated api.Kpi Kpis = 1; */ + for (let i = 0; i < message.Kpis.length; i++) + Kpi.internalBinaryWrite(message.Kpis[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.GetKpisWithSelectionResult + */ +export const GetKpisWithSelectionResult = new GetKpisWithSelectionResult$Type(); +// @generated message type with reflection information, may provide speed optimized methods class GetKpiTableStructureRequest$Type extends MessageType { constructor() { super("api.GetKpiTableStructureRequest", [ @@ -1472,6 +1681,7 @@ export const PopulateMVResult = new PopulateMVResult$Type(); */ export const KpiService = new ServiceType("api.KpiService", [ { name: "GetKpis", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["KPIs"], description: "Get the KPIs analysis possibilities" }, "google.api.method_visibility": { restriction: "SDK" }, "api.rscType": "Project", "api.roles": "Platform.Project-KPI" }, I: GetKpisRequest, O: GetKpisResult }, + { name: "GetKpisWithSelection", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["KPIs"], description: "Get the KPIs analysis possibilities with the list of already selected KPIs" }, "google.api.method_visibility": { restriction: "SDK" }, "api.rscType": "Project", "api.roles": "Platform.Project-KPI" }, I: GetKpisWithSelectionRequest, O: GetKpisWithSelectionResult }, { name: "GetKpiTableStructure", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["KPIs"], description: "Get KPI Table structure" }, "google.api.method_visibility": { restriction: "INTERNAL" }, "api.rscType": "Platform", "api.roles": "Platform.Project-KPI" }, I: GetKpiTableStructureRequest, O: GetKpiTableStructureResult }, { name: "UpdateKpiTableStructure", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["KPIs"], description: "Update KPI Table structure" }, "google.api.method_visibility": { restriction: "INTERNAL" }, "api.rscType": "Platform", "api.roles": "Platform.Project-KPI" }, I: UpdateKpiTableStructureRequest, O: UpdateKpiTableStructureResult }, { name: "DropKpiTableStructure", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["KPIs"], description: "Drop KPI Table structure" }, "google.api.method_visibility": { restriction: "INTERNAL" }, "api.rscType": "Platform", "api.roles": "Platform.Project-KPI" }, I: DropKpiTableStructureRequest, O: DropKpiTableStructureResult }, diff --git a/package.json b/package.json index 011d794..2cfb495 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@reflex-platform/npm-core-sdk", - "version": "1.15.0-SNAPSHOT-260828074503", + "version": "1.15.0-SNAPSHOT-260828091604", "description": "npm libs from core model proto files", "homepage": "", "main": "index.ts", diff --git a/stockQuery.client.ts b/stockQuery.client.ts index d031bfb..85ac52b 100644 --- a/stockQuery.client.ts +++ b/stockQuery.client.ts @@ -12,6 +12,8 @@ import type { CountLinesResult } from "./shared"; import type { CountLinesQuery } from "./shared"; import type { ExtractKPIResult } from "./clickhouse"; import type { ExtractKPIQuery } from "./clickhouse"; +import type { GetKPIDataSimpleJSONResult } from "./clickhouse"; +import type { GetKPIDataSimpleJSONQuery } from "./clickhouse"; import type { GetKPIDataForUserQuery } from "./clickhouse"; import type { GetKPIDataResult } from "./clickhouse"; import type { GetKPIDataQuery } from "./clickhouse"; @@ -60,6 +62,10 @@ export interface IStockQueryClient { * @generated from protobuf rpc: GetKPIDataForUser */ getKPIDataForUser(input: GetKPIDataForUserQuery, options?: RpcOptions): UnaryCall; + /** + * @generated from protobuf rpc: GetKPIDataSimpleJSON + */ + getKPIDataSimpleJSON(input: GetKPIDataSimpleJSONQuery, options?: RpcOptions): UnaryCall; /** * @generated from protobuf rpc: ExtractKPI */ @@ -134,32 +140,39 @@ export class StockQueryClient implements IStockQueryClient, ServiceInfo { const method = this.methods[5], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } + /** + * @generated from protobuf rpc: GetKPIDataSimpleJSON + */ + getKPIDataSimpleJSON(input: GetKPIDataSimpleJSONQuery, options?: RpcOptions): UnaryCall { + const method = this.methods[6], opt = this._transport.mergeOptions(options); + return stackIntercept("unary", this._transport, method, opt, input); + } /** * @generated from protobuf rpc: ExtractKPI */ extractKPI(input: ExtractKPIQuery, options?: RpcOptions): UnaryCall { - const method = this.methods[6], opt = this._transport.mergeOptions(options); + const method = this.methods[7], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: CountLines */ countLines(input: CountLinesQuery, options?: RpcOptions): UnaryCall { - const method = this.methods[7], opt = this._transport.mergeOptions(options); + const method = this.methods[8], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: FindKPIData */ findKPIData(input: FindKPIDataQuery, options?: RpcOptions): UnaryCall { - const method = this.methods[8], opt = this._transport.mergeOptions(options); + const method = this.methods[9], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: Extract */ extract(input: ExtractQuery, options?: RpcOptions): UnaryCall { - const method = this.methods[9], opt = this._transport.mergeOptions(options); + const method = this.methods[10], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } } diff --git a/stockQuery.ts b/stockQuery.ts index 984cde1..ac75d0d 100644 --- a/stockQuery.ts +++ b/stockQuery.ts @@ -9,6 +9,8 @@ import { CountLinesResult } from "./shared"; import { CountLinesQuery } from "./shared"; import { ExtractKPIResult } from "./clickhouse"; import { ExtractKPIQuery } from "./clickhouse"; +import { GetKPIDataSimpleJSONResult } from "./clickhouse"; +import { GetKPIDataSimpleJSONQuery } from "./clickhouse"; import { GetKPIDataForUserQuery } from "./clickhouse"; import { GetKPIDataResult } from "./clickhouse"; import { GetKPIDataQuery } from "./clickhouse"; @@ -629,6 +631,7 @@ export const StockQuery = new ServiceType("api.StockQuery", [ { name: "FindMatchingFieldElements", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Query"], description: "using search criteria & a main field word, find the list of field elements containing the searched word (used for auto completion purposes ...) " }, "google.api.method_visibility": { restriction: "PUBLIC" }, "api.rscType": "Project", "api.roles": "", "api.moduleID": "stock-inventory", "api.tags": "PROJECT_ACTIVITY" }, I: ElementByMatchQuery, O: ElementByMatchResult }, { name: "GetKPIData", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Query"], description: "Get stock KPI data" }, "google.api.method_visibility": { restriction: "PUBLIC" }, "api.rscType": "Project", "api.roles": "Platform.Project-KPI", "api.moduleID": "stock-inventory", "api.tags": "PROJECT_ACTIVITY" }, I: GetKPIDataQuery, O: GetKPIDataResult }, { name: "GetKPIDataForUser", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Query"], description: "Get stock KPI data for a specific user" }, "google.api.method_visibility": { restriction: "INTERNAL" }, "api.rscType": "Platform", "api.roles": "Platform.Project-KPI", "api.moduleID": "", "api.tags": "PROJECT_ACTIVITY" }, I: GetKPIDataForUserQuery, O: GetKPIDataResult }, + { name: "GetKPIDataSimpleJSON", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Query"], summary: "Get stock KPI data (SimpleJSON)", description: "Get stock KPI data in SimpleJSON table format, compatible with Grafana SimpleJSON / Infinity datasource" }, "google.api.method_visibility": { restriction: "PUBLIC" }, "api.rscType": "Project", "api.roles": "Project.Stock-KPI", "api.moduleID": "", "api.tags": "PROJECT_ACTIVITY" }, I: GetKPIDataSimpleJSONQuery, O: GetKPIDataSimpleJSONResult }, { name: "ExtractKPI", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Query"], description: "Schedule a data extraction" }, "google.api.method_visibility": { restriction: "PUBLIC" }, "api.rscType": "Project", "api.roles": "", "api.moduleID": "stock-inventory", "api.tags": "PROJECT_ACTIVITY" }, I: ExtractKPIQuery, O: ExtractKPIResult }, { name: "CountLines", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Query"], description: "Count lines in database for project" }, "google.api.method_visibility": { restriction: "INTERNAL" }, "api.rscType": "Platform", "api.roles": "Platform.Project-Query", "api.moduleID": "stock-inventory", "api.tags": "PROJECT_ACTIVITY" }, I: CountLinesQuery, O: CountLinesResult }, { name: "FindKPIData", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Query"], description: "Find stock KPI data" }, "google.api.method_visibility": { restriction: "PUBLIC" }, "api.rscType": "Project", "api.roles": "", "api.moduleID": "stock-inventory", "api.tags": "PROJECT_ACTIVITY" }, I: FindKPIDataQuery, O: FindKPIDataResult },