fix: code

packages/agent/src/routes/access/chart.ts

@@ -238,10 +238,6 @@ export default class ChartRoute extends CollectionRoute {
         value: row.value as number,
       }));
     }
-
-    throw new ValidationError(
-      `Failed to generate leaderboard chart: parameters do not match pre-requisites`,
-    );
   }
 
   private async computeValue(context: Context, filter: Filter): Promise<number> {

packages/agent/src/utils/forest-schema/generator-fields.ts

@@ -111,11 +111,7 @@ export default class SchemaGeneratorFields {
 
     if (relation.type === 'OneToMany') {
       targetName = relation.originKeyTarget;
-      targetField = SchemaUtils.getColumn(
-        foreignCollection.schema,
-        targetName,
-        foreignCollection.name,
-      );
+      targetField = SchemaUtils.getColumn(collection.schema, targetName, collection.name);
 
       const originKey = SchemaUtils.getColumn(
         foreignCollection.schema,
@@ -178,7 +174,11 @@ export default class SchemaGeneratorFields {
       relation.originKeyTarget,
       collection.name,
     );
-    const keyField = SchemaUtils.getColumn(collection.schema, relation.originKey, collection.name);
+    const keyField = SchemaUtils.getColumn(
+      foreignCollection.schema,
+      relation.originKey,
+      foreignCollection.name,
+    );
 
     return {
       ...baseSchema,

packages/agent/src/utils/query-string.ts

@@ -66,7 +66,7 @@ export default class QueryStringParser {
 
       return new Projection(...explicitRequest);
     } catch (e) {
-      throw new ValidationError(`Invalid projection: ${e.message}}`);
+      throw new ValidationError(`Invalid projection: ${e.message}`);
     }
   }
 

packages/agent/test/routes/access/chart.test.ts

@@ -1,4 +1,8 @@
-import { ConditionTreeFactory, ValidationError } from '@forestadmin/datasource-toolkit';
+import {
+  ConditionTreeFactory,
+  MissingRelationError,
+  ValidationError,
+} from '@forestadmin/datasource-toolkit';
 import { createMockContext } from '@shopify/jest-koa-mocks';
 
 import Chart from '../../../src/routes/access/chart';
@@ -913,11 +917,7 @@ describe('ChartRoute', () => {
               ...defaultContext,
             });
 
-            await expect(chart.handleChart(context)).rejects.toThrow(
-              new ValidationError(
-                'Failed to generate leaderboard chart: parameters do not match pre-requisites',
-              ),
-            );
+            await expect(chart.handleChart(context)).rejects.toThrow(MissingRelationError);
           });
         });
       });

packages/agent/test/utils/query-string.test.ts

@@ -157,7 +157,7 @@ describe('QueryStringParser', () => {
             const fn = () => QueryStringParser.parseProjection(collectionSimple, context);
 
             expect(fn).toThrow(
-              "Invalid projection: field not found 'books.field-that-do-not-exist'",
+              "Invalid projection: The 'books.field-that-do-not-exist' field was not found. Available fields are: [id,name]. Please check if the field name is correct.",
             );
           });
         });

packages/datasource-customizer/src/decorators/binary/collection.ts

