6862777535

Committed 14 Nov 2023 11:10AM UTC coverage: 72.769%. Remained the same

Build # 6862777535

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #822 from Permify/dependabot/go_modules/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp-1.20.0

build(deps): bump go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp from 1.17.0 to 1.20.0

Run Details

5847 of 8035 relevant lines covered (72.77%)

56.33 hits per line

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

56.58

/internal/storage/postgres/schemaReader.go

package postgres

import (
        "context"
        "database/sql"
        "errors"

        "github.com/Masterminds/squirrel"
        "go.opentelemetry.io/otel/codes"

        "github.com/Permify/permify/internal/schema"
        "github.com/Permify/permify/internal/storage"
        db "github.com/Permify/permify/pkg/database/postgres"
        base "github.com/Permify/permify/pkg/pb/base/v1"
)

// SchemaReader - Structure for SchemaReader
type SchemaReader struct {
        database *db.Postgres
        // options
        txOptions sql.TxOptions
}

// NewSchemaReader - Creates a new SchemaReader
func NewSchemaReader(database *db.Postgres) *SchemaReader {
        return &SchemaReader{
                database:  database,
                txOptions: sql.TxOptions{Isolation: sql.LevelReadCommitted, ReadOnly: true},
        }
}

// ReadSchema - Reads entity config from the repository.
func (r *SchemaReader) ReadSchema(ctx context.Context, tenantID, version string) (sch *base.SchemaDefinition, err error) {
        ctx, span := tracer.Start(ctx, "schema-reader.read-schema")
        defer span.End()

        builder := r.database.Builder.Select("name, serialized_definition, version").From(SchemaDefinitionTable).Where(squirrel.Eq{"version": version, "tenant_id": tenantID})

        var query string
        var args []interface{}

        query, args, err = builder.ToSql()
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, errors.New(base.ErrorCode_ERROR_CODE_SQL_BUILDER.String())
        }

        var rows *sql.Rows
        rows, err = r.database.DB.QueryContext(ctx, query, args...)
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, errors.New(base.ErrorCode_ERROR_CODE_EXECUTION.String())
        }
        defer rows.Close()

        var definitions []string
        for rows.Next() {
                sd := storage.SchemaDefinition{}
                err = rows.Scan(&sd.Name, &sd.SerializedDefinition, &sd.Version)
                if err != nil {
                        span.RecordError(err)
                        span.SetStatus(codes.Error, err.Error())
                        return nil, err
                }
                definitions = append(definitions, sd.Serialized())
        }
        if err = rows.Err(); err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, err
        }

        sch, err = schema.NewSchemaFromStringDefinitions(false, definitions...)
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, err
        }

        return sch, err
}

// ReadEntityDefinition - Reads entity config from the repository.
func (r *SchemaReader) ReadEntityDefinition(ctx context.Context, tenantID, name, version string) (definition *base.EntityDefinition, v string, err error) {
        ctx, span := tracer.Start(ctx, "schema-reader.read-entity-definition")
        defer span.End()

        builder := r.database.Builder.Select("name, serialized_definition, version").Where(squirrel.Eq{"name": name, "version": version, "tenant_id": tenantID}).From(SchemaDefinitionTable).Limit(1)

        var query string
        var args []interface{}

        query, args, err = builder.ToSql()
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SQL_BUILDER.String())
        }

        var def storage.SchemaDefinition
        row := r.database.DB.QueryRowContext(ctx, query, args...)
        if err = row.Err(); err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, "", errors.New(base.ErrorCode_ERROR_CODE_EXECUTION.String())
        }

        if err = row.Scan(&def.Name, &def.SerializedDefinition, &def.Version); err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                if errors.Is(err, sql.ErrNoRows) {
                        return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SCHEMA_NOT_FOUND.String())
                }
                return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SCAN.String())
        }

        var sch *base.SchemaDefinition
        sch, err = schema.NewSchemaFromStringDefinitions(false, def.Serialized())
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, "", err
        }

        definition, err = schema.GetEntityByName(sch, name)
        return definition, def.Version, err
}

