@or-sdk/idw 8.2.2 → 8.3.0-beta.4080.0

package/src/api/domainApi.ts

@@ -1,133 +0,0 @@
-import { AxiosError, BaseError, parseAxiosErrorMessage } from '@or-sdk/base';
-
-import {
-  Domain,
-  ListDomains,
-  DomainUpdateData,
-  DomainCreateData,
-  DomainWithEntities, IDWBaseConfig,
-} from '../types';
-
-import { BaseApi } from './BaseApi';
-import { DomainError, DomainNotFoundError } from './errors';
-
-export class DomainApi extends BaseApi {
-  constructor(config: IDWBaseConfig) {
-    super(config);
-  }
-
-  /**
-   * @description Get specific domain
-   * @param slug
-   */
-  public async getDomain(slug: string): Promise<DomainWithEntities> {
-    try {
-      return this.providers.makeRequest<DomainWithEntities>({
-        route: this.buildRoute('domain'),
-        params: {
-          id: slug,
-        },
-      });
-    } catch (error) {
-      throw this._parseError(error, { notFoundMessage: `No domains with slug: '${slug}'` });
-    }
-  }
-
-  /**
-   * @description Get all domains
-   */
-  public async getAllDomains(): Promise<ListDomains> {
-    return await this.providers.makeRequest<ListDomains>({
-      route: this.buildRoute('domains'),
-    });
-  }
-
-  /**
-   * @description Delete specific domain
-   * @param slug
-   */
-  public async deleteDomain(slug: string): Promise<void> {
-    try {
-      return await this.providers.makeRequest({
-        route: this.buildRoute('domain'),
-        method: 'DELETE',
-        params: {
-          id: slug,
-        },
-      });
-    } catch (error) {
-      throw this._parseError(error, { notFoundMessage: `No domains with slug: '${slug}'` });
-    }
-  }
-
-  /**
-   * @description Delete all domains
-   */
-  public async deleteAllDomains(): Promise<void> {
-    return await this.providers.makeRequest({
-      route: this.buildRoute('domains'),
-      method: 'DELETE',
-    });
-  }
-
-  /**
-   * @description Patch specific domain's name and/or abbreviation
-   * @param slug
-   * @param data
-   */
-  public async patchDomain(slug: string, data: DomainUpdateData): Promise<Domain> {
-    try {
-      return await this.providers.makeRequest<Domain>({
-        route: this.buildRoute('domain'),
-        method: 'PATCH',
-        data,
-        params: {
-          id: slug,
-        },
-      });
-    } catch (error) {
-      throw this._parseError(error, { notFoundMessage: `No domains with slug: '${slug}'` });
-    }
-  }
-
-  /**
-   * @description Update specific domain
-   * @param slug
-   * @param data
-   * @deprecated use `patchDomain` instead
-   */
-  public async updateDomain(slug: string, data: DomainUpdateData): Promise<Domain> {
-    return this.patchDomain(slug, data);
-  }
-
-  /**
-   * @description create domain
-   * @param data
-   */
-  public async createDomain(data: DomainCreateData): Promise<Domain> {
-    return await this.providers.makeRequest<Domain>({
-      route: this.buildRoute('domain'),
-      method: 'POST',
-      data,
-    });
-  }
-
-  private _parseError(
-    error: Error | unknown,
-    { notFoundMessage = 'Domain not found' } = {},
-  ): DomainError | DomainNotFoundError | Error {
-    if (!(error instanceof Error)) throw error;
-
-    if (error instanceof AxiosError && error.response?.status === 404) {
-      return new DomainNotFoundError(notFoundMessage, { cause: error });
-    }
-    if (error instanceof BaseError && error.cause instanceof AxiosError && error.cause.response?.status === 404) {
-      return new DomainNotFoundError(notFoundMessage, { cause: error.cause });
-    }
-    if (error instanceof AxiosError) {
-      return new DomainError(parseAxiosErrorMessage(error), { cause: error });
-    }
-
-    return error;
-  }
-}

package/src/api/domainRelationshipApi.ts

@@ -1,170 +0,0 @@
-import {
-  Channel,
-  Skill,
-  Memory,
-  DomainWithObjects,
-  ListSkills,
-  ListChannels,
-  IDWBaseConfig,
-} from '../types';
-
-import { BaseApi } from './BaseApi';
-
-export class DomainRelationshipApi extends BaseApi {
-  constructor(config: IDWBaseConfig) {
-    super(config);
-  }
-
-  /**
-   * @description Get domain's channel list
-   * @param slug Domain's slug
-   */
-  getDomainChannelList(slug: string): Promise<ListChannels> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/channels'),
-      method: 'GET',
-      params: {
-        id: slug,
-      },
-    });
-  }
-
-  /**
-   * @description Get domain's skill list
-   * @param slug Domain's slug
-   */
-  getDomainSkillList(slug: string): Promise<ListSkills> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/skills'),
-      method: 'GET',
-      params: {
-        id: slug,
-      },
-    });
-  }
-
-  /**
-   * @description Get domain's memory list
-   * @param slug Domain's slug
-   */
-  getDomainMemoryList(slug: string): Promise<Memory[]> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/memories'),
-      method: 'GET',
-      params: {
-        id: slug,
-      },
-    });
-  }
-
-  /**
-   * @description Create relationship from domain to the entity
-   * @param slug The domain's slug
-   * @param data The object containing the ids - list of channels IDs separated with comma
-   */
-  attachChannels(
-    slug: string,
-    data: { ids: Array<Skill['slug'] | Skill['uid']>; },
-  ): Promise<DomainWithObjects<Channel>> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/channels'),
-      method: 'POST',
-      data,
-      params: {
-        id: slug,
-      },
-    });
-  }
-
-  /**
-   * @description Create relationship from domain to the entity
-   * @param slug The domain's slug
-   * @param data The object containing the ids - list of skills IDs separated with comma
-   */
-  attachSkills(slug: string, data: { ids: Array<Skill['slug'] | Skill['uid']>; }): Promise<DomainWithObjects<Skill>> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/skills'),
-      method: 'POST',
-      data,
-      params: {
-        id: slug,
-      },
-    });
-  }
-
-  /**
-   * @description Create relationship from domain to the entity
-   * @param slug The domain's slug
-   * @param data The object containing the ids - list of memories IDs separated with comma
-   */
-  attachMemories(
-    slug: string,
-    data: { ids: Array<Skill['slug'] | Skill['uid']>; },
-  ): Promise<DomainWithObjects<Memory>> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/memories'),
-      method: 'POST',
-      data,
-      params: {
-        id: slug,
-      },
-    });
-  }
-
-  /**
-   * @description Remove relationship from domain to the entity
-   * @param slug The domain's slug
-   * @param data The object containing the ids - list of channels IDs separated with comma
-   */
-  detachChannels(
-    slug: string,
-    data: { ids: Array<Skill['slug'] | Skill['uid']>; },
-  ): Promise<DomainWithObjects<Channel>> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/channels'),
-      method: 'DELETE',
-      data,
-      params: {
-        id: slug,
-      },
-    });
-  }
-
-  /**
-   * @description Remove relationship from domain to the entity
-   * @param slug The domain's slug
-   * @param data The object containing the ids - list of skills IDs separated with comma
-   */
-  detachSkills(
-    slug: string,
-    data: { ids: Array<Skill['slug'] | Skill['uid']>; },
-  ): Promise<DomainWithObjects<Skill>> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/skills'),
-      method: 'DELETE',
-      data,
-      params: {
-        id: slug,
-      },
-    });
-  }
-
-  /**
-   * @description Remove relationship from domain to the entity
-   * @param slug The domain's slug
-   * @param data The object containing the ids - list of memories IDs separated with comma
-   */
-  detachMemories(
-    slug: string,
-    data: { ids: Array<Skill['slug'] | Skill['uid']>; },
-  ): Promise<DomainWithObjects<Memory>> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('domain/memories'),
-      method: 'DELETE',
-      data,
-      params: {
-        id: slug,
-      },
-    });
-  }
-}

package/src/api/errors.ts

@@ -1,7 +0,0 @@
-import { BaseError } from '@or-sdk/base';
-
-export class DomainError extends BaseError {}
-export class DomainNotFoundError extends DomainError {}
-
-export class SkillError extends BaseError {}
-export class SkillNotFoundError extends SkillError {}

package/src/api/flowApi.ts

@@ -1,44 +0,0 @@
-import { Flow, FlowWithRelatedEntities, IDWBaseConfig } from '../types';
-
-import { BaseApi } from './BaseApi';
-
-export class FlowApi extends BaseApi {
-  constructor(config: IDWBaseConfig) {
-    super(config);
-  }
-
-  /**
-   * @description Get specific flow
-   * @param id
-   */
-  getFlow(id: string): Promise<Flow>;
-  /**
-   * @description Get specific flow
-   * @param id
-   * @param withRelatedEntities
-   */
-  getFlow<T extends boolean | undefined>(
-    id: string,
-    withRelatedEntities?: T
-  ): T extends true ? Promise<FlowWithRelatedEntities> : Promise<Flow>;
-  //function overload, bc depend on parameter withRelatedEntities response will be different
-  getFlow(id: string, withRelatedEntities?: boolean): Promise<FlowWithRelatedEntities | Flow> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('flow'),
-      params: {
-        id,
-        withRelatedEntities,
-      },
-    });
-  }
-
-  /**
-   * @description Get all flows
-   */
-  getFlows(): Promise<Flow[]> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('flows'),
-      method: 'GET',
-    });
-  }
-}

package/src/api/idwDbApi.ts

@@ -1,29 +0,0 @@
-import { IDWBaseConfig } from '../types';
-
-import { BaseApi } from './BaseApi';
-
-export class IdwDbApi extends BaseApi {
-  constructor(config: IDWBaseConfig) {
-    super(config);
-  }
-
-  /**
-   * Check if db exist
-   */
-  isDbExist(): Promise<boolean> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('db'),
-      method: 'GET',
-    });
-  }
-
-  /**
-   *  Check if db exist. If not, create db and run all pending migrations
-   */
-  prepareDb(): Promise<void> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('db'),
-      method: 'POST',
-    });
-  }
-}

package/src/api/idwInfoApi.ts

@@ -1,63 +0,0 @@
-import { IDWBaseConfig, IdwBaseInfo, IdwInfoWithStatistic, UpdateIdwBaseInfo } from '../types';
-
-import { BaseApi } from './BaseApi';
-
-export class IdwInfoApi extends BaseApi {
-  constructor(config: IDWBaseConfig) {
-    super(config);
-  }
-
-  /**
-   * Get IDW base Info
-   */
-  getBaseInfo(): Promise<IdwBaseInfo> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-info'),
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Get extended IDW info with statistic
-   */
-  getIdwInfoWithStatistic(): Promise<IdwInfoWithStatistic> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-info/statistic'),
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Update IDW base info
-   */
-  updateIdwInfo(data: UpdateIdwBaseInfo): Promise<void> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-info'),
-      method: 'PATCH',
-      data,
-    });
-  }
-
-  /**
-   *  Check if IDW name can be taken
-   */
-  idwNameCanBeTaken(name: string): Promise<true | never> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-info/name-can-be-taken'),
-      method: 'get',
-      params: {
-        name,
-      },
-    });
-  }
-
-  /**
-   *  Check if IDW name can be taken
-   */
-  isIdwAccount(): Promise<boolean> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-info/is-idw-account'),
-      method: 'get',
-    });
-  }
-}

package/src/api/idwRwcApi.ts

@@ -1,98 +0,0 @@
-import { ChatCheckResponse, IDWBaseConfig, IdwRwcData, UpsertIdwRwcData } from '../types';
-
-import { BaseApi } from './BaseApi';
-
-const noop: (...args: []) => void = () => {};
-
-export class IdwRwcApi extends BaseApi {
-  constructor(config: IDWBaseConfig) {
-    super(config);
-  }
-
-  /**
-   * Get IDW RWC data
-   */
-  getIdwRwcData(): Promise<IdwRwcData | undefined> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-rwc'),
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Set IDW RWC data
-   */
-  upsertIdwRwcData(data: UpsertIdwRwcData): Promise<IdwRwcData> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-rwc'),
-      method: 'POST',
-      data,
-    });
-  }
-
-  /**
-   * Remove IDW RWC data
-   */
-  deleteIdwRwcData(): Promise<void> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-rwc'),
-      method: 'DELETE',
-    });
-  }
-
-  /**
-   * Install Rwc chat
-   */
-  installRwcChat(): Promise<void> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-rwc/install'),
-      method: 'POST',
-    });
-  }
-
-  /**
-   * Get Rwc chat status
-   */
-  getChatStatus(): Promise<ChatCheckResponse> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('idw-rwc/install'),
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Subscribe on rwc chat installation process
-   * @param pollingInterval
-   * @param tikCallback
-   * @param errorCallback
-   */
-  getSubscriptionOnInstallationProcess(
-    pollingInterval: number,
-    tikCallback: (status: ChatCheckResponse) => void = noop,
-    errorCallback: (e: unknown) => void = noop
-  ) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const $this = this;
-    let intervalId: NodeJS.Timeout | undefined;
-
-    return {
-      subscribe: function () {
-        intervalId = setInterval(async () => {
-          try {
-            const status = await $this.getChatStatus();
-            tikCallback(status);
-          } catch (e) {
-            errorCallback(e);
-            this.unsubscribe();
-          }
-        }, pollingInterval);
-      },
-      unsubscribe: function () {
-        if (intervalId) {
-          clearInterval(intervalId);
-        }
-      },
-    };
-  }
-
-}

package/src/api/index.ts

@@ -1,11 +0,0 @@
-export * from './errors';
-export { SkillApi } from './skillApi';
-export { MemoryApi } from './memoryApi';
-export { ChannelApi } from './channelApi';
-export { DomainApi } from './domainApi';
-export { DomainRelationshipApi } from './domainRelationshipApi';
-export { MigrationApi } from './migrationApi';
-export { IdwInfoApi } from './idwInfoApi';
-export { IdwDbApi } from './idwDbApi';
-export { IdwRwcApi } from './idwRwcApi';
-export { FlowApi } from './flowApi';

package/src/api/memoryApi.ts

@@ -1,92 +0,0 @@
-import { IDWBaseConfig, ListMemories, Memory, MemoryCreateData, MemoryUpdateData } from '../types';
-
-import { BaseApi } from './BaseApi';
-
-export class MemoryApi extends BaseApi {
-  constructor(config: IDWBaseConfig) {
-    super(config);
-  }
-
-  /**
-   * @description Get specific memory by id
-   * @param id
-   */
-  getMemory(id: string): Promise<Memory> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('memory'),
-      params: {
-        id,
-      },
-    });
-  }
-
-  /**
-   * @description Get all memories
-   */
-  getAllMemories(): Promise<ListMemories> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('memories'),
-    });
-  }
-
-  /**
-   * @description Delete specific memory by id
-   * @param id
-   */
-  deleteMemory(id: string): Promise<void> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('memory'),
-      method: 'DELETE',
-      params: {
-        id,
-      },
-    });
-  }
-
-  /**
-   * @description Delete all memories
-   */
-  deleteAllMemories(): Promise<void> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('memories'),
-      method: 'DELETE',
-    });
-  }
-
-  /**
-   * @description update specific memory by id
-   * @param id
-   * @param data
-   */
-  updateMemory(id: string, data: MemoryUpdateData): Promise<Memory> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('memory'),
-      method: 'PATCH',
-      data,
-      params: {
-        id,
-      },
-    });
-  }
-
-  /**
-   * @description create memory
-   * @param data
-   */
-  createMemory(data: MemoryCreateData): Promise<Memory> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('memory'),
-      method: 'POST',
-      data,
-    });
-  }
-
-  /**
-   * @description Get all suggested (unlinked) memory
-   */
-  getSuggestedMemory(): Promise<ListMemories> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('memories/suggested'),
-    });
-  }
-}

package/src/api/migrationApi.ts

@@ -1,40 +0,0 @@
-import { IDWBaseConfig } from '../types';
-
-import { BaseApi } from './BaseApi';
-
-export class MigrationApi extends BaseApi {
-  constructor(config: IDWBaseConfig) {
-    super(config);
-  }
-
-  /**
-   * Check if there are any pending migrations.
-   * @return true if there are pending migrations
-   */
-  migrationsStatus(): Promise<boolean> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('migration'),
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Run pending migrations
-   */
-  migrationsRun(): Promise<void> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('migration'),
-      method: 'POST',
-    });
-  }
-
-  /**
-   * Revert latest migrations
-   */
-  revertLatest(): Promise<void> {
-    return this.providers.makeRequest({
-      route: this.buildRoute('migration'),
-      method: 'DELETE',
-    });
-  }
-}