sizebay-core-sdk 1.0.0

package/dist/types/src/types/ai-image-service.types.d.ts

@@ -0,0 +1,48 @@
+export interface GetSimilarProductsParams {
+    tenantId: number;
+    collectionName?: string;
+    sessionId?: number;
+    permalink: string;
+    page?: number;
+    perPage?: number;
+}
+export interface Product {
+    id: string;
+    title: string;
+    productType: string;
+    link: string;
+    imageLink: string;
+    gender: string;
+    availability: string;
+    productHash: string;
+    price: string;
+    salePrice?: string;
+    itemGroupId: string;
+    brand: string;
+    color: string;
+    gtin: string;
+    additionalImageLinks: string[];
+}
+export interface GetSimilarProductsResponse {
+    data: Product[];
+    page: number;
+    perPage: number;
+    total: number;
+}
+export interface ProductRecommendedSize {
+    permalink: string;
+    analysisResponse: any | null;
+    productInfo: any | null;
+    recommendedSize: string;
+    recommendedComposedMeasure: any | null;
+    composedMeasureOrder: any | null;
+    productGender: string;
+    profileName: string;
+    sizeSystem: string;
+}
+export interface GetRecommendedProductSizeParams {
+    products: ProductRecommendedSize[];
+}
+export interface GetRecommendedProductSizeResponse {
+    [key: string]: string | number | boolean;
+}

package/dist/types/src/types/client.types.d.ts

@@ -0,0 +1,13 @@
+import { Config } from '../config';
+import { moduleClasses } from '../modules';
+type InstanceTypeOfClass<T> = T extends new (...args: any[]) => infer R ? R : never;
+type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never;
+export type PublicAPI<T> = {
+    [K in keyof T as T[K] extends Function ? K : never]: T[K];
+};
+type ModulesUnion = PublicAPI<InstanceTypeOfClass<(typeof moduleClasses)[number]>>;
+type ModulesIntersection = UnionToIntersection<ModulesUnion>;
+export type ClientType = {
+    config: Config;
+} & ModulesIntersection;
+export {};

package/dist/types/src/types/event.types.d.ts

@@ -0,0 +1,13 @@
+export type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+export interface TrackData {
+    sid: string;
+    tenantId: number;
+    sessionId: number;
+    permalink?: string;
+    properties: Record<string, JSONValue>;
+}
+export interface DataEventPayload extends TrackData {
+    eventName: string;
+}

package/dist/types/src/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './sdk.types';
+export * from './event.types';
+export * from './client.types';
+export * from './ai-image-service.types';

package/dist/types/src/types/sdk.types.d.ts

@@ -0,0 +1,15 @@
+export interface SDKConfigOptions {
+    env?: 'development' | 'production';
+    globalOptions?: {
+        [key: string]: any;
+    };
+    services?: {
+        [serviceName: string]: {
+            [key: string]: any;
+        };
+    };
+}
+export interface EndpointDefinition {
+    production: string;
+    development: string;
+}

package/dist/types/test/config/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/test/core/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/test/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/test/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/test/modules/ai-image-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/test/modules/tracker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/jest.config.cjs

@@ -0,0 +1,18 @@
+const { pathsToModuleNameMapper } = require('ts-jest');
+const { compilerOptions } = require('./tsconfig.json');
+
+
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  testMatch: ['**/test/**/*.test.ts'], // Garante que os testes sejam encontrados corretamente
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, { prefix: '<rootDir>/' }),
+  setupFilesAfterEnv: ["<rootDir>/test/jest.setup.ts"],
+  roots: ['<rootDir>/src', '<rootDir>/test'], // Define onde os arquivos de teste podem ser encontrados
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "sizebay-core-sdk",
+  "version": "1.0.0",
+  "description": "A SDK designed for integrating multiple services (such as event tracking, AI services, etc.) into your application.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "release": "semantic-release",
+    "build": "vite build",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "test:ci": "jest --ci",
+    "test:dev": "ts-node -r tsconfig-paths/register test/example.ts"
+  },
+  "author": "sizebay",
+  "license": "ISC",
+  "keywords": [
+    "events",
+    "sdk",
+    "sizebay",
+    "tracking"
+  ],
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^12.0.1",
+    "@semantic-release/release-notes-generator": "^14.0.3",
+    "@types/jest": "^29.5.14",
+    "@types/node-fetch": "^2.6.12",
+    "conventional-changelog-conventionalcommits": "^8.0.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.0",
+    "semantic-release": "^24.2.1",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.7.3",
+    "vite": "^6.0.11",
+    "vite-plugin-dts": "^4.5.0",
+    "vite-tsconfig-paths": "^5.1.4"
+  }
+}

