@geins/core 0.3.0-canary

package/src/services/logService.ts

@@ -0,0 +1,434 @@
+interface LogTypes {
+  trace: LogTypeMeta;
+  debug: LogTypeMeta;
+  info: LogTypeMeta;
+  warn: LogTypeMeta;
+  error: LogTypeMeta;
+}
+
+interface LogTypeMeta {
+  abbreviation: string;
+  name: string;
+  color: string;
+  icon: string;
+}
+
+interface LogTypeFiles {
+  typescript: LogFileMeta;
+  javascript: LogFileMeta;
+  vue: LogFileMeta;
+  jsx: LogFileMeta;
+  tsx: LogFileMeta;
+  next: LogFileMeta;
+  react: LogFileMeta;
+  astro: LogFileMeta;
+  angular: LogFileMeta;
+  svelte: LogFileMeta;
+}
+
+interface LogFileMeta {
+  abbreviation: string;
+  name: string;
+  color: string;
+  colorServer: string;
+  icon?: string;
+  fileExtensions: string[]; // Added fileExtensions for identifying file type by extension
+}
+
+const logLevels = ['trace', 'debug', 'info', 'warn', 'error'] as const; // Fixed logLevels
+type LogLevel = (typeof logLevels)[number];
+
+const logTypes: LogTypes = {
+  trace: {
+    abbreviation: 'T',
+    name: 'Trace',
+    color: '#881DD7',
+    icon: '🔍',
+  },
+  debug: {
+    abbreviation: 'D',
+    name: 'Debug',
+    color: '#128655',
+    icon: '🐛',
+  },
+  info: {
+    abbreviation: 'I',
+    name: 'Info',
+    color: '#18A7B4',
+    icon: 'ℹ️',
+  },
+  warn: {
+    abbreviation: 'W',
+    name: 'Warning',
+    color: '#D7881D',
+    icon: '⚠️',
+  },
+  error: {
+    abbreviation: 'E',
+    name: 'Error',
+    color: '#D72B1D',
+    icon: '❌',
+  },
+};
+
+const logColorServer = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  underscore: '\x1b[4m',
+
+  fgBlack: '\x1b[30m',
+  fgRed: '\x1b[31m',
+  fgGreen: '\x1b[32m',
+  fgYellow: '\x1b[33m',
+  fgBlue: '\x1b[34m',
+  fgMagenta: '\x1b[35m',
+  fgCyan: '\x1b[36m',
+  fgWhite: '\x1b[37m',
+
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+};
+
+const logTypeFiles: LogTypeFiles = {
+  typescript: {
+    abbreviation: 'TS',
+    name: 'TypeScript',
+    colorServer: logColorServer.bgBlue,
+    color: '#007ACC',
+    icon: '📘',
+    fileExtensions: ['.ts', '.tsx'],
+  },
+  javascript: {
+    abbreviation: 'JS',
+    name: 'JavaScript',
+    color: '#F7DF1E',
+    colorServer: logColorServer.bgYellow,
+    icon: '📙',
+    fileExtensions: ['.js', '.mjs', 'cjs'],
+  },
+  vue: {
+    abbreviation: 'VUE',
+    name: 'Vue',
+    color: '#41B883',
+    colorServer: logColorServer.bgGreen,
+    icon: '🖼️',
+    fileExtensions: ['.vue'],
+  },
+  jsx: {
+    abbreviation: 'JSX',
+    name: 'JSX',
+    color: '#61DAFB',
+    colorServer: logColorServer.bgCyan,
+    icon: '📘',
+    fileExtensions: ['.jsx'],
+  },
+  tsx: {
+    abbreviation: 'TSX',
+    name: 'TSX',
+    color: '#007ACC',
+    colorServer: logColorServer.bgBlue,
+    icon: '📘',
+    fileExtensions: ['.tsx'],
+  },
+  next: {
+    abbreviation: 'NEXT',
+    name: 'Next.js',
+    color: '#000000',
+    colorServer: logColorServer.bgBlue,
+    icon: '🚀',
+    fileExtensions: ['.js', '.ts', '.jsx', '.tsx'],
+  },
+  react: {
+    abbreviation: 'REACT',
+    name: 'React',
+    color: '#61DAFB',
+    colorServer: logColorServer.bgBlue,
+    icon: '⚛️',
+    fileExtensions: ['.jsx', '.tsx'],
+  },
+  astro: {
+    abbreviation: 'ASTRO',
+    name: 'Astro',
+    color: '#FF5D01',
+    colorServer: logColorServer.fgMagenta,
+    icon: '🌌',
+    fileExtensions: ['.astro'],
+  },
+  angular: {
+    abbreviation: 'ANG',
+    name: 'Angular',
+    color: '#DD0031',
+    colorServer: logColorServer.bgBlue,
+    icon: '🅰️',
+    fileExtensions: ['.ts', '.html'],
+  },
+  svelte: {
+    abbreviation: 'SVELTE',
+    name: 'Svelte',
+    color: '#FF3E00',
+    colorServer: logColorServer.bgBlue,
+    icon: '🔥',
+    fileExtensions: ['.svelte'],
+  },
+};
+
+const frameworkPatterns: { [framework: string]: RegExp } = {
+  'Nuxt.js': /\/_nuxt\//,
+  'Vue.js': /\/\.vue\//,
+  React: /\/react\//,
+  Angular: /\/angular\//,
+  Svelte: /\/svelte\//,
+  'Next.js': /\/next\//,
+  Astro: /\/astro\//,
+};
+
+export class LogService {
+  private static configIsEnabled: boolean = true;
+  private static configLogLevel: LogLevel = 'debug';
+
+  // Set configuration for enabling/disabling logs and log levels
+  public static configure({
+    isEnabled = true,
+    logLevel = 'debug',
+  }: {
+    isEnabled?: boolean;
+    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+  } = {}): void {
+    LogService.configIsEnabled = isEnabled;
+    LogService.configLogLevel = logLevel;
+  }
+
+  public static isServer(): boolean {
+    return typeof window === 'undefined';
+  }
+
+  public static trace(...args: any[]): void {
+    LogService.log('trace', args);
+  }
+
+  public static debug(...args: any[]): void {
+    LogService.log('debug', args);
+  }
+
+  public static info(...args: any[]): void {
+    LogService.log('info', args);
+  }
+
+  public static warn(...args: any[]): void {
+    LogService.log('warn', args);
+  }
+
+  public static error(...args: any[]): void {
+    LogService.log('error', args);
+  }
+
+  private static log(logLevel: LogLevel, args: any[]): void {
+    const { methodName, fileName, className, framework, fileType } =
+      LogService.getCallerInfoExtended();
+
+    LogService.output(
+      logLevel,
+      methodName,
+      fileName,
+      className,
+      framework,
+      fileType,
+      args,
+    );
+  }
+
+  private static output(
+    logLevel: LogLevel,
+    methodName: string,
+    fileName: string,
+    className: string,
+    framework: string | null,
+    fileType: LogFileMeta | null,
+    args: any[],
+  ): void {
+    const typeMeta = logTypes[logLevel];
+    const fileTypeInfo = fileType ? ` (${fileType.name})` : '';
+    const frameworkInfo = framework ? ` [${framework}]` : '';
+    const methodInfo = methodName ? `${methodName}()` : '';
+    const classInfo = className ? `${className}.` : '';
+
+    const boxColor = fileType ? fileType.color : typeMeta.color;
+    const boxtColorServer = fileType
+      ? fileType.colorServer
+      : logColorServer.bgWhite;
+    const icon = fileType ? fileType.icon : typeMeta.icon;
+
+    if (LogService.isServer()) {
+      console.log(
+        `${boxtColorServer}${logColorServer.fgBlack}${icon} ${fileName} ${logColorServer.reset}${logColorServer.bgWhite}${logColorServer.fgBlack} ${classInfo}${methodInfo}${logColorServer.reset} `,
+      );
+
+      args.forEach((arg) => {
+        // check type of arg
+        if (typeof arg === 'object') {
+          console.log(
+            `${logColorServer.dim}>> ${logColorServer.reset}`,
+            `${JSON.stringify(arg)}`,
+          );
+          return;
+        } else if (typeof arg === 'string') {
+          console.log(
+            `${logColorServer.dim}>> ${logColorServer.reset}`,
+            `${logColorServer.bright}${arg}${logColorServer.reset}`,
+          );
+        }
+      });
+    } else {
+      console.log(
+        `%c${icon} ${fileName}%c ${classInfo}${methodInfo}`,
+        `background: ${boxColor}; color: #000; padding: 2px 8px; border-radius: 2px 0 0 2px;`,
+        'background: #D3D3D3; color: #000; padding: 2px 8px; border-radius: 0 2px 2px 0;',
+      );
+
+      args.forEach((arg) => {
+        console.log(
+          `%c>>`,
+          `color: ${typeMeta.color}; margin-left: 5px; font-weight: bold;`,
+          arg,
+        );
+      });
+    }
+  }
+
+  private static getCallerInfoExtended(): {
+    methodName: string;
+    fileName: string;
+    className: string;
+    framework: string | null;
+    fileType: LogFileMeta | null;
+  } {
+    let error: any = {};
+
+    try {
+      throw new Error('');
+    } catch (e) {
+      error = e;
+    }
+
+    if (!error.stack) {
+      return {
+        methodName: 'anonymous',
+        fileName: 'unknown',
+        className: '',
+        framework: null,
+        fileType: null,
+      };
+    }
+
+    const stack = error.stack.split('\n');
+    let framework: string | null = null;
+
+    if (LogService.isServer()) {
+      framework = 'node.js';
+      // logic for server server side
+      for (let i = 1; i < stack.length; i++) {
+        const line = stack[i];
+        // Skip internal lines related to LogService and node_modules
+        if (
+          line.includes('LogService') ||
+          line.includes('node_modules') ||
+          line.includes('logService.ts')
+        ) {
+          continue;
+        }
+        // Extract class name (optional) and method name (mandatory)
+        const methodNameMatch = line.match(/at (?:([\w$]+)\.)?(\w+)\s*\(/); // Optional className, methodName
+        const filePathMatch =
+          line.match(/(http.*\.\w+)/) || line.match(/at (.*):\d+:\d+/);
+
+        const className = methodNameMatch ? methodNameMatch[1] || '' : ''; // Return an empty string if class name is not found
+        const methodName = methodNameMatch ? methodNameMatch[2] : 'anonymous';
+        let fileName = 'unknown';
+        let fileType: LogFileMeta | null = null;
+
+        if (filePathMatch) {
+          const fullFilePath = filePathMatch[1];
+          const filePath = fullFilePath.split('/') || [];
+          fileName = filePath.pop() || 'unknown'; // Extract only the file name
+          filePath.reverse();
+          const filePathString = filePath.slice(0, 3).reverse().join('/');
+          fileType = LogService.getFileTypeFromExtension(fileName);
+          fileName = `${filePathString}/${fileName}`;
+        }
+
+        return { methodName, fileName, className, framework, fileType };
+      }
+    } else {
+      // Identify framework based on common paths or file patterns in the stack trace
+      for (const line of stack) {
+        for (const [name, pattern] of Object.entries(frameworkPatterns)) {
+          if (pattern.test(line)) {
+            framework = name;
+            break;
+          }
+        }
+        if (framework) break;
+      }
+
+      // Iterate over the stack and find the first line that doesn't reference LogService or node_modules
+      for (let i = 1; i < stack.length; i++) {
+        const line = stack[i];
+
+        // Skip internal lines related to LogService and node_modules
+        if (line.includes('LogService') || line.includes('node_modules')) {
+          continue;
+        }
+
+        // Extract class name (optional) and method name (mandatory)
+        const methodNameMatch = line.match(/at (?:([\w$]+)\.)?(\w+)\s*\(/); // Optional className, methodName
+        const filePathMatch =
+          line.match(/(http.*\.\w+)/) || line.match(/at (.*):\d+:\d+/);
+
+        const className = methodNameMatch ? methodNameMatch[1] || '' : ''; // Return an empty string if class name is not found
+        const methodName = methodNameMatch ? methodNameMatch[2] : 'anonymous';
+        let fileName = 'unknown';
+        let fileType: LogFileMeta | null = null;
+
+        if (filePathMatch) {
+          let fullFilePath = filePathMatch[1];
+          fullFilePath = fullFilePath.split('?')[0]; // Remove query strings if present
+          fileName = fullFilePath.split('/').pop() || 'unknown'; // Extract only the file name
+
+          // Get file type based on file extension
+          fileType = LogService.getFileTypeFromExtension(fileName);
+        }
+
+        return { methodName, fileName, className, framework, fileType };
+      }
+    }
+
+    return {
+      methodName: 'anonymous',
+      fileName: 'unknown',
+      className: '',
+      framework: null,
+      fileType: null,
+    };
+  }
+
+  // Helper method to get file type from extension
+  private static getFileTypeFromExtension(
+    fileName: string,
+  ): LogFileMeta | null {
+    for (const key in logTypeFiles) {
+      const fileType = logTypeFiles[key as keyof LogTypeFiles];
+      if (fileType.fileExtensions.some((ext) => fileName.endsWith(ext))) {
+        return fileType;
+      }
+    }
+    return null; // Return null if the file type is not identified
+  }
+}
+export const logWrite = LogService.debug;

package/src/services/routingService.ts

@@ -0,0 +1,196 @@
+import { EndpointApiClient } from '../api-client/endpointClient';
+import { IStore } from '../base/baseStore';
+
+const ONE_HOUR_MS = 60 * 60 * 1000; // 1 hour in milliseconds
+const KEY_URL_HISTORY = 'urlHistory';
+const KEY_LAST_FETCH_TIME = 'urlHistory:lastFetchTime';
+
+export enum RoutingServiceState {
+  INIT,
+  FETCHING,
+  READY,
+  ERROR,
+}
+
+export interface RoutingRule extends RoutingItem {
+  httpStatusCode?: number;
+  isCanonical?: boolean;
+}
+
+export interface RoutingItem {
+  fromUrl: string;
+  toUrl: string;
+}
+
+export class RoutingService {
+  private static instance: RoutingService | null = null;
+  private store: IStore;
+  private apiKey: string;
+  private apiClient: EndpointApiClient;
+  private state: RoutingServiceState;
+
+  private constructor(apiKey: string, store: IStore) {
+    if (!apiKey) {
+      this.state = RoutingServiceState.ERROR;
+      throw new Error('API key is required');
+    }
+
+    if (!store) {
+      this.state = RoutingServiceState.ERROR;
+      throw new Error('Store is required');
+    }
+
+    this.state = RoutingServiceState.INIT;
+    this.store = store;
+    this.apiKey = apiKey;
+    this.apiClient = new EndpointApiClient(apiKey);
+    this.state = RoutingServiceState.READY;
+  }
+
+  /**
+   * Retrieves the singleton instance of the RoutingService.
+   * @param apiKey - The API key used for authentication.
+   * @param store - The storage interface for caching routes.
+   * @returns The singleton instance of RoutingService.
+   */
+  public static getInstance(apiKey: string, store: IStore): RoutingService {
+    if (!RoutingService.instance) {
+      RoutingService.instance = new RoutingService(apiKey, store);
+    }
+    return RoutingService.instance;
+  }
+
+  private async setKey(key: string, value: string): Promise<void> {
+    await this.store.setKey(key, value);
+  }
+
+  private async getKey(key: string): Promise<string | null> {
+    return await this.store.getKey(key);
+  }
+
+  /**
+   * Retrieves all routing rules from the store.
+   * @returns A promise that resolves to an array of RoutingRule objects.
+   */
+  public async getRoutingRules(): Promise<RoutingRule[]> {
+    const keys = await this.store.getKeys();
+    const rules: RoutingRule[] = [];
+    for (const key of keys) {
+      if (key === KEY_URL_HISTORY || key === KEY_LAST_FETCH_TIME) {
+        continue;
+      }
+      const toUrl = await this.store.getKey(key);
+      if (toUrl) {
+        rules.push({
+          fromUrl: key,
+          toUrl,
+          httpStatusCode: 301,
+          isCanonical: false,
+        });
+      }
+    }
+    return rules;
+  }
+
+  /**
+   * Retrieves all route keys from the store.
+   * @returns A promise that resolves to an array of route keys.
+   */
+  public async getAllRoutes(): Promise<string[]> {
+    return await this.store.getKeys();
+  }
+
+  private async shouldFetchNewData(): Promise<boolean> {
+    const lastFetchTime = await this.getKey(KEY_LAST_FETCH_TIME);
+    if (!lastFetchTime) return true;
+
+    const lastFetchDate = new Date(lastFetchTime);
+    const timeElapsed = Date.now() - lastFetchDate.getTime();
+    return timeElapsed >= ONE_HOUR_MS;
+  }
+
+  private async fetchAndProcessUrlHistory(): Promise<void> {
+    const history = await this.apiClient.getUrlHistory();
+    for (const item of history) {
+      if (item.oldUrl && item.newUrl && !item.deleted) {
+        await this.setKey(item.oldUrl, item.newUrl);
+      }
+    }
+    await this.setKey(KEY_LAST_FETCH_TIME, new Date().toISOString());
+  }
+
+  /**
+   * Fetches the URL history from the API and updates the store.
+   * If the history was fetched less than an hour ago, it uses the cached data.
+   * @returns A promise that resolves to an array of route keys.
+   * @throws An error if the URL history could not be fetched.
+   */
+  public async fillUrlHistory(): Promise<string[]> {
+    if (this.state === RoutingServiceState.FETCHING) {
+      return this.store.getKeys();
+    }
+
+    this.state = RoutingServiceState.FETCHING;
+    try {
+      if (await this.shouldFetchNewData()) {
+        await this.fetchAndProcessUrlHistory();
+      }
+      return await this.store.getKeys();
+    } catch (error) {
+      this.state = RoutingServiceState.ERROR;
+      throw error;
+    } finally {
+      if (this.state !== RoutingServiceState.ERROR) {
+        this.state = RoutingServiceState.READY;
+      }
+    }
+  }
+
+  /**
+   * Retrieves the route for the given path from the store.
+   * @param path - The path for which to get the route.
+   * @returns A promise that resolves to the route or null if not found.
+   */
+  public async getRoute(path: string): Promise<string | null> {
+    return await this.getKey(path);
+  }
+
+  /**
+   * Refreshes the URL history if more than an hour has passed since the last fetch.
+   * @returns A promise that resolves to an array of route keys.
+   */
+  public async refreshUrlHistoryIfNeeded(): Promise<string[]> {
+    const now = new Date();
+
+    const lastFetchTime = await this.getKey(KEY_LAST_FETCH_TIME);
+    if (lastFetchTime) {
+      const lastFetchDate = new Date(lastFetchTime);
+      const timeElapsed = now.getTime() - lastFetchDate.getTime();
+
+      if (timeElapsed >= ONE_HOUR_MS) {
+        return await this.fillUrlHistory();
+      } else {
+        return await this.store.getKeys();
+      }
+    } else {
+      return await this.fillUrlHistory();
+    }
+  }
+
+  /**
+   * Retrieves the last time the URL history was fetched.
+   * @returns A promise that resolves to the last fetch time as a string or null if not set.
+   */
+  public async getLastFetchTime(): Promise<string | null> {
+    return await this.getKey(KEY_LAST_FETCH_TIME);
+  }
+
+  /**
+   * Fills the routes by fetching the URL history and returns the updated routes.
+   * @returns A promise that resolves to an object containing the urlHistory array.
+   */
+  public async fillRoutes(): Promise<{ urlHistory: string[] }> {
+    const urlHistory = await this.fillUrlHistory();
+    return { urlHistory };
+  }
+}

package/src/stores/channelStore.ts

@@ -0,0 +1,34 @@
+import NodeCache from 'node-cache';
+import { BaseStore } from '../base';
+
+const ttlSeconds = 60 * 60 * 24; // 24 hours
+
+export class ChannelStore extends BaseStore {
+  override store: NodeCache;
+
+  constructor() {
+    super();
+    this.store = this.initStore();
+  }
+
+  initStore() {
+    return new NodeCache({
+      stdTTL: ttlSeconds,
+      checkperiod: ttlSeconds * 0.2,
+      useClones: false,
+    });
+  }
+
+  async getKey(from: string): Promise<any> {
+    return this.store.get(from);
+  }
+  async setKey(from: string, to: string) {
+    return this.store.set(from, to);
+  }
+  async deleteKey(from: string) {
+    return this.store.del(from);
+  }
+  async getKeys() {
+    return this.store.keys();
+  }
+}

package/src/stores/index.ts

@@ -0,0 +1,2 @@
+export * from './routingStore';
+export * from './channelStore';