@api-client/ui 0.5.58 → 0.6.1

package/src/services/SdkService.ts

@@ -0,0 +1,57 @@
+import { Service } from '../core/Service.js'
+import { StoreSdk } from '@api-client/core/sdk/StoreSdkWeb.js'
+
+export default class SdkService extends Service {
+  static override key = 'api-service/sdk'
+  sdk!: StoreSdk
+  protected url: string
+
+  /**
+   * The URL of the API server.
+   * @param url - The URL of the API server.
+   */
+  constructor(url: string) {
+    super()
+    this.url = url
+  }
+
+  override async onCreate(): Promise<void> {
+    this.sdk = new StoreSdk(this.url)
+  }
+
+  // override async onStart(): Promise<void> {
+  //   await this.sdk.initialize()
+  // }
+
+  get organizations(): StoreSdk['organizations'] {
+    return this.sdk.organizations
+  }
+
+  get user(): StoreSdk['user'] {
+    return this.sdk.user
+  }
+
+  get auth(): StoreSdk['auth'] {
+    return this.sdk.auth
+  }
+
+  get file(): StoreSdk['file'] {
+    return this.sdk.file
+  }
+
+  get shared(): StoreSdk['shared'] {
+    return this.sdk.shared
+  }
+
+  get trash(): StoreSdk['trash'] {
+    return this.sdk.trash
+  }
+
+  get dataCatalog(): StoreSdk['dataCatalog'] {
+    return this.sdk.dataCatalog
+  }
+
+  get groups(): StoreSdk['groups'] {
+    return this.sdk.groups
+  }
+}

package/src/services/TransmitService.ts

@@ -0,0 +1,28 @@
+import { Transmit } from '@adonisjs/transmit-client'
+import { Service } from '../core/Service.js'
+
+export default class TransmitService extends Service {
+  static override key = 'api-service/transmit'
+
+  transmit?: Transmit
+
+  protected url: string
+
+  /**
+   * @param url - The URL of the API server.
+   */
+  constructor(url: string) {
+    super()
+    this.url = url
+  }
+
+  protected override async onCreate(): Promise<void> {
+    this.transmit = new Transmit({
+      baseUrl: this.url,
+    })
+  }
+
+  protected override async onDestroy(): Promise<void> {
+    this.transmit?.close()
+  }
+}

package/src/services/UserCacheService.ts

@@ -0,0 +1,51 @@
+import type { IUser } from '@api-client/core/models/store/User.js'
+import { Service } from '../core/Service.js'
+import services from './api_service.js'
+
+export default class UserCacheService extends Service {
+  static override key = 'api-service/user-cache'
+  private organizationId?: string
+
+  /**
+   * Sets the organization ID for the user cache.
+   * This must be called before fetching user data.
+   * @param oid - The organization ID to set for the user cache.
+   * This will clear the cache when the organization changes.
+   */
+  setOrganization(oid: string): void {
+    if (this.organizationId === oid) {
+      return // No change in organization, do nothing
+    }
+    this.organizationId = oid
+  }
+
+  /**
+   * Fetches a user by their unique identifier (UID).
+   * If the user is already cached, it returns the cached user.
+   * Otherwise, it fetches the user from the API and caches it.
+   * @param uid - The unique identifier of the user to fetch.
+   * @returns A promise that resolves to the IUser object or null if not found.
+   */
+  async getUser(uid: string): Promise<IUser | null> {
+    const oid = this.organizationId
+    if (!oid) {
+      throw new Error('Organization ID is not set. Call setOrganization() before fetching user data.')
+    }
+    const cache = await services.get('cache')
+    const cacheKey = `user_${oid}_${uid}`
+    const cachedUser = await cache.get<IUser>(cacheKey)
+    if (cachedUser) {
+      return cachedUser
+    }
+    const sdk = await services.get('sdk')
+    try {
+      const user = await sdk.organizations.users.read(oid, uid)
+      await cache.set(cacheKey, user)
+      return user
+    } catch (error) {
+      const log = await services.get('logger')
+      log.error(`Failed to fetch user with ID ${uid}:`, error)
+      return null
+    }
+  }
+}

package/src/services/UserService.ts

