@rytass/cms-base-nestjs-graphql-module 0.1.25 → 0.1.26

package/src/decorators/language.decorator.ts

@@ -0,0 +1,45 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { DEFAULT_LANGUAGE } from '@rytass/cms-base-nestjs-module';
+import { Request } from 'express';
+
+export const LANGUAGE_HEADER_KEY = 'x-language';
+
+export const Language = createParamDecorator(async (_data: unknown, context: ExecutionContext): Promise<string> => {
+  const contextType = context.getType<'http' | 'graphql'>();
+
+  switch (contextType) {
+    case 'graphql': {
+      const { GqlExecutionContext } = await import('@nestjs/graphql');
+
+      const ctx = GqlExecutionContext.create(context).getContext<{
+        req: Request;
+      }>();
+
+      const headers = ctx.req.headers;
+      const requestLanguage = headers[LANGUAGE_HEADER_KEY];
+
+      if (typeof requestLanguage === 'string') return requestLanguage;
+
+      const acceptLanguage = headers['accept-language'] ?? '';
+
+      if (!acceptLanguage || typeof acceptLanguage !== 'string') return DEFAULT_LANGUAGE;
+
+      return acceptLanguage.split(',')[0].split(';')[0].trim();
+    }
+
+    case 'http':
+    default: {
+      const headers = (context.switchToHttp().getRequest() as Request).headers;
+
+      const requestLanguage = headers[LANGUAGE_HEADER_KEY];
+
+      if (typeof requestLanguage === 'string') return requestLanguage;
+
+      const acceptLanguage = headers['accept-language'] ?? '';
+
+      if (!acceptLanguage || typeof acceptLanguage !== 'string') return DEFAULT_LANGUAGE;
+
+      return acceptLanguage.split(',')[0].split(';')[0].trim();
+    }
+  }
+});

package/src/dto/article-collection.dto.ts

@@ -0,0 +1,9 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { Collection } from './collection.dto';
+import { ArticleDto } from './article.dto';
+
+@ObjectType('ArticleCollection')
+export class ArticleCollectionDto extends Collection {
+  @Field(() => [ArticleDto])
+  articles: ArticleDto[];
+}

package/src/dto/article-multi-language-content.dto.ts

@@ -0,0 +1,18 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { QuadratsContentScalar } from '../scalars/quadrats-element.scalar';
+import type { QuadratsElement } from '@quadrats/core';
+
+@ObjectType('ArticleMultiLanguageContent')
+export class ArticleMultiLanguageContentDto {
+  @Field(() => String)
+  language: string;
+
+  @Field(() => String)
+  title: string;
+
+  @Field(() => String, { nullable: true })
+  description: string | null;
+
+  @Field(() => QuadratsContentScalar)
+  content: QuadratsElement[];
+}

package/src/dto/article-signature-step.dto.ts

@@ -0,0 +1,10 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('ArticleSignatureStep')
+export class ArticleSignatureStepDto {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => String)
+  name: string;
+}

package/src/dto/article-signature.dto.ts

@@ -0,0 +1,21 @@
+import { Field, ID, ObjectType, registerEnumType } from '@nestjs/graphql';
+import { ArticleSignatureResult } from '@rytass/cms-base-nestjs-module';
+
+@ObjectType('ArticleSignature')
+export class ArticleSignatureDto {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => Date)
+  signedAt: Date;
+
+  @Field(() => ArticleSignatureResult)
+  result: ArticleSignatureResult;
+
+  @Field(() => String, { nullable: true })
+  rejectReason: string | null;
+}
+
+registerEnumType(ArticleSignatureResult, {
+  name: 'ArticleSignatureResult',
+});

package/src/dto/article-stage-version.dto.ts

