@api-client/ui 0.5.58 → 0.6.0

package/src/data/FileShareModel.ts

@@ -0,0 +1,258 @@
+import { nanoid } from 'nanoid'
+import type { IFile } from '@api-client/core/models/store/File.js'
+import { Model } from '../core/Model.js'
+import { exponentialBackoffDelay, type RetryOptions, shouldRetryApiError, retry } from './retry_logic.js'
+import { fromError } from '../exceptions/builder.js'
+import type SdkService from '../services/SdkService.js'
+import type { ContextListOptions, IBulkOperationResult } from '@api-client/core/events/BaseEvents.js'
+import { Exception } from '@api-client/core/exceptions/exception.js'
+import type { AccessOperation, IPermission } from '@api-client/core/models/store/Permission.js'
+import type { IUser } from '@api-client/core/models/store/User.js'
+import type { AccessPatchInfo } from '@api-client/core'
+
+/**
+ * TODO: add caching of the user list. When querying for users, each user should be cached
+ *       and the next time the user is queried, it should be fetched from the cache.
+ *       This will prevent multiple requests to the server for the same user.
+ *       This should also work when fetching a list of users by their IDs.
+ *       Cached users should not be queried again.
+ *       Note, the cache should have a TTL of 5 minutes or so, to ensure that the user list is not stale.
+ * @fires users - Fired when the list of users is updated.
+ */
+export default class FileShareModel extends Model<IFile[]> {
+  /**
+   * The organization ID.
+   */
+  oid?: string
+  /**
+   * The list of file ids to process in this request.
+   */
+  ids?: string[]
+  /**
+   * A reference to the SDK service.
+   */
+  sdk: SdkService
+
+  /**
+   * A flag indicating whether the model is currently loading data.
+   */
+  loading: boolean
+
+  constructor(sdk: SdkService) {
+    super()
+    this.sdk = sdk
+    this.loading = false
+  }
+
+  async read(oid: string, ids: string[]): Promise<IFile[]> {
+    this.oid = oid
+    this.ids = ids
+    this.debounce(() => this.#read())
+    await this.taskComplete
+    return this.value || []
+  }
+
+  async #read(): Promise<void> {
+    const { ids, oid } = this
+    if (!ids || !oid) {
+      throw new Exception('FileShareModel: oid and ids must be set before reading files.')
+    }
+    const retryOptions: RetryOptions = {
+      delayMs: exponentialBackoffDelay,
+      shouldRetry: shouldRetryApiError,
+      retries: this.retryCount,
+    }
+    const operation = async (): Promise<IBulkOperationResult<IFile>> => {
+      return this.sdk.file.readBulk(oid, ids)
+    }
+    this.loading = true
+    try {
+      const info = await retry(operation, retryOptions)
+      const valid = info.items.filter((item) => {
+        if (!item) {
+          return false
+        }
+        if (!item.capabilities) {
+          return false
+        }
+        return item.capabilities.canShare
+      }) as IFile[]
+      if (valid.length !== ids.length) {
+        const missing = ids.filter((id) => !valid.some((file) => file.key === id))
+        throw new Exception(`Some files were not found: ${missing.join(', ')}`)
+      }
+      this.raw = valid
+    } catch (e) {
+      const err = fromError(e as Error)
+      this.notifyError(err)
+      throw err
+    } finally {
+      this.loading = false
+    }
+  }
+
+  /**
+   * Lists permissions that are common across multiple files.
+   * A permission is considered common if, for a given `granteeId`, the same `type` and `role`
+   * combination exists in every file provided. The returned permissions are the
+   * actual `IPermission` instances from the first file in the input array that meet this criterion.
+   *
+   * @param files An array of `IFile` objects.
+   * @returns An array of `IPermission` objects that are common to all provided files.
+   *          Returns an empty array if fewer than two files are provided, if the first
+   *          file has no permissions, or if no common permissions are found.
+   */
+  static findCommonPermissions(files: IFile[]): IPermission[] {
+    // Common permissions can only be determined if there are at least two files to compare.
+    if (!files) {
+      return []
+    }
+
+    if (files.length === 1) {
+      return [...files[0].permissions]
+    }
+    const firstFilePermissions = files[0].permissions
+    const commonPermissions: IPermission[] = []
+
+    // Iterate through each permission in the first file.
+    // This permission will be our candidate for a common permission.
+    for (const permFromFirstFile of firstFilePermissions) {
+      let isPermCommonToAllFiles = true
+
+      // Check this candidate permission against all other files.
+      for (let i = 1; i < files.length; i++) {
+        const otherFile = files[i]
+        const otherFilePermissions = otherFile.permissions
+
+        // If a subsequent file has no permissions, the candidate cannot be common.
+        if (!otherFilePermissions || otherFilePermissions.length === 0) {
+          isPermCommonToAllFiles = false
+          break // Move to the next candidate from the first file.
+        }
+
+        // Check if the current candidate permission (based on granteeId, type, and role)
+        // exists in the `otherFile`.
+        const foundInOtherFile = otherFilePermissions.some(
+          (otherPerm) => otherPerm.type === permFromFirstFile.type && otherPerm.role === permFromFirstFile.role
+        )
+
+        if (!foundInOtherFile) {
+          isPermCommonToAllFiles = false
+          break // Move to the next candidate from the first file.
+        }
+      }
+
+      // If the candidate permission was found in all other files, add it to the results.
+      if (isPermCommonToAllFiles) {
+        commonPermissions.push(permFromFirstFile)
+      }
+    }
+    return commonPermissions
+  }
+
+  async searchUsers(ignore: string[], query?: string) {
+    this.debounce(() => this.#queryUsers(ignore, query))
+  }
+
+  async #queryUsers(ignore: string[], query?: string): Promise<void> {
+    const { oid } = this
+    if (!oid) {
+      throw new Exception('FileShareModel: oid must be set before listing users.')
+    }
+    const retryOptions: RetryOptions = {
+      retries: this.retryCount,
+      delayMs: exponentialBackoffDelay,
+      shouldRetry: shouldRetryApiError,
+    }
+    const operation = async (): Promise<IBulkOperationResult<IUser>> => {
+      const options: ContextListOptions = {
+        limit: 20,
+      }
+      if (query) {
+        // options.filter = {
+        //   op: 'OR',
+        //   filters: [
+        //     { field: 'name', operator: 'con', value: query },
+        //     { field: 'email', operator: 'con', value: query },
+        //   ],
+        // }
+        options.filter = {
+          op: 'AND',
+          filters: [
+            {
+              field: 'id',
+              operator: 'nin',
+              value: ignore,
+            },
+            {
+              op: 'OR',
+              filters: [
+                { field: 'name', operator: 'con', value: query },
+                { field: 'email', operator: 'con', value: query },
+              ],
+            },
+          ],
+        }
+      }
+      return this.sdk.organizations.users.list(oid, options)
+    }
+    const result = await retry(operation, retryOptions)
+    this.dispatchEvent(new CustomEvent('users', { detail: result.items }))
+  }
+
+  /**
+   * Fetches a bulk of users by their IDs.
+   * @param oid The organization ID.
+   * @param ids An array of user IDs to fetch.
+   * @returns A promise that resolves to an array of IUser objects.
+   */
+  async getUsersBulk(oid: string, ids: string[]): Promise<IUser[]> {
+    if (!oid || !ids) {
+      throw new Exception('FileShareModel: oid and ids must be set before reading users.')
+    }
+    if (ids.length === 0) {
+      return []
+    }
+    const retryOptions: RetryOptions = {
+      delayMs: exponentialBackoffDelay,
+      shouldRetry: shouldRetryApiError,
+      retries: this.retryCount,
+    }
+    const operation = async (): Promise<IBulkOperationResult<IUser>> => {
+      return this.sdk.organizations.users.readBatch(oid, ids)
+    }
+    const info = await retry(operation, retryOptions)
+    return info.items.filter(Boolean) as IUser[]
+  }
+
+  async commit(operations: AccessOperation[]): Promise<IFile> {
+    const { oid, ids } = this
+    if (!oid || !ids || ids.length === 0) {
+      throw new Exception('FileShareModel: oid and ids must be set before committing changes.')
+    }
+    const info: AccessPatchInfo = {
+      id: nanoid(),
+      patch: operations,
+    }
+    const id = ids[0]
+    const retryOptions: RetryOptions = {
+      delayMs: exponentialBackoffDelay,
+      shouldRetry: shouldRetryApiError,
+      retries: this.retryCount,
+    }
+    const operation = async (): Promise<IFile> => {
+      return this.sdk.file.patchUsers(oid, id, info)
+    }
+    this.loading = true
+    try {
+      const file = await retry(operation, retryOptions)
+      return file
+    } catch (e) {
+      const err = fromError(e as Error)
+      this.notifyError(err)
+      throw err
+    } finally {
+      this.loading = false
+    }
+  }
+}

