@memberjunction/server 0.9.4 → 0.9.6

package/src/context.ts

@@ -1,105 +1,105 @@
-import { IncomingMessage } from 'http';
-import * as url from 'url';
-import { JwtPayload, VerifyOptions, decode, verify } from 'jsonwebtoken';
-import 'reflect-metadata';
-import { Subject, firstValueFrom } from 'rxjs';
-import { AuthenticationError, AuthorizationError } from 'type-graphql';
-import { DataSource } from 'typeorm';
-import { getSigningKeys, validationOptions, verifyUserRecord } from './auth';
-import { authCache } from './cache';
-import { userEmailMap } from './config';
-import { UserPayload } from './types';
-
-const verifyAsync = async (
-  issuer: string,
-  options: VerifyOptions,
-  token: string
-): Promise<JwtPayload> =>
-  new Promise((resolve, reject) => {
-    verify(token, getSigningKeys(issuer), options, (err, jwt) => {
-      if (jwt && typeof jwt !== 'string' && !err) {
-        const payload = jwt.payload ?? jwt;
-
-        console.log(
-          `Valid token: ${payload.name} (${
-            payload.email ? payload.email : payload.preferred_username
-          })`
-        ); // temporary fix to check preferred_username if email is not present
-        resolve(payload);
-      } else {
-        console.warn('Invalid token');
-        reject(err);
-      }
-    });
-  });
-
-export const getUserPayload = async (
-  bearerToken: string,
-  sessionId = 'default',
-  dataSource: DataSource,
-  requestDomain?: string
-): Promise<UserPayload> => {
-  try {
-    const token = bearerToken.replace('Bearer ', '');
-
-    if (!token) {
-      console.warn('No token to validate');
-      throw new AuthenticationError('Missing token');
-    }
-
-    const payload = decode(token);
-    if (!payload || typeof payload === 'string') {
-      throw new AuthenticationError('Invalid token payload');
-    }
-
-    if (!authCache.has(token)) {
-      const issuer = payload.iss;
-      if (!issuer) {
-        console.warn('No issuer claim on token');
-        throw new AuthenticationError('Missing issuer claim on token');
-      }
-
-      await verifyAsync(issuer, validationOptions[issuer], token);
-      authCache.set(token, true);
-    }
-
-    const email = payload?.email
-      ? userEmailMap[payload?.email] ?? payload?.email
-      : payload?.preferred_username; // temporary fix to check preferred_username if email is not present
-    const fullName = payload?.name;
-    const firstName = payload?.given_name || fullName?.split(' ')[0];
-    const lastName = payload?.family_name || fullName?.split(' ')[1] || fullName?.split(' ')[0];
-    const userRecord = await verifyUserRecord(email, firstName, lastName, requestDomain, dataSource);
-
-    if (!userRecord) {
-      console.error(`User ${email} not found`); 
-      throw new AuthorizationError();
-    }
-    else if (!userRecord.IsActive) {
-      console.error(`User ${email} found but inactive`);
-      throw new AuthorizationError();
-    }
-
-    return { userRecord, email, sessionId };
-  } catch (e) {
-    return {} as UserPayload;
-  }
-};
-
-export const contextFunction =
-  ({ setupComplete$, dataSource }: { setupComplete$: Subject<unknown>; dataSource: DataSource }) =>
-  async ({ req }: { req: IncomingMessage }) => {
-    await firstValueFrom(setupComplete$); // wait for setup to complete before processing the request
-
-    const sessionIdRaw = req.headers['x-session-id'];
-    const requestDomain = url.parse(req.headers.origin || '')
-    const sessionId = sessionIdRaw ? sessionIdRaw.toString() : '';
-    const bearerToken = req.headers.authorization ?? '';
-
-    const userPayload = await getUserPayload(bearerToken, sessionId, dataSource, requestDomain?.hostname ? requestDomain.hostname : undefined);
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    console.log((req as any).body?.operationName);
-
-    return { dataSource, userPayload };
-  };
+import { IncomingMessage } from 'http';
+import * as url from 'url';
+import { JwtPayload, VerifyOptions, decode, verify } from 'jsonwebtoken';
+import 'reflect-metadata';
+import { Subject, firstValueFrom } from 'rxjs';
+import { AuthenticationError, AuthorizationError } from 'type-graphql';
+import { DataSource } from 'typeorm';
+import { getSigningKeys, validationOptions, verifyUserRecord } from './auth';
+import { authCache } from './cache';
+import { userEmailMap } from './config';
+import { UserPayload } from './types';
+
+const verifyAsync = async (
+  issuer: string,
+  options: VerifyOptions,
+  token: string
+): Promise<JwtPayload> =>
+  new Promise((resolve, reject) => {
+    verify(token, getSigningKeys(issuer), options, (err, jwt) => {
+      if (jwt && typeof jwt !== 'string' && !err) {
+        const payload = jwt.payload ?? jwt;
+
+        console.log(
+          `Valid token: ${payload.name} (${
+            payload.email ? payload.email : payload.preferred_username
+          })`
+        ); // temporary fix to check preferred_username if email is not present
+        resolve(payload);
+      } else {
+        console.warn('Invalid token');
+        reject(err);
+      }
+    });
+  });
+
+export const getUserPayload = async (
+  bearerToken: string,
+  sessionId = 'default',
+  dataSource: DataSource,
+  requestDomain?: string
+): Promise<UserPayload> => {
+  try {
+    const token = bearerToken.replace('Bearer ', '');
+
+    if (!token) {
+      console.warn('No token to validate');
+      throw new AuthenticationError('Missing token');
+    }
+
+    const payload = decode(token);
+    if (!payload || typeof payload === 'string') {
+      throw new AuthenticationError('Invalid token payload');
+    }
+
+    if (!authCache.has(token)) {
+      const issuer = payload.iss;
+      if (!issuer) {
+        console.warn('No issuer claim on token');
+        throw new AuthenticationError('Missing issuer claim on token');
+      }
+
+      await verifyAsync(issuer, validationOptions[issuer], token);
+      authCache.set(token, true);
+    }
+
+    const email = payload?.email
+      ? userEmailMap[payload?.email] ?? payload?.email
+      : payload?.preferred_username; // temporary fix to check preferred_username if email is not present
+    const fullName = payload?.name;
+    const firstName = payload?.given_name || fullName?.split(' ')[0];
+    const lastName = payload?.family_name || fullName?.split(' ')[1] || fullName?.split(' ')[0];
+    const userRecord = await verifyUserRecord(email, firstName, lastName, requestDomain, dataSource);
+
+    if (!userRecord) {
+      console.error(`User ${email} not found`); 
+      throw new AuthorizationError();
+    }
+    else if (!userRecord.IsActive) {
+      console.error(`User ${email} found but inactive`);
+      throw new AuthorizationError();
+    }
+
+    return { userRecord, email, sessionId };
+  } catch (e) {
+    return {} as UserPayload;
+  }
+};
+
+export const contextFunction =
+  ({ setupComplete$, dataSource }: { setupComplete$: Subject<unknown>; dataSource: DataSource }) =>
+  async ({ req }: { req: IncomingMessage }) => {
+    await firstValueFrom(setupComplete$); // wait for setup to complete before processing the request
+
+    const sessionIdRaw = req.headers['x-session-id'];
+    const requestDomain = url.parse(req.headers.origin || '')
+    const sessionId = sessionIdRaw ? sessionIdRaw.toString() : '';
+    const bearerToken = req.headers.authorization ?? '';
+
+    const userPayload = await getUserPayload(bearerToken, sessionId, dataSource, requestDomain?.hostname ? requestDomain.hostname : undefined);
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    console.log((req as any).body?.operationName);
+
+    return { dataSource, userPayload };
+  };

