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

package/src/mutations/category.mutations.ts

@@ -0,0 +1,78 @@
+import { Args, ID, Mutation, Resolver } from '@nestjs/graphql';
+import { CategoryBaseService, MULTIPLE_LANGUAGE_MODE } from '@rytass/cms-base-nestjs-module';
+import { CreateCategoryArgs } from '../dto/create-category.args';
+import { AllowActions } from '@rytass/member-base-nestjs-module';
+import { BackstageCategoryDto } from '../dto/backstage-category.dto';
+import { UpdateCategoryArgs } from '../dto/update-category.args';
+import { Inject } from '@nestjs/common';
+import { BaseAction } from '../constants/enum/base-action.enum';
+import { BaseResource } from '../constants/enum/base-resource.enum';
+import { MAP_CATEGORY_CUSTOM_FIELDS_TO_ENTITY_COLUMNS } from '../typings/cms-graphql-base-providers';
+import { CustomFieldInput } from '../dto/custom-field.input';
+import { ResolvedCreateCategoryArgsDto } from '../typings/dto/resolved-create-category-args.dto';
+
+@Resolver()
+export class CategoryMutations {
+  constructor(
+    @Inject(MULTIPLE_LANGUAGE_MODE)
+    private readonly multiLanguage: boolean,
+    @Inject(MAP_CATEGORY_CUSTOM_FIELDS_TO_ENTITY_COLUMNS)
+    private readonly mapCategoryCustomFieldsToEntityColumns: (
+      customFields: CustomFieldInput[],
+    ) => Promise<Record<string, string>>,
+    private readonly categoryService: CategoryBaseService,
+  ) {}
+
+  private async resolveCreateCategoryArgs(args: CreateCategoryArgs): Promise<ResolvedCreateCategoryArgsDto> {
+    const extraArgsInput: Record<string, string | object> = {};
+
+    if (args.customFields?.length) {
+      Object.assign(extraArgsInput, await this.mapCategoryCustomFieldsToEntityColumns(args.customFields));
+    }
+
+    const basePayload = {
+      parentIds: args.parentIds,
+      ...extraArgsInput,
+    };
+
+    if (!this.multiLanguage) {
+      const [content] = args.multiLanguageNames;
+
+      return {
+        ...basePayload,
+        name: content.name,
+      };
+    }
+
+    const multiLanguageNames = Object.fromEntries(args.multiLanguageNames.map(name => [name.language, name.name]));
+
+    return {
+      ...basePayload,
+      multiLanguageNames,
+    };
+  }
+
+  @Mutation(() => BackstageCategoryDto)
+  @AllowActions([[BaseResource.CATEGORY, BaseAction.CREATE]])
+  async createCategory(@Args() args: CreateCategoryArgs): Promise<BackstageCategoryDto> {
+    return this.categoryService.create({
+      ...(await this.resolveCreateCategoryArgs(args)),
+    });
+  }
+
+  @Mutation(() => BackstageCategoryDto)
+  @AllowActions([[BaseResource.CATEGORY, BaseAction.UPDATE]])
+  async updateCategory(@Args() args: UpdateCategoryArgs): Promise<BackstageCategoryDto> {
+    return this.categoryService.update(args.id, {
+      ...(await this.resolveCreateCategoryArgs(args)),
+    });
+  }
+
+  @Mutation(() => Boolean)
+  @AllowActions([[BaseResource.CATEGORY, BaseAction.DELETE]])
+  async deleteCategory(@Args('id', { type: () => ID }) id: string): Promise<boolean> {
+    await this.categoryService.archive(id);
+
+    return true;
+  }
+}

package/src/queries/article.queries.ts

