resources

Documentation

Index

• Constants
• Variables
• func GetAllSystemResources() []*model.Resource
• func GetSystemResourceType(resource *model.Resource) proto.Message

Constants

const OpenApiInternal = "internal"

const OpenApiMeta = "meta"

Variables

var AuditLogResource = &model.Resource{
	Name:      "AuditLog",
	Namespace: "system",
	SourceConfig: &model.ResourceSourceConfig{
		DataSource: "system",
		Entity:     "audit_log",
	},
	Immutable: true,
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		special.VersionProperty,
		{
			Name:     "namespace",
			Length:   256,
			Type:     model.ResourceProperty_STRING,
			Required: true,
		},
		{
			Name:     "resource",
			Length:   256,
			Type:     model.ResourceProperty_STRING,
			Required: true,
		},
		{
			Name:     "recordId",
			Length:   256,
			Type:     model.ResourceProperty_STRING,
			Required: true,
			Annotations: map[string]string{
				annotations.SourceDef: "record_id",
			},
		},
		{
			Name:     "time",
			Type:     model.ResourceProperty_TIMESTAMP,
			Required: true,
		},
		{
			Name:     "username",
			Type:     model.ResourceProperty_STRING,
			Required: true,
		},
		{
			Name:     "operation",
			Type:     model.ResourceProperty_ENUM,
			Required: true,
			EnumValues: []string{
				"CREATE",
				"UPDATE",
				"DELETE",
			},
		},
		{
			Name:     "properties",
			Type:     model.ResourceProperty_OBJECT,
			Required: false,
		},
		special.AnnotationsProperty,
	},
	Annotations: map[string]string{
		annotations.OpenApiGroup:     OpenApiInternal,
		annotations.BypassExtensions: annotations.Enabled,
	},
}

var DataSourceResource = &model.Resource{
	Name:      "DataSource",
	Namespace: "system",
	SourceConfig: &model.ResourceSourceConfig{
		DataSource: "system",
		Entity:     "data_source",
	},
	Types: []*model.ResourceSubType{
		special.AuditDataSubType,
	},
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		special.VersionProperty,
		special.AuditProperty,
		{
			Name:     "name",
			Length:   64,
			Unique:   true,
			Type:     model.ResourceProperty_STRING,
			Required: true,
			Annotations: map[string]string{
				annotations.IsHclLabel: annotations.Enabled,
			},
		},
		{
			Name:     "description",
			Length:   64,
			Type:     model.ResourceProperty_STRING,
			Required: false,
			Annotations: map[string]string{
				annotations.AllowEmptyPrimitive: annotations.Enabled,
			},
		},
		{
			Name:     "backend",
			Type:     model.ResourceProperty_STRING,
			Required: true,
		},
		{
			Name:     "options",
			Required: true,
			Type:     model.ResourceProperty_MAP,
			Item: &model.ResourceProperty{
				Type: model.ResourceProperty_STRING,
			},
		},
	},
	Annotations: map[string]string{
		annotations.EnableAudit:  "true",
		annotations.OpenApiGroup: OpenApiInternal,
	},
}

