🔍 Chat Schema Blocks

Chat schema blocks provide JSON Schema definitions for chat data validation in Nodeblocks applications. These schemas ensure data integrity and provide clear contracts for chat-related API endpoints.

---

🎯 Overview

Chat schema blocks are designed to:

• Validate chat data before processing
• Support real-time messaging between users
• Handle channel management and user subscriptions
• Enable message search and filtering capabilities
• Provide channel permissions and access control
• Support real-time notifications and updates

---

📋 Chat Schema Types

Channel Schemas

Core chat channel structures for channel management.

Message Schemas

Chat message structures for real-time communication.

Subscription Schemas

User subscription structures for channel access control.

---

🔧 Available Chat Schemas

📺 Channel Schemas

chatChannelSchema

Base chat channel schema with core channel fields.

Purpose: Defines basic channel structure for chat functionality

Schema Details:

• Type: object
• Required Fields: None (base schema)
• Additional Properties: false (strict validation)
• Properties:
  • name?: string - Channel name
  • ownerId?: string - Channel owner identity ID

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { chatChannelSchema } = schemas;
const validate = ajv.compile(chatChannelSchema as SchemaDefinition);
const isValid = validate({
  name: 'General Chat',
  ownerId: 'identity123'
});

---

createChatChannelSchema

Chat channel creation schema with required name and owner.

Purpose: Validates channel data during creation

Schema Details:

• Type: object
• Required Fields: name, ownerId
• Additional Properties: false (strict validation)
• Content-Type: application/json
• Request Body: required

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { createChatChannelSchema } = schemas;

const schema = createChatChannelSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({
  name: 'General Chat',
  ownerId: 'user123'
});

---

updateChatChannelSchema

Chat channel update schema with optional fields for channel modifications.

Purpose: Validates partial channel data updates

Schema Details:

• Type: object
• Required Fields: None (all fields optional)
• Additional Properties: false (strict validation)
• Content-Type: application/json
• Parameters: channelId (path parameter)
• Request Body: required

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { updateChatChannelSchema } = schemas;

const schema = updateChatChannelSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ name: 'Updated Channel Name' });

---

getChatChannelSchema

Chat channel retrieval schema for getting single channels.

Purpose: Validates requests for retrieving specific chat channels

Schema Details:

• Parameters: channelId (path parameter)
• Purpose: Validates requests for retrieving specific chat channels

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { getChatChannelSchema } = schemas;

const schema = getChatChannelSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ channelId: 'channel123' });

---

deleteChatChannelSchema

Chat channel deletion schema for removing channels.

Purpose: Validates requests for deleting specific chat channels

Schema Details:

• Parameters: channelId (path parameter)
• Purpose: Validates requests for deleting specific chat channels

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { deleteChatChannelSchema } = schemas;

const schema = deleteChatChannelSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ channelId: 'channel123' });

---

findChatChannelsSchema

Chat channels search schema for finding channels with filtering and pagination.

Purpose: Validates requests for searching and paginating chat channels

Schema Details:

• Query Parameters:
  • name?: string - Filter by channel name
  • ownerId?: string - Filter by owner identity
  • page?: number - Pagination page number
  • limit?: number - Pagination limit
• Purpose: Validates requests for searching and paginating chat channels

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { findChatChannelsSchema } = schemas;

const schema = findChatChannelsSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ name: 'General', page: 1, limit: 10 });

---

💬 Message Schemas

chatMessageSchema

Base chat message schema with core message fields.

Purpose: Defines basic message structure for chat functionality

Schema Details:

• Type: object
• Required Fields: None (base schema)
• Additional Properties: false (strict validation)
• Properties:
  • content?: string - Message content
  • senderId?: string - Message sender identity ID
  • title?: string - Message title

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { chatMessageSchema } = schemas;
const validate = ajv.compile(chatMessageSchema as SchemaDefinition);
const isValid = validate({
  content: 'Hello world!',
  senderId: 'identity123',
  title: 'Greeting'
});

---

createChatMessageSchema

Chat message creation schema with required content, sender, and channel.

Purpose: Validates message data during creation

Schema Details:

• Type: object
• Required Fields: content, senderId, channelId
• Optional Fields: title
• Additional Properties: false (strict validation)
• Content-Type: application/json
• Request Body: required

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { createChatMessageSchema } = schemas;

const schema = createChatMessageSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({
  content: 'Hello world!',
  senderId: 'user123',
  channelId: 'channel456'
});

---

updateChatMessageSchema

Chat message update schema with optional fields for message modifications.

Purpose: Validates partial message data updates

Schema Details:

• Type: object
• Required Fields: None (all fields optional)
• Additional Properties: false (strict validation)
• Content-Type: application/json
• Parameters: messageId (path parameter)
• Request Body: required

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { updateChatMessageSchema } = schemas;

const schema = updateChatMessageSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ content: 'Updated message content' });

---

getChatMessageSchema

Chat message retrieval schema for getting single messages.

Purpose: Validates requests for retrieving specific chat messages

Schema Details:

• Parameters: messageId (path parameter)
• Purpose: Validates requests for retrieving specific chat messages

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { getChatMessageSchema } = schemas;

const schema = getChatMessageSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ messageId: 'message123' });

---

deleteChatMessageSchema

Chat message deletion schema for removing messages.

Purpose: Validates requests for deleting specific chat messages

Schema Details:

• Parameters: messageId (path parameter)
• Purpose: Validates requests for deleting specific chat messages

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { deleteChatMessageSchema } = schemas;

const schema = deleteChatMessageSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ messageId: 'message123' });

---

findChatMessagesSchema

Chat messages search schema for finding messages with filtering and pagination.

