@forestadmin/agent 1.0.0-alpha.1

package/dist/utils/forest-schema/generator-actions.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const path_1 = __importDefault(require("path"));
+const action_values_1 = __importDefault(require("./action-values"));
+class SchemaGeneratorActions {
+    static async buildSchema(collection, name) {
+        const schema = collection.schema.actions[name];
+        const actionIndex = Object.keys(collection.schema.actions).indexOf(name);
+        // Generate url-safe friendly name (which won't be unique, but that's OK).
+        const slug = name.toLocaleLowerCase().replace(/[^a-z0-9-]+/g, '-');
+        const fields = await SchemaGeneratorActions.buildFields(collection, name, schema);
+        return {
+            id: `${collection.name}-${actionIndex}-${slug}`,
+            name,
+            type: schema.scope.toLowerCase(),
+            baseUrl: null,
+            endpoint: path_1.default.posix.join('/forest/_actions', collection.name, String(actionIndex), slug),
+            httpMethod: 'POST',
+            redirect: null,
+            download: Boolean(schema.generateFile),
+            fields,
+            hooks: {
+                load: !schema.staticForm,
+                // Always registering the change hook has no consequences, even if we don't use it.
+                change: ['changeHook'],
+            },
+        };
+    }
+    /** Build schema for given field */
+    static buildFieldSchema(dataSource, field) {
+        const { label, description, isRequired, isReadOnly, watchChanges, type } = field;
+        const output = { description, isRequired, isReadOnly };
+        output.field = label;
+        output.value = action_values_1.default.valueToForest(field, field.value);
+        if (watchChanges)
+            output.hook = 'changeHook';
+        if (type === 'Collection') {
+            const collection = dataSource.getCollection(field.collectionName);
+            const [pk] = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(collection.schema);
+            const pkSchema = collection.schema.fields[pk];
+            output.type = pkSchema.columnType;
+            output.reference = `${collection.name}.${pk}`;
+        }
+        else if (type.endsWith('List')) {
+            output.type = [type.substring(0, type.length - 4)];
+        }
+        else {
+            output.type = type;
+        }
+        if (type === 'Enum' || type === 'EnumList') {
+            output.enums = field.enumValues;
+        }
+        return output;
+    }
+    static async buildFields(collection, name, schema) {
+        // We want the schema to be generated on usage => send dummy schema
+        if (!schema.staticForm) {
+            return SchemaGeneratorActions.defaultFields;
+        }
+        // Ask the action to generate a form
+        const fields = await collection.getForm(null, name);
+        if (fields) {
+            // When sending to server, we need to rename 'value' into 'defaultValue'
+            // otherwise, it does not gets applied 🤷‍♂️
+            return fields.map(field => {
+                const newField = SchemaGeneratorActions.buildFieldSchema(collection.dataSource, field);
+                newField.defaultValue = newField.value;
+                delete newField.value;
+                return newField;
+            });
+        }
+        return [];
+    }
+}
+exports.default = SchemaGeneratorActions;
+/**
+ * 'fields' sent to forestadmin-server when we want to generate the form on demand.
+ * This works around a bug in frontend which won't call the server if no fields are defined.
+ */
+SchemaGeneratorActions.defaultFields = [
+    {
+        field: 'Loading...',
+        type: 'String',
+        isReadOnly: true,
+        defaultValue: 'Form is loading',
+        value: undefined,
+        description: '',
+        enums: null,
+        hook: null,
+        isRequired: false,
+        reference: null,
+        widget: null,
+    },
+];
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/forest-schema/generator-collection.d.ts

@@ -0,0 +1,7 @@
+import { Collection } from '@forestadmin/datasource-toolkit';
+import { ForestServerCollection } from './types';
+export default class SchemaGeneratorCollection {
+    /** Build forest-server schema for a collection */
+    static buildSchema(collection: Collection): Promise<ForestServerCollection>;
+}
+//# sourceMappingURL=generator-collection.d.ts.map

