ast.*Schema.DeleteStatement - Code Metrics - Inspection of "feat: partial schema write feature" - Permify/permify - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1153)

by Tolga

created 2024-03-24 14:05 UTC

ast.*Schema.DeleteStatement F

↳ Parent: pkg/dsl/ast/schema.go

Complexity

Conditions

Size

Total Lines	63
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	14
eloc	34
nop	2
dl	0
loc	63
rs	3.6
c	0
b	0
f	0

How to fix Long Method Complexity

package ast

import (
	"errors"
	"fmt"
	"strings"

	base "github.com/Permify/permify/pkg/pb/base/v1"
)

// Schema represents the parsed schema, which contains all the statements
// and extracted entity and relational references used by the schema. It
// is used as an intermediate representation before generating the
// corresponding metadata.
type Schema struct {
	// The list of statements in the schema
	Statements []Statement

	// references - Map of all relational references extracted from the schema
	references *References
}

func NewSchema() *Schema {
	return &Schema{
		Statements: []Statement{},
		references: NewReferences(),
	}
}

// String -
func (sch *Schema) String() string {
	stmts := make([]string, 0, len(sch.Statements))
	for _, stmt := range sch.Statements {
		stmts = append(stmts, stmt.String())
	}
	return strings.Join(stmts, "\n")
}

// GetReferences -
func (sch *Schema) GetReferences() *References {
	return sch.references
}

// SetReferences -
func (sch *Schema) SetReferences(refs *References) {
	sch.references = refs
}

// AddStatement adds a new statement to an entity within the schema. It also updates the schema's references.
func (sch *Schema) AddStatement(entityName string, stmt Statement) error {
	// Loop through all statements in the schema to find the one matching the entity name.
	var entityStmt *EntityStatement
	for _, statement := range sch.Statements {
		if statement.GetName() == entityName {
			// Attempt to cast the found statement to an EntityStatement.
			es, ok := statement.(*EntityStatement)
			if ok {
				entityStmt = es // Successfully found and cast the EntityStatement.
				break
			} else {
				return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ENTITY_STATEMENT.String()) // Casting failed.
			}
		}
	}

	// If no matching entity was found, return an error.
	if entityStmt == nil {
		return errors.New(base.ErrorCode_ERROR_CODE_ENTITY_STATEMENT_NOT_FOUND.String())
	}

	// Construct a unique key for the new statement.
	refKey := fmt.Sprintf("%s#%s", entityName, stmt.GetName())

	// Check if a reference for this statement already exists in the schema.
	if sch.GetReferences().IsReferenceExist(refKey) {
		return errors.New(base.ErrorCode_ERROR_CODE_ALREADY_EXIST.String()) // Avoid duplicating references.
	}

	// Add the new statement to the appropriate list in the EntityStatement, based on its type.
	switch stmt.StatementType() {
	case PERMISSION_STATEMENT:
		// Append the new permission statement to the list of permission statements for the entity.
		entityStmt.PermissionStatements = append(entityStmt.PermissionStatements, stmt)
		// Add a new permission reference to the schema's references.
		return sch.GetReferences().AddPermissionReference(refKey)

	case RELATION_STATEMENT:
		// Append the new relation statement to the list of relation statements for the entity.
		entityStmt.RelationStatements = append(entityStmt.RelationStatements, stmt)
		// Check if the statement can be cast to a RelationStatement and add its references.
		if rs, ok := stmt.(*RelationStatement); ok {
			return sch.GetReferences().AddRelationReferences(refKey, rs.RelationTypes)
		} else {
			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_RELATION_STATEMENT.String())
		}

	case ATTRIBUTE_STATEMENT:
		// Append the new attribute statement to the list of attribute statements for the entity.
		entityStmt.AttributeStatements = append(entityStmt.AttributeStatements, stmt)
		// Check if the statement can be cast to an AttributeStatement and add its references.
		if as, ok := stmt.(*AttributeStatement); ok {
			return sch.GetReferences().AddAttributeReferences(refKey, as.AttributeType)
		} else {
			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ATTRIBUTE_STATEMENT.String())
		}

	default:
		// The statement type is unknown, return an error.
		return errors.New(base.ErrorCode_ERROR_CODE_UNKNOWN_STATEMENT_TYPE.String())
	}
}

