@omujs/chat 0.9.10 → 0.9.26

package/package.json

@@ -1,39 +1,28 @@
 {
-  "type": "module",
-  "name": "@omujs/chat",
-  "version": "0.9.10",
-  "exports": {
-    ".": {
-      "import": "./dist/esm/index.js",
-      "types": "./dist/dts/index.d.ts"
+    "type": "module",
+    "name": "@omujs/chat",
+    "version": "0.9.26",
+    "exports": {
+        ".": {
+            "import": "./dist/esm/index.js",
+            "types": "./dist/dts/index.d.ts"
+        },
+        "./*": {
+            "import": "./dist/esm/*/index.js",
+            "types": "./dist/dts/*/index.d.js"
+        }
     },
-    "./*": {
-      "import": "./dist/esm/*",
-      "types": "./dist/dts/*"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/OMUAPPS/omuapps"
-  },
-  "devDependencies": {
-    "eslint": "^9.9.1",
-    "nodemon": "^3.1.4",
-    "@omujs/eslint-config": "1.0.0",
-    "@omujs/omu": "0.9.10"
-  },
-  "dependencies": {
-    "@omujs/omu": "0.9.10"
-  },
-  "gitHead": "04559d5aec52117d707e0d554ee429b858da522a",
-  "scripts": {
-    "build": "pnpm run ts",
-    "dev": "pnpm run watch",
-    "ts": "pnpm run ts-esm && pnpm run ts-dts",
-    "ts-dts": "tsc --outDir dist/dts --declaration true --emitDeclarationOnly true --declarationMap true",
-    "ts-esm": "tsc --outDir dist/esm",
-    "watch": "nodemon -w src -e ts,json --exec \"pnpm --workspace-root build --only @omujs/chat\"",
-    "lint": "eslint .",
-    "fix": "eslint . --fix"
-  }
-}
+    "scripts": {
+        "build": "bun ../../scripts/package-helper.ts --glob --entrypoint \"src/**/*.ts\" --outdir \"dist/esm\" --dtsdir \"../dts\" --root \"src/\"",
+        "dev": "bun run watch",
+        "watch": "bun ../../scripts/package-helper.ts --glob --entrypoint \"src/**/*.ts\" --outdir \"dist/esm\" --dtsdir \"../dts\" --root \"src/\" --watch"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/OMUAPPS/omuapps"
+    },
+    "dependencies": {
+        "@omujs/omu": "0.9.26"
+    },
+    "gitHead": "04559d5aec52117d707e0d554ee429b858da522a"
+}

package/src/chat.ts

@@ -1,86 +1,92 @@
-import type { Client } from '@omujs/omu/client.js';
-import { EndpointType } from '@omujs/omu/extension/endpoint/endpoint.js';
-import type { Signal } from '@omujs/omu/extension/signal/signal.js';
-import { SignalPermissions, SignalType } from '@omujs/omu/extension/signal/signal.js';
-import type { Table } from '@omujs/omu/extension/table/index.js';
-import { TableType } from '@omujs/omu/extension/table/index.js';
-import { Serializer } from '@omujs/omu/serializer.js';
+import type { Omu } from '@omujs/omu';
+import { Serializer } from '@omujs/omu';
+import { EndpointType } from '@omujs/omu/api/endpoint';
+import type { Signal } from '@omujs/omu/api/signal';
+import { SignalType } from '@omujs/omu/api/signal';
+import type { Table } from '@omujs/omu/api/table';
+import { TableType } from '@omujs/omu/api/table';
 
-import { IDENTIFIER } from './const.js';
-import type { EventHandler, EventSource } from './event/event.js';
-import { EventRegistry } from './event/event.js';
-import { Author, Channel, Message, Provider, Reaction, Room, Vote } from './models/index.js';
+import { PLUGIN_ID } from './const';
+import type { EventHandler, EventSource } from './event';
+import { EventRegistry } from './event';
+import { Author, Channel, Message, Provider, Reaction, Room, Vote } from './models';
 import {
     CHAT_CHANNEL_TREE_PERMISSION_ID,
     CHAT_PERMISSION_ID,
     CHAT_READ_PERMISSION_ID,
     CHAT_WRITE_PERMISSION_ID,
-} from './permissions.js';
+} from './permissions';
 
