@514labs/moose-proto 0.6.297-ci-20-gec2306d8 → 0.6.297-ci-5-g194c6fe0

package/dist/infrastructure_map.mjs

@@ -1964,7 +1964,8 @@ var Table$Type = class extends MessageType3 {
         opt: true,
         T: 9
         /*ScalarType.STRING*/
-      }
+      },
+      { no: 21, name: "projections", kind: "message", repeat: 2, T: () => TableProjection }
     ]);
   }
   create(value) {
@@ -1976,6 +1977,7 @@ var Table$Type = class extends MessageType3 {
     message.lifeCycle = 0;
     message.tableSettings = {};
     message.indexes = [];
+    message.projections = [];
     if (value !== void 0)
       reflectionMergePartial3(this, message, value);
     return message;
@@ -2065,6 +2067,10 @@ var Table$Type = class extends MessageType3 {
         20:
           message.tableSettingsHash = reader.string();
           break;
+        case /* repeated moose.proto.TableProjection projections */
+        21:
+          message.projections.push(TableProjection.internalBinaryRead(reader, reader.uint32(), options));
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -2134,6 +2140,8 @@ var Table$Type = class extends MessageType3 {
       writer.tag(19, WireType3.LengthDelimited).string(message.primaryKeyExpression);
     if (message.tableSettingsHash !== void 0)
       writer.tag(20, WireType3.LengthDelimited).string(message.tableSettingsHash);
+    for (let i = 0; i < message.projections.length; i++)
+      TableProjection.internalBinaryWrite(message.projections[i], writer.tag(21, WireType3.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
@@ -2361,6 +2369,189 @@ var TableIndex$Type = class extends MessageType3 {
   }
 };
 var TableIndex = new TableIndex$Type();
+var ProjectionClause$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.ProjectionClause", [
+      { no: 1, name: "fields", kind: "message", oneof: "clause", T: () => ProjectionFields },
+      {
+        no: 2,
+        name: "expression",
+        kind: "scalar",
+        oneof: "clause",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.clause = { oneofKind: void 0 };
+    if (value !== void 0)
+      reflectionMergePartial3(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* moose.proto.ProjectionFields fields */
+        1:
+          message.clause = {
+            oneofKind: "fields",
+            fields: ProjectionFields.internalBinaryRead(reader, reader.uint32(), options, message.clause.fields)
+          };
+          break;
+        case /* string expression */
+        2:
+          message.clause = {
+            oneofKind: "expression",
+            expression: 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.clause.oneofKind === "fields")
+      ProjectionFields.internalBinaryWrite(message.clause.fields, writer.tag(1, WireType3.LengthDelimited).fork(), options).join();
+    if (message.clause.oneofKind === "expression")
+      writer.tag(2, WireType3.LengthDelimited).string(message.clause.expression);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var ProjectionClause = new ProjectionClause$Type();
+var ProjectionFields$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.ProjectionFields", [
+      {
+        no: 1,
+        name: "field",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.field = [];
+    if (value !== void 0)
+      reflectionMergePartial3(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated string field */
+        1:
+          message.field.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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.field.length; i++)
+      writer.tag(1, WireType3.LengthDelimited).string(message.field[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var ProjectionFields = new ProjectionFields$Type();
+var TableProjection$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.TableProjection", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "select", kind: "message", T: () => ProjectionClause },
+      { no: 3, name: "order_by", kind: "message", T: () => ProjectionClause },
+      { no: 4, name: "group_by", kind: "message", T: () => ProjectionClause }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.name = "";
+    if (value !== void 0)
+      reflectionMergePartial3(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* moose.proto.ProjectionClause select */
+        2:
+          message.select = ProjectionClause.internalBinaryRead(reader, reader.uint32(), options, message.select);
+          break;
+        case /* moose.proto.ProjectionClause order_by */
+        3:
+          message.orderBy = ProjectionClause.internalBinaryRead(reader, reader.uint32(), options, message.orderBy);
+          break;
+        case /* optional moose.proto.ProjectionClause group_by */
+        4:
+          message.groupBy = ProjectionClause.internalBinaryRead(reader, reader.uint32(), options, message.groupBy);
+          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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.name);
+    if (message.select)
+      ProjectionClause.internalBinaryWrite(message.select, writer.tag(2, WireType3.LengthDelimited).fork(), options).join();
+    if (message.orderBy)
+      ProjectionClause.internalBinaryWrite(message.orderBy, writer.tag(3, WireType3.LengthDelimited).fork(), options).join();
+    if (message.groupBy)
+      ProjectionClause.internalBinaryWrite(message.groupBy, writer.tag(4, WireType3.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var TableProjection = new TableProjection$Type();
 var View$Type = class extends MessageType3 {
   constructor() {
     super("moose.proto.View", [
@@ -4432,6 +4623,8 @@ export {
   OrderByFields,
   PrimitiveSignature,
   PrimitiveTypes,
+  ProjectionClause,
+  ProjectionFields,
   SchemaRegistry,
   SchemaRegistry_Encoding,
   SimpleColumnType,
@@ -4441,6 +4634,7 @@ export {
   Table,
   TableAlias,
   TableIndex,
+  TableProjection,
   Topic,
   TopicToTableSyncProcess,
   TopicToTopicSyncProcess,