github.com/instill-ai/component@v0.16.0-beta/pkg/operator/base64/v0/main.go (about)

     1  //go:generate compogen readme --operator ./config ./README.mdx
     2  package base64
     3  
     4  import (
     5  	_ "embed"
     6  	"encoding/base64"
     7  	"encoding/json"
     8  	"fmt"
     9  	"sync"
    10  
    11  	"go.uber.org/zap"
    12  	"google.golang.org/protobuf/encoding/protojson"
    13  	"google.golang.org/protobuf/types/known/structpb"
    14  
    15  	"github.com/instill-ai/component/pkg/base"
    16  )
    17  
    18  const (
    19  	encode = "TASK_ENCODE"
    20  	decode = "TASK_DECODE"
    21  )
    22  
    23  var (
    24  	//go:embed config/definition.json
    25  	definitionJSON []byte
    26  	//go:embed config/tasks.json
    27  	tasksJSON []byte
    28  	once      sync.Once
    29  	op        *operator
    30  )
    31  
    32  type operator struct {
    33  	base.BaseOperator
    34  }
    35  
    36  type execution struct {
    37  	base.BaseOperatorExecution
    38  }
    39  
    40  type Base64 struct {
    41  	Data string `json:"data"`
    42  }
    43  
    44  func Init(l *zap.Logger, u base.UsageHandler) *operator {
    45  	once.Do(func() {
    46  		op = &operator{
    47  			BaseOperator: base.BaseOperator{
    48  				Logger:       l,
    49  				UsageHandler: u,
    50  			},
    51  		}
    52  		err := op.LoadOperatorDefinition(definitionJSON, tasksJSON, nil)
    53  		if err != nil {
    54  			panic(err)
    55  		}
    56  	})
    57  	return op
    58  }
    59  
    60  func (o *operator) CreateExecution(sysVars map[string]any, task string) (*base.ExecutionWrapper, error) {
    61  	return &base.ExecutionWrapper{Execution: &execution{
    62  		BaseOperatorExecution: base.BaseOperatorExecution{Operator: o, SystemVariables: sysVars, Task: task},
    63  	}}, nil
    64  }
    65  
    66  func (e *execution) Execute(inputs []*structpb.Struct) ([]*structpb.Struct, error) {
    67  	outputs := []*structpb.Struct{}
    68  
    69  	for _, input := range inputs {
    70  		base64Struct := Base64{}
    71  		err := base.ConvertFromStructpb(input, &base64Struct)
    72  		if err != nil {
    73  			return nil, err
    74  		}
    75  		switch e.Task {
    76  		case encode:
    77  			base64Struct.Data = Encode(base64Struct.Data)
    78  		case decode:
    79  			base64Struct.Data, err = Decode(base64Struct.Data)
    80  			if err != nil {
    81  				return nil, err
    82  			}
    83  		default:
    84  			return nil, fmt.Errorf("not supported task: %s", e.Task)
    85  		}
    86  		outputJSON, err := json.Marshal(base64Struct)
    87  		if err != nil {
    88  			return nil, err
    89  		}
    90  		output := structpb.Struct{}
    91  		err = protojson.Unmarshal(outputJSON, &output)
    92  		if err != nil {
    93  			return nil, err
    94  		}
    95  		outputs = append(outputs, &output)
    96  	}
    97  	return outputs, nil
    98  }
    99  
   100  func Encode(str string) string {
   101  	return base64.StdEncoding.EncodeToString([]byte(str))
   102  }
   103  
   104  func Decode(str string) (string, error) {
   105  	b, err := base64.StdEncoding.DecodeString(base.TrimBase64Mime(str))
   106  	if err != nil {
   107  		return str, err
   108  	}
   109  	return string(b), nil
   110  }