package/src/directives/Public.ts

@@ -1,42 +1,42 @@
-import { FieldMapper, MapperKind, getDirective, mapSchema } from '@graphql-tools/utils';
-import { GraphQLFieldResolver, defaultFieldResolver } from 'graphql';
-import { AuthorizationError, Directive } from 'type-graphql';
-import { AppContext, DirectiveBuilder } from '../types';
-
-const DIRECTIVE_NAME = 'Public';
-
-export function Public(): PropertyDecorator & MethodDecorator & ClassDecorator;
-export function Public(): PropertyDecorator | MethodDecorator | ClassDecorator {
-  return (targetOrPrototype, propertyKey, descriptor) =>
-    Directive(`@${DIRECTIVE_NAME}`)(targetOrPrototype, propertyKey, descriptor);
-}
-
-export const publicDirective: DirectiveBuilder = {
-  typeDefs: `directive @${DIRECTIVE_NAME} on FIELD_DEFINITION`,
-  transformer: (schema) => {
-    const fieldMapper: FieldMapper = (fieldConfig) => {
-      const directive = getDirective(schema, fieldConfig, DIRECTIVE_NAME)?.[0];
-      if (directive) {
-        return fieldConfig;
-      } else {
-        // `@Public` directive not present, so will require auth
-        const { resolve = defaultFieldResolver } = fieldConfig;
-        const directiveResolver: GraphQLFieldResolver<unknown, AppContext> = async (
-          source,
-          args,
-          context,
-          info
-        ) => {
-          // eslint-disable-next-line
-          if (!context?.userPayload?.userRecord?.IsActive) {
-            throw new AuthorizationError();
-          }
-          return await resolve(source, args, context, info);
-        };
-
-        return { ...fieldConfig, resolve: directiveResolver };
-      }
-    };
-    return mapSchema(schema, { [MapperKind.OBJECT_FIELD]: fieldMapper });
-  },
-};
+import { FieldMapper, MapperKind, getDirective, mapSchema } from '@graphql-tools/utils';
+import { GraphQLFieldResolver, defaultFieldResolver } from 'graphql';
+import { AuthorizationError, Directive } from 'type-graphql';
+import { AppContext, DirectiveBuilder } from '../types';
+
+const DIRECTIVE_NAME = 'Public';
+
+export function Public(): PropertyDecorator & MethodDecorator & ClassDecorator;
+export function Public(): PropertyDecorator | MethodDecorator | ClassDecorator {
+  return (targetOrPrototype, propertyKey, descriptor) =>
+    Directive(`@${DIRECTIVE_NAME}`)(targetOrPrototype, propertyKey, descriptor);
+}
+
+export const publicDirective: DirectiveBuilder = {
+  typeDefs: `directive @${DIRECTIVE_NAME} on FIELD_DEFINITION`,
+  transformer: (schema) => {
+    const fieldMapper: FieldMapper = (fieldConfig) => {
+      const directive = getDirective(schema, fieldConfig, DIRECTIVE_NAME)?.[0];
+      if (directive) {
+        return fieldConfig;
+      } else {
+        // `@Public` directive not present, so will require auth
+        const { resolve = defaultFieldResolver } = fieldConfig;
+        const directiveResolver: GraphQLFieldResolver<unknown, AppContext> = async (
+          source,
+          args,
+          context,
+          info
+        ) => {
+          // eslint-disable-next-line
+          if (!context?.userPayload?.userRecord?.IsActive) {
+            throw new AuthorizationError();
+          }
+          return await resolve(source, args, context, info);
+        };
+
+        return { ...fieldConfig, resolve: directiveResolver };
+      }
+    };
+    return mapSchema(schema, { [MapperKind.OBJECT_FIELD]: fieldMapper });
+  },
+};

