diff --git a/api/swagger/superplane.swagger.json b/api/swagger/superplane.swagger.json index fdd6476267..942f05edc1 100644 --- a/api/swagger/superplane.swagger.json +++ b/api/swagger/superplane.swagger.json @@ -1258,7 +1258,7 @@ }, "put": { "summary": "Update canvas version", - "description": "Updates a user-owned canvas version; if version_id is omitted, updates the live canvas in sandbox mode", + "description": "Updates a user-owned canvas version; if version_id is omitted, updates the live canvas when versioning is disabled", "operationId": "Canvases_UpdateCanvasVersion2", "responses": { "200": { @@ -1334,7 +1334,7 @@ }, "put": { "summary": "Update canvas version", - "description": "Updates a user-owned canvas version; if version_id is omitted, updates the live canvas in sandbox mode", + "description": "Updates a user-owned canvas version; if version_id is omitted, updates the live canvas when versioning is disabled", "operationId": "Canvases_UpdateCanvasVersion", "responses": { "200": { @@ -1437,6 +1437,44 @@ "tags": [ "Canvas" ] + }, + "put": { + "summary": "Update canvas", + "description": "Updates canvas metadata", + "operationId": "Canvases_UpdateCanvas", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/CanvasesUpdateCanvasResponse" + } + }, + "default": { + "description": "An unexpected error response.", + "schema": { + "$ref": "#/definitions/googlerpcStatus" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/CanvasesUpdateCanvasBody" + } + } + ], + "tags": [ + "Canvas" + ] } }, "/api/v1/components": { @@ -4221,6 +4259,9 @@ }, "isTemplate": { "type": "boolean" + }, + "canvasVersioningEnabled": { + "type": "boolean" } } }, @@ -4754,6 +4795,28 @@ } } }, + "CanvasesUpdateCanvasBody": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "canvasVersioningEnabled": { + "type": "boolean" + } + } + }, + "CanvasesUpdateCanvasResponse": { + "type": "object", + "properties": { + "canvas": { + "$ref": "#/definitions/CanvasesCanvas" + } + } + }, "CanvasesUpdateCanvasVersionBody": { "type": "object", "properties": { @@ -5938,7 +6001,7 @@ "type": "string", "format": "date-time" }, - "canvasSandboxModeEnabled": { + "canvasVersioningEnabled": { "type": "boolean" } } diff --git a/db/migrations/20260306193850_rename-canvas-sandbox-mode-to-versioning.down.sql b/db/migrations/20260306193850_rename-canvas-sandbox-mode-to-versioning.down.sql new file mode 100644 index 0000000000..e69de29bb2 diff --git a/db/migrations/20260306193850_rename-canvas-sandbox-mode-to-versioning.up.sql b/db/migrations/20260306193850_rename-canvas-sandbox-mode-to-versioning.up.sql new file mode 100644 index 0000000000..b13bd37f07 --- /dev/null +++ b/db/migrations/20260306193850_rename-canvas-sandbox-mode-to-versioning.up.sql @@ -0,0 +1,12 @@ +BEGIN; + +ALTER TABLE public.organizations + RENAME COLUMN canvas_sandbox_mode_enabled TO canvas_versioning_enabled; + +UPDATE public.organizations +SET canvas_versioning_enabled = NOT canvas_versioning_enabled; + +ALTER TABLE public.organizations + ALTER COLUMN canvas_versioning_enabled SET DEFAULT false; + +COMMIT; diff --git a/db/migrations/20260306201921_add-canvas-versioning-to-workflows.down.sql b/db/migrations/20260306201921_add-canvas-versioning-to-workflows.down.sql new file mode 100644 index 0000000000..e69de29bb2 diff --git a/db/migrations/20260306201921_add-canvas-versioning-to-workflows.up.sql b/db/migrations/20260306201921_add-canvas-versioning-to-workflows.up.sql new file mode 100644 index 0000000000..a4faa607b7 --- /dev/null +++ b/db/migrations/20260306201921_add-canvas-versioning-to-workflows.up.sql @@ -0,0 +1,2 @@ +ALTER TABLE public.workflows + ADD COLUMN canvas_versioning_enabled boolean NOT NULL DEFAULT false; diff --git a/db/structure.sql b/db/structure.sql index d6ef10f19d..61ffd9a583 100644 --- a/db/structure.sql +++ b/db/structure.sql @@ -342,7 +342,7 @@ CREATE TABLE public.organizations ( updated_at timestamp without time zone DEFAULT CURRENT_TIMESTAMP, deleted_at timestamp without time zone, description text DEFAULT ''::text, - canvas_sandbox_mode_enabled boolean DEFAULT true NOT NULL + canvas_versioning_enabled boolean DEFAULT false NOT NULL ); @@ -604,7 +604,8 @@ CREATE TABLE public.workflows ( created_by uuid, deleted_at timestamp without time zone, is_template boolean DEFAULT false NOT NULL, - live_version_id uuid NOT NULL + live_version_id uuid NOT NULL, + canvas_versioning_enabled boolean DEFAULT false NOT NULL ); @@ -1846,7 +1847,7 @@ SET row_security = off; -- COPY public.schema_migrations (version, dirty) FROM stdin; -20260304110100 f +20260306201921 f \. diff --git a/docs/contributing/architecture.md b/docs/contributing/architecture.md index 07a6294cd4..43f33b4efe 100644 --- a/docs/contributing/architecture.md +++ b/docs/contributing/architecture.md @@ -90,6 +90,7 @@ The database model follows a hierarchical structure that enables multi-tenancy a - Top-level tenant boundary providing complete data isolation - All resources (canvases, integrations, secrets) are scoped to an organization +- Organization metadata `canvas_versioning_enabled` (API field `canvasVersioningEnabled`) acts as a global override for canvas versioning when enabled **Canvas:** @@ -97,6 +98,11 @@ The database model follows a hierarchical structure that enables multi-tenancy a - Belongs to an organization - Contains multiple workflows with their nodes and edges - Stores workflow graph structure, node configurations, and metadata +- Canvas editing behavior is controlled by effective canvas versioning: organization metadata `canvas_versioning_enabled` OR canvas metadata `canvas_versioning_enabled` (API field `canvasVersioningEnabled`) +- Effective behavior: + - Organization versioning enabled: all canvases are effectively versioned + - Organization versioning disabled: each canvas uses its own `canvas_versioning_enabled` value +- When effective canvas versioning is enabled, users edit draft versions and publish via change requests; when disabled, users edit the live canvas directly **Integration:** diff --git a/pkg/authorization/interceptor.go b/pkg/authorization/interceptor.go index 6e419ac34c..dfb9e9e63c 100644 --- a/pkg/authorization/interceptor.go +++ b/pkg/authorization/interceptor.go @@ -104,6 +104,7 @@ func NewAuthorizationInterceptor(authService Authorization) *AuthorizationInterc pbCanvases.Canvases_ListCanvases_FullMethodName: {Resource: "canvases", Action: "read", DomainType: models.DomainTypeOrganization}, pbCanvases.Canvases_DescribeCanvas_FullMethodName: {Resource: "canvases", Action: "read", DomainType: models.DomainTypeOrganization}, pbCanvases.Canvases_CreateCanvas_FullMethodName: {Resource: "canvases", Action: "create", DomainType: models.DomainTypeOrganization}, + pbCanvases.Canvases_UpdateCanvas_FullMethodName: {Resource: "canvases", Action: "update", DomainType: models.DomainTypeOrganization}, pbCanvases.Canvases_CreateCanvasVersion_FullMethodName: {Resource: "canvases", Action: "update", DomainType: models.DomainTypeOrganization}, pbCanvases.Canvases_ListCanvasVersions_FullMethodName: {Resource: "canvases", Action: "read", DomainType: models.DomainTypeOrganization}, pbCanvases.Canvases_DescribeCanvasVersion_FullMethodName: {Resource: "canvases", Action: "read", DomainType: models.DomainTypeOrganization}, diff --git a/pkg/cli/commands/canvases/models/canvas.go b/pkg/cli/commands/canvases/models/canvas.go index 29c59b3f20..21b3673c9b 100644 --- a/pkg/cli/commands/canvases/models/canvas.go +++ b/pkg/cli/commands/canvases/models/canvas.go @@ -32,6 +32,10 @@ func ParseCanvas(raw []byte) (*Canvas, error) { return nil, fmt.Errorf("canvas apiVersion is required") } + if resource.Metadata == nil { + return nil, fmt.Errorf("canvas metadata is required") + } + if resource.Metadata.Name == nil { return nil, fmt.Errorf("canvas metadata.name is required") } diff --git a/pkg/cli/commands/canvases/publish.go b/pkg/cli/commands/canvases/publish.go index 5b9905e3f3..e75c47a843 100644 --- a/pkg/cli/commands/canvases/publish.go +++ b/pkg/cli/commands/canvases/publish.go @@ -20,12 +20,12 @@ func (c *publishCommand) Execute(ctx core.CommandContext) error { return err } - versioningContext, err := resolveCanvasVersioningContext(ctx) + versioningContext, err := resolveCanvasVersioningContext(ctx, canvasID) if err != nil { return err } - if versioningContext.sandboxModeEnabled { - return fmt.Errorf("canvas versioning is disabled while sandbox mode is enabled") + if !versioningContext.versioningEnabled { + return fmt.Errorf("effective canvas versioning is disabled for this canvas") } draftVersionID, err := findCurrentUserDraftVersionID(ctx, canvasID) diff --git a/pkg/cli/commands/canvases/root.go b/pkg/cli/commands/canvases/root.go index e98b99ad40..f5f2d3fe9c 100644 --- a/pkg/cli/commands/canvases/root.go +++ b/pkg/cli/commands/canvases/root.go @@ -54,7 +54,7 @@ func NewCommand(options core.BindOptions) *cobra.Command { Args: cobra.MaximumNArgs(1), } updateCmd.Flags().StringVarP(&updateFile, "file", "f", "", "filename, directory, or URL to files to use to update the resource") - updateCmd.Flags().BoolVar(&updateDraft, "draft", false, "update your draft version (required when versioning is enabled)") + updateCmd.Flags().BoolVar(&updateDraft, "draft", false, "update your draft version (required when effective canvas versioning is enabled)") updateCmd.Flags().StringVar(&updateAutoLayout, "auto-layout", "", "automatically arrange the canvas (supported: horizontal)") updateCmd.Flags().StringVar(&updateAutoLayoutScope, "auto-layout-scope", "", "scope for auto layout (full-canvas, connected-component, exact-set)") updateCmd.Flags().StringArrayVar(&updateAutoLayoutNodes, "auto-layout-node", nil, "node id seed for auto layout (repeatable)") diff --git a/pkg/cli/commands/canvases/update.go b/pkg/cli/commands/canvases/update.go index ece0a1f3a8..dd7938e5bc 100644 --- a/pkg/cli/commands/canvases/update.go +++ b/pkg/cli/commands/canvases/update.go @@ -59,19 +59,19 @@ func (c *updateCommand) Execute(ctx core.CommandContext) error { current = &canvas } - versioningContext, err := resolveCanvasVersioningContext(ctx) + versioningContext, err := resolveCanvasVersioningContext(ctx, canvasID) if err != nil { return err } targetVersionID := "" - if versioningContext.sandboxModeEnabled { + if !versioningContext.versioningEnabled { if draftMode { - return fmt.Errorf("--draft cannot be used when canvas sandbox mode is enabled") + return fmt.Errorf("--draft cannot be used when effective canvas versioning is disabled") } } else { if !draftMode { - return fmt.Errorf("canvas versioning is enabled for this organization; use --draft to update your edit version") + return fmt.Errorf("effective canvas versioning is enabled for this canvas; use --draft") } targetVersionID, err = ensureCurrentUserDraftVersionID(ctx, canvasID) diff --git a/pkg/cli/commands/canvases/versioning_helpers.go b/pkg/cli/commands/canvases/versioning_helpers.go index 56e24fa318..141fdb2a0b 100644 --- a/pkg/cli/commands/canvases/versioning_helpers.go +++ b/pkg/cli/commands/canvases/versioning_helpers.go @@ -9,39 +9,22 @@ import ( ) type canvasVersioningContext struct { - currentUserID string - sandboxModeEnabled bool + versioningEnabled bool } -func resolveCanvasVersioningContext(ctx core.CommandContext) (*canvasVersioningContext, error) { - me, _, err := ctx.API.MeAPI.MeMe(ctx.Context).Execute() - if err != nil { - return nil, err - } - - currentUserID := strings.TrimSpace(me.GetId()) - if currentUserID == "" { - return nil, fmt.Errorf("user id not found for authenticated user") - } - - organizationID := strings.TrimSpace(me.GetOrganizationId()) - if organizationID == "" { - return nil, fmt.Errorf("organization id not found for authenticated user") - } - - organizationResponse, _, err := ctx.API.OrganizationAPI. - OrganizationsDescribeOrganization(ctx.Context, organizationID). +func resolveCanvasVersioningContext(ctx core.CommandContext, canvasID string) (*canvasVersioningContext, error) { + canvasResponse, _, err := ctx.API.CanvasAPI. + CanvasesDescribeCanvas(ctx.Context, canvasID). Execute() if err != nil { return nil, err } - if organizationResponse.Organization == nil || organizationResponse.Organization.Metadata == nil { - return nil, fmt.Errorf("organization metadata not found") + if canvasResponse.Canvas == nil || canvasResponse.Canvas.Metadata == nil { + return nil, fmt.Errorf("canvas metadata not found") } return &canvasVersioningContext{ - currentUserID: currentUserID, - sandboxModeEnabled: organizationResponse.Organization.Metadata.GetCanvasSandboxModeEnabled(), + versioningEnabled: canvasResponse.Canvas.Metadata.GetCanvasVersioningEnabled(), }, nil } diff --git a/pkg/cli/whoami.go b/pkg/cli/whoami.go index 9ec5c9f75d..70b61e6a8e 100644 --- a/pkg/cli/whoami.go +++ b/pkg/cli/whoami.go @@ -17,7 +17,7 @@ func (w *whoamiCommand) Execute(ctx core.CommandContext) error { } organizationLabel := response.GetOrganizationId() - var canvasSandboxModeEnabled *bool + var canvasVersioningEnabled *bool if response.HasOrganizationId() && response.GetOrganizationId() != "" { orgResponse, _, err := ctx.API.OrganizationAPI. OrganizationsDescribeOrganization(ctx.Context, response.GetOrganizationId()). @@ -29,20 +29,20 @@ func (w *whoamiCommand) Execute(ctx core.CommandContext) error { organizationLabel = *metadata.Name } - if enabled, ok := metadata.GetCanvasSandboxModeEnabledOk(); ok { - canvasSandboxModeEnabled = enabled + if enabled, ok := metadata.GetCanvasVersioningEnabledOk(); ok { + canvasVersioningEnabled = enabled } } } if ctx.Renderer.IsText() { return ctx.Renderer.RenderText(func(stdout io.Writer) error { - sandboxModeLabel := "unknown" - if canvasSandboxModeEnabled != nil { - if *canvasSandboxModeEnabled { - sandboxModeLabel = "enabled" + versioningLabel := "unknown" + if canvasVersioningEnabled != nil { + if *canvasVersioningEnabled { + versioningLabel = "enabled" } else { - sandboxModeLabel = "disabled" + versioningLabel = "disabled" } } @@ -50,17 +50,17 @@ func (w *whoamiCommand) Execute(ctx core.CommandContext) error { _, _ = fmt.Fprintf(stdout, "Email: %s\n", response.GetEmail()) _, _ = fmt.Fprintf(stdout, "Organization ID: %s\n", response.GetOrganizationId()) _, _ = fmt.Fprintf(stdout, "Organization: %s\n", organizationLabel) - _, _ = fmt.Fprintf(stdout, "Canvas Sandbox Mode: %s\n", sandboxModeLabel) + _, _ = fmt.Fprintf(stdout, "Canvas Versioning: %s\n", versioningLabel) return nil }) } return ctx.Renderer.Render(map[string]any{ - "id": response.GetId(), - "email": response.GetEmail(), - "organizationId": response.GetOrganizationId(), - "organizationName": organizationLabel, - "canvasSandboxModeEnabled": canvasSandboxModeEnabled, + "id": response.GetId(), + "email": response.GetEmail(), + "organizationId": response.GetOrganizationId(), + "organizationName": organizationLabel, + "canvasVersioningEnabled": canvasVersioningEnabled, }) } diff --git a/pkg/grpc/actions/canvases/create_canvas.go b/pkg/grpc/actions/canvases/create_canvas.go index 808c2bdc45..afaed67924 100644 --- a/pkg/grpc/actions/canvases/create_canvas.go +++ b/pkg/grpc/actions/canvases/create_canvas.go @@ -44,18 +44,26 @@ func CreateCanvas(ctx context.Context, registry *registry.Registry, organization if isTemplate { targetOrganizationID = models.TemplateOrganizationID } + canvasVersioningEnabled := false + if !isTemplate { + canvasVersioningEnabled, err = models.IsCanvasVersioningEnabled(targetOrganizationID) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to load organization canvas versioning: %v", err) + } + } liveVersionID := uuid.New() canvas := models.Canvas{ - ID: uuid.New(), - OrganizationID: targetOrganizationID, - LiveVersionID: &liveVersionID, - IsTemplate: isTemplate, - Name: pbCanvas.Metadata.Name, - Description: pbCanvas.Metadata.Description, - CreatedBy: &createdBy, - CreatedAt: &now, - UpdatedAt: &now, + ID: uuid.New(), + OrganizationID: targetOrganizationID, + LiveVersionID: &liveVersionID, + IsTemplate: isTemplate, + CanvasVersioningEnabled: canvasVersioningEnabled, + Name: pbCanvas.Metadata.Name, + Description: pbCanvas.Metadata.Description, + CreatedBy: &createdBy, + CreatedAt: &now, + UpdatedAt: &now, } err = database.Conn().Transaction(func(tx *gorm.DB) error { diff --git a/pkg/grpc/actions/canvases/create_canvas_change_request.go b/pkg/grpc/actions/canvases/create_canvas_change_request.go index 15e4f311dc..1ea7ae1d27 100644 --- a/pkg/grpc/actions/canvases/create_canvas_change_request.go +++ b/pkg/grpc/actions/canvases/create_canvas_change_request.go @@ -66,12 +66,12 @@ func CreateCanvasChangeRequestWithMetadata( return nil, status.Error(codes.FailedPrecondition, "templates are read-only") } - sandboxModeEnabled, modeErr := isCanvasSandboxModeEnabled(organizationID) + versioningEnabled, modeErr := isCanvasVersioningEnabledForCanvas(canvas) if modeErr != nil { - return nil, status.Errorf(codes.Internal, "failed to load organization sandbox mode: %v", modeErr) + return nil, status.Errorf(codes.Internal, "failed to load canvas versioning: %v", modeErr) } - if sandboxModeEnabled { - return nil, status.Error(codes.FailedPrecondition, "canvas versioning is disabled in sandbox mode") + if !versioningEnabled { + return nil, status.Error(codes.FailedPrecondition, "canvas versioning is disabled for this canvas") } userUUID := uuid.MustParse(userID) diff --git a/pkg/grpc/actions/canvases/create_canvas_test.go b/pkg/grpc/actions/canvases/create_canvas_test.go index ffe3ba00f1..fa53764f66 100644 --- a/pkg/grpc/actions/canvases/create_canvas_test.go +++ b/pkg/grpc/actions/canvases/create_canvas_test.go @@ -4,8 +4,11 @@ import ( "context" "testing" + "github.com/google/uuid" "github.com/stretchr/testify/require" "github.com/superplanehq/superplane/pkg/authentication" + "github.com/superplanehq/superplane/pkg/database" + "github.com/superplanehq/superplane/pkg/models" pb "github.com/superplanehq/superplane/pkg/protos/canvases" componentpb "github.com/superplanehq/superplane/pkg/protos/components" "github.com/superplanehq/superplane/test/support" @@ -34,3 +37,36 @@ func TestCreateCanvasDuplicateName(t *testing.T) { require.Error(t, err) require.Equal(t, codes.AlreadyExists, status.Code(err)) } + +func TestCreateCanvasInheritsOrganizationVersioningWhenEnabled(t *testing.T) { + r := support.Setup(t) + ctx := authentication.SetUserIdInMetadata(context.Background(), r.User.String()) + + nowEnabled := true + require.NoError(t, database.Conn().Model(&models.Organization{}).Where("id = ?", r.Organization.ID).Update("canvas_versioning_enabled", nowEnabled).Error) + + workflow := &pb.Canvas{ + Metadata: &pb.Canvas_Metadata{ + Name: "Versioning default canvas", + }, + Spec: &pb.Canvas_Spec{ + Nodes: []*componentpb.Node{}, + Edges: []*componentpb.Edge{}, + }, + } + + response, err := CreateCanvas(ctx, r.Registry, r.Organization.ID.String(), workflow) + require.NoError(t, err) + require.NotNil(t, response) + require.NotNil(t, response.Canvas) + require.NotNil(t, response.Canvas.Metadata) + // New canvases inherit organization versioning. + require.True(t, response.Canvas.Metadata.CanvasVersioningEnabled) + + require.NotEmpty(t, response.Canvas.Metadata.Id) + createdCanvasUUID, parseErr := uuid.Parse(response.Canvas.Metadata.Id) + require.NoError(t, parseErr) + createdCanvas, findErr := models.FindCanvas(r.Organization.ID, createdCanvasUUID) + require.NoError(t, findErr) + require.True(t, createdCanvas.CanvasVersioningEnabled) +} diff --git a/pkg/grpc/actions/canvases/create_canvas_version.go b/pkg/grpc/actions/canvases/create_canvas_version.go index 5037cde29f..89841fa48c 100644 --- a/pkg/grpc/actions/canvases/create_canvas_version.go +++ b/pkg/grpc/actions/canvases/create_canvas_version.go @@ -37,12 +37,12 @@ func CreateCanvasVersion(ctx context.Context, organizationID string, canvasID st return nil, status.Error(codes.FailedPrecondition, "templates are read-only") } - sandboxModeEnabled, err := isCanvasSandboxModeEnabled(organizationID) + versioningEnabled, err := isCanvasVersioningEnabledForCanvas(canvas) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to load organization sandbox mode: %v", err) + return nil, status.Errorf(codes.Internal, "failed to load canvas versioning: %v", err) } - if sandboxModeEnabled { - return nil, status.Error(codes.FailedPrecondition, "canvas versioning is disabled in sandbox mode") + if !versioningEnabled { + return nil, status.Error(codes.FailedPrecondition, "canvas versioning is disabled for this canvas") } userUUID := uuid.MustParse(userID) diff --git a/pkg/grpc/actions/canvases/publish_canvas_change_request.go b/pkg/grpc/actions/canvases/publish_canvas_change_request.go index ff58637596..593ecaa31d 100644 --- a/pkg/grpc/actions/canvases/publish_canvas_change_request.go +++ b/pkg/grpc/actions/canvases/publish_canvas_change_request.go @@ -53,12 +53,12 @@ func PublishCanvasChangeRequest( return nil, nil, status.Error(codes.FailedPrecondition, "templates are read-only") } - sandboxModeEnabled, modeErr := isCanvasSandboxModeEnabled(organizationID) + versioningEnabled, modeErr := isCanvasVersioningEnabledForCanvas(canvas) if modeErr != nil { - return nil, nil, status.Errorf(codes.Internal, "failed to load organization sandbox mode: %v", modeErr) + return nil, nil, status.Errorf(codes.Internal, "failed to load canvas versioning: %v", modeErr) } - if sandboxModeEnabled { - return nil, nil, status.Error(codes.FailedPrecondition, "canvas versioning is disabled in sandbox mode") + if !versioningEnabled { + return nil, nil, status.Error(codes.FailedPrecondition, "canvas versioning is disabled for this canvas") } var version *models.CanvasVersion diff --git a/pkg/grpc/actions/canvases/sandbox_mode.go b/pkg/grpc/actions/canvases/sandbox_mode.go deleted file mode 100644 index 9028b99d1c..0000000000 --- a/pkg/grpc/actions/canvases/sandbox_mode.go +++ /dev/null @@ -1,25 +0,0 @@ -package canvases - -import ( - "github.com/google/uuid" - "github.com/superplanehq/superplane/pkg/models" - "gorm.io/gorm" -) - -func isCanvasSandboxModeEnabled(organizationID string) (bool, error) { - orgID, err := uuid.Parse(organizationID) - if err != nil { - return false, err - } - - return models.IsCanvasSandboxModeEnabled(orgID) -} - -func isCanvasSandboxModeEnabledInTransaction(tx *gorm.DB, organizationID string) (bool, error) { - orgID, err := uuid.Parse(organizationID) - if err != nil { - return false, err - } - - return models.IsCanvasSandboxModeEnabledInTransaction(tx, orgID) -} diff --git a/pkg/grpc/actions/canvases/serialization.go b/pkg/grpc/actions/canvases/serialization.go index 3dd836efd5..f9f495d823 100644 --- a/pkg/grpc/actions/canvases/serialization.go +++ b/pkg/grpc/actions/canvases/serialization.go @@ -24,6 +24,11 @@ func SerializeCanvas(canvas *models.Canvas, includeStatus bool) (*pb.Canvas, err return nil, err } + canvasVersioningEnabled, err := isCanvasVersioningEnabledForCanvas(canvas) + if err != nil { + return nil, err + } + serializedNodes, err := serializeCanvasNodes(canvas.ID, liveVersion.Nodes) if err != nil { return nil, err @@ -42,14 +47,15 @@ func SerializeCanvas(canvas *models.Canvas, includeStatus bool) (*pb.Canvas, err if !includeStatus { return &pb.Canvas{ Metadata: &pb.Canvas_Metadata{ - Id: canvas.ID.String(), - OrganizationId: canvas.OrganizationID.String(), - Name: canvas.Name, - Description: canvas.Description, - CreatedAt: timestamppb.New(*canvas.CreatedAt), - UpdatedAt: timestamppb.New(*canvas.UpdatedAt), - CreatedBy: createdBy, - IsTemplate: canvas.IsTemplate, + Id: canvas.ID.String(), + OrganizationId: canvas.OrganizationID.String(), + Name: canvas.Name, + Description: canvas.Description, + CreatedAt: timestamppb.New(*canvas.CreatedAt), + UpdatedAt: timestamppb.New(*canvas.UpdatedAt), + CreatedBy: createdBy, + IsTemplate: canvas.IsTemplate, + CanvasVersioningEnabled: canvasVersioningEnabled, }, Spec: &pb.Canvas_Spec{ Nodes: serializedNodes, @@ -104,14 +110,15 @@ func SerializeCanvas(canvas *models.Canvas, includeStatus bool) (*pb.Canvas, err return &pb.Canvas{ Metadata: &pb.Canvas_Metadata{ - Id: canvas.ID.String(), - OrganizationId: canvas.OrganizationID.String(), - Name: canvas.Name, - Description: canvas.Description, - CreatedAt: timestamppb.New(*canvas.CreatedAt), - UpdatedAt: timestamppb.New(*canvas.UpdatedAt), - CreatedBy: createdBy, - IsTemplate: canvas.IsTemplate, + Id: canvas.ID.String(), + OrganizationId: canvas.OrganizationID.String(), + Name: canvas.Name, + Description: canvas.Description, + CreatedAt: timestamppb.New(*canvas.CreatedAt), + UpdatedAt: timestamppb.New(*canvas.UpdatedAt), + CreatedBy: createdBy, + IsTemplate: canvas.IsTemplate, + CanvasVersioningEnabled: canvasVersioningEnabled, }, Spec: &pb.Canvas_Spec{ Nodes: serializedNodes, diff --git a/pkg/grpc/actions/canvases/update_canvas.go b/pkg/grpc/actions/canvases/update_canvas.go new file mode 100644 index 0000000000..35d19cffdf --- /dev/null +++ b/pkg/grpc/actions/canvases/update_canvas.go @@ -0,0 +1,96 @@ +package canvases + +import ( + "context" + "errors" + "strings" + "time" + + "github.com/google/uuid" + log "github.com/sirupsen/logrus" + "github.com/superplanehq/superplane/pkg/database" + "github.com/superplanehq/superplane/pkg/grpc/actions/messages" + "github.com/superplanehq/superplane/pkg/models" + pb "github.com/superplanehq/superplane/pkg/protos/canvases" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "gorm.io/gorm" +) + +func UpdateCanvas( + _ context.Context, + organizationID string, + id string, + name *string, + description *string, + canvasVersioningEnabled *bool, +) (*pb.UpdateCanvasResponse, error) { + canvasID, err := uuid.Parse(id) + if err != nil { + return nil, status.Errorf(codes.InvalidArgument, "invalid canvas id: %v", err) + } + + canvas, err := models.FindCanvas(uuid.MustParse(organizationID), canvasID) + if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + if _, templateErr := models.FindCanvasTemplate(canvasID); templateErr == nil { + return nil, status.Error(codes.FailedPrecondition, "templates are read-only") + } + } + return nil, status.Errorf(codes.NotFound, "canvas not found: %v", err) + } + + if canvas.IsTemplate { + return nil, status.Error(codes.FailedPrecondition, "templates are read-only") + } + + changed := false + if name != nil { + nextName := strings.TrimSpace(*name) + if nextName == "" { + return nil, status.Error(codes.InvalidArgument, "canvas name is required") + } + + if canvas.Name != nextName { + canvas.Name = nextName + changed = true + } + } + + if description != nil && canvas.Description != *description { + canvas.Description = *description + changed = true + } + + if canvasVersioningEnabled != nil && canvas.CanvasVersioningEnabled != *canvasVersioningEnabled { + canvas.CanvasVersioningEnabled = *canvasVersioningEnabled + changed = true + } + + if changed { + now := time.Now() + canvas.UpdatedAt = &now + + if saveErr := database.Conn().Save(canvas).Error; saveErr != nil { + if strings.Contains(saveErr.Error(), ErrDuplicateCanvasName) { + return nil, status.Errorf(codes.AlreadyExists, "Canvas with the same name already exists") + } + log.Errorf("failed to update canvas %s metadata: %v", canvas.ID.String(), saveErr) + return nil, status.Error(codes.Internal, "failed to update canvas") + } + } + + if publishErr := messages.NewCanvasUpdatedMessage(canvas.ID.String()).Publish(true); publishErr != nil { + log.Errorf("failed to publish canvas updated RabbitMQ message: %v", publishErr) + } + + serializedCanvas, serializeErr := SerializeCanvas(canvas, false) + if serializeErr != nil { + log.Errorf("failed to serialize canvas %s after update: %v", canvas.ID.String(), serializeErr) + return nil, status.Error(codes.Internal, "failed to serialize canvas") + } + + return &pb.UpdateCanvasResponse{ + Canvas: serializedCanvas, + }, nil +} diff --git a/pkg/grpc/actions/canvases/update_canvas_test.go b/pkg/grpc/actions/canvases/update_canvas_test.go new file mode 100644 index 0000000000..5d78e73af4 --- /dev/null +++ b/pkg/grpc/actions/canvases/update_canvas_test.go @@ -0,0 +1,198 @@ +package canvases + +import ( + "context" + "testing" + + "github.com/google/uuid" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/superplanehq/superplane/pkg/database" + "github.com/superplanehq/superplane/pkg/models" + "github.com/superplanehq/superplane/test/support" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +func Test__UpdateCanvas(t *testing.T) { + r := support.Setup(t) + + t.Run("invalid canvas id -> error", func(t *testing.T) { + name := "name" + description := "description" + _, err := UpdateCanvas(context.Background(), r.Organization.ID.String(), "invalid-id", &name, &description, nil) + s, ok := status.FromError(err) + assert.True(t, ok) + assert.Equal(t, codes.InvalidArgument, s.Code()) + }) + + t.Run("canvas does not exist -> error", func(t *testing.T) { + _, err := UpdateCanvas( + context.Background(), + r.Organization.ID.String(), + uuid.New().String(), + stringPointer("updated-name"), + stringPointer("updated-description"), + nil, + ) + s, ok := status.FromError(err) + assert.True(t, ok) + assert.Equal(t, codes.NotFound, s.Code()) + }) + + t.Run("empty name -> error", func(t *testing.T) { + canvas, _ := support.CreateCanvas(t, r.Organization.ID, r.User, []models.CanvasNode{}, []models.Edge{}) + + _, err := UpdateCanvas( + context.Background(), + r.Organization.ID.String(), + canvas.ID.String(), + stringPointer(" "), + stringPointer("description"), + nil, + ) + s, ok := status.FromError(err) + assert.True(t, ok) + assert.Equal(t, codes.InvalidArgument, s.Code()) + }) + + t.Run("updates canvas metadata", func(t *testing.T) { + canvas, _ := support.CreateCanvas(t, r.Organization.ID, r.User, []models.CanvasNode{}, []models.Edge{}) + newName := support.RandomName("updated-canvas") + newDescription := "Canvas description updated" + + response, err := UpdateCanvas( + context.Background(), + r.Organization.ID.String(), + canvas.ID.String(), + &newName, + &newDescription, + nil, + ) + require.NoError(t, err) + require.NotNil(t, response) + require.NotNil(t, response.Canvas) + require.NotNil(t, response.Canvas.Metadata) + assert.Equal(t, canvas.ID.String(), response.Canvas.Metadata.Id) + assert.Equal(t, newName, response.Canvas.Metadata.Name) + assert.Equal(t, newDescription, response.Canvas.Metadata.Description) + + updatedCanvas, findErr := models.FindCanvas(r.Organization.ID, canvas.ID) + require.NoError(t, findErr) + assert.Equal(t, newName, updatedCanvas.Name) + assert.Equal(t, newDescription, updatedCanvas.Description) + }) + + t.Run("duplicate name -> error", func(t *testing.T) { + existingCanvas, _ := support.CreateCanvas(t, r.Organization.ID, r.User, []models.CanvasNode{}, []models.Edge{}) + targetCanvas, _ := support.CreateCanvas(t, r.Organization.ID, r.User, []models.CanvasNode{}, []models.Edge{}) + + _, err := UpdateCanvas( + context.Background(), + r.Organization.ID.String(), + targetCanvas.ID.String(), + &existingCanvas.Name, + &targetCanvas.Description, + nil, + ) + s, ok := status.FromError(err) + assert.True(t, ok) + assert.Equal(t, codes.AlreadyExists, s.Code()) + }) + + t.Run("updates canvas versioning setting", func(t *testing.T) { + canvas, _ := support.CreateCanvas(t, r.Organization.ID, r.User, []models.CanvasNode{}, []models.Edge{}) + require.NoError( + t, + database.Conn().Model(&models.Organization{}).Where("id = ?", r.Organization.ID).Update("canvas_versioning_enabled", true).Error, + ) + enabled := true + + response, err := UpdateCanvas( + context.Background(), + r.Organization.ID.String(), + canvas.ID.String(), + nil, + nil, + &enabled, + ) + require.NoError(t, err) + require.NotNil(t, response) + require.NotNil(t, response.Canvas) + require.NotNil(t, response.Canvas.Metadata) + assert.True(t, response.Canvas.Metadata.CanvasVersioningEnabled) + + updatedCanvas, findErr := models.FindCanvas(r.Organization.ID, canvas.ID) + require.NoError(t, findErr) + assert.True(t, updatedCanvas.CanvasVersioningEnabled) + }) + + t.Run("organization versioning enabled keeps effective canvas versioning enabled", func(t *testing.T) { + canvas, _ := support.CreateCanvas(t, r.Organization.ID, r.User, []models.CanvasNode{}, []models.Edge{}) + require.NoError( + t, + database.Conn().Model(&models.Organization{}).Where("id = ?", r.Organization.ID).Update("canvas_versioning_enabled", true).Error, + ) + + enabled := true + _, err := UpdateCanvas( + context.Background(), + r.Organization.ID.String(), + canvas.ID.String(), + nil, + nil, + &enabled, + ) + require.NoError(t, err) + + disabled := false + response, err := UpdateCanvas( + context.Background(), + r.Organization.ID.String(), + canvas.ID.String(), + nil, + nil, + &disabled, + ) + require.NoError(t, err) + require.NotNil(t, response) + require.NotNil(t, response.Canvas) + require.NotNil(t, response.Canvas.Metadata) + assert.True(t, response.Canvas.Metadata.CanvasVersioningEnabled) + + updatedCanvas, findErr := models.FindCanvas(r.Organization.ID, canvas.ID) + require.NoError(t, findErr) + assert.False(t, updatedCanvas.CanvasVersioningEnabled) + }) + + t.Run("organization versioning disabled allows effective canvas versioning to be enabled", func(t *testing.T) { + canvas, _ := support.CreateCanvas(t, r.Organization.ID, r.User, []models.CanvasNode{}, []models.Edge{}) + require.NoError( + t, + database.Conn().Model(&models.Organization{}).Where("id = ?", r.Organization.ID).Update("canvas_versioning_enabled", false).Error, + ) + + enabled := true + response, err := UpdateCanvas( + context.Background(), + r.Organization.ID.String(), + canvas.ID.String(), + nil, + nil, + &enabled, + ) + require.NoError(t, err) + require.NotNil(t, response) + require.NotNil(t, response.Canvas) + require.NotNil(t, response.Canvas.Metadata) + assert.True(t, response.Canvas.Metadata.CanvasVersioningEnabled) + + updatedCanvas, findErr := models.FindCanvas(r.Organization.ID, canvas.ID) + require.NoError(t, findErr) + assert.True(t, updatedCanvas.CanvasVersioningEnabled) + }) +} + +func stringPointer(value string) *string { + return &value +} diff --git a/pkg/grpc/actions/canvases/update_canvas_version.go b/pkg/grpc/actions/canvases/update_canvas_version.go index 61608558bb..a802c9ce89 100644 --- a/pkg/grpc/actions/canvases/update_canvas_version.go +++ b/pkg/grpc/actions/canvases/update_canvas_version.go @@ -62,18 +62,18 @@ func UpdateCanvasVersion( return nil, err } - sandboxModeEnabled, err := isCanvasSandboxModeEnabled(organizationID) + versioningEnabled, err := isCanvasVersioningEnabledForCanvas(canvas) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to load organization sandbox mode: %v", err) + return nil, status.Errorf(codes.Internal, "failed to load canvas versioning: %v", err) } requestedVersionID := strings.TrimSpace(versionID) if requestedVersionID == "" { - if !sandboxModeEnabled { - return nil, status.Error(codes.FailedPrecondition, "sandbox mode is disabled; version id is required") + if versioningEnabled { + return nil, status.Error(codes.FailedPrecondition, "canvas versioning is enabled for this canvas; version id is required") } - return updateLiveCanvasInSandbox( + return updateLiveCanvasWithoutVersioning( ctx, encryptor, registry, @@ -85,8 +85,8 @@ func UpdateCanvasVersion( ) } - if sandboxModeEnabled { - return nil, status.Error(codes.FailedPrecondition, "canvas versioning is disabled in sandbox mode") + if !versioningEnabled { + return nil, status.Error(codes.FailedPrecondition, "canvas versioning is disabled for this canvas") } versionUUID, err := uuid.Parse(requestedVersionID) @@ -151,7 +151,7 @@ func UpdateCanvasVersion( }, nil } -func updateLiveCanvasInSandbox( +func updateLiveCanvasWithoutVersioning( ctx context.Context, encryptor crypto.Encryptor, registry *registry.Registry, @@ -265,7 +265,7 @@ func updateLiveCanvasInSandbox( if status.Code(err) != codes.Unknown { return nil, err } - return nil, status.Errorf(codes.Internal, "failed to update live canvas in sandbox mode: %v", err) + return nil, status.Errorf(codes.Internal, "failed to update live canvas without versioning: %v", err) } if err := messages.NewCanvasUpdatedMessage(canvas.ID.String()).Publish(true); err != nil { diff --git a/pkg/grpc/actions/canvases/versioning.go b/pkg/grpc/actions/canvases/versioning.go new file mode 100644 index 0000000000..a8cf06b97c --- /dev/null +++ b/pkg/grpc/actions/canvases/versioning.go @@ -0,0 +1,32 @@ +package canvases + +import ( + "github.com/superplanehq/superplane/pkg/database" + "github.com/superplanehq/superplane/pkg/models" + "gorm.io/gorm" +) + +func isCanvasVersioningEnabledForCanvas(canvas *models.Canvas) (bool, error) { + return isCanvasVersioningEnabledForCanvasInTransaction(database.Conn(), canvas) +} + +func isCanvasVersioningEnabledForCanvasInTransaction(tx *gorm.DB, canvas *models.Canvas) (bool, error) { + if canvas == nil { + return false, nil + } + + // Template canvases are not user-editable, but keep the value stable if needed. + if canvas.IsTemplate { + return canvas.CanvasVersioningEnabled, nil + } + + organizationVersioningEnabled, err := models.IsCanvasVersioningEnabledInTransaction(tx, canvas.OrganizationID) + if err != nil { + return false, err + } + if organizationVersioningEnabled { + return true, nil + } + + return canvas.CanvasVersioningEnabled, nil +} diff --git a/pkg/grpc/actions/organizations/describe_organization.go b/pkg/grpc/actions/organizations/describe_organization.go index e8fc08d959..e059d58fc6 100644 --- a/pkg/grpc/actions/organizations/describe_organization.go +++ b/pkg/grpc/actions/organizations/describe_organization.go @@ -27,12 +27,12 @@ func DescribeOrganization(ctx context.Context, orgID string) (*pb.DescribeOrgani response := &pb.DescribeOrganizationResponse{ Organization: &pb.Organization{ Metadata: &pb.Organization_Metadata{ - Id: organization.ID.String(), - Name: organization.Name, - Description: organization.Description, - CreatedAt: timestamppb.New(*organization.CreatedAt), - UpdatedAt: timestamppb.New(*organization.UpdatedAt), - CanvasSandboxModeEnabled: &organization.CanvasSandboxModeEnabled, + Id: organization.ID.String(), + Name: organization.Name, + Description: organization.Description, + CreatedAt: timestamppb.New(*organization.CreatedAt), + UpdatedAt: timestamppb.New(*organization.UpdatedAt), + CanvasVersioningEnabled: &organization.CanvasVersioningEnabled, }, }, } diff --git a/pkg/grpc/actions/organizations/describe_organization_test.go b/pkg/grpc/actions/organizations/describe_organization_test.go index 4f13f98c0e..e38e368572 100644 --- a/pkg/grpc/actions/organizations/describe_organization_test.go +++ b/pkg/grpc/actions/organizations/describe_organization_test.go @@ -34,7 +34,7 @@ func Test__DescribeOrganization(t *testing.T) { assert.Equal(t, r.Organization.Description, response.Organization.Metadata.Description) assert.Equal(t, *r.Organization.CreatedAt, response.Organization.Metadata.CreatedAt.AsTime()) assert.Equal(t, *r.Organization.UpdatedAt, response.Organization.Metadata.UpdatedAt.AsTime()) - require.NotNil(t, response.Organization.Metadata.CanvasSandboxModeEnabled) - assert.Equal(t, r.Organization.CanvasSandboxModeEnabled, response.Organization.Metadata.GetCanvasSandboxModeEnabled()) + require.NotNil(t, response.Organization.Metadata.CanvasVersioningEnabled) + assert.Equal(t, r.Organization.CanvasVersioningEnabled, response.Organization.Metadata.GetCanvasVersioningEnabled()) }) } diff --git a/pkg/grpc/actions/organizations/update_organization.go b/pkg/grpc/actions/organizations/update_organization.go index d7fef97b29..6d264681dc 100644 --- a/pkg/grpc/actions/organizations/update_organization.go +++ b/pkg/grpc/actions/organizations/update_organization.go @@ -36,8 +36,8 @@ func UpdateOrganization(ctx context.Context, orgID string, pbOrganization *pb.Or organization.Description = pbOrganization.Metadata.Description } - if pbOrganization.Metadata.CanvasSandboxModeEnabled != nil { - organization.CanvasSandboxModeEnabled = *pbOrganization.Metadata.CanvasSandboxModeEnabled + if pbOrganization.Metadata.CanvasVersioningEnabled != nil { + organization.CanvasVersioningEnabled = *pbOrganization.Metadata.CanvasVersioningEnabled } now := time.Now() @@ -55,12 +55,12 @@ func UpdateOrganization(ctx context.Context, orgID string, pbOrganization *pb.Or response := &pb.UpdateOrganizationResponse{ Organization: &pb.Organization{ Metadata: &pb.Organization_Metadata{ - Id: organization.ID.String(), - Name: organization.Name, - Description: organization.Description, - CreatedAt: timestamppb.New(*organization.CreatedAt), - UpdatedAt: timestamppb.New(*organization.UpdatedAt), - CanvasSandboxModeEnabled: &organization.CanvasSandboxModeEnabled, + Id: organization.ID.String(), + Name: organization.Name, + Description: organization.Description, + CreatedAt: timestamppb.New(*organization.CreatedAt), + UpdatedAt: timestamppb.New(*organization.UpdatedAt), + CanvasVersioningEnabled: &organization.CanvasVersioningEnabled, }, }, } diff --git a/pkg/grpc/actions/organizations/update_organization_test.go b/pkg/grpc/actions/organizations/update_organization_test.go index b2dd56829d..53abf9264d 100644 --- a/pkg/grpc/actions/organizations/update_organization_test.go +++ b/pkg/grpc/actions/organizations/update_organization_test.go @@ -33,13 +33,13 @@ func Test__UpdateOrganization(t *testing.T) { }) t.Run("update organization by ID -> success", func(t *testing.T) { - canvasSandboxModeEnabled := false + canvasVersioningEnabled := true updatedOrg := &protos.Organization{ Metadata: &protos.Organization_Metadata{ - Name: "updated-org", - Description: "Updated description", - CanvasSandboxModeEnabled: &canvasSandboxModeEnabled, + Name: "updated-org", + Description: "Updated description", + CanvasVersioningEnabled: &canvasVersioningEnabled, }, } @@ -53,12 +53,12 @@ func Test__UpdateOrganization(t *testing.T) { assert.Equal(t, "Updated description", response.Organization.Metadata.Description) assert.Equal(t, *r.Organization.CreatedAt, response.Organization.Metadata.CreatedAt.AsTime()) assert.True(t, response.Organization.Metadata.UpdatedAt.AsTime().After(*r.Organization.UpdatedAt)) - require.NotNil(t, response.Organization.Metadata.CanvasSandboxModeEnabled) - assert.Equal(t, canvasSandboxModeEnabled, response.Organization.Metadata.GetCanvasSandboxModeEnabled()) + require.NotNil(t, response.Organization.Metadata.CanvasVersioningEnabled) + assert.Equal(t, canvasVersioningEnabled, response.Organization.Metadata.GetCanvasVersioningEnabled()) organization, err := models.FindOrganizationByID(r.Organization.ID.String()) require.NoError(t, err) - assert.Equal(t, canvasSandboxModeEnabled, organization.CanvasSandboxModeEnabled) + assert.Equal(t, canvasVersioningEnabled, organization.CanvasVersioningEnabled) }) t.Run("nil organization -> error", func(t *testing.T) { diff --git a/pkg/grpc/canvas_service.go b/pkg/grpc/canvas_service.go index 8d1863e9cf..cea0f3a7da 100644 --- a/pkg/grpc/canvas_service.go +++ b/pkg/grpc/canvas_service.go @@ -39,6 +39,18 @@ func (s *CanvasService) DescribeCanvas(ctx context.Context, req *pb.DescribeCanv return canvases.DescribeCanvas(ctx, s.registry, organizationID, req.Id) } +func (s *CanvasService) UpdateCanvas(ctx context.Context, req *pb.UpdateCanvasRequest) (*pb.UpdateCanvasResponse, error) { + organizationID := ctx.Value(authorization.OrganizationContextKey).(string) + return canvases.UpdateCanvas( + ctx, + organizationID, + req.Id, + req.Name, + req.Description, + req.CanvasVersioningEnabled, + ) +} + func (s *CanvasService) CreateCanvas(ctx context.Context, req *pb.CreateCanvasRequest) (*pb.CreateCanvasResponse, error) { if req.Canvas == nil { return nil, status.Error(codes.InvalidArgument, "canvas is required") diff --git a/pkg/models/canvas.go b/pkg/models/canvas.go index 6355057766..f5341bb8f3 100644 --- a/pkg/models/canvas.go +++ b/pkg/models/canvas.go @@ -11,16 +11,17 @@ import ( ) type Canvas struct { - ID uuid.UUID - OrganizationID uuid.UUID - LiveVersionID *uuid.UUID - IsTemplate bool - Name string - Description string - CreatedBy *uuid.UUID - CreatedAt *time.Time - UpdatedAt *time.Time - DeletedAt gorm.DeletedAt `gorm:"index"` + ID uuid.UUID + OrganizationID uuid.UUID + LiveVersionID *uuid.UUID + IsTemplate bool + CanvasVersioningEnabled bool + Name string + Description string + CreatedBy *uuid.UUID + CreatedAt *time.Time + UpdatedAt *time.Time + DeletedAt gorm.DeletedAt `gorm:"index"` } func (c *Canvas) TableName() string { diff --git a/pkg/models/organization.go b/pkg/models/organization.go index 586f97c07d..b28ecb1233 100644 --- a/pkg/models/organization.go +++ b/pkg/models/organization.go @@ -13,14 +13,14 @@ import ( ) type Organization struct { - ID uuid.UUID `gorm:"primary_key;default:uuid_generate_v4()"` - Name string `gorm:"uniqueIndex"` - Description string - AllowedProviders datatypes.JSONSlice[string] - CanvasSandboxModeEnabled bool - CreatedAt *time.Time - UpdatedAt *time.Time - DeletedAt gorm.DeletedAt `gorm:"index"` + ID uuid.UUID `gorm:"primary_key;default:uuid_generate_v4()"` + Name string `gorm:"uniqueIndex"` + Description string + AllowedProviders datatypes.JSONSlice[string] + CanvasVersioningEnabled bool + CreatedAt *time.Time + UpdatedAt *time.Time + DeletedAt gorm.DeletedAt `gorm:"index"` } func (o *Organization) IsProviderAllowed(provider string) bool { @@ -84,12 +84,12 @@ func CreateOrganization(name, description string) (*Organization, error) { func CreateOrganizationInTransaction(tx *gorm.DB, name, description string) (*Organization, error) { now := time.Now() organization := Organization{ - Name: name, - Description: description, - AllowedProviders: datatypes.JSONSlice[string]{ProviderGitHub}, - CanvasSandboxModeEnabled: true, - CreatedAt: &now, - UpdatedAt: &now, + Name: name, + Description: description, + AllowedProviders: datatypes.JSONSlice[string]{ProviderGitHub}, + CanvasVersioningEnabled: false, + CreatedAt: &now, + UpdatedAt: &now, } err := tx. @@ -146,14 +146,14 @@ func GetActiveOrganizationIDs() ([]string, error) { return orgIDs, nil } -func IsCanvasSandboxModeEnabled(organizationID uuid.UUID) (bool, error) { - return IsCanvasSandboxModeEnabledInTransaction(database.Conn(), organizationID) +func IsCanvasVersioningEnabled(organizationID uuid.UUID) (bool, error) { + return IsCanvasVersioningEnabledInTransaction(database.Conn(), organizationID) } -func IsCanvasSandboxModeEnabledInTransaction(tx *gorm.DB, organizationID uuid.UUID) (bool, error) { +func IsCanvasVersioningEnabledInTransaction(tx *gorm.DB, organizationID uuid.UUID) (bool, error) { var organization Organization err := tx. - Select("canvas_sandbox_mode_enabled"). + Select("canvas_versioning_enabled"). Where("id = ?", organizationID). First(&organization). Error @@ -161,5 +161,5 @@ func IsCanvasSandboxModeEnabledInTransaction(tx *gorm.DB, organizationID uuid.UU return false, err } - return organization.CanvasSandboxModeEnabled, nil + return organization.CanvasVersioningEnabled, nil } diff --git a/pkg/openapi_client/.openapi-generator/FILES b/pkg/openapi_client/.openapi-generator/FILES index 4c1de15441..5151a89ac2 100644 --- a/pkg/openapi_client/.openapi-generator/FILES +++ b/pkg/openapi_client/.openapi-generator/FILES @@ -89,6 +89,8 @@ docs/CanvasesListNodeQueueItemsResponse.md docs/CanvasesResolveExecutionErrorsBody.md docs/CanvasesSendAiMessageBody.md docs/CanvasesSendAiMessageResponse.md +docs/CanvasesUpdateCanvasBody.md +docs/CanvasesUpdateCanvasResponse.md docs/CanvasesUpdateCanvasVersionBody.md docs/CanvasesUpdateCanvasVersionResponse.md docs/CanvasesUpdateNodePauseBody.md @@ -309,6 +311,8 @@ model_canvases_list_node_queue_items_response.go model_canvases_resolve_execution_errors_body.go model_canvases_send_ai_message_body.go model_canvases_send_ai_message_response.go +model_canvases_update_canvas_body.go +model_canvases_update_canvas_response.go model_canvases_update_canvas_version_body.go model_canvases_update_canvas_version_response.go model_canvases_update_node_pause_body.go diff --git a/pkg/openapi_client/api_canvas.go b/pkg/openapi_client/api_canvas.go index 60ab0169ae..4e723536ea 100644 --- a/pkg/openapi_client/api_canvas.go +++ b/pkg/openapi_client/api_canvas.go @@ -833,3 +833,126 @@ func (a *CanvasAPIService) CanvasesSendAiMessageExecute(r ApiCanvasesSendAiMessa return localVarReturnValue, localVarHTTPResponse, nil } + +type ApiCanvasesUpdateCanvasRequest struct { + ctx context.Context + ApiService *CanvasAPIService + id string + body *CanvasesUpdateCanvasBody +} + +func (r ApiCanvasesUpdateCanvasRequest) Body(body CanvasesUpdateCanvasBody) ApiCanvasesUpdateCanvasRequest { + r.body = &body + return r +} + +func (r ApiCanvasesUpdateCanvasRequest) Execute() (*CanvasesUpdateCanvasResponse, *http.Response, error) { + return r.ApiService.CanvasesUpdateCanvasExecute(r) +} + +/* +CanvasesUpdateCanvas Update canvas + +Updates canvas metadata + + @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). + @param id + @return ApiCanvasesUpdateCanvasRequest +*/ +func (a *CanvasAPIService) CanvasesUpdateCanvas(ctx context.Context, id string) ApiCanvasesUpdateCanvasRequest { + return ApiCanvasesUpdateCanvasRequest{ + ApiService: a, + ctx: ctx, + id: id, + } +} + +// Execute executes the request +// +// @return CanvasesUpdateCanvasResponse +func (a *CanvasAPIService) CanvasesUpdateCanvasExecute(r ApiCanvasesUpdateCanvasRequest) (*CanvasesUpdateCanvasResponse, *http.Response, error) { + var ( + localVarHTTPMethod = http.MethodPut + localVarPostBody interface{} + formFiles []formFile + localVarReturnValue *CanvasesUpdateCanvasResponse + ) + + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "CanvasAPIService.CanvasesUpdateCanvas") + if err != nil { + return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()} + } + + localVarPath := localBasePath + "/api/v1/canvases/{id}" + localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1) + + localVarHeaderParams := make(map[string]string) + localVarQueryParams := url.Values{} + localVarFormParams := url.Values{} + if r.body == nil { + return localVarReturnValue, nil, reportError("body is required and must be specified") + } + + // to determine the Content-Type header + localVarHTTPContentTypes := []string{"application/json"} + + // set Content-Type header + localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) + if localVarHTTPContentType != "" { + localVarHeaderParams["Content-Type"] = localVarHTTPContentType + } + + // to determine the Accept header + localVarHTTPHeaderAccepts := []string{"application/json"} + + // set Accept header + localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts) + if localVarHTTPHeaderAccept != "" { + localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept + } + // body params + localVarPostBody = r.body + req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles) + if err != nil { + return localVarReturnValue, nil, err + } + + localVarHTTPResponse, err := a.client.callAPI(req) + if err != nil || localVarHTTPResponse == nil { + return localVarReturnValue, localVarHTTPResponse, err + } + + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) + localVarHTTPResponse.Body.Close() + localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody)) + if err != nil { + return localVarReturnValue, localVarHTTPResponse, err + } + + if localVarHTTPResponse.StatusCode >= 300 { + newErr := &GenericOpenAPIError{ + body: localVarBody, + error: localVarHTTPResponse.Status, + } + var v GooglerpcStatus + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.error = err.Error() + return localVarReturnValue, localVarHTTPResponse, newErr + } + newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v) + newErr.model = v + return localVarReturnValue, localVarHTTPResponse, newErr + } + + err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr := &GenericOpenAPIError{ + body: localVarBody, + error: err.Error(), + } + return localVarReturnValue, localVarHTTPResponse, newErr + } + + return localVarReturnValue, localVarHTTPResponse, nil +} diff --git a/pkg/openapi_client/api_canvas_version.go b/pkg/openapi_client/api_canvas_version.go index d45d884aed..2813650fd2 100644 --- a/pkg/openapi_client/api_canvas_version.go +++ b/pkg/openapi_client/api_canvas_version.go @@ -413,7 +413,7 @@ func (r ApiCanvasesUpdateCanvasVersionRequest) Execute() (*CanvasesUpdateCanvasV /* CanvasesUpdateCanvasVersion Update canvas version -Updates a user-owned canvas version; if version_id is omitted, updates the live canvas in sandbox mode +Updates a user-owned canvas version; if version_id is omitted, updates the live canvas when versioning is disabled @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). @param canvasId @@ -539,7 +539,7 @@ func (r ApiCanvasesUpdateCanvasVersion2Request) Execute() (*CanvasesUpdateCanvas /* CanvasesUpdateCanvasVersion2 Update canvas version -Updates a user-owned canvas version; if version_id is omitted, updates the live canvas in sandbox mode +Updates a user-owned canvas version; if version_id is omitted, updates the live canvas when versioning is disabled @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). @param canvasId diff --git a/pkg/openapi_client/model_canvases_canvas_metadata.go b/pkg/openapi_client/model_canvases_canvas_metadata.go index eeddd3852f..a4e841bbc8 100644 --- a/pkg/openapi_client/model_canvases_canvas_metadata.go +++ b/pkg/openapi_client/model_canvases_canvas_metadata.go @@ -21,14 +21,15 @@ var _ MappedNullable = &CanvasesCanvasMetadata{} // CanvasesCanvasMetadata struct for CanvasesCanvasMetadata type CanvasesCanvasMetadata struct { - Id *string `json:"id,omitempty"` - OrganizationId *string `json:"organizationId,omitempty"` - Name *string `json:"name,omitempty"` - Description *string `json:"description,omitempty"` - CreatedAt *time.Time `json:"createdAt,omitempty"` - UpdatedAt *time.Time `json:"updatedAt,omitempty"` - CreatedBy *SuperplaneCanvasesUserRef `json:"createdBy,omitempty"` - IsTemplate *bool `json:"isTemplate,omitempty"` + Id *string `json:"id,omitempty"` + OrganizationId *string `json:"organizationId,omitempty"` + Name *string `json:"name,omitempty"` + Description *string `json:"description,omitempty"` + CreatedAt *time.Time `json:"createdAt,omitempty"` + UpdatedAt *time.Time `json:"updatedAt,omitempty"` + CreatedBy *SuperplaneCanvasesUserRef `json:"createdBy,omitempty"` + IsTemplate *bool `json:"isTemplate,omitempty"` + CanvasVersioningEnabled *bool `json:"canvasVersioningEnabled,omitempty"` } // NewCanvasesCanvasMetadata instantiates a new CanvasesCanvasMetadata object @@ -304,6 +305,38 @@ func (o *CanvasesCanvasMetadata) SetIsTemplate(v bool) { o.IsTemplate = &v } +// GetCanvasVersioningEnabled returns the CanvasVersioningEnabled field value if set, zero value otherwise. +func (o *CanvasesCanvasMetadata) GetCanvasVersioningEnabled() bool { + if o == nil || IsNil(o.CanvasVersioningEnabled) { + var ret bool + return ret + } + return *o.CanvasVersioningEnabled +} + +// GetCanvasVersioningEnabledOk returns a tuple with the CanvasVersioningEnabled field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CanvasesCanvasMetadata) GetCanvasVersioningEnabledOk() (*bool, bool) { + if o == nil || IsNil(o.CanvasVersioningEnabled) { + return nil, false + } + return o.CanvasVersioningEnabled, true +} + +// HasCanvasVersioningEnabled returns a boolean if a field has been set. +func (o *CanvasesCanvasMetadata) HasCanvasVersioningEnabled() bool { + if o != nil && !IsNil(o.CanvasVersioningEnabled) { + return true + } + + return false +} + +// SetCanvasVersioningEnabled gets a reference to the given bool and assigns it to the CanvasVersioningEnabled field. +func (o *CanvasesCanvasMetadata) SetCanvasVersioningEnabled(v bool) { + o.CanvasVersioningEnabled = &v +} + func (o CanvasesCanvasMetadata) MarshalJSON() ([]byte, error) { toSerialize, err := o.ToMap() if err != nil { @@ -338,6 +371,9 @@ func (o CanvasesCanvasMetadata) ToMap() (map[string]interface{}, error) { if !IsNil(o.IsTemplate) { toSerialize["isTemplate"] = o.IsTemplate } + if !IsNil(o.CanvasVersioningEnabled) { + toSerialize["canvasVersioningEnabled"] = o.CanvasVersioningEnabled + } return toSerialize, nil } diff --git a/pkg/openapi_client/model_canvases_update_canvas_body.go b/pkg/openapi_client/model_canvases_update_canvas_body.go new file mode 100644 index 0000000000..e1ccc933e6 --- /dev/null +++ b/pkg/openapi_client/model_canvases_update_canvas_body.go @@ -0,0 +1,197 @@ +/* +Superplane Organizations API + +API for managing organizations in the Superplane service + +API version: 1.0 +Contact: support@superplane.com +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package openapi_client + +import ( + "encoding/json" +) + +// checks if the CanvasesUpdateCanvasBody type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &CanvasesUpdateCanvasBody{} + +// CanvasesUpdateCanvasBody struct for CanvasesUpdateCanvasBody +type CanvasesUpdateCanvasBody struct { + Name *string `json:"name,omitempty"` + Description *string `json:"description,omitempty"` + CanvasVersioningEnabled *bool `json:"canvasVersioningEnabled,omitempty"` +} + +// NewCanvasesUpdateCanvasBody instantiates a new CanvasesUpdateCanvasBody object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewCanvasesUpdateCanvasBody() *CanvasesUpdateCanvasBody { + this := CanvasesUpdateCanvasBody{} + return &this +} + +// NewCanvasesUpdateCanvasBodyWithDefaults instantiates a new CanvasesUpdateCanvasBody object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewCanvasesUpdateCanvasBodyWithDefaults() *CanvasesUpdateCanvasBody { + this := CanvasesUpdateCanvasBody{} + return &this +} + +// GetName returns the Name field value if set, zero value otherwise. +func (o *CanvasesUpdateCanvasBody) GetName() string { + if o == nil || IsNil(o.Name) { + var ret string + return ret + } + return *o.Name +} + +// GetNameOk returns a tuple with the Name field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CanvasesUpdateCanvasBody) GetNameOk() (*string, bool) { + if o == nil || IsNil(o.Name) { + return nil, false + } + return o.Name, true +} + +// HasName returns a boolean if a field has been set. +func (o *CanvasesUpdateCanvasBody) HasName() bool { + if o != nil && !IsNil(o.Name) { + return true + } + + return false +} + +// SetName gets a reference to the given string and assigns it to the Name field. +func (o *CanvasesUpdateCanvasBody) SetName(v string) { + o.Name = &v +} + +// GetDescription returns the Description field value if set, zero value otherwise. +func (o *CanvasesUpdateCanvasBody) GetDescription() string { + if o == nil || IsNil(o.Description) { + var ret string + return ret + } + return *o.Description +} + +// GetDescriptionOk returns a tuple with the Description field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CanvasesUpdateCanvasBody) GetDescriptionOk() (*string, bool) { + if o == nil || IsNil(o.Description) { + return nil, false + } + return o.Description, true +} + +// HasDescription returns a boolean if a field has been set. +func (o *CanvasesUpdateCanvasBody) HasDescription() bool { + if o != nil && !IsNil(o.Description) { + return true + } + + return false +} + +// SetDescription gets a reference to the given string and assigns it to the Description field. +func (o *CanvasesUpdateCanvasBody) SetDescription(v string) { + o.Description = &v +} + +// GetCanvasVersioningEnabled returns the CanvasVersioningEnabled field value if set, zero value otherwise. +func (o *CanvasesUpdateCanvasBody) GetCanvasVersioningEnabled() bool { + if o == nil || IsNil(o.CanvasVersioningEnabled) { + var ret bool + return ret + } + return *o.CanvasVersioningEnabled +} + +// GetCanvasVersioningEnabledOk returns a tuple with the CanvasVersioningEnabled field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CanvasesUpdateCanvasBody) GetCanvasVersioningEnabledOk() (*bool, bool) { + if o == nil || IsNil(o.CanvasVersioningEnabled) { + return nil, false + } + return o.CanvasVersioningEnabled, true +} + +// HasCanvasVersioningEnabled returns a boolean if a field has been set. +func (o *CanvasesUpdateCanvasBody) HasCanvasVersioningEnabled() bool { + if o != nil && !IsNil(o.CanvasVersioningEnabled) { + return true + } + + return false +} + +// SetCanvasVersioningEnabled gets a reference to the given bool and assigns it to the CanvasVersioningEnabled field. +func (o *CanvasesUpdateCanvasBody) SetCanvasVersioningEnabled(v bool) { + o.CanvasVersioningEnabled = &v +} + +func (o CanvasesUpdateCanvasBody) MarshalJSON() ([]byte, error) { + toSerialize, err := o.ToMap() + if err != nil { + return []byte{}, err + } + return json.Marshal(toSerialize) +} + +func (o CanvasesUpdateCanvasBody) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + if !IsNil(o.Name) { + toSerialize["name"] = o.Name + } + if !IsNil(o.Description) { + toSerialize["description"] = o.Description + } + if !IsNil(o.CanvasVersioningEnabled) { + toSerialize["canvasVersioningEnabled"] = o.CanvasVersioningEnabled + } + return toSerialize, nil +} + +type NullableCanvasesUpdateCanvasBody struct { + value *CanvasesUpdateCanvasBody + isSet bool +} + +func (v NullableCanvasesUpdateCanvasBody) Get() *CanvasesUpdateCanvasBody { + return v.value +} + +func (v *NullableCanvasesUpdateCanvasBody) Set(val *CanvasesUpdateCanvasBody) { + v.value = val + v.isSet = true +} + +func (v NullableCanvasesUpdateCanvasBody) IsSet() bool { + return v.isSet +} + +func (v *NullableCanvasesUpdateCanvasBody) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableCanvasesUpdateCanvasBody(val *CanvasesUpdateCanvasBody) *NullableCanvasesUpdateCanvasBody { + return &NullableCanvasesUpdateCanvasBody{value: val, isSet: true} +} + +func (v NullableCanvasesUpdateCanvasBody) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableCanvasesUpdateCanvasBody) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/pkg/openapi_client/model_canvases_update_canvas_response.go b/pkg/openapi_client/model_canvases_update_canvas_response.go new file mode 100644 index 0000000000..402582daa1 --- /dev/null +++ b/pkg/openapi_client/model_canvases_update_canvas_response.go @@ -0,0 +1,125 @@ +/* +Superplane Organizations API + +API for managing organizations in the Superplane service + +API version: 1.0 +Contact: support@superplane.com +*/ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package openapi_client + +import ( + "encoding/json" +) + +// checks if the CanvasesUpdateCanvasResponse type satisfies the MappedNullable interface at compile time +var _ MappedNullable = &CanvasesUpdateCanvasResponse{} + +// CanvasesUpdateCanvasResponse struct for CanvasesUpdateCanvasResponse +type CanvasesUpdateCanvasResponse struct { + Canvas *CanvasesCanvas `json:"canvas,omitempty"` +} + +// NewCanvasesUpdateCanvasResponse instantiates a new CanvasesUpdateCanvasResponse object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewCanvasesUpdateCanvasResponse() *CanvasesUpdateCanvasResponse { + this := CanvasesUpdateCanvasResponse{} + return &this +} + +// NewCanvasesUpdateCanvasResponseWithDefaults instantiates a new CanvasesUpdateCanvasResponse object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewCanvasesUpdateCanvasResponseWithDefaults() *CanvasesUpdateCanvasResponse { + this := CanvasesUpdateCanvasResponse{} + return &this +} + +// GetCanvas returns the Canvas field value if set, zero value otherwise. +func (o *CanvasesUpdateCanvasResponse) GetCanvas() CanvasesCanvas { + if o == nil || IsNil(o.Canvas) { + var ret CanvasesCanvas + return ret + } + return *o.Canvas +} + +// GetCanvasOk returns a tuple with the Canvas field value if set, nil otherwise +// and a boolean to check if the value has been set. +func (o *CanvasesUpdateCanvasResponse) GetCanvasOk() (*CanvasesCanvas, bool) { + if o == nil || IsNil(o.Canvas) { + return nil, false + } + return o.Canvas, true +} + +// HasCanvas returns a boolean if a field has been set. +func (o *CanvasesUpdateCanvasResponse) HasCanvas() bool { + if o != nil && !IsNil(o.Canvas) { + return true + } + + return false +} + +// SetCanvas gets a reference to the given CanvasesCanvas and assigns it to the Canvas field. +func (o *CanvasesUpdateCanvasResponse) SetCanvas(v CanvasesCanvas) { + o.Canvas = &v +} + +func (o CanvasesUpdateCanvasResponse) MarshalJSON() ([]byte, error) { + toSerialize, err := o.ToMap() + if err != nil { + return []byte{}, err + } + return json.Marshal(toSerialize) +} + +func (o CanvasesUpdateCanvasResponse) ToMap() (map[string]interface{}, error) { + toSerialize := map[string]interface{}{} + if !IsNil(o.Canvas) { + toSerialize["canvas"] = o.Canvas + } + return toSerialize, nil +} + +type NullableCanvasesUpdateCanvasResponse struct { + value *CanvasesUpdateCanvasResponse + isSet bool +} + +func (v NullableCanvasesUpdateCanvasResponse) Get() *CanvasesUpdateCanvasResponse { + return v.value +} + +func (v *NullableCanvasesUpdateCanvasResponse) Set(val *CanvasesUpdateCanvasResponse) { + v.value = val + v.isSet = true +} + +func (v NullableCanvasesUpdateCanvasResponse) IsSet() bool { + return v.isSet +} + +func (v *NullableCanvasesUpdateCanvasResponse) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableCanvasesUpdateCanvasResponse(val *CanvasesUpdateCanvasResponse) *NullableCanvasesUpdateCanvasResponse { + return &NullableCanvasesUpdateCanvasResponse{value: val, isSet: true} +} + +func (v NullableCanvasesUpdateCanvasResponse) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableCanvasesUpdateCanvasResponse) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/pkg/openapi_client/model_organizations_organization_metadata.go b/pkg/openapi_client/model_organizations_organization_metadata.go index b87a42bf13..078c481bc6 100644 --- a/pkg/openapi_client/model_organizations_organization_metadata.go +++ b/pkg/openapi_client/model_organizations_organization_metadata.go @@ -21,12 +21,12 @@ var _ MappedNullable = &OrganizationsOrganizationMetadata{} // OrganizationsOrganizationMetadata struct for OrganizationsOrganizationMetadata type OrganizationsOrganizationMetadata struct { - Id *string `json:"id,omitempty"` - Name *string `json:"name,omitempty"` - Description *string `json:"description,omitempty"` - CreatedAt *time.Time `json:"createdAt,omitempty"` - UpdatedAt *time.Time `json:"updatedAt,omitempty"` - CanvasSandboxModeEnabled *bool `json:"canvasSandboxModeEnabled,omitempty"` + Id *string `json:"id,omitempty"` + Name *string `json:"name,omitempty"` + Description *string `json:"description,omitempty"` + CreatedAt *time.Time `json:"createdAt,omitempty"` + UpdatedAt *time.Time `json:"updatedAt,omitempty"` + CanvasVersioningEnabled *bool `json:"canvasVersioningEnabled,omitempty"` } // NewOrganizationsOrganizationMetadata instantiates a new OrganizationsOrganizationMetadata object @@ -206,36 +206,36 @@ func (o *OrganizationsOrganizationMetadata) SetUpdatedAt(v time.Time) { o.UpdatedAt = &v } -// GetCanvasSandboxModeEnabled returns the CanvasSandboxModeEnabled field value if set, zero value otherwise. -func (o *OrganizationsOrganizationMetadata) GetCanvasSandboxModeEnabled() bool { - if o == nil || IsNil(o.CanvasSandboxModeEnabled) { +// GetCanvasVersioningEnabled returns the CanvasVersioningEnabled field value if set, zero value otherwise. +func (o *OrganizationsOrganizationMetadata) GetCanvasVersioningEnabled() bool { + if o == nil || IsNil(o.CanvasVersioningEnabled) { var ret bool return ret } - return *o.CanvasSandboxModeEnabled + return *o.CanvasVersioningEnabled } -// GetCanvasSandboxModeEnabledOk returns a tuple with the CanvasSandboxModeEnabled field value if set, nil otherwise +// GetCanvasVersioningEnabledOk returns a tuple with the CanvasVersioningEnabled field value if set, nil otherwise // and a boolean to check if the value has been set. -func (o *OrganizationsOrganizationMetadata) GetCanvasSandboxModeEnabledOk() (*bool, bool) { - if o == nil || IsNil(o.CanvasSandboxModeEnabled) { +func (o *OrganizationsOrganizationMetadata) GetCanvasVersioningEnabledOk() (*bool, bool) { + if o == nil || IsNil(o.CanvasVersioningEnabled) { return nil, false } - return o.CanvasSandboxModeEnabled, true + return o.CanvasVersioningEnabled, true } -// HasCanvasSandboxModeEnabled returns a boolean if a field has been set. -func (o *OrganizationsOrganizationMetadata) HasCanvasSandboxModeEnabled() bool { - if o != nil && !IsNil(o.CanvasSandboxModeEnabled) { +// HasCanvasVersioningEnabled returns a boolean if a field has been set. +func (o *OrganizationsOrganizationMetadata) HasCanvasVersioningEnabled() bool { + if o != nil && !IsNil(o.CanvasVersioningEnabled) { return true } return false } -// SetCanvasSandboxModeEnabled gets a reference to the given bool and assigns it to the CanvasSandboxModeEnabled field. -func (o *OrganizationsOrganizationMetadata) SetCanvasSandboxModeEnabled(v bool) { - o.CanvasSandboxModeEnabled = &v +// SetCanvasVersioningEnabled gets a reference to the given bool and assigns it to the CanvasVersioningEnabled field. +func (o *OrganizationsOrganizationMetadata) SetCanvasVersioningEnabled(v bool) { + o.CanvasVersioningEnabled = &v } func (o OrganizationsOrganizationMetadata) MarshalJSON() ([]byte, error) { @@ -263,8 +263,8 @@ func (o OrganizationsOrganizationMetadata) ToMap() (map[string]interface{}, erro if !IsNil(o.UpdatedAt) { toSerialize["updatedAt"] = o.UpdatedAt } - if !IsNil(o.CanvasSandboxModeEnabled) { - toSerialize["canvasSandboxModeEnabled"] = o.CanvasSandboxModeEnabled + if !IsNil(o.CanvasVersioningEnabled) { + toSerialize["canvasVersioningEnabled"] = o.CanvasVersioningEnabled } return toSerialize, nil } diff --git a/pkg/protos/canvases/canvases.pb.go b/pkg/protos/canvases/canvases.pb.go index 810aab44d2..a8b444e854 100644 --- a/pkg/protos/canvases/canvases.pb.go +++ b/pkg/protos/canvases/canvases.pb.go @@ -69,7 +69,7 @@ func (x CanvasAutoLayout_Algorithm) Number() protoreflect.EnumNumber { // Deprecated: Use CanvasAutoLayout_Algorithm.Descriptor instead. func (CanvasAutoLayout_Algorithm) EnumDescriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{6, 0} + return file_canvases_proto_rawDescGZIP(), []int{8, 0} } type CanvasAutoLayout_Scope int32 @@ -121,7 +121,7 @@ func (x CanvasAutoLayout_Scope) Number() protoreflect.EnumNumber { // Deprecated: Use CanvasAutoLayout_Scope.Descriptor instead. func (CanvasAutoLayout_Scope) EnumDescriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{6, 1} + return file_canvases_proto_rawDescGZIP(), []int{8, 1} } type CanvasChangeRequest_Status int32 @@ -170,7 +170,7 @@ func (x CanvasChangeRequest_Status) Number() protoreflect.EnumNumber { // Deprecated: Use CanvasChangeRequest_Status.Descriptor instead. func (CanvasChangeRequest_Status) EnumDescriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{27, 0} + return file_canvases_proto_rawDescGZIP(), []int{29, 0} } type CanvasNodeExecution_State int32 @@ -222,7 +222,7 @@ func (x CanvasNodeExecution_State) Number() protoreflect.EnumNumber { // Deprecated: Use CanvasNodeExecution_State.Descriptor instead. func (CanvasNodeExecution_State) EnumDescriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{42, 0} + return file_canvases_proto_rawDescGZIP(), []int{44, 0} } type CanvasNodeExecution_Result int32 @@ -274,7 +274,7 @@ func (x CanvasNodeExecution_Result) Number() protoreflect.EnumNumber { // Deprecated: Use CanvasNodeExecution_Result.Descriptor instead. func (CanvasNodeExecution_Result) EnumDescriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{42, 1} + return file_canvases_proto_rawDescGZIP(), []int{44, 1} } type CanvasNodeExecution_ResultReason int32 @@ -323,7 +323,7 @@ func (x CanvasNodeExecution_ResultReason) Number() protoreflect.EnumNumber { // Deprecated: Use CanvasNodeExecution_ResultReason.Descriptor instead. func (CanvasNodeExecution_ResultReason) EnumDescriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{42, 2} + return file_canvases_proto_rawDescGZIP(), []int{44, 2} } type ListCanvasesRequest struct { @@ -502,6 +502,118 @@ func (x *DescribeCanvasResponse) GetCanvas() *Canvas { return nil } +type UpdateCanvasRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name,proto3,oneof" json:"name,omitempty"` + Description *string `protobuf:"bytes,3,opt,name=description,proto3,oneof" json:"description,omitempty"` + CanvasVersioningEnabled *bool `protobuf:"varint,4,opt,name=canvas_versioning_enabled,json=canvasVersioningEnabled,proto3,oneof" json:"canvas_versioning_enabled,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateCanvasRequest) Reset() { + *x = UpdateCanvasRequest{} + mi := &file_canvases_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateCanvasRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateCanvasRequest) ProtoMessage() {} + +func (x *UpdateCanvasRequest) ProtoReflect() protoreflect.Message { + mi := &file_canvases_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateCanvasRequest.ProtoReflect.Descriptor instead. +func (*UpdateCanvasRequest) Descriptor() ([]byte, []int) { + return file_canvases_proto_rawDescGZIP(), []int{4} +} + +func (x *UpdateCanvasRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *UpdateCanvasRequest) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *UpdateCanvasRequest) GetDescription() string { + if x != nil && x.Description != nil { + return *x.Description + } + return "" +} + +func (x *UpdateCanvasRequest) GetCanvasVersioningEnabled() bool { + if x != nil && x.CanvasVersioningEnabled != nil { + return *x.CanvasVersioningEnabled + } + return false +} + +type UpdateCanvasResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Canvas *Canvas `protobuf:"bytes,1,opt,name=canvas,proto3" json:"canvas,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateCanvasResponse) Reset() { + *x = UpdateCanvasResponse{} + mi := &file_canvases_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateCanvasResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateCanvasResponse) ProtoMessage() {} + +func (x *UpdateCanvasResponse) ProtoReflect() protoreflect.Message { + mi := &file_canvases_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateCanvasResponse.ProtoReflect.Descriptor instead. +func (*UpdateCanvasResponse) Descriptor() ([]byte, []int) { + return file_canvases_proto_rawDescGZIP(), []int{5} +} + +func (x *UpdateCanvasResponse) GetCanvas() *Canvas { + if x != nil { + return x.Canvas + } + return nil +} + type CreateCanvasRequest struct { state protoimpl.MessageState `protogen:"open.v1"` Canvas *Canvas `protobuf:"bytes,1,opt,name=canvas,proto3" json:"canvas,omitempty"` @@ -511,7 +623,7 @@ type CreateCanvasRequest struct { func (x *CreateCanvasRequest) Reset() { *x = CreateCanvasRequest{} - mi := &file_canvases_proto_msgTypes[4] + mi := &file_canvases_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -523,7 +635,7 @@ func (x *CreateCanvasRequest) String() string { func (*CreateCanvasRequest) ProtoMessage() {} func (x *CreateCanvasRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[4] + mi := &file_canvases_proto_msgTypes[6] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -536,7 +648,7 @@ func (x *CreateCanvasRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateCanvasRequest.ProtoReflect.Descriptor instead. func (*CreateCanvasRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{4} + return file_canvases_proto_rawDescGZIP(), []int{6} } func (x *CreateCanvasRequest) GetCanvas() *Canvas { @@ -555,7 +667,7 @@ type CreateCanvasResponse struct { func (x *CreateCanvasResponse) Reset() { *x = CreateCanvasResponse{} - mi := &file_canvases_proto_msgTypes[5] + mi := &file_canvases_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -567,7 +679,7 @@ func (x *CreateCanvasResponse) String() string { func (*CreateCanvasResponse) ProtoMessage() {} func (x *CreateCanvasResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[5] + mi := &file_canvases_proto_msgTypes[7] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -580,7 +692,7 @@ func (x *CreateCanvasResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateCanvasResponse.ProtoReflect.Descriptor instead. func (*CreateCanvasResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{5} + return file_canvases_proto_rawDescGZIP(), []int{7} } func (x *CreateCanvasResponse) GetCanvas() *Canvas { @@ -601,7 +713,7 @@ type CanvasAutoLayout struct { func (x *CanvasAutoLayout) Reset() { *x = CanvasAutoLayout{} - mi := &file_canvases_proto_msgTypes[6] + mi := &file_canvases_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -613,7 +725,7 @@ func (x *CanvasAutoLayout) String() string { func (*CanvasAutoLayout) ProtoMessage() {} func (x *CanvasAutoLayout) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[6] + mi := &file_canvases_proto_msgTypes[8] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -626,7 +738,7 @@ func (x *CanvasAutoLayout) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasAutoLayout.ProtoReflect.Descriptor instead. func (*CanvasAutoLayout) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{6} + return file_canvases_proto_rawDescGZIP(), []int{8} } func (x *CanvasAutoLayout) GetAlgorithm() CanvasAutoLayout_Algorithm { @@ -659,7 +771,7 @@ type CreateCanvasVersionRequest struct { func (x *CreateCanvasVersionRequest) Reset() { *x = CreateCanvasVersionRequest{} - mi := &file_canvases_proto_msgTypes[7] + mi := &file_canvases_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -671,7 +783,7 @@ func (x *CreateCanvasVersionRequest) String() string { func (*CreateCanvasVersionRequest) ProtoMessage() {} func (x *CreateCanvasVersionRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[7] + mi := &file_canvases_proto_msgTypes[9] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -684,7 +796,7 @@ func (x *CreateCanvasVersionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateCanvasVersionRequest.ProtoReflect.Descriptor instead. func (*CreateCanvasVersionRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{7} + return file_canvases_proto_rawDescGZIP(), []int{9} } func (x *CreateCanvasVersionRequest) GetCanvasId() string { @@ -703,7 +815,7 @@ type CreateCanvasVersionResponse struct { func (x *CreateCanvasVersionResponse) Reset() { *x = CreateCanvasVersionResponse{} - mi := &file_canvases_proto_msgTypes[8] + mi := &file_canvases_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -715,7 +827,7 @@ func (x *CreateCanvasVersionResponse) String() string { func (*CreateCanvasVersionResponse) ProtoMessage() {} func (x *CreateCanvasVersionResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[8] + mi := &file_canvases_proto_msgTypes[10] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -728,7 +840,7 @@ func (x *CreateCanvasVersionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateCanvasVersionResponse.ProtoReflect.Descriptor instead. func (*CreateCanvasVersionResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{8} + return file_canvases_proto_rawDescGZIP(), []int{10} } func (x *CreateCanvasVersionResponse) GetVersion() *CanvasVersion { @@ -749,7 +861,7 @@ type ListCanvasVersionsRequest struct { func (x *ListCanvasVersionsRequest) Reset() { *x = ListCanvasVersionsRequest{} - mi := &file_canvases_proto_msgTypes[9] + mi := &file_canvases_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -761,7 +873,7 @@ func (x *ListCanvasVersionsRequest) String() string { func (*ListCanvasVersionsRequest) ProtoMessage() {} func (x *ListCanvasVersionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[9] + mi := &file_canvases_proto_msgTypes[11] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -774,7 +886,7 @@ func (x *ListCanvasVersionsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCanvasVersionsRequest.ProtoReflect.Descriptor instead. func (*ListCanvasVersionsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{9} + return file_canvases_proto_rawDescGZIP(), []int{11} } func (x *ListCanvasVersionsRequest) GetCanvasId() string { @@ -810,7 +922,7 @@ type ListCanvasVersionsResponse struct { func (x *ListCanvasVersionsResponse) Reset() { *x = ListCanvasVersionsResponse{} - mi := &file_canvases_proto_msgTypes[10] + mi := &file_canvases_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -822,7 +934,7 @@ func (x *ListCanvasVersionsResponse) String() string { func (*ListCanvasVersionsResponse) ProtoMessage() {} func (x *ListCanvasVersionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[10] + mi := &file_canvases_proto_msgTypes[12] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -835,7 +947,7 @@ func (x *ListCanvasVersionsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCanvasVersionsResponse.ProtoReflect.Descriptor instead. func (*ListCanvasVersionsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{10} + return file_canvases_proto_rawDescGZIP(), []int{12} } func (x *ListCanvasVersionsResponse) GetVersions() []*CanvasVersion { @@ -876,7 +988,7 @@ type DescribeCanvasVersionRequest struct { func (x *DescribeCanvasVersionRequest) Reset() { *x = DescribeCanvasVersionRequest{} - mi := &file_canvases_proto_msgTypes[11] + mi := &file_canvases_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -888,7 +1000,7 @@ func (x *DescribeCanvasVersionRequest) String() string { func (*DescribeCanvasVersionRequest) ProtoMessage() {} func (x *DescribeCanvasVersionRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[11] + mi := &file_canvases_proto_msgTypes[13] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -901,7 +1013,7 @@ func (x *DescribeCanvasVersionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DescribeCanvasVersionRequest.ProtoReflect.Descriptor instead. func (*DescribeCanvasVersionRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{11} + return file_canvases_proto_rawDescGZIP(), []int{13} } func (x *DescribeCanvasVersionRequest) GetCanvasId() string { @@ -927,7 +1039,7 @@ type DescribeCanvasVersionResponse struct { func (x *DescribeCanvasVersionResponse) Reset() { *x = DescribeCanvasVersionResponse{} - mi := &file_canvases_proto_msgTypes[12] + mi := &file_canvases_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -939,7 +1051,7 @@ func (x *DescribeCanvasVersionResponse) String() string { func (*DescribeCanvasVersionResponse) ProtoMessage() {} func (x *DescribeCanvasVersionResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[12] + mi := &file_canvases_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -952,7 +1064,7 @@ func (x *DescribeCanvasVersionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DescribeCanvasVersionResponse.ProtoReflect.Descriptor instead. func (*DescribeCanvasVersionResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{12} + return file_canvases_proto_rawDescGZIP(), []int{14} } func (x *DescribeCanvasVersionResponse) GetVersion() *CanvasVersion { @@ -974,7 +1086,7 @@ type UpdateCanvasVersionRequest struct { func (x *UpdateCanvasVersionRequest) Reset() { *x = UpdateCanvasVersionRequest{} - mi := &file_canvases_proto_msgTypes[13] + mi := &file_canvases_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -986,7 +1098,7 @@ func (x *UpdateCanvasVersionRequest) String() string { func (*UpdateCanvasVersionRequest) ProtoMessage() {} func (x *UpdateCanvasVersionRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[13] + mi := &file_canvases_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -999,7 +1111,7 @@ func (x *UpdateCanvasVersionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateCanvasVersionRequest.ProtoReflect.Descriptor instead. func (*UpdateCanvasVersionRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{13} + return file_canvases_proto_rawDescGZIP(), []int{15} } func (x *UpdateCanvasVersionRequest) GetCanvasId() string { @@ -1039,7 +1151,7 @@ type UpdateCanvasVersionResponse struct { func (x *UpdateCanvasVersionResponse) Reset() { *x = UpdateCanvasVersionResponse{} - mi := &file_canvases_proto_msgTypes[14] + mi := &file_canvases_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1051,7 +1163,7 @@ func (x *UpdateCanvasVersionResponse) String() string { func (*UpdateCanvasVersionResponse) ProtoMessage() {} func (x *UpdateCanvasVersionResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[14] + mi := &file_canvases_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1064,7 +1176,7 @@ func (x *UpdateCanvasVersionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateCanvasVersionResponse.ProtoReflect.Descriptor instead. func (*UpdateCanvasVersionResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{14} + return file_canvases_proto_rawDescGZIP(), []int{16} } func (x *UpdateCanvasVersionResponse) GetVersion() *CanvasVersion { @@ -1086,7 +1198,7 @@ type CreateCanvasChangeRequestRequest struct { func (x *CreateCanvasChangeRequestRequest) Reset() { *x = CreateCanvasChangeRequestRequest{} - mi := &file_canvases_proto_msgTypes[15] + mi := &file_canvases_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1098,7 +1210,7 @@ func (x *CreateCanvasChangeRequestRequest) String() string { func (*CreateCanvasChangeRequestRequest) ProtoMessage() {} func (x *CreateCanvasChangeRequestRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[15] + mi := &file_canvases_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1111,7 +1223,7 @@ func (x *CreateCanvasChangeRequestRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateCanvasChangeRequestRequest.ProtoReflect.Descriptor instead. func (*CreateCanvasChangeRequestRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{15} + return file_canvases_proto_rawDescGZIP(), []int{17} } func (x *CreateCanvasChangeRequestRequest) GetCanvasId() string { @@ -1151,7 +1263,7 @@ type CreateCanvasChangeRequestResponse struct { func (x *CreateCanvasChangeRequestResponse) Reset() { *x = CreateCanvasChangeRequestResponse{} - mi := &file_canvases_proto_msgTypes[16] + mi := &file_canvases_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1163,7 +1275,7 @@ func (x *CreateCanvasChangeRequestResponse) String() string { func (*CreateCanvasChangeRequestResponse) ProtoMessage() {} func (x *CreateCanvasChangeRequestResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[16] + mi := &file_canvases_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1176,7 +1288,7 @@ func (x *CreateCanvasChangeRequestResponse) ProtoReflect() protoreflect.Message // Deprecated: Use CreateCanvasChangeRequestResponse.ProtoReflect.Descriptor instead. func (*CreateCanvasChangeRequestResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{16} + return file_canvases_proto_rawDescGZIP(), []int{18} } func (x *CreateCanvasChangeRequestResponse) GetChangeRequest() *CanvasChangeRequest { @@ -1200,7 +1312,7 @@ type ListCanvasChangeRequestsRequest struct { func (x *ListCanvasChangeRequestsRequest) Reset() { *x = ListCanvasChangeRequestsRequest{} - mi := &file_canvases_proto_msgTypes[17] + mi := &file_canvases_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1212,7 +1324,7 @@ func (x *ListCanvasChangeRequestsRequest) String() string { func (*ListCanvasChangeRequestsRequest) ProtoMessage() {} func (x *ListCanvasChangeRequestsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[17] + mi := &file_canvases_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1225,7 +1337,7 @@ func (x *ListCanvasChangeRequestsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCanvasChangeRequestsRequest.ProtoReflect.Descriptor instead. func (*ListCanvasChangeRequestsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{17} + return file_canvases_proto_rawDescGZIP(), []int{19} } func (x *ListCanvasChangeRequestsRequest) GetCanvasId() string { @@ -1282,7 +1394,7 @@ type ListCanvasChangeRequestsResponse struct { func (x *ListCanvasChangeRequestsResponse) Reset() { *x = ListCanvasChangeRequestsResponse{} - mi := &file_canvases_proto_msgTypes[18] + mi := &file_canvases_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1294,7 +1406,7 @@ func (x *ListCanvasChangeRequestsResponse) String() string { func (*ListCanvasChangeRequestsResponse) ProtoMessage() {} func (x *ListCanvasChangeRequestsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[18] + mi := &file_canvases_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1307,7 +1419,7 @@ func (x *ListCanvasChangeRequestsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCanvasChangeRequestsResponse.ProtoReflect.Descriptor instead. func (*ListCanvasChangeRequestsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{18} + return file_canvases_proto_rawDescGZIP(), []int{20} } func (x *ListCanvasChangeRequestsResponse) GetChangeRequests() []*CanvasChangeRequest { @@ -1348,7 +1460,7 @@ type DescribeCanvasChangeRequestRequest struct { func (x *DescribeCanvasChangeRequestRequest) Reset() { *x = DescribeCanvasChangeRequestRequest{} - mi := &file_canvases_proto_msgTypes[19] + mi := &file_canvases_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1360,7 +1472,7 @@ func (x *DescribeCanvasChangeRequestRequest) String() string { func (*DescribeCanvasChangeRequestRequest) ProtoMessage() {} func (x *DescribeCanvasChangeRequestRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[19] + mi := &file_canvases_proto_msgTypes[21] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1373,7 +1485,7 @@ func (x *DescribeCanvasChangeRequestRequest) ProtoReflect() protoreflect.Message // Deprecated: Use DescribeCanvasChangeRequestRequest.ProtoReflect.Descriptor instead. func (*DescribeCanvasChangeRequestRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{19} + return file_canvases_proto_rawDescGZIP(), []int{21} } func (x *DescribeCanvasChangeRequestRequest) GetCanvasId() string { @@ -1399,7 +1511,7 @@ type DescribeCanvasChangeRequestResponse struct { func (x *DescribeCanvasChangeRequestResponse) Reset() { *x = DescribeCanvasChangeRequestResponse{} - mi := &file_canvases_proto_msgTypes[20] + mi := &file_canvases_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1411,7 +1523,7 @@ func (x *DescribeCanvasChangeRequestResponse) String() string { func (*DescribeCanvasChangeRequestResponse) ProtoMessage() {} func (x *DescribeCanvasChangeRequestResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[20] + mi := &file_canvases_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1424,7 +1536,7 @@ func (x *DescribeCanvasChangeRequestResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use DescribeCanvasChangeRequestResponse.ProtoReflect.Descriptor instead. func (*DescribeCanvasChangeRequestResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{20} + return file_canvases_proto_rawDescGZIP(), []int{22} } func (x *DescribeCanvasChangeRequestResponse) GetChangeRequest() *CanvasChangeRequest { @@ -1443,7 +1555,7 @@ type DeleteCanvasRequest struct { func (x *DeleteCanvasRequest) Reset() { *x = DeleteCanvasRequest{} - mi := &file_canvases_proto_msgTypes[21] + mi := &file_canvases_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1455,7 +1567,7 @@ func (x *DeleteCanvasRequest) String() string { func (*DeleteCanvasRequest) ProtoMessage() {} func (x *DeleteCanvasRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[21] + mi := &file_canvases_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1468,7 +1580,7 @@ func (x *DeleteCanvasRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteCanvasRequest.ProtoReflect.Descriptor instead. func (*DeleteCanvasRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{21} + return file_canvases_proto_rawDescGZIP(), []int{23} } func (x *DeleteCanvasRequest) GetId() string { @@ -1486,7 +1598,7 @@ type DeleteCanvasResponse struct { func (x *DeleteCanvasResponse) Reset() { *x = DeleteCanvasResponse{} - mi := &file_canvases_proto_msgTypes[22] + mi := &file_canvases_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1498,7 +1610,7 @@ func (x *DeleteCanvasResponse) String() string { func (*DeleteCanvasResponse) ProtoMessage() {} func (x *DeleteCanvasResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[22] + mi := &file_canvases_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1511,7 +1623,7 @@ func (x *DeleteCanvasResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteCanvasResponse.ProtoReflect.Descriptor instead. func (*DeleteCanvasResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{22} + return file_canvases_proto_rawDescGZIP(), []int{24} } type UserRef struct { @@ -1524,7 +1636,7 @@ type UserRef struct { func (x *UserRef) Reset() { *x = UserRef{} - mi := &file_canvases_proto_msgTypes[23] + mi := &file_canvases_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1536,7 +1648,7 @@ func (x *UserRef) String() string { func (*UserRef) ProtoMessage() {} func (x *UserRef) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[23] + mi := &file_canvases_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1549,7 +1661,7 @@ func (x *UserRef) ProtoReflect() protoreflect.Message { // Deprecated: Use UserRef.ProtoReflect.Descriptor instead. func (*UserRef) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{23} + return file_canvases_proto_rawDescGZIP(), []int{25} } func (x *UserRef) GetId() string { @@ -1577,7 +1689,7 @@ type Canvas struct { func (x *Canvas) Reset() { *x = Canvas{} - mi := &file_canvases_proto_msgTypes[24] + mi := &file_canvases_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1589,7 +1701,7 @@ func (x *Canvas) String() string { func (*Canvas) ProtoMessage() {} func (x *Canvas) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[24] + mi := &file_canvases_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1602,7 +1714,7 @@ func (x *Canvas) ProtoReflect() protoreflect.Message { // Deprecated: Use Canvas.ProtoReflect.Descriptor instead. func (*Canvas) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{24} + return file_canvases_proto_rawDescGZIP(), []int{26} } func (x *Canvas) GetMetadata() *Canvas_Metadata { @@ -1636,7 +1748,7 @@ type CanvasVersion struct { func (x *CanvasVersion) Reset() { *x = CanvasVersion{} - mi := &file_canvases_proto_msgTypes[25] + mi := &file_canvases_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1648,7 +1760,7 @@ func (x *CanvasVersion) String() string { func (*CanvasVersion) ProtoMessage() {} func (x *CanvasVersion) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[25] + mi := &file_canvases_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1661,7 +1773,7 @@ func (x *CanvasVersion) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasVersion.ProtoReflect.Descriptor instead. func (*CanvasVersion) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{25} + return file_canvases_proto_rawDescGZIP(), []int{27} } func (x *CanvasVersion) GetMetadata() *CanvasVersion_Metadata { @@ -1687,7 +1799,7 @@ type CanvasChangeRequestDiff struct { func (x *CanvasChangeRequestDiff) Reset() { *x = CanvasChangeRequestDiff{} - mi := &file_canvases_proto_msgTypes[26] + mi := &file_canvases_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1699,7 +1811,7 @@ func (x *CanvasChangeRequestDiff) String() string { func (*CanvasChangeRequestDiff) ProtoMessage() {} func (x *CanvasChangeRequestDiff) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[26] + mi := &file_canvases_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1712,7 +1824,7 @@ func (x *CanvasChangeRequestDiff) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasChangeRequestDiff.ProtoReflect.Descriptor instead. func (*CanvasChangeRequestDiff) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{26} + return file_canvases_proto_rawDescGZIP(), []int{28} } func (x *CanvasChangeRequestDiff) GetChangedNodeIds() []string { @@ -1733,7 +1845,7 @@ type CanvasChangeRequest struct { func (x *CanvasChangeRequest) Reset() { *x = CanvasChangeRequest{} - mi := &file_canvases_proto_msgTypes[27] + mi := &file_canvases_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1745,7 +1857,7 @@ func (x *CanvasChangeRequest) String() string { func (*CanvasChangeRequest) ProtoMessage() {} func (x *CanvasChangeRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[27] + mi := &file_canvases_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1758,7 +1870,7 @@ func (x *CanvasChangeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasChangeRequest.ProtoReflect.Descriptor instead. func (*CanvasChangeRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{27} + return file_canvases_proto_rawDescGZIP(), []int{29} } func (x *CanvasChangeRequest) GetMetadata() *CanvasChangeRequest_Metadata { @@ -1794,7 +1906,7 @@ type ListNodeEventsRequest struct { func (x *ListNodeEventsRequest) Reset() { *x = ListNodeEventsRequest{} - mi := &file_canvases_proto_msgTypes[28] + mi := &file_canvases_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1806,7 +1918,7 @@ func (x *ListNodeEventsRequest) String() string { func (*ListNodeEventsRequest) ProtoMessage() {} func (x *ListNodeEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[28] + mi := &file_canvases_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1819,7 +1931,7 @@ func (x *ListNodeEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListNodeEventsRequest.ProtoReflect.Descriptor instead. func (*ListNodeEventsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{28} + return file_canvases_proto_rawDescGZIP(), []int{30} } func (x *ListNodeEventsRequest) GetCanvasId() string { @@ -1862,7 +1974,7 @@ type ListNodeEventsResponse struct { func (x *ListNodeEventsResponse) Reset() { *x = ListNodeEventsResponse{} - mi := &file_canvases_proto_msgTypes[29] + mi := &file_canvases_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1874,7 +1986,7 @@ func (x *ListNodeEventsResponse) String() string { func (*ListNodeEventsResponse) ProtoMessage() {} func (x *ListNodeEventsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[29] + mi := &file_canvases_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1887,7 +1999,7 @@ func (x *ListNodeEventsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListNodeEventsResponse.ProtoReflect.Descriptor instead. func (*ListNodeEventsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{29} + return file_canvases_proto_rawDescGZIP(), []int{31} } func (x *ListNodeEventsResponse) GetEvents() []*CanvasEvent { @@ -1930,7 +2042,7 @@ type EmitNodeEventRequest struct { func (x *EmitNodeEventRequest) Reset() { *x = EmitNodeEventRequest{} - mi := &file_canvases_proto_msgTypes[30] + mi := &file_canvases_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1942,7 +2054,7 @@ func (x *EmitNodeEventRequest) String() string { func (*EmitNodeEventRequest) ProtoMessage() {} func (x *EmitNodeEventRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[30] + mi := &file_canvases_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1955,7 +2067,7 @@ func (x *EmitNodeEventRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EmitNodeEventRequest.ProtoReflect.Descriptor instead. func (*EmitNodeEventRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{30} + return file_canvases_proto_rawDescGZIP(), []int{32} } func (x *EmitNodeEventRequest) GetCanvasId() string { @@ -1995,7 +2107,7 @@ type EmitNodeEventResponse struct { func (x *EmitNodeEventResponse) Reset() { *x = EmitNodeEventResponse{} - mi := &file_canvases_proto_msgTypes[31] + mi := &file_canvases_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2007,7 +2119,7 @@ func (x *EmitNodeEventResponse) String() string { func (*EmitNodeEventResponse) ProtoMessage() {} func (x *EmitNodeEventResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[31] + mi := &file_canvases_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2020,7 +2132,7 @@ func (x *EmitNodeEventResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EmitNodeEventResponse.ProtoReflect.Descriptor instead. func (*EmitNodeEventResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{31} + return file_canvases_proto_rawDescGZIP(), []int{33} } func (x *EmitNodeEventResponse) GetEventId() string { @@ -2042,7 +2154,7 @@ type ListNodeQueueItemsRequest struct { func (x *ListNodeQueueItemsRequest) Reset() { *x = ListNodeQueueItemsRequest{} - mi := &file_canvases_proto_msgTypes[32] + mi := &file_canvases_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2054,7 +2166,7 @@ func (x *ListNodeQueueItemsRequest) String() string { func (*ListNodeQueueItemsRequest) ProtoMessage() {} func (x *ListNodeQueueItemsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[32] + mi := &file_canvases_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2067,7 +2179,7 @@ func (x *ListNodeQueueItemsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListNodeQueueItemsRequest.ProtoReflect.Descriptor instead. func (*ListNodeQueueItemsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{32} + return file_canvases_proto_rawDescGZIP(), []int{34} } func (x *ListNodeQueueItemsRequest) GetCanvasId() string { @@ -2110,7 +2222,7 @@ type ListNodeQueueItemsResponse struct { func (x *ListNodeQueueItemsResponse) Reset() { *x = ListNodeQueueItemsResponse{} - mi := &file_canvases_proto_msgTypes[33] + mi := &file_canvases_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2122,7 +2234,7 @@ func (x *ListNodeQueueItemsResponse) String() string { func (*ListNodeQueueItemsResponse) ProtoMessage() {} func (x *ListNodeQueueItemsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[33] + mi := &file_canvases_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2135,7 +2247,7 @@ func (x *ListNodeQueueItemsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListNodeQueueItemsResponse.ProtoReflect.Descriptor instead. func (*ListNodeQueueItemsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{33} + return file_canvases_proto_rawDescGZIP(), []int{35} } func (x *ListNodeQueueItemsResponse) GetItems() []*CanvasNodeQueueItem { @@ -2177,7 +2289,7 @@ type DeleteNodeQueueItemRequest struct { func (x *DeleteNodeQueueItemRequest) Reset() { *x = DeleteNodeQueueItemRequest{} - mi := &file_canvases_proto_msgTypes[34] + mi := &file_canvases_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2189,7 +2301,7 @@ func (x *DeleteNodeQueueItemRequest) String() string { func (*DeleteNodeQueueItemRequest) ProtoMessage() {} func (x *DeleteNodeQueueItemRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[34] + mi := &file_canvases_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2202,7 +2314,7 @@ func (x *DeleteNodeQueueItemRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteNodeQueueItemRequest.ProtoReflect.Descriptor instead. func (*DeleteNodeQueueItemRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{34} + return file_canvases_proto_rawDescGZIP(), []int{36} } func (x *DeleteNodeQueueItemRequest) GetCanvasId() string { @@ -2234,7 +2346,7 @@ type DeleteNodeQueueItemResponse struct { func (x *DeleteNodeQueueItemResponse) Reset() { *x = DeleteNodeQueueItemResponse{} - mi := &file_canvases_proto_msgTypes[35] + mi := &file_canvases_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2246,7 +2358,7 @@ func (x *DeleteNodeQueueItemResponse) String() string { func (*DeleteNodeQueueItemResponse) ProtoMessage() {} func (x *DeleteNodeQueueItemResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[35] + mi := &file_canvases_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2259,7 +2371,7 @@ func (x *DeleteNodeQueueItemResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteNodeQueueItemResponse.ProtoReflect.Descriptor instead. func (*DeleteNodeQueueItemResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{35} + return file_canvases_proto_rawDescGZIP(), []int{37} } type UpdateNodePauseRequest struct { @@ -2273,7 +2385,7 @@ type UpdateNodePauseRequest struct { func (x *UpdateNodePauseRequest) Reset() { *x = UpdateNodePauseRequest{} - mi := &file_canvases_proto_msgTypes[36] + mi := &file_canvases_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2285,7 +2397,7 @@ func (x *UpdateNodePauseRequest) String() string { func (*UpdateNodePauseRequest) ProtoMessage() {} func (x *UpdateNodePauseRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[36] + mi := &file_canvases_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2298,7 +2410,7 @@ func (x *UpdateNodePauseRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateNodePauseRequest.ProtoReflect.Descriptor instead. func (*UpdateNodePauseRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{36} + return file_canvases_proto_rawDescGZIP(), []int{38} } func (x *UpdateNodePauseRequest) GetCanvasId() string { @@ -2331,7 +2443,7 @@ type UpdateNodePauseResponse struct { func (x *UpdateNodePauseResponse) Reset() { *x = UpdateNodePauseResponse{} - mi := &file_canvases_proto_msgTypes[37] + mi := &file_canvases_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2343,7 +2455,7 @@ func (x *UpdateNodePauseResponse) String() string { func (*UpdateNodePauseResponse) ProtoMessage() {} func (x *UpdateNodePauseResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[37] + mi := &file_canvases_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2356,7 +2468,7 @@ func (x *UpdateNodePauseResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateNodePauseResponse.ProtoReflect.Descriptor instead. func (*UpdateNodePauseResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{37} + return file_canvases_proto_rawDescGZIP(), []int{39} } func (x *UpdateNodePauseResponse) GetNode() *components.Node { @@ -2380,7 +2492,7 @@ type ListNodeExecutionsRequest struct { func (x *ListNodeExecutionsRequest) Reset() { *x = ListNodeExecutionsRequest{} - mi := &file_canvases_proto_msgTypes[38] + mi := &file_canvases_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2392,7 +2504,7 @@ func (x *ListNodeExecutionsRequest) String() string { func (*ListNodeExecutionsRequest) ProtoMessage() {} func (x *ListNodeExecutionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[38] + mi := &file_canvases_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2405,7 +2517,7 @@ func (x *ListNodeExecutionsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListNodeExecutionsRequest.ProtoReflect.Descriptor instead. func (*ListNodeExecutionsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{38} + return file_canvases_proto_rawDescGZIP(), []int{40} } func (x *ListNodeExecutionsRequest) GetCanvasId() string { @@ -2462,7 +2574,7 @@ type ListNodeExecutionsResponse struct { func (x *ListNodeExecutionsResponse) Reset() { *x = ListNodeExecutionsResponse{} - mi := &file_canvases_proto_msgTypes[39] + mi := &file_canvases_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2474,7 +2586,7 @@ func (x *ListNodeExecutionsResponse) String() string { func (*ListNodeExecutionsResponse) ProtoMessage() {} func (x *ListNodeExecutionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[39] + mi := &file_canvases_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2487,7 +2599,7 @@ func (x *ListNodeExecutionsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListNodeExecutionsResponse.ProtoReflect.Descriptor instead. func (*ListNodeExecutionsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{39} + return file_canvases_proto_rawDescGZIP(), []int{41} } func (x *ListNodeExecutionsResponse) GetExecutions() []*CanvasNodeExecution { @@ -2528,7 +2640,7 @@ type ListChildExecutionsRequest struct { func (x *ListChildExecutionsRequest) Reset() { *x = ListChildExecutionsRequest{} - mi := &file_canvases_proto_msgTypes[40] + mi := &file_canvases_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2540,7 +2652,7 @@ func (x *ListChildExecutionsRequest) String() string { func (*ListChildExecutionsRequest) ProtoMessage() {} func (x *ListChildExecutionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[40] + mi := &file_canvases_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2553,7 +2665,7 @@ func (x *ListChildExecutionsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListChildExecutionsRequest.ProtoReflect.Descriptor instead. func (*ListChildExecutionsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{40} + return file_canvases_proto_rawDescGZIP(), []int{42} } func (x *ListChildExecutionsRequest) GetCanvasId() string { @@ -2579,7 +2691,7 @@ type ListChildExecutionsResponse struct { func (x *ListChildExecutionsResponse) Reset() { *x = ListChildExecutionsResponse{} - mi := &file_canvases_proto_msgTypes[41] + mi := &file_canvases_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2591,7 +2703,7 @@ func (x *ListChildExecutionsResponse) String() string { func (*ListChildExecutionsResponse) ProtoMessage() {} func (x *ListChildExecutionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[41] + mi := &file_canvases_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2604,7 +2716,7 @@ func (x *ListChildExecutionsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListChildExecutionsResponse.ProtoReflect.Descriptor instead. func (*ListChildExecutionsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{41} + return file_canvases_proto_rawDescGZIP(), []int{43} } func (x *ListChildExecutionsResponse) GetExecutions() []*CanvasNodeExecution { @@ -2640,7 +2752,7 @@ type CanvasNodeExecution struct { func (x *CanvasNodeExecution) Reset() { *x = CanvasNodeExecution{} - mi := &file_canvases_proto_msgTypes[42] + mi := &file_canvases_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2652,7 +2764,7 @@ func (x *CanvasNodeExecution) String() string { func (*CanvasNodeExecution) ProtoMessage() {} func (x *CanvasNodeExecution) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[42] + mi := &file_canvases_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2665,7 +2777,7 @@ func (x *CanvasNodeExecution) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasNodeExecution.ProtoReflect.Descriptor instead. func (*CanvasNodeExecution) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{42} + return file_canvases_proto_rawDescGZIP(), []int{44} } func (x *CanvasNodeExecution) GetId() string { @@ -2808,7 +2920,7 @@ type CanvasNodeQueueItem struct { func (x *CanvasNodeQueueItem) Reset() { *x = CanvasNodeQueueItem{} - mi := &file_canvases_proto_msgTypes[43] + mi := &file_canvases_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2820,7 +2932,7 @@ func (x *CanvasNodeQueueItem) String() string { func (*CanvasNodeQueueItem) ProtoMessage() {} func (x *CanvasNodeQueueItem) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[43] + mi := &file_canvases_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2833,7 +2945,7 @@ func (x *CanvasNodeQueueItem) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasNodeQueueItem.ProtoReflect.Descriptor instead. func (*CanvasNodeQueueItem) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{43} + return file_canvases_proto_rawDescGZIP(), []int{45} } func (x *CanvasNodeQueueItem) GetId() string { @@ -2890,7 +3002,7 @@ type InvokeNodeExecutionActionRequest struct { func (x *InvokeNodeExecutionActionRequest) Reset() { *x = InvokeNodeExecutionActionRequest{} - mi := &file_canvases_proto_msgTypes[44] + mi := &file_canvases_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2902,7 +3014,7 @@ func (x *InvokeNodeExecutionActionRequest) String() string { func (*InvokeNodeExecutionActionRequest) ProtoMessage() {} func (x *InvokeNodeExecutionActionRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[44] + mi := &file_canvases_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2915,7 +3027,7 @@ func (x *InvokeNodeExecutionActionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use InvokeNodeExecutionActionRequest.ProtoReflect.Descriptor instead. func (*InvokeNodeExecutionActionRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{44} + return file_canvases_proto_rawDescGZIP(), []int{46} } func (x *InvokeNodeExecutionActionRequest) GetCanvasId() string { @@ -2954,7 +3066,7 @@ type InvokeNodeExecutionActionResponse struct { func (x *InvokeNodeExecutionActionResponse) Reset() { *x = InvokeNodeExecutionActionResponse{} - mi := &file_canvases_proto_msgTypes[45] + mi := &file_canvases_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2966,7 +3078,7 @@ func (x *InvokeNodeExecutionActionResponse) String() string { func (*InvokeNodeExecutionActionResponse) ProtoMessage() {} func (x *InvokeNodeExecutionActionResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[45] + mi := &file_canvases_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2979,7 +3091,7 @@ func (x *InvokeNodeExecutionActionResponse) ProtoReflect() protoreflect.Message // Deprecated: Use InvokeNodeExecutionActionResponse.ProtoReflect.Descriptor instead. func (*InvokeNodeExecutionActionResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{45} + return file_canvases_proto_rawDescGZIP(), []int{47} } type InvokeNodeTriggerActionRequest struct { @@ -2994,7 +3106,7 @@ type InvokeNodeTriggerActionRequest struct { func (x *InvokeNodeTriggerActionRequest) Reset() { *x = InvokeNodeTriggerActionRequest{} - mi := &file_canvases_proto_msgTypes[46] + mi := &file_canvases_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3006,7 +3118,7 @@ func (x *InvokeNodeTriggerActionRequest) String() string { func (*InvokeNodeTriggerActionRequest) ProtoMessage() {} func (x *InvokeNodeTriggerActionRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[46] + mi := &file_canvases_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3019,7 +3131,7 @@ func (x *InvokeNodeTriggerActionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use InvokeNodeTriggerActionRequest.ProtoReflect.Descriptor instead. func (*InvokeNodeTriggerActionRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{46} + return file_canvases_proto_rawDescGZIP(), []int{48} } func (x *InvokeNodeTriggerActionRequest) GetCanvasId() string { @@ -3059,7 +3171,7 @@ type InvokeNodeTriggerActionResponse struct { func (x *InvokeNodeTriggerActionResponse) Reset() { *x = InvokeNodeTriggerActionResponse{} - mi := &file_canvases_proto_msgTypes[47] + mi := &file_canvases_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3071,7 +3183,7 @@ func (x *InvokeNodeTriggerActionResponse) String() string { func (*InvokeNodeTriggerActionResponse) ProtoMessage() {} func (x *InvokeNodeTriggerActionResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[47] + mi := &file_canvases_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3084,7 +3196,7 @@ func (x *InvokeNodeTriggerActionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use InvokeNodeTriggerActionResponse.ProtoReflect.Descriptor instead. func (*InvokeNodeTriggerActionResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{47} + return file_canvases_proto_rawDescGZIP(), []int{49} } func (x *InvokeNodeTriggerActionResponse) GetResult() *_struct.Struct { @@ -3105,7 +3217,7 @@ type ListCanvasEventsRequest struct { func (x *ListCanvasEventsRequest) Reset() { *x = ListCanvasEventsRequest{} - mi := &file_canvases_proto_msgTypes[48] + mi := &file_canvases_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3117,7 +3229,7 @@ func (x *ListCanvasEventsRequest) String() string { func (*ListCanvasEventsRequest) ProtoMessage() {} func (x *ListCanvasEventsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[48] + mi := &file_canvases_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3130,7 +3242,7 @@ func (x *ListCanvasEventsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCanvasEventsRequest.ProtoReflect.Descriptor instead. func (*ListCanvasEventsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{48} + return file_canvases_proto_rawDescGZIP(), []int{50} } func (x *ListCanvasEventsRequest) GetCanvasId() string { @@ -3166,7 +3278,7 @@ type ListCanvasEventsResponse struct { func (x *ListCanvasEventsResponse) Reset() { *x = ListCanvasEventsResponse{} - mi := &file_canvases_proto_msgTypes[49] + mi := &file_canvases_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3178,7 +3290,7 @@ func (x *ListCanvasEventsResponse) String() string { func (*ListCanvasEventsResponse) ProtoMessage() {} func (x *ListCanvasEventsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[49] + mi := &file_canvases_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3191,7 +3303,7 @@ func (x *ListCanvasEventsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCanvasEventsResponse.ProtoReflect.Descriptor instead. func (*ListCanvasEventsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{49} + return file_canvases_proto_rawDescGZIP(), []int{51} } func (x *ListCanvasEventsResponse) GetEvents() []*CanvasEventWithExecutions { @@ -3233,7 +3345,7 @@ type CanvasMemory struct { func (x *CanvasMemory) Reset() { *x = CanvasMemory{} - mi := &file_canvases_proto_msgTypes[50] + mi := &file_canvases_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3245,7 +3357,7 @@ func (x *CanvasMemory) String() string { func (*CanvasMemory) ProtoMessage() {} func (x *CanvasMemory) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[50] + mi := &file_canvases_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3258,7 +3370,7 @@ func (x *CanvasMemory) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasMemory.ProtoReflect.Descriptor instead. func (*CanvasMemory) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{50} + return file_canvases_proto_rawDescGZIP(), []int{52} } func (x *CanvasMemory) GetId() string { @@ -3291,7 +3403,7 @@ type ListCanvasMemoriesRequest struct { func (x *ListCanvasMemoriesRequest) Reset() { *x = ListCanvasMemoriesRequest{} - mi := &file_canvases_proto_msgTypes[51] + mi := &file_canvases_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3303,7 +3415,7 @@ func (x *ListCanvasMemoriesRequest) String() string { func (*ListCanvasMemoriesRequest) ProtoMessage() {} func (x *ListCanvasMemoriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[51] + mi := &file_canvases_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3316,7 +3428,7 @@ func (x *ListCanvasMemoriesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCanvasMemoriesRequest.ProtoReflect.Descriptor instead. func (*ListCanvasMemoriesRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{51} + return file_canvases_proto_rawDescGZIP(), []int{53} } func (x *ListCanvasMemoriesRequest) GetCanvasId() string { @@ -3335,7 +3447,7 @@ type ListCanvasMemoriesResponse struct { func (x *ListCanvasMemoriesResponse) Reset() { *x = ListCanvasMemoriesResponse{} - mi := &file_canvases_proto_msgTypes[52] + mi := &file_canvases_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3347,7 +3459,7 @@ func (x *ListCanvasMemoriesResponse) String() string { func (*ListCanvasMemoriesResponse) ProtoMessage() {} func (x *ListCanvasMemoriesResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[52] + mi := &file_canvases_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3360,7 +3472,7 @@ func (x *ListCanvasMemoriesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCanvasMemoriesResponse.ProtoReflect.Descriptor instead. func (*ListCanvasMemoriesResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{52} + return file_canvases_proto_rawDescGZIP(), []int{54} } func (x *ListCanvasMemoriesResponse) GetItems() []*CanvasMemory { @@ -3380,7 +3492,7 @@ type DeleteCanvasMemoryRequest struct { func (x *DeleteCanvasMemoryRequest) Reset() { *x = DeleteCanvasMemoryRequest{} - mi := &file_canvases_proto_msgTypes[53] + mi := &file_canvases_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3392,7 +3504,7 @@ func (x *DeleteCanvasMemoryRequest) String() string { func (*DeleteCanvasMemoryRequest) ProtoMessage() {} func (x *DeleteCanvasMemoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[53] + mi := &file_canvases_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3405,7 +3517,7 @@ func (x *DeleteCanvasMemoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteCanvasMemoryRequest.ProtoReflect.Descriptor instead. func (*DeleteCanvasMemoryRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{53} + return file_canvases_proto_rawDescGZIP(), []int{55} } func (x *DeleteCanvasMemoryRequest) GetCanvasId() string { @@ -3430,7 +3542,7 @@ type DeleteCanvasMemoryResponse struct { func (x *DeleteCanvasMemoryResponse) Reset() { *x = DeleteCanvasMemoryResponse{} - mi := &file_canvases_proto_msgTypes[54] + mi := &file_canvases_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3442,7 +3554,7 @@ func (x *DeleteCanvasMemoryResponse) String() string { func (*DeleteCanvasMemoryResponse) ProtoMessage() {} func (x *DeleteCanvasMemoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[54] + mi := &file_canvases_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3455,7 +3567,7 @@ func (x *DeleteCanvasMemoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteCanvasMemoryResponse.ProtoReflect.Descriptor instead. func (*DeleteCanvasMemoryResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{54} + return file_canvases_proto_rawDescGZIP(), []int{56} } type CanvasEvent struct { @@ -3473,7 +3585,7 @@ type CanvasEvent struct { func (x *CanvasEvent) Reset() { *x = CanvasEvent{} - mi := &file_canvases_proto_msgTypes[55] + mi := &file_canvases_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3485,7 +3597,7 @@ func (x *CanvasEvent) String() string { func (*CanvasEvent) ProtoMessage() {} func (x *CanvasEvent) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[55] + mi := &file_canvases_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3498,7 +3610,7 @@ func (x *CanvasEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasEvent.ProtoReflect.Descriptor instead. func (*CanvasEvent) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{55} + return file_canvases_proto_rawDescGZIP(), []int{57} } func (x *CanvasEvent) GetId() string { @@ -3566,7 +3678,7 @@ type CanvasEventWithExecutions struct { func (x *CanvasEventWithExecutions) Reset() { *x = CanvasEventWithExecutions{} - mi := &file_canvases_proto_msgTypes[56] + mi := &file_canvases_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3578,7 +3690,7 @@ func (x *CanvasEventWithExecutions) String() string { func (*CanvasEventWithExecutions) ProtoMessage() {} func (x *CanvasEventWithExecutions) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[56] + mi := &file_canvases_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3591,7 +3703,7 @@ func (x *CanvasEventWithExecutions) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasEventWithExecutions.ProtoReflect.Descriptor instead. func (*CanvasEventWithExecutions) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{56} + return file_canvases_proto_rawDescGZIP(), []int{58} } func (x *CanvasEventWithExecutions) GetId() string { @@ -3660,7 +3772,7 @@ type ListEventExecutionsRequest struct { func (x *ListEventExecutionsRequest) Reset() { *x = ListEventExecutionsRequest{} - mi := &file_canvases_proto_msgTypes[57] + mi := &file_canvases_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3672,7 +3784,7 @@ func (x *ListEventExecutionsRequest) String() string { func (*ListEventExecutionsRequest) ProtoMessage() {} func (x *ListEventExecutionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[57] + mi := &file_canvases_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3685,7 +3797,7 @@ func (x *ListEventExecutionsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListEventExecutionsRequest.ProtoReflect.Descriptor instead. func (*ListEventExecutionsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{57} + return file_canvases_proto_rawDescGZIP(), []int{59} } func (x *ListEventExecutionsRequest) GetCanvasId() string { @@ -3711,7 +3823,7 @@ type ListEventExecutionsResponse struct { func (x *ListEventExecutionsResponse) Reset() { *x = ListEventExecutionsResponse{} - mi := &file_canvases_proto_msgTypes[58] + mi := &file_canvases_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3723,7 +3835,7 @@ func (x *ListEventExecutionsResponse) String() string { func (*ListEventExecutionsResponse) ProtoMessage() {} func (x *ListEventExecutionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[58] + mi := &file_canvases_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3736,7 +3848,7 @@ func (x *ListEventExecutionsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListEventExecutionsResponse.ProtoReflect.Descriptor instead. func (*ListEventExecutionsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{58} + return file_canvases_proto_rawDescGZIP(), []int{60} } func (x *ListEventExecutionsResponse) GetExecutions() []*CanvasNodeExecution { @@ -3756,7 +3868,7 @@ type CancelExecutionRequest struct { func (x *CancelExecutionRequest) Reset() { *x = CancelExecutionRequest{} - mi := &file_canvases_proto_msgTypes[59] + mi := &file_canvases_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3768,7 +3880,7 @@ func (x *CancelExecutionRequest) String() string { func (*CancelExecutionRequest) ProtoMessage() {} func (x *CancelExecutionRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[59] + mi := &file_canvases_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3781,7 +3893,7 @@ func (x *CancelExecutionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CancelExecutionRequest.ProtoReflect.Descriptor instead. func (*CancelExecutionRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{59} + return file_canvases_proto_rawDescGZIP(), []int{61} } func (x *CancelExecutionRequest) GetCanvasId() string { @@ -3806,7 +3918,7 @@ type CancelExecutionResponse struct { func (x *CancelExecutionResponse) Reset() { *x = CancelExecutionResponse{} - mi := &file_canvases_proto_msgTypes[60] + mi := &file_canvases_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3818,7 +3930,7 @@ func (x *CancelExecutionResponse) String() string { func (*CancelExecutionResponse) ProtoMessage() {} func (x *CancelExecutionResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[60] + mi := &file_canvases_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3831,7 +3943,7 @@ func (x *CancelExecutionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CancelExecutionResponse.ProtoReflect.Descriptor instead. func (*CancelExecutionResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{60} + return file_canvases_proto_rawDescGZIP(), []int{62} } type ResolveExecutionErrorsRequest struct { @@ -3844,7 +3956,7 @@ type ResolveExecutionErrorsRequest struct { func (x *ResolveExecutionErrorsRequest) Reset() { *x = ResolveExecutionErrorsRequest{} - mi := &file_canvases_proto_msgTypes[61] + mi := &file_canvases_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3856,7 +3968,7 @@ func (x *ResolveExecutionErrorsRequest) String() string { func (*ResolveExecutionErrorsRequest) ProtoMessage() {} func (x *ResolveExecutionErrorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[61] + mi := &file_canvases_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3869,7 +3981,7 @@ func (x *ResolveExecutionErrorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveExecutionErrorsRequest.ProtoReflect.Descriptor instead. func (*ResolveExecutionErrorsRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{61} + return file_canvases_proto_rawDescGZIP(), []int{63} } func (x *ResolveExecutionErrorsRequest) GetCanvasId() string { @@ -3894,7 +4006,7 @@ type ResolveExecutionErrorsResponse struct { func (x *ResolveExecutionErrorsResponse) Reset() { *x = ResolveExecutionErrorsResponse{} - mi := &file_canvases_proto_msgTypes[62] + mi := &file_canvases_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3906,7 +4018,7 @@ func (x *ResolveExecutionErrorsResponse) String() string { func (*ResolveExecutionErrorsResponse) ProtoMessage() {} func (x *ResolveExecutionErrorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[62] + mi := &file_canvases_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3919,7 +4031,7 @@ func (x *ResolveExecutionErrorsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveExecutionErrorsResponse.ProtoReflect.Descriptor instead. func (*ResolveExecutionErrorsResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{62} + return file_canvases_proto_rawDescGZIP(), []int{64} } type CanvasAiNodeContext struct { @@ -3934,7 +4046,7 @@ type CanvasAiNodeContext struct { func (x *CanvasAiNodeContext) Reset() { *x = CanvasAiNodeContext{} - mi := &file_canvases_proto_msgTypes[63] + mi := &file_canvases_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3946,7 +4058,7 @@ func (x *CanvasAiNodeContext) String() string { func (*CanvasAiNodeContext) ProtoMessage() {} func (x *CanvasAiNodeContext) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[63] + mi := &file_canvases_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3959,7 +4071,7 @@ func (x *CanvasAiNodeContext) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasAiNodeContext.ProtoReflect.Descriptor instead. func (*CanvasAiNodeContext) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{63} + return file_canvases_proto_rawDescGZIP(), []int{65} } func (x *CanvasAiNodeContext) GetId() string { @@ -4001,7 +4113,7 @@ type CanvasAiBlockContext struct { func (x *CanvasAiBlockContext) Reset() { *x = CanvasAiBlockContext{} - mi := &file_canvases_proto_msgTypes[64] + mi := &file_canvases_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4013,7 +4125,7 @@ func (x *CanvasAiBlockContext) String() string { func (*CanvasAiBlockContext) ProtoMessage() {} func (x *CanvasAiBlockContext) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[64] + mi := &file_canvases_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4026,7 +4138,7 @@ func (x *CanvasAiBlockContext) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasAiBlockContext.ProtoReflect.Descriptor instead. func (*CanvasAiBlockContext) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{64} + return file_canvases_proto_rawDescGZIP(), []int{66} } func (x *CanvasAiBlockContext) GetName() string { @@ -4060,7 +4172,7 @@ type CanvasAiContext struct { func (x *CanvasAiContext) Reset() { *x = CanvasAiContext{} - mi := &file_canvases_proto_msgTypes[65] + mi := &file_canvases_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4072,7 +4184,7 @@ func (x *CanvasAiContext) String() string { func (*CanvasAiContext) ProtoMessage() {} func (x *CanvasAiContext) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[65] + mi := &file_canvases_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4085,7 +4197,7 @@ func (x *CanvasAiContext) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasAiContext.ProtoReflect.Descriptor instead. func (*CanvasAiContext) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{65} + return file_canvases_proto_rawDescGZIP(), []int{67} } func (x *CanvasAiContext) GetNodes() []*CanvasAiNodeContext { @@ -4113,7 +4225,7 @@ type SendAiMessageRequest struct { func (x *SendAiMessageRequest) Reset() { *x = SendAiMessageRequest{} - mi := &file_canvases_proto_msgTypes[66] + mi := &file_canvases_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4125,7 +4237,7 @@ func (x *SendAiMessageRequest) String() string { func (*SendAiMessageRequest) ProtoMessage() {} func (x *SendAiMessageRequest) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[66] + mi := &file_canvases_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4138,7 +4250,7 @@ func (x *SendAiMessageRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SendAiMessageRequest.ProtoReflect.Descriptor instead. func (*SendAiMessageRequest) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{66} + return file_canvases_proto_rawDescGZIP(), []int{68} } func (x *SendAiMessageRequest) GetCanvasId() string { @@ -4172,7 +4284,7 @@ type SendAiMessageResponse struct { func (x *SendAiMessageResponse) Reset() { *x = SendAiMessageResponse{} - mi := &file_canvases_proto_msgTypes[67] + mi := &file_canvases_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4184,7 +4296,7 @@ func (x *SendAiMessageResponse) String() string { func (*SendAiMessageResponse) ProtoMessage() {} func (x *SendAiMessageResponse) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[67] + mi := &file_canvases_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4197,7 +4309,7 @@ func (x *SendAiMessageResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SendAiMessageResponse.ProtoReflect.Descriptor instead. func (*SendAiMessageResponse) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{67} + return file_canvases_proto_rawDescGZIP(), []int{69} } func (x *SendAiMessageResponse) GetAssistantMessage() string { @@ -4226,7 +4338,7 @@ type CanvasNodeEventMessage struct { func (x *CanvasNodeEventMessage) Reset() { *x = CanvasNodeEventMessage{} - mi := &file_canvases_proto_msgTypes[68] + mi := &file_canvases_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4238,7 +4350,7 @@ func (x *CanvasNodeEventMessage) String() string { func (*CanvasNodeEventMessage) ProtoMessage() {} func (x *CanvasNodeEventMessage) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[68] + mi := &file_canvases_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4251,7 +4363,7 @@ func (x *CanvasNodeEventMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasNodeEventMessage.ProtoReflect.Descriptor instead. func (*CanvasNodeEventMessage) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{68} + return file_canvases_proto_rawDescGZIP(), []int{70} } func (x *CanvasNodeEventMessage) GetId() string { @@ -4294,7 +4406,7 @@ type CanvasNodeExecutionMessage struct { func (x *CanvasNodeExecutionMessage) Reset() { *x = CanvasNodeExecutionMessage{} - mi := &file_canvases_proto_msgTypes[69] + mi := &file_canvases_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4306,7 +4418,7 @@ func (x *CanvasNodeExecutionMessage) String() string { func (*CanvasNodeExecutionMessage) ProtoMessage() {} func (x *CanvasNodeExecutionMessage) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[69] + mi := &file_canvases_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4319,7 +4431,7 @@ func (x *CanvasNodeExecutionMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasNodeExecutionMessage.ProtoReflect.Descriptor instead. func (*CanvasNodeExecutionMessage) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{69} + return file_canvases_proto_rawDescGZIP(), []int{71} } func (x *CanvasNodeExecutionMessage) GetId() string { @@ -4362,7 +4474,7 @@ type CanvasNodeQueueItemMessage struct { func (x *CanvasNodeQueueItemMessage) Reset() { *x = CanvasNodeQueueItemMessage{} - mi := &file_canvases_proto_msgTypes[70] + mi := &file_canvases_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4374,7 +4486,7 @@ func (x *CanvasNodeQueueItemMessage) String() string { func (*CanvasNodeQueueItemMessage) ProtoMessage() {} func (x *CanvasNodeQueueItemMessage) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[70] + mi := &file_canvases_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4387,7 +4499,7 @@ func (x *CanvasNodeQueueItemMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasNodeQueueItemMessage.ProtoReflect.Descriptor instead. func (*CanvasNodeQueueItemMessage) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{70} + return file_canvases_proto_rawDescGZIP(), []int{72} } func (x *CanvasNodeQueueItemMessage) GetId() string { @@ -4429,7 +4541,7 @@ type CanvasMessage struct { func (x *CanvasMessage) Reset() { *x = CanvasMessage{} - mi := &file_canvases_proto_msgTypes[71] + mi := &file_canvases_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4441,7 +4553,7 @@ func (x *CanvasMessage) String() string { func (*CanvasMessage) ProtoMessage() {} func (x *CanvasMessage) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[71] + mi := &file_canvases_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4454,7 +4566,7 @@ func (x *CanvasMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasMessage.ProtoReflect.Descriptor instead. func (*CanvasMessage) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{71} + return file_canvases_proto_rawDescGZIP(), []int{73} } func (x *CanvasMessage) GetId() string { @@ -4489,7 +4601,7 @@ type CanvasVersionMessage struct { func (x *CanvasVersionMessage) Reset() { *x = CanvasVersionMessage{} - mi := &file_canvases_proto_msgTypes[72] + mi := &file_canvases_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4501,7 +4613,7 @@ func (x *CanvasVersionMessage) String() string { func (*CanvasVersionMessage) ProtoMessage() {} func (x *CanvasVersionMessage) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[72] + mi := &file_canvases_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4514,7 +4626,7 @@ func (x *CanvasVersionMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasVersionMessage.ProtoReflect.Descriptor instead. func (*CanvasVersionMessage) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{72} + return file_canvases_proto_rawDescGZIP(), []int{74} } func (x *CanvasVersionMessage) GetCanvasId() string { @@ -4539,22 +4651,23 @@ func (x *CanvasVersionMessage) GetTimestamp() *timestamp.Timestamp { } type Canvas_Metadata struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - OrganizationId string `protobuf:"bytes,2,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"` - Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` - Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` - CreatedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` - UpdatedAt *timestamp.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` - CreatedBy *UserRef `protobuf:"bytes,7,opt,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"` - IsTemplate bool `protobuf:"varint,8,opt,name=is_template,json=isTemplate,proto3" json:"is_template,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + OrganizationId string `protobuf:"bytes,2,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + CreatedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + UpdatedAt *timestamp.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` + CreatedBy *UserRef `protobuf:"bytes,7,opt,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"` + IsTemplate bool `protobuf:"varint,8,opt,name=is_template,json=isTemplate,proto3" json:"is_template,omitempty"` + CanvasVersioningEnabled bool `protobuf:"varint,9,opt,name=canvas_versioning_enabled,json=canvasVersioningEnabled,proto3" json:"canvas_versioning_enabled,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *Canvas_Metadata) Reset() { *x = Canvas_Metadata{} - mi := &file_canvases_proto_msgTypes[73] + mi := &file_canvases_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4566,7 +4679,7 @@ func (x *Canvas_Metadata) String() string { func (*Canvas_Metadata) ProtoMessage() {} func (x *Canvas_Metadata) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[73] + mi := &file_canvases_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4579,7 +4692,7 @@ func (x *Canvas_Metadata) ProtoReflect() protoreflect.Message { // Deprecated: Use Canvas_Metadata.ProtoReflect.Descriptor instead. func (*Canvas_Metadata) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{24, 0} + return file_canvases_proto_rawDescGZIP(), []int{26, 0} } func (x *Canvas_Metadata) GetId() string { @@ -4638,6 +4751,13 @@ func (x *Canvas_Metadata) GetIsTemplate() bool { return false } +func (x *Canvas_Metadata) GetCanvasVersioningEnabled() bool { + if x != nil { + return x.CanvasVersioningEnabled + } + return false +} + type Canvas_Spec struct { state protoimpl.MessageState `protogen:"open.v1"` Nodes []*components.Node `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"` @@ -4648,7 +4768,7 @@ type Canvas_Spec struct { func (x *Canvas_Spec) Reset() { *x = Canvas_Spec{} - mi := &file_canvases_proto_msgTypes[74] + mi := &file_canvases_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4660,7 +4780,7 @@ func (x *Canvas_Spec) String() string { func (*Canvas_Spec) ProtoMessage() {} func (x *Canvas_Spec) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[74] + mi := &file_canvases_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4673,7 +4793,7 @@ func (x *Canvas_Spec) ProtoReflect() protoreflect.Message { // Deprecated: Use Canvas_Spec.ProtoReflect.Descriptor instead. func (*Canvas_Spec) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{24, 1} + return file_canvases_proto_rawDescGZIP(), []int{26, 1} } func (x *Canvas_Spec) GetNodes() []*components.Node { @@ -4701,7 +4821,7 @@ type Canvas_Status struct { func (x *Canvas_Status) Reset() { *x = Canvas_Status{} - mi := &file_canvases_proto_msgTypes[75] + mi := &file_canvases_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4713,7 +4833,7 @@ func (x *Canvas_Status) String() string { func (*Canvas_Status) ProtoMessage() {} func (x *Canvas_Status) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[75] + mi := &file_canvases_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4726,7 +4846,7 @@ func (x *Canvas_Status) ProtoReflect() protoreflect.Message { // Deprecated: Use Canvas_Status.ProtoReflect.Descriptor instead. func (*Canvas_Status) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{24, 2} + return file_canvases_proto_rawDescGZIP(), []int{26, 2} } func (x *Canvas_Status) GetLastExecutions() []*CanvasNodeExecution { @@ -4765,7 +4885,7 @@ type CanvasVersion_Metadata struct { func (x *CanvasVersion_Metadata) Reset() { *x = CanvasVersion_Metadata{} - mi := &file_canvases_proto_msgTypes[76] + mi := &file_canvases_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4777,7 +4897,7 @@ func (x *CanvasVersion_Metadata) String() string { func (*CanvasVersion_Metadata) ProtoMessage() {} func (x *CanvasVersion_Metadata) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[76] + mi := &file_canvases_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4790,7 +4910,7 @@ func (x *CanvasVersion_Metadata) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasVersion_Metadata.ProtoReflect.Descriptor instead. func (*CanvasVersion_Metadata) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{25, 0} + return file_canvases_proto_rawDescGZIP(), []int{27, 0} } func (x *CanvasVersion_Metadata) GetId() string { @@ -4860,7 +4980,7 @@ type CanvasChangeRequest_Metadata struct { func (x *CanvasChangeRequest_Metadata) Reset() { *x = CanvasChangeRequest_Metadata{} - mi := &file_canvases_proto_msgTypes[77] + mi := &file_canvases_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4872,7 +4992,7 @@ func (x *CanvasChangeRequest_Metadata) String() string { func (*CanvasChangeRequest_Metadata) ProtoMessage() {} func (x *CanvasChangeRequest_Metadata) ProtoReflect() protoreflect.Message { - mi := &file_canvases_proto_msgTypes[77] + mi := &file_canvases_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4885,7 +5005,7 @@ func (x *CanvasChangeRequest_Metadata) ProtoReflect() protoreflect.Message { // Deprecated: Use CanvasChangeRequest_Metadata.ProtoReflect.Descriptor instead. func (*CanvasChangeRequest_Metadata) Descriptor() ([]byte, []int) { - return file_canvases_proto_rawDescGZIP(), []int{27, 0} + return file_canvases_proto_rawDescGZIP(), []int{29, 0} } func (x *CanvasChangeRequest_Metadata) GetId() string { @@ -4970,6 +5090,16 @@ const file_canvases_proto_rawDesc = "" + "\x15DescribeCanvasRequest\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\"M\n" + "\x16DescribeCanvasResponse\x123\n" + + "\x06canvas\x18\x01 \x01(\v2\x1b.Superplane.Canvases.CanvasR\x06canvas\"\xdd\x01\n" + + "\x13UpdateCanvasRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x17\n" + + "\x04name\x18\x02 \x01(\tH\x00R\x04name\x88\x01\x01\x12%\n" + + "\vdescription\x18\x03 \x01(\tH\x01R\vdescription\x88\x01\x01\x12?\n" + + "\x19canvas_versioning_enabled\x18\x04 \x01(\bH\x02R\x17canvasVersioningEnabled\x88\x01\x01B\a\n" + + "\x05_nameB\x0e\n" + + "\f_descriptionB\x1c\n" + + "\x1a_canvas_versioning_enabled\"K\n" + + "\x14UpdateCanvasResponse\x123\n" + "\x06canvas\x18\x01 \x01(\v2\x1b.Superplane.Canvases.CanvasR\x06canvas\"J\n" + "\x13CreateCanvasRequest\x123\n" + "\x06canvas\x18\x01 \x01(\v2\x1b.Superplane.Canvases.CanvasR\x06canvas\"K\n" + @@ -5047,11 +5177,11 @@ const file_canvases_proto_rawDesc = "" + "\x14DeleteCanvasResponse\"-\n" + "\aUserRef\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + - "\x04name\x18\x02 \x01(\tR\x04name\"\xef\x06\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"\xab\a\n" + "\x06Canvas\x12@\n" + "\bmetadata\x18\x01 \x01(\v2$.Superplane.Canvases.Canvas.MetadataR\bmetadata\x124\n" + "\x04spec\x18\x02 \x01(\v2 .Superplane.Canvases.Canvas.SpecR\x04spec\x12:\n" + - "\x06status\x18\x03 \x01(\v2\".Superplane.Canvases.Canvas.StatusR\x06status\x1a\xcd\x02\n" + + "\x06status\x18\x03 \x01(\v2\".Superplane.Canvases.Canvas.StatusR\x06status\x1a\x89\x03\n" + "\bMetadata\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12'\n" + "\x0forganization_id\x18\x02 \x01(\tR\x0eorganizationId\x12\x12\n" + @@ -5064,7 +5194,8 @@ const file_canvases_proto_rawDesc = "" + "\n" + "created_by\x18\a \x01(\v2\x1c.Superplane.Canvases.UserRefR\tcreatedBy\x12\x1f\n" + "\vis_template\x18\b \x01(\bR\n" + - "isTemplate\x1al\n" + + "isTemplate\x12:\n" + + "\x19canvas_versioning_enabled\x18\t \x01(\bR\x17canvasVersioningEnabled\x1al\n" + "\x04Spec\x121\n" + "\x05nodes\x18\x01 \x03(\v2\x1b.Superplane.Components.NodeR\x05nodes\x121\n" + "\x05edges\x18\x02 \x03(\v2\x1b.Superplane.Components.EdgeR\x05edges\x1a\xf2\x01\n" + @@ -5343,22 +5474,24 @@ const file_canvases_proto_rawDesc = "" + "\tcanvas_id\x18\x01 \x01(\tR\bcanvasId\x12\x1d\n" + "\n" + "version_id\x18\x02 \x01(\tR\tversionId\x128\n" + - "\ttimestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp2\xae9\n" + + "\ttimestamp\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp2\xf5:\n" + "\bCanvases\x12\xb7\x01\n" + "\fListCanvases\x12(.Superplane.Canvases.ListCanvasesRequest\x1a).Superplane.Canvases.ListCanvasesResponse\"R\x92A7\n" + "\x06Canvas\x12\rList canvases\x1a\x1eReturns a list of all canvases\x82\xd3\xe4\x93\x02\x12\x12\x10/api/v1/canvases\x12\xb0\x01\n" + "\fCreateCanvas\x12(.Superplane.Canvases.CreateCanvasRequest\x1a).Superplane.Canvases.CreateCanvasResponse\"K\x92A-\n" + "\x06Canvas\x12\rCreate canvas\x1a\x14Creates a new canvas\x82\xd3\xe4\x93\x02\x15:\x01*\"\x10/api/v1/canvases\x12\xbc\x01\n" + "\x0eDescribeCanvas\x12*.Superplane.Canvases.DescribeCanvasRequest\x1a+.Superplane.Canvases.DescribeCanvasResponse\"Q\x92A1\n" + - "\x06Canvas\x12\x0fDescribe canvas\x1a\x16Returns a canvas by ID\x82\xd3\xe4\x93\x02\x17\x12\x15/api/v1/canvases/{id}\x12\x96\x02\n" + + "\x06Canvas\x12\x0fDescribe canvas\x1a\x16Returns a canvas by ID\x82\xd3\xe4\x93\x02\x17\x12\x15/api/v1/canvases/{id}\x12\xb8\x01\n" + + "\fUpdateCanvas\x12(.Superplane.Canvases.UpdateCanvasRequest\x1a).Superplane.Canvases.UpdateCanvasResponse\"S\x92A0\n" + + "\x06Canvas\x12\rUpdate canvas\x1a\x17Updates canvas metadata\x82\xd3\xe4\x93\x02\x1a:\x01*\x1a\x15/api/v1/canvases/{id}\x12\x96\x02\n" + "\x13CreateCanvasVersion\x12/.Superplane.Canvases.CreateCanvasVersionRequest\x1a0.Superplane.Canvases.CreateCanvasVersionResponse\"\x9b\x01\x92Ah\n" + "\rCanvasVersion\x12\x15Create canvas version\x1a@Creates a user-owned canvas version from the current live canvas\x82\xd3\xe4\x93\x02*:\x01*\"%/api/v1/canvases/{canvas_id}/versions\x12\xed\x01\n" + "\x12ListCanvasVersions\x12..Superplane.Canvases.ListCanvasVersionsRequest\x1a/.Superplane.Canvases.ListCanvasVersionsResponse\"v\x92AF\n" + "\rCanvasVersion\x12\x14List canvas versions\x1a\x1fLists all versions for a canvas\x82\xd3\xe4\x93\x02'\x12%/api/v1/canvases/{canvas_id}/versions\x12\x88\x02\n" + "\x15DescribeCanvasVersion\x121.Superplane.Canvases.DescribeCanvasVersionRequest\x1a2.Superplane.Canvases.DescribeCanvasVersionResponse\"\x87\x01\x92AJ\n" + - "\rCanvasVersion\x12\x17Describe canvas version\x1a Returns one canvas version by ID\x82\xd3\xe4\x93\x024\x122/api/v1/canvases/{canvas_id}/versions/{version_id}\x12\xf6\x02\n" + - "\x13UpdateCanvasVersion\x12/.Superplane.Canvases.UpdateCanvasVersionRequest\x1a0.Superplane.Canvases.UpdateCanvasVersionResponse\"\xfb\x01\x92A\x8e\x01\n" + - "\rCanvasVersion\x12\x15Update canvas version\x1afUpdates a user-owned canvas version; if version_id is omitted, updates the live canvas in sandbox mode\x82\xd3\xe4\x93\x02c:\x01*Z*:\x01*\x1a%/api/v1/canvases/{canvas_id}/versions\x1a2/api/v1/canvases/{canvas_id}/versions/{version_id}\x12\xaf\x02\n" + + "\rCanvasVersion\x12\x17Describe canvas version\x1a Returns one canvas version by ID\x82\xd3\xe4\x93\x024\x122/api/v1/canvases/{canvas_id}/versions/{version_id}\x12\x82\x03\n" + + "\x13UpdateCanvasVersion\x12/.Superplane.Canvases.UpdateCanvasVersionRequest\x1a0.Superplane.Canvases.UpdateCanvasVersionResponse\"\x87\x02\x92A\x9a\x01\n" + + "\rCanvasVersion\x12\x15Update canvas version\x1arUpdates a user-owned canvas version; if version_id is omitted, updates the live canvas when versioning is disabled\x82\xd3\xe4\x93\x02c:\x01*Z*:\x01*\x1a%/api/v1/canvases/{canvas_id}/versions\x1a2/api/v1/canvases/{canvas_id}/versions/{version_id}\x12\xaf\x02\n" + "\x19CreateCanvasChangeRequest\x125.Superplane.Canvases.CreateCanvasChangeRequestRequest\x1a6.Superplane.Canvases.CreateCanvasChangeRequestResponse\"\xa2\x01\x92Ah\n" + "\x13CanvasChangeRequest\x12\x1cCreate canvas change request\x1a3Creates a change request for a draft canvas version\x82\xd3\xe4\x93\x021:\x01*\",/api/v1/canvases/{canvas_id}/change-requests\x12\x97\x02\n" + "\x18ListCanvasChangeRequests\x124.Superplane.Canvases.ListCanvasChangeRequestsRequest\x1a5.Superplane.Canvases.ListCanvasChangeRequestsResponse\"\x8d\x01\x92AV\n" + @@ -5422,7 +5555,7 @@ func file_canvases_proto_rawDescGZIP() []byte { } var file_canvases_proto_enumTypes = make([]protoimpl.EnumInfo, 6) -var file_canvases_proto_msgTypes = make([]protoimpl.MessageInfo, 78) +var file_canvases_proto_msgTypes = make([]protoimpl.MessageInfo, 80) var file_canvases_proto_goTypes = []any{ (CanvasAutoLayout_Algorithm)(0), // 0: Superplane.Canvases.CanvasAutoLayout.Algorithm (CanvasAutoLayout_Scope)(0), // 1: Superplane.Canvases.CanvasAutoLayout.Scope @@ -5434,242 +5567,247 @@ var file_canvases_proto_goTypes = []any{ (*ListCanvasesResponse)(nil), // 7: Superplane.Canvases.ListCanvasesResponse (*DescribeCanvasRequest)(nil), // 8: Superplane.Canvases.DescribeCanvasRequest (*DescribeCanvasResponse)(nil), // 9: Superplane.Canvases.DescribeCanvasResponse - (*CreateCanvasRequest)(nil), // 10: Superplane.Canvases.CreateCanvasRequest - (*CreateCanvasResponse)(nil), // 11: Superplane.Canvases.CreateCanvasResponse - (*CanvasAutoLayout)(nil), // 12: Superplane.Canvases.CanvasAutoLayout - (*CreateCanvasVersionRequest)(nil), // 13: Superplane.Canvases.CreateCanvasVersionRequest - (*CreateCanvasVersionResponse)(nil), // 14: Superplane.Canvases.CreateCanvasVersionResponse - (*ListCanvasVersionsRequest)(nil), // 15: Superplane.Canvases.ListCanvasVersionsRequest - (*ListCanvasVersionsResponse)(nil), // 16: Superplane.Canvases.ListCanvasVersionsResponse - (*DescribeCanvasVersionRequest)(nil), // 17: Superplane.Canvases.DescribeCanvasVersionRequest - (*DescribeCanvasVersionResponse)(nil), // 18: Superplane.Canvases.DescribeCanvasVersionResponse - (*UpdateCanvasVersionRequest)(nil), // 19: Superplane.Canvases.UpdateCanvasVersionRequest - (*UpdateCanvasVersionResponse)(nil), // 20: Superplane.Canvases.UpdateCanvasVersionResponse - (*CreateCanvasChangeRequestRequest)(nil), // 21: Superplane.Canvases.CreateCanvasChangeRequestRequest - (*CreateCanvasChangeRequestResponse)(nil), // 22: Superplane.Canvases.CreateCanvasChangeRequestResponse - (*ListCanvasChangeRequestsRequest)(nil), // 23: Superplane.Canvases.ListCanvasChangeRequestsRequest - (*ListCanvasChangeRequestsResponse)(nil), // 24: Superplane.Canvases.ListCanvasChangeRequestsResponse - (*DescribeCanvasChangeRequestRequest)(nil), // 25: Superplane.Canvases.DescribeCanvasChangeRequestRequest - (*DescribeCanvasChangeRequestResponse)(nil), // 26: Superplane.Canvases.DescribeCanvasChangeRequestResponse - (*DeleteCanvasRequest)(nil), // 27: Superplane.Canvases.DeleteCanvasRequest - (*DeleteCanvasResponse)(nil), // 28: Superplane.Canvases.DeleteCanvasResponse - (*UserRef)(nil), // 29: Superplane.Canvases.UserRef - (*Canvas)(nil), // 30: Superplane.Canvases.Canvas - (*CanvasVersion)(nil), // 31: Superplane.Canvases.CanvasVersion - (*CanvasChangeRequestDiff)(nil), // 32: Superplane.Canvases.CanvasChangeRequestDiff - (*CanvasChangeRequest)(nil), // 33: Superplane.Canvases.CanvasChangeRequest - (*ListNodeEventsRequest)(nil), // 34: Superplane.Canvases.ListNodeEventsRequest - (*ListNodeEventsResponse)(nil), // 35: Superplane.Canvases.ListNodeEventsResponse - (*EmitNodeEventRequest)(nil), // 36: Superplane.Canvases.EmitNodeEventRequest - (*EmitNodeEventResponse)(nil), // 37: Superplane.Canvases.EmitNodeEventResponse - (*ListNodeQueueItemsRequest)(nil), // 38: Superplane.Canvases.ListNodeQueueItemsRequest - (*ListNodeQueueItemsResponse)(nil), // 39: Superplane.Canvases.ListNodeQueueItemsResponse - (*DeleteNodeQueueItemRequest)(nil), // 40: Superplane.Canvases.DeleteNodeQueueItemRequest - (*DeleteNodeQueueItemResponse)(nil), // 41: Superplane.Canvases.DeleteNodeQueueItemResponse - (*UpdateNodePauseRequest)(nil), // 42: Superplane.Canvases.UpdateNodePauseRequest - (*UpdateNodePauseResponse)(nil), // 43: Superplane.Canvases.UpdateNodePauseResponse - (*ListNodeExecutionsRequest)(nil), // 44: Superplane.Canvases.ListNodeExecutionsRequest - (*ListNodeExecutionsResponse)(nil), // 45: Superplane.Canvases.ListNodeExecutionsResponse - (*ListChildExecutionsRequest)(nil), // 46: Superplane.Canvases.ListChildExecutionsRequest - (*ListChildExecutionsResponse)(nil), // 47: Superplane.Canvases.ListChildExecutionsResponse - (*CanvasNodeExecution)(nil), // 48: Superplane.Canvases.CanvasNodeExecution - (*CanvasNodeQueueItem)(nil), // 49: Superplane.Canvases.CanvasNodeQueueItem - (*InvokeNodeExecutionActionRequest)(nil), // 50: Superplane.Canvases.InvokeNodeExecutionActionRequest - (*InvokeNodeExecutionActionResponse)(nil), // 51: Superplane.Canvases.InvokeNodeExecutionActionResponse - (*InvokeNodeTriggerActionRequest)(nil), // 52: Superplane.Canvases.InvokeNodeTriggerActionRequest - (*InvokeNodeTriggerActionResponse)(nil), // 53: Superplane.Canvases.InvokeNodeTriggerActionResponse - (*ListCanvasEventsRequest)(nil), // 54: Superplane.Canvases.ListCanvasEventsRequest - (*ListCanvasEventsResponse)(nil), // 55: Superplane.Canvases.ListCanvasEventsResponse - (*CanvasMemory)(nil), // 56: Superplane.Canvases.CanvasMemory - (*ListCanvasMemoriesRequest)(nil), // 57: Superplane.Canvases.ListCanvasMemoriesRequest - (*ListCanvasMemoriesResponse)(nil), // 58: Superplane.Canvases.ListCanvasMemoriesResponse - (*DeleteCanvasMemoryRequest)(nil), // 59: Superplane.Canvases.DeleteCanvasMemoryRequest - (*DeleteCanvasMemoryResponse)(nil), // 60: Superplane.Canvases.DeleteCanvasMemoryResponse - (*CanvasEvent)(nil), // 61: Superplane.Canvases.CanvasEvent - (*CanvasEventWithExecutions)(nil), // 62: Superplane.Canvases.CanvasEventWithExecutions - (*ListEventExecutionsRequest)(nil), // 63: Superplane.Canvases.ListEventExecutionsRequest - (*ListEventExecutionsResponse)(nil), // 64: Superplane.Canvases.ListEventExecutionsResponse - (*CancelExecutionRequest)(nil), // 65: Superplane.Canvases.CancelExecutionRequest - (*CancelExecutionResponse)(nil), // 66: Superplane.Canvases.CancelExecutionResponse - (*ResolveExecutionErrorsRequest)(nil), // 67: Superplane.Canvases.ResolveExecutionErrorsRequest - (*ResolveExecutionErrorsResponse)(nil), // 68: Superplane.Canvases.ResolveExecutionErrorsResponse - (*CanvasAiNodeContext)(nil), // 69: Superplane.Canvases.CanvasAiNodeContext - (*CanvasAiBlockContext)(nil), // 70: Superplane.Canvases.CanvasAiBlockContext - (*CanvasAiContext)(nil), // 71: Superplane.Canvases.CanvasAiContext - (*SendAiMessageRequest)(nil), // 72: Superplane.Canvases.SendAiMessageRequest - (*SendAiMessageResponse)(nil), // 73: Superplane.Canvases.SendAiMessageResponse - (*CanvasNodeEventMessage)(nil), // 74: Superplane.Canvases.CanvasNodeEventMessage - (*CanvasNodeExecutionMessage)(nil), // 75: Superplane.Canvases.CanvasNodeExecutionMessage - (*CanvasNodeQueueItemMessage)(nil), // 76: Superplane.Canvases.CanvasNodeQueueItemMessage - (*CanvasMessage)(nil), // 77: Superplane.Canvases.CanvasMessage - (*CanvasVersionMessage)(nil), // 78: Superplane.Canvases.CanvasVersionMessage - (*Canvas_Metadata)(nil), // 79: Superplane.Canvases.Canvas.Metadata - (*Canvas_Spec)(nil), // 80: Superplane.Canvases.Canvas.Spec - (*Canvas_Status)(nil), // 81: Superplane.Canvases.Canvas.Status - (*CanvasVersion_Metadata)(nil), // 82: Superplane.Canvases.CanvasVersion.Metadata - (*CanvasChangeRequest_Metadata)(nil), // 83: Superplane.Canvases.CanvasChangeRequest.Metadata - (*timestamp.Timestamp)(nil), // 84: google.protobuf.Timestamp - (*_struct.Struct)(nil), // 85: google.protobuf.Struct - (*components.Node)(nil), // 86: Superplane.Components.Node - (*_struct.Value)(nil), // 87: google.protobuf.Value - (*components.Edge)(nil), // 88: Superplane.Components.Edge + (*UpdateCanvasRequest)(nil), // 10: Superplane.Canvases.UpdateCanvasRequest + (*UpdateCanvasResponse)(nil), // 11: Superplane.Canvases.UpdateCanvasResponse + (*CreateCanvasRequest)(nil), // 12: Superplane.Canvases.CreateCanvasRequest + (*CreateCanvasResponse)(nil), // 13: Superplane.Canvases.CreateCanvasResponse + (*CanvasAutoLayout)(nil), // 14: Superplane.Canvases.CanvasAutoLayout + (*CreateCanvasVersionRequest)(nil), // 15: Superplane.Canvases.CreateCanvasVersionRequest + (*CreateCanvasVersionResponse)(nil), // 16: Superplane.Canvases.CreateCanvasVersionResponse + (*ListCanvasVersionsRequest)(nil), // 17: Superplane.Canvases.ListCanvasVersionsRequest + (*ListCanvasVersionsResponse)(nil), // 18: Superplane.Canvases.ListCanvasVersionsResponse + (*DescribeCanvasVersionRequest)(nil), // 19: Superplane.Canvases.DescribeCanvasVersionRequest + (*DescribeCanvasVersionResponse)(nil), // 20: Superplane.Canvases.DescribeCanvasVersionResponse + (*UpdateCanvasVersionRequest)(nil), // 21: Superplane.Canvases.UpdateCanvasVersionRequest + (*UpdateCanvasVersionResponse)(nil), // 22: Superplane.Canvases.UpdateCanvasVersionResponse + (*CreateCanvasChangeRequestRequest)(nil), // 23: Superplane.Canvases.CreateCanvasChangeRequestRequest + (*CreateCanvasChangeRequestResponse)(nil), // 24: Superplane.Canvases.CreateCanvasChangeRequestResponse + (*ListCanvasChangeRequestsRequest)(nil), // 25: Superplane.Canvases.ListCanvasChangeRequestsRequest + (*ListCanvasChangeRequestsResponse)(nil), // 26: Superplane.Canvases.ListCanvasChangeRequestsResponse + (*DescribeCanvasChangeRequestRequest)(nil), // 27: Superplane.Canvases.DescribeCanvasChangeRequestRequest + (*DescribeCanvasChangeRequestResponse)(nil), // 28: Superplane.Canvases.DescribeCanvasChangeRequestResponse + (*DeleteCanvasRequest)(nil), // 29: Superplane.Canvases.DeleteCanvasRequest + (*DeleteCanvasResponse)(nil), // 30: Superplane.Canvases.DeleteCanvasResponse + (*UserRef)(nil), // 31: Superplane.Canvases.UserRef + (*Canvas)(nil), // 32: Superplane.Canvases.Canvas + (*CanvasVersion)(nil), // 33: Superplane.Canvases.CanvasVersion + (*CanvasChangeRequestDiff)(nil), // 34: Superplane.Canvases.CanvasChangeRequestDiff + (*CanvasChangeRequest)(nil), // 35: Superplane.Canvases.CanvasChangeRequest + (*ListNodeEventsRequest)(nil), // 36: Superplane.Canvases.ListNodeEventsRequest + (*ListNodeEventsResponse)(nil), // 37: Superplane.Canvases.ListNodeEventsResponse + (*EmitNodeEventRequest)(nil), // 38: Superplane.Canvases.EmitNodeEventRequest + (*EmitNodeEventResponse)(nil), // 39: Superplane.Canvases.EmitNodeEventResponse + (*ListNodeQueueItemsRequest)(nil), // 40: Superplane.Canvases.ListNodeQueueItemsRequest + (*ListNodeQueueItemsResponse)(nil), // 41: Superplane.Canvases.ListNodeQueueItemsResponse + (*DeleteNodeQueueItemRequest)(nil), // 42: Superplane.Canvases.DeleteNodeQueueItemRequest + (*DeleteNodeQueueItemResponse)(nil), // 43: Superplane.Canvases.DeleteNodeQueueItemResponse + (*UpdateNodePauseRequest)(nil), // 44: Superplane.Canvases.UpdateNodePauseRequest + (*UpdateNodePauseResponse)(nil), // 45: Superplane.Canvases.UpdateNodePauseResponse + (*ListNodeExecutionsRequest)(nil), // 46: Superplane.Canvases.ListNodeExecutionsRequest + (*ListNodeExecutionsResponse)(nil), // 47: Superplane.Canvases.ListNodeExecutionsResponse + (*ListChildExecutionsRequest)(nil), // 48: Superplane.Canvases.ListChildExecutionsRequest + (*ListChildExecutionsResponse)(nil), // 49: Superplane.Canvases.ListChildExecutionsResponse + (*CanvasNodeExecution)(nil), // 50: Superplane.Canvases.CanvasNodeExecution + (*CanvasNodeQueueItem)(nil), // 51: Superplane.Canvases.CanvasNodeQueueItem + (*InvokeNodeExecutionActionRequest)(nil), // 52: Superplane.Canvases.InvokeNodeExecutionActionRequest + (*InvokeNodeExecutionActionResponse)(nil), // 53: Superplane.Canvases.InvokeNodeExecutionActionResponse + (*InvokeNodeTriggerActionRequest)(nil), // 54: Superplane.Canvases.InvokeNodeTriggerActionRequest + (*InvokeNodeTriggerActionResponse)(nil), // 55: Superplane.Canvases.InvokeNodeTriggerActionResponse + (*ListCanvasEventsRequest)(nil), // 56: Superplane.Canvases.ListCanvasEventsRequest + (*ListCanvasEventsResponse)(nil), // 57: Superplane.Canvases.ListCanvasEventsResponse + (*CanvasMemory)(nil), // 58: Superplane.Canvases.CanvasMemory + (*ListCanvasMemoriesRequest)(nil), // 59: Superplane.Canvases.ListCanvasMemoriesRequest + (*ListCanvasMemoriesResponse)(nil), // 60: Superplane.Canvases.ListCanvasMemoriesResponse + (*DeleteCanvasMemoryRequest)(nil), // 61: Superplane.Canvases.DeleteCanvasMemoryRequest + (*DeleteCanvasMemoryResponse)(nil), // 62: Superplane.Canvases.DeleteCanvasMemoryResponse + (*CanvasEvent)(nil), // 63: Superplane.Canvases.CanvasEvent + (*CanvasEventWithExecutions)(nil), // 64: Superplane.Canvases.CanvasEventWithExecutions + (*ListEventExecutionsRequest)(nil), // 65: Superplane.Canvases.ListEventExecutionsRequest + (*ListEventExecutionsResponse)(nil), // 66: Superplane.Canvases.ListEventExecutionsResponse + (*CancelExecutionRequest)(nil), // 67: Superplane.Canvases.CancelExecutionRequest + (*CancelExecutionResponse)(nil), // 68: Superplane.Canvases.CancelExecutionResponse + (*ResolveExecutionErrorsRequest)(nil), // 69: Superplane.Canvases.ResolveExecutionErrorsRequest + (*ResolveExecutionErrorsResponse)(nil), // 70: Superplane.Canvases.ResolveExecutionErrorsResponse + (*CanvasAiNodeContext)(nil), // 71: Superplane.Canvases.CanvasAiNodeContext + (*CanvasAiBlockContext)(nil), // 72: Superplane.Canvases.CanvasAiBlockContext + (*CanvasAiContext)(nil), // 73: Superplane.Canvases.CanvasAiContext + (*SendAiMessageRequest)(nil), // 74: Superplane.Canvases.SendAiMessageRequest + (*SendAiMessageResponse)(nil), // 75: Superplane.Canvases.SendAiMessageResponse + (*CanvasNodeEventMessage)(nil), // 76: Superplane.Canvases.CanvasNodeEventMessage + (*CanvasNodeExecutionMessage)(nil), // 77: Superplane.Canvases.CanvasNodeExecutionMessage + (*CanvasNodeQueueItemMessage)(nil), // 78: Superplane.Canvases.CanvasNodeQueueItemMessage + (*CanvasMessage)(nil), // 79: Superplane.Canvases.CanvasMessage + (*CanvasVersionMessage)(nil), // 80: Superplane.Canvases.CanvasVersionMessage + (*Canvas_Metadata)(nil), // 81: Superplane.Canvases.Canvas.Metadata + (*Canvas_Spec)(nil), // 82: Superplane.Canvases.Canvas.Spec + (*Canvas_Status)(nil), // 83: Superplane.Canvases.Canvas.Status + (*CanvasVersion_Metadata)(nil), // 84: Superplane.Canvases.CanvasVersion.Metadata + (*CanvasChangeRequest_Metadata)(nil), // 85: Superplane.Canvases.CanvasChangeRequest.Metadata + (*timestamp.Timestamp)(nil), // 86: google.protobuf.Timestamp + (*_struct.Struct)(nil), // 87: google.protobuf.Struct + (*components.Node)(nil), // 88: Superplane.Components.Node + (*_struct.Value)(nil), // 89: google.protobuf.Value + (*components.Edge)(nil), // 90: Superplane.Components.Edge } var file_canvases_proto_depIdxs = []int32{ - 30, // 0: Superplane.Canvases.ListCanvasesResponse.canvases:type_name -> Superplane.Canvases.Canvas - 30, // 1: Superplane.Canvases.DescribeCanvasResponse.canvas:type_name -> Superplane.Canvases.Canvas - 30, // 2: Superplane.Canvases.CreateCanvasRequest.canvas:type_name -> Superplane.Canvases.Canvas - 30, // 3: Superplane.Canvases.CreateCanvasResponse.canvas:type_name -> Superplane.Canvases.Canvas - 0, // 4: Superplane.Canvases.CanvasAutoLayout.algorithm:type_name -> Superplane.Canvases.CanvasAutoLayout.Algorithm - 1, // 5: Superplane.Canvases.CanvasAutoLayout.scope:type_name -> Superplane.Canvases.CanvasAutoLayout.Scope - 31, // 6: Superplane.Canvases.CreateCanvasVersionResponse.version:type_name -> Superplane.Canvases.CanvasVersion - 84, // 7: Superplane.Canvases.ListCanvasVersionsRequest.before:type_name -> google.protobuf.Timestamp - 31, // 8: Superplane.Canvases.ListCanvasVersionsResponse.versions:type_name -> Superplane.Canvases.CanvasVersion - 84, // 9: Superplane.Canvases.ListCanvasVersionsResponse.last_timestamp:type_name -> google.protobuf.Timestamp - 31, // 10: Superplane.Canvases.DescribeCanvasVersionResponse.version:type_name -> Superplane.Canvases.CanvasVersion - 30, // 11: Superplane.Canvases.UpdateCanvasVersionRequest.canvas:type_name -> Superplane.Canvases.Canvas - 12, // 12: Superplane.Canvases.UpdateCanvasVersionRequest.auto_layout:type_name -> Superplane.Canvases.CanvasAutoLayout - 31, // 13: Superplane.Canvases.UpdateCanvasVersionResponse.version:type_name -> Superplane.Canvases.CanvasVersion - 33, // 14: Superplane.Canvases.CreateCanvasChangeRequestResponse.change_request:type_name -> Superplane.Canvases.CanvasChangeRequest - 84, // 15: Superplane.Canvases.ListCanvasChangeRequestsRequest.before:type_name -> google.protobuf.Timestamp - 33, // 16: Superplane.Canvases.ListCanvasChangeRequestsResponse.change_requests:type_name -> Superplane.Canvases.CanvasChangeRequest - 84, // 17: Superplane.Canvases.ListCanvasChangeRequestsResponse.last_timestamp:type_name -> google.protobuf.Timestamp - 33, // 18: Superplane.Canvases.DescribeCanvasChangeRequestResponse.change_request:type_name -> Superplane.Canvases.CanvasChangeRequest - 79, // 19: Superplane.Canvases.Canvas.metadata:type_name -> Superplane.Canvases.Canvas.Metadata - 80, // 20: Superplane.Canvases.Canvas.spec:type_name -> Superplane.Canvases.Canvas.Spec - 81, // 21: Superplane.Canvases.Canvas.status:type_name -> Superplane.Canvases.Canvas.Status - 82, // 22: Superplane.Canvases.CanvasVersion.metadata:type_name -> Superplane.Canvases.CanvasVersion.Metadata - 80, // 23: Superplane.Canvases.CanvasVersion.spec:type_name -> Superplane.Canvases.Canvas.Spec - 83, // 24: Superplane.Canvases.CanvasChangeRequest.metadata:type_name -> Superplane.Canvases.CanvasChangeRequest.Metadata - 31, // 25: Superplane.Canvases.CanvasChangeRequest.version:type_name -> Superplane.Canvases.CanvasVersion - 32, // 26: Superplane.Canvases.CanvasChangeRequest.diff:type_name -> Superplane.Canvases.CanvasChangeRequestDiff - 84, // 27: Superplane.Canvases.ListNodeEventsRequest.before:type_name -> google.protobuf.Timestamp - 61, // 28: Superplane.Canvases.ListNodeEventsResponse.events:type_name -> Superplane.Canvases.CanvasEvent - 84, // 29: Superplane.Canvases.ListNodeEventsResponse.last_timestamp:type_name -> google.protobuf.Timestamp - 85, // 30: Superplane.Canvases.EmitNodeEventRequest.data:type_name -> google.protobuf.Struct - 84, // 31: Superplane.Canvases.ListNodeQueueItemsRequest.before:type_name -> google.protobuf.Timestamp - 49, // 32: Superplane.Canvases.ListNodeQueueItemsResponse.items:type_name -> Superplane.Canvases.CanvasNodeQueueItem - 84, // 33: Superplane.Canvases.ListNodeQueueItemsResponse.last_timestamp:type_name -> google.protobuf.Timestamp - 86, // 34: Superplane.Canvases.UpdateNodePauseResponse.node:type_name -> Superplane.Components.Node - 3, // 35: Superplane.Canvases.ListNodeExecutionsRequest.states:type_name -> Superplane.Canvases.CanvasNodeExecution.State - 4, // 36: Superplane.Canvases.ListNodeExecutionsRequest.results:type_name -> Superplane.Canvases.CanvasNodeExecution.Result - 84, // 37: Superplane.Canvases.ListNodeExecutionsRequest.before:type_name -> google.protobuf.Timestamp - 48, // 38: Superplane.Canvases.ListNodeExecutionsResponse.executions:type_name -> Superplane.Canvases.CanvasNodeExecution - 84, // 39: Superplane.Canvases.ListNodeExecutionsResponse.last_timestamp:type_name -> google.protobuf.Timestamp - 48, // 40: Superplane.Canvases.ListChildExecutionsResponse.executions:type_name -> Superplane.Canvases.CanvasNodeExecution - 3, // 41: Superplane.Canvases.CanvasNodeExecution.state:type_name -> Superplane.Canvases.CanvasNodeExecution.State - 4, // 42: Superplane.Canvases.CanvasNodeExecution.result:type_name -> Superplane.Canvases.CanvasNodeExecution.Result - 5, // 43: Superplane.Canvases.CanvasNodeExecution.result_reason:type_name -> Superplane.Canvases.CanvasNodeExecution.ResultReason - 85, // 44: Superplane.Canvases.CanvasNodeExecution.input:type_name -> google.protobuf.Struct - 85, // 45: Superplane.Canvases.CanvasNodeExecution.outputs:type_name -> google.protobuf.Struct - 84, // 46: Superplane.Canvases.CanvasNodeExecution.created_at:type_name -> google.protobuf.Timestamp - 84, // 47: Superplane.Canvases.CanvasNodeExecution.updated_at:type_name -> google.protobuf.Timestamp - 85, // 48: Superplane.Canvases.CanvasNodeExecution.metadata:type_name -> google.protobuf.Struct - 85, // 49: Superplane.Canvases.CanvasNodeExecution.configuration:type_name -> google.protobuf.Struct - 48, // 50: Superplane.Canvases.CanvasNodeExecution.child_executions:type_name -> Superplane.Canvases.CanvasNodeExecution - 61, // 51: Superplane.Canvases.CanvasNodeExecution.root_event:type_name -> Superplane.Canvases.CanvasEvent - 29, // 52: Superplane.Canvases.CanvasNodeExecution.cancelled_by:type_name -> Superplane.Canvases.UserRef - 85, // 53: Superplane.Canvases.CanvasNodeQueueItem.input:type_name -> google.protobuf.Struct - 61, // 54: Superplane.Canvases.CanvasNodeQueueItem.root_event:type_name -> Superplane.Canvases.CanvasEvent - 84, // 55: Superplane.Canvases.CanvasNodeQueueItem.created_at:type_name -> google.protobuf.Timestamp - 85, // 56: Superplane.Canvases.InvokeNodeExecutionActionRequest.parameters:type_name -> google.protobuf.Struct - 85, // 57: Superplane.Canvases.InvokeNodeTriggerActionRequest.parameters:type_name -> google.protobuf.Struct - 85, // 58: Superplane.Canvases.InvokeNodeTriggerActionResponse.result:type_name -> google.protobuf.Struct - 84, // 59: Superplane.Canvases.ListCanvasEventsRequest.before:type_name -> google.protobuf.Timestamp - 62, // 60: Superplane.Canvases.ListCanvasEventsResponse.events:type_name -> Superplane.Canvases.CanvasEventWithExecutions - 84, // 61: Superplane.Canvases.ListCanvasEventsResponse.last_timestamp:type_name -> google.protobuf.Timestamp - 87, // 62: Superplane.Canvases.CanvasMemory.values:type_name -> google.protobuf.Value - 56, // 63: Superplane.Canvases.ListCanvasMemoriesResponse.items:type_name -> Superplane.Canvases.CanvasMemory - 85, // 64: Superplane.Canvases.CanvasEvent.data:type_name -> google.protobuf.Struct - 84, // 65: Superplane.Canvases.CanvasEvent.created_at:type_name -> google.protobuf.Timestamp - 85, // 66: Superplane.Canvases.CanvasEventWithExecutions.data:type_name -> google.protobuf.Struct - 84, // 67: Superplane.Canvases.CanvasEventWithExecutions.created_at:type_name -> google.protobuf.Timestamp - 48, // 68: Superplane.Canvases.CanvasEventWithExecutions.executions:type_name -> Superplane.Canvases.CanvasNodeExecution - 48, // 69: Superplane.Canvases.ListEventExecutionsResponse.executions:type_name -> Superplane.Canvases.CanvasNodeExecution - 69, // 70: Superplane.Canvases.CanvasAiContext.nodes:type_name -> Superplane.Canvases.CanvasAiNodeContext - 70, // 71: Superplane.Canvases.CanvasAiContext.available_blocks:type_name -> Superplane.Canvases.CanvasAiBlockContext - 71, // 72: Superplane.Canvases.SendAiMessageRequest.canvas_context:type_name -> Superplane.Canvases.CanvasAiContext - 85, // 73: Superplane.Canvases.SendAiMessageResponse.operations:type_name -> google.protobuf.Struct - 84, // 74: Superplane.Canvases.CanvasNodeEventMessage.timestamp:type_name -> google.protobuf.Timestamp - 84, // 75: Superplane.Canvases.CanvasNodeExecutionMessage.timestamp:type_name -> google.protobuf.Timestamp - 84, // 76: Superplane.Canvases.CanvasNodeQueueItemMessage.timestamp:type_name -> google.protobuf.Timestamp - 84, // 77: Superplane.Canvases.CanvasMessage.timestamp:type_name -> google.protobuf.Timestamp - 84, // 78: Superplane.Canvases.CanvasVersionMessage.timestamp:type_name -> google.protobuf.Timestamp - 84, // 79: Superplane.Canvases.Canvas.Metadata.created_at:type_name -> google.protobuf.Timestamp - 84, // 80: Superplane.Canvases.Canvas.Metadata.updated_at:type_name -> google.protobuf.Timestamp - 29, // 81: Superplane.Canvases.Canvas.Metadata.created_by:type_name -> Superplane.Canvases.UserRef - 86, // 82: Superplane.Canvases.Canvas.Spec.nodes:type_name -> Superplane.Components.Node - 88, // 83: Superplane.Canvases.Canvas.Spec.edges:type_name -> Superplane.Components.Edge - 48, // 84: Superplane.Canvases.Canvas.Status.last_executions:type_name -> Superplane.Canvases.CanvasNodeExecution - 49, // 85: Superplane.Canvases.Canvas.Status.next_queue_items:type_name -> Superplane.Canvases.CanvasNodeQueueItem - 61, // 86: Superplane.Canvases.Canvas.Status.last_events:type_name -> Superplane.Canvases.CanvasEvent - 29, // 87: Superplane.Canvases.CanvasVersion.Metadata.owner:type_name -> Superplane.Canvases.UserRef - 84, // 88: Superplane.Canvases.CanvasVersion.Metadata.published_at:type_name -> google.protobuf.Timestamp - 84, // 89: Superplane.Canvases.CanvasVersion.Metadata.created_at:type_name -> google.protobuf.Timestamp - 84, // 90: Superplane.Canvases.CanvasVersion.Metadata.updated_at:type_name -> google.protobuf.Timestamp - 29, // 91: Superplane.Canvases.CanvasChangeRequest.Metadata.owner:type_name -> Superplane.Canvases.UserRef - 2, // 92: Superplane.Canvases.CanvasChangeRequest.Metadata.status:type_name -> Superplane.Canvases.CanvasChangeRequest.Status - 84, // 93: Superplane.Canvases.CanvasChangeRequest.Metadata.published_at:type_name -> google.protobuf.Timestamp - 84, // 94: Superplane.Canvases.CanvasChangeRequest.Metadata.created_at:type_name -> google.protobuf.Timestamp - 84, // 95: Superplane.Canvases.CanvasChangeRequest.Metadata.updated_at:type_name -> google.protobuf.Timestamp - 6, // 96: Superplane.Canvases.Canvases.ListCanvases:input_type -> Superplane.Canvases.ListCanvasesRequest - 10, // 97: Superplane.Canvases.Canvases.CreateCanvas:input_type -> Superplane.Canvases.CreateCanvasRequest - 8, // 98: Superplane.Canvases.Canvases.DescribeCanvas:input_type -> Superplane.Canvases.DescribeCanvasRequest - 13, // 99: Superplane.Canvases.Canvases.CreateCanvasVersion:input_type -> Superplane.Canvases.CreateCanvasVersionRequest - 15, // 100: Superplane.Canvases.Canvases.ListCanvasVersions:input_type -> Superplane.Canvases.ListCanvasVersionsRequest - 17, // 101: Superplane.Canvases.Canvases.DescribeCanvasVersion:input_type -> Superplane.Canvases.DescribeCanvasVersionRequest - 19, // 102: Superplane.Canvases.Canvases.UpdateCanvasVersion:input_type -> Superplane.Canvases.UpdateCanvasVersionRequest - 21, // 103: Superplane.Canvases.Canvases.CreateCanvasChangeRequest:input_type -> Superplane.Canvases.CreateCanvasChangeRequestRequest - 23, // 104: Superplane.Canvases.Canvases.ListCanvasChangeRequests:input_type -> Superplane.Canvases.ListCanvasChangeRequestsRequest - 25, // 105: Superplane.Canvases.Canvases.DescribeCanvasChangeRequest:input_type -> Superplane.Canvases.DescribeCanvasChangeRequestRequest - 27, // 106: Superplane.Canvases.Canvases.DeleteCanvas:input_type -> Superplane.Canvases.DeleteCanvasRequest - 38, // 107: Superplane.Canvases.Canvases.ListNodeQueueItems:input_type -> Superplane.Canvases.ListNodeQueueItemsRequest - 40, // 108: Superplane.Canvases.Canvases.DeleteNodeQueueItem:input_type -> Superplane.Canvases.DeleteNodeQueueItemRequest - 42, // 109: Superplane.Canvases.Canvases.UpdateNodePause:input_type -> Superplane.Canvases.UpdateNodePauseRequest - 44, // 110: Superplane.Canvases.Canvases.ListNodeExecutions:input_type -> Superplane.Canvases.ListNodeExecutionsRequest - 34, // 111: Superplane.Canvases.Canvases.ListNodeEvents:input_type -> Superplane.Canvases.ListNodeEventsRequest - 36, // 112: Superplane.Canvases.Canvases.EmitNodeEvent:input_type -> Superplane.Canvases.EmitNodeEventRequest - 50, // 113: Superplane.Canvases.Canvases.InvokeNodeExecutionAction:input_type -> Superplane.Canvases.InvokeNodeExecutionActionRequest - 52, // 114: Superplane.Canvases.Canvases.InvokeNodeTriggerAction:input_type -> Superplane.Canvases.InvokeNodeTriggerActionRequest - 46, // 115: Superplane.Canvases.Canvases.ListChildExecutions:input_type -> Superplane.Canvases.ListChildExecutionsRequest - 65, // 116: Superplane.Canvases.Canvases.CancelExecution:input_type -> Superplane.Canvases.CancelExecutionRequest - 67, // 117: Superplane.Canvases.Canvases.ResolveExecutionErrors:input_type -> Superplane.Canvases.ResolveExecutionErrorsRequest - 54, // 118: Superplane.Canvases.Canvases.ListCanvasEvents:input_type -> Superplane.Canvases.ListCanvasEventsRequest - 57, // 119: Superplane.Canvases.Canvases.ListCanvasMemories:input_type -> Superplane.Canvases.ListCanvasMemoriesRequest - 59, // 120: Superplane.Canvases.Canvases.DeleteCanvasMemory:input_type -> Superplane.Canvases.DeleteCanvasMemoryRequest - 63, // 121: Superplane.Canvases.Canvases.ListEventExecutions:input_type -> Superplane.Canvases.ListEventExecutionsRequest - 72, // 122: Superplane.Canvases.Canvases.SendAiMessage:input_type -> Superplane.Canvases.SendAiMessageRequest - 7, // 123: Superplane.Canvases.Canvases.ListCanvases:output_type -> Superplane.Canvases.ListCanvasesResponse - 11, // 124: Superplane.Canvases.Canvases.CreateCanvas:output_type -> Superplane.Canvases.CreateCanvasResponse - 9, // 125: Superplane.Canvases.Canvases.DescribeCanvas:output_type -> Superplane.Canvases.DescribeCanvasResponse - 14, // 126: Superplane.Canvases.Canvases.CreateCanvasVersion:output_type -> Superplane.Canvases.CreateCanvasVersionResponse - 16, // 127: Superplane.Canvases.Canvases.ListCanvasVersions:output_type -> Superplane.Canvases.ListCanvasVersionsResponse - 18, // 128: Superplane.Canvases.Canvases.DescribeCanvasVersion:output_type -> Superplane.Canvases.DescribeCanvasVersionResponse - 20, // 129: Superplane.Canvases.Canvases.UpdateCanvasVersion:output_type -> Superplane.Canvases.UpdateCanvasVersionResponse - 22, // 130: Superplane.Canvases.Canvases.CreateCanvasChangeRequest:output_type -> Superplane.Canvases.CreateCanvasChangeRequestResponse - 24, // 131: Superplane.Canvases.Canvases.ListCanvasChangeRequests:output_type -> Superplane.Canvases.ListCanvasChangeRequestsResponse - 26, // 132: Superplane.Canvases.Canvases.DescribeCanvasChangeRequest:output_type -> Superplane.Canvases.DescribeCanvasChangeRequestResponse - 28, // 133: Superplane.Canvases.Canvases.DeleteCanvas:output_type -> Superplane.Canvases.DeleteCanvasResponse - 39, // 134: Superplane.Canvases.Canvases.ListNodeQueueItems:output_type -> Superplane.Canvases.ListNodeQueueItemsResponse - 41, // 135: Superplane.Canvases.Canvases.DeleteNodeQueueItem:output_type -> Superplane.Canvases.DeleteNodeQueueItemResponse - 43, // 136: Superplane.Canvases.Canvases.UpdateNodePause:output_type -> Superplane.Canvases.UpdateNodePauseResponse - 45, // 137: Superplane.Canvases.Canvases.ListNodeExecutions:output_type -> Superplane.Canvases.ListNodeExecutionsResponse - 35, // 138: Superplane.Canvases.Canvases.ListNodeEvents:output_type -> Superplane.Canvases.ListNodeEventsResponse - 37, // 139: Superplane.Canvases.Canvases.EmitNodeEvent:output_type -> Superplane.Canvases.EmitNodeEventResponse - 51, // 140: Superplane.Canvases.Canvases.InvokeNodeExecutionAction:output_type -> Superplane.Canvases.InvokeNodeExecutionActionResponse - 53, // 141: Superplane.Canvases.Canvases.InvokeNodeTriggerAction:output_type -> Superplane.Canvases.InvokeNodeTriggerActionResponse - 47, // 142: Superplane.Canvases.Canvases.ListChildExecutions:output_type -> Superplane.Canvases.ListChildExecutionsResponse - 66, // 143: Superplane.Canvases.Canvases.CancelExecution:output_type -> Superplane.Canvases.CancelExecutionResponse - 68, // 144: Superplane.Canvases.Canvases.ResolveExecutionErrors:output_type -> Superplane.Canvases.ResolveExecutionErrorsResponse - 55, // 145: Superplane.Canvases.Canvases.ListCanvasEvents:output_type -> Superplane.Canvases.ListCanvasEventsResponse - 58, // 146: Superplane.Canvases.Canvases.ListCanvasMemories:output_type -> Superplane.Canvases.ListCanvasMemoriesResponse - 60, // 147: Superplane.Canvases.Canvases.DeleteCanvasMemory:output_type -> Superplane.Canvases.DeleteCanvasMemoryResponse - 64, // 148: Superplane.Canvases.Canvases.ListEventExecutions:output_type -> Superplane.Canvases.ListEventExecutionsResponse - 73, // 149: Superplane.Canvases.Canvases.SendAiMessage:output_type -> Superplane.Canvases.SendAiMessageResponse - 123, // [123:150] is the sub-list for method output_type - 96, // [96:123] is the sub-list for method input_type - 96, // [96:96] is the sub-list for extension type_name - 96, // [96:96] is the sub-list for extension extendee - 0, // [0:96] is the sub-list for field type_name + 32, // 0: Superplane.Canvases.ListCanvasesResponse.canvases:type_name -> Superplane.Canvases.Canvas + 32, // 1: Superplane.Canvases.DescribeCanvasResponse.canvas:type_name -> Superplane.Canvases.Canvas + 32, // 2: Superplane.Canvases.UpdateCanvasResponse.canvas:type_name -> Superplane.Canvases.Canvas + 32, // 3: Superplane.Canvases.CreateCanvasRequest.canvas:type_name -> Superplane.Canvases.Canvas + 32, // 4: Superplane.Canvases.CreateCanvasResponse.canvas:type_name -> Superplane.Canvases.Canvas + 0, // 5: Superplane.Canvases.CanvasAutoLayout.algorithm:type_name -> Superplane.Canvases.CanvasAutoLayout.Algorithm + 1, // 6: Superplane.Canvases.CanvasAutoLayout.scope:type_name -> Superplane.Canvases.CanvasAutoLayout.Scope + 33, // 7: Superplane.Canvases.CreateCanvasVersionResponse.version:type_name -> Superplane.Canvases.CanvasVersion + 86, // 8: Superplane.Canvases.ListCanvasVersionsRequest.before:type_name -> google.protobuf.Timestamp + 33, // 9: Superplane.Canvases.ListCanvasVersionsResponse.versions:type_name -> Superplane.Canvases.CanvasVersion + 86, // 10: Superplane.Canvases.ListCanvasVersionsResponse.last_timestamp:type_name -> google.protobuf.Timestamp + 33, // 11: Superplane.Canvases.DescribeCanvasVersionResponse.version:type_name -> Superplane.Canvases.CanvasVersion + 32, // 12: Superplane.Canvases.UpdateCanvasVersionRequest.canvas:type_name -> Superplane.Canvases.Canvas + 14, // 13: Superplane.Canvases.UpdateCanvasVersionRequest.auto_layout:type_name -> Superplane.Canvases.CanvasAutoLayout + 33, // 14: Superplane.Canvases.UpdateCanvasVersionResponse.version:type_name -> Superplane.Canvases.CanvasVersion + 35, // 15: Superplane.Canvases.CreateCanvasChangeRequestResponse.change_request:type_name -> Superplane.Canvases.CanvasChangeRequest + 86, // 16: Superplane.Canvases.ListCanvasChangeRequestsRequest.before:type_name -> google.protobuf.Timestamp + 35, // 17: Superplane.Canvases.ListCanvasChangeRequestsResponse.change_requests:type_name -> Superplane.Canvases.CanvasChangeRequest + 86, // 18: Superplane.Canvases.ListCanvasChangeRequestsResponse.last_timestamp:type_name -> google.protobuf.Timestamp + 35, // 19: Superplane.Canvases.DescribeCanvasChangeRequestResponse.change_request:type_name -> Superplane.Canvases.CanvasChangeRequest + 81, // 20: Superplane.Canvases.Canvas.metadata:type_name -> Superplane.Canvases.Canvas.Metadata + 82, // 21: Superplane.Canvases.Canvas.spec:type_name -> Superplane.Canvases.Canvas.Spec + 83, // 22: Superplane.Canvases.Canvas.status:type_name -> Superplane.Canvases.Canvas.Status + 84, // 23: Superplane.Canvases.CanvasVersion.metadata:type_name -> Superplane.Canvases.CanvasVersion.Metadata + 82, // 24: Superplane.Canvases.CanvasVersion.spec:type_name -> Superplane.Canvases.Canvas.Spec + 85, // 25: Superplane.Canvases.CanvasChangeRequest.metadata:type_name -> Superplane.Canvases.CanvasChangeRequest.Metadata + 33, // 26: Superplane.Canvases.CanvasChangeRequest.version:type_name -> Superplane.Canvases.CanvasVersion + 34, // 27: Superplane.Canvases.CanvasChangeRequest.diff:type_name -> Superplane.Canvases.CanvasChangeRequestDiff + 86, // 28: Superplane.Canvases.ListNodeEventsRequest.before:type_name -> google.protobuf.Timestamp + 63, // 29: Superplane.Canvases.ListNodeEventsResponse.events:type_name -> Superplane.Canvases.CanvasEvent + 86, // 30: Superplane.Canvases.ListNodeEventsResponse.last_timestamp:type_name -> google.protobuf.Timestamp + 87, // 31: Superplane.Canvases.EmitNodeEventRequest.data:type_name -> google.protobuf.Struct + 86, // 32: Superplane.Canvases.ListNodeQueueItemsRequest.before:type_name -> google.protobuf.Timestamp + 51, // 33: Superplane.Canvases.ListNodeQueueItemsResponse.items:type_name -> Superplane.Canvases.CanvasNodeQueueItem + 86, // 34: Superplane.Canvases.ListNodeQueueItemsResponse.last_timestamp:type_name -> google.protobuf.Timestamp + 88, // 35: Superplane.Canvases.UpdateNodePauseResponse.node:type_name -> Superplane.Components.Node + 3, // 36: Superplane.Canvases.ListNodeExecutionsRequest.states:type_name -> Superplane.Canvases.CanvasNodeExecution.State + 4, // 37: Superplane.Canvases.ListNodeExecutionsRequest.results:type_name -> Superplane.Canvases.CanvasNodeExecution.Result + 86, // 38: Superplane.Canvases.ListNodeExecutionsRequest.before:type_name -> google.protobuf.Timestamp + 50, // 39: Superplane.Canvases.ListNodeExecutionsResponse.executions:type_name -> Superplane.Canvases.CanvasNodeExecution + 86, // 40: Superplane.Canvases.ListNodeExecutionsResponse.last_timestamp:type_name -> google.protobuf.Timestamp + 50, // 41: Superplane.Canvases.ListChildExecutionsResponse.executions:type_name -> Superplane.Canvases.CanvasNodeExecution + 3, // 42: Superplane.Canvases.CanvasNodeExecution.state:type_name -> Superplane.Canvases.CanvasNodeExecution.State + 4, // 43: Superplane.Canvases.CanvasNodeExecution.result:type_name -> Superplane.Canvases.CanvasNodeExecution.Result + 5, // 44: Superplane.Canvases.CanvasNodeExecution.result_reason:type_name -> Superplane.Canvases.CanvasNodeExecution.ResultReason + 87, // 45: Superplane.Canvases.CanvasNodeExecution.input:type_name -> google.protobuf.Struct + 87, // 46: Superplane.Canvases.CanvasNodeExecution.outputs:type_name -> google.protobuf.Struct + 86, // 47: Superplane.Canvases.CanvasNodeExecution.created_at:type_name -> google.protobuf.Timestamp + 86, // 48: Superplane.Canvases.CanvasNodeExecution.updated_at:type_name -> google.protobuf.Timestamp + 87, // 49: Superplane.Canvases.CanvasNodeExecution.metadata:type_name -> google.protobuf.Struct + 87, // 50: Superplane.Canvases.CanvasNodeExecution.configuration:type_name -> google.protobuf.Struct + 50, // 51: Superplane.Canvases.CanvasNodeExecution.child_executions:type_name -> Superplane.Canvases.CanvasNodeExecution + 63, // 52: Superplane.Canvases.CanvasNodeExecution.root_event:type_name -> Superplane.Canvases.CanvasEvent + 31, // 53: Superplane.Canvases.CanvasNodeExecution.cancelled_by:type_name -> Superplane.Canvases.UserRef + 87, // 54: Superplane.Canvases.CanvasNodeQueueItem.input:type_name -> google.protobuf.Struct + 63, // 55: Superplane.Canvases.CanvasNodeQueueItem.root_event:type_name -> Superplane.Canvases.CanvasEvent + 86, // 56: Superplane.Canvases.CanvasNodeQueueItem.created_at:type_name -> google.protobuf.Timestamp + 87, // 57: Superplane.Canvases.InvokeNodeExecutionActionRequest.parameters:type_name -> google.protobuf.Struct + 87, // 58: Superplane.Canvases.InvokeNodeTriggerActionRequest.parameters:type_name -> google.protobuf.Struct + 87, // 59: Superplane.Canvases.InvokeNodeTriggerActionResponse.result:type_name -> google.protobuf.Struct + 86, // 60: Superplane.Canvases.ListCanvasEventsRequest.before:type_name -> google.protobuf.Timestamp + 64, // 61: Superplane.Canvases.ListCanvasEventsResponse.events:type_name -> Superplane.Canvases.CanvasEventWithExecutions + 86, // 62: Superplane.Canvases.ListCanvasEventsResponse.last_timestamp:type_name -> google.protobuf.Timestamp + 89, // 63: Superplane.Canvases.CanvasMemory.values:type_name -> google.protobuf.Value + 58, // 64: Superplane.Canvases.ListCanvasMemoriesResponse.items:type_name -> Superplane.Canvases.CanvasMemory + 87, // 65: Superplane.Canvases.CanvasEvent.data:type_name -> google.protobuf.Struct + 86, // 66: Superplane.Canvases.CanvasEvent.created_at:type_name -> google.protobuf.Timestamp + 87, // 67: Superplane.Canvases.CanvasEventWithExecutions.data:type_name -> google.protobuf.Struct + 86, // 68: Superplane.Canvases.CanvasEventWithExecutions.created_at:type_name -> google.protobuf.Timestamp + 50, // 69: Superplane.Canvases.CanvasEventWithExecutions.executions:type_name -> Superplane.Canvases.CanvasNodeExecution + 50, // 70: Superplane.Canvases.ListEventExecutionsResponse.executions:type_name -> Superplane.Canvases.CanvasNodeExecution + 71, // 71: Superplane.Canvases.CanvasAiContext.nodes:type_name -> Superplane.Canvases.CanvasAiNodeContext + 72, // 72: Superplane.Canvases.CanvasAiContext.available_blocks:type_name -> Superplane.Canvases.CanvasAiBlockContext + 73, // 73: Superplane.Canvases.SendAiMessageRequest.canvas_context:type_name -> Superplane.Canvases.CanvasAiContext + 87, // 74: Superplane.Canvases.SendAiMessageResponse.operations:type_name -> google.protobuf.Struct + 86, // 75: Superplane.Canvases.CanvasNodeEventMessage.timestamp:type_name -> google.protobuf.Timestamp + 86, // 76: Superplane.Canvases.CanvasNodeExecutionMessage.timestamp:type_name -> google.protobuf.Timestamp + 86, // 77: Superplane.Canvases.CanvasNodeQueueItemMessage.timestamp:type_name -> google.protobuf.Timestamp + 86, // 78: Superplane.Canvases.CanvasMessage.timestamp:type_name -> google.protobuf.Timestamp + 86, // 79: Superplane.Canvases.CanvasVersionMessage.timestamp:type_name -> google.protobuf.Timestamp + 86, // 80: Superplane.Canvases.Canvas.Metadata.created_at:type_name -> google.protobuf.Timestamp + 86, // 81: Superplane.Canvases.Canvas.Metadata.updated_at:type_name -> google.protobuf.Timestamp + 31, // 82: Superplane.Canvases.Canvas.Metadata.created_by:type_name -> Superplane.Canvases.UserRef + 88, // 83: Superplane.Canvases.Canvas.Spec.nodes:type_name -> Superplane.Components.Node + 90, // 84: Superplane.Canvases.Canvas.Spec.edges:type_name -> Superplane.Components.Edge + 50, // 85: Superplane.Canvases.Canvas.Status.last_executions:type_name -> Superplane.Canvases.CanvasNodeExecution + 51, // 86: Superplane.Canvases.Canvas.Status.next_queue_items:type_name -> Superplane.Canvases.CanvasNodeQueueItem + 63, // 87: Superplane.Canvases.Canvas.Status.last_events:type_name -> Superplane.Canvases.CanvasEvent + 31, // 88: Superplane.Canvases.CanvasVersion.Metadata.owner:type_name -> Superplane.Canvases.UserRef + 86, // 89: Superplane.Canvases.CanvasVersion.Metadata.published_at:type_name -> google.protobuf.Timestamp + 86, // 90: Superplane.Canvases.CanvasVersion.Metadata.created_at:type_name -> google.protobuf.Timestamp + 86, // 91: Superplane.Canvases.CanvasVersion.Metadata.updated_at:type_name -> google.protobuf.Timestamp + 31, // 92: Superplane.Canvases.CanvasChangeRequest.Metadata.owner:type_name -> Superplane.Canvases.UserRef + 2, // 93: Superplane.Canvases.CanvasChangeRequest.Metadata.status:type_name -> Superplane.Canvases.CanvasChangeRequest.Status + 86, // 94: Superplane.Canvases.CanvasChangeRequest.Metadata.published_at:type_name -> google.protobuf.Timestamp + 86, // 95: Superplane.Canvases.CanvasChangeRequest.Metadata.created_at:type_name -> google.protobuf.Timestamp + 86, // 96: Superplane.Canvases.CanvasChangeRequest.Metadata.updated_at:type_name -> google.protobuf.Timestamp + 6, // 97: Superplane.Canvases.Canvases.ListCanvases:input_type -> Superplane.Canvases.ListCanvasesRequest + 12, // 98: Superplane.Canvases.Canvases.CreateCanvas:input_type -> Superplane.Canvases.CreateCanvasRequest + 8, // 99: Superplane.Canvases.Canvases.DescribeCanvas:input_type -> Superplane.Canvases.DescribeCanvasRequest + 10, // 100: Superplane.Canvases.Canvases.UpdateCanvas:input_type -> Superplane.Canvases.UpdateCanvasRequest + 15, // 101: Superplane.Canvases.Canvases.CreateCanvasVersion:input_type -> Superplane.Canvases.CreateCanvasVersionRequest + 17, // 102: Superplane.Canvases.Canvases.ListCanvasVersions:input_type -> Superplane.Canvases.ListCanvasVersionsRequest + 19, // 103: Superplane.Canvases.Canvases.DescribeCanvasVersion:input_type -> Superplane.Canvases.DescribeCanvasVersionRequest + 21, // 104: Superplane.Canvases.Canvases.UpdateCanvasVersion:input_type -> Superplane.Canvases.UpdateCanvasVersionRequest + 23, // 105: Superplane.Canvases.Canvases.CreateCanvasChangeRequest:input_type -> Superplane.Canvases.CreateCanvasChangeRequestRequest + 25, // 106: Superplane.Canvases.Canvases.ListCanvasChangeRequests:input_type -> Superplane.Canvases.ListCanvasChangeRequestsRequest + 27, // 107: Superplane.Canvases.Canvases.DescribeCanvasChangeRequest:input_type -> Superplane.Canvases.DescribeCanvasChangeRequestRequest + 29, // 108: Superplane.Canvases.Canvases.DeleteCanvas:input_type -> Superplane.Canvases.DeleteCanvasRequest + 40, // 109: Superplane.Canvases.Canvases.ListNodeQueueItems:input_type -> Superplane.Canvases.ListNodeQueueItemsRequest + 42, // 110: Superplane.Canvases.Canvases.DeleteNodeQueueItem:input_type -> Superplane.Canvases.DeleteNodeQueueItemRequest + 44, // 111: Superplane.Canvases.Canvases.UpdateNodePause:input_type -> Superplane.Canvases.UpdateNodePauseRequest + 46, // 112: Superplane.Canvases.Canvases.ListNodeExecutions:input_type -> Superplane.Canvases.ListNodeExecutionsRequest + 36, // 113: Superplane.Canvases.Canvases.ListNodeEvents:input_type -> Superplane.Canvases.ListNodeEventsRequest + 38, // 114: Superplane.Canvases.Canvases.EmitNodeEvent:input_type -> Superplane.Canvases.EmitNodeEventRequest + 52, // 115: Superplane.Canvases.Canvases.InvokeNodeExecutionAction:input_type -> Superplane.Canvases.InvokeNodeExecutionActionRequest + 54, // 116: Superplane.Canvases.Canvases.InvokeNodeTriggerAction:input_type -> Superplane.Canvases.InvokeNodeTriggerActionRequest + 48, // 117: Superplane.Canvases.Canvases.ListChildExecutions:input_type -> Superplane.Canvases.ListChildExecutionsRequest + 67, // 118: Superplane.Canvases.Canvases.CancelExecution:input_type -> Superplane.Canvases.CancelExecutionRequest + 69, // 119: Superplane.Canvases.Canvases.ResolveExecutionErrors:input_type -> Superplane.Canvases.ResolveExecutionErrorsRequest + 56, // 120: Superplane.Canvases.Canvases.ListCanvasEvents:input_type -> Superplane.Canvases.ListCanvasEventsRequest + 59, // 121: Superplane.Canvases.Canvases.ListCanvasMemories:input_type -> Superplane.Canvases.ListCanvasMemoriesRequest + 61, // 122: Superplane.Canvases.Canvases.DeleteCanvasMemory:input_type -> Superplane.Canvases.DeleteCanvasMemoryRequest + 65, // 123: Superplane.Canvases.Canvases.ListEventExecutions:input_type -> Superplane.Canvases.ListEventExecutionsRequest + 74, // 124: Superplane.Canvases.Canvases.SendAiMessage:input_type -> Superplane.Canvases.SendAiMessageRequest + 7, // 125: Superplane.Canvases.Canvases.ListCanvases:output_type -> Superplane.Canvases.ListCanvasesResponse + 13, // 126: Superplane.Canvases.Canvases.CreateCanvas:output_type -> Superplane.Canvases.CreateCanvasResponse + 9, // 127: Superplane.Canvases.Canvases.DescribeCanvas:output_type -> Superplane.Canvases.DescribeCanvasResponse + 11, // 128: Superplane.Canvases.Canvases.UpdateCanvas:output_type -> Superplane.Canvases.UpdateCanvasResponse + 16, // 129: Superplane.Canvases.Canvases.CreateCanvasVersion:output_type -> Superplane.Canvases.CreateCanvasVersionResponse + 18, // 130: Superplane.Canvases.Canvases.ListCanvasVersions:output_type -> Superplane.Canvases.ListCanvasVersionsResponse + 20, // 131: Superplane.Canvases.Canvases.DescribeCanvasVersion:output_type -> Superplane.Canvases.DescribeCanvasVersionResponse + 22, // 132: Superplane.Canvases.Canvases.UpdateCanvasVersion:output_type -> Superplane.Canvases.UpdateCanvasVersionResponse + 24, // 133: Superplane.Canvases.Canvases.CreateCanvasChangeRequest:output_type -> Superplane.Canvases.CreateCanvasChangeRequestResponse + 26, // 134: Superplane.Canvases.Canvases.ListCanvasChangeRequests:output_type -> Superplane.Canvases.ListCanvasChangeRequestsResponse + 28, // 135: Superplane.Canvases.Canvases.DescribeCanvasChangeRequest:output_type -> Superplane.Canvases.DescribeCanvasChangeRequestResponse + 30, // 136: Superplane.Canvases.Canvases.DeleteCanvas:output_type -> Superplane.Canvases.DeleteCanvasResponse + 41, // 137: Superplane.Canvases.Canvases.ListNodeQueueItems:output_type -> Superplane.Canvases.ListNodeQueueItemsResponse + 43, // 138: Superplane.Canvases.Canvases.DeleteNodeQueueItem:output_type -> Superplane.Canvases.DeleteNodeQueueItemResponse + 45, // 139: Superplane.Canvases.Canvases.UpdateNodePause:output_type -> Superplane.Canvases.UpdateNodePauseResponse + 47, // 140: Superplane.Canvases.Canvases.ListNodeExecutions:output_type -> Superplane.Canvases.ListNodeExecutionsResponse + 37, // 141: Superplane.Canvases.Canvases.ListNodeEvents:output_type -> Superplane.Canvases.ListNodeEventsResponse + 39, // 142: Superplane.Canvases.Canvases.EmitNodeEvent:output_type -> Superplane.Canvases.EmitNodeEventResponse + 53, // 143: Superplane.Canvases.Canvases.InvokeNodeExecutionAction:output_type -> Superplane.Canvases.InvokeNodeExecutionActionResponse + 55, // 144: Superplane.Canvases.Canvases.InvokeNodeTriggerAction:output_type -> Superplane.Canvases.InvokeNodeTriggerActionResponse + 49, // 145: Superplane.Canvases.Canvases.ListChildExecutions:output_type -> Superplane.Canvases.ListChildExecutionsResponse + 68, // 146: Superplane.Canvases.Canvases.CancelExecution:output_type -> Superplane.Canvases.CancelExecutionResponse + 70, // 147: Superplane.Canvases.Canvases.ResolveExecutionErrors:output_type -> Superplane.Canvases.ResolveExecutionErrorsResponse + 57, // 148: Superplane.Canvases.Canvases.ListCanvasEvents:output_type -> Superplane.Canvases.ListCanvasEventsResponse + 60, // 149: Superplane.Canvases.Canvases.ListCanvasMemories:output_type -> Superplane.Canvases.ListCanvasMemoriesResponse + 62, // 150: Superplane.Canvases.Canvases.DeleteCanvasMemory:output_type -> Superplane.Canvases.DeleteCanvasMemoryResponse + 66, // 151: Superplane.Canvases.Canvases.ListEventExecutions:output_type -> Superplane.Canvases.ListEventExecutionsResponse + 75, // 152: Superplane.Canvases.Canvases.SendAiMessage:output_type -> Superplane.Canvases.SendAiMessageResponse + 125, // [125:153] is the sub-list for method output_type + 97, // [97:125] is the sub-list for method input_type + 97, // [97:97] is the sub-list for extension type_name + 97, // [97:97] is the sub-list for extension extendee + 0, // [0:97] is the sub-list for field type_name } func init() { file_canvases_proto_init() } @@ -5677,13 +5815,14 @@ func file_canvases_proto_init() { if File_canvases_proto != nil { return } + file_canvases_proto_msgTypes[4].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_canvases_proto_rawDesc), len(file_canvases_proto_rawDesc)), NumEnums: 6, - NumMessages: 78, + NumMessages: 80, NumExtensions: 0, NumServices: 1, }, diff --git a/pkg/protos/canvases/canvases.pb.gw.go b/pkg/protos/canvases/canvases.pb.gw.go index e35f18dda3..fcee316d8e 100644 --- a/pkg/protos/canvases/canvases.pb.gw.go +++ b/pkg/protos/canvases/canvases.pb.gw.go @@ -129,6 +129,48 @@ func local_request_Canvases_DescribeCanvas_0(ctx context.Context, marshaler runt return msg, metadata, err } +func request_Canvases_UpdateCanvas_0(ctx context.Context, marshaler runtime.Marshaler, client CanvasesClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq UpdateCanvasRequest + metadata runtime.ServerMetadata + err error + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + protoReq.Id, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + msg, err := client.UpdateCanvas(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_Canvases_UpdateCanvas_0(ctx context.Context, marshaler runtime.Marshaler, server CanvasesServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq UpdateCanvasRequest + metadata runtime.ServerMetadata + err error + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + protoReq.Id, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + msg, err := server.UpdateCanvas(ctx, &protoReq) + return msg, metadata, err +} + func request_Canvases_CreateCanvasVersion_0(ctx context.Context, marshaler runtime.Marshaler, client CanvasesClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var ( protoReq CreateCanvasVersionRequest @@ -1552,6 +1594,26 @@ func RegisterCanvasesHandlerServer(ctx context.Context, mux *runtime.ServeMux, s } forward_Canvases_DescribeCanvas_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) + mux.Handle(http.MethodPut, pattern_Canvases_UpdateCanvas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/Superplane.Canvases.Canvases/UpdateCanvas", runtime.WithHTTPPathPattern("/api/v1/canvases/{id}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Canvases_UpdateCanvas_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_Canvases_UpdateCanvas_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) mux.Handle(http.MethodPost, pattern_Canvases_CreateCanvasVersion_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -2143,6 +2205,23 @@ func RegisterCanvasesHandlerClient(ctx context.Context, mux *runtime.ServeMux, c } forward_Canvases_DescribeCanvas_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) + mux.Handle(http.MethodPut, pattern_Canvases_UpdateCanvas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/Superplane.Canvases.Canvases/UpdateCanvas", runtime.WithHTTPPathPattern("/api/v1/canvases/{id}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Canvases_UpdateCanvas_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_Canvases_UpdateCanvas_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) mux.Handle(http.MethodPost, pattern_Canvases_CreateCanvasVersion_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -2575,6 +2654,7 @@ var ( pattern_Canvases_ListCanvases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "canvases"}, "")) pattern_Canvases_CreateCanvas_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "canvases"}, "")) pattern_Canvases_DescribeCanvas_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "v1", "canvases", "id"}, "")) + pattern_Canvases_UpdateCanvas_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "v1", "canvases", "id"}, "")) pattern_Canvases_CreateCanvasVersion_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "canvases", "canvas_id", "versions"}, "")) pattern_Canvases_ListCanvasVersions_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"api", "v1", "canvases", "canvas_id", "versions"}, "")) pattern_Canvases_DescribeCanvasVersion_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"api", "v1", "canvases", "canvas_id", "versions", "version_id"}, "")) @@ -2606,6 +2686,7 @@ var ( forward_Canvases_ListCanvases_0 = runtime.ForwardResponseMessage forward_Canvases_CreateCanvas_0 = runtime.ForwardResponseMessage forward_Canvases_DescribeCanvas_0 = runtime.ForwardResponseMessage + forward_Canvases_UpdateCanvas_0 = runtime.ForwardResponseMessage forward_Canvases_CreateCanvasVersion_0 = runtime.ForwardResponseMessage forward_Canvases_ListCanvasVersions_0 = runtime.ForwardResponseMessage forward_Canvases_DescribeCanvasVersion_0 = runtime.ForwardResponseMessage diff --git a/pkg/protos/canvases/canvases_grpc.pb.go b/pkg/protos/canvases/canvases_grpc.pb.go index 4ef3933149..2fce92cdc2 100644 --- a/pkg/protos/canvases/canvases_grpc.pb.go +++ b/pkg/protos/canvases/canvases_grpc.pb.go @@ -22,6 +22,7 @@ const ( Canvases_ListCanvases_FullMethodName = "/Superplane.Canvases.Canvases/ListCanvases" Canvases_CreateCanvas_FullMethodName = "/Superplane.Canvases.Canvases/CreateCanvas" Canvases_DescribeCanvas_FullMethodName = "/Superplane.Canvases.Canvases/DescribeCanvas" + Canvases_UpdateCanvas_FullMethodName = "/Superplane.Canvases.Canvases/UpdateCanvas" Canvases_CreateCanvasVersion_FullMethodName = "/Superplane.Canvases.Canvases/CreateCanvasVersion" Canvases_ListCanvasVersions_FullMethodName = "/Superplane.Canvases.Canvases/ListCanvasVersions" Canvases_DescribeCanvasVersion_FullMethodName = "/Superplane.Canvases.Canvases/DescribeCanvasVersion" @@ -55,6 +56,7 @@ type CanvasesClient interface { ListCanvases(ctx context.Context, in *ListCanvasesRequest, opts ...grpc.CallOption) (*ListCanvasesResponse, error) CreateCanvas(ctx context.Context, in *CreateCanvasRequest, opts ...grpc.CallOption) (*CreateCanvasResponse, error) DescribeCanvas(ctx context.Context, in *DescribeCanvasRequest, opts ...grpc.CallOption) (*DescribeCanvasResponse, error) + UpdateCanvas(ctx context.Context, in *UpdateCanvasRequest, opts ...grpc.CallOption) (*UpdateCanvasResponse, error) CreateCanvasVersion(ctx context.Context, in *CreateCanvasVersionRequest, opts ...grpc.CallOption) (*CreateCanvasVersionResponse, error) ListCanvasVersions(ctx context.Context, in *ListCanvasVersionsRequest, opts ...grpc.CallOption) (*ListCanvasVersionsResponse, error) DescribeCanvasVersion(ctx context.Context, in *DescribeCanvasVersionRequest, opts ...grpc.CallOption) (*DescribeCanvasVersionResponse, error) @@ -119,6 +121,16 @@ func (c *canvasesClient) DescribeCanvas(ctx context.Context, in *DescribeCanvasR return out, nil } +func (c *canvasesClient) UpdateCanvas(ctx context.Context, in *UpdateCanvasRequest, opts ...grpc.CallOption) (*UpdateCanvasResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(UpdateCanvasResponse) + err := c.cc.Invoke(ctx, Canvases_UpdateCanvas_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *canvasesClient) CreateCanvasVersion(ctx context.Context, in *CreateCanvasVersionRequest, opts ...grpc.CallOption) (*CreateCanvasVersionResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CreateCanvasVersionResponse) @@ -366,6 +378,7 @@ type CanvasesServer interface { ListCanvases(context.Context, *ListCanvasesRequest) (*ListCanvasesResponse, error) CreateCanvas(context.Context, *CreateCanvasRequest) (*CreateCanvasResponse, error) DescribeCanvas(context.Context, *DescribeCanvasRequest) (*DescribeCanvasResponse, error) + UpdateCanvas(context.Context, *UpdateCanvasRequest) (*UpdateCanvasResponse, error) CreateCanvasVersion(context.Context, *CreateCanvasVersionRequest) (*CreateCanvasVersionResponse, error) ListCanvasVersions(context.Context, *ListCanvasVersionsRequest) (*ListCanvasVersionsResponse, error) DescribeCanvasVersion(context.Context, *DescribeCanvasVersionRequest) (*DescribeCanvasVersionResponse, error) @@ -408,6 +421,9 @@ func (UnimplementedCanvasesServer) CreateCanvas(context.Context, *CreateCanvasRe func (UnimplementedCanvasesServer) DescribeCanvas(context.Context, *DescribeCanvasRequest) (*DescribeCanvasResponse, error) { return nil, status.Error(codes.Unimplemented, "method DescribeCanvas not implemented") } +func (UnimplementedCanvasesServer) UpdateCanvas(context.Context, *UpdateCanvasRequest) (*UpdateCanvasResponse, error) { + return nil, status.Error(codes.Unimplemented, "method UpdateCanvas not implemented") +} func (UnimplementedCanvasesServer) CreateCanvasVersion(context.Context, *CreateCanvasVersionRequest) (*CreateCanvasVersionResponse, error) { return nil, status.Error(codes.Unimplemented, "method CreateCanvasVersion not implemented") } @@ -554,6 +570,24 @@ func _Canvases_DescribeCanvas_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _Canvases_UpdateCanvas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateCanvasRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CanvasesServer).UpdateCanvas(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Canvases_UpdateCanvas_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CanvasesServer).UpdateCanvas(ctx, req.(*UpdateCanvasRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Canvases_CreateCanvasVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CreateCanvasVersionRequest) if err := dec(in); err != nil { @@ -1005,6 +1039,10 @@ var Canvases_ServiceDesc = grpc.ServiceDesc{ MethodName: "DescribeCanvas", Handler: _Canvases_DescribeCanvas_Handler, }, + { + MethodName: "UpdateCanvas", + Handler: _Canvases_UpdateCanvas_Handler, + }, { MethodName: "CreateCanvasVersion", Handler: _Canvases_CreateCanvasVersion_Handler, diff --git a/pkg/protos/organizations/organizations.pb.go b/pkg/protos/organizations/organizations.pb.go index 2ad513af04..d2546fbf2e 100644 --- a/pkg/protos/organizations/organizations.pb.go +++ b/pkg/protos/organizations/organizations.pb.go @@ -2659,15 +2659,15 @@ func (x *InvitationCreated) GetTimestamp() *timestamp.Timestamp { } type Organization_Metadata struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` - CreatedAt *timestamp.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` - UpdatedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` - CanvasSandboxModeEnabled *bool `protobuf:"varint,6,opt,name=canvas_sandbox_mode_enabled,json=canvasSandboxModeEnabled,proto3,oneof" json:"canvas_sandbox_mode_enabled,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + CreatedAt *timestamp.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + UpdatedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` + CanvasVersioningEnabled *bool `protobuf:"varint,6,opt,name=canvas_versioning_enabled,json=canvasVersioningEnabled,proto3,oneof" json:"canvas_versioning_enabled,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *Organization_Metadata) Reset() { @@ -2735,9 +2735,9 @@ func (x *Organization_Metadata) GetUpdatedAt() *timestamp.Timestamp { return nil } -func (x *Organization_Metadata) GetCanvasSandboxModeEnabled() bool { - if x != nil && x.CanvasSandboxModeEnabled != nil { - return *x.CanvasSandboxModeEnabled +func (x *Organization_Metadata) GetCanvasVersioningEnabled() bool { + if x != nil && x.CanvasVersioningEnabled != nil { + return *x.CanvasVersioningEnabled } return false } @@ -3010,9 +3010,9 @@ var File_organizations_proto protoreflect.FileDescriptor const file_organizations_proto_rawDesc = "" + "\n" + - "\x13organizations.proto\x12\x18Superplane.Organizations\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a.protoc-gen-openapiv2/options/annotations.proto\"\x88\x03\n" + + "\x13organizations.proto\x12\x18Superplane.Organizations\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a.protoc-gen-openapiv2/options/annotations.proto\"\x83\x03\n" + "\fOrganization\x12K\n" + - "\bmetadata\x18\x01 \x01(\v2/.Superplane.Organizations.Organization.MetadataR\bmetadata\x1a\xaa\x02\n" + + "\bmetadata\x18\x01 \x01(\v2/.Superplane.Organizations.Organization.MetadataR\bmetadata\x1a\xa5\x02\n" + "\bMetadata\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12 \n" + @@ -3020,9 +3020,9 @@ const file_organizations_proto_rawDesc = "" + "\n" + "created_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x129\n" + "\n" + - "updated_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\x12B\n" + - "\x1bcanvas_sandbox_mode_enabled\x18\x06 \x01(\bH\x00R\x18canvasSandboxModeEnabled\x88\x01\x01B\x1e\n" + - "\x1c_canvas_sandbox_mode_enabled\"-\n" + + "updated_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\x12?\n" + + "\x19canvas_versioning_enabled\x18\x06 \x01(\bH\x00R\x17canvasVersioningEnabled\x88\x01\x01B\x1c\n" + + "\x1a_canvas_versioning_enabled\"-\n" + "\x1bDescribeOrganizationRequest\x12\x0e\n" + "\x02id\x18\x01 \x01(\tR\x02id\"j\n" + "\x1cDescribeOrganizationResponse\x12J\n" + diff --git a/protos/canvases.proto b/protos/canvases.proto index 8572adaea5..637486c88a 100644 --- a/protos/canvases.proto +++ b/protos/canvases.proto @@ -61,6 +61,18 @@ service Canvases { }; } + rpc UpdateCanvas(UpdateCanvasRequest) returns (UpdateCanvasResponse) { + option (google.api.http) = { + put: "/api/v1/canvases/{id}" + body: "*" + }; + option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = { + summary: "Update canvas"; + description: "Updates canvas metadata"; + tags: "Canvas"; + }; + } + rpc CreateCanvasVersion(CreateCanvasVersionRequest) returns (CreateCanvasVersionResponse) { option (google.api.http) = { post: "/api/v1/canvases/{canvas_id}/versions" @@ -106,7 +118,7 @@ service Canvases { }; option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = { summary: "Update canvas version"; - description: "Updates a user-owned canvas version; if version_id is omitted, updates the live canvas in sandbox mode"; + description: "Updates a user-owned canvas version; if version_id is omitted, updates the live canvas when versioning is disabled"; tags: "CanvasVersion"; }; } @@ -357,6 +369,17 @@ message DescribeCanvasResponse { Canvas canvas = 1; } +message UpdateCanvasRequest { + string id = 1; + optional string name = 2; + optional string description = 3; + optional bool canvas_versioning_enabled = 4; +} + +message UpdateCanvasResponse { + Canvas canvas = 1; +} + message CreateCanvasRequest { Canvas canvas = 1; } @@ -481,6 +504,7 @@ message Canvas { google.protobuf.Timestamp updated_at = 6; UserRef created_by = 7; bool is_template = 8; + bool canvas_versioning_enabled = 9; } message Spec { diff --git a/protos/organizations.proto b/protos/organizations.proto index 1dfd177097..b6824ed0cd 100644 --- a/protos/organizations.proto +++ b/protos/organizations.proto @@ -272,7 +272,7 @@ message Organization { string description = 3; google.protobuf.Timestamp created_at = 4; google.protobuf.Timestamp updated_at = 5; - optional bool canvas_sandbox_mode_enabled = 6; + optional bool canvas_versioning_enabled = 6; } Metadata metadata = 1; diff --git a/templates/skills/system.md b/templates/skills/system.md index 83275f766e..02aeb7095b 100644 --- a/templates/skills/system.md +++ b/templates/skills/system.md @@ -8,6 +8,9 @@ Product model: - Each node execution emits payload data into a message chain that downstream expressions can read. - Components are capabilities; nodes are configured instances of those components on the canvas. - Integrations provide many components/triggers. Use only components available in availableBlocks. +- Canvas versioning precedence: organization `canvasVersioningEnabled` OR canvas `canvasVersioningEnabled` defines effective behavior. +- If organization `canvasVersioningEnabled` is true, all canvases are effectively versioned. +- If organization `canvasVersioningEnabled` is false, each canvas can be versioned or not via its own setting. Glossary: - Canvas: the workspace graph containing nodes and subscriptions. - Workflow: behavior expressed by the canvas when events move through it. diff --git a/test/e2e/canvas_versioning_enforcement_test.go b/test/e2e/canvas_versioning_enforcement_test.go new file mode 100644 index 0000000000..fde8869ed3 --- /dev/null +++ b/test/e2e/canvas_versioning_enforcement_test.go @@ -0,0 +1,162 @@ +package e2e + +import ( + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/superplanehq/superplane/pkg/database" + "github.com/superplanehq/superplane/pkg/models" + q "github.com/superplanehq/superplane/test/e2e/queries" + "github.com/superplanehq/superplane/test/e2e/session" + "github.com/superplanehq/superplane/test/e2e/shared" +) + +func TestCanvasVersioningEnforcement(t *testing.T) { + t.Run("organization versioning enabled enforces effective canvas versioning enabled", func(t *testing.T) { + steps := &canvasVersioningEnforcementSteps{t: t} + steps.start() + steps.givenACanvasExists("E2E Canvas Versioning Org On") + + steps.setCanvasVersioningInDB(false) + steps.setOrganizationVersioningInDB(true) + + steps.visitCanvasSettings() + steps.assertCanvasVersioningToggleChecked(true) + steps.assertCanvasVersioningToggleDisabled() + steps.session.AssertText("Versioning is enabled by your organization settings for all canvases.") + + // Enforcement must not require mutating every canvas row. + steps.assertCanvasVersioningInDB(false) + }) + + t.Run("organization versioning disabled allows per-canvas on and off", func(t *testing.T) { + steps := &canvasVersioningEnforcementSteps{t: t} + steps.start() + steps.givenACanvasExists("E2E Canvas Versioning Org Off") + + steps.setOrganizationVersioningInDB(false) + steps.setCanvasVersioningInDB(false) + + steps.visitCanvasSettings() + steps.assertCanvasVersioningToggleEnabled() + steps.assertCanvasVersioningToggleChecked(false) + steps.session.AssertText("This toggle controls versioning for this canvas.") + + steps.setCanvasVersioningToggle(true) + steps.saveCanvasSettings() + steps.assertCanvasVersioningInDB(true) + + steps.setCanvasVersioningToggle(false) + steps.saveCanvasSettings() + steps.assertCanvasVersioningInDB(false) + }) +} + +type canvasVersioningEnforcementSteps struct { + t *testing.T + session *session.TestSession + canvas *shared.CanvasSteps +} + +func (s *canvasVersioningEnforcementSteps) start() { + s.session = ctx.NewSession(s.t) + s.session.Start() + s.session.Login() +} + +func (s *canvasVersioningEnforcementSteps) givenACanvasExists(name string) { + s.canvas = shared.NewCanvasSteps(name, s.t, s.session) + s.canvas.Create() +} + +func (s *canvasVersioningEnforcementSteps) setOrganizationVersioningInDB(enabled bool) { + err := database.Conn(). + Model(&models.Organization{}). + Where("id = ?", s.session.OrgID). + Update("canvas_versioning_enabled", enabled). + Error + require.NoError(s.t, err) +} + +func (s *canvasVersioningEnforcementSteps) setCanvasVersioningInDB(enabled bool) { + err := database.Conn(). + Model(&models.Canvas{}). + Where("id = ?", s.canvas.WorkflowID). + Update("canvas_versioning_enabled", enabled). + Error + require.NoError(s.t, err) +} + +func (s *canvasVersioningEnforcementSteps) visitCanvasSettings() { + s.canvas.Visit() + s.session.AssertVisible(q.Locator(`header button:has-text("Settings")`)) + s.session.Click(q.Locator(`header button:has-text("Settings")`)) + s.session.AssertText("Canvas Name") + s.session.AssertVisible(canvasVersioningSwitchQuery()) +} + +func (s *canvasVersioningEnforcementSteps) saveCanvasSettings() { + s.session.Click(q.Locator(`button:has-text("Save Changes")`)) + s.session.AssertText("Canvas updated successfully") +} + +func (s *canvasVersioningEnforcementSteps) assertCanvasVersioningToggleDisabled() { + s.session.AssertDisabled(canvasVersioningSwitchQuery()) +} + +func (s *canvasVersioningEnforcementSteps) assertCanvasVersioningToggleEnabled() { + disabled, err := canvasVersioningSwitchQuery().Run(s.session).IsDisabled() + require.NoError(s.t, err) + require.False(s.t, disabled) +} + +func (s *canvasVersioningEnforcementSteps) assertCanvasVersioningToggleChecked(expected bool) { + attr, err := canvasVersioningSwitchQuery().Run(s.session).GetAttribute("aria-checked") + require.NoError(s.t, err) + + expectedString := "false" + if expected { + expectedString = "true" + } + + require.Equal(s.t, expectedString, attr) +} + +func (s *canvasVersioningEnforcementSteps) setCanvasVersioningToggle(enabled bool) { + s.assertCanvasVersioningToggleEnabled() + + attr, err := canvasVersioningSwitchQuery().Run(s.session).GetAttribute("aria-checked") + require.NoError(s.t, err) + + currentlyEnabled := attr == "true" + if currentlyEnabled == enabled { + return + } + + s.session.Click(canvasVersioningSwitchQuery()) + s.assertCanvasVersioningToggleChecked(enabled) +} + +func (s *canvasVersioningEnforcementSteps) assertCanvasVersioningInDB(expected bool) { + deadline := time.Now().Add(3 * time.Second) + + for { + canvas, err := models.FindCanvas(s.session.OrgID, s.canvas.WorkflowID) + require.NoError(s.t, err) + if canvas.CanvasVersioningEnabled == expected { + return + } + + if time.Now().After(deadline) { + s.t.Fatalf("expected canvas_versioning_enabled=%t, got %t", expected, canvas.CanvasVersioningEnabled) + } + + time.Sleep(200 * time.Millisecond) + } +} + +func canvasVersioningSwitchQuery() q.Query { + return q.Locator(`button[role="switch"][aria-label="Toggle canvas versioning"]`) +} diff --git a/test/support/support.go b/test/support/support.go index 8e4721a3e3..abc002f6cb 100644 --- a/test/support/support.go +++ b/test/support/support.go @@ -305,6 +305,8 @@ func CreateNextNodeExecution( func CreateCanvas(t *testing.T, orgID uuid.UUID, userID uuid.UUID, nodes []models.CanvasNode, edges []models.Edge) (*models.Canvas, []models.CanvasNode) { now := time.Now() liveVersionID := uuid.New() + canvasVersioningEnabled, err := models.IsCanvasVersioningEnabled(orgID) + require.NoError(t, err) inputNodes := make([]models.Node, len(nodes)) for i, node := range nodes { @@ -324,14 +326,15 @@ func CreateCanvas(t *testing.T, orgID uuid.UUID, userID uuid.UUID, nodes []model // Create canvas // workflow := &models.Canvas{ - ID: uuid.New(), - OrganizationID: orgID, - LiveVersionID: &liveVersionID, - Name: RandomName("canvas"), - Description: "Test canvas", - CreatedBy: &userID, - CreatedAt: &now, - UpdatedAt: &now, + ID: uuid.New(), + OrganizationID: orgID, + LiveVersionID: &liveVersionID, + CanvasVersioningEnabled: canvasVersioningEnabled, + Name: RandomName("canvas"), + Description: "Test canvas", + CreatedBy: &userID, + CreatedAt: &now, + UpdatedAt: &now, } // diff --git a/web_src/src/api-client/index.ts b/web_src/src/api-client/index.ts index e14505a87c..30f7707bcc 100644 --- a/web_src/src/api-client/index.ts +++ b/web_src/src/api-client/index.ts @@ -31,6 +31,7 @@ export { canvasesListNodeQueueItems, canvasesResolveExecutionErrors, canvasesSendAiMessage, + canvasesUpdateCanvas, canvasesUpdateCanvasVersion, canvasesUpdateCanvasVersion2, canvasesUpdateNodePause, @@ -315,6 +316,13 @@ export type { CanvasesSendAiMessageResponse, CanvasesSendAiMessageResponse2, CanvasesSendAiMessageResponses, + CanvasesUpdateCanvasBody, + CanvasesUpdateCanvasData, + CanvasesUpdateCanvasError, + CanvasesUpdateCanvasErrors, + CanvasesUpdateCanvasResponse, + CanvasesUpdateCanvasResponse2, + CanvasesUpdateCanvasResponses, CanvasesUpdateCanvasVersion2Data, CanvasesUpdateCanvasVersion2Error, CanvasesUpdateCanvasVersion2Errors, diff --git a/web_src/src/api-client/sdk.gen.ts b/web_src/src/api-client/sdk.gen.ts index a92365359e..037cb21286 100644 --- a/web_src/src/api-client/sdk.gen.ts +++ b/web_src/src/api-client/sdk.gen.ts @@ -93,6 +93,9 @@ import type { CanvasesSendAiMessageData, CanvasesSendAiMessageErrors, CanvasesSendAiMessageResponses, + CanvasesUpdateCanvasData, + CanvasesUpdateCanvasErrors, + CanvasesUpdateCanvasResponses, CanvasesUpdateCanvasVersion2Data, CanvasesUpdateCanvasVersion2Errors, CanvasesUpdateCanvasVersion2Responses, @@ -752,7 +755,7 @@ export const canvasesCreateCanvasVersion = /** * Update canvas version * - * Updates a user-owned canvas version; if version_id is omitted, updates the live canvas in sandbox mode + * Updates a user-owned canvas version; if version_id is omitted, updates the live canvas when versioning is disabled */ export const canvasesUpdateCanvasVersion2 = ( options: Options, @@ -787,7 +790,7 @@ export const canvasesDescribeCanvasVersion = ( options: Options, @@ -829,6 +832,23 @@ export const canvasesDescribeCanvas = ( ...options, }); +/** + * Update canvas + * + * Updates canvas metadata + */ +export const canvasesUpdateCanvas = ( + options: Options, +) => + (options.client ?? client).put({ + url: "/api/v1/canvases/{id}", + ...options, + headers: { + "Content-Type": "application/json", + ...options.headers, + }, + }); + /** * List components * diff --git a/web_src/src/api-client/types.gen.ts b/web_src/src/api-client/types.gen.ts index b48d9755eb..8ec61ad2db 100644 --- a/web_src/src/api-client/types.gen.ts +++ b/web_src/src/api-client/types.gen.ts @@ -182,6 +182,7 @@ export type CanvasesCanvasMetadata = { updatedAt?: string; createdBy?: SuperplaneCanvasesUserRef; isTemplate?: boolean; + canvasVersioningEnabled?: boolean; }; export type CanvasesCanvasNodeExecution = { @@ -415,6 +416,16 @@ export type CanvasesSendAiMessageResponse = { }>; }; +export type CanvasesUpdateCanvasBody = { + name?: string; + description?: string; + canvasVersioningEnabled?: boolean; +}; + +export type CanvasesUpdateCanvasResponse = { + canvas?: CanvasesCanvas; +}; + export type CanvasesUpdateCanvasVersionBody = { versionId?: string; canvas?: CanvasesCanvas; @@ -900,7 +911,7 @@ export type OrganizationsOrganizationMetadata = { description?: string; createdAt?: string; updatedAt?: string; - canvasSandboxModeEnabled?: boolean; + canvasVersioningEnabled?: boolean; }; export type OrganizationsRemoveInvitationResponse = { @@ -2277,6 +2288,33 @@ export type CanvasesDescribeCanvasResponses = { export type CanvasesDescribeCanvasResponse2 = CanvasesDescribeCanvasResponses[keyof CanvasesDescribeCanvasResponses]; +export type CanvasesUpdateCanvasData = { + body: CanvasesUpdateCanvasBody; + path: { + id: string; + }; + query?: never; + url: "/api/v1/canvases/{id}"; +}; + +export type CanvasesUpdateCanvasErrors = { + /** + * An unexpected error response. + */ + default: GooglerpcStatus; +}; + +export type CanvasesUpdateCanvasError = CanvasesUpdateCanvasErrors[keyof CanvasesUpdateCanvasErrors]; + +export type CanvasesUpdateCanvasResponses = { + /** + * A successful response. + */ + 200: CanvasesUpdateCanvasResponse; +}; + +export type CanvasesUpdateCanvasResponse2 = CanvasesUpdateCanvasResponses[keyof CanvasesUpdateCanvasResponses]; + export type ComponentsListComponentsData = { body?: never; path?: never; diff --git a/web_src/src/components/OrganizationMenuButton.tsx b/web_src/src/components/OrganizationMenuButton.tsx index d8e10f0798..2ecca8cb7a 100644 --- a/web_src/src/components/OrganizationMenuButton.tsx +++ b/web_src/src/components/OrganizationMenuButton.tsx @@ -17,6 +17,7 @@ import { Users, } from "lucide-react"; import { useEffect, useRef, useState } from "react"; +import { Link } from "react-router-dom"; import { PermissionTooltip } from "@/components/PermissionGate"; import { usePermissions } from "@/contexts/PermissionsContext"; @@ -165,43 +166,51 @@ export function OrganizationMenuButton({ organizationId, onLogoClick, className const MenuIcon = link.Icon; const allowed = !link.permission || permissionsLoading || canAct(link.permission.resource, link.permission.action); - const linkButton = ( + + if (!allowed) { + return ( + + + + ); + } + + return link.href ? ( + setIsMenuOpen(false)} + className="group flex items-center gap-2 rounded-md px-1.5 py-1 text-left text-sm font-medium text-gray-500 hover:bg-sky-100 hover:text-gray-800" + > + + {link.label} + + ) : ( ); - - if (allowed) { - return linkButton; - } - - return ( - - {linkButton} - - ); })} @@ -219,15 +228,15 @@ export function OrganizationMenuButton({ organizationId, onLogoClick, className {sidebarUserLinks.map((link) => { const MenuIcon = link.Icon; return link.href ? ( - setIsMenuOpen(false)} > {link.label} - + ) : ( +
diff --git a/web_src/src/pages/auth/OrganizationSelect.tsx b/web_src/src/pages/auth/OrganizationSelect.tsx index e5d12ceda9..7248abbc96 100644 --- a/web_src/src/pages/auth/OrganizationSelect.tsx +++ b/web_src/src/pages/auth/OrganizationSelect.tsx @@ -1,7 +1,7 @@ import SuperplaneLogo from "@/assets/superplane.svg"; import { Building, Palette, User } from "lucide-react"; import React, { useEffect, useState } from "react"; -import { useLocation, useNavigate } from "react-router-dom"; +import { Link, useLocation, useNavigate } from "react-router-dom"; import { Text } from "../../components/Text/text"; import { useAccount } from "../../contexts/AccountContext"; @@ -69,11 +69,6 @@ const OrganizationSelect: React.FC = () => { } }; - const handleOrganizationSelect = (org: Organization) => { - // Redirect to the organization's app route - window.location.href = `/${org.id}`; - }; - if (loading) { return (
@@ -118,10 +113,10 @@ const OrganizationSelect: React.FC = () => {
{organizations.map((org) => ( -
handleOrganizationSelect(org)} >
@@ -142,12 +137,12 @@ const OrganizationSelect: React.FC = () => {
-
+ ))} -
navigate("/create")} >

+ Create new

@@ -155,7 +150,7 @@ const OrganizationSelect: React.FC = () => { Start fresh with a new organization -
+
diff --git a/web_src/src/pages/canvas/CreateCanvasPage.tsx b/web_src/src/pages/canvas/CreateCanvasPage.tsx index 42ca2ba5cc..6fadf871a6 100644 --- a/web_src/src/pages/canvas/CreateCanvasPage.tsx +++ b/web_src/src/pages/canvas/CreateCanvasPage.tsx @@ -1,7 +1,7 @@ import { OrganizationMenuButton } from "@/components/OrganizationMenuButton"; import { usePageTitle } from "@/hooks/usePageTitle"; import { useState } from "react"; -import { useNavigate, useParams } from "react-router-dom"; +import { Link, useNavigate, useParams } from "react-router-dom"; import { Field, Label } from "../../components/Fieldset/fieldset"; import { Heading } from "../../components/Heading/heading"; import { Input } from "../../components/Input/input"; @@ -170,12 +170,7 @@ export function CreateCanvasPage() {
{workflowTemplates.map((template) => ( - + ))}
@@ -188,32 +183,20 @@ export function CreateCanvasPage() { interface TemplateCardProps { template: any; organizationId: string; - navigate: any; } -function TemplateCard({ template, organizationId, navigate }: TemplateCardProps) { +function TemplateCard({ template, organizationId }: TemplateCardProps) { const previewNodes = (template.spec?.nodes || []) as ComponentsNode[]; const previewEdges = (template.spec?.edges || []) as ComponentsEdge[]; const templateId = template.metadata?.id; if (!templateId) return null; - const handleNavigate = () => navigate(`/${organizationId}/templates/${templateId}`); + const templateHref = `/${organizationId}/templates/${templateId}`; return ( -
{ - if (event.defaultPrevented) return; - handleNavigate(); - }} - onKeyDown={(e) => { - if (e.key === "Enter" || e.key === " ") { - e.preventDefault(); - handleNavigate(); - } - }} +
@@ -246,7 +229,7 @@ function TemplateCard({ template, organizationId, navigate }: TemplateCardProps) ) : null}
- + ); } diff --git a/web_src/src/pages/custom-component/index.tsx b/web_src/src/pages/custom-component/index.tsx index a87b9d20ca..8357b4d06c 100644 --- a/web_src/src/pages/custom-component/index.tsx +++ b/web_src/src/pages/custom-component/index.tsx @@ -4,7 +4,7 @@ import "@xyflow/react/dist/style.css"; import ELK from "elkjs/lib/elk.bundled.js"; import { AlertCircle, Component as ComponentIcon } from "lucide-react"; import { useCallback, useEffect, useMemo, useRef, useState } from "react"; -import { useNavigate, useParams, useSearchParams } from "react-router-dom"; +import { Link, useParams, useSearchParams } from "react-router-dom"; import { ComponentsComponent, ComponentsIntegrationRef, ComponentsNode } from "../../api-client"; import { Heading } from "../../components/Heading/heading"; import { Button } from "../../components/ui/button"; @@ -134,7 +134,6 @@ const createBlockData = (node: any, component: ComponentsComponent | undefined): export const CustomComponent = () => { const { organizationId, blueprintId } = useParams<{ organizationId: string; blueprintId: string }>(); - const navigate = useNavigate(); const [searchParams] = useSearchParams(); const [blueprintConfiguration, setBlueprintConfiguration] = useState([]); const [blueprintOutputChannels, setBlueprintOutputChannels] = useState([]); @@ -1267,8 +1266,8 @@ export const CustomComponent = () => {
Blueprint not found -
); diff --git a/web_src/src/pages/home/index.tsx b/web_src/src/pages/home/index.tsx index 005af55ac9..591e29d775 100644 --- a/web_src/src/pages/home/index.tsx +++ b/web_src/src/pages/home/index.tsx @@ -3,7 +3,7 @@ import { usePageTitle } from "@/hooks/usePageTitle"; import { Box, GitBranch, MoreVertical, Palette, Pencil, Plus, Rainbow, Search, Trash2 } from "lucide-react"; import { useState, type MouseEvent } from "react"; import { useQueryClient } from "@tanstack/react-query"; -import { useLocation, useNavigate, useParams } from "react-router-dom"; +import { Link, useLocation, useNavigate, useParams } from "react-router-dom"; import { CreateCanvasModal } from "../../components/CreateCanvasModal"; import { CreateCustomComponentModal } from "../../components/CreateCustomComponentModal"; import { Dialog, DialogActions, DialogDescription, DialogTitle } from "../../components/Dialog/dialog"; @@ -492,8 +492,6 @@ function CanvasGridView({ canDeleteCanvases, permissionsLoading, }: CanvasGridViewProps) { - const navigate = useNavigate(); - return (
{filteredCanvases.map((canvas) => ( @@ -501,7 +499,6 @@ function CanvasGridView({ key={canvas.id} canvas={canvas} organizationId={organizationId} - navigate={navigate} onEdit={onEditCanvas} canUpdateCanvases={canUpdateCanvases} canDeleteCanvases={canDeleteCanvases} @@ -515,7 +512,6 @@ function CanvasGridView({ interface CanvasCardProps { canvas: CanvasCardData; organizationId: string; - navigate: any; onEdit: (canvas: CanvasCardData) => void; canUpdateCanvases: boolean; canDeleteCanvases: boolean; @@ -525,34 +521,19 @@ interface CanvasCardProps { function CanvasCard({ canvas, organizationId, - navigate, onEdit, canUpdateCanvases, canDeleteCanvases, permissionsLoading, }: CanvasCardProps) { - const handleNavigate = () => navigate(`/${organizationId}/canvases/${canvas.id}`); + const canvasHref = `/${organizationId}/canvases/${canvas.id}`; const previewNodes = canvas.nodes || []; const previewEdges = canvas.edges || []; return ( -
{ - if (event.defaultPrevented) return; - handleNavigate(); - }} - onKeyDown={(event) => { - if (event.key === "Enter" || event.key === " ") { - event.preventDefault(); - handleNavigate(); - } - }} - className="min-h-48 bg-white dark:bg-gray-800 rounded-md outline outline-gray-950/15 hover:shadow-md transition-shadow cursor-pointer" - > -
+
+ +
@@ -565,14 +546,16 @@ function CanvasCard({ {canvas.name}
- +
+ +
{canvas.description ? ( @@ -721,6 +704,7 @@ function CanvasActionsMenu({ }; const openDialog = (event: MouseEvent) => { + event.preventDefault(); event.stopPropagation(); setIsDialogOpen(true); }; @@ -761,7 +745,13 @@ function CanvasActionsMenu({ return ( <> -
) => event.stopPropagation()}> +
) => { + event.preventDefault(); + event.stopPropagation(); + }} + > {!canManage ? ( ) : ( - ) => event.stopPropagation()}> + ) => { + event.preventDefault(); + event.stopPropagation(); + }} + > +

Integration Details

@@ -225,12 +227,13 @@ export function IntegrationDetails({ organizationId }: IntegrationDetailsProps) return (
- +

Integration Details

@@ -243,12 +246,13 @@ export function IntegrationDetails({ organizationId }: IntegrationDetailsProps) return (
- + {/* Back button */} - + {/* Details */}
diff --git a/web_src/src/pages/organization/settings/index.tsx b/web_src/src/pages/organization/settings/index.tsx index 3380b6aa81..8c9951f54f 100644 --- a/web_src/src/pages/organization/settings/index.tsx +++ b/web_src/src/pages/organization/settings/index.tsx @@ -1,4 +1,4 @@ -import { Routes, Route, Navigate, useNavigate, useLocation } from "react-router-dom"; +import { Routes, Route, Navigate, Link, useLocation } from "react-router-dom"; import { Sidebar, SidebarBody, SidebarSection } from "../../../components/Sidebar/sidebar"; import { General } from "./General"; import { Groups } from "./Groups"; @@ -38,7 +38,6 @@ import { usePermissions } from "@/contexts/PermissionsContext"; import { PermissionTooltip, RequirePermission } from "@/components/PermissionGate"; export function OrganizationSettings() { - const navigate = useNavigate(); const location = useLocation(); const { account: user, loading: userLoading } = useAccount(); const { organizationId } = useParams<{ organizationId: string }>(); @@ -181,25 +180,6 @@ export function OrganizationSettings() { { id: "sign-out", label: "Sign Out", action: () => (window.location.href = "/logout"), Icon: LogOut }, ]; - const handleLinkClick = (link: NavLink) => { - if (link.permission && !permissionsLoading && !canAct(link.permission.resource, link.permission.action)) { - return; - } - - if (link.action) { - link.action(); - return; - } - - if (link.href) { - if (link.href.startsWith("http")) { - window.location.href = link.href; - } else { - navigate(link.href); - } - } - }; - const isLinkActive = (link: NavLink) => { if (link.id === "canvases") { return location.pathname === `/${organizationId}`; @@ -276,14 +256,9 @@ export function OrganizationSettings() { - +
@@ -294,18 +269,65 @@ export function OrganizationSettings() {
{organizationLinks.map((link) => { const allowed = canAccessLink(link); - const linkButton = ( + + if (!allowed) { + return ( + + + + ); + } + + if (link.href) { + return ( + + + {link.label} + + ); + } + + return ( ); - - if (allowed) { - return linkButton; - } - - return ( - - {linkButton} - - ); })}
@@ -349,28 +355,50 @@ export function OrganizationSettings() {

{userEmail}

- {userLinks.map((link) => ( - - ))} + > + + {link.label} + + ), + )}
diff --git a/web_src/src/pages/workflowv2/CanvasSettingsView.tsx b/web_src/src/pages/workflowv2/CanvasSettingsView.tsx new file mode 100644 index 0000000000..ec1af57d80 --- /dev/null +++ b/web_src/src/pages/workflowv2/CanvasSettingsView.tsx @@ -0,0 +1,151 @@ +import { useEffect, useMemo, useState } from "react"; +import { Field, Fieldset, Label } from "@/components/Fieldset/fieldset"; +import { Input } from "@/components/Input/input"; +import { Button } from "@/components/ui/button"; +import { Textarea } from "@/components/ui/textarea"; +import { Switch } from "@/ui/switch"; +import { Tooltip, TooltipContent, TooltipTrigger } from "@/ui/tooltip"; + +type CanvasSettingsValues = { + name: string; + description: string; + canvasVersioningEnabled: boolean; +}; + +interface CanvasSettingsViewProps { + initialValues: CanvasSettingsValues; + canUpdateCanvas: boolean; + orgVersioningEnabled?: boolean; + isSaving: boolean; + onSave: (values: { name: string; description: string; canvasVersioningEnabled?: boolean }) => Promise; +} + +export function CanvasSettingsView({ + initialValues, + canUpdateCanvas, + orgVersioningEnabled, + isSaving, + onSave, +}: CanvasSettingsViewProps) { + const [name, setName] = useState(initialValues.name); + const [description, setDescription] = useState(initialValues.description); + const [canvasVersioningEnabled, setCanvasVersioningEnabled] = useState(initialValues.canvasVersioningEnabled); + const [saveMessage, setSaveMessage] = useState(null); + const isVersioningEnforcedByOrganization = orgVersioningEnabled === true; + const isVersioningToggleDisabled = !canUpdateCanvas || isVersioningEnforcedByOrganization; + const versioningEnforcedTooltip = "Versioning is enabled by your organization settings for all canvases."; + + useEffect(() => { + setName(initialValues.name); + setDescription(initialValues.description); + setCanvasVersioningEnabled(isVersioningEnforcedByOrganization ? true : initialValues.canvasVersioningEnabled); + }, [initialValues, isVersioningEnforcedByOrganization]); + + const hasChanges = useMemo(() => { + const effectiveCanvasVersioningEnabled = isVersioningEnforcedByOrganization ? true : canvasVersioningEnabled; + return ( + name !== initialValues.name || + description !== initialValues.description || + effectiveCanvasVersioningEnabled !== initialValues.canvasVersioningEnabled + ); + }, [canvasVersioningEnabled, description, initialValues, isVersioningEnforcedByOrganization, name]); + + const handleSave = async () => { + if (!canUpdateCanvas) { + return; + } + + setSaveMessage(null); + try { + await onSave({ + name, + description, + canvasVersioningEnabled: isVersioningEnforcedByOrganization ? undefined : canvasVersioningEnabled, + }); + setSaveMessage("Canvas updated successfully"); + setTimeout(() => setSaveMessage(null), 3000); + } catch { + setSaveMessage("Failed to update canvas"); + setTimeout(() => setSaveMessage(null), 3000); + } + }; + + const versioningSection = ( +
+
+
+ +

+ Manage canvas edits with drafts and publish flow. When disabled, users edit the live canvas directly. + {isVersioningEnforcedByOrganization + ? " Versioning is enabled by your organization settings for all canvases." + : " This toggle controls versioning for this canvas."} +

+
+
+ + {isVersioningEnforcedByOrganization ? "Enabled" : canvasVersioningEnabled ? "Enabled" : "Disabled"} + + +
+
+
+ ); + + return ( +
+
+ + + setName(event.target.value)} + disabled={!canUpdateCanvas} + /> + + + + +