@devvit/protos 0.12.1-next-2025-09-08-20-55-43-6ce1b439e.0 → 0.12.1-next-2025-09-09-13-45-18-0f0a506a2.0

package/schema/.snootobuf/deps/.snootobuf/deps/reddit/coreplatform/cloudroutines/operation/v1/operation.proto

@@ -0,0 +1,148 @@
+syntax = "proto3";
+
+package reddit.coreplatform.cloudroutines.operation.v1;
+
+import "google/protobuf/timestamp.proto";
+import "google/rpc/status.proto";
+import "validate/validate.proto";
+
+option go_package = "github.snooguts.net/reddit/cloudroutines/go/operationpb/v1;operationpb";
+
+// RPC Service for working with Cloudroutines operations
+service OperationService {
+  // Poll for the status of an operation
+  rpc PollOperationStatuses(PollOperationStatusesRequest) returns (PollOperationStatusesResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+
+  // Update the status of an operation
+  rpc PublishOperationStatus(PublishOperationStatusRequest) returns (PublishOperationStatusResponse) {
+    option idempotency_level = IDEMPOTENT;
+  }
+
+  // Mark an operation as skippable
+  rpc SkipOperation(SkipOperationRequest) returns (SkipOperationResponse) {
+    option idempotency_level = IDEMPOTENT;
+  }
+}
+
+// Request payload to check the statuses of Cloudroutines operations
+// This request requires the operationURI, consisting of the fully qualified Cloudroutines callback name and event ID.
+// If the retention period has elapsed, then requesting a previously valid operation URI will result in
+// a NOT_FOUND status code being returned.
+message PollOperationStatusesRequest {
+  // A list of operation URIs (RFC 3986) to request statuses for, each formatted as
+  // `{worker_pool_namespace}:{callback_name}:{eventID}`.
+  repeated string operation_uris = 1 [(validate.rules).repeated = {
+    min_items: 1
+    max_items: 10
+    items: {
+      string: {
+        uri: true
+        min_len: 1
+        max_len: 255
+      }
+    }
+  }];
+}
+
+// Response payload to check the statuses of Cloudroutines operations
+message PollOperationStatusesResponse {
+  // A map of operations by their URI to their statuses
+  map<string, Operation> associated_operations = 2;
+}
+
+// Request payload to update the status of a Cloudroutines operation
+// This request requires the operationURI, consisting of the fully qualified Cloudroutines callback name and event ID.
+message PublishOperationStatusRequest {
+  // The operation URI (RFC 3986), formatted as `{worker_pool_namespace}:{callback_name}:{eventID}`.
+  string operation_uri = 1 [(validate.rules).string = {
+    uri: true
+    min_len: 1
+    max_len: 255
+  }];
+
+  // The status to update the operation to, must be a valid status (not UNKNOWN). If the operation on the request
+  // is in an initial phase, any provided status value on the request will be ignored and default to UNKNOWN.
+  // Terminal statuses (any status that is not UNKNOWN) cannot be overwritten.
+  google.rpc.Status status = 3;
+
+  // The phase corresponding to the status update for the operation.
+  Phase phase = 4 [(validate.rules).enum = {
+    not_in: [0]
+  }];
+}
+
+// Response payload to update the status of a Cloudroutines operation
+message PublishOperationStatusResponse {}
+
+// Request payload to mark an operation as skippable
+message SkipOperationRequest {
+  // The operation URI (RFC 3986), formatted as `{worker_pool_namespace}:{callback_name}:{eventID}`.
+  string operation_uri = 1 [(validate.rules).string = {
+    uri: true
+    min_len: 1
+    max_len: 255
+  }];
+}
+
+// Response payload to mark an operation as skippable
+message SkipOperationResponse {}
+
+// Phase represents the individual states a Cloudroutines operation can be in throughout its lifecycle.
+enum Phase {
+  // No status was specified or set.
+  PHASE_UNSPECIFIED = 0;
+
+  // An operation is acknowledged by the system but not processed yet. The initial state.
+  PHASE_PENDING = 1;
+
+  // An operation has started processing within the system. Used only for long running operations.
+  PHASE_IN_PROGRESS = 2;
+
+  // An operation has successfully processed or ended up in an unrecoverable error state.
+  PHASE_COMPLETED = 3;
+}
+
+// An operation represents the Cloudroutines operation state including its current status.
+// Due to the nature of Cloudroutines, these are eventually consistent values.
+message Operation {
+  // The operation URI, formatted as `{worker_pool_namespace}:{callback_name}:{eventID}`.
+  // TODO: fix regex
+  string uri = 1 [(validate.rules).string = {
+    // pattern: "^[-_.a-zA-Z0-9]+$",
+    min_len: 1
+    max_len: 255
+  }];
+
+  // The phase of the operation.
+  Phase phase = 2;
+
+  // Operations that complete successfully will have a status `OK`. Any other status code indicates failure.
+  // Status will only be populated when phase is completed. If an operation produces any metadata or results,
+  // they will be available as additional details on the status.
+  google.rpc.Status status = 3;
+
+  // Time when the operation expires from both the event queue and status store.
+  google.protobuf.Timestamp expires_at = 4;
+}
+
+// Used internally within Cloudroutines to asynchronously store the given operation
+message StoreOperationStatus {
+  // The event ID, a unique identifier for an event.
+  string event_id = 1 [(validate.rules).string = {
+    min_len: 1
+    max_len: 255
+  }];
+
+  // The fully qualified Cloudroutines callback name (worker pool namespace + callback name) that processed the operation.
+  string fq_callback_name = 2 [(validate.rules).string = {
+    ignore_empty: true
+    // pattern: "^[-_.a-zA-Z0-9]+$",
+    min_len: 1
+    max_len: 255
+  }];
+
+  // The status to update the operation to, must be a valid status (not UNKNOWN).
+  google.rpc.Status status = 3;
+}

package/schema/.snootobuf/deps/.snootobuf/deps/reddit/coreplatform/cloudroutines/publication/v1/publication_service.proto

@@ -0,0 +1,56 @@
+syntax = "proto3";
+
+package reddit.coreplatform.cloudroutines.publication.v1;
+
+import "reddit/coreplatform/events/cloudevent/v1/cloudevent.proto";
+import "validate/validate.proto";
+
+option go_package = "github.snooguts.net/reddit/cloudroutines/go/publicationpb/v1;publicationpb";
+
+service PublicationService {
+  // PublishEvent makes an RPC call to the Cloudroutines server to publish the given event at the given topic
+  rpc PublishEvent(PublishEventRequest) returns (PublishEventResponse) {
+    option idempotency_level = IDEMPOTENT;
+  }
+}
+
+// Request message containing the event to be published by the user's registered callback
+// Server performs checks to ensure the request parameters are valid:
+// event type and topic are compatible, key is provided if topic is ordered
+message PublishEventRequest {
+  // CloudEvent compliant event payload
+  reddit.coreplatform.events.cloudevent.v1.CloudEvent event = 1 [(validate.rules).message.required = true];
+
+  // Topic to publish the given event to. Typically, this is the fully qualified message name of the event.
+  string topic = 2 [(validate.rules).string = {
+    pattern: "^[-_.a-zA-Z0-9]+$"
+    min_len: 1
+    max_len: 255
+  }];
+
+  // Value to use as the partition key (used for ordering) when publishing the given event.
+  // Must be set to guarantee ordering within a partition, if no ordering is necessary, then pass the event ID.
+  string partition_key = 3 [(validate.rules).string = {
+    pattern: "^[-_.a-zA-Z0-9]+$"
+    min_len: 1
+    max_len: 255
+  }];
+}
+
+// Response message containing the published event details
+message PublishEventResponse {
+  // Event detail information
+  EventDetails event_details = 1;
+}
+
+// Message containing the published event details
+message EventDetails {
+  // The event ID, a unique identifier of the event published
+  string event_id = 1;
+
+  // The topic the event was published to
+  string topic = 2;
+
+  // The partition key the event was published to
+  string partition_key = 3;
+}

package/schema/.snootobuf/deps/.snootobuf/deps/reddit/coreplatform/cloudroutines/scheduling/v1/offsets.proto

@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package reddit.coreplatform.cloudroutines.scheduling.v1;
+
+option go_package = "github.snooguts.net/reddit/cloudroutines/go/schedulingpb/v1;schedulingpb";
+
+message DataSourceOffsetRange {
+  message KafkaTopicOffsetRange {
+    string topic = 1;
+    map<int32, int64> start_offset_by_partition = 2;
+    map<int32, int64> end_offset_by_partition = 3;
+  }
+
+  oneof offset_range {
+    KafkaTopicOffsetRange kafka_topic_offset_range = 1;
+  }
+}

package/schema/.snootobuf/deps/.snootobuf/deps/reddit/coreplatform/cloudroutines/scheduling/v1/scheduling.proto

@@ -0,0 +1,25 @@
+syntax = "proto3";
+
+package reddit.coreplatform.cloudroutines.scheduling.v1;
+
+import "reddit/coreplatform/events/cloudevent/v1/cloudevent.proto";
+
+option go_package = "github.snooguts.net/reddit/cloudroutines/go/schedulingpb/v1;schedulingpb";
+
+service SchedulerService {
+  rpc ScheduleTask(ScheduleTaskRequest) returns (ScheduleTaskResponse) {
+    option idempotency_level = IDEMPOTENT;
+  }
+}
+
+message TaskReference {
+  string id = 1;
+}
+
+message ScheduleTaskRequest {
+  reddit.coreplatform.events.cloudevent.v1.CloudEvent event = 1;
+}
+
+message ScheduleTaskResponse {
+  TaskReference task_reference = 1;
+}

package/schema/.snootobuf/deps/.snootobuf/deps/reddit/coreplatform/cloudroutines/testing/v1/testing.proto

@@ -0,0 +1,72 @@
+syntax = "proto3";
+
+package reddit.coreplatform.cloudroutines.testing.v1;
+
+import "reddit/coreplatform/cloudroutines/event/v1/event.proto";
+
+option go_package = "github.snooguts.net/reddit/cloudroutines/go/testingpb/v1;testingpb";
+
+// Request message containing the event to be processed by the user's registered event handler
+message ExampleEvent {
+  string user_id = 1 [(reddit.coreplatform.cloudroutines.event.v1.field) = {sharding_identifier: true}];
+
+  string subreddit_id = 2;
+}
+
+message ExampleTask {
+  string user_id = 1 [(reddit.coreplatform.cloudroutines.event.v1.field) = {sharding_identifier: true}];
+
+  string greeting = 2;
+}
+
+message ExampleCustomizedEvent {
+  option (reddit.coreplatform.cloudroutines.event.v1.message) = {
+    default_topic: "my_existing_topic"
+    publication_source_whitelist: [
+      {
+        deployment_reference: {
+          name: "reddit-service-cloudroutines-dummy-client"
+          namespace: "reddit-service-cloudroutines"
+        }
+      }
+    ]
+  };
+
+  string subreddit_id = 1 [(reddit.coreplatform.cloudroutines.event.v1.field) = {sharding_identifier: true}];
+}
+
+message ExampleCustomizedNestedEvent {
+  message Relation {
+    string relation_id = 1;
+    RelationDetails details = 2;
+  }
+
+  message RelationDetails {
+    string thing1_id = 1; // this is the sharding identifier
+    string thing2_id = 2;
+    int64 int64_field = 3;
+    repeated string repeated_string_field = 4;
+    float float_field = 5;
+  }
+
+  string event_id = 1;
+
+  Relation relation = 2 [(reddit.coreplatform.cloudroutines.event.v1.field) = {
+    sharding_identifier: true
+    sharding_field_path: "details.thing1_id"
+  }];
+
+  int64 int64_field = 3;
+  repeated string repeated_string_field = 4;
+  float float_field = 5;
+}
+
+message ExampleDLQEvent {
+  string user_id = 1 [(reddit.coreplatform.cloudroutines.event.v1.field) = {sharding_identifier: true}];
+
+  string subreddit_id = 2;
+}
+
+message ExampleResult {
+  string greeting = 1;
+}

package/schema/.snootobuf/deps/.snootobuf/deps/reddit/coreplatform/cloudroutines/workerpool/v1/workerpool.proto

@@ -0,0 +1,213 @@
+syntax = "proto3";
+
+package reddit.coreplatform.cloudroutines.workerpool.v1;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/timestamp.proto";
+import "google/rpc/status.proto";
+import "reddit/coreplatform/cloudroutines/experimental/v1/experimental.proto";
+import "reddit/coreplatform/cloudroutines/scheduling/v1/offsets.proto";
+import "validate/validate.proto";
+
+option go_package = "github.snooguts.net/reddit/cloudroutines/go/workerpoolpb/v1;workerpoolpb";
+
+service WorkerPoolService {
+  // RegisterWorkerPoolVersion handles the registration of new workers to a given pool.
+  // Responses contain a mapping of callback names to corresponding error statuses encountered during registration.
+  // Problematic callbacks will be omitted from registration and returned in the response errors map.
+  rpc RegisterWorkerPoolVersion(RegisterWorkerPoolVersionRequest) returns (RegisterWorkerPoolVersionResponse) {
+    option idempotency_level = IDEMPOTENT;
+  }
+
+  // ReplayCallbackWithWindow will trigger Cloudroutines to redeliver messages published within the specified time
+  // window to the specified callback. If the time window falls outside of the topic retention window, then no messages will
+  // be delivered and an error is returned.
+  rpc ReplayCallbackWithWindow(ReplayCallbackWithWindowRequest) returns (ReplayCallbackWithWindowResponse) {
+    option idempotency_level = IDEMPOTENT;
+  }
+}
+
+message ReplayWindow {
+  google.protobuf.Timestamp start = 1;
+  google.protobuf.Timestamp end = 2;
+}
+
+message ReplayCallbackWithWindowRequest {
+  string callback_namespace = 1 [(validate.rules).string = {
+    pattern: "^[-a-zA-Z0-9]+$"
+    min_len: 1
+    max_len: 255
+  }];
+  string callback_name = 2 [(validate.rules).string = {
+    pattern: "^[_a-zA-Z0-9]+$"
+    min_len: 1
+    max_len: 255
+  }];
+
+  ReplayWindow replay_window = 3;
+}
+
+message ReplayCallbackWithWindowResponse {
+  reddit.coreplatform.cloudroutines.scheduling.v1.DataSourceOffsetRange window_offset_range = 1;
+}
+
+message RegisterWorkerPoolVersionRequest {
+  // Reference to the worker pool that the worker is registering to.
+  WorkerPool.Source worker_pool_source = 1;
+
+  WorkerPool.Version worker_pool_version = 2;
+
+  // Unique ID of the worker instance.
+  // This must match the pod name of the caller.
+  string worker_id = 3 [(validate.rules).string = {
+    pattern: "^[-_.a-zA-Z0-9]+$"
+    min_len: 1
+    max_len: 255
+  }];
+}
+
+message CallbackInfo {
+  // The name of the callback
+  string name = 1 [(validate.rules).string = {
+    pattern: "^[_a-zA-Z0-9]+$"
+    min_len: 1
+    max_len: 255
+  }];
+
+  string request_full_name = 2;
+
+  // The kafka topic that the callback wants to handle.
+  // If empty, the kafka topic will default to the fullname of the message descriptor.
+  string source_topic = 3 [(validate.rules).string = {
+    ignore_empty: true
+    pattern: "^[-_.a-zA-Z0-9]+$"
+    max_len: 255
+  }];
+
+  // Configuration for experimental callback settings and features.
+  // Not recommended for general usage.
+  experimental.v1.ExperimentalCallbackOptions experimental_options = 4;
+
+  // A list of extensions which influence the scheduling decisions and consumer behavior. This
+  // field is meant to be populated only by the Cloudroutines scheduler. Attempts to configure this
+  // outside of the scheduler should fail immediately.
+  repeated google.protobuf.Any internal_scheduling_extensions = 5;
+}
+
+message RegisterWorkerPoolVersionResponse {
+  // Mapping of callback names to error statuses encountered during registration.
+  map<string, google.rpc.Status> errors = 1;
+}
+
+// Used internally within Cloudroutines to asynchronously update worker discovery information.
+message WorkerPoolEvent {
+  message RegisterVersion {
+    WorkerPool.Source source = 1;
+    WorkerPool.Version version = 2;
+
+    // The unique identifier for the member of the worker pool which triggered this registration event. If blank,
+    // this the event was triggered by internal automation or a state resync. This value is usually the pod name.
+    string worker_id = 3;
+  }
+
+  message EvictVersion {
+    WorkerPool.Source source = 1;
+    WorkerPool.Version version = 2;
+  }
+
+  message EvictPool {
+    WorkerPool.Source source = 1;
+  }
+
+  oneof event {
+    RegisterVersion register_version = 1;
+    EvictVersion evict_version = 2;
+    EvictPool evict_pool = 3;
+  }
+}
+
+message WorkerPool {
+  message Source {
+    oneof source {
+      // Reference to the deployment that the worker pool is associated with.
+      // Contains separate fields for the deployment name and namespace.
+      DeploymentReference deployment_reference = 1;
+    }
+  }
+
+  message Version {
+    // The version of the worker pool. By default this is the pod template hash which we use as the
+    // version identifier for a set of pods. When dynamic reloading is enabled, we have to use the
+    // computed hash of the callback contents.
+    string id = 1 [(validate.rules).string = {
+      pattern: "^[-_.a-zA-Z0-9]+$"
+      min_len: 1
+      max_len: 255
+    }];
+
+    // The port that the workers are listening on.
+    int32 port = 3 [(validate.rules).int32 = {
+      gte: 1
+      lte: 65535
+    }];
+    // The list of callbacks that the worker pool is able to handle.
+    map<string, CallbackInfo> callbacks = 4 [(validate.rules).map = {min_pairs: 1}];
+
+    google.protobuf.Any workload_extension = 5;
+
+    // Optional version id of the deployment or workload this version struct is associated with. This field is
+    // used when dynamic reloading of callbacks is configured.
+    string workload_version_id = 6;
+  }
+
+  Source source = 1;
+
+  map<string, Version> versions = 2;
+}
+
+message DeploymentReference {
+  // The name of the deployment.
+  string name = 1 [(validate.rules).string = {
+    pattern: "^[-_.a-zA-Z0-9]+$"
+    min_len: 1
+    max_len: 255
+  }];
+  // The namespace of the deployment.
+  string namespace = 2 [(validate.rules).string = {
+    pattern: "^[-_.a-zA-Z0-9]+$"
+    min_len: 1
+    max_len: 255
+  }];
+}
+
+message EinhornWorkloadExtension {
+  message PortRange {
+    int32 start = 1 [(validate.rules).int32 = {
+      gte: 1
+      lte: 65535
+    }];
+    int32 end = 2 [(validate.rules).int32 = {
+      gte: 1
+      lte: 65535
+    }];
+  }
+
+  // The port range that the worker pool is listening on.
+  PortRange port_range = 1;
+}
+
+message MonocerosWorkloadExtension {
+  message PortRange {
+    int32 start = 1 [(validate.rules).int32 = {
+      gte: 1
+      lte: 65535
+    }];
+    int32 end = 2 [(validate.rules).int32 = {
+      gte: 1
+      lte: 65535
+    }];
+  }
+
+  // The port range that the worker pool is listening on.
+  PortRange port_range = 1;
+}

package/schema/.snootobuf/deps/.snootobuf/deps/reddit/coreplatform/comments/v1/comment_tree.proto

@@ -0,0 +1,78 @@
+syntax = "proto3";
+
+package reddit.coreplatform.comments.v1;
+
+import "google/protobuf/descriptor.proto";
+import "reddit/coreplatform/comments/v1/comments.proto";
+
+option go_package = "github.snooguts.net/reddit/thing-api/go/grpc/comments/v1;comments";
+option java_multiple_files = true;
+option java_outer_classname = "CommentTreeProto";
+option java_package = "com.reddit.coreplatform.api.comments.v1";
+
+// Message representing a comment tree. This is not a traditional tree or graph.
+// A CommentTree is represented via a list of Nodes.
+// Each of which may contain a Comment Thing model, comment id, or a cursor to sub-segment of the tree.
+message CommentTree {
+  // Enum with possible max_comments/max_depth cached/precomputed comment tree sizes
+  enum PrecomputedTreeView {
+    // the default value is unspecified so usage of this enum must be explicit when supplying a value
+    PRECOMPUTED_TREE_VIEW_UNSPECIFIED = 0;
+    // logged out user - 200 max_comments / 5 max_depth
+    PRECOMPUTED_TREE_VIEW_LOGGED_OUT = 1;
+    // logged in user - 500 max_comments / 5 max_depth
+    PRECOMPUTED_TREE_VIEW_DEFAULT = 2;
+    // the user has Gold/Premium - 1500 max_comments / 7 max_depth
+    PRECOMPUTED_TREE_VIEW_GOLD = 3;
+    // user viewing on Shreddit - 10 max_comments / 2 max_depth
+    PRECOMPUTED_TREE_VIEW_SHREDDIT = 4;
+  }
+
+  // Filters comments based on conditions when generating a CommentTree
+  enum Filter {
+    // No filtering will be applied
+    FILTER_UNSPECIFIED = 0;
+
+    // Only include comments which have a response by the OP or a collaborator
+    FILTER_ANSWERED = 1;
+    // Only include comments which do not have a response by the OP or a collaborator
+    FILTER_UNANSWERED = 2;
+  }
+
+  // LoadMoreComments represents a pointer to a comment tree subset that was hidden because of size/depth limitations or content relevancy.
+  message LoadMoreComments {
+    // A reference to a subset of a CommentTree
+    string cursor = 1;
+    // The number of comments the cursor points to
+    int32 num_comments = 2;
+  }
+
+  // Node represents a comment node (hydrated or non-hydrated) or a LoadMoreComments cursor.
+  message Node {
+    // The depth of this comment node from overall tree. This is the distance between
+    // this node and the root node of the comment tree.
+    int32 depth = 1;
+
+    // The t1 Thing Comment id of the parent of this comment. If this comment
+    // has no parent, then this field will be an empty string.
+    string parent_id = 2;
+
+    // The value of this (comment) Node.
+    oneof value {
+      // A fully hydrated Comment Thing model. This field will only be populated if the
+      // client requested the tree nodes to be hydrated.
+      Comment comment = 3;
+
+      // A t1 Thing Comment id that represents a comment. This field is populated if *no* comment hydration was requested.
+      string comment_id = 4;
+
+      // A reference to a comment tree subset. This node is used to represent
+      // a tree node for comments that are part of the tree but need to be loaded
+      // separately due to response size limitations or content relevancy.
+      LoadMoreComments load_more_comments = 5;
+    }
+  }
+
+  // An ordered list of the nodes that this comment tree segment is comprised of
+  repeated Node nodes = 1;
+}