20 |
21 |
32 |
33 |
38 |
39 |
55 |
56 |
75 |
76 |
77 |
78 |
79 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | [](https://api.reuse.software/info/github.com/cap-js/graphql)
2 |
3 | # CDS protocol adapter for GraphQL
4 |
5 | ## About this project
6 |
7 | A GraphQL protocol adapter for [SAP Cloud Application Programming Model](https://cap.cloud.sap) Node.js.
8 | This adapter generically generates a GraphQL schema for the models of an application and serves an endpoint that allows you to query your services using the GraphQL query language.
9 |
10 | _**WARNING:** This package is in an early general availability state. This means that it is generally available, with stable APIs unless otherwise indicated, and you can use it for production. However, please note the [current limitations](#limitations) listed below._
11 |
12 | ## Requirements and Setup
13 |
14 | 1. Simply add the GraphQL adapter to your project using `npm`:
15 | ```js
16 | npm add @cap-js/graphql
17 | ```
18 |
19 | > This command will set up the GraphQL plug-in with the `@sap/cds` runtime. It enables the new [middlewares architecture](https://cap.cloud.sap/docs/node.js/middlewares) in Node.js and registers a GraphQL endpoint at `/graphql` serving all CRUD requests for the application services found in your model.
20 |
21 | 2. Annotate the services you want to serve, e.g. using `@graphql` or `@protocol: 'graphql'`.
22 |
23 | 3. Run your server as usual, e.g. using `cds watch`.
24 | > The runtime will serve all annotated services via GraphQL at the default configured endpoint.
25 |
26 | ## Limitations
27 |
28 | - **Actions** and functions are not yet supported.
29 | - **CDS annotations** like `@readonly` aren’t considered during schema generation.
30 | - **Cursor-based Pagination** – we currently support offset-based pagination, and will add cursor-based pagination going forward. While we intend to support both variants then, it is not guaranteed that we can do so without breaking changes to current behaviour.
31 | - **Extensions** are not yet considered.
32 |
33 | ## Support, Feedback, Contributing
34 |
35 | This project is open to feature requests/suggestions, bug reports etc. via [GitHub issues](https://github.com/cap-js/graphql/issues). Contribution and feedback are encouraged and always welcome. For more information about how to contribute, the project structure, as well as additional contribution information, see our [Contribution Guidelines](CONTRIBUTING.md).
36 |
37 | ## Code of Conduct
38 |
39 | We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone. By participating in this project, you agree to abide by its [Code of Conduct](CODE_OF_CONDUCT.md) at all times.
40 |
41 | ## Licensing
42 |
43 | Copyright 2022 SAP SE or an SAP affiliate company and cap-js/graphql contributors. Please see our [LICENSE](LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/cap-js/graphql).
44 |
--------------------------------------------------------------------------------
/lib/schema/types/object.js:
--------------------------------------------------------------------------------
1 | const cds = require('@sap/cds')
2 | const LOG = cds.log('graphql')
3 | const { GraphQLObjectType, GraphQLList, GraphQLInt } = require('graphql')
4 | const { gqlName } = require('../../utils')
5 | const argsGenerator = require('../args')
6 | const { shouldElementBeIgnored } = require('../util')
7 | const { cdsToGraphQLScalarType } = require('../types/scalar')
8 | const { CONNECTION_FIELDS } = require('../../constants')
9 |
10 | module.exports = cache => {
11 | const entityToObjectConnectionType = entity => {
12 | const name = gqlName(entity.name) + '_connection'
13 |
14 | if (cache.has(name)) return cache.get(name)
15 |
16 | const fields = {}
17 | const entityObjectConnectionType = new GraphQLObjectType({ name, fields: () => fields })
18 | cache.set(name, entityObjectConnectionType)
19 |
20 | const objectType = entityToObjectType(entity)
21 | if (!objectType) {
22 | cache.set(name)
23 | return
24 | }
25 |
26 | fields[CONNECTION_FIELDS.nodes] = { type: new GraphQLList(objectType) }
27 | fields[CONNECTION_FIELDS.totalCount] = { type: GraphQLInt }
28 |
29 | return entityObjectConnectionType
30 | }
31 |
32 | const entityToObjectType = entity => {
33 | const entityName = gqlName(entity.name)
34 |
35 | if (cache.has(entityName)) return cache.get(entityName)
36 |
37 | const fields = {}
38 | const entityObjectType = new GraphQLObjectType({
39 | name: entityName,
40 | description: entity.doc,
41 | fields: () => fields
42 | })
43 | cache.set(entityName, entityObjectType)
44 |
45 | for (const name in entity.elements) {
46 | const element = entity.elements[name]
47 |
48 | // REVISIT: requires differentiation for support of configurable schema flavors
49 | const type = element.is2many ? _elementToObjectConnectionType(element) : _elementToObjectType(element)
50 | if (!type) continue
51 |
52 | const field = { type, description: element.doc }
53 | if (element.is2many) field.args = argsGenerator(cache).generateArgumentsForType(element)
54 | fields[gqlName(name)] = field
55 | }
56 |
57 | // fields is empty e.g. for empty aspects
58 | if (!Object.keys(fields).length) {
59 | LOG.warn(`Entity "${entity.name}" has no fields and has therefore been excluded from the schema.`)
60 | cache.set(entityName, undefined)
61 | return
62 | }
63 |
64 | return entityObjectType
65 | }
66 |
67 | const _elementToObjectType = element => {
68 | if (shouldElementBeIgnored(element)) return
69 |
70 | const gqlScalarType = cdsToGraphQLScalarType(element)
71 | if (element.isAssociation || element.isComposition) {
72 | const type = gqlScalarType || entityToObjectType(element._target)
73 | return element.is2one ? type : new GraphQLList(type)
74 | } else if (gqlScalarType) {
75 | return gqlScalarType
76 | }
77 | }
78 |
79 | const _elementToObjectConnectionType = element => {
80 | if (shouldElementBeIgnored(element)) return
81 |
82 | const gqlScalarType = cdsToGraphQLScalarType(element._type)
83 | return entityToObjectConnectionType(gqlScalarType || element._target)
84 | }
85 |
86 | return { entityToObjectConnectionType, entityToObjectType }
87 | }
88 |
--------------------------------------------------------------------------------
/test/schemas/model-structure/composition-of-aspect.gql:
--------------------------------------------------------------------------------
1 | type CompositionOfAspectService {
2 | Books(filter: [CompositionOfAspectService_Books_filter], orderBy: [CompositionOfAspectService_Books_orderBy], skip: Int, top: Int): CompositionOfAspectService_Books_connection
3 | }
4 |
5 | type CompositionOfAspectService_Books {
6 | chapters(filter: [CompositionOfAspectService_Books_chapters_filter], orderBy: [CompositionOfAspectService_Books_chapters_orderBy], skip: Int, top: Int): CompositionOfAspectService_Books_chapters_connection
7 | id: ID
8 | reviews(filter: [CompositionOfAspectService_Books_reviews_filter], orderBy: [CompositionOfAspectService_Books_reviews_orderBy], skip: Int, top: Int): CompositionOfAspectService_Books_reviews_connection
9 | }
10 |
11 | input CompositionOfAspectService_Books_C {
12 | chapters: [CompositionOfAspectService_Books_chapters_C]
13 | id: ID
14 | reviews: [CompositionOfAspectService_Books_reviews_C]
15 | }
16 |
17 | input CompositionOfAspectService_Books_U {
18 | chapters: [CompositionOfAspectService_Books_chapters_C]
19 | reviews: [CompositionOfAspectService_Books_reviews_C]
20 | }
21 |
22 | type CompositionOfAspectService_Books_chapters {
23 | id: ID
24 | }
25 |
26 | input CompositionOfAspectService_Books_chapters_C {
27 | id: ID
28 | }
29 |
30 | type CompositionOfAspectService_Books_chapters_connection {
31 | nodes: [CompositionOfAspectService_Books_chapters]
32 | totalCount: Int
33 | }
34 |
35 | input CompositionOfAspectService_Books_chapters_filter {
36 | id: [ID_filter]
37 | }
38 |
39 | input CompositionOfAspectService_Books_chapters_orderBy {
40 | id: SortDirection
41 | }
42 |
43 | type CompositionOfAspectService_Books_connection {
44 | nodes: [CompositionOfAspectService_Books]
45 | totalCount: Int
46 | }
47 |
48 | input CompositionOfAspectService_Books_filter {
49 | id: [ID_filter]
50 | }
51 |
52 | type CompositionOfAspectService_Books_input {
53 | create(input: [CompositionOfAspectService_Books_C]!): [CompositionOfAspectService_Books]
54 | delete(filter: [CompositionOfAspectService_Books_filter]!): Int
55 | update(filter: [CompositionOfAspectService_Books_filter]!, input: CompositionOfAspectService_Books_U!): [CompositionOfAspectService_Books]
56 | }
57 |
58 | input CompositionOfAspectService_Books_orderBy {
59 | id: SortDirection
60 | }
61 |
62 | type CompositionOfAspectService_Books_reviews {
63 | id: ID
64 | }
65 |
66 | input CompositionOfAspectService_Books_reviews_C {
67 | id: ID
68 | }
69 |
70 | type CompositionOfAspectService_Books_reviews_connection {
71 | nodes: [CompositionOfAspectService_Books_reviews]
72 | totalCount: Int
73 | }
74 |
75 | input CompositionOfAspectService_Books_reviews_filter {
76 | id: [ID_filter]
77 | }
78 |
79 | input CompositionOfAspectService_Books_reviews_orderBy {
80 | id: SortDirection
81 | }
82 |
83 | type CompositionOfAspectService_input {
84 | Books: CompositionOfAspectService_Books_input
85 | }
86 |
87 | input ID_filter {
88 | eq: ID
89 | ge: ID
90 | gt: ID
91 | in: [ID]
92 | le: ID
93 | lt: ID
94 | ne: [ID]
95 | }
96 |
97 | type Mutation {
98 | CompositionOfAspectService: CompositionOfAspectService_input
99 | }
100 |
101 | type Query {
102 | CompositionOfAspectService: CompositionOfAspectService
103 | }
104 |
105 | enum SortDirection {
106 | asc
107 | desc
108 | }
--------------------------------------------------------------------------------
/lib/resolvers/parse/ast2cqn/where.js:
--------------------------------------------------------------------------------
1 | const { RELATIONAL_OPERATORS, LOGICAL_OPERATORS, STRING_OPERATIONS } = require('../../../constants')
2 | const { Kind } = require('graphql')
3 |
4 | const GQL_TO_CDS_STRING_OPERATIONS = {
5 | [STRING_OPERATIONS.startswith]: 'startswith',
6 | [STRING_OPERATIONS.endswith]: 'endswith',
7 | [STRING_OPERATIONS.contains]: 'contains'
8 | }
9 |
10 | const GQL_TO_CDS_QL_OPERATOR = {
11 | [RELATIONAL_OPERATORS.eq]: '=',
12 | [RELATIONAL_OPERATORS.ne]: '!=',
13 | [RELATIONAL_OPERATORS.gt]: '>',
14 | [RELATIONAL_OPERATORS.ge]: '>=',
15 | [RELATIONAL_OPERATORS.le]: '<=',
16 | [RELATIONAL_OPERATORS.lt]: '<',
17 | [LOGICAL_OPERATORS.in]: 'in'
18 | }
19 |
20 | const _gqlOperatorToCdsOperator = gqlOperator =>
21 | GQL_TO_CDS_QL_OPERATOR[gqlOperator] || GQL_TO_CDS_STRING_OPERATIONS[gqlOperator]
22 |
23 | const _to_xpr = (ref, gqlOperator, value) => {
24 | const cdsOperator = _gqlOperatorToCdsOperator(gqlOperator)
25 | const val = { val: value }
26 |
27 | if (STRING_OPERATIONS[gqlOperator]) return [{ func: cdsOperator, args: [ref, val] }]
28 | return [ref, cdsOperator, val]
29 | }
30 |
31 | const _objectFieldTo_xpr = (objectField, columnName) => {
32 | const ref = { ref: [columnName] }
33 | const gqlOperator = objectField.name.value
34 | const operand = objectField.value
35 |
36 | if (gqlOperator === LOGICAL_OPERATORS.in) {
37 | const list =
38 | operand.kind === Kind.LIST ? operand.values.map(value => ({ val: value.value })) : [{ val: operand.value }]
39 | return [ref, _gqlOperatorToCdsOperator(gqlOperator), { list }]
40 | }
41 |
42 | if (operand.kind === Kind.LIST) {
43 | const _xprs = operand.values.map(value => _to_xpr(ref, gqlOperator, value.value))
44 | return _joinedXprFrom_xprs(_xprs, 'and')
45 | }
46 |
47 | return _to_xpr(ref, gqlOperator, operand.value)
48 | }
49 |
50 | const _parseObjectField = (objectField, columnName) => {
51 | if (columnName) return _objectFieldTo_xpr(objectField, columnName)
52 |
53 | const value = objectField.value
54 | const name = objectField.name.value
55 | switch (value.kind) {
56 | case Kind.LIST:
57 | return _parseListValue(value, name)
58 | case Kind.OBJECT:
59 | return _parseObjectValue(value, name)
60 | }
61 | }
62 |
63 | const _arrayInsertBetweenFlat = (array, element) =>
64 | array.flatMap((e, index) => (index === array.length - 1 ? [e] : [e, element])).flat()
65 |
66 | const _joinedXprFrom_xprs = (_xprs, operator) => ({ xpr: _arrayInsertBetweenFlat(_xprs, operator) })
67 |
68 | const _true_xpr = [{ val: '1' }, '=', { val: '1' }]
69 |
70 | const _parseObjectValue = (objectValue, columnName) => {
71 | const _xprs = objectValue.fields
72 | .map(field => _parseObjectField(field, columnName))
73 | .filter(field => field !== undefined)
74 | if (_xprs.length === 0) return _true_xpr
75 | else if (_xprs.length === 1) return _xprs[0]
76 | return _joinedXprFrom_xprs(_xprs, 'and')
77 | }
78 |
79 | const _false_xpr = [{ val: '0' }, '=', { val: '1' }]
80 |
81 | const _parseListValue = (listValue, columnName) => {
82 | const _xprs = listValue.values.map(value => _parseObjectValue(value, columnName)).filter(value => value !== undefined)
83 | if (_xprs.length === 0) return _false_xpr
84 | else if (_xprs.length === 1) return _xprs[0]
85 | return _joinedXprFrom_xprs(_xprs, 'or')
86 | }
87 |
88 | const astToWhere = filterArg => {
89 | const value = filterArg.value
90 | switch (value.kind) {
91 | case Kind.LIST:
92 | return _parseListValue(value)
93 | case Kind.OBJECT:
94 | return _parseObjectValue(value)
95 | }
96 | }
97 |
98 | module.exports = astToWhere
99 |
--------------------------------------------------------------------------------
/test/schemas/edge-cases/field-named-localized.gql:
--------------------------------------------------------------------------------
1 | type FieldNamedLocalizedService {
2 | Root(filter: [FieldNamedLocalizedService_Root_filter], orderBy: [FieldNamedLocalizedService_Root_orderBy], skip: Int, top: Int): FieldNamedLocalizedService_Root_connection
3 | localized(filter: [FieldNamedLocalizedService_localized_filter], orderBy: [FieldNamedLocalizedService_localized_orderBy], skip: Int, top: Int): FieldNamedLocalizedService_localized_connection
4 | }
5 |
6 | type FieldNamedLocalizedService_Root {
7 | ID: Int
8 | localized(filter: [FieldNamedLocalizedService_localized_filter], orderBy: [FieldNamedLocalizedService_localized_orderBy], skip: Int, top: Int): FieldNamedLocalizedService_localized_connection
9 | }
10 |
11 | input FieldNamedLocalizedService_Root_C {
12 | ID: Int
13 | localized: [FieldNamedLocalizedService_localized_C]
14 | }
15 |
16 | input FieldNamedLocalizedService_Root_U {
17 | localized: [FieldNamedLocalizedService_localized_C]
18 | }
19 |
20 | type FieldNamedLocalizedService_Root_connection {
21 | nodes: [FieldNamedLocalizedService_Root]
22 | totalCount: Int
23 | }
24 |
25 | input FieldNamedLocalizedService_Root_filter {
26 | ID: [Int_filter]
27 | }
28 |
29 | type FieldNamedLocalizedService_Root_input {
30 | create(input: [FieldNamedLocalizedService_Root_C]!): [FieldNamedLocalizedService_Root]
31 | delete(filter: [FieldNamedLocalizedService_Root_filter]!): Int
32 | update(filter: [FieldNamedLocalizedService_Root_filter]!, input: FieldNamedLocalizedService_Root_U!): [FieldNamedLocalizedService_Root]
33 | }
34 |
35 | input FieldNamedLocalizedService_Root_orderBy {
36 | ID: SortDirection
37 | }
38 |
39 | type FieldNamedLocalizedService_input {
40 | Root: FieldNamedLocalizedService_Root_input
41 | localized: FieldNamedLocalizedService_localized_input
42 | }
43 |
44 | type FieldNamedLocalizedService_localized {
45 | ID: Int
46 | localized: String
47 | root: FieldNamedLocalizedService_Root
48 | }
49 |
50 | input FieldNamedLocalizedService_localized_C {
51 | ID: Int
52 | localized: String
53 | root: FieldNamedLocalizedService_Root_C
54 | }
55 |
56 | input FieldNamedLocalizedService_localized_U {
57 | localized: String
58 | root: FieldNamedLocalizedService_Root_C
59 | }
60 |
61 | type FieldNamedLocalizedService_localized_connection {
62 | nodes: [FieldNamedLocalizedService_localized]
63 | totalCount: Int
64 | }
65 |
66 | input FieldNamedLocalizedService_localized_filter {
67 | ID: [Int_filter]
68 | localized: [String_filter]
69 | }
70 |
71 | type FieldNamedLocalizedService_localized_input {
72 | create(input: [FieldNamedLocalizedService_localized_C]!): [FieldNamedLocalizedService_localized]
73 | delete(filter: [FieldNamedLocalizedService_localized_filter]!): Int
74 | update(filter: [FieldNamedLocalizedService_localized_filter]!, input: FieldNamedLocalizedService_localized_U!): [FieldNamedLocalizedService_localized]
75 | }
76 |
77 | input FieldNamedLocalizedService_localized_orderBy {
78 | ID: SortDirection
79 | localized: SortDirection
80 | }
81 |
82 | input Int_filter {
83 | eq: Int
84 | ge: Int
85 | gt: Int
86 | in: [Int]
87 | le: Int
88 | lt: Int
89 | ne: [Int]
90 | }
91 |
92 | type Mutation {
93 | FieldNamedLocalizedService: FieldNamedLocalizedService_input
94 | }
95 |
96 | type Query {
97 | FieldNamedLocalizedService: FieldNamedLocalizedService
98 | }
99 |
100 | enum SortDirection {
101 | asc
102 | desc
103 | }
104 |
105 | input String_filter {
106 | contains: [String]
107 | endswith: String
108 | eq: String
109 | ge: String
110 | gt: String
111 | in: [String]
112 | le: String
113 | lt: String
114 | ne: [String]
115 | startswith: String
116 | }
--------------------------------------------------------------------------------
/test/schemas/edge-cases/fields-with-connection-names.gql:
--------------------------------------------------------------------------------
1 | type FieldsWithConnectionNamesService {
2 | Nodes(filter: [FieldsWithConnectionNamesService_Nodes_filter], orderBy: [FieldsWithConnectionNamesService_Nodes_orderBy], skip: Int, top: Int): FieldsWithConnectionNamesService_Nodes_connection
3 | Root(filter: [FieldsWithConnectionNamesService_Root_filter], orderBy: [FieldsWithConnectionNamesService_Root_orderBy], skip: Int, top: Int): FieldsWithConnectionNamesService_Root_connection
4 | }
5 |
6 | type FieldsWithConnectionNamesService_Nodes {
7 | ID: ID
8 | nodes: String
9 | totalCount: String
10 | }
11 |
12 | input FieldsWithConnectionNamesService_Nodes_C {
13 | ID: ID
14 | nodes: String
15 | totalCount: String
16 | }
17 |
18 | input FieldsWithConnectionNamesService_Nodes_U {
19 | nodes: String
20 | totalCount: String
21 | }
22 |
23 | type FieldsWithConnectionNamesService_Nodes_connection {
24 | nodes: [FieldsWithConnectionNamesService_Nodes]
25 | totalCount: Int
26 | }
27 |
28 | input FieldsWithConnectionNamesService_Nodes_filter {
29 | ID: [ID_filter]
30 | nodes: [String_filter]
31 | totalCount: [String_filter]
32 | }
33 |
34 | type FieldsWithConnectionNamesService_Nodes_input {
35 | create(input: [FieldsWithConnectionNamesService_Nodes_C]!): [FieldsWithConnectionNamesService_Nodes]
36 | delete(filter: [FieldsWithConnectionNamesService_Nodes_filter]!): Int
37 | update(filter: [FieldsWithConnectionNamesService_Nodes_filter]!, input: FieldsWithConnectionNamesService_Nodes_U!): [FieldsWithConnectionNamesService_Nodes]
38 | }
39 |
40 | input FieldsWithConnectionNamesService_Nodes_orderBy {
41 | ID: SortDirection
42 | nodes: SortDirection
43 | totalCount: SortDirection
44 | }
45 |
46 | type FieldsWithConnectionNamesService_Root {
47 | ID: ID
48 | nodes: FieldsWithConnectionNamesService_Nodes
49 | totalCount: String
50 | }
51 |
52 | input FieldsWithConnectionNamesService_Root_C {
53 | ID: ID
54 | nodes: FieldsWithConnectionNamesService_Nodes_C
55 | totalCount: String
56 | }
57 |
58 | input FieldsWithConnectionNamesService_Root_U {
59 | nodes: FieldsWithConnectionNamesService_Nodes_C
60 | totalCount: String
61 | }
62 |
63 | type FieldsWithConnectionNamesService_Root_connection {
64 | nodes: [FieldsWithConnectionNamesService_Root]
65 | totalCount: Int
66 | }
67 |
68 | input FieldsWithConnectionNamesService_Root_filter {
69 | ID: [ID_filter]
70 | totalCount: [String_filter]
71 | }
72 |
73 | type FieldsWithConnectionNamesService_Root_input {
74 | create(input: [FieldsWithConnectionNamesService_Root_C]!): [FieldsWithConnectionNamesService_Root]
75 | delete(filter: [FieldsWithConnectionNamesService_Root_filter]!): Int
76 | update(filter: [FieldsWithConnectionNamesService_Root_filter]!, input: FieldsWithConnectionNamesService_Root_U!): [FieldsWithConnectionNamesService_Root]
77 | }
78 |
79 | input FieldsWithConnectionNamesService_Root_orderBy {
80 | ID: SortDirection
81 | totalCount: SortDirection
82 | }
83 |
84 | type FieldsWithConnectionNamesService_input {
85 | Nodes: FieldsWithConnectionNamesService_Nodes_input
86 | Root: FieldsWithConnectionNamesService_Root_input
87 | }
88 |
89 | input ID_filter {
90 | eq: ID
91 | ge: ID
92 | gt: ID
93 | in: [ID]
94 | le: ID
95 | lt: ID
96 | ne: [ID]
97 | }
98 |
99 | type Mutation {
100 | FieldsWithConnectionNamesService: FieldsWithConnectionNamesService_input
101 | }
102 |
103 | type Query {
104 | FieldsWithConnectionNamesService: FieldsWithConnectionNamesService
105 | }
106 |
107 | enum SortDirection {
108 | asc
109 | desc
110 | }
111 |
112 | input String_filter {
113 | contains: [String]
114 | endswith: String
115 | eq: String
116 | ge: String
117 | gt: String
118 | in: [String]
119 | le: String
120 | lt: String
121 | ne: [String]
122 | startswith: String
123 | }
--------------------------------------------------------------------------------
/lib/schema/mutation.js:
--------------------------------------------------------------------------------
1 | const { GraphQLObjectType, GraphQLList, GraphQLInt, GraphQLNonNull } = require('graphql')
2 | const { gqlName } = require('../utils')
3 | const objectGenerator = require('./types/object')
4 | const filterGenerator = require('./args/filter')
5 | const inputObjectGenerator = require('./args/input')
6 | const { ARGS } = require('../constants')
7 | const { isCompositionOfAspect } = require('./util')
8 |
9 | module.exports = cache => {
10 | const generateMutationObjectType = (services, resolvers) => {
11 | const fields = {}
12 |
13 | for (const key in services) {
14 | const service = services[key]
15 | const serviceName = gqlName(service.name)
16 | const resolve = resolvers[serviceName]
17 | const type = _serviceToObjectType(service)
18 | if (type) fields[serviceName] = { type, resolve }
19 | }
20 |
21 | if (!Object.keys(fields).length) return
22 |
23 | return new GraphQLObjectType({ name: 'Mutation', fields })
24 | }
25 |
26 | const _serviceToObjectType = service => {
27 | const fields = {}
28 |
29 | for (const key in service.entities) {
30 | const entity = service.entities[key]
31 |
32 | if (isCompositionOfAspect(entity)) continue
33 |
34 | const entityName = gqlName(key)
35 | const type = _entityToObjectType(entity)
36 | if (type) fields[entityName] = { type }
37 | }
38 |
39 | if (!Object.keys(fields).length) return
40 |
41 | return new GraphQLObjectType({ name: gqlName(service.name) + '_input', fields })
42 | }
43 |
44 | const _entityToObjectType = entity => {
45 | // Filter out undefined fields
46 | const fields = Object.fromEntries(
47 | Object.entries({
48 | create: _create(entity),
49 | update: _update(entity),
50 | delete: _delete(entity)
51 | }).filter(([_, v]) => v)
52 | )
53 |
54 | if (!Object.keys(fields).length) return
55 |
56 | return new GraphQLObjectType({ name: gqlName(entity.name) + '_input', fields })
57 | }
58 |
59 | const _create = entity => {
60 | const entityObjectType = objectGenerator(cache).entityToObjectType(entity)
61 |
62 | const createInputObjectType = inputObjectGenerator(cache).entityToInputObjectType(entity, false)
63 | if (!createInputObjectType) return
64 |
65 | const args = {
66 | [ARGS.input]: { type: new GraphQLNonNull(new GraphQLList(createInputObjectType)) }
67 | }
68 | return { type: new GraphQLList(entityObjectType), args }
69 | }
70 |
71 | const _update = entity => {
72 | const entityObjectType = objectGenerator(cache).entityToObjectType(entity)
73 |
74 | const filterInputObjectType = filterGenerator(cache).generateFilterForEntity(entity)
75 | const updateInputObjectType = inputObjectGenerator(cache).entityToInputObjectType(entity, true)
76 | // filterInputObjectType is undefined if the entity only contains elements that are associations or compositions
77 | // updateInputObjectType is undefined if it is generated for an entity that only contains key elements
78 | if (!filterInputObjectType || !updateInputObjectType) return
79 |
80 | const args = {
81 | [ARGS.filter]: { type: new GraphQLNonNull(filterInputObjectType) },
82 | [ARGS.input]: { type: new GraphQLNonNull(updateInputObjectType) }
83 | }
84 | return { type: new GraphQLList(entityObjectType), args }
85 | }
86 |
87 | const _delete = entity => {
88 | const filterInputObjectType = filterGenerator(cache).generateFilterForEntity(entity)
89 | // filterInputObjectType is undefined if the entity only contains elements that are associations or compositions
90 | if (!filterInputObjectType) return
91 |
92 | const args = {
93 | [ARGS.filter]: { type: new GraphQLNonNull(filterInputObjectType) }
94 | }
95 | return { type: GraphQLInt, args }
96 | }
97 |
98 | return { generateMutationObjectType }
99 | }
100 |
--------------------------------------------------------------------------------
/lib/schema/args/filter.js:
--------------------------------------------------------------------------------
1 | const {
2 | GraphQLList,
3 | GraphQLString,
4 | GraphQLBoolean,
5 | GraphQLFloat,
6 | GraphQLInt,
7 | GraphQLID,
8 | GraphQLInputObjectType
9 | } = require('graphql')
10 | const { gqlName } = require('../../utils')
11 | const { hasScalarFields, shouldElementBeIgnored } = require('../util')
12 | const { cdsToGraphQLScalarType } = require('../types/scalar')
13 | const { RELATIONAL_OPERATORS, LOGICAL_OPERATORS, STRING_OPERATIONS, OPERATOR_LIST_SUPPORT } = require('../../constants')
14 | const {
15 | GraphQLBinary,
16 | GraphQLDate,
17 | GraphQLDateTime,
18 | GraphQLInt16,
19 | GraphQLInt64,
20 | GraphQLDecimal,
21 | GraphQLTime,
22 | GraphQLTimestamp,
23 | GraphQLUInt8
24 | } = require('../types/custom')
25 |
26 | module.exports = cache => {
27 | const generateFilterForEntity = entity => {
28 | if (!hasScalarFields(entity)) return
29 |
30 | const filterName = gqlName(entity.name) + '_filter'
31 |
32 | if (cache.has(filterName)) return cache.get(filterName)
33 |
34 | const fields = {}
35 | const filterInputType = new GraphQLList(new GraphQLInputObjectType({ name: filterName, fields: () => fields }))
36 | cache.set(filterName, filterInputType)
37 |
38 | for (const name in entity.elements) {
39 | const element = entity.elements[name]
40 | const type = generateFilterForElement(element)
41 | if (type) fields[gqlName(name)] = { type }
42 | }
43 |
44 | return filterInputType
45 | }
46 |
47 | const generateFilterForElement = (element, followAssocOrComp) => {
48 | if (shouldElementBeIgnored(element)) return
49 |
50 | const gqlScalarType = cdsToGraphQLScalarType(element)
51 | if (followAssocOrComp && (element.isAssociation || element.isComposition)) {
52 | return gqlScalarType ? _generateScalarFilter(gqlScalarType) : generateFilterForEntity(element._target)
53 | } else if (gqlScalarType) {
54 | return _generateScalarFilter(gqlScalarType)
55 | }
56 | }
57 |
58 | const _generateScalarFilter = gqlType => {
59 | const numericOperators = Object.values({ ...RELATIONAL_OPERATORS, ...LOGICAL_OPERATORS })
60 | const filterType = {
61 | // REVISIT: which filters for binary
62 | [GraphQLBinary.name]: _generateFilterType(GraphQLBinary, [RELATIONAL_OPERATORS.eq, RELATIONAL_OPERATORS.ne]),
63 | [GraphQLBoolean.name]: _generateFilterType(GraphQLBoolean, [RELATIONAL_OPERATORS.eq, RELATIONAL_OPERATORS.ne]),
64 | [GraphQLDate.name]: _generateFilterType(GraphQLDate, numericOperators),
65 | [GraphQLDateTime.name]: _generateFilterType(GraphQLDateTime, numericOperators),
66 | [GraphQLDecimal.name]: _generateFilterType(GraphQLDecimal, numericOperators),
67 | // REVISIT: should 'eq'/'ne'/'in' be generated since exact comparisons could be difficult due to floating point errors?
68 | [GraphQLFloat.name]: _generateFilterType(GraphQLFloat, numericOperators),
69 | [GraphQLID.name]: _generateFilterType(GraphQLID, numericOperators),
70 | [GraphQLInt.name]: _generateFilterType(GraphQLInt, numericOperators),
71 | [GraphQLInt16.name]: _generateFilterType(GraphQLInt16, numericOperators),
72 | [GraphQLInt64.name]: _generateFilterType(GraphQLInt64, numericOperators),
73 | [GraphQLString.name]: _generateFilterType(
74 | GraphQLString,
75 | Object.values({ ...RELATIONAL_OPERATORS, ...LOGICAL_OPERATORS, ...STRING_OPERATIONS })
76 | ),
77 | [GraphQLTime.name]: _generateFilterType(GraphQLTime, numericOperators),
78 | [GraphQLTimestamp.name]: _generateFilterType(GraphQLTimestamp, numericOperators),
79 | [GraphQLUInt8.name]: _generateFilterType(GraphQLUInt8, numericOperators)
80 | }[gqlType.name]
81 | return new GraphQLList(filterType)
82 | }
83 |
84 | const _generateFilterType = (gqlType, operations) => {
85 | const filterName = gqlType.name + '_filter'
86 |
87 | if (cache.has(filterName)) return cache.get(filterName)
88 |
89 | const ops = operations.map(op => [[op], { type: OPERATOR_LIST_SUPPORT[op] ? new GraphQLList(gqlType) : gqlType }])
90 | const fields = Object.fromEntries(ops)
91 | const filterType = new GraphQLInputObjectType({ name: filterName, fields })
92 | cache.set(filterName, filterType)
93 |
94 | return filterType
95 | }
96 |
97 | return { generateFilterForEntity, generateFilterForElement }
98 | }
99 |
--------------------------------------------------------------------------------
/test/tests/request.test.js:
--------------------------------------------------------------------------------
1 | describe('graphql - cds.request', () => {
2 | const cds = require('@sap/cds')
3 | const path = require('path')
4 | const { gql } = require('../util')
5 |
6 | const { axios, POST } = cds.test(path.join(__dirname, '../resources/cds.Request'))
7 | // Prevent axios from throwing errors for non 2xx status codes
8 | axios.defaults.validateStatus = false
9 |
10 | describe('HTTP request headers are correctly passed to custom handlers', () => {
11 | const my_header = 'my header value'
12 |
13 | test('Create', async () => {
14 | const query = gql`
15 | mutation {
16 | RequestService {
17 | A {
18 | create(input: {}) {
19 | my_header
20 | }
21 | }
22 | }
23 | }
24 | `
25 | const data = {
26 | RequestService: {
27 | A: {
28 | create: [{ my_header }]
29 | }
30 | }
31 | }
32 | const response = await POST('/graphql', { query }, { headers: { my_header } })
33 | expect(response.data).toEqual({ data })
34 | })
35 |
36 | test('Read', async () => {
37 | const query = gql`
38 | {
39 | RequestService {
40 | A {
41 | nodes {
42 | my_header
43 | }
44 | }
45 | }
46 | }
47 | `
48 | const data = {
49 | RequestService: {
50 | A: {
51 | nodes: [{ my_header }]
52 | }
53 | }
54 | }
55 | const response = await POST('/graphql', { query }, { headers: { my_header } })
56 | expect(response.data).toEqual({ data })
57 | })
58 |
59 | test('Update', async () => {
60 | const query = gql`
61 | mutation {
62 | RequestService {
63 | A {
64 | update(filter: [], input: {}) {
65 | my_header
66 | }
67 | }
68 | }
69 | }
70 | `
71 | const data = {
72 | RequestService: {
73 | A: {
74 | update: [{ my_header }]
75 | }
76 | }
77 | }
78 | const response = await POST('/graphql', { query }, { headers: { my_header } })
79 | expect(response.data).toEqual({ data })
80 | })
81 |
82 | test('Delete', async () => {
83 | const query = gql`
84 | mutation {
85 | RequestService {
86 | A {
87 | delete(filter: [])
88 | }
89 | }
90 | }
91 | `
92 | const data = {
93 | RequestService: {
94 | A: {
95 | delete: 999
96 | }
97 | }
98 | }
99 | const response = await POST('/graphql', { query }, { headers: { my_header } })
100 | expect(response.data).toEqual({ data })
101 | })
102 | })
103 |
104 | describe('HTTP response headers are correctly set in custom handlers', () => {
105 | const my_res_header = 'my res header value'
106 |
107 | test('Create', async () => {
108 | const query = gql`
109 | mutation {
110 | RequestService {
111 | A {
112 | create(input: {}) {
113 | id
114 | }
115 | }
116 | }
117 | }
118 | `
119 | const response = await POST('/graphql', { query })
120 | expect(response.headers).toMatchObject({ my_res_header })
121 | })
122 |
123 | test('Read', async () => {
124 | const query = gql`
125 | {
126 | RequestService {
127 | A {
128 | nodes {
129 | id
130 | }
131 | }
132 | }
133 | }
134 | `
135 | const response = await POST('/graphql', { query })
136 | expect(response.headers).toMatchObject({ my_res_header })
137 | })
138 |
139 | test('Update', async () => {
140 | const query = gql`
141 | mutation {
142 | RequestService {
143 | A {
144 | update(filter: [], input: {}) {
145 | id
146 | }
147 | }
148 | }
149 | }
150 | `
151 | const response = await POST('/graphql', { query })
152 | expect(response.headers).toMatchObject({ my_res_header })
153 | })
154 |
155 | test('Delete', async () => {
156 | const query = gql`
157 | mutation {
158 | RequestService {
159 | A {
160 | delete(filter: [])
161 | }
162 | }
163 | }
164 | `
165 | const response = await POST('/graphql', { query })
166 | expect(response.headers).toMatchObject({ my_res_header })
167 | })
168 | })
169 | })
170 |
--------------------------------------------------------------------------------
/lib/resolvers/error.js:
--------------------------------------------------------------------------------
1 | const cds = require('@sap/cds')
2 | const { i18n } = cds
3 | const LOG_CDS = cds.log()
4 | const LOG_GRAPHQL = cds.log('graphql')
5 | const { GraphQLError } = require('graphql')
6 | const { IS_PRODUCTION } = require('../utils')
7 |
8 | // FIXME: importing internal modules from @sap/cds is discouraged and not recommended for external usage
9 | const { normalizeError } = require('@sap/cds/libx/odata/middleware/error')
10 |
11 | const _applyToJSON = error => {
12 | // Make stack enumerable so it isn't stripped by toJSON function
13 | if (error.stack) Object.defineProperty(error, 'stack', { value: error.stack, enumerable: true })
14 | // Call toJSON function to apply i18n
15 | return error.toJSON ? error.toJSON() : error
16 | }
17 |
18 | const _reorderProperties = error => {
19 | // 'stack' and 'stacktrace' to cover both common cases that a custom error formatter might return
20 | let { code, message, details, stack, stacktrace } = error
21 | if (details) details = details.map(_reorderProperties)
22 | return { code, message, ...error, stack, stacktrace, details }
23 | }
24 |
25 | const _cdsToGraphQLError = (context, err) => {
26 | const { req, errorFormatter } = context
27 | let error = normalizeError(err, req, false)
28 |
29 | error = _applyToJSON(error)
30 | if (error.details) error.details = error.details.map(_applyToJSON)
31 |
32 | // In case of 5xx errors in production don't reveal details to clients
33 | if (IS_PRODUCTION && error.status >= 500 && error.$sanitize !== false)
34 | error = {
35 | message: i18n.messages.at(error.status, cds.context.locale) || 'Internal Server Error',
36 | code: String(error.status) // toJSON is intentionally gone
37 | }
38 |
39 | // Apply error formatter to error details first if they exist, then apply error formatter to outer error
40 | if (error.details) error.details = error.details.map(errorFormatter)
41 | error = errorFormatter(error)
42 |
43 | // Ensure error properties are ordered nicely for the client
44 | error = _reorderProperties(error)
45 |
46 | const { message } = error
47 | const extensions = error
48 |
49 | // Top level message is already passed to GraphQLError to be used beside extensions -> not needed in extensions
50 | delete extensions.message
51 |
52 | const graphQLError = new GraphQLError(message, { extensions })
53 |
54 | return Object.defineProperty(graphQLError, '_cdsError', { value: true, writable: false, enumerable: false })
55 | }
56 |
57 | const _clone = obj => Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj))
58 |
59 | // TODO: Revise this logging functionality, as it's not specific to protocol adapters.
60 | // This function should be relocated and/or cleaned up when the new abstract/generic
61 | // protocol adapter is designed and implemented.
62 | const _log = (error, req) => {
63 | // log errors and warnings only
64 | if (LOG_CDS.level <= cds.log.levels.WARN) return
65 |
66 | // Clone of the original error object to prevent mutation and unintended side-effects.
67 | // Notice that the cloned error is logged to standard output in its default language,
68 | // whereas the original error message is locale-dependent as it is usually sent in the
69 | // HTTP response to HTTP Clients to be displayed in the user interface.
70 | let error2log = _clone(error)
71 | if (error.details) {
72 | error2log.details = error.details.map(error => _clone(error))
73 |
74 | // Excluding the stack trace for the outer error as the inner stack trace already
75 | // contains the initial segment of the outer stack trace.
76 | delete error2log.stack
77 | }
78 |
79 | error2log = normalizeError(error2log, { __proto__: req, locale: '' }, false)
80 |
81 | // determine if the status code represents a client error (4xx range)
82 | if (error2log.status >= 400 && error2log.status < 500) {
83 | if (LOG_CDS._warn) LOG_CDS.warn(error2log)
84 | } else {
85 | // server error
86 | if (LOG_CDS._error) LOG_CDS.error(error2log)
87 | }
88 | }
89 |
90 | const _ensureError = error => (error instanceof Error ? error : new Error(error))
91 |
92 | const handleCDSError = (context, error) => {
93 | error = _ensureError(error)
94 | _log(error, context.req)
95 | return _cdsToGraphQLError(context, error)
96 | }
97 |
98 | const formatError = error => {
99 | // Note: error is not always an instance of GraphQLError
100 |
101 | // CDS errors have already been logged and already have a stacktrace in extensions
102 | if (error.originalError?._cdsError) return error
103 |
104 | if (LOG_GRAPHQL._error) LOG_GRAPHQL.error(error)
105 |
106 | // error does not have an extensions property when it is not an instance of GraphQLError
107 | if (!IS_PRODUCTION && error.extensions) error.extensions.stacktrace = error.stack.split('\n')
108 |
109 | return error
110 | }
111 |
112 | module.exports = { handleCDSError, formatError }
113 |
--------------------------------------------------------------------------------
/test/tests/annotations.test.js:
--------------------------------------------------------------------------------
1 | describe('graphql - annotations', () => {
2 | const cds = require('@sap/cds')
3 | const path = require('path')
4 | const { gql } = require('../util')
5 |
6 | const { axios, POST } = cds.test(path.join(__dirname, '../resources/annotations'))
7 | // Prevent axios from throwing errors for non 2xx status codes
8 | axios.defaults.validateStatus = false
9 |
10 | describe('protocols annotations', () => {
11 | const path = '/custom-graphql-path'
12 |
13 | test('service not annotated is not served', async () => {
14 | const query = gql`
15 | {
16 | NotAnnotated {
17 | A {
18 | nodes {
19 | id
20 | }
21 | }
22 | }
23 | }
24 | `
25 | const response = await POST(path, { query })
26 | expect(response.data.errors[0].message).toMatch(/^Cannot query field "NotAnnotated" on type "Query"\./)
27 | })
28 |
29 | test('service annotated with "@protocol: \'none\'" is not served', async () => {
30 | const query = gql`
31 | {
32 | AnnotatedWithAtProtocolNone {
33 | A {
34 | nodes {
35 | id
36 | }
37 | }
38 | }
39 | }
40 | `
41 | const response = await POST(path, { query })
42 | expect(response.data.errors[0].message).toMatch(
43 | /^Cannot query field "AnnotatedWithAtProtocolNone" on type "Query"\./
44 | )
45 | })
46 |
47 | test('service annotated with non-GraphQL protocol is not served', async () => {
48 | const query = gql`
49 | {
50 | AnnotatedWithNonGraphQL {
51 | A {
52 | nodes {
53 | id
54 | }
55 | }
56 | }
57 | }
58 | `
59 | const response = await POST(path, { query })
60 | expect(response.data.errors[0].message).toMatch(/^Cannot query field "AnnotatedWithNonGraphQL" on type "Query"\./)
61 | })
62 |
63 | test('service annotated with @graphql is served at configured path', async () => {
64 | const query = gql`
65 | {
66 | AnnotatedWithAtGraphQL {
67 | A {
68 | nodes {
69 | id
70 | }
71 | }
72 | }
73 | }
74 | `
75 | const response = await POST(path, { query })
76 | expect(response.data).not.toHaveProperty('errors')
77 | })
78 |
79 | test('service annotated with "@protocol: \'graphql\'" is served at configured path', async () => {
80 | const query = gql`
81 | {
82 | AnnotatedWithAtProtocolString {
83 | A {
84 | nodes {
85 | id
86 | }
87 | }
88 | }
89 | }
90 | `
91 | const response = await POST(path, { query })
92 | expect(response.data).not.toHaveProperty('errors')
93 | })
94 |
95 | test('service annotated with "@protocol: [\'graphql\']" is served at configured path', async () => {
96 | const query = gql`
97 | {
98 | AnnotatedWithAtProtocolStringList {
99 | A {
100 | nodes {
101 | id
102 | }
103 | }
104 | }
105 | }
106 | `
107 | const response = await POST(path, { query })
108 | expect(response.data).not.toHaveProperty('errors')
109 | })
110 |
111 | test('service annotated with "@protocol: [{kind: \'graphql\'}]" is served at configured path', async () => {
112 | const query = gql`
113 | {
114 | AnnotatedWithAtProtocolObjectList {
115 | A {
116 | nodes {
117 | id
118 | }
119 | }
120 | }
121 | }
122 | `
123 | const response = await POST(path, { query })
124 | expect(response.data).not.toHaveProperty('errors')
125 | })
126 |
127 | test('service annotated with "@protocol: { graphql }" is served at configured path', async () => {
128 | const query = gql`
129 | {
130 | AnnotatedWithAtProtocolObjectWithKey {
131 | A {
132 | nodes {
133 | id
134 | }
135 | }
136 | }
137 | }
138 | `
139 | const response = await POST(path, { query })
140 | expect(response.data).not.toHaveProperty('errors')
141 | })
142 |
143 | test('service annotated with "@protocol: { graphql: \'dummy\' }" is served at configured path', async () => {
144 | const query = gql`
145 | {
146 | AnnotatedWithAtProtocolObjectWithKeyAndValue {
147 | A {
148 | nodes {
149 | id
150 | }
151 | }
152 | }
153 | }
154 | `
155 | const response = await POST(path, { query })
156 | expect(response.data).not.toHaveProperty('errors')
157 | })
158 | })
159 | })
160 |
--------------------------------------------------------------------------------
/test/resources/bookshop/test/requests.http:
--------------------------------------------------------------------------------
1 | @server = http://localhost:4004
2 | @me = Authorization: Basic {{$processEnv USER}}:
3 |
4 |
5 | ### ------------------------------------------------------------------------
6 | # Get service info
7 | GET {{server}}/browse
8 | {{me}}
9 |
10 |
11 | ### ------------------------------------------------------------------------
12 | # Get $metadata document
13 | GET {{server}}/browse/$metadata
14 | {{me}}
15 |
16 |
17 | ### ------------------------------------------------------------------------
18 | # Browse Books as any user
19 | GET {{server}}/browse/ListOfBooks?
20 | # &$select=title,stock
21 | &$expand=genre
22 | # &sap-language=de
23 | {{me}}
24 |
25 |
26 | ### ------------------------------------------------------------------------
27 | # Fetch Authors as admin
28 | GET {{server}}/admin/Authors?
29 | # &$select=name,dateOfBirth,placeOfBirth
30 | # &$expand=books($select=title;$expand=currency)
31 | # &$filter=ID eq 101
32 | # &sap-language=de
33 | Authorization: Basic alice:
34 |
35 | ### ------------------------------------------------------------------------
36 | # Create Author
37 | POST {{server}}/admin/Authors
38 | Content-Type: application/json;IEEE754Compatible=true
39 | Authorization: Basic alice:
40 |
41 | {
42 | "ID": 112,
43 | "name": "Shakespeeeeere",
44 | "age": 22
45 | }
46 |
47 |
48 | ### ------------------------------------------------------------------------
49 | # Create book
50 | POST {{server}}/admin/Books
51 | Content-Type: application/json;IEEE754Compatible=true
52 | Authorization: Basic alice:
53 |
54 | {
55 | "ID": 2,
56 | "title": "Poems : Pocket Poets",
57 | "descr": "The Everyman's Library Pocket Poets hardcover series is popular for its compact size and reasonable price which does not compromise content. Poems: Bronte contains poems that demonstrate a sensibility elemental in its force with an imaginative discipline and flexibility of the highest order. Also included are an Editor's Note and an index of first lines.",
58 | "author": { "ID": 101 },
59 | "genre": { "ID": 12 },
60 | "stock": 5,
61 | "price": "12.05",
62 | "currency": { "code": "USD" }
63 | }
64 |
65 |
66 | ### ------------------------------------------------------------------------
67 | # Put image to books
68 | PUT {{server}}/admin/Books(2)/image
69 | Content-Type: image/png
70 | Authorization: Basic alice:
71 |
72 | data:image/png;base64,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
73 |
74 |
75 | ### ------------------------------------------------------------------------
76 | # Reading image from from the server directly
77 | GET {{server}}/browse/Books(2)/image
78 |
79 |
80 | ### ------------------------------------------------------------------------
81 | # Submit Order as authenticated user
82 | # (send that three times to get out-of-stock message)
83 | POST {{server}}/browse/submitOrder
84 | Content-Type: application/json
85 | {{me}}
86 |
87 | { "book":201, "quantity":5 }
88 |
89 |
90 | ### ------------------------------------------------------------------------
91 | # Browse Genres
92 | GET {{server}}/browse/Genres?
93 | # &$filter=parent_ID eq null&$select=name
94 | # &$expand=children($select=name)
95 | {{me}}
96 |
--------------------------------------------------------------------------------
/test/tests/queries/paging-offset.test.js:
--------------------------------------------------------------------------------
1 | describe('graphql - offset-based paging', () => {
2 | const cds = require('@sap/cds')
3 | const path = require('path')
4 | const { gql } = require('../../util')
5 |
6 | const { axios, POST } = cds.test(path.join(__dirname, '../../resources/bookshop-graphql'))
7 | // Prevent axios from throwing errors for non 2xx status codes
8 | axios.defaults.validateStatus = false
9 | axios.defaults.headers = {
10 | authorization: 'Basic YWxpY2U6'
11 | }
12 |
13 | // REVISIT: unskip for support of configurable schema flavors
14 | describe.skip('queries with paging arguments without connections', () => {
15 | test('query with top argument on field', async () => {
16 | const query = gql`
17 | {
18 | AdminServiceBasic {
19 | Authors(top: 2) {
20 | name
21 | }
22 | }
23 | }
24 | `
25 | const data = {
26 | AdminServiceBasic: {
27 | Authors: [{ name: 'Emily Brontë' }, { name: 'Charlotte Brontë' }]
28 | }
29 | }
30 | const response = await POST('/graphql', { query })
31 | expect(response.data).toEqual({ data })
32 | })
33 |
34 | test('query with top and skip arguments on field', async () => {
35 | const query = gql`
36 | {
37 | AdminServiceBasic {
38 | Authors(top: 2, skip: 2) {
39 | name
40 | }
41 | }
42 | }
43 | `
44 | const data = {
45 | AdminServiceBasic: {
46 | Authors: [{ name: 'Edgar Allen Poe' }, { name: 'Richard Carpenter' }]
47 | }
48 | }
49 | const response = await POST('/graphql', { query })
50 | expect(response.data).toEqual({ data })
51 | })
52 |
53 | test('query with top and skip arguments on nested fields', async () => {
54 | const query = gql`
55 | {
56 | AdminServiceBasic {
57 | Authors(top: 2, skip: 2) {
58 | name
59 | books(top: 1, skip: 1) {
60 | title
61 | }
62 | }
63 | }
64 | }
65 | `
66 | const data = {
67 | AdminService: {
68 | Authors: [
69 | {
70 | name: 'Edgar Allen Poe',
71 | books: [
72 | // Edgar Allen Poe has 2 books, but only 1 requested.
73 | {
74 | title: 'Eleonora'
75 | }
76 | ]
77 | },
78 | {
79 | name: 'Richard Carpenter',
80 | books: []
81 | }
82 | ]
83 | }
84 | }
85 |
86 | const response = await POST('/graphql', { query })
87 | expect(response.data).toEqual({ data })
88 | })
89 | })
90 |
91 | describe('queries with paging arguments with connections', () => {
92 | test('query with top argument on field', async () => {
93 | const query = gql`
94 | {
95 | AdminService {
96 | Authors(top: 2) {
97 | nodes {
98 | name
99 | }
100 | }
101 | }
102 | }
103 | `
104 | const data = {
105 | AdminService: {
106 | Authors: { nodes: [{ name: 'Emily Brontë' }, { name: 'Charlotte Brontë' }] }
107 | }
108 | }
109 | const response = await POST('/graphql', { query })
110 | expect(response.data).toEqual({ data })
111 | })
112 |
113 | test('query with top and skip arguments on field', async () => {
114 | const query = gql`
115 | {
116 | AdminService {
117 | Authors(top: 2, skip: 2) {
118 | nodes {
119 | name
120 | }
121 | }
122 | }
123 | }
124 | `
125 | const data = {
126 | AdminService: {
127 | Authors: { nodes: [{ name: 'Edgar Allen Poe' }, { name: 'Richard Carpenter' }] }
128 | }
129 | }
130 | const response = await POST('/graphql', { query })
131 | expect(response.data).toEqual({ data })
132 | })
133 |
134 | test('query with top and skip arguments on nested fields', async () => {
135 | const query = gql`
136 | {
137 | AdminService {
138 | Authors(top: 2, skip: 2) {
139 | nodes {
140 | name
141 | books(top: 1, skip: 1) {
142 | nodes {
143 | title
144 | }
145 | }
146 | }
147 | }
148 | }
149 | }
150 | `
151 | const data = {
152 | AdminService: {
153 | Authors: {
154 | nodes: [
155 | {
156 | name: 'Edgar Allen Poe',
157 | books: {
158 | // Edgar Allen Poe has 2 books, but only 1 requested.
159 | nodes: [
160 | {
161 | title: 'Eleonora'
162 | }
163 | ]
164 | }
165 | },
166 | {
167 | name: 'Richard Carpenter',
168 | books: {
169 | nodes: []
170 | }
171 | }
172 | ]
173 | }
174 | }
175 | }
176 |
177 | const response = await POST('/graphql', { query })
178 | expect(response.data).toEqual({ data })
179 | })
180 | })
181 | })
182 |
--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 | # Contributor Covenant Code of Conduct
2 |
3 | ## Our Pledge
4 |
5 | We as members, contributors, and leaders pledge to make participation in our
6 | community a harassment-free experience for everyone, regardless of age, body
7 | size, visible or invisible disability, ethnicity, sex characteristics, gender
8 | identity and expression, level of experience, education, socio-economic status,
9 | nationality, personal appearance, race, caste, color, religion, or sexual
10 | identity and orientation.
11 |
12 | We pledge to act and interact in ways that contribute to an open, welcoming,
13 | diverse, inclusive, and healthy community.
14 |
15 | ## Our Standards
16 |
17 | Examples of behavior that contributes to a positive environment for our
18 | community include:
19 |
20 | * Demonstrating empathy and kindness toward other people
21 | * Being respectful of differing opinions, viewpoints, and experiences
22 | * Giving and gracefully accepting constructive feedback
23 | * Accepting responsibility and apologizing to those affected by our mistakes,
24 | and learning from the experience
25 | * Focusing on what is best not just for us as individuals, but for the overall
26 | community
27 |
28 | Examples of unacceptable behavior include:
29 |
30 | * The use of sexualized language or imagery, and sexual attention or advances of
31 | any kind
32 | * Trolling, insulting or derogatory comments, and personal or political attacks
33 | * Public or private harassment
34 | * Publishing others' private information, such as a physical or email address,
35 | without their explicit permission
36 | * Other conduct which could reasonably be considered inappropriate in a
37 | professional setting
38 |
39 | ## Enforcement Responsibilities
40 |
41 | Community leaders are responsible for clarifying and enforcing our standards of
42 | acceptable behavior and will take appropriate and fair corrective action in
43 | response to any behavior that they deem inappropriate, threatening, offensive,
44 | or harmful.
45 |
46 | Community leaders have the right and responsibility to remove, edit, or reject
47 | comments, commits, code, wiki edits, issues, and other contributions that are
48 | not aligned to this Code of Conduct, and will communicate reasons for moderation
49 | decisions when appropriate.
50 |
51 | ## Scope
52 |
53 | This Code of Conduct applies within all community spaces, and also applies when
54 | an individual is officially representing the community in public spaces.
55 | Examples of representing our community include using an official e-mail address,
56 | posting via an official social media account, or acting as an appointed
57 | representative at an online or offline event.
58 |
59 | ## Enforcement
60 |
61 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
62 | reported to the community leaders responsible for enforcement at
63 | cap@sap.com.
64 | All complaints will be reviewed and investigated promptly and fairly.
65 |
66 | All community leaders are obligated to respect the privacy and security of the
67 | reporter of any incident.
68 |
69 | ## Enforcement Guidelines
70 |
71 | Community leaders will follow these Community Impact Guidelines in determining
72 | the consequences for any action they deem in violation of this Code of Conduct:
73 |
74 | ### 1. Correction
75 |
76 | **Community Impact**: Use of inappropriate language or other behavior deemed
77 | unprofessional or unwelcome in the community.
78 |
79 | **Consequence**: A private, written warning from community leaders, providing
80 | clarity around the nature of the violation and an explanation of why the
81 | behavior was inappropriate. A public apology may be requested.
82 |
83 | ### 2. Warning
84 |
85 | **Community Impact**: A violation through a single incident or series of
86 | actions.
87 |
88 | **Consequence**: A warning with consequences for continued behavior. No
89 | interaction with the people involved, including unsolicited interaction with
90 | those enforcing the Code of Conduct, for a specified period of time. This
91 | includes avoiding interactions in community spaces as well as external channels
92 | like social media. Violating these terms may lead to a temporary or permanent
93 | ban.
94 |
95 | ### 3. Temporary Ban
96 |
97 | **Community Impact**: A serious violation of community standards, including
98 | sustained inappropriate behavior.
99 |
100 | **Consequence**: A temporary ban from any sort of interaction or public
101 | communication with the community for a specified period of time. No public or
102 | private interaction with the people involved, including unsolicited interaction
103 | with those enforcing the Code of Conduct, is allowed during this period.
104 | Violating these terms may lead to a permanent ban.
105 |
106 | ### 4. Permanent Ban
107 |
108 | **Community Impact**: Demonstrating a pattern of violation of community
109 | standards, including sustained inappropriate behavior, harassment of an
110 | individual, or aggression toward or disparagement of classes of individuals.
111 |
112 | **Consequence**: A permanent ban from any sort of public interaction within the
113 | community.
114 |
115 | ## Attribution
116 |
117 | This Code of Conduct is adapted from the [Contributor Covenant][homepage],
118 | version 2.1, available at
119 | [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
120 |
121 | Community Impact Guidelines were inspired by
122 | [Mozilla's code of conduct enforcement ladder][Mozilla CoC].
123 |
124 | For answers to common questions about this code of conduct, see the FAQ at
125 | [https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
126 | [https://www.contributor-covenant.org/translations][translations].
127 |
128 | [homepage]: https://www.contributor-covenant.org
129 | [v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
130 | [Mozilla CoC]: https://github.com/mozilla/diversity
131 | [FAQ]: https://www.contributor-covenant.org/faq
132 | [translations]: https://www.contributor-covenant.org/translations
133 |
--------------------------------------------------------------------------------
/test/tests/concurrency.test.js:
--------------------------------------------------------------------------------
1 | describe('graphql - resolver concurrency', () => {
2 | const cds = require('@sap/cds')
3 | const path = require('path')
4 | const { gql } = require('../util')
5 |
6 | const { axios, POST } = cds.test(path.join(__dirname, '../resources/concurrency'))
7 | // Prevent axios from throwing errors for non 2xx status codes
8 | axios.defaults.validateStatus = false
9 |
10 | describe('execution order of query and mutation resolvers', () => {
11 | let _log = []
12 |
13 | beforeEach(() => {
14 | console.log = s => _log.push(s) // eslint-disable-line no-console
15 | })
16 |
17 | afterEach(() => {
18 | _log = []
19 | })
20 |
21 | test('query resolvers should be executed in parallel', async () => {
22 | const query = gql`
23 | query {
24 | ConcurrencyService {
25 | A {
26 | nodes {
27 | id
28 | }
29 | }
30 | B {
31 | nodes {
32 | id
33 | }
34 | }
35 | C {
36 | nodes {
37 | id
38 | }
39 | }
40 | }
41 | }
42 | `
43 | await POST('/graphql', { query })
44 | expect(_log[0]).toEqual('BEGIN READ A')
45 | expect(_log[1]).toEqual('BEGIN READ B')
46 | expect(_log[2]).toEqual('BEGIN READ C')
47 | expect(_log[3]).toEqual('END READ B')
48 | expect(_log[4]).toEqual('END READ C')
49 | expect(_log[5]).toEqual('END READ A')
50 | })
51 |
52 | test('mutation resolvers should be executed serially', async () => {
53 | const query = gql`
54 | mutation {
55 | ConcurrencyService {
56 | A {
57 | create(input: {}) {
58 | id
59 | }
60 | }
61 | B {
62 | create(input: {}) {
63 | id
64 | }
65 | }
66 | C {
67 | create(input: {}) {
68 | id
69 | }
70 | }
71 | }
72 | }
73 | `
74 | await POST('/graphql', { query })
75 | expect(_log[0]).toEqual('BEGIN CREATE A')
76 | expect(_log[1]).toEqual('END CREATE A')
77 | expect(_log[2]).toEqual('BEGIN CREATE B')
78 | expect(_log[3]).toEqual('END CREATE B')
79 | expect(_log[4]).toEqual('BEGIN CREATE C')
80 | expect(_log[5]).toEqual('END CREATE C')
81 | })
82 | })
83 |
84 | describe('queries and mutations returning data and errors', () => {
85 | test('query resolvers return both data and an error', async () => {
86 | const query = gql`
87 | query {
88 | DataAndErrorsService {
89 | A {
90 | nodes {
91 | timestamp
92 | }
93 | }
94 | B {
95 | nodes {
96 | timestamp
97 | }
98 | }
99 | C {
100 | nodes {
101 | timestamp
102 | }
103 | }
104 | }
105 | }
106 | `
107 | const errors = [
108 | {
109 | message: 'My error on READ B',
110 | locations: [
111 | {
112 | line: 9,
113 | column: 13
114 | }
115 | ],
116 | path: ['DataAndErrorsService', 'B'],
117 | extensions: expect.any(Object)
118 | }
119 | ]
120 | const data = {
121 | DataAndErrorsService: {
122 | A: {
123 | nodes: [
124 | {
125 | timestamp: expect.any(String)
126 | }
127 | ]
128 | },
129 | B: null,
130 | C: {
131 | nodes: [
132 | {
133 | timestamp: expect.any(String)
134 | }
135 | ]
136 | }
137 | }
138 | }
139 | const response = await POST('/graphql', { query })
140 | expect(response.data).toEqual({ errors, data })
141 | // A sleeps 3000 ms, C sleeps 2000 ms
142 | // Since query resolvers are executed in parallel C should resolve before A
143 | expect(new Date(response.data.data.DataAndErrorsService.A.nodes[0].timestamp).getTime()).toBeGreaterThan(
144 | new Date(response.data.data.DataAndErrorsService.C.nodes[0].timestamp).getTime()
145 | )
146 | })
147 |
148 | test('mutation resolvers return both data and an error', async () => {
149 | const query = gql`
150 | mutation {
151 | DataAndErrorsService {
152 | A {
153 | create(input: {}) {
154 | timestamp
155 | }
156 | }
157 | B {
158 | create(input: {}) {
159 | timestamp
160 | }
161 | }
162 | C {
163 | create(input: {}) {
164 | timestamp
165 | }
166 | }
167 | }
168 | }
169 | `
170 | const errors = [
171 | {
172 | message: 'My error on CREATE B',
173 | locations: [
174 | {
175 | line: 10,
176 | column: 15
177 | }
178 | ],
179 | path: ['DataAndErrorsService', 'B', 'create'],
180 | extensions: expect.any(Object)
181 | }
182 | ]
183 | const data = {
184 | DataAndErrorsService: {
185 | A: {
186 | create: [
187 | {
188 | timestamp: expect.any(String)
189 | }
190 | ]
191 | },
192 | B: {
193 | create: null
194 | },
195 | C: {
196 | create: [
197 | {
198 | timestamp: expect.any(String)
199 | }
200 | ]
201 | }
202 | }
203 | }
204 | const response = await POST('/graphql', { query })
205 | expect(response.data).toEqual({ errors, data })
206 | // A sleeps 3000 ms, C sleeps 2000 ms
207 | // Since mutation resolvers are executed serially A should resolve before C
208 | expect(new Date(response.data.data.DataAndErrorsService.A.create[0].timestamp).getTime()).toBeLessThan(
209 | new Date(response.data.data.DataAndErrorsService.C.create[0].timestamp).getTime()
210 | )
211 | })
212 | })
213 | })
214 |
--------------------------------------------------------------------------------
/test/tests/queries/orderBy.test.js:
--------------------------------------------------------------------------------
1 | describe('graphql - orderBy', () => {
2 | const cds = require('@sap/cds')
3 | const path = require('path')
4 | const { gql } = require('../../util')
5 |
6 | const { axios, POST } = cds.test(path.join(__dirname, '../../resources/bookshop-graphql'))
7 | // Prevent axios from throwing errors for non 2xx status codes
8 | axios.defaults.validateStatus = false
9 | axios.defaults.headers = {
10 | authorization: 'Basic YWxpY2U6'
11 | }
12 |
13 | // REVISIT: unskip for support of configurable schema flavors
14 | describe.skip('queries with orderBy argument without connections', () => {
15 | test('query with single orderBy object on field', async () => {
16 | const query = gql`
17 | {
18 | AdminServiceBasic {
19 | Books(orderBy: { ID: desc }) {
20 | ID
21 | title
22 | }
23 | }
24 | }
25 | `
26 | const data = {
27 | AdminServiceBasic: {
28 | Books: [
29 | { ID: 271, title: 'Catweazle' },
30 | { ID: 252, title: 'Eleonora' },
31 | { ID: 251, title: 'The Raven' },
32 | { ID: 207, title: 'Jane Eyre' },
33 | { ID: 201, title: 'Wuthering Heights' }
34 | ]
35 | }
36 | }
37 | const response = await POST('/graphql', { query })
38 | expect(response.data).toEqual({ data })
39 | })
40 |
41 | test('query with list of orderBy object on field', async () => {
42 | // Use createdAt as first sort criteria to test second level sort criteria,
43 | // since they all have the same values due to being created at the same time
44 | const query = gql`
45 | {
46 | AdminServiceBasic {
47 | Books(orderBy: [{ createdAt: desc }, { ID: desc }]) {
48 | ID
49 | title
50 | }
51 | }
52 | }
53 | `
54 | const data = {
55 | AdminServiceBasic: {
56 | Books: [
57 | { ID: 271, title: 'Catweazle' },
58 | { ID: 252, title: 'Eleonora' },
59 | { ID: 251, title: 'The Raven' },
60 | { ID: 207, title: 'Jane Eyre' },
61 | { ID: 201, title: 'Wuthering Heights' }
62 | ]
63 | }
64 | }
65 | const response = await POST('/graphql', { query })
66 | expect(response.data).toEqual({ data })
67 | })
68 |
69 | test('query with orderBy objects on nested fields', async () => {
70 | const query = gql`
71 | {
72 | AdminServiceBasic {
73 | Authors(orderBy: { ID: desc }) {
74 | ID
75 | books(orderBy: { title: desc }) {
76 | title
77 | }
78 | }
79 | }
80 | }
81 | `
82 | const data = {
83 | AdminServiceBasic: {
84 | Authors: [
85 | { ID: 170, books: [{ title: 'Catweazle' }] },
86 | { ID: 150, books: [{ title: 'The Raven' }, { title: 'Eleonora' }] },
87 | { ID: 107, books: [{ title: 'Jane Eyre' }] },
88 | { ID: 101, books: [{ title: 'Wuthering Heights' }] }
89 | ]
90 | }
91 | }
92 | const response = await POST('/graphql', { query })
93 | expect(response.data).toEqual({ data })
94 | })
95 | })
96 |
97 | describe('queries with orderBy argument with connections', () => {
98 | test('query with single orderBy object on field', async () => {
99 | const query = gql`
100 | {
101 | AdminService {
102 | Books(orderBy: { ID: desc }) {
103 | nodes {
104 | ID
105 | title
106 | }
107 | }
108 | }
109 | }
110 | `
111 | const data = {
112 | AdminService: {
113 | Books: {
114 | nodes: [
115 | { ID: 271, title: 'Catweazle' },
116 | { ID: 252, title: 'Eleonora' },
117 | { ID: 251, title: 'The Raven' },
118 | { ID: 207, title: 'Jane Eyre' },
119 | { ID: 201, title: 'Wuthering Heights' }
120 | ]
121 | }
122 | }
123 | }
124 | const response = await POST('/graphql', { query })
125 | expect(response.data).toEqual({ data })
126 | })
127 |
128 | test('query with list of orderBy object on field', async () => {
129 | // Use createdAt as first sort criteria to test second level sort criteria,
130 | // since they all have the same values due to being created at the same time
131 | const query = gql`
132 | {
133 | AdminService {
134 | Books(orderBy: [{ createdAt: desc }, { ID: desc }]) {
135 | nodes {
136 | ID
137 | title
138 | }
139 | }
140 | }
141 | }
142 | `
143 | const data = {
144 | AdminService: {
145 | Books: {
146 | nodes: [
147 | { ID: 271, title: 'Catweazle' },
148 | { ID: 252, title: 'Eleonora' },
149 | { ID: 251, title: 'The Raven' },
150 | { ID: 207, title: 'Jane Eyre' },
151 | { ID: 201, title: 'Wuthering Heights' }
152 | ]
153 | }
154 | }
155 | }
156 | const response = await POST('/graphql', { query })
157 | expect(response.data).toEqual({ data })
158 | })
159 |
160 | test('query with orderBy objects on nested fields', async () => {
161 | const query = gql`
162 | {
163 | AdminService {
164 | Authors(orderBy: { ID: desc }) {
165 | nodes {
166 | ID
167 | books(orderBy: { title: desc }) {
168 | nodes {
169 | title
170 | }
171 | }
172 | }
173 | }
174 | }
175 | }
176 | `
177 | const data = {
178 | AdminService: {
179 | Authors: {
180 | nodes: [
181 | { ID: 170, books: { nodes: [{ title: 'Catweazle' }] } },
182 | { ID: 150, books: { nodes: [{ title: 'The Raven' }, { title: 'Eleonora' }] } },
183 | { ID: 107, books: { nodes: [{ title: 'Jane Eyre' }] } },
184 | { ID: 101, books: { nodes: [{ title: 'Wuthering Heights' }] } }
185 | ]
186 | }
187 | }
188 | }
189 | const response = await POST('/graphql', { query })
190 | expect(response.data).toEqual({ data })
191 | })
192 | })
193 | })
194 |
--------------------------------------------------------------------------------
Capire Books
34 | 35 | 36 | 37 || Book | 40 |Author | 41 |Genre | 42 |Rating | 43 |Price | 44 | 45 |
|---|---|---|---|---|
| {{ book.title }} | 47 |{{ book.author }} | 48 |{{ book.genre.name }} | 49 |50 | {{ ('★'.repeat(Math.round(book.rating))+'☆☆☆☆☆').slice(0,5) }} ({{ book.numberOfReviews }}) 51 | | 52 |{{ book.currency && book.currency.symbol }} {{ book.price }} | 53 |
57 | ![]()
58 |
63 |
67 |
70 | {{ book.title }}
68 |{{ book.descr }}
69 |
71 | ( click on a row to see details... )
72 |
73 |
74 |