// UpdateStatement updates a statement of a specific type (permission, relation, or attribute)
// for a given entity within the schema. It either updates an existing statement or appends a new one if not found.
func (sch *Schema) UpdateStatement(entityName string, newStmt Statement) error {
	// Iterate through all statements in the schema to find the one matching the entity name.
	for _, statement := range sch.Statements {
		if statement.GetName() == entityName {
			// Convert the generic statement interface to a specific EntityStatement type.
			entityStmt, ok := statement.(*EntityStatement)
			if !ok {
				return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ENTITY_STATEMENT.String())
			}

			// Construct a unique reference key for the new statement.
			referenceKey := fmt.Sprintf("%s#%s", entityName, newStmt.GetName())

			// Check if a reference for the statement already exists within the schema.
			if !sch.GetReferences().IsReferenceExist(referenceKey) {
				return errors.New(base.ErrorCode_ERROR_CODE_REFERENCE_NOT_FOUND.String())
			}

			// Based on the statement type, update the corresponding list in the EntityStatement.
			switch newStmt.StatementType() {
			case PERMISSION_STATEMENT, RELATION_STATEMENT, ATTRIBUTE_STATEMENT:
				var stmts *[]Statement // Pointer to the slice of statements to update.

				// Assign the correct slice based on the type of the new statement.
				switch newStmt.StatementType() {
				case PERMISSION_STATEMENT:
					stmts = &entityStmt.PermissionStatements
				case RELATION_STATEMENT:
					stmts = &entityStmt.RelationStatements
				case ATTRIBUTE_STATEMENT:
					stmts = &entityStmt.AttributeStatements
				}

				// Flag to check if the statement has been updated.
				updated := false

				// Iterate over the statements to find and update the one with the matching name.
				for i, stmt := range *stmts {
					if stmt.GetName() == newStmt.GetName() {
						(*stmts)[i] = newStmt
						updated = true
						break // Stop iterating once the statement is updated.
					}
				}

				// If the statement was not found and updated, append it to the slice.
				if !updated {
					*stmts = append(*stmts, newStmt)
				}

				// Update the reference in the schema based on the statement type.
				switch newStmt.StatementType() {
				case PERMISSION_STATEMENT:
					return sch.GetReferences().UpdatePermissionReference(referenceKey)
				case RELATION_STATEMENT:
					if rs, ok := newStmt.(*RelationStatement); ok {
						return sch.GetReferences().UpdateRelationReferences(referenceKey, rs.RelationTypes)
					}
					return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_RELATION_STATEMENT.String())
				case ATTRIBUTE_STATEMENT:
					if as, ok := newStmt.(*AttributeStatement); ok {
						return sch.GetReferences().UpdateAttributeReferences(referenceKey, as.AttributeType)
					}
					return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ATTRIBUTE_STATEMENT.String())
				}
			default:
				return errors.New(base.ErrorCode_ERROR_CODE_UNKNOWN_STATEMENT_TYPE.String())
			}
			// Return nil to indicate successful update.
			return nil
		}
	}

	// If no matching entity statement is found, return an error.
	return errors.New(base.ErrorCode_ERROR_CODE_ENTITY_STATEMENT_NOT_FOUND.String())
}