-const MESSAGE_TABLE_TYPE = TableType.createModel(IDENTIFIER, {
+const MESSAGE_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
     name: 'messages',
-    model: Message,
+    serializer: Message,
+    key: (item) => item.key(),
     permissions: {
         all: CHAT_PERMISSION_ID,
         read: CHAT_READ_PERMISSION_ID,
         write: CHAT_WRITE_PERMISSION_ID,
     },
 });
-const AUTHOR_TABLE_TYPE = TableType.createModel(IDENTIFIER, {
+const AUTHOR_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
     name: 'authors',
-    model: Author,
+    serializer: Author,
+    key: (item) => item.key(),
     permissions: {
         all: CHAT_PERMISSION_ID,
         read: CHAT_READ_PERMISSION_ID,
         write: CHAT_WRITE_PERMISSION_ID,
     },
 });
-const CHANNEL_TABLE_TYPE = TableType.createModel(IDENTIFIER, {
+const CHANNEL_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
     name: 'channels',
-    model: Channel,
+    serializer: Channel,
+    key: (item) => item.key(),
     permissions: {
         all: CHAT_PERMISSION_ID,
         read: CHAT_READ_PERMISSION_ID,
         write: CHAT_WRITE_PERMISSION_ID,
     },
 });
-const PROVIDER_TABLE_TYPE = TableType.createModel(IDENTIFIER, {
+const PROVIDER_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
     name: 'providers',
-    model: Provider,
+    serializer: Provider,
+    key: (item) => item.key(),
     permissions: {
         all: CHAT_PERMISSION_ID,
         read: CHAT_READ_PERMISSION_ID,
         write: CHAT_WRITE_PERMISSION_ID,
     },
 });
-const ROOM_TABLE_TYPE = TableType.createModel(IDENTIFIER, {
+const ROOM_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
     name: 'rooms',
-    model: Room,
+    serializer: Room,
+    key: (item) => item.key(),
     permissions: {
         all: CHAT_PERMISSION_ID,
         read: CHAT_READ_PERMISSION_ID,
         write: CHAT_WRITE_PERMISSION_ID,
     },
 });
-const VOTE_TABLE_TYPE = TableType.createModel(IDENTIFIER, {
+const VOTE_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
     name: 'votes',
-    model: Vote,
+    serializer: Vote,
+    key: (item) => item.key(),
     permissions: {
         all: CHAT_PERMISSION_ID,
         read: CHAT_READ_PERMISSION_ID,
         write: CHAT_WRITE_PERMISSION_ID,
     },
 });
