@things-factory/notification 8.0.0 → 9.0.0-beta.3

package/server/service/notification/directive-notification.ts

@@ -1,71 +0,0 @@
-import { defaultFieldResolver, GraphQLSchema } from 'graphql'
-import gql from 'graphql-tag'
-
-import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils'
-
-const debug = require('debug')('things-factory:notification:directive-notification')
-
-const DIRECTIVE = 'notification'
-
-export const notificationDirectiveTypeDefs = gql`
-  directive @notification(
-    receivers: String
-    topic: String
-    subject: String # info
-    title: String
-    body: String
-    image: String
-    url: String
-    # timestamp = String(Date.now())
-    mode: String # background
-  ) on FIELD_DEFINITION
-`
-export const directiveNotification = (schema: GraphQLSchema) =>
-  mapSchema(schema, {
-    [MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName, schema) => {
-      const notificationDirective = getDirective(schema, fieldConfig, DIRECTIVE)?.[0]
-      if (notificationDirective) {
-        const { resolve = defaultFieldResolver, args } = fieldConfig
-
-        if (!args) {
-          throw new Error(`Unexpected Error. args should be defined in @notification directive for field ${fieldName}.`)
-        }
-
-        const {
-          receivers,
-          topic,
-          subject = 'info',
-          title,
-          body,
-          image,
-          url,
-          mode = 'background'
-        } = notificationDirective
-        const timestamp = Date.now()
-
-        fieldConfig.resolve = async function (source, args, context, info) {
-          const result = await resolve.call(this, source, args, context, info)
-
-          const { domain, user, notify } = context.state
-
-          if (!notify) {
-            debug('notify not set')
-          } else {
-            try {
-              await notify({
-                receivers: [user.id],
-                notificationDirective,
-                timestamp: new Date()
-              })
-            } catch (err) {
-              debug(err)
-            }
-          }
-
-          return result
-        }
-
-        return fieldConfig
-      }
-    }
-  })

package/server/service/notification/index.ts

@@ -1,14 +0,0 @@
-import { Notification } from './notification'
-import { NotificationQuery } from './notification-query'
-import { NotificationMutation } from './notification-mutation'
-import { NotificationSubscription } from './notification-subscription'
-import { notificationDirectiveTypeDefs, directiveNotification } from './directive-notification'
-
-export const typeDefs = {
-  notificationDirectiveTypeDefs
-}
-export const entities = [Notification]
-export const resolvers = [NotificationQuery, NotificationMutation, NotificationSubscription]
-export const directives = {
-  notification: directiveNotification
-}

package/server/service/notification/notification-mutation.ts