Purpose: Validates requests for searching and paginating chat messages within a specific channel

Schema Details:

• Query Parameters:
  • channelId: string - Required filter by channel
  • content?: string - Optional filter by message content
  • senderId?: string - Optional filter by sender
  • title?: string - Optional filter by message title
  • page?: number - Pagination page number
  • limit?: number - Pagination limit
• Purpose: Validates requests for searching and paginating chat messages

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { findChatMessagesSchema } = schemas;

const schema = findChatMessagesSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ 
  channelId: 'channel123',
  senderId: 'user123',
  page: 1,
  limit: 10 
});

---

📝 Message Template Schemas

Message template structures for reusable chat content and standardized messaging.

chatMessageTemplateSchema

Base chat message template schema defining the structure for reusable message templates.

Purpose: Defines the core structure for chat message templates used across the application

Schema Details:

• Type: object
• Required Fields: None (base schema)
• Additional Properties: false (strict validation)
• Properties:
  • content?: string - Template message content
  • organizationId?: string - Organization identifier for template scope
  • permissions?: string[] - Array of permission strings for access control
  • title?: string - Template title/description

Usage:

// Use as base for other schemas:
export const createSchema = withSchema({
  requestBody: {
    content: {
      'application/json': {
        schema: {
          ...chatMessageTemplateSchema,
          required: ['content', 'title']
        }
      }
    }
  }
});

createChatMessageTemplateSchema

Chat message template creation schema with required fields validation for template creation requests.

Purpose: Validates message template data during creation with required content and title fields

Schema Details:

• Content-Type: application/json
• Request Body: required
• Required Fields: content, title
• Optional Fields: organizationId, permissions
• Additional Properties: false (strict validation)

Request Body Structure:

Field	Type	Required	Description
content	string	✅	Template message content
title	string	✅	Template title/description
organizationId	string	❌	Organization identifier for template scope
permissions	string[]	❌	Array of permission strings for access control

Usage:

// Use as base for other schemas:
export const createSchema = withSchema({
  requestBody: {
    content: {
      'application/json': {
        schema: {
          ...chatMessageTemplateSchema,
          required: ['content', 'title']
        }
      }
    }
  }
});

getChatMessageTemplateSchema

Chat message template retrieval schema with path parameter validation.

Purpose: Validates requests for retrieving a chat message template by ID

Schema Details:

• Parameters: messageTemplateId (path parameter)
• Purpose: Validates requests for retrieving a chat message template by ID

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { getChatMessageTemplateSchema } = schemas;

const schema = getChatMessageTemplateSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ messageTemplateId: 'template123' });

---

🔔 Subscription Schemas

chatSubscriptionSchema

Base chat subscription schema with core subscription fields.

Purpose: Defines basic subscription structure for chat channels

Schema Details:

• Type: object
• Required Fields: None (base schema)
• Additional Properties: false (strict validation)
• Properties:
  • approved?: boolean - Subscription approval status
  • permissions?: string[] - User permissions array
  • subscribedAt?: string - Subscription date (date-time format)
  • subscribedId?: string - Subscriber identity ID
  • channelId?: string - Channel ID

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { chatSubscriptionSchema } = schemas;
const validate = ajv.compile(chatSubscriptionSchema as SchemaDefinition);
const isValid = validate({
  channelId: 'channel123',
  subscribedId: 'identity456',
  approved: true,
  permissions: ['read', 'write']
});

---

createChatSubscriptionSchema

Chat subscription creation schema with required channel ID.

Purpose: Validates subscription data during creation

Schema Details:

• Type: object
• Required Fields: channelId, subscribedId
• Optional Fields: approved, permissions, subscribedAt
• Additional Properties: false (strict validation)
• Content-Type: application/json
• Request Body: required

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { createChatSubscriptionSchema } = schemas;

const schema = createChatSubscriptionSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({
  channelId: 'channel123',
  subscribedId: 'user456',
  approved: true
});

---

getChatSubscriptionSchema

Chat subscription retrieval schema for getting single subscriptions.

Purpose: Validates requests for retrieving specific chat subscriptions

Schema Details:

• Parameters: subscriptionId (path parameter)

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { getChatSubscriptionSchema } = schemas;

const schema = getChatSubscriptionSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ subscriptionId: 'sub123' });

---

deleteChatSubscriptionSchema

Chat subscription deletion schema for removing subscriptions.

Purpose: Validates requests for deleting specific chat subscriptions

Schema Details:

• Parameters: subscriptionId (path parameter)
• Purpose: Validates requests for deleting specific chat subscriptions

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { deleteChatSubscriptionSchema } = schemas;

const schema = deleteChatSubscriptionSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ subscriptionId: 'sub123' });

---

findChatSubscriptionsSchema

Chat subscriptions search schema for finding subscriptions with filtering and pagination.

Purpose: Validates requests for searching and paginating chat subscriptions

Schema Details:

• Query Parameters:
  • approved?: boolean - Filter by approval status
  • channelId?: string - Filter by channel
  • subscribedAt?: string - Filter by subscription date (date-time format)
  • subscribedId?: string - Filter by subscriber
  • page?: number - Pagination page number
  • limit?: number - Pagination limit
• Purpose: Validates requests for searching and paginating chat subscriptions

Usage:

import { schemas } from '@nodeblocks/backend-sdk';

const { findChatSubscriptionsSchema } = schemas;

const schema = findChatSubscriptionsSchema({});
const validate = ajv.compile(schema.schemas as SchemaDefinition);
const isValid = validate({ 
  approved: true,
  page: 1,
  limit: 10 
});

---

🔗 Related Documentation

• Chat Domain Overview - Chat domain overview