@things-factory/attachment-base 8.0.0-beta.8 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/attachment-base",
-  "version": "8.0.0-beta.8",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -29,11 +29,11 @@
     "@aws-sdk/s3-presigned-post": "^3.46.0",
     "@azure/storage-blob": "^12.18.0",
     "@koa/multer": "^3.0.0",
-    "@things-factory/auth-base": "^8.0.0-beta.8",
-    "@things-factory/env": "^8.0.0-beta.4",
-    "@things-factory/shell": "^8.0.0-beta.5",
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/env": "^8.0.0",
+    "@things-factory/shell": "^8.0.0",
     "mime": "^3.0.0",
     "multer": "^1.4.5-lts.1"
   },
-  "gitHead": "bf5206511b2d84dfb95edc3dae7f54f6cbb9bcca"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/attachment-const.ts

@@ -0,0 +1,5 @@
+import { config } from '@things-factory/env'
+
+export var STORAGE: any = config.get('storage')
+export var AWBSTORAGE: any = config.get('awbFileStorage')
+export const ATTACHMENT_PATH: string = config.get('attachmentPath', 'attachment')

package/server/awb-storage-s3.ts

@@ -0,0 +1,44 @@
+import { S3Client } from '@aws-sdk/client-s3'
+import { Upload } from '@aws-sdk/lib-storage'
+import { logger } from '@things-factory/env'
+
+import { AWBSTORAGE } from './attachment-const'
+
+if (AWBSTORAGE && AWBSTORAGE.type == 's3') {
+  const client = new S3Client({
+    credentials: {
+      accessKeyId: AWBSTORAGE.accessKeyId,
+      secretAccessKey: AWBSTORAGE.secretAccessKey
+    },
+    region: AWBSTORAGE.region
+  })
+
+  /* upload file */
+  AWBSTORAGE.uploadFile = async ({ stream, filename }) => {
+    const upload = new Upload({
+      client,
+      params: {
+        Bucket: AWBSTORAGE.bucketName,
+        Key: `${filename}.pdf`,
+        Body: stream,
+        ContentType: 'application/pdf'
+      }
+    })
+
+    let result
+    let url
+    try {
+      result = (await upload.done()) as any
+      url = `https://${AWBSTORAGE.bucketName}.s3.${AWBSTORAGE.region}.amazonaws.com/${filename}.pdf`
+    } catch (e) {
+      console.log(e)
+    }
+
+    return {
+      result,
+      url
+    }
+  }
+
+  logger.info('operato-awb: S3 Bucket Storage is Ready.')
+}

package/server/index.ts

@@ -0,0 +1,15 @@
+export * from './attachment-const'
+export * from './service'
+export {
+  createAttachment,
+  createAttachments,
+  deleteAttachment,
+  deleteAttachmentsByRef,
+  multipleUpload,
+  singleUpload
+} from './service/attachment/attachment-mutation'
+
+import './routes'
+
+export * from './attachment-const'
+export * from './util'

package/server/routes.ts

@@ -0,0 +1,35 @@
+import './storage-file'
+import './storage-s3'
+import './storage-database'
+import './storage-azure-blob'
+
+import { ATTACHMENT_PATH, STORAGE } from './attachment-const'
+
+const multer = require('@koa/multer')
+const upload = multer() // note you can pass `multer` options here
+
+const { Readable } = require('stream')
+
+// process.on('bootstrap-module-domain-private-route' as any, (app, routes) => {
+process.on('bootstrap-module-global-public-route' as any, (app, routes) => {
+  // TODO make this secure
+  routes.get(`/${ATTACHMENT_PATH}/:attachment`, async (context, next) => {
+    context.set('Cache-Control', 'public, max-age=31536000') // 캐시 기간 설정 : 1년
+    context.set('Expires', new Date(Date.now() + 31536000000).toUTCString()) // 캐시 만료일 설정
+
+    await STORAGE.sendFile(context, context.params.attachment, next)
+  })
+
+  routes.post(`/${ATTACHMENT_PATH}`, upload.any(), async (context, next) => {
+    const files = context.files
+
+    const result: { id: string; path: string; size: number }[] = await Promise.all(
+      files.map(file => STORAGE.uploadFile({ file, context }))
+    )
+
+    context.status = 200
+    // Support < IE 10 browser
+    context.set('Content-Type', 'text/html;charset=UTF-8')
+    context.body = JSON.stringify(result)
+  })
+})

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

