@nomalism-com/api 0.33.82 → 0.34.1

package/src/modules/user/logout.ts

@@ -0,0 +1,20 @@
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async logout(): Promise<void> {
+    await this.api.post(`${this.route}`);
+  }
+}

package/src/modules/user/maturityDates.ts

@@ -0,0 +1,61 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.MaturityDates.Entity;
+
+export import ICreateRequest = Nomalism.MaturityDates.ICreateRequest;
+
+export import IUpdateRequest = Nomalism.MaturityDates.IUpdateRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export default class Repository implements Nomalism.MaturityDates.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/password.ts

@@ -0,0 +1,29 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IForgotPassword = Nomalism.Password.IForgotPassword;
+
+export import IResetPassword = Nomalism.Password.IResetPassword;
+
+export default class Repository implements Nomalism.Password.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async forgotPassword(body: IForgotPassword): Promise<void> {
+    await this.api.post(`${this.publicRoute}forgot`, body);
+  }
+
+  async resetPassword(body: IResetPassword): Promise<void> {
+    await this.api.post(`${this.publicRoute}reset`, body);
+  }
+}

package/src/modules/user/paymentMethods.ts

@@ -0,0 +1,61 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.PaymentMethods.Entity;
+
+export import ICreateRequest = Nomalism.PaymentMethods.ICreateRequest;
+
+export import IUpdateRequest = Nomalism.PaymentMethods.IUpdateRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export default class Repository implements Nomalism.PaymentMethods.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/permission.ts

@@ -0,0 +1,45 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import ICreateRequest = Nomalism.Permissions.ICreateRequest;
+export import IEntity = Nomalism.Permissions.Entity;
+
+export default class Repository implements Nomalism.Permissions.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(): Promise<Nomalism.Permissions.Entity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdNumberRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/persona.ts

@@ -0,0 +1,92 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntityExtended = Nomalism.Persona.IEntityExtended;
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+export import ICreateRequest = Nomalism.Persona.ICreateRequest;
+export import IUpdateRequest = Nomalism.Persona.IUpdateRequest;
+
+export import IBasicSearchRequest = Nomalism.Persona.IBasicSearchRequest;
+export import IBasicSearchResponse = Nomalism.Persona.IBasicSearchResponse;
+
+export import IFindByOwnerIdResponse = Nomalism.Persona.IFindByOwnerIdResponse;
+
+export import IFindRequest = Nomalism.Persona.IFindRequest;
+export import IFindResponse = Nomalism.Persona.IFindResponse;
+
+export default class Repository implements Nomalism.Persona.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntityExtended | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async findContactPersonaByOwnerId(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<Nomalism.Persona.IFindContactPersonaByOwnerId> {
+    const response = await this.api.get(`${this.route}contact`, { params });
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntityExtended> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntityExtended | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(params: Nomalism.Persona.IDeletePersonaRequest): Promise<IEntityExtended | null> {
+    const response = await this.api.delete(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findByBasic(
+    params: IBasicSearchRequest,
+  ): Promise<Nomalism.shared.IPaginationResponse<IBasicSearchResponse>> {
+    const response = await this.api.get(`${this.route}basic_search`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async find(data: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, {
+      data,
+    });
+    return response.data;
+  }
+
+  async findByEmail(
+    data: Nomalism.Persona.IFindByEmailRequest,
+  ): Promise<Nomalism.Persona.IFindByEmailResponse[]> {
+    const response = await this.api.get(`${this.route}by_email`, {
+      data,
+    });
+    return response.data;
+  }
+}

package/src/modules/user/provider.ts

@@ -0,0 +1,99 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindByQueryRequest = Nomalism.Providers.IFindByQueryRequest;
+
+export import IFindRequest = Nomalism.Providers.IFindRequest;
+export import IFindResponse = Nomalism.Providers.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.Providers.IFindPaginatedRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+export import IFindByOwnerIdResponse = Nomalism.Providers.IFindByOwnerIdResponse;
+
+export import IFindByIdResponse = Nomalism.Providers.IFindByIdResponse;
+
+export import ICreateRequest = Nomalism.Providers.ICreateRequest;
+
+export import IEntity = Nomalism.Providers.Entity;
+
+export import IUpdateRequest = Nomalism.Providers.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.Providers.IFindResponse>;
+
+export default class Repository implements Nomalism.Providers.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findByQuery(data: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.post(`${this.route}query`, data);
+    return response.data;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findMinifiedManufacturer(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified_manufacturer`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindByIdResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IFindResponse | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/providerType.ts

@@ -0,0 +1,72 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.ProviderType.IFindRequest;
+export import IFindResponse = Nomalism.ProviderType.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.ProviderType.IFindPaginatedRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import ICreateRequest = Nomalism.ProviderType.ICreateRequest;
+export import IEntity = Nomalism.ProviderType.Entity;
+
+export import IUpdateRequest = Nomalism.ProviderType.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.ProviderType.IFindResponse>;
+
+export default class Repository implements Nomalism.ProviderType.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/purchaseCondition.ts

@@ -0,0 +1,71 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.PurchaseConditions.Entity;
+
+export import IFindRequest = Nomalism.PurchaseConditions.IFindRequest;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+
+export import ICreateRequest = Nomalism.PurchaseConditions.ICreateRequest;
+
+export import IUpdateRequest = Nomalism.PurchaseConditions.IUpdateRequest;
+
+export import IFindPaginatedRequest = Nomalism.PurchaseConditions.IFindPaginatedRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.PurchaseConditions.Entity>;
+
+export default class Repository implements Nomalism.PurchaseConditions.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(params: IFindRequest): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/reasonForExemption.ts

@@ -0,0 +1,72 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.ReasonForExemption.IFindRequest;
+export import IFindResponse = Nomalism.ReasonForExemption.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.ReasonForExemption.IFindPaginatedRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import ICreateRequest = Nomalism.ReasonForExemption.ICreateRequest;
+export import IEntity = Nomalism.ReasonForExemption.Entity;
+
+export import IUpdateRequest = Nomalism.ReasonForExemption.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.ReasonForExemption.IFindResponse>;
+
+export default class Repository implements Nomalism.ReasonForExemption.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/refreshToken.ts

@@ -0,0 +1,25 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import ICreateRequest = Nomalism.RefreshToken.ICreateRequest;
+export import ICreateResponse = Nomalism.RefreshToken.ICreateResponse;
+
+export default class Repository implements Nomalism.RefreshToken.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(body: ICreateRequest): Promise<ICreateResponse> {
+    const response = await this.api.post(`${this.publicRoute}`, body);
+    return response.data;
+  }
+}