// ReadRuleDefinition - Reads rule config from the repository.
func (r *SchemaReader) ReadRuleDefinition(ctx context.Context, tenantID, name, version string) (definition *base.RuleDefinition, v string, err error) {
        ctx, span := tracer.Start(ctx, "schema-reader.read-rule-definition")
        defer span.End()

        builder := r.database.Builder.Select("name, serialized_definition, version").Where(squirrel.Eq{"name": name, "version": version, "tenant_id": tenantID}).From(SchemaDefinitionTable).Limit(1)

        var query string
        var args []interface{}

        query, args, err = builder.ToSql()
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SQL_BUILDER.String())
        }

        var def storage.SchemaDefinition
        row := r.database.DB.QueryRowContext(ctx, query, args...)
        if err = row.Err(); err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, "", errors.New(base.ErrorCode_ERROR_CODE_EXECUTION.String())
        }

        if err = row.Scan(&def.Name, &def.SerializedDefinition, &def.Version); err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                if errors.Is(err, sql.ErrNoRows) {
                        return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SCHEMA_NOT_FOUND.String())
                }
                return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SCAN.String())
        }

        var sch *base.SchemaDefinition
        sch, err = schema.NewSchemaFromStringDefinitions(false, def.Serialized())
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return nil, "", err
        }

        definition, err = schema.GetRuleByName(sch, name)
        return definition, def.Version, err
}

// HeadVersion - Finds the latest version of the schema.
func (r *SchemaReader) HeadVersion(ctx context.Context, tenantID string) (version string, err error) {
        ctx, span := tracer.Start(ctx, "schema-reader.head-version")
        defer span.End()

        var query string
        var args []interface{}
        query, args, err = r.database.Builder.
                Select("version").From(SchemaDefinitionTable).Where(squirrel.Eq{"tenant_id": tenantID}).OrderBy("version DESC").Limit(1).
                ToSql()
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                return "", errors.New(base.ErrorCode_ERROR_CODE_SQL_BUILDER.String())
        }
        row := r.database.DB.QueryRowContext(ctx, query, args...)
        err = row.Scan(&version)
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())
                if errors.Is(err, sql.ErrNoRows) {
                        return "", errors.New(base.ErrorCode_ERROR_CODE_SCHEMA_NOT_FOUND.String())
                }
                return "", err
        }

        return version, nil
}