@@ -1,119 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Notification } from './notification'
-import { NewNotification, NotificationPatch } from './notification-type'
-
-@Resolver(Notification)
-export class NotificationMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Notification, { description: 'To create new Notification' })
-  async createNotification(
-    @Arg('notification') notification: NewNotification,
-    @Ctx() context: ResolverContext
-  ): Promise<Notification> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(Notification).save({
-      ...notification,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Notification, { description: 'To modify Notification information' })
-  async updateNotification(
-    @Arg('id') id: string,
-    @Arg('patch') patch: NotificationPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Notification> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Notification)
-    const notification = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...notification,
-      ...patch,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Notification], { description: "To modify multiple Notificationes' information" })
-  async updateMultipleNotification(
-    @Arg('patches', type => [NotificationPatch]) patches: NotificationPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Notification[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const notificationRepo = tx.getRepository(Notification)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await notificationRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const notification = await notificationRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await notificationRepo.save({
-          ...notification,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Notification' })
-  async deleteNotification(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Notification).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Notificationes' })
-  async deleteNotificationes(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Notification).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}

package/server/service/notification/notification-query.ts

@@ -1,76 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam, ScalarDate } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Notification } from './notification'
-import { NotificationList } from './notification-type'
-
-@Resolver(Notification)
-export class NotificationQuery {
-  @Query(returns => Notification!, { nullable: true, description: 'To fetch a Notification' })
-  async notification(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Notification> {
-    const { domain } = context.state
-
-    return await getRepository(Notification).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => NotificationList, { description: 'To fetch multiple Notificationes' })
-  async notificationes(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<NotificationList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Notification),
-      searchables: ['title', 'body']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => NotificationList, { description: 'To fetch my notifications' })
-  async myNotifications(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<NotificationList> {
-    const { domain, user } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      alias: 'nb',
-      repository: await getRepository(Notification),
-      searchables: ['title', 'body']
-    }).andWhere('nb.owner = :user', { user: user.id })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => User)
-  async owner(@Root() notification: Notification): Promise<User> {
-    return notification.ownerId && (await getRepository(User).findOneBy({ id: notification.ownerId }))
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() notification: Notification): Promise<Domain> {
-    return notification.domainId && (await getRepository(Domain).findOneBy({ id: notification.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() notification: Notification): Promise<User> {
-    return notification.updaterId && (await getRepository(User).findOneBy({ id: notification.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() notification: Notification): Promise<User> {
-    return notification.creatorId && (await getRepository(User).findOneBy({ id: notification.creatorId }))
-  }
-}

package/server/service/notification/notification-subscription.ts

@@ -1,44 +0,0 @@
-import { filter, pipe } from 'graphql-yoga'
-import { Arg, Resolver, FieldResolver, Root, Subscription } from 'type-graphql'
-
-import { pubsub, ScalarDate } from '@things-factory/shell'
-
-import { Notification } from './notification'
-
-@Resolver(Notification)
-export class NotificationSubscription {
-  @Subscription({
-    subscribe: ({ args, context, info }) => {
-      const { subjects = [] } = args
-
-      return pipe(
-        pubsub.subscribe('notification'),
-        filter(async (payload: { notification: Notification }) => {
-          /* normally, subscription context doesn't have domain */
-          const { domain, user } = context.state
-
-          const {
-            notification: { subject, domain: pdomain }
-          } = payload
-
-          const subdomain = pdomain?.subdomain
-
-          if (subdomain) {
-            if (domain?.subdomain) {
-              if (subdomain !== domain.subdomain) {
-                return false
-              }
-            } else if (!user.domains.find(d => d.subdomain === subdomain)) {
-              return false
-            }
-          }
-
-          return !subject || subjects.indexOf(subject) !== -1
-        })
-      )
-    }
-  })
-  notification(@Root() payload: { notification: Notification }, @Arg('subjects', type => [String], { nullable: true }) subjects: string[]): Notification {
-    return payload.notification
-  }
-}

package/server/service/notification/notification-type.ts

@@ -1,55 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-import { ScalarObject } from '@things-factory/shell'
-
-import { Notification, NotificationStatus } from './notification'
-
-@InputType()
-export class NewNotification {
-  @Field({ nullable: true })
-  ownerId?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  subject?: string
-
-  @Field({ nullable: true })
-  title?: string
-
-  @Field({ nullable: true })
-  body?: string
-
-  @Field({ nullable: true })
-  url?: string
-
-  @Field({ nullable: true })
-  image?: string
-
-  @Field(type => ScalarObject, { nullable: true })
-  property?: any
-
-  @Field({ nullable: true })
-  timestamp?: Date
-}
-
-@InputType()
-export class NotificationPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field(type => NotificationStatus, { nullable: true })
-  state?: NotificationStatus
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class NotificationList {
-  @Field(type => [Notification])
-  items: Notification[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/notification/notification.ts

@@ -1,105 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain, ScalarObject, ScalarDate } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-export enum NotificationStatus {
-  NOTREAD = 'UNREAD',
-  READ = 'READ'
-}
-
-registerEnumType(NotificationStatus, {
-  name: 'NotificationStatus',
-  description: 'state enumeration of a notification'
-})
-
-@Entity()
-@Index('ix_notification_0', (notification: Notification) => [notification.domain, notification.type], { unique: false })
-@ObjectType({ description: 'Entity for Notification' })
-export class Notification {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((notification: Notification) => notification.domain)
-  domainId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  owner?: User
-
-  @RelationId((notification: Notification) => notification.owner)
-  ownerId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  type?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  subject?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  title?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  body?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  url?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  image?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: NotificationStatus
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  property?: any
-
-  @Column('date', { nullable: true })
-  @Field(type => ScalarDate, { nullable: true })
-  timestamp?: Date
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((notification: Notification) => notification.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((notification: Notification) => notification.updater)
-  updaterId?: string
-}

package/server/service/notification-rule/event-subscriber.ts

@@ -1,20 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-
-import { NotificationRule } from './notification-rule'
-import { NotificationRuleHistory } from './notification-rule-history'
-
-@EventSubscriber()
-export class NotificationRuleHistoryEntitySubscriber extends HistoryEntitySubscriber<
-  NotificationRule,
-  NotificationRuleHistory
-> {
-  public get entity() {
-    return NotificationRule
-  }
-
-  public get historyEntity() {
-    return NotificationRuleHistory
-  }
-}

package/server/service/notification-rule/index.ts

@@ -1,9 +0,0 @@
-import { NotificationRule } from './notification-rule'
-import { NotificationRuleHistory } from './notification-rule-history'
-import { NotificationRuleQuery } from './notification-rule-query'
-import { NotificationRuleMutation } from './notification-rule-mutation'
-import { NotificationRuleHistoryEntitySubscriber } from './event-subscriber'
-
-export const entities = [NotificationRule, NotificationRuleHistory]
-export const resolvers = [NotificationRuleQuery, NotificationRuleMutation]
-export const subscribers = [NotificationRuleHistoryEntitySubscriber]

package/server/service/notification-rule/notification-rule-history.ts

@@ -1,136 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
-
-import {
-  HistoryActionColumn,
-  HistoryActionType,
-  HistoryEntityInterface,
-  HistoryOriginalIdColumn
-} from '@operato/typeorm-history'
-import { Role, User } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-import { Domain } from '@things-factory/shell'
-
-import { NotificationRule, NotificationRuleStatus, RecipientItem } from './notification-rule'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index(
-  'ix_notification-rule_history_0',
-  (notificationRuleHistory: NotificationRuleHistory) => [
-    notificationRuleHistory.originalId,
-    notificationRuleHistory.version
-  ],
-  { unique: true }
-)
-@Index(
-  'ix_notification-rule_history_1',
-  (notificationRuleHistory: NotificationRuleHistory) => [
-    notificationRuleHistory.domain,
-    notificationRuleHistory.originalId,
-    notificationRuleHistory.version
-  ],
-  { unique: true }
-)
-@ObjectType({ description: 'History Entity of NotificationRule' })
-export class NotificationRuleHistory implements HistoryEntityInterface<NotificationRule> {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({ nullable: true, default: 1 })
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((notificationRule: NotificationRule) => notificationRule.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: NotificationRuleStatus
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  title: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  body: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  url: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  thumbnail: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  channels: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [RecipientItem], { nullable: true, description: 'notification recipients.' })
-  recipients: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((notificationRule: NotificationRule) => notificationRule.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((notificationRule: NotificationRule) => notificationRule.updater)
-  updaterId?: string
-
-  @HistoryOriginalIdColumn()
-  public originalId!: string
-
-  @HistoryActionColumn({
-    nullable: false,
-    type:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'enum'
-        : DATABASE_TYPE == 'oracle'
-          ? 'varchar2'
-          : DATABASE_TYPE == 'mssql'
-            ? 'nvarchar'
-            : 'varchar',
-    enum:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? HistoryActionType
-        : undefined,
-    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 10
-  })
-  public action!: HistoryActionType
-}