@tec.pet/tecpet-sdk 0.0.29

package/src/domain/combo/dto/pa.get-combo-pricing.dto.ts

@@ -0,0 +1,10 @@
+export interface PaComboPricingResponse {
+  id: number;
+  name: string;
+  price: number;
+  description: string;
+}
+
+export interface PaGetCombosPricingResponse {
+  data: PaComboPricingResponse[];
+}

package/src/domain/employee/dto/employee.dto.ts

@@ -0,0 +1,6 @@
+export interface Employee {
+    id: number;
+    name: string;
+    phone: string;
+    ddi: string;
+}

package/src/domain/pet/dto/pa.create-pet.dto.ts

@@ -0,0 +1,13 @@
+import {GenderType} from "./pa.get-pet.dto";
+import {BillingItemType} from "../../billingMethod/enum/billing-method-type.enum";
+
+export interface PaCreatePetInput {
+  clientId: number;
+  name: string;
+  specieId: string;
+  breedId: number;
+  genre: GenderType;
+  hair: BillingItemType;
+  size: BillingItemType;
+  birthDate?: Date;
+}

package/src/domain/pet/dto/pa.edit-pet.dto.ts

@@ -0,0 +1,15 @@
+import {SpecieType} from "../../specie/enum/specie-type.enum";
+import {GenderType} from "./pa.get-pet.dto";
+import {BillingItemType} from "../../billingMethod/enum/billing-method-type.enum";
+
+export class PaEditPetInput {
+  name?: string;
+  specieId?: string;
+  specie?: SpecieType;
+  breedId?: number;
+  genre?: GenderType;
+  hair?: BillingItemType;
+  size?: BillingItemType;
+  birthDate?: string;
+  weigth?: number;
+}

package/src/domain/pet/dto/pa.get-pet-activity.dto.ts

@@ -0,0 +1,5 @@
+export interface PaGetPetActivityResponse {
+  id: string;
+  name: string;
+  petId: number;
+}

package/src/domain/pet/dto/pa.get-pet.dto.ts

@@ -0,0 +1,22 @@
+import {BillingItemType} from "../../billingMethod";
+import {SpecieType, SpecieTypeEnum} from "../../specie/enum/specie-type.enum";
+
+export enum GenderType {
+  MALE = 'MALE',
+  FEMALE = 'FEMALE'
+}
+
+export interface PaPetResponse {
+  id: number;
+  name: string;
+  specieId: string;
+  specieType: SpecieTypeEnum;
+  specie: SpecieType;
+  specieName: string;
+  breedId: number;
+  breedName: string;
+  genre: GenderType;
+  hair: BillingItemType;
+  size: BillingItemType;
+  birthDate: string;
+}

package/src/domain/pet/dto/pa.get-pets.dto.ts

@@ -0,0 +1,8 @@
+import {IPaginationResponse} from "../../types/pagination.types";
+import {PaPetResponse} from "./pa.get-pet.dto";
+
+
+export interface PaGetPetsResponse {
+  data: PaPetResponse[];
+  pagination: IPaginationResponse;
+}

package/src/domain/pet/index.ts

@@ -0,0 +1 @@
+export * from './dto/pa.get-pet.dto';

package/src/domain/pet/pet.service.ts

@@ -0,0 +1,36 @@
+import {HttpClient} from "infra/http/client.http";
+import {PaPetResponse} from "./dto/pa.get-pet.dto";
+import {PaGetPetsResponse} from "./dto/pa.get-pets.dto";
+import {PaCreatePetInput} from "./dto/pa.create-pet.dto";
+import {PaEditPetInput} from "./dto/pa.edit-pet.dto";
+
+export class PetService {
+  constructor(private readonly api: HttpClient) {
+  }
+
+  async getByClient(clientId: number): Promise<Array<PaPetResponse> | null> {
+    const response = await this.api.get<PaGetPetsResponse>(`/pet`, {
+        clientId,
+      })
+    if (response?.data?.length) {
+      return response.data;
+    }
+    return [];
+  }
+
+  async create(petInput: PaCreatePetInput): Promise<PaPetResponse | null> {
+    const response = await this.api.post<PaPetResponse>(`/pet`, petInput)
+    if (response?.id) {
+      return response;
+    }
+    return null;
+  }
+
+  async edit(petId: number, body: PaEditPetInput): Promise<PaPetResponse | null> {
+    const response = await this.api.put<PaPetResponse>(`/pet/${petId}`, body)
+    if (response?.id) {
+      return response;
+    }
+    return null;
+  }
+}