1	package postgres
2
3	import (
4	"context"
5	"database/sql"
6	"errors"
7
8	"github.com/Masterminds/squirrel"
9	"go.opentelemetry.io/otel/codes"
10
11	"github.com/Permify/permify/internal/schema"
12	"github.com/Permify/permify/internal/storage"
13	db "github.com/Permify/permify/pkg/database/postgres"
14	base "github.com/Permify/permify/pkg/pb/base/v1"
15	)
16
17	// SchemaReader - Structure for SchemaReader
18	type SchemaReader struct {
19	database *db.Postgres
20	// options
21	txOptions sql.TxOptions
22	}
23
24	// NewSchemaReader - Creates a new SchemaReader
25	func NewSchemaReader(database db.Postgres) SchemaReader {	5✔
26	return &SchemaReader{	5✔
27	database: database,	5✔
28	txOptions: sql.TxOptions{Isolation: sql.LevelReadCommitted, ReadOnly: true},	5✔
29	}	5✔
30	}	5✔
31
32	// ReadSchema - Reads entity config from the repository.
33	func (r SchemaReader) ReadSchema(ctx context.Context, tenantID, version string) (sch base.SchemaDefinition, err error) {	2✔
34	ctx, span := tracer.Start(ctx, "schema-reader.read-schema")	2✔
35	defer span.End()	2✔
36		2✔
37	builder := r.database.Builder.Select("name, serialized_definition, version").From(SchemaDefinitionTable).Where(squirrel.Eq{"version": version, "tenant_id": tenantID})	2✔
38		2✔
39	var query string	2✔
40	var args []interface{}	2✔
41		2✔
42	query, args, err = builder.ToSql()	2✔
43	if err != nil {	2✔
44	span.RecordError(err)	×
45	span.SetStatus(codes.Error, err.Error())	×
46	return nil, errors.New(base.ErrorCode_ERROR_CODE_SQL_BUILDER.String())	×
47	}	×
48
49	var rows *sql.Rows	2✔
50	rows, err = r.database.DB.QueryContext(ctx, query, args...)	2✔
51	if err != nil {	2✔
52	span.RecordError(err)	×
53	span.SetStatus(codes.Error, err.Error())	×
54	return nil, errors.New(base.ErrorCode_ERROR_CODE_EXECUTION.String())	×
55	}	×
56	defer rows.Close()	2✔
57		2✔
58	var definitions []string	2✔
59	for rows.Next() {	6✔
60	sd := storage.SchemaDefinition{}	4✔
61	err = rows.Scan(&sd.Name, &sd.SerializedDefinition, &sd.Version)	4✔
62	if err != nil {	4✔
63	span.RecordError(err)	×
64	span.SetStatus(codes.Error, err.Error())	×
65	return nil, err	×
66	}	×
67	definitions = append(definitions, sd.Serialized())	4✔
68	}
69	if err = rows.Err(); err != nil {	2✔
70	span.RecordError(err)	×
71	span.SetStatus(codes.Error, err.Error())	×
72	return nil, err	×
73	}	×
74
75	sch, err = schema.NewSchemaFromStringDefinitions(false, definitions...)	2✔
76	if err != nil {	2✔
77	span.RecordError(err)	×
78	span.SetStatus(codes.Error, err.Error())	×
79	return nil, err	×
80	}	×
81
82	return sch, err	2✔
83	}
84
85	// ReadEntityDefinition - Reads entity config from the repository.
86	func (r SchemaReader) ReadEntityDefinition(ctx context.Context, tenantID, name, version string) (definition base.EntityDefinition, v string, err error) {	1✔
87	ctx, span := tracer.Start(ctx, "schema-reader.read-entity-definition")	1✔
88	defer span.End()	1✔
89		1✔
90	builder := r.database.Builder.Select("name, serialized_definition, version").Where(squirrel.Eq{"name": name, "version": version, "tenant_id": tenantID}).From(SchemaDefinitionTable).Limit(1)	1✔
91		1✔
92	var query string	1✔
93	var args []interface{}	1✔
94		1✔
95	query, args, err = builder.ToSql()	1✔
96	if err != nil {	1✔
97	span.RecordError(err)	×
98	span.SetStatus(codes.Error, err.Error())	×
99	return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SQL_BUILDER.String())	×
100	}	×
101
102	var def storage.SchemaDefinition	1✔
103	row := r.database.DB.QueryRowContext(ctx, query, args...)	1✔
104	if err = row.Err(); err != nil {	1✔
105	span.RecordError(err)	×
106	span.SetStatus(codes.Error, err.Error())	×
107	return nil, "", errors.New(base.ErrorCode_ERROR_CODE_EXECUTION.String())	×
108	}	×
109
110	if err = row.Scan(&def.Name, &def.SerializedDefinition, &def.Version); err != nil {	1✔
111	span.RecordError(err)	×
112	span.SetStatus(codes.Error, err.Error())	×
113	if errors.Is(err, sql.ErrNoRows) {	×
114	return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SCHEMA_NOT_FOUND.String())	×
115	}	×
116	return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SCAN.String())	×
117	}
118
119	var sch *base.SchemaDefinition	1✔
120	sch, err = schema.NewSchemaFromStringDefinitions(false, def.Serialized())	1✔
121	if err != nil {	1✔
122	span.RecordError(err)	×
123	span.SetStatus(codes.Error, err.Error())	×
124	return nil, "", err	×
125	}	×
126
127	definition, err = schema.GetEntityByName(sch, name)	1✔
128	return definition, def.Version, err	1✔
129	}
130
131	// ReadRuleDefinition - Reads rule config from the repository.
132	func (r SchemaReader) ReadRuleDefinition(ctx context.Context, tenantID, name, version string) (definition base.RuleDefinition, v string, err error) {	1✔
133	ctx, span := tracer.Start(ctx, "schema-reader.read-rule-definition")	1✔
134	defer span.End()	1✔
135		1✔
136	builder := r.database.Builder.Select("name, serialized_definition, version").Where(squirrel.Eq{"name": name, "version": version, "tenant_id": tenantID}).From(SchemaDefinitionTable).Limit(1)	1✔
137		1✔
138	var query string	1✔
139	var args []interface{}	1✔
140		1✔
141	query, args, err = builder.ToSql()	1✔
142	if err != nil {	1✔
143	span.RecordError(err)	×
144	span.SetStatus(codes.Error, err.Error())	×
145	return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SQL_BUILDER.String())	×
146	}	×
147
148	var def storage.SchemaDefinition	1✔
149	row := r.database.DB.QueryRowContext(ctx, query, args...)	1✔
150	if err = row.Err(); err != nil {	1✔
151	span.RecordError(err)	×
152	span.SetStatus(codes.Error, err.Error())	×
153	return nil, "", errors.New(base.ErrorCode_ERROR_CODE_EXECUTION.String())	×
154	}	×
155
156	if err = row.Scan(&def.Name, &def.SerializedDefinition, &def.Version); err != nil {	1✔
157	span.RecordError(err)	×
158	span.SetStatus(codes.Error, err.Error())	×
159	if errors.Is(err, sql.ErrNoRows) {	×
160	return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SCHEMA_NOT_FOUND.String())	×
161	}	×
162	return nil, "", errors.New(base.ErrorCode_ERROR_CODE_SCAN.String())	×
163	}
164
165	var sch *base.SchemaDefinition	1✔
166	sch, err = schema.NewSchemaFromStringDefinitions(false, def.Serialized())	1✔
167	if err != nil {	1✔
168	span.RecordError(err)	×
169	span.SetStatus(codes.Error, err.Error())	×
170	return nil, "", err	×
171	}	×
172
173	definition, err = schema.GetRuleByName(sch, name)	1✔
174	return definition, def.Version, err	1✔
175	}
176
177	// HeadVersion - Finds the latest version of the schema.
178	func (r *SchemaReader) HeadVersion(ctx context.Context, tenantID string) (version string, err error) {	1✔
179	ctx, span := tracer.Start(ctx, "schema-reader.head-version")	1✔
180	defer span.End()	1✔
181		1✔
182	var query string	1✔
183	var args []interface{}	1✔
184	query, args, err = r.database.Builder.	1✔
185	Select("version").From(SchemaDefinitionTable).Where(squirrel.Eq{"tenant_id": tenantID}).OrderBy("version DESC").Limit(1).	1✔
186	ToSql()	1✔
187	if err != nil {	1✔
188	span.RecordError(err)	×
189	span.SetStatus(codes.Error, err.Error())	×
190	return "", errors.New(base.ErrorCode_ERROR_CODE_SQL_BUILDER.String())	×
191	}	×
192	row := r.database.DB.QueryRowContext(ctx, query, args...)	1✔
193	err = row.Scan(&version)	1✔
194	if err != nil {	1✔
195	span.RecordError(err)	×
196	span.SetStatus(codes.Error, err.Error())	×
197	if errors.Is(err, sql.ErrNoRows) {	×
198	return "", errors.New(base.ErrorCode_ERROR_CODE_SCHEMA_NOT_FOUND.String())	×
199	}	×
200	return "", err	×
201	}
202
203	return version, nil	1✔
204	}

Permify / permify / 6862777535

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