var ExtensionResource = &model.Resource{
	Name:      "Extension",
	Namespace: "system",
	SourceConfig: &model.ResourceSourceConfig{
		DataSource: "system",
		Entity:     "extension",
	},
	Types: []*model.ResourceSubType{
		sub_types.BooleanExpression,
		sub_types.PairExpression,
		sub_types.Expression,
		special.AuditDataSubType,
		{
			Name: "FunctionCall",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name:     "host",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
				{
					Name:     "functionName",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
			},
		},
		{
			Name: "HttpCall",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name:     "uri",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
				{
					Name:     "method",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
			},
		},
		{
			Name: "ChannelCall",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name:     "channelKey",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
			},
		},
		{
			Name: "ExternalCall",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name:    "functionCall",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("FunctionCall"),
				},
				{
					Name:    "httpCall",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("HttpCall"),
				},
				{
					Name:    "channelCall",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("ChannelCall"),
				},
			},
		},
		{
			Name: "EventSelector",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name: "actions",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name: "action",
						Type: model.ResourceProperty_ENUM,
						EnumValues: []string{
							"CREATE",
							"UPDATE",
							"DELETE",
							"GET",
							"LIST",
							"OPERATE",
						},
						Annotations: map[string]string{
							annotations.TypeName: "EventAction",
						},
					},
				},
				{
					Name:    "recordSelector",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer(sub_types.BooleanExpression.Name),
				},
				{
					Name: "namespaces",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{Type: model.ResourceProperty_STRING},
				},
				{
					Name: "resources",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{Type: model.ResourceProperty_STRING},
				},
				{
					Name: "ids",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{Type: model.ResourceProperty_STRING},
				},
				special.AnnotationsProperty,
			},
		},
		{
			Name: "RecordSearchParams",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name:    "query",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: &sub_types.BooleanExpression.Name,
				},
				{
					Name: "limit",
					Type: model.ResourceProperty_INT32,
				},
				{
					Name: "offset",
					Type: model.ResourceProperty_INT32,
				},
				{
					Name: "resolveReferences",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Type: model.ResourceProperty_STRING,
					},
				},
			},
		},
		{
			Name: "Event",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name:      "id",
					Type:      model.ResourceProperty_STRING,
					Required:  true,
					Immutable: true,
				},
				{
					Name: "action",
					Type: model.ResourceProperty_ENUM,
					EnumValues: []string{
						"CREATE",
						"UPDATE",
						"DELETE",
						"GET",
						"LIST",
						"OPERATE",
					},
					Required: true,
				},
				{
					Name:    "recordSearchParams",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("RecordSearchParams"),
				},
				{
					Name: "resource",
					Type: model.ResourceProperty_REFERENCE,
					Reference: &model.Reference{
						Resource: "Resource",
					},
				},
				{
					Name: "records",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Type: model.ResourceProperty_REFERENCE,
						Reference: &model.Reference{
							Resource: "Record",
						},
					},
				},
				{
					Name: "finalizes",
					Type: model.ResourceProperty_BOOL,
				},
				{
					Name: "sync",
					Type: model.ResourceProperty_BOOL,
				},
				{
					Name: "time",
					Type: model.ResourceProperty_TIMESTAMP,
				},
				{
					Name: "total",
					Type: model.ResourceProperty_INT64,
				},
				special.AnnotationsProperty,
				{
					Name:    "error",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("Error"),
				},
			},
		},
		{
			Name: "ErrorField",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name: "recordId",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "property",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "message",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "value",
					Type: model.ResourceProperty_OBJECT,
				},
			},
		},
		{
			Name: "Error",
			Annotations: map[string]string{
				annotations.CommonType: annotations.Enabled,
			},
			Properties: []*model.ResourceProperty{
				{
					Name: "code",
					Type: model.ResourceProperty_ENUM,
					EnumValues: []string{
						"UNKNOWN_ERROR",
						"RECORD_NOT_FOUND",
						"UNABLE_TO_LOCATE_PRIMARY_KEY",
						"INTERNAL_ERROR",
						"PROPERTY_NOT_FOUND",
						"RECORD_VALIDATION_ERROR",
						"RESOURCE_VALIDATION_ERROR",
						"AUTHENTICATION_FAILED",
						"ALREADY_EXISTS",
						"ACCESS_DENIED",
						"BACKEND_ERROR",
						"UNIQUE_VIOLATION",
						"REFERENCE_VIOLATION",
						"RESOURCE_NOT_FOUND",
						"UNSUPPORTED_OPERATION",
						"EXTERNAL_BACKEND_COMMUNICATION_ERROR",
						"EXTERNAL_BACKEND_ERROR",
						"RATE_LIMIT_ERROR",
					},
				},
				{
					Name: "message",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "fields",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("ErrorField"),
					},
				},
			},
		},
	},
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		special.VersionProperty,
		special.AuditProperty,
		{
			Name:     "name",
			Length:   256,
			Type:     model.ResourceProperty_STRING,
			Unique:   true,
			Required: true,
			Annotations: map[string]string{
				annotations.IsHclLabel: annotations.Enabled,
			},
		},
		{
			Name:     "description",
			Length:   1024,
			Type:     model.ResourceProperty_STRING,
			Required: false,
		},
		{
			Name:     "selector",
			Type:     model.ResourceProperty_STRUCT,
			Required: false,
			TypeRef:  util.Pointer("EventSelector"),
		},
		{
			Name:     "order",
			Type:     model.ResourceProperty_INT32,
			Required: true,
		},
		{
			Name:     "finalizes",
			Type:     model.ResourceProperty_BOOL,
			Required: true,
		},
		{
			Name:     "sync",
			Type:     model.ResourceProperty_BOOL,
			Required: true,
		},
		{
			Name:     "responds",
			Type:     model.ResourceProperty_BOOL,
			Required: true,
		},
		{
			Name:     "call",
			Type:     model.ResourceProperty_STRUCT,
			Required: true,
			TypeRef:  util.Pointer("ExternalCall"),
		},
		special.AnnotationsProperty,
	},
	Annotations: map[string]string{
		annotations.EnableAudit:  "true",
		annotations.OpenApiGroup: OpenApiInternal,
	},
}