package/src/domain/segment/enum/segment.enum.ts

@@ -0,0 +1,6 @@
+export enum ShopSegment {
+  PET_SHOP = 'PET_SHOP',
+  CLINIC = 'CLINIC',
+  DAY_CARE = 'DAY_CARE',
+  HOTEL = 'HOTEL',
+}

package/src/domain/service/dto/pa.get-service-pricing.dto.ts

@@ -0,0 +1,27 @@
+export enum ServiceCategoryType {
+  BATH = 'BATH',
+  GROOM = 'GROOM',
+  CLINIC = 'CLINIC',
+  DAY_CARE = 'DAY_CARE',
+  HOTEL = 'HOTEL',
+  ADDITIONAL = 'ADDITIONAL',
+  CUSTOM = 'CUSTOM',
+}
+
+export interface PaServicePricingResponse {
+  id: number;
+  name: string;
+  price: number;
+  description: string;
+}
+
+export interface PaGetServicePricingResponse {
+  id: number;
+  name: string;
+  type: ServiceCategoryType;
+  services: Array<PaServicePricingResponse>;
+}
+
+export interface PaGetServicesPricingResponse {
+  data: PaGetServicePricingResponse[];
+}

package/src/domain/service/service.service.ts

@@ -0,0 +1,20 @@
+import { HttpClient } from "infra/http/client.http";
+import { ShopSegment } from "../segment/enum/segment.enum";
+import { PaGetServicePricingResponse, PaGetServicesPricingResponse, ServiceCategoryType } from "./dto/pa.get-service-pricing.dto";
+
+export class ServiceService {
+  constructor(private readonly api: HttpClient) {
+  }
+
+  async pricing(petId: number, segment: ShopSegment,serviceCategoryTypes:ServiceCategoryType[], shopId: number): Promise<Array<PaGetServicePricingResponse> | null> {
+    const response = await this.api.get<PaGetServicesPricingResponse>(`/service/pricing`, {
+      petId,
+      segment,
+      serviceCategoryTypes,
+    }, shopId)
+    if (response && response.data?.length) {
+      return response.data;
+    }
+    return [];
+  }
+}

package/src/domain/shop/dto/pa.get-shop-configurations.dto.ts

@@ -0,0 +1,92 @@
+import {ShopSegment} from "../../segment/enum/segment.enum";
+import {AddressDto} from "../../client";
+import {SpecieTypeEnum} from "../../specie/enum/specie-type.enum";
+import {PaBillingResponse} from "../../billingMethod/dto/pa.get-billing-methods.dto";
+
+interface AdvancedConfigSegment {
+  id: number;
+  segmentType: ShopSegment
+}
+
+export interface PaShopConfigurationsSpecie {
+  id: string;
+  type: SpecieTypeEnum;
+  name: string;
+}
+
+export interface PaShopConfigurationsSegment {
+  id: number;
+  type: ShopSegment;
+  name: string;
+}
+
+export interface AdvancedConfigResponseDto {
+  extraAuth: boolean;
+  extraAuthPassword: string;
+  segments: AdvancedConfigSegment[];
+  global: {
+    allowSearchByCPF: boolean;
+    defaultToSearchByCPF: boolean;
+    defaultToSearchByPhone: boolean;
+    multipleChatDepartments: boolean;
+    replaceCatWithOtherSpecies: boolean;
+    bypassEmployeeCode: boolean;
+    serviceByBreed: boolean;
+    requestEmployeeOnClientAccess: boolean;
+  };
+  serviceArea: {
+    hideReception: boolean;
+  };
+  employee: {
+    mandatoryCPF: boolean;
+  };
+  client: {
+    mandatoryAddress: boolean;
+    mandatoryCPF: boolean;
+    hideRemove: boolean;
+  };
+  booking: {
+    replaceComboWithPromotion: boolean;
+    filterServicesByBreed: boolean;
+    canSchedule: boolean;
+    canCancelIfPaid: boolean;
+    canDeliverIfUnpaid: boolean;
+    canCancelIfStarted: boolean;
+    canEditIfDelivered: boolean;
+    canRevertIfStarted: boolean;
+  };
+  finance: {
+    mandatoryCardInputs: boolean;
+    enableCouponInputs: boolean;
+    enableConvertPaymentToVoucher: boolean;
+  };
+  dashboard: {
+    enableEmployeesCommissions: boolean;
+    enableCommissionProjection: boolean;
+  };
+  paymentGateway: {
+    enabled: boolean;
+  };
+  invoice: {
+    allowManualItemAddition: boolean;
+  };
+  notification: {
+    triggerSchedule: boolean;
+  };
+  petCare: {
+    enabled: boolean;
+  };
+  animalMating: {
+    enabled: boolean;
+  };
+}
+
+export interface PaShopConfigurationsResponse {
+  id: number;
+  name: string;
+  advancedConfig: AdvancedConfigResponseDto;
+  address: AddressDto;
+  segments: Array<PaShopConfigurationsSegment>;
+  species: Array<PaShopConfigurationsSpecie>;
+  billing: PaBillingResponse[];
+}

