Refactored media upload, download api.

(Convenience methods like sendMedia, sendMultiMedia were not affected.)

Removed talk implementation reference from OpenLinkService.

Update version to 4.1.0

Author: storycraft

package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-kakao",
-  "version": "4.0.6",
+  "version": "4.1.0",
   "description": "Loco protocol compatible library",
   "main": "./dist/index.js",
   "exports": {

src/channel/channel-session.ts

@@ -11,9 +11,9 @@ import { Long } from '..';
 import { ChannelUser, NormalChannelUserInfo } from '../user';
 import { ChannelMeta, NormalChannelInfo, SetChannelMeta } from './channel-info';
 import { ChatOnRoomRes } from '../packet/chat';
-import { MediaDownloader, MediaUploader, MultiMediaUploader, MediaUploadTemplate } from '../talk';
-import { MediaKeyComponent } from '../media';
 import { ChannelMetaType } from './meta';
+import { MediaKeyComponent, MediaMultiPost, MediaPost, MediaUploadForm } from '../media';
+import { FixedReadStream } from '../stream';
 
 export interface ChannelTemplate {
 
@@ -95,28 +95,38 @@ export interface ChannelSession {
   getChatListFrom(startLogId?: Long): AsyncCommandResult<Chatlog[]>;
 
   /**
-   * Create media downloader
+   * Create media download stream
    *
    * @param media
    * @param type
+   * @param {number} [offset=0] Download start position
    */
-  downloadMedia(media: MediaKeyComponent, type: ChatType): AsyncCommandResult<MediaDownloader>;
+  downloadMedia(media: MediaKeyComponent, type: ChatType, offset?: number): AsyncCommandResult<FixedReadStream>;
 
   /**
-   * Create media uploader.
+   * Create media thumbnail download stream
+   *
+   * @param media
+   * @param type
+   * @param {number} [offset=0] Download start position
+   */
+  downloadMediaThumb(media: MediaKeyComponent, type: ChatType, offset?: number): AsyncCommandResult<FixedReadStream>;
+
+  /**
+   * Upload media.
    *
    * @param type Media type. Supports PHOTO, VIDEO, TEXT, FILE type.
-   * @param template
+   * @param form
    */
-  uploadMedia(type: ChatType, template: MediaUploadTemplate): AsyncCommandResult<MediaUploader>;
+  uploadMedia(type: ChatType, form: MediaUploadForm): AsyncCommandResult<MediaPost>;
 
   /**
-   * Create multi media uploader.
+   * Upload multi media.
    *
    * @param type Media type. Currently works only with MULTIPHOTO.
-   * @param templates
+   * @param forms
    */
-  uploadMultiMedia(type: ChatType, templates: MediaUploadTemplate[]): AsyncCommandResult<MultiMediaUploader[]>;
+  uploadMultiMedia(type: ChatType, forms: MediaUploadForm[]): AsyncCommandResult<MediaMultiPost>;
 
 }
 

src/channel/store.ts

@@ -54,7 +54,7 @@ export interface UpdatableChannelDataStore<T, U> extends ChannelDataStore<T, U>,
 
 }
 
-export interface ChannelListStore<T> {
+export interface ChannelStore<T> {
 
   /**
    * Try to get channel instance with channel id

src/chat/store.ts

@@ -9,9 +9,9 @@ import { Chatlog } from './chat';
 import { ChatListUpdater } from './updater';
 
 /**
- * Store chat list
+ * Store chats
  */
-export interface ChatListStore {
+export interface ChatStore {
 
   /**
    * Get latest chatlog
@@ -44,6 +44,6 @@ export interface ChatListStore {
 
 }
 
-export interface UpdatableChatListStore extends ChatListStore, ChatListUpdater {
+export interface UpdatableChatListStore extends ChatStore, ChatListUpdater {
 
 }

src/media/index.ts

@@ -4,6 +4,8 @@
  * Copyright (c) storycraft. Licensed under the MIT Licence.
  */
 
+export * from './upload';
+
 export interface MediaKeyComponent {
 
   key: string;

src/media/upload.ts

@@ -0,0 +1,99 @@
+/*
+ * Created on Sat Mar 13 2021
+ *
+ * Copyright (c) storycraft. Licensed under the MIT Licence.
+ */
+
+import { Chatlog } from '../chat';
+import { AsyncCommandResult, CommandResult } from '../request';
+import { FixedWriteStream } from '../stream';
+
+export interface MediaMetadata {
+
+  /**
+   * Media name
+   */
+  readonly name: string;
+
+  /**
+   * Media width (only photo, video)
+   */
+  readonly width?: number;
+
+   /**
+    * Media height (only photo, video)
+    */
+  readonly height?: number;
+ 
+   /**
+    * File extension (Optional. Required when sending file)
+    */
+  readonly ext?: string;
+
+}
+
+export interface MediaUploadForm {
+
+  /**
+   * Size of media data
+   */
+  readonly size: number;
+
+  /**
+   * Checksum of media data (sha1)
+   */
+  readonly checksum: string;
+
+  /**
+   * Media metadata
+   */
+  readonly metadata: MediaMetadata;
+
+}
+
+export interface MediaPostEntry {
+
+  /**
+   * Start offset of media data.
+   */
+  offset: number;
+
+  /**
+   * Write stream
+   */
+  stream: FixedWriteStream;
+
+}
+
+export interface MediaMultiPostEntry extends MediaPostEntry {
+
+  /**
+   * Finish current media upload and close media stream.
+   */
+  finish(): AsyncCommandResult;
+
+}
+
+export interface MediaPost extends MediaPostEntry {
+
+  /**
+   * Finish media upload and close media stream.
+   */
+  finish(): AsyncCommandResult<Chatlog>;
+
+}
+
+export interface MediaMultiPost {
+
+  /**
+   * Media post entries. Ordered same as given UploadForm list.
+   * Each loop will create connection for n-th UploadForm.
+   */
+  entries: AsyncIterableIterator<CommandResult<MediaMultiPostEntry>>;
+
+  /**
+   * Finish all media uploads and send to channel.
+   */
+  finish(): AsyncCommandResult<Chatlog>;
+
+}

src/openlink/open-link-service.ts

@@ -6,10 +6,8 @@
 
 import { Long } from 'bson';
 import { InformedOpenLink } from '..';
-import { TypedEmitter } from '../event/typed';
-import { OpenLinkEvent } from '../talk/event';
 
-export interface OpenLinkService extends TypedEmitter<OpenLinkEvent> {
+export interface OpenLinkService {
 
   /**
    * Get all client link as iterator

src/stream/fixed.ts

@@ -51,7 +51,7 @@ export class FixedReadStream implements ReadStream, FixedStream {
 
     let view: Uint8Array = buffer;
     if (this._read + view.byteLength > this._size) {
-      view = buffer.subarray(0, Math.max(this._size - this._read, 0));
+      view = buffer.subarray(0, this._size - this._read);
     }
 
     const read = await this._stream.read(view);

src/stream/index.ts

@@ -115,6 +115,24 @@ export namespace ReadStreamUtil {
     return data;
   }
 
+  /**
+   * Write every read data from ReadStream to WriteStream.
+   *
+   * @param {ReadStream} read Stream to be read
+   * @param {WriteStream} write Stream to be written
+   * @return {Promise<number>} Bytes written.
+   */
+  export async function copy(read: ReadStream, write: WriteStream): Promise<number> {
+    let written = 0;
+
+    for await (const data of iter(read)) {
+      if (write.ended) break;
+      written += await write.write(data);
+    }
+
+    return written;
+  }
+
 }
 
 /**

src/talk/channel/common.ts

@@ -5,45 +5,74 @@
  */
 
 import { Long } from 'bson';
+import { sha1 } from 'hash-wasm';
 import { TalkChannel } from '.';
 import { ChannelDataUpdater, ChannelSession, NormalChannelSession, UpdatableChannelDataStore } from '../../channel';
 import { Chatlog, ChatLogged, ChatType } from '../../chat';
-import { MediaKeyComponent } from '../../media';
+import { MediaUploadForm } from '../../media';
 import { OpenChannelSession } from '../../openlink';
-import { AsyncCommandResult, CommandResultDone, KnownDataStatusCode } from '../../request';
+import { AsyncCommandResult, KnownDataStatusCode } from '../../request';
 import { ChannelUser, NormalChannelUserInfo, OpenChannelUserInfo } from '../../user';
 import { MediaUploadTemplate } from '../media/upload';
 
 /*
  * Common complex channel methods
  */
 
+export async function mediaTemplateToForm(template: MediaUploadTemplate): Promise<MediaUploadForm> {
+  return {
+    size: template.data.byteLength,
+    checksum: await sha1(template.data),
+    metadata: {
+      name: template.name,
+      width: template.width,
+      height: template.height,
+      ext: template.ext
+    }
+  };
+}
+
 export async function sendMultiMedia(
-    channelSession: ChannelSession,
-    type: ChatType,
-    templates: MediaUploadTemplate[],
+  channelSession: ChannelSession,
+  type: ChatType,
+  templates: MediaUploadTemplate[],
 ): AsyncCommandResult<Chatlog> {
-  const res = await channelSession.uploadMultiMedia(type, templates);
+  const res = await channelSession.uploadMultiMedia(
+    type,
+    await Promise.all(templates.map(mediaTemplateToForm))
+  );
   if (!res.success) return res;
 
-  const keyResList = await Promise.all(res.result.map((uploader) => uploader.upload()));
-  const failed = keyResList.find((uploadRes) => !uploadRes.success);
-  if (failed && !failed.success) return failed;
-  const keyList = keyResList as CommandResultDone<MediaKeyComponent>[];
+  let i = 0;
+  for await (const entryRes of res.result.entries) {
+    if (!entryRes.success) return entryRes;
+    const entry = entryRes.result;
+    const data = templates[i].data;
 
-  return channelSession.forwardChat({
-    text: '',
-    type,
-    attachment: {
-      kl: keyList.map((uploadRes) => uploadRes.result.key),
-      wl: templates.map((template) => template.width || 0),
-      hl: templates.map((template) => template.height || 0),
-      mtl: templates.map((template) => template.ext || ''),
-      sl: templates.map((template) => template.data.byteLength),
-      imageUrls: [], thumbnailUrls: [],
-      thumbnailWidths: [], thumbnailHeights: [],
-    },
-  });
+    await entry.stream.write(data.subarray(Math.min(entry.offset, data.byteLength)));
+
+    const finishRes = await entry.finish();
+    if (!finishRes.success) return finishRes;
+
+    i++;
+  }
+
+  return res.result.finish();
+}
+
+export async function sendMedia(
+  channelSession: ChannelSession,
+  type: ChatType,
+  template: MediaUploadTemplate
+): AsyncCommandResult<Chatlog> {
+  const res = await channelSession.uploadMedia(type, await mediaTemplateToForm(template));
+  if (!res.success) return res;
+
+  const data = template.data;
+
+  await res.result.stream.write(data);
+
+  return res.result.finish();
 }
 
 export function initWatermark(
@@ -128,7 +157,7 @@ export async function updateChatList(
  * Store channel data in memory
  */
 export class TalkMemoryChannelDataStore<T, U>
-implements UpdatableChannelDataStore<T, U> {
+  implements UpdatableChannelDataStore<T, U> {
 
   constructor(
     private _info: T,
@@ -137,7 +166,7 @@ implements UpdatableChannelDataStore<T, U> {
   ) {
 
   }
-  
+
   get info(): Readonly<T> {
     return this._info;
   }
@@ -210,13 +239,13 @@ implements UpdatableChannelDataStore<T, U> {
 
     return userInfoRes || watermarkRes;
   }
-  
+
   updateWatermark(readerId: Long, watermark: Long): void {
     this._watermarkMap.set(readerId.toString(), watermark);
   }
 
   clearWatermark(): void {
     this._watermarkMap.clear();
   }
-  
+
 }