var NamespaceResource = &model.Resource{
	Name:      "Namespace",
	Namespace: "system",
	SourceConfig: &model.ResourceSourceConfig{
		DataSource: "system",
		Entity:     "namespace",
	},
	Types: []*model.ResourceSubType{
		special.AuditDataSubType,
	},
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		special.VersionProperty,
		special.AuditProperty,
		{
			Name:      "name",
			Type:      model.ResourceProperty_STRING,
			Length:    256,
			Required:  true,
			Unique:    true,
			Immutable: true,
			Annotations: map[string]string{
				annotations.IsHclLabel: annotations.Enabled,
			},
		},
		{
			Name:     "description",
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: false,
		},
		{
			Name:     "details",
			Type:     model.ResourceProperty_OBJECT,
			Required: false,
		},
	},
	Annotations: map[string]string{
		annotations.EnableAudit:  "true",
		annotations.OpenApiGroup: OpenApiInternal,
	},
}

var PermissionResource = &model.Resource{
	Name:        "Permission",
	Title:       util.Pointer("Permission"),
	Description: util.Pointer("Permission is a resource that defines the access control rules for resources for users."),
	Namespace:   "system",
	SourceConfig: &model.ResourceSourceConfig{
		DataSource: "system",
		Entity:     "permission",
	},
	Types: []*model.ResourceSubType{
		special.AuditDataSubType,
		sub_types.BooleanExpression,
		sub_types.PairExpression,
		sub_types.Expression,
	},
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		special.VersionProperty,
		special.AuditProperty,
		{
			Name:         "namespace",
			Title:        util.Pointer("Namespace"),
			Description:  util.Pointer(`The namespace(name) of the resource. If given it will be used to match the resource by namespace.`),
			Type:         model.ResourceProperty_STRING,
			Length:       255,
			ExampleValue: structpb.NewStringValue("default"),
		},
		{
			Name:         "resource",
			Title:        util.Pointer("Resource"),
			Description:  util.Pointer(`The name of the resource. If given it will be used to match the resource by name.`),
			Type:         model.ResourceProperty_STRING,
			Length:       255,
			ExampleValue: structpb.NewStringValue("Book"),
		},
		{
			Name:    "recordSelector",
			Type:    model.ResourceProperty_STRUCT,
			TypeRef: util.Pointer(sub_types.BooleanExpression.Name),
		},
		{
			Name:         "operation",
			Title:        util.Pointer("Operation"),
			Description:  util.Pointer(`The operation of the permission. It is used to match the operation of the request. If given it will be used to match the operation of the request.`),
			Type:         model.ResourceProperty_ENUM,
			Length:       255,
			Required:     true,
			DefaultValue: structpb.NewStringValue("FULL"),
			EnumValues: []string{
				"READ",
				"CREATE",
				"UPDATE",
				"DELETE",
				"FULL",
			},
			ExampleValue: structpb.NewStringValue("READ"),
		},
		{
			Name:        "before",
			Title:       util.Pointer("Before"),
			Description: util.Pointer(`The timestamp before which the permission is valid. If given it will be used to match the timestamp of the request.`),
			Type:        model.ResourceProperty_TIMESTAMP,
		},
		{
			Name:        "after",
			Title:       util.Pointer("After"),
			Description: util.Pointer(`The timestamp after which the permission is valid. If given it will be used to match the timestamp of the request.`),
			Type:        model.ResourceProperty_TIMESTAMP,
		},
		{
			Name:        "user",
			Title:       util.Pointer("User"),
			Description: util.Pointer(`The user who has the permission. If given it will be used to match the user of the request. It is ignored by default, because if permissions is set through User this property is overrides and auto-populated by system`),
			Type:        model.ResourceProperty_REFERENCE,
			Reference: &model.Reference{
				Namespace: UserResource.Namespace,
				Resource:  UserResource.Name,
			},
		},
		{
			Name:        "role",
			Title:       util.Pointer("Role"),
			Description: util.Pointer(`The role who has the permission. If given it will be used to match the role of the request. It is ignored by default, because if permissions is set through Role this property is overrides and auto-populated by system`),
			Type:        model.ResourceProperty_REFERENCE,
			Reference: &model.Reference{
				Namespace: RoleResource.Namespace,
				Resource:  RoleResource.Name,
			},
		},
		{
			Name:        "permit",
			Title:       util.Pointer("Permit"),
			Description: util.Pointer(`The permit of the permission. If permission is matched, this property is judging field to indicate that if operation is allowed or not`),
			Required:    true,
			Length:      255,
			Type:        model.ResourceProperty_ENUM,
			EnumValues: []string{
				"ALLOW",
				"REJECT",
			},
		},
		{
			Name: "localFlags",
			Type: model.ResourceProperty_OBJECT,
		},
	},
	Annotations: map[string]string{
		annotations.EnableAudit:  annotations.Enabled,
		annotations.OpenApiGroup: OpenApiMeta,
	},
}

