sizebay-core-sdk 1.0.0

package/test/index.test.ts

@@ -0,0 +1,12 @@
+import { createClient } from '@src/core/client';
+import * as Types from '@src/types';
+
+describe('Index Module', () => {
+  it('should export Client', () => {
+    expect(createClient).toBeDefined();
+  });
+
+  it('should export types', () => {
+    expect(Types).toBeDefined();
+  });
+});

package/test/jest.setup.ts

@@ -0,0 +1,8 @@
+beforeAll(() => {
+  global.fetch = jest.fn(() =>
+    Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve({ success: true }),
+    })
+  ) as jest.Mock;
+});

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

@@ -0,0 +1,234 @@
+import { AIImageService } from '@src/modules/ai-image-service';
+import {
+  GetSimilarProductsParams,
+  GetSimilarProductsResponse,
+  GetRecommendedProductSizeParams,
+  GetRecommendedProductSizeResponse,
+} from '@src/types/ai-image-service.types';
+
+describe('AIImageService', () => {
+  // Use a valid base URL for constructing request URLs.
+  const fakeEndpoint = 'https://example.com/ai-image-service';
+  let fakeConfig: { getEndpoint: (serviceName: string) => string };
+  let aiImageService: AIImageService;
+
+  beforeEach(() => {
+    // Reinitialize the fake configuration for each test.
+    fakeConfig = {
+      getEndpoint: (serviceName: string) => fakeEndpoint,
+    };
+    // Cast fakeConfig as any to bypass missing properties required by Config.
+    aiImageService = new AIImageService(fakeConfig as any);
+  });
+
+  afterEach(() => {
+    // Reset global.fetch if it was set.
+    if (global.fetch && (global.fetch as jest.Mock).mockReset) {
+      (global.fetch as jest.Mock).mockReset();
+    }
+  });
+
+  describe('getSimilarProducts', () => {
+    it('should send the GET request with correct query parameters and return the JSON response', async () => {
+      const fakeResponseData: GetSimilarProductsResponse = {
+        data: [
+          {
+            id: '1',
+            title: 'Product 1',
+            productType: 'type',
+            link: 'https://example.com/product/1',
+            imageLink: 'https://example.com/product/1.jpg',
+            gender: 'unisex',
+            availability: 'in stock',
+            productHash: 'abc',
+            price: '100',
+            salePrice: '80',
+            itemGroupId: 'group1',
+            brand: 'BrandA',
+            color: 'red',
+            gtin: '123456',
+            additionalImageLinks: ['https://example.com/product/1_2.jpg'],
+          },
+        ],
+        page: 1,
+        perPage: 10,
+        total: 1,
+      };
+
+      const fakeFetchResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue(fakeResponseData),
+      };
+
+      global.fetch = jest.fn().mockResolvedValue(fakeFetchResponse as any);
+
+      const params: GetSimilarProductsParams = {
+        tenantId: 1,
+        permalink: 'https://example.com/product/1',
+        collectionName: 'collectionA',
+        sessionId: 123,
+        page: 1,
+        perPage: 10,
+      };
+
+      const result = await aiImageService.getSimilarProducts(params);
+
+      // Build expected URL with query parameters.
+      const expectedUrl = new URL(`${fakeEndpoint}/recommendations/similar`);
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined) {
+          expectedUrl.searchParams.append(key, String(value));
+        }
+      });
+
+      expect(global.fetch).toHaveBeenCalledWith(expectedUrl.toString(), {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json' },
+      });
+      expect(result).toEqual(fakeResponseData);
+    });
+
+    it('should throw an error if the response is not ok', async () => {
+      const errorText = 'Bad Request';
+      const fakeFetchResponse = {
+        ok: false,
+        status: 400,
+        text: jest.fn().mockResolvedValue(errorText),
+      };
+
+      global.fetch = jest.fn().mockResolvedValue(fakeFetchResponse as any);
+
+      const params: GetSimilarProductsParams = {
+        tenantId: 1,
+        permalink: 'https://example.com/product/1',
+        collectionName: 'collectionA',
+        sessionId: 123,
+        page: 1,
+        perPage: 10,
+      };
+
+      await expect(aiImageService.getSimilarProducts(params)).rejects.toThrow(
+        `Request error: 400 - ${errorText}`,
+      );
+    });
+
+    it('should throw an error if fetch fails', async () => {
+      const errorMessage = 'Network error';
+      global.fetch = jest.fn().mockRejectedValue(new Error(errorMessage));
+
+      const params: GetSimilarProductsParams = {
+        tenantId: 1,
+        permalink: 'https://example.com/product/1',
+        collectionName: 'collectionA',
+        sessionId: 123,
+        page: 1,
+        perPage: 10,
+      };
+
+      await expect(aiImageService.getSimilarProducts(params)).rejects.toThrow(
+        `Error fetching similar products: ${errorMessage}`,
+      );
+    });
+  });
+
+  describe('getRecommendedProductSize', () => {
+    it('should send the POST request with the correct payload and return the JSON response', async () => {
+      const fakeResponseData: GetRecommendedProductSizeResponse = {
+        recommendedSize: 'M',
+        someOtherKey: 123,
+      };
+
+      const fakeFetchResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue(fakeResponseData),
+      };
+
+      global.fetch = jest.fn().mockResolvedValue(fakeFetchResponse as any);
+
+      const payload: GetRecommendedProductSizeParams = {
+        products: [
+          {
+            permalink: 'https://example.com/product/1',
+            analysisResponse: null,
+            productInfo: null,
+            recommendedSize: 'M',
+            recommendedComposedMeasure: null,
+            composedMeasureOrder: null,
+            productGender: 'unisex',
+            profileName: 'profile1',
+            sizeSystem: 'US',
+          },
+        ],
+      };
+
+      const result = await aiImageService.getRecommendedProductSize(payload);
+
+      const expectedUrl = `${fakeEndpoint}/recommendations/size-by-products`;
+
+      expect(global.fetch).toHaveBeenCalledWith(expectedUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      expect(result).toEqual(fakeResponseData);
+    });
+
+    it('should throw an error if the response is not ok', async () => {
+      const errorText = 'Server Error';
+      const fakeFetchResponse = {
+        ok: false,
+        status: 500,
+        text: jest.fn().mockResolvedValue(errorText),
+      };
+
+      global.fetch = jest.fn().mockResolvedValue(fakeFetchResponse as any);
+
+      const payload: GetRecommendedProductSizeParams = {
+        products: [
+          {
+            permalink: 'https://example.com/product/1',
+            analysisResponse: null,
+            productInfo: null,
+            recommendedSize: 'M',
+            recommendedComposedMeasure: null,
+            composedMeasureOrder: null,
+            productGender: 'unisex',
+            profileName: 'profile1',
+            sizeSystem: 'US',
+          },
+        ],
+      };
+
+      await expect(
+        aiImageService.getRecommendedProductSize(payload),
+      ).rejects.toThrow(`Request error: 500 - ${errorText}`);
+    });
+
+    it('should throw an error if fetch fails', async () => {
+      const errorMessage = 'Network error';
+      global.fetch = jest.fn().mockRejectedValue(new Error(errorMessage));
+
+      const payload: GetRecommendedProductSizeParams = {
+        products: [
+          {
+            permalink: 'https://example.com/product/1',
+            analysisResponse: null,
+            productInfo: null,
+            recommendedSize: 'M',
+            recommendedComposedMeasure: null,
+            composedMeasureOrder: null,
+            productGender: 'unisex',
+            profileName: 'profile1',
+            sizeSystem: 'US',
+          },
+        ],
+      };
+
+      await expect(
+        aiImageService.getRecommendedProductSize(payload),
+      ).rejects.toThrow(
+        `Error fetching recommended product size: ${errorMessage}`,
+      );
+    });
+  });
+});