package/src/domain/shop/index.ts

@@ -0,0 +1 @@
+export * from '../shop/dto/pa.get-shop-configurations.dto';

package/src/domain/shop/shop.service.ts

@@ -0,0 +1,15 @@
+import {HttpClient} from "infra/http/client.http";
+import {PaShopConfigurationsResponse} from "./dto/pa.get-shop-configurations.dto";
+
+export class ShopService {
+  constructor(private readonly api: HttpClient) {
+  }
+
+  async getConfigurations(shopId: number): Promise<PaShopConfigurationsResponse | null> {
+    const response = await this.api.get<PaShopConfigurationsResponse>(`/shop/configurations`, {}, shopId)
+    if (response?.id) {
+      return response;
+    }
+    return null;
+  }
+}

package/src/domain/specie/dto/pa.get-specie.dto.ts

@@ -0,0 +1,7 @@
+import {SpecieTypeEnum} from '../enum/specie-type.enum';
+
+export interface PaSpecieResponse {
+  id: string;
+  name: string;
+  specieType: SpecieTypeEnum;
+}

package/src/domain/specie/dto/pa.get-species.dto.ts

@@ -0,0 +1,7 @@
+import {PaSpecieResponse} from "./pa.get-specie.dto";
+import {IPaginationResponse} from "../../types/pagination.types";
+
+export interface PaGetSpeciesResponse {
+  data: PaSpecieResponse[];
+  pagination: IPaginationResponse;
+}

package/src/domain/specie/enum/specie-type.enum.ts

@@ -0,0 +1,21 @@
+export enum SpecieTypeEnum {
+  CANINE = 'CANINE',
+  FELINE = 'FELINE',
+  RODENT = 'RODENT',
+  FISH = 'FISH',
+  BIRD = 'BIRD',
+  EQUINE = 'EQUINE',
+  REPTILE = 'REPTILE',
+  BOVINE = 'BOVINE',
+  PRIMATE = 'PRIMATE',
+  LEPORID = 'LEPORID',
+  SWINE = 'SWINE',
+  INSECT = 'INSECT',
+  ARCHNIDE = 'ARCHNIDE',
+  AMPHIBIAN = 'AMPHIBIAN',
+}
+
+export enum SpecieType {
+  DOG = 'DOG',
+  CAT = 'CAT',
+}

package/src/domain/specie/index.ts

@@ -0,0 +1,2 @@
+// export * from './enum/chatbot-platform-type.enum';
+// export * from './dto/chatbot-settings.json';

package/src/domain/specie/specie.service.ts

@@ -0,0 +1,18 @@
+import {HttpClient} from "infra/http/client.http";
+import {logger} from "../../infra/logger/stdout.logger";
+import {PaGetSpeciesResponse} from "./dto/pa.get-species.dto";
+import {PaSpecieResponse} from "./dto/pa.get-specie.dto";
+
+export class SpecieService {
+  constructor(private readonly api: HttpClient) {
+  }
+
+  async list(shopId: number): Promise<Array<PaSpecieResponse> | null> {
+    const response = await this.api.get<PaGetSpeciesResponse>(`/specie`, {}, shopId)
+    if (response && response.data?.length) {
+      logger.debug(SpecieService.name, JSON.stringify(response, null, 2));
+      return response.data;
+    }
+    return [];
+  }
+}

package/src/domain/token/dto/pa.extract-token.dto.ts

@@ -0,0 +1,4 @@
+export interface PaExtractTokenResponse {
+  user: string;
+  shop: { id: number; name: string; }
+}

package/src/domain/token/index.ts

@@ -0,0 +1 @@
+export * from '../token/dto/pa.extract-token.dto';

package/src/domain/token/token.service.ts