var PropertyType = &model.ResourceSubType{
	Name:        "Property",
	Title:       "Property",
	Description: "Property is a type that represents a property of a resource. It is like an API properties or properties of class in a programming language",
	Annotations: map[string]string{
		annotations.CommonType: annotations.Enabled,
	},
	Properties: ResourcePropertyProperties,
}

var RecordResource = &model.Resource{
	Name:        "Record",
	Title:       util.Pointer("Generic Record"),
	Description: util.Pointer("A generic record resource. All Apis are extended from Generic Record resource"),
	Namespace:   "system",
	Virtual:     true,
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		{
			Name:  "properties",
			Title: util.Pointer("Properties"),
			Description: util.Pointer(`The properties of the record. The schema of properties are defined in the resource definition. 
Here you will put the payload corresponding to the resource definition.
`),
			Type:     model.ResourceProperty_OBJECT,
			Required: true,
		},
		{
			Name: "packedProperties",
			Type: model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Type: model.ResourceProperty_OBJECT,
			},
			Annotations: map[string]string{
				annotations.OpenApiHide: "true",
			},
		},
	},

	Annotations: map[string]string{

		annotations.RestApiDisabled: annotations.Enabled,
	},
}

var ResourcePropertyProperties = []*model.ResourceProperty{
	{
		Name:        "type",
		Title:       util.Pointer("Type"),
		Description: util.Pointer(`The type of the property. Property Data Types can be one of it. Types can be written with all capital letters.`),
		Type:        model.ResourceProperty_ENUM,
		EnumValues: []string{
			"BOOL",
			"STRING",
			"FLOAT32",
			"FLOAT64",
			"INT32",
			"INT64",
			"BYTES",
			"UUID",
			"DATE",
			"TIME",
			"TIMESTAMP",
			"OBJECT",
			"MAP",
			"LIST",
			"REFERENCE",
			"ENUM",
			"STRUCT",
		},
		ExampleValue: structpb.NewStringValue("STRING"),
		Required:     true,
	},
	{
		Name:  "typeRef",
		Title: util.Pointer("Type Reference"),
		Description: util.Pointer(`The type reference of the property. It is only used for STRUCT type. 
When you used STRUCT type, you need to define your type inside types of resource and then you can use its name as typeRef.`),
		Type:         model.ResourceProperty_STRING,
		Length:       256,
		ExampleValue: structpb.NewStringValue("BookPublishingDetails"),
		Required:     false,
	},
	{
		Name:  "primary",
		Title: util.Pointer("Primary"),
		Description: util.Pointer(`The primary property of the resource. It is used to identify the resource. When it is not supplied, an id property is automatically created.
Normally primary property should not be provided. It is only used for special cases. If provided, it can break some functionalities of system. 
If Primary is provided, it should be a single property. It can not be a list or map.
If Primary is provided, internal id property will not be created.
`),
		Type:         model.ResourceProperty_BOOL,
		Required:     true,
		DefaultValue: structpb.NewBoolValue(false),
	},
	{
		Name:  "required",
		Title: util.Pointer("Required"),
		Description: util.Pointer(`This property indicates that whether or not given property is required.
When creating/updating records, if required property is not and defaultValue is given in property, the system will allow request but will use default value instead.
(In all cases if default value is provided it will be used in case of property absence)
`),
		Type:     model.ResourceProperty_BOOL,
		Required: true,

		DefaultValue: structpb.NewBoolValue(false),
	},
	{
		Name:  "unique",
		Title: util.Pointer("Unique"),
		Description: util.Pointer(`This property indicates that whether or not given property is unique.
Unique property is only working for single property, for combination of properties to become unique, you can use indexes with unique flag 
`),
		Type:     model.ResourceProperty_BOOL,
		Required: true,

		DefaultValue: structpb.NewBoolValue(false),
	},
	{
		Name:        "immutable",
		Title:       util.Pointer("Immutable"),
		Description: util.Pointer("This property indicates that whether or not given property is immutable. Immutable properties can not be updated."),
		Type:        model.ResourceProperty_BOOL,
		Required:    true,

		DefaultValue: structpb.NewBoolValue(false),
	},
	{
		Name:        "virtual",
		Title:       util.Pointer("Virtual"),
		Description: util.Pointer("This property indicates that whether or not given property is virtual. Virtual properties are not stored in database."),
		Type:        model.ResourceProperty_BOOL,
		Required:    true,

		DefaultValue: structpb.NewBoolValue(false),
	},
	{
		Name:         "length",
		Title:        util.Pointer("Length"),
		Description:  util.Pointer("This property indicates the length of the property. It is only used for STRING type."),
		Type:         model.ResourceProperty_INT32,
		Required:     true,
		ExampleValue: structpb.NewNumberValue(256),
		DefaultValue: structpb.NewNumberValue(256),
	},
	{
		Name:        "item",
		Title:       util.Pointer("Item"),
		Description: util.Pointer(`This property indicates the item type of the property. It is only used for LIST and MAP types.`),
		Type:        model.ResourceProperty_STRUCT,
		Required:    false,
		ExampleValue: structpb.NewStructValue(&structpb.Struct{
			Fields: map[string]*structpb.Value{
				"type": structpb.NewStringValue("STRING"),
			},
		}),
		TypeRef: util.Pointer("Property"),
	},
	{
		Name:  "reference",
		Title: util.Pointer("Reference"),
		Description: util.Pointer(`This property indicates the reference type of the property. It is only used for REFERENCE type.
When you use REFERENCE type, you need to provide reference details.
Reference details is used to locate referenced resource
When providing reference details, you need to provide namespace and resource name of the referenced resource.
If you don't provide namespace, it will be assumed as the same namespace with the resource.
`),
		Type:         model.ResourceProperty_STRING,
		ExampleValue: structpb.NewStringValue("Book"),
	},
	{
		Name:         "backReference",
		Title:        util.Pointer("Back Reference"),
		Description:  util.Pointer(`This property is to indicate the back reference property of the property. It is only used for REFERENCE type.`),
		Type:         model.ResourceProperty_STRING,
		ExampleValue: structpb.NewStringValue("Book"),
	},
	{
		Name:  "defaultValue",
		Title: util.Pointer("Default Value"),
		Description: util.Pointer(`This property indicates the default value of the property. 
It is used when creating/updating records and property is not provided.
`),
		Type:         model.ResourceProperty_OBJECT,
		ExampleValue: structpb.NewStringValue("Lord of the Rings"),
		Required:     false,
	},
	{
		Name:        "enumValues",
		Title:       util.Pointer("Enum Values"),
		Description: util.Pointer(`This property is only used with ENUM type. This property indicates the enum values of the property.`),
		Type:        model.ResourceProperty_LIST,
		Item: &model.ResourceProperty{
			Type: model.ResourceProperty_STRING,
		},
		ExampleValue: structpb.NewListValue(&structpb.ListValue{
			Values: []*structpb.Value{
				structpb.NewStringValue("UNKNOWN"),
				structpb.NewStringValue("ASC"),
				structpb.NewStringValue("DESC"),
			},
		}),
		Required: false,
	},
	{
		Name:         "exampleValue",
		Title:        util.Pointer("Example Value"),
		Description:  util.Pointer(`This property indicates the example value of the property.`),
		Type:         model.ResourceProperty_OBJECT,
		ExampleValue: structpb.NewStringValue(`no-book-name`),
		Required:     false,
	},
	{
		Name:         "title",
		Title:        util.Pointer("Title"),
		Description:  util.Pointer(`This property indicates the title of the property. It is used to have meaningful names for the properties.`),
		Type:         model.ResourceProperty_STRING,
		Length:       256,
		ExampleValue: structpb.NewStringValue(`Book Title`),
		Required:     false,
	},
	{
		Name:         "description",
		Title:        util.Pointer("Description"),
		Description:  util.Pointer(`This property indicates the description of the property. It is used to have meaningful description for the properties.`),
		Type:         model.ResourceProperty_STRING,
		Length:       256,
		ExampleValue: structpb.NewStringValue(`Book Title is a property of Book Resource. It represents the title of the book.`),
		Required:     false,
	},
	special.AnnotationsProperty,
}