package/dist/utils/forest-schema/generator-collection.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const generator_actions_1 = __importDefault(require("./generator-actions"));
+const generator_fields_1 = __importDefault(require("./generator-fields"));
+const generator_segments_1 = __importDefault(require("./generator-segments"));
+class SchemaGeneratorCollection {
+    /** Build forest-server schema for a collection */
+    static async buildSchema(collection) {
+        return {
+            actions: await Promise.all(Object.keys(collection.schema.actions)
+                .sort()
+                .map(name => generator_actions_1.default.buildSchema(collection, name))),
+            fields: Object.keys(collection.schema.fields)
+                .filter(name => !datasource_toolkit_1.SchemaUtils.isForeignKey(collection.schema, name))
+                .sort()
+                .map(name => generator_fields_1.default.buildSchema(collection, name)),
+            icon: null,
+            integration: null,
+            isReadOnly: Object.values(collection.schema.fields).every(field => field.type === 'Column' && field.isReadOnly),
+            isSearchable: collection.schema.searchable,
+            isVirtual: false,
+            name: collection.name,
+            onlyForRelationships: false,
+            paginationType: 'page',
+            segments: collection.schema.segments
+                .sort()
+                .map(name => generator_segments_1.default.buildSchema(collection, name)),
+        };
+    }
+}
+exports.default = SchemaGeneratorCollection;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdG9yLWNvbGxlY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvZm9yZXN0LXNjaGVtYS9nZW5lcmF0b3ItY29sbGVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHdFQUEwRTtBQUUxRSw0RUFBeUQ7QUFDekQsMEVBQXVEO0FBQ3ZELDhFQUEyRDtBQUUzRCxNQUFxQix5QkFBeUI7SUFDNUMsa0RBQWtEO0lBQ2xELE1BQU0sQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLFVBQXNCO1FBQzdDLE9BQU87WUFDTCxPQUFPLEVBQUUsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUN4QixNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDO2lCQUNuQyxJQUFJLEVBQUU7aUJBQ04sR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsMkJBQXNCLENBQUMsV0FBVyxDQUFDLFVBQVUsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUNyRTtZQUNELE1BQU0sRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDO2lCQUMxQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDLGdDQUFXLENBQUMsWUFBWSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7aUJBQ2xFLElBQUksRUFBRTtpQkFDTixHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQywwQkFBcUIsQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQ25FLElBQUksRUFBRSxJQUFJO1lBQ1YsV0FBVyxFQUFFLElBQUk7WUFDakIsVUFBVSxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLENBQ3ZELEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxRQUFRLElBQUksS0FBSyxDQUFDLFVBQVUsQ0FDckQ7WUFDRCxZQUFZLEVBQUUsVUFBVSxDQUFDLE1BQU0sQ0FBQyxVQUFVO1lBQzFDLFNBQVMsRUFBRSxLQUFLO1lBQ2hCLElBQUksRUFBRSxVQUFVLENBQUMsSUFBSTtZQUNyQixvQkFBb0IsRUFBRSxLQUFLO1lBQzNCLGNBQWMsRUFBRSxNQUFNO1lBQ3RCLFFBQVEsRUFBRSxVQUFVLENBQUMsTUFBTSxDQUFDLFFBQVE7aUJBQ2pDLElBQUksRUFBRTtpQkFDTixHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyw0QkFBdUIsQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxDQUFDO1NBQ3RFLENBQUM7SUFDSixDQUFDO0NBQ0Y7QUE1QkQsNENBNEJDIn0=

package/dist/utils/forest-schema/generator-fields.d.ts

@@ -0,0 +1,14 @@
+import { Collection } from '@forestadmin/datasource-toolkit';
+import { ForestServerField } from './types';
+export default class SchemaGeneratorFields {
+    private static relationMap;
+    static buildSchema(collection: Collection, name: string): ForestServerField;
+    private static buildColumnSchema;
+    private static convertColumnType;
+    private static buildToManyRelationSchema;
+    private static isForeignCollectionFilterable;
+    private static buildOneToOneSchema;
+    private static buildManyToOneSchema;
+    private static buildRelationSchema;
+}
+//# sourceMappingURL=generator-fields.d.ts.map

