def relationship_name_mapper(relationship: RelationshipProperty) -> str:
# Union of Mapper or ORM instance
referred_cls = relationship.argument
if hasattr(referred_cls, "class_"):
referred_cls = referred_cls.class_
elif callable(referred_cls):
referred_cls = referred_cls()
referred_name = get_table_name(referred_cls)
cardinal_name = to_plural(
referred_name) if relationship.uselist else referred_name
camel_name = snake_to_camel(cardinal_name, upper=False)
relationship_name = (camel_name + "By" + "And".join(
snake_to_camel(local_col.name, upper=True) + "To" +
snake_to_camel(remote_col.name, upper=True)
for local_col, remote_col in relationship.local_remote_pairs))
return relationship_name
def composite_input_factory(sqla_composite: SQLACompositeType) -> InputObjectType:
name = snake_to_camel(sqla_composite.name, upper=True) + "Input"
fields = {}
for column in sqla_composite.columns:
column_key = str(column.key)
gql_key = column_key
gql_field = convert_column_to_input(column)
fields[gql_key] = gql_field
return_type = InputObjectType(name, fields)
return_type.sqla_composite = sqla_composite
return return_type
def composite_factory(sqla_composite: SQLACompositeType) -> CompositeType:
name = snake_to_camel(sqla_composite.name, upper=True)
fields = {}
for column in sqla_composite.columns:
column_key = str(column.key)
gql_key = column_key
gql_type = convert_column(column)
fields[gql_key] = gql_type
return_type = CompositeType(name, fields)
return_type.sqla_composite = sqla_composite
return return_type
def sqla_models_to_graphql_schema(
sqla_models,
sql_functions: typing.Optional[typing.List[SQLFunction]] = None,
jwt_identifier: typing.Optional[str] = None,
jwt_secret: typing.Optional[str] = None,
) -> Schema:
"""Creates a GraphQL Schema from SQLA Models
**Parameters**
* **sqla_models**: _List[Type[SQLAModel]]_ = List of SQLAlchemy models to include in the GraphQL schema
* **jwt_identifier**: _str_ = qualified path of SQL composite type to use encode as a JWT e.g. 'public.jwt'
* **jwt_secret**: _str_ = Secret key used to encrypt JWT contents
* **sql_functions** = **NOT PUBLIC API**
"""
if sql_functions is None:
sql_functions = []
query_fields = {}
mutation_fields = {}
# Tables
for sqla_model in sqla_models:
if not Config.exclude_read_one(sqla_model):
# e.g. account(nodeId: NodeID)
single_name = snake_to_camel(get_table_name(sqla_model),
upper=False)
query_fields[single_name] = table_field_factory(
sqla_model, resolver)
if not Config.exclude_read_all(sqla_model):
# e.g. allAccounts(first: Int, last: Int ....)
connection_name = "all" + snake_to_camel(
to_plural(get_table_name(sqla_model)), upper=True)
query_fields[connection_name] = connection_field_factory(
sqla_model, resolver)
if not Config.exclude_create(sqla_model):
# e.g. createAccount(input: CreateAccountInput)
mutation_fields.update(
create_entrypoint_factory(sqla_model, resolver=resolver))
if not Config.exclude_update(sqla_model):
# e.g. updateAccount(input: UpdateAccountInput)
mutation_fields.update(
update_entrypoint_factory(sqla_model, resolver=resolver))
if not Config.exclude_delete(sqla_model):
# e.g. deleteAccount(input: DeleteAccountInput)
mutation_fields.update(
delete_entrypoint_factory(sqla_model, resolver=resolver))
# Functions
for sql_function in sql_functions:
if is_jwt_function(sql_function, jwt_identifier):
mutation_fields.update(
mutable_function_entrypoint_factory(sql_function=sql_function,
resolver=resolver,
jwt_secret=jwt_secret))
else:
# Immutable functions are queries
if sql_function.is_immutable:
query_fields.update(
immutable_function_entrypoint_factory(
sql_function=sql_function, resolver=resolver))
# Mutable functions are mutations
else:
mutation_fields.update(
mutable_function_entrypoint_factory(
sql_function=sql_function, resolver=resolver))
schema_kwargs = {
"query": ObjectType(name="Query", fields=query_fields),
"mutation": ObjectType(name="Mutation", fields=mutation_fields),
}
return Schema(**{k: v for k, v in schema_kwargs.items() if v.fields})
def rename_table(base, tablename: str, table: Table) -> str:
"""Produce a 'camelized' class name, e.g. 'words_and_underscores' -> 'WordsAndUnderscores'"""
return snake_to_camel(tablename, upper=True)
def enum_name_mapper(enum: Type[postgresql.base.ENUM]) -> str:
return snake_to_camel((enum.name or "") + "_enum", upper=True)
def column_name_mapper(column: Column) -> str:
return snake_to_camel(column.name, upper=False)
def table_type_name_mapper(sqla_table: TableProtocol) -> str:
table_name = get_table_name(sqla_table)
return snake_to_camel(table_name)
def function_type_name_mapper(sql_function: SQLFunction) -> str:
"""to_upper -> ToUpper"""
return snake_to_camel(sql_function.name, upper=True)
def function_name_mapper(sql_function: SQLFunction) -> str:
"""to_upper -> toUpper"""
return snake_to_camel(sql_function.name, upper=False)