jsontpmutator

var GQLBatchProcess = &graphql.Field{
	Name:        "BatchProcess",
	Type:        kind.GQLProposalResponseType,
	Description: "",

	Args: graphql.FieldConfigArgument{
		"input": &graphql.ArgumentConfig{
			Description: "Input JSON as list. " +
				"supported action: INSERT, UPSERT, UPDATE, MERGE, DELETE " +
				"example `[{action:\"INSERT\",data:{id:1,value:100}}," +
				"{action:\"UPSERT\",data:{id:2,value:5}}]`",
			Type: graphql.NewNonNull(graphql.NewList(graphql.NewNonNull(kind.GQLJSONType))),
		},
	},

	Resolve: func(p graphql.ResolveParams) (interface{}, error) {
		input := p.Args["input"].([]interface{})
		jsonContext, ok := p.Source.(*json.Context)
		if !ok {
			return nil, nil
		}

		if !utility.HasReadPermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrReadPermissionRequired.Error())
		}

		if !utility.HasWritePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrWritePermissionRequired.Error())
		}

		if !utility.HasUpdatePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrUpdatePermissionRequired.Error())
		}

		if !utility.HasDeletePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrDeletePermissionRequired.Error())
		}

		batch := jsonContext.Client.NewBatch()

		for _, si := range input {
			sim := si.(map[string]interface{})
			action := sim["action"].(string)
			data := sim["data"].(map[string]interface{})
			switch action {
			case "INSERT":
				err := batch.InsertJSONMap(data)
				if err != nil {
					return nil, gqlerrors.NewFormattedError(err.Error())
				}
			case "MERGE":
				err := batch.MergeJSONMap(data)
				if err != nil {
					return nil, gqlerrors.NewFormattedError(err.Error())
				}
			case "UPDATE":
				err := batch.UpdateJSONMap(data)
				if err != nil {
					return nil, gqlerrors.NewFormattedError(err.Error())
				}
			case "UPSERT":
				err := batch.UpsertJSONMap(data)
				if err != nil {
					return nil, gqlerrors.NewFormattedError(err.Error())
				}
			case "DELETE":
				err := batch.DeleteJSONMap(data)
				if err != nil {
					return nil, gqlerrors.NewFormattedError(err.Error())
				}
			}
		}

		pr, err := jsonContext.Client.ApplyBatch(batch)
		if err != nil {
			return nil, gqlerrors.NewFormattedError(err.Error())
		}
		return pr, nil
	},
}

var GQLDelete = &graphql.Field{
	Name:        "Delete",
	Type:        kind.GQLProposalResponseType,
	Description: "",

	Args: graphql.FieldConfigArgument{
		"id": &graphql.ArgumentConfig{
			Description: "ID",
			Type:        graphql.NewNonNull(graphql.ID),
		},
	},

	Resolve: func(p graphql.ResolveParams) (interface{}, error) {
		id := p.Args["id"].(string)
		jsonContext, ok := p.Source.(*json.Context)
		if !ok {
			return nil, nil
		}

		if !utility.HasReadPermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrReadPermissionRequired.Error())
		}

		if !utility.HasWritePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrWritePermissionRequired.Error())
		}

		pr, err := jsonContext.Client.DeleteJSONMap(map[string]interface{}{"id": id})

		if err != nil {
			return nil, gqlerrors.NewFormattedError(err.Error())
		}

		return pr, nil
	},
}

var GQLInsert = &graphql.Field{
	Name:        "Insert",
	Type:        kind.GQLProposalResponseType,
	Description: "",

	Args: graphql.FieldConfigArgument{
		"input": &graphql.ArgumentConfig{
			Description: "Input object",
			Type:        graphql.NewNonNull(kind.GQLJSONType),
		},
	},

	Resolve: func(p graphql.ResolveParams) (interface{}, error) {
		input := p.Args["input"].(map[string]interface{})
		jsonContext, ok := p.Source.(*json.Context)
		if !ok {
			return nil, nil
		}

		if !utility.HasReadPermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrReadPermissionRequired.Error())
		}

		if !utility.HasWritePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrWritePermissionRequired.Error())
		}

		pr, err := jsonContext.Client.InsertJSONMap(input)
		if err != nil {
			return nil, gqlerrors.NewFormattedError(err.Error())
		}
		return pr, nil
	},
}