@@ -0,0 +1,214 @@
+import type { IUser } from '@api-client/core/models/store/User.js'
+import type { GroupSchema } from '@api-client/core/models/store/Group.js'
+import { type IPermission, Permission } from '@api-client/core/models/store/Permission.js'
+import { Service } from '../core/Service.js'
+import services from './api_service.js'
+
+enum CheckState {
+  NotChecked,
+  Checking,
+  Checked,
+}
+
+const UserCacheKey = 'current_user'
+
+export default class UserService extends Service {
+  static override key = 'api-service/user'
+
+  /**
+   * Tells yhe current state of checking for user session.
+   */
+  status = CheckState.NotChecked
+
+  /**
+   * The currently logged in user.
+   */
+  #user: IUser | null = null
+
+  /**
+   * The list of groups the user belongs to.
+   */
+  #groups: GroupSchema[] = []
+
+  /**
+   * A hidden value for the `updateComplete` getter.
+   */
+  #updateComplete?: Promise<void>
+
+  /**
+   * The resolver to call when the update completes.
+   */
+  #updateResolver?: () => void
+
+  /**
+   * Checks whether user is logged in and exists.
+   * @returns `true`
+   */
+  get isLoggedIn(): boolean {
+    return !!this.#user
+  }
+
+  protected override async onStart(): Promise<void> {
+    // do this asynchronously to avoid blocking the app startup
+    const logger = await services.get('logger')
+    logger.debug('[UserService]: Starting service')
+    this.load()
+  }
+
+  protected override async onDestroy(): Promise<void> {
+    this.#groups = []
+    this.#user = null
+    const logger = await services.get('logger')
+    logger.debug('[UserService]: Destroying service')
+  }
+
+  /**
+   * Ensures that the user data is loaded.
+   * @returns A promise that resolves when the user data is loaded.
+   */
+  async ready(): Promise<void> {
+    if (this.status === CheckState.Checking) {
+      await this.#updateComplete
+      return
+    }
+    if (this.status === CheckState.NotChecked) {
+      await this.load()
+    }
+  }
+
+  /**
+   * Loads the user data from the API.
+   * This gets the user data from the API and the list of groups the user belongs to.
+   *
+   * Note that calling this method multiple times will refresh the user data
+   * and the list of groups, so it is recommended to call this method only once
+   * and then use the `getUser()` method to get the user data.
+   * @returns A promise that resolves when the user data is loaded.
+   */
+  async load(): Promise<void> {
+    const logger = await services.get('logger')
+    logger.debug('[UserService]: Loading user data')
+    if (this.status === CheckState.Checking) {
+      logger.debug('[UserService]: Already checking user data')
+      return this.#updateComplete
+    }
+    logger.debug('[UserService]: Starting to check user data')
+    this.status = CheckState.Checking
+    this.#updateComplete = new Promise<void>((resolver) => {
+      this.#updateResolver = resolver
+    })
+    try {
+      logger.debug('[UserService]: Loading user and groups')
+      await this.#loadUser()
+      await this.#loadGroups()
+      this.status = CheckState.Checked
+    } catch (error) {
+      // ...ignore errors here, they are handled in the loading methods
+      this.status = CheckState.NotChecked
+      logger.error('[UserService]: Error loading user data', error)
+    }
+    logger.debug('[UserService]: Finished loading user data')
+    this.#updateResolver?.()
+    this.#updateResolver = undefined
+    this.#updateComplete = undefined
+    this.dispatchEvent(new Event('userloaded'))
+  }
+
+  async getUserOrThrow(): Promise<IUser> {
+    const user = await this.getUser()
+    if (!user) {
+      throw new Error('The user session is not available. Please log in again.')
+    }
+    return user
+  }
+
+  async getUser(): Promise<IUser | null> {
+    if (this.status === CheckState.Checking) {
+      await this.#updateComplete
+    }
+    return this.#user
+  }
+
+  async getGroups(): Promise<GroupSchema[]> {
+    if (this.status === CheckState.Checking) {
+      await this.#updateComplete
+      return this.#groups
+    }
+    return this.#groups
+  }
+
+  async #loadUser(): Promise<void> {
+    const logger = await services.get('logger')
+    const sdk = await services.get('sdk')
+    const cache = await services.get('cache')
+    const cachedUser = await cache.get<IUser>(UserCacheKey)
+    if (cachedUser) {
+      this.#user = cachedUser
+      return
+    }
+    try {
+      this.#user = await sdk.user.me()
+      logger.debug('[UserService]: Has user data')
+      await cache.set<IUser>(UserCacheKey, this.#user, cache.TTL.OneHour)
+    } catch (error) {
+      logger.error('[UserService]: Failed to load user data', error)
+      this.#user = null
+    }
+  }
+
+  async #loadGroups(): Promise<void> {
+    const cache = await services.get('cache')
+    const logger = await services.get('logger')
+    const orgService = await services.get('org')
+    const org = await orgService.currentOrganization()
+    const uid = this.#user?.key
+    if (!org || !uid) {
+      logger.info('UserService: No organization or user ID found, cannot load groups.')
+      this.#groups = []
+      return
+    }
+    const cachedGroups = await cache.get<GroupSchema[]>(`user_groups_${org.key}`)
+    if (cachedGroups) {
+      this.#groups = cachedGroups
+      return
+    }
+
+    const sdk = await services.get('sdk')
+    try {
+      const result = await sdk.groups.list(org.key, { uid })
+      this.#groups = result.items
+      logger.debug(`[UserService]: Loaded ${this.#groups.length} groups`)
+      await cache.set<GroupSchema[]>(`user_groups_${org.key}`, this.#groups, cache.TTL.OneHour)
+    } catch (error) {
+      logger.error('UserService: Failed to load groups', error)
+      this.#groups = []
+    }
+  }
+
+  /**
+   * Finds the user's highest permission in the given list of permissions.
+   * @param permissions The list of permissions to search in.
+   * @return The user's permission if found, otherwise `undefined`.
+   */
+  findUserPermission(permissions: IPermission[]): IPermission | undefined {
+    const uid = this.#user?.key
+    const relevantPermissions: Permission[] = []
+    for (const p of permissions) {
+      if (p.granteeId === uid) {
+        relevantPermissions.push(new Permission(p))
+      } else if (p.type === 'group') {
+        const group = this.#groups.find((g) => g.key === p.granteeId)
+        if (group) {
+          relevantPermissions.push(new Permission(p))
+        }
+      } else if (p.type === 'organization') {
+        relevantPermissions.push(new Permission(p))
+      }
+    }
+    if (relevantPermissions.length === 0) {
+      return undefined
+    }
+    relevantPermissions.sort((a, b) => (Permission.isHigherRole(a.role, b.role) ? -1 : 1))
+    return relevantPermissions[0].toJSON()
+  }
+}

