class Book(DjangoObject): model = BookModel custom_actions = { "getById": Action(parameters={"id": IntegerType(validators=And(NotNegative, NotZero))}, return_value=ObjectType("self"), validators=NotRestrictedBook, exec_fn=get_by_id), "getById2": Action(parameters={"id": IntegerType(validators=NotNegative)}, data={"Title": StringType(validators=LongerThen3Characters)}, return_value=ObjectType("self"), validators=NotRestrictedBook, exec_fn=get_by_id)}
def convert(self, adapter, **kwargs): self.set_ref() object_name = self.to.__name__ object_module = self.to.__module__ cls = object_storage.get(object_module, object_name) self.parameters = { "filters": ObjectType(cls.filter_type, nullable=True) } list_cls = object_storage.get(object_module, object_name + "List") obj = ObjectType(list_cls, parameters=self.parameters) obj.resolver = self.resolver return obj.convert(adapter, **kwargs)
class ActionInfo(Object): fields = { "name": StringType(), "parameters": PlainListType(ObjectType(FieldInfo)), "data": PlainListType(ObjectType(FieldInfo)), "return_type": StringType(), "permitted": BooleanType(), "deny_reason": StringType(nullable=True), "retry_in": DurationType(nullable=True), "mutation": BooleanType() } hidden = True
def determine_parameters(self): if self._determined_parameters is None: self._determined_parameters = ({ "filters": ObjectType(self.parent_class.filter_type, nullable=True) }) self._determined_parameters.update(self.parameters)
class ObjectInfo(Object): fields = { "name": StringType(), "pk_field": StringType(nullable=True), "actions": PlainListType(ObjectType(ActionInfo)), } hidden = True
def convert_to_object_type(field, field_name, both_fields, input_fields, output_fields): target_model = field.remote_field.model target_pk_field_name, target_pk_field = get_pk_field(target_model) converted_pk_field = DJANGO_SIMPLE_API_MAP[target_pk_field.__class__] validators = [DjangoValidator(x) for x in field.validators] validators.append(ForeignKeyValidator(target_model)) input_fields[field_name + "_id"] = converted_pk_field( nullable=field.null, exclude_filters=(), validators=validators) output_fields[field_name] = ObjectType(target_model, nullable=field.null, exclude_filters=())
class PersonList(Object): fields = { "count": IntegerType(), "records": PlainListType(ObjectType(Person), parameters={ "limit": IntegerType(nullable=True, default=20), "offset": IntegerType(nullable=True, default=0), }, resolver=resolve) }
class IntList(Object): fields = { "count": IntegerType(), "all_records": PlainListType(IntegerType()), "records": ObjectType( "self", parameters={ "limit": IntegerType(nullable=True, default=20), "offset": IntegerType(nullable=True, default=0), }, resolver=resolve ) }
def inject_references(mcs, cls): for field in { **cls.fields, **cls.input_fields, **cls.output_fields }.values(): field.set_parent_class(cls) for action_name, action in cls.actions.items(): action.set_parent_class(cls) action.set_name(action_name) if not getattr(cls, "hidden", False): cls.output_fields["__actions"] = PlainListType( ObjectType("simple_api.object.meta_types.ActionInfo"), resolver=build_actions_resolver(cls))
def __init__(self, parameters=None, data=None, return_value=None, get_fn=None, exec_fn=None, permissions=None, **kwargs): return_value = return_value or ObjectType("self") super().__init__(parameters=parameters, data=data, return_value=return_value, exec_fn=exec_fn, permissions=permissions, **kwargs) self.get_fn = get_fn self._determined_get_fn = None
def __init__(self, parameters=None, data=None, return_value=None, exec_fn=None, permissions=None, **kwargs): self.parameters = parameters or {} self.data = data or {} self.return_value = return_value or ObjectType("self") self.exec_fn = exec_fn self.permissions = ensure_tuple(permissions) self.kwargs = kwargs # these attributes exist to ensure that 1) the input from the user is stored unmodified in the attributes above # and 2) everything is determined just once (better performance, less error-prone) self._determined_exec_fn = None self._determined_parameters = None self._determined_permissions = None self._determined_data = None self._action = None super().__init__()
def create_associated_list_type(cls): def resolve_pagination(request, parent_val, params, **kwargs): return parent_val[params["offset"]:(params["offset"] + params["limit"])] attrs = { "fields": { "count": IntegerType(), "data": PlainListType(ObjectType(cls), parameters={ "limit": IntegerType(nullable=True, default=DEFAULT_LIMIT), "offset": IntegerType(nullable=True, default=0), }, resolver=resolve_pagination) }, "hidden": True, } ObjectMeta(cls.__name__ + "List", (Object, ), attrs, module=cls.__module__)
return parent_val[params["offset"]:(params["offset"] + params["limit"])] class IntList(Object): fields = { "count": IntegerType(), "records": PlainListType(IntegerType(), parameters={ "limit": IntegerType(nullable=True, default=20), "offset": IntegerType(nullable=True, default=0), }, resolver=resolve) } def get(request, params, **kwargs): return AttrDict(count=len(params["input"]), records=params["input"]) actions = { "get": Action(parameters={"input": PlainListType(IntegerType())}, return_value=ObjectType(IntList), exec_fn=get) } schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)
def convert_to_readonly_object_type(field, field_name, both_fields, input_fields, output_fields): target_model = field.remote_field.model # for OneToOneRel, we don't want to generate filters, as one_to_one_rel_id does not exist in Django output_fields[field_name] = ObjectType(target_model, nullable=field.null)
def build_type_info(): return Action(return_value=PlainListType(ObjectType(TypeInfo)), exec_fn=type_info)
return [ { "int1": 0, "int2": 10 }, None, { "int1": 2, "int2": 12 }, ] actions = { "getNonNull": Action(return_value=PlainListType(ObjectType(TestObject)), exec_fn=non_null), "getNull": Action(return_value=PlainListType(ObjectType(TestObject, nullable=True), nullable=True), exec_fn=null), "getListNullElemNonNull": Action(return_value=PlainListType(ObjectType(TestObject), nullable=True), exec_fn=null), "getListNonNullElemNull": Action(return_value=PlainListType(ObjectType(TestObject, nullable=True)), exec_fn=list_non_null_elem_null), } schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)
from simple_api.object.datatypes import IntegerType, ObjectType from simple_api.object.object import Object from simple_api.utils import AttrDict from simple_api.adapters.graphql.utils import build_patterns def get(request, params, **kwargs): return AttrDict(number=20, number_def=5) def get_number(request, parent_val, params, **kwargs): return params.get("num") or parent_val class TestObject(Object): fields = { "number": IntegerType(parameters={"num": IntegerType(nullable=True)}, resolver=get_number), "number_def": IntegerType(parameters={"num": IntegerType(nullable=True, default=5)}, resolver=get_number), } actions = {"get": Action(return_value=ObjectType(TestObject), exec_fn=get)} schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)
class Location(Object): fields = {"name": StringType(), "coords": ObjectType(Coordinates)}
"time": params.get("time"), "datetime": params.get("datetime") } class TestObject(Object): fields = { "date": DateType(), "time": TimeType(), "datetime": DateTimeType(), } actions = { "getObject": Action(return_value=ObjectType(TestObject), exec_fn=get_object), "getDate": Action(return_value=DateType(), exec_fn=get_date), "getTime": Action(return_value=TimeType(), exec_fn=get_time), "getDatetime": Action(return_value=DateTimeType(), exec_fn=get_datetime), "echo": Action(parameters={ "date": DateType(), "time": TimeType(), "datetime": DateTimeType() }, return_value=ObjectType(TestObject), exec_fn=echo), }
class TestObject(Object): fields = { "self": ObjectType("self", nullable=True) }
from simple_api.adapters.graphql.graphql import GraphQLAdapter from simple_api.adapters.utils import generate from simple_api.object.actions import Action from simple_api.object.datatypes import ObjectType, StringType, IntegerType from simple_api.object.object import Object from simple_api.adapters.graphql.utils import build_patterns class Coordinates(Object): fields = {"lat": IntegerType(), "lng": IntegerType()} class Location(Object): fields = {"name": StringType(), "coords": ObjectType(Coordinates)} def echo(request, params, **kwargs): return params["loc"] actions = { "echo": Action(parameters={"loc": ObjectType(Location)}, return_value=ObjectType(Location), exec_fn=echo) } schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)
def get(request, params, **kwargs): if "id" in params: return "{}.{}".format(params["id"]["int1"], params["id"]["int2"]) return "no params passed" class TestObject(Object): fields = { "int1": IntegerType(), "int2": IntegerType(), } actions = { "get": Action(parameters={"id": ObjectType(TestObject)}, return_value=StringType(), exec_fn=get), "getNull": Action(parameters={"id": ObjectType(TestObject, nullable=True)}, return_value=StringType(), exec_fn=get), "getNullDefault": Action(parameters={ "id": ObjectType(TestObject, nullable=True, default={ "int1": 10, "int2": 20 }) }, return_value=StringType(),
from simple_api.adapters.graphql.graphql import GraphQLAdapter from simple_api.adapters.utils import generate from simple_api.object.actions import Action from simple_api.object.datatypes import ObjectType from simple_api.adapters.graphql.utils import build_patterns from .b import get actions = { "get": Action(return_value=ObjectType("C"), exec_fn=get) } schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)
from simple_api.adapters.graphql.graphql import GraphQLAdapter from simple_api.adapters.utils import generate from simple_api.object.actions import Action from simple_api.object.datatypes import ObjectType, DurationType from simple_api.object.object import Object from simple_api.adapters.graphql.utils import build_patterns def echo(request, params, **kwargs): return params["in"] class TestObject(Object): fields = {"duration": DurationType()} actions = { "get": Action(return_value=DurationType(), parameters={"in": DurationType()}, exec_fn=echo), "getObject": Action(return_value=ObjectType(TestObject), parameters={"in": ObjectType(TestObject)}, exec_fn=echo) } schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)
} class PersonList(Object): fields = { "count": IntegerType(), "records": PlainListType(ObjectType(Person), parameters={ "limit": IntegerType(nullable=True, default=20), "offset": IntegerType(nullable=True, default=0), }, resolver=resolve) } def get(request, params, **kwargs): return AttrDict(count=len(params["input"]), records=params["input"]) actions = { "get": Action(parameters={"input": PlainListType(ObjectType(Person))}, return_value=ObjectType(PersonList), exec_fn=get) } schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)
def build_action_info(actions): return Action(return_value=PlainListType(ObjectType(ActionInfo)), exec_fn=build_action_info_fn(actions))
class C(Object): fields = {"a": ObjectType(A), "b": ObjectType("B")}
def resolve(request, parent_val, params, **kwargs): res = parent_val[params["offset"]:(params["offset"]+params["limit"])] return AttrDict(count=len(res), all_records=res, records=res) class IntList(Object): fields = { "count": IntegerType(), "all_records": PlainListType(IntegerType()), "records": ObjectType( "self", parameters={ "limit": IntegerType(nullable=True, default=20), "offset": IntegerType(nullable=True, default=0), }, resolver=resolve ) } def get(request, params, **kwargs): return AttrDict(count=len(params["input"]), all_records=params["input"], records=params["input"]) actions = { "get": Action(parameters={"input": PlainListType(IntegerType())}, return_value=ObjectType(IntList), exec_fn=get) } schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)
class A(Object): fields = { "s1": StringType(), "s2": ObjectType("self", nullable=True) }
from simple_api.adapters.graphql.graphql import GraphQLAdapter from simple_api.adapters.utils import generate from simple_api.object.actions import Action from simple_api.object.datatypes import ObjectType from simple_api.object.object import Object from simple_api.adapters.graphql.utils import build_patterns def get(request, params, **kwargs): return None class TestObject(Object): fields = { "self": ObjectType("self", nullable=True) } actions = { "get": Action(return_value=ObjectType(TestObject, nullable=True), exec_fn=get) } schema = generate(GraphQLAdapter, actions) patterns = build_patterns("api/", schema)