xyne-apps 1.0.0

package/src/modules/chat/schema.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+
+export const ChatPostMessageSchema = z
+  .object({
+    text: z.string().min(1, "text is required").trim(),
+  })
+  .extend({
+    channelId: z.string().min(1, "Channel ID is required").trim().optional(),
+    conversationId: z.string().trim().optional(),
+  })
+  .refine(
+    (data) => !!data.channelId || !!data.conversationId,
+    {
+      message: "Either channelId or conversationId is required",
+      path: ["channelId"],
+    },
+  );
+
+export type ChatPostMessageParams = z.infer<typeof ChatPostMessageSchema>;
+
+export interface ChatPostMessageResponse {
+  eventType: string;
+  conversationId: string;
+  messageId: string;
+}
+
+export const ChatUpdateMessageSchema = z
+  .object({
+    messageId: z.string().min(1, "messageId is required").trim(),
+    text: z.string().min(1, "text is required").trim(),
+  })
+  .extend({
+    channelId: z.string().min(1, "channelId is required").trim().optional(),
+    conversationId: z
+      .string()
+      .min(1, "conversationId is required")
+      .trim()
+      .optional(),
+  })
+  .refine((data) => !!data.channelId || !!data.conversationId, {
+    message: "At least one of channelId or conversationId is required",
+    path: ["channelId"],
+  });
+
+export type ChatUpdateMessageParams = z.infer<typeof ChatUpdateMessageSchema>;
+
+export interface ChatUpdateMessageResponse {
+  eventType: string;
+  conversationId: string;
+  messageId: string;
+}
+
+
+export const ChannelHistoryQuerySchema = z
+  .object({
+    channelId: z.string().min(1, "Channel ID is required").trim(),
+    limit: z
+      .string()
+      .optional()
+      .transform((val) => (val ? parseInt(val, 10) : 1000)),
+    cursor: z.string().optional(),
+  })
+  ;
+
+export type ChannelHistoryQueryParams = z.input<
+  typeof ChannelHistoryQuerySchema
+>;
+
+export const ConversationRepliesQuerySchema = z
+  .object({
+    conversationId: z
+      .string()
+      .min(1, "Conversation ID is required")
+      .trim(),
+    channelId: z.string().min(1, "Channel ID is required").trim().optional(),
+    limit: z
+      .string()
+      .optional()
+      .transform((val) => (val ? parseInt(val, 10) : 1000)),
+    cursor: z.string().optional(),
+  });
+
+export type ConversationRepliesQueryParams = z.input<
+  typeof ConversationRepliesQuerySchema
+>;
+
+export interface AppEventAttachment {
+  attachmentId: string;
+  fileName: string;
+  fileSize: number;
+  mimeType: string;
+  fileUrl: string;
+}
+
+export interface ChannelHistoryItem {
+  initialMessageId: string;
+  conversationId: string;
+  content: string;
+  cleanContent: string;
+  userId: string;
+  createdAt: Date;
+  attachments?: AppEventAttachment[];
+}
+
+export interface ConversationRepliesItem {
+  messageId: string;
+  conversationId: string;
+  content: string;
+  cleanContent: string;
+  userId: string;
+  createdAt: Date;
+  attachments?: AppEventAttachment[];
+}
+
+export interface ChatPaginatedResponse {
+  items: ChannelHistoryItem[] | ConversationRepliesItem[];
+  nextCursor?: string;
+  hasMore: boolean;
+}

package/src/modules/files/index.ts

@@ -0,0 +1,37 @@
+import type { XyneClient } from "../../client.js";
+import {
+  type UploadFilesInput,
+  UploadFilesInputSchema,
+  type FileUploadResponse,
+} from "./schema.js";
+
+export class FilesModule {
+  constructor(private readonly client: XyneClient) {}
+
+  public async filesUpload(params: UploadFilesInput): Promise<FileUploadResponse> {
+    const parsed = UploadFilesInputSchema.parse(params);
+    const { files, channelId, text, conversationId } = parsed;
+
+    const formData = new FormData();
+
+    if (channelId) formData.append("channelId", channelId);
+    if (text) formData.append("text", text);
+    if (conversationId) formData.append("conversationId", conversationId);
+
+    for (const f of files) {
+      const nameFromBlob = (f as any).name;
+      const multipartName =
+        typeof nameFromBlob === "string" && nameFromBlob.length > 0
+          ? nameFromBlob
+          : "file";
+      formData.append("files", f as any, multipartName);
+    }
+
+    return this.client.request<FileUploadResponse>({
+      method: "POST",
+      path: "/files/filesUpload",
+      body: formData,
+    });
+  }
+}
+