package/src/services/api_service.ts

@@ -0,0 +1,24 @@
+import { ServiceManager } from '../core/ServiceManager.js'
+import type UserService from './UserService.js'
+import type OrganizationService from './OrganizationService.js'
+import type SdkService from './SdkService.js'
+import type ConfigurationService from './ConfigurationService.js'
+import type TransmitService from './TransmitService.js'
+import type LoggingService from './LoggingService.js'
+import type UserCacheService from './UserCacheService.js'
+import type CacheService from './CacheService.js'
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export type KnownBindings = {
+  config: ConfigurationService
+  sdk: SdkService
+  user: UserService
+  userCache: UserCacheService
+  org: OrganizationService
+  transmit: TransmitService
+  logger: LoggingService
+  cache: CacheService
+}
+
+const manager = new ServiceManager<KnownBindings>()
+export { manager as default }

package/tsconfig.json

@@ -6,7 +6,12 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "noEmitOnError": true,
-    "lib": ["esnext", "DOM", "Decorators", "dom.iterable"],
+    "lib": [
+      "esnext",
+      "DOM",
+      "Decorators",
+      "dom.iterable"
+    ],
     "strict": true,
     "esModuleInterop": true,
     "experimentalDecorators": false,
@@ -32,10 +37,20 @@
     "resolveJsonModule": true,
     "plugins": [
       {
-        "name": "@jarrodek/ts-lit-plugin"
+        "name": "ts-lit-plugin"
       }
     ]
   },
-  "include": ["src/**/*.ts", "test/elements/navigation/Navigation.test.ts"],
-  "exclude": ["demo/apis/*", "demo/models/*", "node_modules", ".wireit", ".tmp", ".rollup.cache"]
+  "include": [
+    "src/**/*.ts",
+    "test/elements/navigation/Navigation.test.ts"
+  ],
+  "exclude": [
+    "demo/apis/*",
+    "demo/models/*",
+    "node_modules",
+    ".wireit",
+    ".tmp",
+    ".rollup.cache"
+  ]
 }