From 067b11d41eea73501213e9471bf18218a0f91214 Mon Sep 17 00:00:00 2001 From: mernxl Date: Tue, 11 Sep 2018 04:10:00 +0100 Subject: [PATCH 1/6] chore: add tslint prettier rules plugins, apply styles to all `.ts` files * add `tslint-config-prettier` and `tslint-plugin-prettier` packages --- package.json | 2 + src/fieldsConverter.d.ts | 57 ++++++++++++++-------- src/index.d.ts | 6 ++- src/resolvers/connection.d.ts | 6 ++- src/resolvers/count.d.ts | 3 +- src/resolvers/createMany.d.ts | 3 +- src/resolvers/createOne.d.ts | 3 +- src/resolvers/findById.d.ts | 3 +- src/resolvers/findByIds.d.ts | 3 +- src/resolvers/findMany.d.ts | 3 +- src/resolvers/findOne.d.ts | 3 +- src/resolvers/helpers/filter.d.ts | 19 +++++--- src/resolvers/helpers/filterOperators.d.ts | 17 +++++-- src/resolvers/helpers/index.d.ts | 10 ++-- src/resolvers/helpers/limit.d.ts | 10 ++-- src/resolvers/helpers/record.d.ts | 15 +++--- src/resolvers/helpers/sort.d.ts | 14 ++++-- src/resolvers/index.d.ts | 55 +++++++++++---------- src/resolvers/pagination.d.ts | 5 +- src/resolvers/removeById.d.ts | 3 +- src/resolvers/removeMany.d.ts | 3 +- src/resolvers/removeOne.d.ts | 3 +- src/resolvers/updateById.d.ts | 3 +- src/resolvers/updateMany.d.ts | 3 +- src/resolvers/updateOne.d.ts | 3 +- src/utils/getIndexesFromModel.d.ts | 14 ++++-- src/utils/toMongoDottedObject.d.ts | 3 +- tsconfig.json | 4 +- tslint.json | 37 +++++++++++--- yarn.lock | 15 +++++- 30 files changed, 217 insertions(+), 111 deletions(-) diff --git a/package.json b/package.json index 2fee0433..0a5609d4 100644 --- a/package.json +++ b/package.json @@ -72,6 +72,8 @@ "rimraf": "^2.6.2", "semantic-release": "^15.9.12", "tslint": "^5.11.0", + "tslint-config-prettier": "^1.15.0", + "tslint-plugin-prettier": "^1.3.0", "typescript": "^3.0.3" }, "config": { diff --git a/src/fieldsConverter.d.ts b/src/fieldsConverter.d.ts index 4b9d518b..74cbfd8f 100644 --- a/src/fieldsConverter.d.ts +++ b/src/fieldsConverter.d.ts @@ -1,4 +1,8 @@ -import { EnumTypeComposer, SchemaComposer, TypeComposer } from 'graphql-compose'; +import { + EnumTypeComposer, + SchemaComposer, + TypeComposer, +} from 'graphql-compose'; import { GraphQLScalarType } from 'graphql-compose/lib/graphql'; import { Model, Schema } from 'mongoose'; @@ -9,66 +13,79 @@ type MongooseFieldMapT = { [fieldName: string]: MongooseFieldT }; type ComposeScalarType = string | GraphQLScalarType; type ComposeOutputType = - | TypeComposer | ComposeScalarType | EnumTypeComposer + | TypeComposer + | ComposeScalarType + | EnumTypeComposer | [TypeComposer | ComposeScalarType | EnumTypeComposer]; export type MongoosePseudoModelT = { - schema: Schema, + schema: Schema; }; export const ComplexTypes: { - ARRAY: 'ARRAY', - EMBEDDED: 'EMBEDDED', - DOCUMENT_ARRAY: 'DOCUMENT_ARRAY', - ENUM: 'ENUM', - REFERENCE: 'REFERENCE', - SCALAR: 'SCALAR', - MIXED: 'MIXED', + ARRAY: 'ARRAY'; + EMBEDDED: 'EMBEDDED'; + DOCUMENT_ARRAY: 'DOCUMENT_ARRAY'; + ENUM: 'ENUM'; + REFERENCE: 'REFERENCE'; + SCALAR: 'SCALAR'; + MIXED: 'MIXED'; }; -export function dotPathsToEmbedded(fields: MongooseFieldMapT): MongooseFieldMapT; +export function dotPathsToEmbedded( + fields: MongooseFieldMapT, +): MongooseFieldMapT; -export function getFieldsFromModel(model: Model | MongoosePseudoModelT): MongooseFieldMapT; +export function getFieldsFromModel( + model: Model | MongoosePseudoModelT, +): MongooseFieldMapT; export function convertModelToGraphQL( model: Model | MongoosePseudoModelT, typeName: string, - sc?: SchemaComposer): TypeComposer; + sc?: SchemaComposer, +): TypeComposer; export function convertSchemaToGraphQL( schema: Schema, typeName: string, - sc?: SchemaComposer): TypeComposer; + sc?: SchemaComposer, +): TypeComposer; export function convertFieldToGraphQL( field: MongooseFieldT, prefix: string | undefined, - schemaComposer: SchemaComposer + schemaComposer: SchemaComposer, ): ComposeOutputType; -export function deriveComplexType(field: MongooseFieldT): keyof typeof ComplexTypes; +export function deriveComplexType( + field: MongooseFieldT, +): keyof typeof ComplexTypes; export function scalarToGraphQL(field: MongooseFieldT): ComposeScalarType; export function arrayToGraphQL( field: MongooseFieldT, prefix: string | undefined, - schemaComposer: SchemaComposer + schemaComposer: SchemaComposer, ): ComposeOutputType; export function embeddedToGraphQL( field: MongooseFieldT, prefix: string | undefined, - schemaComposer: SchemaComposer): TypeComposer; + schemaComposer: SchemaComposer, +): TypeComposer; export function enumToGraphQL( field: MongooseFieldT, prefix: string | undefined, - schemaComposer: SchemaComposer): EnumTypeComposer; + schemaComposer: SchemaComposer, +): EnumTypeComposer; export function documentArrayToGraphQL( field: MongooseFieldT, prefix: string | undefined, - schemaComposer: SchemaComposer): [TypeComposer]; + schemaComposer: SchemaComposer, +): [TypeComposer]; export function referenceToGraphQL(field: MongooseFieldT): ComposeScalarType; diff --git a/src/index.d.ts b/src/index.d.ts index 504cbd0a..59d55ffb 100644 --- a/src/index.d.ts +++ b/src/index.d.ts @@ -7,4 +7,8 @@ export default composeWithMongoose; export * from './fieldsConverter'; // @ts-todo export * from './discriminators'; // untyped yet -export { composeWithMongoose, composeWithMongooseDiscriminators, GraphQLMongoID }; +export { + composeWithMongoose, + composeWithMongooseDiscriminators, + GraphQLMongoID, +}; diff --git a/src/resolvers/connection.d.ts b/src/resolvers/connection.d.ts index bd4bf4cf..2ad885a7 100644 --- a/src/resolvers/connection.d.ts +++ b/src/resolvers/connection.d.ts @@ -10,7 +10,8 @@ export type ConnectionSortMapOpts = { [opt: string]: any }; export default function connection( model: Model, tc: TypeComposer, - opts?: ConnectionSortMapOpts): Resolver | undefined; + opts?: ConnectionSortMapOpts, +): Resolver | undefined; export function prepareCursorQuery( rawQuery: object, @@ -18,4 +19,5 @@ export function prepareCursorQuery( indexKeys: string[], indexData: IndexT, nextOper: '$gt' | '$lt', - prevOper: '$lt' | '$gt'): void; + prevOper: '$lt' | '$gt', +): void; diff --git a/src/resolvers/count.d.ts b/src/resolvers/count.d.ts index e5176325..fec2796d 100644 --- a/src/resolvers/count.d.ts +++ b/src/resolvers/count.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function count( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/createMany.d.ts b/src/resolvers/createMany.d.ts index fc4ee9ec..d26078f8 100644 --- a/src/resolvers/createMany.d.ts +++ b/src/resolvers/createMany.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function createMany( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/createOne.d.ts b/src/resolvers/createOne.d.ts index b87a8d70..2bd15c6b 100644 --- a/src/resolvers/createOne.d.ts +++ b/src/resolvers/createOne.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function createOne( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/findById.d.ts b/src/resolvers/findById.d.ts index e8080aa3..c21e95e4 100644 --- a/src/resolvers/findById.d.ts +++ b/src/resolvers/findById.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function findById( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/findByIds.d.ts b/src/resolvers/findByIds.d.ts index 7282cee9..8f000059 100644 --- a/src/resolvers/findByIds.d.ts +++ b/src/resolvers/findByIds.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function findByIds( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/findMany.d.ts b/src/resolvers/findMany.d.ts index 805532e5..3fb92447 100644 --- a/src/resolvers/findMany.d.ts +++ b/src/resolvers/findMany.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function findMany( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/findOne.d.ts b/src/resolvers/findOne.d.ts index 33a90e50..02d829ec 100644 --- a/src/resolvers/findOne.d.ts +++ b/src/resolvers/findOne.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function findOne( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/helpers/filter.d.ts b/src/resolvers/helpers/filter.d.ts index 7bf7868e..ed3a74ae 100644 --- a/src/resolvers/helpers/filter.d.ts +++ b/src/resolvers/helpers/filter.d.ts @@ -4,19 +4,22 @@ import { ExtendedResolveParams } from '../index'; import { FilterOperatorsOpts } from './filterOperators'; export type FilterHelperArgsOpts = { - filterTypeName?: string, - isRequired?: boolean, - onlyIndexed?: boolean, - requiredFields?: string | string[], - operators?: FilterOperatorsOpts | false, - removeFields?: string | string[], + filterTypeName?: string; + isRequired?: boolean; + onlyIndexed?: boolean; + requiredFields?: string | string[]; + operators?: FilterOperatorsOpts | false; + removeFields?: string | string[]; }; -export function getFilterHelperArgOptsMap(): Partial>; +export function getFilterHelperArgOptsMap(): Partial< + Record +>; export function filterHelperArgs( typeComposer: TypeComposer, model: Model, - opts?: FilterHelperArgsOpts): ComposeFieldConfigArgumentMap; + opts?: FilterHelperArgsOpts, +): ComposeFieldConfigArgumentMap; export function filterHelper(resolveParams: ExtendedResolveParams): void; diff --git a/src/resolvers/helpers/filterOperators.d.ts b/src/resolvers/helpers/filterOperators.d.ts index 2bd00e3f..a8a4c54c 100644 --- a/src/resolvers/helpers/filterOperators.d.ts +++ b/src/resolvers/helpers/filterOperators.d.ts @@ -3,19 +3,28 @@ import { Model } from 'mongoose'; import { ExtendedResolveParams } from '../index'; import { FilterHelperArgsOpts } from './filter'; -export type FilterOperatorNames = 'gt' | 'gte' | 'lt' | 'lte' | 'ne' | 'in[]' | 'nin[]'; +export type FilterOperatorNames = + | 'gt' + | 'gte' + | 'lt' + | 'lte' + | 'ne' + | 'in[]' + | 'nin[]'; export const OPERATORS_FIELDNAME: string; export type FilterOperatorsOpts = { - [fieldName: string]: FilterOperatorNames[] | false, + [fieldName: string]: FilterOperatorNames[] | false; }; export function addFilterOperators( itc: InputTypeComposer, model: Model, - opts: FilterHelperArgsOpts): void; + opts: FilterHelperArgsOpts, +): void; export function processFilterOperators( filter: object, - resolveParams: ExtendedResolveParams): void; + resolveParams: ExtendedResolveParams, +): void; diff --git a/src/resolvers/helpers/index.d.ts b/src/resolvers/helpers/index.d.ts index 0a05b560..f7466086 100644 --- a/src/resolvers/helpers/index.d.ts +++ b/src/resolvers/helpers/index.d.ts @@ -10,9 +10,9 @@ export * from './skip'; export * from './sort'; export const MergeAbleHelperArgsOpts: { - sort: string, - skip: string, - limit: ReturnType, - filter: ReturnType, - record: ReturnType + sort: string; + skip: string; + limit: ReturnType; + filter: ReturnType; + record: ReturnType; }; diff --git a/src/resolvers/helpers/limit.d.ts b/src/resolvers/helpers/limit.d.ts index 10b60045..86c24131 100644 --- a/src/resolvers/helpers/limit.d.ts +++ b/src/resolvers/helpers/limit.d.ts @@ -2,11 +2,15 @@ import { ComposeFieldConfigArgumentMap } from 'graphql-compose'; import { ExtendedResolveParams } from '../index'; export type LimitHelperArgsOpts = { - defaultValue?: number, + defaultValue?: number; }; -export function getLimitHelperArgsOptsMap(): Partial>; +export function getLimitHelperArgsOptsMap(): Partial< + Record +>; -export function limitHelperArgs(opts?: LimitHelperArgsOpts): ComposeFieldConfigArgumentMap; +export function limitHelperArgs( + opts?: LimitHelperArgsOpts, +): ComposeFieldConfigArgumentMap; export function limitHelper(resolveParams: ExtendedResolveParams): void; diff --git a/src/resolvers/helpers/record.d.ts b/src/resolvers/helpers/record.d.ts index 06039cb7..5224cbb9 100644 --- a/src/resolvers/helpers/record.d.ts +++ b/src/resolvers/helpers/record.d.ts @@ -1,14 +1,17 @@ import { ComposeFieldConfigArgumentMap, TypeComposer } from 'graphql-compose'; export type RecordHelperArgsOpts = { - recordTypeName?: string, - isRequired?: boolean, - removeFields?: string[], - requiredFields?: string[], + recordTypeName?: string; + isRequired?: boolean; + removeFields?: string[]; + requiredFields?: string[]; }; -export function getRecordHelperArgsOptsMap(): Partial>; +export function getRecordHelperArgsOptsMap(): Partial< + Record +>; export function recordHelperArgs( tc: TypeComposer, - opts?: RecordHelperArgsOpts): ComposeFieldConfigArgumentMap; + opts?: RecordHelperArgsOpts, +): ComposeFieldConfigArgumentMap; diff --git a/src/resolvers/helpers/sort.d.ts b/src/resolvers/helpers/sort.d.ts index f00668ff..9abfdb89 100644 --- a/src/resolvers/helpers/sort.d.ts +++ b/src/resolvers/helpers/sort.d.ts @@ -1,20 +1,26 @@ -import { ComposeFieldConfigArgumentMap, EnumTypeComposer, SchemaComposer, TypeComposer } from 'graphql-compose'; +import { + ComposeFieldConfigArgumentMap, + EnumTypeComposer, + SchemaComposer, + TypeComposer, +} from 'graphql-compose'; import { Model } from 'mongoose'; import { ExtendedResolveParams } from '../index'; export type SortHelperArgsOpts = { - sortTypeName?: string, + sortTypeName?: string; }; export function sortHelperArgs( typeComposer: TypeComposer, model: Model, - opts?: SortHelperArgsOpts): ComposeFieldConfigArgumentMap; + opts?: SortHelperArgsOpts, +): ComposeFieldConfigArgumentMap; export function sortHelper(resolveParams: ExtendedResolveParams): void; export function getSortTypeFromModel( typeName: string, model: Model, - schemaComposer: SchemaComposer + schemaComposer: SchemaComposer, ): EnumTypeComposer; diff --git a/src/resolvers/index.d.ts b/src/resolvers/index.d.ts index 9d502cd0..9195cd9f 100644 --- a/src/resolvers/index.d.ts +++ b/src/resolvers/index.d.ts @@ -11,7 +11,12 @@ import findByIds from './findByIds'; import findMany from './findMany'; import findOne from './findOne'; -import { FilterHelperArgsOpts, LimitHelperArgsOpts, RecordHelperArgsOpts, SortHelperArgsOpts } from './helpers'; +import { + FilterHelperArgsOpts, + LimitHelperArgsOpts, + RecordHelperArgsOpts, + SortHelperArgsOpts, +} from './helpers'; import pagination from './pagination'; @@ -24,18 +29,18 @@ import updateMany from './updateMany'; import updateOne from './updateOne'; export type GenResolverOpts = { - filter?: FilterHelperArgsOpts, - sort?: SortHelperArgsOpts, - record?: RecordHelperArgsOpts, - records?: RecordHelperArgsOpts, - limit?: LimitHelperArgsOpts, + filter?: FilterHelperArgsOpts; + sort?: SortHelperArgsOpts; + record?: RecordHelperArgsOpts; + records?: RecordHelperArgsOpts; + limit?: LimitHelperArgsOpts; }; export type ExtendedResolveParams = ResolveParams & { - query: DocumentQuery, - rawQuery: { [optName: string]: any }, - beforeQuery?: (query: any, rp: ExtendedResolveParams) => Promise, - beforeRecordMutate?: (record: any, rp: ExtendedResolveParams) => Promise, + query: DocumentQuery; + rawQuery: { [optName: string]: any }; + beforeQuery?: (query: any, rp: ExtendedResolveParams) => Promise; + beforeRecordMutate?: (record: any, rp: ExtendedResolveParams) => Promise; }; export { @@ -59,19 +64,19 @@ export { export function getAvailableNames(): string[]; export const EMCResolvers: { - findById: 'findById', - findByIds: 'findByIds', - findOne: 'findOne', - findMany: 'findMany', - updateById: 'updateById', - updateOne: 'updateOne', - updateMany: 'updateMany', - removeById: 'removeById', - removeOne: 'removeOne', - removeMany: 'removeMany', - createOne: 'createOne', - createMany: 'createMany', - count: 'count', - connection: 'connection', - pagination: 'pagination', + findById: 'findById'; + findByIds: 'findByIds'; + findOne: 'findOne'; + findMany: 'findMany'; + updateById: 'updateById'; + updateOne: 'updateOne'; + updateMany: 'updateMany'; + removeById: 'removeById'; + removeOne: 'removeOne'; + removeMany: 'removeMany'; + createOne: 'createOne'; + createMany: 'createMany'; + count: 'count'; + connection: 'connection'; + pagination: 'pagination'; }; diff --git a/src/resolvers/pagination.d.ts b/src/resolvers/pagination.d.ts index 79d669f7..7f0d95f1 100644 --- a/src/resolvers/pagination.d.ts +++ b/src/resolvers/pagination.d.ts @@ -2,10 +2,11 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; export type PaginationResolverOpts = { - perPage?: number, + perPage?: number; }; export default function pagination( model: Model, tc: TypeComposer, - opts?: PaginationResolverOpts): Resolver | undefined; + opts?: PaginationResolverOpts, +): Resolver | undefined; diff --git a/src/resolvers/removeById.d.ts b/src/resolvers/removeById.d.ts index 13206346..1fcd43a4 100644 --- a/src/resolvers/removeById.d.ts +++ b/src/resolvers/removeById.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function removeById( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/removeMany.d.ts b/src/resolvers/removeMany.d.ts index 13206346..1fcd43a4 100644 --- a/src/resolvers/removeMany.d.ts +++ b/src/resolvers/removeMany.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function removeById( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/removeOne.d.ts b/src/resolvers/removeOne.d.ts index 0fb69e97..e5abe54b 100644 --- a/src/resolvers/removeOne.d.ts +++ b/src/resolvers/removeOne.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function removeOne( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/updateById.d.ts b/src/resolvers/updateById.d.ts index d2ac2e15..0c268838 100644 --- a/src/resolvers/updateById.d.ts +++ b/src/resolvers/updateById.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function updateById( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/updateMany.d.ts b/src/resolvers/updateMany.d.ts index 9398f66a..746f36c9 100644 --- a/src/resolvers/updateMany.d.ts +++ b/src/resolvers/updateMany.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function updateMany( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/resolvers/updateOne.d.ts b/src/resolvers/updateOne.d.ts index 64f7be53..53b0905a 100644 --- a/src/resolvers/updateOne.d.ts +++ b/src/resolvers/updateOne.d.ts @@ -5,4 +5,5 @@ import { GenResolverOpts } from './index'; export default function updateOne( model: Model, tc: TypeComposer, - opts?: GenResolverOpts): Resolver; + opts?: GenResolverOpts, +): Resolver; diff --git a/src/utils/getIndexesFromModel.d.ts b/src/utils/getIndexesFromModel.d.ts index 5d49117e..efc9394f 100644 --- a/src/utils/getIndexesFromModel.d.ts +++ b/src/utils/getIndexesFromModel.d.ts @@ -1,22 +1,26 @@ import { Model } from 'mongoose'; export type getIndexesFromModelOpts = { - extractCompound?: boolean, - skipSpecificIndexes?: boolean, + extractCompound?: boolean; + skipSpecificIndexes?: boolean; }; export type IndexT = { [fieldName: string]: any }; export function getIndexesFromModel( mongooseModel: Model, - opts?: getIndexesFromModelOpts): IndexT[]; + opts?: getIndexesFromModelOpts, +): IndexT[]; export function getUniqueIndexes(mongooseModel: Model): IndexT[]; export type ExtendByReversedIndexesOpts = { - reversedFirst?: boolean, + reversedFirst?: boolean; }; -export function extendByReversedIndexes(indexes: IndexT[], opts?: ExtendByReversedIndexesOpts): IndexT[]; +export function extendByReversedIndexes( + indexes: IndexT[], + opts?: ExtendByReversedIndexesOpts, +): IndexT[]; export function getIndexedFieldNamesForGraphQL(model: Model): string[]; diff --git a/src/utils/toMongoDottedObject.d.ts b/src/utils/toMongoDottedObject.d.ts index 7d7cc30b..642dead3 100644 --- a/src/utils/toMongoDottedObject.d.ts +++ b/src/utils/toMongoDottedObject.d.ts @@ -1,4 +1,5 @@ export default function toMongoDottedObject( obj: object, target?: object, - path?: string[]): { [dottedPath: string]: any }; + path?: string[], +): { [dottedPath: string]: any }; diff --git a/tsconfig.json b/tsconfig.json index 0d0a961f..b44b199d 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -5,8 +5,8 @@ "strict": true, "lib": ["es2017", "esnext.asynciterable"] }, - "include": ["src/**/*.d.ts"], + "include": ["src/**/*.ts"], "exclude": [ "./node_modules" ] -} \ No newline at end of file +} diff --git a/tslint.json b/tslint.json index 680d01f8..8b280fc1 100644 --- a/tslint.json +++ b/tslint.json @@ -1,18 +1,39 @@ { "defaultSeverity": "error", "extends": [ - "tslint:recommended" + "tslint:recommended", + "tslint-config-prettier" + ], + "rulesDirectory": [ + "tslint-plugin-prettier" ], "jsRules": {}, "rules": { - "quotemark": [true, "single"], - "trailing-comma": [false], + "prettier": [ + true, + { + "semi": true, + "singleQuote": true, + "trailingComma": "all", + "bracketSpacing": true, + "parser": "typescript" + } + ], + "trailing-comma": [ + false + ], "ordered-imports": false, - "member-ordering": [true, { "order": "fields-first" }], + "member-ordering": [ + true, + { + "order": "fields-first" + } + ], "variable-name": false, - "interface-name": [true, "never-prefix"], + "arrow-parens": false, + "interface-name": false, "no-reference-import": false, - "interface-over-type-literal": false - }, - "rulesDirectory": [] + "interface-over-type-literal": false, + "object-literal-sort-keys": false + } } diff --git a/yarn.lock b/yarn.lock index 0825b09e..bf4869da 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2416,7 +2416,7 @@ eslint-plugin-import@^2.14.0: read-pkg-up "^2.0.0" resolve "^1.6.0" -eslint-plugin-prettier@^2.6.2: +eslint-plugin-prettier@^2.2.0, eslint-plugin-prettier@^2.6.2: version "2.6.2" resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-2.6.2.tgz#71998c60aedfa2141f7bfcbf9d1c459bf98b4fad" dependencies: @@ -7224,10 +7224,21 @@ trim-right@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003" -tslib@^1.8.0, tslib@^1.8.1, tslib@^1.9.0: +tslib@^1.7.1, tslib@^1.8.0, tslib@^1.8.1, tslib@^1.9.0: version "1.9.3" resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.9.3.tgz#d7e4dd79245d85428c4d7e4822a79917954ca286" +tslint-config-prettier@^1.15.0: + version "1.15.0" + resolved "https://registry.yarnpkg.com/tslint-config-prettier/-/tslint-config-prettier-1.15.0.tgz#76b9714399004ab6831fdcf76d89b73691c812cf" + +tslint-plugin-prettier@^1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/tslint-plugin-prettier/-/tslint-plugin-prettier-1.3.0.tgz#7eb65d19ea786a859501a42491b78c5de2031a3f" + dependencies: + eslint-plugin-prettier "^2.2.0" + tslib "^1.7.1" + tslint@^5.11.0: version "5.11.0" resolved "https://registry.yarnpkg.com/tslint/-/tslint-5.11.0.tgz#98f30c02eae3cde7006201e4c33cb08b48581eed" From e03258a2eccd05e6fa255813e8f8e5aa4f9f1d43 Mon Sep 17 00:00:00 2001 From: mernxl Date: Tue, 18 Sep 2018 13:59:46 +0100 Subject: [PATCH 2/6] chore: update `graphql-compose` to v5.1.1 this is to get all the latest changes that were made with TypeComposer --- package.json | 2 +- yarn.lock | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/package.json b/package.json index 0a5609d4..e51acfe0 100644 --- a/package.json +++ b/package.json @@ -61,7 +61,7 @@ "eslint-plugin-prettier": "^2.6.2", "flow-bin": "^0.80.0", "graphql": "14.0.0", - "graphql-compose": "^5.0.2", + "graphql-compose": "^5.1.1", "graphql-compose-connection": ">=4.0.0", "graphql-compose-pagination": ">=4.0.0", "jest": "^23.5.0", diff --git a/yarn.lock b/yarn.lock index bf4869da..b7862e56 100644 --- a/yarn.lock +++ b/yarn.lock @@ -3174,9 +3174,9 @@ graphql-compose-pagination@>=4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/graphql-compose-pagination/-/graphql-compose-pagination-4.0.0.tgz#a48625e3716f929878f9b8093740837ad52a039e" -graphql-compose@^5.0.2: - version "5.0.2" - resolved "https://registry.yarnpkg.com/graphql-compose/-/graphql-compose-5.0.2.tgz#ad0cbdcd31d1648fa9267a3ffe89c0b39df6d222" +graphql-compose@^5.1.1: + version "5.1.1" + resolved "https://registry.yarnpkg.com/graphql-compose/-/graphql-compose-5.1.1.tgz#df2b8633a0d2dd53dfbc92072b4d5a1c854da4d8" dependencies: graphql-type-json "^0.2.1" object-path "^0.11.4" From f437c7be140e9378a734493976235ebc1e5332a1 Mon Sep 17 00:00:00 2001 From: mernxl Date: Tue, 18 Sep 2018 14:57:31 +0100 Subject: [PATCH 3/6] feat(TypeScript): add typings for `DiscriminatorTypeComposer` fix(TypeScript): adjust composeMongoose types to support new TypeComposer typings --- .../typedefs/composeWithMongoose.spec.ts | 39 +++++++ .../composeWithMongooseDiscriminators.spec.ts | 96 +++++++++++++++++ src/__tests__/typedefs/mock-typedefs.ts | 54 ++++++++++ src/composeWithMongoose.d.ts | 15 +-- src/composeWithMongooseDiscriminators.d.ts | 17 ++- .../DiscriminatorTypeComposer.d.ts | 100 ++++++++++++++++++ src/discriminators/index.d.ts | 11 ++ src/fieldsConverter.d.ts | 6 +- src/index.d.ts | 2 +- 9 files changed, 325 insertions(+), 15 deletions(-) create mode 100644 src/__tests__/typedefs/composeWithMongoose.spec.ts create mode 100644 src/__tests__/typedefs/composeWithMongooseDiscriminators.spec.ts create mode 100644 src/__tests__/typedefs/mock-typedefs.ts create mode 100644 src/discriminators/DiscriminatorTypeComposer.d.ts create mode 100644 src/discriminators/index.d.ts diff --git a/src/__tests__/typedefs/composeWithMongoose.spec.ts b/src/__tests__/typedefs/composeWithMongoose.spec.ts new file mode 100644 index 00000000..44258cb6 --- /dev/null +++ b/src/__tests__/typedefs/composeWithMongoose.spec.ts @@ -0,0 +1,39 @@ +import { model, Schema } from 'mongoose'; +import { composeWithMongoose } from '../../composeWithMongoose'; +import { Context, IUser, IUserModel } from './mock-typedefs'; + +const UserModel = model('User', new Schema({})); +const PostModel = model('Post', new Schema({})); + +const UserTC = composeWithMongoose(UserModel); + +// if one doesn't pass `any` as source, then we will eventually get `Document` +// as source which to an extend is not as open as `any`. +// the `Document` type was set internally by mongoose typedefs. +const PostTC = composeWithMongoose(PostModel); + +UserTC.addFields({ + newField: { + // test Thunk + type: 'Int', + resolve: (source, args, context) => { + source.name = 'GQC'; + // source.name = 44; + context.auth = 'auth'; + // context.auth = 44; + }, + }, +}); + +PostTC.addFields({ + newField: { + // test Thunk + type: 'Int', + resolve: (source, args, context) => { + source.name = 'GQC'; + // source.name = 44; + context.auth = 'auth'; + // context.auth = 44; + }, + }, +}); diff --git a/src/__tests__/typedefs/composeWithMongooseDiscriminators.spec.ts b/src/__tests__/typedefs/composeWithMongooseDiscriminators.spec.ts new file mode 100644 index 00000000..0de6199f --- /dev/null +++ b/src/__tests__/typedefs/composeWithMongooseDiscriminators.spec.ts @@ -0,0 +1,96 @@ +import { model, Schema } from 'mongoose'; +import { composeWithMongooseDiscriminators } from '../../composeWithMongooseDiscriminators'; +import { + Context, + EnumCharacterType, + ICharacter, + ICharacterModel, + IDroid, + IPerson, +} from './mock-typedefs'; + +const CharacterModel = model( + 'Character', + new Schema({}), +); + +const PersonModel = CharacterModel.discriminator( + EnumCharacterType.Person, + new Schema({}), +); +const DroidModel = CharacterModel.discriminator( + EnumCharacterType.Droid, + new Schema({}), +); + +const CharacterTC = composeWithMongooseDiscriminators( + CharacterModel, + { + reorderFields: true, + }, +); + +const PersonTC = CharacterTC.discriminator(PersonModel); +const DroidTC = CharacterTC.discriminator(DroidModel); + +CharacterTC.getResolver( + 'findOne', +).wrapResolve(next => rp => { + if (rp.source && rp.args) { + rp.args.arg1 = 'string'; + rp.args.arg2 = 888; + } +}); + +CharacterTC.addFields({ + newField: { + // test Thunk + type: 'Int', + resolve: (source, args, context) => { + source.name = 'GQC'; + // source.name = 44; + context.auth = 'auth'; + // context.auth = 44; + }, + }, +}); + +PersonTC.addFields({ + newField: { + // test Thunk + type: 'Int', + resolve: (source, args, context) => { + source.name = 'GQC'; + // source.name = 44; + source.dob = 51225545; + // source.dob = 'string'; + context.auth = 'auth'; + // context.auth = 44; + }, + }, +}); + +DroidTC.addFields({ + newField: { + // test Thunk + type: 'Int', + resolve: (source, args, context) => { + source.name = 'GQC'; + // source.name = 44; + source.makeDate = new Date(); + // source.makeDate = 55566156; + context.auth = 'auth'; + // context.auth = 44; + }, + }, +}); + +// Testing a scenario where we use no types +const Char = model('Char', new Schema({})); +const Per = Char.discriminator('Per', new Schema({})); + +// by default, from mongoose types, sources are `Document`. +// it is good to explicitly override `Document` to `any` +// then since we did not pass a context, our context results to `any` +const CharTC = composeWithMongooseDiscriminators(Char); +const PerTC = CharTC.discriminator(Per); diff --git a/src/__tests__/typedefs/mock-typedefs.ts b/src/__tests__/typedefs/mock-typedefs.ts new file mode 100644 index 00000000..560193b9 --- /dev/null +++ b/src/__tests__/typedefs/mock-typedefs.ts @@ -0,0 +1,54 @@ +import { Document, Model } from 'mongoose'; + +export interface Context { + uid: string; + profileUrl: string; + auth: string; +} + +export interface IUser extends Document { + name: string; + age: number; + gender: 'male' | 'female' | 'ladyboy'; + skills: string[]; +} + +export interface IUserModel extends Model { + statics1: string; +} + +export interface IPost extends Document { + title: string; + body: string; + comments: Array<{ by: string; text: string }>; +} + +export enum EnumCharacterType { + Person = 'Person', + Droid = 'Droid', +} + +export interface ICharacter extends Document { + name: string; + type: EnumCharacterType; + kind: string; + friends: string[]; + appearsIn: string[]; +} + +// if static functions exist +export interface ICharacterModel extends Model { + getCharactersFriends(id: string): ICharacter[]; +} + +export interface IPerson extends ICharacter { + dob: number; + starShips: string[]; + totalCredits: number; +} + +export interface IDroid extends ICharacter { + makeDate: Date; + modelNumber: number; + primaryFunction: string[]; +} diff --git a/src/composeWithMongoose.d.ts b/src/composeWithMongoose.d.ts index eb95335b..a99dcf28 100644 --- a/src/composeWithMongoose.d.ts +++ b/src/composeWithMongoose.d.ts @@ -13,8 +13,8 @@ import { } from './resolvers/helpers'; import { PaginationResolverOpts } from './resolvers/pagination'; -export type TypeConverterOpts = { - schemaComposer?: SchemaComposer; +export type TypeConverterOpts = { + schemaComposer?: SchemaComposer; name?: string; description?: string; fields?: { @@ -111,10 +111,13 @@ export type TypeConverterResolversOpts = { pagination?: PaginationResolverOpts | false; }; -export function composeWithMongoose( - model: Model, - opts?: TypeConverterOpts, -): TypeComposer; +export function composeWithMongoose< + TModel extends Document = any, + TContext = any +>( + model: Model, + opts?: TypeConverterOpts, +): TypeComposer; export function prepareFields( tc: TypeComposer, diff --git a/src/composeWithMongooseDiscriminators.d.ts b/src/composeWithMongooseDiscriminators.d.ts index 35ac17d6..13bde477 100644 --- a/src/composeWithMongooseDiscriminators.d.ts +++ b/src/composeWithMongooseDiscriminators.d.ts @@ -1,6 +1,13 @@ -import { TypeComposerClass } from 'graphql-compose'; -import { Model } from 'mongoose'; +import { Document, Model } from 'mongoose'; +import { + DiscriminatorOptions, + DiscriminatorTypeComposer, +} from './discriminators'; -export function composeWithMongooseDiscriminators( - baseModel: Model, - opts?: { [opts: string]: any }): TypeComposerClass; +export function composeWithMongooseDiscriminators< + TBaseModel extends Document = any, + TContext = any +>( + baseModel: Model, + opts?: DiscriminatorOptions, +): DiscriminatorTypeComposer; diff --git a/src/discriminators/DiscriminatorTypeComposer.d.ts b/src/discriminators/DiscriminatorTypeComposer.d.ts new file mode 100644 index 00000000..cbff2fe0 --- /dev/null +++ b/src/discriminators/DiscriminatorTypeComposer.d.ts @@ -0,0 +1,100 @@ +import { + ComposeFieldConfig, + ComposeFieldConfigMap, + EnumTypeComposer, + GetRecordIdFn, + InterfaceTypeComposer, + RelationOpts, + SchemaComposer, + TypeComposer, +} from 'graphql-compose'; +import { Document, Model } from 'mongoose'; +import { TypeConverterOpts } from '../composeWithMongoose'; + +export type DiscriminatorOptions = TypeConverterOpts< + TContext +> & { + reorderFields?: boolean | string[]; // true order: _id, DKey, DInterfaceFields, DiscriminatorFields +}; + +export class DiscriminatorTypeComposer< + TBaseModel extends Document, + TContext +> extends TypeComposer { + public static schemaComposer: SchemaComposer; + + private discriminatorKey: string; + + private DKeyETC: EnumTypeComposer; + + private opts: DiscriminatorOptions; + + private DInterface: InterfaceTypeComposer; + + private childTCs: Array>; + + public static createFromModel( + baseModel: Model, + opts?: DiscriminatorOptions, + ): DiscriminatorTypeComposer; + + public getDKey(): string; + + public getDKeyETC(): EnumTypeComposer; + + public getDInterface(): InterfaceTypeComposer; + + public hasChildTC(DName: string): boolean; + + public setFields(fields: ComposeFieldConfigMap): this; + + public setField( + fieldName: string, + fieldConfig: ComposeFieldConfig, + ): this; + + // discriminators must have all interface fields + public addFields( + newFields: ComposeFieldConfigMap, + ): this; + + public addNestedFields( + newFields: ComposeFieldConfigMap, + ): this; + + public removeField(fieldNameOrArray: string | string[]): this; + + public removeOtherFields(fieldNameOrArray: string | string[]): this; + + public extendField( + fieldName: string, + partialFieldConfig: ComposeFieldConfig, + ): this; + + public reorderFields(names: string[]): this; + + public makeFieldNonNull(fieldNameOrArray: string | string[]): this; + + public makeFieldNullable(fieldNameOrArray: string | string[]): this; + + public deprecateFields( + fields: { [fieldName: string]: string } | string[] | string, + ): this; + + public addRelation( + fieldName: string, + relationOpts: RelationOpts, + ): this; + + public addRelation( + fieldName: string, + relationOpts: RelationOpts, + ): this; + + public setRecordIdFn(fn: GetRecordIdFn): this; + + public discriminator( + childModel: Model, + opts?: TypeConverterOpts, + ): TypeComposer; +} diff --git a/src/discriminators/index.d.ts b/src/discriminators/index.d.ts new file mode 100644 index 00000000..39d12993 --- /dev/null +++ b/src/discriminators/index.d.ts @@ -0,0 +1,11 @@ +import { TypeConverterOpts } from '../composeWithMongoose'; + +export { + DiscriminatorTypeComposer, + DiscriminatorOptions, +} from './DiscriminatorTypeComposer'; + +export function mergeCustomizationOptions( + baseCOptions: TypeConverterOpts, + childCOptions?: TypeConverterOpts, +): TypeConverterOpts | void; diff --git a/src/fieldsConverter.d.ts b/src/fieldsConverter.d.ts index 74cbfd8f..51cfa9da 100644 --- a/src/fieldsConverter.d.ts +++ b/src/fieldsConverter.d.ts @@ -46,11 +46,11 @@ export function convertModelToGraphQL( sc?: SchemaComposer, ): TypeComposer; -export function convertSchemaToGraphQL( +export function convertSchemaToGraphQL( schema: Schema, typeName: string, - sc?: SchemaComposer, -): TypeComposer; + sc?: SchemaComposer, +): TypeComposer; export function convertFieldToGraphQL( field: MongooseFieldT, diff --git a/src/index.d.ts b/src/index.d.ts index 59d55ffb..2115d412 100644 --- a/src/index.d.ts +++ b/src/index.d.ts @@ -5,7 +5,7 @@ import GraphQLMongoID from './types/mongoid'; export default composeWithMongoose; export * from './fieldsConverter'; -// @ts-todo export * from './discriminators'; // untyped yet +export * from './discriminators'; export { composeWithMongoose, From fdfc1c77c0848af3e37e05c10ba27d58297fb482 Mon Sep 17 00:00:00 2001 From: mernxl Date: Tue, 18 Sep 2018 15:16:09 +0100 Subject: [PATCH 4/6] chore: update `graphql-compose` to v5.2.0 as it contains `TArgs`, `TArgsMap` changes --- package.json | 2 +- yarn.lock | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/package.json b/package.json index e51acfe0..071387a9 100644 --- a/package.json +++ b/package.json @@ -61,7 +61,7 @@ "eslint-plugin-prettier": "^2.6.2", "flow-bin": "^0.80.0", "graphql": "14.0.0", - "graphql-compose": "^5.1.1", + "graphql-compose": "^5.2.0", "graphql-compose-connection": ">=4.0.0", "graphql-compose-pagination": ">=4.0.0", "jest": "^23.5.0", diff --git a/yarn.lock b/yarn.lock index b7862e56..70844b21 100644 --- a/yarn.lock +++ b/yarn.lock @@ -3174,9 +3174,9 @@ graphql-compose-pagination@>=4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/graphql-compose-pagination/-/graphql-compose-pagination-4.0.0.tgz#a48625e3716f929878f9b8093740837ad52a039e" -graphql-compose@^5.1.1: - version "5.1.1" - resolved "https://registry.yarnpkg.com/graphql-compose/-/graphql-compose-5.1.1.tgz#df2b8633a0d2dd53dfbc92072b4d5a1c854da4d8" +graphql-compose@^5.2.0: + version "5.2.0" + resolved "https://registry.yarnpkg.com/graphql-compose/-/graphql-compose-5.2.0.tgz#1ce447ed55162df91f2364d2ccdc65387342b774" dependencies: graphql-type-json "^0.2.1" object-path "^0.11.4" From beddb30df1adbf63441350113bdf3b485245804d Mon Sep 17 00:00:00 2001 From: mernxl Date: Tue, 18 Sep 2018 15:17:02 +0100 Subject: [PATCH 5/6] feat(TypeScript): add `TArgs` and `TArgsMap` to `DiscriminatorTypeComposer` --- .../DiscriminatorTypeComposer.d.ts | 37 +++++++++++++++---- 1 file changed, 30 insertions(+), 7 deletions(-) diff --git a/src/discriminators/DiscriminatorTypeComposer.d.ts b/src/discriminators/DiscriminatorTypeComposer.d.ts index cbff2fe0..50fdd2e2 100644 --- a/src/discriminators/DiscriminatorTypeComposer.d.ts +++ b/src/discriminators/DiscriminatorTypeComposer.d.ts @@ -38,6 +38,9 @@ export class DiscriminatorTypeComposer< opts?: DiscriminatorOptions, ): DiscriminatorTypeComposer; + // ------------------------------------------------ + // DiscriminatorTypeComposer Specific methods + // ------------------------------------------------ public getDKey(): string; public getDKeyETC(): EnumTypeComposer; @@ -46,11 +49,28 @@ export class DiscriminatorTypeComposer< public hasChildTC(DName: string): boolean; - public setFields(fields: ComposeFieldConfigMap): this; + public discriminator( + childModel: Model, + opts?: TypeConverterOpts, + ): TypeComposer; + // ------------------------------------------------ + // TypeComposer Overridden methods + // ------------------------------------------------ public setField( fieldName: string, - fieldConfig: ComposeFieldConfig, + fieldConfig: ComposeFieldConfig, + ): this; + + public setField( + fieldName: string, + fieldConfig: ComposeFieldConfig, + ): this; + + public setFields(fields: ComposeFieldConfigMap): this; + + public setFields( + fields: ComposeFieldConfigMap, ): this; // discriminators must have all interface fields @@ -58,10 +78,18 @@ export class DiscriminatorTypeComposer< newFields: ComposeFieldConfigMap, ): this; + public addFields( + newFields: ComposeFieldConfigMap, + ): this; + public addNestedFields( newFields: ComposeFieldConfigMap, ): this; + public addNestedFields( + newFields: ComposeFieldConfigMap, + ): this; + public removeField(fieldNameOrArray: string | string[]): this; public removeOtherFields(fieldNameOrArray: string | string[]): this; @@ -92,9 +120,4 @@ export class DiscriminatorTypeComposer< ): this; public setRecordIdFn(fn: GetRecordIdFn): this; - - public discriminator( - childModel: Model, - opts?: TypeConverterOpts, - ): TypeComposer; } From 983ec540c0090a224769093cc0d8ac88a22d393b Mon Sep 17 00:00:00 2001 From: mernxl Date: Sat, 22 Sep 2018 10:44:03 +0100 Subject: [PATCH 6/6] feat(TypeScript): add helpers for resolver args, get by `${ResolverName}Args` --- package.json | 2 +- .../typedefs/composeWithMongoose.spec.ts | 20 +++++++++++-- src/index.d.ts | 1 + src/resolvers.d.ts | 15 ++++++++++ src/resolvers/connection.d.ts | 29 ++++++++++++++++++ src/resolvers/count.d.ts | 8 +++++ src/resolvers/createMany.d.ts | 9 ++++++ src/resolvers/createOne.d.ts | 8 +++++ src/resolvers/findById.d.ts | 7 +++++ src/resolvers/findByIds.d.ts | 10 +++++++ src/resolvers/findMany.d.ts | 30 +++++++++++++++---- src/resolvers/findOne.d.ts | 10 +++++++ src/resolvers/helpers/filter.d.ts | 11 ++++++- src/resolvers/helpers/filterOperators.d.ts | 30 +++++++++++++++++-- src/resolvers/helpers/limit.d.ts | 2 ++ src/resolvers/helpers/record.d.ts | 3 ++ src/resolvers/helpers/skip.d.ts | 2 ++ src/resolvers/helpers/sort.d.ts | 2 ++ src/resolvers/pagination.d.ts | 24 +++++++++++++++ src/resolvers/removeById.d.ts | 10 +++++++ src/resolvers/removeMany.d.ts | 9 ++++++ src/resolvers/removeOne.d.ts | 12 ++++++++ src/resolvers/updateById.d.ts | 9 ++++++ src/resolvers/updateMany.d.ts | 10 +++++++ src/resolvers/updateOne.d.ts | 8 +++++ src/types/mongoid.d.ts | 2 ++ 26 files changed, 271 insertions(+), 12 deletions(-) create mode 100644 src/resolvers.d.ts diff --git a/package.json b/package.json index 071387a9..2474714d 100644 --- a/package.json +++ b/package.json @@ -99,7 +99,7 @@ "coverage": "jest --coverage --maxWorkers 4", "lint": "npm run eslint && npm run tslint", "eslint": "eslint --ext .js ./src", - "tslint": "tslint -p . \"src/**/*.d.ts\"", + "tslint": "tslint -p .", "tscheck": "tsc", "flow": "./node_modules/.bin/flow", "test": "npm run coverage && npm run lint && npm run flow && npm run tscheck", diff --git a/src/__tests__/typedefs/composeWithMongoose.spec.ts b/src/__tests__/typedefs/composeWithMongoose.spec.ts index 44258cb6..9fb720d2 100644 --- a/src/__tests__/typedefs/composeWithMongoose.spec.ts +++ b/src/__tests__/typedefs/composeWithMongoose.spec.ts @@ -1,6 +1,7 @@ import { model, Schema } from 'mongoose'; import { composeWithMongoose } from '../../composeWithMongoose'; -import { Context, IUser, IUserModel } from './mock-typedefs'; +import { FindManyArgs } from '../..'; +import { Context, IPost, IUser, IUserModel } from './mock-typedefs'; const UserModel = model('User', new Schema({})); const PostModel = model('Post', new Schema({})); @@ -31,9 +32,22 @@ PostTC.addFields({ type: 'Int', resolve: (source, args, context) => { source.name = 'GQC'; - // source.name = 44; + source.name = 44; context.auth = 'auth'; - // context.auth = 44; + context.auth = 44; }, }, }); + +PostTC.getResolver('findMany').wrapResolve>( + next => rp => { + if (rp.source && rp.args) { + rp.args.limit = 50; + // fix this to display only Post fields. + // Avoid Document fields + rp.args.filter.title = 'New Title'; + // rp.args.filter.title = 5; + // rp.args.limit = 'limit'; + } + }, +); diff --git a/src/index.d.ts b/src/index.d.ts index 2115d412..6e3de2f0 100644 --- a/src/index.d.ts +++ b/src/index.d.ts @@ -4,6 +4,7 @@ import GraphQLMongoID from './types/mongoid'; export default composeWithMongoose; +export * from './resolvers'; export * from './fieldsConverter'; export * from './discriminators'; diff --git a/src/resolvers.d.ts b/src/resolvers.d.ts new file mode 100644 index 00000000..b8fb3785 --- /dev/null +++ b/src/resolvers.d.ts @@ -0,0 +1,15 @@ +export { CountArgs } from './resolvers/count'; +export { ConnectionArgs } from './resolvers/connection'; +export { PaginationArgs } from './resolvers/pagination'; +export { CreateOneArgs } from './resolvers/createOne'; +export { CreateManyArgs } from './resolvers/createMany'; +export { RemoveOneArgs } from './resolvers/removeOne'; +export { RemoveByIdArgs } from './resolvers/removeById'; +export { RemoveManyArgs } from './resolvers/removeMany'; +export { UpdateOneArgs } from './resolvers/updateOne'; +export { UpdateByIdArgs } from './resolvers/updateById'; +export { UpdateManyArgs } from './resolvers/updateMany'; +export { FindByIdArgs } from './resolvers/findById'; +export { FindByIdsArgs } from './resolvers/findByIds'; +export { FindOneArgs } from './resolvers/findOne'; +export { FindManyArgs } from './resolvers/findMany'; diff --git a/src/resolvers/connection.d.ts b/src/resolvers/connection.d.ts index 2ad885a7..bb5b5aa2 100644 --- a/src/resolvers/connection.d.ts +++ b/src/resolvers/connection.d.ts @@ -1,7 +1,9 @@ import { Resolver, TypeComposer } from 'graphql-compose'; // import { ConnectionSortMapOpts } from 'graphql-compose-connection'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; import { IndexT } from '../utils'; +import { FilterHelperArgs, SortHelperArgs } from './helpers'; // @ts-todo The ConnectionSortMapOpts is not available yet since graphql-compose-connection doesn't have types for now, // fallback to a simple object. @@ -21,3 +23,30 @@ export function prepareCursorQuery( nextOper: '$gt' | '$lt', prevOper: '$lt' | '$gt', ): void; + +export type ConnectionArgs = { + first: number; + after: string; + last: number; + before: string; + filter: FilterHelperArgs; + sort: SortHelperArgs; +}; + +export type ConnectionPageInfo = { + hasNextPage: boolean; + hasPreviousPage: boolean; + startCursor: string; + endCursor: string; +}; + +export type ConnectionEdges = { + node: TSource; + cursor: number; +}; + +export type ConnectionRSource = { + count: number; + pageInfo: ConnectionPageInfo; + edges: ConnectionEdges; +}; diff --git a/src/resolvers/count.d.ts b/src/resolvers/count.d.ts index fec2796d..74575778 100644 --- a/src/resolvers/count.d.ts +++ b/src/resolvers/count.d.ts @@ -1,7 +1,15 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { FilterHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; +export type CountArgs = { + filter: FilterHelperArgs; +}; + +export type CountRSource = number; + export default function count( model: Model, tc: TypeComposer, diff --git a/src/resolvers/createMany.d.ts b/src/resolvers/createMany.d.ts index d26078f8..c3c2a037 100644 --- a/src/resolvers/createMany.d.ts +++ b/src/resolvers/createMany.d.ts @@ -1,7 +1,16 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { RecordsHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; +export type CreateManyArgs = RecordsHelperArgs; +export type CreateManyRSource = { + records: TSource[]; + recordIds: MongoId[]; + createCount: number; +}; + export default function createMany( model: Model, tc: TypeComposer, diff --git a/src/resolvers/createOne.d.ts b/src/resolvers/createOne.d.ts index 2bd15c6b..1c32a944 100644 --- a/src/resolvers/createOne.d.ts +++ b/src/resolvers/createOne.d.ts @@ -1,7 +1,15 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { RecordHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; +export type CreateOneArgs = RecordHelperArgs; +export type CreateOneRSource = { + recordId: MongoId; + record: TSource; +}; + export default function createOne( model: Model, tc: TypeComposer, diff --git a/src/resolvers/findById.d.ts b/src/resolvers/findById.d.ts index c21e95e4..57b9ed37 100644 --- a/src/resolvers/findById.d.ts +++ b/src/resolvers/findById.d.ts @@ -1,5 +1,6 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; import { GenResolverOpts } from './index'; export default function findById( @@ -7,3 +8,9 @@ export default function findById( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type FindByIdArgs = { + _id: MongoId; +}; + +export type FindByIdRSource = TSource; diff --git a/src/resolvers/findByIds.d.ts b/src/resolvers/findByIds.d.ts index 8f000059..e529f819 100644 --- a/src/resolvers/findByIds.d.ts +++ b/src/resolvers/findByIds.d.ts @@ -1,5 +1,7 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { LimitHelperArgs, SortHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; export default function findByIds( @@ -7,3 +9,11 @@ export default function findByIds( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type FindByIdsArgs = { + _ids: [MongoId]; + limit: LimitHelperArgs; + sort: SortHelperArgs; +}; + +export type FindByIdsRSource = TSource[]; diff --git a/src/resolvers/findMany.d.ts b/src/resolvers/findMany.d.ts index 3fb92447..0be7b0b4 100644 --- a/src/resolvers/findMany.d.ts +++ b/src/resolvers/findMany.d.ts @@ -1,9 +1,29 @@ import { Resolver, TypeComposer } from 'graphql-compose'; -import { Model } from 'mongoose'; +import { Document, Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { + FilterHelperArgs, + LimitHelperArgs, + SkipHelperArgs, + SortHelperArgs, +} from './helpers'; import { GenResolverOpts } from './index'; -export default function findMany( - model: Model, - tc: TypeComposer, +export default function findMany< + TSource extends Document = any, + TContext = any, + TArgs = any +>( + model: Model, + tc: TypeComposer, opts?: GenResolverOpts, -): Resolver; +): Resolver; + +export type FindManyArgs = { + filter: FilterHelperArgs; + skip: SkipHelperArgs; + limit: LimitHelperArgs; + sort: SortHelperArgs; +}; + +export type FindManyRSource = TSource[]; diff --git a/src/resolvers/findOne.d.ts b/src/resolvers/findOne.d.ts index 02d829ec..f1dd9dd1 100644 --- a/src/resolvers/findOne.d.ts +++ b/src/resolvers/findOne.d.ts @@ -1,5 +1,7 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { FilterHelperArgs, SkipHelperArgs, SortHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; export default function findOne( @@ -7,3 +9,11 @@ export default function findOne( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type FindOneArgs = { + filter: FilterHelperArgs; + skip: SkipHelperArgs; + sort: SortHelperArgs; +}; + +export type FindOneRSource = TSource; diff --git a/src/resolvers/helpers/filter.d.ts b/src/resolvers/helpers/filter.d.ts index ed3a74ae..69bf3024 100644 --- a/src/resolvers/helpers/filter.d.ts +++ b/src/resolvers/helpers/filter.d.ts @@ -1,7 +1,8 @@ import { ComposeFieldConfigArgumentMap, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../../types/mongoid'; import { ExtendedResolveParams } from '../index'; -import { FilterOperatorsOpts } from './filterOperators'; +import { FilterOperatorsArgs, FilterOperatorsOpts } from './filterOperators'; export type FilterHelperArgsOpts = { filterTypeName?: string; @@ -12,6 +13,14 @@ export type FilterHelperArgsOpts = { removeFields?: string | string[]; }; +export type FilterHelperArgs< + TSource = any, + IndexedFieldsMap = { _id: MongoId } +> = TSource & + FilterOperatorsArgs & { + _ids: MongoId[]; + }; + export function getFilterHelperArgOptsMap(): Partial< Record >; diff --git a/src/resolvers/helpers/filterOperators.d.ts b/src/resolvers/helpers/filterOperators.d.ts index a8a4c54c..c94485f8 100644 --- a/src/resolvers/helpers/filterOperators.d.ts +++ b/src/resolvers/helpers/filterOperators.d.ts @@ -1,7 +1,9 @@ import { InputTypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; import { ExtendedResolveParams } from '../index'; -import { FilterHelperArgsOpts } from './filter'; +import { FilterHelperArgs, FilterHelperArgsOpts } from './filter'; + +export const OPERATORS_FIELDNAME: '_operators'; export type FilterOperatorNames = | 'gt' @@ -12,7 +14,31 @@ export type FilterOperatorNames = | 'in[]' | 'nin[]'; -export const OPERATORS_FIELDNAME: string; +type PlainOperatorNames = Exclude; +type ArrayOperatorNames = 'in' | 'nin'; + +type PlainOperatorFieldTypeMap = Record< + PlainOperatorNames, + FieldType +>; +type ArrayOperatorFieldTypeMap = Record< + ArrayOperatorNames, + FieldType[] +>; + +// IndexedFieldsMap = { fieldName: type } +export type Filter_operatorsArgs = { + [fieldName in keyof IndexedFieldMap]: PlainOperatorFieldTypeMap< + IndexedFieldMap[fieldName] + > & + ArrayOperatorFieldTypeMap +}; + +export type FilterOperatorsArgs = { + _operators: Filter_operatorsArgs; + OR: FilterHelperArgs; + AND: FilterHelperArgs; +}; export type FilterOperatorsOpts = { [fieldName: string]: FilterOperatorNames[] | false; diff --git a/src/resolvers/helpers/limit.d.ts b/src/resolvers/helpers/limit.d.ts index 86c24131..1c4c1d76 100644 --- a/src/resolvers/helpers/limit.d.ts +++ b/src/resolvers/helpers/limit.d.ts @@ -5,6 +5,8 @@ export type LimitHelperArgsOpts = { defaultValue?: number; }; +export type LimitHelperArgs = number; + export function getLimitHelperArgsOptsMap(): Partial< Record >; diff --git a/src/resolvers/helpers/record.d.ts b/src/resolvers/helpers/record.d.ts index 5224cbb9..4c93d664 100644 --- a/src/resolvers/helpers/record.d.ts +++ b/src/resolvers/helpers/record.d.ts @@ -11,6 +11,9 @@ export function getRecordHelperArgsOptsMap(): Partial< Record >; +export type RecordHelperArgs = { record: TSource }; +export type RecordsHelperArgs = { records: TSource[] }; + export function recordHelperArgs( tc: TypeComposer, opts?: RecordHelperArgsOpts, diff --git a/src/resolvers/helpers/skip.d.ts b/src/resolvers/helpers/skip.d.ts index 1db97f21..fbc0edb0 100644 --- a/src/resolvers/helpers/skip.d.ts +++ b/src/resolvers/helpers/skip.d.ts @@ -1,6 +1,8 @@ import { ComposeFieldConfigArgumentMap } from 'graphql-compose'; import { ExtendedResolveParams } from '../index'; +export type SkipHelperArgs = number; + export function skipHelperArgs(): ComposeFieldConfigArgumentMap; export function skipHelper(resolveParams: ExtendedResolveParams): void; diff --git a/src/resolvers/helpers/sort.d.ts b/src/resolvers/helpers/sort.d.ts index 9abfdb89..3a2ac1d9 100644 --- a/src/resolvers/helpers/sort.d.ts +++ b/src/resolvers/helpers/sort.d.ts @@ -11,6 +11,8 @@ export type SortHelperArgsOpts = { sortTypeName?: string; }; +export type SortHelperArgs = '_ID_ASC' | '_ID_DESC' | any; + export function sortHelperArgs( typeComposer: TypeComposer, model: Model, diff --git a/src/resolvers/pagination.d.ts b/src/resolvers/pagination.d.ts index 7f0d95f1..c29ff2a0 100644 --- a/src/resolvers/pagination.d.ts +++ b/src/resolvers/pagination.d.ts @@ -1,5 +1,7 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { FilterHelperArgs, SortHelperArgs } from './helpers'; export type PaginationResolverOpts = { perPage?: number; @@ -10,3 +12,25 @@ export default function pagination( tc: TypeComposer, opts?: PaginationResolverOpts, ): Resolver | undefined; + +export type PaginationArgs = { + page: number; + perPage: number; + filter: FilterHelperArgs; + sort: SortHelperArgs; +}; + +export type PaginationPageInfo = { + currentPage?: number; + perPage: number; + perCount: number; + itemCount: number; + hasNextPage: boolean; + hasPreviousPage: boolean; +}; + +export type PaginationRSource = { + count: number; + items: TSource[]; + pageInfo: PaginationPageInfo; +}; diff --git a/src/resolvers/removeById.d.ts b/src/resolvers/removeById.d.ts index 1fcd43a4..d5770e3e 100644 --- a/src/resolvers/removeById.d.ts +++ b/src/resolvers/removeById.d.ts @@ -1,5 +1,6 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; import { GenResolverOpts } from './index'; export default function removeById( @@ -7,3 +8,12 @@ export default function removeById( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type RemoveByIdArgs = { + _id: MongoId; +}; + +export type RemoveByIdRSource = { + recordId: MongoId; + record: TSource; +}; diff --git a/src/resolvers/removeMany.d.ts b/src/resolvers/removeMany.d.ts index 1fcd43a4..cced923b 100644 --- a/src/resolvers/removeMany.d.ts +++ b/src/resolvers/removeMany.d.ts @@ -1,5 +1,6 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { FilterHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; export default function removeById( @@ -7,3 +8,11 @@ export default function removeById( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type RemoveManyArgs = { + filter: FilterHelperArgs; +}; + +export type RemoveManyRSource = { + numAffected: number; +}; diff --git a/src/resolvers/removeOne.d.ts b/src/resolvers/removeOne.d.ts index e5abe54b..d61ad610 100644 --- a/src/resolvers/removeOne.d.ts +++ b/src/resolvers/removeOne.d.ts @@ -1,5 +1,7 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { FilterHelperArgs, SortHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; export default function removeOne( @@ -7,3 +9,13 @@ export default function removeOne( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type RemoveOneArgs = { + filter: FilterHelperArgs; + sort: SortHelperArgs; +}; + +export type RemoveOneRSource = { + recordId: MongoId; + record: TSource; +}; diff --git a/src/resolvers/updateById.d.ts b/src/resolvers/updateById.d.ts index 0c268838..c5b223e4 100644 --- a/src/resolvers/updateById.d.ts +++ b/src/resolvers/updateById.d.ts @@ -1,5 +1,7 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { RecordHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; export default function updateById( @@ -7,3 +9,10 @@ export default function updateById( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type UpdateByIdArgs = RecordHelperArgs; + +export type UpdateByIdRSource = { + recordId: MongoId; + record: TSource; +}; diff --git a/src/resolvers/updateMany.d.ts b/src/resolvers/updateMany.d.ts index 746f36c9..a2673469 100644 --- a/src/resolvers/updateMany.d.ts +++ b/src/resolvers/updateMany.d.ts @@ -1,5 +1,8 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { FindManyArgs } from './findMany'; +import { RecordHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; export default function updateMany( @@ -7,3 +10,10 @@ export default function updateMany( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type UpdateManyArgs< + TSource, + IndexedFields = { _id: MongoId } +> = RecordHelperArgs & FindManyArgs; + +export type UpdateManyRSource = { numAffected: number }; diff --git a/src/resolvers/updateOne.d.ts b/src/resolvers/updateOne.d.ts index 53b0905a..251d7773 100644 --- a/src/resolvers/updateOne.d.ts +++ b/src/resolvers/updateOne.d.ts @@ -1,5 +1,8 @@ import { Resolver, TypeComposer } from 'graphql-compose'; import { Model } from 'mongoose'; +import { MongoId } from '../types/mongoid'; +import { FindOneArgs } from './findOne'; +import { RecordHelperArgs } from './helpers'; import { GenResolverOpts } from './index'; export default function updateOne( @@ -7,3 +10,8 @@ export default function updateOne( tc: TypeComposer, opts?: GenResolverOpts, ): Resolver; + +export type UpdateOneArgs< + TSource, + IndexedFields = { _id: MongoId } +> = RecordHelperArgs & FindOneArgs; diff --git a/src/types/mongoid.d.ts b/src/types/mongoid.d.ts index 5e9aee72..6b51031c 100644 --- a/src/types/mongoid.d.ts +++ b/src/types/mongoid.d.ts @@ -1,5 +1,7 @@ import { GraphQLScalarType } from 'graphql-compose/lib/graphql'; +export type MongoId = string | any; + declare const GraphQLMongoID: GraphQLScalarType; export default GraphQLMongoID;