@rubixstudios/payload-typesense 1.0.0

package/dist/lib/cache.js

@@ -0,0 +1,96 @@
+export class SearchCache {
+    cache = new Map();
+    defaultTTL;
+    maxSize;
+    constructor(options = {}){
+        this.defaultTTL = options.ttl || 5 * 60 * 1000; // 5 minutes default
+        this.maxSize = options.maxSize || 1000; // 1000 entries default
+    }
+    /**
+   * Generate cache key from search parameters
+   */ generateKey(query, collection, params) {
+        const baseKey = `${collection || 'universal'}:${query}`;
+        if (params) {
+            const sortedParams = Object.keys(params).sort().map((key)=>`${key}=${params[key]}`).join('&');
+            return `${baseKey}:${sortedParams}`;
+        }
+        return baseKey;
+    }
+    /**
+   * Clear expired entries
+   */ cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()){
+            if (now - entry.timestamp > entry.ttl) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+   * Clear cache entries matching pattern
+   */ clear(pattern) {
+        if (!pattern) {
+            this.cache.clear();
+            return;
+        }
+        for (const key of this.cache.keys()){
+            if (key.includes(pattern)) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+   * Get cached search result
+   */ get(query, collection, params) {
+        const key = this.generateKey(query, collection || '', params);
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check if entry has expired
+        if (Date.now() - entry.timestamp > entry.ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.data;
+    }
+    /**
+   * Get cache statistics
+   */ getStats() {
+        return {
+            maxSize: this.maxSize,
+            size: this.cache.size
+        };
+    }
+    /**
+   * Check if cache has valid entry
+   */ has(query, collection, params) {
+        return this.get(query, collection, params) !== null;
+    }
+    /**
+   * Set cached search result
+   */ set(query, data, collection, params, ttl) {
+        const key = this.generateKey(query, collection || '', params);
+        // Enforce max size by removing oldest entries
+        if (this.cache.size >= this.maxSize) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey) {
+                this.cache.delete(oldestKey);
+            }
+        }
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now(),
+            ttl: ttl || this.defaultTTL
+        });
+    }
+}
+// Global cache instance
+export const searchCache = new SearchCache({
+    maxSize: 1000,
+    ttl: 5 * 60 * 1000 // 5 minutes
+});
+// Cleanup expired entries every 10 minutes
+setInterval(()=>{
+    searchCache.cleanup();
+}, 10 * 60 * 1000);

