@infuro/cms-core 1.0.7 → 1.0.9

package/dist/index.js

@@ -779,6 +779,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
 import { clsx } from "clsx";
 import { twMerge } from "tailwind-merge";
@@ -1375,7 +1522,7 @@ Blog = __decorateClass([
 ], Blog);
 
 // src/entities/contact.entity.ts
-import { Entity as Entity16, PrimaryGeneratedColumn as PrimaryGeneratedColumn16, Column as Column16, OneToMany as OneToMany7 } from "typeorm";
+import { Entity as Entity18, PrimaryGeneratedColumn as PrimaryGeneratedColumn18, Column as Column18, OneToMany as OneToMany8 } from "typeorm";
 
 // src/entities/form-submission.entity.ts
 import { Entity as Entity12, PrimaryGeneratedColumn as PrimaryGeneratedColumn12, Column as Column12, ManyToOne as ManyToOne6, JoinColumn as JoinColumn6 } from "typeorm";
@@ -1834,6 +1981,74 @@ Payment = __decorateClass([
   Entity15("payments")
 ], Payment);
 
+// src/entities/chat-conversation.entity.ts
+import { Entity as Entity17, PrimaryGeneratedColumn as PrimaryGeneratedColumn17, Column as Column17, ManyToOne as ManyToOne11, OneToMany as OneToMany7, JoinColumn as JoinColumn11 } from "typeorm";
+
+// src/entities/chat-message.entity.ts
+import { Entity as Entity16, PrimaryGeneratedColumn as PrimaryGeneratedColumn16, Column as Column16, ManyToOne as ManyToOne10, JoinColumn as JoinColumn10 } from "typeorm";
+var ChatMessage = class {
+  id;
+  conversationId;
+  role;
+  content;
+  createdAt;
+  conversation;
+};
+__decorateClass([
+  PrimaryGeneratedColumn16()
+], ChatMessage.prototype, "id", 2);
+__decorateClass([
+  Column16("int")
+], ChatMessage.prototype, "conversationId", 2);
+__decorateClass([
+  Column16("varchar")
+], ChatMessage.prototype, "role", 2);
+__decorateClass([
+  Column16("text")
+], ChatMessage.prototype, "content", 2);
+__decorateClass([
+  Column16({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ChatMessage.prototype, "createdAt", 2);
+__decorateClass([
+  ManyToOne10(() => ChatConversation, (c) => c.messages, { onDelete: "CASCADE" }),
+  JoinColumn10({ name: "conversationId" })
+], ChatMessage.prototype, "conversation", 2);
+ChatMessage = __decorateClass([
+  Entity16("chat_messages")
+], ChatMessage);
+
+// src/entities/chat-conversation.entity.ts
+var ChatConversation = class {
+  id;
+  contactId;
+  createdAt;
+  updatedAt;
+  contact;
+  messages;
+};
+__decorateClass([
+  PrimaryGeneratedColumn17()
+], ChatConversation.prototype, "id", 2);
+__decorateClass([
+  Column17("int")
+], ChatConversation.prototype, "contactId", 2);
+__decorateClass([
+  Column17({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ChatConversation.prototype, "createdAt", 2);
+__decorateClass([
+  Column17({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ChatConversation.prototype, "updatedAt", 2);
+__decorateClass([
+  ManyToOne11(() => Contact, (c) => c.chatConversations, { onDelete: "CASCADE" }),
+  JoinColumn11({ name: "contactId" })
+], ChatConversation.prototype, "contact", 2);
+__decorateClass([
+  OneToMany7(() => ChatMessage, (m) => m.conversation)
+], ChatConversation.prototype, "messages", 2);
+ChatConversation = __decorateClass([
+  Entity17("chat_conversations")
+], ChatConversation);
+
 // src/entities/contact.entity.ts
 var Contact = class {
   id;
@@ -1855,70 +2070,74 @@ var Contact = class {
   addresses;
   orders;
   payments;
+  chatConversations;
 };
 __decorateClass([
-  PrimaryGeneratedColumn16()
+  PrimaryGeneratedColumn18()
 ], Contact.prototype, "id", 2);
 __decorateClass([
-  Column16("varchar")
+  Column18("varchar")
 ], Contact.prototype, "name", 2);
 __decorateClass([
-  Column16("varchar", { unique: true })
+  Column18("varchar", { unique: true })
 ], Contact.prototype, "email", 2);
 __decorateClass([
-  Column16("varchar", { nullable: true })
+  Column18("varchar", { nullable: true })
 ], Contact.prototype, "phone", 2);
 __decorateClass([
-  Column16("varchar", { nullable: true })
+  Column18("varchar", { nullable: true })
 ], Contact.prototype, "type", 2);
 __decorateClass([
-  Column16("varchar", { nullable: true })
+  Column18("varchar", { nullable: true })
 ], Contact.prototype, "company", 2);
 __decorateClass([
-  Column16("varchar", { nullable: true })
+  Column18("varchar", { nullable: true })
 ], Contact.prototype, "taxId", 2);
 __decorateClass([
-  Column16("text", { nullable: true })
+  Column18("text", { nullable: true })
 ], Contact.prototype, "notes", 2);
 __decorateClass([
-  Column16({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column18({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "createdAt", 2);
 __decorateClass([
-  Column16({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column18({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "updatedAt", 2);
 __decorateClass([
-  Column16({ type: "timestamp", nullable: true })
+  Column18({ type: "timestamp", nullable: true })
 ], Contact.prototype, "deletedAt", 2);
 __decorateClass([
-  Column16("boolean", { default: false })
+  Column18("boolean", { default: false })
 ], Contact.prototype, "deleted", 2);
 __decorateClass([
-  Column16("int", { nullable: true })
+  Column18("int", { nullable: true })
 ], Contact.prototype, "createdBy", 2);
 __decorateClass([
-  Column16("int", { nullable: true })
+  Column18("int", { nullable: true })
 ], Contact.prototype, "updatedBy", 2);
 __decorateClass([
-  Column16("int", { nullable: true })
+  Column18("int", { nullable: true })
 ], Contact.prototype, "deletedBy", 2);
 __decorateClass([
-  OneToMany7(() => FormSubmission, (fs) => fs.contact)
+  OneToMany8(() => FormSubmission, (fs) => fs.contact)
 ], Contact.prototype, "form_submissions", 2);
 __decorateClass([
-  OneToMany7(() => Address, (a) => a.contact)
+  OneToMany8(() => Address, (a) => a.contact)
 ], Contact.prototype, "addresses", 2);
 __decorateClass([
-  OneToMany7(() => Order, (o) => o.contact)
+  OneToMany8(() => Order, (o) => o.contact)
 ], Contact.prototype, "orders", 2);
 __decorateClass([
-  OneToMany7(() => Payment, (p) => p.contact)
+  OneToMany8(() => Payment, (p) => p.contact)
 ], Contact.prototype, "payments", 2);
+__decorateClass([
+  OneToMany8(() => ChatConversation, (c) => c.contact)
+], Contact.prototype, "chatConversations", 2);
 Contact = __decorateClass([
-  Entity16("contacts")
+  Entity18("contacts")
 ], Contact);
 
 // src/entities/config.entity.ts
-import { Entity as Entity17, PrimaryGeneratedColumn as PrimaryGeneratedColumn17, Column as Column17, Unique } from "typeorm";
+import { Entity as Entity19, PrimaryGeneratedColumn as PrimaryGeneratedColumn19, Column as Column19, Unique } from "typeorm";
 var Config = class {
   id;
   settings;
@@ -1935,51 +2154,51 @@ var Config = class {
   deletedBy;
 };
 __decorateClass([
-  PrimaryGeneratedColumn17()
+  PrimaryGeneratedColumn19()
 ], Config.prototype, "id", 2);
 __decorateClass([
-  Column17("varchar")
+  Column19("varchar")
 ], Config.prototype, "settings", 2);
 __decorateClass([
-  Column17("varchar")
+  Column19("varchar")
 ], Config.prototype, "key", 2);
 __decorateClass([
-  Column17("varchar")
+  Column19("varchar")
 ], Config.prototype, "value", 2);
 __decorateClass([
-  Column17("varchar", { default: "private" })
+  Column19("varchar", { default: "private" })
 ], Config.prototype, "type", 2);
 __decorateClass([
-  Column17("boolean", { default: false })
+  Column19("boolean", { default: false })
 ], Config.prototype, "encrypted", 2);
 __decorateClass([
-  Column17({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column19({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "createdAt", 2);
 __decorateClass([
-  Column17({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column19({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "updatedAt", 2);
 __decorateClass([
-  Column17({ type: "timestamp", nullable: true })
+  Column19({ type: "timestamp", nullable: true })
 ], Config.prototype, "deletedAt", 2);
 __decorateClass([
-  Column17("boolean", { default: false })
+  Column19("boolean", { default: false })
 ], Config.prototype, "deleted", 2);
 __decorateClass([
-  Column17("int", { nullable: true })
+  Column19("int", { nullable: true })
 ], Config.prototype, "createdBy", 2);
 __decorateClass([
-  Column17("int", { nullable: true })
+  Column19("int", { nullable: true })
 ], Config.prototype, "updatedBy", 2);
 __decorateClass([
-  Column17("int", { nullable: true })
+  Column19("int", { nullable: true })
 ], Config.prototype, "deletedBy", 2);
 Config = __decorateClass([
-  Entity17("configs"),
+  Entity19("configs"),
   Unique(["settings", "key"])
 ], Config);
 
 // src/entities/media.entity.ts
-import { Entity as Entity18, PrimaryGeneratedColumn as PrimaryGeneratedColumn18, Column as Column18 } from "typeorm";
+import { Entity as Entity20, PrimaryGeneratedColumn as PrimaryGeneratedColumn20, Column as Column20 } from "typeorm";
 var Media = class {
   id;
   filename;
@@ -1994,44 +2213,44 @@ var Media = class {
   deleted;
 };
 __decorateClass([
-  PrimaryGeneratedColumn18()
+  PrimaryGeneratedColumn20()
 ], Media.prototype, "id", 2);
 __decorateClass([
-  Column18("varchar")
+  Column20("varchar")
 ], Media.prototype, "filename", 2);
 __decorateClass([
-  Column18("varchar")
+  Column20("varchar")
 ], Media.prototype, "url", 2);
 __decorateClass([
-  Column18("varchar")
+  Column20("varchar")
 ], Media.prototype, "mimeType", 2);
 __decorateClass([
-  Column18("int", { default: 0 })
+  Column20("int", { default: 0 })
 ], Media.prototype, "size", 2);
 __decorateClass([
-  Column18("varchar", { nullable: true })
+  Column20("varchar", { nullable: true })
 ], Media.prototype, "alt", 2);
 __decorateClass([
-  Column18("boolean", { default: false })
+  Column20("boolean", { default: false })
 ], Media.prototype, "isPublic", 2);
 __decorateClass([
-  Column18({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column20({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "createdAt", 2);
 __decorateClass([
-  Column18({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column20({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "updatedAt", 2);
 __decorateClass([
-  Column18({ type: "timestamp", nullable: true })
+  Column20({ type: "timestamp", nullable: true })
 ], Media.prototype, "deletedAt", 2);
 __decorateClass([
-  Column18("boolean", { default: false })
+  Column20("boolean", { default: false })
 ], Media.prototype, "deleted", 2);
 Media = __decorateClass([
-  Entity18("media")
+  Entity20("media")
 ], Media);
 
 // src/entities/page.entity.ts
-import { Entity as Entity19, PrimaryGeneratedColumn as PrimaryGeneratedColumn19, Column as Column19, ManyToOne as ManyToOne10, JoinColumn as JoinColumn10 } from "typeorm";
+import { Entity as Entity21, PrimaryGeneratedColumn as PrimaryGeneratedColumn21, Column as Column21, ManyToOne as ManyToOne12, JoinColumn as JoinColumn12 } from "typeorm";
 var Page = class {
   id;
   title;
@@ -2052,64 +2271,64 @@ var Page = class {
   deletedBy;
 };
 __decorateClass([
-  PrimaryGeneratedColumn19()
+  PrimaryGeneratedColumn21()
 ], Page.prototype, "id", 2);
 __decorateClass([
-  Column19("varchar")
+  Column21("varchar")
 ], Page.prototype, "title", 2);
 __decorateClass([
-  Column19("varchar", { unique: true })
+  Column21("varchar", { unique: true })
 ], Page.prototype, "slug", 2);
 __decorateClass([
-  Column19({ type: "jsonb", default: {} })
+  Column21({ type: "jsonb", default: {} })
 ], Page.prototype, "content", 2);
 __decorateClass([
-  Column19("boolean", { default: false })
+  Column21("boolean", { default: false })
 ], Page.prototype, "published", 2);
 __decorateClass([
-  Column19("varchar", { default: "default" })
+  Column21("varchar", { default: "default" })
 ], Page.prototype, "theme", 2);
 __decorateClass([
-  Column19("int", { nullable: true })
+  Column21("int", { nullable: true })
 ], Page.prototype, "parentId", 2);
 __decorateClass([
-  ManyToOne10(() => Page, { onDelete: "SET NULL" }),
-  JoinColumn10({ name: "parentId" })
+  ManyToOne12(() => Page, { onDelete: "SET NULL" }),
+  JoinColumn12({ name: "parentId" })
 ], Page.prototype, "parent", 2);
 __decorateClass([
-  Column19("int", { nullable: true })
+  Column21("int", { nullable: true })
 ], Page.prototype, "seoId", 2);
 __decorateClass([
-  ManyToOne10(() => Seo, { onDelete: "SET NULL" }),
-  JoinColumn10({ name: "seoId" })
+  ManyToOne12(() => Seo, { onDelete: "SET NULL" }),
+  JoinColumn12({ name: "seoId" })
 ], Page.prototype, "seo", 2);
 __decorateClass([
-  Column19({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column21({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "createdAt", 2);
 __decorateClass([
-  Column19({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column21({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "updatedAt", 2);
 __decorateClass([
-  Column19({ type: "timestamp", nullable: true })
+  Column21({ type: "timestamp", nullable: true })
 ], Page.prototype, "deletedAt", 2);
 __decorateClass([
-  Column19("boolean", { default: false })
+  Column21("boolean", { default: false })
 ], Page.prototype, "deleted", 2);
 __decorateClass([
-  Column19("int", { nullable: true })
+  Column21("int", { nullable: true })
 ], Page.prototype, "createdBy", 2);
 __decorateClass([
-  Column19("int", { nullable: true })
+  Column21("int", { nullable: true })
 ], Page.prototype, "updatedBy", 2);
 __decorateClass([
-  Column19("int", { nullable: true })
+  Column21("int", { nullable: true })
 ], Page.prototype, "deletedBy", 2);
 Page = __decorateClass([
-  Entity19("pages")
+  Entity21("pages")
 ], Page);
 
 // src/entities/product-category.entity.ts
-import { Entity as Entity20, PrimaryGeneratedColumn as PrimaryGeneratedColumn20, Column as Column20, ManyToOne as ManyToOne11, OneToMany as OneToMany8, JoinColumn as JoinColumn11 } from "typeorm";
+import { Entity as Entity22, PrimaryGeneratedColumn as PrimaryGeneratedColumn22, Column as Column22, ManyToOne as ManyToOne13, OneToMany as OneToMany9, JoinColumn as JoinColumn13 } from "typeorm";
 var ProductCategory = class {
   id;
   name;
@@ -2133,75 +2352,75 @@ var ProductCategory = class {
   collections;
 };
 __decorateClass([
-  PrimaryGeneratedColumn20()
+  PrimaryGeneratedColumn22()
 ], ProductCategory.prototype, "id", 2);
 __decorateClass([
-  Column20("varchar")
+  Column22("varchar")
 ], ProductCategory.prototype, "name", 2);
 __decorateClass([
-  Column20("varchar", { unique: true })
+  Column22("varchar", { unique: true })
 ], ProductCategory.prototype, "slug", 2);
 __decorateClass([
-  Column20("int", { nullable: true })
+  Column22("int", { nullable: true })
 ], ProductCategory.prototype, "parentId", 2);
 __decorateClass([
-  Column20("varchar", { nullable: true })
+  Column22("varchar", { nullable: true })
 ], ProductCategory.prototype, "image", 2);
 __decorateClass([
-  Column20("text", { nullable: true })
+  Column22("text", { nullable: true })
 ], ProductCategory.prototype, "description", 2);
 __decorateClass([
-  Column20("jsonb", { nullable: true })
+  Column22("jsonb", { nullable: true })
 ], ProductCategory.prototype, "metadata", 2);
 __decorateClass([
-  Column20("boolean", { default: true })
+  Column22("boolean", { default: true })
 ], ProductCategory.prototype, "active", 2);
 __decorateClass([
-  Column20("int", { default: 0 })
+  Column22("int", { default: 0 })
 ], ProductCategory.prototype, "sortOrder", 2);
 __decorateClass([
-  Column20({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column22({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductCategory.prototype, "createdAt", 2);
 __decorateClass([
-  Column20({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column22({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductCategory.prototype, "updatedAt", 2);
 __decorateClass([
-  Column20({ type: "timestamp", nullable: true })
+  Column22({ type: "timestamp", nullable: true })
 ], ProductCategory.prototype, "deletedAt", 2);
 __decorateClass([
-  Column20("boolean", { default: false })
+  Column22("boolean", { default: false })
 ], ProductCategory.prototype, "deleted", 2);
 __decorateClass([
-  Column20("int", { nullable: true })
+  Column22("int", { nullable: true })
 ], ProductCategory.prototype, "createdBy", 2);
 __decorateClass([
-  Column20("int", { nullable: true })
+  Column22("int", { nullable: true })
 ], ProductCategory.prototype, "updatedBy", 2);
 __decorateClass([
-  Column20("int", { nullable: true })
+  Column22("int", { nullable: true })
 ], ProductCategory.prototype, "deletedBy", 2);
 __decorateClass([
-  ManyToOne11(() => ProductCategory, (c) => c.children, { onDelete: "SET NULL" }),
-  JoinColumn11({ name: "parentId" })
+  ManyToOne13(() => ProductCategory, (c) => c.children, { onDelete: "SET NULL" }),
+  JoinColumn13({ name: "parentId" })
 ], ProductCategory.prototype, "parent", 2);
 __decorateClass([
-  OneToMany8(() => ProductCategory, (c) => c.parent)
+  OneToMany9(() => ProductCategory, (c) => c.parent)
 ], ProductCategory.prototype, "children", 2);
 __decorateClass([
-  OneToMany8("Product", "category")
+  OneToMany9("Product", "category")
 ], ProductCategory.prototype, "products", 2);
 __decorateClass([
-  OneToMany8("Collection", "category")
+  OneToMany9("Collection", "category")
 ], ProductCategory.prototype, "collections", 2);
 ProductCategory = __decorateClass([
-  Entity20("product_categories")
+  Entity22("product_categories")
 ], ProductCategory);
 
 // src/entities/collection.entity.ts
-import { Entity as Entity22, PrimaryGeneratedColumn as PrimaryGeneratedColumn22, Column as Column22, ManyToOne as ManyToOne13, OneToMany as OneToMany10, JoinColumn as JoinColumn13 } from "typeorm";
+import { Entity as Entity24, PrimaryGeneratedColumn as PrimaryGeneratedColumn24, Column as Column24, ManyToOne as ManyToOne15, OneToMany as OneToMany11, JoinColumn as JoinColumn15 } from "typeorm";
 
 // src/entities/brand.entity.ts
-import { Entity as Entity21, PrimaryGeneratedColumn as PrimaryGeneratedColumn21, Column as Column21, OneToMany as OneToMany9, ManyToOne as ManyToOne12, JoinColumn as JoinColumn12 } from "typeorm";
+import { Entity as Entity23, PrimaryGeneratedColumn as PrimaryGeneratedColumn23, Column as Column23, OneToMany as OneToMany10, ManyToOne as ManyToOne14, JoinColumn as JoinColumn14 } from "typeorm";
 var Brand = class {
   id;
   name;
@@ -2224,65 +2443,65 @@ var Brand = class {
   collections;
 };
 __decorateClass([
-  PrimaryGeneratedColumn21()
+  PrimaryGeneratedColumn23()
 ], Brand.prototype, "id", 2);
 __decorateClass([
-  Column21("varchar")
+  Column23("varchar")
 ], Brand.prototype, "name", 2);
 __decorateClass([
-  Column21("varchar", { unique: true })
+  Column23("varchar", { unique: true })
 ], Brand.prototype, "slug", 2);
 __decorateClass([
-  Column21("varchar", { nullable: true })
+  Column23("varchar", { nullable: true })
 ], Brand.prototype, "logo", 2);
 __decorateClass([
-  Column21("jsonb", { nullable: true })
+  Column23("jsonb", { nullable: true })
 ], Brand.prototype, "metadata", 2);
 __decorateClass([
-  Column21("text", { nullable: true })
+  Column23("text", { nullable: true })
 ], Brand.prototype, "description", 2);
 __decorateClass([
-  Column21("boolean", { default: true })
+  Column23("boolean", { default: true })
 ], Brand.prototype, "active", 2);
 __decorateClass([
-  Column21("int", { default: 0 })
+  Column23("int", { default: 0 })
 ], Brand.prototype, "sortOrder", 2);
 __decorateClass([
-  Column21({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column23({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Brand.prototype, "createdAt", 2);
 __decorateClass([
-  Column21({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column23({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Brand.prototype, "updatedAt", 2);
 __decorateClass([
-  Column21({ type: "timestamp", nullable: true })
+  Column23({ type: "timestamp", nullable: true })
 ], Brand.prototype, "deletedAt", 2);
 __decorateClass([
-  Column21("boolean", { default: false })
+  Column23("boolean", { default: false })
 ], Brand.prototype, "deleted", 2);
 __decorateClass([
-  Column21("int", { nullable: true })
+  Column23("int", { nullable: true })
 ], Brand.prototype, "createdBy", 2);
 __decorateClass([
-  Column21("int", { nullable: true })
+  Column23("int", { nullable: true })
 ], Brand.prototype, "updatedBy", 2);
 __decorateClass([
-  Column21("int", { nullable: true })
+  Column23("int", { nullable: true })
 ], Brand.prototype, "deletedBy", 2);
 __decorateClass([
-  Column21("int", { nullable: true })
+  Column23("int", { nullable: true })
 ], Brand.prototype, "seoId", 2);
 __decorateClass([
-  ManyToOne12(() => Seo, { onDelete: "SET NULL" }),
-  JoinColumn12({ name: "seoId" })
+  ManyToOne14(() => Seo, { onDelete: "SET NULL" }),
+  JoinColumn14({ name: "seoId" })
 ], Brand.prototype, "seo", 2);
 __decorateClass([
-  OneToMany9("Product", "brand")
+  OneToMany10("Product", "brand")
 ], Brand.prototype, "products", 2);
 __decorateClass([
-  OneToMany9("Collection", "brand")
+  OneToMany10("Collection", "brand")
 ], Brand.prototype, "collections", 2);
 Brand = __decorateClass([
-  Entity21("brands")
+  Entity23("brands")
 ], Brand);
 
 // src/entities/collection.entity.ts
@@ -2311,80 +2530,80 @@ var Collection = class {
   products;
 };
 __decorateClass([
-  PrimaryGeneratedColumn22()
+  PrimaryGeneratedColumn24()
 ], Collection.prototype, "id", 2);
 __decorateClass([
-  Column22("int", { nullable: true })
+  Column24("int", { nullable: true })
 ], Collection.prototype, "categoryId", 2);
 __decorateClass([
-  Column22("int", { nullable: true })
+  Column24("int", { nullable: true })
 ], Collection.prototype, "brandId", 2);
 __decorateClass([
-  Column22("varchar")
+  Column24("varchar")
 ], Collection.prototype, "name", 2);
 __decorateClass([
-  Column22("varchar", { unique: true })
+  Column24("varchar", { unique: true })
 ], Collection.prototype, "slug", 2);
 __decorateClass([
-  Column22("text", { nullable: true })
+  Column24("text", { nullable: true })
 ], Collection.prototype, "description", 2);
 __decorateClass([
-  Column22("varchar", { nullable: true })
+  Column24("varchar", { nullable: true })
 ], Collection.prototype, "image", 2);
 __decorateClass([
-  Column22("jsonb", { nullable: true })
+  Column24("jsonb", { nullable: true })
 ], Collection.prototype, "metadata", 2);
 __decorateClass([
-  Column22("boolean", { default: true })
+  Column24("boolean", { default: true })
 ], Collection.prototype, "active", 2);
 __decorateClass([
-  Column22("int", { default: 0 })
+  Column24("int", { default: 0 })
 ], Collection.prototype, "sortOrder", 2);
 __decorateClass([
-  Column22({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column24({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Collection.prototype, "createdAt", 2);
 __decorateClass([
-  Column22({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column24({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Collection.prototype, "updatedAt", 2);
 __decorateClass([
-  Column22({ type: "timestamp", nullable: true })
+  Column24({ type: "timestamp", nullable: true })
 ], Collection.prototype, "deletedAt", 2);
 __decorateClass([
-  Column22("boolean", { default: false })
+  Column24("boolean", { default: false })
 ], Collection.prototype, "deleted", 2);
 __decorateClass([
-  Column22("int", { nullable: true })
+  Column24("int", { nullable: true })
 ], Collection.prototype, "createdBy", 2);
 __decorateClass([
-  Column22("int", { nullable: true })
+  Column24("int", { nullable: true })
 ], Collection.prototype, "updatedBy", 2);
 __decorateClass([
-  Column22("int", { nullable: true })
+  Column24("int", { nullable: true })
 ], Collection.prototype, "deletedBy", 2);
 __decorateClass([
-  Column22("int", { nullable: true })
+  Column24("int", { nullable: true })
 ], Collection.prototype, "seoId", 2);
 __decorateClass([
-  ManyToOne13(() => Seo, { onDelete: "SET NULL" }),
-  JoinColumn13({ name: "seoId" })
+  ManyToOne15(() => Seo, { onDelete: "SET NULL" }),
+  JoinColumn15({ name: "seoId" })
 ], Collection.prototype, "seo", 2);
 __decorateClass([
-  ManyToOne13(() => ProductCategory, (c) => c.collections, { onDelete: "SET NULL" }),
-  JoinColumn13({ name: "categoryId" })
+  ManyToOne15(() => ProductCategory, (c) => c.collections, { onDelete: "SET NULL" }),
+  JoinColumn15({ name: "categoryId" })
 ], Collection.prototype, "category", 2);
 __decorateClass([
-  ManyToOne13(() => Brand, (b) => b.collections, { onDelete: "SET NULL" }),
-  JoinColumn13({ name: "brandId" })
+  ManyToOne15(() => Brand, (b) => b.collections, { onDelete: "SET NULL" }),
+  JoinColumn15({ name: "brandId" })
 ], Collection.prototype, "brand", 2);
 __decorateClass([
-  OneToMany10("Product", "collection")
+  OneToMany11("Product", "collection")
 ], Collection.prototype, "products", 2);
 Collection = __decorateClass([
-  Entity22("collections")
+  Entity24("collections")
 ], Collection);
 
 // src/entities/product.entity.ts
-import { Entity as Entity23, PrimaryGeneratedColumn as PrimaryGeneratedColumn23, Column as Column23, ManyToOne as ManyToOne14, OneToMany as OneToMany11, JoinColumn as JoinColumn14 } from "typeorm";
+import { Entity as Entity25, PrimaryGeneratedColumn as PrimaryGeneratedColumn25, Column as Column25, ManyToOne as ManyToOne16, OneToMany as OneToMany12, JoinColumn as JoinColumn16 } from "typeorm";
 var Product = class {
   id;
   collectionId;
@@ -2415,96 +2634,96 @@ var Product = class {
   taxes;
 };
 __decorateClass([
-  PrimaryGeneratedColumn23()
+  PrimaryGeneratedColumn25()
 ], Product.prototype, "id", 2);
 __decorateClass([
-  Column23("int", { nullable: true })
+  Column25("int", { nullable: true })
 ], Product.prototype, "collectionId", 2);
 __decorateClass([
-  Column23("int", { nullable: true })
+  Column25("int", { nullable: true })
 ], Product.prototype, "brandId", 2);
 __decorateClass([
-  Column23("int", { nullable: true })
+  Column25("int", { nullable: true })
 ], Product.prototype, "categoryId", 2);
 __decorateClass([
-  Column23("varchar", { nullable: true })
+  Column25("varchar", { nullable: true })
 ], Product.prototype, "sku", 2);
 __decorateClass([
-  Column23("varchar", { unique: true, nullable: true })
+  Column25("varchar", { unique: true, nullable: true })
 ], Product.prototype, "slug", 2);
 __decorateClass([
-  Column23("varchar", { nullable: true })
+  Column25("varchar", { nullable: true })
 ], Product.prototype, "name", 2);
 __decorateClass([
-  Column23("decimal", { precision: 12, scale: 2 })
+  Column25("decimal", { precision: 12, scale: 2 })
 ], Product.prototype, "price", 2);
 __decorateClass([
-  Column23("decimal", { precision: 12, scale: 2, nullable: true })
+  Column25("decimal", { precision: 12, scale: 2, nullable: true })
 ], Product.prototype, "compareAtPrice", 2);
 __decorateClass([
-  Column23("int", { default: 0 })
+  Column25("int", { default: 0 })
 ], Product.prototype, "quantity", 2);
 __decorateClass([
-  Column23("varchar", { default: "draft" })
+  Column25("varchar", { default: "draft" })
 ], Product.prototype, "status", 2);
 __decorateClass([
-  Column23("boolean", { default: false })
+  Column25("boolean", { default: false })
 ], Product.prototype, "featured", 2);
 __decorateClass([
-  Column23("jsonb", { nullable: true })
+  Column25("jsonb", { nullable: true })
 ], Product.prototype, "metadata", 2);
 __decorateClass([
-  Column23({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column25({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Product.prototype, "createdAt", 2);
 __decorateClass([
-  Column23({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column25({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Product.prototype, "updatedAt", 2);
 __decorateClass([
-  Column23({ type: "timestamp", nullable: true })
+  Column25({ type: "timestamp", nullable: true })
 ], Product.prototype, "deletedAt", 2);
 __decorateClass([
-  Column23("boolean", { default: false })
+  Column25("boolean", { default: false })
 ], Product.prototype, "deleted", 2);
 __decorateClass([
-  Column23("int", { nullable: true })
+  Column25("int", { nullable: true })
 ], Product.prototype, "createdBy", 2);
 __decorateClass([
-  Column23("int", { nullable: true })
+  Column25("int", { nullable: true })
 ], Product.prototype, "updatedBy", 2);
 __decorateClass([
-  Column23("int", { nullable: true })
+  Column25("int", { nullable: true })
 ], Product.prototype, "deletedBy", 2);
 __decorateClass([
-  Column23("int", { nullable: true })
+  Column25("int", { nullable: true })
 ], Product.prototype, "seoId", 2);
 __decorateClass([
-  ManyToOne14(() => Seo, { onDelete: "SET NULL" }),
-  JoinColumn14({ name: "seoId" })
+  ManyToOne16(() => Seo, { onDelete: "SET NULL" }),
+  JoinColumn16({ name: "seoId" })
 ], Product.prototype, "seo", 2);
 __decorateClass([
-  ManyToOne14(() => Collection, (c) => c.products, { onDelete: "SET NULL" }),
-  JoinColumn14({ name: "collectionId" })
+  ManyToOne16(() => Collection, (c) => c.products, { onDelete: "SET NULL" }),
+  JoinColumn16({ name: "collectionId" })
 ], Product.prototype, "collection", 2);
 __decorateClass([
-  ManyToOne14(() => Brand, (b) => b.products, { onDelete: "SET NULL" }),
-  JoinColumn14({ name: "brandId" })
+  ManyToOne16(() => Brand, (b) => b.products, { onDelete: "SET NULL" }),
+  JoinColumn16({ name: "brandId" })
 ], Product.prototype, "brand", 2);
 __decorateClass([
-  ManyToOne14(() => ProductCategory, (c) => c.products, { onDelete: "SET NULL" }),
-  JoinColumn14({ name: "categoryId" })
+  ManyToOne16(() => ProductCategory, (c) => c.products, { onDelete: "SET NULL" }),
+  JoinColumn16({ name: "categoryId" })
 ], Product.prototype, "category", 2);
 __decorateClass([
-  OneToMany11("ProductAttribute", "product")
+  OneToMany12("ProductAttribute", "product")
 ], Product.prototype, "attributes", 2);
 __decorateClass([
-  OneToMany11("ProductTax", "product")
+  OneToMany12("ProductTax", "product")
 ], Product.prototype, "taxes", 2);
 Product = __decorateClass([
-  Entity23("products")
+  Entity25("products")
 ], Product);
 
 // src/entities/attribute.entity.ts
-import { Entity as Entity24, PrimaryGeneratedColumn as PrimaryGeneratedColumn24, Column as Column24 } from "typeorm";
+import { Entity as Entity26, PrimaryGeneratedColumn as PrimaryGeneratedColumn26, Column as Column26 } from "typeorm";
 var Attribute = class {
   id;
   name;
@@ -2523,56 +2742,56 @@ var Attribute = class {
   deletedBy;
 };
 __decorateClass([
-  PrimaryGeneratedColumn24()
+  PrimaryGeneratedColumn26()
 ], Attribute.prototype, "id", 2);
 __decorateClass([
-  Column24("varchar")
+  Column26("varchar")
 ], Attribute.prototype, "name", 2);
 __decorateClass([
-  Column24("varchar", { unique: true })
+  Column26("varchar", { unique: true })
 ], Attribute.prototype, "slug", 2);
 __decorateClass([
-  Column24("varchar", { default: "text" })
+  Column26("varchar", { default: "text" })
 ], Attribute.prototype, "type", 2);
 __decorateClass([
-  Column24("jsonb", { nullable: true })
+  Column26("jsonb", { nullable: true })
 ], Attribute.prototype, "options", 2);
 __decorateClass([
-  Column24("jsonb", { nullable: true })
+  Column26("jsonb", { nullable: true })
 ], Attribute.prototype, "metadata", 2);
 __decorateClass([
-  Column24("boolean", { default: true })
+  Column26("boolean", { default: true })
 ], Attribute.prototype, "active", 2);
 __decorateClass([
-  Column24("int", { default: 0 })
+  Column26("int", { default: 0 })
 ], Attribute.prototype, "sortOrder", 2);
 __decorateClass([
-  Column24({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column26({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Attribute.prototype, "createdAt", 2);
 __decorateClass([
-  Column24({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column26({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Attribute.prototype, "updatedAt", 2);
 __decorateClass([
-  Column24({ type: "timestamp", nullable: true })
+  Column26({ type: "timestamp", nullable: true })
 ], Attribute.prototype, "deletedAt", 2);
 __decorateClass([
-  Column24("boolean", { default: false })
+  Column26("boolean", { default: false })
 ], Attribute.prototype, "deleted", 2);
 __decorateClass([
-  Column24("int", { nullable: true })
+  Column26("int", { nullable: true })
 ], Attribute.prototype, "createdBy", 2);
 __decorateClass([
-  Column24("int", { nullable: true })
+  Column26("int", { nullable: true })
 ], Attribute.prototype, "updatedBy", 2);
 __decorateClass([
-  Column24("int", { nullable: true })
+  Column26("int", { nullable: true })
 ], Attribute.prototype, "deletedBy", 2);
 Attribute = __decorateClass([
-  Entity24("attributes")
+  Entity26("attributes")
 ], Attribute);
 
 // src/entities/product-attribute.entity.ts
-import { Entity as Entity25, PrimaryGeneratedColumn as PrimaryGeneratedColumn25, Column as Column25, ManyToOne as ManyToOne15, JoinColumn as JoinColumn15 } from "typeorm";
+import { Entity as Entity27, PrimaryGeneratedColumn as PrimaryGeneratedColumn27, Column as Column27, ManyToOne as ManyToOne17, JoinColumn as JoinColumn17 } from "typeorm";
 var ProductAttribute = class {
   id;
   productId;
@@ -2585,40 +2804,40 @@ var ProductAttribute = class {
   attribute;
 };
 __decorateClass([
-  PrimaryGeneratedColumn25()
+  PrimaryGeneratedColumn27()
 ], ProductAttribute.prototype, "id", 2);
 __decorateClass([
-  Column25("int")
+  Column27("int")
 ], ProductAttribute.prototype, "productId", 2);
 __decorateClass([
-  Column25("int")
+  Column27("int")
 ], ProductAttribute.prototype, "attributeId", 2);
 __decorateClass([
-  Column25("varchar")
+  Column27("varchar")
 ], ProductAttribute.prototype, "value", 2);
 __decorateClass([
-  Column25("jsonb", { nullable: true })
+  Column27("jsonb", { nullable: true })
 ], ProductAttribute.prototype, "metadata", 2);
 __decorateClass([
-  Column25({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column27({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductAttribute.prototype, "createdAt", 2);
 __decorateClass([
-  Column25({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column27({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductAttribute.prototype, "updatedAt", 2);
 __decorateClass([
-  ManyToOne15(() => Product, (p) => p.attributes, { onDelete: "CASCADE" }),
-  JoinColumn15({ name: "productId" })
+  ManyToOne17(() => Product, (p) => p.attributes, { onDelete: "CASCADE" }),
+  JoinColumn17({ name: "productId" })
 ], ProductAttribute.prototype, "product", 2);
 __decorateClass([
-  ManyToOne15(() => Attribute, { onDelete: "CASCADE" }),
-  JoinColumn15({ name: "attributeId" })
+  ManyToOne17(() => Attribute, { onDelete: "CASCADE" }),
+  JoinColumn17({ name: "attributeId" })
 ], ProductAttribute.prototype, "attribute", 2);
 ProductAttribute = __decorateClass([
-  Entity25("product_attributes")
+  Entity27("product_attributes")
 ], ProductAttribute);
 
 // src/entities/tax.entity.ts
-import { Entity as Entity26, PrimaryGeneratedColumn as PrimaryGeneratedColumn26, Column as Column26 } from "typeorm";
+import { Entity as Entity28, PrimaryGeneratedColumn as PrimaryGeneratedColumn28, Column as Column28 } from "typeorm";
 var Tax = class {
   id;
   name;
@@ -2637,56 +2856,56 @@ var Tax = class {
   deletedBy;
 };
 __decorateClass([
-  PrimaryGeneratedColumn26()
+  PrimaryGeneratedColumn28()
 ], Tax.prototype, "id", 2);
 __decorateClass([
-  Column26("varchar")
+  Column28("varchar")
 ], Tax.prototype, "name", 2);
 __decorateClass([
-  Column26("varchar", { unique: true })
+  Column28("varchar", { unique: true })
 ], Tax.prototype, "slug", 2);
 __decorateClass([
-  Column26("decimal", { precision: 5, scale: 2 })
+  Column28("decimal", { precision: 5, scale: 2 })
 ], Tax.prototype, "rate", 2);
 __decorateClass([
-  Column26("boolean", { default: false })
+  Column28("boolean", { default: false })
 ], Tax.prototype, "isDefault", 2);
 __decorateClass([
-  Column26("text", { nullable: true })
+  Column28("text", { nullable: true })
 ], Tax.prototype, "description", 2);
 __decorateClass([
-  Column26("boolean", { default: true })
+  Column28("boolean", { default: true })
 ], Tax.prototype, "active", 2);
 __decorateClass([
-  Column26("jsonb", { nullable: true })
+  Column28("jsonb", { nullable: true })
 ], Tax.prototype, "metadata", 2);
 __decorateClass([
-  Column26({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column28({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Tax.prototype, "createdAt", 2);
 __decorateClass([
-  Column26({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column28({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Tax.prototype, "updatedAt", 2);
 __decorateClass([
-  Column26({ type: "timestamp", nullable: true })
+  Column28({ type: "timestamp", nullable: true })
 ], Tax.prototype, "deletedAt", 2);
 __decorateClass([
-  Column26("boolean", { default: false })
+  Column28("boolean", { default: false })
 ], Tax.prototype, "deleted", 2);
 __decorateClass([
-  Column26("int", { nullable: true })
+  Column28("int", { nullable: true })
 ], Tax.prototype, "createdBy", 2);
 __decorateClass([
-  Column26("int", { nullable: true })
+  Column28("int", { nullable: true })
 ], Tax.prototype, "updatedBy", 2);
 __decorateClass([
-  Column26("int", { nullable: true })
+  Column28("int", { nullable: true })
 ], Tax.prototype, "deletedBy", 2);
 Tax = __decorateClass([
-  Entity26("taxes")
+  Entity28("taxes")
 ], Tax);
 
 // src/entities/product-tax.entity.ts
-import { Entity as Entity27, PrimaryGeneratedColumn as PrimaryGeneratedColumn27, Column as Column27, ManyToOne as ManyToOne16, JoinColumn as JoinColumn16 } from "typeorm";
+import { Entity as Entity29, PrimaryGeneratedColumn as PrimaryGeneratedColumn29, Column as Column29, ManyToOne as ManyToOne18, JoinColumn as JoinColumn18 } from "typeorm";
 var ProductTax = class {
   id;
   productId;
@@ -2698,37 +2917,37 @@ var ProductTax = class {
   tax;
 };
 __decorateClass([
-  PrimaryGeneratedColumn27()
+  PrimaryGeneratedColumn29()
 ], ProductTax.prototype, "id", 2);
 __decorateClass([
-  Column27("int")
+  Column29("int")
 ], ProductTax.prototype, "productId", 2);
 __decorateClass([
-  Column27("int")
+  Column29("int")
 ], ProductTax.prototype, "taxId", 2);
 __decorateClass([
-  Column27("decimal", { precision: 5, scale: 2, nullable: true })
+  Column29("decimal", { precision: 5, scale: 2, nullable: true })
 ], ProductTax.prototype, "rate", 2);
 __decorateClass([
-  Column27({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column29({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductTax.prototype, "createdAt", 2);
 __decorateClass([
-  Column27({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column29({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductTax.prototype, "updatedAt", 2);
 __decorateClass([
-  ManyToOne16(() => Product, (p) => p.taxes, { onDelete: "CASCADE" }),
-  JoinColumn16({ name: "productId" })
+  ManyToOne18(() => Product, (p) => p.taxes, { onDelete: "CASCADE" }),
+  JoinColumn18({ name: "productId" })
 ], ProductTax.prototype, "product", 2);
 __decorateClass([
-  ManyToOne16(() => Tax, { onDelete: "CASCADE" }),
-  JoinColumn16({ name: "taxId" })
+  ManyToOne18(() => Tax, { onDelete: "CASCADE" }),
+  JoinColumn18({ name: "taxId" })
 ], ProductTax.prototype, "tax", 2);
 ProductTax = __decorateClass([
-  Entity27("product_taxes")
+  Entity29("product_taxes")
 ], ProductTax);
 
 // src/entities/order-item.entity.ts
-import { Entity as Entity28, PrimaryGeneratedColumn as PrimaryGeneratedColumn28, Column as Column28, ManyToOne as ManyToOne17, JoinColumn as JoinColumn17 } from "typeorm";
+import { Entity as Entity30, PrimaryGeneratedColumn as PrimaryGeneratedColumn30, Column as Column30, ManyToOne as ManyToOne19, JoinColumn as JoinColumn19 } from "typeorm";
 var OrderItem = class {
   id;
   orderId;
@@ -2744,47 +2963,118 @@ var OrderItem = class {
   product;
 };
 __decorateClass([
-  PrimaryGeneratedColumn28()
+  PrimaryGeneratedColumn30()
 ], OrderItem.prototype, "id", 2);
 __decorateClass([
-  Column28("int")
+  Column30("int")
 ], OrderItem.prototype, "orderId", 2);
 __decorateClass([
-  Column28("int")
+  Column30("int")
 ], OrderItem.prototype, "productId", 2);
 __decorateClass([
-  Column28("int", { default: 1 })
+  Column30("int", { default: 1 })
 ], OrderItem.prototype, "quantity", 2);
 __decorateClass([
-  Column28("decimal", { precision: 12, scale: 2 })
+  Column30("decimal", { precision: 12, scale: 2 })
 ], OrderItem.prototype, "unitPrice", 2);
 __decorateClass([
-  Column28("decimal", { precision: 12, scale: 2, default: 0 })
+  Column30("decimal", { precision: 12, scale: 2, default: 0 })
 ], OrderItem.prototype, "tax", 2);
 __decorateClass([
-  Column28("decimal", { precision: 12, scale: 2 })
+  Column30("decimal", { precision: 12, scale: 2 })
 ], OrderItem.prototype, "total", 2);
 __decorateClass([
-  Column28("jsonb", { nullable: true })
+  Column30("jsonb", { nullable: true })
 ], OrderItem.prototype, "metadata", 2);
 __decorateClass([
-  Column28({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column30({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], OrderItem.prototype, "createdAt", 2);
 __decorateClass([
-  Column28({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column30({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], OrderItem.prototype, "updatedAt", 2);
 __decorateClass([
-  ManyToOne17(() => Order, (o) => o.items, { onDelete: "CASCADE" }),
-  JoinColumn17({ name: "orderId" })
+  ManyToOne19(() => Order, (o) => o.items, { onDelete: "CASCADE" }),
+  JoinColumn19({ name: "orderId" })
 ], OrderItem.prototype, "order", 2);
 __decorateClass([
-  ManyToOne17(() => Product, { onDelete: "CASCADE" }),
-  JoinColumn17({ name: "productId" })
+  ManyToOne19(() => Product, { onDelete: "CASCADE" }),
+  JoinColumn19({ name: "productId" })
 ], OrderItem.prototype, "product", 2);
 OrderItem = __decorateClass([
-  Entity28("order_items")
+  Entity30("order_items")
 ], OrderItem);
 
+// src/entities/knowledge-base-document.entity.ts
+import { Entity as Entity32, PrimaryGeneratedColumn as PrimaryGeneratedColumn32, Column as Column32, OneToMany as OneToMany13 } from "typeorm";
+
+// src/entities/knowledge-base-chunk.entity.ts
+import { Entity as Entity31, PrimaryGeneratedColumn as PrimaryGeneratedColumn31, Column as Column31, ManyToOne as ManyToOne20, JoinColumn as JoinColumn20 } from "typeorm";
+var KnowledgeBaseChunk = class {
+  id;
+  documentId;
+  content;
+  chunkIndex;
+  createdAt;
+  document;
+};
+__decorateClass([
+  PrimaryGeneratedColumn31()
+], KnowledgeBaseChunk.prototype, "id", 2);
+__decorateClass([
+  Column31("int")
+], KnowledgeBaseChunk.prototype, "documentId", 2);
+__decorateClass([
+  Column31("text")
+], KnowledgeBaseChunk.prototype, "content", 2);
+__decorateClass([
+  Column31("int", { default: 0 })
+], KnowledgeBaseChunk.prototype, "chunkIndex", 2);
+__decorateClass([
+  Column31({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], KnowledgeBaseChunk.prototype, "createdAt", 2);
+__decorateClass([
+  ManyToOne20(() => KnowledgeBaseDocument, (d) => d.chunks, { onDelete: "CASCADE" }),
+  JoinColumn20({ name: "documentId" })
+], KnowledgeBaseChunk.prototype, "document", 2);
+KnowledgeBaseChunk = __decorateClass([
+  Entity31("knowledge_base_chunks")
+], KnowledgeBaseChunk);
+
+// src/entities/knowledge-base-document.entity.ts
+var KnowledgeBaseDocument = class {
+  id;
+  name;
+  sourceUrl;
+  content;
+  createdAt;
+  updatedAt;
+  chunks;
+};
+__decorateClass([
+  PrimaryGeneratedColumn32()
+], KnowledgeBaseDocument.prototype, "id", 2);
+__decorateClass([
+  Column32("varchar")
+], KnowledgeBaseDocument.prototype, "name", 2);
+__decorateClass([
+  Column32("varchar", { nullable: true })
+], KnowledgeBaseDocument.prototype, "sourceUrl", 2);
+__decorateClass([
+  Column32("text")
+], KnowledgeBaseDocument.prototype, "content", 2);
+__decorateClass([
+  Column32({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], KnowledgeBaseDocument.prototype, "createdAt", 2);
+__decorateClass([
+  Column32({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], KnowledgeBaseDocument.prototype, "updatedAt", 2);
+__decorateClass([
+  OneToMany13(() => KnowledgeBaseChunk, (c) => c.document)
+], KnowledgeBaseDocument.prototype, "chunks", 2);
+KnowledgeBaseDocument = __decorateClass([
+  Entity32("knowledge_base_documents")
+], KnowledgeBaseDocument);
+
 // src/entities/index.ts
 var CMS_ENTITY_MAP = {
   users: User,
@@ -2814,7 +3104,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
@@ -4098,6 +4392,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: ILike2(`%${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"]);
@@ -4120,7 +4537,8 @@ function createCmsApiHandler(config) {
     usersApi,
     userAvatar,
     userProfile,
-    settings: settingsConfig
+    settings: settingsConfig,
+    chat: chatConfig
   } = config;
   const analytics = analyticsConfig ?? (getCms ? {
     json: config.json,
@@ -4165,6 +4583,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;
@@ -4224,6 +4643,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 });
@@ -4271,6 +4695,8 @@ export {
   Brand,
   CMS_ENTITY_MAP,
   Category,
+  ChatConversation,
+  ChatMessage,
   Collection,
   Comment,
   Config,
@@ -4280,6 +4706,9 @@ export {
   Form,
   FormField,
   FormSubmission,
+  KnowledgeBaseChunk,
+  KnowledgeBaseDocument,
+  LlmService,
   Media,
   OPEN_ENDPOINTS,
   Order,
@@ -4332,6 +4761,7 @@ export {
   getRequiredPermission,
   isOpenEndpoint,
   isPublicMethod,
+  llmPlugin,
   localStoragePlugin,
   paymentPlugin,
   s3StoragePlugin,