@things-factory/attachment-base 8.0.0-beta.1 → 8.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/attachment-base",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.4",
   "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.1",
-    "@things-factory/env": "^8.0.0-beta.1",
-    "@things-factory/shell": "^8.0.0-beta.1",
+    "@things-factory/auth-base": "^8.0.0-beta.4",
+    "@things-factory/env": "^8.0.0-beta.4",
+    "@things-factory/shell": "^8.0.0-beta.4",
     "mime": "^3.0.0",
     "multer": "^1.4.5-lts.1"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "d83d12ed4ba07177dff1dac26e37be347d156b43"
 }

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,24 +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'
-
-import { normalizeNamesToNFC } from './nfc-normalize'
-
-process.on('bootstrap-module-start' as any, async ({ app, config, client }: any) => {
-  /* 이 코드는 기존 첨부파일의 NFC 정규화를 강제로 실행하기 위해서 임시로 작성되었다. */
-  normalizeNamesToNFC()
-    .then(() => console.log('Normalization completed.'))
-    .catch(err => console.error('Error during normalization:', err))
-})

package/server/nfc-normalize.ts

@@ -1,25 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-import { Attachment } from './service/attachment/attachment'
-
-export async function normalizeNamesToNFC() {
-  const attachmentRepository = getRepository(Attachment)
-
-  // 모든 Attachment 항목을 조회
-  const attachments = await attachmentRepository.find()
-
-  // NFD로 저장된 name을 NFC로 변환하여 업데이트
-  for (const attachment of attachments) {
-    if (attachment.name) {
-      const normalizedName = attachment.name.normalize('NFC')
-
-      // name이 NFD로 저장된 경우만 업데이트
-      if (attachment.name !== normalizedName) {
-        attachment.name = normalizedName
-        await attachmentRepository.save(attachment)
-        console.log(`Updated name for attachment ID ${attachment.id}: ${normalizedName}`)
-      }
-    }
-  }
-
-  console.log('All names have been normalized to NFC.')
-}

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[]
-}

package/server/service/attachment/attachment.ts

