@nlabs/metropolisjs 0.1.1 → 0.1.2

package/lib/actions/tagActions/tagActions.d.ts

@@ -0,0 +1,55 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { TagType } from '../../adapters/tagAdapter/tagAdapter';
+export interface TagAdapterOptions {
+    strict?: boolean;
+    allowPartial?: boolean;
+    environment?: 'development' | 'production' | 'test';
+    customValidation?: (input: unknown) => unknown;
+}
+export interface TagActionsOptions {
+    tagAdapter?: (input: unknown, options?: TagAdapterOptions) => any;
+    tagAdapterOptions?: TagAdapterOptions;
+}
+export type TagApiResultsType = {
+    tags: {
+        addTag: TagType;
+        addTagToProfile: TagType;
+        deleteTag: TagType;
+        deleteTagFromProfile: TagType;
+        getTags: TagType[];
+        updateTag: TagType;
+    };
+};
+export interface TagActions {
+    addTag: (tag: Partial<TagType>, tagProps?: string[]) => Promise<TagType>;
+    addTagToProfile: (tagId: string, tagProps?: string[]) => Promise<TagType>;
+    deleteTag: (tagId: string, tagProps?: string[]) => Promise<TagType>;
+    deleteTagFromProfile: (tagId: string, tagProps?: string[]) => Promise<TagType>;
+    getTags: (tagProps?: string[]) => Promise<TagType[]>;
+    updateTag: (tag: Partial<TagType>, tagProps?: string[]) => Promise<TagType>;
+    updateTagAdapter: (adapter: (input: unknown, options?: TagAdapterOptions) => any) => void;
+    updateTagAdapterOptions: (options: TagAdapterOptions) => void;
+}
+/**
+ * Factory function to create TagActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const tagActions = createTagActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customTagAdapter = (input: unknown, options?: TagAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   if (input.name && input.name.length > 50) {
+ *     throw new Error('Tag name too long');
+ *   }
+ *   return input;
+ * };
+ *
+ * const tagActions = createTagActions(flux, {
+ *   tagAdapter: customTagAdapter
+ * });
+ */
+export declare const createTagActions: (flux: FluxFramework, options?: TagActionsOptions) => TagActions;

package/lib/actions/tagActions/tagActions.js

@@ -0,0 +1,2 @@
+import{validateTagInput as E}from"../../adapters/tagAdapter/tagAdapter";import{TAG_CONSTANTS as s}from"../../stores/tagStore";import{appMutation as l,appQuery as S}from"../../utils/api";const y="tags",O=(t,u)=>E(t),m=(t,u)=>(T,d)=>{const i={...u,...d};let c=O(T,i);return t&&(c=t(c,i)),i?.customValidation&&(c=i.customValidation(c)),c},F=(t,u)=>{let T=u?.tagAdapterOptions||{},d=u?.tagAdapter,i=m(d,T);return{addTag:async(e,o=[])=>{try{const a={tag:{type:"TagInput!",value:i(e,T)}},g=n=>{const{tags:{addTag:p={}}}=n;return t.dispatch({tag:p,type:s.ADD_ITEM_SUCCESS})},{tag:r}=await l(t,"addTag",y,a,["category","id","name","tagId",...o],{onSuccess:g});return r}catch(a){throw t.dispatch({error:a,type:s.ADD_ITEM_ERROR}),a}},addTagToProfile:async(e,o=[])=>{try{const a={tagId:{type:"ID!",value:e}},g=n=>{const{tags:{addTagToProfile:p={}}}=n;return t.dispatch({tag:p,type:s.ADD_PROFILE_SUCCESS})},{tag:r}=await l(t,"addTagToProfile",y,a,["category","id","name","tagId",...o],{onSuccess:g});return r}catch(a){throw t.dispatch({error:a,type:s.ADD_PROFILE_ERROR}),a}},deleteTag:async(e,o=[])=>{try{const a={tagId:{type:"ID!",value:e}},g=n=>{const{tags:{deleteTag:p={}}}=n;return t.dispatch({tag:p,type:s.REMOVE_ITEM_SUCCESS})},{tag:r}=await l(t,"deleteTag",y,a,["category","id","name","tagId",...o],{onSuccess:g});return r}catch(a){throw t.dispatch({error:a,type:s.REMOVE_ITEM_ERROR}),a}},deleteTagFromProfile:async(e,o=[])=>{try{const a={tagId:{type:"ID!",value:e}},g=n=>{const{tags:{deleteTagFromProfile:p={}}}=n;return t.dispatch({tag:p,type:s.REMOVE_PROFILE_SUCCESS})},{tag:r}=await l(t,"deleteTagFromProfile",y,a,["category","id","name","tagId",...o],{onSuccess:g});return r}catch(a){throw t.dispatch({error:a,type:s.REMOVE_PROFILE_ERROR}),a}},getTags:async(e=[])=>{const o=t.getState("tag.list",[]),a=t.getState("tag.expires",0),g=Date.now();if(o.length&&g<a)return await t.dispatch({tags:o,type:s.GET_LIST_SUCCESS}),o;try{const r={from:{type:"String",value:0},search:{type:"Int",value:""},to:{type:"Int",value:-1}},n=A=>{const{tags:{getTags:P}}=A;return t.dispatch({tags:P,type:s.GET_LIST_SUCCESS})},{tags:p}=await S(t,"tags",y,r,["category","id","name","tagId",...e],{onSuccess:n});return p}catch(r){throw t.dispatch({error:r,type:s.GET_LIST_SUCCESS}),r}},updateTag:async(e,o=[])=>{try{const a={tag:{type:"TagInput!",value:i(e,T)}},g=n=>{const{tags:{updateTag:p={}}}=n;return t.dispatch({tag:p,type:s.UPDATE_ITEM_SUCCESS})},{tag:r}=await l(t,"updateTag",y,a,["category","id","name","tagId",...o],{onSuccess:g});return r}catch(a){throw t.dispatch({error:a,type:s.UPDATE_ITEM_ERROR}),a}},updateTagAdapter:e=>{d=e,i=m(d,T)},updateTagAdapterOptions:e=>{T={...T,...e},i=m(d,T)}}};export{F as createTagActions};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/tagActions/tagActions.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2021-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {validateTagInput} from '../../adapters/tagAdapter/tagAdapter';\nimport {TAG_CONSTANTS} from '../../stores/tagStore';\nimport {appMutation, appQuery} from '../../utils/api';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {TagType} from '../../adapters/tagAdapter/tagAdapter';\nimport type {ReaktorDbCollection} from '../../utils/api';\n\nconst DATA_TYPE: ReaktorDbCollection = 'tags';\n\nexport interface TagAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface TagActionsOptions {\n  tagAdapter?: (input: unknown, options?: TagAdapterOptions) => any;\n  tagAdapterOptions?: TagAdapterOptions;\n}\n\nexport type TagApiResultsType = {\n  tags: {\n    addTag: TagType;\n    addTagToProfile: TagType;\n    deleteTag: TagType;\n    deleteTagFromProfile: TagType;\n    getTags: TagType[];\n    updateTag: TagType;\n  };\n};\n\nexport interface TagActions {\n  addTag: (tag: Partial<TagType>, tagProps?: string[]) => Promise<TagType>;\n  addTagToProfile: (tagId: string, tagProps?: string[]) => Promise<TagType>;\n  deleteTag: (tagId: string, tagProps?: string[]) => Promise<TagType>;\n  deleteTagFromProfile: (tagId: string, tagProps?: string[]) => Promise<TagType>;\n  getTags: (tagProps?: string[]) => Promise<TagType[]>;\n  updateTag: (tag: Partial<TagType>, tagProps?: string[]) => Promise<TagType>;\n  updateTagAdapter: (adapter: (input: unknown, options?: TagAdapterOptions) => any) => void;\n  updateTagAdapterOptions: (options: TagAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultTagValidator = (input: unknown, options?: TagAdapterOptions) => validateTagInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createTagValidator = (\n  customAdapter?: (input: unknown, options?: TagAdapterOptions) => any,\n  options?: TagAdapterOptions\n) => (input: unknown, validatorOptions?: TagAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultTagValidator(input, mergedOptions);\n\n  // Apply custom validation if provided\n  if(customAdapter) {\n    validated = customAdapter(validated, mergedOptions);\n  }\n\n  // Apply custom validation from options if provided\n  if(mergedOptions?.customValidation) {\n    validated = mergedOptions.customValidation(validated) as TagType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create TagActions with enhanced adapter injection capabilities.\n * Custom adapters are merged with default behavior, allowing partial overrides.\n *\n * @example\n * // Basic usage with default adapters\n * const tagActions = createTagActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customTagAdapter = (input: unknown, options?: TagAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.name && input.name.length > 50) {\n *     throw new Error('Tag name too long');\n *   }\n *   return input;\n * };\n *\n * const tagActions = createTagActions(flux, {\n *   tagAdapter: customTagAdapter\n * });\n */\nexport const createTagActions = (\n  flux: FluxFramework,\n  options?: TagActionsOptions\n): TagActions => {\n  // Initialize adapter state\n  let tagAdapterOptions: TagAdapterOptions = options?.tagAdapterOptions || {};\n  let customTagAdapter = options?.tagAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateTag = createTagValidator(customTagAdapter, tagAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateTagAdapter = (adapter: (input: unknown, options?: TagAdapterOptions) => any): void => {\n    customTagAdapter = adapter;\n    validateTag = createTagValidator(customTagAdapter, tagAdapterOptions);\n  };\n\n  const updateTagAdapterOptions = (options: TagAdapterOptions): void => {\n    tagAdapterOptions = {...tagAdapterOptions, ...options};\n    validateTag = createTagValidator(customTagAdapter, tagAdapterOptions);\n  };\n\n  // Action implementations\n  const addTag = async (tag: Partial<TagType>, tagProps: string[] = []): Promise<TagType> => {\n    try {\n      const queryVariables = {\n        tag: {\n          type: 'TagInput!',\n          value: validateTag(tag, tagAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: TagApiResultsType) => {\n        const {tags: {addTag: tag = {}}} = data;\n        return flux.dispatch({tag, type: TAG_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      const {tag: addedTag} = await appMutation(\n        flux,\n        'addTag',\n        DATA_TYPE,\n        queryVariables,\n        ['category', 'id', 'name', 'tagId', ...tagProps],\n        {onSuccess}\n      );\n\n      return addedTag as TagType;\n    } catch(error) {\n      flux.dispatch({error, type: TAG_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const addTagToProfile = async (tagId: string, tagProps: string[] = []): Promise<TagType> => {\n    try {\n      const queryVariables = {\n        tagId: {\n          type: 'ID!',\n          value: tagId\n        }\n      };\n\n      const onSuccess = (data: TagApiResultsType) => {\n        const {tags: {addTagToProfile: tag = {}}} = data;\n        return flux.dispatch({tag, type: TAG_CONSTANTS.ADD_PROFILE_SUCCESS});\n      };\n\n      const {tag: addedTag} = await appMutation(\n        flux,\n        'addTagToProfile',\n        DATA_TYPE,\n        queryVariables,\n        ['category', 'id', 'name', 'tagId', ...tagProps],\n        {onSuccess}\n      );\n\n      return addedTag as TagType;\n    } catch(error) {\n      flux.dispatch({error, type: TAG_CONSTANTS.ADD_PROFILE_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteTag = async (tagId: string, tagProps: string[] = []): Promise<TagType> => {\n    try {\n      const queryVariables = {\n        tagId: {\n          type: 'ID!',\n          value: tagId\n        }\n      };\n\n      const onSuccess = (data: TagApiResultsType) => {\n        const {tags: {deleteTag: tag = {}}} = data;\n        return flux.dispatch({tag, type: TAG_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      const {tag: deletedTag} = await appMutation(\n        flux,\n        'deleteTag',\n        DATA_TYPE,\n        queryVariables,\n        ['category', 'id', 'name', 'tagId', ...tagProps],\n        {onSuccess}\n      );\n\n      return deletedTag as TagType;\n    } catch(error) {\n      flux.dispatch({error, type: TAG_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteTagFromProfile = async (tagId: string, tagProps: string[] = []): Promise<TagType> => {\n    try {\n      const queryVariables = {\n        tagId: {\n          type: 'ID!',\n          value: tagId\n        }\n      };\n\n      const onSuccess = (data: TagApiResultsType) => {\n        const {tags: {deleteTagFromProfile: tag = {}}} = data;\n        return flux.dispatch({\n          tag,\n          type: TAG_CONSTANTS.REMOVE_PROFILE_SUCCESS\n        });\n      };\n\n      const {tag: deletedTag} = await appMutation(\n        flux,\n        'deleteTagFromProfile',\n        DATA_TYPE,\n        queryVariables,\n        ['category', 'id', 'name', 'tagId', ...tagProps],\n        {onSuccess}\n      );\n\n      return deletedTag as TagType;\n    } catch(error) {\n      flux.dispatch({error, type: TAG_CONSTANTS.REMOVE_PROFILE_ERROR});\n      throw error;\n    }\n  };\n\n  const getTags = async (tagProps: string[] = []): Promise<TagType[]> => {\n    const initialTags: TagType[] = flux.getState('tag.list', []) as TagType[];\n    const cacheExpires: number = flux.getState('tag.expires', 0) as number;\n    const now: number = Date.now();\n\n    if(initialTags.length && now < cacheExpires) {\n      await flux.dispatch({tags: initialTags, type: TAG_CONSTANTS.GET_LIST_SUCCESS});\n      return initialTags;\n    }\n\n    try {\n      const queryVariables = {\n        from: {\n          type: 'String',\n          value: 0\n        },\n        search: {\n          type: 'Int',\n          value: ''\n        },\n        to: {\n          type: 'Int',\n          value: -1\n        }\n      };\n\n      const onSuccess = (data: TagApiResultsType) => {\n        const {tags: {getTags}} = data;\n        return flux.dispatch({\n          tags: getTags,\n          type: TAG_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {tags: tagsList} = await appQuery(\n        flux,\n        'tags',\n        DATA_TYPE,\n        queryVariables,\n        ['category', 'id', 'name', 'tagId', ...tagProps],\n        {onSuccess}\n      );\n\n      return tagsList as TagType[];\n    } catch(error) {\n      flux.dispatch({error, type: TAG_CONSTANTS.GET_LIST_SUCCESS});\n      throw error;\n    }\n  };\n\n  const updateTag = async (tag: Partial<TagType>, tagProps: string[] = []): Promise<TagType> => {\n    try {\n      const queryVariables = {\n        tag: {\n          type: 'TagInput!',\n          value: validateTag(tag, tagAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: TagApiResultsType) => {\n        const {tags: {updateTag: tag = {}}} = data;\n        return flux.dispatch({tag, type: TAG_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      const {tag: updatedTag} = await appMutation(\n        flux,\n        'updateTag',\n        DATA_TYPE,\n        queryVariables,\n        ['category', 'id', 'name', 'tagId', ...tagProps],\n        {onSuccess}\n      );\n\n      return updatedTag as TagType;\n    } catch(error) {\n      flux.dispatch({error, type: TAG_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  // Return the actions object\n  return {\n    addTag,\n    addTagToProfile,\n    deleteTag,\n    deleteTagFromProfile,\n    getTags,\n    updateTag,\n    updateTagAdapter,\n    updateTagAdapterOptions\n  };\n};\n\n"],
  "mappings": "AAIA,OAAQ,oBAAAA,MAAuB,uCAC/B,OAAQ,iBAAAC,MAAoB,wBAC5B,OAAQ,eAAAC,EAAa,YAAAC,MAAe,kBAMpC,MAAMC,EAAiC,OAqCjCC,EAAsB,CAACC,EAAgBC,IAAgCP,EAAiBM,CAAK,EAG7FE,EAAqB,CACzBC,EACAF,IACG,CAACD,EAAgBI,IAAyC,CAC7D,MAAMC,EAAgB,CAAC,GAAGJ,EAAS,GAAGG,CAAgB,EAGtD,IAAIE,EAAYP,EAAoBC,EAAOK,CAAa,EAGxD,OAAGF,IACDG,EAAYH,EAAcG,EAAWD,CAAa,GAIjDA,GAAe,mBAChBC,EAAYD,EAAc,iBAAiBC,CAAS,GAG/CA,CACT,EAwBaC,EAAmB,CAC9BC,EACAP,IACe,CAEf,IAAIQ,EAAuCR,GAAS,mBAAqB,CAAC,EACtES,EAAmBT,GAAS,WAG5BU,EAAcT,EAAmBQ,EAAkBD,CAAiB,EA0NxE,MAAO,CACL,OA7Ma,MAAOG,EAAuBC,EAAqB,CAAC,IAAwB,CACzF,GAAI,CACF,MAAMC,EAAiB,CACrB,IAAK,CACH,KAAM,YACN,MAAOH,EAAYC,EAAKH,CAAiB,CAC3C,CACF,EAEMM,EAAaC,GAA4B,CAC7C,KAAM,CAAC,KAAM,CAAC,OAAQJ,EAAM,CAAC,CAAC,CAAC,EAAII,EACnC,OAAOR,EAAK,SAAS,CAAC,IAAAI,EAAK,KAAMjB,EAAc,gBAAgB,CAAC,CAClE,EAEM,CAAC,IAAKsB,CAAQ,EAAI,MAAMrB,EAC5BY,EACA,SACAV,EACAgB,EACA,CAAC,WAAY,KAAM,OAAQ,QAAS,GAAGD,CAAQ,EAC/C,CAAC,UAAAE,CAAS,CACZ,EAEA,OAAOE,CACT,OAAQC,EAAO,CACb,MAAAV,EAAK,SAAS,CAAC,MAAAU,EAAO,KAAMvB,EAAc,cAAc,CAAC,EACnDuB,CACR,CACF,EAkLE,gBAhLsB,MAAOC,EAAeN,EAAqB,CAAC,IAAwB,CAC1F,GAAI,CACF,MAAMC,EAAiB,CACrB,MAAO,CACL,KAAM,MACN,MAAOK,CACT,CACF,EAEMJ,EAAaC,GAA4B,CAC7C,KAAM,CAAC,KAAM,CAAC,gBAAiBJ,EAAM,CAAC,CAAC,CAAC,EAAII,EAC5C,OAAOR,EAAK,SAAS,CAAC,IAAAI,EAAK,KAAMjB,EAAc,mBAAmB,CAAC,CACrE,EAEM,CAAC,IAAKsB,CAAQ,EAAI,MAAMrB,EAC5BY,EACA,kBACAV,EACAgB,EACA,CAAC,WAAY,KAAM,OAAQ,QAAS,GAAGD,CAAQ,EAC/C,CAAC,UAAAE,CAAS,CACZ,EAEA,OAAOE,CACT,OAAQC,EAAO,CACb,MAAAV,EAAK,SAAS,CAAC,MAAAU,EAAO,KAAMvB,EAAc,iBAAiB,CAAC,EACtDuB,CACR,CACF,EAqJE,UAnJgB,MAAOC,EAAeN,EAAqB,CAAC,IAAwB,CACpF,GAAI,CACF,MAAMC,EAAiB,CACrB,MAAO,CACL,KAAM,MACN,MAAOK,CACT,CACF,EAEMJ,EAAaC,GAA4B,CAC7C,KAAM,CAAC,KAAM,CAAC,UAAWJ,EAAM,CAAC,CAAC,CAAC,EAAII,EACtC,OAAOR,EAAK,SAAS,CAAC,IAAAI,EAAK,KAAMjB,EAAc,mBAAmB,CAAC,CACrE,EAEM,CAAC,IAAKyB,CAAU,EAAI,MAAMxB,EAC9BY,EACA,YACAV,EACAgB,EACA,CAAC,WAAY,KAAM,OAAQ,QAAS,GAAGD,CAAQ,EAC/C,CAAC,UAAAE,CAAS,CACZ,EAEA,OAAOK,CACT,OAAQF,EAAO,CACb,MAAAV,EAAK,SAAS,CAAC,MAAAU,EAAO,KAAMvB,EAAc,iBAAiB,CAAC,EACtDuB,CACR,CACF,EAwHE,qBAtH2B,MAAOC,EAAeN,EAAqB,CAAC,IAAwB,CAC/F,GAAI,CACF,MAAMC,EAAiB,CACrB,MAAO,CACL,KAAM,MACN,MAAOK,CACT,CACF,EAEMJ,EAAaC,GAA4B,CAC7C,KAAM,CAAC,KAAM,CAAC,qBAAsBJ,EAAM,CAAC,CAAC,CAAC,EAAII,EACjD,OAAOR,EAAK,SAAS,CACnB,IAAAI,EACA,KAAMjB,EAAc,sBACtB,CAAC,CACH,EAEM,CAAC,IAAKyB,CAAU,EAAI,MAAMxB,EAC9BY,EACA,uBACAV,EACAgB,EACA,CAAC,WAAY,KAAM,OAAQ,QAAS,GAAGD,CAAQ,EAC/C,CAAC,UAAAE,CAAS,CACZ,EAEA,OAAOK,CACT,OAAQF,EAAO,CACb,MAAAV,EAAK,SAAS,CAAC,MAAAU,EAAO,KAAMvB,EAAc,oBAAoB,CAAC,EACzDuB,CACR,CACF,EAwFE,QAtFc,MAAOL,EAAqB,CAAC,IAA0B,CACrE,MAAMQ,EAAyBb,EAAK,SAAS,WAAY,CAAC,CAAC,EACrDc,EAAuBd,EAAK,SAAS,cAAe,CAAC,EACrDe,EAAc,KAAK,IAAI,EAE7B,GAAGF,EAAY,QAAUE,EAAMD,EAC7B,aAAMd,EAAK,SAAS,CAAC,KAAMa,EAAa,KAAM1B,EAAc,gBAAgB,CAAC,EACtE0B,EAGT,GAAI,CACF,MAAMP,EAAiB,CACrB,KAAM,CACJ,KAAM,SACN,MAAO,CACT,EACA,OAAQ,CACN,KAAM,MACN,MAAO,EACT,EACA,GAAI,CACF,KAAM,MACN,MAAO,EACT,CACF,EAEMC,EAAaC,GAA4B,CAC7C,KAAM,CAAC,KAAM,CAAC,QAAAQ,CAAO,CAAC,EAAIR,EAC1B,OAAOR,EAAK,SAAS,CACnB,KAAMgB,EACN,KAAM7B,EAAc,gBACtB,CAAC,CACH,EAEM,CAAC,KAAM8B,CAAQ,EAAI,MAAM5B,EAC7BW,EACA,OACAV,EACAgB,EACA,CAAC,WAAY,KAAM,OAAQ,QAAS,GAAGD,CAAQ,EAC/C,CAAC,UAAAE,CAAS,CACZ,EAEA,OAAOU,CACT,OAAQP,EAAO,CACb,MAAAV,EAAK,SAAS,CAAC,MAAAU,EAAO,KAAMvB,EAAc,gBAAgB,CAAC,EACrDuB,CACR,CACF,EAuCE,UArCgB,MAAON,EAAuBC,EAAqB,CAAC,IAAwB,CAC5F,GAAI,CACF,MAAMC,EAAiB,CACrB,IAAK,CACH,KAAM,YACN,MAAOH,EAAYC,EAAKH,CAAiB,CAC3C,CACF,EAEMM,EAAaC,GAA4B,CAC7C,KAAM,CAAC,KAAM,CAAC,UAAWJ,EAAM,CAAC,CAAC,CAAC,EAAII,EACtC,OAAOR,EAAK,SAAS,CAAC,IAAAI,EAAK,KAAMjB,EAAc,mBAAmB,CAAC,CACrE,EAEM,CAAC,IAAK+B,CAAU,EAAI,MAAM9B,EAC9BY,EACA,YACAV,EACAgB,EACA,CAAC,WAAY,KAAM,OAAQ,QAAS,GAAGD,CAAQ,EAC/C,CAAC,UAAAE,CAAS,CACZ,EAEA,OAAOW,CACT,OAAQR,EAAO,CACb,MAAAV,EAAK,SAAS,CAAC,MAAAU,EAAO,KAAMvB,EAAc,iBAAiB,CAAC,EACtDuB,CACR,CACF,EAUE,iBA9NwBS,GAAwE,CAChGjB,EAAmBiB,EACnBhB,EAAcT,EAAmBQ,EAAkBD,CAAiB,CACtE,EA4NE,wBA1N+BR,GAAqC,CACpEQ,EAAoB,CAAC,GAAGA,EAAmB,GAAGR,CAAO,EACrDU,EAAcT,EAAmBQ,EAAkBD,CAAiB,CACtE,CAwNA,CACF",
  "names": ["validateTagInput", "TAG_CONSTANTS", "appMutation", "appQuery", "DATA_TYPE", "defaultTagValidator", "input", "options", "createTagValidator", "customAdapter", "validatorOptions", "mergedOptions", "validated", "createTagActions", "flux", "tagAdapterOptions", "customTagAdapter", "validateTag", "tag", "tagProps", "queryVariables", "onSuccess", "data", "addedTag", "error", "tagId", "deletedTag", "initialTags", "cacheExpires", "now", "getTags", "tagsList", "updatedTag", "adapter"]
}


package/lib/actions/userActions/userActions.d.ts

@@ -0,0 +1,131 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { PersonaType } from '../../adapters/personaAdapter/personaAdapter';
+import type { User } from '../../adapters/userAdapter/userAdapter';
+import type { SessionType } from '../../utils/api';
+import type { BaseAdapterOptions } from '../../utils/validatorFactory';
+export interface UserAdapterOptions extends BaseAdapterOptions {
+}
+export interface PersonaAdapterOptions extends BaseAdapterOptions {
+}
+export interface UserActionsOptions {
+    readonly userAdapter?: (input: unknown, options?: UserAdapterOptions) => any;
+    readonly personaAdapter?: (input: unknown, options?: PersonaAdapterOptions) => any;
+    readonly userAdapterOptions?: UserAdapterOptions;
+    readonly personaAdapterOptions?: PersonaAdapterOptions;
+}
+export interface UserApiResultsType {
+    readonly users: {
+        readonly activeCount?: number;
+        readonly add?: Partial<User>;
+        readonly confirmCode?: boolean;
+        readonly deactivate?: Partial<User>;
+        readonly forgotPassword?: boolean;
+        readonly itemById?: Partial<User>;
+        readonly itemBySession?: Partial<User>;
+        readonly itemByToken?: Partial<User>;
+        readonly itemByUsername?: Partial<User>;
+        readonly list?: User[];
+        readonly listByConnection?: User[];
+        readonly listByLatest?: User[];
+        readonly listByReactions?: User[];
+        readonly listByTags?: User[];
+        readonly refreshSession?: SessionType;
+        readonly remove?: Partial<User>;
+        readonly resetPassword?: boolean;
+        readonly session?: Partial<User>;
+        readonly signIn?: Partial<User>;
+        readonly signUp?: Partial<User>;
+        readonly update?: Partial<User>;
+        readonly updatePassword?: Partial<boolean>;
+        readonly updatePersona?: Partial<PersonaType>;
+    };
+}
+export interface userActions {
+    add: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;
+    confirmCode: (type: 'email' | 'phone', code: number) => Promise<boolean>;
+    remove: (userId: string) => Promise<User>;
+    session: (userProps?: string[]) => Promise<User>;
+    itemById: (userId: string, userProps?: string[]) => Promise<User>;
+    listByLatest: (username?: string, from?: number, to?: number, userProps?: string[]) => Promise<User[]>;
+    listByConnection: (userId: string, from?: number, to?: number, userProps?: string[]) => Promise<User[]>;
+    listByReactions: (username: string, reactionNames: string[], from?: number, to?: number, profileProps?: string[]) => Promise<User[]>;
+    listByTags: (username: string, tagNames: string[], from?: number, to?: number, profileProps?: string[]) => Promise<User[]>;
+    isLoggedIn: () => boolean;
+    refreshSession: (token?: string, expires?: number) => Promise<SessionType>;
+    signIn: (username: string, password: string, expires?: number) => Promise<SessionType>;
+    signOut: () => Promise<boolean>;
+    confirmSignUp: (code: string, type: 'email' | 'phone') => Promise<boolean>;
+    forgotPassword: (username: string) => Promise<boolean>;
+    resetPassword: (username: string, password: string, code: string, type: 'email' | 'phone') => Promise<boolean>;
+    updatePassword: (password: string, newPassword: string) => Promise<boolean>;
+    updateUser: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;
+    updatePersona: (personaInput: Partial<PersonaType>) => Promise<PersonaType>;
+    signUp: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;
+    updateUserAdapter: (adapter: (input: unknown, options?: UserAdapterOptions) => any) => void;
+    updatePersonaAdapter: (adapter: (input: unknown, options?: PersonaAdapterOptions) => any) => void;
+    updateUserAdapterOptions: (options: UserAdapterOptions) => void;
+    updatePersonaAdapterOptions: (options: PersonaAdapterOptions) => void;
+}
+/**
+ * Factory function to create userActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const userActions = createUserActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customUserAdapter = (input: unknown, options?: UserAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   if (input.email && !input.email.includes('@company.com')) {
+ *     throw new Error('Only company emails allowed');
+ *   }
+ *   return input;
+ * };
+ *
+ * const userActions = createUserActions(flux, {
+ *   userAdapter: customUserAdapter
+ * });
+ *
+ * @example
+ * // Configuration-based adapters
+ * const userActions = createUserActions(flux, {
+ *   userAdapterOptions: {
+ *     strict: true,
+ *     environment: 'production'
+ *   }
+ * });
+ *
+ * @example
+ * // Runtime adapter updates
+ * userActions.updateUserAdapter(customUserAdapter);
+ *
+ * @example
+ * // Complex adapter with business logic
+ * const businessUserAdapter = (input: unknown, options?: UserAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   const user = input as any;
+ *
+ *   // Add business-specific validation
+ *   if (user.userAccess > 5) {
+ *     throw new Error('User access level too high');
+ *   }
+ *
+ *   // Add computed fields
+ *   return {
+ *     ...user,
+ *     fullName: `${user.first || ''} ${user.last || ''}`.trim(),
+ *     isAdmin: user.userAccess >= 3
+ *   };
+ * };
+ *
+ * const userActions = createUserActions(flux, {
+ *   userAdapter: businessUserAdapter,
+ *   userAdapterOptions: {
+ *     strict: true,
+ *     environment: 'production'
+ *   }
+ * });
+ */
+export declare const createUserActions: (flux: FluxFramework, options?: UserActionsOptions) => userActions;

package/lib/actions/userActions/userActions.js

@@ -0,0 +1,2 @@
+import{DateTime as y}from"luxon";import{validatePersonaInput as A}from"../../adapters/personaAdapter/personaAdapter";import{validateUserInput as b}from"../../adapters/userAdapter/userAdapter";import{USER_CONSTANTS as d}from"../../stores/userStore";import{appMutation as P,publicMutation as l,refreshSession as S}from"../../utils/api";import{createBaseActions as g}from"../../utils/baseActionFactory";const m="users",f=(r,p)=>{const i=b(r);if(p?.strict&&!i.username)throw new Error("Username is required in strict mode");return i},I=(r,p)=>A(r),Q=(r,p)=>{const i=g(r,f,{adapter:p?.userAdapter,adapterOptions:p?.userAdapterOptions}),c=g(r,I,{adapter:p?.personaAdapter,adapterOptions:p?.personaAdapterOptions});return{add:async(e,s=[])=>{const t={user:{type:"UserInput",value:i.validator(e)}},n=o=>{const{users:{add:u={}}}=o;return r.dispatch({user:u,type:d.ADD_ITEM_SUCCESS})},{users:{add:a={}}}=await l(r,"add",m,t,s||["added","address","dob","city","country","gender","imageUrl","latitude","longitude","mailingList","modified","state","tags {id, name, tagId}","thumbUrl","userAccess","userId","username"],{onSuccess:n});return r.dispatch({user:a,type:d.ADD_ITEM_SUCCESS}),a},confirmCode:async(e,s)=>!0,remove:async e=>({}),session:async(e=[])=>({}),itemById:async(e,s=[])=>({}),listByLatest:async(e="",s=0,t=10,n=[])=>[],listByConnection:async(e,s=0,t=10,n=[])=>[],listByReactions:async(e,s,t=0,n=10,a=[])=>[],listByTags:async(e,s,t=0,n=10,a=[])=>[],isLoggedIn:()=>{const e=r.getState("user.session.expires");if(!e)return!1;const s=y.fromMillis(e);return Math.round(s.diff(y.local(),"minutes").toObject().minutes)>0},refreshSession:async(e,s=15)=>(await S(r,e,s))?.refreshSession||{},signIn:async(e,s,t=15)=>{const n={expires:{type:"Int",value:t},password:{type:"String!",value:s},username:{type:"String!",value:e}},a=(o={})=>{const U=o?.users?.signIn||{};return r.dispatch({session:U,type:d.SIGN_IN_SUCCESS})};try{return await l(r,"signIn",m,n,["expires","issued","token","userId","username"],{onSuccess:a}),r.getState("user.session")||{}}catch(o){throw r.dispatch({error:o,type:d.SIGN_IN_ERROR}),o}},signOut:async()=>!0,confirmSignUp:async(e,s)=>!0,forgotPassword:async e=>!0,resetPassword:async(e,s,t,n)=>!0,updatePassword:async(e,s)=>!0,updateUser:async(e,s=[])=>{const t={user:{type:"UserUpdateInput!",value:i.validator(e)}},n=(o={})=>{const{users:{update:u={}}}=o;return r.dispatch({user:u,type:d.UPDATE_ITEM_SUCCESS})},{user:a}=await P(r,"update",m,t,["added","address","birthdate","city","country","gender","imageCount","imageUrl","latitude","longitude","mailingList","modified","state","tags {id, name, tagId}","thumbUrl","userAccess","userId","username",...s],{onSuccess:n});return a},updatePersona:async e=>{const s={persona:{type:"PersonaUpdateInput!",value:c.validator(e)}},t=(a={})=>{const{users:{updatePersona:o={}}}=a;return r.dispatch({persona:o,type:d.UPDATE_PERSONA_SUCCESS})},{persona:n}=await P(r,"updatePersona",m,s,[],{onSuccess:t});return n},signUp:async(e,s=[])=>{const t={user:{type:"UserInput!",value:i.validator(e)}},n=o=>{const{users:{signUp:u={}}}=o;return r.dispatch({user:u,type:d.SIGN_UP_SUCCESS})},{users:{signUp:a={}}}=await l(r,"signUp",m,t,["added","city","country","dob","firstName","gender","imageCount","imageUrl","latitude","lastName","longitude","mailingList","modified","name","state","tags {id, name, tagId}","thumbUrl","userAccess","userId","username",...s],{onSuccess:n});return a},updateUserAdapter:i.updateAdapter,updatePersonaAdapter:c.updateAdapter,updateUserAdapterOptions:i.updateOptions,updatePersonaAdapterOptions:c.updateOptions}};export{Q as createUserActions};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/userActions/userActions.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 {DateTime} from 'luxon';\n\nimport {validatePersonaInput} from '../../adapters/personaAdapter/personaAdapter';\nimport {validateUserInput} from '../../adapters/userAdapter/userAdapter';\nimport {USER_CONSTANTS} from '../../stores/userStore';\nimport {appMutation, publicMutation, refreshSession} from '../../utils/api';\nimport {createBaseActions} from '../../utils/baseActionFactory';\n\nimport type {FluxAction, FluxFramework} from '@nlabs/arkhamjs';\nimport type {PersonaType} from '../../adapters/personaAdapter/personaAdapter';\nimport type {User} from '../../adapters/userAdapter/userAdapter';\nimport type {ApiResultsType, ReaktorDbCollection, SessionType} from '../../utils/api';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory';\n\nconst DATA_TYPE: ReaktorDbCollection = 'users';\n\nexport interface UserAdapterOptions extends BaseAdapterOptions {\n  // User-specific options can be added here\n}\n\nexport interface PersonaAdapterOptions extends BaseAdapterOptions {\n  // Persona-specific options can be added here\n}\n\nexport interface UserActionsOptions {\n  readonly userAdapter?: (input: unknown, options?: UserAdapterOptions) => any;\n  readonly personaAdapter?: (input: unknown, options?: PersonaAdapterOptions) => any;\n  readonly userAdapterOptions?: UserAdapterOptions;\n  readonly personaAdapterOptions?: PersonaAdapterOptions;\n}\n\nexport interface UserApiResultsType {\n  readonly users: {\n    readonly activeCount?: number;\n    readonly add?: Partial<User>;\n    readonly confirmCode?: boolean;\n    readonly deactivate?: Partial<User>;\n    readonly forgotPassword?: boolean;\n    readonly itemById?: Partial<User>;\n    readonly itemBySession?: Partial<User>;\n    readonly itemByToken?: Partial<User>;\n    readonly itemByUsername?: Partial<User>;\n    readonly list?: User[];\n    readonly listByConnection?: User[];\n    readonly listByLatest?: User[];\n    readonly listByReactions?: User[];\n    readonly listByTags?: User[];\n    readonly refreshSession?: SessionType;\n    readonly remove?: Partial<User>;\n    readonly resetPassword?: boolean;\n    readonly session?: Partial<User>;\n    readonly signIn?: Partial<User>;\n    readonly signUp?: Partial<User>;\n    readonly update?: Partial<User>;\n    readonly updatePassword?: Partial<boolean>;\n    readonly updatePersona?: Partial<PersonaType>;\n  };\n}\n\n// Default validation functions\nconst defaultUserValidator = (input: unknown, options?: UserAdapterOptions) => {\n  const validated = validateUserInput(input);\n\n  if(options?.strict && !validated.username) {\n    throw new Error('Username is required in strict mode');\n  }\n\n  return validated;\n};\n\nconst defaultPersonaValidator = (input: unknown, options?: PersonaAdapterOptions) => validatePersonaInput(input);\n\nexport interface userActions {\n  add: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;\n  confirmCode: (type: 'email' | 'phone', code: number) => Promise<boolean>;\n  remove: (userId: string) => Promise<User>;\n  session: (userProps?: string[]) => Promise<User>;\n  itemById: (userId: string, userProps?: string[]) => Promise<User>;\n  listByLatest: (username?: string, from?: number, to?: number, userProps?: string[]) => Promise<User[]>;\n  listByConnection: (userId: string, from?: number, to?: number, userProps?: string[]) => Promise<User[]>;\n  listByReactions: (username: string, reactionNames: string[], from?: number, to?: number, profileProps?: string[]) => Promise<User[]>;\n  listByTags: (username: string, tagNames: string[], from?: number, to?: number, profileProps?: string[]) => Promise<User[]>;\n  isLoggedIn: () => boolean;\n  refreshSession: (token?: string, expires?: number) => Promise<SessionType>;\n  signIn: (username: string, password: string, expires?: number) => Promise<SessionType>;\n  signOut: () => Promise<boolean>;\n  confirmSignUp: (code: string, type: 'email' | 'phone') => Promise<boolean>;\n  forgotPassword: (username: string) => Promise<boolean>;\n  resetPassword: (username: string, password: string, code: string, type: 'email' | 'phone') => Promise<boolean>;\n  updatePassword: (password: string, newPassword: string) => Promise<boolean>;\n  updateUser: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;\n  updatePersona: (personaInput: Partial<PersonaType>) => Promise<PersonaType>;\n  signUp: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;\n  updateUserAdapter: (adapter: (input: unknown, options?: UserAdapterOptions) => any) => void;\n  updatePersonaAdapter: (adapter: (input: unknown, options?: PersonaAdapterOptions) => any) => void;\n  updateUserAdapterOptions: (options: UserAdapterOptions) => void;\n  updatePersonaAdapterOptions: (options: PersonaAdapterOptions) => void;\n}\n\n/**\n * Factory function to create userActions with enhanced adapter injection capabilities.\n * Custom adapters are merged with default behavior, allowing partial overrides.\n *\n * @example\n * // Basic usage with default adapters\n * const userActions = createUserActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customUserAdapter = (input: unknown, options?: UserAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.email && !input.email.includes('@company.com')) {\n *     throw new Error('Only company emails allowed');\n *   }\n *   return input;\n * };\n *\n * const userActions = createUserActions(flux, {\n *   userAdapter: customUserAdapter\n * });\n *\n * @example\n * // Configuration-based adapters\n * const userActions = createUserActions(flux, {\n *   userAdapterOptions: {\n *     strict: true,\n *     environment: 'production'\n *   }\n * });\n *\n * @example\n * // Runtime adapter updates\n * userActions.updateUserAdapter(customUserAdapter);\n *\n * @example\n * // Complex adapter with business logic\n * const businessUserAdapter = (input: unknown, options?: UserAdapterOptions) => {\n *   // input is already validated by default adapter\n *   const user = input as any;\n *\n *   // Add business-specific validation\n *   if (user.userAccess > 5) {\n *     throw new Error('User access level too high');\n *   }\n *\n *   // Add computed fields\n *   return {\n *     ...user,\n *     fullName: `${user.first || ''} ${user.last || ''}`.trim(),\n *     isAdmin: user.userAccess >= 3\n *   };\n * };\n *\n * const userActions = createUserActions(flux, {\n *   userAdapter: businessUserAdapter,\n *   userAdapterOptions: {\n *     strict: true,\n *     environment: 'production'\n *   }\n * });\n */\nexport const createUserActions = (\n  flux: FluxFramework,\n  options?: UserActionsOptions\n): userActions => {\n  // Create base actions for user validation\n  const userBase = createBaseActions(flux, defaultUserValidator, {\n    adapter: options?.userAdapter,\n    adapterOptions: options?.userAdapterOptions\n  });\n\n  // Create base actions for persona validation\n  const personaBase = createBaseActions(flux, defaultPersonaValidator, {\n    adapter: options?.personaAdapter,\n    adapterOptions: options?.personaAdapterOptions\n  });\n\n  // Action implementations using the base utilities\n  const add = async (userInput: Partial<User>, userProps: string[] = []): Promise<User> => {\n    const queryVariables = {\n      user: {\n        type: 'UserInput',\n        value: userBase.validator(userInput)\n      }\n    };\n\n    const onSuccess = (data: UserApiResultsType): Promise<FluxAction> => {\n      const {users: {add = {}}} = data;\n      return flux.dispatch({\n        user: add,\n        type: USER_CONSTANTS.ADD_ITEM_SUCCESS\n      });\n    };\n\n    const {users: {add: user = {}}} = await publicMutation<UserApiResultsType>(\n      flux,\n      'add',\n      DATA_TYPE,\n      queryVariables,\n      userProps || [\n        'added',\n        'address',\n        'dob',\n        'city',\n        'country',\n        'gender',\n        'imageUrl',\n        'latitude',\n        'longitude',\n        'mailingList',\n        'modified',\n        'state',\n        'tags {id, name, tagId}',\n        'thumbUrl',\n        'userAccess',\n        'userId',\n        'username'\n      ],\n      {onSuccess}\n    );\n\n    flux.dispatch({user, type: USER_CONSTANTS.ADD_ITEM_SUCCESS});\n    return user as User;\n  };\n\n  const signUp = async (userInput: Partial<User>, userProps: string[] = []): Promise<User> => {\n    const queryVariables = {\n      user: {\n        type: 'UserInput!',\n        value: userBase.validator(userInput)\n      }\n    };\n\n    const onSuccess = (data: UserApiResultsType): Promise<FluxAction> => {\n      const {users: {signUp = {}}} = data;\n      return flux.dispatch({\n        user: signUp,\n        type: USER_CONSTANTS.SIGN_UP_SUCCESS\n      });\n    };\n\n    const {users: {signUp: user = {}}} = await publicMutation<UserApiResultsType>(\n      flux,\n      'signUp',\n      DATA_TYPE,\n      queryVariables,\n      [\n        'added',\n        'city',\n        'country',\n        'dob',\n        'firstName',\n        'gender',\n        'imageCount',\n        'imageUrl',\n        'latitude',\n        'lastName',\n        'longitude',\n        'mailingList',\n        'modified',\n        'name',\n        'state',\n        'tags {id, name, tagId}',\n        'thumbUrl',\n        'userAccess',\n        'userId',\n        'username',\n        ...userProps\n      ],\n      {onSuccess}\n    );\n    return user as User;\n  };\n\n  const updateUser = async (userInput: Partial<User>, userProps: string[] = []): Promise<User> => {\n    const queryVariables = {\n      user: {\n        type: 'UserUpdateInput!',\n        value: userBase.validator(userInput)\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const {users: {update = {}}} = data as unknown as UserApiResultsType;\n      return flux.dispatch({\n        user: update,\n        type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS\n      });\n    };\n\n    const {user} = await appMutation(\n      flux,\n      'update',\n      DATA_TYPE,\n      queryVariables,\n      [\n        'added',\n        'address',\n        'birthdate',\n        'city',\n        'country',\n        'gender',\n        'imageCount',\n        'imageUrl',\n        'latitude',\n        'longitude',\n        'mailingList',\n        'modified',\n        'state',\n        'tags {id, name, tagId}',\n        'thumbUrl',\n        'userAccess',\n        'userId',\n        'username',\n        ...userProps\n      ],\n      {onSuccess}\n    );\n    return user as User;\n  };\n\n  const updatePersona = async (personaInput: Partial<PersonaType>): Promise<PersonaType> => {\n    const queryVariables = {\n      persona: {\n        type: 'PersonaUpdateInput!',\n        value: personaBase.validator(personaInput)\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const {users: {updatePersona = {}}} = data as unknown as UserApiResultsType;\n      return flux.dispatch({persona: updatePersona, type: USER_CONSTANTS.UPDATE_PERSONA_SUCCESS});\n    };\n\n    const {persona} = await appMutation(flux, 'updatePersona', DATA_TYPE, queryVariables, [], {onSuccess});\n    return persona as PersonaType;\n  };\n\n  // Placeholder implementations for other methods (you can add the full implementations)\n  const confirmCode = async (type: 'email' | 'phone', code: number): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const remove = async (userId: string): Promise<User> =>\n    // Implementation here\n    ({} as User)\n  ;\n\n  const session = async (userProps: string[] = []): Promise<User> =>\n    // Implementation here\n    ({} as User)\n  ;\n\n  const itemById = async (userId: string, userProps: string[] = []): Promise<User> =>\n    // Implementation here\n    ({} as User)\n  ;\n\n  const listByLatest = async (\n    username: string = '',\n    from: number = 0,\n    to: number = 10,\n    userProps: string[] = []\n  ): Promise<User[]> =>\n    // Implementation here\n    []\n  ;\n\n  const listByConnection = async (\n    userId: string,\n    from: number = 0,\n    to: number = 10,\n    userProps: string[] = []\n  ): Promise<User[]> =>\n    // Implementation here\n    []\n  ;\n\n  const listByReactions = async (\n    username: string,\n    reactionNames: string[],\n    from: number = 0,\n    to: number = 10,\n    profileProps: string[] = []\n  ): Promise<User[]> =>\n    // Implementation here\n    []\n  ;\n\n  const listByTags = async (\n    username: string,\n    tagNames: string[],\n    from: number = 0,\n    to: number = 10,\n    profileProps: string[] = []\n  ): Promise<User[]> =>\n    // Implementation here\n    []\n  ;\n\n  const isLoggedIn = (): boolean => {\n    const expires: number = flux.getState('user.session.expires') as number;\n\n    if(!expires) {\n      return false;\n    }\n\n    const expireDate = DateTime.fromMillis(expires);\n    const expiredDiff: number = Math.round(expireDate.diff(DateTime.local(), 'minutes').toObject().minutes);\n\n    return expiredDiff > 0;\n  };\n\n  const refreshSessionAction = async (token?: string, expires: number = 15): Promise<SessionType> => {\n    const result = await refreshSession(flux, token, expires);\n    return (result?.refreshSession || {}) as SessionType;\n  };\n\n  const signIn = async (username: string, password: string, expires: number = 15): Promise<SessionType> => {\n    const queryVariables = {\n      expires: {\n        type: 'Int',\n        value: expires\n      },\n      password: {\n        type: 'String!',\n        value: password\n      },\n      username: {\n        type: 'String!',\n        value: username\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}): Promise<FluxAction> => {\n      // Robustly extract users from the response\n      const users = (data as any)?.users;\n      const sessionData = users?.signIn || {};\n      return flux.dispatch({\n        session: sessionData,\n        type: USER_CONSTANTS.SIGN_IN_SUCCESS\n      });\n    };\n\n    try {\n      // publicMutation returns the result of onSuccess callback, which is a FluxAction\n      await publicMutation<UserApiResultsType>(\n        flux,\n        'signIn',\n        DATA_TYPE,\n        queryVariables,\n        ['expires', 'issued', 'token', 'userId', 'username'],\n        {onSuccess}\n      );\n\n      // Return the session data from the flux state since onSuccess already processed it\n      const sessionData = flux.getState('user.session') || {};\n      return sessionData as SessionType;\n    } catch(error) {\n      flux.dispatch({error, type: USER_CONSTANTS.SIGN_IN_ERROR});\n      throw error;\n    }\n  };\n\n  const signOut = async (): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const confirmSignUp = async (code: string, type: 'email' | 'phone'): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const forgotPassword = async (username: string): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const resetPassword = async (\n    username: string,\n    password: string,\n    code: string,\n    type: 'email' | 'phone'\n  ): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const updatePassword = async (password: string, newPassword: string): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  // Return the actions object with update functions from base actions\n  return {\n    add,\n    confirmCode,\n    remove,\n    session,\n    itemById,\n    listByLatest,\n    listByConnection,\n    listByReactions,\n    listByTags,\n    isLoggedIn,\n    refreshSession: refreshSessionAction,\n    signIn,\n    signOut,\n    confirmSignUp,\n    forgotPassword,\n    resetPassword,\n    updatePassword,\n    updateUser,\n    updatePersona,\n    signUp,\n    updateUserAdapter: userBase.updateAdapter,\n    updatePersonaAdapter: personaBase.updateAdapter,\n    updateUserAdapterOptions: userBase.updateOptions,\n    updatePersonaAdapterOptions: personaBase.updateOptions\n  };\n};\n"],
  "mappings": "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",
  "names": ["DateTime", "validatePersonaInput", "validateUserInput", "USER_CONSTANTS", "appMutation", "publicMutation", "refreshSession", "createBaseActions", "DATA_TYPE", "defaultUserValidator", "input", "options", "validated", "defaultPersonaValidator", "createUserActions", "flux", "userBase", "personaBase", "userInput", "userProps", "queryVariables", "onSuccess", "data", "add", "user", "type", "code", "userId", "username", "from", "to", "reactionNames", "profileProps", "tagNames", "expires", "expireDate", "token", "password", "sessionData", "error", "newPassword", "update", "personaInput", "updatePersona", "persona", "signUp"]
}


package/lib/actions/websocketActions/websocketActions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import Sockette from 'sockette';
+import type { FluxFramework } from '@nlabs/arkhamjs';
+interface WebSocketMessage {
+    type: string;
+    payload?: Record<string, unknown>;
+}
+export interface WebsocketActions {
+    wsSend: (message: WebSocketMessage) => void;
+    onReceive: (event: any) => void;
+    onClose: (event: any) => void;
+    onError: (event: any) => void;
+    onOpen: (event: any) => void;
+    wsInit: (token?: string) => Sockette | null;
+}
+/**
+ * Factory function to create WebsocketActions.
+ *
+ * @example
+ * // Basic usage
+ * const websocketActions = createWebsocketActions(flux);
+ *
+ * @example
+ * // Initialize websocket connection
+ * const ws = websocketActions.wsInit(token);
+ */
+export declare const createWebsocketActions: (flux: FluxFramework) => WebsocketActions;
+export {};

package/lib/actions/websocketActions/websocketActions.js

@@ -0,0 +1,2 @@
+import g from"sockette";import{Config as l}from"../../config";import{WEBSOCKET_CONSTANTS as a}from"../../stores/websocketStore";const y=n=>{let o;const k=e=>{o&&o.json(e)},r=e=>{const{data:t,timeStamp:s}=e,c=JSON.parse(t);n.dispatch({data:c,timestamp:s,type:a.MESSAGE})},i=e=>{const{timeStamp:t}=e;n.dispatch({timestamp:t,type:a.CLOSE})},m=e=>{const{timeStamp:t}=e;n.dispatch({timestamp:t,type:a.ERROR})},p=e=>{const{timeStamp:t}=e;n.dispatch({timestamp:t,type:a.OPEN})};return{wsSend:k,onReceive:r,onClose:i,onError:m,onOpen:p,wsInit:e=>{if(o)return o;const t=l.get("app.urls.websocket"),s=e||n.getState("user.session.token");if(s){const c=`${t}?token=${s}`;return o=new g(c,{maxAttempts:5,onclose:i,onerror:m,onmessage:r,onopen:p,timeout:6e4}),o}return null}}};export{y as createWebsocketActions};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2FjdGlvbnMvd2Vic29ja2V0QWN0aW9ucy93ZWJzb2NrZXRBY3Rpb25zLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOS1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IFNvY2tldHRlIGZyb20gJ3NvY2tldHRlJztcblxuaW1wb3J0IHtDb25maWd9IGZyb20gJy4uLy4uL2NvbmZpZyc7XG5pbXBvcnQge1dFQlNPQ0tFVF9DT05TVEFOVFN9IGZyb20gJy4uLy4uL3N0b3Jlcy93ZWJzb2NrZXRTdG9yZSc7XG5cbmltcG9ydCB0eXBlIHtGbHV4RnJhbWV3b3JrfSBmcm9tICdAbmxhYnMvYXJraGFtanMnO1xuXG5pbnRlcmZhY2UgV2ViU29ja2V0TWVzc2FnZSB7XG4gIHR5cGU6IHN0cmluZztcbiAgcGF5bG9hZD86IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFdlYnNvY2tldEFjdGlvbnMge1xuICB3c1NlbmQ6IChtZXNzYWdlOiBXZWJTb2NrZXRNZXNzYWdlKSA9PiB2b2lkO1xuICBvblJlY2VpdmU6IChldmVudDogYW55KSA9PiB2b2lkO1xuICBvbkNsb3NlOiAoZXZlbnQ6IGFueSkgPT4gdm9pZDtcbiAgb25FcnJvcjogKGV2ZW50OiBhbnkpID0+IHZvaWQ7XG4gIG9uT3BlbjogKGV2ZW50OiBhbnkpID0+IHZvaWQ7XG4gIHdzSW5pdDogKHRva2VuPzogc3RyaW5nKSA9PiBTb2NrZXR0ZSB8IG51bGw7XG59XG5cbi8qKlxuICogRmFjdG9yeSBmdW5jdGlvbiB0byBjcmVhdGUgV2Vic29ja2V0QWN0aW9ucy5cbiAqXG4gKiBAZXhhbXBsZVxuICogLy8gQmFzaWMgdXNhZ2VcbiAqIGNvbnN0IHdlYnNvY2tldEFjdGlvbnMgPSBjcmVhdGVXZWJzb2NrZXRBY3Rpb25zKGZsdXgpO1xuICpcbiAqIEBleGFtcGxlXG4gKiAvLyBJbml0aWFsaXplIHdlYnNvY2tldCBjb25uZWN0aW9uXG4gKiBjb25zdCB3cyA9IHdlYnNvY2tldEFjdGlvbnMud3NJbml0KHRva2VuKTtcbiAqL1xuZXhwb3J0IGNvbnN0IGNyZWF0ZVdlYnNvY2tldEFjdGlvbnMgPSAoZmx1eDogRmx1eEZyYW1ld29yayk6IFdlYnNvY2tldEFjdGlvbnMgPT4ge1xuICBsZXQgd3M6IFNvY2tldHRlO1xuXG4gIGNvbnN0IHdzU2VuZCA9IChtZXNzYWdlOiBXZWJTb2NrZXRNZXNzYWdlKSA9PiB7XG4gICAgY29uc29sZS5sb2coJ3dlYnNvY2tldHM6Om9uT3Blbjo6bWVzc2FnZScsIHt3cywgbWVzc2FnZX0pO1xuICAgIGlmKHdzKSB7XG4gICAgICB3cy5qc29uKG1lc3NhZ2UpO1xuICAgIH1cbiAgfTtcblxuICBjb25zdCBvblJlY2VpdmUgPSAoZXZlbnQ6IGFueSkgPT4ge1xuICAgIGNvbnN0IHtkYXRhOiBldmVudERhdGEsIHRpbWVTdGFtcDogdGltZXN0YW1wfSA9IGV2ZW50O1xuICAgIGNvbnN0IGRhdGEgPSBKU09OLnBhcnNlKGV2ZW50RGF0YSk7XG4gICAgY29uc29sZS5sb2coJ3dlYnNvY2tldHM6Om9uUmVjaWV2ZTo6ZGF0YScsIGRhdGEpO1xuICAgIGZsdXguZGlzcGF0Y2goe2RhdGEsIHRpbWVzdGFtcCwgdHlwZTogV0VCU09DS0VUX0NPTlNUQU5UUy5NRVNTQUdFfSk7XG4gIH07XG5cbiAgY29uc3Qgb25DbG9zZSA9IChldmVudDogYW55KSA9PiB7XG4gICAgY29uc29sZS5sb2coJ3dlYnNvY2tldHM6Om9uT3Blbjo6bWVzc2FnZScsIGV2ZW50KTtcbiAgICBjb25zdCB7dGltZVN0YW1wOiB0aW1lc3RhbXB9ID0gZXZlbnQ7XG4gICAgZmx1eC5kaXNwYXRjaCh7dGltZXN0YW1wLCB0eXBlOiBXRUJTT0NLRVRfQ09OU1RBTlRTLkNMT1NFfSk7XG4gIH07XG5cbiAgY29uc3Qgb25FcnJvciA9IChldmVudDogYW55KSA9PiB7XG4gICAgY29uc3Qge3RpbWVTdGFtcDogdGltZXN0YW1wfSA9IGV2ZW50O1xuICAgIGZsdXguZGlzcGF0Y2goe3RpbWVzdGFtcCwgdHlwZTogV0VCU09DS0VUX0NPTlNUQU5UUy5FUlJPUn0pO1xuICB9O1xuXG4gIGNvbnN0IG9uT3BlbiA9IChldmVudDogYW55KSA9PiB7XG4gICAgY29uc29sZS5sb2coJ3dlYnNvY2tldHM6Om9uT3Blbjo6ZXZlbnQnLCBldmVudCk7XG4gICAgY29uc3Qge3RpbWVTdGFtcDogdGltZXN0YW1wfSA9IGV2ZW50O1xuICAgIGZsdXguZGlzcGF0Y2goe3RpbWVzdGFtcCwgdHlwZTogV0VCU09DS0VUX0NPTlNUQU5UUy5PUEVOfSk7XG4gIH07XG5cbiAgY29uc3Qgd3NJbml0ID0gKHRva2VuPzogc3RyaW5nKTogU29ja2V0dGUgfCBudWxsID0+IHtcbiAgICBpZih3cykge1xuICAgICAgcmV0dXJuIHdzO1xuICAgIH1cblxuICAgIGNvbnN0IHdlYnNvY2tldFVybDogc3RyaW5nID0gQ29uZmlnLmdldCgnYXBwLnVybHMud2Vic29ja2V0Jyk7XG4gICAgY29uc3Qgc2Vzc2lvblRva2VuOiBzdHJpbmcgPSB0b2tlbiB8fCBmbHV4LmdldFN0YXRlKCd1c2VyLnNlc3Npb24udG9rZW4nKTtcblxuICAgIGlmKHNlc3Npb25Ub2tlbikge1xuICAgICAgY29uc3QgdXJsOiBzdHJpbmcgPSBgJHt3ZWJzb2NrZXRVcmx9P3Rva2VuPSR7c2Vzc2lvblRva2VufWA7XG5cbiAgICAgIHdzID0gbmV3IFNvY2tldHRlKHVybCwge1xuICAgICAgICBtYXhBdHRlbXB0czogNSxcbiAgICAgICAgb25jbG9zZTogb25DbG9zZSxcbiAgICAgICAgb25lcnJvcjogb25FcnJvcixcbiAgICAgICAgb25tZXNzYWdlOiBvblJlY2VpdmUsXG4gICAgICAgIG9ub3Blbjogb25PcGVuLFxuICAgICAgICB0aW1lb3V0OiA2MDAwMFxuICAgICAgfSk7XG5cbiAgICAgIHJldHVybiB3cztcbiAgICB9XG5cbiAgICByZXR1cm4gbnVsbDtcbiAgfTtcblxuICAvLyBSZXR1cm4gdGhlIGFjdGlvbnMgb2JqZWN0XG4gIHJldHVybiB7XG4gICAgd3NTZW5kLFxuICAgIG9uUmVjZWl2ZSxcbiAgICBvbkNsb3NlLFxuICAgIG9uRXJyb3IsXG4gICAgb25PcGVuLFxuICAgIHdzSW5pdFxuICB9O1xufTtcblxuIl0sCiAgIm1hcHBpbmdzIjogIkFBSUEsT0FBT0EsTUFBYyxXQUVyQixPQUFRLFVBQUFDLE1BQWEsZUFDckIsT0FBUSx1QkFBQUMsTUFBMEIsOEJBNkIzQixNQUFNQyxFQUEwQkMsR0FBMEMsQ0FDL0UsSUFBSUMsRUFFSixNQUFNQyxFQUFVQyxHQUE4QixDQUV6Q0YsR0FDREEsRUFBRyxLQUFLRSxDQUFPLENBRW5CLEVBRU1DLEVBQWFDLEdBQWUsQ0FDaEMsS0FBTSxDQUFDLEtBQU1DLEVBQVcsVUFBV0MsQ0FBUyxFQUFJRixFQUMxQ0csRUFBTyxLQUFLLE1BQU1GLENBQVMsRUFFakNOLEVBQUssU0FBUyxDQUFDLEtBQUFRLEVBQU0sVUFBQUQsRUFBVyxLQUFNVCxFQUFvQixPQUFPLENBQUMsQ0FDcEUsRUFFTVcsRUFBV0osR0FBZSxDQUU5QixLQUFNLENBQUMsVUFBV0UsQ0FBUyxFQUFJRixFQUMvQkwsRUFBSyxTQUFTLENBQUMsVUFBQU8sRUFBVyxLQUFNVCxFQUFvQixLQUFLLENBQUMsQ0FDNUQsRUFFTVksRUFBV0wsR0FBZSxDQUM5QixLQUFNLENBQUMsVUFBV0UsQ0FBUyxFQUFJRixFQUMvQkwsRUFBSyxTQUFTLENBQUMsVUFBQU8sRUFBVyxLQUFNVCxFQUFvQixLQUFLLENBQUMsQ0FDNUQsRUFFTWEsRUFBVU4sR0FBZSxDQUU3QixLQUFNLENBQUMsVUFBV0UsQ0FBUyxFQUFJRixFQUMvQkwsRUFBSyxTQUFTLENBQUMsVUFBQU8sRUFBVyxLQUFNVCxFQUFvQixJQUFJLENBQUMsQ0FDM0QsRUE2QkEsTUFBTyxDQUNMLE9BQUFJLEVBQ0EsVUFBQUUsRUFDQSxRQUFBSyxFQUNBLFFBQUFDLEVBQ0EsT0FBQUMsRUFDQSxPQWpDY0MsR0FBb0MsQ0FDbEQsR0FBR1gsRUFDRCxPQUFPQSxFQUdULE1BQU1ZLEVBQXVCaEIsRUFBTyxJQUFJLG9CQUFvQixFQUN0RGlCLEVBQXVCRixHQUFTWixFQUFLLFNBQVMsb0JBQW9CLEVBRXhFLEdBQUdjLEVBQWMsQ0FDZixNQUFNQyxFQUFjLEdBQUdGLENBQVksVUFBVUMsQ0FBWSxHQUV6RCxPQUFBYixFQUFLLElBQUlMLEVBQVNtQixFQUFLLENBQ3JCLFlBQWEsRUFDYixRQUFTTixFQUNULFFBQVNDLEVBQ1QsVUFBV04sRUFDWCxPQUFRTyxFQUNSLFFBQVMsR0FDWCxDQUFDLEVBRU1WLENBQ1QsQ0FFQSxPQUFPLElBQ1QsQ0FVQSxDQUNGIiwKICAibmFtZXMiOiBbIlNvY2tldHRlIiwgIkNvbmZpZyIsICJXRUJTT0NLRVRfQ09OU1RBTlRTIiwgImNyZWF0ZVdlYnNvY2tldEFjdGlvbnMiLCAiZmx1eCIsICJ3cyIsICJ3c1NlbmQiLCAibWVzc2FnZSIsICJvblJlY2VpdmUiLCAiZXZlbnQiLCAiZXZlbnREYXRhIiwgInRpbWVzdGFtcCIsICJkYXRhIiwgIm9uQ2xvc2UiLCAib25FcnJvciIsICJvbk9wZW4iLCAidG9rZW4iLCAid2Vic29ja2V0VXJsIiwgInNlc3Npb25Ub2tlbiIsICJ1cmwiXQp9Cg==

package/lib/adapters/arangoAdapter/arangoAdapter.d.ts

@@ -0,0 +1,20 @@
+export interface DocumentType {
+    _from?: string;
+    _id?: string;
+    _key?: string;
+    _oldRev?: string;
+    _rev?: string;
+    _to?: string;
+    added?: number;
+    id?: string;
+    modified?: number;
+    [key: string]: any;
+}
+export declare class ArangoValidationError extends Error {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare const validateDocumentInput: (doc: unknown) => DocumentType;
+export declare const formatDocumentOutput: (doc: DocumentType) => DocumentType;
+export declare const parseDocument: (doc: DocumentType) => DocumentType;
+export declare const removeEmptyKeys: <T extends Record<string, any>>(obj: T) => T;

package/lib/adapters/arangoAdapter/arangoAdapter.js

@@ -0,0 +1,2 @@
+import{parseArangoId as c,parseId as p,parseNum as d}from"@nlabs/utils";import{z as t}from"zod";class i extends Error{constructor(r,o){super(r);this.field=o;this.name="ArangoValidationError"}}const m=t.object({_from:t.string().optional(),_id:t.string().optional(),_key:t.string().optional(),_oldRev:t.string().optional(),_rev:t.string().optional(),_to:t.string().optional(),added:t.number().optional(),id:t.string().optional(),modified:t.number().optional()}).passthrough(),D=n=>{try{return m.parse(n)}catch(e){if(e instanceof t.ZodError){const r=e.issues.map(o=>`${o.path.join(".")}: ${o.message}`).join(", ");throw new i(`Document validation failed: ${r}`)}throw e}},T=n=>n,_=n=>{try{return u(n)}catch(e){throw e instanceof i?e:new i(`Document parsing failed: ${e instanceof Error?e.message:"Unknown error"}`)}},u=n=>{const{_id:e,_key:r,added:o,id:s,modified:a}=n;return f({...n,...(e||s)&&{id:c(e||s||"")},...r&&{_key:p(r||"")},...o!==void 0&&{added:d(o,13)},...a!==void 0&&{modified:d(a,13)}})},f=n=>{const e={};for(const[r,o]of Object.entries(n))o!=null&&o!==""&&(e[r]=o);return e};export{i as ArangoValidationError,T as formatDocumentOutput,_ as parseDocument,f as removeEmptyKeys,D as validateDocumentInput};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/adapters/contentAdapter/contentAdapter.d.ts

@@ -0,0 +1,31 @@
+export interface ContentType {
+    _id?: string;
+    _key?: string;
+    contentId?: string;
+    id?: string;
+    key: string;
+    locale: 'en' | 'es' | 'fr' | 'de' | 'pt' | 'it';
+    content: string;
+    description?: string;
+    category?: string;
+    isActive?: boolean;
+    userId?: string;
+    [key: string]: any;
+}
+export interface ContentInputType {
+    contentId?: string;
+    key: string;
+    locale?: 'en' | 'es' | 'fr' | 'de' | 'pt' | 'it';
+    content: string;
+    description?: string;
+    category?: string;
+    isActive?: boolean;
+    [key: string]: any;
+}
+export declare class ContentValidationError extends Error {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare const parseContent: (content: ContentType) => ContentType;
+export declare const parseContentInput: (content: ContentInputType) => ContentInputType;
+export declare const parseContentFromDb: (content: ContentType) => ContentType;

package/lib/adapters/contentAdapter/contentAdapter.js

@@ -0,0 +1,2 @@
+import{parseArangoId as f,parseId as l,parseString as r}from"@nlabs/utils";import{z as t}from"zod";import{parseDocument as C,removeEmptyKeys as b}from"../arangoAdapter/arangoAdapter";class m extends Error{constructor(n,s){super(n);this.field=s;this.name="ContentValidationError"}}const I=t.object({contentId:t.string().optional(),key:t.string().min(1,"Key is required").max(200,"Key must be less than 200 characters"),locale:t.enum(["en","es","fr","de","pt","it"],{message:"Locale must be one of: en, es, fr, de, pt, it"}),content:t.string().min(1,"Content is required").max(1e4,"Content must be less than 10000 characters"),description:t.string().max(500,"Description must be less than 500 characters").optional(),category:t.string().max(100,"Category must be less than 100 characters").optional(),isActive:t.boolean().optional(),userId:t.string().optional()}),x=t.object({contentId:t.string().optional(),key:t.string().min(1,"Key is required").max(200,"Key must be less than 200 characters"),locale:t.enum(["en","es","fr","de","pt","it"],{message:"Locale must be one of: en, es, fr, de, pt, it"}).optional(),content:t.string().min(1,"Content is required").max(1e4,"Content must be less than 10000 characters"),description:t.string().max(500,"Description must be less than 500 characters").optional(),category:t.string().max(100,"Category must be less than 100 characters").optional(),isActive:t.boolean().optional()}),A=o=>{try{return I.parse(o)}catch(e){if(e instanceof t.ZodError){const n=e.issues[0]?.path.join("."),s=e.issues[0]?.message||"Validation failed";throw new m(s,n)}throw e}},E=o=>{try{return x.parse(o)}catch(e){if(e instanceof t.ZodError){const n=e.issues[0]?.path.join("."),s=e.issues[0]?.message||"Validation failed";throw new m(s,n)}throw e}},T=o=>{const{_id:e,_key:n,contentId:s,id:i,key:g,locale:y,content:u,description:a,category:c,isActive:p,userId:d}=o,h={...C(o),...(n||s)&&{contentId:l(n||s||"")},...(e||i||n||s)&&{id:f(e||i||`content/${n||s}`)},key:r(g,200),locale:y,content:r(u,1e4),...a&&{description:r(a,500)},...c&&{category:r(c,100)},...p!==void 0&&{isActive:p},...d&&{userId:l(d)}};return b(h)},K=o=>T(o);export{m as ContentValidationError,A as parseContent,K as parseContentFromDb,E as parseContentInput};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/adapters/contentAdapter/contentAdapter.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 {parseArangoId, parseId, parseString} from '@nlabs/utils';\nimport {z} from 'zod';\n\nimport {parseDocument, removeEmptyKeys} from '../arangoAdapter/arangoAdapter';\n\nexport interface ContentType {\n  _id?: string;\n  _key?: string;\n  contentId?: string;\n  id?: string;\n  key: string;\n  locale: 'en' | 'es' | 'fr' | 'de' | 'pt' | 'it';\n  content: string;\n  description?: string;\n  category?: string;\n  isActive?: boolean;\n  userId?: string;\n  [key: string]: any;\n}\n\nexport interface ContentInputType {\n  contentId?: string;\n  key: string;\n  locale?: 'en' | 'es' | 'fr' | 'de' | 'pt' | 'it';\n  content: string;\n  description?: string;\n  category?: string;\n  isActive?: boolean;\n  [key: string]: any;\n}\n\nexport class ContentValidationError extends Error {\n  constructor(message: string, public field?: string) {\n    super(message);\n    this.name = 'ContentValidationError';\n  }\n}\n\nconst contentSchema = z.object({\n  contentId: z.string().optional(),\n  key: z.string().min(1, 'Key is required').max(200, 'Key must be less than 200 characters'),\n  locale: z.enum(['en', 'es', 'fr', 'de', 'pt', 'it'], {\n    message: 'Locale must be one of: en, es, fr, de, pt, it'\n  }),\n  content: z.string().min(1, 'Content is required').max(10000, 'Content must be less than 10000 characters'),\n  description: z.string().max(500, 'Description must be less than 500 characters').optional(),\n  category: z.string().max(100, 'Category must be less than 100 characters').optional(),\n  isActive: z.boolean().optional(),\n  userId: z.string().optional()\n});\n\nconst contentInputSchema = z.object({\n  contentId: z.string().optional(),\n  key: z.string().min(1, 'Key is required').max(200, 'Key must be less than 200 characters'),\n  locale: z.enum(['en', 'es', 'fr', 'de', 'pt', 'it'], {\n    message: 'Locale must be one of: en, es, fr, de, pt, it'\n  }).optional(),\n  content: z.string().min(1, 'Content is required').max(10000, 'Content must be less than 10000 characters'),\n  description: z.string().max(500, 'Description must be less than 500 characters').optional(),\n  category: z.string().max(100, 'Category must be less than 100 characters').optional(),\n  isActive: z.boolean().optional()\n});\n\nexport const parseContent = (content: ContentType): ContentType => {\n  try {\n    const validated = contentSchema.parse(content);\n    return validated as ContentType;\n  } catch(error) {\n    if(error instanceof z.ZodError) {\n      const field = error.issues[0]?.path.join('.');\n      const message = error.issues[0]?.message || 'Validation failed';\n      throw new ContentValidationError(message, field);\n    }\n    throw error;\n  }\n};\n\nexport const parseContentInput = (content: ContentInputType): ContentInputType => {\n  try {\n    const validated = contentInputSchema.parse(content);\n    return validated as ContentInputType;\n  } catch(error) {\n    if(error instanceof z.ZodError) {\n      const field = error.issues[0]?.path.join('.');\n      const message = error.issues[0]?.message || 'Validation failed';\n      throw new ContentValidationError(message, field);\n    }\n    throw error;\n  }\n};\n\nconst performContentTransformation = (content: ContentType): ContentType => {\n  const {\n    _id,\n    _key,\n    contentId,\n    id,\n    key,\n    locale,\n    content: contentText,\n    description,\n    category,\n    isActive,\n    userId\n  } = content;\n\n  const transformed = {\n    ...parseDocument(content),\n    ...((_key || contentId) && {contentId: parseId(_key || contentId || '')}),\n    ...((_id || id || _key || contentId) && {id: parseArangoId(_id || id || `content/${_key || contentId}`)}),\n    key: parseString(key, 200),\n    locale,\n    content: parseString(contentText, 10000),\n    ...(description && {description: parseString(description, 500)}),\n    ...(category && {category: parseString(category, 100)}),\n    ...(isActive !== undefined && {isActive}),\n    ...(userId && {userId: parseId(userId)})\n  };\n\n  return removeEmptyKeys(transformed) as ContentType;\n};\n\nexport const parseContentFromDb = (content: ContentType): ContentType => performContentTransformation(content);"],
  "mappings": "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",
  "names": ["parseArangoId", "parseId", "parseString", "z", "parseDocument", "removeEmptyKeys", "ContentValidationError", "message", "field", "contentSchema", "contentInputSchema", "parseContent", "content", "error", "parseContentInput", "performContentTransformation", "_id", "_key", "contentId", "id", "key", "locale", "contentText", "description", "category", "isActive", "userId", "transformed", "parseContentFromDb"]
}


package/lib/adapters/conversationAdapter/conversationAdapter.d.ts

@@ -0,0 +1,23 @@
+export interface ConversationType {
+    _id?: string;
+    _key?: string;
+    _rev?: string;
+    _oldRev?: string;
+    _from?: string;
+    _to?: string;
+    added?: number;
+    conversationId?: string;
+    id?: string;
+    isDirect?: boolean;
+    modified?: number;
+    name?: string;
+    users?: any[];
+    [key: string]: any;
+}
+export declare class ConversationValidationError extends Error {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare const validateConversationInput: (conversation: unknown) => ConversationType;
+export declare const formatConversationOutput: (conversation: ConversationType) => ConversationType;
+export declare const parseConversation: (conversation: ConversationType) => ConversationType;

package/lib/adapters/conversationAdapter/conversationAdapter.js

@@ -0,0 +1,2 @@
+import{parseArangoId as c,parseId as v,parseString as l}from"@nlabs/utils";import{z as o}from"zod";import{parseDocument as g,removeEmptyKeys as f}from"../arangoAdapter/arangoAdapter";import{parseUser as u}from"../userAdapter/userAdapter";class i extends Error{constructor(t,e){super(t);this.field=e;this.name="ConversationValidationError"}}const y=o.object({_id:o.string().optional(),_key:o.string().optional(),_rev:o.string().optional(),_oldRev:o.string().optional(),_from:o.string().optional(),_to:o.string().optional(),added:o.number().optional(),conversationId:o.string().optional(),id:o.string().optional(),isDirect:o.boolean().optional(),modified:o.number().optional(),name:o.string().max(160).optional(),type:o.string(),users:o.array(o.any()).optional()}).passthrough(),I=n=>{try{return y.parse(n)}catch(r){if(r instanceof o.ZodError){const t=r.issues.map(e=>`${e.path.join(".")}: ${e.message}`).join(", ");throw new i(`Conversation validation failed: ${t}`)}throw r}},x=n=>n,E=n=>{try{return C(n)}catch(r){throw r instanceof i?r:new i(`Conversation parsing failed: ${r instanceof Error?r.message:"Unknown error"}`)}},C=n=>{const{_id:r,_key:t,conversationId:e,id:s,isDirect:a,name:p,users:d}=n;return f({...g(n),...(r||s||t||e)&&{id:c(r||s||`conversations/${t||e}`)},...(t||e)&&{conversationId:v(t||e||"")},...a!==void 0&&{isDirect:!!a},...p&&{name:l(p,160)},...d?.length&&{users:d.map(m=>u(m))}})};export{i as ConversationValidationError,x as formatConversationOutput,E as parseConversation,I as validateConversationInput};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2FkYXB0ZXJzL2NvbnZlcnNhdGlvbkFkYXB0ZXIvY29udmVyc2F0aW9uQWRhcHRlci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHtwYXJzZUFyYW5nb0lkLCBwYXJzZUlkLCBwYXJzZVN0cmluZ30gZnJvbSAnQG5sYWJzL3V0aWxzJztcbmltcG9ydCB7en0gZnJvbSAnem9kJztcblxuaW1wb3J0IHtwYXJzZURvY3VtZW50LCByZW1vdmVFbXB0eUtleXN9IGZyb20gJy4uL2FyYW5nb0FkYXB0ZXIvYXJhbmdvQWRhcHRlcic7XG5pbXBvcnQge3BhcnNlVXNlcn0gZnJvbSAnLi4vdXNlckFkYXB0ZXIvdXNlckFkYXB0ZXInO1xuXG5leHBvcnQgaW50ZXJmYWNlIENvbnZlcnNhdGlvblR5cGUge1xuICBfaWQ/OiBzdHJpbmc7XG4gIF9rZXk/OiBzdHJpbmc7XG4gIF9yZXY/OiBzdHJpbmc7XG4gIF9vbGRSZXY/OiBzdHJpbmc7XG4gIF9mcm9tPzogc3RyaW5nO1xuICBfdG8/OiBzdHJpbmc7XG4gIGFkZGVkPzogbnVtYmVyO1xuICBjb252ZXJzYXRpb25JZD86IHN0cmluZztcbiAgaWQ/OiBzdHJpbmc7XG4gIGlzRGlyZWN0PzogYm9vbGVhbjtcbiAgbW9kaWZpZWQ/OiBudW1iZXI7XG4gIG5hbWU/OiBzdHJpbmc7XG4gIHVzZXJzPzogYW55W107XG4gIFtrZXk6IHN0cmluZ106IGFueTtcbn1cblxuZXhwb3J0IGNsYXNzIENvbnZlcnNhdGlvblZhbGlkYXRpb25FcnJvciBleHRlbmRzIEVycm9yIHtcbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nLCBwdWJsaWMgZmllbGQ/OiBzdHJpbmcpIHtcbiAgICBzdXBlcihtZXNzYWdlKTtcbiAgICB0aGlzLm5hbWUgPSAnQ29udmVyc2F0aW9uVmFsaWRhdGlvbkVycm9yJztcbiAgfVxufVxuXG5jb25zdCBDb252ZXJzYXRpb25JbnB1dFNjaGVtYSA9IHoub2JqZWN0KHtcbiAgX2lkOiB6LnN0cmluZygpLm9wdGlvbmFsKCksXG4gIF9rZXk6IHouc3RyaW5nKCkub3B0aW9uYWwoKSxcbiAgX3Jldjogei5zdHJpbmcoKS5vcHRpb25hbCgpLFxuICBfb2xkUmV2OiB6LnN0cmluZygpLm9wdGlvbmFsKCksXG4gIF9mcm9tOiB6LnN0cmluZygpLm9wdGlvbmFsKCksXG4gIF90bzogei5zdHJpbmcoKS5vcHRpb25hbCgpLFxuICBhZGRlZDogei5udW1iZXIoKS5vcHRpb25hbCgpLFxuICBjb252ZXJzYXRpb25JZDogei5zdHJpbmcoKS5vcHRpb25hbCgpLFxuICBpZDogei5zdHJpbmcoKS5vcHRpb25hbCgpLFxuICBpc0RpcmVjdDogei5ib29sZWFuKCkub3B0aW9uYWwoKSxcbiAgbW9kaWZpZWQ6IHoubnVtYmVyKCkub3B0aW9uYWwoKSxcbiAgbmFtZTogei5zdHJpbmcoKS5tYXgoMTYwKS5vcHRpb25hbCgpLFxuICB0eXBlOiB6LnN0cmluZygpLFxuICB1c2Vyczogei5hcnJheSh6LmFueSgpKS5vcHRpb25hbCgpXG59KS5wYXNzdGhyb3VnaCgpO1xuXG5leHBvcnQgY29uc3QgdmFsaWRhdGVDb252ZXJzYXRpb25JbnB1dCA9IChjb252ZXJzYXRpb246IHVua25vd24pOiBDb252ZXJzYXRpb25UeXBlID0+IHtcbiAgdHJ5IHtcbiAgICBjb25zdCB2YWxpZGF0ZWQgPSBDb252ZXJzYXRpb25JbnB1dFNjaGVtYS5wYXJzZShjb252ZXJzYXRpb24pO1xuICAgIHJldHVybiB2YWxpZGF0ZWQgYXMgQ29udmVyc2F0aW9uVHlwZTtcbiAgfSBjYXRjaChlcnJvcikge1xuICAgIGlmKGVycm9yIGluc3RhbmNlb2Ygei5ab2RFcnJvcikge1xuICAgICAgY29uc3QgZmllbGRFcnJvcnMgPSBlcnJvci5pc3N1ZXMubWFwKChlKSA9PiBgJHtlLnBhdGguam9pbignLicpfTogJHtlLm1lc3NhZ2V9YCkuam9pbignLCAnKTtcbiAgICAgIHRocm93IG5ldyBDb252ZXJzYXRpb25WYWxpZGF0aW9uRXJyb3IoYENvbnZlcnNhdGlvbiB2YWxpZGF0aW9uIGZhaWxlZDogJHtmaWVsZEVycm9yc31gKTtcbiAgICB9XG4gICAgdGhyb3cgZXJyb3I7XG4gIH1cbn07XG5cbmV4cG9ydCBjb25zdCBmb3JtYXRDb252ZXJzYXRpb25PdXRwdXQgPSAoY29udmVyc2F0aW9uOiBDb252ZXJzYXRpb25UeXBlKTogQ29udmVyc2F0aW9uVHlwZSA9PiBjb252ZXJzYXRpb247XG5cbmV4cG9ydCBjb25zdCBwYXJzZUNvbnZlcnNhdGlvbiA9IChjb252ZXJzYXRpb246IENvbnZlcnNhdGlvblR5cGUpOiBDb252ZXJzYXRpb25UeXBlID0+IHtcbiAgdHJ5IHtcbiAgICBjb25zdCBwYXJzZWQgPSBwZXJmb3JtQ29udmVyc2F0aW9uVHJhbnNmb3JtYXRpb24oY29udmVyc2F0aW9uKTtcbiAgICByZXR1cm4gcGFyc2VkO1xuICB9IGNhdGNoKGVycm9yKSB7XG4gICAgaWYoZXJyb3IgaW5zdGFuY2VvZiBDb252ZXJzYXRpb25WYWxpZGF0aW9uRXJyb3IpIHtcbiAgICAgIHRocm93IGVycm9yO1xuICAgIH1cbiAgICB0aHJvdyBuZXcgQ29udmVyc2F0aW9uVmFsaWRhdGlvbkVycm9yKGBDb252ZXJzYXRpb24gcGFyc2luZyBmYWlsZWQ6ICR7ZXJyb3IgaW5zdGFuY2VvZiBFcnJvciA/IGVycm9yLm1lc3NhZ2UgOiAnVW5rbm93biBlcnJvcid9YCk7XG4gIH1cbn07XG5cbmNvbnN0IHBlcmZvcm1Db252ZXJzYXRpb25UcmFuc2Zvcm1hdGlvbiA9IChjb252ZXJzYXRpb246IENvbnZlcnNhdGlvblR5cGUpOiBDb252ZXJzYXRpb25UeXBlID0+IHtcbiAgY29uc3Qge1xuICAgIF9pZCxcbiAgICBfa2V5LFxuICAgIGNvbnZlcnNhdGlvbklkLFxuICAgIGlkLFxuICAgIGlzRGlyZWN0LFxuICAgIG5hbWUsXG4gICAgdXNlcnNcbiAgfSA9IGNvbnZlcnNhdGlvbjtcblxuICBjb25zdCB0cmFuc2Zvcm1lZCA9IHJlbW92ZUVtcHR5S2V5cyh7XG4gICAgLi4ucGFyc2VEb2N1bWVudChjb252ZXJzYXRpb24pLFxuICAgIC4uLigoX2lkIHx8IGlkIHx8IF9rZXkgfHwgY29udmVyc2F0aW9uSWQpICYmIHtpZDogcGFyc2VBcmFuZ29JZChfaWQgfHwgaWQgfHwgYGNvbnZlcnNhdGlvbnMvJHtfa2V5IHx8IGNvbnZlcnNhdGlvbklkfWApfSksXG4gICAgLi4uKChfa2V5IHx8IGNvbnZlcnNhdGlvbklkKSAmJiB7Y29udmVyc2F0aW9uSWQ6IHBhcnNlSWQoX2tleSB8fCBjb252ZXJzYXRpb25JZCB8fCAnJyl9KSxcbiAgICAuLi4oaXNEaXJlY3QgIT09IHVuZGVmaW5lZCAmJiB7aXNEaXJlY3Q6ICEhaXNEaXJlY3R9KSxcbiAgICAuLi4obmFtZSAmJiB7bmFtZTogcGFyc2VTdHJpbmcobmFtZSwgMTYwKX0pLFxuICAgIC4uLih1c2Vycz8ubGVuZ3RoICYmIHt1c2VyczogdXNlcnMubWFwKCh1c2VyKSA9PiBwYXJzZVVzZXIodXNlcikpfSlcbiAgfSk7XG5cbiAgcmV0dXJuIHRyYW5zZm9ybWVkO1xufTsiXSwKICAibWFwcGluZ3MiOiAiQUFBQSxPQUFRLGlCQUFBQSxFQUFlLFdBQUFDLEVBQVMsZUFBQUMsTUFBa0IsZUFDbEQsT0FBUSxLQUFBQyxNQUFRLE1BRWhCLE9BQVEsaUJBQUFDLEVBQWUsbUJBQUFDLE1BQXNCLGlDQUM3QyxPQUFRLGFBQUFDLE1BQWdCLDZCQW1CakIsTUFBTUMsVUFBb0MsS0FBTSxDQUNyRCxZQUFZQyxFQUF3QkMsRUFBZ0IsQ0FDbEQsTUFBTUQsQ0FBTyxFQURxQixXQUFBQyxFQUVsQyxLQUFLLEtBQU8sNkJBQ2QsQ0FDRixDQUVBLE1BQU1DLEVBQTBCUCxFQUFFLE9BQU8sQ0FDdkMsSUFBS0EsRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUN6QixLQUFNQSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQzFCLEtBQU1BLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFDMUIsUUFBU0EsRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUM3QixNQUFPQSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQzNCLElBQUtBLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFDekIsTUFBT0EsRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUMzQixlQUFnQkEsRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUNwQyxHQUFJQSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQ3hCLFNBQVVBLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFDL0IsU0FBVUEsRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUM5QixLQUFNQSxFQUFFLE9BQU8sRUFBRSxJQUFJLEdBQUcsRUFBRSxTQUFTLEVBQ25DLEtBQU1BLEVBQUUsT0FBTyxFQUNmLE1BQU9BLEVBQUUsTUFBTUEsRUFBRSxJQUFJLENBQUMsRUFBRSxTQUFTLENBQ25DLENBQUMsRUFBRSxZQUFZLEVBRUZRLEVBQTZCQyxHQUE0QyxDQUNwRixHQUFJLENBRUYsT0FEa0JGLEVBQXdCLE1BQU1FLENBQVksQ0FFOUQsT0FBUUMsRUFBTyxDQUNiLEdBQUdBLGFBQWlCVixFQUFFLFNBQVUsQ0FDOUIsTUFBTVcsRUFBY0QsRUFBTSxPQUFPLElBQUssR0FBTSxHQUFHLEVBQUUsS0FBSyxLQUFLLEdBQUcsQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLEVBQUUsS0FBSyxJQUFJLEVBQzFGLE1BQU0sSUFBSU4sRUFBNEIsbUNBQW1DTyxDQUFXLEVBQUUsQ0FDeEYsQ0FDQSxNQUFNRCxDQUNSLENBQ0YsRUFFYUUsRUFBNEJILEdBQXFEQSxFQUVqRkksRUFBcUJKLEdBQXFELENBQ3JGLEdBQUksQ0FFRixPQURlSyxFQUFrQ0wsQ0FBWSxDQUUvRCxPQUFRQyxFQUFPLENBQ2IsTUFBR0EsYUFBaUJOLEVBQ1pNLEVBRUYsSUFBSU4sRUFBNEIsZ0NBQWdDTSxhQUFpQixNQUFRQSxFQUFNLFFBQVUsZUFBZSxFQUFFLENBQ2xJLENBQ0YsRUFFTUksRUFBcUNMLEdBQXFELENBQzlGLEtBQU0sQ0FDSixJQUFBTSxFQUNBLEtBQUFDLEVBQ0EsZUFBQUMsRUFDQSxHQUFBQyxFQUNBLFNBQUFDLEVBQ0EsS0FBQUMsRUFDQSxNQUFBQyxDQUNGLEVBQUlaLEVBV0osT0FUb0JQLEVBQWdCLENBQ2xDLEdBQUdELEVBQWNRLENBQVksRUFDN0IsSUFBS00sR0FBT0csR0FBTUYsR0FBUUMsSUFBbUIsQ0FBQyxHQUFJcEIsRUFBY2tCLEdBQU9HLEdBQU0saUJBQWlCRixHQUFRQyxDQUFjLEVBQUUsQ0FBQyxFQUN2SCxJQUFLRCxHQUFRQyxJQUFtQixDQUFDLGVBQWdCbkIsRUFBUWtCLEdBQVFDLEdBQWtCLEVBQUUsQ0FBQyxFQUN0RixHQUFJRSxJQUFhLFFBQWEsQ0FBQyxTQUFVLENBQUMsQ0FBQ0EsQ0FBUSxFQUNuRCxHQUFJQyxHQUFRLENBQUMsS0FBTXJCLEVBQVlxQixFQUFNLEdBQUcsQ0FBQyxFQUN6QyxHQUFJQyxHQUFPLFFBQVUsQ0FBQyxNQUFPQSxFQUFNLElBQUtDLEdBQVNuQixFQUFVbUIsQ0FBSSxDQUFDLENBQUMsQ0FDbkUsQ0FBQyxDQUdIIiwKICAibmFtZXMiOiBbInBhcnNlQXJhbmdvSWQiLCAicGFyc2VJZCIsICJwYXJzZVN0cmluZyIsICJ6IiwgInBhcnNlRG9jdW1lbnQiLCAicmVtb3ZlRW1wdHlLZXlzIiwgInBhcnNlVXNlciIsICJDb252ZXJzYXRpb25WYWxpZGF0aW9uRXJyb3IiLCAibWVzc2FnZSIsICJmaWVsZCIsICJDb252ZXJzYXRpb25JbnB1dFNjaGVtYSIsICJ2YWxpZGF0ZUNvbnZlcnNhdGlvbklucHV0IiwgImNvbnZlcnNhdGlvbiIsICJlcnJvciIsICJmaWVsZEVycm9ycyIsICJmb3JtYXRDb252ZXJzYXRpb25PdXRwdXQiLCAicGFyc2VDb252ZXJzYXRpb24iLCAicGVyZm9ybUNvbnZlcnNhdGlvblRyYW5zZm9ybWF0aW9uIiwgIl9pZCIsICJfa2V5IiwgImNvbnZlcnNhdGlvbklkIiwgImlkIiwgImlzRGlyZWN0IiwgIm5hbWUiLCAidXNlcnMiLCAidXNlciJdCn0K

package/lib/adapters/eventAdapter/eventAdapter.d.ts

@@ -0,0 +1,43 @@
+export interface EventType {
+    _id?: string;
+    _key?: string;
+    _rev?: string;
+    _oldRev?: string;
+    _from?: string;
+    _to?: string;
+    address?: string;
+    cached?: number;
+    content?: string;
+    endDate?: number;
+    eventId?: string;
+    groupId?: string;
+    id?: string;
+    images?: any[];
+    isGoing?: boolean;
+    latitude?: number;
+    location?: string | {
+        address: string;
+        latitude: number;
+        longitude: number;
+    };
+    longitude?: number;
+    mentions?: any[];
+    modified?: number;
+    name?: string;
+    postId?: string;
+    reactions?: string[];
+    rsvpCount?: number;
+    startDate?: number;
+    tags?: any[];
+    type?: string;
+    user?: any;
+    viewCount?: number;
+    [key: string]: any;
+}
+export declare class EventValidationError extends Error {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare const validateEventInput: (event: unknown) => EventType;
+export declare const formatEventOutput: (event: EventType) => EventType;
+export declare const parseEvent: (event: EventType) => EventType;

package/lib/adapters/eventAdapter/eventAdapter.js

@@ -0,0 +1,2 @@
+import{parseArangoId as U,parseId as u,parseNum as o,parseString as g}from"@nlabs/utils";import{z as t}from"zod";import{parseDocument as V,removeEmptyKeys as z}from"../arangoAdapter/arangoAdapter";import{parseImage as A}from"../imageAdapter/imageAdapter";import{parseReaktorContent as K,parseReaktorDate as G,parseReaktorType as N}from"../reaktorAdapter/reaktorAdapter";import{parseTag as O}from"../tagAdapter/tagAdapter";import{parseUser as S}from"../userAdapter/userAdapter";class l extends Error{constructor(r,i){super(r);this.field=i;this.name="EventValidationError"}}const Z=t.object({_id:t.string().optional(),_key:t.string().optional(),_rev:t.string().optional(),_oldRev:t.string().optional(),_from:t.string().optional(),_to:t.string().optional(),address:t.string().optional(),cached:t.number().optional(),content:t.string().optional(),endDate:t.number().optional(),eventId:t.string().optional(),groupId:t.string().optional(),id:t.string().optional(),images:t.array(t.any()).optional(),isGoing:t.boolean().optional(),latitude:t.number().optional(),location:t.union([t.string(),t.object({address:t.string(),latitude:t.number(),longitude:t.number()})]).optional(),longitude:t.number().optional(),mentions:t.array(t.any()).optional(),modified:t.number().optional(),name:t.string().optional(),postId:t.string().optional(),reactions:t.array(t.string()).optional(),rsvpCount:t.number().optional(),startDate:t.number().optional(),tags:t.array(t.any()).optional(),type:t.string().optional(),user:t.any().optional(),viewCount:t.number().optional()}).passthrough(),Q=e=>{try{return Z.parse(e)}catch(n){if(n instanceof t.ZodError){const r=n.issues.map(i=>`${i.path.join(".")}: ${i.message}`).join(", ");throw new l(`Event validation failed: ${r}`)}throw n}},W=e=>e,X=e=>{try{return q(e)}catch(n){throw n instanceof l?n:new l(`Event parsing failed: ${n instanceof Error?n.message:"Unknown error"}`)}},q=e=>{const{_id:n,_key:r,address:i,cached:m,content:c,endDate:v,eventId:d,groupId:y,id:f,images:b,isGoing:E,latitude:h,location:a,longitude:I,mentions:_,name:w,postId:T,reactions:D,rsvpCount:k,startDate:C,tags:x,type:j,user:R,viewCount:$}=e,p=z({...V(e),...i&&{address:g(i,160)},...m!==void 0&&{cached:o(m)},...c&&{content:K(c)},...v!==void 0&&{endDate:G(v)},...(n||f||r||d)&&{id:U(n||f||`events/${r||d}`)},...(r||d)&&{eventId:u(r||d||"")},...y&&{groupId:u(y)},...b?.length&&{images:b.map(s=>A(s))},...E!==void 0&&{isGoing:!!E},...h!==void 0&&{latitude:o(h,15)},...I!==void 0&&{longitude:o(I,15)},..._?.length&&{mentions:_.map(s=>S(s))},...w&&{name:g(w,160)},...T&&{postId:u(T)},...D?.length&&{reactions:D},...k!==void 0&&{rsvpCount:o(k)},...C!==void 0&&{startDate:G(C)},...x?.length&&{tags:x.map(s=>O(s))},...j&&{type:N(j)},...R&&{user:S(R)},...$!==void 0&&{viewCount:o($)}});return a&&typeof a=="object"&&(p.address=g(a.address,160),p.latitude=o(a.latitude,15),p.longitude=o(a.longitude,15)),p};export{l as EventValidationError,W as formatEventOutput,X as parseEvent,Q as validateEventInput};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/adapters/eventAdapter/eventAdapter.ts"],
  "sourcesContent": ["import {parseArangoId, parseId, parseNum, parseString} from '@nlabs/utils';\nimport {z} from 'zod';\n\nimport {parseDocument, removeEmptyKeys} from '../arangoAdapter/arangoAdapter';\nimport {parseImage} from '../imageAdapter/imageAdapter';\nimport {parseReaktorContent, parseReaktorDate, parseReaktorType} from '../reaktorAdapter/reaktorAdapter';\nimport {parseTag} from '../tagAdapter/tagAdapter';\nimport {parseUser} from '../userAdapter/userAdapter';\n\nexport interface EventType {\n  _id?: string;\n  _key?: string;\n  _rev?: string;\n  _oldRev?: string;\n  _from?: string;\n  _to?: string;\n  address?: string;\n  cached?: number;\n  content?: string;\n  endDate?: number;\n  eventId?: string;\n  groupId?: string;\n  id?: string;\n  images?: any[];\n  isGoing?: boolean;\n  latitude?: number;\n  location?: string | {address: string; latitude: number; longitude: number};\n  longitude?: number;\n  mentions?: any[];\n  modified?: number;\n  name?: string;\n  postId?: string;\n  reactions?: string[];\n  rsvpCount?: number;\n  startDate?: number;\n  tags?: any[];\n  type?: string;\n  user?: any;\n  viewCount?: number;\n  [key: string]: any;\n}\n\nexport class EventValidationError extends Error {\n  constructor(message: string, public field?: string) {\n    super(message);\n    this.name = 'EventValidationError';\n  }\n}\n\nconst EventInputSchema = z.object({\n  _id: z.string().optional(),\n  _key: z.string().optional(),\n  _rev: z.string().optional(),\n  _oldRev: z.string().optional(),\n  _from: z.string().optional(),\n  _to: z.string().optional(),\n  address: z.string().optional(),\n  cached: z.number().optional(),\n  content: z.string().optional(),\n  endDate: z.number().optional(),\n  eventId: z.string().optional(),\n  groupId: z.string().optional(),\n  id: z.string().optional(),\n  images: z.array(z.any()).optional(),\n  isGoing: z.boolean().optional(),\n  latitude: z.number().optional(),\n  location: z.union([z.string(), z.object({\n    address: z.string(),\n    latitude: z.number(),\n    longitude: z.number()\n  })]).optional(),\n  longitude: z.number().optional(),\n  mentions: z.array(z.any()).optional(),\n  modified: z.number().optional(),\n  name: z.string().optional(),\n  postId: z.string().optional(),\n  reactions: z.array(z.string()).optional(),\n  rsvpCount: z.number().optional(),\n  startDate: z.number().optional(),\n  tags: z.array(z.any()).optional(),\n  type: z.string().optional(),\n  user: z.any().optional(),\n  viewCount: z.number().optional()\n}).passthrough();\n\nexport const validateEventInput = (event: unknown): EventType => {\n  try {\n    const validated = EventInputSchema.parse(event);\n    return validated as EventType;\n  } catch(error) {\n    if(error instanceof z.ZodError) {\n      const fieldErrors = error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');\n      throw new EventValidationError(`Event validation failed: ${fieldErrors}`);\n    }\n    throw error;\n  }\n};\n\nexport const formatEventOutput = (event: EventType): EventType => event;\n\nexport const parseEvent = (event: EventType): EventType => {\n  try {\n    const parsed = performEventTransformation(event);\n    return parsed;\n  } catch(error) {\n    if(error instanceof EventValidationError) {\n      throw error;\n    }\n    throw new EventValidationError(`Event parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n  }\n};\n\nconst performEventTransformation = (event: EventType): EventType => {\n  const {\n    _id,\n    _key,\n    address,\n    cached,\n    content,\n    endDate,\n    eventId,\n    groupId,\n    id,\n    images,\n    isGoing,\n    latitude,\n    location,\n    longitude,\n    mentions,\n    name,\n    postId,\n    reactions,\n    rsvpCount,\n    startDate,\n    tags,\n    type,\n    user,\n    viewCount\n  } = event;\n\n  const transformed = removeEmptyKeys({\n    ...parseDocument(event),\n    ...(address && {address: parseString(address, 160)}),\n    ...(cached !== undefined && {cached: parseNum(cached)}),\n    ...(content && {content: parseReaktorContent(content)}),\n    ...(endDate !== undefined && {endDate: parseReaktorDate(endDate)}),\n    ...((_id || id || _key || eventId) && {id: parseArangoId(_id || id || `events/${_key || eventId}`)}),\n    ...((_key || eventId) && {eventId: parseId(_key || eventId || '')}),\n    ...(groupId && {groupId: parseId(groupId)}),\n    ...(images?.length && {images: images.map((image) => parseImage(image))}),\n    ...(isGoing !== undefined && {isGoing: !!isGoing}),\n    ...(latitude !== undefined && {latitude: parseNum(latitude, 15)}),\n    ...(longitude !== undefined && {longitude: parseNum(longitude, 15)}),\n    ...(mentions?.length && {mentions: mentions.map((mention) => parseUser(mention))}),\n    ...(name && {name: parseString(name, 160)}),\n    ...(postId && {postId: parseId(postId)}),\n    ...(reactions?.length && {reactions}),\n    ...(rsvpCount !== undefined && {rsvpCount: parseNum(rsvpCount)}),\n    ...(startDate !== undefined && {startDate: parseReaktorDate(startDate)}),\n    ...(tags?.length && {tags: tags.map((tag) => parseTag(tag))}),\n    ...(type && {type: parseReaktorType(type)}),\n    ...(user && {user: parseUser(user)}),\n    ...(viewCount !== undefined && {viewCount: parseNum(viewCount)})\n  });\n\n  // Handle location object\n  if(location && typeof location === 'object') {\n    transformed.address = parseString(location.address, 160);\n    transformed.latitude = parseNum(location.latitude, 15);\n    transformed.longitude = parseNum(location.longitude, 15);\n  }\n\n  return transformed;\n};"],
  "mappings": "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",
  "names": ["parseArangoId", "parseId", "parseNum", "parseString", "z", "parseDocument", "removeEmptyKeys", "parseImage", "parseReaktorContent", "parseReaktorDate", "parseReaktorType", "parseTag", "parseUser", "EventValidationError", "message", "field", "EventInputSchema", "validateEventInput", "event", "error", "fieldErrors", "e", "formatEventOutput", "parseEvent", "performEventTransformation", "_id", "_key", "address", "cached", "content", "endDate", "eventId", "groupId", "id", "images", "isGoing", "latitude", "location", "longitude", "mentions", "name", "postId", "reactions", "rsvpCount", "startDate", "tags", "type", "user", "viewCount", "transformed", "image", "mention", "tag"]
}
