@things-factory/attachment-base 8.0.0 → 9.0.0-beta.3

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,78 +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') /* 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,78 +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') /* 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,139 +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') /* 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
-}