@infuro/cms-core 1.0.7 → 1.0.9

package/dist/index.cjs

@@ -256,6 +256,8 @@ __export(src_exports, {
   Brand: () => Brand,
   CMS_ENTITY_MAP: () => CMS_ENTITY_MAP,
   Category: () => Category,
+  ChatConversation: () => ChatConversation,
+  ChatMessage: () => ChatMessage,
   Collection: () => Collection,
   Comment: () => Comment,
   Config: () => Config,
@@ -265,6 +267,9 @@ __export(src_exports, {
   Form: () => Form,
   FormField: () => FormField,
   FormSubmission: () => FormSubmission,
+  KnowledgeBaseChunk: () => KnowledgeBaseChunk,
+  KnowledgeBaseDocument: () => KnowledgeBaseDocument,
+  LlmService: () => LlmService,
   Media: () => Media,
   OPEN_ENDPOINTS: () => OPEN_ENDPOINTS,
   Order: () => Order,
@@ -317,6 +322,7 @@ __export(src_exports, {
   getRequiredPermission: () => getRequiredPermission,
   isOpenEndpoint: () => isOpenEndpoint,
   isPublicMethod: () => isPublicMethod,
+  llmPlugin: () => llmPlugin,
   localStoragePlugin: () => localStoragePlugin,
   paymentPlugin: () => paymentPlugin,
   s3StoragePlugin: () => s3StoragePlugin,
@@ -878,6 +884,153 @@ function localStoragePlugin(config = {}) {
   };
 }
 
+// src/plugins/llm/llm-service.ts
+var LlmService = class _LlmService {
+  constructor(baseURL, apiKey, defaultEmbeddingModel) {
+    this.baseURL = baseURL;
+    this.apiKey = apiKey;
+    this.defaultEmbeddingModel = defaultEmbeddingModel;
+  }
+  static embedWarned = false;
+  get base() {
+    return this.baseURL.replace(/\/$/, "");
+  }
+  get url() {
+    return `${this.base}/v1/chat/completions`;
+  }
+  /**
+   * OpenAI-compatible embeddings. Returns [] if endpoint not available or unexpected response.
+   * Server must implement: POST /v1/embeddings
+   * Body: { model: string, input: string }
+   * Response: { data: [ { embedding: number[] } ] } or { embedding: number[] }
+   */
+  async embed(text, options = {}) {
+    const model = options.model ?? this.defaultEmbeddingModel ?? "text-embedding-3-small";
+    const input = text.slice(0, 8e3);
+    const res = await fetch(`${this.base}/v1/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        input
+      })
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      if (!_LlmService.embedWarned) {
+        _LlmService.embedWarned = true;
+        console.warn(`[LLM embed] ${res.status} ${res.statusText}: ${body.slice(0, 400)}`);
+      }
+      return [];
+    }
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      console.warn("[LLM embed] Response is not JSON");
+      return [];
+    }
+    let embedding = data?.data?.[0]?.embedding;
+    if (!Array.isArray(embedding) && Array.isArray(data?.embedding)) {
+      embedding = data.embedding;
+    }
+    if (!Array.isArray(embedding) && Array.isArray(data?.data?.[0])) {
+      const first = data.data[0];
+      embedding = Array.isArray(first) ? first : first?.embedding;
+    }
+    if (!Array.isArray(embedding) && !_LlmService.embedWarned) {
+      _LlmService.embedWarned = true;
+      console.warn("[LLM embed] Unexpected response shape. Keys:", Object.keys(data), "data[0] type:", Array.isArray(data?.data) ? typeof data.data[0] : "n/a");
+    }
+    return Array.isArray(embedding) ? embedding : [];
+  }
+  async chat(messages, options = {}) {
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: options.model ?? "qwen2.5:3b-instruct",
+        messages,
+        stream: false,
+        temperature: options.temperature,
+        max_tokens: options.max_tokens
+      })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`LLM gateway error: ${res.status} ${text}`);
+    }
+    const data = await res.json();
+    const content = data.choices?.[0]?.message?.content ?? "";
+    return { content };
+  }
+  async *streamChat(messages, options = {}) {
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: options.model ?? "qwen2.5:3b-instruct",
+        messages,
+        stream: true,
+        temperature: options.temperature,
+        max_tokens: options.max_tokens
+      })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`LLM gateway error: ${res.status} ${text}`);
+    }
+    const reader = res.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.startsWith("data: ") && line !== "data: [DONE]") {
+          try {
+            const json = JSON.parse(line.slice(6));
+            const content = json.choices?.[0]?.delta?.content;
+            if (content) yield content;
+          } catch {
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/plugins/llm/index.ts
+function llmPlugin(config = {}) {
+  return {
+    name: "llm",
+    version: "1.0.0",
+    async init(context) {
+      const baseURL = config.baseURL ?? context.config.LLM_GATEWAY_URL;
+      const apiKey = config.apiKey ?? context.config.LLM_API_KEY;
+      if (!baseURL || !apiKey) {
+        context.logger.warn("LLM plugin skipped: LLM_GATEWAY_URL or LLM_API_KEY not set");
+        return void 0;
+      }
+      const embeddingModel = config.embeddingModel ?? context.config.EMBEDDING_MODEL;
+      return new LlmService(baseURL.replace(/\/$/, ""), apiKey, embeddingModel);
+    }
+  };
+}
+
 // src/lib/utils.ts
 var import_clsx = require("clsx");
 var import_tailwind_merge = require("tailwind-merge");
@@ -1465,7 +1618,7 @@ Blog = __decorateClass([
 ], Blog);
 
 // src/entities/contact.entity.ts
-var import_typeorm16 = require("typeorm");
+var import_typeorm18 = require("typeorm");
 
 // src/entities/form-submission.entity.ts
 var import_typeorm12 = require("typeorm");
@@ -1924,6 +2077,74 @@ Payment = __decorateClass([
   (0, import_typeorm15.Entity)("payments")
 ], Payment);
 
+// src/entities/chat-conversation.entity.ts
+var import_typeorm17 = require("typeorm");
+
+// src/entities/chat-message.entity.ts
+var import_typeorm16 = require("typeorm");
+var ChatMessage = class {
+  id;
+  conversationId;
+  role;
+  content;
+  createdAt;
+  conversation;
+};
+__decorateClass([
+  (0, import_typeorm16.PrimaryGeneratedColumn)()
+], ChatMessage.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm16.Column)("int")
+], ChatMessage.prototype, "conversationId", 2);
+__decorateClass([
+  (0, import_typeorm16.Column)("varchar")
+], ChatMessage.prototype, "role", 2);
+__decorateClass([
+  (0, import_typeorm16.Column)("text")
+], ChatMessage.prototype, "content", 2);
+__decorateClass([
+  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ChatMessage.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm16.ManyToOne)(() => ChatConversation, (c) => c.messages, { onDelete: "CASCADE" }),
+  (0, import_typeorm16.JoinColumn)({ name: "conversationId" })
+], ChatMessage.prototype, "conversation", 2);
+ChatMessage = __decorateClass([
+  (0, import_typeorm16.Entity)("chat_messages")
+], ChatMessage);
+
+// src/entities/chat-conversation.entity.ts
+var ChatConversation = class {
+  id;
+  contactId;
+  createdAt;
+  updatedAt;
+  contact;
+  messages;
+};
+__decorateClass([
+  (0, import_typeorm17.PrimaryGeneratedColumn)()
+], ChatConversation.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm17.Column)("int")
+], ChatConversation.prototype, "contactId", 2);
+__decorateClass([
+  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ChatConversation.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ChatConversation.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm17.ManyToOne)(() => Contact, (c) => c.chatConversations, { onDelete: "CASCADE" }),
+  (0, import_typeorm17.JoinColumn)({ name: "contactId" })
+], ChatConversation.prototype, "contact", 2);
+__decorateClass([
+  (0, import_typeorm17.OneToMany)(() => ChatMessage, (m) => m.conversation)
+], ChatConversation.prototype, "messages", 2);
+ChatConversation = __decorateClass([
+  (0, import_typeorm17.Entity)("chat_conversations")
+], ChatConversation);
+
 // src/entities/contact.entity.ts
 var Contact = class {
   id;
@@ -1945,70 +2166,74 @@ var Contact = class {
   addresses;
   orders;
   payments;
+  chatConversations;
 };
 __decorateClass([
-  (0, import_typeorm16.PrimaryGeneratedColumn)()
+  (0, import_typeorm18.PrimaryGeneratedColumn)()
 ], Contact.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar")
+  (0, import_typeorm18.Column)("varchar")
 ], Contact.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { unique: true })
+  (0, import_typeorm18.Column)("varchar", { unique: true })
 ], Contact.prototype, "email", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { nullable: true })
+  (0, import_typeorm18.Column)("varchar", { nullable: true })
 ], Contact.prototype, "phone", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { nullable: true })
+  (0, import_typeorm18.Column)("varchar", { nullable: true })
 ], Contact.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { nullable: true })
+  (0, import_typeorm18.Column)("varchar", { nullable: true })
 ], Contact.prototype, "company", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { nullable: true })
+  (0, import_typeorm18.Column)("varchar", { nullable: true })
 ], Contact.prototype, "taxId", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("text", { nullable: true })
+  (0, import_typeorm18.Column)("text", { nullable: true })
 ], Contact.prototype, "notes", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm18.Column)({ type: "timestamp", nullable: true })
 ], Contact.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("boolean", { default: false })
+  (0, import_typeorm18.Column)("boolean", { default: false })
 ], Contact.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm18.Column)("int", { nullable: true })
 ], Contact.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm18.Column)("int", { nullable: true })
 ], Contact.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm18.Column)("int", { nullable: true })
 ], Contact.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm16.OneToMany)(() => FormSubmission, (fs) => fs.contact)
+  (0, import_typeorm18.OneToMany)(() => FormSubmission, (fs) => fs.contact)
 ], Contact.prototype, "form_submissions", 2);
 __decorateClass([
-  (0, import_typeorm16.OneToMany)(() => Address, (a) => a.contact)
+  (0, import_typeorm18.OneToMany)(() => Address, (a) => a.contact)
 ], Contact.prototype, "addresses", 2);
 __decorateClass([
-  (0, import_typeorm16.OneToMany)(() => Order, (o) => o.contact)
+  (0, import_typeorm18.OneToMany)(() => Order, (o) => o.contact)
 ], Contact.prototype, "orders", 2);
 __decorateClass([
-  (0, import_typeorm16.OneToMany)(() => Payment, (p) => p.contact)
+  (0, import_typeorm18.OneToMany)(() => Payment, (p) => p.contact)
 ], Contact.prototype, "payments", 2);
+__decorateClass([
+  (0, import_typeorm18.OneToMany)(() => ChatConversation, (c) => c.contact)
+], Contact.prototype, "chatConversations", 2);
 Contact = __decorateClass([
-  (0, import_typeorm16.Entity)("contacts")
+  (0, import_typeorm18.Entity)("contacts")
 ], Contact);
 
 // src/entities/config.entity.ts
-var import_typeorm17 = require("typeorm");
+var import_typeorm19 = require("typeorm");
 var Config = class {
   id;
   settings;
@@ -2025,51 +2250,51 @@ var Config = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm17.PrimaryGeneratedColumn)()
+  (0, import_typeorm19.PrimaryGeneratedColumn)()
 ], Config.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("varchar")
+  (0, import_typeorm19.Column)("varchar")
 ], Config.prototype, "settings", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("varchar")
+  (0, import_typeorm19.Column)("varchar")
 ], Config.prototype, "key", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("varchar")
+  (0, import_typeorm19.Column)("varchar")
 ], Config.prototype, "value", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("varchar", { default: "private" })
+  (0, import_typeorm19.Column)("varchar", { default: "private" })
 ], Config.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("boolean", { default: false })
+  (0, import_typeorm19.Column)("boolean", { default: false })
 ], Config.prototype, "encrypted", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm19.Column)({ type: "timestamp", nullable: true })
 ], Config.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("boolean", { default: false })
+  (0, import_typeorm19.Column)("boolean", { default: false })
 ], Config.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], Config.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], Config.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], Config.prototype, "deletedBy", 2);
 Config = __decorateClass([
-  (0, import_typeorm17.Entity)("configs"),
-  (0, import_typeorm17.Unique)(["settings", "key"])
+  (0, import_typeorm19.Entity)("configs"),
+  (0, import_typeorm19.Unique)(["settings", "key"])
 ], Config);
 
 // src/entities/media.entity.ts
-var import_typeorm18 = require("typeorm");
+var import_typeorm20 = require("typeorm");
 var Media = class {
   id;
   filename;
@@ -2084,44 +2309,44 @@ var Media = class {
   deleted;
 };
 __decorateClass([
-  (0, import_typeorm18.PrimaryGeneratedColumn)()
+  (0, import_typeorm20.PrimaryGeneratedColumn)()
 ], Media.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("varchar")
+  (0, import_typeorm20.Column)("varchar")
 ], Media.prototype, "filename", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("varchar")
+  (0, import_typeorm20.Column)("varchar")
 ], Media.prototype, "url", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("varchar")
+  (0, import_typeorm20.Column)("varchar")
 ], Media.prototype, "mimeType", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("int", { default: 0 })
+  (0, import_typeorm20.Column)("int", { default: 0 })
 ], Media.prototype, "size", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("varchar", { nullable: true })
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
 ], Media.prototype, "alt", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("boolean", { default: false })
+  (0, import_typeorm20.Column)("boolean", { default: false })
 ], Media.prototype, "isPublic", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm20.Column)({ type: "timestamp", nullable: true })
 ], Media.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("boolean", { default: false })
+  (0, import_typeorm20.Column)("boolean", { default: false })
 ], Media.prototype, "deleted", 2);
 Media = __decorateClass([
-  (0, import_typeorm18.Entity)("media")
+  (0, import_typeorm20.Entity)("media")
 ], Media);
 
 // src/entities/page.entity.ts
-var import_typeorm19 = require("typeorm");
+var import_typeorm21 = require("typeorm");
 var Page = class {
   id;
   title;
@@ -2142,64 +2367,64 @@ var Page = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm19.PrimaryGeneratedColumn)()
+  (0, import_typeorm21.PrimaryGeneratedColumn)()
 ], Page.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar")
+  (0, import_typeorm21.Column)("varchar")
 ], Page.prototype, "title", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { unique: true })
+  (0, import_typeorm21.Column)("varchar", { unique: true })
 ], Page.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)({ type: "jsonb", default: {} })
+  (0, import_typeorm21.Column)({ type: "jsonb", default: {} })
 ], Page.prototype, "content", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("boolean", { default: false })
+  (0, import_typeorm21.Column)("boolean", { default: false })
 ], Page.prototype, "published", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { default: "default" })
+  (0, import_typeorm21.Column)("varchar", { default: "default" })
 ], Page.prototype, "theme", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Page.prototype, "parentId", 2);
 __decorateClass([
-  (0, import_typeorm19.ManyToOne)(() => Page, { onDelete: "SET NULL" }),
-  (0, import_typeorm19.JoinColumn)({ name: "parentId" })
+  (0, import_typeorm21.ManyToOne)(() => Page, { onDelete: "SET NULL" }),
+  (0, import_typeorm21.JoinColumn)({ name: "parentId" })
 ], Page.prototype, "parent", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Page.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm19.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm19.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm21.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm21.JoinColumn)({ name: "seoId" })
 ], Page.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm21.Column)({ type: "timestamp", nullable: true })
 ], Page.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("boolean", { default: false })
+  (0, import_typeorm21.Column)("boolean", { default: false })
 ], Page.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Page.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Page.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Page.prototype, "deletedBy", 2);
 Page = __decorateClass([
-  (0, import_typeorm19.Entity)("pages")
+  (0, import_typeorm21.Entity)("pages")
 ], Page);
 
 // src/entities/product-category.entity.ts
-var import_typeorm20 = require("typeorm");
+var import_typeorm22 = require("typeorm");
 var ProductCategory = class {
   id;
   name;
@@ -2223,75 +2448,75 @@ var ProductCategory = class {
   collections;
 };
 __decorateClass([
-  (0, import_typeorm20.PrimaryGeneratedColumn)()
+  (0, import_typeorm22.PrimaryGeneratedColumn)()
 ], ProductCategory.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("varchar")
+  (0, import_typeorm22.Column)("varchar")
 ], ProductCategory.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("varchar", { unique: true })
+  (0, import_typeorm22.Column)("varchar", { unique: true })
 ], ProductCategory.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm22.Column)("int", { nullable: true })
 ], ProductCategory.prototype, "parentId", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("varchar", { nullable: true })
+  (0, import_typeorm22.Column)("varchar", { nullable: true })
 ], ProductCategory.prototype, "image", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("text", { nullable: true })
+  (0, import_typeorm22.Column)("text", { nullable: true })
 ], ProductCategory.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("jsonb", { nullable: true })
+  (0, import_typeorm22.Column)("jsonb", { nullable: true })
 ], ProductCategory.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("boolean", { default: true })
+  (0, import_typeorm22.Column)("boolean", { default: true })
 ], ProductCategory.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { default: 0 })
+  (0, import_typeorm22.Column)("int", { default: 0 })
 ], ProductCategory.prototype, "sortOrder", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductCategory.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductCategory.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm22.Column)({ type: "timestamp", nullable: true })
 ], ProductCategory.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("boolean", { default: false })
+  (0, import_typeorm22.Column)("boolean", { default: false })
 ], ProductCategory.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm22.Column)("int", { nullable: true })
 ], ProductCategory.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm22.Column)("int", { nullable: true })
 ], ProductCategory.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm22.Column)("int", { nullable: true })
 ], ProductCategory.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm20.ManyToOne)(() => ProductCategory, (c) => c.children, { onDelete: "SET NULL" }),
-  (0, import_typeorm20.JoinColumn)({ name: "parentId" })
+  (0, import_typeorm22.ManyToOne)(() => ProductCategory, (c) => c.children, { onDelete: "SET NULL" }),
+  (0, import_typeorm22.JoinColumn)({ name: "parentId" })
 ], ProductCategory.prototype, "parent", 2);
 __decorateClass([
-  (0, import_typeorm20.OneToMany)(() => ProductCategory, (c) => c.parent)
+  (0, import_typeorm22.OneToMany)(() => ProductCategory, (c) => c.parent)
 ], ProductCategory.prototype, "children", 2);
 __decorateClass([
-  (0, import_typeorm20.OneToMany)("Product", "category")
+  (0, import_typeorm22.OneToMany)("Product", "category")
 ], ProductCategory.prototype, "products", 2);
 __decorateClass([
-  (0, import_typeorm20.OneToMany)("Collection", "category")
+  (0, import_typeorm22.OneToMany)("Collection", "category")
 ], ProductCategory.prototype, "collections", 2);
 ProductCategory = __decorateClass([
-  (0, import_typeorm20.Entity)("product_categories")
+  (0, import_typeorm22.Entity)("product_categories")
 ], ProductCategory);
 
 // src/entities/collection.entity.ts
-var import_typeorm22 = require("typeorm");
+var import_typeorm24 = require("typeorm");
 
 // src/entities/brand.entity.ts
-var import_typeorm21 = require("typeorm");
+var import_typeorm23 = require("typeorm");
 var Brand = class {
   id;
   name;
@@ -2314,65 +2539,65 @@ var Brand = class {
   collections;
 };
 __decorateClass([
-  (0, import_typeorm21.PrimaryGeneratedColumn)()
+  (0, import_typeorm23.PrimaryGeneratedColumn)()
 ], Brand.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("varchar")
+  (0, import_typeorm23.Column)("varchar")
 ], Brand.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("varchar", { unique: true })
+  (0, import_typeorm23.Column)("varchar", { unique: true })
 ], Brand.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("varchar", { nullable: true })
+  (0, import_typeorm23.Column)("varchar", { nullable: true })
 ], Brand.prototype, "logo", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("jsonb", { nullable: true })
+  (0, import_typeorm23.Column)("jsonb", { nullable: true })
 ], Brand.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("text", { nullable: true })
+  (0, import_typeorm23.Column)("text", { nullable: true })
 ], Brand.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("boolean", { default: true })
+  (0, import_typeorm23.Column)("boolean", { default: true })
 ], Brand.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { default: 0 })
+  (0, import_typeorm23.Column)("int", { default: 0 })
 ], Brand.prototype, "sortOrder", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Brand.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Brand.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm23.Column)({ type: "timestamp", nullable: true })
 ], Brand.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("boolean", { default: false })
+  (0, import_typeorm23.Column)("boolean", { default: false })
 ], Brand.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { nullable: true })
+  (0, import_typeorm23.Column)("int", { nullable: true })
 ], Brand.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { nullable: true })
+  (0, import_typeorm23.Column)("int", { nullable: true })
 ], Brand.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { nullable: true })
+  (0, import_typeorm23.Column)("int", { nullable: true })
 ], Brand.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { nullable: true })
+  (0, import_typeorm23.Column)("int", { nullable: true })
 ], Brand.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm21.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm21.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm23.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm23.JoinColumn)({ name: "seoId" })
 ], Brand.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm21.OneToMany)("Product", "brand")
+  (0, import_typeorm23.OneToMany)("Product", "brand")
 ], Brand.prototype, "products", 2);
 __decorateClass([
-  (0, import_typeorm21.OneToMany)("Collection", "brand")
+  (0, import_typeorm23.OneToMany)("Collection", "brand")
 ], Brand.prototype, "collections", 2);
 Brand = __decorateClass([
-  (0, import_typeorm21.Entity)("brands")
+  (0, import_typeorm23.Entity)("brands")
 ], Brand);
 
 // src/entities/collection.entity.ts
@@ -2401,80 +2626,80 @@ var Collection = class {
   products;
 };
 __decorateClass([
-  (0, import_typeorm22.PrimaryGeneratedColumn)()
+  (0, import_typeorm24.PrimaryGeneratedColumn)()
 ], Collection.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("int", { nullable: true })
+  (0, import_typeorm24.Column)("int", { nullable: true })
 ], Collection.prototype, "categoryId", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("int", { nullable: true })
+  (0, import_typeorm24.Column)("int", { nullable: true })
 ], Collection.prototype, "brandId", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("varchar")
+  (0, import_typeorm24.Column)("varchar")
 ], Collection.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("varchar", { unique: true })
+  (0, import_typeorm24.Column)("varchar", { unique: true })
 ], Collection.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("text", { nullable: true })
+  (0, import_typeorm24.Column)("text", { nullable: true })
 ], Collection.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("varchar", { nullable: true })
+  (0, import_typeorm24.Column)("varchar", { nullable: true })
 ], Collection.prototype, "image", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("jsonb", { nullable: true })
+  (0, import_typeorm24.Column)("jsonb", { nullable: true })
 ], Collection.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("boolean", { default: true })
+  (0, import_typeorm24.Column)("boolean", { default: true })
 ], Collection.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("int", { default: 0 })
+  (0, import_typeorm24.Column)("int", { default: 0 })
 ], Collection.prototype, "sortOrder", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Collection.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Collection.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm24.Column)({ type: "timestamp", nullable: true })
 ], Collection.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("boolean", { default: false })
+  (0, import_typeorm24.Column)("boolean", { default: false })
 ], Collection.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("int", { nullable: true })
+  (0, import_typeorm24.Column)("int", { nullable: true })
 ], Collection.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("int", { nullable: true })
+  (0, import_typeorm24.Column)("int", { nullable: true })
 ], Collection.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("int", { nullable: true })
+  (0, import_typeorm24.Column)("int", { nullable: true })
 ], Collection.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("int", { nullable: true })
+  (0, import_typeorm24.Column)("int", { nullable: true })
 ], Collection.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm22.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm22.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm24.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm24.JoinColumn)({ name: "seoId" })
 ], Collection.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm22.ManyToOne)(() => ProductCategory, (c) => c.collections, { onDelete: "SET NULL" }),
-  (0, import_typeorm22.JoinColumn)({ name: "categoryId" })
+  (0, import_typeorm24.ManyToOne)(() => ProductCategory, (c) => c.collections, { onDelete: "SET NULL" }),
+  (0, import_typeorm24.JoinColumn)({ name: "categoryId" })
 ], Collection.prototype, "category", 2);
 __decorateClass([
-  (0, import_typeorm22.ManyToOne)(() => Brand, (b) => b.collections, { onDelete: "SET NULL" }),
-  (0, import_typeorm22.JoinColumn)({ name: "brandId" })
+  (0, import_typeorm24.ManyToOne)(() => Brand, (b) => b.collections, { onDelete: "SET NULL" }),
+  (0, import_typeorm24.JoinColumn)({ name: "brandId" })
 ], Collection.prototype, "brand", 2);
 __decorateClass([
-  (0, import_typeorm22.OneToMany)("Product", "collection")
+  (0, import_typeorm24.OneToMany)("Product", "collection")
 ], Collection.prototype, "products", 2);
 Collection = __decorateClass([
-  (0, import_typeorm22.Entity)("collections")
+  (0, import_typeorm24.Entity)("collections")
 ], Collection);
 
 // src/entities/product.entity.ts
-var import_typeorm23 = require("typeorm");
+var import_typeorm25 = require("typeorm");
 var Product = class {
   id;
   collectionId;
@@ -2505,96 +2730,96 @@ var Product = class {
   taxes;
 };
 __decorateClass([
-  (0, import_typeorm23.PrimaryGeneratedColumn)()
+  (0, import_typeorm25.PrimaryGeneratedColumn)()
 ], Product.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Product.prototype, "collectionId", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Product.prototype, "brandId", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Product.prototype, "categoryId", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("varchar", { nullable: true })
+  (0, import_typeorm25.Column)("varchar", { nullable: true })
 ], Product.prototype, "sku", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("varchar", { unique: true, nullable: true })
+  (0, import_typeorm25.Column)("varchar", { unique: true, nullable: true })
 ], Product.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("varchar", { nullable: true })
+  (0, import_typeorm25.Column)("varchar", { nullable: true })
 ], Product.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("decimal", { precision: 12, scale: 2 })
+  (0, import_typeorm25.Column)("decimal", { precision: 12, scale: 2 })
 ], Product.prototype, "price", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("decimal", { precision: 12, scale: 2, nullable: true })
+  (0, import_typeorm25.Column)("decimal", { precision: 12, scale: 2, nullable: true })
 ], Product.prototype, "compareAtPrice", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int", { default: 0 })
+  (0, import_typeorm25.Column)("int", { default: 0 })
 ], Product.prototype, "quantity", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("varchar", { default: "draft" })
+  (0, import_typeorm25.Column)("varchar", { default: "draft" })
 ], Product.prototype, "status", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("boolean", { default: false })
+  (0, import_typeorm25.Column)("boolean", { default: false })
 ], Product.prototype, "featured", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("jsonb", { nullable: true })
+  (0, import_typeorm25.Column)("jsonb", { nullable: true })
 ], Product.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Product.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Product.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm25.Column)({ type: "timestamp", nullable: true })
 ], Product.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("boolean", { default: false })
+  (0, import_typeorm25.Column)("boolean", { default: false })
 ], Product.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Product.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Product.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Product.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Product.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm23.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm23.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm25.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm25.JoinColumn)({ name: "seoId" })
 ], Product.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm23.ManyToOne)(() => Collection, (c) => c.products, { onDelete: "SET NULL" }),
-  (0, import_typeorm23.JoinColumn)({ name: "collectionId" })
+  (0, import_typeorm25.ManyToOne)(() => Collection, (c) => c.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm25.JoinColumn)({ name: "collectionId" })
 ], Product.prototype, "collection", 2);
 __decorateClass([
-  (0, import_typeorm23.ManyToOne)(() => Brand, (b) => b.products, { onDelete: "SET NULL" }),
-  (0, import_typeorm23.JoinColumn)({ name: "brandId" })
+  (0, import_typeorm25.ManyToOne)(() => Brand, (b) => b.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm25.JoinColumn)({ name: "brandId" })
 ], Product.prototype, "brand", 2);
 __decorateClass([
-  (0, import_typeorm23.ManyToOne)(() => ProductCategory, (c) => c.products, { onDelete: "SET NULL" }),
-  (0, import_typeorm23.JoinColumn)({ name: "categoryId" })
+  (0, import_typeorm25.ManyToOne)(() => ProductCategory, (c) => c.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm25.JoinColumn)({ name: "categoryId" })
 ], Product.prototype, "category", 2);
 __decorateClass([
-  (0, import_typeorm23.OneToMany)("ProductAttribute", "product")
+  (0, import_typeorm25.OneToMany)("ProductAttribute", "product")
 ], Product.prototype, "attributes", 2);
 __decorateClass([
-  (0, import_typeorm23.OneToMany)("ProductTax", "product")
+  (0, import_typeorm25.OneToMany)("ProductTax", "product")
 ], Product.prototype, "taxes", 2);
 Product = __decorateClass([
-  (0, import_typeorm23.Entity)("products")
+  (0, import_typeorm25.Entity)("products")
 ], Product);
 
 // src/entities/attribute.entity.ts
-var import_typeorm24 = require("typeorm");
+var import_typeorm26 = require("typeorm");
 var Attribute = class {
   id;
   name;
@@ -2613,56 +2838,56 @@ var Attribute = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm24.PrimaryGeneratedColumn)()
+  (0, import_typeorm26.PrimaryGeneratedColumn)()
 ], Attribute.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar")
+  (0, import_typeorm26.Column)("varchar")
 ], Attribute.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar", { unique: true })
+  (0, import_typeorm26.Column)("varchar", { unique: true })
 ], Attribute.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar", { default: "text" })
+  (0, import_typeorm26.Column)("varchar", { default: "text" })
 ], Attribute.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("jsonb", { nullable: true })
+  (0, import_typeorm26.Column)("jsonb", { nullable: true })
 ], Attribute.prototype, "options", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("jsonb", { nullable: true })
+  (0, import_typeorm26.Column)("jsonb", { nullable: true })
 ], Attribute.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("boolean", { default: true })
+  (0, import_typeorm26.Column)("boolean", { default: true })
 ], Attribute.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("int", { default: 0 })
+  (0, import_typeorm26.Column)("int", { default: 0 })
 ], Attribute.prototype, "sortOrder", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Attribute.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Attribute.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm26.Column)({ type: "timestamp", nullable: true })
 ], Attribute.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("boolean", { default: false })
+  (0, import_typeorm26.Column)("boolean", { default: false })
 ], Attribute.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("int", { nullable: true })
+  (0, import_typeorm26.Column)("int", { nullable: true })
 ], Attribute.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("int", { nullable: true })
+  (0, import_typeorm26.Column)("int", { nullable: true })
 ], Attribute.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("int", { nullable: true })
+  (0, import_typeorm26.Column)("int", { nullable: true })
 ], Attribute.prototype, "deletedBy", 2);
 Attribute = __decorateClass([
-  (0, import_typeorm24.Entity)("attributes")
+  (0, import_typeorm26.Entity)("attributes")
 ], Attribute);
 
 // src/entities/product-attribute.entity.ts
-var import_typeorm25 = require("typeorm");
+var import_typeorm27 = require("typeorm");
 var ProductAttribute = class {
   id;
   productId;
@@ -2675,40 +2900,40 @@ var ProductAttribute = class {
   attribute;
 };
 __decorateClass([
-  (0, import_typeorm25.PrimaryGeneratedColumn)()
+  (0, import_typeorm27.PrimaryGeneratedColumn)()
 ], ProductAttribute.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("int")
+  (0, import_typeorm27.Column)("int")
 ], ProductAttribute.prototype, "productId", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("int")
+  (0, import_typeorm27.Column)("int")
 ], ProductAttribute.prototype, "attributeId", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("varchar")
+  (0, import_typeorm27.Column)("varchar")
 ], ProductAttribute.prototype, "value", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("jsonb", { nullable: true })
+  (0, import_typeorm27.Column)("jsonb", { nullable: true })
 ], ProductAttribute.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductAttribute.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductAttribute.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm25.ManyToOne)(() => Product, (p) => p.attributes, { onDelete: "CASCADE" }),
-  (0, import_typeorm25.JoinColumn)({ name: "productId" })
+  (0, import_typeorm27.ManyToOne)(() => Product, (p) => p.attributes, { onDelete: "CASCADE" }),
+  (0, import_typeorm27.JoinColumn)({ name: "productId" })
 ], ProductAttribute.prototype, "product", 2);
 __decorateClass([
-  (0, import_typeorm25.ManyToOne)(() => Attribute, { onDelete: "CASCADE" }),
-  (0, import_typeorm25.JoinColumn)({ name: "attributeId" })
+  (0, import_typeorm27.ManyToOne)(() => Attribute, { onDelete: "CASCADE" }),
+  (0, import_typeorm27.JoinColumn)({ name: "attributeId" })
 ], ProductAttribute.prototype, "attribute", 2);
 ProductAttribute = __decorateClass([
-  (0, import_typeorm25.Entity)("product_attributes")
+  (0, import_typeorm27.Entity)("product_attributes")
 ], ProductAttribute);
 
 // src/entities/tax.entity.ts
-var import_typeorm26 = require("typeorm");
+var import_typeorm28 = require("typeorm");
 var Tax = class {
   id;
   name;
@@ -2727,56 +2952,56 @@ var Tax = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm26.PrimaryGeneratedColumn)()
+  (0, import_typeorm28.PrimaryGeneratedColumn)()
 ], Tax.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("varchar")
+  (0, import_typeorm28.Column)("varchar")
 ], Tax.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("varchar", { unique: true })
+  (0, import_typeorm28.Column)("varchar", { unique: true })
 ], Tax.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("decimal", { precision: 5, scale: 2 })
+  (0, import_typeorm28.Column)("decimal", { precision: 5, scale: 2 })
 ], Tax.prototype, "rate", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("boolean", { default: false })
+  (0, import_typeorm28.Column)("boolean", { default: false })
 ], Tax.prototype, "isDefault", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("text", { nullable: true })
+  (0, import_typeorm28.Column)("text", { nullable: true })
 ], Tax.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("boolean", { default: true })
+  (0, import_typeorm28.Column)("boolean", { default: true })
 ], Tax.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("jsonb", { nullable: true })
+  (0, import_typeorm28.Column)("jsonb", { nullable: true })
 ], Tax.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Tax.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Tax.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm28.Column)({ type: "timestamp", nullable: true })
 ], Tax.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("boolean", { default: false })
+  (0, import_typeorm28.Column)("boolean", { default: false })
 ], Tax.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("int", { nullable: true })
+  (0, import_typeorm28.Column)("int", { nullable: true })
 ], Tax.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("int", { nullable: true })
+  (0, import_typeorm28.Column)("int", { nullable: true })
 ], Tax.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("int", { nullable: true })
+  (0, import_typeorm28.Column)("int", { nullable: true })
 ], Tax.prototype, "deletedBy", 2);
 Tax = __decorateClass([
-  (0, import_typeorm26.Entity)("taxes")
+  (0, import_typeorm28.Entity)("taxes")
 ], Tax);
 
 // src/entities/product-tax.entity.ts
-var import_typeorm27 = require("typeorm");
+var import_typeorm29 = require("typeorm");
 var ProductTax = class {
   id;
   productId;
@@ -2788,37 +3013,37 @@ var ProductTax = class {
   tax;
 };
 __decorateClass([
-  (0, import_typeorm27.PrimaryGeneratedColumn)()
+  (0, import_typeorm29.PrimaryGeneratedColumn)()
 ], ProductTax.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("int")
+  (0, import_typeorm29.Column)("int")
 ], ProductTax.prototype, "productId", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("int")
+  (0, import_typeorm29.Column)("int")
 ], ProductTax.prototype, "taxId", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("decimal", { precision: 5, scale: 2, nullable: true })
+  (0, import_typeorm29.Column)("decimal", { precision: 5, scale: 2, nullable: true })
 ], ProductTax.prototype, "rate", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm29.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductTax.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm29.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductTax.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm27.ManyToOne)(() => Product, (p) => p.taxes, { onDelete: "CASCADE" }),
-  (0, import_typeorm27.JoinColumn)({ name: "productId" })
+  (0, import_typeorm29.ManyToOne)(() => Product, (p) => p.taxes, { onDelete: "CASCADE" }),
+  (0, import_typeorm29.JoinColumn)({ name: "productId" })
 ], ProductTax.prototype, "product", 2);
 __decorateClass([
-  (0, import_typeorm27.ManyToOne)(() => Tax, { onDelete: "CASCADE" }),
-  (0, import_typeorm27.JoinColumn)({ name: "taxId" })
+  (0, import_typeorm29.ManyToOne)(() => Tax, { onDelete: "CASCADE" }),
+  (0, import_typeorm29.JoinColumn)({ name: "taxId" })
 ], ProductTax.prototype, "tax", 2);
 ProductTax = __decorateClass([
-  (0, import_typeorm27.Entity)("product_taxes")
+  (0, import_typeorm29.Entity)("product_taxes")
 ], ProductTax);
 
 // src/entities/order-item.entity.ts
-var import_typeorm28 = require("typeorm");
+var import_typeorm30 = require("typeorm");
 var OrderItem = class {
   id;
   orderId;
@@ -2834,47 +3059,118 @@ var OrderItem = class {
   product;
 };
 __decorateClass([
-  (0, import_typeorm28.PrimaryGeneratedColumn)()
+  (0, import_typeorm30.PrimaryGeneratedColumn)()
 ], OrderItem.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("int")
+  (0, import_typeorm30.Column)("int")
 ], OrderItem.prototype, "orderId", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("int")
+  (0, import_typeorm30.Column)("int")
 ], OrderItem.prototype, "productId", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("int", { default: 1 })
+  (0, import_typeorm30.Column)("int", { default: 1 })
 ], OrderItem.prototype, "quantity", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("decimal", { precision: 12, scale: 2 })
+  (0, import_typeorm30.Column)("decimal", { precision: 12, scale: 2 })
 ], OrderItem.prototype, "unitPrice", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+  (0, import_typeorm30.Column)("decimal", { precision: 12, scale: 2, default: 0 })
 ], OrderItem.prototype, "tax", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("decimal", { precision: 12, scale: 2 })
+  (0, import_typeorm30.Column)("decimal", { precision: 12, scale: 2 })
 ], OrderItem.prototype, "total", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("jsonb", { nullable: true })
+  (0, import_typeorm30.Column)("jsonb", { nullable: true })
 ], OrderItem.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm30.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], OrderItem.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm30.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], OrderItem.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm28.ManyToOne)(() => Order, (o) => o.items, { onDelete: "CASCADE" }),
-  (0, import_typeorm28.JoinColumn)({ name: "orderId" })
+  (0, import_typeorm30.ManyToOne)(() => Order, (o) => o.items, { onDelete: "CASCADE" }),
+  (0, import_typeorm30.JoinColumn)({ name: "orderId" })
 ], OrderItem.prototype, "order", 2);
 __decorateClass([
-  (0, import_typeorm28.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
-  (0, import_typeorm28.JoinColumn)({ name: "productId" })
+  (0, import_typeorm30.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
+  (0, import_typeorm30.JoinColumn)({ name: "productId" })
 ], OrderItem.prototype, "product", 2);
 OrderItem = __decorateClass([
-  (0, import_typeorm28.Entity)("order_items")
+  (0, import_typeorm30.Entity)("order_items")
 ], OrderItem);
 
+// src/entities/knowledge-base-document.entity.ts
+var import_typeorm32 = require("typeorm");
+
+// src/entities/knowledge-base-chunk.entity.ts
+var import_typeorm31 = require("typeorm");
+var KnowledgeBaseChunk = class {
+  id;
+  documentId;
+  content;
+  chunkIndex;
+  createdAt;
+  document;
+};
+__decorateClass([
+  (0, import_typeorm31.PrimaryGeneratedColumn)()
+], KnowledgeBaseChunk.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm31.Column)("int")
+], KnowledgeBaseChunk.prototype, "documentId", 2);
+__decorateClass([
+  (0, import_typeorm31.Column)("text")
+], KnowledgeBaseChunk.prototype, "content", 2);
+__decorateClass([
+  (0, import_typeorm31.Column)("int", { default: 0 })
+], KnowledgeBaseChunk.prototype, "chunkIndex", 2);
+__decorateClass([
+  (0, import_typeorm31.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], KnowledgeBaseChunk.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm31.ManyToOne)(() => KnowledgeBaseDocument, (d) => d.chunks, { onDelete: "CASCADE" }),
+  (0, import_typeorm31.JoinColumn)({ name: "documentId" })
+], KnowledgeBaseChunk.prototype, "document", 2);
+KnowledgeBaseChunk = __decorateClass([
+  (0, import_typeorm31.Entity)("knowledge_base_chunks")
+], KnowledgeBaseChunk);
+
+// src/entities/knowledge-base-document.entity.ts
+var KnowledgeBaseDocument = class {
+  id;
+  name;
+  sourceUrl;
+  content;
+  createdAt;
+  updatedAt;
+  chunks;
+};
+__decorateClass([
+  (0, import_typeorm32.PrimaryGeneratedColumn)()
+], KnowledgeBaseDocument.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm32.Column)("varchar")
+], KnowledgeBaseDocument.prototype, "name", 2);
+__decorateClass([
+  (0, import_typeorm32.Column)("varchar", { nullable: true })
+], KnowledgeBaseDocument.prototype, "sourceUrl", 2);
+__decorateClass([
+  (0, import_typeorm32.Column)("text")
+], KnowledgeBaseDocument.prototype, "content", 2);
+__decorateClass([
+  (0, import_typeorm32.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], KnowledgeBaseDocument.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm32.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], KnowledgeBaseDocument.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm32.OneToMany)(() => KnowledgeBaseChunk, (c) => c.document)
+], KnowledgeBaseDocument.prototype, "chunks", 2);
+KnowledgeBaseDocument = __decorateClass([
+  (0, import_typeorm32.Entity)("knowledge_base_documents")
+], KnowledgeBaseDocument);
+
 // src/entities/index.ts
 var CMS_ENTITY_MAP = {
   users: User,
@@ -2904,7 +3200,11 @@ var CMS_ENTITY_MAP = {
   orders: Order,
   order_items: OrderItem,
   payments: Payment,
-  brands: Brand
+  brands: Brand,
+  knowledge_base_documents: KnowledgeBaseDocument,
+  knowledge_base_chunks: KnowledgeBaseChunk,
+  chat_conversations: ChatConversation,
+  chat_messages: ChatMessage
 };
 
 // src/auth/helpers.ts
@@ -3073,7 +3373,7 @@ function getNextAuthOptions(config) {
 }
 
 // src/api/crud.ts
-var import_typeorm29 = require("typeorm");
+var import_typeorm33 = require("typeorm");
 var DATE_COLUMN_TYPES = /* @__PURE__ */ new Set([
   "date",
   "datetime",
@@ -3214,10 +3514,10 @@ function createCrudHandler(dataSource, entityMap, options) {
         const inventory = searchParams.get("inventory")?.trim();
         const productWhere = {};
         if (statusFilter) productWhere.status = statusFilter;
-        if (inventory === "in_stock") productWhere.quantity = (0, import_typeorm29.MoreThan)(0);
+        if (inventory === "in_stock") productWhere.quantity = (0, import_typeorm33.MoreThan)(0);
         if (inventory === "out_of_stock") productWhere.quantity = 0;
         if (search && typeof search === "string" && search.trim()) {
-          productWhere.name = (0, import_typeorm29.ILike)(`%${search.trim()}%`);
+          productWhere.name = (0, import_typeorm33.ILike)(`%${search.trim()}%`);
         }
         const [data2, total2] = await repo2.findAndCount({
           where: Object.keys(productWhere).length ? productWhere : void 0,
@@ -3272,11 +3572,11 @@ function createCrudHandler(dataSource, entityMap, options) {
       let where = {};
       if (resource === "media") {
         const mediaWhere = {};
-        if (search) mediaWhere.filename = (0, import_typeorm29.ILike)(`%${search}%`);
-        if (typeFilter) mediaWhere.mimeType = (0, import_typeorm29.Like)(`${typeFilter}/%`);
+        if (search) mediaWhere.filename = (0, import_typeorm33.ILike)(`%${search}%`);
+        if (typeFilter) mediaWhere.mimeType = (0, import_typeorm33.Like)(`${typeFilter}/%`);
         where = Object.keys(mediaWhere).length > 0 ? mediaWhere : {};
       } else if (search) {
-        where = [{ name: (0, import_typeorm29.ILike)(`%${search}%`) }, { title: (0, import_typeorm29.ILike)(`%${search}%`) }];
+        where = [{ name: (0, import_typeorm33.ILike)(`%${search}%`) }, { title: (0, import_typeorm33.ILike)(`%${search}%`) }];
       }
       const [data, total] = await repo.findAndCount({
         skip,
@@ -3607,7 +3907,7 @@ function createUserAuthApiRouter(config) {
 }
 
 // src/api/cms-handlers.ts
-var import_typeorm30 = require("typeorm");
+var import_typeorm34 = require("typeorm");
 function createDashboardStatsHandler(config) {
   const { dataSource, entityMap, json, requireAuth, requirePermission } = config;
   return async function GET(req) {
@@ -3626,8 +3926,8 @@ function createDashboardStatsHandler(config) {
         repo("form_submissions")?.count() ?? 0,
         repo("users")?.count({ where: { deleted: false } }) ?? 0,
         repo("blogs")?.count({ where: { deleted: false } }) ?? 0,
-        repo("contacts")?.count({ where: { createdAt: (0, import_typeorm30.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0,
-        repo("form_submissions")?.count({ where: { createdAt: (0, import_typeorm30.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0
+        repo("contacts")?.count({ where: { createdAt: (0, import_typeorm34.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0,
+        repo("form_submissions")?.count({ where: { createdAt: (0, import_typeorm34.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0
       ]);
       return json({
         contacts: { total: contactsCount, recent: recentContacts },
@@ -3980,7 +4280,7 @@ function createUsersApiHandlers(config) {
         const sortField = url.searchParams.get("sortField") || "createdAt";
         const sortOrder = url.searchParams.get("sortOrder") === "desc" ? "DESC" : "ASC";
         const search = url.searchParams.get("search");
-        const where = search ? [{ name: (0, import_typeorm30.ILike)(`%${search}%`) }, { email: (0, import_typeorm30.ILike)(`%${search}%`) }] : {};
+        const where = search ? [{ name: (0, import_typeorm34.ILike)(`%${search}%`) }, { email: (0, import_typeorm34.ILike)(`%${search}%`) }] : {};
         const [data, total] = await userRepo().findAndCount({
           skip,
           take: limit,
@@ -4188,6 +4488,129 @@ function createSettingsApiHandlers(config) {
     }
   };
 }
+var KB_CHUNK_LIMIT = 10;
+var KB_CONTEXT_MAX_CHARS = 4e3;
+function getQueryTerms(message) {
+  return message.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2).slice(0, 6);
+}
+function createChatHandlers(config) {
+  const { dataSource, entityMap, json, getCms } = config;
+  const contactRepo = () => dataSource.getRepository(entityMap.contacts);
+  const convRepo = () => dataSource.getRepository(entityMap.chat_conversations);
+  const msgRepo = () => dataSource.getRepository(entityMap.chat_messages);
+  const chunkRepo = () => dataSource.getRepository(entityMap.knowledge_base_chunks);
+  return {
+    async identify(req) {
+      try {
+        const body = await req.json();
+        const name = body?.name?.trim();
+        const email = body?.email?.trim();
+        if (!name || !email) return json({ error: "name and email required" }, { status: 400 });
+        const repo = contactRepo();
+        let contact = await repo.findOne({ where: { email, deleted: false } });
+        if (!contact) {
+          const created = repo.create({ name, email, phone: body.phone?.trim() || null });
+          contact = await repo.save(created);
+        }
+        const convRepoInst = convRepo();
+        const conv = await convRepoInst.save(convRepoInst.create({ contactId: contact.id }));
+        return json({
+          contactId: contact.id,
+          conversationId: conv.id
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to identify";
+        return json({ error: "Failed to identify", detail: message }, { status: 500 });
+      }
+    },
+    async getMessages(req, conversationId) {
+      try {
+        const conv = await convRepo().findOne({
+          where: { id: parseInt(conversationId, 10) },
+          relations: ["messages"]
+        });
+        if (!conv) return json({ error: "Conversation not found" }, { status: 404 });
+        const messages = (conv.messages ?? []).sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()).map((m) => ({ role: m.role, content: m.content }));
+        return json({ messages });
+      } catch {
+        return json({ error: "Failed to fetch messages" }, { status: 500 });
+      }
+    },
+    async postMessage(req) {
+      try {
+        const body = await req.json();
+        const conversationId = body?.conversationId;
+        const message = body?.message?.trim();
+        if (!conversationId || !message) return json({ error: "conversationId and message required" }, { status: 400 });
+        const conv = await convRepo().findOne({
+          where: { id: conversationId },
+          relations: ["messages"]
+        });
+        if (!conv) return json({ error: "Conversation not found" }, { status: 404 });
+        const msgRepoInst = msgRepo();
+        await msgRepoInst.save(msgRepoInst.create({ conversationId, role: "user", content: message }));
+        const cms = await getCms();
+        const llm = cms.getPlugin("llm");
+        if (!llm?.chat) return json({ error: "LLM not configured" }, { status: 503 });
+        let contextParts = [];
+        const queryEmbedding = llm.embed ? await llm.embed(message) : null;
+        if (queryEmbedding && queryEmbedding.length > 0) {
+          const vectorStr = "[" + queryEmbedding.join(",") + "]";
+          try {
+            const rows = await dataSource.query(
+              `SELECT id, content FROM knowledge_base_chunks WHERE embedding IS NOT NULL ORDER BY embedding <=> $1::vector LIMIT $2`,
+              [vectorStr, KB_CHUNK_LIMIT]
+            );
+            let totalLen = 0;
+            for (const r of rows) {
+              const text = (r.content ?? "").trim();
+              if (!text || totalLen + text.length > KB_CONTEXT_MAX_CHARS) continue;
+              contextParts.push(text);
+              totalLen += text.length;
+            }
+          } catch {
+          }
+        }
+        if (contextParts.length === 0) {
+          const terms = getQueryTerms(message);
+          if (terms.length > 0) {
+            const conditions = terms.map((t) => ({ content: (0, import_typeorm34.ILike)(`%${t}%`) }));
+            const chunks = await chunkRepo().find({
+              where: conditions,
+              take: KB_CHUNK_LIMIT,
+              order: { id: "ASC" }
+            });
+            const seen = /* @__PURE__ */ new Set();
+            let totalLen = 0;
+            for (const c of chunks) {
+              const text = c.content.trim();
+              if (seen.has(text) || totalLen + text.length > KB_CONTEXT_MAX_CHARS) continue;
+              seen.add(text);
+              contextParts.push(text);
+              totalLen += text.length;
+            }
+          }
+        }
+        const history = (conv.messages ?? []).sort((a, b) => new Date(a.createdAt ?? 0).getTime() - new Date(b.createdAt ?? 0).getTime()).map((m) => ({ role: m.role, content: m.content }));
+        const systemContent = contextParts.length > 0 ? `Use the following context about the company and its products to answer. If the answer is not in the context, say so.
+
+Context:
+${contextParts.join("\n\n")}` : "You are a helpful assistant for the company. If you do not have specific information, say so.";
+        const messages = [
+          { role: "system", content: systemContent },
+          ...history,
+          { role: "user", content: message }
+        ];
+        const { content } = await llm.chat(messages);
+        await msgRepoInst.save(msgRepoInst.create({ conversationId, role: "assistant", content }));
+        return json({ content });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "";
+        return json({ error: msg || "Failed to send message" }, { status: 500 });
+      }
+    }
+  };
+}
 
 // src/api/cms-api-handler.ts
 var DEFAULT_EXCLUDE = /* @__PURE__ */ new Set(["users", "password_reset_tokens", "user_groups", "permissions", "comments", "form_fields", "configs"]);
@@ -4210,7 +4633,8 @@ function createCmsApiHandler(config) {
     usersApi,
     userAvatar,
     userProfile,
-    settings: settingsConfig
+    settings: settingsConfig,
+    chat: chatConfig
   } = config;
   const analytics = analyticsConfig ?? (getCms ? {
     json: config.json,
@@ -4255,6 +4679,7 @@ function createCmsApiHandler(config) {
   const avatarPost = userAvatar ? createUserAvatarHandler(userAvatar) : null;
   const profilePut = userProfile ? createUserProfileHandler(userProfile) : null;
   const settingsHandlers = settingsConfig ? createSettingsApiHandlers(settingsConfig) : null;
+  const chatHandlers = chatConfig ? createChatHandlers(chatConfig) : null;
   function resolveResource(segment) {
     const model = pathToModel(segment);
     return crudResources.includes(model) ? model : segment;
@@ -4314,6 +4739,11 @@ function createCmsApiHandler(config) {
         if (method === "GET") return settingsHandlers.GET(req, path[1]);
         if (method === "PUT") return settingsHandlers.PUT(req, path[1]);
       }
+      if (path[0] === "chat" && chatHandlers) {
+        if (path.length === 2 && path[1] === "identify" && method === "POST") return chatHandlers.identify(req);
+        if (path.length === 4 && path[1] === "conversations" && path[3] === "messages" && method === "GET") return chatHandlers.getMessages(req, path[2]);
+        if (path.length === 2 && path[1] === "messages" && method === "POST") return chatHandlers.postMessage(req);
+      }
       if (path.length === 0) return config.json({ error: "Not found" }, { status: 404 });
       const resource = resolveResource(path[0]);
       if (!crudResources.includes(resource)) return config.json({ error: "Invalid resource" }, { status: 400 });
@@ -4362,6 +4792,8 @@ var DEFAULT_ADMIN_NAV = [
   Brand,
   CMS_ENTITY_MAP,
   Category,
+  ChatConversation,
+  ChatMessage,
   Collection,
   Comment,
   Config,
@@ -4371,6 +4803,9 @@ var DEFAULT_ADMIN_NAV = [
   Form,
   FormField,
   FormSubmission,
+  KnowledgeBaseChunk,
+  KnowledgeBaseDocument,
+  LlmService,
   Media,
   OPEN_ENDPOINTS,
   Order,
@@ -4423,6 +4858,7 @@ var DEFAULT_ADMIN_NAV = [
   getRequiredPermission,
   isOpenEndpoint,
   isPublicMethod,
+  llmPlugin,
   localStoragePlugin,
   paymentPlugin,
   s3StoragePlugin,