package/test/modules/tracker.test.ts

@@ -0,0 +1,86 @@
+import { Tracker } from '@src/modules/tracker';
+import { TrackData } from '@src/types';
+
+describe('Tracker', () => {
+  const fakeEndpoint = 'https://example.com/tracker';
+  const fakeConfig = {
+    getEndpoint: jest.fn().mockReturnValue(fakeEndpoint),
+  };
+
+  let tracker: Tracker;
+
+  beforeEach(() => {
+    tracker = new Tracker(fakeConfig as any);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should send the event and return the JSON response', async () => {
+    const fakeResponseData = { success: true };
+
+    const fakeFetchResponse = {
+      ok: true,
+      json: jest.fn().mockResolvedValue(fakeResponseData),
+    };
+    global.fetch = jest.fn().mockResolvedValue(fakeFetchResponse as any);
+
+    const eventName = 'testEvent';
+    const payload: TrackData = {
+      sid: 'abc123',
+      tenantId: 1,
+      sessionId: 1,
+      properties: { some: 'data' },
+    };
+
+    const result = await tracker.track(eventName, payload);
+
+    expect(global.fetch).toHaveBeenCalledWith(fakeEndpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ eventName, ...payload }),
+    });
+    expect(result).toEqual(fakeResponseData);
+  });
+
+  it('should throw an error if the response is not ok', async () => {
+    const errorText = 'Internal Server Error';
+
+    const fakeFetchResponse = {
+      ok: false,
+      status: 500,
+      text: jest.fn().mockResolvedValue(errorText),
+    };
+    global.fetch = jest.fn().mockResolvedValue(fakeFetchResponse as any);
+
+    const eventName = 'testEvent';
+    const payload: TrackData = {
+      sid: 'abc123',
+      tenantId: 1,
+      sessionId: 1,
+      properties: { some: 'data' },
+    };
+
+    await expect(tracker.track(eventName, payload)).rejects.toThrow(
+      `Request error: 500 - ${errorText}`,
+    );
+  });
+
+  it('should throw an error if fetch fails', async () => {
+    const errorMessage = 'Network error';
+    global.fetch = jest.fn().mockRejectedValue(new Error(errorMessage));
+
+    const eventName = 'testEvent';
+    const payload: TrackData = {
+      sid: 'abc123',
+      tenantId: 1,
+      sessionId: 1,
+      properties: { some: 'data' },
+    };
+
+    await expect(tracker.track(eventName, payload)).rejects.toThrow(
+      errorMessage,
+    );
+  });
+});

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "esModuleInterop": true,
+    "paths": {
+      "@src/*": ["src/*"],
+      "@test/*": ["test/*"]
+    }
+  },
+  "include": ["src/**/*", "templates/**/*", "test/**/*" ]
+}

package/vite.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from "vite";
+import dts from 'vite-plugin-dts'
+import path from "path";
+import tsconfigPaths from 'vite-tsconfig-paths';
+
+export default defineConfig({
+  plugins: [
+    dts({
+      outDir: "dist/types",
+    }),
+    tsconfigPaths()
+  ],
+  build: {
+    lib: {
+      entry: path.resolve(__dirname, "src/index.ts"),
+      name: "sizebay-core-sdk",
+      fileName: (format) => `sizebay-core-sdk.${format}.js`,
+      formats: ["es", "umd"],
+    },
+    rollupOptions: {
+      external: [],
+      output: {
+        globals: {},
+      },
+    },
+  },
+});