@amityco/ts-sdk 6.26.3 → 6.27.1-061592b.0

package/src/messageRepository/api/createMessage.ts

@@ -3,10 +3,10 @@ import { fireEvent } from '~/core/events';
 import { getActiveClient, getActiveUser } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
-import { upsertInCache, pullFromCache, pushToCache, dropFromCache } from '~/cache/api';
+import { dropFromCache, pullFromCache, pushToCache, upsertInCache } from '~/cache/api';
 
-import { convertParams, prepareMessagePayload } from '../utils';
 import { LinkedObject } from '~/utils/linkedObject';
+import { convertParams, prepareMessagePayload } from '../utils';
 
 const getLocalId = () => `LOCAL_${uuid()}`;
 
@@ -16,109 +16,32 @@ let uniqueId: string | undefined;
 /* begin_public_function
   id: message.create.text_message, message.create.image_message, message.create.file_message, message.create.video_message, message.create.audio_message, message.create.custom_message
 */
-/**
- * ```js
- * import { createMessage, createQuery, runQuery } from '@amityco/ts-sdk'
- *
- * const query = createQuery(createMessage, {
- *   subChannelId: 'foobar',
- *   data: { text: 'hello world' },
- * });
- *
- * runQuery(query, ({ data: message, loading }) => {
- *   console.log(message);
- * });
- * ```
- *
- * Creates an {@link Amity.Message}
- *
- * @param bundle The data necessary to create a new {@link Amity.Message}
- * @returns The newly created {@link Amity.Message}
- *
- * @category Message API
- * @async
- */
-export const createMessage = async <T extends Amity.MessageContentType>(
-  bundle: Pick<
-    Amity.Message<T>,
-    'subChannelId' | 'parentId' | 'dataType' | 'tags' | 'metadata' | 'mentionees'
-  > & {
-    data?: Amity.Message<T>['data'];
-    fileId?: Amity.File['fileId'];
-    // Custom referenceId is a workaround for the case:
-    // User wants to create an image message. He should
-    // - create and show dummy message in ui
-    // - upload image to get fileId, while uploading show a spinner in dummy message in ui
-    // - call createMessage and pass fileId
-    // - replace dummy message with the actual message received from backend
-    // Custom referenceId is needed to make relation between dummy message and actual message.
-    // TODO: passing file src into createMessage so that sdk uploads files itself,
-    // returns the dummy message bound with the file to eliminate the need to create
-    // the dummy message on the user side,
-    referenceId?: string;
-  },
-): Promise<Amity.Cached<Amity.Message>> => {
-  const client = getActiveClient();
-  client.log('message/createMessage', bundle);
-
-  const referenceId = bundle.referenceId || uniqueId || getLocalId();
-  uniqueId = undefined;
-
-  const { data: payload } = await client.http.post<Amity.MessagePayload>('/api/v5/messages', {
-    ...convertParams(bundle),
-    referenceId,
-  });
-
-  const data = await prepareMessagePayload(payload);
-  const { messages } = data;
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) {
-    dropFromCache(['message', 'get', referenceId]);
-    ingestInCache(data, { cachedAt });
-  }
-
-  fireEvent('local.message.created', { messages });
 
-  return {
-    data: LinkedObject.message(messages[0]),
-    cachedAt,
-  };
+type createMessageParam<T extends Amity.MessageContentType> = Pick<
+  Amity.Message<T>,
+  'subChannelId' | 'parentId' | 'dataType' | 'tags' | 'metadata' | 'mentionees'
+> & {
+  data?: Amity.Message<T>['data'];
+  fileId?: Amity.File['fileId'];
+  referenceId?: string;
 };
 
