@nlabs/reaktor 0.10.5 → 0.10.6

package/lib/actions/apps.d.ts

@@ -23,3 +23,4 @@ export declare const deleteApp: (context: ApiContext, app: AppType) => Promise<A
 export declare const deactivateApp: (context: ApiContext, app: AppType) => Promise<UserType>;
 export declare const getApp: (context: ApiContext, options?: AppOptions) => Promise<AppType>;
 export declare const getApps: (context: ApiContext, options?: AppOptions) => Promise<AppType[]>;
+//# sourceMappingURL=apps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apps.d.ts","sourceRoot":"","sources":["../../src/actions/apps.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,yBAAyB,CAAC;AAKtD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,cAAc,GAAI,SAAQ,MAAM,EAAO,QAOpB,CAAC;AAEjC,eAAO,MAAM,eAAe,GAAI,UAAS,UAAe;;SAhBxC,MAAM;UACL,MAAM;WACL,MAAM;WACN,MAAM;SACR,MAAM;CAuBrB,CAAC;AAEF,eAAO,MAAM,MAAM,GAAU,SAAS,UAAU,EAAE,KAAK,OAAO,KAAG,OAAO,CAAC,QAAQ,CAmEhF,CAAC;AAEF,eAAO,MAAM,SAAS,GAAU,SAAS,UAAU,EAAE,KAAK,OAAO,KAAG,OAAO,CAAC,OAAO,CAmBlF,CAAC;AAEF,eAAO,MAAM,SAAS,GAAU,SAAS,UAAU,EAAE,KAAK,OAAO,KAAG,OAAO,CAAC,OAAO,CA0BlF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,UAAU,EAAE,KAAK,OAAO,KAAG,OAAO,CAAC,QAAQ,CAyBjF,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,SAAS,UAAU,EAAE,UAAU,UAAU,KAAG,OAAO,CAAC,OAAO,CAwCjF,CAAC;AAEF,eAAO,MAAM,OAAO,GAAU,SAAS,UAAU,EAAE,UAAU,UAAU,KAAG,OAAO,CAAC,OAAO,EAAE,CAiC1F,CAAC"}

package/lib/actions/apps.js

