Function NewSchemaFromEntityAndRuleDefinitions

internal/schema/schema.go:30–73

NewSchemaFromEntityAndRuleDefinitions creates a new base.SchemaDefinition from entity and rule definitions. It takes two slices of pointers to base.EntityDefinition and base.RuleDefinition, representing the entities and rules to include in the schema. It returns a pointer to the created base.SchemaD

(entities []*base.EntityDefinition, rules []*base.RuleDefinition)

// It takes two slices of pointers to base.EntityDefinition and base.RuleDefinition, representing the entities and rules to include in the schema.
// It returns a pointer to the created base.SchemaDefinition.
func NewSchemaFromEntityAndRuleDefinitions(entities []*base.EntityDefinition, rules []*base.RuleDefinition) *base.SchemaDefinition {
	// Create a new base.SchemaDefinition with empty maps for EntityDefinitions, RuleDefinitions, and References.
	schema := &base.SchemaDefinition{
		EntityDefinitions: map[string]*base.EntityDefinition{},
		RuleDefinitions:   map[string]*base.RuleDefinition{},
		References:        map[string]base.SchemaDefinition_Reference{},
	}

	// Process each entity in the entities slice.
	for _, entity := range entities {
		// If the entity's Relations map is nil, initialize it as an empty map.
		if entity.Relations == nil {
			entity.Relations = map[string]*base.RelationDefinition{}
		}

		// If the entity's Permissions map is nil, initialize it as an empty map.
		if entity.Permissions == nil {
			entity.Permissions = map[string]*base.PermissionDefinition{}
		}

		// Add the entity to the EntityDefinitions map of the schema, using its name as the key.
		schema.EntityDefinitions[entity.Name] = entity

		// Set a reference for the entity in the References map of the schema, indicating it's an entity reference.
		schema.References[entity.Name] = base.SchemaDefinition_REFERENCE_ENTITY
	}

	// Process each rule in the rules slice.
	for _, rule := range rules {
		// If the rule's Arguments map is nil, initialize it as an empty map.
		if rule.Arguments == nil {
			rule.Arguments = map[string]base.AttributeType{}
		}

		// Add the rule to the RuleDefinitions map of the schema, using its name as the key.
		schema.RuleDefinitions[rule.Name] = rule

		// Set a reference for the rule in the References map of the schema, indicating it's a rule reference.
		schema.References[rule.Name] = base.SchemaDefinition_REFERENCE_RULE
	}

	// Return the created schema.
	return schema
}

func NewEntityAndRuleDefinitionsFromStringDefinitions(validation bool, definitions ...string) ([]*base.EntityDefinition, []*base.RuleDefinition, error) {
	// Use the parser to parse the string definitions into a Schema object