json-rest-api 1.0.7 → 1.0.8

package/tests/field-getters.test.js

@@ -0,0 +1,353 @@
+import { describe, it, before, beforeEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import knexLib from 'knex';
+import { createFieldGettersApi } from './fixtures/api-configs.js';
+import { cleanTables } from './helpers/test-utils.js';
+
+// Create Knex instance for tests
+const knex = knexLib({
+  client: 'better-sqlite3',
+  connection: {
+    filename: ':memory:'
+  },
+  useNullAsDefault: true
+});
+
+// API instance that persists across tests
+let api;
+
+describe('Field Getters', () => {
+  before(async () => {
+    // Initialize API once
+    api = await createFieldGettersApi(knex);
+  });
+
+  after(async () => {
+    // Close database connection to allow tests to exit
+    await knex.destroy();
+  });
+
+  describe('Basic Field Transformations', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['getter_users']);
+    });
+
+    it('should apply simple getter transformations', async () => {
+      // Create user with data that needs transformation
+      const user = await api.resources.users.post({
+        email: '  USER@EXAMPLE.COM  ',
+        name: '  John Doe  ',
+        phone: '1234567890',
+        metadata_json: '{"key": "value", "num": 123}',
+        tags_csv: 'tag1, tag2, tag3'
+      });
+
+      // Check transformations applied on create
+      assert.equal(user.email, 'user@example.com');
+      assert.equal(user.name, 'John Doe');
+      assert.equal(user.phone, '(123) 456-7890');
+      assert.deepEqual(user.metadata_json, { key: 'value', num: 123 });
+      assert.deepEqual(user.tags_csv, ['tag1', 'tag2', 'tag3']);
+
+      // Verify getters apply on fetch too
+      const fetched = await api.resources.users.get({ id: user.id });
+      assert.equal(fetched.email, 'user@example.com');
+      assert.equal(fetched.name, 'John Doe');
+      assert.equal(fetched.phone, '(123) 456-7890');
+      assert.deepEqual(fetched.metadata_json, { key: 'value', num: 123 });
+      assert.deepEqual(fetched.tags_csv, ['tag1', 'tag2', 'tag3']);
+    });
+
+    it('should handle null and undefined values', async () => {
+      const user = await api.resources.users.post({
+        email: null,
+        name: undefined,
+        phone: null,
+        metadata_json: null,
+        tags_csv: null
+      });
+
+      assert.equal(user.email, undefined); // null?.toLowerCase().trim() returns undefined
+      assert.equal(user.name, undefined); // undefined is passed, getter returns undefined
+      assert.equal(user.phone, null); // getter explicitly returns null for falsy values
+      assert.deepEqual(user.metadata_json, {});
+      assert.deepEqual(user.tags_csv, []);
+    });
+
+    it('should handle invalid data gracefully', async () => {
+      const user = await api.resources.users.post({
+        email: '  mixed@CASE.com  ',
+        name: '   ',
+        phone: '123', // Too short
+        metadata_json: 'invalid json',
+        tags_csv: ', , empty, , values, '
+      });
+
+      assert.equal(user.email, 'mixed@case.com');
+      assert.equal(user.name, '');
+      assert.equal(user.phone, '123'); // Unchanged when can't format
+      assert.deepEqual(user.metadata_json, {}); // Empty object on parse error
+      assert.deepEqual(user.tags_csv, ['empty', 'values']); // Filters empty values
+    });
+  });
+
+  describe('Getters with Computed Fields', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['getter_products']);
+    });
+
+    it('should apply getters before computed fields', async () => {
+      const product = await api.resources.products.post({
+        name: 'widget',
+        description: 'This is a very long product description that should be truncated',
+        price_str: '100.00',
+        tax_rate_str: '0.20'
+      });
+
+      // Getters should transform values
+      assert.equal(product.name, 'WIDGET');
+      assert.equal(product.description, 'This is a very long product description that sh...');
+      assert.equal(typeof product.price_str, 'number');
+      assert.equal(product.price_str, 100);
+      assert.equal(product.tax_rate_str, 0.20);
+      
+      // Computed field should see getter-transformed values
+      assert.equal(product.total_price, 120);
+    });
+
+    it('should work with sparse fieldsets', async () => {
+      const product = await api.resources.products.post({
+        name: 'another widget',
+        description: 'Short desc',
+        price_str: '50.00',
+        tax_rate_str: '0.10'
+      });
+
+      // Fetch with sparse fieldsets
+      const sparse = await api.resources.products.get({
+        id: product.id,
+        queryParams: {
+          fields: { products: 'name,total_price' }
+        }
+      });
+
+      assert.equal(sparse.name, 'ANOTHER WIDGET');
+      assert.ok(Math.abs(sparse.total_price - 55) < 0.0001, `Expected total_price to be ~55, got ${sparse.total_price}`);
+      assert.equal(sparse.description, undefined);
+      assert.equal(sparse.price_str, undefined);
+    });
+  });
+
+  describe('Getter Dependencies', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['getter_formatted']);
+    });
+
+    it('should apply getters in dependency order', async () => {
+      const data = await api.resources.formatted_data.post({
+        step1: '  hello  ',
+        step2: 'world',
+        step3: 'end'
+      });
+
+      // Check that getters ran in order
+      assert.equal(data.step1, 'hello'); // Trimmed
+      assert.equal(data.step2, 'world [step1: hello]'); // Sees trimmed step1
+      assert.equal(data.step3, 'end [step2: world [step1: hello]]'); // Sees processed step2
+    });
+
+    it('should handle missing dependencies gracefully', async () => {
+      const data = await api.resources.formatted_data.post({
+        step3: 'only step3'
+        // step1 and step2 are missing
+      });
+
+      assert.equal(data.step1, undefined);
+      assert.equal(data.step2, null);
+      assert.equal(data.step3, 'only step3 [step2: null]');
+    });
+  });
+
+  describe('Async Getters', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['getter_encrypted']);
+    });
+
+    it('should support async getter functions', async () => {
+      // Helper to simulate encryption
+      const encrypt = (value) => Buffer.from(value).toString('base64');
+
+      // Store encrypted data directly in DB
+      const id = await knex('getter_encrypted').insert({
+        secret: encrypt('my-secret-value'),
+        data: encrypt('sensitive-info')
+      }).returning('id').then(r => r[0].id);
+
+      // Fetch should decrypt via async getters
+      const record = await api.resources.encrypted_data.get({ id });
+      assert.equal(record.secret, 'my-secret-value');
+      assert.equal(record.data, '[encrypted_data] sensitive-info');
+    });
+
+    it('should handle null values in async getters', async () => {
+      const record = await api.resources.encrypted_data.post({
+        secret: null,
+        data: null
+      });
+
+      assert.equal(record.secret, null);
+      assert.equal(record.data, null);
+    });
+  });
+
+  describe('Getters in Included Resources', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['getter_products', 'getter_reviews']);
+    });
+
+    it('should apply getters to included resources', async () => {
+      const product = await api.resources.products.post({
+        name: 'test product',
+        description: 'A product',
+        price_str: '99.99',
+        tax_rate_str: '0'
+      });
+
+      // Add reviews
+      await api.resources.reviews.post({
+        product_id: product.id,
+        content: 'Great product!',
+        rating: 5
+      });
+
+      await api.resources.reviews.post({
+        product_id: product.id,
+        content: 'Not bad',
+        rating: 3
+      });
+
+      // Fetch with includes
+      const result = await api.resources.products.get({
+        id: product.id,
+        queryParams: {
+          include: ['reviews']
+        }
+      });
+
+      // Product getters should apply
+      assert.equal(result.name, 'TEST PRODUCT');
+      
+      // Review getters should apply to included resources
+      assert.equal(result.reviews.length, 2);
+      assert.equal(result.reviews[0].content, '[REVIEW] Great product!');
+      assert.equal(result.reviews[1].content, '[REVIEW] Not bad');
+    });
+
+    it('should work with sparse fieldsets on included resources', async () => {
+      const product = await api.resources.products.post({
+        name: 'another product',
+        description: 'Description',
+        price_str: '10',
+        tax_rate_str: '0'
+      });
+
+      await api.resources.reviews.post({
+        product_id: product.id,
+        content: 'Review text',
+        rating: 4
+      });
+
+      const result = await api.resources.products.get({
+        id: product.id,
+        queryParams: {
+          include: ['reviews'],
+          fields: {
+            products: 'name',
+            reviews: 'content' // Only content, not rating
+          }
+        }
+      });
+
+      assert.equal(result.name, 'ANOTHER PRODUCT');
+      assert.equal(result.description, undefined);
+      
+      assert.equal(result.reviews.length, 1);
+      assert.equal(result.reviews[0].content, '[REVIEW] Review text');
+      assert.equal(result.reviews[0].rating, undefined);
+    });
+  });
+
+  describe('Getter Error Handling', () => {
+    it('should handle getter errors gracefully', async () => {
+      // Add a resource with a failing getter
+      await api.addResource('error_test', {
+        schema: {
+          id: { type: 'id' },
+          good_field: {
+            type: 'string',
+            getter: (value) => value?.toUpperCase()
+          },
+          bad_field: {
+            type: 'string',
+            getter: (value) => {
+              throw new Error('Getter failed!');
+            }
+          }
+        },
+        tableName: 'getter_errors'
+      });
+      await api.resources.error_test.createKnexTable();
+
+      const record = await api.resources.error_test.post({
+        good_field: 'hello',
+        bad_field: 'world'
+      });
+
+      // Good field should be transformed
+      assert.equal(record.good_field, 'HELLO');
+      // Bad field should keep original value (error logged but not thrown)
+      assert.equal(record.bad_field, 'world');
+
+      await cleanTables(knex, ['getter_errors']);
+    });
+  });
+
+  describe('Circular Dependencies', () => {
+    it('should detect circular getter dependencies', async () => {
+      await assert.rejects(
+        api.addResource('circular_test', {
+          schema: {
+            fieldA: {
+              type: 'string',
+              getter: (v) => v,
+              runGetterAfter: ['fieldB']
+            },
+            fieldB: {
+              type: 'string',
+              getter: (v) => v,
+              runGetterAfter: ['fieldA']
+            }
+          },
+          tableName: 'circular_test'
+        }),
+        /Circular dependency detected/
+      );
+    });
+
+    it('should detect unknown getter dependencies', async () => {
+      await assert.rejects(
+        api.addResource('unknown_test', {
+          schema: {
+            field1: {
+              type: 'string',
+              getter: (v) => v,
+              runGetterAfter: ['nonexistent']
+            }
+          },
+          tableName: 'unknown_test'
+        }),
+        /getter dependency 'nonexistent' that does not exist/
+      );
+    });
+  });
+});