@@ -0,0 +1,343 @@
+import { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import promisesAll from 'promises-all'
+
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { config, logger } from '@things-factory/env'
+import { getRepository } from '@things-factory/shell'
+
+import { STORAGE } from '../../attachment-const'
+import { Attachment } from './attachment'
+import { AttachmentPatch, NewAttachment, UploadURL } from './attachment-types'
+
+const allowedMimeTypes = config.get('fileUpload/mimeTypes', [])
+
+@Resolver(Attachment)
+export class AttachmentMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Attachment)
+  async createAttachment(
+    @Arg('attachment', type => NewAttachment) attachment: NewAttachment,
+    @Ctx() context: ResolverContext
+  ): Promise<Attachment> {
+    return await createAttachment(null, { attachment }, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Attachment])
+  async createAttachments(
+    @Arg('attachments', type => [NewAttachment]) attachments: NewAttachment[],
+    @Ctx() context: ResolverContext
+  ): Promise<Attachment[]> {
+    return await createAttachments(null, { attachments }, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Attachment)
+  async updateAttachment(
+    @Arg('id') id: string,
+    @Arg('patch', type => AttachmentPatch) patch: AttachmentPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Attachment> {
+    const attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: context.state.domain.id },
+        id
+      }
+    })
+
+    return await getRepository(Attachment).save({
+      ...attachment,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteAttachment(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    return await deleteAttachment(null, { id }, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteAttachmentsByRef(
+    @Arg('refBys', type => [String]) refBys: string[],
+    @Arg('refType', type => String, { nullable: true }) refType: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    return await deleteAttachmentsByRef(null, { refBys, refType }, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Attachment)
+  async singleUpload(
+    @Arg('file', type => GraphQLUpload) file: FileUpload,
+    @Ctx() context: ResolverContext
+  ): Promise<Attachment> {
+    return await singleUpload(null, { file }, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Attachment])
+  async multipleUpload(
+    @Arg('files', type => [GraphQLUpload]) files: FileUpload[],
+    @Ctx() context: ResolverContext
+  ): Promise<Attachment[]> {
+    return await multipleUpload(null, { files }, context)
+  }
+
+  @Mutation(returns => UploadURL)
+  async generateUploadURL(
+    @Arg('type', type => String) type: string,
+    @Ctx() context: ResolverContext
+  ): Promise<{ url: string; fields: { [key: string]: string } }> {
+    return await generateUploadURL(null, { type }, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Attachment], { description: 'To import some Attachments' })
+  async importAttachments(
+    @Arg('file', () => GraphQLUpload) file: FileUpload,
+    @Ctx() context: ResolverContext
+  ): Promise<Attachment[]> {
+    return await importAttachments(file, context)
+  }
+}
+
+export async function createAttachment(_: any, { attachment }, context: ResolverContext): Promise<Attachment> {
+  const { file, category, refType = '', refBy, description } = attachment
+  const { mimetype } = (await file) as FileUpload
+
+  if (allowedMimeTypes instanceof Array && allowedMimeTypes.length > 0 && !allowedMimeTypes.includes('*/*')) {
+    const isAllowed = allowedMimeTypes.some(type => {
+      const [typeMain, typeSub] = type.split('/')
+      const [mimeMain, mimeSub] = mimetype.split('/')
+      return (
+        (typeMain === mimeMain && (typeSub === '*' || typeSub === mimeSub)) || (typeMain === '*' && typeSub === '*')
+      )
+    })
+
+    if (!isAllowed) {
+      throw Error(context.t(`error.not allowed file type for upload`, { mimetype }))
+    }
+  }
+
+  const { id, path, size, filename, encoding, contents } = await STORAGE.uploadFile({ file, context })
+  const { domain, user, tx } = context.state
+
+  const repository = tx ? tx.getRepository(Attachment) : getRepository(Attachment)
+
+  return await repository.save({
+    domain,
+    creator: user,
+    updater: user,
+    id,
+    description,
+    name: filename,
+    mimetype,
+    encoding,
+    refType,
+    refBy,
+    category: category || mimetype.split('/').shift(),
+    size: size as any,
+    path,
+    contents
+  })
+}
+
+export async function createAttachments(_: any, { attachments }, context: ResolverContext): Promise<Attachment[]> {
+  const { resolve, reject } = await promisesAll.all(
+    attachments.map(attachment => createAttachment(_, { attachment }, context))
+  )
+
+  if (reject.length) {
+    reject.forEach(({ name, message }) => logger.error(`${name}: ${message}`))
+
+    return reject
+  }
+
+  return resolve
+}
+
+export async function deleteAttachment(_: any, { id }, context: ResolverContext): Promise<boolean> {
+  const { domain, tx } = context.state
+
+  const repository = tx ? tx.getRepository(Attachment) : getRepository(Attachment)
+  const attachment = await repository.findOne({
+    where: { domain: { id: domain.id }, id }
+  })
+
+  if (attachment) {
+    await repository.delete({ id: attachment.id })
+    await STORAGE.deleteFile(attachment.path)
+    return true
+  } else {
+    return false
+  }
+}
+
+interface DeleteAttachmentsObject {
+  refBys: Array<string>
+  refType?: string
+}
+export async function deleteAttachmentsByRef(
+  _: any,
+  { refBys, refType = null }: DeleteAttachmentsObject,
+  context: ResolverContext
+): Promise<boolean> {
+  const { domain, tx } = context.state
+  const repository = tx ? tx.getRepository(Attachment) : getRepository(Attachment)
+  const inquryWhereClause: any = { domain: { id: domain.id }, refBy: In(refBys) }
+  const deleteWhereClause: any = { refBy: In(refBys) }
+  
+  // refType이 존재하면 where 절에 추가
+  if (refType) {
+    inquryWhereClause.refType = refType;
+    deleteWhereClause.refType = refType;
+  }
+  
+  const attachments = await repository.find({
+    where: inquryWhereClause
+  })
+
+  //remove attachment from repo
+  await repository.delete(deleteWhereClause)
+
+  //remove files from attachments folder
+  if (attachments.length) {
+    await Promise.all(
+      attachments.map(async attachment => {
+        await STORAGE.deleteFile(attachment.path)
+      })
+    )
+
+    return true
+  } else {
+    return false
+  }
+}
+
+export async function generateUploadURL(
+  _: any,
+  { type },
+  context: ResolverContext
+): Promise<{ url: string; fields: { [key: string]: string } }> {
+  return await STORAGE.generateUploadURL(type)
+}
+
+export async function singleUpload(_: any, { file }, context: ResolverContext): Promise<Attachment> {
+  return await createAttachment(null, { attachment: { file } }, context)
+}
+
+export async function multipleUpload(_: any, { files }, context: ResolverContext): Promise<Attachment[]> {
+  return await createAttachments(null, { attachments: { files } }, context)
+}
+
+async function parseJSONFile(uploadedFile: FileUpload): Promise<any> {
+  var { createReadStream } = await uploadedFile
+
+  return new Promise((resolve, reject) => {
+    const chunks: Uint8Array[] = []
+
+    createReadStream()
+      .on('data', (chunk: Uint8Array) => {
+        chunks.push(chunk)
+      })
+      .on('end', () => {
+        try {
+          const fileContents = Buffer.concat(chunks).toString('utf-8')
+          const jsonData = JSON.parse(fileContents)
+          resolve(jsonData)
+        } catch (error) {
+          reject(error)
+        }
+      })
+      .on('error', (error: Error) => {
+        reject(error)
+      })
+  })
+}
+
+function dataURLToFileUpload(dataURL: string, filename: string, mimeType: string): FileUpload {
+  const indexOfComma = dataURL.indexOf(',')
+  if (indexOfComma === -1) {
+    throw new Error('Invalid Data URL')
+  }
+
+  const base64Data = dataURL.slice(indexOfComma + 1)
+  const buffer = Buffer.from(base64Data, 'base64')
+
+  return {
+    filename,
+    mimetype: mimeType,
+    encoding: 'base64',
+    createReadStream: () => {
+      const stream = require('stream')
+      const readable = new stream.Readable()
+      readable.push(buffer)
+      readable.push(null)
+      return readable
+    }
+  }
+}
+
+export async function importAttachments(upload: FileUpload, context: ResolverContext): Promise<Attachment[]> {
+  const { domain, user, notify, tx } = context.state
+
+  const repository = tx.getRepository(Attachment)
+
+  const attachments = []
+
+  const parsed = await parseJSONFile(upload)
+
+  for (const id in parsed) {
+    var { name, description, category, mimetype, encoding, contents } = parsed[id]
+    if (!name || !contents || !mimetype) {
+      throw 'Malformed attachments import file'
+    }
+
+    var sameIdAttachment = await repository.findOneBy({ id })
+
+    if (sameIdAttachment) {
+      if (sameIdAttachment.domainId != domain.id) {
+        throw `Attachment with id/name(${id}/${name}) is already taken in another domain`
+      }
+
+      // 동일 아이디 첨부파일이 있다면, 스킵한다.
+      continue
+    }
+
+    const file = dataURLToFileUpload(contents, name, mimetype)
+
+    var { path, size, contents } = await STORAGE.uploadFile({ id, file, context })
+
+    attachments.push(
+      await repository.save({
+        domain,
+        creator: user,
+        updater: user,
+        id,
+        description,
+        name,
+        mimetype,
+        encoding,
+        category: category || mimetype.split('/').shift(),
+        size: size as any,
+        path,
+        contents
+      })
+    )
+  }
+
+  notify &&
+    notify({
+      mode: 'in-app',
+      title: `${attachments.length} Attachment(s) are imported`,
+      body: `${attachments.length} Attachment(s) are imported by ${user.name}`
+    })
+
+  return attachments
+}

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

@@ -0,0 +1,78 @@
+import { In } from 'typeorm'
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { AttachmentList } from '../'
+import { Attachment } from './attachment'
+
+@Resolver(Attachment)
+export class AttachmentQuery {
+  @Directive('@privilege(category: "attachment", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => AttachmentList)
+  async attachments(
+    @Ctx() context: ResolverContext,
+    @Args(type => ListParam) params: ListParam
+  ): Promise<AttachmentList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: await getRepository(Attachment),
+      params,
+      domain,
+      alias: 'attachment',
+      searchables: ['name', 'description', 'tags']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "attachment", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Attachment)
+  async attachment(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Attachment> {
+    const { domain } = context.state
+
+    return await getRepository(Attachment).findOne({
+      select: [
+        'domain',
+        'id',
+        'name',
+        'path',
+        'size',
+        'mimetype',
+        'encoding',
+        'category',
+        'updatedAt',
+        'updater',
+        'createdAt',
+        'creator'
+      ],
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() attachment: Attachment) {
+    return await getRepository(Domain).findOneBy({
+      id: attachment.domainId
+    })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() attachment: Attachment): Promise<User> {
+    return await getRepository(User).findOneBy({
+      id: attachment.updaterId
+    })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() attachment: Attachment): Promise<User> {
+    return await getRepository(User).findOneBy({
+      id: attachment.creatorId
+    })
+  }
+}

package/server/service/attachment/attachment-types.ts

@@ -0,0 +1,76 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ScalarAny, ScalarObject } from '@things-factory/shell'
+
+import { Attachment } from './attachment'
+
+@ObjectType()
+export class AttachmentList {
+  @Field(type => [Attachment])
+  items: Attachment[]
+
+  @Field(type => Int)
+  total: number
+}
+
+@ObjectType()
+export class UploadURL {
+  @Field(type => String)
+  url: string
+
+  @Field(type => ScalarAny)
+  fields: any
+}
+
+@InputType()
+export class NewAttachment {
+  @Field({ nullable: true })
+  category: string
+
+  @Field(type => GraphQLUpload)
+  file: FileUpload
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  refType: string
+
+  @Field({ nullable: true })
+  refBy: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  tags?: string[]
+}
+
+@InputType()
+export class AttachmentPatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  mimetype: string
+
+  @Field({ nullable: true })
+  encoding: string
+
+  @Field({ nullable: true })
+  category: string
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  file: FileUpload
+
+  @Field({ nullable: true })
+  refType: string
+
+  @Field({ nullable: true })
+  refBy: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  tags?: string[]
+}