@api-client/core 0.10.13 → 0.11.1

package/src/events/BaseEvents.ts

@@ -1,6 +1,5 @@
 import { JsonPatch } from '@api-client/json'
-import CustomEvent from './CustomEvent.js';
-import { AccessOperation } from '../models/store/Permission.js';
+import CustomEvent from './CustomEvent.js'
 
 /**
  * Base event detail definition for the events that returns a `result`
@@ -11,7 +10,7 @@ export interface ContextEventDetailWithResult<T> {
    * This property is set by the context provider, a promise resolved when the operation finish
    * with the corresponding result.
    */
-  result?: Promise<T> | undefined;
+  result?: Promise<T | undefined> | undefined
 }
 
 /**
@@ -30,8 +29,8 @@ export class ContextEvent<S extends object, R> extends CustomEvent<S & ContextEv
       detail: {
         result: undefined,
         ...detail,
-      }
-    });
+      },
+    })
   }
 }
 
@@ -39,11 +38,11 @@ export interface ContextReadEventDetail {
   /**
    * The key of the state object to read.
    */
-  key: string;
+  key: string
   /**
    * Optional parent, when needed.
    */
-  parent?: string;
+  parent?: string
 }
 
 /**
@@ -56,7 +55,7 @@ export class ContextReadEvent<T> extends ContextEvent<ContextReadEventDetail, T
    * @param parent Optional parent, when needed.
    */
   constructor(type: string, key: string, parent?: string) {
-    super(type, { key, parent });
+    super(type, { key, parent })
   }
 }
 
@@ -64,23 +63,26 @@ export interface ContextReadBulkEventDetail {
   /**
    * The list of keys to read.
    */
-  keys: string[];
+  keys: string[]
   /**
    * Optional parent, when needed.
    */
-  parent?: string;
+  parent?: string
 }
 
 /**
  * An event to be used to read a list of object from the API store.
  */
-export class ContextReadBulkEvent<T> extends ContextEvent<ContextReadBulkEventDetail, IBulkOperationResult<(T | null | undefined)>> {
+export class ContextReadBulkEvent<T> extends ContextEvent<
+  ContextReadBulkEventDetail,
+  IBulkOperationResult<T | null | undefined>
+> {
   /**
    * @param type The type of the event
    * @param keys The list of domain keys to read. These must be of the same domain type.
    */
   constructor(type: string, keys: string[], parent?: string) {
-    super(type, { keys, parent });
+    super(type, { keys, parent })
   }
 }
 
@@ -93,53 +95,53 @@ export interface ContextChangeRecord<T> {
    * The data kind of the changed item.
    * May not be present when this is used with the old architecture.
    */
-  kind?: string;
+  kind?: string
   /**
    * The key of the changed context state object.
    */
-  key: string;
+  key: string
   /**
    * The updated context state object.
    */
-  item?: T;
+  item?: T
   /**
    * Optionally, when relevant, the key of the parent of the changed object.
    */
-  parent?: string;
+  parent?: string
   /**
-   * The parent space.
+   * The parent organization.
    */
-  space?: string;
+  organization?: string
 }
 
 export interface ContextDeleteEventDetail {
   /**
    * The key of the domain object to remove.
    */
-  key: string;
+  key: string
   /**
    * The key of the parent object, if applicable.
    */
-  parent?: string;
+  parent?: string
   /**
-   * The parent space.
+   * The parent organization.
    */
-  space?: string;
+  organization?: string
 }
 
 export interface ContextDeleteBulkEventDetail {
   /**
    * The list of keys of the domain object to remove.
    */
-  keys: string[];
+  keys: string[]
   /**
    * The key of the parent object, if applicable.
    */
-  parent?: string;
+  parent?: string
   /**
-   * The parent space.
+   * The parent organization.
    */
-  space?: string;
+  organization?: string
 }
 
 /**
@@ -153,7 +155,7 @@ export class ContextDeleteEvent extends ContextEvent<ContextDeleteEventDetail, C
    * @param parent The key of the parent object, if applicable.
    */
   constructor(type: string, key: string, parent?: string) {
-    super(type, { key, parent });
+    super(type, { key, parent })
   }
 }
 
@@ -163,17 +165,20 @@ export class ContextDeleteEvent extends ContextEvent<ContextDeleteEventDetail, C
 export interface IBulkOperationResult<T> {
   /**
    * The ordered list of delete result for each item.
-   * 
+   *
    * The batch operation does not return specific errors. Use the direct delete operation
    * for the detailed error.
    */
-  items: (T | undefined | null)[];
+  items: (T | undefined | null)[]
 }
 
 /**
  * An event to be used to delete a number of entities in the context provider.
  */
-export class ContextDeleteBulkEvent extends ContextEvent<ContextDeleteBulkEventDetail, IBulkOperationResult<ContextDeleteRecord>> {
+export class ContextDeleteBulkEvent extends ContextEvent<
+  ContextDeleteBulkEventDetail,
+  IBulkOperationResult<ContextDeleteRecord>
+> {
   /**
    * An event to be used to delete a number of entities in the context provider.
    * @param type The type of the event to dispatch.
@@ -181,7 +186,7 @@ export class ContextDeleteBulkEvent extends ContextEvent<ContextDeleteBulkEventD
    * @param parent The key of the parent object, if applicable.
    */
   constructor(type: string, keys: string[], parent?: string) {
-    super(type, { keys, parent });
+    super(type, { keys, parent })
   }
 }
 
@@ -190,38 +195,41 @@ export interface ContextDeleteRecord {
    * The data kind of the deleted item.
    * May not be present when this is used with the old architecture.
    */
-  kind?: string;
+  kind?: string
   /**
    * The key of the removed object.
    */
-  key: string;
+  key: string
   /**
    * The key of the parent object, if applicable.
    */
-  parent?: string;
+  parent?: string
 }
 
 /**
  * An event dispatched to the context store to restore previously deleted items.
  */
-export class ContextRestoreEvent<T> extends ContextEvent<{ records: ContextDeleteRecord[] }, IBulkOperationResult<ContextChangeRecord<T>>> {
+export class ContextRestoreEvent<T> extends ContextEvent<
+  { records: ContextDeleteRecord[] },
+  IBulkOperationResult<ContextChangeRecord<T>>
+> {
   /**
    * An event dispatched to the context store to restore previously deleted items.
-   * 
+   *
    * The result of the event is the list of `ContextChangeRecord` for the restored items.
-   * 
+   *
    * @param type The type of the event.
    * @param records The records of previously deleted items.
    */
   constructor(type: string, records: ContextDeleteRecord[]) {
-    super(type, { records });
+    super(type, { records })
   }
 }
 
 /**
  * An event dispatched when a context store object has been deleted.
  * In general a single context store uses the same event to dispatch the change record.
- * For example the `data-store` dispatches the `x` event and the change record has the 
+ * For example the `data-store` dispatches the `x` event and the change record has the
  * `kind` property that is used to recognize the type of the data object.
  */
 export class ContextStateDeleteEvent extends CustomEvent<ContextDeleteRecord> {
@@ -235,7 +243,7 @@ export class ContextStateDeleteEvent extends CustomEvent<ContextDeleteRecord> {
       composed: true,
       cancelable: false,
       detail: record,
-    });
+    })
   }
 }
 
@@ -253,7 +261,7 @@ export class ContextStateUpdateEvent<T> extends CustomEvent<ContextChangeRecord<
       composed: true,
       cancelable: false,
       detail: record,
-    });
+    })
   }
 }
 
@@ -261,64 +269,70 @@ export interface ContextUpdateEventDetail<T> {
   /**
    * The context store object to be updated by the context provider.
    */
-  item: T;
+  item: T
   /**
    * The key of the parent object, if applicable.
    */
-  parent?: string;
+  parent?: string
 }
 
 export interface ContextUpdateBulkEventDetail<T = unknown> {
   /**
    * The list of context store objects to be updated by the context provider.
    */
-  items: T[];
+  items: T[]
   /**
    * The key of the parent object, if applicable.
    */
-  parent?: string;
+  parent?: string
 }
 
 /**
  * An event that is dispatched to update the entire object in the store.
  * This is equivalent to PUT operation in REST HTTP.
- * 
+ *
  * @template T The object that is being updated.
  * @template U The object that is returned by the context store after updating. By default it is the `T`.
  */
-export class ContextUpdateEvent<T extends object, U = T> extends ContextEvent<ContextUpdateEventDetail<T>, ContextChangeRecord<U>> {
-  /**
-   * An event that is dispatched to update the entire object in the store.
-   * This is equivalent to PUT operation in REST HTTP.
-   * 
-   * @param type The type of the event to dispatch
-   * @param updateInfo The update information.
-   */
-  constructor(type: string, updateInfo: ContextUpdateEventDetail<T>) {
-    super(type, updateInfo);
-  }
+export class ContextUpdateEvent<T extends object, U = T> extends ContextEvent<
+  ContextUpdateEventDetail<T>,
+  ContextChangeRecord<U>
+> {
+  // /**
+  //  * An event that is dispatched to update the entire object in the store.
+  //  * This is equivalent to PUT operation in REST HTTP.
+  //  *
+  //  * @param type The type of the event to dispatch
+  //  * @param updateInfo The update information.
+  //  */
+  // constructor(type: string, updateInfo: ContextUpdateEventDetail<T>) {
+  //   super(type, updateInfo)
+  // }
 }
 
 /**
  * An event that is dispatched to update a list of objects in the store.
  * This is equivalent to PUT operation in REST HTTP.
- * 
+ *
  * If there's a parent, this event only allows to update entities in bulk for the same parent.
- * 
+ *
  * @template T The object that is being updated.
  * @template U The object that is returned by the context store after updating. By default it is the `T`.
  */
-export class ContextUpdateBulkEvent<T extends object, U = T> extends ContextEvent<ContextUpdateBulkEventDetail<T>, IBulkOperationResult<ContextChangeRecord<U>>> {
-  /**
-   * An event that is dispatched to update the entire object in the store.
-   * This is equivalent to PUT operation in REST HTTP.
-   * 
-   * @param type The type of the event to dispatch
-   * @param updateInfo The update information.
-   */
-  constructor(type: string, updateInfo: ContextUpdateBulkEventDetail<T>) {
-    super(type, updateInfo);
-  }
+export class ContextUpdateBulkEvent<T extends object, U = T> extends ContextEvent<
+  ContextUpdateBulkEventDetail<T>,
+  IBulkOperationResult<ContextChangeRecord<U>>
+> {
+  // /**
+  //  * An event that is dispatched to update the entire object in the store.
+  //  * This is equivalent to PUT operation in REST HTTP.
+  //  *
+  //  * @param type The type of the event to dispatch
+  //  * @param updateInfo The update information.
+  //  */
+  // constructor(type: string, updateInfo: ContextUpdateBulkEventDetail<T>) {
+  //   super(type, updateInfo)
+  // }
 }
 
 /**
@@ -328,12 +342,12 @@ export interface ContextListResult<T> {
   /**
    * The cursor to use with the next query. It has the list state encoded in it.
    */
-  cursor?: string;
+  cursor?: string
   /**
    * The list of items in the response.
    * May be empty array when there was no more results.
    */
-  items: T[];
+  items: T[]
 }
 
 /**
@@ -343,49 +357,46 @@ export interface ContextListOptions {
   /**
    * The number of results per the page.
    */
-  limit?: number;
+  limit?: number
   /**
-   * Page cursor to use with the query. This is returned by the 
+   * Page cursor to use with the query. This is returned by the
    */
-  cursor?: string;
+  cursor?: string
   /**
    * Optional general purpose parent for the query.
    */
-  parent?: string;
+  parent?: string
   /**
    * Supported by some endpoints. When set it performs a query on the data store.
    */
-  query?: string;
+  query?: string
   /**
    * Only with the `query` property. Tells the system in which fields to search for the query term.
    */
-  queryField?: string[];
+  queryField?: string[]
   /**
    * Whether to use the `descending` order.
    */
-  descending?: boolean;
+  descending?: boolean
   /**
    * The name of the field to order then results.
    */
-  orderField?: string;
+  orderField?: string
   /**
    * General purpose type property to filer the results.
    * This is used, for example, by the history store to list history for a specific type of requests,
    */
-  type?: string;
+  type?: string
   /**
    * Used when synchronizing data in the local store with the data stored in the net-store.
-   * The timestamp when the last synchronization was performed. The resulting array will contain only items that 
+   * The timestamp when the last synchronization was performed. The resulting array will contain only items that
    * have been updated since that date.
    */
-  since?: number;
-}
-
-export interface ContextSpaceListOptions extends ContextListOptions {
+  since?: number
   /**
-   * The identifier of the parent space (or organization).
+   * The list of kinds to list. This is used when querying for files.
    */
-  space: string;
+  kinds?: unknown[]
 }
 
 export class ContextListEvent<T> extends ContextEvent<ContextListOptions, ContextListResult<T>> {
@@ -394,7 +405,7 @@ export class ContextListEvent<T> extends ContextEvent<ContextListOptions, Contex
    * @param opts Query options.
    */
   constructor(type: string, opts: ContextListOptions = {}) {
-    super(type, opts);
+    super(type, opts)
   }
 }
 
@@ -402,186 +413,183 @@ export interface IQueryDetail {
   /**
    * The query term. All values are always passed as string. Context store must parse value if it requires other types.
    */
-  term: string;
+  term: string
 
   /**
    * If the context store supports it, the tags to use with the query function to limit the results.
    */
-  tags?: string[];
+  tags?: string[]
 
   /**
    * General purpose type to be defined by the context store.
    * Allows to specify the type of the query to perform.
    */
-  type?: string;
+  type?: string
 
   /**
    * General purpose keyword to be defined by the context store.
    * The purpose is to instruct the context store to perform detailed search.
    * Usually this means longer search time but more accurate results.
    */
-  detailed?: boolean;
+  detailed?: boolean
 }
 
 export interface IQueryResponse<T = unknown> {
   /**
    * An ordered list of results.
    */
-  items: IQueryResult<T>[];
+  items: IQueryResult<T>[]
 }
 
 export interface IQueryResult<T = unknown> {
   /**
    * The document.
    */
-  doc: T;
+  doc: T
   /**
    * The list of indexes where this document was found.
    */
-  index: string[];
+  index: string[]
 }
 
 /**
  * An event dispatched to the context store to perform a query operation.
- * If the context store supports the query operation, it should use the definition of `IQueryDetail` to perform the query.
+ * If the context store supports the query operation, it should use the definition
+ * of `IQueryDetail` to perform the query.
  * The result is the list of objects ordered by the store from the most relevant items to the least.
- * 
- * The implementation should not assume pagination and return enough results for the user to find what they were looking for
+ *
+ * The implementation should not assume pagination and return enough results
+ * for the user to find what they were looking for
  * or to redefine the query. Suggested limit is `50` which in many cases is equivalent of 2 pages of results.
  */
 export class ContextQueryEvent<T = unknown> extends ContextEvent<IQueryDetail, IQueryResponse<T>> {
   /**
    * An event dispatched to the context store to perform a query operation.
-   * If the context store supports the query operation, it should use the definition of `IQueryDetail` to perform the query.
+   * If the context store supports the query operation, it should use the definition
+   * of `IQueryDetail` to perform the query.
    * The result is the list of objects ordered by the store from the most relevant items to the least.
-   * 
-   * The implementation should not assume pagination and return enough results for the user to find what they were looking for
+   *
+   * The implementation should not assume pagination and return enough results
+   * the user to find what they were looking for
    * or to redefine the query. Suggested limit is `50` which in many cases is equivalent of 2 pages of results.
-   * 
+   *
    * @param type The type of the event.
    * @param opts The query options.
    */
-  constructor(type: string, opts: IQueryDetail) {
-    super(type, opts);
-  }
+  // constructor(type: string, opts: IQueryDetail) {
+  //   super(type, opts)
+  // }
 }
 
 /**
  * Query options to list history for a request in a project.
- * The user has to have access to the parent user space to read / create / delete the history.
+ * The user has to have access to the parent user organization to read / create / delete the history.
  */
 export interface IHistoryRequestListOptions extends ContextListOptions {
-  type: 'request';
+  type: 'request'
   /**
-   * The key of the parent space.
+   * The key of the parent organization.
    */
-  space: string;
+  organization: string
   /**
    * The id of the project that contains the request.
    */
-  project: string;
+  project: string
   /**
    * The id of the request.
    */
-  id: string;
+  id: string
   /**
    * Whether to limit the list of results to the history that belongs to the current user.
    */
-  user?: boolean;
+  user?: boolean
 }
 
 /**
  * Listing options for the HTTP history.
  */
-export type HistoryListOptions = IHistoryRequestListOptions;
+export type HistoryListOptions = IHistoryRequestListOptions
 
 export interface IProjectExecutionListOptions extends ContextListOptions {
   /**
-   * The key of the parent space.
+   * The key of the parent organization.
    */
-  space: string;
+  organization: string
 
   /**
    * The id of the parent project
    */
-  project: string;
-  
+  project: string
+
   /**
    * The key of the application that made the records.
    * This is optional and will returns results for the project made in all apps.
    */
-  app?: string;
+  app?: string
 
   /**
    * The key of the parent folder, if any.
    * Note, when this is not provided the endpoint only returns list of logs
    * created for the project.
    */
-  parent?: string;
+  parent?: string
 
   /**
    * The user id that made that project run. Optional.
    */
-  user?: string;
+  user?: string
 }
 
-
+/**
+ * @deprecated Use `PatchInfo` instead
+ */
 export interface IPatchBase {
   /**
    * Auto generated by the client sending the PATCH.
    */
-  id: string;
+  id: string
   /**
    * The application id that generated the patch.
    * This is a string that is assigned to each application in the suite.
    * External applications need to use a constant string for their apps.
    */
-  app: string;
+  app: string
   /**
    * The version of the application that generated the patch.
    * This can and will be used to handle potential differences between suite applications.
    */
-  appVersion: string;
+  appVersion: string
   /**
    * The patch generated by the client.
    */
-  patch: unknown;
-}
-
-/**
- * An interface describing a schema to be sent to the server
- * when making a patch of a file.
- */
-export interface IPatchInfo extends IPatchBase {
+  patch: unknown
   /**
-   * The patch generated by the client.
+   * The current timestamp.
    */
-  patch: JsonPatch;
+  timestamp: number
 }
 
 /**
  * An interface describing a schema to be sent to the server
- * when making a patch with user access to a file.
+ * when making a patch of a file.
+ * @deprecated Use `MediaPatchInfo` instead
  */
-export interface IAccessPatchInfo {
-  /**
-   * Auto generated by the client sending the PATCH.
-   */
-  id: string;
+export interface IPatchInfo extends IPatchBase {
   /**
    * The patch generated by the client.
    */
-  patch: AccessOperation[];
+  patch: JsonPatch
 }
 
 /**
  * A schema sent by the store server in a response to the patch request.
  * It contains an information about the applied patch, the reverse operation associated with it,
  * application information, and the generated by the client patch id.
+ * @deprecated Use `MediaPatchRevision` instead
  */
 export interface IPatchRevision extends IPatchInfo {
   /**
    * The patch to apply to the object to revert the changes.
    */
-  revert: JsonPatch;
+  revert: JsonPatch
 }