var ResourceResource = &model.Resource{
	Name:        "Resource",
	Namespace:   "system",
	Title:       util.Pointer("Resource"),
	Description: util.Pointer("Resource is a top level resource that represents a model and API in the system"),
	SourceConfig: &model.ResourceSourceConfig{
		DataSource: "system",
		Entity:     "resource",
	},
	Types: []*model.ResourceSubType{
		PropertyType,
		SubTypeType,
		special.AuditDataSubType,
		{
			Name: "IndexProperty",
			Properties: []*model.ResourceProperty{
				{
					Name:     "name",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
				{
					Name:     "order",
					Type:     model.ResourceProperty_ENUM,
					Required: false,
					EnumValues: []string{
						"UNKNOWN", "ASC", "DESC",
					},
					DefaultValue: structpb.NewStringValue("ASC"),
				},
			},
		},
		{
			Name: "Index",
			Properties: []*model.ResourceProperty{
				{
					Name: "properties",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("IndexProperty"),
					},
				},
				{
					Name:     "indexType",
					Type:     model.ResourceProperty_ENUM,
					Required: false,
					EnumValues: []string{
						"BTREE", "HASH",
					},
					DefaultValue: structpb.NewStringValue("BTREE"),
				},
				{
					Name:     "unique",
					Type:     model.ResourceProperty_BOOL,
					Required: false,
				},
				special.AnnotationsProperty,
			},
		},
	},
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		special.VersionProperty,
		special.AuditProperty,
		{
			Name:         "name",
			Title:        util.Pointer("Name"),
			Description:  util.Pointer("The name of the resource. Name is the main parameter of resource, it is used to identify the resource. It is also used to name API endpoints."),
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			Required:     true,
			Unique:       false,
			ExampleValue: structpb.NewStringValue("Book"),
			Annotations: map[string]string{
				annotations.IsHclLabel: annotations.Enabled,
			},
		},
		{
			Name:        "namespace",
			Title:       util.Pointer("Namespace"),
			Description: util.Pointer("The namespace of the resource. Namespace is used to group resources. It is also used to name API endpoints together with Resource. "),
			Type:        model.ResourceProperty_REFERENCE,
			Required:    true,
			Reference: &model.Reference{
				Resource:  NamespaceResource.Name,
				Namespace: NamespaceResource.Namespace,
			},
			DefaultValue: structpb.NewStructValue(&structpb.Struct{
				Fields: map[string]*structpb.Value{
					"name": structpb.NewStringValue("default"),
				},
			}),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{
				Fields: map[string]*structpb.Value{
					"name": structpb.NewStringValue("default"),
				},
			}),
		},
		{
			Name:  "virtual",
			Title: util.Pointer("Virtual"),
			Description: util.Pointer(`This property indicates that whether or not given resource is virtual. 
Virtual resources are not stored in database. They are created on the fly.
Virtual resources are used to prepare bind them to extensions or nano codes, etc. without touching to database.
`),
			Type:     model.ResourceProperty_BOOL,
			Required: true,

			DefaultValue: structpb.NewBoolValue(false),
		},
		{
			Name:        "properties",
			Title:       util.Pointer("Properties"),
			Description: util.Pointer(`This property indicates the properties of the resource.`),
			Type:        model.ResourceProperty_MAP,
			Required:    true,
			Item: &model.ResourceProperty{
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("Property"),
			},
			ExampleValue: structpb.NewListValue(&structpb.ListValue{
				Values: []*structpb.Value{
					structpb.NewStructValue(&structpb.Struct{
						Fields: map[string]*structpb.Value{
							"name": structpb.NewStringValue("title"),
							"type": structpb.NewStringValue("name"),
						},
					}),
					structpb.NewStructValue(&structpb.Struct{
						Fields: map[string]*structpb.Value{
							"name": structpb.NewStringValue("type"),
							"type": structpb.NewStringValue("STRING"),
						},
					}),
				},
			}),
		},
		{
			Name:  "indexes",
			Title: util.Pointer("Indexes"),
			Description: util.Pointer(`This property indicates the indexes of the resource.
Indexes are used to speed up the queries. Indexes are used to define complex unique constraints.
`),
			Type:     model.ResourceProperty_LIST,
			Required: false,
			Item: &model.ResourceProperty{
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("Index"),
			},
		},
		{
			Name:  "types",
			Title: util.Pointer("Types"),
			Description: util.Pointer(`This property indicates the types of the resource.
This is used to hav sub types, which will be used by other properties which has type STRUCT.
`),
			Type:     model.ResourceProperty_LIST,
			Required: false,
			Item: &model.ResourceProperty{
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("SubType"),
			},
		},
		{
			Name:         "immutable",
			Title:        util.Pointer("Immutable"),
			Description:  util.Pointer("This property indicates that whether or not given resource is immutable. Immutable resources can not be updated or deleted."),
			Type:         model.ResourceProperty_BOOL,
			Required:     true,
			DefaultValue: structpb.NewBoolValue(false),
		},
		{
			Name:  "abstract",
			Title: util.Pointer("Abstract"),
			Description: util.Pointer(`This property indicates that whether or not given resource is abstract.
Abstract resources are not stored in database. No record related operation is allowed in abstract resources.
Abstract resources are mostly used for code generation (for abstract types, etc.)
`),
			Type:     model.ResourceProperty_BOOL,
			Required: true,

			DefaultValue: structpb.NewBoolValue(false),
		},
		{
			Name:        "checkReferences",
			Title:       util.Pointer("Check References"),
			Description: util.Pointer(`This property indicates that whether or not check references is enabled. Check references resources are used to check references to other resources. It is acting if enabled only in create/update operations`),
			Type:        model.ResourceProperty_BOOL,
			Required:    true,

			DefaultValue: structpb.NewBoolValue(false),
		},
		{
			Name:  "dataSource",
			Title: util.Pointer("Data Source"),
			Description: util.Pointer(`This property indicates the data source of the resource.
Data source is used to store the records of the resource.
Each resource can have only one data source. But data source can be different from resource to resource.
Updating data source of a resource is not migrating any data.
DataSource property is used for non-virtual resources.
If DataSource is not provided, default DataSource will be used
`),
			Type:     model.ResourceProperty_REFERENCE,
			Required: false,
			Reference: &model.Reference{
				Resource:  DataSourceResource.Name,
				Namespace: DataSourceResource.Namespace,
			},
		},
		{
			Name:         "entity",
			Title:        util.Pointer("Entity"),
			Description:  util.Pointer(`This property indicates the entity of the resource. By entity, table name is considered for relational databases`),
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			Required:     false,
			ExampleValue: structpb.NewStringValue("book"),
		},
		{
			Name:         "catalog",
			Title:        util.Pointer("Catalog"),
			Description:  util.Pointer(`This property indicates the catalog of the resource. By catalog, schema name is considered for relational databases.`),
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			Required:     false,
			ExampleValue: structpb.NewStringValue("public"),
		},
		{
			Name:         "title",
			Title:        util.Pointer("Title"),
			Description:  util.Pointer(`This property indicates the title of the resource. It is used to have meaningful names for the resources.`),
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			Required:     false,
			ExampleValue: structpb.NewStringValue(`Book`),
		},
		{
			Name:         "description",
			Title:        util.Pointer("Description"),
			Description:  util.Pointer(`This property indicates the description of the resource. It is used to have meaningful description for the resources.`),
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			Required:     false,
			ExampleValue: structpb.NewStringValue(`Book is a resource in the system. It represents a book in the system.`),
		},
		special.AnnotationsProperty,
	},
	Indexes: []*model.ResourceIndex{
		{
			Properties: []*model.ResourceIndexProperty{
				{
					Name: "namespace",
				},
				{
					Name: "name",
				},
			},
			Unique: true,
		},
	},
	Annotations: map[string]string{
		annotations.EnableAudit:     annotations.Enabled,
		annotations.RestApiDisabled: annotations.Enabled,
		annotations.OpenApiGroup:    OpenApiMeta,
		annotations.OpenApiRestPath: "resources",
	},
}