package/dist/lib/config-validation.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+export declare const TypesenseSearchConfigSchema: z.ZodObject<{
+    collections: z.ZodRecord<z.ZodString, z.ZodObject<{
+        displayName: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        facetFields: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        fieldMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        icon: z.ZodOptional<z.ZodString>;
+        searchFields: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        cache: z.ZodOptional<z.ZodObject<{
+            maxSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            ttl: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        categorized: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strip>>;
+    typesense: z.ZodObject<{
+        apiKey: z.ZodString;
+        connectionTimeoutSeconds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        nodes: z.ZodArray<z.ZodObject<{
+            host: z.ZodString;
+            port: z.ZodNumber;
+            protocol: z.ZodEnum<{
+                http: "http";
+                https: "https";
+            }>;
+        }, z.core.$strip>>;
+        numRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        retryIntervalSeconds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ValidatedTypesenseSearchConfig = z.infer<typeof TypesenseSearchConfigSchema>;
+export interface ValidationResult {
+    data?: ValidatedTypesenseSearchConfig;
+    errors?: string[];
+    success: boolean;
+}
+/**
+ * Validate plugin configuration
+ */
+export declare function validateConfig(config: unknown): ValidationResult;
+/**
+ * Validate and transform configuration with defaults
+ */
+export declare function validateAndTransformConfig(config: unknown): ValidationResult;
+/**
+ * Validate individual collection configuration
+ */
+export declare function validateCollectionConfig(collectionSlug: string, config: unknown): ValidationResult;
+/**
+ * Get configuration validation errors in a user-friendly format
+ */
+export declare function getValidationErrors(errors: string[]): string;
+/**
+ * Validate search parameters
+ */
+export declare const SearchParamsSchema: z.ZodObject<{
+    facets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    highlight_fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    num_typos: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    q: z.ZodString;
+    snippet_threshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sort_by: z.ZodOptional<z.ZodString>;
+    typo_tokens_threshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export type ValidatedSearchParams = z.infer<typeof SearchParamsSchema>;
+/**
+ * Validate search parameters
+ */
+export declare function validateSearchParams(params: unknown): ValidationResult;
+//# sourceMappingURL=config-validation.d.ts.map

package/dist/lib/config-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-validation.d.ts","sourceRoot":"","sources":["../../src/lib/config-validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgCvB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUtC,CAAA;AAGF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAGxF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,8BAA8B,CAAA;IACrC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAyBhE;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAyB5E;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAyBlG;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAE5D;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;iBAW7B,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEtE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAyBtE"}

package/dist/lib/config-validation.js

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+// Typesense node configuration schema
+const TypesenseNodeSchema = z.object({
+    host: z.string().min(1, 'Host is required'),
+    port: z.number().int().min(1).max(65535, 'Port must be between 1 and 65535'),
+    protocol: z.enum([
+        'http',
+        'https'
+    ])
+});
+// Collection configuration schema
+const CollectionConfigSchema = z.object({
+    displayName: z.string().optional(),
+    enabled: z.boolean().optional().default(true),
+    facetFields: z.array(z.string()).optional().default([]),
+    fieldMapping: z.record(z.string(), z.string()).optional(),
+    icon: z.string().optional(),
+    searchFields: z.array(z.string()).min(1, 'At least one search field is required')
+});
+// Cache configuration schema
+const CacheConfigSchema = z.object({
+    maxSize: z.number().int().min(1, 'Max size must be at least 1').optional().default(1000),
+    ttl: z.number().int().min(1000, 'TTL must be at least 1000ms').optional().default(300000) // 5 minutes
+});
+// Settings configuration schema
+const SettingsConfigSchema = z.object({
+    cache: CacheConfigSchema.optional(),
+    categorized: z.boolean().optional().default(false)
+});
+// Main plugin configuration schema
+export const TypesenseSearchConfigSchema = z.object({
+    collections: z.record(z.string(), CollectionConfigSchema),
+    settings: SettingsConfigSchema.optional(),
+    typesense: z.object({
+        apiKey: z.string().min(1, 'API key is required'),
+        connectionTimeoutSeconds: z.number().int().min(1).optional().default(10),
+        nodes: z.array(TypesenseNodeSchema).min(1, 'At least one Typesense node is required'),
+        numRetries: z.number().int().min(0).optional().default(3),
+        retryIntervalSeconds: z.number().int().min(1).optional().default(1)
+    })
+});
+/**
+ * Validate plugin configuration
+ */ export function validateConfig(config) {
+    try {
+        const validatedConfig = TypesenseSearchConfigSchema.parse(config);
+        return {
+            data: validatedConfig,
+            success: true
+        };
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const errors = error.issues.map((err)=>{
+                const path = err.path.length > 0 ? `${err.path.join('.')}: ` : '';
+                return `${path}${err.message}`;
+            });
+            return {
+                errors,
+                success: false
+            };
+        }
+        return {
+            errors: [
+                'Invalid configuration format'
+            ],
+            success: false
+        };
+    }
+}
+/**
+ * Validate and transform configuration with defaults
+ */ export function validateAndTransformConfig(config) {
+    try {
+        const validatedConfig = TypesenseSearchConfigSchema.parse(config);
+        return {
+            data: validatedConfig,
+            success: true
+        };
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const errors = error.issues.map((err)=>{
+                const path = err.path.length > 0 ? `${err.path.join('.')}: ` : '';
+                return `${path}${err.message}`;
+            });
+            return {
+                errors,
+                success: false
+            };
+        }
+        return {
+            errors: [
+                'Invalid configuration format'
+            ],
+            success: false
+        };
+    }
+}
+/**
+ * Validate individual collection configuration
+ */ export function validateCollectionConfig(collectionSlug, config) {
+    try {
+        const validatedConfig = CollectionConfigSchema.parse(config);
+        return {
+            data: {
+                [collectionSlug]: validatedConfig
+            },
+            success: true
+        };
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const errors = error.issues.map((err)=>{
+                const path = err.path.length > 0 ? `${err.path.join('.')}: ` : '';
+                return `Collection '${collectionSlug}' - ${path}${err.message}`;
+            });
+            return {
+                errors,
+                success: false
+            };
+        }
+        return {
+            errors: [
+                `Collection '${collectionSlug}': Invalid configuration format`
+            ],
+            success: false
+        };
+    }
+}
+/**
+ * Get configuration validation errors in a user-friendly format
+ */ export function getValidationErrors(errors) {
+    return errors.map((error, index)=>`${index + 1}. ${error}`).join('\n');
+}
+/**
+ * Validate search parameters
+ */ export const SearchParamsSchema = z.object({
+    facets: z.array(z.string()).optional(),
+    filters: z.record(z.string(), z.any()).optional(),
+    highlight_fields: z.array(z.string()).optional(),
+    num_typos: z.number().int().min(0).max(4).optional().default(0),
+    page: z.number().int().min(1).optional().default(1),
+    per_page: z.number().int().min(1).max(250).optional().default(10),
+    q: z.string().min(1, 'Query parameter "q" is required'),
+    snippet_threshold: z.number().int().min(0).max(100).optional().default(30),
+    sort_by: z.string().optional(),
+    typo_tokens_threshold: z.number().int().min(1).optional().default(1)
+});
+/**
+ * Validate search parameters
+ */ export function validateSearchParams(params) {
+    try {
+        const validatedParams = SearchParamsSchema.parse(params);
+        return {
+            data: validatedParams,
+            success: true
+        };
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const errors = error.issues.map((err)=>{
+                const path = err.path.length > 0 ? `${err.path.join('.')}: ` : '';
+                return `${path}${err.message}`;
+            });
+            return {
+                errors,
+                success: false
+            };
+        }
+        return {
+            errors: [
+                'Invalid search parameters format'
+            ],
+            success: false
+        };
+    }
+}

package/dist/lib/hooks.d.ts

@@ -0,0 +1,4 @@
+import type Typesense from 'typesense';
+import type { TypesenseSearchConfig } from '../index.js';
+export declare const setupHooks: (typesenseClient: Typesense.Client, pluginOptions: TypesenseSearchConfig, existingHooks?: any) => any;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/lib/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/lib/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,WAAW,CAAA;AAEtC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAIxD,eAAO,MAAM,UAAU,GACrB,iBAAiB,SAAS,CAAC,MAAM,EACjC,eAAe,qBAAqB,EACpC,gBAAgB,GAAG,QAiCpB,CAAA"}

package/dist/lib/hooks.js

@@ -0,0 +1,54 @@
+import { mapPayloadDocumentToTypesense } from './schema-mapper.js';
+export const setupHooks = (typesenseClient, pluginOptions, existingHooks)=>{
+    const hooks = {
+        ...existingHooks
+    };
+    if (pluginOptions.collections) {
+        for (const [collectionSlug, config] of Object.entries(pluginOptions.collections)){
+            if (config?.enabled) {
+                // After create/update hook
+                hooks.afterChange = {
+                    ...hooks.afterChange,
+                    [collectionSlug]: [
+                        ...hooks.afterChange?.[collectionSlug] || [],
+                        async ({ doc, operation, req: _req })=>{
+                            await syncDocumentToTypesense(typesenseClient, collectionSlug, doc, operation, config);
+                        }
+                    ]
+                };
+                // After delete hook
+                hooks.afterDelete = {
+                    ...hooks.afterDelete,
+                    [collectionSlug]: [
+                        ...hooks.afterDelete?.[collectionSlug] || [],
+                        async ({ doc, req: _req })=>{
+                            await deleteDocumentFromTypesense(typesenseClient, collectionSlug, doc.id);
+                        }
+                    ]
+                };
+            }
+        }
+    }
+    return hooks;
+};
+const syncDocumentToTypesense = async (typesenseClient, collectionSlug, doc, operation, config)=>{
+    try {
+        const typesenseDoc = mapPayloadDocumentToTypesense(doc, collectionSlug, config);
+        await typesenseClient.collections(collectionSlug).documents().upsert(typesenseDoc);
+    // Document synced successfully
+    } catch (error) {
+        // Handle document sync error
+        // Log the problematic document for debugging
+        if (error.message.includes('validation')) {
+        // Log problematic document details
+        }
+    }
+};
+const deleteDocumentFromTypesense = async (typesenseClient, collectionSlug, docId)=>{
+    try {
+        await typesenseClient.collections(collectionSlug).documents(docId).delete();
+    // Document deleted successfully
+    } catch (_error) {
+    // Handle document deletion error
+    }
+};

package/dist/lib/initialization.d.ts

@@ -0,0 +1,5 @@
+import type { Payload } from 'payload';
+import type Typesense from 'typesense';
+import type { TypesenseSearchConfig } from '../index.js';
+export declare const initializeTypesenseCollections: (payload: Payload, typesenseClient: Typesense.Client, pluginOptions: TypesenseSearchConfig) => Promise<void>;
+//# sourceMappingURL=initialization.d.ts.map

package/dist/lib/initialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialization.d.ts","sourceRoot":"","sources":["../../src/lib/initialization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,SAAS,MAAM,WAAW,CAAA;AAEtC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAMxD,eAAO,MAAM,8BAA8B,GACzC,SAAS,OAAO,EAChB,iBAAiB,SAAS,CAAC,MAAM,EACjC,eAAe,qBAAqB,kBAiCrC,CAAA"}

package/dist/lib/initialization.js

@@ -0,0 +1,102 @@
+import { validateConfig } from './config-validation.js';
+import { mapCollectionToTypesenseSchema, mapPayloadDocumentToTypesense } from './schema-mapper.js';
+import { testTypesenseConnection } from './typesense-client.js';
+export const initializeTypesenseCollections = async (payload, typesenseClient, pluginOptions)=>{
+    // Validate configuration first
+    const validation = validateConfig(pluginOptions);
+    if (!validation.success) {
+        // Handle configuration validation error
+        throw new Error('Invalid plugin configuration');
+    }
+    // Configuration validated successfully
+    // Test Typesense connection first
+    const isConnected = await testTypesenseConnection(typesenseClient);
+    if (!isConnected) {
+        // Typesense connection failed
+        return;
+    }
+    // Initialize Typesense collections
+    if (pluginOptions.collections) {
+        for (const [collectionSlug, config] of Object.entries(pluginOptions.collections)){
+            if (config?.enabled) {
+                try {
+                    await initializeCollection(payload, typesenseClient, collectionSlug, config);
+                } catch (_error) {
+                // Handle collection initialization error
+                }
+            }
+        }
+    }
+// Collections initialized successfully
+};
+const initializeCollection = async (payload, typesenseClient, collectionSlug, config)=>{
+    // Get the collection config from Payload
+    const collection = payload.collections[collectionSlug];
+    if (!collection) {
+        // Collection not found in Payload
+        return;
+    }
+    // Create Typesense schema
+    const schema = mapCollectionToTypesenseSchema(collection, collectionSlug, config);
+    // Create schema for collection
+    try {
+        // Check if collection exists
+        await typesenseClient.collections(collectionSlug).retrieve();
+    // Collection already exists
+    } catch (_error) {
+        // Collection doesn't exist, create it
+        try {
+            await typesenseClient.collections().create(schema);
+        // Collection created successfully
+        } catch (_createError) {
+            // Handle collection creation error
+            return;
+        }
+    }
+    // Sync existing documents
+    await syncExistingDocuments(payload, typesenseClient, collectionSlug, config);
+};
+const syncExistingDocuments = async (payload, typesenseClient, collectionSlug, config)=>{
+    try {
+        const { docs } = await payload.find({
+            collection: collectionSlug,
+            depth: 0,
+            limit: 1000
+        });
+        if (docs.length === 0) {
+            // No documents to sync
+            return;
+        }
+        // Batch sync documents
+        const batchSize = 100;
+        for(let i = 0; i < docs.length; i += batchSize){
+            const batch = docs.slice(i, i + batchSize);
+            const typesenseDocs = batch.map((doc)=>mapPayloadDocumentToTypesense(doc, collectionSlug, config));
+            try {
+                const _importResult = await typesenseClient.collections(collectionSlug).documents().import(typesenseDocs, {
+                    action: 'upsert'
+                });
+            // Documents synced successfully
+            } catch (batchError) {
+                // Handle batch sync error
+                // Log detailed import results if available
+                if (batchError.importResults) {
+                    // Handle import results error
+                    // Try to sync documents individually to identify problematic ones
+                    // Attempt individual document sync
+                    for(let j = 0; j < typesenseDocs.length; j++){
+                        try {
+                            await typesenseClient.collections(collectionSlug).documents().upsert(typesenseDocs[j]);
+                        // Individual sync successful
+                        } catch (_individualError) {
+                        // Handle individual sync error
+                        }
+                    }
+                }
+            }
+        }
+    // Successfully synced documents
+    } catch (_error) {
+    // Handle document sync error
+    }
+};

package/dist/lib/schema-mapper.d.ts

@@ -0,0 +1,14 @@
+import type { Collection } from 'payload';
+import type { TypesenseSearchConfig } from '../index.js';
+export declare const mapCollectionToTypesenseSchema: (collection: Collection, collectionSlug: string, config: NonNullable<TypesenseSearchConfig["collections"]>[string] | undefined) => {
+    name: string;
+    fields: ({
+        name: string;
+        type: "string";
+    } | {
+        name: string;
+        type: "int64";
+    })[];
+};
+export declare const mapPayloadDocumentToTypesense: (doc: any, collectionSlug: string, config: NonNullable<TypesenseSearchConfig["collections"]>[string] | undefined) => any;
+//# sourceMappingURL=schema-mapper.d.ts.map

package/dist/lib/schema-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-mapper.d.ts","sourceRoot":"","sources":["../../src/lib/schema-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA6BxD,eAAO,MAAM,8BAA8B,GACzC,YAAY,UAAU,EACtB,gBAAgB,MAAM,EACtB,QAAQ,WAAW,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS;;;;;;;;;CAyC9E,CAAA;AAED,eAAO,MAAM,6BAA6B,GACxC,KAAK,GAAG,EACR,gBAAgB,MAAM,EACtB,QAAQ,WAAW,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,QA+E9E,CAAA"}

package/dist/lib/schema-mapper.js

@@ -0,0 +1,137 @@
+// Helper function to extract text content from richText structure
+const extractTextFromRichText = (richText)=>{
+    if (!richText || !richText.root) {
+        return '';
+    }
+    const extractText = (node)=>{
+        if (typeof node === 'string') {
+            return node;
+        }
+        if (node && typeof node === 'object') {
+            if (node.text) {
+                return node.text;
+            }
+            if (node.children && Array.isArray(node.children)) {
+                return node.children.map(extractText).join('');
+            }
+        }
+        return '';
+    };
+    return extractText(richText.root);
+};
+export const mapCollectionToTypesenseSchema = (collection, collectionSlug, config)=>{
+    const searchableFields = config?.searchFields || [
+        'title',
+        'content',
+        'description'
+    ];
+    const facetFields = config?.facetFields || [];
+    // Map schema for collection
+    // Base fields that every collection should have
+    // Note: 'id' field is automatically created by Typesense, so we don't include it
+    const baseFields = [
+        {
+            name: 'slug',
+            type: 'string'
+        },
+        {
+            name: 'createdAt',
+            type: 'int64'
+        },
+        {
+            name: 'updatedAt',
+            type: 'int64'
+        }
+    ];
+    // Map searchable fields
+    const searchFields = searchableFields.map((field)=>({
+            name: field,
+            type: 'string',
+            facet: facetFields.includes(field)
+        }));
+    // Process search fields
+    // Map facet-only fields (not in searchable fields)
+    const facetOnlyFields = facetFields.filter((field)=>!searchableFields.includes(field)).map((field)=>({
+            name: field,
+            type: 'string',
+            facet: true
+        }));
+    const finalSchema = {
+        name: collectionSlug,
+        fields: [
+            ...baseFields,
+            ...searchFields,
+            ...facetOnlyFields
+        ]
+    };
+    // Return final schema
+    return finalSchema;
+};
+export const mapPayloadDocumentToTypesense = (doc, collectionSlug, config)=>{
+    const searchableFields = config?.searchFields || [
+        'title',
+        'content',
+        'description'
+    ];
+    const facetFields = config?.facetFields || [];
+    // Validate required fields
+    if (!doc.id) {
+        throw new Error(`Document missing required 'id' field: ${JSON.stringify(doc)}`);
+    }
+    if (!doc.createdAt) {
+        // Use current time for missing createdAt
+        doc.createdAt = new Date();
+    }
+    if (!doc.updatedAt) {
+        // Use current time for missing updatedAt
+        doc.updatedAt = new Date();
+    }
+    // Base document structure with safe date handling
+    const typesenseDoc = {
+        id: String(doc.id),
+        slug: doc.slug || '',
+        createdAt: new Date(doc.createdAt).getTime(),
+        updatedAt: new Date(doc.updatedAt).getTime()
+    };
+    // Add searchable fields with validation
+    searchableFields.forEach((field)=>{
+        // Handle array fields with dot notation (e.g., 'technologies.name', 'tags.tag')
+        if (field.includes('.')) {
+            const [arrayField, subField] = field.split('.', 2);
+            if (arrayField && subField && Array.isArray(doc[arrayField]) && doc[arrayField].length > 0) {
+                typesenseDoc[field] = doc[arrayField].map((item)=>item?.[subField] || '').join(' ');
+            } else {
+                typesenseDoc[field] = '';
+            }
+        } else if (doc[field] !== undefined && doc[field] !== null) {
+            // Handle richText fields specially
+            if ((field === 'content' || field === 'description') && typeof doc[field] === 'object' && doc[field].root) {
+                // Extract text from richText structure
+                typesenseDoc[field] = extractTextFromRichText(doc[field]);
+            } else {
+                // Convert to string for other fields
+                typesenseDoc[field] = String(doc[field]);
+            }
+        } else {
+            // Set empty string for missing fields
+            typesenseDoc[field] = '';
+        }
+    });
+    // Add facet fields with validation - ensure all facet fields are present
+    facetFields.forEach((field)=>{
+        if (doc[field] !== undefined && doc[field] !== null) {
+            // Convert to string for facet fields
+            typesenseDoc[field] = String(doc[field]);
+        } else {
+            // Add default value for missing facet fields
+            typesenseDoc[field] = 'unknown';
+        }
+    });
+    // Validate that we have at least one searchable field
+    const hasSearchableContent = searchableFields.some((field)=>typesenseDoc[field] && typesenseDoc[field].trim().length > 0);
+    if (!hasSearchableContent) {
+        // Add placeholder for missing content
+        typesenseDoc.title = typesenseDoc.title || `Document ${doc.id}`;
+    }
+    return typesenseDoc;
+};