@@ -1,129 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, ScalarObject } from '@things-factory/shell'
-
-import { ATTACHMENT_PATH } from '../../attachment-const'
-import { config } from '@things-factory/env'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index('ix_attachment_0', (attachment: Attachment) => [attachment.domain, attachment.name], { unique: false })
-@Index('ix_attachment_1', (attachment: Attachment) => [attachment.domain, attachment.category, attachment.name], {
-  unique: false
-})
-@Index('ix_attachment_2', (attachment: Attachment) => [attachment.domain, attachment.refBy], {
-  unique: false
-})
-@Index('ix_attachment_3', (attachment: Attachment) => [attachment.domain, attachment.refType, attachment.refBy], {
-  unique: false
-})
-@ObjectType()
-export class Attachment {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id?: string
-
-  @ManyToOne(type => Domain, { nullable: false })
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((attachment: Attachment) => attachment.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column()
-  @Field()
-  mimetype?: string
-
-  @Column()
-  @Field()
-  encoding?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  category?: string
-
-  @Column({ nullable: true, default: '' })
-  @Field({ nullable: true })
-  refType?: string = ''
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  refBy?: string
-
-  @Column()
-  @Field()
-  path?: string
-
-  @Column({
-    nullable: true,
-    type: DATABASE_TYPE == 'mssql' ? 'bigint' : undefined
-  })
-  @Field()
-  size?: string
-
-  @Column({
-    nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longblob'
-        : DATABASE_TYPE == 'postgres'
-          ? 'bytea'
-          : DATABASE_TYPE == 'mssql'
-            ? 'varbinary'
-            : 'blob',
-    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
-  })
-  contents?: Buffer
-
-  @Column('simple-json', { nullable: true, default: null })
-  @Field(type => ScalarObject, { nullable: true })
-  tags?: string[]
-
-  @CreateDateColumn()
-  @Field()
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field()
-  updatedAt?: Date
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((attachment: Attachment) => attachment.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((attachment: Attachment) => attachment.updater)
-  updaterId?: string
-
-  @Field()
-  get fullpath(): string {
-    return `/${ATTACHMENT_PATH}/${this.path}`
-  }
-}

package/server/service/attachment/index.ts

@@ -1,6 +0,0 @@
-import { Attachment } from './attachment'
-import { AttachmentMutation } from './attachment-mutation'
-import { AttachmentQuery } from './attachment-query'
-
-export const entities = [Attachment]
-export const resolvers = [AttachmentQuery, AttachmentMutation]

package/server/service/index.ts

@@ -1,19 +0,0 @@
-/* IMPORT ENTITIES AND RESOLVERS */
-import { entities as AttachmentEntity, resolvers as AttachmentResolvers } from './attachment'
-
-/* EXPORT ENTITY TYPES */
-export * from './attachment/attachment'
-/* EXPORT TYPES */
-export * from './attachment/attachment-types'
-
-export const entities = [
-  /* ENTITIES */
-  ...AttachmentEntity
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...AttachmentResolvers
-  ]
-}

package/server/storage-azure-blob.ts

@@ -1,111 +0,0 @@
-import { BlobServiceClient } from '@azure/storage-blob'
-import { logger } from '@things-factory/env'
-
-import { STORAGE } from './attachment-const'
-
-const crypto = require('crypto')
-const mime = require('mime')
-
-if (STORAGE && STORAGE.type == 'azureblob') {
-  const blobServiceClient = BlobServiceClient.fromConnectionString(STORAGE.connectionString)
-
-  /* upload file */
-  STORAGE.uploadFile = async ({ id, file }) => {
-    const { createReadStream, filename, mimetype, encoding } = await file
-
-    const containerClient = blobServiceClient.getContainerClient(STORAGE.containerName)
-    id = id || crypto.randomUUID()
-    const ext = filename.split('.').pop()
-    const key = ext ? `${id}.${ext}` : id
-
-    const blockBlobClient = containerClient.getBlockBlobClient(key)
-    const stream = createReadStream()
-    const buffer = await streamToBuffer(stream)
-
-    await blockBlobClient.upload(buffer, buffer.length, {
-      blobHTTPHeaders: {
-        blobContentType: mimetype
-      }
-    })
-
-    // await blockBlobClient.uploadStream(stream, undefined, undefined, {
-    //   blobHTTPHeaders: {
-    //     blobContentType: mimetype
-    //   }
-    // })
-
-    const url = `${STORAGE.url}/${STORAGE.containerName}/${key}`
-    return {
-      id,
-      path: key,
-      filename,
-      size: buffer.length,
-      mimetype,
-      encoding
-    }
-  }
-
-  STORAGE.deleteFile = async (path: string) => {
-    const containerClient = blobServiceClient.getContainerClient(STORAGE.containerName)
-    const blockBlobClient = containerClient.getBlockBlobClient(path)
-    await blockBlobClient.deleteIfExists()
-  }
-
-  /* TODO Streaming to Streaming 으로 구현하라. */
-  STORAGE.sendFile = async (context, attachment, next) => {
-    const containerClient = blobServiceClient.getContainerClient(STORAGE.containerName)
-    const blockBlobClient = containerClient.getBlockBlobClient(attachment)
-
-    const result = await blockBlobClient.getProperties()
-    const response = await blockBlobClient.download(0)
-    const body = response.readableStreamBody
-
-    context.set({
-      'Content-Length': result.contentLength,
-      'Content-Type': mime.getType(attachment),
-      'Last-Modified': result.lastModified.toUTCString(),
-      ETag: result.etag,
-      'Cache-Control': 'public, max-age=31556926'
-    })
-
-    context.body = body
-  }
-
-  STORAGE.readFile = async (attachment: string, encoding: string) => {
-    const containerClient = blobServiceClient.getContainerClient(STORAGE.containerName)
-    const blockBlobClient = containerClient.getBlockBlobClient(attachment)
-
-    const response = await blockBlobClient.download(0)
-    const body = response.readableStreamBody
-
-    const buffer = Buffer.from(await streamToBuffer(body))
-
-    switch (encoding) {
-      case 'base64':
-        return buffer.toString('base64')
-      default:
-        return buffer
-    }
-  }
-
-  STORAGE.generateUploadURL = async (type: string): Promise<{ url: string; fields: { [key: string]: string } }> => {
-    const expiresInMinutes = 1
-    const id = crypto.randomUUID()
-
-    return {
-      url: `${STORAGE.url}/${STORAGE.containerName}/${id}`,
-      fields: {}
-    }
-  }
-
-  logger.info('Azure Blob Storage is Ready.')
-}
-
-async function streamToBuffer(stream): Promise<Buffer> {
-  return new Promise<Buffer>((resolve, reject) => {
-    const chunks = []
-    stream.on('data', chunk => chunks.push(chunk))
-    stream.on('end', () => resolve(Buffer.concat(chunks)))
-    stream.on('error', reject)
-  })
-}

package/server/storage-database.ts

@@ -1,80 +0,0 @@
-import contentDisposition from 'content-disposition'
-
-import { logger } from '@things-factory/env'
-import { getRepository } from '@things-factory/shell'
-
-import { Attachment } from './service/attachment/attachment'
-import { ATTACHMENT_PATH, STORAGE } from './attachment-const'
-
-const crypto = require('crypto')
-
-if (STORAGE && STORAGE.type == 'database') {
-  STORAGE.uploadFile = async ({ id, file, context }) => {
-    var { createReadStream, filename, mimetype, encoding } = await file
-    filename = Buffer.from(filename, 'latin1')
-      .toString('utf-8')
-      .normalize('NFC') /* Because busboy uses latin1 encoding */
-
-    const stream = createReadStream()
-
-    const chunks: Buffer[] = []
-    for await (const chunk of stream) {
-      if (chunk instanceof Buffer) {
-        chunks.push(chunk)
-      }
-    }
-
-    id = id || crypto.randomUUID()
-    const ext = filename.split('.').pop()
-    const path = ext ? `${id}.${ext}` : id
-
-    const contents = Buffer.concat(chunks)
-
-    return {
-      id,
-      filename,
-      mimetype,
-      encoding,
-      contents,
-      path,
-      size: contents.length
-    }
-  }
-
-  STORAGE.deleteFile = async path => {}
-
-  STORAGE.sendFile = async (context, attachment, next) => {
-    const id = attachment.split('.')[0]
-
-    const entity = await getRepository(Attachment).findOne({
-      select: ['name', 'contents'],
-      where: { id }
-    })
-
-    context.set('Content-Disposition', contentDisposition(entity.name))
-    context.body = entity.contents
-    context.type = entity.mimetype
-  }
-
-  STORAGE.readFile = async (attachment, encoding) => {
-    const id = attachment.split('.')[0]
-
-    const entity = await getRepository(Attachment).findOne({
-      select: ['name', 'contents'],
-      where: { id }
-    })
-
-    return await entity.contents
-  }
-
-  STORAGE.generateUploadURL = async (type: string): Promise<{ url: string; fields: { [key: string]: string } }> => {
-    const id = crypto.randomUUID()
-
-    return await {
-      url: `/${ATTACHMENT_PATH}`,
-      fields: {}
-    }
-  }
-
-  logger.info('File Storage is Ready.')
-}

package/server/storage-file.ts

@@ -1,80 +0,0 @@
-import * as fs from 'fs'
-import * as mkdirp from 'mkdirp'
-import { resolve } from 'path'
-
-import { config, logger } from '@things-factory/env'
-
-import { ATTACHMENT_PATH, STORAGE } from './attachment-const'
-
-const crypto = require('crypto')
-const send = require('koa-send')
-
-if (STORAGE && STORAGE.type == 'file') {
-  const uploadDir = config.getPath(null, STORAGE.base || 'attachments')
-
-  STORAGE.uploadFile = async ({ id, file }) => {
-    var { createReadStream, filename, mimetype, encoding } = await file
-    filename = Buffer.from(filename, 'latin1')
-      .toString('utf-8')
-      .normalize('NFC') /* Because busboy uses latin1 encoding */
-
-    const stream = createReadStream()
-
-    mkdirp.sync(uploadDir)
-
-    id = id || crypto.randomUUID()
-    const ext = filename.split('.').pop()
-    const path = ext ? resolve(uploadDir, `${id}.${ext}`) : resolve(uploadDir, id)
-    const relativePath = path.split('\\').pop().split('/').pop()
-    var size: number = 0
-
-    return new Promise<{
-      id: string
-      filename: string
-      path: string
-      size: number
-      mimetype: string
-      encoding: string
-    }>((resolve, reject) =>
-      stream
-        .on('error', error => {
-          if (stream.truncated)
-            // Delete the truncated file
-            fs.unlinkSync(path)
-          reject(error)
-        })
-        .on('data', chunk => {
-          size += chunk.length
-        })
-        .pipe(fs.createWriteStream(path))
-        .on('finish', () => resolve({ id, filename, path: relativePath, size, mimetype, encoding }))
-    )
-  }
-
-  STORAGE.deleteFile = async path => {
-    const fullpath = resolve(uploadDir, path)
-
-    await fs.unlink(fullpath, logger.error)
-  }
-
-  STORAGE.sendFile = async (context, attachment, next) => {
-    await send(context, attachment, { root: uploadDir })
-  }
-
-  STORAGE.readFile = (attachment, encoding) => {
-    const fullpath = resolve(uploadDir, attachment)
-
-    return fs.readFileSync(fullpath, encoding)
-  }
-
-  STORAGE.generateUploadURL = async (type: string): Promise<{ url: string; fields: { [key: string]: string } }> => {
-    const id = crypto.randomUUID()
-
-    return await {
-      url: `/${ATTACHMENT_PATH}`,
-      fields: {}
-    }
-  }
-
-  logger.info('File Storage is Ready.')
-}

package/server/storage-s3.ts

@@ -1,141 +0,0 @@
-import type { Readable } from 'stream'
-
-import {
-  DeleteObjectCommand,
-  GetObjectCommand,
-  GetObjectCommandInput,
-  HeadObjectCommand,
-  S3Client
-} from '@aws-sdk/client-s3'
-import { Upload } from '@aws-sdk/lib-storage'
-import { createPresignedPost } from '@aws-sdk/s3-presigned-post'
-import { logger } from '@things-factory/env'
-
-import { STORAGE } from './attachment-const'
-
-const crypto = require('crypto')
-const mime = require('mime')
-
-if (STORAGE && STORAGE.type == 's3') {
-  const client = new S3Client({
-    credentials: {
-      accessKeyId: STORAGE.accessKeyId,
-      secretAccessKey: STORAGE.secretAccessKey
-    },
-    region: STORAGE.region
-  })
-
-  const streamToBuffer = (stream: Readable) =>
-    new Promise<Buffer>((resolve, reject) => {
-      const chunks: Buffer[] = []
-      stream.on('data', chunk => chunks.push(chunk))
-      stream.once('end', () => resolve(Buffer.concat(chunks)))
-      stream.once('error', reject)
-    })
-
-  /* upload file */
-  STORAGE.uploadFile = async ({ id, file }) => {
-    var { createReadStream, filename, mimetype, encoding } = await file
-    filename = Buffer.from(filename, 'latin1')
-      .toString('utf-8')
-      .normalize('NFC') /* Because busboy uses latin1 encoding */
-
-    const stream = createReadStream()
-    id = id || crypto.randomUUID()
-    const ext = filename.split('.').pop()
-    const key = ext ? `${id}.${ext}` : id
-
-    const upload = new Upload({
-      client,
-      params: {
-        Bucket: STORAGE.bucketName,
-        Key: key,
-        Body: stream
-      }
-    })
-
-    await upload.done()
-
-    const headObjectCommand = new HeadObjectCommand({
-      Bucket: STORAGE.bucketName,
-      Key: key
-    })
-
-    const { ContentLength } = await client.send(headObjectCommand)
-
-    return {
-      id,
-      path: key,
-      filename,
-      size: ContentLength,
-      mimetype,
-      encoding
-    }
-  }
-
-  STORAGE.deleteFile = async (path: string) => {
-    const command = new DeleteObjectCommand({
-      Bucket: STORAGE.bucketName,
-      Key: path
-    })
-
-    return await client.send(command)
-  }
-
-  /* TODO Streaming to Streaming 으로 구현하라. */
-  STORAGE.sendFile = async (context, attachment, next) => {
-    const result = await client.send(
-      new GetObjectCommand({
-        Bucket: STORAGE.bucketName,
-        Key: attachment
-      } as GetObjectCommandInput)
-    )
-
-    context.set({
-      'Content-Length': result.ContentLength,
-      'Content-Type': mime.getType(attachment),
-      'Last-Modified': result.LastModified.toUTCString(),
-      ETag: result.ETag,
-      'Cache-Control': 'public, max-age=31556926'
-    })
-
-    context.body = result.Body
-  }
-
-  STORAGE.readFile = async (attachment: string, encoding: string) => {
-    /*
-     * refered to
-     * https://transang.me/modern-fetch-and-how-to-get-buffer-output-from-aws-sdk-v3-getobjectcommand/#the-body-type
-     */
-    const result = await client.send(
-      new GetObjectCommand({
-        Bucket: STORAGE.bucketName,
-        Key: attachment
-      } as GetObjectCommandInput)
-    )
-
-    var body = result.Body as Readable
-    var buffer = await streamToBuffer(body)
-
-    switch (encoding) {
-      case 'base64':
-        return buffer.toString('base64')
-      default:
-        return await buffer
-    }
-  }
-
-  STORAGE.generateUploadURL = async (type: string): Promise<{ url: string; fields: { [key: string]: string } }> => {
-    const expiresInMinutes = 1
-    const id = crypto.randomUUID()
-
-    return await createPresignedPost(client, {
-      Bucket: STORAGE.bucketName,
-      Key: id,
-      Expires: expiresInMinutes * 60,
-      Conditions: [['eq', '$Content-Type', type]]
-    })
-  }
-
-  logger.info('S3 Bucket Storage is Ready.')
-}

package/server/util/index.ts

@@ -1 +0,0 @@
-export * from './upload-awb'

package/server/util/upload-awb.ts

@@ -1,11 +0,0 @@
-import '../awb-storage-s3'
-
-import { AWBSTORAGE } from '../attachment-const'
-
-export async function uploadAwb(param: any) {
-  const { content, title } = param
-
-  let result = await AWBSTORAGE.uploadFile({ stream: content, filename: title })
-
-  return result
-}