@shadimakhoul/ggcoach 1.0.0

package/types/auth.ts

@@ -0,0 +1,66 @@
+import { AccountType } from "./enums";
+
+export interface JWTPayload {
+  id: number;
+  email: string;
+  phoneNumber: string | null;
+  firstName: string;
+  lastName: string;
+  accountType: string;
+  is_active: boolean;
+  emailVerified: boolean;
+  phoneVerified: boolean;
+  tokenVersion?: number;
+  tokenType?: 'access' | 'refresh';
+}
+
+export interface UserAttributes {
+  id: number;
+  firstName: string;
+  lastName: string;
+  email: string;
+  phoneNumber: string | null;
+  password: string;
+  accountType: AccountType;
+  is_active: boolean;
+  emailVerified: boolean;
+  emailVerifiedAt?: Date | null;
+  phoneVerified: boolean;
+  phoneVerifiedAt?: Date | null;
+  tokenVersion?: number;
+  created_at?: Date;
+  updated_at?: Date;
+}
+
+declare global {
+  namespace Express {
+    interface Request {
+      user?: JWTPayload;
+    }
+  }
+}
+
+export interface UserCreationAttributes extends Omit<
+  UserAttributes,
+  | 'id'
+  | 'is_active'
+  | 'created_at'
+  | 'updated_at'
+  | 'emailVerified'
+  | 'emailVerifiedAt'
+  | 'phoneVerified'
+  | 'phoneVerifiedAt'
+> {}
+
+export interface AuthResponse {
+  success: boolean;
+  message: string;
+  data?: {
+    user: Omit<UserAttributes, 'password'>;
+    tokens: {
+      access_token: string;
+      refresh_token: string;
+    };
+  };
+  error?: string;
+}

package/types/enums/auth.ts

@@ -0,0 +1,6 @@
+export enum AccountType {
+  Client = 'Client',
+  Provider = 'Provider',
+  Admin = 'Admin',
+  SuperAdmin = 'SuperAdmin',
+}

package/types/enums/index.ts

@@ -0,0 +1 @@
+export * from './auth';

package/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./auth"
+export * from "./admin-auth"
+export * from "./enums"

package/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './jwt';
+export * from './logger';
+export * from './openapi';

package/utils/jwt.ts

