@lemoncloud/chatic-sockets-lib 0.2.0 → 0.2.1

package/dist/lib/channel/types.d.ts

@@ -0,0 +1,175 @@
+import type { InferSocketRequest, SocketRequestMessage } from '../types';
+import type { ChannelStereo } from '../../modules/chat/types';
+export interface ChannelCreateRequestData {
+    stereo: ChannelStereo;
+    name?: string;
+}
+export interface ChannelByIdRequestData {
+    channelId: string;
+}
+export interface ChannelLeaveRequestData {
+    channelId: string;
+    userId?: string;
+}
+export interface ChannelMineRequestData {
+    page?: number;
+    limit?: number;
+    detail?: boolean;
+    hasSite?: boolean;
+}
+export interface ChannelUpdateRequestData {
+    channelId: string;
+    name?: string;
+    desc?: string;
+    thumbnail?: string;
+}
+export interface ChannelInviteRequestData {
+    channelId: string;
+    userIds: string[];
+}
+export interface ChannelListUserRequestData {
+    channelId: string;
+    limit?: number;
+    page?: number;
+    detail?: boolean;
+}
+export interface ChannelUpdateJoinRequestData {
+    channelId: string;
+    joinId?: string;
+    nick?: string;
+    notify?: '' | 'all' | 'mention' | 'none';
+}
+export interface ChannelSyncRequestData {
+    since?: number;
+}
+export interface ChannelSyncUsersRequestData {
+    channelId: string;
+    since?: number;
+}
+declare module '../types' {
+    interface SocketPacketRegistry {
+        'channel.create': {
+            request: ChannelCreateRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.join': {
+            request: ChannelByIdRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.leave': {
+            request: ChannelLeaveRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.get-self': {
+            request: Record<string, never>;
+            response: unknown;
+            error: null;
+        };
+        'channel.mine': {
+            request: ChannelMineRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.list-user': {
+            request: ChannelListUserRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.invite': {
+            request: ChannelInviteRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.update': {
+            request: ChannelUpdateRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.update-join': {
+            request: ChannelUpdateJoinRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.delete': {
+            request: ChannelByIdRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.sync': {
+            request: ChannelSyncRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.sync-users': {
+            request: ChannelSyncUsersRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.sync-site-profile': {
+            request: ChannelSyncRequestData;
+            response: unknown;
+            error: null;
+        };
+        'channel.unreads': {
+            request: Record<string, never>;
+            response: unknown;
+            error: null;
+        };
+    }
+}
+export declare type ChannelCreateType = 'channel.create';
+export declare type ChannelCreateInput = InferSocketRequest<ChannelCreateType>;
+export declare type ChannelCreateRequestMessage = SocketRequestMessage<ChannelCreateType>;
+export declare type ChannelJoinType = 'channel.join';
+export declare type ChannelJoinInput = InferSocketRequest<ChannelJoinType>;
+export declare type ChannelJoinRequestMessage = SocketRequestMessage<ChannelJoinType>;
+export declare type ChannelLeaveType = 'channel.leave';
+export declare type ChannelLeaveInput = InferSocketRequest<ChannelLeaveType>;
+export declare type ChannelLeaveRequestMessage = SocketRequestMessage<ChannelLeaveType>;
+export declare type ChannelGetSelfType = 'channel.get-self';
+export declare type ChannelGetSelfInput = InferSocketRequest<ChannelGetSelfType>;
+export declare type ChannelGetSelfRequestMessage = SocketRequestMessage<ChannelGetSelfType>;
+export declare type ChannelMineType = 'channel.mine';
+export declare type ChannelMineInput = InferSocketRequest<ChannelMineType>;
+export declare type ChannelListMyInput = ChannelMineInput;
+export declare type ChannelMineRequestMessage = SocketRequestMessage<ChannelMineType>;
+export declare type ChannelListUserType = 'channel.list-user';
+export declare type ChannelListUserInput = InferSocketRequest<ChannelListUserType>;
+export declare type ChannelListUserRequestMessage = SocketRequestMessage<ChannelListUserType>;
+export declare type ChannelInviteType = 'channel.invite';
+export declare type ChannelInviteInput = InferSocketRequest<ChannelInviteType>;
+export declare type ChannelInviteRequestMessage = SocketRequestMessage<ChannelInviteType>;
+export declare type ChannelUpdateType = 'channel.update';
+export declare type ChannelUpdateInput = InferSocketRequest<ChannelUpdateType>;
+export declare type ChannelUpdateRequestMessage = SocketRequestMessage<ChannelUpdateType>;
+export declare type ChannelUpdateJoinType = 'channel.update-join';
+export declare type ChannelUpdateJoinInput = InferSocketRequest<ChannelUpdateJoinType>;
+export declare type JoinUpdateInput = ChannelUpdateJoinInput;
+export declare type ChannelUpdateJoinRequestMessage = SocketRequestMessage<ChannelUpdateJoinType>;
+export declare type ChannelDeleteType = 'channel.delete';
+export declare type ChannelDeleteInput = InferSocketRequest<ChannelDeleteType>;
+export declare type ChannelDeleteRequestMessage = SocketRequestMessage<ChannelDeleteType>;
+export declare type ChannelSyncType = 'channel.sync';
+export declare type ChannelSyncInput = InferSocketRequest<ChannelSyncType>;
+export declare type ChannelSyncRequestMessage = SocketRequestMessage<ChannelSyncType>;
+export declare type ChannelSyncUsersType = 'channel.sync-users';
+export declare type ChannelSyncUsersInput = InferSocketRequest<ChannelSyncUsersType>;
+export declare type ChannelSyncUsersRequestMessage = SocketRequestMessage<ChannelSyncUsersType>;
+export declare type ChannelSyncProfileType = 'channel.sync-site-profile';
+export declare type ChannelSyncProfileInput = InferSocketRequest<ChannelSyncProfileType>;
+export declare type ChannelSyncSiteProfileInput = ChannelSyncProfileInput;
+export declare type ChannelSyncProfileRequestMessage = SocketRequestMessage<ChannelSyncProfileType>;
+export declare type ChannelUnreadsType = 'channel.unreads';
+export declare type ChannelUnreadsInput = InferSocketRequest<ChannelUnreadsType>;
+export declare type ChannelUnreadsRequestMessage = SocketRequestMessage<ChannelUnreadsType>;
+export declare type ChatStartInput = ChannelCreateInput;
+export declare type ChatMineInput = ChannelMineInput;
+export declare type ChatUsersInput = ChannelListUserInput;
+export declare type ChatInviteInput = ChannelInviteInput;
+export declare type ChatLeaveInput = ChannelLeaveInput;
+export declare type ChatUpdateChannelInput = ChannelUpdateInput;
+export declare type ChatUpdateJoinInput = ChannelUpdateJoinInput;
+export declare type ChatDeleteChannelInput = ChannelDeleteInput;

