@nextplus/js-sdk 0.0.9 → 0.0.11

package/src/smoke.ts

@@ -1,83 +1,594 @@
-import { configure } from './index';
-
-async function main() {
-  console.log('=== Testing with email and returnType: data ===');
-  const sdk = configure({
-    baseURL: 'http://127.0.0.1:3000/api',
-    email: 'operator@operator.com',
-    password: 'operator@operator.com',
-    returnType: 'data', // Only return data, not full response
-  });
+// @ts-ignore - Node test runner types may not be available
+import { test, describe } from 'node:test';
+// @ts-ignore - Node assert types may not be available
+import assert from 'node:assert/strict';
+import { configure, TableService, UserModelService } from './index';
+
+const BASE_URL = 'http://127.0.0.1:3000/api';
+const TEST_EMAIL = 'operator@operator.com';
+const TEST_USERNAME = 'operator';
+const TEST_PASSWORD = 'operator@operator.com';
+
+describe('NextPlus SDK', () => {
+  describe('Credential-Based Authentication', () => {
+    test('should configure with email and returnType: data', async () => {
+      const sdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+        returnType: 'data',
+      });
+
+      const tables = await sdk.TableService.find({
+        query: {
+          filter: JSON.stringify({
+            limit: 10,
+            order: 'created DESC',
+            fields: {
+              id: true,
+              name: true,
+              created: true,
+            },
+            where: {
+              name: 'no-such-table!',
+            },
+          }),
+        },
+      });
+
+      assert.ok(Array.isArray(tables), 'Response should be an array');
+    });
+
+    test('should handle validation errors with email auth', async () => {
+      const sdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+        returnType: 'data',
+      });
+
+      await assert.rejects(
+        async () => {
+          await sdk.TableService.create({ body: {} } as any);
+        },
+        (error: any) => {
+          assert.ok(error.message, 'Error should have a message');
+          return true;
+        },
+        'Should throw validation error',
+      );
+    });
+
+    test('should configure with username and returnType: raw', async () => {
+      const sdk = configure({
+        baseURL: BASE_URL,
+        username: TEST_USERNAME,
+        password: TEST_PASSWORD,
+        returnType: 'raw',
+      });
+
+      const tablesRaw = await sdk.TableService.find({
+        query: {
+          filter: JSON.stringify({
+            where: {
+              name: 'test',
+            },
+            limit: 5,
+          }),
+        },
+      });
 
-  console.log('SDK configured (email)');
-
-  // Test with returnType: 'data' - should return only the data array
-  const tables = await sdk.TableService.find({
-    query: {
-      filter: JSON.stringify({
-        language: 'he',
-        limit: 10,
-        order: 'created DESC',
-        fields: {
-          id: true,
-          name: true,
-          created: true
-        },
-        where: {
-          name: 'no-such-table!'
-        }
-      })
-    }
+      assert.ok('data' in tablesRaw, 'Response should have data property');
+      assert.ok(
+        'request' in tablesRaw,
+        'Response should have request property',
+      );
+      assert.ok(
+        'response' in tablesRaw,
+        'Response should have response property',
+      );
+      assert.ok(Array.isArray(tablesRaw.data), 'Data should be an array');
+    });
+
+    test('should handle validation errors with username auth (raw mode)', async () => {
+      const sdk = configure({
+        baseURL: BASE_URL,
+        username: TEST_USERNAME,
+        password: TEST_PASSWORD,
+        returnType: 'raw',
+      });
+
+      // In raw mode, errors are returned in the response object, not thrown
+      const response = await sdk.TableService.create({ body: {} } as any);
+      assert.ok('error' in response, 'Response should have error property');
+      assert.ok(response.error, 'Error should be present');
+    });
   });
 
-  console.log(
-    'Tables found (data only):',
-    Array.isArray(tables) ? `Array with ${tables.length} items` : tables,
-  );
-  // Test validation error handling
-  try {
-    const newTable = await sdk.TableService.create({ body: {} } as any);
-    console.log('New table created:', newTable);
-  } catch (error: any) {
-    console.log('Expected validation error caught:', error.message);
-  }
-
-
-  console.log('\n=== Testing with username and returnType: raw ===');
-  const sdk2 = configure({
-    baseURL: 'http://127.0.0.1:3000/api',
-    username: 'operator', // Using username instead of email
-    password: 'operator@operator.com',
-    returnType: 'raw', // Return full response object
+  describe('Token-Based Authentication', () => {
+    let accessToken: string;
+
+    test('should obtain access token via login', async () => {
+      const loginSdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+        returnType: 'raw',
+      });
+
+      // Manually login to get the token
+      const loginResponse = await UserModelService.login({
+        client: loginSdk.client,
+        body: {
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          forceLogin: true,
+        },
+      });
+
+      accessToken = (loginResponse.data as any)?.id;
+      assert.ok(accessToken, 'Should receive access token');
+      assert.ok(
+        typeof accessToken === 'string',
+        'Access token should be a string',
+      );
+    });
+
+    test('should configure and make requests with access token', async () => {
+      // Get token first using credential-based SDK
+      const loginSdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
+
+      const loginResponse = await UserModelService.login({
+        client: loginSdk.client,
+        body: {
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          forceLogin: true,
+        },
+      });
+
+      const token = (loginResponse.data as any)?.id;
+      assert.ok(token, 'Should receive access token');
+
+      // Use token
+      const tokenSdk = configure({
+        baseURL: BASE_URL,
+        accessToken: token,
+        returnType: 'data',
+      });
+
+      const tables = await tokenSdk.TableService.find({
+        query: {
+          filter: JSON.stringify({
+            limit: 5,
+            fields: {
+              name: true,
+            },
+          }),
+        },
+      });
+
+      assert.ok(Array.isArray(tables), 'Response should be an array');
+    });
   });
 
-  console.log('SDK configured (username)');
+  describe('Tree-Shakeable Service Imports', () => {
+    test('should throw errors with throwOnError: true', async () => {
+      // Get token first
+      const loginSdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
+
+      const loginResponse = await UserModelService.login({
+        client: loginSdk.client,
+        body: {
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          forceLogin: true,
+        },
+      });
+
+      const token = (loginResponse.data as any)?.id;
+      assert.ok(token, 'Should receive access token');
+
+      // Configure with throwOnError: true
+      configure({
+        baseURL: BASE_URL,
+        accessToken: token,
+        throwOnError: true,
+      });
+
+      // Should throw on validation error
+      await assert.rejects(
+        async () => {
+          await TableService.create({ body: {} } as any);
+        },
+        (error: any) => {
+          assert.ok(error, 'Should throw error');
+          return true;
+        },
+        'Should throw error for invalid request',
+      );
+    });
+
+    test('should work with global default client (no client parameter at all)', async () => {
+      // Get token first
+      const loginSdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
+
+      const loginResponse = await UserModelService.login({
+        client: loginSdk.client,
+        body: {
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          forceLogin: true,
+        },
+      });
+
+      const token = (loginResponse.data as any)?.id;
+      assert.ok(token, 'Should receive access token');
+
+      // configure() automatically sets global default client!
+      configure({
+        baseURL: BASE_URL,
+        accessToken: token,
+      });
+
+      // Use TableService without any client parameter at all!
+      const response = await TableService.find({
+        query: {
+          filter: JSON.stringify({
+            limit: 5,
+            fields: {
+              name: true,
+            },
+          }),
+        },
+      });
+
+      assert.ok('data' in response, 'Response should have data');
+      assert.ok(
+        Array.isArray(response.data),
+        'Response data should be an array',
+      );
+
+      // Make another call - still no client needed
+      const response2 = await TableService.find({
+        query: {
+          filter: JSON.stringify({
+            limit: 1,
+          }),
+        },
+      });
+
+      assert.ok('data' in response2, 'Second call should also work');
+      assert.ok(response2.data, 'Second call should have data');
+    });
+
+    test('should work with token auth and imported TableService only', async () => {
+      // Get token first
+      const loginSdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
 
-  // Test with returnType: 'raw' - should return { data, request, response }
-  const tablesRaw = await sdk2.TableService.find({
-    query: {
-      filter: JSON.stringify({
-        where: {
-          name: 'test'
+      const loginResponse = await UserModelService.login({
+        client: loginSdk.client,
+        body: {
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          forceLogin: true,
         },
-        limit: 5
-      })
-    }
+      });
+
+      const token = (loginResponse.data as any)?.id;
+      assert.ok(token, 'Should receive access token');
+
+      // Configure with token only
+      const sdk = configure({
+        baseURL: BASE_URL,
+        accessToken: token,
+      });
+
+      // Import and use TableService directly - tree-shakeable!
+      // This means UserModelService and other services won't be in the bundle
+      const response = await TableService.find({
+        client: sdk.client,
+        query: {
+          filter: JSON.stringify({
+            limit: 5,
+            fields: {
+              name: true,
+            },
+          }),
+        },
+      });
+
+      assert.ok('data' in response, 'Response should have data');
+      assert.ok(response.data, 'Response data should exist');
+      assert.ok(
+        Array.isArray(response.data),
+        'Response data should be an array',
+      );
+      if (response.data) {
+        assert.ok(response.data.length <= 5, 'Should respect limit');
+      }
+    });
+
+    test('should work with sdk.service() helper (no client parameter needed)', async () => {
+      // Get token first
+      const loginSdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
+
+      const loginResponse = await UserModelService.login({
+        client: loginSdk.client,
+        body: {
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          forceLogin: true,
+        },
+      });
+
+      const token = (loginResponse.data as any)?.id;
+      assert.ok(token, 'Should receive access token');
+
+      // Use configure() and bind services
+      const sdk = configure({
+        baseURL: BASE_URL,
+        accessToken: token,
+      });
+
+      // Bind the service - no need to pass client on every call!
+      const Tables = sdk.service(TableService);
+
+      const tablesResponse = await Tables.find({
+        query: {
+          filter: JSON.stringify({
+            limit: 3,
+            fields: {
+              name: true,
+            },
+          }),
+        },
+      });
+
+      // When using bound services, response is in raw format
+      assert.ok('data' in tablesResponse, 'Response should have data');
+      assert.ok(
+        Array.isArray(tablesResponse.data),
+        'Response data should be an array',
+      );
+    });
+
+    test('should work with sdk.client for manual control', async () => {
+      // Get token first
+      const loginSdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
+
+      const loginResponse = await UserModelService.login({
+        client: loginSdk.client,
+        body: {
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          forceLogin: true,
+        },
+      });
+
+      const token = (loginResponse.data as any)?.id;
+      assert.ok(token, 'Should receive access token');
+
+      // Use configure() and access the client for tree-shakeable imports
+      const sdk = configure({
+        baseURL: BASE_URL,
+        accessToken: token,
+      });
+
+      const tablesWithClient = await TableService.find({
+        client: sdk.client,
+        query: {
+          filter: JSON.stringify({
+            limit: 3,
+            fields: {
+              name: true,
+            },
+          }),
+        },
+      });
+
+      // When using sdk.client with individual service imports,
+      // the response is in raw format (not affected by returnType)
+      assert.ok('data' in tablesWithClient, 'Response should have data');
+      assert.ok(
+        Array.isArray(tablesWithClient.data),
+        'Response data should be an array',
+      );
+    });
   });
 
-  console.log('Tables found (raw response):', {
-    hasData: 'data' in tablesRaw,
-    hasRequest: 'request' in tablesRaw,
-    hasResponse: 'response' in tablesRaw,
-    dataLength: tablesRaw.data ? tablesRaw.data.length : 'no data',
+  describe('Interceptors', () => {
+    test('should allow adding request interceptors with tree-shakeable imports', async () => {
+      const sdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
+
+      // Track if interceptor was called
+      let interceptorCalled = false;
+      let requestUrl = '';
+
+      sdk.client.interceptors.request.use((request: Request) => {
+        interceptorCalled = true;
+        requestUrl = request.url;
+        return request;
+      });
+
+      // Use with full SDK
+      await sdk.TableService.find({
+        query: {
+          filter: JSON.stringify({ limit: 1 }),
+        },
+      });
+
+      assert.ok(interceptorCalled, 'Request interceptor should be called');
+      assert.ok(
+        requestUrl.includes('/Tables'),
+        'Request URL should be captured',
+      );
+    });
+
+    test('should allow adding response interceptors', async () => {
+      const sdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
+
+      let responseInterceptorCalled = false;
+      let responseStatus = 0;
+
+      sdk.client.interceptors.response.use((response: Response) => {
+        responseInterceptorCalled = true;
+        responseStatus = response.status;
+        return response;
+      });
+
+      await sdk.TableService.find({
+        query: {
+          filter: JSON.stringify({ limit: 1 }),
+        },
+      });
+
+      assert.ok(
+        responseInterceptorCalled,
+        'Response interceptor should be called',
+      );
+      assert.strictEqual(responseStatus, 200, 'Response status should be 200');
+    });
+
+    test('should work with bound services (sdk.service)', async () => {
+      const sdk = configure({
+        baseURL: BASE_URL,
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+      });
+
+      let interceptorCount = 0;
+
+      sdk.client.interceptors.request.use((request: Request) => {
+        interceptorCount++;
+        return request;
+      });
+
+      // Bind service
+      const Tables = sdk.service(TableService);
+
+      // Make request with bound service
+      await Tables.find({
+        query: {
+          filter: JSON.stringify({ limit: 1 }),
+        },
+      });
+
+      assert.ok(
+        interceptorCount > 0,
+        'Interceptor should work with bound services',
+      );
+    });
   });
 
-  try {
-    const createTable = await sdk2.TableService.create({ body: {} } as any);
-    console.log('Table created:', createTable);
-  } catch (error: any) {
-    console.log('Expected validation error caught (raw mode):', error.message);
-  }
-}
+  describe('Configuration Validation', () => {
+    test('should throw error when both token and credentials provided', () => {
+      assert.throws(
+        () => {
+          configure({
+            baseURL: BASE_URL,
+            accessToken: 'token',
+            email: 'test@test.com',
+            password: 'password',
+          } as any);
+        },
+        (error: any) => {
+          assert.ok(
+            error.message.includes('either accessToken or credentials'),
+            'Error message should mention mutual exclusivity',
+          );
+          return true;
+        },
+        'Should throw error for both token and credentials',
+      );
+    });
+
+    test('should throw error when neither token nor credentials provided', () => {
+      assert.throws(
+        () => {
+          configure({
+            baseURL: BASE_URL,
+            returnType: 'data',
+          } as any);
+        },
+        (error: any) => {
+          assert.ok(
+            error.message.includes('Either accessToken or credentials'),
+            'Error message should mention missing auth',
+          );
+          return true;
+        },
+        'Should throw error for missing authentication',
+      );
+    });
+
+    test('should throw error when password provided without email or username', () => {
+      assert.throws(
+        () => {
+          configure({
+            baseURL: BASE_URL,
+            password: 'password',
+          } as any);
+        },
+        (error: any) => {
+          assert.ok(error.message, 'Should have error message');
+          return true;
+        },
+        'Should throw error for password without email/username',
+      );
+    });
 
-main().catch(console.error);
+    test('should throw error when both email and username provided', () => {
+      assert.throws(
+        () => {
+          configure({
+            baseURL: BASE_URL,
+            email: 'test@test.com',
+            username: 'testuser',
+            password: 'password',
+          } as any);
+        },
+        (error: any) => {
+          assert.ok(
+            error.message.includes('either email or username'),
+            'Error message should mention mutual exclusivity',
+          );
+          return true;
+        },
+        'Should throw error for both email and username',
+      );
+    });
+  });
+});