@@ -0,0 +1,66 @@
+import jwt from 'jsonwebtoken';
+import { JWTPayload, UserAttributes } from '../types/auth';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'your-super-secret-jwt-key-change-in-production';
+const JWT_EXPIRES_IN = process.env.JWT_EXPIRES_IN || '7d';
+
+export const generateToken = (user: UserAttributes): string => {
+  const payload: JWTPayload = {
+    id: user.id,
+    email: user.email,
+    phoneNumber: user.phoneNumber,
+    firstName: user.firstName,
+    lastName: user.lastName,
+    accountType: user.accountType,
+    is_active: user.is_active,
+    emailVerified: user.emailVerified,
+    phoneVerified: user.phoneVerified,
+    tokenVersion: user.tokenVersion ?? 0,
+    tokenType: 'access',
+  };
+
+  const options: jwt.SignOptions = {
+    expiresIn: JWT_EXPIRES_IN,
+    issuer: 'ggcoach-auth-service',
+    audience: 'ggcoach-app'
+  } as jwt.SignOptions;
+
+  return jwt.sign(payload, JWT_SECRET, options);
+};
+
+export const verifyToken = (token: string): JWTPayload => {
+  try {
+    const decoded = jwt.verify(token, JWT_SECRET, {
+      issuer: 'ggcoach-auth-service',
+      audience: 'ggcoach-app'
+    }) as JWTPayload;
+    
+    return decoded;
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+};
+
+export const generateRefreshToken = (user: UserAttributes): string => {
+  const payload: JWTPayload = {
+    id: user.id,
+    email: user.email,
+    phoneNumber: user.phoneNumber,
+    firstName: user.firstName,
+    lastName: user.lastName,
+    accountType: user.accountType,
+    is_active: user.is_active,
+    emailVerified: user.emailVerified,
+    phoneVerified: user.phoneVerified,
+    tokenVersion: user.tokenVersion ?? 0,
+    tokenType: 'refresh',
+  };
+
+  const options: jwt.SignOptions = {
+    expiresIn: '30d',
+    issuer: 'ggcoach-auth-service',
+    audience: 'ggcoach-app'
+  } as jwt.SignOptions;
+
+  return jwt.sign(payload, JWT_SECRET, options);
+};

package/utils/logger.ts

@@ -0,0 +1,90 @@
+import winston from 'winston';
+import path from 'path';
+import fs from 'fs';
+
+// Ensure logs directory exists
+const logsDir = path.resolve(__dirname, '..', '..', 'logs');
+if (!fs.existsSync(logsDir)) {
+  try {
+    fs.mkdirSync(logsDir, { recursive: true });
+  } catch (err) {
+    // If creating the logs directory fails, continue without file transports
+    // console.warn will be used as a fallback during bootstrap
+    // eslint-disable-next-line no-console
+    console.warn('Could not create logs directory:', err);
+  }
+}
+
+// Custom log levels as requested: info, error, crit, warn
+const customLevels = {
+  levels: {
+    crit: 0,
+    error: 1,
+    warn: 2,
+    info: 3
+  },
+  colors: {
+    crit: 'magenta',
+    error: 'red',
+    warn: 'yellow',
+    info: 'green'
+  }
+};
+
+const { combine, timestamp, printf, colorize } = winston.format;
+
+const logFormat = printf(({ level, message, timestamp: ts, ...meta }) => {
+  const metaString = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+  return `${ts} [${level}]: ${message}${metaString}`;
+});
+
+// Create transports
+const transports: winston.transport[] = [];
+
+// Console transport (always available)
+transports.push(
+  new winston.transports.Console({
+    format: combine(colorize({ all: true }), timestamp(), logFormat)
+  })
+);
+
+// File transports (if logs directory is available)
+try {
+  transports.push(
+    new winston.transports.File({
+      filename: path.join(logsDir, 'error.log'),
+      level: 'error',
+      format: combine(timestamp(), logFormat)
+    })
+  );
+
+  transports.push(
+    new winston.transports.File({
+      filename: path.join(logsDir, 'combined.log'),
+      level: 'info',
+      format: combine(timestamp(), logFormat)
+    })
+  );
+} catch (err) {
+  // If file transports can't be created, proceed with console-only logging
+  // eslint-disable-next-line no-console
+  console.warn('File transports unavailable, using console only for logging.');
+}
+
+export const logger = winston.createLogger({
+  levels: customLevels.levels,
+  level: (process.env.LOG_LEVEL as string) || 'info',
+  transports,
+  exitOnError: false
+});
+
+winston.addColors(customLevels.colors);
+
+// Attach a stream for morgan or other logging middleware
+export const stream = {
+  write: (message: string) => {
+    // morgan adds a newline at the end
+    logger.info(message.trim());
+  }
+};
+

package/utils/openapi.ts

@@ -0,0 +1,125 @@
+import { Express } from 'express';
+import listEndpoints from 'express-list-endpoints';
+
+type OpenApiSpec = Record<string, unknown>;
+type OpenApiPaths = Record<string, Record<string, unknown>>;
+
+type TagResolver = (path: string, method: string) => string[] | undefined;
+
+type BuildOptions = {
+  tagResolver?: TagResolver;
+};
+
+type Endpoint = {
+  path: string;
+  methods: string[];
+  middlewares: string[];
+};
+
+const AUTH_MIDDLEWARES = new Set([
+  'authenticateToken',
+  'requireAdmin',
+  'requireSuperAdmin',
+]);
+
+const getRecord = (value: unknown): Record<string, unknown> => {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+
+  return {};
+};
+
+const shouldSkipPath = (path: string): boolean => {
+  if (!path) {
+    return true;
+  }
+
+  if (path === '*' || path === '/*') {
+    return true;
+  }
+
+  return path.startsWith('/api-docs');
+};
+
+const normalizePath = (path: string): string => {
+  const trimmed = path.endsWith('/') && path.length > 1 ? path.slice(0, -1) : path;
+  return trimmed || '/';
+};
+
+const buildPathsFromEndpoints = (
+  endpoints: Endpoint[],
+  tagResolver?: TagResolver
+): OpenApiPaths => {
+  const paths: OpenApiPaths = {};
+  const allowedMethods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']);
+
+  endpoints.forEach((endpoint) => {
+    const path = normalizePath(endpoint.path);
+    if (shouldSkipPath(path)) {
+      return;
+    }
+
+    endpoint.methods
+      .map((method) => method.toUpperCase())
+      .filter((method) => allowedMethods.has(method))
+      .forEach((method) => {
+        const methodKey = method.toLowerCase();
+        if (!paths[path]) {
+          paths[path] = {};
+        }
+
+        if (paths[path][methodKey]) {
+          return;
+        }
+
+        const tags = tagResolver ? tagResolver(path, methodKey) : undefined;
+
+        const requiresAuth = endpoint.middlewares.some((m) => AUTH_MIDDLEWARES.has(m));
+
+        paths[path][methodKey] = {
+          summary: `${method} ${path}`,
+          ...(tags && tags.length > 0 ? { tags } : {}),
+          ...(requiresAuth ? { security: [{ bearerAuth: [] }] } : {}),
+          responses: {
+            '200': {
+              description: 'Success',
+            },
+          },
+        };
+      });
+  });
+
+  return paths;
+};
+
+const mergePaths = (basePaths: OpenApiPaths, generatedPaths: OpenApiPaths): OpenApiPaths => {
+  const merged: OpenApiPaths = { ...generatedPaths };
+
+  Object.entries(basePaths).forEach(([path, methods]) => {
+    const generatedMethods = merged[path] ?? {};
+    merged[path] = {
+      ...generatedMethods,
+      ...methods,
+    };
+  });
+
+  return merged;
+};
+
+export const buildOpenApiSpecFromExpress = (
+  app: Express,
+  baseSpec: OpenApiSpec,
+  options: BuildOptions = {}
+): OpenApiSpec => {
+  const endpoints = listEndpoints(app) as Endpoint[];
+  const basePaths = getRecord(baseSpec.paths) as OpenApiPaths;
+  const generatedPaths = buildPathsFromEndpoints(endpoints, options.tagResolver);
+
+  return {
+    ...baseSpec,
+    paths: {
+      ...mergePaths(basePaths, generatedPaths),
+    },
+  };
+};