@@ -0,0 +1,23 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import { BackstageArticleDto } from './backstage-article.dto';
+
+@ObjectType('ArticleStageVersion')
+export class ArticleStageVersionDto {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => BackstageArticleDto, { nullable: true })
+  draft: BackstageArticleDto | null;
+
+  @Field(() => BackstageArticleDto, { nullable: true })
+  reviewing: BackstageArticleDto | null;
+
+  @Field(() => BackstageArticleDto, { nullable: true })
+  verified: BackstageArticleDto | null;
+
+  @Field(() => BackstageArticleDto, { nullable: true })
+  scheduled: BackstageArticleDto | null;
+
+  @Field(() => BackstageArticleDto, { nullable: true })
+  released: BackstageArticleDto | null;
+}

package/src/dto/article-version-content.input.ts

@@ -0,0 +1,18 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { QuadratsContentScalar } from '../scalars/quadrats-element.scalar';
+import { QuadratsElement } from '@quadrats/core';
+
+@InputType('ArticleVersionContentInput')
+export class ArticleVersionContentInput {
+  @Field(() => String, { nullable: true })
+  language?: string | null;
+
+  @Field(() => String)
+  title: string;
+
+  @Field(() => String, { nullable: true })
+  description?: string | null;
+
+  @Field(() => QuadratsContentScalar)
+  content: QuadratsElement[];
+}

package/src/dto/article.dto.ts

@@ -0,0 +1,16 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { BaseArticleDto } from './base-article.dto';
+import { QuadratsContentScalar } from '../scalars/quadrats-element.scalar';
+import type { QuadratsElement } from '@quadrats/core';
+
+@ObjectType('Article')
+export class ArticleDto extends BaseArticleDto {
+  @Field(() => String)
+  title: string;
+
+  @Field(() => String, { nullable: true })
+  description: string | null;
+
+  @Field(() => QuadratsContentScalar)
+  content: QuadratsElement[];
+}

package/src/dto/articles.args.ts

@@ -0,0 +1,16 @@
+import { ArgsType, Field, ID, Int } from '@nestjs/graphql';
+
+@ArgsType()
+export class ArticlesArgs {
+  @Field(() => [ID], { nullable: true })
+  categoryIds?: string[] | null;
+
+  @Field(() => Int, { nullable: true })
+  offset?: number | null;
+
+  @Field(() => Int, { nullable: true })
+  limit?: number | null;
+
+  @Field(() => String, { nullable: true })
+  searchTerm?: string | null;
+}

package/src/dto/backstage-article-collection.dto.ts

@@ -0,0 +1,9 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { Collection } from './collection.dto';
+import { BackstageArticleDto } from './backstage-article.dto';
+
+@ObjectType('BackstageArticleCollection')
+export class BackstageArticleCollectionDto extends Collection {
+  @Field(() => [BackstageArticleDto])
+  articles: BackstageArticleDto[];
+}

package/src/dto/backstage-article.args.ts

@@ -0,0 +1,20 @@
+import { ArgsType, Field, registerEnumType } from '@nestjs/graphql';
+import { ArticleSorter, ArticleStage } from '@rytass/cms-base-nestjs-module';
+import { ArticlesArgs } from './articles.args';
+
+@ArgsType()
+export class BackstageArticleArgs extends ArticlesArgs {
+  @Field(() => ArticleStage)
+  stage: ArticleStage;
+
+  @Field(() => ArticleSorter, { nullable: true })
+  sorter?: ArticleSorter | null;
+}
+
+registerEnumType(ArticleStage, {
+  name: 'ArticleStage',
+});
+
+registerEnumType(ArticleSorter, {
+  name: 'ArticleSorter',
+});

package/src/dto/backstage-article.dto.ts

@@ -0,0 +1,14 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+import { BaseArticleDto } from './base-article.dto';
+
+@ObjectType('BackstageArticle')
+export class BackstageArticleDto extends BaseArticleDto {
+  @Field(() => Int)
+  version: number;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | null;
+
+  @Field(() => Date, { nullable: true })
+  submittedAt?: Date | null;
+}

package/src/dto/backstage-category.dto.ts

@@ -0,0 +1,5 @@
+import { ObjectType } from '@nestjs/graphql';
+import { BaseCategoryDto } from './base-category.dto';
+
+@ObjectType('BackstageCategory')
+export class BackstageCategoryDto extends BaseCategoryDto {}

package/src/dto/base-article.dto.ts