package/src/directives/index.ts

@@ -1 +1 @@
-export * from './Public';
+export * from './Public';

package/src/index.ts

@@ -1,105 +1,105 @@
-import dotenv from 'dotenv';
-
-dotenv.config();
-
-import { expressMiddleware } from '@apollo/server/express4';
-import { mergeSchemas } from '@graphql-tools/schema';
-import { Metadata } from '@memberjunction/core';
-import { setupSQLServerClient, SQLServerProviderConfigData } from '@memberjunction/sqlserver-dataprovider';
-import { json } from 'body-parser';
-import cors from 'cors';
-import express from 'express';
-import { convertPathToPattern, globSync } from 'fast-glob';
-import { useServer } from 'graphql-ws/lib/use/ws';
-import { createServer } from 'node:http';
-import 'reflect-metadata';
-import { ReplaySubject } from 'rxjs';
-import { BuildSchemaOptions, buildSchemaSync, GraphQLTimestamp } from 'type-graphql';
-import { DataSource } from 'typeorm';
-import { WebSocketServer } from 'ws';
-import buildApolloServer from './apolloServer';
-import { configInfo, graphqlPort, graphqlRootPath, mj_core_schema, websiteRunFromPackage } from './config';
-import { contextFunction, getUserPayload } from './context';
-import { publicDirective } from './directives';
-import orm from './orm';
-
-const cacheRefreshInterval = configInfo.databaseSettings.metadataCacheRefreshInterval;
-
-export { MaxLength } from 'class-validator';
-export * from 'type-graphql';
-export { NewUserBase } from './auth/newUsers';
-export { configInfo } from './config';
-export * from './directives';
-export * from './types';
-
-export const serve = async (resolverPaths: Array<string>) => {
-  const paths = resolverPaths.flatMap((path) => globSync(convertPathToPattern(path)));
-  console.log({ resolverPaths, paths });
-
-  const dataSource = new DataSource(orm(paths));
-  const setupComplete$ = new ReplaySubject(1);
-  dataSource
-    .initialize()
-    .then(async () => {
-      const config = new SQLServerProviderConfigData(dataSource, '', mj_core_schema, cacheRefreshInterval);
-      await setupSQLServerClient(config); // datasource is already initialized, so we can setup the client right away
-      const md = new Metadata();
-      console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
-
-      setupComplete$.next(true);
-    })
-    .catch((err) => {
-      console.error('Error during Data Source initialization', err);
-    });
-
-  const dynamicModules = await Promise.all(paths.map((modulePath) => import(modulePath.replace(/\.[jt]s$/, ''))));
-  const resolvers = dynamicModules.flatMap((module) =>
-    Object.values(module).filter((value) => typeof value === 'function')
-  ) as BuildSchemaOptions['resolvers'];
-
-  const schema = publicDirective.transformer(
-    mergeSchemas({
-      schemas: [
-        buildSchemaSync({
-          resolvers,
-          validate: false,
-          scalarsMap: [{ type: Date, scalar: GraphQLTimestamp }],
-          emitSchemaFile: websiteRunFromPackage !== 1,
-        }),
-      ],
-      typeDefs: [publicDirective.typeDefs],
-    })
-  );
-
-  const app = express();
-  const httpServer = createServer(app);
-
-  const webSocketServer = new WebSocketServer({ server: httpServer, path: graphqlRootPath });
-  const serverCleanup = useServer(
-    {
-      schema,
-      context: async ({ connectionParams }) => {
-        const userPayload = await getUserPayload(String(connectionParams?.Authorization), undefined, dataSource);
-        return { userPayload };
-      },
-    },
-    webSocketServer
-  );
-
-  const apolloServer = buildApolloServer({ schema }, { httpServer, serverCleanup });
-  await apolloServer.start();
-
-  app.use(
-    graphqlRootPath,
-    cors<cors.CorsRequest>(),
-    json(),
-    expressMiddleware(apolloServer, {
-      context: contextFunction({ setupComplete$, dataSource }),
-    })
-  );
-
-  await new Promise<void>((resolve) => httpServer.listen({ port: graphqlPort }, resolve));
-  console.log(`🚀 Server ready at http://localhost:${graphqlPort}/`);
-};
-
-export default serve;
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+import { expressMiddleware } from '@apollo/server/express4';
+import { mergeSchemas } from '@graphql-tools/schema';
+import { Metadata } from '@memberjunction/core';
+import { setupSQLServerClient, SQLServerProviderConfigData } from '@memberjunction/sqlserver-dataprovider';
+import { json } from 'body-parser';
+import cors from 'cors';
+import express from 'express';
+import { convertPathToPattern, globSync } from 'fast-glob';
+import { useServer } from 'graphql-ws/lib/use/ws';
+import { createServer } from 'node:http';
+import 'reflect-metadata';
+import { ReplaySubject } from 'rxjs';
+import { BuildSchemaOptions, buildSchemaSync, GraphQLTimestamp } from 'type-graphql';
+import { DataSource } from 'typeorm';
+import { WebSocketServer } from 'ws';
+import buildApolloServer from './apolloServer';
+import { configInfo, graphqlPort, graphqlRootPath, mj_core_schema, websiteRunFromPackage } from './config';
+import { contextFunction, getUserPayload } from './context';
+import { publicDirective } from './directives';
+import orm from './orm';
+
+const cacheRefreshInterval = configInfo.databaseSettings.metadataCacheRefreshInterval;
+
+export { MaxLength } from 'class-validator';
+export * from 'type-graphql';
+export { NewUserBase } from './auth/newUsers';
+export { configInfo } from './config';
+export * from './directives';
+export * from './types';
+
+export const serve = async (resolverPaths: Array<string>) => {
+  const paths = resolverPaths.flatMap((path) => globSync(convertPathToPattern(path)));
+  console.log({ resolverPaths, paths });
+
+  const dataSource = new DataSource(orm(paths));
+  const setupComplete$ = new ReplaySubject(1);
+  dataSource
+    .initialize()
+    .then(async () => {
+      const config = new SQLServerProviderConfigData(dataSource, '', mj_core_schema, cacheRefreshInterval);
+      await setupSQLServerClient(config); // datasource is already initialized, so we can setup the client right away
+      const md = new Metadata();
+      console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
+
+      setupComplete$.next(true);
+    })
+    .catch((err) => {
+      console.error('Error during Data Source initialization', err);
+    });
+
+  const dynamicModules = await Promise.all(paths.map((modulePath) => import(modulePath.replace(/\.[jt]s$/, ''))));
+  const resolvers = dynamicModules.flatMap((module) =>
+    Object.values(module).filter((value) => typeof value === 'function')
+  ) as BuildSchemaOptions['resolvers'];
+
+  const schema = publicDirective.transformer(
+    mergeSchemas({
+      schemas: [
+        buildSchemaSync({
+          resolvers,
+          validate: false,
+          scalarsMap: [{ type: Date, scalar: GraphQLTimestamp }],
+          emitSchemaFile: websiteRunFromPackage !== 1,
+        }),
+      ],
+      typeDefs: [publicDirective.typeDefs],
+    })
+  );
+
+  const app = express();
+  const httpServer = createServer(app);
+
+  const webSocketServer = new WebSocketServer({ server: httpServer, path: graphqlRootPath });
+  const serverCleanup = useServer(
+    {
+      schema,
+      context: async ({ connectionParams }) => {
+        const userPayload = await getUserPayload(String(connectionParams?.Authorization), undefined, dataSource);
+        return { userPayload };
+      },
+    },
+    webSocketServer
+  );
+
+  const apolloServer = buildApolloServer({ schema }, { httpServer, serverCleanup });
+  await apolloServer.start();
+
+  app.use(
+    graphqlRootPath,
+    cors<cors.CorsRequest>(),
+    json(),
+    expressMiddleware(apolloServer, {
+      context: contextFunction({ setupComplete$, dataSource }),
+    })
+  );
+
+  await new Promise<void>((resolve) => httpServer.listen({ port: graphqlPort }, resolve));
+  console.log(`🚀 Server ready at http://localhost:${graphqlPort}/`);
+};
+
+export default serve;