@@ -0,0 +1,221 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { aql } from 'arangojs';
+import { logError, logException, UserError } from '../utils/analyticsUtils.js';
+import { getDocId, getLimit, selectReactionCountByType, useDb } from '../utils/arangodbUtils.js';
+import { isAdminUser } from '../utils/sessionUtils.js';
+import { createHash, parseArangoId, parseEmail, parseId, parsePhone, parseString } from '@nlabs/utils/parsers/strings';
+import { ErrorTypes } from '../types/error.types.js';
+const eventCategory = 'apps';
+export const getAppOptional = (fields = [])=>fields.reduce((selects, field)=>{
+        if (field.includes('Count')) {
+            return selectReactionCountByType('apps', 'a', field, selects);
+        }
+        return selects;
+    }, {
+        objects: [],
+        queries: []
+    });
+export const parseAppOptions = (options = {})=>{
+    const { from = 0, to = 30 } = options;
+    const limit = getLimit(from, to);
+    return {
+        ...options,
+        limit
+    };
+};
+export const addApp = async (context, app)=>{
+    const action = 'addUser';
+    const { databaseName } = context;
+    const { email = '', name = '', phone = '' } = app;
+    const formatName = parseString(name);
+    const formatEmail = parseEmail(email);
+    const formatPhone = parsePhone(phone);
+    if (!formatName) {
+        throw logException({
+            action,
+            category: eventCategory,
+            params: {
+                name
+            },
+            value: ErrorTypes.INVALID_ARGUMENTS
+        }, context);
+    }
+    const filters = [
+        `a.name == "${formatName}"`
+    ];
+    if (formatEmail) {
+        filters.push(`a.email == "${formatEmail}"`);
+    }
+    const checkQuery = `FOR u IN users
+    FILTER ${filters.join(' || ')}
+    RETURN u`;
+    try {
+        const existingApps = await useDb(databaseName).query(checkQuery).then((cursor)=>cursor.all());
+        if (existingApps.length) {
+            throw logException({
+                action,
+                category: eventCategory,
+                params: {
+                    name
+                },
+                value: ErrorTypes.EXISTING_ITEM
+            }, context);
+        }
+    } catch (error) {
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR,
+            params: {
+                name
+            }
+        }, error, context);
+    }
+    const insert = {
+        _key: createHash(name),
+        active: true,
+        added: Date.now(),
+        email: formatEmail,
+        modified: Date.now(),
+        name: formatName,
+        phone: formatPhone
+    };
+    const insertQuery = aql`INSERT ${insert} IN apps RETURN NEW`;
+    return await useDb(databaseName).query(insertQuery).then((cursor)=>cursor.next() || {}).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR,
+            params: {
+                name
+            }
+        }, error, context));
+};
+export const updateApp = async (context, app)=>{
+    const action = 'updateApp';
+    const { databaseName } = context;
+    const { _key, _id, id, appId, ...updated } = app;
+    const appDocId = getDocId('apps', app);
+    const appQuery = aql`LET a = DOCUMENT(${appDocId})
+    UPDATE a WITH ${updated} IN apps
+    RETURN NEW`;
+    return await useDb(databaseName).query(appQuery).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR,
+            params: {
+                app
+            }
+        }, error, context));
+};
+export const deleteApp = async (context, app)=>{
+    const action = 'deleteApp';
+    const { databaseName, session = {} } = context;
+    const isAdmin = isAdminUser(session);
+    const appDocId = getDocId('apps', app);
+    if (!isAdmin) {
+        return Promise.reject(new UserError(ErrorTypes.INVALID_SESSION));
+    }
+    const aqlQuery = aql`FOR a IN apps
+    FILTER a._id == \"${appDocId}\"
+    LIMIT 1
+    REMOVE a IN apps
+    RETURN OLD`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR,
+            params: app
+        }, error, context);
+    });
+};
+export const deactivateApp = (context, app)=>{
+    const action = 'deactivateApp';
+    const { databaseName, session = {} } = context;
+    const isAdmin = isAdminUser(session);
+    const appDocId = getDocId('apps', app);
+    if (!isAdmin) {
+        return Promise.reject(new UserError(ErrorTypes.INVALID_SESSION));
+    }
+    const updated = {
+        active: false
+    };
+    const aqlQuery = aql`UPDATE ${appDocId} WITH ${updated} IN apps LIMIT 1 RETURN NEW`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR,
+            params: app
+        }, error, context);
+    });
+};
+export const getApp = (context, options)=>{
+    const action = 'getApp';
+    const { databaseName, fields, session = {} } = context;
+    const { id, key, name } = parseAppOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getAppOptional(fields);
+    const filterBy = [
+        'a.active == true'
+    ];
+    const isAdmin = isAdminUser(session);
+    if (!isAdmin) {
+        return Promise.reject(new UserError(ErrorTypes.INVALID_SESSION));
+    }
+    if (id) {
+        filterBy.push(`a._id == "${parseArangoId(id)}"`);
+    }
+    if (key) {
+        filterBy.push(`a._key == "apps/${parseId(key)}"`);
+    }
+    if (name) {
+        filterBy.push(`CONTAINS(a.name, "${parseString(name)}")`);
+    }
+    // Get data from database
+    const aqlQuery = `FOR a IN apps
+    FILTER ${filterBy.join(' && ')}
+    ${selectQueries.join('\n')}
+    RETURN MERGE(a, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR,
+            params: options
+        }, error, context);
+    });
+};
+export const getApps = async (context, options)=>{
+    const action = 'getApps';
+    const { databaseName, fields, session = {} } = context;
+    const { limit, name } = parseAppOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getAppOptional(fields);
+    const filterBy = [
+        'a.active == true'
+    ];
+    const isAdmin = isAdminUser(session);
+    if (!isAdmin) {
+        return Promise.reject(new UserError(ErrorTypes.INVALID_SESSION));
+    }
+    if (name) {
+        filterBy.push(`CONTAINS(a.name, "${parseString(name)}")`);
+    }
+    const aqlQuery = `FOR a IN apps
+    FILTER ${filterBy.join(' && ')}
+    ${selectQueries.join('\n')}
+    ${limit.aql}
+    SORT a.name
+    RETURN MERGE(a, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.all()).catch((error)=>{
+        throw logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR,
+            params: options
+        }, error, context);
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/apps.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {aql} from 'arangojs';\nimport type {AqlQuery} from 'arangojs/aql';\n\nimport {logError, logException, UserError} from '../utils/analyticsUtils.js';\nimport {getDocId, getLimit, selectReactionCountByType, useDb} from '../utils/arangodbUtils.js';\nimport {isAdminUser} from '../utils/sessionUtils.js';\n\nimport {createHash, parseArangoId, parseEmail, parseId, parsePhone, parseString} from '@nlabs/utils/parsers/strings';\nimport type {AppType} from '../types/apps.types.js';\nimport type {ApiContext} from '../types/auth.types.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport type {UserType} from '../types/users.types.js';\nimport type {Session} from '../utils/sessionUtils.js';\n\nconst eventCategory: string = 'apps';\n\nexport interface AppOptions {\n  readonly id?: string;\n  readonly key?: string;\n  readonly from?: number;\n  readonly name?: string;\n  readonly to?: number;\n}\n\nexport const getAppOptional = (fields: string[] = []) =>\n  fields.reduce((selects, field: string) => {\n    if(field.includes('Count')) {\n      return selectReactionCountByType('apps', 'a', field, selects);\n    }\n\n    return selects;\n  }, {objects: [], queries: []});\n\nexport const parseAppOptions = (options: AppOptions = {}) => {\n  const {\n    from = 0,\n    to = 30\n  } = options;\n  const limit = getLimit(from, to);\n\n  return {\n    ...options,\n    limit\n  };\n};\n\nexport const addApp = async (context: ApiContext, app: AppType): Promise<UserType> => {\n  const action = 'addUser';\n  const {databaseName} = context;\n  const {email = '', name = '', phone = ''} = app;\n  const formatName = parseString(name);\n  const formatEmail = parseEmail(email);\n  const formatPhone = parsePhone(phone);\n\n  if(!formatName) {\n    throw logException({\n      action,\n      category: eventCategory,\n      params: {name},\n      value: ErrorTypes.INVALID_ARGUMENTS\n    }, context);\n  }\n\n  const filters: string[] = [`a.name == \"${formatName}\"`];\n\n  if(formatEmail) {\n    filters.push(`a.email == \"${formatEmail}\"`);\n  }\n\n  const checkQuery: string = `FOR u IN users\n    FILTER ${filters.join(' || ')}\n    RETURN u`;\n\n  try {\n    const existingApps = await useDb(databaseName).query(checkQuery).then((cursor) => cursor.all());\n\n    if(existingApps.length) {\n      throw logException({\n        action,\n        category: eventCategory,\n        params: {name},\n        value: ErrorTypes.EXISTING_ITEM\n      }, context);\n    }\n  } catch(error) {\n    throw logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR,\n      params: {name}\n    }, error, context);\n  }\n\n  const insert: AppType = {\n    _key: createHash(name),\n    active: true,\n    added: Date.now(),\n    email: formatEmail,\n    modified: Date.now(),\n    name: formatName,\n    phone: formatPhone\n  };\n\n  const insertQuery: AqlQuery = aql`INSERT ${insert} IN apps RETURN NEW`;\n\n  return await useDb(databaseName).query(insertQuery)\n    .then((cursor) => cursor.next() || {})\n    .catch((error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR,\n      params: {name}\n    }, error, context));\n};\n\nexport const updateApp = async (context: ApiContext, app: AppType): Promise<AppType> => {\n  const action: string = 'updateApp';\n  const {databaseName} = context;\n  const {_key, _id, id, appId, ...updated} = app;\n  const appDocId = getDocId('apps', app);\n  const appQuery: AqlQuery = aql`LET a = DOCUMENT(${appDocId})\n    UPDATE a WITH ${updated} IN apps\n    RETURN NEW`;\n\n  return await useDb(databaseName).query(appQuery)\n    .then((cursor) => cursor.next())\n    .catch((error) =>\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR,\n        params: {app}\n      }, error, context)\n    );\n};\n\nexport const deleteApp = async (context: ApiContext, app: AppType): Promise<AppType> => {\n  const action: string = 'deleteApp';\n  const {databaseName, session = {}} = context;\n  const isAdmin = isAdminUser(session as Session);\n  const appDocId = getDocId('apps', app);\n\n  if(!isAdmin) {\n    return Promise.reject(new UserError(ErrorTypes.INVALID_SESSION));\n  }\n\n  const aqlQuery: AqlQuery = aql`FOR a IN apps\n    FILTER a._id == \\\"${appDocId}\\\"\n    LIMIT 1\n    REMOVE a IN apps\n    RETURN OLD`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .catch((error) =>{\n      throw logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR,\n        params: app as Record<string, unknown>\n      }, error, context);\n    });\n};\n\nexport const deactivateApp = (context: ApiContext, app: AppType): Promise<UserType> => {\n  const action: string = 'deactivateApp';\n  const {databaseName, session = {}} = context;\n  const isAdmin = isAdminUser(session as Session);\n  const appDocId = getDocId('apps', app);\n\n  if(!isAdmin) {\n    return Promise.reject(new UserError(ErrorTypes.INVALID_SESSION));\n  }\n\n  const updated: AppType = {\n    active: false\n  };\n  const aqlQuery: AqlQuery = aql`UPDATE ${appDocId} WITH ${updated} IN apps LIMIT 1 RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR,\n        params: app as Record<string, unknown>\n      }, error, context);\n    });\n};\n\nexport const getApp = (context: ApiContext, options?: AppOptions): Promise<AppType> => {\n  const action: string = 'getApp';\n  const {databaseName, fields, session = {}} = context;\n  const {id, key, name} = parseAppOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getAppOptional(fields);\n  const filterBy: string[] = ['a.active == true'];\n  const isAdmin = isAdminUser(session as Session);\n\n  if(!isAdmin) {\n    return Promise.reject(new UserError(ErrorTypes.INVALID_SESSION));\n  }\n\n  if(id) {\n    filterBy.push(`a._id == \"${parseArangoId(id)}\"`);\n  }\n\n  if(key) {\n    filterBy.push(`a._key == \"apps/${parseId(key)}\"`);\n  }\n\n  if(name) {\n    filterBy.push(`CONTAINS(a.name, \"${parseString(name)}\")`);\n  }\n\n  // Get data from database\n  const aqlQuery: string = `FOR a IN apps\n    FILTER ${filterBy.join(' && ')}\n    ${selectQueries.join('\\n')}\n    RETURN MERGE(a, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.next() as unknown as AppType)\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR,\n        params: options as Record<string, unknown>\n      }, error, context);\n    });\n};\n\nexport const getApps = async (context: ApiContext, options?: AppOptions): Promise<AppType[]> => {\n  const action: string = 'getApps';\n  const {databaseName, fields, session = {}} = context;\n  const {limit, name} = parseAppOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getAppOptional(fields);\n  const filterBy: string[] = ['a.active == true'];\n  const isAdmin = isAdminUser(session as Session);\n\n  if(!isAdmin) {\n    return Promise.reject(new UserError(ErrorTypes.INVALID_SESSION));\n  }\n\n  if(name) {\n    filterBy.push(`CONTAINS(a.name, \"${parseString(name)}\")`);\n  }\n\n  const aqlQuery: string = `FOR a IN apps\n    FILTER ${filterBy.join(' && ')}\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT a.name\n    RETURN MERGE(a, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as AppType[])\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR,\n        params: options as Record<string, unknown>\n      }, error, context);\n    });\n};\n"],"names":["aql","logError","logException","UserError","getDocId","getLimit","selectReactionCountByType","useDb","isAdminUser","createHash","parseArangoId","parseEmail","parseId","parsePhone","parseString","ErrorTypes","eventCategory","getAppOptional","fields","reduce","selects","field","includes","objects","queries","parseAppOptions","options","from","to","limit","addApp","context","app","action","databaseName","email","name","phone","formatName","formatEmail","formatPhone","category","params","value","INVALID_ARGUMENTS","filters","push","checkQuery","join","existingApps","query","then","cursor","all","length","EXISTING_ITEM","error","label","DATABASE_ERROR","insert","_key","active","added","Date","now","modified","insertQuery","next","catch","updateApp","_id","id","appId","updated","appDocId","appQuery","deleteApp","session","isAdmin","Promise","reject","INVALID_SESSION","aqlQuery","deactivateApp","getApp","key","selectObjects","selectQueries","filterBy","getApps"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,GAAG,QAAO,WAAW;AAG7B,SAAQC,QAAQ,EAAEC,YAAY,EAAEC,SAAS,QAAO,6BAA6B;AAC7E,SAAQC,QAAQ,EAAEC,QAAQ,EAAEC,yBAAyB,EAAEC,KAAK,QAAO,4BAA4B;AAC/F,SAAQC,WAAW,QAAO,2BAA2B;AAErD,SAAQC,UAAU,EAAEC,aAAa,EAAEC,UAAU,EAAEC,OAAO,EAAEC,UAAU,EAAEC,WAAW,QAAO,+BAA+B;AAGrH,SAAQC,UAAU,QAAO,0BAA0B;AAInD,MAAMC,gBAAwB;AAU9B,OAAO,MAAMC,iBAAiB,CAACC,SAAmB,EAAE,GAClDA,OAAOC,MAAM,CAAC,CAACC,SAASC;QACtB,IAAGA,MAAMC,QAAQ,CAAC,UAAU;YAC1B,OAAOhB,0BAA0B,QAAQ,KAAKe,OAAOD;QACvD;QAEA,OAAOA;IACT,GAAG;QAACG,SAAS,EAAE;QAAEC,SAAS,EAAE;IAAA,GAAG;AAEjC,OAAO,MAAMC,kBAAkB,CAACC,UAAsB,CAAC,CAAC;IACtD,MAAM,EACJC,OAAO,CAAC,EACRC,KAAK,EAAE,EACR,GAAGF;IACJ,MAAMG,QAAQxB,SAASsB,MAAMC;IAE7B,OAAO;QACL,GAAGF,OAAO;QACVG;IACF;AACF,EAAE;AAEF,OAAO,MAAMC,SAAS,OAAOC,SAAqBC;IAChD,MAAMC,SAAS;IACf,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAM,EAACI,QAAQ,EAAE,EAAEC,OAAO,EAAE,EAAEC,QAAQ,EAAE,EAAC,GAAGL;IAC5C,MAAMM,aAAaxB,YAAYsB;IAC/B,MAAMG,cAAc5B,WAAWwB;IAC/B,MAAMK,cAAc3B,WAAWwB;IAE/B,IAAG,CAACC,YAAY;QACd,MAAMpC,aAAa;YACjB+B;YACAQ,UAAUzB;YACV0B,QAAQ;gBAACN;YAAI;YACbO,OAAO5B,WAAW6B,iBAAiB;QACrC,GAAGb;IACL;IAEA,MAAMc,UAAoB;QAAC,CAAC,WAAW,EAAEP,WAAW,CAAC,CAAC;KAAC;IAEvD,IAAGC,aAAa;QACdM,QAAQC,IAAI,CAAC,CAAC,YAAY,EAAEP,YAAY,CAAC,CAAC;IAC5C;IAEA,MAAMQ,aAAqB,CAAC;WACnB,EAAEF,QAAQG,IAAI,CAAC,QAAQ;YACtB,CAAC;IAEX,IAAI;QACF,MAAMC,eAAe,MAAM1C,MAAM2B,cAAcgB,KAAK,CAACH,YAAYI,IAAI,CAAC,CAACC,SAAWA,OAAOC,GAAG;QAE5F,IAAGJ,aAAaK,MAAM,EAAE;YACtB,MAAMpD,aAAa;gBACjB+B;gBACAQ,UAAUzB;gBACV0B,QAAQ;oBAACN;gBAAI;gBACbO,OAAO5B,WAAWwC,aAAa;YACjC,GAAGxB;QACL;IACF,EAAE,OAAMyB,OAAO;QACb,MAAMvD,SAAS;YACbgC;YACAQ,UAAUzB;YACVyC,OAAO1C,WAAW2C,cAAc;YAChChB,QAAQ;gBAACN;YAAI;QACf,GAAGoB,OAAOzB;IACZ;IAEA,MAAM4B,SAAkB;QACtBC,MAAMnD,WAAW2B;QACjByB,QAAQ;QACRC,OAAOC,KAAKC,GAAG;QACf7B,OAAOI;QACP0B,UAAUF,KAAKC,GAAG;QAClB5B,MAAME;QACND,OAAOG;IACT;IAEA,MAAM0B,cAAwBlE,GAAG,CAAC,OAAO,EAAE2D,OAAO,mBAAmB,CAAC;IAEtE,OAAO,MAAMpD,MAAM2B,cAAcgB,KAAK,CAACgB,aACpCf,IAAI,CAAC,CAACC,SAAWA,OAAOe,IAAI,MAAM,CAAC,GACnCC,KAAK,CAAC,CAACZ,QAAUvD,SAAS;YACzBgC;YACAQ,UAAUzB;YACVyC,OAAO1C,WAAW2C,cAAc;YAChChB,QAAQ;gBAACN;YAAI;QACf,GAAGoB,OAAOzB;AACd,EAAE;AAEF,OAAO,MAAMsC,YAAY,OAAOtC,SAAqBC;IACnD,MAAMC,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAC,GAAGH;IACvB,MAAM,EAAC6B,IAAI,EAAEU,GAAG,EAAEC,EAAE,EAAEC,KAAK,EAAE,GAAGC,SAAQ,GAAGzC;IAC3C,MAAM0C,WAAWtE,SAAS,QAAQ4B;IAClC,MAAM2C,WAAqB3E,GAAG,CAAC,iBAAiB,EAAE0E,SAAS;kBAC3C,EAAED,QAAQ;cACd,CAAC;IAEb,OAAO,MAAMlE,MAAM2B,cAAcgB,KAAK,CAACyB,UACpCxB,IAAI,CAAC,CAACC,SAAWA,OAAOe,IAAI,IAC5BC,KAAK,CAAC,CAACZ,QACNvD,SAAS;YACPgC;YACAQ,UAAUzB;YACVyC,OAAO1C,WAAW2C,cAAc;YAChChB,QAAQ;gBAACV;YAAG;QACd,GAAGwB,OAAOzB;AAEhB,EAAE;AAEF,OAAO,MAAM6C,YAAY,OAAO7C,SAAqBC;IACnD,MAAMC,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAE2C,UAAU,CAAC,CAAC,EAAC,GAAG9C;IACrC,MAAM+C,UAAUtE,YAAYqE;IAC5B,MAAMH,WAAWtE,SAAS,QAAQ4B;IAElC,IAAG,CAAC8C,SAAS;QACX,OAAOC,QAAQC,MAAM,CAAC,IAAI7E,UAAUY,WAAWkE,eAAe;IAChE;IAEA,MAAMC,WAAqBlF,GAAG,CAAC;sBACX,EAAE0E,SAAS;;;cAGnB,CAAC;IAEb,OAAOnE,MAAM2B,cAAcgB,KAAK,CAACgC,UAC9B/B,IAAI,CAAC,CAACC,SAAWA,OAAOe,IAAI,IAC5BC,KAAK,CAAC,CAACZ;QACN,MAAMvD,SAAS;YACbgC;YACAQ,UAAUzB;YACVyC,OAAO1C,WAAW2C,cAAc;YAChChB,QAAQV;QACV,GAAGwB,OAAOzB;IACZ;AACJ,EAAE;AAEF,OAAO,MAAMoD,gBAAgB,CAACpD,SAAqBC;IACjD,MAAMC,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAE2C,UAAU,CAAC,CAAC,EAAC,GAAG9C;IACrC,MAAM+C,UAAUtE,YAAYqE;IAC5B,MAAMH,WAAWtE,SAAS,QAAQ4B;IAElC,IAAG,CAAC8C,SAAS;QACX,OAAOC,QAAQC,MAAM,CAAC,IAAI7E,UAAUY,WAAWkE,eAAe;IAChE;IAEA,MAAMR,UAAmB;QACvBZ,QAAQ;IACV;IACA,MAAMqB,WAAqBlF,GAAG,CAAC,OAAO,EAAE0E,SAAS,MAAM,EAAED,QAAQ,2BAA2B,CAAC;IAE7F,OAAOlE,MAAM2B,cAAcgB,KAAK,CAACgC,UAC9B/B,IAAI,CAAC,CAACC,SAAWA,OAAOe,IAAI,IAC5BC,KAAK,CAAC,CAACZ;QACN,MAAMvD,SAAS;YACbgC;YACAQ,UAAUzB;YACVyC,OAAO1C,WAAW2C,cAAc;YAChChB,QAAQV;QACV,GAAGwB,OAAOzB;IACZ;AACJ,EAAE;AAEF,OAAO,MAAMqD,SAAS,CAACrD,SAAqBL;IAC1C,MAAMO,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEhB,MAAM,EAAE2D,UAAU,CAAC,CAAC,EAAC,GAAG9C;IAC7C,MAAM,EAACwC,EAAE,EAAEc,GAAG,EAAEjD,IAAI,EAAC,GAAGX,gBAAgBC;IACxC,MAAM,EAACH,SAAS+D,aAAa,EAAE9D,SAAS+D,aAAa,EAAC,GAAGtE,eAAeC;IACxE,MAAMsE,WAAqB;QAAC;KAAmB;IAC/C,MAAMV,UAAUtE,YAAYqE;IAE5B,IAAG,CAACC,SAAS;QACX,OAAOC,QAAQC,MAAM,CAAC,IAAI7E,UAAUY,WAAWkE,eAAe;IAChE;IAEA,IAAGV,IAAI;QACLiB,SAAS1C,IAAI,CAAC,CAAC,UAAU,EAAEpC,cAAc6D,IAAI,CAAC,CAAC;IACjD;IAEA,IAAGc,KAAK;QACNG,SAAS1C,IAAI,CAAC,CAAC,gBAAgB,EAAElC,QAAQyE,KAAK,CAAC,CAAC;IAClD;IAEA,IAAGjD,MAAM;QACPoD,SAAS1C,IAAI,CAAC,CAAC,kBAAkB,EAAEhC,YAAYsB,MAAM,EAAE,CAAC;IAC1D;IAEA,yBAAyB;IACzB,MAAM8C,WAAmB,CAAC;WACjB,EAAEM,SAASxC,IAAI,CAAC,QAAQ;IAC/B,EAAEuC,cAAcvC,IAAI,CAAC,MAAM;qBACV,EAAEsC,cAActC,IAAI,CAAC,MAAM,EAAE,CAAC;IAEjD,OAAOzC,MAAM2B,cAAcgB,KAAK,CAACgC,UAC9B/B,IAAI,CAAC,CAACC,SAAWA,OAAOe,IAAI,IAC5BC,KAAK,CAAC,CAACZ;QACN,MAAMvD,SAAS;YACbgC;YACAQ,UAAUzB;YACVyC,OAAO1C,WAAW2C,cAAc;YAChChB,QAAQhB;QACV,GAAG8B,OAAOzB;IACZ;AACJ,EAAE;AAEF,OAAO,MAAM0D,UAAU,OAAO1D,SAAqBL;IACjD,MAAMO,SAAiB;IACvB,MAAM,EAACC,YAAY,EAAEhB,MAAM,EAAE2D,UAAU,CAAC,CAAC,EAAC,GAAG9C;IAC7C,MAAM,EAACF,KAAK,EAAEO,IAAI,EAAC,GAAGX,gBAAgBC;IACtC,MAAM,EAACH,SAAS+D,aAAa,EAAE9D,SAAS+D,aAAa,EAAC,GAAGtE,eAAeC;IACxE,MAAMsE,WAAqB;QAAC;KAAmB;IAC/C,MAAMV,UAAUtE,YAAYqE;IAE5B,IAAG,CAACC,SAAS;QACX,OAAOC,QAAQC,MAAM,CAAC,IAAI7E,UAAUY,WAAWkE,eAAe;IAChE;IAEA,IAAG7C,MAAM;QACPoD,SAAS1C,IAAI,CAAC,CAAC,kBAAkB,EAAEhC,YAAYsB,MAAM,EAAE,CAAC;IAC1D;IAEA,MAAM8C,WAAmB,CAAC;WACjB,EAAEM,SAASxC,IAAI,CAAC,QAAQ;IAC/B,EAAEuC,cAAcvC,IAAI,CAAC,MAAM;IAC3B,EAAEnB,MAAM7B,GAAG,CAAC;;qBAEK,EAAEsF,cAActC,IAAI,CAAC,MAAM,EAAE,CAAC;IAEjD,OAAOzC,MAAM2B,cAAcgB,KAAK,CAACgC,UAC9B/B,IAAI,CAAC,CAACC,SAAWA,OAAOC,GAAG,IAC3Be,KAAK,CAAC,CAACZ;QACN,MAAMvD,SAAS;YACbgC;YACAQ,UAAUzB;YACVyC,OAAO1C,WAAW2C,cAAc;YAChChB,QAAQhB;QACV,GAAG8B,OAAOzB;IACZ;AACJ,EAAE"}

package/lib/actions/connections.d.ts

@@ -3,3 +3,4 @@ import type { ConnectionType } from '../types/connections.types.js';
 export declare const addConnection: (context: ApiContext, fromType: string, fromId: string, toType: string, toId: string, value?: string) => Promise<boolean>;
 export declare const getConnection: (context: ApiContext, fromType: string, fromId: string, toType: string, toId: string) => Promise<ConnectionType>;
 export declare const deleteConnection: (context: ApiContext, fromType: string, fromId: string, toType: string, toId: string) => Promise<boolean>;
+//# sourceMappingURL=connections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../../src/actions/connections.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,+BAA+B,CAAC;AAIlE,eAAO,MAAM,aAAa,GACxB,SAAS,UAAU,EACnB,UAAU,MAAM,EAChB,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,QAAQ,MAAM,KACb,OAAO,CAAC,OAAO,CAyBjB,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,SAAS,UAAU,EACnB,UAAU,MAAM,EAChB,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,MAAM,MAAM,KACX,OAAO,CAAC,cAAc,CAkBxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,SAAS,UAAU,EACnB,UAAU,MAAM,EAChB,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,MAAM,MAAM,KACX,OAAO,CAAC,OAAO,CAqBjB,CAAC"}

package/lib/actions/connections.js

@@ -0,0 +1,62 @@
+import { parseArangoId, parseString } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { useDb } from '../utils/arangodbUtils.js';
+const eventCategory = 'connections';
+export const addConnection = (context, fromType, fromId, toType, toId, value)=>{
+    const action = 'addConnection';
+    const { databaseName } = context;
+    const formatFromDocId = parseArangoId(`${fromType}/${fromId}`);
+    const formatToDocId = parseArangoId(`${toType}/${toId}`);
+    const insert = {
+        _from: formatFromDocId,
+        _to: formatToDocId,
+        isDirect: true,
+        type: toType,
+        value: !!value ? parseString(value, 32) : undefined
+    };
+    const aqlQry = aql`INSERT ${insert} IN hasConnection`;
+    return useDb(databaseName).query(aqlQry).then(()=>true).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return false;
+    });
+};
+export const getConnection = (context, fromType, fromId, toType, toId)=>{
+    const action = 'getConnection';
+    const { databaseName } = context;
+    const formatFromDocId = parseArangoId(`${fromType}/${fromId}`);
+    const formatToDocId = parseArangoId(`${toType}/${toId}`);
+    const aqlQry = aql`FOR hc in hasConnection
+    FILTER hc._from == ${formatFromDocId} && hc._to == ${formatToDocId}
+    LIMIT 1`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const deleteConnection = (context, fromType, fromId, toType, toId)=>{
+    const action = 'deleteReactionByItem';
+    const { databaseName } = context;
+    const formatFromDocId = parseArangoId(`${fromType}/${fromId}`);
+    const formatToDocId = parseArangoId(`${toType}/${toId}`);
+    const aqlQry = aql`FOR hc in hasConnection
+    FILTER hc._from == ${formatFromDocId} && hc._to == ${formatToDocId}
+    LIMIT 1
+    REMOVE hc IN hasConnection`;
+    return useDb(databaseName).query(aqlQry).then(()=>true).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return false;
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/actions/content.d.ts

@@ -11,3 +11,4 @@ export declare const getContentWithFallback: (context: ApiContext, key: string,
 export declare const addContent: (context: ApiContext, contentInput: ContentInputType) => Promise<ContentType>;
 export declare const updateContent: (context: ApiContext, contentInput: ContentInputType) => Promise<ContentType>;
 export declare const searchContent: (context: ApiContext, options?: ContentOptions) => Promise<ContentType[]>;
+//# sourceMappingURL=content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/actions/content.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAC,gBAAgB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,EAAC,MAAM,2BAA2B,CAAC;AAIrG,eAAO,MAAM,mBAAmB,GAAI,UAAS,cAAmB;;;;;CAc/D,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,SAAS,UAAU,EACnB,KAAK,MAAM,EACX,SAAQ,MAAa,KACpB,OAAO,CAAC,WAAW,GAAG,IAAI,CA2B5B,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,SAAS,UAAU,EACnB,KAAK,MAAM,EACX,iBAAiB,MAAM,EACvB,SAAQ,MAAa,KACpB,OAAO,CAAC,MAAM,CA6FhB,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,SAAS,UAAU,EACnB,cAAc,gBAAgB,KAC7B,OAAO,CAAC,WAAW,CAqCrB,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,SAAS,UAAU,EACnB,cAAc,gBAAgB,KAC7B,OAAO,CAAC,WAAW,CAmDrB,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,SAAS,UAAU,EACnB,UAAS,cAAmB,KAC3B,OAAO,CAAC,WAAW,EAAE,CAmDvB,CAAC"}

package/lib/actions/content.js

@@ -0,0 +1,240 @@
+/**
+ * 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 == ${formatKey} && c.locale == ${formatLocale} && c.isActive == true
+    LIMIT 1
+    RETURN c
+  `;
+    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 == ${contentId}
+    UPDATE c WITH ${update} IN content
+    RETURN NEW
+  `;
+    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
+    ${filterClause}
+    SORT c.key, c.locale
+    RETURN c
+  `;
+    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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"}