package/src/modules/files/schema.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+export const UploadFilesInputSchema = z
+  .object({
+    // Multipart payload expects `files` entries.
+    files: z.array(z.instanceof(Blob)).min(1, "Missing file uploads. Provide `files`."),
+    channelId: z.string().min(1, "Channel ID is required").trim().optional(),
+    text: z.string().trim().optional(),
+    conversationId: z.string().trim().optional(),
+  })
+  .refine(
+    (data) => !!data.channelId || !!data.conversationId,
+    {
+      message: "Either channelId or conversationId is required",
+      path: ["channelId"],
+    },
+  );
+
+export type UploadFilesInput = z.input<typeof UploadFilesInputSchema>;
+
+export interface FileAttachment {
+  fileid: string;
+  originalFilename: string;
+  url: string;
+  size: number;
+  mimeType: string;
+}
+
+export type FileUploadEventType = string;
+
+export interface FileUploadResponse {
+  eventType: FileUploadEventType;
+  conversationId: string;
+  messageId: string;
+  attachments: Array<FileAttachment>;
+}
+

package/src/modules/tickets/index.ts

@@ -0,0 +1,23 @@
+import type { XyneClient } from "../../client.js";
+import {
+  CreateTicketBodySchema,
+  type CreateTicketBodyParams,
+  type TicketActionResponse,
+} from "./schema.js";
+
+export class TicketsModule {
+  constructor(private readonly client: XyneClient) {}
+
+  public async createTicket(
+    params: CreateTicketBodyParams,
+  ): Promise<TicketActionResponse> {
+    const body = CreateTicketBodySchema.parse(params);
+
+    return this.client.request<TicketActionResponse>({
+      method: "POST",
+      path: "/ticket/createTicket",
+      body,
+    });
+  }
+}
+

package/src/modules/tickets/schema.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+
+export enum TicketPriority {
+  LOW = "LOW",
+  MEDIUM = "MEDIUM",
+  HIGH = "HIGH",
+}
+
+export const CreateTicketBodySchema = z.object({
+  title: z.string().min(1, "Title is required").trim(),
+  description: z.string().min(1, "Description is required").trim(),
+  projectId: z.string().min(1, "Project ID is required").trim(),
+  boardId: z.string().min(1, "Board ID is required").trim(),
+  channelId: z.string().min(1, "Channel ID is required").trim(),
+  text: z.string().trim().optional(),
+  priority: z.nativeEnum(TicketPriority).optional(),
+  assignedToEmail: z.string().email("Invalid email format").trim().optional(),
+  assignedUserGroupAlias: z.string().trim().optional(),
+  userId: z.string().min(1, "User ID is required").trim(),
+});
+
+export type CreateTicketBodyParams = z.infer<typeof CreateTicketBodySchema>;
+
+export interface TicketActionResponse {
+  eventType: string;
+  ticketId: string;
+  xyneId: string;
+  conversationId: string;
+  messageId: string;
+}
+

package/src/modules/user/index.ts

@@ -0,0 +1,28 @@
+import type { XyneClient } from "../../client.js";
+import {
+  UserInfoQuerySchema,
+  type UserInfoQueryParams,
+  type UserResponse,
+} from "./schema.js";
+
+export class UserModule {
+  constructor(private readonly client: XyneClient) {}
+
+  public async info(params: UserInfoQueryParams): Promise<UserResponse> {
+    const parsed = UserInfoQuerySchema.parse(params);
+
+    const queryParams = new URLSearchParams();
+    if (parsed.channelId) queryParams.set("channelId", parsed.channelId);
+    if (parsed.conversationId)
+      queryParams.set("conversationId", parsed.conversationId);
+    queryParams.set("user", parsed.user);
+
+    const result = await this.client.request<unknown>({
+      method: "GET",
+      path: `/user/info?${queryParams.toString()}`,
+    });
+
+    return result as UserResponse;
+  }
+}
+

package/src/modules/user/schema.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+export const UserInfoQuerySchema = z
+  .object({
+    channelId: z.string().min(1, "Channel ID is required").trim().optional(),
+    conversationId: z
+      .string()
+      .min(1, "Conversation ID is required")
+      .trim()
+      .optional(),
+    user: z.string().min(1, "User is required").trim(),
+  })
+  .refine((data) => !!data.channelId || !!data.conversationId, {
+    message: "Either channelId or conversationId is required",
+    path: ["channelId"],
+  });
+
+export type UserInfoQueryParams = z.input<typeof UserInfoQuerySchema>;
+
+export interface UserResponse {
+  userId: string;
+  name: string;
+  email: string;
+  picture: string | null;
+  userType: string;
+  status: string;
+  joined: Date;
+}
+

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}