var GQLJSONTPMutatorType = graphql.NewObject(graphql.ObjectConfig{
	Name:        "JSONTPMutator",
	Description: "",
	Fields: graphql.Fields{
		"merge":        GQLMerge,
		"insert":       GQLInsert,
		"upsert":       GQLUpsert,
		"update":       GQLUpdate,
		"delete":       GQLDelete,
		"batchProcess": GQLBatchProcess,
	},
})

var GQLMerge = &graphql.Field{
	Name:        "Merge",
	Type:        kind.GQLProposalResponseType,
	Description: "",

	Args: graphql.FieldConfigArgument{
		"input": &graphql.ArgumentConfig{
			Description: "Input object",
			Type:        graphql.NewNonNull(kind.GQLJSONType),
		},
	},

	Resolve: func(p graphql.ResolveParams) (interface{}, error) {
		input := p.Args["input"].(map[string]interface{})
		jsonContext, ok := p.Source.(*json.Context)
		if !ok {
			return nil, nil
		}

		if !utility.HasReadPermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrReadPermissionRequired.Error())
		}

		if !utility.HasUpdatePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrUpdatePermissionRequired.Error())
		}

		if !utility.HasWritePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrWritePermissionRequired.Error())
		}

		pr, err := jsonContext.Client.MergeJSONMap(input)

		if err != nil {
			return nil, gqlerrors.NewFormattedError(err.Error())
		}

		return pr, nil
	},
}

var GQLUpdate = &graphql.Field{
	Name:        "Update",
	Type:        kind.GQLProposalResponseType,
	Description: "",

	Args: graphql.FieldConfigArgument{
		"input": &graphql.ArgumentConfig{
			Description: "Input object",
			Type:        graphql.NewNonNull(kind.GQLJSONType),
		},
	},

	Resolve: func(p graphql.ResolveParams) (interface{}, error) {
		input := p.Args["input"].(map[string]interface{})
		jsonContext, ok := p.Source.(*json.Context)
		if !ok {
			return nil, nil
		}

		if !utility.HasUpdatePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrUpdatePermissionRequired.Error())
		}

		if !utility.HasReadPermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrReadPermissionRequired.Error())
		}

		if !utility.HasWritePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrWritePermissionRequired.Error())
		}

		pr, err := jsonContext.Client.UpdateJSONMap(input)

		if err != nil {
			return nil, gqlerrors.NewFormattedError(err.Error())
		}

		return pr, nil
	},
}

var GQLUpsert = &graphql.Field{
	Name:        "Upsert",
	Type:        kind.GQLProposalResponseType,
	Description: "",

	Args: graphql.FieldConfigArgument{
		"input": &graphql.ArgumentConfig{
			Description: "Input object",
			Type:        graphql.NewNonNull(kind.GQLJSONType),
		},
	},

	Resolve: func(p graphql.ResolveParams) (interface{}, error) {
		input := p.Args["input"].(map[string]interface{})
		jsonContext, ok := p.Source.(*json.Context)
		if !ok {
			return nil, nil
		}

		if !utility.HasReadPermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrReadPermissionRequired.Error())
		}

		if !utility.HasUpdatePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrUpdatePermissionRequired.Error())
		}

		if !utility.HasWritePermission(jsonContext.AccessControl) {
			return nil, gqlerrors.NewFormattedError(x.ErrWritePermissionRequired.Error())
		}

		pr, err := jsonContext.Client.UpsertJSONMap(input)

		if err != nil {
			return nil, gqlerrors.NewFormattedError(err.Error())
		}

		return pr, nil
	},
}