@ikonintegration/module-config-api 2.0.16 → 2.0.18

package/CacheClient.ts

@@ -0,0 +1,251 @@
+// @ts-nocheck — This file is compiled in CI alongside generated sources (Api.js, data-contracts.js)
+import { Api } from './Api.js'
+import { CustomerResponse, TenantResponse } from './data-contracts.js'
+import { MemoryCache } from './MemoryCache.js'
+import { RedisLike, CacheConfig, CacheConstants } from './CacheTypes.js'
+
+/**
+ * Extended client that wraps the auto-generated Api with Redis cache support.
+ * Provides direct Redis-backed lookups for customers, tenants, certifications, and courses.
+ *
+ * Usage:
+ * ```ts
+ * import { CacheClient } from "@ikonintegration/module-config-api/cache";
+ *
+ * const client = new CacheClient({
+ *   // API layer (passed to the generated Api client)
+ *   baseUrl: "https://api.example.com",
+ *   // Cache layer (optional — enables Redis-backed lookups)
+ *   cache: {
+ *     endpoint: "redis.example.com",
+ *     username: "default",
+ *     password: "secret",
+ *     enableTLS: true,
+ *     version: 5
+ *   }
+ * });
+ * ```
+ */
+export class CacheClient {
+  public api: Api<unknown>
+  private _localCache: MemoryCache
+  private _remoteCache: RedisLike | null = null
+  private _cacheConfig: CacheConfig | null
+
+  constructor(options: {
+    baseUrl?: string
+    baseApiParams?: ConstructorParameters<typeof Api>[0]
+    cache?: CacheConfig
+  }) {
+    this.api = new Api({
+      baseURL: options.baseUrl,
+      ...options.baseApiParams,
+    })
+    this._localCache = new MemoryCache()
+    this._cacheConfig = options.cache || null
+  }
+
+  /********* CACHE LAYER — Customers *********/
+
+  async getAllCustomers(): Promise<CustomerResponse[] | null> {
+    let allCustomers = this._localCache.getValue<CustomerResponse[]>(CacheConstants.CustomerPrefix)
+    if (!allCustomers) {
+      console.debug('ConfigClient - Customers Fetch All')
+      allCustomers = await this._getAllRemoteCustomers()
+      if (!allCustomers) return null
+      this._localCache.setValue(CacheConstants.CustomerPrefix, allCustomers, CacheConstants.AllCustomersTTL)
+    }
+    return allCustomers
+  }
+
+  async getCustomerByID(customerID: string): Promise<CustomerResponse | null> {
+    // Attempt local cache
+    let customer = this._localCache.getValue<CustomerResponse>(`${CacheConstants.CustomerPrefix}${customerID}`)
+    // Attempt from allCustomers local cache
+    if (!customer) {
+      const allCustomers = this._localCache.getValue<CustomerResponse[]>(CacheConstants.CustomerPrefix)
+      customer = allCustomers?.find(c => c.id === customerID) || null
+    }
+    // Attempt remote cache
+    if (!customer) {
+      console.debug('ConfigClient - Customer Fetch:', customerID)
+      await this._initCacheClient()
+      const raw = await this._remoteCache?.get(`${CacheConstants.CustomerPrefix}${customerID}`)
+      if (!raw) return null
+      customer = JSON.parse(raw)
+      this._localCache.setValue(`${CacheConstants.CustomerPrefix}${customerID}`, customer, CacheConstants.CustomerTTL)
+    }
+    return customer
+  }
+
+  /********* CACHE LAYER — Tenants *********/
+
+  async getAllTenants(): Promise<TenantResponse[] | null> {
+    let allTenants = this._localCache.getValue<TenantResponse[]>(CacheConstants.TenantPrefix)
+    if (!allTenants) {
+      console.debug('ConfigClient - Tenants Fetch All')
+      allTenants = await this._getAllRemoteTenants()
+      if (!allTenants) return null
+      this._localCache.setValue(CacheConstants.TenantPrefix, allTenants, CacheConstants.AllTenantsTTL)
+    }
+    return allTenants
+  }
+
+  async getTenantByID(tenantID: string): Promise<TenantResponse | null> {
+    let tenant = this._localCache.getValue<TenantResponse>(`${CacheConstants.TenantPrefix}${tenantID}`)
+    if (!tenant) {
+      console.debug('ConfigClient - Tenant Fetch:', tenantID)
+      await this._initCacheClient()
+      const raw = await this._remoteCache?.get(`${CacheConstants.TenantPrefix}${tenantID}`)
+      if (!raw) return null
+      tenant = JSON.parse(raw)
+      this._localCache.setValue(`${CacheConstants.TenantPrefix}${tenantID}`, tenant, CacheConstants.TenantTTL)
+    }
+    return tenant
+  }
+
+  /********* CACHE LAYER — Certifications & Courses *********/
+
+  async getCertificationByID(certID: string, tenantID: string) {
+    const tenant = await this.getTenantByID(tenantID)
+    if (!tenant || !Array.isArray((tenant as any).certifications)) return null
+    return (tenant as any).certifications.find((c: any) => c.id === certID) || null
+  }
+
+  async getCourseByID(courseID: string, tenantID: string) {
+    const tenant = await this.getTenantByID(tenantID)
+    if (!tenant || !Array.isArray((tenant as any).certifications)) return null
+    for (const cert of (tenant as any).certifications) {
+      for (const req of cert.requirements || []) {
+        if (Array.isArray(req)) {
+          const found = req.find((r: any) => r.id === courseID)
+          if (found) return found
+        } else if (req.id === courseID) return req
+      }
+    }
+    return null
+  }
+
+  async getCourseInCertificationByID(certificationID: string, courseID: string, tenantID: string) {
+    const tenant = await this.getTenantByID(tenantID)
+    if (!tenant || !Array.isArray((tenant as any).certifications)) return null
+    const cert = (tenant as any).certifications.find((c: any) => c.id === certificationID)
+    if (!cert) return null
+    for (const req of cert.requirements || []) {
+      if (Array.isArray(req)) {
+        const found = req.find((r: any) => r.id === courseID)
+        if (found) return found
+      } else if (req.id === courseID) return req
+    }
+    return null
+  }
+
+  async getAllCoursesByTenantID(tenantID: string) {
+    const tenant = await this.getTenantByID(tenantID)
+    if (!tenant || !Array.isArray((tenant as any).certifications)) return null
+    const courses: any[] = []
+    for (const cert of (tenant as any).certifications) {
+      for (const req of cert.requirements || []) {
+        if (Array.isArray(req)) {
+          for (const sub of req) courses.push(sub)
+        } else courses.push(req)
+      }
+    }
+    return courses
+  }
+
+  async getAllCoursesByCertificationID(certID: string, tenantID: string) {
+    const tenant = await this.getTenantByID(tenantID)
+    if (!tenant || !Array.isArray((tenant as any).certifications)) return null
+    const courses: any[] = []
+    for (const cert of (tenant as any).certifications) {
+      if (cert.id !== certID) continue
+      for (const req of cert.requirements || []) {
+        if (Array.isArray(req)) {
+          for (const sub of req) courses.push(sub)
+        } else courses.push(req)
+      }
+    }
+    return courses
+  }
+
+  async getAllCourses() {
+    return this.getAllCoursesByCustomerID(null)
+  }
+
+  async getAllCoursesByCustomerID(customerID: string | null) {
+    const allTenants = await this.getAllTenants()
+    if (!allTenants) return []
+    const filtered = allTenants.filter(t => !customerID || (t as any).customerID === customerID)
+    const courses: any[] = []
+    for (const tenant of filtered) {
+      if (!Array.isArray((tenant as any).certifications)) continue
+      for (const cert of (tenant as any).certifications) {
+        for (const req of cert.requirements || []) {
+          if (Array.isArray(req)) {
+            for (const sub of req) {
+              if (!courses.find(c => c.id === sub.id)) courses.push(sub)
+            }
+          } else {
+            if (!courses.find(c => c.id === req.id)) courses.push(req)
+          }
+        }
+      }
+    }
+    return courses
+  }
+
+  /********* CACHE LAYER — Course Providers *********/
+
+  async getCourseProviderByIDs(courseProviderID: string, customerID: string) {
+    const customer = await this.getCustomerByID(customerID)
+    if (!customer || !Array.isArray((customer as any).courseProviders)) return null
+    return (customer as any).courseProviders.find((p: any) => p === courseProviderID) || null
+  }
+
+  /********* Private *********/
+
+  private async _getAllRemoteCustomers(): Promise<CustomerResponse[] | null> {
+    await this._initCacheClient()
+    if (!this._remoteCache) return null
+    const allKeys = await this._remoteCache.keys(`${CacheConstants.CustomerPrefix}*`)
+    if (!allKeys || allKeys.length === 0) return null
+    const raw = await this._remoteCache.mGet(allKeys)
+    return Array.isArray(raw) ? raw.map(r => JSON.parse(r)) : null
+  }
+
+  private async _getAllRemoteTenants(): Promise<TenantResponse[] | null> {
+    await this._initCacheClient()
+    if (!this._remoteCache) return null
+    const allKeys = await this._remoteCache.keys(`${CacheConstants.TenantPrefix}*`)
+    if (!allKeys || allKeys.length === 0) return null
+    const raw = await this._remoteCache.mGet(allKeys)
+    return Array.isArray(raw) ? raw.map(r => JSON.parse(r)) : null
+  }
+
+  private async _initCacheClient() {
+    if (this._remoteCache || !this._cacheConfig) return
+    const config = this._cacheConfig
+
+    if (config.version === 5) {
+      const dynamicImport = ['@ikonintegration/ikapi']
+      const { Redis } = await import(dynamicImport[0])
+      this._remoteCache = await Redis.connection({
+        hostname: config.endpoint,
+        username: config.username,
+        password: config.password,
+        enableTLS: config.enableTLS ?? true,
+      })
+    } else {
+      const dynamicImport = ['redis', '@ikonintegration/ikapi']
+      await import(dynamicImport[0])
+      const IKAPI = (await import(dynamicImport[1])).default
+      this._remoteCache = new IKAPI.IKRedis({
+        host: config.endpoint,
+        user: config.username,
+        password: config.password,
+        enableTLS: config.enableTLS ?? true,
+      })
+    }
+  }
+}

