@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/handlers/graphqlHandler.js

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1,105 @@
+/**
+ * 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 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
+      LIMIT 1
+      RETURN u;
+    )
+    LIMIT 1
+    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 ${convoDocId} hasConversation
+    FOR n IN connections
+    FILTER inUser.userId == n.userId
+    RETURN n.connectionId
+  )
+  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 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

@@ -0,0 +1,41 @@
+/**
+ * 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

@@ -0,0 +1,85 @@
+/**
+ * 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,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

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

@@ -0,0 +1,20 @@
+/**
+ * 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"}

package/lib/lambdas/utils/websocket.js

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2021-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { ApiGatewayManagementApi } from '@aws-sdk/client-apigatewaymanagementapi';
+import { isPlainObject } from '@nlabs/utils/checks/isPlainObject';
+import { Config } from '../../config.js';
+import { removeConnection } from '../actions/websockets.js';
+const { API_ID, DOMAIN_NAME, stage } = process.env;
+export class WebsocketClient {
+    client;
+    constructor(config){
+        if (config) {
+            this.setupClient(config);
+        } else {
+            this.setupClient({
+                requestContext: {
+                    apiId: API_ID,
+                    domainName: DOMAIN_NAME,
+                    stage
+                }
+            });
+        }
+    }
+    // Allow just passing a single event to setup the client for ease of use
+    setupClient(config) {
+        if (!this.client) {
+            const { requestContext } = config;
+            const { apiId, domainName, stage } = requestContext;
+            let updatedDomainName = domainName;
+            if (apiId) {
+                updatedDomainName = `${apiId}.execute-api.${process.env.region}.amazonaws.com`;
+            }
+            let endpoint;
+            switch(stage){
+                case 'prod':
+                    endpoint = `https://${updatedDomainName}/prod`;
+                    break;
+                case 'dev':
+                    endpoint = `https://${updatedDomainName}/dev`;
+                    break;
+                default:
+                    endpoint = 'http://local.phantaze.com:3001';
+                    break;
+            }
+            this.client = new ApiGatewayManagementApi({
+                endpoint,
+                region: Config.get('aws.region')
+            });
+        }
+    }
+    async send(connections, payload) {
+        // Cheat and allow event to be passed in this also lets us default to setupClient too
+        const connectionIds = [];
+        if (isPlainObject(connections)) {
+            await this.setupClient(connections);
+            const { connectionId: connId } = connections.requestContext;
+            connectionIds.push(connId);
+        } else {
+            connectionIds.push(...connections);
+        }
+        if (this.client) {
+            await Promise.all(connectionIds.map((connectionId)=>this.client.postToConnection({
+                    ConnectionId: connectionId,
+                    Data: JSON.stringify(payload)
+                }).catch(async (postError)=>{
+                    console.log('WebsocketError::postError', JSON.stringify(postError));
+                    if (postError.statusCode === 410) {
+                        // Disconnect client
+                        await removeConnection(connectionId);
+                    }
+                })));
+        }
+        return true;
+    }
+}
+export const wsClient = new WebsocketClient();
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mocks/conversation.d.ts

@@ -6,3 +6,4 @@ export declare const mockConversation: {
     userId: string;
     users: any[];
 };
+//# sourceMappingURL=conversation.d.ts.map

package/lib/mocks/conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation.d.ts","sourceRoot":"","sources":["../../src/mocks/conversation.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;;;;CAO5B,CAAC"}

package/lib/mocks/conversation.js

@@ -0,0 +1,10 @@
+export const mockConversation = {
+    _id: 'conversations/conversation1',
+    _key: 'conversation1',
+    id: 'conversations/conversation1',
+    added: 1616508107,
+    userId: 'user1',
+    users: []
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JlYWt0b3Ivc3JjL21vY2tzL2NvbnZlcnNhdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgbW9ja0NvbnZlcnNhdGlvbiA9IHtcbiAgX2lkOiAnY29udmVyc2F0aW9ucy9jb252ZXJzYXRpb24xJyxcbiAgX2tleTogJ2NvbnZlcnNhdGlvbjEnLFxuICBpZDogJ2NvbnZlcnNhdGlvbnMvY29udmVyc2F0aW9uMScsXG4gIGFkZGVkOiAxNjE2NTA4MTA3LFxuICB1c2VySWQ6ICd1c2VyMScsXG4gIHVzZXJzOiBbXVxufTsiXSwibmFtZXMiOlsibW9ja0NvbnZlcnNhdGlvbiIsIl9pZCIsIl9rZXkiLCJpZCIsImFkZGVkIiwidXNlcklkIiwidXNlcnMiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sTUFBTUEsbUJBQW1CO0lBQzlCQyxLQUFLO0lBQ0xDLE1BQU07SUFDTkMsSUFBSTtJQUNKQyxPQUFPO0lBQ1BDLFFBQVE7SUFDUkMsT0FBTyxFQUFFO0FBQ1gsRUFBRSJ9

package/lib/mocks/file.d.ts

@@ -9,3 +9,4 @@ export declare const mockFile: {
     url: string;
     userId: string;
 };
+//# sourceMappingURL=file.d.ts.map

package/lib/mocks/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/mocks/file.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ;;;;;;;;;;CAUpB,CAAC"}