@@ -41,7 +41,11 @@ export default class BinaryCollectionDecorator extends CollectionDecorator {
   private useHexConversion: Map<string, boolean> = new Map();
 
   setBinaryMode(name: string, type: BinaryMode): void {
-    const field = SchemaUtils.getField(this.childCollection.schema, this.childCollection.name);
+    const field = SchemaUtils.getField(
+      this.childCollection.schema,
+      name,
+      this.childCollection.name,
+    );
 
     if (type !== 'datauri' && type !== 'hex') {
       throw new Error('Invalid binary mode');

packages/datasource-customizer/src/decorators/override/collection.ts

@@ -78,7 +78,8 @@ export default class OverrideCollectionDecorator extends CollectionDecorator {
     records.forEach(result => {
       let hasPrimaryKey = false;
       Object.keys(result).forEach(key => {
-        const field = SchemaUtils.getField(this.schema, key, this.name);
+        // don't use SchemaUtils.getField util because if the field does not exist, we remove it.
+        const field = this.schema.fields[key];
 
         if (!field || field.type !== 'Column') {
           delete result[key];

packages/datasource-customizer/src/decorators/write/write-replace/collection.ts

@@ -114,8 +114,6 @@ export default class WriteReplacerCollectionDecorator extends CollectionDecorato
 
       return { [key]: await relation.rewritePatch(caller, action, record[key]) };
     }
-
-    throw new Error(`Unknown field: "${key}"`);
   }
 
   /**

packages/datasource-customizer/test/context/wrapper.test.ts

@@ -5,6 +5,7 @@ import {
   ConditionTreeLeaf,
   DataSource,
   Filter,
+  MissingFieldError,
   Page,
   PaginatedFilter,
   Projection,
@@ -168,7 +169,7 @@ describe('RelaxedWrappers', () => {
     test('should validate patch operation before forwarding update', async () => {
       await expect(() =>
         relaxed.update({ segment: 'some_segment' }, { nonexistingField: 'newValue' }),
-      ).toThrow('Unknown field "nonexistingField"');
+      ).toThrow(MissingFieldError);
 
       expect(collection.update).not.toHaveBeenCalled();
     });

packages/datasource-customizer/test/decorators/override/collection.test.ts

@@ -137,7 +137,7 @@ describe('OverrideCollectionDecorator', () => {
 
       describe('when the handler does not return a primary key in each record', () => {
         it('should throw an error', async () => {
-          const handler = jest.fn().mockResolvedValue([{ id: 'valid' }, { noId: 1 }]);
+          const handler = jest.fn().mockResolvedValue([{ id: 'valid' }, { description: 1 }]);
 
           const currentCaller = factories.caller.build();
           const currentData = [factories.recordData.build()];

packages/datasource-customizer/test/decorators/relation/collection.test.ts

@@ -8,7 +8,6 @@ import {
   Filter,
   ManyToManySchema,
   MissingColumnError,
-  MissingFieldError,
   PaginatedFilter,
   Projection,
   Sort,
@@ -284,7 +283,7 @@ describe('RelationCollectionDecorator', () => {
             foreignCollection: 'persons',
             foreignKey: '__nonExisting__',
           }),
-        ).toThrow(MissingFieldError);
+        ).toThrow(MissingColumnError);
       });
     });
 
@@ -352,7 +351,7 @@ describe('RelationCollectionDecorator', () => {
             originKey: '__nonExisting__',
             throughCollection: 'passports',
           } as ManyToManySchema),
-        ).toThrow(MissingFieldError);
+        ).toThrow(MissingColumnError);
       });
 
       test('should throw with a non existent fk', () => {
@@ -364,7 +363,7 @@ describe('RelationCollectionDecorator', () => {
             originKey: 'ownerId',
             throughCollection: 'passports',
           } as ManyToManySchema),
-        ).toThrow(MissingFieldError);
+        ).toThrow(MissingColumnError);
       });
     });
 

packages/datasource-customizer/test/decorators/write/write-replace/collection_simple-creations.test.ts

@@ -1,4 +1,4 @@
-import { Collection } from '@forestadmin/datasource-toolkit';
+import { Collection, MissingFieldError } from '@forestadmin/datasource-toolkit';
 import * as factories from '@forestadmin/datasource-toolkit/dist/test/__factories__';
 
 import WriteDataSourceDecorator from '../../../../src/decorators/write/datasource';
@@ -160,17 +160,13 @@ describe('WriteDecorator > Create with no relations', () => {
     test('when the handler returns non existent fields', async () => {
       decorator.replaceFieldWriting('age', () => ({ author: 'Asimov' }));
 
-      await expect(decorator.create(caller, [{ age: '10' }])).rejects.toThrow(
-        'Unknown field: "author"',
-      );
+      await expect(decorator.create(caller, [{ age: '10' }])).rejects.toThrow(MissingFieldError);
     });
 
     test('when the handler returns non existent relations', async () => {
       decorator.replaceFieldWriting('age', () => ({ author: { lastname: 'Asimov' } }));
 
-      await expect(decorator.create(caller, [{ age: '10' }])).rejects.toThrow(
-        'Unknown field: "author"',
-      );
+      await expect(decorator.create(caller, [{ age: '10' }])).rejects.toThrow(MissingFieldError);
     });
 
     test('if the customer attemps to update the patch in the handler', async () => {

packages/datasource-customizer/test/decorators/write/write-replace/collection_simple-updates.test.ts

@@ -1,4 +1,4 @@
-import { Collection } from '@forestadmin/datasource-toolkit';
+import { Collection, MissingFieldError } from '@forestadmin/datasource-toolkit';
 import * as factories from '@forestadmin/datasource-toolkit/dist/test/__factories__';
 
 import WriteReplacerCollectionDecorator from '../../../../src/decorators/write/write-replace/collection';
@@ -155,15 +155,15 @@ describe('WriteDecorator > Simple structure', () => {
     decorator.replaceFieldWriting('age', () => ({ author: 'Asimov' }));
 
     await expect(decorator.update(caller, filter, { age: '10' })).rejects.toThrow(
-      'Unknown field: "author"',
+      MissingFieldError,
     );
   });
 
   test('should throw when the handler returns non existent relations', async () => {
     decorator.replaceFieldWriting('age', () => ({ author: { lastname: 'Asimov' } }));
 
     await expect(decorator.update(caller, filter, { age: '10' })).rejects.toThrow(
-      'Unknown field: "author"',
+      MissingFieldError,
     );
   });
 

packages/datasource-toolkit/src/interfaces/query/projection/factory.ts

@@ -29,10 +29,6 @@ export default class ProjectionFactory {
   }
 
   static columns(collection: Collection): Projection {
-    return new Projection(
-      ...Object.keys(collection.schema.fields).filter(
-        f => SchemaUtils.getColumn(collection.schema, f, collection.name).type === 'Column',
-      ),
-    );
+    return new Projection(...SchemaUtils.getColumnNames(collection.schema));
   }
 }

packages/datasource-toolkit/src/utils/schema.ts

@@ -20,6 +20,8 @@ export default class SchemaUtils {
     fieldName: string,
     collectionName?: string,
   ): void {
+    SchemaUtils.throwIfAccessingFieldFromRelation(fieldName, collectionName);
+
     if (schema.fields[fieldName]) {
       throw new AlreadyDefinedFieldError({ fieldName, collectionName });
     }
@@ -58,9 +60,7 @@ export default class SchemaUtils {
   ): ColumnSchema {
     SchemaUtils.throwIfAccessingFieldFromRelation(fieldName, collectionName);
 
-    const columns = Object.keys(schema.fields).filter(
-      name => schema.fields[name].type === 'Column',
-    );
+    const columns = SchemaUtils.getColumnNames(schema);
 
     if (!columns.find(name => name === fieldName)) {
       throw new MissingColumnError({ fieldName, availableFields: columns, collectionName });
@@ -128,6 +128,12 @@ export default class SchemaUtils {
     return relationFieldSchema as ManyToManySchema | OneToManySchema;
   }
 
+  static getColumnNames(schema: CollectionSchema): string[] {
+    return Object.keys(schema.fields).filter(
+      name => SchemaUtils.getField(schema, name).type === 'Column',
+    );
+  }
+
   private static throwIfAccessingFieldFromRelation(
     fieldName: string,
     collectionName?: string,

packages/datasource-toolkit/src/validation/field.ts

@@ -1,6 +1,7 @@
 import { MAP_ALLOWED_TYPES_FOR_COLUMN_TYPE } from './rules';
 import TypeGetter from './type-getter';
-import { MissingFieldError, MissingRelationError, ValidationError } from '../errors';
+import { MissingRelationError, ValidationError } from '../errors';
+import { SchemaUtils } from '../index';
 import { Collection } from '../interfaces/collection';
 import { ColumnSchema, PrimitiveTypes } from '../interfaces/schema';
 
@@ -9,15 +10,7 @@ export default class FieldValidator {
     const dotIndex = field.indexOf(':');
 
     if (dotIndex === -1) {
-      const schema = collection.schema.fields[field];
-
-      if (!schema) {
-        throw new MissingFieldError({
-          collectionName: collection.name,
-          fieldName: field,
-          availableFields: Object.keys(collection.schema.fields),
-        });
-      }
+      const schema = SchemaUtils.getField(collection.schema, field, collection.name);
 
       if (schema.type !== 'Column') {
         throw new ValidationError(