@@ -0,0 +1,15 @@
+import {HttpClient} from "infra/http/client.http";
+import {PaExtractTokenResponse} from "./dto/pa.extract-token.dto";
+
+export class TokenService {
+  constructor(private readonly api: HttpClient) {
+  }
+
+  async extract(token: string): Promise<PaExtractTokenResponse | null> {
+    const response = await this.api.get<PaExtractTokenResponse>(`/token/${token}`)
+    if (response?.user && response?.shop) {
+      return response;
+    }
+    return null;
+  }
+}

package/src/domain/types/pagination.types.ts

@@ -0,0 +1,10 @@
+export interface IPaginationResponse {
+  page: number;
+  count: number;
+  hasMore: boolean;
+  limit: number;
+}
+export interface IPaginationGeneric {
+  page?: number;
+  limit?: number;
+}

package/src/index.ts

@@ -0,0 +1,52 @@
+import {ClientService} from "./domain/client/client.service";
+import {HttpClient} from "./infra/http/client.http";
+import {ChatbotService} from "./domain/chatbot/chatbotService";
+import {PetService} from "./domain/pet/pet.service";
+import {BreedService} from "./domain/breed/breed.service";
+import {SpecieService} from "./domain/specie/specie.service";
+import {BillingMethodService} from "./domain/billingMethod/billingMethod.service";
+import {ShopService} from "./domain/shop/shop.service";
+import {ComboService} from "./domain/combo/combo.service";
+import {ServiceService} from "./domain/service/service.service";
+import {AvailableTimesService} from "./domain/availableTimes/availableTimes.service";
+import {BookingService} from "./domain/booking/booking.service";
+import {TokenService} from "./domain/token/token.service";
+
+export class TecpetSDK {
+  private api: HttpClient;
+  public client: ClientService;
+  public pet: PetService;
+  public breed: BreedService;
+  public chatbot: ChatbotService;
+  public specie: SpecieService;
+  public billingMethod: BillingMethodService;
+  public shop: ShopService;
+  public combo: ComboService;
+  public service: ServiceService;
+  public availableTimes: AvailableTimesService;
+  public booking: BookingService;
+  public token: TokenService;
+
+  constructor(baseURL: string, apiKey?: string) {
+    this.api = new HttpClient(baseURL, apiKey);
+    this.client = new ClientService(this.api);
+    this.pet = new PetService(this.api);
+    this.breed = new BreedService(this.api);
+    this.chatbot = new ChatbotService(this.api);
+    this.specie = new SpecieService(this.api);
+    this.billingMethod = new BillingMethodService(this.api);
+    this.shop = new ShopService(this.api);
+    this.combo = new ComboService(this.api);
+    this.service = new ServiceService(this.api);
+    this.availableTimes = new AvailableTimesService(this.api);
+    this.booking = new BookingService(this.api);
+    this.token = new TokenService(this.api);
+  }
+}
+
+export * from './domain/chatbot';
+export * from './domain/booking';
+export * from './domain/shop';
+export * from './domain/client';
+export * from './domain/billingMethod';
+export * from './domain/pet';

package/src/infra/http/client.http.ts

@@ -0,0 +1,91 @@
+import axios, { AxiosHeaders, AxiosInstance, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import { logger } from "../logger/stdout.logger";
+
+export class HttpClient {
+    private readonly client: AxiosInstance;
+
+    constructor(
+        private readonly apiUrl: string,
+        private readonly apiKey?: string
+    ) {
+        this.client = axios.create({
+            baseURL: apiUrl,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.apiKey && {Authorization: `Bearer ${this.apiKey}`})
+            }
+        });
+
+        this.client.interceptors.request.use((config: InternalAxiosRequestConfig) => {
+            logger.debug('tecpet-sdk', `[HTTP] ${this.shop(config.headers)} → ${config.method?.toUpperCase()} [HTTP] → ${config.baseURL}${config.url}`, config?.params || '', config?.data || '');
+            return config;
+        });
+
+        this.client.interceptors.response.use(
+            (response: AxiosResponse) => {
+                logger.debug('tecpet-sdk', `[HTTP] ${this.shop(response.config.headers)} ← ${response.status} ${response.config.url}`, response?.data);
+                return response;
+            },
+            (error) => {
+                logger.error('tecpet-sdk', `[HTTP] ${this.shop(error)} ← Error: ${error.message}`);
+                if (error.response) {
+                    logger.error('tecpet-sdk', `[HTTP] ${this.shop(error)} ← Response:`, error?.response?.data);
+                }
+                return Promise.reject(error);
+            }
+        );
+    }
+
+    async get<T>(path: string, payload?: any, shopId?: number): Promise<T> {
+        try {
+            const response = await this.client.get<T>(
+                path,
+                {params: payload, headers: this.headers({shopId})},
+            );
+            return response?.data as T;
+        } catch (error: any) {
+            throw error.response.data;
+        }
+    }
+
+    async post<T>(path: string, payload?: any, shopId?: number): Promise<T> {
+        try {
+            const response = await this.client.post<T>(
+                path,
+                payload,
+                {headers: this.headers({shopId})},
+            );
+            return response?.data as T;
+        } catch (error: any) {
+            throw error.response.data;
+        }
+    }
+
+    async put<T>(path: string, payload?: any, shopId?: number): Promise<T> {
+        try {
+            const response = await this.client.put<T>(
+                path,
+                payload,
+                {headers: this.headers({shopId})},
+            );
+            return response?.data as T;
+        } catch (error: any) {
+            throw error.response.data;
+        }
+    }
+
+    private headers({shopId}: { shopId?: number }) {
+        if (shopId) {
+            return {
+                ...this.client.defaults.headers.common,
+                'x-shop': shopId
+            }
+        }
+        return this.client.defaults.headers.common;
+    }
+
+    private shop(headers: AxiosHeaders): string {
+        const shop = headers?.['x-shop']?.toString();
+        return shop ? `shop=${shop}` : '';
+    }
+}