@@ -0,0 +1,19 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('BaseArticle')
+export class BaseArticleDto {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => [String])
+  tags: string[];
+
+  @Field(() => Date)
+  createdAt: Date;
+
+  @Field(() => Date)
+  updatedAt: Date;
+
+  @Field(() => Date, { nullable: true })
+  releasedAt: Date | null;
+}

package/src/dto/base-category.dto.ts

@@ -0,0 +1,13 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('BaseCategory')
+export class BaseCategoryDto {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => Date)
+  createdAt: Date;
+
+  @Field(() => Date)
+  updatedAt: Date;
+}

package/src/dto/categories.args.ts

@@ -0,0 +1,27 @@
+import { ArgsType, Field, ID, registerEnumType } from '@nestjs/graphql';
+import { CategorySorter } from '@rytass/cms-base-nestjs-module';
+
+@ArgsType()
+export class CategoriesArgs {
+  @Field(() => [ID], { nullable: true })
+  parentIds?: string[] | null;
+
+  @Field(() => [ID], { nullable: true })
+  ids?: string[] | null;
+
+  @Field(() => String, { nullable: true })
+  searchTerm?: string | null;
+
+  @Field(() => Boolean, {
+    description: 'If true, return only top level categories',
+    nullable: true,
+  })
+  fromTop?: boolean | null;
+
+  @Field(() => CategorySorter, { nullable: true })
+  sorter?: CategorySorter | null;
+}
+
+registerEnumType(CategorySorter, {
+  name: 'CategorySorter',
+});

package/src/dto/category-multi-language-name.dto.ts

@@ -0,0 +1,10 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('CategoryMultiLanguageName')
+export class CategoryMultiLanguageNameDto {
+  @Field(() => String)
+  language: string;
+
+  @Field(() => String)
+  name: string;
+}

package/src/dto/category-multi-language-name.input.ts

@@ -0,0 +1,10 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+@InputType('CategoryMultiLanguageNameInput')
+export class CategoryMultiLanguageNameInput {
+  @Field(() => String, { nullable: true })
+  language?: string | null;
+
+  @Field(() => String)
+  name: string;
+}

package/src/dto/category.dto.ts

@@ -0,0 +1,8 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { BaseCategoryDto } from './base-category.dto';
+
+@ObjectType('Category')
+export class CategoryDto extends BaseCategoryDto {
+  @Field(() => String)
+  name: string;
+}

package/src/dto/collection.dto.ts

@@ -0,0 +1,13 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('Collection')
+export class Collection {
+  @Field(() => Int)
+  total: number;
+
+  @Field(() => Int)
+  offset: number;
+
+  @Field(() => Int)
+  limit: number;
+}

package/src/dto/create-article.args.ts

@@ -0,0 +1,27 @@
+import { ArgsType, Field, ID } from '@nestjs/graphql';
+import { ArticleVersionContentInput } from './article-version-content.input';
+import { CustomFieldInput } from './custom-field.input';
+
+@ArgsType()
+export class CreateArticleArgs {
+  @Field(() => [ID])
+  categoryIds: string[];
+
+  @Field(() => [String])
+  tags: string[];
+
+  @Field(() => [ArticleVersionContentInput])
+  multiLanguageContents: ArticleVersionContentInput[];
+
+  @Field(() => Date, { nullable: true })
+  releasedAt?: Date | null;
+
+  @Field(() => Boolean, { nullable: true })
+  submitted?: boolean | null;
+
+  @Field(() => String, { nullable: true })
+  signatureLevel?: string | null;
+
+  @Field(() => [CustomFieldInput], { nullable: true })
+  customFields?: CustomFieldInput[];
+}

package/src/dto/create-category.args.ts

@@ -0,0 +1,15 @@
+import { ArgsType, Field, ID } from '@nestjs/graphql';
+import { CategoryMultiLanguageNameInput } from './category-multi-language-name.input';
+import { CustomFieldInput } from './custom-field.input';
+
+@ArgsType()
+export class CreateCategoryArgs {
+  @Field(() => [ID], { nullable: true })
+  parentIds?: string[] | null;
+
+  @Field(() => [CategoryMultiLanguageNameInput])
+  multiLanguageNames: CategoryMultiLanguageNameInput[];
+
+  @Field(() => [CustomFieldInput], { nullable: true })
+  customFields?: CustomFieldInput[];
+}

