apache-iggy 0.6.0 → 0.7.0

package/dist/wire/user/get-user.command.d.ts

@@ -19,13 +19,24 @@
 import type { CommandResponse } from '../../client/client.type.js';
 import { type Id } from '../identifier.utils.js';
 import { type User } from './user.utils.js';
+/**
+ * Parameters for the get user command.
+ */
 export type GetUser = {
+    /** User identifier (ID or username) */
     userId: Id;
 };
+/**
+ * Get user command definition.
+ * Retrieves a single user with permissions.
+ */
 export declare const GET_USER: {
     code: number;
     serialize: ({ userId }: GetUser) => Buffer<ArrayBufferLike>;
     deserialize: (r: CommandResponse) => User | null;
 };
+/**
+ * Executable get user command function.
+ */
 export declare const getUser: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: GetUser) => Promise<User | null>;
 //# sourceMappingURL=get-user.command.d.ts.map

package/dist/wire/user/get-user.command.js

@@ -20,6 +20,10 @@ import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { serializeIdentifier } from '../identifier.utils.js';
 import { deserializeUser } from './user.utils.js';
+/**
+ * Get user command definition.
+ * Retrieves a single user with permissions.
+ */
 export const GET_USER = {
     code: COMMAND_CODE.GetUser,
     serialize: ({ userId }) => {
@@ -31,5 +35,8 @@ export const GET_USER = {
         return deserializeUser(r.data);
     }
 };
+/**
+ * Executable get user command function.
+ */
 export const getUser = wrapCommand(GET_USER);
 //# sourceMappingURL=get-user.command.js.map

package/dist/wire/user/get-users.command.d.ts

@@ -18,10 +18,17 @@
  */
 import type { CommandResponse } from '../../client/client.type.js';
 import { type BaseUser } from './user.utils.js';
+/**
+ * Get users command definition.
+ * Retrieves all users (without permissions).
+ */
 export declare const GET_USERS: {
     code: number;
     serialize: () => Buffer<ArrayBuffer>;
     deserialize: (r: CommandResponse) => BaseUser[];
 };
+/**
+ * Executable get users command function.
+ */
 export declare const getUsers: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: void) => Promise<BaseUser[]>;
 //# sourceMappingURL=get-users.command.d.ts.map

package/dist/wire/user/get-users.command.js

@@ -19,10 +19,17 @@
 import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
 import { deserializeUsers } from './user.utils.js';
+/**
+ * Get users command definition.
+ * Retrieves all users (without permissions).
+ */
 export const GET_USERS = {
     code: COMMAND_CODE.GetUsers,
     serialize: () => Buffer.alloc(0),
     deserialize: (r) => deserializeUsers(r.data)
 };
+/**
+ * Executable get users command function.
+ */
 export const getUsers = wrapCommand(GET_USERS);
 //# sourceMappingURL=get-users.command.js.map

package/dist/wire/user/permissions.utils.d.ts

@@ -16,62 +16,170 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+/**
+ * Global permissions for server-wide operations.
+ */
 export type GlobalPermissions = {
+    /** Can manage server configuration */
     ManageServers: boolean;
+    /** Can read server information */
     ReadServers: boolean;
+    /** Can manage users */
     ManageUsers: boolean;
+    /** Can read user information */
     ReadUsers: boolean;
+    /** Can manage streams */
     ManageStreams: boolean;
+    /** Can read stream information */
     ReadStreams: boolean;
+    /** Can manage topics */
     ManageTopics: boolean;
+    /** Can read topic information */
     ReadTopics: boolean;
+    /** Can poll messages */
     PollMessages: boolean;
+    /** Can send messages */
     SendMessages: boolean;
 };
+/**
+ * Result of deserializing global permissions.
+ */
 type GlobalPermissionsDeserialized = {
+    /** Number of bytes consumed */
     bytesRead: number;
+    /** Deserialized permissions */
     data: GlobalPermissions;
 };
+/**
+ * Permissions for a specific topic.
+ */
 export type TopicPermissions = {
+    /** Can manage the topic */
     manage: boolean;
+    /** Can read the topic */
     read: boolean;
+    /** Can poll messages from the topic */
     pollMessages: boolean;
+    /** Can send messages to the topic */
     sendMessages: boolean;
 };
+/**
+ * Topic permissions with topic identifier.
+ */
 export type TopicPerms = {
+    /** Topic ID */
     topicId: number;
+    /** Topic permissions */
     permissions: TopicPermissions;
 };
