@things-factory/attachment-base 8.0.38 → 9.0.0-9.0.0-beta.59.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/attachment-base",
-  "version": "8.0.38",
+  "version": "9.0.0-9.0.0-beta.59.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.38",
-    "@things-factory/env": "^8.0.37",
-    "@things-factory/shell": "^8.0.38",
+    "@things-factory/auth-base": "^9.0.0-9.0.0-beta.59.0",
+    "@things-factory/env": "^9.0.0-9.0.0-beta.59.0",
+    "@things-factory/shell": "^9.0.0-9.0.0-beta.59.0",
     "mime": "^3.0.0",
     "multer": "^1.4.5-lts.1"
   },
-  "gitHead": "613db8b1fa9fd156294f113518348247ae61a2db"
+  "gitHead": "cf6ee84b991f469a4e71198b0e6314b45e9e10b8"
 }

package/server/attachment-const.ts

@@ -1,5 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,343 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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[]
-}