@omujs/omu 0.6.21 → 0.6.23

package/src/extension/table/packets.ts

@@ -1,4 +1,4 @@
-import { ByteReader, ByteWriter } from '../../bytebuffer.js';
+import { ByteReader, ByteWriter, Flags } from '../../bytebuffer.js';
 import { Identifier } from '../../identifier.js';
 
 import type { TableConfig } from './table.js';
@@ -114,31 +114,19 @@ export class TableProxyPacket {
 export class TableFetchPacket {
     constructor(
         public readonly id: Identifier,
-        public readonly before: number | null,
-        public readonly after: number | null,
-        public readonly cursor: string | null,
+        public readonly limit: number,
+        public readonly backward: boolean = false,
+        public readonly cursor: string | null = null,
     ) {}
 
     public static serialize(packet: TableFetchPacket): Uint8Array {
         const writer = new ByteWriter();
         writer.writeString(packet.id.key());
-        let flags = 0;
-        if (packet.before !== null) {
-            flags |= 0b1;
-        }
-        if (packet.after !== null) {
-            flags |= 0b10;
-        }
-        if (packet.cursor !== null) {
-            flags |= 0b100;
-        }
-        writer.writeByte(flags);
-        if (packet.before !== null) {
-            writer.writeInt(packet.before);
-        }
-        if (packet.after !== null) {
-            writer.writeInt(packet.after);
-        }
+        writer.writeInt(packet.limit);
+        const flags = new Flags({length: 2});
+        flags.set(0, packet.backward);
+        flags.set(1, packet.cursor !== null);
+        writer.writeFlags(flags);
         if (packet.cursor !== null) {
             writer.writeString(packet.cursor);
         }
@@ -148,11 +136,11 @@ export class TableFetchPacket {
     public static deserialize(data: Uint8Array): TableFetchPacket {
         const reader = new ByteReader(data);
         const id = Identifier.fromKey(reader.readString());
-        const flags = reader.readByte();
-        const before = flags & 0b1 ? reader.readInt() : null;
-        const after = flags & 0b10 ? reader.readInt() : null;
-        const cursor = flags & 0b100 ? reader.readString() : null;
-        return new TableFetchPacket(id, before, after, cursor);
+        const limit = reader.readInt();
+        const flags = reader.readFlags(2);
+        const backward = flags.get(0);
+        const cursor = flags.ifSet(1, () => reader.readString());
+        return new TableFetchPacket(id, limit, backward, cursor);
     }
 }
 

package/src/extension/table/table-extension.ts

@@ -80,6 +80,33 @@ const TABLE_ITEM_GET_ENDPOINT = EndpointType.createSerialized<TableKeysPacket, T
         permissionId: TABLE_PERMISSION_ID,
     },
 );
+const TABLE_ITEM_HAS_ENDPOINT = EndpointType.createSerialized<TableKeysPacket, Record<string, boolean>>(
+    TABLE_EXTENSION_TYPE,
+    {
+        name: 'item_has',
+        requestSerializer: TableKeysPacket,
+        responseSerializer: Serializer.json(),
+        permissionId: TABLE_PERMISSION_ID,
+    },
+);
+const TABLE_ITEM_HAS_ALL_ENDPOINT = EndpointType.createSerialized<TableKeysPacket, boolean>(
+    TABLE_EXTENSION_TYPE,
+    {
+        name: 'item_has_all',
+        requestSerializer: TableKeysPacket,
+        responseSerializer: Serializer.json(),
+        permissionId: TABLE_PERMISSION_ID,
+    },
+);
+const TABLE_ITEM_HAS_ANY_ENDPOINT = EndpointType.createSerialized<TableKeysPacket, boolean>(
+    TABLE_EXTENSION_TYPE,
+    {
+        name: 'item_has_any',
+        requestSerializer: TableKeysPacket,
+        responseSerializer: Serializer.json(),
+        permissionId: TABLE_PERMISSION_ID,
+    },
+);
 const TABLE_FETCH_ENDPOINT = EndpointType.createSerialized<TableFetchPacket, TableItemsPacket>(
     TABLE_EXTENSION_TYPE,
     {
@@ -277,6 +304,7 @@ class TableImpl<T> implements Table<T> {
         });
         client.event.ready.listen(() => this.onReady());
     }
+    
     private updateCache(items: Map<string, T>): void {
         if (!this.cacheSize) {
             this.cache = items;
@@ -412,18 +440,53 @@ class TableImpl<T> implements Table<T> {
         });
     }
 
+    public async has(key: string): Promise<boolean> {
+        if (this.cache.has(key)) {
+            return true;
+        }
+        const res = await this.client.endpoints.call(TABLE_ITEM_HAS_ENDPOINT, {
+            id: this.id,
+            keys: [key],
+        });
+        return res[key] ?? false;
+    }
+
+    public async hasMany<T extends Record<string, unknown>>(...keys: (keyof T)[]): Promise<{ [key in keyof T]: boolean }> {
+        const res = await this.client.endpoints.call(TABLE_ITEM_HAS_ENDPOINT, {
+            id: this.id,
+            keys: keys,
+        });
+        return res as { [key in keyof T]: boolean };
+    }
+
+    public async hasAll(...keys: string[]): Promise<boolean> {
+        const res = await this.client.endpoints.call(TABLE_ITEM_HAS_ALL_ENDPOINT, {
+            id: this.id,
+            keys,
+        });
+        return res;
+    }
+
+    public async hasAny(...keys: string[]): Promise<boolean> {
+        const res = await this.client.endpoints.call(TABLE_ITEM_HAS_ANY_ENDPOINT, {
+            id: this.id,
+            keys,
+        });
+        return res;
+    }
+
     public async fetchItems({
-        before,
-        after,
+        limit,
+        backward,
         cursor,
     }: {
-        before: number;
-        after: number;
+        limit: number;
+        backward?: boolean;
         cursor?: string;
     }): Promise<Map<string, T>> {
         const res = await this.client.endpoints.call(
             TABLE_FETCH_ENDPOINT,
-            new TableFetchPacket(this.id, before, after, cursor ?? null),
+            new TableFetchPacket(this.id, limit, backward, cursor),
         );
         const items = this.deserializeItems(res.items);
         this.updateCache(items);
@@ -463,30 +526,17 @@ class TableImpl<T> implements Table<T> {
         backward?: boolean;
         cursor?: string;
     }): AsyncIterable<T> {
-        let items: Map<string, T> = await this.fetchItems(
-            backward
-                ? {
-                    before: 0,
-                    after: this.cacheSize ?? 100,
-                    cursor,
-                }
-                : {
-                    before: this.cacheSize ?? 100,
-                    after: 0,
-                    cursor,
-                },
-        );
-        yield* items.values();
-        while (items.size > 0) {
-            const cursor = this.keyFunction(
-                backward ? items.values().next().value : [...items.values()].pop(),
-            );
-            items = await this.fetchItems(
-                backward
-                    ? { before: 0, after: this.cacheSize ?? 100, cursor }
-                    : { before: this.cacheSize ?? 100, after: 0, cursor },
-            );
+        while (true) {
+            const items = await this.fetchItems({
+                limit: this.cacheSize ?? 100,
+                backward,
+                cursor,
+            });
+            if (items.size === 0) {
+                break;
+            }
             yield* items.values();
+            cursor = this.keyFunction(backward ? items.values().next().value : [...items.values()].pop());
         }
     }
 

package/src/extension/table/table.ts

@@ -19,14 +19,18 @@ export interface Table<T> {
     update(...item: T[]): Promise<void>;
     remove(...items: T[]): Promise<void>;
     clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    hasMany<T extends Record<string, unknown>>(...keys: (keyof T)[]): Promise<{ [key in keyof T]: boolean }>;
+    hasAll(...keys: string[]): Promise<boolean>;
+    hasAny(...keys: string[]): Promise<boolean>;
 
     fetchItems({
-        before,
-        after,
+        limit,
+        backward,
         cursor,
     }: {
-        before?: number;
-        after?: number;
+        limit: number;
+        backward?: boolean;
         cursor?: string;
     }): Promise<Map<string, T>>;
     fetchRange({ start, end }: { start: string; end: string }): Promise<Map<string, T>>;

package/src/identifier.ts

@@ -55,18 +55,18 @@ export class Identifier implements Model<string>, Keyable {
         return new Identifier(namespace, ...path.split('/'));
     }
 
-    static fromUrl(url: string | URL): Identifier {
-        let parsedUrl: URL;
-        if (typeof url === 'string') {
-            parsedUrl = new URL(url);
-        } else {
-            parsedUrl = url;
-        }
-        const namespace = parsedUrl.hostname.split('.').reverse().join('.');
+    public static fromUrl(url: string | URL): Identifier {
+        const parsedUrl = new URL(url);
+        const namespace = Identifier.namespaceFromUrl(parsedUrl.href);
         const path = parsedUrl.pathname.slice(1).split('/');
         return new Identifier(namespace, ...path);
     }
 
+    public static namespaceFromUrl(url: string | URL): string {
+        const parsed = new URL(url);
+        return parsed.hostname.split('.').reverse().join('.');
+    }
+
     public toJson(): string {
         return this.key();
     }

package/src/network/network.ts

@@ -12,6 +12,7 @@ import {
 import { EventEmitter } from '../event-emitter.js';
 import { IdentifierMap } from '../identifier.js';
 import type { TokenProvider } from '../token.js';
+import { VERSION } from '../version.js';
 
 import type { Connection } from './connection.js';
 import { PacketMapper } from './connection.js';
@@ -138,6 +139,7 @@ export class Network {
             type: PACKET_TYPES.CONNECT,
             data: new ConnectPacket({
                 app: this.client.app,
+                protocol: {version: VERSION},
                 token,
             }),
         });

package/src/network/packet/packet-types.ts

@@ -8,24 +8,34 @@ import { PacketType } from './packet.js';
 
 const IDENTIFIER = new Identifier('core', 'packet');
 
+type ProtocolInfo = {
+    version: string,
+};
+
 type ConnectPacketJson = {
     app: AppJson,
+    protocol: ProtocolInfo,
     token?: string,
 };
 export class ConnectPacket implements Model<ConnectPacketJson> {
     public readonly app: App;
+    public readonly protocol: ProtocolInfo;
     public readonly token?: string;
+    
     constructor(options: {
         app: App,
+        protocol: ProtocolInfo,
         token?: string,
     }) {
         this.app = options.app;
+        this.protocol = options.protocol;
         this.token = options.token;
     }
 
     static fromJson(data: ConnectPacketJson): ConnectPacket {
         return new ConnectPacket({
             app: App.fromJson(data.app),
+            protocol: data.protocol,
             token: data.token,
         });
     }
@@ -33,6 +43,7 @@ export class ConnectPacket implements Model<ConnectPacketJson> {
     toJson(): ConnectPacketJson {
         return {
             app: this.app.toJson(),
+            protocol: this.protocol,
             token: this.token,
         };
     }

package/src/omu.ts

@@ -43,8 +43,8 @@ export class Omu implements Client {
     readonly dashboard: DashboardExtension;
     readonly extensions: ExtensionRegistry;
     readonly tables: TableExtension;
-    readonly registry: RegistryExtension;
-    readonly signal: SignalExtension;
+    readonly registries: RegistryExtension;
+    readonly signals: SignalExtension;
     readonly assets: AssetExtension;
     readonly i18n: I18nExtension;
     readonly server: ServerExtension;
@@ -79,8 +79,8 @@ export class Omu implements Client {
         this.plugins = this.extensions.register(PLUGIN_EXTENSION_TYPE);
         this.tables = this.extensions.register(TABLE_EXTENSION_TYPE);
         this.dashboard = this.extensions.register(DASHBOARD_EXTENSION_TYPE);
-        this.registry = this.extensions.register(REGISTRY_EXTENSION_TYPE);
-        this.signal = this.extensions.register(SIGNAL_EXTENSION_TYPE);
+        this.registries = this.extensions.register(REGISTRY_EXTENSION_TYPE);
+        this.signals = this.extensions.register(SIGNAL_EXTENSION_TYPE);
         this.assets = this.extensions.register(ASSET_EXTENSION_TYPE);
         this.i18n = this.extensions.register(I18N_EXTENSION_TYPE);
         this.server = this.extensions.register(SERVER_EXTENSION_TYPE);

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.6.22';