@@ -0,0 +1,71 @@
+import { Args, ID, Int, Query, Resolver } from '@nestjs/graphql';
+import {
+  ArticleBaseService,
+  ArticleSorter,
+  ArticleStage,
+  DEFAULT_LANGUAGE,
+  MULTIPLE_LANGUAGE_MODE,
+  SingleArticleBaseDto,
+} from '@rytass/cms-base-nestjs-module';
+import { ArticlesArgs } from '../dto/articles.args';
+import { AllowActions, IsPublic } from '@rytass/member-base-nestjs-module';
+import { Language } from '../decorators/language.decorator';
+import { ArticleCollectionDto } from '../dto/article-collection.dto';
+import { ArticleDto } from '../dto/article.dto';
+import { BackstageArticleDto } from '../dto/backstage-article.dto';
+import { BackstageArticleCollectionDto } from '../dto/backstage-article-collection.dto';
+import { Inject } from '@nestjs/common';
+import { BackstageArticleArgs } from '../dto/backstage-article.args';
+import { BaseAction } from '../constants/enum/base-action.enum';
+import { BaseResource } from '../constants/enum/base-resource.enum';
+
+@Resolver()
+export class ArticleQueries {
+  constructor(
+    private readonly articleService: ArticleBaseService,
+    @Inject(MULTIPLE_LANGUAGE_MODE)
+    private readonly multiLanguage: boolean,
+  ) {}
+
+  @Query(() => ArticleDto)
+  @IsPublic()
+  article(
+    @Args('id', { type: () => ID }) id: string,
+    @Language() language: string = DEFAULT_LANGUAGE,
+  ): Promise<ArticleDto> {
+    return this.articleService.findById(id, {
+      stage: ArticleStage.RELEASED,
+      language: this.multiLanguage ? (language ?? DEFAULT_LANGUAGE) : undefined,
+    }) as Promise<SingleArticleBaseDto>;
+  }
+
+  @Query(() => ArticleCollectionDto)
+  @IsPublic()
+  async articles(
+    @Args() args: ArticlesArgs,
+    @Language() language: string = DEFAULT_LANGUAGE,
+  ): Promise<ArticleCollectionDto> {
+    return this.articleService.findCollection({
+      ...args,
+      stage: ArticleStage.RELEASED,
+      language: this.multiLanguage ? (language ?? DEFAULT_LANGUAGE) : undefined,
+      sorter: ArticleSorter.RELEASED_AT_DESC,
+    }) as Promise<ArticleCollectionDto>;
+  }
+
+  @Query(() => BackstageArticleDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.READ]])
+  async backstageArticle(
+    @Args('id', { type: () => ID }) id: string,
+    @Args('version', { type: () => Int, nullable: true })
+    version?: number | null,
+  ): Promise<BackstageArticleDto> {
+    return this.articleService.findById(id, { version });
+  }
+
+  @Query(() => BackstageArticleCollectionDto)
+  @AllowActions([[BaseResource.ARTICLE, BaseAction.LIST]])
+  backstageArticles(@Args() args: BackstageArticleArgs): Promise<BackstageArticleCollectionDto> {
+    return this.articleService.findCollection(args);
+  }
+}

package/src/queries/category.queries.ts

@@ -0,0 +1,53 @@
+import { Args, ID, Query, Resolver } from '@nestjs/graphql';
+import { CategoryBaseService, DEFAULT_LANGUAGE, MULTIPLE_LANGUAGE_MODE } from '@rytass/cms-base-nestjs-module';
+import { CategoriesArgs } from '../dto/categories.args';
+import { AllowActions, IsPublic } from '@rytass/member-base-nestjs-module';
+import { CategoryDto } from '../dto/category.dto';
+import { Language } from '../decorators/language.decorator';
+import { BackstageCategoryDto } from '../dto/backstage-category.dto';
+import { Inject } from '@nestjs/common';
+import { BaseAction } from '../constants/enum/base-action.enum';
+import { BaseResource } from '../constants/enum/base-resource.enum';
+
+@Resolver()
+export class CategoryQueries {
+  constructor(
+    @Inject(MULTIPLE_LANGUAGE_MODE)
+    private readonly multiLanguage: boolean,
+    private readonly categoryService: CategoryBaseService,
+  ) {}
+
+  @Query(() => CategoryDto)
+  @IsPublic()
+  async category(
+    @Args('id', { type: () => ID }) id: string,
+    @Language() language: string = DEFAULT_LANGUAGE,
+  ): Promise<CategoryDto> {
+    if (this.multiLanguage) {
+      return this.categoryService.findById(id, language);
+    }
+
+    return this.categoryService.findById(id) as Promise<CategoryDto>;
+  }
+
+  @Query(() => [CategoryDto])
+  @IsPublic()
+  categories(@Args() args: CategoriesArgs, @Language() language: string = DEFAULT_LANGUAGE): Promise<CategoryDto[]> {
+    return this.categoryService.findAll({
+      ...args,
+      language: this.multiLanguage ? language : null,
+    }) as Promise<CategoryDto[]>;
+  }
+
+  @Query(() => BackstageCategoryDto)
+  @AllowActions([[BaseResource.CATEGORY, BaseAction.READ]])
+  backstageCategory(@Args('id', { type: () => ID }) id: string): Promise<BackstageCategoryDto> {
+    return this.categoryService.findById(id);
+  }
+
+  @Query(() => [BackstageCategoryDto])
+  @AllowActions([[BaseResource.CATEGORY, BaseAction.LIST]])
+  backstageCategories(@Args() args: CategoriesArgs): Promise<BackstageCategoryDto[]> {
+    return this.categoryService.findAll(args);
+  }
+}

