Update baton sdk and regenerate capabiltiies

.golangci.yml

@@ -70,7 +70,6 @@ linters:
     - bodyclose # checks whether HTTP response body is closed successfully
     - durationcheck # check for two durations multiplied together
     - errorlint # errorlint is a linter for that can be used to find code that will cause problems with the error wrapping scheme introduced in Go 1.13.
-    - execinquery # execinquery is a linter about query string checker in Query function which reads your Go src files and warning it finds
     - exhaustive # check exhaustiveness of enum switch statements
     - exportloopref # checks for pointers to enclosing loop variables
     - forbidigo # Forbids identifiers

baton_capabilities.json

@@ -1,99 +1,115 @@
 {
-  "@type":  "type.googleapis.com/c1.connector.v2.ConnectorCapabilities",
-  "resourceTypeCapabilities":  [
+  "@type": "type.googleapis.com/c1.connector.v2.ConnectorCapabilities",
+  "resourceTypeCapabilities": [
     {
-      "resourceType":  {
-        "id":  "column",
-        "displayName":  "Column"
+      "resourceType": {
+        "id": "column",
+        "displayName": "Column"
       },
-      "capabilities":  [
+      "capabilities": [
         "CAPABILITY_SYNC"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "database",
-        "displayName":  "Database"
+      "resourceType": {
+        "id": "database",
+        "displayName": "Database"
       },
-      "capabilities":  [
-        "CAPABILITY_SYNC"
+      "capabilities": [
+        "CAPABILITY_SYNC",
+        "CAPABILITY_PROVISION",
+        "CAPABILITY_RESOURCE_CREATE",
+        "CAPABILITY_RESOURCE_DELETE"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "function",
-        "displayName":  "Function"
+      "resourceType": {
+        "id": "function",
+        "displayName": "Function"
       },
-      "capabilities":  [
+      "capabilities": [
         "CAPABILITY_SYNC"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "large-object",
-        "displayName":  "Large Object"
+      "resourceType": {
+        "id": "large-object",
+        "displayName": "Large Object"
       },
-      "capabilities":  [
+      "capabilities": [
         "CAPABILITY_SYNC"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "procedure",
-        "displayName":  "Procedure"
+      "resourceType": {
+        "id": "procedure",
+        "displayName": "Procedure"
       },
-      "capabilities":  [
+      "capabilities": [
         "CAPABILITY_SYNC"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "role",
-        "displayName":  "Role",
-        "traits":  [
+      "resourceType": {
+        "id": "role",
+        "displayName": "Role",
+        "traits": [
           "TRAIT_ROLE",
           "TRAIT_USER"
         ]
       },
-      "capabilities":  [
-        "CAPABILITY_SYNC"
+      "capabilities": [
+        "CAPABILITY_SYNC",
+        "CAPABILITY_PROVISION",
+        "CAPABILITY_ACCOUNT_PROVISIONING",
+        "CAPABILITY_CREDENTIAL_ROTATION",
+        "CAPABILITY_RESOURCE_CREATE",
+        "CAPABILITY_RESOURCE_DELETE"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "schema",
-        "displayName":  "Schema"
+      "resourceType": {
+        "id": "schema",
+        "displayName": "Schema"
       },
-      "capabilities":  [
+      "capabilities": [
         "CAPABILITY_SYNC"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "sequence",
-        "displayName":  "Sequence"
+      "resourceType": {
+        "id": "sequence",
+        "displayName": "Sequence"
       },
-      "capabilities":  [
+      "capabilities": [
         "CAPABILITY_SYNC"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "table",
-        "displayName":  "Table"
+      "resourceType": {
+        "id": "table",
+        "displayName": "Table"
       },
-      "capabilities":  [
+      "capabilities": [
         "CAPABILITY_SYNC"
       ]
     },
     {
-      "resourceType":  {
-        "id":  "view",
-        "displayName":  "View"
+      "resourceType": {
+        "id": "view",
+        "displayName": "View"
       },
-      "capabilities":  [
+      "capabilities": [
         "CAPABILITY_SYNC"
       ]
     }
+  ],
+  "connectorCapabilities": [
+    "CAPABILITY_SYNC",
+    "CAPABILITY_PROVISION",
+    "CAPABILITY_RESOURCE_CREATE",
+    "CAPABILITY_RESOURCE_DELETE",
+    "CAPABILITY_ACCOUNT_PROVISIONING",
+    "CAPABILITY_CREDENTIAL_ROTATION"
   ]
 }

cmd/baton-postgresql/config.go

@@ -1,27 +1,18 @@
 package main
 
 import (
-	"context"
-	"fmt"
-
-	"github.com/conductorone/baton-sdk/pkg/cli"
+	"github.com/conductorone/baton-sdk/pkg/field"
 )
 
-// config defines the external configuration required for the connector to run.
-type config struct {
-	cli.BaseConfig `mapstructure:",squash"` // Puts the base config options in the same place as the connector options
-
-	Dsn                 string   `mapstructure:"dsn"`
-	Schemas             []string `mapstructure:"schemas"`
-	IncludeColumns      bool     `mapstructure:"include-columns"`
-	IncludeLargeObjects bool     `mapstructure:"include-large-objects"`
-}
+var (
+	dsn                 = field.StringField("dsn", field.WithRequired(true), field.WithDescription("The DSN to connect to the database"))
+	schemas             = field.StringSliceField("schemas", field.WithDefaultValue([]string{"public"}), field.WithDescription("The schemas to include in the sync"))
+	includeColumns      = field.BoolField("include-columns", field.WithDescription("Include column privileges when syncing. This can result in large amounts of data"))
+	includeLargeObjects = field.BoolField("include-large-objects", field.WithDescription("Include large objects when syncing. This can result in large amounts of data"))
+)
 
-// validateConfig is run after the configuration is loaded, and should return an error if it isn't valid.
-func validateConfig(ctx context.Context, cfg *config) error {
-	if cfg.Dsn == "" {
-		return fmt.Errorf("--dsn is required")
-	}
+var relationships = []field.SchemaFieldRelationship{}
 
-	return nil
-}
+var configuration = field.NewConfiguration([]field.SchemaField{
+	dsn, schemas, includeColumns, includeLargeObjects,
+}, relationships...)

cmd/baton-postgresql/main.go

@@ -5,74 +5,50 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/conductorone/baton-sdk/pkg/cli"
 	"github.com/conductorone/baton-sdk/pkg/connectorbuilder"
 	"github.com/conductorone/baton-sdk/pkg/types"
 	"github.com/grpc-ecosystem/go-grpc-middleware/logging/zap/ctxzap"
+	"github.com/spf13/viper"
 	"go.uber.org/zap"
 
 	"github.com/conductorone/baton-postgresql/pkg/connector"
+	configschema "github.com/conductorone/baton-sdk/pkg/config"
 )
 
 var version = "dev"
 
 func main() {
 	ctx := context.Background()
 
-	cfg := &config{}
-	cmd, err := cli.NewCmd(ctx, "baton-postgresql", cfg, validateConfig, getConnector)
+	_, cmd, err := configschema.DefineConfiguration(ctx, "baton-postgresql", getConnector, configuration)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err.Error())
 		os.Exit(1)
 	}
 
 	cmd.Version = version
 
-	cmd.PersistentFlags().String(
-		"dsn",
-		"",
-		"The connection string for the PostgreSQL database ($BATON_DSN)\nexample: postgres://username:password@localhost:5432/database_name",
-	)
-
-	cmd.PersistentFlags().StringSlice(
-		"schemas",
-		[]string{"public"},
-		"The schemas to include in the sync. ($BATON_SCHEMAS)\nThis defaults to 'public' only.",
-	)
-
-	cmd.PersistentFlags().Bool(
-		"include-columns",
-		false,
-		"Include column privileges when syncing. This can result in large amounts of data. ($BATON_INCLUDE_COLUMNS)\nThis defaults to false.",
-	)
-
-	cmd.PersistentFlags().Bool(
-		"include-large-objects",
-		false,
-		"Include large objects when syncing. This can result in large amounts of data. ($BATON_INCLUDE_LARGE_OBJECTS)\nThis defaults to false.",
-	)
-
 	err = cmd.Execute()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err.Error())
 		os.Exit(1)
 	}
 }
 
-func getConnector(ctx context.Context, cfg *config) (types.ConnectorServer, error) {
+func getConnector(ctx context.Context, v *viper.Viper) (types.ConnectorServer, error) {
 	l := ctxzap.Extract(ctx)
 
-	cb, err := connector.New(ctx, cfg.Dsn, cfg.Schemas, cfg.IncludeColumns, cfg.IncludeLargeObjects)
+	cb, err := connector.New(ctx, v.GetString("dsn"), v.GetStringSlice("schemas"), v.GetBool("include-columns"), v.GetBool("include-large-objects"))
 	if err != nil {
 		l.Error("error creating connector", zap.Error(err))
 		return nil, err
 	}
 
-	connector, err := connectorbuilder.NewConnector(ctx, cb)
+	newConnector, err := connectorbuilder.NewConnector(ctx, cb)
 	if err != nil {
 		l.Error("error creating connector", zap.Error(err))
 		return nil, err
 	}
 
-	return connector, nil
+	return newConnector, nil
 }