// DeleteStatement removes a specific statement from an entity within the schema.
// It identifies the statement by its name and the name of the entity it belongs to.
// If successful, it also removes the corresponding reference from the schema.
func (sch *Schema) DeleteStatement(entityName, name string) error {
	// Iterate over all statements in the schema to find the entity by name.
	for _, statement := range sch.Statements {
		if statement.GetName() == entityName {
			// Try to convert the found statement into an EntityStatement.
			entityStmt, ok := statement.(*EntityStatement)
			if !ok {
				// If conversion fails, return an error indicating wrong type.
				return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ENTITY_STATEMENT.String())
			}

			// Construct the reference key from the entity and statement names.
			referenceKey := fmt.Sprintf("%s#%s", entityName, name)
			// Retrieve the type of reference associated with the key.
			refType, ok := sch.GetReferences().GetReferenceType(referenceKey)
			if !ok {
				// If no reference is found, return an error.
				return errors.New(base.ErrorCode_ERROR_CODE_REFERENCE_NOT_FOUND.String())
			}

			// Declare a variable to hold the target list of statements for modification.
			var targetStatements *[]Statement
			// Assign the targetStatements pointer based on the reference type.
			switch refType {
			case PERMISSION:
				targetStatements = &entityStmt.PermissionStatements
			case RELATION:
				targetStatements = &entityStmt.RelationStatements
			case ATTRIBUTE:
				targetStatements = &entityStmt.AttributeStatements
			default:
				// If the reference type is unknown, return an error.
				return errors.New(base.ErrorCode_ERROR_CODE_UNKNOWN_REFERENCE_TYPE.String())
			}

			// Create a new slice to hold all statements except the one to be deleted.
			var newStatements []Statement
			for _, stmt := range *targetStatements {
				if stmt.GetName() != name {
					// If the statement is not the one to delete, add it to the new slice.
					newStatements = append(newStatements, stmt)
				}
			}
			// Replace the old slice with the new slice, effectively deleting the statement.
			*targetStatements = newStatements

			// Remove the corresponding reference based on the reference type.
			switch refType {
			case PERMISSION:
				return sch.GetReferences().RemovePermissionReference(referenceKey)
			case RELATION:
				return sch.GetReferences().RemoveRelationReferences(referenceKey)
			case ATTRIBUTE:
				return sch.GetReferences().RemoveAttributeReferences(referenceKey)
			}

			// If the statement was successfully removed, return nil to indicate success.
			return nil
		}
	}

	// If no matching entity is found in the schema, return an error.
	return errors.New(base.ErrorCode_ERROR_CODE_ENTITY_STATEMENT_NOT_FOUND.String())
}