package/src/infra/logger/logger.interface.ts

@@ -0,0 +1,7 @@
+export interface ILogger {
+  debug(tag: string, message: string, ...meta: any[]): void;
+  info(tag: string, message: string, ...meta: any[]): void;
+  warn(tag: string, message: string, ...meta: any[]): void;
+  error(tag: string, message: string, ...meta: any[]): void;
+  fatal(tag: string, message: string, ...meta: any[]): void;
+}

package/src/infra/logger/stdout.logger.ts

@@ -0,0 +1,85 @@
+import { format } from 'date-fns';
+import chalk from 'chalk';
+import {ILogger} from "./logger.interface";
+
+export class StdoutLogger implements ILogger {
+  constructor(private readonly color: boolean = true) {}
+
+  debug(tag: string, message: string, ...meta: any[]): void {
+    this.log('debug', tag, message, meta);
+  }
+
+  info(tag: string, message: string, ...meta: any[]): void {
+    this.log('info', tag, message, meta);
+  }
+
+  warn(tag: string, message: string, ...meta: any[]): void {
+    this.log('warn', tag, message, meta);
+  }
+
+  error(tag: string, message: string, ...meta: any[]): void {
+    this.log('error', tag, message, meta);
+  }
+
+  fatal(tag: string, message: string, ...meta: any[]): void {
+    this.log('fatal', tag, message, meta);
+  }
+
+  private log(level: string, tag: string, message: string, meta: any[]): void {
+    const timestamp = this.date();
+    const coloredLevel = this.color ? this.colorizeLevel(level) : `[${level.toUpperCase()}]`;
+    const coloredTag = this.color ? chalk.bold.cyan(`[${tag}]`) : `[${tag}]`;
+    const output = `${timestamp} ${coloredLevel} ${coloredTag} ${message}`;
+
+    const metaStr = this.meta(meta);
+
+    switch (level) {
+      case 'debug':
+        console.debug(output, metaStr);
+        break;
+      case 'info':
+        console.info(output, metaStr);
+        break;
+      case 'warn':
+        console.warn(output, metaStr);
+        break;
+      case 'error':
+      case 'fatal':
+        console.error(output, metaStr);
+        break;
+      default:
+        console.log(output, metaStr);
+    }
+  }
+
+  private colorizeLevel(level: string): string {
+    const label = `[${level.toUpperCase()}]`;
+    switch (level) {
+      case 'debug':
+        return chalk.gray(label);
+      case 'info':
+        return chalk.green(label);
+      case 'warn':
+        return chalk.yellow(label);
+      case 'error':
+        return chalk.red(label);
+      case 'fatal':
+        return chalk.bgRed.white.bold(label);
+      default:
+        return label;
+    }
+  }
+
+  private date(): string {
+    return chalk.dim(format(new Date(), 'yyyy-MM-dd HH:mm:ss'));
+  }
+
+  private meta(meta: any[]): string {
+    if (meta && meta.length) {
+      return chalk.italic.gray(JSON.stringify(meta.filter(m => m)));
+    }
+    return '';
+  }
+}
+
+export const logger = new StdoutLogger();

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "CommonJS",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "baseUrl": "./src",
+    "declaration": true,
+    "declarationDir": "dist"
+  },
+}