@insignia-education/api-sdk-js 0.9.22 → 0.9.24

package/eslint.config.mjs

@@ -16,4 +16,14 @@ export default [
             "no-console": "warn",
         },
     },
+    {
+        files: ["tests/**/*.js"],
+        languageOptions: {
+            globals: {
+                ...globals.node,
+                ...globals.jest,
+                fetch: "readonly",
+            },
+        },
+    },
 ];

package/jest.config.mjs

@@ -4,6 +4,16 @@ const config = {
     coverageDirectory: 'coverage',
     coverageProvider: 'v8',
 
+    reporters: [
+        'default',
+        ['jest-html-reporter', {
+            outputPath: 'coverage/test-report.html',
+            pageTitle: 'API SDK Test Report',
+            includeFailureMsg: true,
+            includeConsoleLog: true,
+        }],
+    ],
+
     projects: [
         {
             displayName: 'unit',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@insignia-education/api-sdk-js",
-  "version": "0.9.22",
+  "version": "0.9.24",
   "description": "JavaScript SDK for the Insignia Education API",
   "main": "index.js",
   "type": "module",

package/src/Client.js

@@ -1,5 +1,6 @@
 export default class InsigniaClient {
     #baseUrl;
+    #cookies = new Map();
 
     constructor(baseUrl) {
         this.#baseUrl = InsigniaClient._resolve(baseUrl);
@@ -16,14 +17,66 @@ export default class InsigniaClient {
     }
 
     #headers() {
-        return { 'Content-Type': 'application/json' };
+        const headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        };
+
+        const cookie = this.#cookieHeader();
+        if (cookie) headers.Cookie = cookie;
+
+        return headers;
+    }
+
+    #cookieHeader() {
+        if (typeof window !== 'undefined' || this.#cookies.size === 0) return null;
+
+        return Array.from(this.#cookies.entries())
+            .map(([name, value]) => `${name}=${value}`)
+            .join('; ');
+    }
+
+    #storeCookies(response) {
+        if (typeof window !== 'undefined') return;
+
+        const headers = response.headers;
+        const setCookies = typeof headers?.getSetCookie === 'function'
+            ? headers.getSetCookie()
+            : [headers?.get?.('set-cookie')].filter(Boolean);
+
+        for (const setCookie of setCookies) {
+            const [pair] = setCookie.split(';');
+            const separator = pair.indexOf('=');
+            if (separator === -1) continue;
+
+            this.#cookies.set(pair.slice(0, separator), pair.slice(separator + 1));
+        }
+    }
+
+    async #parseResponse(response) {
+        if ([204, 205].includes(response.status)) return null;
+
+        try {
+            if (typeof response.text === 'function') {
+                const text = await response.text();
+                return text === '' ? null : JSON.parse(text);
+            }
+
+            return await response.json();
+        } catch (error) {
+            if (error instanceof SyntaxError && error.message.includes('Unexpected end')) {
+                return null;
+            }
+            throw error;
+        }
     }
 
     async #request(method, path, body = null) {
         const options = { method, headers: this.#headers(), credentials: 'include' };
         if (body !== null) options.body = JSON.stringify(body);
         const response = await fetch(`${this.#baseUrl}${path}`, options);
-        const data = await response.json();
+        this.#storeCookies(response);
+        const data = await this.#parseResponse(response);
         return data?.success ? data.response : data;
     }
 

package/src/api/v1/Courses.js

@@ -5,7 +5,16 @@ export default class Courses {
         this.#client = client;
     }
 
-    get(id = null)  { return id ? this.#client.get(`/courses/${id}`) : this.#client.get('/courses'); }
+    getByCod(cod) { return this.#client.get(`/courses/cod/${cod}`); }
+
+    get(id = null, { page = 1, perPage = 15 } = {}) {
+        if (id) return this.#client.get(`/courses/${id}`);
+        const params = new URLSearchParams();
+        if (page)    params.set('page', page);
+        if (perPage) params.set('per_page', perPage);
+        const qs = params.toString();
+        return this.#client.get(qs ? `/courses?${qs}` : '/courses');
+    }
     create(data)    { return this.#client.put('/courses', data); }
     edit(id, data)  { return this.#client.patch(`/courses/${id}`, data); }
     delete(id)      { return this.#client.del(`/courses/${id}`); }

package/src/api/v1/Zoom.js

@@ -10,14 +10,4 @@ export default class Zoom {
             get: (id = null) => id ? this.#client.get(`/zoom/meetings/${id}`) : this.#client.get('/zoom/meetings'),
         };
     }
-
-    tokens() {
-        const base = '/zoom/tokens';
-        return {
-            get:    (id = null) => id ? this.#client.get(`${base}/${id}`) : this.#client.get(base),
-            create: (data)      => this.#client.put(base, data),
-            edit:   (id, data)  => this.#client.patch(`${base}/${id}`, data),
-            delete: (id)        => this.#client.del(`${base}/${id}`),
-        };
-    }
 }

package/src/api/v1/index.js

@@ -21,10 +21,8 @@ import PaymentMethods from './PaymentMethods.js';
 import Quizzes from './Quizzes.js';
 import ShortLinks from './ShortLinks.js';
 import Surveys from './Surveys.js';
-import Tags from './Tags.js';
 import Taxes from './Taxes.js';
 import Teacher from './Teacher.js';
-import Translations from './Translations.js';
 import UserTypes from './UserTypes.js';
 import Users from './Users.js';
 import Zoom from './Zoom.js';
@@ -36,6 +34,7 @@ export default class InsigniaApiV1 extends InsigniaApi {
         baseUrl += !/\/v1(\/|$)/.test(baseUrl) ? '/v1' : '';
         return baseUrl;
     }
+    
     constructor(baseUrl = null) {
         let url = InsigniaApiV1._resolve(baseUrl);
         super(url);
@@ -62,10 +61,8 @@ export default class InsigniaApiV1 extends InsigniaApi {
         this.quizzes              = new Quizzes(this);
         this.shortLinks           = new ShortLinks(this);
         this.surveys              = new Surveys(this);
-        this.tags                 = new Tags(this);
         this.taxes                = new Taxes(this);
         this.teacher              = new Teacher(this);
-        this.translations         = new Translations(this);
         this.userTypes            = new UserTypes(this);
         this.users                = new Users(this);
         this.zoom                 = new Zoom(this);

package/tests/client.test.js

@@ -79,6 +79,19 @@ describe('baseUrl resolution', () => {
             expect.any(Object)
         );
     });
+
+    test('falls back to default when process is undefined', async () => {
+        const saved = global.process;
+        global.process = undefined;
+        global.fetch = mockFetch();
+        const client = new InsigniaClient(null);
+        await client.get('/test');
+        expect(global.fetch).toHaveBeenCalledWith(
+            'https://insigniaeducation.com/test',
+            expect.any(Object)
+        );
+        global.process = saved;
+    });
 });
 
 // ─── HTTP methods ─────────────────────────────────────────────────────────────
@@ -152,9 +165,10 @@ describe('HTTP methods', () => {
         expect(options.body).toBeUndefined();
     });
 
-    test('Content-Type is always application/json', async () => {
+    test('JSON headers are always sent', async () => {
         await client.get('/path');
         const [, options] = global.fetch.mock.calls[0];
+        expect(options.headers.Accept).toBe('application/json');
         expect(options.headers['Content-Type']).toBe('application/json');
     });
 
@@ -164,6 +178,26 @@ describe('HTTP methods', () => {
         expect(options.credentials).toBe('include');
     });
 
+    test('stores response cookies and sends them on later requests in Node', async () => {
+        global.fetch = jest.fn()
+            .mockResolvedValueOnce({
+                headers: {
+                    getSetCookie: () => ['token=abc123; Path=/; HttpOnly; Secure; SameSite=Lax'],
+                },
+                json: () => Promise.resolve({ success: 'ok' }),
+            })
+            .mockResolvedValueOnce({
+                json: () => Promise.resolve({ id: 1, title: 'test' }),
+            });
+        client = new InsigniaClient(BASE);
+
+        await client.post('/auth/login', { email: 'admin@example.com', password: 'secret' });
+        await client.get('/accounts');
+
+        const [, options] = global.fetch.mock.calls[1];
+        expect(options.headers.Cookie).toBe('token=abc123');
+    });
+
     test('returns parsed JSON from response', async () => {
         global.fetch = jest.fn().mockResolvedValue({
             json: () => Promise.resolve({ id: 1, name: 'test' }),
@@ -172,4 +206,33 @@ describe('HTTP methods', () => {
         const result = await client.get('/path');
         expect(result).toEqual({ id: 1, name: 'test' });
     });
+
+    test('returns null for empty response text', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            status: 200,
+            text: () => Promise.resolve(''),
+        });
+        client = new InsigniaClient(BASE);
+        const result = await client.get('/path');
+        expect(result).toBeNull();
+    });
+
+    test('returns null for no-content responses', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            status: 204,
+            json: jest.fn(),
+        });
+        client = new InsigniaClient(BASE);
+        const result = await client.del('/path');
+        expect(result).toBeNull();
+    });
+
+    test('returns null when json parsing fails because the response is empty', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            json: () => Promise.reject(new SyntaxError('Unexpected end of JSON input')),
+        });
+        client = new InsigniaClient(BASE);
+        const result = await client.get('/path');
+        expect(result).toBeNull();
+    });
 });