-const CREATE_CHANNEL_TREE_ENDPOINT = EndpointType.createJson(IDENTIFIER, {
+const CREATE_CHANNEL_TREE_ENDPOINT = EndpointType.createJson(PLUGIN_ID, {
     name: 'create_channel_tree',
     requestSerializer: Serializer.noop<string>(),
-    responseSerializer: Serializer.model(Channel).toArray(),
+    responseSerializer: Serializer.of(Channel).toArray(),
     permissionId: CHAT_CHANNEL_TREE_PERMISSION_ID,
 });
-const REACTION_SIGNAL = SignalType.createJson(IDENTIFIER, {
+const REACTION_SIGNAL = SignalType.createJson(PLUGIN_ID, {
     name: 'reaction',
-    serializer: Serializer.model(Reaction),
-    permissions: new SignalPermissions(CHAT_PERMISSION_ID),
+    serializer: Reaction,
+    permissions: { all: CHAT_PERMISSION_ID },
 });
 
 export class Chat {
@@ -93,30 +99,30 @@ export class Chat {
     public readonly reactionSignal: Signal<Reaction>;
     private readonly eventRegistry: EventRegistry;
 
-    private constructor(private readonly client: Client) {
-        client.server.require(IDENTIFIER);
-        client.permissions.require(CHAT_PERMISSION_ID);
+    private constructor(private readonly omu: Omu) {
+        omu.sessions.require(PLUGIN_ID);
+        omu.permissions.require(CHAT_PERMISSION_ID);
         this.eventRegistry = new EventRegistry(this);
-        this.messages = client.tables.get(MESSAGE_TABLE_TYPE);
-        this.authors = client.tables.get(AUTHOR_TABLE_TYPE);
-        this.channels = client.tables.get(CHANNEL_TABLE_TYPE);
-        this.providers = client.tables.get(PROVIDER_TABLE_TYPE);
-        this.rooms = client.tables.get(ROOM_TABLE_TYPE);
-        this.votes = client.tables.get(VOTE_TABLE_TYPE);
-        this.reactionSignal = client.signals.get(REACTION_SIGNAL);
+        this.messages = omu.tables.get(MESSAGE_TABLE_TYPE);
+        this.authors = omu.tables.get(AUTHOR_TABLE_TYPE);
+        this.channels = omu.tables.get(CHANNEL_TABLE_TYPE);
+        this.providers = omu.tables.get(PROVIDER_TABLE_TYPE);
+        this.rooms = omu.tables.get(ROOM_TABLE_TYPE);
+        this.votes = omu.tables.get(VOTE_TABLE_TYPE);
+        this.reactionSignal = omu.signals.get(REACTION_SIGNAL);
         this.messages.setCacheSize(1000);
         this.authors.setCacheSize(500);
     }
 
-    public static create(client: Client): Chat {
-        if (client.ready) {
+    public static create(omu: Omu): Chat {
+        if (omu.ready) {
             throw new Error('OMU instance is already started');
         }
-        return new Chat(client);
+        return new Chat(omu);
     }
 
     public async createChannelTree(url: string): Promise<Channel[]> {
-        return await this.client.endpoints.call(CREATE_CHANNEL_TREE_ENDPOINT, url);
+        return await this.omu.endpoints.call(CREATE_CHANNEL_TREE_ENDPOINT, url);
     }
 
     public on<P extends Array<any>>(event: EventSource<P>, handler: EventHandler<P>): void {

package/src/const.ts

@@ -1,3 +1,3 @@
-import { Identifier } from '@omujs/omu/identifier.js';
+import { Identifier } from '@omujs/omu';
 
-export const IDENTIFIER = new Identifier('com.omuapps', 'chat');
+export const PLUGIN_ID: Identifier = new Identifier('com.omuapps', 'chat');

package/src/event/event-types.ts

@@ -1,10 +1,16 @@
+import { Author } from '../models/author.js';
+import { Channel } from '../models/channel.js';
+import { Message } from '../models/message.js';
+import { Provider } from '../models/provider.js';
+import { Room } from '../models/room.js';
+import { Vote } from '../models/vote.js';
 import { TableEvent } from './event.js';
 
-export const events = {
-    message: new TableEvent((chat) => chat.messages),
-    author: new TableEvent((chat) => chat.authors),
-    channel: new TableEvent((chat) => chat.channels),
-    provider: new TableEvent((chat) => chat.providers),
-    room: new TableEvent((chat) => chat.rooms),
-    vote: new TableEvent((chat) => chat.votes),
+export const events: { Message: TableEvent<Message>; Author: TableEvent<Author>; Channel: TableEvent<Channel>; Provider: TableEvent<Provider>; Room: TableEvent<Room>; Vote: TableEvent<Vote> } = {
+    Message: new TableEvent((chat) => chat.messages),
+    Author: new TableEvent((chat) => chat.authors),
+    Channel: new TableEvent((chat) => chat.channels),
+    Provider: new TableEvent((chat) => chat.providers),
+    Room: new TableEvent((chat) => chat.rooms),
+    Vote: new TableEvent((chat) => chat.votes),
 };

package/src/event/event.ts

@@ -1,6 +1,6 @@
-import type { Unlisten } from '@omujs/omu/event-emitter.js';
-import { EventEmitter } from '@omujs/omu/event-emitter.js';
-import type { Table } from '@omujs/omu/extension/table/table.js';
+import type { Table } from '@omujs/omu/api/table';
+import type { Unlisten } from '@omujs/omu/event';
+import { EventEmitter } from '@omujs/omu/event';
 
 import type { Chat } from '../chat.js';
 
@@ -20,24 +20,24 @@ export class ListenerEvent<P extends Array<any>> implements EventSource<P> {
 }
 
 export class TableEvent<T> extends ListenerEvent<[Map<string, T>]> {
-    public readonly addBatch: ListenerEvent<[Map<string, T>]>;
-    public readonly updateBatch: ListenerEvent<[Map<string, T>]>;
-    public readonly removeBatch: ListenerEvent<[Map<string, T>]>;
-    public readonly add: EventSource<[T]>;
-    public readonly update: EventSource<[T]>;
-    public readonly remove: EventSource<[T]>;
-    public readonly clear: EventSource<[]>;
+    public readonly AddBatch: ListenerEvent<[Map<string, T>]>;
+    public readonly UpdateBatch: ListenerEvent<[Map<string, T>]>;
+    public readonly RemoveBatch: ListenerEvent<[Map<string, T>]>;
+    public readonly Add: EventSource<[T]>;
+    public readonly Update: EventSource<[T]>;
+    public readonly Remove: EventSource<[T]>;
+    public readonly Clear: EventSource<[]>;
     public readonly wrappers: Record<string, Unlisten>;
 
     constructor(private readonly getTable: (chat: Chat) => Table<T>) {
         super((chat) => getTable(chat).event.cacheUpdate);
-        this.addBatch = new ListenerEvent((chat) => getTable(chat).event.add);
-        this.updateBatch = new ListenerEvent((chat) => getTable(chat).event.update);
-        this.removeBatch = new ListenerEvent((chat) => getTable(chat).event.remove);
-        this.add = this.createBatchSubscriber((table) => table.event.add);
-        this.update = this.createBatchSubscriber((table) => table.event.update);
-        this.remove = this.createBatchSubscriber((table) => table.event.remove);
-        this.clear = new ListenerEvent((client) => getTable(client).event.clear);
+        this.AddBatch = new ListenerEvent((chat) => getTable(chat).event.add);
+        this.UpdateBatch = new ListenerEvent((chat) => getTable(chat).event.update);
+        this.RemoveBatch = new ListenerEvent((chat) => getTable(chat).event.remove);
+        this.Add = this.createBatchSubscriber((table) => table.event.add);
+        this.Update = this.createBatchSubscriber((table) => table.event.update);
+        this.Remove = this.createBatchSubscriber((table) => table.event.remove);
+        this.Clear = new ListenerEvent((client) => getTable(client).event.clear);
         this.wrappers = {};
     }
 
@@ -63,7 +63,7 @@ export class TableEvent<T> extends ListenerEvent<[Map<string, T>]> {
             return () => {
                 stopListen();
                 clearEvent();
-            }
+            };
         };
 
         return {

package/src/event/index.ts

@@ -1,2 +1,3 @@
+export { events as Events } from './event-types.js';
 export { EventHandler, EventRegistry, EventSource } from './event.js';
-export { events } from './event-types.js';
+

package/src/index.ts

@@ -1,5 +1,6 @@
 export { Chat } from './chat.js';
-export { events as ChatEvents, events } from './event/index.js';
-export * as models from './models/index.js';
-export * as permissions from './permissions.js';
-
+export { Events as ChatEvents } from './event';
+export * as Models from './models';
+export { Content };
+import { Content } from './models';
+export * as ChatPermissions from './permissions.js';

package/src/models/author.ts

@@ -1,6 +1,4 @@
-import { Identifier } from '@omujs/omu/identifier.js';
-import type { Keyable } from '@omujs/omu/interface.js';
-import type { Model } from '@omujs/omu/model.js';
+import { Identifier } from '@omujs/omu';
 
 import type { RoleJson } from './role.js';
 import { Role } from './role.js';
@@ -16,37 +14,37 @@ export type AuthorMetadata = {
 export type AuthorJson = {
     provider_id: string;
     id: string;
+    metadata: AuthorMetadata;
     name?: string;
     avatar_url?: string;
     roles?: RoleJson[];
-    metadata?: AuthorMetadata;
 };
 
-export class Author implements Keyable, Model<AuthorJson> {
+export class Author {
     public providerId: Identifier;
     public id: Identifier;
+    public metadata: AuthorMetadata;
     public name?: string;
     public avatarUrl?: string;
     public roles?: Role[];
-    public metadata?: AuthorMetadata;
 
     constructor(options: {
         providerId: Identifier;
         id: Identifier;
+        metadata?: AuthorMetadata;
         name?: string;
         avatarUrl?: string;
         roles?: Role[];
-        metadata?: AuthorMetadata;
     }) {
         this.providerId = options.providerId;
         this.id = options.id;
+        this.metadata = options.metadata || {};
         this.name = options.name;
         this.avatarUrl = options.avatarUrl;
         this.roles = options.roles;
-        this.metadata = options.metadata;
     }
 
-    static fromJson(info: AuthorJson): Author {
+    public static deserialize(info: AuthorJson): Author {
         return new Author({
             providerId: Identifier.fromKey(info.provider_id),
             id: Identifier.fromKey(info.id),
@@ -58,17 +56,17 @@ export class Author implements Keyable, Model<AuthorJson> {
     }
 
     key(): string {
-        return `${this.providerId}:${this.id}`;
+        return this.id.key();
     }
 
-    toJson(): AuthorJson {
+    public static serialize(item: Author): AuthorJson {
         return {
-            provider_id: this.providerId.key(),
-            id: this.id.key(),
-            name: this.name,
-            avatar_url: this.avatarUrl,
-            roles: this.roles?.map((role) => role.toJson()),
-            metadata: this.metadata,
+            provider_id: item.providerId.key(),
+            id: item.id.key(),
+            name: item.name,
+            avatar_url: item.avatarUrl,
+            roles: item.roles?.map((role) => role.toJson()),
+            metadata: item.metadata,
         };
     }
 }

package/src/models/channel.ts

@@ -1,6 +1,4 @@
-import { Identifier } from '@omujs/omu/identifier.js';
-import type { Keyable } from '@omujs/omu/interface.js';
-import type { Model } from '@omujs/omu/model.js';
+import { Identifier } from '@omujs/omu';
 
 export type ChannelJson = {
     provider_id: string;
@@ -12,7 +10,7 @@ export type ChannelJson = {
     icon_url: string;
 };
 
-export class Channel implements Model<ChannelJson>, Keyable {
+export class Channel {
     providerId: Identifier;
     id: Identifier;
     url: string;
@@ -39,7 +37,7 @@ export class Channel implements Model<ChannelJson>, Keyable {
         this.iconUrl = option.iconUrl;
     }
 
-    static fromJson(json: ChannelJson): Channel {
+    public static deserialize(json: ChannelJson): Channel {
         return new Channel({
             providerId: Identifier.fromKey(json.provider_id),
             id: Identifier.fromKey(json.id),
@@ -55,15 +53,15 @@ export class Channel implements Model<ChannelJson>, Keyable {
         return this.id.key();
     }
 
-    toJson(): ChannelJson {
+    public static serialize(item: Channel): ChannelJson {
         return {
-            provider_id: this.providerId.key(),
-            id: this.id.key(),
-            url: this.url,
-            name: this.name,
-            description: this.description,
-            active: this.active,
-            icon_url: this.iconUrl,
+            provider_id: item.providerId.key(),
+            id: item.id.key(),
+            url: item.url,
+            name: item.name,
+            description: item.description,
+            active: item.active,
+            icon_url: item.iconUrl,
         };
     }
 }