+/** Result of deserializing topic permissions */
 type TopicPermissionsDeserialized = {
     bytesRead: number;
 } & TopicPerms;
+/**
+ * Permissions for a specific stream.
+ */
 export type StreamPermissions = {
+    /** Can manage the stream */
     manageStream: boolean;
+    /** Can read the stream */
     readStream: boolean;
+    /** Can manage topics within the stream */
     manageTopics: boolean;
+    /** Can read topics within the stream */
     readTopics: boolean;
+    /** Can poll messages from the stream */
     pollMessages: boolean;
+    /** Can send messages to the stream */
     sendMessages: boolean;
 };
+/**
+ * Stream permissions with stream identifier and topic permissions.
+ */
 export type StreamPerms = {
+    /** Stream ID */
     streamId: number;
+    /** Stream-level permissions */
     permissions: StreamPermissions;
+    /** Topic-specific permissions within the stream */
     topics: TopicPerms[];
 };
+/** Result of deserializing stream permissions */
 type StreamPermissionsDeserialized = {
     bytesRead: number;
 } & StreamPerms;
+/**
+ * Complete user permissions including global and stream-level permissions.
+ */
 export type UserPermissions = {
+    /** Global permissions */
     global: GlobalPermissions;
+    /** Stream-specific permissions */
     streams: StreamPerms[];
 };
+/**
+ * Deserializes global permissions from a buffer.
+ *
+ * @param p - Buffer containing serialized permissions
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized permissions
+ */
 export declare const deserializeGlobalPermissions: (p: Buffer, pos?: number) => GlobalPermissionsDeserialized;
+/**
+ * Serializes global permissions to a buffer.
+ *
+ * @param p - Global permissions to serialize
+ * @returns Serialized permissions buffer (10 bytes)
+ */
 export declare const serializeGlobalPermission: (p: GlobalPermissions) => Buffer<ArrayBuffer>;
+/**
+ * Deserializes topic permissions from a buffer.
+ *
+ * @param p - Buffer containing serialized permissions
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read, topic ID, and permissions
+ */
 export declare const deserializeTopicPermissions: (p: Buffer, pos?: number) => TopicPermissionsDeserialized;
+/**
+ * Serializes topic permissions to a buffer.
+ *
+ * @param p - Topic permissions to serialize
+ * @returns Serialized permissions buffer (8 bytes)
+ */
 export declare const serializeTopicPermissions: (p: TopicPerms) => Buffer<ArrayBuffer>;
+/**
+ * Deserializes stream permissions from a buffer.
+ * Includes nested topic permissions if present.
+ *
+ * @param p - Buffer containing serialized permissions
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read, stream ID, permissions, and topics
+ */
 export declare const deserializeStreamPermissions: (p: Buffer, pos?: number) => StreamPermissionsDeserialized;
+/**
+ * Serializes stream permissions to a buffer.
+ * Includes nested topic permissions if present.
+ *
+ * @param p - Stream permissions to serialize
+ * @returns Serialized permissions buffer
+ */
 export declare const serializeStreamPermissions: (p: StreamPerms) => Buffer<ArrayBuffer>;
+/**
+ * Deserializes complete user permissions from a buffer.
+ * Includes global permissions and stream-level permissions.
+ *
+ * @param p - Buffer containing serialized permissions
+ * @param pos - Starting position in the buffer
+ * @returns Deserialized user permissions
+ */
 export declare const deserializePermissions: (p: Buffer, pos?: number) => UserPermissions;
+/**
+ * Serializes user permissions to a buffer.
+ * Returns a single zero byte if no permissions provided.
+ *
+ * @param p - Optional user permissions to serialize
+ * @returns Serialized permissions buffer
+ */
 export declare const serializePermissions: (p?: UserPermissions) => Buffer<ArrayBuffer>;
 export {};
 //# sourceMappingURL=permissions.utils.d.ts.map

package/dist/wire/user/permissions.utils.js

@@ -17,8 +17,27 @@
  * under the License.
  */
 import { uint8ToBuf, uint32ToBuf } from '../number.utils.js';
+/**
+ * Converts a number to a boolean (1 = true).
+ *
+ * @param u - Number to convert
+ * @returns True if u equals 1
+ */
 const toBool = (u) => u === 1;
+/**
+ * Converts a boolean to a byte value.
+ *
+ * @param b - Boolean value
+ * @returns 1 if true, 0 if false
+ */
 const boolToByte = (b) => b ? 1 : 0;