var RoleResource = &model.Resource{
	Name:        "Role",
	Title:       util.Pointer("Role"),
	Description: util.Pointer("Role is a resource that defines the access control model. It is used to give permissions to users in a grouped way"),
	Namespace:   "system",
	SourceConfig: &model.ResourceSourceConfig{
		DataSource: "system",
		Entity:     "role",
	},
	Types: []*model.ResourceSubType{
		special.AuditDataSubType,
	},
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		special.VersionProperty,
		special.AuditProperty,
		{
			Name:        "name",
			Title:       util.Pointer("Name"),
			Description: util.Pointer(`The name of the role`),
			Type:        model.ResourceProperty_STRING,
			Length:      256,
			Required:    true,
			Unique:      true,
			Annotations: map[string]string{
				annotations.IsHclLabel: annotations.Enabled,
			},
		},
		{
			Name:        "permissions",
			Description: util.Pointer(`The permissions of the role. It is used to define the access control rules for resources for roles. When you set permissions it is automatically created though Permission Resource. No need to manage it manually`),
			Type:        model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Type: model.ResourceProperty_REFERENCE,
				Reference: &model.Reference{
					Namespace: "system",
					Resource:  "Permission",
				},
				BackReference: &model.BackReference{
					Property: "role",
				},
			},
			Required: false,
		},
		{
			Name:        "details",
			Title:       util.Pointer("Details"),
			Description: util.Pointer(`The details of the user. It is used to store additional information about the user.`),
			Type:        model.ResourceProperty_OBJECT,
		},
	},
	Annotations: map[string]string{
		annotations.EnableAudit:  annotations.Enabled,
		annotations.OpenApiGroup: OpenApiMeta,
	},
}