package/src/resolvers/article-signature.resolver.ts

@@ -0,0 +1,29 @@
+import { ResolveField, Resolver, Root } from '@nestjs/graphql';
+import { ArticleSignatureDto } from '../dto/article-signature.dto';
+import { UserDto } from '../dto/user.dto';
+import { Authenticated } from '@rytass/member-base-nestjs-module';
+import { MemberDataLoader } from '../data-loaders/members.dataloader';
+import { ArticleSignatureEntity, DEFAULT_SIGNATURE_LEVEL } from '@rytass/cms-base-nestjs-module';
+import { ArticleSignatureStepDto } from '../dto/article-signature-step.dto';
+
+@Resolver(() => ArticleSignatureDto)
+export class ArticleSignatureResolver {
+  constructor(private readonly memberDataloader: MemberDataLoader) {}
+
+  @ResolveField(() => UserDto, { nullable: true })
+  @Authenticated()
+  signer(@Root() signature: ArticleSignatureEntity): Promise<UserDto | null> | null {
+    return signature.signerId ? this.memberDataloader.loader.load(signature.signerId) : null;
+  }
+
+  @ResolveField(() => ArticleSignatureStepDto)
+  @Authenticated()
+  step(@Root() signature: ArticleSignatureEntity): ArticleSignatureStepDto {
+    return (
+      signature.signatureLevel ?? {
+        id: DEFAULT_SIGNATURE_LEVEL,
+        name: DEFAULT_SIGNATURE_LEVEL,
+      }
+    );
+  }
+}

package/src/resolvers/article.resolver.ts

@@ -0,0 +1,41 @@
+import { ResolveField, Resolver, Root } from '@nestjs/graphql';
+import { ArticleDto } from '../dto/article.dto';
+import { MemberDataLoader } from '../data-loaders/members.dataloader';
+import { UserDto } from '../dto/user.dto';
+import { IsPublic } from '@rytass/member-base-nestjs-module';
+import { DEFAULT_LANGUAGE, MULTIPLE_LANGUAGE_MODE, type ArticleBaseDto } from '@rytass/cms-base-nestjs-module';
+import { CategoryDto } from '../dto/category.dto';
+import { ArticleDataLoader } from '../data-loaders/article.dataloader';
+import { Language } from '../decorators/language.decorator';
+import { Inject } from '@nestjs/common';
+
+@Resolver(() => ArticleDto)
+export class ArticleResolver {
+  constructor(
+    private readonly memberDataloader: MemberDataLoader,
+    private readonly articleDataloader: ArticleDataLoader,
+    @Inject(MULTIPLE_LANGUAGE_MODE)
+    private readonly multiLanguage: boolean,
+  ) {}
+
+  @ResolveField(() => String)
+  @IsPublic()
+  articleId(@Root() article: ArticleBaseDto): string {
+    return article.id.split(':')[0];
+  }
+
+  @ResolveField(() => UserDto, { nullable: true })
+  @IsPublic()
+  releasedBy(@Root() article: ArticleBaseDto): Promise<UserDto | null> | null {
+    return article.releasedBy ? this.memberDataloader.loader.load(article.releasedBy) : null;
+  }
+
+  @ResolveField(() => [CategoryDto])
+  @IsPublic()
+  categories(@Root() article: ArticleBaseDto, @Language() language: string = DEFAULT_LANGUAGE): Promise<CategoryDto[]> {
+    return this.articleDataloader.categoriesLoader.load({
+      articleId: article.id,
+      language: this.multiLanguage ? language : DEFAULT_LANGUAGE,
+    });
+  }
+}