package/src/config/endpoints.ts

@@ -0,0 +1,14 @@
+import { EndpointDefinition } from "@src/types";
+
+export const endpoints: Record<string, EndpointDefinition> = {
+  tracker: {
+    production: 'https://data-event-service.internalsizebay.com/events',
+    development: 'https://data-event-service.internalsizebay.com/events',
+  },
+ 
+  aiImageService: {
+    production: 'https://ai-image-service.example.com/production',
+    development: 'https://ai-image-service.example.com/development',
+  },
+  // Adicione outros serviços conforme necessário
+};

package/src/config/index.ts

@@ -0,0 +1,42 @@
+import { SDKConfigOptions } from '@src/types';
+import { endpoints } from './endpoints';
+import { EndpointDefinition } from '@src/types';
+
+export class Config {
+  private endpoints: Record<string, string>;
+  private serviceOverrides: { [service: string]: { [key: string]: any } };
+
+  constructor(options: SDKConfigOptions) {
+    const env = options.env || 'development';
+    this.serviceOverrides = options.services || {};
+
+    this.endpoints = {};
+
+    for (const service in endpoints) {
+      if (Object.prototype.hasOwnProperty.call(endpoints, service)) {
+        const endpointDefinition = endpoints[service];
+        const endpoint = endpointDefinition[env as keyof EndpointDefinition];
+
+        if (!endpoint) {
+          continue;
+        }
+
+        this.endpoints[service] = endpoint;
+      }
+    }
+  }
+
+  getEndpoint(serviceName: string): string {
+    const endpoint = this.endpoints[serviceName];
+    if (!endpoint) {
+      throw new Error(
+        `Endpoint for service '${serviceName}' is not configured.`,
+      );
+    }
+    return endpoint;
+  }
+
+  getServiceConfig(serviceName: string): { [key: string]: any } {
+    return this.serviceOverrides[serviceName] || {};
+  }
+}

package/src/core/client.ts

@@ -0,0 +1,26 @@
+import { Config } from '@src/config';
+import { moduleClasses } from '@src/modules';
+import { ClientType, SDKConfigOptions } from '@src/types';
+
+export function createClient(options: SDKConfigOptions): ClientType {
+  const config = new Config(options);
+  const modules = moduleClasses.map((ModuleClass) => new ModuleClass(config));
+  const client: any = { config };
+
+  modules.forEach((moduleInstance) => {
+    Object.getOwnPropertyNames(moduleInstance).forEach((key) => {
+      if (typeof moduleInstance[key] === 'function') {
+        client[key] = moduleInstance[key].bind(moduleInstance);
+      }
+    });
+
+    const prototype = Object.getPrototypeOf(moduleInstance);
+    Object.getOwnPropertyNames(prototype).forEach((key) => {
+      if (key !== 'constructor' && typeof moduleInstance[key] === 'function') {
+        client[key] = moduleInstance[key].bind(moduleInstance);
+      }
+    });
+  });
+
+  return client as ClientType;
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createClient } from './core/client';
+export * from './types';

package/src/modules/ai-image-service.ts

@@ -0,0 +1,68 @@
+import { Config } from '@src/config';
+import {
+  GetRecommendedProductSizeParams,
+  GetRecommendedProductSizeResponse,
+  GetSimilarProductsParams,
+  GetSimilarProductsResponse,
+} from '@src/types/ai-image-service.types';
+
+export class AIImageService {
+  private endpoint: string;
+
+  constructor(config: Config) {
+    this.endpoint = config.getEndpoint('aiImageService');
+  }
+
+  public async getSimilarProducts(
+    params: GetSimilarProductsParams,
+  ): Promise<GetSimilarProductsResponse> {
+    const url = new URL(`${this.endpoint}/recommendations/similar`);
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined) {
+        url.searchParams.append(key, String(value));
+      }
+    });
+
+    try {
+      const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Request error: ${response.status} - ${errorText}`);
+      }
+
+      return (await response.json()) as GetSimilarProductsResponse;
+    } catch (error: any) {
+      throw new Error(`Error fetching similar products: ${error.message}`);
+    }
+  }
+
+  public async getRecommendedProductSize(
+    payload: GetRecommendedProductSizeParams,
+  ): Promise<GetRecommendedProductSizeResponse> {
+    const url = new URL(`${this.endpoint}/recommendations/size-by-products`);
+
+    try {
+      const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Request error: ${response.status} - ${errorText}`);
+      }
+      return (await response.json()) as GetRecommendedProductSizeResponse;
+    } catch (error: any) {
+      throw new Error(`Error fetching recommended product size: ${error.message}`);
+    }
+  }
+}