1			package ast
2
3			import (
4			"errors"
5			"fmt"
6			"strings"
7
8			base "github.com/Permify/permify/pkg/pb/base/v1"
9			)
10
11			// Schema represents the parsed schema, which contains all the statements
12			// and extracted entity and relational references used by the schema. It
13			// is used as an intermediate representation before generating the
14			// corresponding metadata.
15			type Schema struct {
16			// The list of statements in the schema
17			Statements []Statement
18
19			// references - Map of all relational references extracted from the schema
20			references *References
21			}
22
23			func NewSchema() *Schema {
24			return &Schema{
25			Statements: []Statement{},
26			references: NewReferences(),
27			}
28			}
29
30			// String -
31			func (sch *Schema) String() string {
32			stmts := make([]string, 0, len(sch.Statements))
33			for _, stmt := range sch.Statements {
34			stmts = append(stmts, stmt.String())
35			}
36			return strings.Join(stmts, "\n")
37			}
38
39			// GetReferences -
40			func (sch Schema) GetReferences() References {
41			return sch.references
42			}
43
44			// SetReferences -
45			func (sch Schema) SetReferences(refs References) {
46			sch.references = refs
47			}
48
49			// AddStatement adds a new statement to an entity within the schema. It also updates the schema's references.
50			func (sch *Schema) AddStatement(entityName string, stmt Statement) error {
51			// Loop through all statements in the schema to find the one matching the entity name.
52			var entityStmt *EntityStatement
53			for _, statement := range sch.Statements {
54			if statement.GetName() == entityName {
55			// Attempt to cast the found statement to an EntityStatement.
56			es, ok := statement.(*EntityStatement)
57			if ok {
58			entityStmt = es // Successfully found and cast the EntityStatement.
59			break
60			} else {
61			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ENTITY_STATEMENT.String()) // Casting failed.
62			}
63			}
64			}
65
66			// If no matching entity was found, return an error.
67			if entityStmt == nil {
68			return errors.New(base.ErrorCode_ERROR_CODE_ENTITY_STATEMENT_NOT_FOUND.String())
69			}
70
71			// Construct a unique key for the new statement.
72			refKey := fmt.Sprintf("%s#%s", entityName, stmt.GetName())
73
74			// Check if a reference for this statement already exists in the schema.
75			if sch.GetReferences().IsReferenceExist(refKey) {
76			return errors.New(base.ErrorCode_ERROR_CODE_ALREADY_EXIST.String()) // Avoid duplicating references.
77			}
78
79			// Add the new statement to the appropriate list in the EntityStatement, based on its type.
80			switch stmt.StatementType() {
81			case PERMISSION_STATEMENT:
82			// Append the new permission statement to the list of permission statements for the entity.
83			entityStmt.PermissionStatements = append(entityStmt.PermissionStatements, stmt)
84			// Add a new permission reference to the schema's references.
85			return sch.GetReferences().AddPermissionReference(refKey)
86
87			case RELATION_STATEMENT:
88			// Append the new relation statement to the list of relation statements for the entity.
89			entityStmt.RelationStatements = append(entityStmt.RelationStatements, stmt)
90			// Check if the statement can be cast to a RelationStatement and add its references.
91			if rs, ok := stmt.(*RelationStatement); ok {
92			return sch.GetReferences().AddRelationReferences(refKey, rs.RelationTypes)
93			} else {
94			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_RELATION_STATEMENT.String())
95			}
96
97			case ATTRIBUTE_STATEMENT:
98			// Append the new attribute statement to the list of attribute statements for the entity.
99			entityStmt.AttributeStatements = append(entityStmt.AttributeStatements, stmt)
100			// Check if the statement can be cast to an AttributeStatement and add its references.
101			if as, ok := stmt.(*AttributeStatement); ok {
102			return sch.GetReferences().AddAttributeReferences(refKey, as.AttributeType)
103			} else {
104			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ATTRIBUTE_STATEMENT.String())
105			}
106
107			default:
108			// The statement type is unknown, return an error.
109			return errors.New(base.ErrorCode_ERROR_CODE_UNKNOWN_STATEMENT_TYPE.String())
110			}
111			}
112
113			// UpdateStatement updates a statement of a specific type (permission, relation, or attribute)
114			// for a given entity within the schema. It either updates an existing statement or appends a new one if not found.
115			func (sch *Schema) UpdateStatement(entityName string, newStmt Statement) error {
116			// Iterate through all statements in the schema to find the one matching the entity name.
117			for _, statement := range sch.Statements {
118			if statement.GetName() == entityName {
119			// Convert the generic statement interface to a specific EntityStatement type.
120			entityStmt, ok := statement.(*EntityStatement)
121			if !ok {
122			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ENTITY_STATEMENT.String())
123			}
124
125			// Construct a unique reference key for the new statement.
126			referenceKey := fmt.Sprintf("%s#%s", entityName, newStmt.GetName())
127
128			// Check if a reference for the statement already exists within the schema.
129			if !sch.GetReferences().IsReferenceExist(referenceKey) {
130			return errors.New(base.ErrorCode_ERROR_CODE_REFERENCE_NOT_FOUND.String())
131			}
132
133			// Based on the statement type, update the corresponding list in the EntityStatement.
134			switch newStmt.StatementType() {
135			case PERMISSION_STATEMENT, RELATION_STATEMENT, ATTRIBUTE_STATEMENT:
136			var stmts *[]Statement // Pointer to the slice of statements to update.
137
138			// Assign the correct slice based on the type of the new statement.
139			switch newStmt.StatementType() {
140			case PERMISSION_STATEMENT:
141			stmts = &entityStmt.PermissionStatements
142			case RELATION_STATEMENT:
143			stmts = &entityStmt.RelationStatements
144			case ATTRIBUTE_STATEMENT:
145			stmts = &entityStmt.AttributeStatements
146			}
147
148			// Flag to check if the statement has been updated.
149			updated := false
150
151			// Iterate over the statements to find and update the one with the matching name.
152			for i, stmt := range *stmts {
153			if stmt.GetName() == newStmt.GetName() {
154			(*stmts)[i] = newStmt
155			updated = true
156			break // Stop iterating once the statement is updated.
157			}
158			}
159
160			// If the statement was not found and updated, append it to the slice.
161			if !updated {
162			stmts = append(stmts, newStmt)
163			}
164
165			// Update the reference in the schema based on the statement type.
166			switch newStmt.StatementType() {
167			case PERMISSION_STATEMENT:
168			return sch.GetReferences().UpdatePermissionReference(referenceKey)
169			case RELATION_STATEMENT:
170			if rs, ok := newStmt.(*RelationStatement); ok {
171			return sch.GetReferences().UpdateRelationReferences(referenceKey, rs.RelationTypes)
172			}
173			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_RELATION_STATEMENT.String())
174			case ATTRIBUTE_STATEMENT:
175			if as, ok := newStmt.(*AttributeStatement); ok {
176			return sch.GetReferences().UpdateAttributeReferences(referenceKey, as.AttributeType)
177			}
178			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ATTRIBUTE_STATEMENT.String())
179			}
180			default:
181			return errors.New(base.ErrorCode_ERROR_CODE_UNKNOWN_STATEMENT_TYPE.String())
182			}
183			// Return nil to indicate successful update.
184			return nil
185			}
186			}
187
188			// If no matching entity statement is found, return an error.
189			return errors.New(base.ErrorCode_ERROR_CODE_ENTITY_STATEMENT_NOT_FOUND.String())
190			}
191
192			// DeleteStatement removes a specific statement from an entity within the schema.
193			// It identifies the statement by its name and the name of the entity it belongs to.
194			// If successful, it also removes the corresponding reference from the schema.
195			func (sch *Schema) DeleteStatement(entityName, name string) error {
196			// Iterate over all statements in the schema to find the entity by name.
197			for _, statement := range sch.Statements {
198			if statement.GetName() == entityName {
199			// Try to convert the found statement into an EntityStatement.
200			entityStmt, ok := statement.(*EntityStatement)
201			if !ok {
202			// If conversion fails, return an error indicating wrong type.
203			return errors.New(base.ErrorCode_ERROR_CODE_CANNOT_CONVERT_TO_ENTITY_STATEMENT.String())
204			}
205
206			// Construct the reference key from the entity and statement names.
207			referenceKey := fmt.Sprintf("%s#%s", entityName, name)
208			// Retrieve the type of reference associated with the key.
209			refType, ok := sch.GetReferences().GetReferenceType(referenceKey)
210			if !ok {
211			// If no reference is found, return an error.
212			return errors.New(base.ErrorCode_ERROR_CODE_REFERENCE_NOT_FOUND.String())
213			}
214
215			// Declare a variable to hold the target list of statements for modification.
216			var targetStatements *[]Statement
217			// Assign the targetStatements pointer based on the reference type.
218			switch refType {
219			case PERMISSION:
220			targetStatements = &entityStmt.PermissionStatements
221			case RELATION:
222			targetStatements = &entityStmt.RelationStatements
223			case ATTRIBUTE:
224			targetStatements = &entityStmt.AttributeStatements
225			default:
226			// If the reference type is unknown, return an error.
227			return errors.New(base.ErrorCode_ERROR_CODE_UNKNOWN_REFERENCE_TYPE.String())
228			}
229
230			// Create a new slice to hold all statements except the one to be deleted.
231			var newStatements []Statement
232			for _, stmt := range *targetStatements {
233			if stmt.GetName() != name {
234			// If the statement is not the one to delete, add it to the new slice.
235			newStatements = append(newStatements, stmt)
236			}
237			}
238			// Replace the old slice with the new slice, effectively deleting the statement.
239			*targetStatements = newStatements
240
241			// Remove the corresponding reference based on the reference type.
242			switch refType {
243			case PERMISSION:
244			return sch.GetReferences().RemovePermissionReference(referenceKey)
245			case RELATION:
246			return sch.GetReferences().RemoveRelationReferences(referenceKey)
247			case ATTRIBUTE:
248			return sch.GetReferences().RemoveAttributeReferences(referenceKey)
249			}
250
251			// If the statement was successfully removed, return nil to indicate success.
252			return nil
253			}
254			}
255
256			// If no matching entity is found in the schema, return an error.
257			return errors.New(base.ErrorCode_ERROR_CODE_ENTITY_STATEMENT_NOT_FOUND.String())
258			}
259

Permify / permify

Pull Request — master (#1153)

ast.*Schema.DeleteStatement F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like