package/src/dto/custom-field.input.ts

@@ -0,0 +1,10 @@
+import { Field, ID, InputType } from '@nestjs/graphql';
+
+@InputType('CustomFieldInput')
+export class CustomFieldInput {
+  @Field(() => ID)
+  key: string;
+
+  @Field(() => String)
+  value: string;
+}

package/src/dto/update-article.args.ts

@@ -0,0 +1,8 @@
+import { ArgsType, Field, ID } from '@nestjs/graphql';
+import { CreateArticleArgs } from './create-article.args';
+
+@ArgsType()
+export class UpdateArticleArgs extends CreateArticleArgs {
+  @Field(() => ID)
+  id: string;
+}

package/src/dto/update-category.args.ts

@@ -0,0 +1,8 @@
+import { ArgsType, Field, ID } from '@nestjs/graphql';
+import { CreateCategoryArgs } from './create-category.args';
+
+@ArgsType()
+export class UpdateCategoryArgs extends CreateCategoryArgs {
+  @Field(() => ID)
+  id: string;
+}

package/src/dto/user.dto.ts

@@ -0,0 +1,10 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+@ObjectType('User')
+export class UserDto {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => String)
+  account: string;
+}

package/{index.d.ts → src/index.ts}

@@ -1,4 +1,6 @@
 export * from './cms-base-graphql.module';
+
+// GraphQL Types
 export * from './dto/backstage-article.dto';
 export * from './dto/article.dto';
 export * from './dto/article-collection.dto';

package/src/mutations/article.mutations.ts