package/src/data/FilesModel.ts

@@ -0,0 +1,226 @@
+import { Model } from '../core/Model.js'
+import { exponentialBackoffDelay, type RetryOptions, shouldRetryApiError, retry } from './retry_logic.js'
+import { fromError } from '../exceptions/builder.js'
+import { LiveData } from '../reactive/LiveData.js'
+import type SdkService from '../services/SdkService.js'
+import { filesSortFunction } from '../lib/files/Utils.js'
+import type { IFile } from '@api-client/core/models/store/File.js'
+import type { ListFileKind } from '@api-client/core/sdk/FilesSdk.js'
+import type { ContextListOptions, ContextListResult } from '@api-client/core/events/BaseEvents.js'
+
+export type FilesSource = 'own' | 'shared'
+
+enum ModelState {
+  /**
+   * Not doing anything.
+   */
+  idle,
+  /**
+   * Currently querying for file data.
+   */
+  reading,
+  /**
+   * Data was received and the result yielded no results or less than the limit.
+   */
+  ended,
+}
+
+export default class FilesModel extends Model<LiveData<IFile[]>> {
+  source: FilesSource = 'own'
+  /**
+   * The pagination cursor for files to use with the next query.
+   */
+  cursor?: string
+
+  /**
+   * The current state of the model.
+   */
+  state: ModelState = ModelState.idle
+
+  /**
+   * The list of file kinds to list.
+   * Folders are always included.
+   */
+  kinds?: ListFileKind[]
+
+  /**
+   * The variable parent folder key.
+   * This is set when interacting with the UI or when the `folder` attribute change.
+   */
+  parent?: string
+
+  override get value(): LiveData<IFile[]> {
+    return this.raw as LiveData<IFile[]>
+  }
+
+  constructor(
+    public oid: string,
+    public sdk: SdkService,
+    source: FilesSource = 'own'
+  ) {
+    super()
+    this.source = source
+    this.raw = new LiveData<IFile[]>([])
+  }
+
+  resetListState(): void {
+    this.value.set([])
+    this.cursor = undefined
+    this.state = ModelState.idle
+  }
+
+  scheduleQuery(): void {
+    this.debounce(this.#query)
+  }
+
+  /**
+   * Sets a parent and makes the query.
+   * It does nothing if the parent is already set.
+   *
+   * @param key The key of the parent to query. Empty for root folder.
+   */
+  selectFolder(key?: string): void {
+    if (this.parent === key) {
+      return
+    }
+    this.parent = key
+    this.resetListState()
+    this.scheduleQuery()
+  }
+
+  /**
+   * Finds a file by the key.
+   * @param key The key of the file to find
+   * @returns The file, if any
+   */
+  getFile(key: string): IFile | undefined {
+    return this.value.value.find((i) => i.key === key)
+  }
+
+  replaceFile(file: IFile): void {
+    const files = this.value.value
+    const index = files.findIndex((i) => i.key === file.key)
+    if (index === -1) {
+      files.push(file)
+    } else {
+      files[index] = file
+    }
+    files.sort(filesSortFunction)
+  }
+
+  addFile(file: IFile): void {
+    const files = this.value.value
+    files.push(file)
+    files.sort(filesSortFunction)
+  }
+
+  removeFile(key: string): void {
+    const files = this.value.value
+    const index = files.findIndex((i) => i.key === key)
+    if (index === -1) {
+      return
+    }
+    files.splice(index, 1)
+  }
+
+  removeFiles(keys: string[]): void {
+    this.value.set(this.value.value.filter((file) => !keys.includes(file.key)))
+  }
+
+  async #query(): Promise<void> {
+    if (this.state !== ModelState.idle) {
+      return
+    }
+    this.state = ModelState.reading
+    try {
+      const result = await this.listFiles()
+      this.#processFileResults(result)
+    } catch (e) {
+      const err = fromError(e as Error)
+      this.notifyError(new Error(`Unable to load files list. ${err.message}`))
+      this.state = ModelState.idle
+    }
+    this.dispatchEvent(new Event('querycomplete'))
+  }
+
+  #processFileResults(result: ContextListResult<IFile>): void {
+    const { items, cursor } = result
+    if (cursor) {
+      this.cursor = cursor
+    }
+    if (!items.length) {
+      this.state = ModelState.ended
+      return
+    }
+    if (!this.value.value.length) {
+      // we only sort the first page as later the user scrolls and sorting would change the order.
+      items.sort(filesSortFunction)
+    }
+    this.value.set(this.value.value.concat(items))
+    this.state = ModelState.idle
+  }
+
+  async listFiles(): Promise<ContextListResult<IFile>> {
+    const operation = async (): Promise<ContextListResult<IFile>> => {
+      const opts = this.getPageQueryOptions()
+      if (this.source === 'shared' && !this.parent) {
+        return this.sdk.shared.list(this.oid, opts)
+      }
+      return this.sdk.file.list(this.oid, opts)
+    }
+    const retryOptions: RetryOptions = {
+      retries: this.retryCount,
+      delayMs: exponentialBackoffDelay,
+      shouldRetry: shouldRetryApiError,
+    }
+    return retry(operation, retryOptions)
+  }
+
+  getPageQueryOptions(): ContextListOptions {
+    const { cursor: filesCursor, parent, limit, kinds } = this
+    const opts: ContextListOptions = {
+      // descending: true,
+    }
+    if (filesCursor) {
+      opts.cursor = filesCursor
+    }
+    if (parent) {
+      opts.parent = parent
+    }
+    if (typeof limit === 'number' && limit) {
+      opts.limit = limit
+    }
+    if (Array.isArray(kinds) && kinds.length) {
+      opts.filter = {
+        op: 'OR',
+        filters: kinds.map((kind) => ({
+          field: 'kind',
+          operator: 'eq',
+          value: kind,
+        })),
+      }
+    }
+    return opts
+  }
+
+  async deleteFiles(keys: string[]): Promise<void> {
+    if (!keys.length) {
+      return
+    }
+    const operation = async (): Promise<void> => {
+      await this.sdk.file.deleteBulk(this.oid, keys)
+    }
+    const retryOptions: RetryOptions = {
+      delayMs: exponentialBackoffDelay,
+      shouldRetry: shouldRetryApiError,
+      retries: this.retryCount,
+    }
+    try {
+      await retry(operation, retryOptions)
+      this.removeFiles(keys)
+    } catch (e) {
+      const err = fromError(e as Error)
+      this.notifyError(err)
+    }
+  }
+}