package/dist/lib/channel/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/chat/types.d.ts

@@ -0,0 +1,79 @@
+import type { InferSocketRequest, SocketRequestMessage } from '../types';
+export interface ChatSendRequestData {
+    channelId: string;
+    content: string;
+    contentType?: string;
+    parentId?: string;
+}
+export interface ChatReadRequestData {
+    channelId: string;
+    chatNo: number;
+}
+export interface ChatFeedRequestData {
+    channelId: string;
+    cursorNo?: number;
+    limit?: number;
+}
+export interface ChatUpdateRequestData {
+    id: string;
+    content?: string;
+    contentType?: string;
+}
+export interface ChatDeleteRequestData {
+    id: string;
+}
+export interface ChatGetRequestData {
+    id: string;
+}
+declare module '../types' {
+    interface SocketPacketRegistry {
+        'chat.send': {
+            request: ChatSendRequestData;
+            response: unknown;
+            error: null;
+        };
+        'chat.read': {
+            request: ChatReadRequestData;
+            response: unknown;
+            error: null;
+        };
+        'chat.feed': {
+            request: ChatFeedRequestData;
+            response: unknown;
+            error: null;
+        };
+        'chat.update': {
+            request: ChatUpdateRequestData;
+            response: unknown;
+            error: null;
+        };
+        'chat.delete': {
+            request: ChatDeleteRequestData;
+            response: unknown;
+            error: null;
+        };
+        'chat.get': {
+            request: ChatGetRequestData;
+            response: unknown;
+            error: null;
+        };
+    }
+}
+export declare type ChatSendType = 'chat.send';
+export declare type ChatSendInput = InferSocketRequest<ChatSendType>;
+export declare type ChatSendRequestMessage = SocketRequestMessage<ChatSendType>;
+export declare type ChatReadType = 'chat.read';
+export declare type ChatReadInput = InferSocketRequest<ChatReadType>;
+export declare type ChatReadRequestMessage = SocketRequestMessage<ChatReadType>;
+export declare type ChatFeedType = 'chat.feed';
+export declare type ChatFeedInput = InferSocketRequest<ChatFeedType>;
+export declare type ChatFeedRequestMessage = SocketRequestMessage<ChatFeedType>;
+export declare type ChatUpdateType = 'chat.update';
+export declare type ChatUpdateInput = InferSocketRequest<ChatUpdateType>;
+export declare type ChatUpdateRequestMessage = SocketRequestMessage<ChatUpdateType>;
+export declare type ChatDeleteType = 'chat.delete';
+export declare type ChatDeleteInput = InferSocketRequest<ChatDeleteType>;
+export declare type ChatDeleteRequestMessage = SocketRequestMessage<ChatDeleteType>;
+export declare type ChatGetType = 'chat.get';
+export declare type ChatGetInput = InferSocketRequest<ChatGetType>;
+export declare type ChatGetRequestMessage = SocketRequestMessage<ChatGetType>;