var SubTypeType = &model.ResourceSubType{
	Name:        "SubType",
	Title:       "Sub Type",
	Description: "Sub Type is a type that represents a sub type of a resource. It is mostly used by STRUCT type to define the properties of the struct. ",
	Annotations: map[string]string{
		annotations.CommonType: annotations.Enabled,
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "name",
			Title:        util.Pointer("Name"),
			Description:  util.Pointer("The name of the sub type. "),
			Type:         model.ResourceProperty_STRING,
			ExampleValue: structpb.NewStringValue("Book"),
			Required:     true,
		},
		{
			Name:         "title",
			Title:        util.Pointer("Title"),
			Description:  util.Pointer("The title of the sub type. It is used to have meaningful names for the sub types."),
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			ExampleValue: structpb.NewStringValue("Book"),
			Required:     false,
		},
		{
			Name:         "description",
			Title:        util.Pointer("Description"),
			Description:  util.Pointer("The description of the sub type. It is used to have meaningful description for the sub types. "),
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			ExampleValue: structpb.NewStringValue("Book is a sub type of Resource. It represents a book in the system. "),
			Required:     false,
		},
		{
			Name:        "properties",
			Title:       util.Pointer("Properties"),
			Description: util.Pointer("The properties of the sub type. It is used to define the properties of the sub type. "),
			Type:        model.ResourceProperty_MAP,
			Required:    true,
			Item: &model.ResourceProperty{
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("Property"),
			},
			ExampleValue: structpb.NewListValue(&structpb.ListValue{
				Values: []*structpb.Value{
					structpb.NewStructValue(&structpb.Struct{
						Fields: map[string]*structpb.Value{
							"name": structpb.NewStringValue("title"),
							"type": structpb.NewStringValue("STRING"),
						},
					}),
				},
			}),
		},
	},
}