package/src/modules/index.ts

@@ -0,0 +1,7 @@
+import { Tracker } from "./tracker";
+import { AIImageService } from "./ai-image-service";
+ 
+export const moduleClasses = [
+  Tracker,
+  AIImageService,
+];

package/src/modules/tracker.ts

@@ -0,0 +1,37 @@
+import { DataEventPayload, TrackData } from "../types";
+import { Config } from "../config";
+
+export class Tracker {
+  
+  private endpoint: string;
+
+  constructor(config: Config) {
+    // Define "config" como não enumerável
+    
+    this.endpoint =  config.getEndpoint('tracker');
+  }
+
+  public async track(eventName: string, payload: TrackData): Promise<any> {
+    const data: DataEventPayload = {
+      eventName,
+      ...payload,
+    };
+
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Request error: ${response.status} - ${errorText}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/types/ai-image-service.types.ts

@@ -0,0 +1,52 @@
+export interface GetSimilarProductsParams {
+  tenantId: number;
+  collectionName?: string;
+  sessionId?: number;
+  permalink: string;
+  page?: number;
+  perPage?: number;
+}
+export interface Product {
+  id: string;
+  title: string;
+  productType: string;
+  link: string;
+  imageLink: string;
+  gender: string;
+  availability: string;
+  productHash: string;
+  price: string;
+  salePrice?: string;
+  itemGroupId: string;
+  brand: string;
+  color: string;
+  gtin: string;
+  additionalImageLinks: string[];
+}
+
+export interface GetSimilarProductsResponse {
+  data: Product[];
+  page: number;
+  perPage: number;
+  total: number;
+}
+
+export interface ProductRecommendedSize {
+  permalink: string;
+  analysisResponse: any | null;
+  productInfo: any | null;
+  recommendedSize: string;
+  recommendedComposedMeasure: any | null;
+  composedMeasureOrder: any | null;
+  productGender: string;
+  profileName: string;
+  sizeSystem: string;
+}
+
+export interface GetRecommendedProductSizeParams {
+  products: ProductRecommendedSize[];
+}
+
+export interface GetRecommendedProductSizeResponse {
+  [key: string]: string | number | boolean;
+}

package/src/types/client.types.ts

@@ -0,0 +1,30 @@
+import { Config } from '@src/config';
+import { moduleClasses } from '@src/modules';
+
+type InstanceTypeOfClass<T> = T extends new (...args: any[]) => infer R
+  ? R
+  : never;
+
+type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (
+  x: infer I,
+) => any
+  ? I
+  : never;
+
+// Helper que extrai apenas os métodos (funções) públicos do módulo
+export type PublicAPI<T> = {
+  [K in keyof T as T[K] extends Function ? K : never]: T[K];
+};
+
+// Cria uma união com os tipos dos módulos (apenas a API pública)
+type ModulesUnion = PublicAPI<
+  InstanceTypeOfClass<(typeof moduleClasses)[number]>
+>;
+
+// Converte a união em interseção
+type ModulesIntersection = UnionToIntersection<ModulesUnion>;
+
+// Define o tipo final do Client (expondo apenas a API pública dos módulos)
+export type ClientType = {
+  config: Config;
+} & ModulesIntersection;

package/src/types/event.types.ts

@@ -0,0 +1,28 @@
+/**
+ * Represents any valid JSON value.
+ */
+export type JSONValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JSONValue[]
+  | { [key: string]: JSONValue };
+
+/**
+ * Interface that defines the structure of a tracked event.
+ */
+export interface TrackData {
+  sid: string;
+  tenantId: number;
+  sessionId: number;
+  permalink?: string;
+  properties: Record<string, JSONValue>;
+}
+
+/**
+ * Payload for the track event.
+ */
+export interface DataEventPayload extends TrackData {
+  eventName: string;
+}

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from './sdk.types';
+export * from './event.types';
+export * from './client.types';
+export * from './ai-image-service.types';

package/src/types/sdk.types.ts

@@ -0,0 +1,17 @@
+export interface SDKConfigOptions {
+  env?: 'development' | 'production';
+
+  globalOptions?: {
+    [key: string]: any;
+  };
+
+  services?: {
+    [serviceName: string]: {
+      [key: string]: any;
+    };
+  };
+}
+export interface EndpointDefinition {
+  production: string;
+  development: string;
+}

package/test/config/config.test.ts

@@ -0,0 +1,59 @@
+import { Config } from "@src/config";
+
+ 
+jest.mock('@src/config/endpoints', () => ({
+  endpoints: {
+    serviceA: {
+      development: "http://localhost:3000",
+      production: "https://api.example.com",
+    },
+    serviceB: {
+      development: "http://localhost:3001",
+      production: "https://api2.example.com",
+    },
+  },
+}));
+
+describe('Config', () => {
+  describe('getEndpoint', () => {
+    it('should return the service endpoint for the default environment (development)', () => {
+      const options = { env: 'development', services: {} } as const;
+      const config = new Config(options);
+      expect(config.getEndpoint('serviceA')).toBe("http://localhost:3000");
+    });
+
+    it('should return the service endpoint for the production environment', () => {
+      const options = { env: 'production', services: {} } as const;
+      const config = new Config(options);
+      expect(config.getEndpoint('serviceB')).toBe("https://api2.example.com");
+    });
+
+    it("should throw an error if the service endpoint is not configured", () => {
+      const options = { env: 'development', services: {} } as const;
+      const config = new Config(options);
+      expect(() => config.getEndpoint('nonExistingService')).toThrowError(
+        "Endpoint for service 'nonExistingService' is not configured."
+      );
+    });
+    
+  });
+
+  describe('getServiceConfig', () => {
+    it('should return the service configuration if it exists', () => {
+      const options = {
+        env: 'development',
+        services: {
+          serviceA: { someKey: 'someValue' },
+        },
+      } as const;
+      const config = new Config(options);
+      expect(config.getServiceConfig('serviceA')).toEqual({ someKey: 'someValue' });
+    });
+
+    it('should return an empty object if the service configuration does not exist', () => {
+      const options = { env: 'development', services: {} } as const;
+      const config = new Config(options);
+      expect(config.getServiceConfig('nonExistingService')).toEqual({});
+    });
+  });
+});

package/test/core/client.test.ts

@@ -0,0 +1,32 @@
+import { moduleClasses } from '@src/modules';
+
+import { SDKConfigOptions } from '@src/types';
+import { createClient } from '@src/index';
+
+describe('createClient', () => {
+  const options: SDKConfigOptions = {
+    env: 'development',
+    globalOptions: { key: 'value' },
+  };
+
+  const client = createClient(options);
+
+  it('should instantiate each module listed in moduleClasses and add its methods to the client', () => {
+    moduleClasses.forEach((ModuleClass) => {
+      const instance = new ModuleClass(client.config);
+
+      Object.getOwnPropertyNames(instance).forEach((prop) => {
+        if (typeof instance[prop] === 'function') {
+          expect(typeof client[prop]).toBe('function');
+        }
+      });
+
+      const proto = Object.getPrototypeOf(instance);
+      Object.getOwnPropertyNames(proto).forEach((prop) => {
+        if (prop !== 'constructor' && typeof instance[prop] === 'function') {
+          expect(typeof client[prop]).toBe('function');
+        }
+      });
+    });
+  });
+});

package/test/example.ts

@@ -0,0 +1,53 @@
+import { createClient } from '@src/core/client';
+
+/*async function main() {
+  const client = createClient({ env: 'development'});
+
+  const payload = {
+    sid: 'a0cf8559-926a-4a75-b4ca-7c4c13fed69c',
+    tenantId: 123,
+    eventName: 'ADD_TO_CART',
+    sessionId: 123,
+    permalink: 'https://www.example.com/2IC-7370',
+    properties: {
+      quantity: 1,
+      device: 'APP',
+      country: 'BR',
+    },
+  };
+
+  try {
+    const result = await client.track('samuel', payload);
+    console.log('Resposta 200 do endpoint:', result);
+  } catch (error) {
+    console.error('Erro ao enviar o evento:', error);
+  }
+}
+
+*/
+
+async function main() {
+  // Cria o client com a configuração desejada
+  const client = createClient({ env: 'development' });
+
+    // Define os parâmetros para buscar produtos similares, conforme a tipagem
+    const params = {
+      tenantId: 123,
+      permalink: 'https://www.example.com/produto-exemplo',
+      collectionName: 'colecao-exemplo', // opcional
+      sessionId: 456,                   // opcional
+      page: 1,                          // opcional
+      perPage: 10                       // opcional
+    };
+
+  try {
+    // Chama o método do módulo AIImageService
+    const result = await client.getSimilarProducts(params);
+    console.log('Resposta 200 do endpoint AIImageService:', result);
+  } catch (error) {
+    console.error('Erro ao buscar produtos similares:', error);
+  }
+}
+
+
+main();