package/src/resolvers/backstage-article.resolver.ts

@@ -0,0 +1,161 @@
+import { ID, ResolveField, Resolver, Root } from '@nestjs/graphql';
+import { MemberDataLoader } from '../data-loaders/members.dataloader';
+import { UserDto } from '../dto/user.dto';
+import { Authenticated } from '@rytass/member-base-nestjs-module';
+import {
+  ArticleSignatureDataLoader,
+  ArticleStage,
+  ArticleVersionDataLoader,
+  DEFAULT_LANGUAGE,
+  MULTIPLE_LANGUAGE_MODE,
+  ArticleDataLoader as ModuleArticleDataLoader,
+  type ArticleBaseDto,
+} from '@rytass/cms-base-nestjs-module';
+import { CategoryDto } from '../dto/category.dto';
+import { ArticleDataLoader } from '../data-loaders/article.dataloader';
+import { Language } from '../decorators/language.decorator';
+import { BadRequestException, Inject } from '@nestjs/common';
+import { BackstageArticleDto } from '../dto/backstage-article.dto';
+import { ArticleMultiLanguageContentDto } from '../dto/article-multi-language-content.dto';
+import { QuadratsContentScalar } from '../scalars/quadrats-element.scalar';
+import { QuadratsElement } from '@quadrats/core';
+import { ArticleStageVersionDto } from '../dto/article-stage-version.dto';
+import { ArticleSignatureDto } from '../dto/article-signature.dto';
+
+@Resolver(() => BackstageArticleDto)
+export class BackstageArticleResolver {
+  constructor(
+    private readonly memberDataloader: MemberDataLoader,
+    private readonly articleDataloader: ArticleDataLoader,
+    @Inject(MULTIPLE_LANGUAGE_MODE)
+    private readonly multiLanguage: boolean,
+    private readonly articleVersionDataLoader: ArticleVersionDataLoader,
+    private readonly moduleArticleDataLoader: ModuleArticleDataLoader,
+    private readonly versionSignaturesLoader: ArticleSignatureDataLoader,
+  ) {}
+
+  @ResolveField(() => ID)
+  @Authenticated()
+  id(@Root() article: ArticleBaseDto): string {
+    return `${article.id}:${article.version}`;
+  }
+
+  @ResolveField(() => String)
+  @Authenticated()
+  articleId(@Root() article: ArticleBaseDto): string {
+    return article.id;
+  }
+
+  @ResolveField(() => UserDto, { nullable: true })
+  @Authenticated()
+  submittedBy(@Root() article: ArticleBaseDto): Promise<UserDto | null> | null {
+    return article.submittedBy ? this.memberDataloader.loader.load(article.submittedBy) : null;
+  }
+
+  @ResolveField(() => UserDto, { nullable: true })
+  @Authenticated()
+  lastEditor(@Root() article: ArticleBaseDto): Promise<UserDto | null> | null {
+    return article.updatedBy ? this.memberDataloader.loader.load(article.updatedBy) : null;
+  }
+
+  @ResolveField(() => UserDto, { nullable: true })
+  @Authenticated()
+  releasedBy(@Root() article: ArticleBaseDto): Promise<UserDto | null> | null {
+    return article.releasedBy ? this.memberDataloader.loader.load(article.releasedBy) : null;
+  }
+
+  @ResolveField(() => [CategoryDto])
+  @Authenticated()
+  categories(@Root() article: ArticleBaseDto, @Language() language: string = DEFAULT_LANGUAGE): Promise<CategoryDto[]> {
+    return this.articleDataloader.categoriesLoaderNoCache.load({
+      articleId: article.id,
+      language: this.multiLanguage ? language : DEFAULT_LANGUAGE,
+    });
+  }
+
+  @ResolveField(() => String)
+  @Authenticated()
+  title(@Root() article: ArticleBaseDto): string {
+    if ('title' in article && !this.multiLanguage) {
+      return article.title;
+    }
+
+    throw new BadRequestException('Title field is not available in multi-language mode.');
+  }
+
+  @ResolveField(() => String, { nullable: true })
+  @Authenticated()
+  description(@Root() article: ArticleBaseDto): string | null {
+    if ('description' in article && !this.multiLanguage) {
+      return article.description ?? null;
+    }
+
+    throw new BadRequestException('Description field is not available in multi-language mode.');
+  }
+
+  @ResolveField(() => QuadratsContentScalar)
+  @Authenticated()
+  content(@Root() article: ArticleBaseDto): QuadratsElement[] {
+    if ('content' in article && !this.multiLanguage) {
+      return article.content;
+    }
+
+    throw new BadRequestException('Content field is not available in multi-language mode.');
+  }
+
+  @ResolveField(() => [ArticleMultiLanguageContentDto])
+  @Authenticated()
+  multiLanguageContents(@Root() article: ArticleBaseDto): ArticleMultiLanguageContentDto[] {
+    if ('multiLanguageContents' in article) {
+      return article.multiLanguageContents;
+    }
+
+    return [
+      {
+        language: DEFAULT_LANGUAGE,
+        title: article.title,
+        description: article.description,
+        content: article.content,
+      },
+    ];
+  }
+
+  @ResolveField(() => [BackstageArticleDto])
+  @Authenticated()
+  versions(@Root() article: ArticleBaseDto): Promise<BackstageArticleDto[]> {
+    return this.articleVersionDataLoader.versionsLoader.load(article.id);
+  }
+
+  @ResolveField(() => ArticleStage)
+  @Authenticated()
+  stage(@Root() article: ArticleBaseDto): Promise<ArticleStage> {
+    return this.moduleArticleDataLoader.stageLoader.load({
+      id: article.id,
+      version: article.version,
+    });
+  }
+
+  @ResolveField(() => [ArticleSignatureDto])
+  @Authenticated()
+  signatures(@Root() article: ArticleBaseDto): Promise<ArticleSignatureDto[]> {
+    return this.versionSignaturesLoader.versionSignaturesLoader.load({
+      id: article.id,
+      version: article.version,
+    });
+  }
+
+  @ResolveField(() => ArticleStageVersionDto)
+  @Authenticated()
+  async stageVersions(@Root() article: ArticleBaseDto): Promise<ArticleStageVersionDto> {
+    const versions = await this.articleVersionDataLoader.stageVersionsLoader.load(article.id);
+
+    return {
+      id: article.id,
+      draft: versions[ArticleStage.DRAFT] ?? null,
+      reviewing: versions[ArticleStage.REVIEWING] ?? null,
+      verified: versions[ArticleStage.VERIFIED] ?? null,
+      scheduled: versions[ArticleStage.SCHEDULED] ?? null,
+      released: versions[ArticleStage.RELEASED] ?? null,
+    };
+  }
+}