@@ -0,0 +1,177 @@
+import { ArticleBaseService, DEFAULT_LANGUAGE, MULTIPLE_LANGUAGE_MODE } from '@rytass/cms-base-nestjs-module';
+import { Args, ID, Int, Mutation, Resolver } from '@nestjs/graphql';
+import { BackstageArticleDto } from '../dto/backstage-article.dto';
+import { CreateArticleArgs } from '../dto/create-article.args';
+import { AllowActions, MemberId } from '@rytass/member-base-nestjs-module';
+import { UpdateArticleArgs } from '../dto/update-article.args';
+import { Inject } from '@nestjs/common';
+import { BaseAction } from '../constants/enum/base-action.enum';
+import { BaseResource } from '../constants/enum/base-resource.enum';
+import { MAP_ARTICLE_CUSTOM_FIELDS_TO_ENTITY_COLUMNS } from '../typings/cms-graphql-base-providers';
+import { CustomFieldInput } from '../dto/custom-field.input';
+import { ResolvedCreateArticleArgsDto } from '../typings/dto/resolved-create-article-args.dto';
+
+@Resolver()
+export class ArticleMutations {
+  constructor(
+    @Inject(MULTIPLE_LANGUAGE_MODE)
+    private readonly multiLanguage: boolean,
+    @Inject(MAP_ARTICLE_CUSTOM_FIELDS_TO_ENTITY_COLUMNS)
+    private readonly mapArticleCustomFieldsToEntityColumns: (
+      customFields: CustomFieldInput[],
+    ) => Promise<Record<string, string>>,
+    private readonly articleService: ArticleBaseService,
+  ) {}
+
+  private async resolveCreateArticleArgs(args: CreateArticleArgs): Promise<ResolvedCreateArticleArgsDto> {
+    const extraArgsInput: Record<string, string | object> = {};
+
+    if (args.customFields?.length) {
+      Object.assign(extraArgsInput, await this.mapArticleCustomFieldsToEntityColumns(args.customFields));
+    }
+
+    const basePayload = {
+      categoryIds: args.categoryIds,
+      tags: args.tags,
+      submitted: args.submitted ?? undefined,
+      signatureLevel: args.signatureLevel ?? null,
+      releasedAt: args.releasedAt ?? null,
+      ...extraArgsInput,
+    };
+
+    if (!this.multiLanguage) {
+      const [content] = args.multiLanguageContents;
+
+      return {
+        ...basePayload,
+        title: content.title,
+        content: content.content,
+        description: content.description ?? undefined,
+      };
+    }
+
+    const multiLanguageContents = args.multiLanguageContents.reduce(
+      (vars, content) => ({
+        ...vars,
+        [content.language ?? DEFAULT_LANGUAGE]: {
+          title: content.title,
+          description: content.description,
+          content: content.content,
+        },
+      }),
+      {},
+    );
+
+    return {
+      ...basePayload,
+      multiLanguageContents,
+    };
+  }
+
+  @Mutation(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.CREATE]])
+  async createArticle(@MemberId() memberId: string, @Args() args: CreateArticleArgs): Promise<BackstageArticleDto> {
+    return this.articleService.create({
+      ...(await this.resolveCreateArticleArgs(args)),
+      userId: memberId,
+    });
+  }
+
+  @Mutation(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.UPDATE]])
+  async updateArticle(@MemberId() memberId: string, @Args() args: UpdateArticleArgs): Promise<BackstageArticleDto> {
+    return this.articleService.addVersion(args.id, {
+      ...(await this.resolveCreateArticleArgs(args)),
+      userId: memberId,
+    });
+  }
+
+  @Mutation(() => Boolean)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.DELETE]])
+  async deleteArticle(@Args('id', { type: () => ID }) id: string): Promise<boolean> {
+    await this.articleService.archive(id);
+
+    return true;
+  }
+
+  @Mutation(() => Boolean)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.DELETE_VERSION]])
+  async deleteArticleVersion(
+    @Args('id', { type: () => ID }) id: string,
+    @Args('version', { type: () => Int }) version: number,
+  ): Promise<boolean> {
+    await this.articleService.deleteVersion(id, version);
+
+    return true;
+  }
+
+  @Mutation(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.SUBMIT]])
+  async submitArticle(
+    @MemberId() memberId: string,
+    @Args('id', { type: () => ID }) id: string,
+  ): Promise<BackstageArticleDto> {
+    return this.articleService.submit(id, {
+      userId: memberId,
+    });
+  }
+
+  @Mutation(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.PUT_BACK]])
+  async putBackArticle(
+    @MemberId() _memberId: string,
+    @Args('id', { type: () => ID }) id: string,
+  ): Promise<BackstageArticleDto> {
+    return this.articleService.putBack(id);
+  }
+
+  @Mutation(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.APPROVE]])
+  async approveArticle(
+    @Args('id', { type: () => ID }) id: string,
+    @Args('version', { type: () => Int, nullable: true })
+    version?: number | null,
+  ): Promise<BackstageArticleDto> {
+    const article = await this.articleService.findById(id);
+
+    return this.articleService.approveVersion({
+      id,
+      version: version ?? article.version,
+    });
+  }
+
+  @Mutation(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.REJECT]])
+  async rejectArticle(
+    @Args('id', { type: () => ID }) id: string,
+    @Args('reason', { type: () => String, nullable: true })
+    reason?: string | null,
+  ): Promise<BackstageArticleDto> {
+    return this.articleService.rejectVersion({ id }, { reason });
+  }
+
+  @Mutation(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.RELEASE]])
+  releaseArticle(
+    @MemberId() userId: string,
+    @Args('id', { type: () => ID }) id: string,
+    @Args('releasedAt', { type: () => Date }) releasedAt: Date,
+    @Args('version', { type: () => Int, nullable: true })
+    version?: number | null,
+  ): Promise<BackstageArticleDto> {
+    return this.articleService.release(id, {
+      releasedAt,
+      userId,
+      version: version ?? undefined,
+    });
+  }
+
+  @Mutation(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.WITHDRAW]])
+  withdrawArticle(
+    @Args('id', { type: () => ID }) id: string,
+    @Args('version', { type: () => Int }) version: number,
+  ): Promise<BackstageArticleDto> {
+    return this.articleService.withdraw(id, version);
+  }
+}