19929347875

Committed 04 Dec 2025 12:41PM UTC coverage: 50.769% (-0.1%) from 50.876%

Build # 19929347875

Build Type

push

github

Committed by

ory-bot

Commit Message

chore: fix golangci-lint warnings

GitOrigin-RevId: 05ddc40c2

Run Details

24 of 50 new or added lines in 20 files covered. (48.0%)

5 existing lines in 2 files now uncovered.

3831 of 7546 relevant lines covered (50.77%)

0.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/cmd/relationtuple/create.go

// Copyright © 2023 Ory Corp
// SPDX-License-Identifier: Apache-2.0

package relationtuple

import (
        "bytes"
        "encoding/json"
        "fmt"
        "io"
        "os"
        "path/filepath"

        "github.com/ory/keto/ketoapi"

        rts "github.com/ory/keto/proto/ory/keto/relation_tuples/v1alpha2"

        "github.com/spf13/cobra"

        "github.com/ory/x/cmdx"
)

func NewCreateCmd() *cobra.Command {
        cmd := &cobra.Command{
                Use:   "create <relationships.json> [<relationships-dir>]",
                Short: "Create relationships from JSON files",
                Long: "Create relationships from JSON files.\n" +
                        "A directory will be traversed and all relationships will be created.\n" +
                        "Pass the special filename `-` to read from STD_IN.",
                Args: cobra.MinimumNArgs(1),
                RunE: transactRelationTuples(rts.RelationTupleDelta_ACTION_INSERT),
        }
        registerPackageFlags(cmd.Flags())

        return cmd
}

func readTuplesFromArg(cmd *cobra.Command, arg string) ([]*ketoapi.RelationTuple, error) {
        var f io.Reader
        if arg == "-" {
                f = cmd.InOrStdin()
        } else {
                cleanArg := filepath.Clean(arg)
                stats, err := os.Stat(cleanArg)
                if err != nil {
                        _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Error getting stats for %s: %s\n", arg, err)
                        return nil, cmdx.FailSilently(cmd)
                }

                if stats.IsDir() {
                        fi, err := os.ReadDir(cleanArg)
                        if err != nil {
                                return nil, err
                        }

                        var tuples []*ketoapi.RelationTuple
                        for _, child := range fi {
                                t, err := readTuplesFromArg(cmd, filepath.Join(cleanArg, child.Name()))
                                if err != nil {
                                        return nil, err
                                }
                                tuples = append(tuples, t...)
                        }
                        return tuples, nil
                }

                ff, err := os.Open(cleanArg)
                if err != nil {
                        _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Error processing arg %s: %s\n", arg, err)
                        return nil, cmdx.FailSilently(cmd)
                }
                defer func() { _ = ff.Close() }()
                f = ff
        }

        fc, err := io.ReadAll(f)
        if err != nil {
                _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Could read file %s: %s\n", arg, err)
                return nil, cmdx.FailSilently(cmd)
        }

        decoder := json.NewDecoder(bytes.NewReader(fc))
        decoder.DisallowUnknownFields()
        // it is ok to not validate beforehand because json.Unmarshal will report errors
        if fc[0] == '[' {
                var ts []*ketoapi.RelationTuple
                if err := decoder.Decode(&ts); err != nil {
                        _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Could not decode: %s\n", err)
                        return nil, cmdx.FailSilently(cmd)
                }
                return ts, nil
        }

        var r ketoapi.RelationTuple
        if err := decoder.Decode(&r); err != nil {
                _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Could not decode: %s\n", err)
                return nil, cmdx.FailSilently(cmd)
        }

        return []*ketoapi.RelationTuple{&r}, nil
}

1	// Copyright © 2023 Ory Corp
2	// SPDX-License-Identifier: Apache-2.0
3
4	package relationtuple
5
6	import (
7	"bytes"
8	"encoding/json"
9	"fmt"
10	"io"
11	"os"
12	"path/filepath"
13
14	"github.com/ory/keto/ketoapi"
15
16	rts "github.com/ory/keto/proto/ory/keto/relation_tuples/v1alpha2"
17
18	"github.com/spf13/cobra"
19
20	"github.com/ory/x/cmdx"
21	)
22
23	func NewCreateCmd() *cobra.Command {	×
24	cmd := &cobra.Command{	×
25	Use: "create <relationships.json> [<relationships-dir>]",	×
26	Short: "Create relationships from JSON files",	×
27	Long: "Create relationships from JSON files.\n" +	×
28	"A directory will be traversed and all relationships will be created.\n" +	×
29	"Pass the special filename `-` to read from STD_IN.",	×
30	Args: cobra.MinimumNArgs(1),	×
31	RunE: transactRelationTuples(rts.RelationTupleDelta_ACTION_INSERT),	×
32	}	×
33	registerPackageFlags(cmd.Flags())	×
34		×
35	return cmd	×
36	}	×
37
38	func readTuplesFromArg(cmd cobra.Command, arg string) ([]ketoapi.RelationTuple, error) {	×
39	var f io.Reader	×
40	if arg == "-" {	×
41	f = cmd.InOrStdin()	×
42	} else {	×
NEW 43	cleanArg := filepath.Clean(arg)	×
NEW 44	stats, err := os.Stat(cleanArg)	×
45	if err != nil {	×
46	_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Error getting stats for %s: %s\n", arg, err)	×
47	return nil, cmdx.FailSilently(cmd)	×
48	}	×
49
50	if stats.IsDir() {	×
NEW 51	fi, err := os.ReadDir(cleanArg)	×
52	if err != nil {	×
53	return nil, err	×
54	}	×
55
56	var tuples []*ketoapi.RelationTuple	×
57	for _, child := range fi {	×
NEW 58	t, err := readTuplesFromArg(cmd, filepath.Join(cleanArg, child.Name()))	×
59	if err != nil {	×
60	return nil, err	×
61	}	×
62	tuples = append(tuples, t...)	×
63	}
64	return tuples, nil	×
65	}
66
NEW 67	ff, err := os.Open(cleanArg)	×
68	if err != nil {	×
69	_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Error processing arg %s: %s\n", arg, err)	×
70	return nil, cmdx.FailSilently(cmd)	×
71	}	×
NEW 72	defer func() { _ = ff.Close() }()	×
NEW 73	f = ff	×
74	}
75
76	fc, err := io.ReadAll(f)	×
77	if err != nil {	×
78	_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Could read file %s: %s\n", arg, err)	×
79	return nil, cmdx.FailSilently(cmd)	×
80	}	×
81
82	decoder := json.NewDecoder(bytes.NewReader(fc))	×
83	decoder.DisallowUnknownFields()	×
84	// it is ok to not validate beforehand because json.Unmarshal will report errors	×
85	if fc[0] == '[' {	×
86	var ts []*ketoapi.RelationTuple	×
87	if err := decoder.Decode(&ts); err != nil {	×
88	_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Could not decode: %s\n", err)	×
89	return nil, cmdx.FailSilently(cmd)	×
90	}	×
91	return ts, nil	×
92	}
93
94	var r ketoapi.RelationTuple	×
95	if err := decoder.Decode(&r); err != nil {	×
96	_, _ = fmt.Fprintf(cmd.ErrOrStderr(), "Could not decode: %s\n", err)	×
97	return nil, cmdx.FailSilently(cmd)	×
98	}	×
99
100	return []*ketoapi.RelationTuple{&r}, nil	×
101	}

ory / keto / 19929347875

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous