@nlabs/reaktor 0.10.2 → 0.10.6

package/lib/handlers/graphqlHandler.js

@@ -1,2 +1,118 @@
-import{graphql as m}from"graphql";import{schemaComposer as d}from"graphql-compose";import{Config as y}from"../config.js";import{extractLanguageContext as g}from"../utils/contextUtils.js";import{createContext as f,getGqlFields as h,getLambdaData as C}from"../utils/index.js";const k=(i,o,r,n,t)=>{const a={...n,fields:h(t)};return i(o,r,a,t)},N=i=>async o=>{try{const r=await f(i,o),n=g(o),t={config:y.get(),...r,languageContext:n,request:o},a=e=>{Object.keys(e.getFields()).forEach(s=>{try{e.hasResolver(s)&&e.wrapResolver(s,k)}catch{}})};a(d.Query),a(d.Mutation);const u=C(o),l=d.buildSchema(),{body:c}=u;if(!c?.query)return{body:JSON.stringify({data:null,errors:[{message:"No GraphQL query found in request body"}]}),headers:{"Content-Type":"application/json"},statusCode:200};try{const e=await Promise.resolve(m({contextValue:t,schema:l,source:c.query,variableValues:c.variables}));return e.errors&&e.errors.length>0,{body:JSON.stringify(e),headers:{"Content-Type":"application/json"},statusCode:200}}catch(e){const s=e instanceof Error?e.message:"GraphQL execution error",p=e instanceof Error?e.stack:void 0;return{body:JSON.stringify({data:null,errors:[{message:s,stack:process.env.NODE_ENV==="development"?p:void 0}]}),headers:{"Content-Type":"application/json"},statusCode:500}}}catch(r){const n=r instanceof Error?r.message:"An unknown error occurred in the handler",t=r instanceof Error?r.stack:void 0;return{body:JSON.stringify({data:null,errors:[{message:n,stack:process.env.NODE_ENV==="development"?t:void 0}]}),headers:{"Content-Type":"application/json"},statusCode:500}}};export{N as createGraphqlHandler};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/handlers/graphqlHandler.ts"],
  "sourcesContent": ["import {graphql} from 'graphql';\nimport {ObjectTypeComposer, schemaComposer} from 'graphql-compose';\n\nimport {Config} from '../config.js';\nimport {extractLanguageContext} from '../utils/contextUtils.js';\nimport {createContext, getGqlFields, getLambdaData, type LambdaData} from '../utils/index.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {APIGatewayEvent} from 'aws-lambda';\nimport type {ExecutionResult} from 'graphql';\n\nconst addFieldsMiddleware = (resolve, source, args, context: ApiContext, info) => {\n  const enhancedContext = {\n    ...context,\n    fields: getGqlFields(info)\n  };\n\n  return resolve(source, args, enhancedContext, info);\n};\n\nexport const createGraphqlHandler = (context: ApiContext) =>\n  async (event: APIGatewayEvent): Promise<ExecutionResult | Record<string, unknown>> => {\n    try {\n      const updatedContext: ApiContext = await createContext(context, event);\n      const languageContext = extractLanguageContext(event);\n\n      const contextWithLanguage = {\n        config: Config.get(),\n        ...updatedContext,\n        languageContext,\n        request: event\n      };\n\n      const applyFieldsMiddleware = (tc: ObjectTypeComposer<unknown, unknown>) => {\n        Object.keys(tc.getFields()).forEach((fieldName) => {\n          try {\n            if(tc.hasResolver(fieldName)) {\n              tc.wrapResolver(fieldName, addFieldsMiddleware as any);\n            }\n          } catch(error) {\n            console.warn(`Skipping field ${fieldName} - not a resolver:`, error.message);\n          }\n        });\n      };\n\n      applyFieldsMiddleware(schemaComposer.Query);\n      applyFieldsMiddleware(schemaComposer.Mutation);\n\n      const parseData = getLambdaData(event as unknown as LambdaData);\n      const schema = schemaComposer.buildSchema();\n      const {body} = parseData;\n\n      if(!body?.query) {\n        console.warn('No GraphQL query found in request body');\n\n        return {\n          body: JSON.stringify({\n            data: null,\n            errors: [{\n              message: 'No GraphQL query found in request body'\n            }]\n          }),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 200\n        };\n      }\n\n      try {\n        const result = await Promise.resolve(graphql({\n          contextValue: contextWithLanguage,\n          schema,\n          source: body.query,\n          variableValues: body.variables\n        }));\n\n        if(result.errors && result.errors.length > 0) {\n          console.error('GraphQL execution errors:', result.errors);\n        }\n\n        return {\n          body: JSON.stringify(result),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 200\n        };\n      } catch(graphqlError: unknown) {\n        console.error('Error during GraphQL execution:', graphqlError);\n\n        const errorMessage = graphqlError instanceof Error ? graphqlError.message : 'GraphQL execution error';\n        const errorStack = graphqlError instanceof Error ? graphqlError.stack : undefined;\n\n        return {\n          body: JSON.stringify({\n            data: null,\n            errors: [{\n              message: errorMessage,\n              stack: process.env.NODE_ENV === 'development' ? errorStack : undefined\n            }]\n          }),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 500\n        };\n      }\n    } catch(err: unknown) {\n      console.error('Handler error:', {\n        message: err instanceof Error ? err.message : 'Unknown error',\n        stack: err instanceof Error ? err.stack : undefined\n      });\n\n      const errorMessage = err instanceof Error ? err.message : 'An unknown error occurred in the handler';\n      const errorStack = err instanceof Error ? err.stack : undefined;\n\n      return {\n        body: JSON.stringify({\n          data: null,\n          errors: [{\n            message: errorMessage,\n            stack: process.env.NODE_ENV === 'development' ? errorStack : undefined\n          }]\n        }),\n        headers: {\n          'Content-Type': 'application/json'\n        },\n        statusCode: 500\n      };\n    }\n  };"],
  "mappings": "AAAA,OAAQ,WAAAA,MAAc,UACtB,OAA4B,kBAAAC,MAAqB,kBAEjD,OAAQ,UAAAC,MAAa,eACrB,OAAQ,0BAAAC,MAA6B,2BACrC,OAAQ,iBAAAC,EAAe,gBAAAC,EAAc,iBAAAC,MAAqC,oBAM1E,MAAMC,EAAsB,CAACC,EAASC,EAAQC,EAAMC,EAAqBC,IAAS,CAChF,MAAMC,EAAkB,CACtB,GAAGF,EACH,OAAQN,EAAaO,CAAI,CAC3B,EAEA,OAAOJ,EAAQC,EAAQC,EAAMG,EAAiBD,CAAI,CACpD,EAEaE,EAAwBH,GACnC,MAAOI,GAA+E,CACpF,GAAI,CACF,MAAMC,EAA6B,MAAMZ,EAAcO,EAASI,CAAK,EAC/DE,EAAkBd,EAAuBY,CAAK,EAE9CG,EAAsB,CAC1B,OAAQhB,EAAO,IAAI,EACnB,GAAGc,EACH,gBAAAC,EACA,QAASF,CACX,EAEMI,EAAyBC,GAA6C,CAC1E,OAAO,KAAKA,EAAG,UAAU,CAAC,EAAE,QAASC,GAAc,CACjD,GAAI,CACCD,EAAG,YAAYC,CAAS,GACzBD,EAAG,aAAaC,EAAWd,CAA0B,CAEzD,MAAe,CAEf,CACF,CAAC,CACH,EAEAY,EAAsBlB,EAAe,KAAK,EAC1CkB,EAAsBlB,EAAe,QAAQ,EAE7C,MAAMqB,EAAYhB,EAAcS,CAA8B,EACxDQ,EAAStB,EAAe,YAAY,EACpC,CAAC,KAAAuB,CAAI,EAAIF,EAEf,GAAG,CAACE,GAAM,MAGR,MAAO,CACL,KAAM,KAAK,UAAU,CACnB,KAAM,KACN,OAAQ,CAAC,CACP,QAAS,wCACX,CAAC,CACH,CAAC,EACD,QAAS,CACP,eAAgB,kBAClB,EACA,WAAY,GACd,EAGF,GAAI,CACF,MAAMC,EAAS,MAAM,QAAQ,QAAQzB,EAAQ,CAC3C,aAAckB,EACd,OAAAK,EACA,OAAQC,EAAK,MACb,eAAgBA,EAAK,SACvB,CAAC,CAAC,EAEF,OAAGC,EAAO,QAAUA,EAAO,OAAO,OAAS,EAIpC,CACL,KAAM,KAAK,UAAUA,CAAM,EAC3B,QAAS,CACP,eAAgB,kBAClB,EACA,WAAY,GACd,CACF,OAAQC,EAAuB,CAG7B,MAAMC,EAAeD,aAAwB,MAAQA,EAAa,QAAU,0BACtEE,EAAaF,aAAwB,MAAQA,EAAa,MAAQ,OAExE,MAAO,CACL,KAAM,KAAK,UAAU,CACnB,KAAM,KACN,OAAQ,CAAC,CACP,QAASC,EACT,MAAO,QAAQ,IAAI,WAAa,cAAgBC,EAAa,MAC/D,CAAC,CACH,CAAC,EACD,QAAS,CACP,eAAgB,kBAClB,EACA,WAAY,GACd,CACF,CACF,OAAQC,EAAc,CAMpB,MAAMF,EAAeE,aAAe,MAAQA,EAAI,QAAU,2CACpDD,EAAaC,aAAe,MAAQA,EAAI,MAAQ,OAEtD,MAAO,CACL,KAAM,KAAK,UAAU,CACnB,KAAM,KACN,OAAQ,CAAC,CACP,QAASF,EACT,MAAO,QAAQ,IAAI,WAAa,cAAgBC,EAAa,MAC/D,CAAC,CACH,CAAC,EACD,QAAS,CACP,eAAgB,kBAClB,EACA,WAAY,GACd,CACF,CACF",
  "names": ["graphql", "schemaComposer", "Config", "extractLanguageContext", "createContext", "getGqlFields", "getLambdaData", "addFieldsMiddleware", "resolve", "source", "args", "context", "info", "enhancedContext", "createGraphqlHandler", "event", "updatedContext", "languageContext", "contextWithLanguage", "applyFieldsMiddleware", "tc", "fieldName", "parseData", "schema", "body", "result", "graphqlError", "errorMessage", "errorStack", "err"]
}

+import { graphql } from 'graphql';
+import { schemaComposer } from 'graphql-compose';
+import { Config } from '../config.js';
+import { extractLanguageContext } from '../utils/contextUtils.js';
+import { createContext, getGqlFields, getLambdaData } from '../utils/index.js';
+const addFieldsMiddleware = (resolve, source, args, context, info)=>{
+    const enhancedContext = {
+        ...context,
+        fields: getGqlFields(info)
+    };
+    return resolve(source, args, enhancedContext, info);
+};
+export const createGraphqlHandler = (context)=>async (event)=>{
+        try {
+            const updatedContext = await createContext(context, event);
+            const languageContext = extractLanguageContext(event);
+            const contextWithLanguage = {
+                config: Config.get(),
+                ...updatedContext,
+                languageContext,
+                request: event
+            };
+            const applyFieldsMiddleware = (tc)=>{
+                Object.keys(tc.getFields()).forEach((fieldName)=>{
+                    try {
+                        if (tc.hasResolver(fieldName)) {
+                            tc.wrapResolver(fieldName, addFieldsMiddleware);
+                        }
+                    } catch (error) {
+                        console.warn(`Skipping field ${fieldName} - not a resolver:`, error.message);
+                    }
+                });
+            };
+            applyFieldsMiddleware(schemaComposer.Query);
+            applyFieldsMiddleware(schemaComposer.Mutation);
+            const parseData = getLambdaData(event);
+            const schema = schemaComposer.buildSchema();
+            const { body } = parseData;
+            if (!body?.query) {
+                console.warn('No GraphQL query found in request body');
+                return {
+                    body: JSON.stringify({
+                        data: null,
+                        errors: [
+                            {
+                                message: 'No GraphQL query found in request body'
+                            }
+                        ]
+                    }),
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    statusCode: 200
+                };
+            }
+            try {
+                const result = await Promise.resolve(graphql({
+                    contextValue: contextWithLanguage,
+                    schema,
+                    source: body.query,
+                    variableValues: body.variables
+                }));
+                if (result.errors && result.errors.length > 0) {
+                    console.error('GraphQL execution errors:', result.errors);
+                }
+                return {
+                    body: JSON.stringify(result),
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    statusCode: 200
+                };
+            } catch (graphqlError) {
+                console.error('Error during GraphQL execution:', graphqlError);
+                const errorMessage = graphqlError instanceof Error ? graphqlError.message : 'GraphQL execution error';
+                const errorStack = graphqlError instanceof Error ? graphqlError.stack : undefined;
+                return {
+                    body: JSON.stringify({
+                        data: null,
+                        errors: [
+                            {
+                                message: errorMessage,
+                                stack: process.env.NODE_ENV === 'development' ? errorStack : undefined
+                            }
+                        ]
+                    }),
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    statusCode: 500
+                };
+            }
+        } catch (err) {
+            console.error('Handler error:', {
+                message: err instanceof Error ? err.message : 'Unknown error',
+                stack: err instanceof Error ? err.stack : undefined
+            });
+            const errorMessage = err instanceof Error ? err.message : 'An unknown error occurred in the handler';
+            const errorStack = err instanceof Error ? err.stack : undefined;
+            return {
+                body: JSON.stringify({
+                    data: null,
+                    errors: [
+                        {
+                            message: errorMessage,
+                            stack: process.env.NODE_ENV === 'development' ? errorStack : undefined
+                        }
+                    ]
+                }),
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                statusCode: 500
+            };
+        }
+    };
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/handlers/graphqlHandler.ts"],"sourcesContent":["import {graphql} from 'graphql';\nimport {ObjectTypeComposer, schemaComposer} from 'graphql-compose';\n\nimport {Config} from '../config.js';\nimport {extractLanguageContext} from '../utils/contextUtils.js';\nimport {createContext, getGqlFields, getLambdaData, type LambdaData} from '../utils/index.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {APIGatewayEvent} from 'aws-lambda';\nimport type {ExecutionResult} from 'graphql';\n\nconst addFieldsMiddleware = (resolve, source, args, context: ApiContext, info) => {\n  const enhancedContext = {\n    ...context,\n    fields: getGqlFields(info)\n  };\n\n  return resolve(source, args, enhancedContext, info);\n};\n\nexport const createGraphqlHandler = (context: ApiContext) =>\n  async (event: APIGatewayEvent): Promise<ExecutionResult | Record<string, unknown>> => {\n    try {\n      const updatedContext: ApiContext = await createContext(context, event);\n      const languageContext = extractLanguageContext(event);\n\n      const contextWithLanguage = {\n        config: Config.get(),\n        ...updatedContext,\n        languageContext,\n        request: event\n      };\n\n      const applyFieldsMiddleware = (tc: ObjectTypeComposer<unknown, unknown>) => {\n        Object.keys(tc.getFields()).forEach((fieldName) => {\n          try {\n            if(tc.hasResolver(fieldName)) {\n              tc.wrapResolver(fieldName, addFieldsMiddleware as any);\n            }\n          } catch(error) {\n            console.warn(`Skipping field ${fieldName} - not a resolver:`, error.message);\n          }\n        });\n      };\n\n      applyFieldsMiddleware(schemaComposer.Query);\n      applyFieldsMiddleware(schemaComposer.Mutation);\n\n      const parseData = getLambdaData(event as unknown as LambdaData);\n      const schema = schemaComposer.buildSchema();\n      const {body} = parseData;\n\n      if(!body?.query) {\n        console.warn('No GraphQL query found in request body');\n\n        return {\n          body: JSON.stringify({\n            data: null,\n            errors: [{\n              message: 'No GraphQL query found in request body'\n            }]\n          }),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 200\n        };\n      }\n\n      try {\n        const result = await Promise.resolve(graphql({\n          contextValue: contextWithLanguage,\n          schema,\n          source: body.query,\n          variableValues: body.variables\n        }));\n\n        if(result.errors && result.errors.length > 0) {\n          console.error('GraphQL execution errors:', result.errors);\n        }\n\n        return {\n          body: JSON.stringify(result),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 200\n        };\n      } catch(graphqlError: unknown) {\n        console.error('Error during GraphQL execution:', graphqlError);\n\n        const errorMessage = graphqlError instanceof Error ? graphqlError.message : 'GraphQL execution error';\n        const errorStack = graphqlError instanceof Error ? graphqlError.stack : undefined;\n\n        return {\n          body: JSON.stringify({\n            data: null,\n            errors: [{\n              message: errorMessage,\n              stack: process.env.NODE_ENV === 'development' ? errorStack : undefined\n            }]\n          }),\n          headers: {\n            'Content-Type': 'application/json'\n          },\n          statusCode: 500\n        };\n      }\n    } catch(err: unknown) {\n      console.error('Handler error:', {\n        message: err instanceof Error ? err.message : 'Unknown error',\n        stack: err instanceof Error ? err.stack : undefined\n      });\n\n      const errorMessage = err instanceof Error ? err.message : 'An unknown error occurred in the handler';\n      const errorStack = err instanceof Error ? err.stack : undefined;\n\n      return {\n        body: JSON.stringify({\n          data: null,\n          errors: [{\n            message: errorMessage,\n            stack: process.env.NODE_ENV === 'development' ? errorStack : undefined\n          }]\n        }),\n        headers: {\n          'Content-Type': 'application/json'\n        },\n        statusCode: 500\n      };\n    }\n  };"],"names":["graphql","schemaComposer","Config","extractLanguageContext","createContext","getGqlFields","getLambdaData","addFieldsMiddleware","resolve","source","args","context","info","enhancedContext","fields","createGraphqlHandler","event","updatedContext","languageContext","contextWithLanguage","config","get","request","applyFieldsMiddleware","tc","Object","keys","getFields","forEach","fieldName","hasResolver","wrapResolver","error","console","warn","message","Query","Mutation","parseData","schema","buildSchema","body","query","JSON","stringify","data","errors","headers","statusCode","result","Promise","contextValue","variableValues","variables","length","graphqlError","errorMessage","Error","errorStack","stack","undefined","process","env","NODE_ENV","err"],"mappings":"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"}

package/lib/index.d.ts

@@ -17,3 +17,4 @@ export * from './objectTypes/index.js';
 export * from './queries/index.js';
 export * from './types/index.js';
 export * from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,OAAO,EAAE,cAAc,EACvB,YAAY,EACZ,SAAS,EACT,UAAU,EACV,WAAW,EAAE,cAAc,EAAE,iBAAiB,EAAE,aAAa,EAAE,WAAW,EAC3E,MAAM,SAAS,CAAC;AACjB,OAAO,EAAC,cAAc,EAAC,MAAM,iBAAiB,CAAC;AAE/C,YAAY,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AAC7C,YAAY,EAAC,iBAAiB,EAAE,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAE3E,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}

package/lib/index.js

@@ -1,2 +1,18 @@
-import{graphql as p,GraphQLBoolean as e,GraphQLFloat as t,GraphQLID as m,GraphQLInt as x,GraphQLList as a,GraphQLNonNull as f,GraphQLObjectType as h,GraphQLString as l,graphqlSync as L}from"graphql";import{schemaComposer as Q}from"graphql-compose";export*from"./actions/index.js";export*from"./adapters/index.js";export*from"./config.js";export*from"./handlers/graphqlHandler.js";export*from"./lambdas/authorizer.js";export*from"./lambdas/connection.js";export*from"./mutations/index.js";export*from"./objectTypes/index.js";export*from"./queries/index.js";export*from"./types/index.js";export*from"./utils/index.js";export{e as GraphQLBoolean,t as GraphQLFloat,m as GraphQLID,x as GraphQLInt,a as GraphQLList,f as GraphQLNonNull,h as GraphQLObjectType,l as GraphQLString,p as graphql,L as graphqlSync,Q as schemaComposer};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOS1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuZXhwb3J0IHtcbiAgZ3JhcGhxbCwgR3JhcGhRTEJvb2xlYW4sXG4gIEdyYXBoUUxGbG9hdCxcbiAgR3JhcGhRTElELFxuICBHcmFwaFFMSW50LFxuICBHcmFwaFFMTGlzdCwgR3JhcGhRTE5vbk51bGwsIEdyYXBoUUxPYmplY3RUeXBlLCBHcmFwaFFMU3RyaW5nLCBncmFwaHFsU3luY1xufSBmcm9tICdncmFwaHFsJztcbmV4cG9ydCB7c2NoZW1hQ29tcG9zZXJ9IGZyb20gJ2dyYXBocWwtY29tcG9zZSc7XG5cbmV4cG9ydCB0eXBlIHtFeGVjdXRpb25SZXN1bHR9IGZyb20gJ2dyYXBocWwnO1xuZXhwb3J0IHR5cGUge0lucHV0VHlwZUNvbXBvc2VyLCBPYmplY3RUeXBlQ29tcG9zZXJ9IGZyb20gJ2dyYXBocWwtY29tcG9zZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vYWN0aW9ucy9pbmRleC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2FkYXB0ZXJzL2luZGV4LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uZmlnLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vaGFuZGxlcnMvZ3JhcGhxbEhhbmRsZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9sYW1iZGFzL2F1dGhvcml6ZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9sYW1iZGFzL2Nvbm5lY3Rpb24uanMnO1xuZXhwb3J0ICogZnJvbSAnLi9tdXRhdGlvbnMvaW5kZXguanMnO1xuZXhwb3J0ICogZnJvbSAnLi9vYmplY3RUeXBlcy9pbmRleC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJpZXMvaW5kZXguanMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcy9pbmRleC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzL2luZGV4LmpzJztcblxuIl0sCiAgIm1hcHBpbmdzIjogIkFBSUEsT0FDRSxXQUFBQSxFQUFTLGtCQUFBQyxFQUNULGdCQUFBQyxFQUNBLGFBQUFDLEVBQ0EsY0FBQUMsRUFDQSxlQUFBQyxFQUFhLGtCQUFBQyxFQUFnQixxQkFBQUMsRUFBbUIsaUJBQUFDLEVBQWUsZUFBQUMsTUFDMUQsVUFDUCxPQUFRLGtCQUFBQyxNQUFxQixrQkFLN0IsV0FBYyxxQkFDZCxXQUFjLHNCQUNkLFdBQWMsY0FDZCxXQUFjLCtCQUNkLFdBQWMsMEJBQ2QsV0FBYywwQkFDZCxXQUFjLHVCQUNkLFdBQWMseUJBQ2QsV0FBYyxxQkFDZCxXQUFjLG1CQUNkLFdBQWMiLAogICJuYW1lcyI6IFsiZ3JhcGhxbCIsICJHcmFwaFFMQm9vbGVhbiIsICJHcmFwaFFMRmxvYXQiLCAiR3JhcGhRTElEIiwgIkdyYXBoUUxJbnQiLCAiR3JhcGhRTExpc3QiLCAiR3JhcGhRTE5vbk51bGwiLCAiR3JhcGhRTE9iamVjdFR5cGUiLCAiR3JhcGhRTFN0cmluZyIsICJncmFwaHFsU3luYyIsICJzY2hlbWFDb21wb3NlciJdCn0K
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export { graphql, GraphQLBoolean, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, graphqlSync } from 'graphql';
+export { schemaComposer } from 'graphql-compose';
+export * from './actions/index.js';
+export * from './adapters/index.js';
+export * from './config.js';
+export * from './handlers/graphqlHandler.js';
+export * from './lambdas/authorizer.js';
+export * from './lambdas/connection.js';
+export * from './mutations/index.js';
+export * from './objectTypes/index.js';
+export * from './queries/index.js';
+export * from './types/index.js';
+export * from './utils/index.js';
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/actions/websockets.d.ts

@@ -5,3 +5,4 @@ export declare const getConnectionByUserId: (userId?: string) => Promise<Websock
 export declare const getConnectionById: (socketId: string) => Promise<WebsocketConnection>;
 export declare const getConnectionByConvo: (context: ApiContext, convoId: string) => Promise<WebsocketConnection[]>;
 export declare const removeConnection: (connectionId: string) => Promise<WebsocketConnection>;
+//# sourceMappingURL=websockets.d.ts.map

package/lib/lambdas/actions/websockets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websockets.d.ts","sourceRoot":"","sources":["../../../src/lambdas/actions/websockets.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,iCAAiC,CAAC;AAGzE,eAAO,MAAM,aAAa,GAAU,cAAc,MAAM,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAwCpG,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAalF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAmB/E,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,SAAS,UAAU,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,mBAAmB,EAAE,CAqBxG,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,cAAc,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAelF,CAAC"}

package/lib/lambdas/actions/websockets.js

@@ -1,11 +1,62 @@
-import{aql as c}from"arangojs";import{createHash as m,parseId as R,parseString as E}from"@nlabs/utils/parsers/strings";import{useDb as i}from"../../utils/arangodbUtils.js";import{getSession as p}from"../../utils/sessionUtils.js";const{ARANGODB_DATABASE:a}=process.env,g=async(e,r)=>{const o=E(e,32),{userId:t}=p(r);if(!t)return{_key:"",socketId:"",userId:""};try{const n=i(a),I={connectionId:o,modified:Date.now()},d={...I,_key:m(`connection-${o}`),userId:t},s=c`UPSERT {userId: ${d.userId}}
-      INSERT ${d}
-      UPDATE ${I}
-      IN connections RETURN NEW`;return n.query(s).then(u=>u.next()).catch(u=>{throw u})}catch{throw new Error("Unauthorized Context")}},C=e=>{const r=R(e),o=i(a),t=c`FOR c IN connections
-    FILTER c.userId == ${r}
+/**
+ * Copyright (c) 2021-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { aql } from 'arangojs';
+import { createHash, parseId, parseString } from '@nlabs/utils/parsers/strings';
+import { useDb } from '../../utils/arangodbUtils.js';
+import { getSession } from '../../utils/sessionUtils.js';
+const { ARANGODB_DATABASE: databaseName } = process.env;
+export const addConnection = async (connectionId, token)=>{
+    // const action: string = 'delete';
+    const formatConnId = parseString(connectionId, 32);
+    // Verifies token
+    const { userId } = getSession(token);
+    if (!userId) {
+        return {
+            _key: '',
+            socketId: '',
+            userId: ''
+        };
+    }
+    try {
+        const db = useDb(databaseName);
+        const update = {
+            connectionId: formatConnId,
+            modified: Date.now()
+        };
+        const insert = {
+            ...update,
+            _key: createHash(`connection-${formatConnId}`),
+            userId
+        };
+        const aqlQry = aql`UPSERT {userId: ${insert.userId}}
+      INSERT ${insert}
+      UPDATE ${update}
+      IN connections RETURN NEW`;
+        return db.query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+            throw error;
+        });
+    } catch (error) {
+        console.log('parseContext::error', error);
+        throw new Error('Unauthorized Context');
+    }
+};
+export const getConnectionByUserId = (userId)=>{
+    const formatUserId = parseId(userId);
+    const db = useDb(databaseName);
+    const aqlQry = aql`FOR c IN connections
+    FILTER c.userId == ${formatUserId}
     LIMIT 1
-    RETURN c`;return o.query(t).then(n=>n.next()).catch(n=>{throw n})},U=e=>{const r=E(e,32),o=i(a),t=c`FOR c IN connections
-    FILTER c.connectionId == ${r}
+    RETURN c`;
+    return db.query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw error;
+    });
+};
+export const getConnectionById = (socketId)=>{
+    const formatSocketId = parseString(socketId, 32);
+    const db = useDb(databaseName);
+    const aqlQry = aql`FOR c IN connections
+    FILTER c.connectionId == ${formatSocketId}
     LET user = FIRST(
       FOR u IN users
       FILTER u.userId == c.userId
@@ -13,18 +64,42 @@ import{aql as c}from"arangojs";import{createHash as m,parseId as R,parseString a
       RETURN u;
     )
     LIMIT 1
-    RETURN MERGE(c, {user:user}`;return o.query(t).then(n=>n.next()).catch(n=>{throw n})},D=(e,r)=>{const{session:{userId:o=""}={}}=e,t=`users/${R(o)}`,n=`conversations/${R(r)}`,I=i(a),d=c`FOR c, e IN 1..1 OUTBOUND ${t} hasConversation
-  FILTER c._id == ${n}
+    RETURN MERGE(c, {user:user}`;
+    return db.query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw error;
+    });
+};
+export const getConnectionByConvo = (context, convoId)=>{
+    const { session: { userId: sessionId = '' } = {} } = context;
+    const sessionDocId = `users/${parseId(sessionId)}`;
+    const convoDocId = `conversations/${parseId(convoId)}`;
+    const db = useDb(databaseName);
+    const aqlQry = aql`FOR c, e IN 1..1 OUTBOUND ${sessionDocId} hasConversation
+  FILTER c._id == ${convoDocId}
   LIMIT 1
   LET u = (
-    FOR inUser, inEdge IN 1..1 INBOUND ${n} hasConversation
+    FOR inUser, inEdge IN 1..1 INBOUND ${convoDocId} hasConversation
     FOR n IN connections
     FILTER inUser.userId == n.userId
     RETURN n.connectionId
   )
-  RETURN u`;return I.query(d).then(s=>s.all()).catch(s=>{throw s})},q=e=>{const r=E(e,32),o=i(a),t=c`FOR c IN connections
-      FILTER c.connectionId == ${r}
+  RETURN u`;
+    return db.query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        throw error;
+    });
+};
+export const removeConnection = (connectionId)=>{
+    // const action: string = 'delete';
+    const formatConnId = parseString(connectionId, 32);
+    const db = useDb(databaseName);
+    const aqlQry = aql`FOR c IN connections
+      FILTER c.connectionId == ${formatConnId}
       LIMIT 1
       REMOVE c IN connections
-      RETURN OLD`;return o.query(t).then(n=>n.next()).catch(n=>{throw n})};export{g as addConnection,D as getConnectionByConvo,U as getConnectionById,C as getConnectionByUserId,q as removeConnection};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/lambdas/actions/websockets.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 {aql, Database} from 'arangojs';\n\nimport {createHash, parseId, parseString} from '@nlabs/utils/parsers/strings';\nimport {useDb} from '../../utils/arangodbUtils.js';\nimport {getSession} from '../../utils/sessionUtils.js';\n\nimport type {AqlQuery} from 'arangojs/aql';\nimport type {ApiContext} from '../../types/auth.types.js';\nimport type {WebsocketConnection} from '../../types/websockets.types.js';\nconst {ARANGODB_DATABASE: databaseName} = process.env;\n\nexport const addConnection = async (connectionId: string, token: string): Promise<WebsocketConnection> => {\n  // const action: string = 'delete';\n  const formatConnId: string = parseString(connectionId, 32);\n\n  // Verifies token\n  const {userId} = getSession(token);\n\n  if(!userId) {\n    return {\n      _key: '',\n      socketId: '',\n      userId: ''\n    };\n  }\n\n  try {\n    const db: Database = useDb(databaseName);\n    const update = {\n      connectionId: formatConnId,\n      modified: Date.now()\n    };\n    const insert = {\n      ...update,\n      _key: createHash(`connection-${formatConnId}`),\n      userId\n    };\n    const aqlQry: AqlQuery = aql`UPSERT {userId: ${insert.userId}}\n      INSERT ${insert}\n      UPDATE ${update}\n      IN connections RETURN NEW`;\n\n    return db.query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => {\n        throw error;\n      });\n  } catch(error) {\n    console.log('parseContext::error', error);\n    throw new Error('Unauthorized Context');\n  }\n};\n\nexport const getConnectionByUserId = (userId?: string): Promise<WebsocketConnection> => {\n  const formatUserId: string = parseId(userId);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.userId == ${formatUserId}\n    LIMIT 1\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionById = (socketId: string): Promise<WebsocketConnection> => {\n  const formatSocketId: string = parseString(socketId, 32);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.connectionId == ${formatSocketId}\n    LET user = FIRST(\n      FOR u IN users\n      FILTER u.userId == c.userId\n      LIMIT 1\n      RETURN u;\n    )\n    LIMIT 1\n    RETURN MERGE(c, {user:user}`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionByConvo = (context: ApiContext, convoId: string): Promise<WebsocketConnection[]> => {\n  const {session: {userId: sessionId = ''} = {}} = context;\n  const sessionDocId: string = `users/${parseId(sessionId)}`;\n  const convoDocId: string = `conversations/${parseId(convoId)}`;\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c, e IN 1..1 OUTBOUND ${sessionDocId} hasConversation\n  FILTER c._id == ${convoDocId}\n  LIMIT 1\n  LET u = (\n    FOR inUser, inEdge IN 1..1 INBOUND ${convoDocId} hasConversation\n    FOR n IN connections\n    FILTER inUser.userId == n.userId\n    RETURN n.connectionId\n  )\n  RETURN u`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const removeConnection = (connectionId: string): Promise<WebsocketConnection> => {\n  // const action: string = 'delete';\n  const formatConnId: string = parseString(connectionId, 32);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n      FILTER c.connectionId == ${formatConnId}\n      LIMIT 1\n      REMOVE c IN connections\n      RETURN OLD`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n"],
  "mappings": "AAIA,OAAQ,OAAAA,MAAoB,WAE5B,OAAQ,cAAAC,EAAY,WAAAC,EAAS,eAAAC,MAAkB,+BAC/C,OAAQ,SAAAC,MAAY,+BACpB,OAAQ,cAAAC,MAAiB,8BAKzB,KAAM,CAAC,kBAAmBC,CAAY,EAAI,QAAQ,IAErCC,EAAgB,MAAOC,EAAsBC,IAAgD,CAExG,MAAMC,EAAuBP,EAAYK,EAAc,EAAE,EAGnD,CAAC,OAAAG,CAAM,EAAIN,EAAWI,CAAK,EAEjC,GAAG,CAACE,EACF,MAAO,CACL,KAAM,GACN,SAAU,GACV,OAAQ,EACV,EAGF,GAAI,CACF,MAAMC,EAAeR,EAAME,CAAY,EACjCO,EAAS,CACb,aAAcH,EACd,SAAU,KAAK,IAAI,CACrB,EACMI,EAAS,CACb,GAAGD,EACH,KAAMZ,EAAW,cAAcS,CAAY,EAAE,EAC7C,OAAAC,CACF,EACMI,EAAmBf,oBAAsBc,EAAO,MAAM;AAAA,eACjDA,CAAM;AAAA,eACND,CAAM;AAAA,iCAGjB,OAAOD,EAAG,MAAMG,CAAM,EACnB,KAAMC,GAAWA,EAAO,KAAK,CAAC,EAC9B,MAAOC,GAAiB,CACvB,MAAMA,CACR,CAAC,CACL,MAAe,CAEb,MAAM,IAAI,MAAM,sBAAsB,CACxC,CACF,EAEaC,EAAyBP,GAAkD,CACtF,MAAMQ,EAAuBjB,EAAQS,CAAM,EACrCC,EAAeR,EAAME,CAAY,EACjCS,EAASf;AAAA,yBACQmB,CAAY;AAAA;AAAA,cAInC,OAAOP,EAAG,MAAMG,CAAM,EACnB,KAAMC,GAAWA,EAAO,KAAK,CAAC,EAC9B,MAAOC,GAAiB,CACvB,MAAMA,CACR,CAAC,CACL,EAEaG,EAAqBC,GAAmD,CACnF,MAAMC,EAAyBnB,EAAYkB,EAAU,EAAE,EACjDT,EAAeR,EAAME,CAAY,EACjCS,EAASf;AAAA,+BACcsB,CAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAU3C,OAAOV,EAAG,MAAMG,CAAM,EACnB,KAAMC,GAAWA,EAAO,KAAK,CAAC,EAC9B,MAAOC,GAAiB,CACvB,MAAMA,CACR,CAAC,CACL,EAEaM,EAAuB,CAACC,EAAqBC,IAAoD,CAC5G,KAAM,CAAC,QAAS,CAAC,OAAQC,EAAY,EAAE,EAAI,CAAC,CAAC,EAAIF,EAC3CG,EAAuB,SAASzB,EAAQwB,CAAS,CAAC,GAClDE,EAAqB,iBAAiB1B,EAAQuB,CAAO,CAAC,GACtDb,EAAeR,EAAME,CAAY,EACjCS,EAASf,8BAAgC2B,CAAY;AAAA,oBACzCC,CAAU;AAAA;AAAA;AAAA,yCAGWA,CAAU;AAAA;AAAA;AAAA;AAAA;AAAA,YAOjD,OAAOhB,EAAG,MAAMG,CAAM,EACnB,KAAMC,GAAWA,EAAO,IAAI,CAAC,EAC7B,MAAOC,GAAiB,CACvB,MAAMA,CACR,CAAC,CACL,EAEaY,EAAoBrB,GAAuD,CAEtF,MAAME,EAAuBP,EAAYK,EAAc,EAAE,EACnDI,EAAeR,EAAME,CAAY,EACjCS,EAASf;AAAA,iCACgBU,CAAY;AAAA;AAAA;AAAA,kBAK3C,OAAOE,EAAG,MAAMG,CAAM,EACnB,KAAMC,GAAWA,EAAO,KAAK,CAAC,EAC9B,MAAOC,GAAiB,CACvB,MAAMA,CACR,CAAC,CACL",
  "names": ["aql", "createHash", "parseId", "parseString", "useDb", "getSession", "databaseName", "addConnection", "connectionId", "token", "formatConnId", "userId", "db", "update", "insert", "aqlQry", "cursor", "error", "getConnectionByUserId", "formatUserId", "getConnectionById", "socketId", "formatSocketId", "getConnectionByConvo", "context", "convoId", "sessionId", "sessionDocId", "convoDocId", "removeConnection"]
}

+      RETURN OLD`;
+    return db.query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw error;
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/lambdas/actions/websockets.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 {aql, Database} from 'arangojs';\n\nimport {createHash, parseId, parseString} from '@nlabs/utils/parsers/strings';\nimport {useDb} from '../../utils/arangodbUtils.js';\nimport {getSession} from '../../utils/sessionUtils.js';\n\nimport type {AqlQuery} from 'arangojs/aql';\nimport type {ApiContext} from '../../types/auth.types.js';\nimport type {WebsocketConnection} from '../../types/websockets.types.js';\nconst {ARANGODB_DATABASE: databaseName} = process.env;\n\nexport const addConnection = async (connectionId: string, token: string): Promise<WebsocketConnection> => {\n  // const action: string = 'delete';\n  const formatConnId: string = parseString(connectionId, 32);\n\n  // Verifies token\n  const {userId} = getSession(token);\n\n  if(!userId) {\n    return {\n      _key: '',\n      socketId: '',\n      userId: ''\n    };\n  }\n\n  try {\n    const db: Database = useDb(databaseName);\n    const update = {\n      connectionId: formatConnId,\n      modified: Date.now()\n    };\n    const insert = {\n      ...update,\n      _key: createHash(`connection-${formatConnId}`),\n      userId\n    };\n    const aqlQry: AqlQuery = aql`UPSERT {userId: ${insert.userId}}\n      INSERT ${insert}\n      UPDATE ${update}\n      IN connections RETURN NEW`;\n\n    return db.query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => {\n        throw error;\n      });\n  } catch(error) {\n    console.log('parseContext::error', error);\n    throw new Error('Unauthorized Context');\n  }\n};\n\nexport const getConnectionByUserId = (userId?: string): Promise<WebsocketConnection> => {\n  const formatUserId: string = parseId(userId);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.userId == ${formatUserId}\n    LIMIT 1\n    RETURN c`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionById = (socketId: string): Promise<WebsocketConnection> => {\n  const formatSocketId: string = parseString(socketId, 32);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n    FILTER c.connectionId == ${formatSocketId}\n    LET user = FIRST(\n      FOR u IN users\n      FILTER u.userId == c.userId\n      LIMIT 1\n      RETURN u;\n    )\n    LIMIT 1\n    RETURN MERGE(c, {user:user}`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionByConvo = (context: ApiContext, convoId: string): Promise<WebsocketConnection[]> => {\n  const {session: {userId: sessionId = ''} = {}} = context;\n  const sessionDocId: string = `users/${parseId(sessionId)}`;\n  const convoDocId: string = `conversations/${parseId(convoId)}`;\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c, e IN 1..1 OUTBOUND ${sessionDocId} hasConversation\n  FILTER c._id == ${convoDocId}\n  LIMIT 1\n  LET u = (\n    FOR inUser, inEdge IN 1..1 INBOUND ${convoDocId} hasConversation\n    FOR n IN connections\n    FILTER inUser.userId == n.userId\n    RETURN n.connectionId\n  )\n  RETURN u`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const removeConnection = (connectionId: string): Promise<WebsocketConnection> => {\n  // const action: string = 'delete';\n  const formatConnId: string = parseString(connectionId, 32);\n  const db: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c IN connections\n      FILTER c.connectionId == ${formatConnId}\n      LIMIT 1\n      REMOVE c IN connections\n      RETURN OLD`;\n\n  return db.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n"],"names":["aql","createHash","parseId","parseString","useDb","getSession","ARANGODB_DATABASE","databaseName","process","env","addConnection","connectionId","token","formatConnId","userId","_key","socketId","db","update","modified","Date","now","insert","aqlQry","query","then","cursor","next","catch","error","console","log","Error","getConnectionByUserId","formatUserId","getConnectionById","formatSocketId","getConnectionByConvo","context","convoId","session","sessionId","sessionDocId","convoDocId","all","removeConnection"],"mappings":"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"}

package/lib/lambdas/authorizer.d.ts

@@ -18,3 +18,4 @@ export declare const generateAuthResponse: (principalId: any, effect: any, metho
     };
 };
 export declare const authorizer: (event: any, context: any, callback: any) => any;
+//# sourceMappingURL=authorizer.d.ts.map

package/lib/lambdas/authorizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorizer.d.ts","sourceRoot":"","sources":["../../src/lambdas/authorizer.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,sBAAsB,GAAI,WAAM,EAAE,cAAS;;;;;;;CAiBvD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,gBAAW,EAAE,WAAM,EAAE,cAAS;;;;;;;;;;CAOlE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,UAAK,EAAE,YAAO,EAAE,aAAQ,QAelD,CAAC"}

package/lib/lambdas/authorizer.js

@@ -1,2 +1,41 @@
-import{getSession as c}from"../utils/sessionUtils.js";const l=(e,n)=>!e||!n?null:{Version:"2012-10-17",Statement:[{Action:"execute-api:Invoke",Effect:e,Resource:n}]},i=(e,n,t)=>{const o=l(n,t);return{principalId:e,policyDocument:o}},m=(e,n,t)=>{const{authorizationToken:o="",methodArn:r}=e,s=o.replace(/bearer/i,"").trim();if(!s||!r)return t(null,"Unauthorized");const u=c(s);return u?.userId?t(null,i(u.userId,"Allow",r)):t(null,i(u?.userId,"Deny",r))};export{m as authorizer,i as generateAuthResponse,l as generatePolicyDocument};
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Copyright (c) 2021-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { getSession } from '../utils/sessionUtils.js';
+export const generatePolicyDocument = (effect, methodArn)=>{
+    if (!effect || !methodArn) {
+        return null;
+    }
+    const policyDocument = {
+        Version: '2012-10-17',
+        Statement: [
+            {
+                Action: 'execute-api:Invoke',
+                Effect: effect,
+                Resource: methodArn
+            }
+        ]
+    };
+    return policyDocument;
+};
+export const generateAuthResponse = (principalId, effect, methodArn)=>{
+    const policyDocument = generatePolicyDocument(effect, methodArn);
+    return {
+        principalId,
+        policyDocument
+    };
+};
+export const authorizer = (event, context, callback)=>{
+    const { authorizationToken = '', methodArn } = event;
+    const token = authorizationToken.replace(/bearer/i, '').trim();
+    if (!token || !methodArn) {
+        return callback(null, 'Unauthorized');
+    }
+    const session = getSession(token);
+    if (session?.userId) {
+        return callback(null, generateAuthResponse(session.userId, 'Allow', methodArn));
+    }
+    return callback(null, generateAuthResponse(session?.userId, 'Deny', methodArn));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas/connection.d.ts

@@ -10,3 +10,4 @@ export declare const defaultHandler: (event: any) => Promise<{
 export declare const messageHandler: (event: any) => Promise<{
     statusCode: number;
 }>;
+//# sourceMappingURL=connection.d.ts.map

package/lib/lambdas/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../src/lambdas/connection.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,cAAc,GAAU,UAAK;;;;;EAqBzC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,UAAK;;EAOzC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,UAAK;;EA+BzC,CAAC"}

package/lib/lambdas/connection.js

@@ -1,2 +1,85 @@
-import{getConversation as k}from"../actions/conversations.js";import{Config as b}from"../config.js";import{useDb as v}from"../utils/arangodbUtils.js";import{addConnection as x,getConnectionById as N,getConnectionByUserId as S,removeConnection as T}from"./actions/websockets.js";import{parseMessage as A}from"./utils/message.js";import{wsClient as i}from"./utils/websocket.js";const n={statusCode:200},p={statusCode:500},{ARANGODB_DATABASE:B}=process.env,D=t=>({config:b.get(),database:v(B),session:{userId:t}}),P=async t=>{i.setupClient(t);const{queryStringParameters:o={},requestContext:a}=t,{connectionId:e,eventType:s}=a,{token:r}=o;try{return s==="CONNECT"?(await x(e,r),n):s==="DISCONNECT"?(await T(e),n):{...p,message:"Unknown type"}}catch(c){return{...p,message:c.message}}},U=async t=>(await i.send(t,{event:"error",message:"invalid action type"}),n),W=async t=>{const{body:o,requestContext:a}=t,{socketId:e}=a,s=JSON.parse(o).data,{conversationId:r="",content:c=""}=s,u=A(c),g=await N(e),{userId:C}=g,y=D(C),f=await k(y,r),{users:l=[]}=f;return await Promise.all(l.map(async w=>{const{userId:I}=w,m=await S(I);if(m){const{socketId:d}=m;d&&i.send(d,{action:"reaktorMessage",data:u})}})),n};export{P as connectHandler,U as defaultHandler,W as messageHandler};
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Copyright (c) 2021-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { getConversation } from '../actions/conversations.js';
+import { Config } from '../config.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { addConnection, getConnectionById, getConnectionByUserId, removeConnection } from './actions/websockets.js';
+import { parseMessage } from './utils/message.js';
+import { wsClient } from './utils/websocket.js';
+const successStatus = {
+    statusCode: 200
+};
+const errorStatus = {
+    statusCode: 500
+};
+const { ARANGODB_DATABASE: databaseName } = process.env;
+const getBasicContext = (userId)=>({
+        config: Config.get(),
+        database: useDb(databaseName),
+        session: {
+            userId
+        }
+    });
+export const connectHandler = async (event)=>{
+    // We do this so first connect EVER sets up some needed config state in db
+    // this goes away after CloudFormation support is added for web sockets
+    wsClient.setupClient(event);
+    const { queryStringParameters = {}, requestContext } = event;
+    const { connectionId, eventType } = requestContext;
+    const { token } = queryStringParameters;
+    try {
+        if (eventType === 'CONNECT') {
+            await addConnection(connectionId, token);
+            return successStatus;
+        } else if (eventType === 'DISCONNECT') {
+            await removeConnection(connectionId);
+            return successStatus;
+        }
+        return {
+            ...errorStatus,
+            message: 'Unknown type'
+        };
+    } catch (error) {
+        return {
+            ...errorStatus,
+            message: error.message
+        };
+    }
+};
+export const defaultHandler = async (event)=>{
+    await wsClient.send(event, {
+        event: 'error',
+        message: 'invalid action type'
+    });
+    return successStatus;
+};
+export const messageHandler = async (event)=>{
+    const { body, requestContext } = event;
+    const { socketId } = requestContext;
+    const message = JSON.parse(body).data;
+    const { conversationId = '', content = '' } = message;
+    const formatContent = parseMessage(content);
+    // Get current user by connection
+    const connection = await getConnectionById(socketId);
+    const { userId } = connection;
+    const authContext = getBasicContext(userId);
+    const conversation = await getConversation(authContext, conversationId);
+    const { users = [] } = conversation;
+    await Promise.all(users.map(async (user)=>{
+        const { userId } = user;
+        const connection = await getConnectionByUserId(userId);
+        if (connection) {
+            const { socketId } = connection;
+            if (socketId) {
+                wsClient.send(socketId, {
+                    action: 'reaktorMessage',
+                    data: formatContent
+                });
+            }
+        }
+    }));
+    return successStatus;
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3Ivc3JjL2xhbWJkYXMvY29ubmVjdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAyMS1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IHtnZXRDb252ZXJzYXRpb259IGZyb20gJy4uL2FjdGlvbnMvY29udmVyc2F0aW9ucy5qcyc7XG5pbXBvcnQge0NvbmZpZ30gZnJvbSAnLi4vY29uZmlnLmpzJztcbmltcG9ydCB7dXNlRGJ9IGZyb20gJy4uL3V0aWxzL2FyYW5nb2RiVXRpbHMuanMnO1xuaW1wb3J0IHthZGRDb25uZWN0aW9uLCBnZXRDb25uZWN0aW9uQnlJZCwgZ2V0Q29ubmVjdGlvbkJ5VXNlcklkLCByZW1vdmVDb25uZWN0aW9ufSBmcm9tICcuL2FjdGlvbnMvd2Vic29ja2V0cy5qcyc7XG5pbXBvcnQge3BhcnNlTWVzc2FnZX0gZnJvbSAnLi91dGlscy9tZXNzYWdlLmpzJztcbmltcG9ydCB7d3NDbGllbnR9IGZyb20gJy4vdXRpbHMvd2Vic29ja2V0LmpzJztcblxuaW1wb3J0IHR5cGUge1dlYnNvY2tldE1lc3NhZ2VUeXBlfSBmcm9tICcuLi90eXBlcy93ZWJzb2NrZXRzLnR5cGVzLmpzJztcblxuY29uc3Qgc3VjY2Vzc1N0YXR1cyA9IHtzdGF0dXNDb2RlOiAyMDB9O1xuY29uc3QgZXJyb3JTdGF0dXMgPSB7c3RhdHVzQ29kZTogNTAwfTtcbmNvbnN0IHtBUkFOR09EQl9EQVRBQkFTRTogZGF0YWJhc2VOYW1lfSA9IHByb2Nlc3MuZW52O1xuY29uc3QgZ2V0QmFzaWNDb250ZXh0ID0gKHVzZXJJZDogc3RyaW5nKSA9PiAoe2NvbmZpZzogQ29uZmlnLmdldCgpLCBkYXRhYmFzZTogdXNlRGIoZGF0YWJhc2VOYW1lKSwgc2Vzc2lvbjoge3VzZXJJZH19KTtcblxuZXhwb3J0IGNvbnN0IGNvbm5lY3RIYW5kbGVyID0gYXN5bmMgKGV2ZW50KSA9PiB7XG4gIC8vIFdlIGRvIHRoaXMgc28gZmlyc3QgY29ubmVjdCBFVkVSIHNldHMgdXAgc29tZSBuZWVkZWQgY29uZmlnIHN0YXRlIGluIGRiXG4gIC8vIHRoaXMgZ29lcyBhd2F5IGFmdGVyIENsb3VkRm9ybWF0aW9uIHN1cHBvcnQgaXMgYWRkZWQgZm9yIHdlYiBzb2NrZXRzXG4gIHdzQ2xpZW50LnNldHVwQ2xpZW50KGV2ZW50KTtcbiAgY29uc3Qge3F1ZXJ5U3RyaW5nUGFyYW1ldGVycyA9IHt9LCByZXF1ZXN0Q29udGV4dH0gPSBldmVudDtcbiAgY29uc3Qge2Nvbm5lY3Rpb25JZCwgZXZlbnRUeXBlfSA9IHJlcXVlc3RDb250ZXh0O1xuICBjb25zdCB7dG9rZW59ID0gcXVlcnlTdHJpbmdQYXJhbWV0ZXJzO1xuXG4gIHRyeSB7XG4gICAgaWYoZXZlbnRUeXBlID09PSAnQ09OTkVDVCcpIHtcbiAgICAgIGF3YWl0IGFkZENvbm5lY3Rpb24oY29ubmVjdGlvbklkLCB0b2tlbik7XG4gICAgICByZXR1cm4gc3VjY2Vzc1N0YXR1cztcbiAgICB9IGVsc2UgaWYoZXZlbnRUeXBlID09PSAnRElTQ09OTkVDVCcpIHtcbiAgICAgIGF3YWl0IHJlbW92ZUNvbm5lY3Rpb24oY29ubmVjdGlvbklkKTtcbiAgICAgIHJldHVybiBzdWNjZXNzU3RhdHVzO1xuICAgIH1cblxuICAgIHJldHVybiB7Li4uZXJyb3JTdGF0dXMsIG1lc3NhZ2U6ICdVbmtub3duIHR5cGUnfTtcbiAgfSBjYXRjaChlcnJvcikge1xuICAgIHJldHVybiB7Li4uZXJyb3JTdGF0dXMsIG1lc3NhZ2U6IGVycm9yLm1lc3NhZ2V9O1xuICB9XG59O1xuXG5leHBvcnQgY29uc3QgZGVmYXVsdEhhbmRsZXIgPSBhc3luYyAoZXZlbnQpID0+IHtcbiAgYXdhaXQgd3NDbGllbnQuc2VuZChldmVudCwge1xuICAgIGV2ZW50OiAnZXJyb3InLFxuICAgIG1lc3NhZ2U6ICdpbnZhbGlkIGFjdGlvbiB0eXBlJ1xuICB9KTtcblxuICByZXR1cm4gc3VjY2Vzc1N0YXR1cztcbn07XG5cbmV4cG9ydCBjb25zdCBtZXNzYWdlSGFuZGxlciA9IGFzeW5jIChldmVudCkgPT4ge1xuICBjb25zdCB7Ym9keSwgcmVxdWVzdENvbnRleHR9ID0gZXZlbnQ7XG4gIGNvbnN0IHtzb2NrZXRJZH0gPSByZXF1ZXN0Q29udGV4dDtcbiAgY29uc3QgbWVzc2FnZTogV2Vic29ja2V0TWVzc2FnZVR5cGUgPSBKU09OLnBhcnNlKGJvZHkpLmRhdGE7XG4gIGNvbnN0IHtjb252ZXJzYXRpb25JZCA9ICcnLCBjb250ZW50ID0gJyd9ID0gbWVzc2FnZTtcbiAgY29uc3QgZm9ybWF0Q29udGVudDogc3RyaW5nID0gcGFyc2VNZXNzYWdlKGNvbnRlbnQpO1xuXG4gIC8vIEdldCBjdXJyZW50IHVzZXIgYnkgY29ubmVjdGlvblxuICBjb25zdCBjb25uZWN0aW9uID0gYXdhaXQgZ2V0Q29ubmVjdGlvbkJ5SWQoc29ja2V0SWQpO1xuICBjb25zdCB7dXNlcklkfSA9IGNvbm5lY3Rpb247XG4gIGNvbnN0IGF1dGhDb250ZXh0ID0gZ2V0QmFzaWNDb250ZXh0KHVzZXJJZCk7XG4gIGNvbnN0IGNvbnZlcnNhdGlvbiA9IGF3YWl0IGdldENvbnZlcnNhdGlvbihhdXRoQ29udGV4dCwgY29udmVyc2F0aW9uSWQpO1xuICBjb25zdCB7dXNlcnMgPSBbXX0gPSBjb252ZXJzYXRpb247XG5cbiAgYXdhaXQgUHJvbWlzZS5hbGwodXNlcnMubWFwKGFzeW5jICh1c2VyKSA9PiB7XG4gICAgY29uc3Qge3VzZXJJZH0gPSB1c2VyO1xuICAgIGNvbnN0IGNvbm5lY3Rpb24gPSBhd2FpdCBnZXRDb25uZWN0aW9uQnlVc2VySWQodXNlcklkKTtcblxuICAgIGlmKGNvbm5lY3Rpb24pIHtcbiAgICAgIGNvbnN0IHtzb2NrZXRJZH0gPSBjb25uZWN0aW9uO1xuXG4gICAgICBpZihzb2NrZXRJZCkge1xuICAgICAgICB3c0NsaWVudC5zZW5kKHNvY2tldElkLCB7XG4gICAgICAgICAgYWN0aW9uOiAncmVha3Rvck1lc3NhZ2UnLFxuICAgICAgICAgIGRhdGE6IGZvcm1hdENvbnRlbnRcbiAgICAgICAgfSk7XG4gICAgICB9XG4gICAgfVxuICB9KSk7XG5cbiAgcmV0dXJuIHN1Y2Nlc3NTdGF0dXM7XG59O1xuIl0sIm5hbWVzIjpbImdldENvbnZlcnNhdGlvbiIsIkNvbmZpZyIsInVzZURiIiwiYWRkQ29ubmVjdGlvbiIsImdldENvbm5lY3Rpb25CeUlkIiwiZ2V0Q29ubmVjdGlvbkJ5VXNlcklkIiwicmVtb3ZlQ29ubmVjdGlvbiIsInBhcnNlTWVzc2FnZSIsIndzQ2xpZW50Iiwic3VjY2Vzc1N0YXR1cyIsInN0YXR1c0NvZGUiLCJlcnJvclN0YXR1cyIsIkFSQU5HT0RCX0RBVEFCQVNFIiwiZGF0YWJhc2VOYW1lIiwicHJvY2VzcyIsImVudiIsImdldEJhc2ljQ29udGV4dCIsInVzZXJJZCIsImNvbmZpZyIsImdldCIsImRhdGFiYXNlIiwic2Vzc2lvbiIsImNvbm5lY3RIYW5kbGVyIiwiZXZlbnQiLCJzZXR1cENsaWVudCIsInF1ZXJ5U3RyaW5nUGFyYW1ldGVycyIsInJlcXVlc3RDb250ZXh0IiwiY29ubmVjdGlvbklkIiwiZXZlbnRUeXBlIiwidG9rZW4iLCJtZXNzYWdlIiwiZXJyb3IiLCJkZWZhdWx0SGFuZGxlciIsInNlbmQiLCJtZXNzYWdlSGFuZGxlciIsImJvZHkiLCJzb2NrZXRJZCIsIkpTT04iLCJwYXJzZSIsImRhdGEiLCJjb252ZXJzYXRpb25JZCIsImNvbnRlbnQiLCJmb3JtYXRDb250ZW50IiwiY29ubmVjdGlvbiIsImF1dGhDb250ZXh0IiwiY29udmVyc2F0aW9uIiwidXNlcnMiLCJQcm9taXNlIiwiYWxsIiwibWFwIiwidXNlciIsImFjdGlvbiJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDLEdBQ0QsU0FBUUEsZUFBZSxRQUFPLDhCQUE4QjtBQUM1RCxTQUFRQyxNQUFNLFFBQU8sZUFBZTtBQUNwQyxTQUFRQyxLQUFLLFFBQU8sNEJBQTRCO0FBQ2hELFNBQVFDLGFBQWEsRUFBRUMsaUJBQWlCLEVBQUVDLHFCQUFxQixFQUFFQyxnQkFBZ0IsUUFBTywwQkFBMEI7QUFDbEgsU0FBUUMsWUFBWSxRQUFPLHFCQUFxQjtBQUNoRCxTQUFRQyxRQUFRLFFBQU8sdUJBQXVCO0FBSTlDLE1BQU1DLGdCQUFnQjtJQUFDQyxZQUFZO0FBQUc7QUFDdEMsTUFBTUMsY0FBYztJQUFDRCxZQUFZO0FBQUc7QUFDcEMsTUFBTSxFQUFDRSxtQkFBbUJDLFlBQVksRUFBQyxHQUFHQyxRQUFRQyxHQUFHO0FBQ3JELE1BQU1DLGtCQUFrQixDQUFDQyxTQUFvQixDQUFBO1FBQUNDLFFBQVFqQixPQUFPa0IsR0FBRztRQUFJQyxVQUFVbEIsTUFBTVc7UUFBZVEsU0FBUztZQUFDSjtRQUFNO0lBQUMsQ0FBQTtBQUVwSCxPQUFPLE1BQU1LLGlCQUFpQixPQUFPQztJQUNuQywwRUFBMEU7SUFDMUUsdUVBQXVFO0lBQ3ZFZixTQUFTZ0IsV0FBVyxDQUFDRDtJQUNyQixNQUFNLEVBQUNFLHdCQUF3QixDQUFDLENBQUMsRUFBRUMsY0FBYyxFQUFDLEdBQUdIO0lBQ3JELE1BQU0sRUFBQ0ksWUFBWSxFQUFFQyxTQUFTLEVBQUMsR0FBR0Y7SUFDbEMsTUFBTSxFQUFDRyxLQUFLLEVBQUMsR0FBR0o7SUFFaEIsSUFBSTtRQUNGLElBQUdHLGNBQWMsV0FBVztZQUMxQixNQUFNekIsY0FBY3dCLGNBQWNFO1lBQ2xDLE9BQU9wQjtRQUNULE9BQU8sSUFBR21CLGNBQWMsY0FBYztZQUNwQyxNQUFNdEIsaUJBQWlCcUI7WUFDdkIsT0FBT2xCO1FBQ1Q7UUFFQSxPQUFPO1lBQUMsR0FBR0UsV0FBVztZQUFFbUIsU0FBUztRQUFjO0lBQ2pELEVBQUUsT0FBTUMsT0FBTztRQUNiLE9BQU87WUFBQyxHQUFHcEIsV0FBVztZQUFFbUIsU0FBU0MsTUFBTUQsT0FBTztRQUFBO0lBQ2hEO0FBQ0YsRUFBRTtBQUVGLE9BQU8sTUFBTUUsaUJBQWlCLE9BQU9UO0lBQ25DLE1BQU1mLFNBQVN5QixJQUFJLENBQUNWLE9BQU87UUFDekJBLE9BQU87UUFDUE8sU0FBUztJQUNYO0lBRUEsT0FBT3JCO0FBQ1QsRUFBRTtBQUVGLE9BQU8sTUFBTXlCLGlCQUFpQixPQUFPWDtJQUNuQyxNQUFNLEVBQUNZLElBQUksRUFBRVQsY0FBYyxFQUFDLEdBQUdIO0lBQy9CLE1BQU0sRUFBQ2EsUUFBUSxFQUFDLEdBQUdWO0lBQ25CLE1BQU1JLFVBQWdDTyxLQUFLQyxLQUFLLENBQUNILE1BQU1JLElBQUk7SUFDM0QsTUFBTSxFQUFDQyxpQkFBaUIsRUFBRSxFQUFFQyxVQUFVLEVBQUUsRUFBQyxHQUFHWDtJQUM1QyxNQUFNWSxnQkFBd0JuQyxhQUFha0M7SUFFM0MsaUNBQWlDO0lBQ2pDLE1BQU1FLGFBQWEsTUFBTXZDLGtCQUFrQmdDO0lBQzNDLE1BQU0sRUFBQ25CLE1BQU0sRUFBQyxHQUFHMEI7SUFDakIsTUFBTUMsY0FBYzVCLGdCQUFnQkM7SUFDcEMsTUFBTTRCLGVBQWUsTUFBTTdDLGdCQUFnQjRDLGFBQWFKO0lBQ3hELE1BQU0sRUFBQ00sUUFBUSxFQUFFLEVBQUMsR0FBR0Q7SUFFckIsTUFBTUUsUUFBUUMsR0FBRyxDQUFDRixNQUFNRyxHQUFHLENBQUMsT0FBT0M7UUFDakMsTUFBTSxFQUFDakMsTUFBTSxFQUFDLEdBQUdpQztRQUNqQixNQUFNUCxhQUFhLE1BQU10QyxzQkFBc0JZO1FBRS9DLElBQUcwQixZQUFZO1lBQ2IsTUFBTSxFQUFDUCxRQUFRLEVBQUMsR0FBR087WUFFbkIsSUFBR1AsVUFBVTtnQkFDWDVCLFNBQVN5QixJQUFJLENBQUNHLFVBQVU7b0JBQ3RCZSxRQUFRO29CQUNSWixNQUFNRztnQkFDUjtZQUNGO1FBQ0Y7SUFDRjtJQUVBLE9BQU9qQztBQUNULEVBQUUifQ==

package/lib/lambdas/utils/message.d.ts

@@ -1 +1,2 @@
 export declare const parseMessage: (content: string) => string;
+//# sourceMappingURL=message.d.ts.map

package/lib/lambdas/utils/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../../src/lambdas/utils/message.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,KAAG,MAG7C,CAAC"}

package/lib/lambdas/utils/message.js

@@ -1,2 +1,20 @@
-import s from"sanitize-html";const r=e=>s(e,{allowedAttributes:{},allowedTags:["ul","ol","b","i","em","strike","pre","strong","li"]});export{r as parseMessage};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2xhbWJkYXMvdXRpbHMvbWVzc2FnZS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMjEtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCBzYW5pdGl6ZSBmcm9tICdzYW5pdGl6ZS1odG1sJztcblxuZXhwb3J0IGNvbnN0IHBhcnNlTWVzc2FnZSA9IChjb250ZW50OiBzdHJpbmcpOiBzdHJpbmcgPT4gc2FuaXRpemUoY29udGVudCwge1xuICBhbGxvd2VkQXR0cmlidXRlczoge30sXG4gIGFsbG93ZWRUYWdzOiBbJ3VsJywgJ29sJywgJ2InLCAnaScsICdlbScsICdzdHJpa2UnLCAncHJlJywgJ3N0cm9uZycsICdsaSddXG59KTtcbiJdLAogICJtYXBwaW5ncyI6ICJBQUlBLE9BQU9BLE1BQWMsZ0JBRWQsTUFBTUMsRUFBZ0JDLEdBQTRCRixFQUFTRSxFQUFTLENBQ3pFLGtCQUFtQixDQUFDLEVBQ3BCLFlBQWEsQ0FBQyxLQUFNLEtBQU0sSUFBSyxJQUFLLEtBQU0sU0FBVSxNQUFPLFNBQVUsSUFBSSxDQUMzRSxDQUFDIiwKICAibmFtZXMiOiBbInNhbml0aXplIiwgInBhcnNlTWVzc2FnZSIsICJjb250ZW50Il0KfQo=
+/**
+ * Copyright (c) 2021-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import sanitize from 'sanitize-html';
+export const parseMessage = (content)=>sanitize(content, {
+        allowedAttributes: {},
+        allowedTags: [
+            'ul',
+            'ol',
+            'b',
+            'i',
+            'em',
+            'strike',
+            'pre',
+            'strong',
+            'li'
+        ]
+    });
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3Ivc3JjL2xhbWJkYXMvdXRpbHMvbWVzc2FnZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAyMS1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IHNhbml0aXplIGZyb20gJ3Nhbml0aXplLWh0bWwnO1xuXG5leHBvcnQgY29uc3QgcGFyc2VNZXNzYWdlID0gKGNvbnRlbnQ6IHN0cmluZyk6IHN0cmluZyA9PiBzYW5pdGl6ZShjb250ZW50LCB7XG4gIGFsbG93ZWRBdHRyaWJ1dGVzOiB7fSxcbiAgYWxsb3dlZFRhZ3M6IFsndWwnLCAnb2wnLCAnYicsICdpJywgJ2VtJywgJ3N0cmlrZScsICdwcmUnLCAnc3Ryb25nJywgJ2xpJ11cbn0pO1xuIl0sIm5hbWVzIjpbInNhbml0aXplIiwicGFyc2VNZXNzYWdlIiwiY29udGVudCIsImFsbG93ZWRBdHRyaWJ1dGVzIiwiYWxsb3dlZFRhZ3MiXSwibWFwcGluZ3MiOiJBQUFBOzs7Q0FHQyxHQUNELE9BQU9BLGNBQWMsZ0JBQWdCO0FBRXJDLE9BQU8sTUFBTUMsZUFBZSxDQUFDQyxVQUE0QkYsU0FBU0UsU0FBUztRQUN6RUMsbUJBQW1CLENBQUM7UUFDcEJDLGFBQWE7WUFBQztZQUFNO1lBQU07WUFBSztZQUFLO1lBQU07WUFBVTtZQUFPO1lBQVU7U0FBSztJQUM1RSxHQUFHIn0=

package/lib/lambdas/utils/websocket.d.ts

@@ -5,3 +5,4 @@ export declare class WebsocketClient {
     send(connections: any, payload: any): Promise<boolean>;
 }
 export declare const wsClient: WebsocketClient;
+//# sourceMappingURL=websocket.d.ts.map

package/lib/lambdas/utils/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../../src/lambdas/utils/websocket.ts"],"names":[],"mappings":"AAYA,qBAAa,eAAe;IAC1B,MAAM,MAAC;gBAEK,MAAM,CAAC,KAAA;IASnB,WAAW,CAAC,MAAM,KAAA;IA+BZ,IAAI,CAAC,WAAW,KAAA,EAAE,OAAO,KAAA;CA8BhC;AAED,eAAO,MAAM,QAAQ,iBAAwB,CAAC"}