package/CacheTypes.ts

@@ -0,0 +1,35 @@
+/**
+ * Minimal interface for Redis-like clients used by the cache layer.
+ * Supports both @ikonintegration/ikapi Redis and the legacy IKRedis.
+ */
+export interface RedisLike {
+  get(key: string): Promise<string | null>
+  keys(pattern: string): Promise<string[]>
+  mGet(keys: string[]): Promise<string[]>
+}
+
+/**
+ * Configuration for the Redis cache connection.
+ */
+export interface CacheConfig {
+  endpoint: string
+  username: string
+  password: string
+  enableTLS?: boolean
+  /** Set to 5 to use the new @ikonintegration/ikapi Redis client */
+  version?: number
+}
+
+/**
+ * Cache key prefixes and TTL constants (matching the legacy client).
+ */
+export const CacheConstants = {
+  // Customer
+  CustomerPrefix: 'CO::',
+  AllCustomersTTL: 60 * 60, // 1 hour
+  CustomerTTL: 60, // 1 minute
+  // Tenant
+  TenantPrefix: 'TN::',
+  AllTenantsTTL: 60 * 60, // 1 hour
+  TenantTTL: 60, // 1 minute
+} as const

package/MemoryCache.ts

@@ -0,0 +1,29 @@
+/**
+ * Simple in-memory TTL cache used as a local layer before hitting Redis.
+ */
+export class MemoryCache {
+  private store: Map<string, { value: any; expiresAt: number }> = new Map()
+
+  getValue<T = any>(key: string): T | null {
+    const entry = this.store.get(key)
+    if (!entry) return null
+    if (entry.expiresAt > 0 && Date.now() > entry.expiresAt) {
+      this.store.delete(key)
+      return null
+    }
+    return entry.value as T
+  }
+
+  setValue(key: string, value: any, ttlSeconds: number = 0): void {
+    const expiresAt = ttlSeconds > 0 ? Date.now() + ttlSeconds * 1000 : 0
+    this.store.set(key, { value, expiresAt })
+  }
+
+  cleanKey(key: string): void {
+    this.store.delete(key)
+  }
+
+  clear(): void {
+    this.store.clear()
+  }
+}