package/src/resolvers/backstage-category.resolver.ts

@@ -0,0 +1,40 @@
+import { ResolveField, Resolver, Root } from '@nestjs/graphql';
+import { Authenticated } from '@rytass/member-base-nestjs-module';
+import { type CategoryBaseDto, DEFAULT_LANGUAGE, MULTIPLE_LANGUAGE_MODE } from '@rytass/cms-base-nestjs-module';
+
+import { BadRequestException, Inject } from '@nestjs/common';
+import { CategoryMultiLanguageNameDto } from '../dto/category-multi-language-name.dto';
+import { BackstageCategoryDto } from '../dto/backstage-category.dto';
+
+@Resolver(() => BackstageCategoryDto)
+export class BackstageCategoryResolver {
+  constructor(
+    @Inject(MULTIPLE_LANGUAGE_MODE)
+    private readonly multiLanguage: boolean,
+  ) {}
+
+  @ResolveField(() => String)
+  @Authenticated()
+  name(@Root() category: CategoryBaseDto): string {
+    if ('name' in category && !this.multiLanguage) {
+      return category.name;
+    }
+
+    throw new BadRequestException('Name field is not available in multi-language mode.');
+  }
+
+  @ResolveField(() => [CategoryMultiLanguageNameDto])
+  @Authenticated()
+  multiLanguageNames(@Root() category: CategoryBaseDto): CategoryMultiLanguageNameDto[] {
+    if ('multiLanguageNames' in category) {
+      return category.multiLanguageNames;
+    }
+
+    return [
+      {
+        language: DEFAULT_LANGUAGE,
+        name: category.name,
+      },
+    ];
+  }
+}

