@nlabs/reaktor 0.10.2 → 0.10.6

package/lib/actions/content.js

@@ -1,17 +1,240 @@
-import{createHash as $,parseString as u}from"@nlabs/utils/parsers/strings";import{aql as L}from"arangojs";import{parseContentFromDb as h,parseContentInput as q}from"../adapters/contentAdapter.js";import{Config as b}from"../config.js";import{ErrorTypes as A}from"../types/error.types.js";import{logError as T}from"../utils/analyticsUtils.js";import{useDb as R}from"../utils/arangodbUtils.js";import{translateText as x}from"../utils/googleTranslate.js";import{extractLanguage as m,isRegionalLocale as N}from"../utils/localeUtils.js";const v="content",D=(e={})=>{const{category:t,isActive:a=!0,key:o,locale:s}=e;return{category:t?u(t,100):void 0,isActive:a,key:o?u(o,200):void 0,locale:s}},E=async(e,t,a="en")=>{const o="getContent",{databaseName:s}=e,i=u(t,200),r=u(a,5),p=L`
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { createHash, parseString } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { parseContentFromDb, parseContentInput } from '../adapters/contentAdapter.js';
+import { Config } from '../config.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { translateText } from '../utils/googleTranslate.js';
+import { extractLanguage, isRegionalLocale } from '../utils/localeUtils.js';
+const eventCategory = 'content';
+export const parseContentOptions = (options = {})=>{
+    const { category, isActive = true, key, locale } = options;
+    return {
+        category: category ? parseString(category, 100) : undefined,
+        isActive,
+        key: key ? parseString(key, 200) : undefined,
+        locale
+    };
+};
+export const getContent = async (context, key, locale = 'en')=>{
+    const action = 'getContent';
+    const { databaseName } = context;
+    const formatKey = parseString(key, 200);
+    const formatLocale = parseString(locale, 5);
+    const aqlQry = aql`
     FOR c IN content
-    FILTER c.key == ${i} && c.locale == ${r} && c.isActive == true
+    FILTER c.key == ${formatKey} && c.locale == ${formatLocale} && c.isActive == true
     LIMIT 1
     RETURN c
-  `;try{const n=await R(s).query(p).then(c=>c.next()).catch(c=>T({action:o,category:v,label:A.DATABASE_ERROR},c,e));return n?h(n):null}catch(n){throw n}},H=async(e,t,a,o="en")=>{const s=b.get("app.locale")||"en";try{let i=await E(e,t,o);if(i?.content)return i.content;if(N(o)){const r=m(o);if(i=await E(e,t,r),i?.content)return C(e,{key:t,content:i.content,locale:o,description:`Extracted from ${r}`}).catch(p=>{}),i.content}if(o===s)return a&&C(e,{key:t,content:a,locale:o,description:"Auto-generated from fallback"}).catch(r=>{}),a||t;try{let r=await E(e,t,s),p;if(r?.content)p=r.content;else{if(N(s)){const c=m(s);r=await E(e,t,c)}if(r?.content)p=r.content;else if(a)p=a,C(e,{key:t,content:a,locale:s,description:"Auto-generated from fallback"}).catch(c=>{});else return t}const n=await x(p,m(o),m(s));return C(e,{key:t,content:n,locale:o,description:`Auto-translated from ${s}`}).catch(c=>{}),n}catch{return a||t}}catch{return a||t}},C=async(e,t)=>{const a="addContent",{databaseName:o,session:s}=e,i=Date.now(),r=q(t),{key:p,locale:n="en",content:c,description:y,category:l,isActive:g=!0}=r,d=$(`content-${p}-${n}`),f={_id:`content/${d}`,_key:d,added:i,key:u(p,200),locale:n,content:u(c,1e4),description:y?u(y,500):void 0,category:l?u(l,100):void 0,isActive:g,modified:i,userId:s?.userId},O=L`INSERT ${f} IN content RETURN NEW`;try{const w=await R(o).query(O).then(I=>I.next()).catch(I=>T({action:a,category:v,label:A.DATABASE_ERROR},I,e));return h(w)}catch(w){throw w}},K=async(e,t)=>{const a="updateContent",{databaseName:o}=e,s=Date.now(),i=q(t),{contentId:r,content:p,description:n,category:c,isActive:y}=i;if(!r)throw new Error("Content ID is required for update");const l={content:u(p,1e4),modified:s};n!==void 0&&(l.description=n?u(n,500):void 0),c!==void 0&&(l.category=c?u(c,100):void 0),y!==void 0&&(l.isActive=y);const g=L`
+  `;
+    try {
+        const content = await useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+        return content ? parseContentFromDb(content) : null;
+    } catch (error) {
+        throw error;
+    }
+};
+export const getContentWithFallback = async (context, key, fallbackContent, locale = 'en')=>{
+    const appLocale = Config.get('app.locale') || 'en';
+    try {
+        let content = await getContent(context, key, locale);
+        if (content?.content) {
+            return content.content;
+        }
+        if (isRegionalLocale(locale)) {
+            const language = extractLanguage(locale);
+            content = await getContent(context, key, language);
+            if (content?.content) {
+                addContent(context, {
+                    key,
+                    content: content.content,
+                    locale,
+                    description: `Extracted from ${language}`
+                }).catch((saveError)=>{
+                    console.error('Error saving extracted content:', saveError);
+                });
+                return content.content;
+            }
+        }
+        if (locale === appLocale) {
+            if (fallbackContent) {
+                addContent(context, {
+                    key,
+                    content: fallbackContent,
+                    locale,
+                    description: 'Auto-generated from fallback'
+                }).catch((saveError)=>{
+                    console.error('Error saving fallback content:', saveError);
+                });
+            }
+            return fallbackContent || key;
+        }
+        try {
+            let sourceContent = await getContent(context, key, appLocale);
+            let sourceText;
+            if (sourceContent?.content) {
+                sourceText = sourceContent.content;
+            } else {
+                if (isRegionalLocale(appLocale)) {
+                    const appLanguage = extractLanguage(appLocale);
+                    sourceContent = await getContent(context, key, appLanguage);
+                }
+                if (sourceContent?.content) {
+                    sourceText = sourceContent.content;
+                } else if (fallbackContent) {
+                    sourceText = fallbackContent;
+                    addContent(context, {
+                        key,
+                        content: fallbackContent,
+                        locale: appLocale,
+                        description: 'Auto-generated from fallback'
+                    }).catch((saveError)=>{
+                        console.error('Error saving fallback as default content:', saveError);
+                    });
+                } else {
+                    return key;
+                }
+            }
+            const translatedText = await translateText(sourceText, extractLanguage(locale), extractLanguage(appLocale));
+            addContent(context, {
+                key,
+                content: translatedText,
+                locale,
+                description: `Auto-translated from ${appLocale}`
+            }).catch((saveError)=>{
+                console.error('Error saving translated content:', saveError);
+            });
+            return translatedText;
+        } catch (translationError) {
+            console.error('Translation error:', translationError);
+            return fallbackContent || key;
+        }
+    } catch (error) {
+        console.error('Error fetching content from database:', error);
+        return fallbackContent || key;
+    }
+};
+export const addContent = async (context, contentInput)=>{
+    const action = 'addContent';
+    const { databaseName, session } = context;
+    const now = Date.now();
+    const parsedContent = parseContentInput(contentInput);
+    const { key, locale = 'en', content, description, category, isActive = true } = parsedContent;
+    const contentId = createHash(`content-${key}-${locale}`);
+    const insert = {
+        _id: `content/${contentId}`,
+        _key: contentId,
+        added: now,
+        key: parseString(key, 200),
+        locale,
+        content: parseString(content, 10000),
+        description: description ? parseString(description, 500) : undefined,
+        category: category ? parseString(category, 100) : undefined,
+        isActive,
+        modified: now,
+        userId: session?.userId
+    };
+    const aqlQry = aql`INSERT ${insert} IN content RETURN NEW`;
+    try {
+        const savedContent = await useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+        return parseContentFromDb(savedContent);
+    } catch (error) {
+        throw error;
+    }
+};
+export const updateContent = async (context, contentInput)=>{
+    const action = 'updateContent';
+    const { databaseName } = context;
+    const now = Date.now();
+    const parsedContent = parseContentInput(contentInput);
+    const { contentId, content, description, category, isActive } = parsedContent;
+    if (!contentId) {
+        throw new Error('Content ID is required for update');
+    }
+    const update = {
+        content: parseString(content, 10000),
+        modified: now
+    };
+    if (description !== undefined) {
+        update.description = description ? parseString(description, 500) : undefined;
+    }
+    if (category !== undefined) {
+        update.category = category ? parseString(category, 100) : undefined;
+    }
+    if (isActive !== undefined) {
+        update.isActive = isActive;
+    }
+    const aqlQry = aql`
     FOR c IN content
-    FILTER c._key == ${r}
-    UPDATE c WITH ${l} IN content
+    FILTER c._key == ${contentId}
+    UPDATE c WITH ${update} IN content
     RETURN NEW
-  `;try{const d=await R(o).query(g).then(f=>f.next()).catch(f=>T({action:a,category:v,label:A.DATABASE_ERROR},f,e));if(!d)throw new Error("Content not found or access denied");return h(d)}catch(d){throw d}},M=async(e,t={})=>{const a="searchContent",{databaseName:o}=e,{category:s,isActive:i,key:r,locale:p}=D(t),n=[],c={};r&&(n.push("c.key == @key"),c.key=r),p&&(n.push("c.locale == @locale"),c.locale=p),s&&(n.push("c.category == @category"),c.category=s),i!==void 0&&(n.push("c.isActive == @isActive"),c.isActive=i);const l=`
+  `;
+    try {
+        const updatedContent = await useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+        if (!updatedContent) {
+            throw new Error('Content not found or access denied');
+        }
+        return parseContentFromDb(updatedContent);
+    } catch (error) {
+        throw error;
+    }
+};
+export const searchContent = async (context, options = {})=>{
+    const action = 'searchContent';
+    const { databaseName } = context;
+    const { category, isActive, key, locale } = parseContentOptions(options);
+    const filterConditions = [];
+    const bindVars = {};
+    if (key) {
+        filterConditions.push('c.key == @key');
+        bindVars.key = key;
+    }
+    if (locale) {
+        filterConditions.push('c.locale == @locale');
+        bindVars.locale = locale;
+    }
+    if (category) {
+        filterConditions.push('c.category == @category');
+        bindVars.category = category;
+    }
+    if (isActive !== undefined) {
+        filterConditions.push('c.isActive == @isActive');
+        bindVars.isActive = isActive;
+    }
+    const filterClause = filterConditions.length > 0 ? `FILTER ${filterConditions.join(' && ')}` : '';
+    const aqlQuery = `
     FOR c IN content
-    ${n.length>0?`FILTER ${n.join(" && ")}`:""}
+    ${filterClause}
     SORT c.key, c.locale
     RETURN c
-  `;try{return(await R(o).query(l,c).then(d=>d.all()).catch(d=>T({action:a,category:v,label:A.DATABASE_ERROR},d,e))).map(d=>h(d))}catch(g){throw g}};export{C as addContent,E as getContent,H as getContentWithFallback,D as parseContentOptions,M as searchContent,K as updateContent};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/content.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseString} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport type {AqlQuery} from 'arangojs/aql';\n\nimport {parseContentFromDb, parseContentInput} from '../adapters/contentAdapter.js';\nimport {Config} from '../config.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {translateText} from '../utils/googleTranslate.js';\nimport {extractLanguage, isRegionalLocale} from '../utils/localeUtils.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {ContentInputType, ContentOptions, ContentType, Locale} from '../types/content.types.js';\n\nconst eventCategory: string = 'content';\n\nexport const parseContentOptions = (options: ContentOptions = {}) => {\n  const {\n    category,\n    isActive = true,\n    key,\n    locale\n  } = options;\n\n  return {\n    category: category ? parseString(category, 100) : undefined,\n    isActive,\n    key: key ? parseString(key, 200) : undefined,\n    locale\n  };\n};\n\nexport const getContent = async (\n  context: ApiContext,\n  key: string,\n  locale: string = 'en'\n): Promise<ContentType | null> => {\n  const action: string = 'getContent';\n  const {databaseName} = context;\n  const formatKey: string = parseString(key, 200);\n  const formatLocale: string = parseString(locale, 5);\n\n  const aqlQry: AqlQuery = aql`\n    FOR c IN content\n    FILTER c.key == ${formatKey} && c.locale == ${formatLocale} && c.isActive == true\n    LIMIT 1\n    RETURN c\n  `;\n\n  try {\n    const content: ContentType | null = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n\n    return content ? parseContentFromDb(content) : null;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const getContentWithFallback = async (\n  context: ApiContext,\n  key: string,\n  fallbackContent: string,\n  locale: Locale = 'en'\n): Promise<string> => {\n  const appLocale = (Config.get('app.locale') || 'en') as Locale;\n\n  try {\n    let content = await getContent(context, key, locale);\n\n    if(content?.content) {\n      return content.content;\n    }\n\n    if(isRegionalLocale(locale)) {\n      const language = extractLanguage(locale);\n      content = await getContent(context, key, language as Locale);\n\n      if(content?.content) {\n        addContent(context, {\n          key,\n          content: content.content,\n          locale,\n          description: `Extracted from ${language}`\n        }).catch((saveError) => {\n          console.error('Error saving extracted content:', saveError);\n        });\n\n        return content.content;\n      }\n    }\n\n    if(locale === appLocale) {\n      if(fallbackContent) {\n        addContent(context, {\n          key,\n          content: fallbackContent,\n          locale,\n          description: 'Auto-generated from fallback'\n        }).catch((saveError) => {\n          console.error('Error saving fallback content:', saveError);\n        });\n      }\n\n      return fallbackContent || key;\n    }\n    try {\n      let sourceContent = await getContent(context, key, appLocale);\n      let sourceText: string;\n\n      if(sourceContent?.content) {\n        sourceText = sourceContent.content;\n      } else {\n        if(isRegionalLocale(appLocale)) {\n          const appLanguage = extractLanguage(appLocale);\n          sourceContent = await getContent(context, key, appLanguage as Locale);\n        }\n\n        if(sourceContent?.content) {\n          sourceText = sourceContent.content;\n        } else if(fallbackContent) {\n          sourceText = fallbackContent;\n\n          addContent(context, {\n            key,\n            content: fallbackContent,\n            locale: appLocale,\n            description: 'Auto-generated from fallback'\n          }).catch((saveError) => {\n            console.error('Error saving fallback as default content:', saveError);\n          });\n        } else {\n          return key;\n        }\n      }\n\n      const translatedText = await translateText(sourceText, extractLanguage(locale), extractLanguage(appLocale));\n\n      addContent(context, {\n        key,\n        content: translatedText,\n        locale,\n        description: `Auto-translated from ${appLocale}`\n      }).catch((saveError) => {\n        console.error('Error saving translated content:', saveError);\n      });\n\n      return translatedText;\n    } catch(translationError) {\n      console.error('Translation error:', translationError);\n\n      return fallbackContent || key;\n    }\n  } catch(error) {\n    console.error('Error fetching content from database:', error);\n    return fallbackContent || key;\n  }\n};\n\nexport const addContent = async (\n  context: ApiContext,\n  contentInput: ContentInputType\n): Promise<ContentType> => {\n  const action: string = 'addContent';\n  const {databaseName, session} = context;\n  const now = Date.now();\n  const parsedContent = parseContentInput(contentInput);\n  const {key, locale = 'en', content, description, category, isActive = true} = parsedContent;\n  const contentId = createHash(`content-${key}-${locale}`);\n  const insert: ContentType = {\n    _id: `content/${contentId}`,\n    _key: contentId,\n    added: now,\n    key: parseString(key, 200),\n    locale,\n    content: parseString(content, 10000),\n    description: (description ? parseString(description, 500) : undefined) as string,\n    category: (category ? parseString(category, 100) : undefined) as string,\n    isActive,\n    modified: now,\n    userId: session?.userId as string\n  };\n\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN content RETURN NEW`;\n\n  try {\n    const savedContent: ContentType = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n\n    return parseContentFromDb(savedContent);\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const updateContent = async (\n  context: ApiContext,\n  contentInput: ContentInputType\n): Promise<ContentType> => {\n  const action: string = 'updateContent';\n  const {databaseName} = context;\n  const now = Date.now();\n  const parsedContent = parseContentInput(contentInput);\n  const {contentId, content, description, category, isActive} = parsedContent;\n\n  if(!contentId) {\n    throw new Error('Content ID is required for update');\n  }\n\n  const update: any = {\n    content: parseString(content, 10000),\n    modified: now\n  };\n\n  if(description !== undefined) {\n    update.description = description ? parseString(description, 500) : undefined;\n  }\n  if(category !== undefined) {\n    update.category = category ? parseString(category, 100) : undefined;\n  }\n  if(isActive !== undefined) {\n    update.isActive = isActive;\n  }\n\n  const aqlQry: AqlQuery = aql`\n    FOR c IN content\n    FILTER c._key == ${contentId}\n    UPDATE c WITH ${update} IN content\n    RETURN NEW\n  `;\n\n  try {\n    const updatedContent: ContentType = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n\n    if(!updatedContent) {\n      throw new Error('Content not found or access denied');\n    }\n\n    return parseContentFromDb(updatedContent);\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const searchContent = async (\n  context: ApiContext,\n  options: ContentOptions = {}\n): Promise<ContentType[]> => {\n  const action: string = 'searchContent';\n  const {databaseName} = context;\n  const {category, isActive, key, locale} = parseContentOptions(options);\n\n  const filterConditions: string[] = [];\n  const bindVars: Record<string, any> = {};\n\n  if(key) {\n    filterConditions.push('c.key == @key');\n    bindVars.key = key;\n  }\n\n  if(locale) {\n    filterConditions.push('c.locale == @locale');\n    bindVars.locale = locale;\n  }\n\n  if(category) {\n    filterConditions.push('c.category == @category');\n    bindVars.category = category;\n  }\n\n  if(isActive !== undefined) {\n    filterConditions.push('c.isActive == @isActive');\n    bindVars.isActive = isActive;\n  }\n\n  const filterClause = filterConditions.length > 0 ? `FILTER ${filterConditions.join(' && ')}` : '';\n\n  const aqlQuery = `\n    FOR c IN content\n    ${filterClause}\n    SORT c.key, c.locale\n    RETURN c\n  `;\n\n  try {\n    const contentList = await useDb(databaseName)\n      .query(aqlQuery, bindVars)\n      .then((cursor) => cursor.all())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n\n    return (contentList as ContentType[]).map((content) => parseContentFromDb(content));\n  } catch(error) {\n    throw error;\n  }\n};"],
  "mappings": "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",
  "names": ["createHash", "parseString", "aql", "parseContentFromDb", "parseContentInput", "Config", "ErrorTypes", "logError", "useDb", "translateText", "extractLanguage", "isRegionalLocale", "eventCategory", "parseContentOptions", "options", "category", "isActive", "key", "locale", "getContent", "context", "action", "databaseName", "formatKey", "formatLocale", "aqlQry", "content", "cursor", "error", "getContentWithFallback", "fallbackContent", "appLocale", "language", "addContent", "saveError", "sourceContent", "sourceText", "appLanguage", "translatedText", "contentInput", "session", "now", "parsedContent", "description", "contentId", "insert", "savedContent", "updateContent", "update", "updatedContent", "searchContent", "filterConditions", "bindVars", "aqlQuery"]
}

+  `;
+    try {
+        const contentList = await useDb(databaseName).query(aqlQuery, bindVars).then((cursor)=>cursor.all()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+        return contentList.map((content)=>parseContentFromDb(content));
+    } catch (error) {
+        throw error;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/content.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseString} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport type {AqlQuery} from 'arangojs/aql';\n\nimport {parseContentFromDb, parseContentInput} from '../adapters/contentAdapter.js';\nimport {Config} from '../config.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {translateText} from '../utils/googleTranslate.js';\nimport {extractLanguage, isRegionalLocale} from '../utils/localeUtils.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {ContentInputType, ContentOptions, ContentType, Locale} from '../types/content.types.js';\n\nconst eventCategory: string = 'content';\n\nexport const parseContentOptions = (options: ContentOptions = {}) => {\n  const {\n    category,\n    isActive = true,\n    key,\n    locale\n  } = options;\n\n  return {\n    category: category ? parseString(category, 100) : undefined,\n    isActive,\n    key: key ? parseString(key, 200) : undefined,\n    locale\n  };\n};\n\nexport const getContent = async (\n  context: ApiContext,\n  key: string,\n  locale: string = 'en'\n): Promise<ContentType | null> => {\n  const action: string = 'getContent';\n  const {databaseName} = context;\n  const formatKey: string = parseString(key, 200);\n  const formatLocale: string = parseString(locale, 5);\n\n  const aqlQry: AqlQuery = aql`\n    FOR c IN content\n    FILTER c.key == ${formatKey} && c.locale == ${formatLocale} && c.isActive == true\n    LIMIT 1\n    RETURN c\n  `;\n\n  try {\n    const content: ContentType | null = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n\n    return content ? parseContentFromDb(content) : null;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const getContentWithFallback = async (\n  context: ApiContext,\n  key: string,\n  fallbackContent: string,\n  locale: Locale = 'en'\n): Promise<string> => {\n  const appLocale = (Config.get('app.locale') || 'en') as Locale;\n\n  try {\n    let content = await getContent(context, key, locale);\n\n    if(content?.content) {\n      return content.content;\n    }\n\n    if(isRegionalLocale(locale)) {\n      const language = extractLanguage(locale);\n      content = await getContent(context, key, language as Locale);\n\n      if(content?.content) {\n        addContent(context, {\n          key,\n          content: content.content,\n          locale,\n          description: `Extracted from ${language}`\n        }).catch((saveError) => {\n          console.error('Error saving extracted content:', saveError);\n        });\n\n        return content.content;\n      }\n    }\n\n    if(locale === appLocale) {\n      if(fallbackContent) {\n        addContent(context, {\n          key,\n          content: fallbackContent,\n          locale,\n          description: 'Auto-generated from fallback'\n        }).catch((saveError) => {\n          console.error('Error saving fallback content:', saveError);\n        });\n      }\n\n      return fallbackContent || key;\n    }\n    try {\n      let sourceContent = await getContent(context, key, appLocale);\n      let sourceText: string;\n\n      if(sourceContent?.content) {\n        sourceText = sourceContent.content;\n      } else {\n        if(isRegionalLocale(appLocale)) {\n          const appLanguage = extractLanguage(appLocale);\n          sourceContent = await getContent(context, key, appLanguage as Locale);\n        }\n\n        if(sourceContent?.content) {\n          sourceText = sourceContent.content;\n        } else if(fallbackContent) {\n          sourceText = fallbackContent;\n\n          addContent(context, {\n            key,\n            content: fallbackContent,\n            locale: appLocale,\n            description: 'Auto-generated from fallback'\n          }).catch((saveError) => {\n            console.error('Error saving fallback as default content:', saveError);\n          });\n        } else {\n          return key;\n        }\n      }\n\n      const translatedText = await translateText(sourceText, extractLanguage(locale), extractLanguage(appLocale));\n\n      addContent(context, {\n        key,\n        content: translatedText,\n        locale,\n        description: `Auto-translated from ${appLocale}`\n      }).catch((saveError) => {\n        console.error('Error saving translated content:', saveError);\n      });\n\n      return translatedText;\n    } catch(translationError) {\n      console.error('Translation error:', translationError);\n\n      return fallbackContent || key;\n    }\n  } catch(error) {\n    console.error('Error fetching content from database:', error);\n    return fallbackContent || key;\n  }\n};\n\nexport const addContent = async (\n  context: ApiContext,\n  contentInput: ContentInputType\n): Promise<ContentType> => {\n  const action: string = 'addContent';\n  const {databaseName, session} = context;\n  const now = Date.now();\n  const parsedContent = parseContentInput(contentInput);\n  const {key, locale = 'en', content, description, category, isActive = true} = parsedContent;\n  const contentId = createHash(`content-${key}-${locale}`);\n  const insert: ContentType = {\n    _id: `content/${contentId}`,\n    _key: contentId,\n    added: now,\n    key: parseString(key, 200),\n    locale,\n    content: parseString(content, 10000),\n    description: (description ? parseString(description, 500) : undefined) as string,\n    category: (category ? parseString(category, 100) : undefined) as string,\n    isActive,\n    modified: now,\n    userId: session?.userId as string\n  };\n\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN content RETURN NEW`;\n\n  try {\n    const savedContent: ContentType = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n\n    return parseContentFromDb(savedContent);\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const updateContent = async (\n  context: ApiContext,\n  contentInput: ContentInputType\n): Promise<ContentType> => {\n  const action: string = 'updateContent';\n  const {databaseName} = context;\n  const now = Date.now();\n  const parsedContent = parseContentInput(contentInput);\n  const {contentId, content, description, category, isActive} = parsedContent;\n\n  if(!contentId) {\n    throw new Error('Content ID is required for update');\n  }\n\n  const update: any = {\n    content: parseString(content, 10000),\n    modified: now\n  };\n\n  if(description !== undefined) {\n    update.description = description ? parseString(description, 500) : undefined;\n  }\n  if(category !== undefined) {\n    update.category = category ? parseString(category, 100) : undefined;\n  }\n  if(isActive !== undefined) {\n    update.isActive = isActive;\n  }\n\n  const aqlQry: AqlQuery = aql`\n    FOR c IN content\n    FILTER c._key == ${contentId}\n    UPDATE c WITH ${update} IN content\n    RETURN NEW\n  `;\n\n  try {\n    const updatedContent: ContentType = await useDb(databaseName)\n      .query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n\n    if(!updatedContent) {\n      throw new Error('Content not found or access denied');\n    }\n\n    return parseContentFromDb(updatedContent);\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const searchContent = async (\n  context: ApiContext,\n  options: ContentOptions = {}\n): Promise<ContentType[]> => {\n  const action: string = 'searchContent';\n  const {databaseName} = context;\n  const {category, isActive, key, locale} = parseContentOptions(options);\n\n  const filterConditions: string[] = [];\n  const bindVars: Record<string, any> = {};\n\n  if(key) {\n    filterConditions.push('c.key == @key');\n    bindVars.key = key;\n  }\n\n  if(locale) {\n    filterConditions.push('c.locale == @locale');\n    bindVars.locale = locale;\n  }\n\n  if(category) {\n    filterConditions.push('c.category == @category');\n    bindVars.category = category;\n  }\n\n  if(isActive !== undefined) {\n    filterConditions.push('c.isActive == @isActive');\n    bindVars.isActive = isActive;\n  }\n\n  const filterClause = filterConditions.length > 0 ? `FILTER ${filterConditions.join(' && ')}` : '';\n\n  const aqlQuery = `\n    FOR c IN content\n    ${filterClause}\n    SORT c.key, c.locale\n    RETURN c\n  `;\n\n  try {\n    const contentList = await useDb(databaseName)\n      .query(aqlQuery, bindVars)\n      .then((cursor) => cursor.all())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n\n    return (contentList as ContentType[]).map((content) => parseContentFromDb(content));\n  } catch(error) {\n    throw error;\n  }\n};"],"names":["createHash","parseString","aql","parseContentFromDb","parseContentInput","Config","ErrorTypes","logError","useDb","translateText","extractLanguage","isRegionalLocale","eventCategory","parseContentOptions","options","category","isActive","key","locale","undefined","getContent","context","action","databaseName","formatKey","formatLocale","aqlQry","content","query","then","cursor","next","catch","error","label","DATABASE_ERROR","getContentWithFallback","fallbackContent","appLocale","get","language","addContent","description","saveError","console","sourceContent","sourceText","appLanguage","translatedText","translationError","contentInput","session","now","Date","parsedContent","contentId","insert","_id","_key","added","modified","userId","savedContent","updateContent","Error","update","updatedContent","searchContent","filterConditions","bindVars","push","filterClause","length","join","aqlQuery","contentList","all","map"],"mappings":"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"}

package/lib/actions/conversations.d.ts

@@ -14,3 +14,4 @@ export declare const getConversation: (context: ApiContext, conversationId: stri
 export declare const updateConversation: (context: ApiContext, conversation: ConversationType) => Promise<ConversationType>;
 export declare const addUserToConversation: (context: ApiContext, { conversationId, userId }: UpdateConversationUserParams) => Promise<ConversationType>;
 export declare const deleteUserFromConversation: (context: ApiContext, { conversationId, userId }: UpdateConversationUserParams) => Promise<ConversationType>;
+//# sourceMappingURL=conversations.d.ts.map

package/lib/actions/conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversations.d.ts","sourceRoot":"","sources":["../../src/actions/conversations.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAC,aAAa,EAAW,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,uBAAuB,EACvB,wBAAwB,EACxB,4BAA4B,EAC7B,MAAM,iCAAiC,CAAC;AAMzC,eAAO,MAAM,wBAAwB,GAAI,UAAS,mBAAwB;WAOzC,aAAa;CAE7C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,SAAS,UAAU,EAAE,QAAQ,MAAM,EAAE,aAAQ,KAAG,OAAO,CAAC,gBAAgB,EAAE,CAwB1G,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,SAAS,UAAU,EACnB,0BAIG,wBAAwB,KAC1B,OAAO,CAAC,gBAAgB,CAgC1B,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,SAAS,UAAU,EACnB,0BAIG,wBAAwB,KAC1B,OAAO,CAAC,gBAAgB,CA2C1B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,UAAU,EACnB,0CAIG,uBAAuB,KACzB,OAAO,CAAC,cAAc,EAAE,CA4B1B,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,SAAS,UAAU,EACnB,0CAIG,uBAAuB,KACzB,OAAO,CAAC,gBAAgB,EAAE,CA2B5B,CAAC;AAoCF,eAAO,MAAM,eAAe,GAAI,SAAS,UAAU,EAAE,gBAAgB,MAAM,KAAG,OAAO,CAAC,gBAAgB,CA8CrG,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,UAAU,EACnB,cAAc,gBAAgB,KAC7B,OAAO,CAAC,gBAAgB,CAmC1B,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,SAAS,UAAU,EACnB,4BAGG,4BAA4B,KAC9B,OAAO,CAAC,gBAAgB,CAuC1B,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,SAAS,UAAU,EACnB,4BAGG,4BAA4B,KAC9B,OAAO,CAAC,gBAAgB,CAqB1B,CAAC"}