@ikonintegration/module-config-api 2.0.19 → 2.0.21

package/Api.ts

@@ -2934,7 +2934,7 @@ export interface FaqResponse {
   answer?: string
 }
 
-export interface InputVnr9Fm759Zi {
+export interface InputAcavfff528 {
   /**
    * Tenant ID this FAQ belongs to
    * @example "tenant456"
@@ -2957,7 +2957,7 @@ export interface InputVnr9Fm759Zi {
   answer?: string
 }
 
-export interface InputGbe7Fhz907 {
+export interface InputUshnduveu4 {
   /**
    * Tenant ID this FAQ belongs to
    * @example "tenant456"
@@ -3128,6 +3128,19 @@ export interface CertificationResponse {
    * @example "req123"
    */
   validityRequirementID?: string
+  /** Overrides email templates for specific email events */
+  emailEventOverrides?: {
+    /**
+     * Email event identifier
+     * @example "event001"
+     */
+    eventID: string
+    /**
+     * Email template identifier override for the event
+     * @example "template001"
+     */
+    templateID: string
+  }[]
   /** Warning threshold for incomplete certification */
   warningIncompleteCertificationDays?: {
     /**
@@ -3328,6 +3341,19 @@ export interface CertificationRequestBody {
    * @example "req123"
    */
   validityRequirementID?: string
+  /** Overrides email templates for specific email events */
+  emailEventOverrides?: {
+    /**
+     * Email event identifier
+     * @example "event001"
+     */
+    eventID: string
+    /**
+     * Email template identifier override for the event
+     * @example "template001"
+     */
+    templateID: string
+  }[]
   /** Warning threshold for incomplete certification */
   warningIncompleteCertificationDays?: {
     /**
@@ -3549,6 +3575,19 @@ export interface CertificationListResponse {
      * @example "req123"
      */
     validityRequirementID?: string
+    /** Overrides email templates for specific email events */
+    emailEventOverrides?: {
+      /**
+       * Email event identifier
+       * @example "event001"
+       */
+      eventID: string
+      /**
+       * Email template identifier override for the event
+       * @example "template001"
+       */
+      templateID: string
+    }[]
     /** Warning threshold for incomplete certification */
     warningIncompleteCertificationDays?: {
       /**
@@ -3922,6 +3961,19 @@ export interface CourseResponse {
      */
     courseFailed?: string | null
   }
+  /** Overrides email templates for specific email events */
+  emailEventOverrides?: {
+    /**
+     * Email event identifier
+     * @example "event001"
+     */
+    eventID: string
+    /**
+     * Email template identifier override for the event
+     * @example "template001"
+     */
+    templateID: string
+  }[]
   /**
    * Display name
    * @example "Safety Training Course"
@@ -4226,6 +4278,19 @@ export interface CourseRequestBody {
      */
     courseFailed?: string | null
   }
+  /** Overrides email templates for specific email events */
+  emailEventOverrides?: {
+    /**
+     * Email event identifier
+     * @example "event001"
+     */
+    eventID: string
+    /**
+     * Email template identifier override for the event
+     * @example "template001"
+     */
+    templateID: string
+  }[]
   /**
    * Display name
    * @example "Safety Training Course"
@@ -4592,6 +4657,19 @@ export interface CourseListResponse {
        */
       courseFailed?: string | null
     }
+    /** Overrides email templates for specific email events */
+    emailEventOverrides?: {
+      /**
+       * Email event identifier
+       * @example "event001"
+       */
+      eventID: string
+      /**
+       * Email template identifier override for the event
+       * @example "template001"
+       */
+      templateID: string
+    }[]
     /**
      * Display name
      * @example "Safety Training Course"
@@ -5354,7 +5432,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title No title
- * @version 2.0.19
+ * @version 2.0.21
  * @baseUrl http://localhost:8080
  * @contact Ikon Integration <ikon@ikonintegration.com> (http://example.com)
  */
@@ -6019,7 +6097,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request POST:/tenant/{tenantID}/faq/{faqID}
      * @secure
      */
-    createFaq: (tenantId: string, faqId: string, data: InputVnr9Fm759Zi, params: RequestParams = {}) =>
+    createFaq: (tenantId: string, faqId: string, data: InputAcavfff528, params: RequestParams = {}) =>
       this.request<CreateFaqData, CreateFaqError>({
         path: `/tenant/${tenantId}/faq/${faqId}`,
         method: 'POST',
@@ -6038,7 +6116,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @request PUT:/tenant/{tenantID}/faq/{faqID}
      * @secure
      */
-    updateFaq: (tenantId: string, faqId: string, data: InputGbe7Fhz907, params: RequestParams = {}) =>
+    updateFaq: (tenantId: string, faqId: string, data: InputUshnduveu4, params: RequestParams = {}) =>
       this.request<UpdateFaqData, UpdateFaqError>({
         path: `/tenant/${tenantId}/faq/${faqId}`,
         method: 'PUT',

package/CacheClient.ts

@@ -1,21 +1,26 @@
 // @ts-nocheck — This file is compiled in CI alongside generated sources (Api.js)
-import { Api } from './Api.js'
-import type { CustomerResponse, TenantResponse } from './Api.js'
 import { MemoryCache } from './MemoryCache.js'
-import { RedisLike, CacheConfig, CacheConstants } from './CacheTypes.js'
+import {
+  RedisLike,
+  CacheConfig,
+  CacheConstants,
+  CachedCustomer,
+  CachedTenant,
+  CachedCertification,
+  CachedCourse,
+} 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.
+ * Provides direct Redis-backed lookups for expanded customers, tenants, certifications, and courses
+ * as they are stored in the persistent cache (not the raw API responses).
  *
  * Usage:
  * ```ts
- * import { CacheClient } from "@ikonintegration/module-config-api/cache";
+ * import { CacheClient } from "@ikonintegration/module-config-api";
  *
  * 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",
@@ -27,28 +32,21 @@ import { RedisLike, CacheConfig, CacheConstants } from './CacheTypes.js'
  * ```
  */
 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,
-    })
+  constructor(options: { cache?: CacheConfig }) {
     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)
+  async getAllCustomers(): Promise<CachedCustomer[] | null> {
+    let allCustomers = this._localCache.getValue<CachedCustomer[]>(CacheConstants.CustomerPrefix)
     if (!allCustomers) {
       console.debug('ConfigClient - Customers Fetch All')
       allCustomers = await this._getAllRemoteCustomers()
@@ -58,12 +56,12 @@ export class CacheClient {
     return allCustomers
   }
 
-  async getCustomerByID(customerID: string): Promise<CustomerResponse | null> {
+  async getCustomerByID(customerID: string): Promise<CachedCustomer | null> {
     // Attempt local cache
-    let customer = this._localCache.getValue<CustomerResponse>(`${CacheConstants.CustomerPrefix}${customerID}`)
+    let customer = this._localCache.getValue<CachedCustomer>(`${CacheConstants.CustomerPrefix}${customerID}`)
     // Attempt from allCustomers local cache
     if (!customer) {
-      const allCustomers = this._localCache.getValue<CustomerResponse[]>(CacheConstants.CustomerPrefix)
+      const allCustomers = this._localCache.getValue<CachedCustomer[]>(CacheConstants.CustomerPrefix)
       customer = allCustomers?.find(c => c.id === customerID) || null
     }
     // Attempt remote cache
@@ -80,8 +78,8 @@ export class CacheClient {
 
   /********* CACHE LAYER — Tenants *********/
 
-  async getAllTenants(): Promise<TenantResponse[] | null> {
-    let allTenants = this._localCache.getValue<TenantResponse[]>(CacheConstants.TenantPrefix)
+  async getAllTenants(): Promise<CachedTenant[] | null> {
+    let allTenants = this._localCache.getValue<CachedTenant[]>(CacheConstants.TenantPrefix)
     if (!allTenants) {
       console.debug('ConfigClient - Tenants Fetch All')
       allTenants = await this._getAllRemoteTenants()
@@ -91,8 +89,8 @@ export class CacheClient {
     return allTenants
   }
 
-  async getTenantByID(tenantID: string): Promise<TenantResponse | null> {
-    let tenant = this._localCache.getValue<TenantResponse>(`${CacheConstants.TenantPrefix}${tenantID}`)
+  async getTenantByID(tenantID: string): Promise<CachedTenant | null> {
+    let tenant = this._localCache.getValue<CachedTenant>(`${CacheConstants.TenantPrefix}${tenantID}`)
     if (!tenant) {
       console.debug('ConfigClient - Tenant Fetch:', tenantID)
       await this._initCacheClient()
@@ -106,19 +104,19 @@ export class CacheClient {
 
   /********* CACHE LAYER — Certifications & Courses *********/
 
-  async getCertificationByID(certID: string, tenantID: string) {
+  async getCertificationByID(certID: string, tenantID: string): Promise<CachedCertification | null> {
     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
+    if (!tenant?.certifications) return null
+    return tenant.certifications.find(c => c.id === certID) || null
   }
 
-  async getCourseByID(courseID: string, tenantID: string) {
+  async getCourseByID(courseID: string, tenantID: string): Promise<CachedCourse | null> {
     const tenant = await this.getTenantByID(tenantID)
-    if (!tenant || !Array.isArray((tenant as any).certifications)) return null
-    for (const cert of (tenant as any).certifications) {
+    if (!tenant?.certifications) return null
+    for (const cert of tenant.certifications) {
       for (const req of cert.requirements || []) {
         if (Array.isArray(req)) {
-          const found = req.find((r: any) => r.id === courseID)
+          const found = req.find(r => r.id === courseID)
           if (found) return found
         } else if (req.id === courseID) return req
       }
@@ -126,25 +124,29 @@ export class CacheClient {
     return null
   }
 
-  async getCourseInCertificationByID(certificationID: string, courseID: string, tenantID: string) {
+  async getCourseInCertificationByID(
+    certificationID: string,
+    courseID: string,
+    tenantID: string
+  ): Promise<CachedCourse | null> {
     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 (!tenant?.certifications) return null
+    const cert = tenant.certifications.find(c => 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)
+        const found = req.find(r => r.id === courseID)
         if (found) return found
       } else if (req.id === courseID) return req
     }
     return null
   }
 
-  async getAllCoursesByTenantID(tenantID: string) {
+  async getAllCoursesByTenantID(tenantID: string): Promise<CachedCourse[] | null> {
     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 (!tenant?.certifications) return null
+    const courses: CachedCourse[] = []
+    for (const cert of tenant.certifications) {
       for (const req of cert.requirements || []) {
         if (Array.isArray(req)) {
           for (const sub of req) courses.push(sub)
@@ -154,11 +156,11 @@ export class CacheClient {
     return courses
   }
 
-  async getAllCoursesByCertificationID(certID: string, tenantID: string) {
+  async getAllCoursesByCertificationID(certID: string, tenantID: string): Promise<CachedCourse[] | null> {
     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 (!tenant?.certifications) return null
+    const courses: CachedCourse[] = []
+    for (const cert of tenant.certifications) {
       if (cert.id !== certID) continue
       for (const req of cert.requirements || []) {
         if (Array.isArray(req)) {
@@ -169,18 +171,18 @@ export class CacheClient {
     return courses
   }
 
-  async getAllCourses() {
+  async getAllCourses(): Promise<CachedCourse[]> {
     return this.getAllCoursesByCustomerID(null)
   }
 
-  async getAllCoursesByCustomerID(customerID: string | null) {
+  async getAllCoursesByCustomerID(customerID: string | null): Promise<CachedCourse[]> {
     const allTenants = await this.getAllTenants()
     if (!allTenants) return []
-    const filtered = allTenants.filter(t => !customerID || (t as any).customerID === customerID)
-    const courses: any[] = []
+    const filtered = allTenants.filter(t => !customerID || t.customerID === customerID)
+    const courses: CachedCourse[] = []
     for (const tenant of filtered) {
-      if (!Array.isArray((tenant as any).certifications)) continue
-      for (const cert of (tenant as any).certifications) {
+      if (!tenant.certifications) continue
+      for (const cert of tenant.certifications) {
         for (const req of cert.requirements || []) {
           if (Array.isArray(req)) {
             for (const sub of req) {
@@ -199,13 +201,13 @@ export class CacheClient {
 
   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
+    if (!customer?.allowedOnlineCourseProviders) return null
+    return customer.allowedOnlineCourseProviders.find(p => p.id === courseProviderID) || null
   }
 
   /********* Private *********/
 
-  private async _getAllRemoteCustomers(): Promise<CustomerResponse[] | null> {
+  private async _getAllRemoteCustomers(): Promise<CachedCustomer[] | null> {
     await this._initCacheClient()
     if (!this._remoteCache) return null
     const allKeys = await this._remoteCache.keys(`${CacheConstants.CustomerPrefix}*`)
@@ -214,7 +216,7 @@ export class CacheClient {
     return Array.isArray(raw) ? raw.map(r => JSON.parse(r)) : null
   }
 
-  private async _getAllRemoteTenants(): Promise<TenantResponse[] | null> {
+  private async _getAllRemoteTenants(): Promise<CachedTenant[] | null> {
     await this._initCacheClient()
     if (!this._remoteCache) return null
     const allKeys = await this._remoteCache.keys(`${CacheConstants.TenantPrefix}*`)

package/CacheTypes.ts

@@ -21,7 +21,7 @@ export interface CacheConfig {
 }
 
 /**
- * Cache key prefixes and TTL constants (matching the legacy client).
+ * Cache key prefixes and TTL constants (matching the persistent cache).
  */
 export const CacheConstants = {
   // Customer
@@ -33,3 +33,273 @@ export const CacheConstants = {
   AllTenantsTTL: 60 * 60, // 1 hour
   TenantTTL: 60, // 1 minute
 } as const
+
+// ─── Expanded (Cached) Types ────────────────────────────────────────────────
+
+/**
+ * Course provider object as stored in the expanded customer cache.
+ */
+export interface CachedCourseProvider {
+  id: string
+  type?: string
+  onlineTemplateIDs?: string[]
+  provider?: any
+  createdBy?: string
+  createdOn?: number
+  updatedBy?: string
+  updatedOn?: number
+}
+
+/**
+ * Tile permissions as injected into the cached customer.
+ */
+export interface CachedTilePermissions {
+  customerID?: string
+  tilePermissions?: Record<string, any>
+  [key: string]: any
+}
+
+/**
+ * The expanded customer object stored in the persistent cache.
+ * Differs from CustomerResponse:
+ * - `allowedOnlineCourseProviders` contains full CourseProvider objects (not just IDs)
+ * - `tilePermissions` is injected from the PortalTilePermissions table
+ */
+export interface CachedCustomer {
+  id: string
+  createdBy?: string
+  createdOn?: number
+  updatedBy?: string
+  updatedOn?: number
+  timezoneCode?: string
+  adminRole?: string
+  userRole?: string
+  instructorRole?: string
+  idmKey?: string
+  idmToken?: string
+  idmAPIUser?: string
+  idmAPIPassword?: string
+  mailerSender?: string
+  preventUserFromUpdatingNames?: boolean
+  orgModEndpoint?: string
+  orgAdminRole?: string
+  orgSubAdminRole?: string
+  orgUserRole?: string
+  orgModNamespace?: string
+  /** Expanded: full CourseProvider objects (not just IDs) */
+  allowedOnlineCourseProviders?: CachedCourseProvider[]
+  allowedForeignReqs?: string[]
+  displayName?: string
+  sharedModuleLicenseAPIKey?: string
+  sharedModuleConfigAPIKey?: string
+  sharedModuleAuditingAPIKey?: string
+  sharedModuleAgreementAPIKey?: string
+  sharedModuleOrganizationAPIKey?: string
+  sharedModuleClassroomAPIKey?: string
+  sharedModuleMailerAPIKey?: string
+  authConfig?: Record<string, any>
+  portalConfig?: {
+    theme?: string
+    domain?: string
+    cookiesHubDomain?: string
+    acceptConnectionsFrom?: string
+  }
+  theme?: Record<string, any>
+  domain?: string
+  cookiesHubDomain?: string
+  acceptConnectionsFrom?: string[]
+  worksafeTerm?: string
+  cancelationPolicies?: Array<{
+    id?: string
+    description?: string
+    cancelPolicy?: {
+      isBusinessDays?: boolean
+      canBeCanceled?: boolean
+      canBeRescheduled?: boolean
+      rules?: Array<{
+        untilDaysBefore?: number
+        percentageRefunded?: number
+        amountCharged?: number
+        deductEnrolmentPayment?: boolean
+      }>
+    }
+  }>
+  salesTaxLabel?: string
+  ignoreCustomAttributesForSignUp?: boolean
+  timezone?: string
+  /** Injected from PortalTilePermissions table */
+  tilePermissions?: CachedTilePermissions | null
+  cooldownPolicies?: Array<{
+    id?: string
+    description?: string
+    cooldownPolicy?: {
+      rules?: Array<{
+        untilFailedAttempts?: number
+        cooldownPeriod?: number
+        invalidateCourseRequirements?: boolean
+        lockApplication?: boolean
+        blockCourse?: boolean
+        autoUnlockInDays?: number
+      }>
+    }
+  }>
+  ui?: {
+    banner?: {
+      type?: string
+      content?: string
+    }
+  }
+  featureFlags?: Array<{
+    name: string
+    enabled: boolean
+    metadata?: string
+  }>
+  [key: string]: any
+}
+
+/**
+ * Course object as stored inside cached certification requirements.
+ */
+export interface CachedCourse {
+  id: string
+  certificationID: string
+  tenantID?: string
+  customerID?: string
+  productID?: string
+  waivePayments?: boolean
+  coolDownPeriod?: number | number[] | null
+  coolDownPolicy?: any
+  enableRequestToEnrol?: boolean
+  materialsProductID?: string
+  maxRetry?: number
+  requirementsIDs?: string[]
+  requiredOnRenew?: boolean
+  validityPeriod?: number
+  validityPeriodInMonths?: number
+  validityPeriodInYears?: number
+  webhooks?: string[]
+  isRetakeAllowed?: boolean
+  allowStudentUploads?: boolean
+  allowIfAnyRequirementMet?: boolean
+  allowOnlyIfCertificationIsValid?: boolean
+  gracePeriodAfterCertCompletion?: number
+  courseFailWebhooks?: string[]
+  cooldownStartWebhooks?: string[]
+  cooldownEndWebhooks?: string[]
+  lockAfterFailure?: boolean
+  agreementID?: string
+  isMandatory?: boolean
+  points?: number
+  courseBooks?: Array<{ fileID: string; fileName: string; attachToEmail?: boolean }>
+  courseCertificateType?: string
+  courseCertificateTemplate?: string
+  courseCertNumberMaskFormat?: string
+  courseCertNumberMode?: string
+  courseCertNumberInitialNumber?: string
+  externalRequirementWebhook?: string
+  reuseCertNumber?: boolean
+  warningDuePaymentRemainingDays?: number
+  warningRemainingDays?: Array<{ template: string; period: number }>
+  onlineWarningRemainingDays?: Array<{ template: string; period: number }>
+  emailComplement?: string
+  emailTemplates?: { coursePassed?: string | null; courseFailed?: string | null }
+  emailEventOverrides?: Array<{ eventID: string; templateID: string }>
+  displayName?: string
+  cardDescription?: string
+  description?: string
+  uiTerm?: string
+  uiLogo?: string
+  calendarColor?: string
+  showCollapsed?: boolean
+  passUiTerm?: string
+  failUiTerm?: string
+  courseType?: string
+  preventLaunchIfCompleted?: boolean
+  requirementUserAttribIDs?: Array<{ partition: string; attributeName: string; description: string }>
+  createdBy?: string
+  createdOn?: number
+  updatedBy?: string
+  updatedOn?: number
+  [key: string]: any
+}
+
+/**
+ * Training provider object as stored inside cached certifications.
+ */
+export interface CachedTrainingProvider {
+  id: string
+  customerID: string
+  name?: string
+  url?: string
+  isDisabled?: boolean
+  createdBy?: string
+  createdOn?: number
+  updatedBy?: string
+  updatedOn?: number
+}
+
+/**
+ * Application section within a cached certification.
+ */
+export interface CachedApplicationSection {
+  applicationEnabled?: boolean
+  equivalenciesSection?: {
+    sectionEnabled?: boolean
+    /** Expanded equivalence objects with isDisabled flag */
+    options?: Array<{ id: string; isDisabled?: boolean; [key: string]: any }>
+  }
+  requirementsSection?: {
+    sectionEnabled?: boolean
+    /** Expanded requirement objects with isDisabled flag */
+    requirements?: Array<{ id: string; isDisabled?: boolean; [key: string]: any }>
+  }
+  electiveRequirementsSection?: {
+    sectionEnabled?: boolean
+    requirements?: Array<{ id: string; isDisabled?: boolean; [key: string]: any }>
+  }
+  customRequirementsSections?: Array<{
+    sectionEnabled?: boolean
+    requirements?: Array<{ id: string; isDisabled?: boolean; [key: string]: any }>
+    [key: string]: any
+  }>
+  [key: string]: any
+}
+
+/**
+ * Certification object as stored inside the cached tenant.
+ * Contains expanded requirements (full course objects) and application sections.
+ */
+export interface CachedCertification {
+  id: string
+  customerID: string
+  tenantID: string
+  /** Expanded course requirements — can be CachedCourse or CachedCourse[] (grouped alternatives) */
+  requirements?: (CachedCourse | CachedCourse[])[]
+  application?: CachedApplicationSection
+  renewal?: {
+    application?: CachedApplicationSection
+    [key: string]: any
+  }
+  /** Training providers relevant to this certification */
+  trainingProviders?: CachedTrainingProvider[]
+  [key: string]: any
+}
+
+/**
+ * The expanded tenant object stored in the persistent cache.
+ * Differs from TenantResponse:
+ * - `certifications` array is injected with fully expanded certification objects
+ *   (including courses, applications with equivalencies/requirements, training providers)
+ */
+export interface CachedTenant {
+  id: string
+  customerID: string
+  createdBy?: string
+  createdOn?: number
+  updatedBy?: string
+  updatedOn?: number
+  name?: string
+  /** Expanded certifications with full course/application/training provider data */
+  certifications?: CachedCertification[]
+  [key: string]: any
+}