package/src/scalars/quadrats-element.scalar.ts

@@ -0,0 +1,56 @@
+import { BadRequestException, InternalServerErrorException, Logger } from '@nestjs/common';
+import { QuadratsElement } from '@quadrats/core';
+import { GraphQLScalarType, Kind, ValueNode } from 'graphql';
+
+export const QuadratsContentScalar = new GraphQLScalarType({
+  name: 'QuadratsContent',
+  description: 'QuadratsContent custom scalar type (as JSON string)',
+
+  parseValue: (value: unknown): QuadratsElement => {
+    if (typeof value === 'string') {
+      let parsedValue: QuadratsElement;
+
+      try {
+        parsedValue = JSON.parse(value);
+      } catch (error) {
+        Logger.error(`Error parsing QuadratsContent (parseValue): ${error}`);
+
+        throw new InternalServerErrorException('Invalid QuadratsElement value');
+      }
+
+      if (!Array.isArray(parsedValue)) {
+        throw new BadRequestException('Expected a JSON string for QuadratsContent');
+      }
+
+      return parsedValue;
+    }
+
+    throw new BadRequestException('Expected a JSON string for QuadratsContent');
+  },
+
+  serialize: (value: unknown): string => {
+    if (typeof value === 'string') {
+      return value;
+    }
+
+    try {
+      return JSON.stringify(value);
+    } catch (error) {
+      Logger.error(`Error serializing QuadratsContent: ${error}`);
+      throw new InternalServerErrorException('Error serializing QuadratsElement');
+    }
+  },
+
+  parseLiteral: (ast: ValueNode): QuadratsElement => {
+    try {
+      if (ast.kind === Kind.STRING) {
+        return JSON.parse(ast.value);
+      }
+    } catch (error) {
+      Logger.error(`Error parsing QuadratsContent (parseLiteral): ${error}`);
+      throw new InternalServerErrorException('Invalid QuadratsElement value');
+    }
+
+    throw new Error('Expected string literal for QuadratsContent');
+  },
+});

package/src/typings/cms-graphql-base-providers.ts

@@ -0,0 +1,3 @@
+export const CMS_BASE_GRAPHQL_MODULE_OPTIONS = Symbol('CMS_BASE_GRAPHQL_MODULE_OPTIONS');
+export const MAP_ARTICLE_CUSTOM_FIELDS_TO_ENTITY_COLUMNS = Symbol('MAP_ARTICLE_CUSTOM_FIELDS_TO_ENTITY_COLUMNS');
+export const MAP_CATEGORY_CUSTOM_FIELDS_TO_ENTITY_COLUMNS = Symbol('MAP_CATEGORY_CUSTOM_FIELDS_TO_ENTITY_COLUMNS');

package/{typings/cms-graphql-base-root-module-async-options.dto.d.ts → src/typings/cms-graphql-base-root-module-async-options.dto.ts}

@@ -1,9 +1,11 @@
 import { InjectionToken, ModuleMetadata, OptionalFactoryDependency, Type } from '@nestjs/common';
 import { CMSGraphqlBaseModuleOptionFactory } from './cms-graphql-base-root-module-option-factory';
 import { CMSGraphqlBaseModuleOptionsDto } from './cms-graphql-base-root-module-options.dto';
+
 export interface CMSGraphqlBaseModuleAsyncOptionsDto extends Pick<ModuleMetadata, 'imports'> {
-    useFactory?: (...args: any[]) => Promise<CMSGraphqlBaseModuleOptionsDto> | CMSGraphqlBaseModuleOptionsDto;
-    inject?: (InjectionToken | OptionalFactoryDependency)[];
-    useClass?: Type<CMSGraphqlBaseModuleOptionFactory>;
-    useExisting?: Type<CMSGraphqlBaseModuleOptionFactory>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  useFactory?: (...args: any[]) => Promise<CMSGraphqlBaseModuleOptionsDto> | CMSGraphqlBaseModuleOptionsDto;
+  inject?: (InjectionToken | OptionalFactoryDependency)[];
+  useClass?: Type<CMSGraphqlBaseModuleOptionFactory>;
+  useExisting?: Type<CMSGraphqlBaseModuleOptionFactory>;
 }

package/{typings/cms-graphql-base-root-module-option-factory.d.ts → src/typings/cms-graphql-base-root-module-option-factory.ts}