package/dist/lib/chat/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/cloud/types.d.ts

@@ -0,0 +1,18 @@
+import type { InferSocketRequest, SocketRequestMessage } from '../types';
+export interface CloudUpdateRequestData {
+    cloudId?: string;
+    name?: string;
+}
+declare module '../types' {
+    interface SocketPacketRegistry {
+        'cloud.update': {
+            request: CloudUpdateRequestData;
+            response: unknown;
+            error: null;
+        };
+    }
+}
+export declare type CloudUpdateType = 'cloud.update';
+export declare type CloudUpdateInput = InferSocketRequest<CloudUpdateType>;
+export declare type UpdateCloudInput = CloudUpdateInput;
+export declare type CloudUpdateRequestMessage = SocketRequestMessage<CloudUpdateType>;

package/dist/lib/cloud/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/device/types.d.ts

@@ -42,6 +42,7 @@ export declare type DeviceGetType = 'device.read';
 export declare type DeviceGetResponseData = InferSocketResponse<DeviceGetType>;
 export declare type DeviceGetErrorData = InferSocketError<DeviceGetType>;
 export declare type DeviceGetInput = InferSocketRequest<DeviceGetType>;
+export declare type DeviceReadInput = DeviceGetInput;
 export declare type DeviceGetRequestMessage = SocketRequestMessage<DeviceGetType>;
 export declare type DeviceGetResponseMessage = SocketResponseMessage<DeviceGetType>;
 export declare type DeviceGetErrorMessage = SocketErrorMessage<DeviceGetType>;

package/dist/lib/socket-actions.d.ts