package/src/data/InvitationModel.ts

@@ -0,0 +1,69 @@
+import { Model } from '../core/Model.js'
+import { exponentialBackoffDelay, type RetryOptions, shouldRetryApiError, retry } from './retry_logic.js'
+import type SdkService from '../services/SdkService.js'
+import type { InvitationSchema } from '@api-client/core/models/store/Invitation.js'
+
+export default class InvitationModel extends Model<InvitationSchema> {
+  /**
+   * A reference to the SDK service used to perform API calls.
+   */
+  sdk: SdkService
+  /**
+   * Whether the model is currently loading data.
+   */
+  loading = false
+
+  constructor(sdk: SdkService) {
+    super()
+    this.sdk = sdk
+  }
+
+  /**
+   * Fetches the invitation data for the given token.
+   * @param token The invitation token to fetch.
+   * @returns The invitation data.
+   * @throws Error if the invitation cannot be fetched (e.g., network error or invalid token).
+   */
+  async fetch(token: string): Promise<InvitationSchema> {
+    this.loading = true
+    const operation = async (): Promise<InvitationSchema> => {
+      return this.sdk.organizations.invitations.findByToken(token)
+    }
+    const retryOptions: RetryOptions = {
+      retries: this.retryCount,
+      delayMs: exponentialBackoffDelay,
+      shouldRetry: shouldRetryApiError,
+    }
+    try {
+      this.raw = await retry(operation, retryOptions)
+    } finally {
+      this.loading = false
+    }
+    return this.raw
+  }
+
+  /**
+   * Rejects the invitation.
+   * @throws Error if the invitation cannot be rejected (e.g., network error).
+   */
+  async reject(): Promise<void> {
+    const { value } = this
+    if (!value) {
+      throw new Error('Cannot reject invitation without fetching it first.')
+    }
+    this.loading = true
+    const operation = async (): Promise<InvitationSchema> => {
+      return this.sdk.organizations.invitations.decline(value.oid, value.token)
+    }
+    const retryOptions: RetryOptions = {
+      retries: this.retryCount,
+      delayMs: exponentialBackoffDelay,
+      shouldRetry: shouldRetryApiError,
+    }
+    try {
+      this.raw = await retry(operation, retryOptions)
+    } finally {
+      this.loading = false
+    }
+  }
+}