feat(graphql): Add limit offset paging without connections

packages/query-graphql/__tests__/__fixtures__/index.ts

@@ -37,6 +37,7 @@ export const filterInputTypeSDL = readGraphql(resolve(__dirname, './filter-input
 export const pagingInputTypeSDL = readGraphql(resolve(__dirname, './paging-input-type.graphql'));
 export const pageInfoObjectTypeSDL = readGraphql(resolve(__dirname, './page-info-object-type.graphql'));
 export const sortingInputTypeSDL = readGraphql(resolve(__dirname, './sorting-input-type.graphql'));
-export const queryArgsTypeSDL = readGraphql(resolve(__dirname, './query-args-type.graphql'));
+export const cursorQueryArgsTypeSDL = readGraphql(resolve(__dirname, './cursor-query-args-type.graphql'));
+export const limitOffsetQueryArgsTypeSDL = readGraphql(resolve(__dirname, './limit-offset-query-args-type.graphql'));
 export const connectionObjectTypeSDL = readGraphql(resolve(__dirname, './connection-object-type.graphql'));
 export const edgeObjectTypeSDL = readGraphql(resolve(__dirname, './edge-object-type.graphql'));

packages/query-graphql/__tests__/__fixtures__/limit-offset-query-args-type.graphql

@@ -0,0 +1,227 @@
+type Query {
+  test(
+    """Limit or page results."""
+    paging: LimitOffsetPaging = {limit: 10}
+
+    """Specify to filter the records returned."""
+    filter: TestQueryFilter = {}
+
+    """Specify to sort results."""
+    sorting: [TestQuerySort!] = []
+  ): String!
+}
+
+input LimitOffsetPaging {
+  """Limit the number of records returned"""
+  limit: Int
+
+  """Offset to start returning records from"""
+  offset: Int
+}
+
+input TestQueryFilter {
+  and: [TestQueryFilter!]
+  or: [TestQueryFilter!]
+  idField: IDFilterComparison
+  idFieldOption: IDFilterComparison
+  stringField: StringFieldComparison
+  stringFieldOptional: StringFieldComparison
+  booleanField: BooleanFieldComparison
+  booleanFieldOptional: BooleanFieldComparison
+  numberField: NumberFieldComparison
+  numberFieldOptional: NumberFieldComparison
+  floatField: FloatFieldComparison
+  floatFieldOptional: FloatFieldComparison
+  intField: IntFieldComparison
+  intFieldOptional: IntFieldComparison
+  timestampField: TimestampFieldComparison
+  timestampFieldOptional: TimestampFieldComparison
+  date: DateFieldComparison
+  dateOptional: DateFieldComparison
+}
+
+input IDFilterComparison {
+  is: Boolean
+  isNot: Boolean
+  eq: ID
+  neq: ID
+  gt: ID
+  gte: ID
+  lt: ID
+  lte: ID
+  like: ID
+  notLike: ID
+  iLike: ID
+  notILike: ID
+  in: [ID!]
+  notIn: [ID!]
+}
+
+input StringFieldComparison {
+  is: Boolean
+  isNot: Boolean
+  eq: String
+  neq: String
+  gt: String
+  gte: String
+  lt: String
+  lte: String
+  like: String
+  notLike: String
+  iLike: String
+  notILike: String
+  in: [String!]
+  notIn: [String!]
+}
+
+input BooleanFieldComparison {
+  is: Boolean
+  isNot: Boolean
+}
+
+input NumberFieldComparison {
+  is: Boolean
+  isNot: Boolean
+  eq: Float
+  neq: Float
+  gt: Float
+  gte: Float
+  lt: Float
+  lte: Float
+  in: [Float!]
+  notIn: [Float!]
+  between: NumberFieldComparisonBetween
+  notBetween: NumberFieldComparisonBetween
+}
+
+input NumberFieldComparisonBetween {
+  lower: Float!
+  upper: Float!
+}
+
+input FloatFieldComparison {
+  is: Boolean
+  isNot: Boolean
+  eq: Float
+  neq: Float
+  gt: Float
+  gte: Float
+  lt: Float
+  lte: Float
+  in: [Float!]
+  notIn: [Float!]
+  between: FloatFieldComparisonBetween
+  notBetween: FloatFieldComparisonBetween
+}
+
+input FloatFieldComparisonBetween {
+  lower: Float!
+  upper: Float!
+}
+
+input IntFieldComparison {
+  is: Boolean
+  isNot: Boolean
+  eq: Int
+  neq: Int
+  gt: Int
+  gte: Int
+  lt: Int
+  lte: Int
+  in: [Int!]
+  notIn: [Int!]
+  between: IntFieldComparisonBetween
+  notBetween: IntFieldComparisonBetween
+}
+
+input IntFieldComparisonBetween {
+  lower: Int!
+  upper: Int!
+}
+
+input TimestampFieldComparison {
+  is: Boolean
+  isNot: Boolean
+  eq: Timestamp
+  neq: Timestamp
+  gt: Timestamp
+  gte: Timestamp
+  lt: Timestamp
+  lte: Timestamp
+  in: [Timestamp!]
+  notIn: [Timestamp!]
+  between: TimestampFieldComparisonBetween
+  notBetween: TimestampFieldComparisonBetween
+}
+
+"""
+`Date` type as integer. Type represents date and time as number of milliseconds from start of UNIX epoch.
+"""
+scalar Timestamp
+
+input TimestampFieldComparisonBetween {
+  lower: Timestamp!
+  upper: Timestamp!
+}
+
+input DateFieldComparison {
+  is: Boolean
+  isNot: Boolean
+  eq: DateTime
+  neq: DateTime
+  gt: DateTime
+  gte: DateTime
+  lt: DateTime
+  lte: DateTime
+  in: [DateTime!]
+  notIn: [DateTime!]
+  between: DateFieldComparisonBetween
+  notBetween: DateFieldComparisonBetween
+}
+
+"""
+A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format.
+"""
+scalar DateTime
+
+input DateFieldComparisonBetween {
+  lower: DateTime!
+  upper: DateTime!
+}
+
+input TestQuerySort {
+  field: TestQuerySortFields!
+  direction: SortDirection!
+  nulls: SortNulls
+}
+
+enum TestQuerySortFields {
+  idField
+  idFieldOption
+  stringField
+  stringFieldOptional
+  booleanField
+  booleanFieldOptional
+  numberField
+  numberFieldOptional
+  floatField
+  floatFieldOptional
+  intField
+  intFieldOptional
+  timestampField
+  timestampFieldOptional
+  date
+  dateOptional
+}
+
+"""Sort Directions"""
+enum SortDirection {
+  ASC
+  DESC
+}
+
+"""Sort Nulls Options"""
+enum SortNulls {
+  NULLS_FIRST
+  NULLS_LAST
+}

packages/query-graphql/__tests__/decorators/relation.decorator.spec.ts

@@ -1,5 +1,5 @@
 import { ObjectType } from '@nestjs/graphql';
-import { Relation, Connection } from '../../src';
+import { Relation, Connection, PagingStrategies } from '../../src';
 import { getMetadataStorage } from '../../src/metadata';
 
 @ObjectType()
@@ -18,9 +18,25 @@ describe('@Relation', () => {
     const relation = relations![0];
     expect(relation.name).toBe('test');
     expect(relation.relationTypeFunc).toBe(relationFn);
-    expect(relation.isConnection).toBe(false);
+    expect(relation.isMany).toBe(false);
     expect(relation.relationOpts).toBe(relationOpts);
   });
+
+  it('should set the isMany flag if the relationFn returns an array', () => {
+    const relationFn = () => [TestRelation];
+    const relationOpts = { disableRead: true };
+    @ObjectType()
+    @Relation('tests', relationFn, relationOpts)
+    class TestDTO {}
+
+    const relations = getMetadataStorage().getRelations(TestDTO);
+    expect(relations).toHaveLength(1);
+    const relation = relations![0];
+    expect(relation.name).toBe('tests');
+    expect(relation.relationTypeFunc).toBe(relationFn);
+    expect(relation.isMany).toBe(true);
+    expect(relation.relationOpts).toEqual({ ...relationOpts, pagingStrategy: PagingStrategies.LIMIT_OFFSET });
+  });
 });
 
 describe('@Connection', () => {
@@ -36,7 +52,7 @@ describe('@Connection', () => {
     const relation = relations![0];
     expect(relation.name).toBe('test');
     expect(relation.relationTypeFunc).toBe(relationFn);
-    expect(relation.isConnection).toBe(true);
-    expect(relation.relationOpts).toBe(relationOpts);
+    expect(relation.isMany).toBe(true);
+    expect(relation.relationOpts).toEqual({ pagingStrategy: PagingStrategies.CURSOR, ...relationOpts });
   });
 });

packages/query-graphql/__tests__/resolvers/__fixtures__/index.ts

@@ -91,6 +91,9 @@ export const readCustomConnectionResolverSDL = readGraphql(
   resolve(__dirname, 'read', 'read-custom-connection.resolver.graphql'),
 );
 export const readCustomQueryResolverSDL = readGraphql(resolve(__dirname, 'read', 'read-custom-query.resolver.graphql'));
+export const readLimitOffsetQueryResolverSDL = readGraphql(
+  resolve(__dirname, 'read', 'read-limit-offset-query.resolver.graphql'),
+);
 
 export const updateBasicResolverSDL = readGraphql(resolve(__dirname, 'update', 'update-basic.resolver.graphql'));
 export const updateDisabledResolverSDL = readGraphql(resolve(__dirname, 'update', 'update-disabled.resolver.graphql'));