* add microsoft graph auth
* change mail to id
* add graph user id and email
* add microsoft graph auth test case
* remove validating auth data using mail
* add test case to AuthenticationAdapters
* fix indentation
* fix httpsRequest and fakeClaim not found
* add newline eof last
* fix test in auth adapter
* fix unhandled promise rejection
* feat: add allowHeaders to Options
This allows developers to use custom headers in their API requests, and they will be accepted by their mounted app.
* refactor: convert allowCrossDomain to generator to add appId in scope
This is necessary as the middleware may run in OPTIONS request that do not contain the appId within the header.
* chore: update Definitions and docs
* fix: update test to use new allowCrossDomain params
* chore: add tests for allowCustomDomain middleware re: allowHeadrs
* Fix: aggregate not matching null values
* Exclude Postgres from this new test - it does not even support and is not working correctly - should be addressed separately
* refactor(GraphQL): Pointer constraint input type as ID
Redefines the Pointer constraint input type from a custom scalar to
a simple ID.
* fix: PR review requested changes
* Remove nested operations
* Improve error log
* Fix bug schema to load
* Fix ParseGraphQLSchema tests
* Fix tests
* Fix failing tests
* First verstion not complete of create class mutation
* Fix bug caused by circular dependency
* Renaming files
* Schema types should be loaded before parse classes
* Fix tests
* Create class mutation boilerplate
* Improve CreateClassSchemaInput fields names
* Remove fields
* Pointer and relation fields
* Improve pointer default type
* Class type
* Create class mutation resolver
* Schema field transformers
* Class types transformations
* First test
* Numbers test
* Boolean tests
* Date test
* Fix some get tests
* Test for created at and updated at
* File tests
* Test for objects
* Renaming reducerFabric to reducerGenerator
* Changing get tests for file and object
* Object composed queries test
* Array test
* Null field test
* Bytes test
* Geo Point test
* Polygons tests
* Remove create generic mutation
* Fix tests
* Create class test - isRequired and defaultValue will be added back later
* Enforce master key
* Fix tests
* Duplicated field test
* updateClass mutation
* Remove update generic mutation tests
* Remove update generic mutation
* deleteClass mutation
* Remove delete generic mutation tests
* Remove delete generic mutation
* class query
* Classes query
* Remove get generic query from tests
* Remove remaining generic operations and fix tests
* Fix last test
* Try to fix redis tests
* Fix postgres tests
* Update objectsMutations and objectsQueries files locations
* Rename classSchema files to schema files
* Rename ClassObject to ParseObject
* Fix names and paths
* Still some wrong names
* refactor(GraphQL): Rename objectId to id
Renames `objectId` to `id` for the GraphQL API. Queries, mutations,
custom and generic types were updated.
Removes `RELATION_INPUT` and `POINTER_INPUT`. Now the user just need
to provide the ID of the object to link.
* fix: Column "id" not found on Postgres
* fix: Avoid deleting Parse class objectId
* fix: Undo objectId removal on mutations
* fix: Handle generic mutation id
* moved whitelisting of own user to remove conflict with custom classes and * permission
* added new pointer-perm regex to permissions
* added pointer-permissions support
* added tests
* fixed typo
* fixed typo 2
* added tests using find operation
* renamed protectedFields pointerPerm to userField
* decoupled readUserFields from CLP and removed readUser from protectedFields before querying
* updated tests
* Add a test on deep complex GraphQL Query
* Relation/Pointer new DX + deep nested mutations
* Fix lint
* Review
* Remove unnecessary code
* Fix objectId on update
* feat: Avoid setting a relation as required or with a defaultValue
* chore: Test to update a class with a relation field with options
* chore: Improve tests
* Support: serverCloseComplete option
Callback when server has fully shutdown.
Please check that all cases are covered.
* handle error on startup
* fix tests
* test workaround
* remove serverCloseComplete chech on startup failure
* added array support for pointer permissions
* added tests for array support for pointer permissions
* Postgres fix
* simplify PG, no idea why this works
* Renaming GraphQL Types/Inputs
* Add Native Type to avoid collision
* Use pluralize for renaming
* Fixing tests
* Improve name collision management - tests passsing
* Renaming few more default types
* Rename file input
* Reverting fields types to not collide with the relay spec types
Improver users mutations
* Adding ArrayResult to the reserved list
* Fixing tests
* Add more unit tests to ParseGraphQLSchema
* Test transformClassNameToGraphQL
* Name collision tests
* fix(package): update mongodb to version 3.3.0
* chore(package): update lockfile package-lock.json
* Fix tests
* Fix GraphQL tests for read preference
* Fix mongo adapter deprecation notice
* Fix the way the connections are checked, return promise when shutting down mongo
* GraphQL Object constraints
Implements the GraphQL Object constraints, which allows us to filter queries results using the `$eq`, `$lt`, `$gt`, `$in`, and other Parse supported constraints.
Example:
```
query objects {
findMyClass(where: {
objField: {
_eq: {
key: 'foo.bar',
value: 'hello'
},
_gt: {
key: 'foo.number',
value: 10
},
_lt: {
key: 'anotherNumber',
value: 5
}
}
}) {
results {
objectId
}
}
}
```
In the example above, we have the `findMyClass` query (automatically generated for the `MyClass` class), and a field named `objField` whose type is Object. The object below represents a valid `objField` value and would satisfy all constraints:
```
{
"foo": {
"bar": "hello",
"number": 11
},
"anotherNumber": 4
}
```
The Object constraint is applied only when using Parse class object type queries. When using "generic" queries such as `get` and `find`, this type of constraint is not available.
* Objects constraints not working on Postgres
Fixes the $eq, $ne, $gt, and $lt constraints when applied on an Object type field.
* Fix object constraint field name
* Fix Postgres constraints indexes
* fix: Object type composed constraints not working
* fix: Rename key and value fields
* refactor: Object constraints for generic queries
* fix: Object constraints not working on Postgres
* Batch transaction boilerplate
* Refactoring transaction boilerplate
* Independent sessions test
* Transactions - partial
* Missing only one test
* All tests passing for mongo db
* Tests on Travis
* Transactions on postgres
* Fix travis to restart mongodb
* Remove mongodb service and keep only mongodb runner
* MongoDB service back
* Initialize replicaset
* Remove mongodb runner again
* Again only with mongodb-runner and removing cache
* Trying with pretest and posttest
* WiredTiger
* Pretest and posttest again
* Removing inexistent scripts
* wiredTiger
* One more attempt
* Trying another way to run mongodb-runner
* Fixing tests
* Include batch transaction on direct access
* Add tests to direct access
* Add field options to mongo schema metadata
* Add/fix test with fields options
* Add required validation failing test
* Add more tests
* Only set default value if field is undefined
* Fix redis test
* Fix tests
* Test for creating a new class with field options
* Validate default value type
* fix lint (weird)
* Fix lint another way
* Add tests for beforeSave trigger and solve small issue regarding the use of unset in the beforeSave trigger
* add parse-graph-ql configuration for class schema customisation
Not yet tested - essentially an RFC
* refactor and add graphql router, controller and config cache
* fix(GraphQLController): add missing check isEnabled
* chore(GraphQLController): remove awaits from cache put
* chore(GraphQLController): remove check for if its enabled
* refactor(GraphQLController): only use cache if mounted
* chore(GraphQLController): group all validation errors and throw at once
* chore(GraphQLSchema): move transformations into controller validation
* refactor(GraphQL): improve ctrl validation and fix schema usage of config
* refactor(GraphQLSchema): remove code related to additional schema
This code has been moved into a separate feature branch.
* fix(GraphQLSchema): fix incorrect default return type for class configs
* refactor(GraphQLSchema): update staleness check code to account for config
* fix(GraphQLServer): fix regressed tests due to internal schema changes
This will be followed up with a backwards compatability fix for the `ClassFields` issue to avoid breakages for our users
* refactor: rename to ParseGraphQLController for consistency
* fix(ParseGraphQLCtrl): numerous fixes for validity checking
Also includes some minor code refactoring
* chore(GraphQL): minor syntax cleanup
* fix(SchemaController): add _GraphQLConfig to volatile classes
* refactor(ParseGraphQLServer): return update config value in setGraphQLConfig
* testing(ParseGraphQL): add test cases for new graphQLConfig
* fix(GraphQLController): fix issue where config with multiple items was not being mapped to the db
* fix(postgres): add _GraphQLConfig default schema on load
fixes failing postgres tests
* GraphQL @mock directive (#5836)
* Add mock directive
* Include tests for @mock directive
* Fix existing tests due to the change from ClassFields to ClassCreateFields
* fix(parseClassMutations): safer type transformation based on input type
* fix(parseClassMutations): only define necessary input fields
* fix(GraphQL): fix incorrect import paths
* make possible to alter response using the after save trigger like for after find
* code clearing to follow same object checking
* remove console log debug
* fix test unit
This PR empowers the Parse GraphQL API with custom user-defined schema. The developers can now write their own types, queries, and mutations, which will merged with the ones that are automatically generated. The new types are resolved by the application's cloud code functions.
Therefore, regarding https://github.com/parse-community/parse-server/issues/5777, this PR closes the cloud functions needs and also addresses the graphql customization topic. In my view, I think that this PR, together with https://github.com/parse-community/parse-server/pull/5782 and https://github.com/parse-community/parse-server/pull/5818, when merged, closes the issue.
How it works:
1. When initializing ParseGraphQLServer, now the developer can pass a custom schema that will be merged to the auto-generated one:
```
parseGraphQLServer = new ParseGraphQLServer(parseServer, {
graphQLPath: '/graphql',
graphQLCustomTypeDefs: gql`
extend type Query {
custom: Custom @namespace
}
type Custom {
hello: String @resolve
hello2: String @resolve(to: "hello")
userEcho(user: _UserFields!): _UserClass! @resolve
}
`,
});
```
Note:
- This PR includes a @namespace directive that can be used to the top level field of the nested queries and mutations (it basically just returns an empty object);
- This PR includes a @resolve directive that can be used to notify the Parse GraphQL Server to resolve that field using a cloud code function. The `to` argument specifies the function name. If the `to` argument is not passed, the Parse GraphQL Server will look for a function with the same name of the field;
- This PR allows creating custom types using the auto-generated ones as in `userEcho(user: _UserFields!): _UserClass! @resolve`;
- This PR allows to extend the auto-generated types, as in `extend type Query { ... }`.
2. Once the schema was set, you just need to write regular cloud code functions:
```
Parse.Cloud.define('hello', async () => {
return 'Hello world!';
});
Parse.Cloud.define('userEcho', async req => {
return req.params.user;
});
```
3. Now you are ready to play with your new custom api:
```
query {
custom {
hello
hello2
userEcho(user: { username: "somefolk" }) {
username
}
}
}
```
should return
```
{
"data": {
"custom": {
"hello": "Hello world!",
"hello2": "Hello world!",
"userEcho": {
"username": "somefolk"
}
}
}
}
```