@@ -1,4 +1,5 @@
 import { CMSGraphqlBaseModuleOptionsDto } from './cms-graphql-base-root-module-options.dto';
+
 export interface CMSGraphqlBaseModuleOptionFactory {
-    createCMSOptions(): Promise<CMSGraphqlBaseModuleOptionsDto> | CMSGraphqlBaseModuleOptionsDto;
+  createCMSOptions(): Promise<CMSGraphqlBaseModuleOptionsDto> | CMSGraphqlBaseModuleOptionsDto;
 }

package/src/typings/cms-graphql-base-root-module-options.dto.ts

@@ -0,0 +1,11 @@
+import { CMSBaseModuleOptionsDto } from '@rytass/cms-base-nestjs-module';
+import { CustomFieldInput } from '../dto/custom-field.input';
+
+export interface CMSGraphqlBaseModuleOptionsDto extends CMSBaseModuleOptionsDto {
+  mapArticleCustomFieldsToEntityColumns?: (
+    customFields: CustomFieldInput[],
+  ) => Promise<Record<string, string | object>> | Record<string, string | object>;
+  mapCategoryCustomFieldsToEntityColumns?: (
+    customFields: CustomFieldInput[],
+  ) => Promise<Record<string, string | object>> | Record<string, string | object>;
+}

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

@@ -0,0 +1,33 @@
+import { QuadratsElement } from '@quadrats/core';
+import { CustomFieldValue } from '../custom-field-value.type';
+
+type BaseResolvedCreateArticleArgsDto = {
+  categoryIds: string[];
+  tags: string[];
+  submitted?: boolean;
+  signatureLevel?: string | null;
+  releasedAt?: Date | null;
+  // Allow additional custom fields
+  [key: string]: CustomFieldValue;
+};
+
+export type SingleLanguageResolvedCreateArticleArgsDto = BaseResolvedCreateArticleArgsDto & {
+  title: string;
+  content: QuadratsElement[];
+  description?: string;
+};
+
+export type MultiLanguageResolvedCreateArticleArgsDto = BaseResolvedCreateArticleArgsDto & {
+  multiLanguageContents: Record<
+    string,
+    {
+      title: string;
+      description?: string;
+      content: QuadratsElement[];
+    }
+  >;
+};
+
+export type ResolvedCreateArticleArgsDto =
+  | SingleLanguageResolvedCreateArticleArgsDto
+  | MultiLanguageResolvedCreateArticleArgsDto;

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

@@ -0,0 +1,19 @@
+import { CustomFieldValue } from '../custom-field-value.type';
+
+type BaseResolvedCreateCategoryArgsDto = {
+  parentIds?: string[] | null;
+  // Allow additional custom fields
+  [key: string]: CustomFieldValue;
+};
+
+export type SingleLanguageResolvedCreateCategoryArgsDto = BaseResolvedCreateCategoryArgsDto & {
+  name: string;
+};
+
+export type MultiLanguageResolvedCreateCategoryArgsDto = BaseResolvedCreateCategoryArgsDto & {
+  multiLanguageNames: Record<string, string>;
+};
+
+export type ResolvedCreateCategoryArgsDto =
+  | SingleLanguageResolvedCreateCategoryArgsDto
+  | MultiLanguageResolvedCreateCategoryArgsDto;

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.node.json",
+  "compilerOptions": {
+    "rootDir": "./src"
+  },
+  "exclude": ["**/*.spec.*"],
+  "include": ["./src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Rytass Co. Ltd.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/cms-base-graphql.module.d.ts

@@ -1,9 +0,0 @@
-import { DynamicModule } from '@nestjs/common';
-import { CMSGraphqlBaseModuleOptionsDto } from './typings/cms-graphql-base-root-module-options.dto';
-import { CMSGraphqlBaseModuleAsyncOptionsDto } from './typings/cms-graphql-base-root-module-async-options.dto';
-export declare class CMSBaseGraphQLModule {
-    static forRootAsync(options: CMSGraphqlBaseModuleAsyncOptionsDto): DynamicModule;
-    static forRoot(options: CMSGraphqlBaseModuleOptionsDto): DynamicModule;
-    private static createAsyncProvider;
-    private static createAsyncOptionsProvider;
-}