@nextplus/js-sdk 0.0.12 → 1.14.47

package/src/smoke.ts

@@ -1,594 +1,83 @@
-// @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,
-          }),
-        },
-      });
-
-      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');
-    });
+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
   });
 
-  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 (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!'
+        }
+      })
+    }
   });
 
-  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,
-      });
-
-      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 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 (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('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);
+  console.log('SDK configured (username)');
 
-      // Make request with bound service
-      await Tables.find({
-        query: {
-          filter: JSON.stringify({ limit: 1 }),
+  // Test with returnType: 'raw' - should return { data, request, response }
+  const tablesRaw = await sdk2.TableService.find({
+    query: {
+      filter: JSON.stringify({
+        where: {
+          name: 'test'
         },
-      });
-
-      assert.ok(
-        interceptorCount > 0,
-        'Interceptor should work with bound services',
-      );
-    });
+        limit: 5
+      })
+    }
   });
 
-  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',
-      );
-    });
+  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',
+  });
 
-    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',
-      );
-    });
+  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);
+  }
+}
 
-    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',
-      );
-    });
-  });
-});
+main().catch(console.error);