+/**
+ * Deserializes global permissions from a buffer.
+ *
+ * @param p - Buffer containing serialized permissions
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized permissions
+ */
 export const deserializeGlobalPermissions = (p, pos = 0) => {
     return {
         bytesRead: 10,
@@ -36,6 +55,12 @@ export const deserializeGlobalPermissions = (p, pos = 0) => {
         }
     };
 };
+/**
+ * Serializes global permissions to a buffer.
+ *
+ * @param p - Global permissions to serialize
+ * @returns Serialized permissions buffer (10 bytes)
+ */
 export const serializeGlobalPermission = (p) => {
     return Buffer.concat([
         uint8ToBuf(boolToByte(p.ManageServers)),
@@ -50,6 +75,13 @@ export const serializeGlobalPermission = (p) => {
         uint8ToBuf(boolToByte(p.SendMessages)),
     ]);
 };
+/**
+ * Deserializes topic permissions from a buffer.
+ *
+ * @param p - Buffer containing serialized permissions
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read, topic ID, and permissions
+ */
 export const deserializeTopicPermissions = (p, pos = 0) => {
     const topicId = p.readUInt32LE(pos);
     const permissions = {
@@ -64,6 +96,12 @@ export const deserializeTopicPermissions = (p, pos = 0) => {
         permissions
     };
 };
+/**
+ * Serializes topic permissions to a buffer.
+ *
+ * @param p - Topic permissions to serialize
+ * @returns Serialized permissions buffer (8 bytes)
+ */
 export const serializeTopicPermissions = (p) => {
     return Buffer.concat([
         uint32ToBuf(p.topicId),
@@ -73,6 +111,14 @@ export const serializeTopicPermissions = (p) => {
         uint8ToBuf(boolToByte(p.permissions.sendMessages)),
     ]);
 };
+/**
+ * Deserializes stream permissions from a buffer.
+ * Includes nested topic permissions if present.
+ *
+ * @param p - Buffer containing serialized permissions
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read, stream ID, permissions, and topics
+ */
 export const deserializeStreamPermissions = (p, pos = 0) => {
     const start = pos;
     const streamId = p.readUInt32LE(pos);
@@ -105,6 +151,13 @@ export const deserializeStreamPermissions = (p, pos = 0) => {
         topics
     };
 };
+/**
+ * Serializes stream permissions to a buffer.
+ * Includes nested topic permissions if present.
+ *
+ * @param p - Stream permissions to serialize
+ * @returns Serialized permissions buffer
+ */
 export const serializeStreamPermissions = (p) => {
     const bStream = Buffer.concat([
         uint32ToBuf(p.streamId),
@@ -124,6 +177,14 @@ export const serializeStreamPermissions = (p) => {
         ac, serializeTopicPermissions(c)
     ]), bHead);
 };
+/**
+ * Deserializes complete user permissions from a buffer.
+ * Includes global permissions and stream-level permissions.
+ *
+ * @param p - Buffer containing serialized permissions
+ * @param pos - Starting position in the buffer
+ * @returns Deserialized user permissions
+ */
 export const deserializePermissions = (p, pos = 0) => {
     const { bytesRead, data } = deserializeGlobalPermissions(p, pos);
     pos += bytesRead;
@@ -145,6 +206,13 @@ export const deserializePermissions = (p, pos = 0) => {
         streams
     };
 };
+/**
+ * Serializes user permissions to a buffer.
+ * Returns a single zero byte if no permissions provided.
+ *
+ * @param p - Optional user permissions to serialize
+ * @returns Serialized permissions buffer
+ */
 export const serializePermissions = (p) => {
     if (!p)
         return uint8ToBuf(0);

package/dist/wire/user/update-permissions.command.d.ts

@@ -18,14 +18,26 @@
  */
 import { type Id } from '../identifier.utils.js';
 import { type UserPermissions } from './permissions.utils.js';
+/**
+ * Parameters for the update permissions command.
+ */
 export type UpdatePermissions = {
+    /** User identifier (ID or username) */
     userId: Id;
+    /** New permissions to set */
     permissions: UserPermissions;
 };
+/**
+ * Update permissions command definition.
+ * Updates a user's permissions.
+ */
 export declare const UPDATE_PERMISSIONS: {
     code: number;
     serialize: ({ userId, permissions }: UpdatePermissions) => Buffer<ArrayBuffer>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
+/**
+ * Executable update permissions command function.
+ */
 export declare const updatePermissions: (getClient: import("../../index.js").ClientProvider) => (arg: UpdatePermissions) => Promise<boolean>;
 //# sourceMappingURL=update-permissions.command.d.ts.map

package/dist/wire/user/update-permissions.command.js

@@ -22,6 +22,10 @@ import { deserializeVoidResponse } from '../../client/client.utils.js';
 import { uint32ToBuf, boolToBuf } from '../number.utils.js';
 import { serializeIdentifier } from '../identifier.utils.js';
 import { serializePermissions } from './permissions.utils.js';
+/**
+ * Update permissions command definition.
+ * Updates a user's permissions.
+ */
 export const UPDATE_PERMISSIONS = {
     code: COMMAND_CODE.UpdatePermissions,
     serialize: ({ userId, permissions }) => {
@@ -35,5 +39,8 @@ export const UPDATE_PERMISSIONS = {
     },
     deserialize: deserializeVoidResponse
 };
+/**
+ * Executable update permissions command function.
+ */
 export const updatePermissions = wrapCommand(UPDATE_PERMISSIONS);
 //# sourceMappingURL=update-permissions.command.js.map

package/dist/wire/user/update-user.command.d.ts

@@ -18,15 +18,28 @@
  */
 import type { UserStatus } from './user.utils.js';
 import { type Id } from '../identifier.utils.js';
+/**
+ * Parameters for the update user command.
+ */
 export type UpdateUser = {
+    /** User identifier (ID or username) */
     userId: Id;
+    /** Optional new username (1-255 bytes) */
     username?: string;
+    /** Optional new status */
     status?: UserStatus;
 };
+/**
+ * Update user command definition.
+ * Updates a user's username and/or status.
+ */
 export declare const UPDATE_USER: {
     code: number;
     serialize: ({ userId, username, status }: UpdateUser) => Buffer<ArrayBuffer>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
+/**
+ * Executable update user command function.
+ */
 export declare const updateUser: (getClient: import("../../index.js").ClientProvider) => (arg: UpdateUser) => Promise<boolean>;
 //# sourceMappingURL=update-user.command.d.ts.map

package/dist/wire/user/update-user.command.js

@@ -21,6 +21,10 @@ import { COMMAND_CODE } from '../command.code.js';
 import { deserializeVoidResponse } from '../../client/client.utils.js';
 import { serializeIdentifier } from '../identifier.utils.js';
 import { uint8ToBuf } from '../number.utils.js';
+/**
+ * Update user command definition.
+ * Updates a user's username and/or status.
+ */
 export const UPDATE_USER = {
     code: COMMAND_CODE.UpdateUser,
     serialize: ({ userId, username, status }) => {
@@ -50,5 +54,8 @@ export const UPDATE_USER = {
     },
     deserialize: deserializeVoidResponse
 };
+/**
+ * Executable update user command function.
+ */
 export const updateUser = wrapCommand(UPDATE_USER);
 //# sourceMappingURL=update-user.command.js.map

package/dist/wire/user/user.utils.d.ts

@@ -17,25 +17,65 @@
  * under the License.
  */
 import { type UserPermissions } from './permissions.utils.js';
+/**
+ * Basic user information without permissions.
+ */
 export type BaseUser = {
+    /** User ID */
     id: number;
+    /** User creation timestamp */
     createdAt: Date;
+    /** User status (Active/Inactive) */
     status: string;
+    /** Username */
     userName: string;
 };
+/**
+ * Result of deserializing a base user.
+ */
 type BaseUserDeserialized = {
+    /** Number of bytes consumed */
     bytesRead: number;
+    /** Deserialized user data */
     data: BaseUser;
 };
+/** User with permissions information */
 export type User = BaseUser & {
     permissions: UserPermissions | null;
 };
+/**
+ * User status enumeration.
+ */
 export declare enum UserStatus {
+    /** Active user */
     Active = 1,
+    /** Inactive user */
     Inactive = 2
 }
+/**
+ * Deserializes a base user from a buffer.
+ *
+ * @param p - Buffer containing serialized user data
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized user data
+ * @throws Error if the buffer is empty (user does not exist)
+ */
 export declare const deserializeBaseUser: (p: Buffer, pos?: number) => BaseUserDeserialized;
+/**
+ * Deserializes a user with permissions from a buffer.
+ *
+ * @param p - Buffer containing serialized user data
+ * @param pos - Starting position in the buffer
+ * @returns Deserialized user with permissions
+ */
 export declare const deserializeUser: (p: Buffer, pos?: number) => User;
+/**
+ * Deserializes multiple base users from a buffer.
+ *
+ * @param p - Buffer containing serialized users data
+ * @param pos - Starting position in the buffer
+ * @returns Array of deserialized base users
+ */
 export declare const deserializeUsers: (p: Buffer, pos?: number) => BaseUser[];
 export {};
 //# sourceMappingURL=user.utils.d.ts.map

package/dist/wire/user/user.utils.js

@@ -18,12 +18,23 @@
  */
 import { toDate } from '../serialize.utils.js';
 import { deserializePermissions } from './permissions.utils.js';
+/**
+ * User status enumeration.
+ */
 export var UserStatus;
 (function (UserStatus) {
+    /** Active user */
     UserStatus[UserStatus["Active"] = 1] = "Active";
+    /** Inactive user */
     UserStatus[UserStatus["Inactive"] = 2] = "Inactive";
 })(UserStatus || (UserStatus = {}));
 ;
+/**
+ * Converts a numeric status code to a status string.
+ *
+ * @param t - Numeric status code
+ * @returns Status string ('Active', 'Inactive', or unknown)
+ */
 const statusString = (t) => {
     switch (t.toString()) {
         case '1': return 'Active';
@@ -32,6 +43,14 @@ const statusString = (t) => {
         // default: throw new Error(`unknown_status_${t}`);
     }
 };
+/**
+ * Deserializes a base user from a buffer.
+ *
+ * @param p - Buffer containing serialized user data
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized user data
+ * @throws Error if the buffer is empty (user does not exist)
+ */
 export const deserializeBaseUser = (p, pos = 0) => {
     if (p.length === 0)
         throw new Error('User does not exist');
@@ -50,6 +69,13 @@ export const deserializeBaseUser = (p, pos = 0) => {
         }
     };
 };
+/**
+ * Deserializes a user with permissions from a buffer.
+ *
+ * @param p - Buffer containing serialized user data
+ * @param pos - Starting position in the buffer
+ * @returns Deserialized user with permissions
+ */
 export const deserializeUser = (p, pos = 0) => {
     const { bytesRead, data } = deserializeBaseUser(p, pos);
     pos += bytesRead;
@@ -63,6 +89,13 @@ export const deserializeUser = (p, pos = 0) => {
     }
     return { ...data, permissions };
 };
+/**
+ * Deserializes multiple base users from a buffer.
+ *
+ * @param p - Buffer containing serialized users data
+ * @param pos - Starting position in the buffer
+ * @returns Array of deserialized base users
+ */
 export const deserializeUsers = (p, pos = 0) => {
     const users = [];
     const end = p.length;

package/dist/wire/uuid.utils.d.ts

@@ -17,6 +17,19 @@
  * under the License.
  */
 import { UUID } from "uuidv7";
+/**
+ * Parses a UUID string into a UUID object.
+ *
+ * @param uid - UUID string to parse
+ * @returns Parsed UUID object
+ */
 export declare const parse: (uid: string) => UUID;
+/**
+ * Generates a new UUID v7 (time-ordered) string.
+ * UUID v7 is a time-ordered UUID that provides better database indexing performance.
+ *
+ * @returns UUID v7 string
+ * @see https://github.com/LiosK/uuidv7
+ */
 export declare const v7: () => string;
 //# sourceMappingURL=uuid.utils.d.ts.map

package/dist/wire/uuid.utils.js

@@ -17,7 +17,19 @@
  * under the License.
  */
 import { uuidv7, UUID } from "uuidv7";
+/**
+ * Parses a UUID string into a UUID object.
+ *
+ * @param uid - UUID string to parse
+ * @returns Parsed UUID object
+ */
 export const parse = (uid) => UUID.parse(uid);
-// https://github.com/LiosK/uuidv7
+/**
+ * Generates a new UUID v7 (time-ordered) string.
+ * UUID v7 is a time-ordered UUID that provides better database indexing performance.
+ *
+ * @returns UUID v7 string
+ * @see https://github.com/LiosK/uuidv7
+ */
 export const v7 = () => uuidv7();
 //# sourceMappingURL=uuid.utils.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apache-iggy",
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Official Apache Iggy NodeJS SDK",
   "keywords": [
     "iggy",
@@ -42,7 +42,7 @@
     "commitlint": "commitlint --edit",
     "build": "tsc -p tsconfig.json",
     "start": "node dist/index.js",
-    "prepare": "husky"
+    "prepare": "husky || true"
   },
   "author": "github.com/T1B0",
   "license": "Apache-2.0",