package/src/orm.ts

@@ -1,23 +1,23 @@
-import { DataSourceOptions } from 'typeorm';
-import { configInfo, dbDatabase, dbHost, dbPassword, dbPort, dbUsername } from './config';
-
-const orm = (entities: Array<string>): DataSourceOptions => {
-  const ormConfig = {
-    type: 'mssql' as const,
-    entities,
-    logging: false,
-    host: dbHost,
-    port: dbPort,
-    username: dbUsername,
-    password: dbPassword,
-    database: dbDatabase,
-    synchronize: false,
-    requestTimeout: configInfo.databaseSettings.requestTimeout,
-    connectionTimeout: configInfo.databaseSettings.connectionTimeout,
-  };
-
-  console.log({ ormConfig: { ...ormConfig, password: '***' } });
-  return ormConfig;
-};
-
-export default orm;
+import { DataSourceOptions } from 'typeorm';
+import { configInfo, dbDatabase, dbHost, dbPassword, dbPort, dbUsername } from './config';
+
+const orm = (entities: Array<string>): DataSourceOptions => {
+  const ormConfig = {
+    type: 'mssql' as const,
+    entities,
+    logging: false,
+    host: dbHost,
+    port: dbPort,
+    username: dbUsername,
+    password: dbPassword,
+    database: dbDatabase,
+    synchronize: false,
+    requestTimeout: configInfo.databaseSettings.requestTimeout,
+    connectionTimeout: configInfo.databaseSettings.connectionTimeout,
+  };
+
+  console.log({ ormConfig: { ...ormConfig, password: '***' } });
+  return ormConfig;
+};
+
+export default orm;

package/src/types.ts

@@ -1,19 +1,19 @@
-import { GraphQLSchema } from 'graphql';
-import { DataSource, QueryRunner } from 'typeorm';
-
-export type UserPayload = {
-  email: string;
-  userRecord: any;
-  sessionId: string;
-};
-
-export type AppContext = {
-  dataSource: DataSource;
-  userPayload: UserPayload;
-  queryRunner?: QueryRunner;
-};
-
-export type DirectiveBuilder = {
-  typeDefs: string;
-  transformer: (schema: GraphQLSchema) => GraphQLSchema;
-};
+import { GraphQLSchema } from 'graphql';
+import { DataSource, QueryRunner } from 'typeorm';
+
+export type UserPayload = {
+  email: string;
+  userRecord: any;
+  sessionId: string;
+};
+
+export type AppContext = {
+  dataSource: DataSource;
+  userPayload: UserPayload;
+  queryRunner?: QueryRunner;
+};
+
+export type DirectiveBuilder = {
+  typeDefs: string;
+  transformer: (schema: GraphQLSchema) => GraphQLSchema;
+};