@codeleap/debug 5.8.9 → 5.8.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeleap/debug",
-  "version": "5.8.9",
+  "version": "5.8.10",
   "main": "src/index.ts",
   "license": "UNLICENSED",
   "repository": {
@@ -9,7 +9,7 @@
     "directory": "packages/debug"
   },
   "devDependencies": {
-    "@codeleap/config": "5.8.9",
+    "@codeleap/config": "5.8.10",
     "ts-node-dev": "1.1.8"
   },
   "scripts": {

package/package.json.bak

@@ -1,6 +1,6 @@
 {
   "name": "@codeleap/debug",
-  "version": "5.8.9",
+  "version": "5.8.10",
   "main": "src/index.ts",
   "license": "UNLICENSED",
   "repository": {

package/src/EnvironmentManager/class.ts

@@ -0,0 +1,139 @@
+import { globalState } from '@codeleap/store'
+import { Keyof, StringRecord, TypeGuards } from '@codeleap/types'
+import { capitalize, deepEqual } from '@codeleap/utils'
+import { useState, useMemo } from 'react'
+import { EnvironmentStore, EnvironmentManagerConfig, Editor } from './types'
+import { EDITORS } from './const'
+
+export class EnvironmentManager<T extends StringRecord> {
+  private store: ReturnType<typeof globalState<EnvironmentStore<T>>>
+
+  private initialStoreValue: EnvironmentStore<T>
+
+  readonly editors = EDITORS
+
+  get environments() {
+    return this.config.environments
+  }
+
+  get defaultConfig() {
+    return {
+      environment: this.config.defaultEnvironment,
+      customUrl: '',
+      enabledBy: null,
+    } as EnvironmentStore<T>
+  }
+
+  constructor(private config: EnvironmentManagerConfig<T>) {
+    this.store = globalState<EnvironmentStore<T>>(
+      this.defaultConfig,
+      { persistKey: config?.persistKey ?? 'environment-manager' }
+    )
+
+    this.initialStoreValue = this.store.get()
+  }
+
+  testUrl(url: string) {
+    const urlValidator: RegExp = /^https?:\/\/([a-zA-Z0-9.-]+|localhost|(\d{1,3}\.){3}\d{1,3})(?::\d+)?\/$/
+    return urlValidator.test(url)
+  }
+
+  get env(): EnvironmentStore<T> {
+    const value = this.store.get() ?? this.defaultConfig
+
+    if (value.enabledBy) {
+      if (value.environment === this.config.customEnvironment && !this.testUrl(value.customUrl)) {
+        value.environment = this.defaultConfig.environment
+      }
+
+      return value
+    }
+
+    return this.defaultConfig
+  }
+
+  setEnabled(by: Editor | false = false) {
+    const disable = by === false || TypeGuards.isNil(by)
+    this.store.set({ enabledBy: disable ? null : by })
+    return !disable
+  }
+
+  get isEnabled(): boolean {
+    return !TypeGuards.isNil(this.isEnabledBy)
+  }
+
+  get isEnabledBy(): Editor {
+    return this.store.get(s => s?.enabledBy)
+  }
+
+  get isEnabledBySystem(): boolean {
+    return this.isEnabledBy === EDITORS.SYSTEM
+  }
+
+  get isEnabledByUser(): boolean {
+    return this.isEnabledBy === EDITORS.USER
+  }
+
+  get is(): Record<Capitalize<Keyof<T> extends string ? Keyof<T> : string>, boolean> {
+    const environment = this.store.get(s => s?.environment ?? this.defaultConfig.environment)
+
+    return Object.entries(this.environments).reduce((acc, [key, value]) => {
+      acc[capitalize(key) as Keyof<T>] = environment === key
+      return acc
+    }, {} as Record<Keyof<T>, boolean>)
+  }
+
+  get serverUrl() {
+    const env = this.env
+
+    if (env.environment === this.config.customEnvironment) {
+      if (!this.testUrl(env.customUrl)) {
+        return this.environments[this.defaultConfig.environment]
+      }
+
+      return env.customUrl
+    }
+
+    return this.environments[env.environment] ?? this.environments[this.defaultConfig.environment]
+  }
+
+  setEnvironment(environment: Keyof<T>) {
+    if (!this.isEnabled) return
+    this.store.set({ environment })
+  }
+
+  isEnvironment(env: Keyof<T>): boolean {
+    const current = this.env
+    return current.environment === env
+  }
+
+  setCustomUrl(url: string) {
+    if (!url.endsWith('/')) {
+      url += '/'
+    }
+
+    if (!this.testUrl(url)) return
+
+    this.store.set({ customUrl: url })
+  }
+
+  use() {
+    const value = this.store.use()
+
+    const { enabledBy, ...config } = value ?? this.defaultConfig
+
+    const [customUrl, setCustomUrl] = useState(config?.customUrl)
+
+    const changed = useMemo(() => !deepEqual(value, this.initialStoreValue), [value])
+
+    return {
+      enabled: !!enabledBy,
+      enabledByUser: enabledBy === EDITORS.USER,
+      enabledBySystem: enabledBy === EDITORS.SYSTEM,
+      config,
+      changed,
+      customUrl,
+      setCustomUrl,
+    }
+  }
+}

package/src/EnvironmentManager/const.ts

@@ -0,0 +1,4 @@
+export const EDITORS = {
+  SYSTEM: 'system',
+  USER: 'user',
+} as const

package/src/EnvironmentManager/factor.ts

@@ -0,0 +1,7 @@
+import { StringRecord } from '@codeleap/types'
+import { EnvironmentManager } from './class'
+import { EnvironmentManagerConfig } from './types'
+
+export function createEnvironmentManager<T extends StringRecord>(config: EnvironmentManagerConfig<T>) {
+  return new EnvironmentManager<T>(config)
+}

package/src/EnvironmentManager/index.ts

@@ -0,0 +1,3 @@
+export * from './factor'
+export * from './class'
+export * from './types'

package/src/EnvironmentManager/tests.spec.ts

@@ -0,0 +1,330 @@
+import { describe, test, expect, beforeEach } from 'bun:test'
+import { createEnvironmentManager } from './factor'
+import { EnvironmentManager } from './class'
+import { EDITORS } from './const'
+
+type TestEnvironments = {
+  development: string
+  staging: string
+  production: string
+  custom: string
+}
+
+describe('EnvironmentManager', () => {
+  let manager: EnvironmentManager<TestEnvironments>
+
+  const envs = {
+    development: 'http://localhost:3000/',
+    staging: 'https://staging.example.com/',
+    production: 'https://api.example.com/',
+    custom: '',
+  }
+
+  const testConfig = {
+    environments: envs,
+    defaultEnvironment: 'development' as const,
+    customEnvironment: 'custom' as const,
+    persistKey: 'test-env-manager',
+  }
+
+  beforeEach(() => {
+    manager = createEnvironmentManager<TestEnvironments>(testConfig)
+  })
+
+  describe('Initialization', () => {
+    test('should create instance with correct config', () => {
+      expect(manager).toBeInstanceOf(EnvironmentManager)
+      expect(manager.environments).toEqual(testConfig.environments)
+      expect(manager.editors).toEqual(EDITORS)
+    })
+
+    test('should have correct default config', () => {
+      expect(manager.defaultConfig).toEqual({
+        environment: 'development',
+        customUrl: '',
+        enabledBy: null,
+      })
+    })
+  })
+
+  describe('URL Validation', () => {
+    test('should validate correct HTTP URLs', () => {
+      expect(manager.testUrl(envs.development)).toBe(true)
+      expect(manager.testUrl('http://example.com/')).toBe(true)
+      expect(manager.testUrl('http://192.168.1.1:8080/')).toBe(true)
+    })
+
+    test('should validate correct HTTPS URLs', () => {
+      expect(manager.testUrl('https://example.com/')).toBe(true)
+      expect(manager.testUrl(envs.production)).toBe(true)
+      expect(manager.testUrl('https://sub.domain.example.com:443/')).toBe(true)
+    })
+
+    test('should reject invalid URLs', () => {
+      expect(manager.testUrl('ftp://example.com/')).toBe(false)
+      expect(manager.testUrl('http://example.com')).toBe(false)
+      expect(manager.testUrl('example.com/')).toBe(false)
+      expect(manager.testUrl('http:/example.com/')).toBe(false)
+      expect(manager.testUrl('')).toBe(false)
+    })
+  })
+
+  describe('Enable/Disable functionality', () => {
+    test('should start disabled by default', () => {
+      expect(manager.isEnabled).toBe(false)
+      expect(manager.isEnabledBy).toBeNull()
+    })
+
+    test('should enable by user', () => {
+      const result = manager.setEnabled(EDITORS.USER)
+      expect(result).toBe(true)
+      expect(manager.isEnabled).toBe(true)
+      expect(manager.isEnabledByUser).toBe(true)
+      expect(manager.isEnabledBySystem).toBe(false)
+    })
+
+    test('should enable by system', () => {
+      manager.setEnabled(EDITORS.SYSTEM)
+      expect(manager.isEnabled).toBe(true)
+      expect(manager.isEnabledBySystem).toBe(true)
+      expect(manager.isEnabledByUser).toBe(false)
+    })
+
+    test('should disable when setting null', () => {
+      manager.setEnabled(EDITORS.USER)
+      expect(manager.isEnabled).toBe(true)
+
+      const result = manager.setEnabled(false)
+      expect(result).toBe(false)
+      expect(manager.isEnabled).toBe(false)
+    })
+  })
+
+  describe('Environment management', () => {
+    beforeEach(() => {
+      manager.setEnabled(EDITORS.USER)
+    })
+
+    test('should return default environment when disabled', () => {
+      manager.setEnabled(false)
+      const env = manager.env
+      expect(env.environment).toBe('development')
+    })
+
+    test('should set environment when enabled', () => {
+      manager.setEnvironment('staging')
+      const env = manager.env
+      expect(env.environment).toBe('staging')
+    })
+
+    test('should not set environment when disabled', () => {
+      manager.setEnabled(false)
+      manager.setEnvironment('production')
+      expect(manager.isEnvironment('development')).toBe(true)
+    })
+
+    test('should check current environment correctly', () => {
+      manager.setEnvironment('production')
+      expect(manager.isEnvironment('production')).toBe(true)
+      expect(manager.isEnvironment('staging')).toBe(false)
+    })
+  })
+
+  describe('Environment checker (is)', () => {
+    beforeEach(() => {
+      manager.setEnabled(EDITORS.USER)
+    })
+
+    test('should have correct environment flags for development', () => {
+      manager.setEnvironment('development')
+      expect(manager.is.Development).toBe(true)
+      expect(manager.is.Staging).toBe(false)
+      expect(manager.is.Production).toBe(false)
+    })
+
+    test('should have correct environment flags for production', () => {
+      manager.setEnvironment('production')
+      expect(manager.is.Production).toBe(true)
+      expect(manager.is.Development).toBe(false)
+      expect(manager.is.Staging).toBe(false)
+    })
+
+    test('should have correct environment flags for staging', () => {
+      manager.setEnvironment('staging')
+      expect(manager.is.Staging).toBe(true)
+      expect(manager.is.Development).toBe(false)
+      expect(manager.is.Production).toBe(false)
+    })
+  })
+
+  describe('Server URL', () => {
+    beforeEach(() => {
+      manager.setEnabled(EDITORS.USER)
+    })
+
+    test('should return correct URL for each environment', () => {
+      manager.setEnvironment('development')
+      expect(manager.serverUrl).toBe(envs.development)
+
+      manager.setEnvironment('staging')
+      expect(manager.serverUrl).toBe(envs.staging)
+
+      manager.setEnvironment('production')
+      expect(manager.serverUrl).toBe(envs.production)
+    })
+
+    test('should return default URL when disabled', () => {
+      manager.setEnabled(false)
+      expect(manager.serverUrl).toBe(envs.development)
+    })
+
+    test('should return custom URL when set and valid', () => {
+      manager.setCustomUrl('https://custom.example.com/')
+      manager.setEnvironment('custom')
+      expect(manager.serverUrl).toBe('https://custom.example.com/')
+    })
+  })
+
+  describe('Custom URL', () => {
+    beforeEach(() => {
+      manager.setEnabled(EDITORS.USER)
+    })
+
+    test('should set valid custom URL', () => {
+      manager.setCustomUrl('https://custom.example.com/')
+      manager.setEnvironment('custom')
+      expect(manager.serverUrl).toBe('https://custom.example.com/')
+    })
+
+    test('should add trailing slash if missing', () => {
+      manager.setCustomUrl('https://custom.example.com')
+      manager.setEnvironment('custom')
+      expect(manager.serverUrl).toBe('https://custom.example.com/')
+    })
+
+    test('should not set invalid custom URL', () => {
+      const initialUrl = manager.env.customUrl
+      manager.setCustomUrl('invalid-url')
+      expect(manager.env.customUrl).toBe(initialUrl)
+    })
+
+    test('should handle localhost custom URLs', () => {
+      manager.setCustomUrl('http://localhost:4000/')
+      manager.setEnvironment('custom')
+      expect(manager.serverUrl).toBe('http://localhost:4000/')
+    })
+
+    test('should handle IP address custom URLs', () => {
+      manager.setCustomUrl('http://192.168.1.100:8080/')
+      manager.setEnvironment('custom')
+      expect(manager.serverUrl).toBe('http://192.168.1.100:8080/')
+    })
+  })
+
+  describe('Factory function', () => {
+    test('should create manager instance', () => {
+      const newManager = createEnvironmentManager<TestEnvironments>(testConfig)
+      expect(newManager).toBeInstanceOf(EnvironmentManager)
+    })
+
+    test('should create independent instances', () => {
+      const manager1 = createEnvironmentManager<TestEnvironments>({
+        ...testConfig,
+        persistKey: 'manager-1',
+      })
+      const manager2 = createEnvironmentManager<TestEnvironments>({
+        ...testConfig,
+        persistKey: 'manager-2',
+      })
+
+      manager1.setEnabled(EDITORS.USER)
+      manager1.setEnvironment('production')
+
+      manager2.setEnabled(EDITORS.SYSTEM)
+      manager2.setEnvironment('staging')
+
+      expect(manager1.isEnabledByUser).toBe(true)
+      expect(manager2.isEnabledBySystem).toBe(true)
+    })
+  })
+
+  describe('EDITORS constant', () => {
+    test('should have correct editor values', () => {
+      expect(EDITORS.SYSTEM).toBe('system')
+      expect(EDITORS.USER).toBe('user')
+    })
+  })
+
+  describe('Edge cases', () => {
+    test('should handle repeated setEnvironment calls', () => {
+      manager.setEnabled(EDITORS.USER)
+      manager.setEnvironment('development')
+      manager.setEnvironment('staging')
+      manager.setEnvironment('production')
+
+      expect(manager.isEnvironment('production')).toBe(true)
+    })
+
+    test('should handle empty custom URL', () => {
+      manager.setEnabled(EDITORS.USER)
+      manager.setCustomUrl('')
+      expect(manager.testUrl('')).toBe(false)
+    })
+
+    test('should handle switching between enabled states', () => {
+      manager.setEnabled(EDITORS.USER)
+      expect(manager.isEnabledByUser).toBe(true)
+
+      manager.setEnabled(EDITORS.SYSTEM)
+      expect(manager.isEnabledBySystem).toBe(true)
+      expect(manager.isEnabledByUser).toBe(false)
+    })
+
+    test('should handle multiple custom URL changes', () => {
+      manager.setEnabled(EDITORS.USER)
+
+      manager.setCustomUrl('https://custom1.example.com/')
+      manager.setEnvironment('custom')
+      expect(manager.serverUrl).toBe('https://custom1.example.com/')
+
+      manager.setCustomUrl('https://custom2.example.com/')
+      expect(manager.serverUrl).toBe('https://custom2.example.com/')
+    })
+  })
+
+  describe('Integration tests', () => {
+    test('should handle full workflow: enable, set env, get URL', () => {
+      manager.setEnabled(null)
+      expect(manager.isEnabled).toBe(false)
+
+      manager.setEnabled(EDITORS.USER)
+      expect(manager.isEnabled).toBe(true)
+
+      manager.setEnvironment('production')
+      expect(manager.isEnvironment('production')).toBe(true)
+
+      expect(manager.serverUrl).toBe(envs.production)
+    })
+
+    test('should handle custom URL workflow', () => {
+      manager.setEnabled(EDITORS.USER)
+
+      manager.setCustomUrl('https://my-api.example.com/')
+      expect(manager.testUrl('https://my-api.example.com/')).toBe(true)
+
+      manager.setEnvironment('custom')
+      expect(manager.isEnvironment('custom')).toBe(true)
+      expect(manager.serverUrl).toBe('https://my-api.example.com/')
+    })
+
+    test('should fallback correctly on invalid custom URL', () => {
+      manager.setEnabled(EDITORS.USER)
+
+      manager.setEnvironment('custom')
+      manager.setCustomUrl('https://my-api.example.com/')
+      manager.setCustomUrl('not-a-valid-url')
+
+      expect(manager.serverUrl).toBe('https://my-api.example.com/')
+    })
+  })
+})

package/src/EnvironmentManager/types.ts

@@ -0,0 +1,17 @@
+import { Keyof, StringRecord, ValueOf } from '@codeleap/types'
+import { EDITORS } from './const'
+
+export type Editor = ValueOf<typeof EDITORS> | null
+
+export type EnvironmentManagerConfig<T extends StringRecord> = {
+  environments: T
+  defaultEnvironment: Keyof<T>
+  customEnvironment: Keyof<T>
+  persistKey?: string
+}
+
+export type EnvironmentStore<T extends StringRecord> = {
+  environment: Keyof<T>
+  customUrl?: string
+  enabledBy: Editor
+}

package/src/faker.ts

@@ -0,0 +1,34 @@
+const names = [
+  'James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard', 'Joseph', 'Thomas',
+  'Charles', 'Christopher', 'Daniel', 'Matthew', 'Anthony', 'Donald', 'Mark', 'Paul', 'Steven',
+  'Andrew', 'Kenneth', 'Joshua', 'Kevin', 'Brian', 'George', 'Edward', 'Ronald', 'Timothy',
+  'Jason', 'Jeffrey', 'Ryan', 'Gary', 'Jacob'
+]
+
+const surnames = [
+  'Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis',
+  'Lopez', 'Wilson', 'Anderson', 'Thomas', 'Taylor', 'Moore',
+  'Jackson', 'Martin', 'Lee', 'Perez', 'Thompson', 'White', 'Harris', 'Sanchez', 'Clark',
+  'Ramirez', 'Lewis', 'Robinson', 'Walker', 'Young', 'Allen', 'King', 'Wright', 'Scott', 'Torres',
+]
+
+const animals = [
+  'lion', 'tiger', 'zebra', 'panda', 'koala', 'bear',
+  'wolf', 'fox', 'rabbit', 'bat', 'spider', 'frog', 'shark'
+]
+
+function getRandom(list: Array<string>) {
+  return list[Math.floor(Math.random() * list.length)]
+}
+
+function number(min: number = 0, max: number = 100) {
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+export const faker = {
+  lastName: () => getRandom(surnames),
+  firstName: () => getRandom(names),
+  animal: () => getRandom(animals),
+  number,
+  name: () => `${getRandom(names)} ${getRandom(surnames)}`
+}

package/src/index.ts

@@ -1 +1,3 @@
 export * from './FakeRestApi'
+export * from './EnvironmentManager'
+export * from './faker'