feat: Generate other output types

Author: unlight

README.md

@@ -40,7 +40,7 @@ npx prisma generate
     -   `{feature}` - model name in dashed case or 'prisma' if unknown
     -   `{name}` - name of model/input/arg
     -   `{dasherizedName}` - dashed-case name of model/input/arg without suffix
-    -   `{type}` - short type name (model, input)
+    -   `{type}` - short type name (model, input, args, output)
 -   `combineScalarFilters` - Combine nested/nullable scalar filters to single
     (default: `true`)
 -   `atomicNumberOperations` - Atomic number operations,

package.json

@@ -49,7 +49,6 @@
   },
   "dependencies": {
     "@prisma/generator-helper": "^2.6.2",
-    "boolean": "^3.0.1",
     "get-relative-path": "^1.0.2",
     "pupa": "^2.0.1",
     "to-kebab": "^1.0.7",

src/@generated/article/aggregate-article.output.ts

@@ -0,0 +1,39 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+import { ArticleAvgAggregate } from './article-avg-aggregate.output';
+import { ArticleMaxAggregate } from './article-max-aggregate.output';
+import { ArticleMinAggregate } from './article-min-aggregate.output';
+import { ArticleSumAggregate } from './article-sum-aggregate.output';
+
+@ObjectType()
+export class AggregateArticle {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    count?: number | null;
+
+    @Field(() => ArticleAvgAggregate, {
+        nullable: true,
+        description: undefined,
+    })
+    avg?: ArticleAvgAggregate | null;
+
+    @Field(() => ArticleSumAggregate, {
+        nullable: true,
+        description: undefined,
+    })
+    sum?: ArticleSumAggregate | null;
+
+    @Field(() => ArticleMinAggregate, {
+        nullable: true,
+        description: undefined,
+    })
+    min?: ArticleMinAggregate | null;
+
+    @Field(() => ArticleMaxAggregate, {
+        nullable: true,
+        description: undefined,
+    })
+    max?: ArticleMaxAggregate | null;
+}

src/@generated/article/article-avg-aggregate.output.ts

@@ -0,0 +1,10 @@
+import { Field, Float, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class ArticleAvgAggregate {
+    @Field(() => Float, {
+        nullable: true,
+        description: undefined,
+    })
+    favoritesCount?: number | null;
+}

src/@generated/article/article-max-aggregate.output.ts

@@ -0,0 +1,10 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class ArticleMaxAggregate {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    favoritesCount?: number | null;
+}

src/@generated/article/article-min-aggregate.output.ts

@@ -0,0 +1,10 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class ArticleMinAggregate {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    favoritesCount?: number | null;
+}

src/@generated/article/article-sum-aggregate.output.ts

@@ -0,0 +1,10 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class ArticleSumAggregate {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    favoritesCount?: number | null;
+}

src/@generated/comment/aggregate-comment.output.ts

@@ -0,0 +1,10 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class AggregateComment {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    count?: number | null;
+}

src/@generated/prisma/batch-payload.output.ts

@@ -0,0 +1,10 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class BatchPayload {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    count?: number | null;
+}

src/@generated/tag/aggregate-tag.output.ts

@@ -0,0 +1,10 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class AggregateTag {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    count?: number | null;
+}

src/@generated/user/aggregate-user.output.ts

@@ -0,0 +1,39 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+import { UserAvgAggregate } from './user-avg-aggregate.output';
+import { UserMaxAggregate } from './user-max-aggregate.output';
+import { UserMinAggregate } from './user-min-aggregate.output';
+import { UserSumAggregate } from './user-sum-aggregate.output';
+
+@ObjectType()
+export class AggregateUser {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    count?: number | null;
+
+    @Field(() => UserAvgAggregate, {
+        nullable: true,
+        description: undefined,
+    })
+    avg?: UserAvgAggregate | null;
+
+    @Field(() => UserSumAggregate, {
+        nullable: true,
+        description: undefined,
+    })
+    sum?: UserSumAggregate | null;
+
+    @Field(() => UserMinAggregate, {
+        nullable: true,
+        description: undefined,
+    })
+    min?: UserMinAggregate | null;
+
+    @Field(() => UserMaxAggregate, {
+        nullable: true,
+        description: undefined,
+    })
+    max?: UserMaxAggregate | null;
+}

src/@generated/user/user-avg-aggregate.output.ts

@@ -0,0 +1,16 @@
+import { Field, Float, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class UserAvgAggregate {
+    @Field(() => Float, {
+        nullable: true,
+        description: undefined,
+    })
+    countComments?: number | null;
+
+    @Field(() => Float, {
+        nullable: true,
+        description: undefined,
+    })
+    rating?: number | null;
+}

src/@generated/user/user-max-aggregate.output.ts

@@ -0,0 +1,16 @@
+import { Field, Float, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class UserMaxAggregate {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    countComments?: number | null;
+
+    @Field(() => Float, {
+        nullable: true,
+        description: undefined,
+    })
+    rating?: number | null;
+}

src/@generated/user/user-min-aggregate.output.ts

@@ -0,0 +1,16 @@
+import { Field, Float, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class UserMinAggregate {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    countComments?: number | null;
+
+    @Field(() => Float, {
+        nullable: true,
+        description: undefined,
+    })
+    rating?: number | null;
+}

src/@generated/user/user-sum-aggregate.output.ts

@@ -0,0 +1,16 @@
+import { Field, Float, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class UserSumAggregate {
+    @Field(() => Int, {
+        nullable: true,
+        description: undefined,
+    })
+    countComments?: number | null;
+
+    @Field(() => Float, {
+        nullable: true,
+        description: undefined,
+    })
+    rating?: number | null;
+}

src/example/user/user.resolver.ts

@@ -4,6 +4,7 @@ import { PrismaClient } from '@prisma/client';
 import * as Prisma from '@prisma/client';
 
 import { AggregateUserArgs } from '../../@generated/user/aggregate-user.args';
+import { AggregateUser } from '../../@generated/user/aggregate-user.output';
 import { UserUpdateInput } from '../../@generated/user/user-update.input';
 import { UserWhereInput } from '../../@generated/user/user-where.input';
 import { User } from '../../@generated/user/user.model';
@@ -48,10 +49,11 @@ export class UserResolver {
         return null;
     }
 
-    @Query(() => [User])
+    @Query(() => AggregateUser)
     async userAggregate(@Args() args: AggregateUserArgs, @Info() info) {
         console.log('args', args);
         const result = await prisma.user.aggregate(args as Prisma.AggregateUserArgs);
         console.log('result', result);
+        return result;
     }
 }

src/feature-name.ts

@@ -0,0 +1,84 @@
+type FeatureNameArgs = {
+    name: string;
+    models: string[];
+    fallback: string;
+};
+
+export function featureName(args: FeatureNameArgs) {
+    const { name, models } = args;
+    let result = args.fallback;
+    for (const keyword of splitKeywords) {
+        const [test] = name.split(keyword, 1);
+        if (models.includes(test)) {
+            result = test;
+            return result;
+        }
+    }
+    for (const keyword of endsWithKeywords) {
+        const [test] = name.split(keyword).slice(-1);
+        if (models.includes(test)) {
+            result = test;
+            return result;
+        }
+    }
+    for (const [start, end] of middleKeywords) {
+        const test = name.slice(start.length).slice(0, -end.length);
+        if (models.includes(test)) {
+            result = test;
+            return result;
+        }
+    }
+    return result;
+}
+
+const splitKeywords = [
+    'CreateInput',
+    'CreateMany',
+    'CreateOneWithout',
+    'CreateWithout',
+    'DistinctField',
+    'Filter',
+    'ManyWithout',
+    'OrderByInput',
+    'RelationFilter',
+    'ListRelationFilter',
+    'ScalarWhereInput',
+    'UpdateInput',
+    'UpdateMany',
+    'UpdateOneRequiredWithout',
+    'UpdateOneWithout',
+    'UpdateWith',
+    'UpsertWith',
+    'UpsertWithout',
+    'WhereInput',
+    'WhereUniqueInput',
+    'AvgAggregate',
+    'SumAggregate',
+    'MinAggregate',
+    'MaxAggregate',
+].sort((a, b) => b.length - a.length);
+
+const endsWithKeywords = [
+    'Aggregate',
+    'aggregate',
+    'createOne',
+    'deleteMany',
+    'deleteOne',
+    'findMany',
+    'findOne',
+    'updateMany',
+    'updateOne',
+    'upsertOne',
+];
+
+const middleKeywords = [
+    ['Aggregate', 'Args'],
+    ['CreateOne', 'Args'],
+    ['DeleteMany', 'Args'],
+    ['DeleteOne', 'Args'],
+    ['FindMany', 'Args'],
+    ['FindOne', 'Args'],
+    ['UpdateMany', 'Args'],
+    ['UpdateOne', 'Args'],
+    ['UpsertOne', 'Args'],
+];