package/tests/helpers.js

@@ -0,0 +1,16 @@
+import InsigniaApiV1 from '../src/api/v1/index.js';
+
+export const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+export const loginCustomer = () => api.auth.login({
+    email: process.env.TEST_EMAIL,
+    password: process.env.TEST_PASSWORD,
+});
+
+export const loginAdmin = () => api.auth.login({
+    email: process.env.TEST_EMAIL_ADMIN,
+    password: process.env.TEST_PASSWORD_ADMIN,
+});
+
+
+export const logout = () => api.auth.logout();

package/tests/integration/api/v1/accounts.test.js

@@ -0,0 +1,37 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../helpers.js';
+
+describe('api/v1/accounts', () => {
+    test('get | unauthenticated', async () => {
+        await api.accounts.get()
+            .then(response => {
+                expect(response.success).toBe(false);
+                expect(response.status).toBe(401);
+            });
+    });
+    test('get | authenticated but other type', async () => {
+        await loginCustomer();
+        await api.accounts.get()
+            .then(response => {
+                console.log(response);
+                expect(response.success).toBe(false);
+                expect(response.status).toBe(403);
+            });
+    });
+    test('get | authenticated', async () => {
+        await loginAdmin();
+        await api.accounts.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(response.length > 0).toBe(true);
+                response.forEach(account => {
+                    expect(account["id"]).toBeDefined();
+                    expect(account["cod"]).toBeDefined();
+                    expect(account["title"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/auth/login.test.js

@@ -0,0 +1,60 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin,
+    logout,
+} from '../../../../helpers.js';
+
+
+
+
+describe('api/v1/auth/login', () => {
+    test('POST | failure | no email validation', async () => {
+        const password = process.env.TEST_PASSWORD;
+        logout()
+        .then(() => api.auth.login({ password })
+            .then(response => {
+                // here we have more info of the request because we have the errors
+                expect(response["success"]).toBeDefined();
+                expect(response["status"]).toBeDefined();
+                expect(response["status"]).toBe(422);
+                expect(response["errors"]).toBeDefined();
+                expect(Object.values(response["errors"]).length > 0).toBe(true);
+                expect(response["errors"]["email"]).toBeDefined();
+            }));
+    });
+
+    test('POST | failure | no password validation', async () => {
+        const email = process.env.TEST_EMAIL;
+        logout()
+        .then(() => api.auth.login({ email })
+            .then(response => {
+                // here we have more info of the request because we have the errors
+                expect(response["success"]).toBeDefined();
+                expect(response["errors"]).toBeDefined();
+                expect(response["status"]).toBeDefined();
+                expect(response["status"]).toBe(422);
+                expect(Object.values(response["errors"]).length > 0).toBe(true);
+                expect(response["errors"]["password"]).toBeDefined();
+            }));
+        
+    });
+
+    test('POST | success', async () => {
+        logout()
+        .then(() => loginAdmin()
+            .then(response => {
+                expect(response["success"]).toBeDefined();
+                expect(response["success"]).toBe("ok");
+            }));
+    });
+
+    test('POST | double login', async () => {
+        loginAdmin()
+        .then(() => loginAdmin()
+            .then(response => {
+                expect(response["success"]).toBeDefined();
+                expect(response["success"]).toBe("ok");
+            }));
+    });
+});

package/tests/integration/api/v1/categories.test.js

@@ -0,0 +1,19 @@
+import { 
+    api
+} from '../../../helpers.js';
+
+describe('api/v1/categories', () => {
+    test('get', async () => {
+        await api.categories.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(response.length > 0).toBe(true);
+                response.forEach(category => {
+                    expect(category["id"]).toBeDefined();
+                    expect(category["cod"]).toBeDefined();
+                    expect(category["title"]).toBeDefined();
+                    expect(category["enabled"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/changelogs.test.js

@@ -0,0 +1,21 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../helpers.js';
+
+describe('api/v1/changelogs', () => {
+    test('get | authenticated', async () => {
+        await loginAdmin();
+        await api.changelogs.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(changelog => {
+                    expect(changelog["id"]).toBeDefined();
+                    expect(changelog["created_at"]).toBeDefined();
+                    expect(changelog["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/configs.test.js

@@ -0,0 +1,20 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../helpers.js';
+
+describe('api/v1/configs', () => {
+    test('get', async () => {
+        await api.configs.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(response.length > 0).toBe(true);
+                response.forEach(config => {
+                    expect(config["id"]).toBeDefined();
+                    expect(config["cod"]).toBeDefined();
+                    expect(config["value"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/contact-forms.test.js

@@ -0,0 +1,24 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../helpers.js';
+
+
+describe('api/v1/contact-forms', () => {
+    test('get | authenticated', async () => {
+        await loginAdmin();
+        await api.contactForms.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(form => {
+                    expect(form["id"]).toBeDefined();
+                    expect(form["name"]).toBeDefined();
+                    expect(form["email"]).toBeDefined();
+                    expect(form["message"]).toBeDefined();
+                    expect(form["created_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/conversational-topics.test.js

@@ -0,0 +1,19 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+describe('api/v1/conversational-topics', () => {
+    test('get', async () => {
+        await api.conversationalTopics.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(response.length > 0).toBe(true);
+                response.forEach(topic => {
+                    expect(topic["id"]).toBeDefined();
+                    expect(topic["cod"]).toBeDefined();
+                    expect(topic["title"]).toBeDefined();
+                    expect(topic["enabled"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/countries.test.js

@@ -0,0 +1,20 @@
+
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+describe('api/v1/countries', () => {
+    test('get', async () => {
+        api.countries.get()
+        .then(response => {
+            response = Object.values(response);
+            expect(response.length > 0).toBe(true);
+            response.forEach(country => {
+                expect(country["id"]).toBeDefined();
+                expect(country["cod"]).toBeDefined();
+                expect(country["domain"]).toBeDefined();
+                expect(country["phone_prefix"]).toBeDefined();
+            })
+        });
+    });
+});

package/tests/integration/api/v1/coupons.test.js

@@ -0,0 +1,26 @@
+import InsigniaApiV1 from '../../../../src/api/v1/index.js';
+
+const api = new InsigniaApiV1(process.env.INSIGNIA_EDUCATION_API_BASE_URL);
+
+const login = () => api.auth.login({
+    email: process.env.TEST_EMAIL,
+    password: process.env.TEST_PASSWORD,
+});
+
+describe('api/v1/coupons', () => {
+    test('get | authenticated', async () => {
+        await login();
+        await api.coupons.get()
+            .then(response => {
+                response = Object.values(response);
+                expect(Array.isArray(response)).toBe(true);
+                response.forEach(coupon => {
+                    expect(coupon["id"]).toBeDefined();
+                    expect(coupon["cod"]).toBeDefined();
+                    expect(coupon["enabled"]).toBeDefined();
+                    expect(coupon["created_at"]).toBeDefined();
+                    expect(coupon["updated_at"]).toBeDefined();
+                });
+            });
+    });
+});

package/tests/integration/api/v1/courses/by-cod.test.js

@@ -0,0 +1,19 @@
+import { 
+    api, 
+    loginCustomer,
+    loginAdmin
+} from '../../../../helpers.js';
+
+describe('api/v1/courses/cod/:cod', () => {
+    test('get by cod | returns matching course', async () => {
+        const firstPage = await api.courses.get();
+        const cod = firstPage["data"][0]["cod"];
+        await api.courses.getByCod(cod)
+            .then(response => {
+                expect(response["id"]).toBeDefined();
+                expect(response["cod"]).toBe(cod);
+                expect(response["title"]).toBeDefined();
+                expect(response["enabled"]).toBeDefined();
+            });
+    });
+});