package/tests/field-setters.test.js

@@ -0,0 +1,310 @@
+import { describe, it, before, beforeEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import knexLib from 'knex';
+import { createFieldSettersApi } from './fixtures/api-configs.js';
+import { cleanTables } from './helpers/test-utils.js';
+
+// Create Knex instance for tests
+const knex = knexLib({
+  client: 'better-sqlite3',
+  connection: {
+    filename: ':memory:'
+  },
+  useNullAsDefault: true
+});
+
+// API instance that persists across tests
+let api;
+
+describe('Field Setters', () => {
+  before(async () => {
+    // Initialize API once
+    api = await createFieldSettersApi(knex);
+  });
+
+  after(async () => {
+    // Close database connection to allow tests to exit
+    await knex.destroy();
+  });
+
+  describe('Basic Field Transformations', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['setter_users']);
+    });
+
+    it('should apply simple setter transformations on create', async () => {
+      // Create user with data that needs transformation
+      const user = await api.resources.users.post({
+        email: '  USER@EXAMPLE.COM  ',
+        username: '  JohnDoe  ',
+        tags: 'tag1,tag2,tag3',  // Pass as string
+        preferences: '{"theme":"dark","notifications":true}'  // Pass as JSON string
+      });
+
+      // Get the user to verify setters were applied
+      const fetchedUser = await api.resources.users.get({ id: user.id });
+      
+      // The setters transformed the data before storage
+      assert.equal(fetchedUser.email, 'user@example.com');
+      assert.equal(fetchedUser.username, 'johndoe');
+      assert.equal(fetchedUser.tags, 'tag1,tag2,tag3');
+      assert.equal(fetchedUser.preferences, '{"theme":"dark","notifications":true}');
+    });
+
+    it('should apply setter transformations on update (PUT)', async () => {
+      // Create initial user
+      const user = await api.resources.users.post({
+        email: 'original@example.com',
+        username: 'originaluser',
+        tags: 'old',
+        preferences: '{"theme":"light"}'
+      });
+
+      // Update with PUT
+      await api.resources.users.put({
+        id: user.id,
+        email: '  UPDATED@EXAMPLE.COM  ',
+        username: '  UpdatedUser  ',
+        tags: 'new1,new2',
+        preferences: '{"theme":"dark","lang":"en"}'
+      });
+
+      // Get the user to verify setters were applied
+      const updatedUser = await api.resources.users.get({ id: user.id });
+      assert.equal(updatedUser.email, 'updated@example.com');
+      assert.equal(updatedUser.username, 'updateduser');
+      assert.equal(updatedUser.tags, 'new1,new2');
+      assert.equal(updatedUser.preferences, '{"theme":"dark","lang":"en"}');
+    });
+
+    it('should apply setter transformations on partial update (PATCH)', async () => {
+      // Create initial user
+      const user = await api.resources.users.post({
+        email: 'original@example.com',
+        username: 'originaluser',
+        tags: 'old',
+        preferences: '{"theme":"light"}'
+      });
+
+      // Update only email with PATCH
+      await api.resources.users.patch({
+        id: user.id,
+        email: '  PATCHED@EXAMPLE.COM  '
+      });
+
+      // Get the user to verify setter was applied only to patched field
+      const patchedUser = await api.resources.users.get({ id: user.id });
+      assert.equal(patchedUser.email, 'patched@example.com');
+      assert.equal(patchedUser.username, 'originaluser'); // Unchanged
+    });
+  });
+
+  describe('Type Conversion Setters', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['setter_products']);
+    });
+
+    it('should apply type conversion setters after validation', async () => {
+      const product = await api.resources.products.post({
+        name: 'Test Product',
+        price: 99.999,  // Will be rounded to cents
+        discount_percent: 15.678,  // Will be rounded to integer
+        metadata: { key: 'value' }  // Will be stringified
+      });
+
+      // Get the product to verify setters were applied
+      const fetchedProduct = await api.resources.products.get({ id: product.id });
+      assert.equal(fetchedProduct.price, 10000); // 99.999 * 100 rounded = 10000 cents
+      assert.equal(fetchedProduct.discount_percent, 16); // 15.678 rounded
+      assert.equal(fetchedProduct.metadata, '{"key":"value"}');
+    });
+  });
+
+  describe('Async Setters', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['setter_secure']);
+    });
+
+    it('should support async setter functions', async () => {
+      const record = await api.resources.secure_data.post({
+        password: 'mysecretpassword',
+        api_key: 'test-key-123',
+        data: 'sensitive information'
+      });
+
+      console.log('**********************************************')
+      console.log(record)
+      // Check if record has id
+      assert.ok(record.id, 'Record should have an id');
+
+      // Get the record to verify async setters were applied
+      const fetchedRecord = await api.resources.secure_data.get({ id: record.id });
+      
+      // Password should be hashed (mock hash)
+      assert.equal(fetchedRecord.password, 'hashed:mysecretpassword');
+      
+      // API key should be encrypted (base64)
+      assert.equal(fetchedRecord.api_key, Buffer.from('test-key-123').toString('base64'));
+      
+      // Data should be encrypted
+      assert.equal(fetchedRecord.data, Buffer.from('sensitive information').toString('base64'));
+    });
+  });
+
+  describe('Setter Dependencies', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['setter_computed']);
+    });
+
+    it('should apply setters in dependency order', async () => {
+      const data = await api.resources.computed_data.post({
+        base_value: 100,
+        multiplier: 2,
+        adjustment: 10
+        // calculated_value depends on base_value and multiplier
+        // final_value depends on calculated_value and adjustment
+      });
+
+      const fetchedData = await api.resources.computed_data.get({ id: data.id });
+      assert.equal(fetchedData.base_value, 100);
+      assert.equal(fetchedData.multiplier, 2);
+      assert.equal(fetchedData.adjustment, 10);
+      assert.equal(fetchedData.calculated_value, 200); // 100 * 2
+      assert.equal(fetchedData.final_value, 210); // 200 + 10
+    });
+  });
+
+  describe('Error Handling', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['setter_users']);
+    });
+
+    it('should handle setter errors gracefully', async () => {
+      // Create a resource with a failing setter
+      await api.addResource('error_test', {
+        schema: {
+          id: { type: 'id' },
+          good_field: {
+            type: 'string',
+            setter: (value) => value?.toLowerCase()
+          },
+          bad_field: {
+            type: 'string',
+            setter: (value) => {
+              throw new Error('Setter failed!');
+            }
+          }
+        },
+        tableName: 'setter_errors'
+      });
+      await api.resources.error_test.createKnexTable();
+
+      const record = await api.resources.error_test.post({
+        good_field: 'HELLO',
+        bad_field: 'world'
+      });
+
+      const fetchedRecord = await api.resources.error_test.get({ id: record.id });
+      // Good field should be transformed
+      assert.equal(fetchedRecord.good_field, 'hello');
+      // Bad field should keep validated value (error logged but not thrown)
+      assert.equal(fetchedRecord.bad_field, 'world');
+
+      await cleanTables(knex, ['setter_errors']);
+    });
+  });
+
+  describe('Null and Undefined Handling', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['setter_nullable']);
+    });
+
+    it('should handle null and undefined values in setters', async () => {
+      const data = await api.resources.nullable_data.post({
+        field1: null,
+        field2: undefined,
+        field3: '',
+        field4: 0
+      });
+
+      const fetchedData = await api.resources.nullable_data.get({ id: data.id });
+      assert.equal(fetchedData.field1, null);
+      assert.equal(fetchedData.field2, null);
+      assert.equal(fetchedData.field3, 'empty'); // Empty string transformed
+      assert.equal(fetchedData.field4, -1); // Zero transformed
+    });
+  });
+
+  describe('Validation Before Setters', () => {
+    beforeEach(async () => {
+      await cleanTables(knex, ['setter_validated']);
+    });
+
+    it('should run setters only after successful validation', async () => {
+      // Try to create with invalid data
+      await assert.rejects(
+        api.resources.validated_data.post({
+          email: 'not-an-email',  // Should fail validation
+          age: 150  // Should fail max validation
+        }),
+        /Schema validation failed/
+      );
+
+      // No records should be created - verify with query
+      const records = await api.resources.validated_data.query();
+      assert.equal(records?.length || 0, 0);
+    });
+
+    it('should apply setters to validated type-cast data', async () => {
+      const data = await api.resources.validated_data.post({
+        email: '  VALID@EXAMPLE.COM  ',
+        age: '25',  // String will be cast to number
+        score: '98.7'  // String will be cast to number
+      });
+
+      const fetchedData = await api.resources.validated_data.get({ id: data.id });
+      assert.equal(fetchedData.email, 'valid@example.com');
+      assert.equal(fetchedData.age, 25); // Setter sees number, not string
+      assert.equal(fetchedData.score, 99); // Rounded up by setter
+    });
+  });
+
+  describe('Circular Dependencies', () => {
+    it('should detect circular setter dependencies', async () => {
+      await assert.rejects(
+        api.addResource('circular_setters', {
+          schema: {
+            fieldA: {
+              type: 'string',
+              setter: (v) => v,
+              runSetterAfter: ['fieldB']
+            },
+            fieldB: {
+              type: 'string',
+              setter: (v) => v,
+              runSetterAfter: ['fieldA']
+            }
+          },
+          tableName: 'circular_setters'
+        }),
+        /Circular dependency detected/
+      );
+    });
+
+    it('should detect unknown setter dependencies', async () => {
+      await assert.rejects(
+        api.addResource('unknown_deps', {
+          schema: {
+            field1: {
+              type: 'string',
+              setter: (v) => v,
+              runSetterAfter: ['nonexistent']
+            }
+          },
+          tableName: 'unknown_deps'
+        }),
+        /setter dependency 'nonexistent' that does not exist/
+      );
+    });
+  });
+});