var UserResource = &model.Resource{
	Name:        "User",
	Title:       util.Pointer("User"),
	Description: util.Pointer("User is a resource that defines the access control model. It is used to authenticate and authorize users."),
	Namespace:   "system",
	SourceConfig: &model.ResourceSourceConfig{
		DataSource: "system",
		Entity:     "user",
	},
	Types: []*model.ResourceSubType{
		special.AuditDataSubType,
	},
	Properties: []*model.ResourceProperty{
		special.IdProperty,
		special.VersionProperty,
		special.AuditProperty,
		{
			Name:     "username",
			Title:    util.Pointer("Username"),
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: true,
			Unique:   true,
			Annotations: map[string]string{
				annotations.IsHclLabel: annotations.Enabled,
			},
		},
		{
			Name:     "password",
			Title:    util.Pointer("Password"),
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: false,
		},
		{
			Name:  "roles",
			Title: util.Pointer("Roles"),
			Type:  model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Type: model.ResourceProperty_REFERENCE,
				Reference: &model.Reference{
					Namespace: RoleResource.Namespace,
					Resource:  RoleResource.Name,
				},
			},
		},
		{
			Name:        "permissions",
			Title:       util.Pointer("Permissions"),
			Description: util.Pointer(`The permissions of the user. It is used to define the access control rules for resources for users. When you set permissions it is automatically created though Permission Resource. No need to manage it manually`),
			Type:        model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Type: model.ResourceProperty_REFERENCE,
				Reference: &model.Reference{
					Namespace: "system",
					Resource:  "Permission",
				},
				BackReference: &model.BackReference{
					Property: "user",
				},
			},
			Required: false,
		},
		{
			Name:        "details",
			Title:       util.Pointer("Details"),
			Description: util.Pointer(`The details of the user. It is used to store additional information about the user.`),
			Type:        model.ResourceProperty_OBJECT,
		},
	},
	Annotations: map[string]string{
		annotations.EnableAudit:  annotations.Enabled,
		annotations.OpenApiGroup: OpenApiMeta,
	},
}

Functions

func GetAllSystemResources

func GetAllSystemResources() []*model.Resource

func GetSystemResourceType

func GetSystemResourceType(resource *model.Resource) proto.Message