package/dist/utils/forest-schema/generator-fields.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const filterable_1 = __importDefault(require("./filterable"));
+const validation_1 = __importDefault(require("./validation"));
+class SchemaGeneratorFields {
+    static buildSchema(collection, name) {
+        const { type } = collection.schema.fields[name];
+        let schema;
+        switch (type) {
+            case 'Column':
+                schema = SchemaGeneratorFields.buildColumnSchema(collection, name);
+                break;
+            case 'ManyToOne':
+            case 'OneToMany':
+            case 'ManyToMany':
+            case 'OneToOne':
+                schema = SchemaGeneratorFields.buildRelationSchema(collection, name);
+                break;
+            default:
+                throw new Error('Invalid field type');
+        }
+        return Object.entries(schema)
+            .sort()
+            .reduce((sortedSchema, [key, value]) => {
+            sortedSchema[key] = value;
+            return sortedSchema;
+        }, {});
+    }
+    static buildColumnSchema(collection, name) {
+        const column = collection.schema.fields[name];
+        return {
+            defaultValue: column.defaultValue ?? null,
+            enums: column.enumValues ?? null,
+            field: name,
+            integration: null,
+            inverseOf: null,
+            isFilterable: filterable_1.default.isFilterable(column.columnType, column.filterOperators),
+            isPrimaryKey: Boolean(column.isPrimaryKey),
+            isReadOnly: Boolean(column.isReadOnly),
+            isRequired: column.validation?.some(v => v.operator === 'Present') ?? false,
+            isSortable: Boolean(column.isSortable),
+            isVirtual: false,
+            reference: null,
+            type: this.convertColumnType(column.columnType),
+            validations: validation_1.default.convertValidationList(column.validation),
+        };
+    }
+    static convertColumnType(type) {
+        if (typeof type === 'string')
+            return type;
+        if (Array.isArray(type)) {
+            return [this.convertColumnType(type[0])];
+        }
+        return {
+            fields: Object.entries(type).map(([key, subType]) => ({
+                field: key,
+                type: this.convertColumnType(subType),
+            })),
+        };
+    }
+    static buildToManyRelationSchema(relation, collection, foreignCollection, baseSchema) {
+        let targetName;
+        let targetField;
+        let isReadOnly;
+        if (relation.type === 'OneToMany') {
+            targetName = relation.originKeyTarget;
+            targetField = collection.schema.fields[targetName];
+            const originKey = foreignCollection.schema.fields[relation.originKey];
+            isReadOnly = originKey.isReadOnly;
+        }
+        else {
+            targetName = relation.foreignKeyTarget;
+            targetField = foreignCollection.schema.fields[targetName];
+            const throughSchema = collection.dataSource.getCollection(relation.throughCollection).schema;
+            const foreignKey = throughSchema.fields[relation.foreignKey];
+            const originKey = throughSchema.fields[relation.originKey];
+            isReadOnly = originKey.isReadOnly || foreignKey.isReadOnly;
+        }
+        return {
+            ...baseSchema,
+            type: [targetField.columnType],
+            defaultValue: null,
+            isFilterable: false,
+            isPrimaryKey: false,
+            isRequired: false,
+            isReadOnly: Boolean(isReadOnly),
+            isSortable: false,
+            validations: [],
+            reference: `${foreignCollection.name}.${targetName}`,
+        };
+    }
+    static isForeignCollectionFilterable(foreignCollection) {
+        return Object.values(foreignCollection.schema.fields).some(field => field.type === 'Column' &&
+            filterable_1.default.isFilterable(field.columnType, field.filterOperators));
+    }
+    static buildOneToOneSchema(relation, collection, foreignCollection, baseSchema) {
+        const targetField = collection.schema.fields[relation.originKeyTarget];
+        const keyField = foreignCollection.schema.fields[relation.originKey];
+        return {
+            ...baseSchema,
+            type: keyField.columnType,
+            defaultValue: null,
+            isFilterable: SchemaGeneratorFields.isForeignCollectionFilterable(foreignCollection),
+            isPrimaryKey: false,
+            isRequired: false,
+            isReadOnly: Boolean(keyField.isReadOnly),
+            isSortable: Boolean(targetField.isSortable),
+            validations: [],
+            reference: `${foreignCollection.name}.${relation.originKeyTarget}`,
+        };
+    }
+    static buildManyToOneSchema(relation, collection, foreignCollection, baseSchema) {
+        const keyField = collection.schema.fields[relation.foreignKey];
+        return {
+            ...baseSchema,
+            type: keyField.columnType,
+            defaultValue: keyField.defaultValue ?? null,
+            isFilterable: SchemaGeneratorFields.isForeignCollectionFilterable(foreignCollection),
+            isPrimaryKey: Boolean(keyField.isPrimaryKey),
+            isRequired: keyField.validation?.some(v => v.operator === 'Present') ?? false,
+            isReadOnly: Boolean(keyField.isReadOnly),
+            isSortable: Boolean(keyField.isSortable),
+            validations: validation_1.default.convertValidationList(keyField.validation),
+            reference: `${foreignCollection.name}.${relation.foreignKeyTarget}`,
+        };
+    }
+    static buildRelationSchema(collection, name) {
+        const relation = collection.schema.fields[name];
+        const foreignCollection = collection.dataSource.getCollection(relation.foreignCollection);
+        const relationSchema = {
+            field: name,
+            enums: null,
+            integration: null,
+            isVirtual: false,
+            inverseOf: datasource_toolkit_1.CollectionUtils.getInverseRelation(collection, name),
+            relationship: SchemaGeneratorFields.relationMap[relation.type],
+        };
+        switch (relation.type) {
+            case 'ManyToMany':
+            case 'OneToMany':
+                return SchemaGeneratorFields.buildToManyRelationSchema(relation, collection, foreignCollection, relationSchema);
+            case 'OneToOne':
+                return SchemaGeneratorFields.buildOneToOneSchema(relation, collection, foreignCollection, relationSchema);
+            default:
+                return SchemaGeneratorFields.buildManyToOneSchema(relation, collection, foreignCollection, relationSchema);
+        }
+    }
+}
+exports.default = SchemaGeneratorFields;
+SchemaGeneratorFields.relationMap = {
+    ManyToMany: 'BelongsToMany',
+    ManyToOne: 'BelongsTo',
+    OneToMany: 'HasMany',
+    OneToOne: 'HasOne',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/forest-schema/generator-segments.d.ts

@@ -0,0 +1,6 @@
+import { Collection, CollectionSchema } from '@forestadmin/datasource-toolkit';
+import { ForestServerSegment } from './types';
+export default class SchemaGeneratorSegments {
+    static buildSchema(collection: Collection, name: CollectionSchema['segments'][number]): ForestServerSegment;
+}
+//# sourceMappingURL=generator-segments.d.ts.map

package/dist/utils/forest-schema/generator-segments.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SchemaGeneratorSegments {
+    static buildSchema(collection, name) {
+        return { id: `${collection.name}.${name}`, name };
+    }
+}
+exports.default = SchemaGeneratorSegments;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdG9yLXNlZ21lbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL2ZvcmVzdC1zY2hlbWEvZ2VuZXJhdG9yLXNlZ21lbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0EsTUFBcUIsdUJBQXVCO0lBQzFDLE1BQU0sQ0FBQyxXQUFXLENBQ2hCLFVBQXNCLEVBQ3RCLElBQTBDO1FBRTFDLE9BQU8sRUFBRSxFQUFFLEVBQUUsR0FBRyxVQUFVLENBQUMsSUFBSSxJQUFJLElBQUksRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDO0lBQ3BELENBQUM7Q0FDRjtBQVBELDBDQU9DIn0=

package/dist/utils/forest-schema/types.d.ts

@@ -0,0 +1,85 @@
+import { PrimitiveTypes } from '@forestadmin/datasource-toolkit';
+export declare type ForestServerColumnType = PrimitiveTypes | [ForestServerColumnType] | {
+    fields: Array<{
+        field: string;
+        type: ForestServerColumnType;
+    }>;
+};
+export declare type ForestServerCollection = {
+    name: string;
+    icon: null;
+    integration: null;
+    isReadOnly: boolean;
+    isSearchable: boolean;
+    isVirtual: false;
+    onlyForRelationships: boolean;
+    paginationType: 'page';
+    actions: Array<ForestServerAction>;
+    fields: Array<ForestServerField>;
+    segments: Array<ForestServerSegment>;
+};
+export declare type ForestServerAction = {
+    id: string;
+    name: string;
+    type: 'single' | 'bulk' | 'global';
+    baseUrl: string;
+    endpoint: string;
+    httpMethod: 'POST';
+    redirect: unknown;
+    download: boolean;
+    fields: ForestServerActionField[];
+    hooks: {
+        load: boolean;
+        change: Array<unknown>;
+    };
+};
+export declare type ForestServerActionField = {
+    value: unknown;
+    defaultValue: unknown;
+    description: string | null;
+    enums: string[];
+    field: string;
+    hook: string;
+    isReadOnly: boolean;
+    isRequired: boolean;
+    reference: string | null;
+    type: ForestServerColumnType;
+    widget: null | 'belongsto select' | 'file picker';
+};
+export declare type ForestServerField = Partial<{
+    field: string;
+    type: ForestServerColumnType;
+    defaultValue: unknown;
+    enums: null | string[];
+    integration: null;
+    isFilterable: boolean;
+    isPrimaryKey: boolean;
+    isReadOnly: boolean;
+    isRequired: boolean;
+    isSortable: boolean;
+    isVirtual: boolean;
+    reference: null | string;
+    inverseOf: null | string;
+    relationship: 'BelongsTo' | 'BelongsToMany' | 'HasMany' | 'HasOne';
+    validations: Array<{
+        message: string | null;
+        type: ValidationType;
+        value: unknown;
+    }>;
+}>;
+export declare type ForestServerSegment = {
+    id: string;
+    name: string;
+};
+export declare enum ValidationType {
+    Present = "is present",
+    GreaterThan = "is greater than",
+    LessThan = "is less than",
+    Before = "is before",
+    After = "is after",
+    LongerThan = "is longer than",
+    ShorterThan = "is shorter than",
+    Contains = "contains",
+    Like = "is like"
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/forest-schema/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationType = void 0;
+var ValidationType;
+(function (ValidationType) {
+    ValidationType["Present"] = "is present";
+    ValidationType["GreaterThan"] = "is greater than";
+    ValidationType["LessThan"] = "is less than";
+    ValidationType["Before"] = "is before";
+    ValidationType["After"] = "is after";
+    ValidationType["LongerThan"] = "is longer than";
+    ValidationType["ShorterThan"] = "is shorter than";
+    ValidationType["Contains"] = "contains";
+    ValidationType["Like"] = "is like";
+})(ValidationType = exports.ValidationType || (exports.ValidationType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvZm9yZXN0LXNjaGVtYS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUEwRUEsSUFBWSxjQVVYO0FBVkQsV0FBWSxjQUFjO0lBQ3hCLHdDQUFzQixDQUFBO0lBQ3RCLGlEQUErQixDQUFBO0lBQy9CLDJDQUF5QixDQUFBO0lBQ3pCLHNDQUFvQixDQUFBO0lBQ3BCLG9DQUFrQixDQUFBO0lBQ2xCLCtDQUE2QixDQUFBO0lBQzdCLGlEQUErQixDQUFBO0lBQy9CLHVDQUFxQixDQUFBO0lBQ3JCLGtDQUFnQixDQUFBO0FBQ2xCLENBQUMsRUFWVyxjQUFjLEdBQWQsc0JBQWMsS0FBZCxzQkFBYyxRQVV6QiJ9

package/dist/utils/forest-schema/validation.d.ts

@@ -0,0 +1,10 @@
+import { ColumnSchema } from '@forestadmin/datasource-toolkit';
+import { ForestServerField } from './types';
+declare type FrontendValidation = ForestServerField['validations'][number];
+declare type Validation = ColumnSchema['validation'][number];
+export default class FrontendValidationUtils {
+    private static operatorValidationTypeMap;
+    static convertValidationList(rules?: Validation[]): FrontendValidation[];
+}
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/dist/utils/forest-schema/validation.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+class FrontendValidationUtils {
+    static convertValidationList(rules) {
+        if (!rules)
+            return [];
+        return rules
+            .map(rule => {
+            const type = FrontendValidationUtils.operatorValidationTypeMap[rule.operator];
+            const error = `${rule.operator}${rule.value !== undefined ? `(${rule.value})` : ``}`;
+            const message = `Failed validation rule: '${error}'`;
+            return type ? { type, value: rule.value, message } : null;
+        })
+            .filter(Boolean);
+    }
+}
+exports.default = FrontendValidationUtils;
+FrontendValidationUtils.operatorValidationTypeMap = {
+    Present: types_1.ValidationType.Present,
+    GreaterThan: types_1.ValidationType.GreaterThan,
+    LessThan: types_1.ValidationType.LessThan,
+    LongerThan: types_1.ValidationType.LongerThan,
+    ShorterThan: types_1.ValidationType.ShorterThan,
+    Contains: types_1.ValidationType.Contains,
+    Like: types_1.ValidationType.Like,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9mb3Jlc3Qtc2NoZW1hL3ZhbGlkYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFDQSxtQ0FBNEQ7QUFLNUQsTUFBcUIsdUJBQXVCO0lBVzFDLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxLQUFvQjtRQUMvQyxJQUFJLENBQUMsS0FBSztZQUFFLE9BQU8sRUFBRSxDQUFDO1FBRXRCLE9BQU8sS0FBSzthQUNULEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUNWLE1BQU0sSUFBSSxHQUFHLHVCQUF1QixDQUFDLHlCQUF5QixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUM5RSxNQUFNLEtBQUssR0FBRyxHQUFHLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLEtBQUssS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQztZQUNyRixNQUFNLE9BQU8sR0FBRyw0QkFBNEIsS0FBSyxHQUFHLENBQUM7WUFFckQsT0FBTyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7UUFDNUQsQ0FBQyxDQUFDO2FBQ0QsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3JCLENBQUM7O0FBdkJILDBDQXdCQztBQXZCZ0IsaURBQXlCLEdBQThDO0lBQ3BGLE9BQU8sRUFBRSxzQkFBYyxDQUFDLE9BQU87SUFDL0IsV0FBVyxFQUFFLHNCQUFjLENBQUMsV0FBVztJQUN2QyxRQUFRLEVBQUUsc0JBQWMsQ0FBQyxRQUFRO0lBQ2pDLFVBQVUsRUFBRSxzQkFBYyxDQUFDLFVBQVU7SUFDckMsV0FBVyxFQUFFLHNCQUFjLENBQUMsV0FBVztJQUN2QyxRQUFRLEVBQUUsc0JBQWMsQ0FBQyxRQUFRO0lBQ2pDLElBQUksRUFBRSxzQkFBYyxDQUFDLElBQUk7Q0FDMUIsQ0FBQyJ9

package/dist/utils/id.d.ts

@@ -0,0 +1,8 @@
+import { CollectionSchema, CompositeId, RecordData } from '@forestadmin/datasource-toolkit';
+export default class IdUtils {
+    static packIds(schema: CollectionSchema, records: RecordData[]): string[];
+    static packId(schema: CollectionSchema, record: RecordData): string;
+    static unpackIds(schema: CollectionSchema, packedIds: string[]): CompositeId[];
+    static unpackId(schema: CollectionSchema, packedId: string): CompositeId;
+}
+//# sourceMappingURL=id.d.ts.map

package/dist/utils/id.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class IdUtils {
+    static packIds(schema, records) {
+        return records.map(packedId => IdUtils.packId(schema, packedId));
+    }
+    static packId(schema, record) {
+        const pkNames = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(schema);
+        if (!pkNames.length) {
+            throw new Error('This collection has no primary key');
+        }
+        if (pkNames.some(pkName => record[pkName] === undefined)) {
+            throw new Error(`Missing one of expected fields: '${pkNames.join("', '")}'`);
+        }
+        return pkNames.map(pk => String(record[pk])).join('|');
+    }
+    static unpackIds(schema, packedIds) {
+        if (!Array.isArray(packedIds)) {
+            throw new datasource_toolkit_1.ValidationError(`Expected array, received: ${typeof packedIds}`);
+        }
+        return packedIds.map(packedId => IdUtils.unpackId(schema, packedId));
+    }
+    static unpackId(schema, packedId) {
+        if (typeof packedId !== 'string') {
+            throw new datasource_toolkit_1.ValidationError(`Expected string, received: ${typeof packedId}`);
+        }
+        const pkNames = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(schema);
+        const pkValues = packedId.split('|');
+        if (pkValues.length !== pkNames.length) {
+            throw new datasource_toolkit_1.ValidationError(`Expected ${pkNames.length} values, found ${pkValues.length}`);
+        }
+        return pkNames.map((pkName, index) => {
+            const schemaField = schema.fields[pkName];
+            const value = pkValues[index];
+            const castedValue = schemaField.columnType === 'Number' ? Number(value) : value;
+            datasource_toolkit_1.FieldValidator.validateValue(pkName, schemaField, castedValue);
+            return castedValue;
+        });
+    }
+}
+exports.default = IdUtils;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/options-validator.d.ts

@@ -0,0 +1,12 @@
+import { AgentOptions, AgentOptionsWithDefaults } from '../types';
+export default class OptionsValidator {
+    private static loggerPrefix;
+    static withDefaults(options: AgentOptions): AgentOptionsWithDefaults;
+    static validate(options: AgentOptions): AgentOptionsWithDefaults;
+    private static checkForestServerOptions;
+    private static checkAuthOptions;
+    private static checkOtherOptions;
+    private static isExistingPath;
+    private static isUrl;
+}
+//# sourceMappingURL=options-validator.d.ts.map