@@ -0,0 +1,239 @@
+/**
+ * `socket-actions.ts`
+ * - supported wsv2 socket domain/action lookup table.
+ *
+ * Keep this file client-safe. It is used as a public type contract and must not
+ * import server-side modules.
+ */
+/**
+ * lookup table
+ * - wsv2에서 공개/지원하는 socket action 목록
+ */
+export declare const SocketActionTypeLUT: {
+    /**
+     * DomainType
+     * - message domain
+     */
+    readonly DomainType: {
+        readonly '': "";
+        /** system - builtin/system messages */
+        readonly system: "system";
+        /** sockets - socket connection helpers */
+        readonly sockets: "sockets";
+        /** device - client device state */
+        readonly device: "device";
+        /** auth - connection authentication */
+        readonly auth: "auth";
+        /** channel - chat channel operations */
+        readonly channel: "channel";
+        /** chat - chat message operations */
+        readonly chat: "chat";
+        /** user - user/site profile operations */
+        readonly user: "user";
+        /** cloud - cloud profile operations */
+        readonly cloud: "cloud";
+    };
+    /**
+     * SystemActionType
+     * - system 도메인 액션
+     */
+    readonly SystemActionType: {
+        readonly '': "";
+        /** ping - keep-alive request */
+        readonly ping: "ping";
+        /** pong - keep-alive response/event */
+        readonly pong: "pong";
+        /** info - connection/server information */
+        readonly info: "info";
+        /** message - generic system message */
+        readonly message: "message";
+        /** error - generic system error */
+        readonly error: "error";
+    };
+    /**
+     * SocketsActionType
+     * - sockets 도메인 액션
+     */
+    readonly SocketsActionType: {
+        readonly '': "";
+        /** find-connection - find or create current connection model */
+        readonly 'find-connection': "find-connection";
+    };
+    /**
+     * DeviceActionType
+     * - device 도메인 액션
+     */
+    readonly DeviceActionType: {
+        readonly '': "";
+        /** save - create or update linked device */
+        readonly save: "save";
+        /** read - read linked or requested device */
+        readonly read: "read";
+        /** sync - client device state sync hint */
+        readonly sync: "sync";
+    };
+    /**
+     * AuthActionType
+     * - auth 도메인 액션
+     */
+    readonly AuthActionType: {
+        readonly '': "";
+        /** update - update authentication state for current connection */
+        readonly update: "update";
+    };
+    /**
+     * ChannelActionType
+     * - channel 도메인 액션
+     */
+    readonly ChannelActionType: {
+        readonly '': "";
+        /** create - create a channel */
+        readonly create: "create";
+        /** join - join a channel */
+        readonly join: "join";
+        /** leave - leave or kick from a channel */
+        readonly leave: "leave";
+        /** get-self - get or create personal channel */
+        readonly 'get-self': "get-self";
+        /** mine - list my channels */
+        readonly mine: "mine";
+        /** list-user - list channel members */
+        readonly 'list-user': "list-user";
+        /** invite - invite users to a channel */
+        readonly invite: "invite";
+        /** update - update channel information */
+        readonly update: "update";
+        /** update-join - update channel participation settings */
+        readonly 'update-join': "update-join";
+        /** delete - delete a channel */
+        readonly delete: "delete";
+        /** sync - synchronize channel list/state */
+        readonly sync: "sync";
+        /** sync-users - synchronize channel users */
+        readonly 'sync-users': "sync-users";
+        /** sync-site-profile - synchronize related site profile */
+        readonly 'sync-site-profile': "sync-site-profile";
+        /** unreads - get unread message summary */
+        readonly unreads: "unreads";
+    };
+    /**
+     * ChatActionType
+     * - chat 도메인 액션
+     */
+    readonly ChatActionType: {
+        readonly '': "";
+        /** send - send chat message */
+        readonly send: "send";
+        /** read - mark chat message/channel as read */
+        readonly read: "read";
+        /** feed - get chat feed */
+        readonly feed: "feed";
+    };
+    /**
+     * UserActionType
+     * - user 도메인 액션
+     */
+    readonly UserActionType: {
+        readonly '': "";
+        /** invite - invite a user */
+        readonly invite: "invite";
+        /** invite-batch - invite multiple users */
+        readonly 'invite-batch': "invite-batch";
+        /** my-site - list accessible sites */
+        readonly 'my-site': "my-site";
+        /** make-site - create a site */
+        readonly 'make-site': "make-site";
+        /** update-profile - update user profile */
+        readonly 'update-profile': "update-profile";
+        /** update-site - update site profile */
+        readonly 'update-site': "update-site";
+        /** get-site-profile - get site profile */
+        readonly 'get-site-profile': "get-site-profile";
+        /** set-site-profile - set site profile */
+        readonly 'set-site-profile': "set-site-profile";
+    };
+    /**
+     * CloudActionType
+     * - cloud 도메인 액션
+     */
+    readonly CloudActionType: {
+        readonly '': "";
+        /** update - update cloud profile */
+        readonly update: "update";
+    };
+};
+declare type SocketActionKeyOf<T> = Extract<keyof T, string>;
+declare type NonEmptySocketAction<T extends string> = Exclude<T, ''>;
+/**
+ * type: `SocketDomainType`
+ */
+export declare type SocketDomainType = SocketActionKeyOf<typeof SocketActionTypeLUT.DomainType>;
+/**
+ * type: `SocketSystemActionType`
+ */
+export declare type SocketSystemActionType = SocketActionKeyOf<typeof SocketActionTypeLUT.SystemActionType>;
+/**
+ * type: `SocketSocketsActionType`
+ */
+export declare type SocketSocketsActionType = SocketActionKeyOf<typeof SocketActionTypeLUT.SocketsActionType>;
+/**
+ * type: `SocketDeviceActionType`
+ */
+export declare type SocketDeviceActionType = SocketActionKeyOf<typeof SocketActionTypeLUT.DeviceActionType>;
+/**
+ * type: `SocketAuthActionType`
+ */
+export declare type SocketAuthActionType = SocketActionKeyOf<typeof SocketActionTypeLUT.AuthActionType>;
+/**
+ * type: `SocketChannelActionType`
+ */
+export declare type SocketChannelActionType = SocketActionKeyOf<typeof SocketActionTypeLUT.ChannelActionType>;
+/**
+ * type: `SocketChatActionType`
+ */
+export declare type SocketChatActionType = SocketActionKeyOf<typeof SocketActionTypeLUT.ChatActionType>;
+/**
+ * type: `SocketUserActionType`
+ */
+export declare type SocketUserActionType = SocketActionKeyOf<typeof SocketActionTypeLUT.UserActionType>;
+/**
+ * type: `SocketCloudActionType`
+ */
+export declare type SocketCloudActionType = SocketActionKeyOf<typeof SocketActionTypeLUT.CloudActionType>;
+/**
+ * type: `SocketActionType`
+ */
+export declare type SocketActionType = SocketSystemActionType | SocketSocketsActionType | SocketDeviceActionType | SocketAuthActionType | SocketChannelActionType | SocketChatActionType | SocketUserActionType | SocketCloudActionType;
+/**
+ * interface: `SocketActionTypeMap`
+ * - domain to action type map
+ */
+export interface SocketActionTypeMap {
+    system: SocketSystemActionType;
+    sockets: SocketSocketsActionType;
+    device: SocketDeviceActionType;
+    auth: SocketAuthActionType;
+    channel: SocketChannelActionType;
+    chat: SocketChatActionType;
+    user: SocketUserActionType;
+    cloud: SocketCloudActionType;
+}
+/**
+ * type: `SocketSupportedDomainType`
+ */
+export declare type SocketSupportedDomainType = keyof SocketActionTypeMap;
+/**
+ * type: `SocketSupportedActionType`
+ */
+export declare type SocketSupportedActionType = NonEmptySocketAction<SocketActionType>;
+/**
+ * type: `SocketActionTypeOf`
+ */
+export declare type SocketActionTypeOf<TDomain extends SocketSupportedDomainType> = SocketActionTypeMap[TDomain];
+/**
+ * type: `SocketPacketActionType`
+ */
+export declare type SocketPacketActionType = {
+    [TDomain in SocketSupportedDomainType]: `${TDomain}.${NonEmptySocketAction<SocketActionTypeMap[TDomain]>}`;
+}[SocketSupportedDomainType];
+export {};