@amityco/ts-sdk 7.10.0 → 7.10.1-8b116307.0

package/dist/utils/linkedObject/eventLinkObject.d.ts

@@ -0,0 +1,2 @@
+export declare const eventLinkedObject: (event: Amity.InternalEvent) => Amity.Event;
+//# sourceMappingURL=eventLinkObject.d.ts.map

package/dist/utils/linkedObject/eventLinkObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventLinkObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/eventLinkObject.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB,UAAW,MAAM,aAAa,KAAG,WAqB9D,CAAC"}

package/dist/utils/linkedObject/index.d.ts

@@ -16,5 +16,6 @@ export declare const LinkedObject: {
     invitation: (invitation: Amity.InternalInvitation) => Amity.Invitation;
     joinRequest: (joinRequest: Amity.InternalJoinRequest) => Amity.JoinRequest;
     channelMember: (channelMember: Amity.Membership<"channel">) => Amity.Membership<"channel">;
+    event: (event: Amity.RawEvent) => Amity.Event;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/linkedObject/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/index.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;CAkBxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/index.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;CAmBxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "7.10.0",
+  "version": "7.10.1-8b116307.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/core/events.ts

@@ -160,6 +160,24 @@ declare global {
       'marker.userFeed-updated': Amity.UserFeedUpdatedPayload;
     };
 
+    type MqttEventEvents = {
+      'event.created': Amity.EventPayload;
+      'event.updated': Amity.EventPayload;
+      'event.deleted': Amity.EventPayload;
+      'event.started': Amity.EventPayload;
+      'event.ended': Amity.EventPayload;
+      'event.cancelled': Amity.EventPayload;
+    };
+
+    type MqttEventRSVPEvents = {
+      'event.rsvp.changed': Amity.EventPayload;
+    };
+
+    type MqttEventNotificationEvents = {
+      'event.reminder': Amity.EventPayload;
+      'event.invitation': Amity.EventPayload;
+    };
+
     type MqttRTE = MqttChannelEvents &
       MqttSubChannelEvents &
       MqttMessageEvents &
@@ -169,7 +187,10 @@ declare global {
       MqttUserEvents &
       MqttFollowEvents &
       MqttMarkerEvents &
-      MqttStoryEvents;
+      MqttStoryEvents &
+      MqttEventEvents &
+      MqttEventRSVPEvents &
+      MqttEventNotificationEvents;
 
     type LocalPostEvents = {
       'local.post.updated': Amity.PostPayload;
@@ -210,6 +231,24 @@ declare global {
       'local.follow.requestDeclined': Amity.FollowStatusPayload;
     };
 
+    type LocalEventEvents = {
+      'local.event.created': Amity.EventPayload;
+      'local.event.updated': Amity.EventPayload;
+      'local.event.deleted': Amity.EventPayload;
+      'local.event.started': Amity.EventPayload;
+      'local.event.ended': Amity.EventPayload;
+      'local.event.cancelled': Amity.EventPayload;
+    };
+
+    type LocalEventRSVPEvents = {
+      'local.event.rsvp.changed': Amity.EventPayload;
+    };
+
+    type LocalEventNotificationEvents = {
+      'local.event.reminder': Amity.EventPayload;
+      'local.event.invitation': Amity.EventPayload;
+    };
+
     type LocalEvents = {
       'local.channel.updated': MakeRequired<Amity.ProcessedChannelPayload, 'channels'>;
       'local.channel.fetched': Amity.StaticInternalChannel[];
@@ -287,7 +326,10 @@ declare global {
     } & LocalPostEvents &
       LocalCommentEvents &
       LocalCommunityEvents &
-      LocalFollowEvents;
+      LocalFollowEvents &
+      LocalEventEvents &
+      LocalEventRSVPEvents &
+      LocalEventNotificationEvents;
 
     type Events = WsEvents & MqttEvents & MqttRTE & LocalEvents;
   }

package/src/@types/core/model.ts

@@ -64,6 +64,8 @@ declare global {
       invitation: Amity.InternalInvitation;
 
       joinRequest: Amity.InternalJoinRequest;
+
+      event: Amity.InternalEvent;
     };
 
     type Model = ValueOf<Models>;
@@ -131,6 +133,8 @@ declare global {
 
       invitation: Pick<Amity.InternalInvitation, '_id'>;
       joinRequest: Pick<Amity.InternalJoinRequest, 'joinRequestId'>;
+
+      event: Pick<Amity.InternalEvent, 'eventId'>;
     };
   }
 }

package/src/@types/core/payload.ts

@@ -30,6 +30,7 @@ declare global {
       invitation: Amity.InvitationPayload;
       myInvitation: Amity.MyInvitationsPayload;
       joinRequest: Amity.CommunityJoinRequestPayload;
+      event: Amity.EventPayload;
     };
 
     type UserPayload = {
@@ -623,5 +624,19 @@ declare global {
     type StreamViewerUnbanPayload = { list: RawStreamViewerBan[] };
 
     type ChannelSetUserMutedPayload = RawChannelSetUserMuted;
+
+    type EventPayload = {
+      events: Amity.RawEvent[];
+      users: Amity.RawUser[];
+      files: Amity.File[];
+      videoStreamings: Amity.RawStream[];
+    };
+
+    type ProcessedEventPayload = {
+      events: Amity.InternalEvent[];
+      users: Amity.InternalUser[];
+      files: Amity.File[];
+      videoStreamings: Amity.InternalStream[];
+    };
   }
 }

package/src/@types/domains/event.ts

@@ -0,0 +1,81 @@
+export {};
+
+export enum AmityEventType {
+  Virtual = 'virtual',
+  InPerson = 'in_person',
+}
+
+export enum AmityEventOriginType {
+  Community = 'community',
+  User = 'user',
+}
+
+export enum AmityEventStatus {
+  Scheduled = 'scheduled',
+  Live = 'live',
+  Ended = 'ended',
+  Cancelled = 'cancelled',
+}
+
+declare global {
+  namespace Amity {
+    type EventType = AmityEventType;
+
+    type EventOriginType = AmityEventOriginType;
+
+    type EventStatus = AmityEventStatus;
+
+    type RawEvent = {
+      eventId: string;
+      userId: string;
+      publicId: string;
+      title: string;
+      description: string;
+      type: Amity.EventType;
+      status: Amity.EventStatus;
+      isInviteOnly: boolean;
+      startTime: Date;
+      endTime?: Date;
+      coverImageUrl: string;
+      originType: Amity.EventOriginType;
+      originId: string;
+      communityId?: string;
+      livestreamId?: string;
+      rsvpCount: number;
+      interestedCount: number;
+      isLocationVisible: boolean;
+      location?: string;
+      externalUrl?: string;
+    } & Amity.Taggable &
+      Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete;
+
+    type InternalEvent = RawEvent;
+
+    type Event = Amity.InternalEvent & Amity.EventLinkObject;
+
+    type EventLinkObject = {
+      discussionCommunity?: Amity.Community;
+      liveStream?: Amity.Stream;
+      creator?: Amity.User;
+    };
+
+    type EventCreatePayload = Pick<
+      Amity.Event,
+      | 'title'
+      | 'description'
+      | 'type'
+      | 'isInviteOnly'
+      | 'startTime'
+      | 'endTime'
+      | 'originType'
+      | 'originId'
+      | 'location'
+      | 'externalUrl'
+      | 'tags'
+    > & {
+      coverImageFileId?: string;
+    };
+  }
+}

package/src/@types/index.ts

@@ -47,3 +47,4 @@ export * from './domains/liveReaction';
 export * from './domains/feed';
 export * from './domains/hashtag';
 export * from './domains/user';
+export * from './domains/event';

package/src/eventRepository/api/createEvent.ts

@@ -0,0 +1,45 @@
+import { fireEvent } from '~/core/events';
+import { prepareEventPayload } from '../utils';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { eventLinkedObject } from '~/utils/linkedObject/eventLinkObject';
+
+/* begin_public_function
+  id: event.create
+*/
+/**
+ * ```js
+ * import { createEvent } from '@amityco/ts-sdk'
+ * const created = await createEvent(bundle)
+ * ```
+ *
+ * Creates an {@link Amity.Event}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Event}
+ * @returns The newly created {@link Amity.Event}
+ *
+ * @category Event API
+ * @async
+ */
+export const createEvent = async (
+  bundle: Amity.EventCreatePayload,
+): Promise<Amity.Cached<Amity.Event>> => {
+  const client = getActiveClient();
+  client.log('event/createEvent', bundle);
+
+  const { data: payload } = await client.http.post<Amity.EventPayload>('/api/v1/events', bundle);
+
+  const preparedPayload = prepareEventPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(preparedPayload, { cachedAt });
+
+  fireEvent('event.created', preparedPayload);
+
+  return {
+    data: eventLinkedObject(preparedPayload.events[0]),
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/eventRepository/api/index.ts

@@ -0,0 +1 @@
+export * from './createEvent';

package/src/eventRepository/index.ts

@@ -0,0 +1 @@
+export * from './api';

package/src/eventRepository/utils/index.ts

@@ -0,0 +1 @@
+export * from './prepareEventPayload';

package/src/eventRepository/utils/prepareEventPayload.ts

@@ -0,0 +1,10 @@
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+
+export const prepareEventPayload = (
+  rawPayload: Amity.EventPayload,
+): Amity.ProcessedEventPayload => {
+  return {
+    ...rawPayload,
+    users: rawPayload.users.map(convertRawUserToInternalUser),
+  };
+};

package/src/index.ts

@@ -57,3 +57,5 @@ export * as InvitationRepository from './invitationRepository';
 export * as LiveReactionRepository from './liveReactionRepository';
 
 export { GET_WATCHER_URLS } from './utils/linkedObject/streamLinkedObject';
+
+export * as EventRepository from './eventRepository';

package/src/utils/linkedObject/eventLinkObject.ts

@@ -0,0 +1,26 @@
+import { userLinkedObject } from './userLinkedObject';
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { communityLinkedObject } from './communityLinkedObject';
+
+export const eventLinkedObject = (event: Amity.InternalEvent): Amity.Event => {
+  return {
+    ...event,
+    get creator() {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', event.userId]);
+      if (!cacheData?.data) return;
+      return userLinkedObject(cacheData.data);
+    },
+    get discussionCommunity() {
+      if (!event.communityId) return;
+      const cacheData = pullFromCache<Amity.Community>(['community', 'get', event.communityId]);
+      if (!cacheData?.data) return;
+      return communityLinkedObject(cacheData.data);
+    },
+    get liveStream() {
+      if (!event.livestreamId) return;
+      const cacheData = pullFromCache<Amity.Stream>(['stream', 'get', event.livestreamId]);
+      if (!cacheData?.data) return;
+      return cacheData.data;
+    },
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -15,6 +15,7 @@ import { communityLinkedObject } from './communityLinkedObject';
 import { invitationLinkedObject } from './invitationLinkedObject';
 import { joinRequestLinkedObject } from './joinRequestLinkedObject';
 import { channelMemberLinkedObject } from './channelMemberLinkedObject';
+import { eventLinkedObject } from './eventLinkObject';
 
 export const LinkedObject = {
   ad: adLinkedObject,
@@ -34,4 +35,5 @@ export const LinkedObject = {
   invitation: invitationLinkedObject,
   joinRequest: joinRequestLinkedObject,
   channelMember: channelMemberLinkedObject,
+  event: eventLinkedObject,
 };