-/**
- * ```js
- * import { createMessage } from '@amityco/ts-sdk'
- *
- * const created = createMessage.optimistically({
- *   channelId: 'foobar',
- *   data: { text: 'hello world' }
- * })
- * ```
- *
- * Creates an {@link Amity.Message} in cache
- *
- * @param bundle The data necessary to create a new {@link Amity.Message}
- * @returns The newly created {@link Amity.Message}
- *
- * @category Message API
- */
-createMessage.optimistically = ({
-  referenceId,
-  ...bundle
-}: Parameters<typeof createMessage>[0]): Amity.Cached<Amity.Message> | undefined => {
+const createMessageOptimistic = <T extends Amity.MessageContentType>(
+  bundle: createMessageParam<T>,
+): Amity.InternalMessage | undefined => {
   const client = getActiveClient();
 
   if (!client.cache) return;
 
   /*
-   * when creating messages optimistically a messageId needs to be added by the
-   * client, created a new variable so as to allow backward compatibility of API
+   * When creating messages optimistically a messageId needs to be added by the
+   * client, created a new variable to allow backward compatibility of API
    *
    * Updated to handle client requirement to add messageId while uploading
-   * message with image. Temporary!
+   * a message with image.
+   * Temporary!
    */
-  uniqueId = referenceId || getLocalId();
+  uniqueId = bundle.referenceId || getLocalId();
   const bundleWithMessageId = { messageId: uniqueId, uniqueId, ...bundle };
 
   client.log('message/createMessage.optimistically', bundleWithMessageId);
@@ -153,6 +76,8 @@ createMessage.optimistically = ({
     childrenNumber: 0,
     createdAt: createdTime,
     updatedAt: createdTime,
+    syncState: Amity.SyncState.Syncing,
+    isDeleted: false,
     ...bundleWithMessageId,
   } as Amity.InternalMessage;
 
@@ -161,9 +86,69 @@ createMessage.optimistically = ({
   pushToCache(['message', 'get', message.messageId], message, { cachedAt });
   fireEvent('local.message.created', { messages: [message] });
 
-  return {
-    cachedAt,
-    data: LinkedObject.message(message),
-  };
+  return message;
+};
+/**
+ * ```js
+ * import { createMessage, createQuery, runQuery } from '@amityco/ts-sdk'
+ *
+ * const query = createQuery(createMessage, {
+ *   subChannelId: 'foobar',
+ *   data: { text: 'hello world' },
+ * });
+ *
+ * runQuery(query, ({ data: message, loading }) => {
+ *   console.log(message);
+ * });
+ * ```
+ *
+ * Creates an {@link Amity.Message}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ * @async
+ */
+export const createMessage = async <T extends Amity.MessageContentType>(
+  bundle: createMessageParam<T>,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/createMessage', bundle);
+
+  const optimisticData = createMessageOptimistic<T>(bundle);
+
+  const referenceId = bundle.referenceId || uniqueId || getLocalId();
+  uniqueId = undefined;
+
+  try {
+    const { data: payload } = await client.http.post<Amity.MessagePayload>('/api/v5/messages', {
+      ...convertParams(bundle),
+      referenceId,
+    });
+
+    const data = await prepareMessagePayload(payload);
+    const { messages } = data;
+
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) {
+      ingestInCache(data, { cachedAt });
+    }
+
+    fireEvent('local.message.created', {
+      messages: [{ ...messages[0], syncState: Amity.SyncState.Synced }],
+    });
+
+    return {
+      data: LinkedObject.message(messages[0]),
+      cachedAt,
+    };
+  } catch (e) {
+    fireEvent('local.message.created', {
+      messages: [{ ...optimisticData, syncState: Amity.SyncState.Error } as Amity.InternalMessage],
+    });
+
+    throw e;
+  }
 };
 /* end_public_function */

package/src/messageRepository/events/onMessageCreated.ts

@@ -1,11 +1,11 @@
 import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareMessagePayload } from '../utils';
 import { updateSubChannelUnreadFromMessage } from '~/marker/utils/updateSubChannelUnreadFromMessage';
 import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
-import { markReadMessage } from '../utils/markReadMessage';
 import { getActiveUser } from '~/client/api/activeUser';
+import { markReadMessage } from '../utils/markReadMessage';
+import { prepareMessagePayload } from '../utils';
 
 /**
  * ```js
@@ -64,10 +64,16 @@ export const onMessageCreatedLocal = (
   const client = getActiveClient();
 
   const disposers = [
-    createEventSubscriber(client, 'message/onMessageCreated', 'local.message.created', payload =>
-      payload.messages.forEach(message => {
-        callback(message);
-      }),
+    createEventSubscriber(
+      client,
+      'message/onMessageCreated',
+      'local.message.created',
+      async payload => {
+        ingestInCache(payload);
+        return payload.messages.forEach(message => {
+          callback(message);
+        });
+      },
     ),
   ];
 

package/src/messageRepository/observers/getMessages/MessageLiveCollectionController.ts

@@ -1,8 +1,7 @@
 import hash from 'object-hash';
 import { pullFromCache, pushToCache } from '~/cache/api';
-import { MessagePaginationController } from './MessagePaginationController';
-import { MessageQueryStreamController } from './MessageQueryStreamController';
 import {
+  onMessageCreatedLocal,
   onMessageCreatedMqtt,
   onMessageDeleted,
   onMessageFlagCleared,
@@ -18,6 +17,8 @@ import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
 import { filterByPropEquality } from '~/core/query';
 import { prepareMessagePayload } from '~/messageRepository/utils';
 import { LinkedObject } from '~/utils/linkedObject';
+import { MessageQueryStreamController } from './MessageQueryStreamController';
+import { MessagePaginationController } from './MessagePaginationController';
 
 export class MessageLiveCollectionController extends LiveCollectionController<
   'message',
@@ -52,31 +53,10 @@ export class MessageLiveCollectionController extends LiveCollectionController<
     this.loadPage({ initial: true });
   }
 
-  protected setup() {
-    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
-    if (!collection) {
-      pushToCache(this.cacheKey, {
-        data: [],
-        query: this.query,
-      });
-    }
-  }
-
-  protected async persistModel(response: Amity.MessagePayload & Amity.Pagination) {
-    await this.queryStreamController.saveToMainDB(response);
-  }
-
-  protected persistQueryStream({
-    response,
-    direction,
-    refresh,
-  }: Amity.LiveCollectionPersistQueryStreamParams<'message'>) {
-    this.queryStreamController.appendToQueryStream(response, direction, refresh);
-  }
-
   startSubscription() {
     return this.queryStreamController.subscribeRTE([
       { fn: onMessageCreatedMqtt, action: 'onCreate' },
+      { fn: onMessageCreatedLocal, action: 'onCreate' },
       { fn: onMessageDeleted, action: 'onDelete' },
       { fn: onMessageUpdated, action: 'onUpdate' },
       { fn: onMessageFlagged, action: 'onFlagged' },
@@ -160,4 +140,26 @@ export class MessageLiveCollectionController extends LiveCollectionController<
 
     return messages;
   }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        query: this.query,
+      });
+    }
+  }
+
+  protected async persistModel(response: Amity.MessagePayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(response);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'message'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
 }

package/src/messageRepository/observers/getMessages/MessageQueryStreamController.ts

@@ -72,6 +72,7 @@ export class MessageQueryStreamController extends QueryStreamController<
     return (payload: Amity.InternalMessage) => {
       if (action === 'onCreate') {
         const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+        const { referenceId } = payload;
 
         if (!collection) return;
         if (this.query.subChannelId !== payload?.subChannelId || !collection) return;
@@ -115,11 +116,11 @@ export class MessageQueryStreamController extends QueryStreamController<
           (!this.query.sortBy || this.query.sortBy === 'segmentDesc') &&
           !this.paginationController.getPrevToken()
         ) {
-          collection.data = [...new Set([payload.messageId, ...collection.data])];
+          collection.data = [...new Set([referenceId ?? payload.messageId, ...collection.data])];
         }
 
         if (this.query.sortBy === 'segmentAsc' && !this.paginationController.getNextToken()) {
-          collection.data = [...new Set([...collection.data, payload.messageId])];
+          collection.data = [...new Set([...collection.data, referenceId ?? payload.messageId])];
         }
 
         pushToCache(this.cacheKey, collection);

package/src/messageRepository/observers/observeMessages.ts

@@ -2,13 +2,13 @@ import { getActiveClient } from '~/client/api';
 import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
 import { convertEventPayload } from '~/utils/event';
 
+import { LinkedObject } from '~/utils/linkedObject';
 import {
+  onMessageCreatedLocal,
   onMessageCreatedMqtt,
-  onMessageUpdated,
   onMessageDeleted,
-  onMessageCreatedLocal,
+  onMessageUpdated,
 } from '../events';
-import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js

package/src/messageRepository/utils/prepareMessagePayload.ts

@@ -8,7 +8,6 @@ import { MessageContentType } from '~/@types';
 import { convertFromRaw as convertSubChannelFromRaw } from '~/subChannelRepository/utils/convertSubChannelFromRaw';
 import { updateSubChannelCache } from '~/subChannelRepository/utils/updateSubChannelCache';
 import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
-import { getMessageReadCount } from './getMessageReadCount';
 
 export function convertFromRaw(
   message: Amity.RawMessage,
@@ -62,6 +61,7 @@ export function convertFromRaw(
     subChannelId: messageFeedId,
     uniqueId: cache ? cache.data.uniqueId : messageId,
     referenceId,
+    syncState: Amity.SyncState.Synced,
   };
 
   if (mentionedUsers) {

package/src/postRepository/internalApi/getPost.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { prepareMembershipPayload } from '~/group/utils';
+
+export const getPost = async (
+  postId: Amity.InternalPost['postId'],
+): Promise<Amity.Cached<Amity.InternalPost>> => {
+  const client = getActiveClient();
+  client.log('post/getPost', postId);
+
+  isInTombstone('post', postId);
+
+  let payload: Amity.PostPayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.PostPayload>(
+      `/api/v3/posts/${encodeURIComponent(postId)}`,
+    );
+    payload = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('post', postId);
+    }
+
+    throw error;
+  }
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { posts } = data;
+
+  const result = posts.find(post => post.postId === postId)!;
+
+  return {
+    data: result,
+    cachedAt,
+  };
+};
+
+getPost.locally = (
+  postId: Amity.InternalPost['postId'],
+): Amity.Cached<Amity.InternalPost> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getPost.locally', postId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.InternalPost>(['post', 'get', postId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/postRepository/internalApi/index.ts

@@ -0,0 +1,16 @@
+export * from './getPostByIds';
+
+export * from './createPost';
+export * from './updatePost';
+export * from './editPost';
+
+export * from './deletePost';
+export * from './softDeletePost';
+export * from './hardDeletePost';
+
+export * from './approvePost';
+export * from './declinePost';
+
+export * from './flagPost';
+export * from './unflagPost';
+export * from './isPostFlaggedByMe';

package/src/postRepository/observers/getPost.ts

@@ -42,7 +42,14 @@ export const getPost = (
   postId: Amity.Post['postId'],
   callback: Amity.LiveObjectCallback<Amity.Post>,
 ): Amity.Unsubscriber => {
-  return liveObject(postId, callback, 'postId', _getPost, [
+  const responder: Amity.LiveObjectCallback<Amity.InternalPost> = (
+    snapshot: Amity.LiveObject<Amity.InternalPost>,
+  ) => {
+    const { data } = snapshot;
+    callback({ ...snapshot, data: data ? LinkedObject.post(snapshot.data) : data });
+  };
+
+  return liveObject(postId, responder, 'postId', _getPost, [
     onPostApproved,
     onPostDeclined,
     (callback: Amity.Listener<Amity.InternalPost>) => {

package/src/postRepository/observers/getPosts/PostLiveCollectionController.ts

@@ -0,0 +1,190 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { PostPaginationController } from './PostPaginationController';
+import { PostQueryStreamController } from './PostQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onPostCreated,
+  onPostUpdated,
+  onPostDeleted,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+  onPostApproved,
+  onPostDeclined,
+} from '~/postRepository/events';
+import {
+  filterByFeedType,
+  filterByPostDataTypes,
+  filterByPropEquality,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import { isNonNullable } from '~/utils';
+import { EnumPostActions } from './enums';
+import { LinkedObject } from '~/utils/linkedObject';
+import { preparePostPayload } from '~/postRepository/utils/payload';
+import { convertEventPayload } from '~/utils/event';
+import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
+import { getPost } from '~/postRepository/internalApi/getPost';
+
+export class PostLiveCollectionController extends LiveCollectionController<
+  'post',
+  Amity.PostLiveCollection,
+  Amity.Post,
+  PostPaginationController
+> {
+  private queryStreamController: PostQueryStreamController;
+
+  private query: Amity.PostLiveCollection;
+
+  constructor(query: Amity.PostLiveCollection, callback: Amity.LiveCollectionCallback<Amity.Post>) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['posts', 'collection', queryStreamId];
+    const paginationController = new PostPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new PostQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      preparePostPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.PostPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'post'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
+      { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
+      { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
+      { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
+      { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
+      { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+      { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
+      { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+      { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+      {
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.InternalComment>) => {
+            return onCommentCreated(async (comment: Amity.InternalComment) => {
+              const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(
+                this.cacheKey,
+              )?.data;
+
+              if (!currentCollection || currentCollection.data.includes(comment.referenceId))
+                return;
+
+              await getPost(comment.referenceId);
+              callback(comment);
+            });
+          },
+          'referenceId',
+          'post',
+        ),
+        action: EnumPostActions.OnPostUpdated,
+      },
+      {
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.InternalComment>) => {
+            return onCommentDeleted(async (comment: Amity.InternalComment) => {
+              const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(
+                this.cacheKey,
+              )?.data;
+
+              if (!currentCollection || currentCollection.data.includes(comment.referenceId))
+                return;
+
+              await getPost(comment.referenceId);
+              callback(comment);
+            });
+          },
+          'referenceId',
+          'post',
+        ),
+        action: EnumPostActions.OnPostUpdated,
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalPost>(['post', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? [],
+    ).map(LinkedObject.post);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.InternalPost[]) {
+    let posts = data;
+
+    if (!this.query.includeDeleted) {
+      posts = filterByPropEquality(posts, 'isDeleted', false);
+    }
+
+    if (this.query.tags) {
+      posts = posts.filter(p => p.tags?.some(t => this.query.tags?.includes(t)));
+    }
+
+    if (this.query.targetType === 'community' && this.query.feedType) {
+      posts = filterByFeedType(posts, this.query.feedType);
+    }
+
+    if (this.query.dataTypes?.length) {
+      posts = filterByPostDataTypes(posts, this.query.dataTypes);
+    }
+
+    switch (this.query.sortBy) {
+      case 'firstCreated':
+        posts = posts.sort(sortByFirstCreated);
+        break;
+      case 'lastCreated':
+      default:
+        posts = posts.sort(sortByLastCreated);
+        break;
+    }
+
+    return posts;
+  }
+}