@forestadmin/agent 1.0.0-beta.5 → 1.0.0-beta.52

package/dist/builder/collection.js

@@ -6,9 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
 const filterable_1 = __importDefault(require("../agent/utils/forest-schema/filterable"));
 class CollectionBuilder {
-    constructor(agentBuilder, name) {
-        this.agentBuilder = agentBuilder;
+    constructor(stack, name) {
         this.name = name;
+        this.stack = stack;
+    }
+    /**
+     * Disable count in list view pagination for improved performance.
+     *
+     * @example
+     * .disableCount()
+     */
+    disableCount() {
+        this.stack.schema.getCollection(this.name).overrideSchema({ countable: false });
+        return this;
     }
     /**
      * Import a field from a many to one or one to one relation.
@@ -19,7 +29,7 @@ class CollectionBuilder {
      * .importField('authorName', { path: 'author:fullName' })
      */
     importField(name, options) {
-        const collection = this.agentBuilder.lateComputed.getCollection(this.name);
+        const collection = this.stack.lateComputed.getCollection(this.name);
         const schema = datasource_toolkit_1.CollectionUtils.getFieldSchema(collection, options.path);
         this.addField(name, {
             beforeRelations: options.beforeRelations,
@@ -29,58 +39,77 @@ class CollectionBuilder {
             getValues: records => records.map(r => datasource_toolkit_1.RecordUtils.getFieldValue(r, options.path)),
             enumValues: schema.enumValues,
         });
+        if (!schema.isReadOnly && !options.readonly) {
+            this.stack.write.getCollection(this.name).replaceFieldWriting(name, value => {
+                const path = options.path.split(':');
+                const writingPath = {};
+                path.reduce((nestedPath, currentPath, index) => {
+                    nestedPath[currentPath] = index === path.length - 1 ? value : {};
+                    return nestedPath[currentPath];
+                }, writingPath);
+                return writingPath;
+            });
+        }
+        if (schema.isReadOnly && options.readonly === false) {
+            throw new Error(`Readonly option should not be false because the field "${options.path}" is not writable`);
+        }
         for (const operator of schema.filterOperators) {
-            const handler = (value) => ({ field: options.path, operator, value });
+            const handler = value => ({ field: options.path, operator, value });
             this.replaceFieldOperator(name, operator, handler);
         }
         if (schema.isSortable) {
-            this.replaceFieldSorting(name, [{ field: options.path, ascending: true }]);
+            this.replaceFieldSorting(name, [
+                { field: options.path, ascending: true },
+            ]);
         }
         return this;
     }
     /**
      * Allow to rename a field of a given collection.
-     * @param {string} oldName the current name of the field in a given collection
-     * @param {string} newName the new name of the field
+     * @param oldName the current name of the field in a given collection
+     * @param newName the new name of the field
      * @example
      * .renameField('theCurrentNameOfTheField', 'theNewNameOfTheField');
      */
     renameField(oldName, newName) {
-        this.agentBuilder.rename.getCollection(this.name).renameField(oldName, newName);
+        this.stack.renameField.getCollection(this.name).renameField(oldName, newName);
         return this;
     }
     /**
      * Remove field by setting its visibility to false.
-     * @param {...string[]} names the fields to remove
+     * @param names the fields to remove
      * @example
-     * .removeField('aFieldToRemove', 'anOtherFieldToRemove');
+     * .removeField('aFieldToRemove', 'anotherFieldToRemove');
      */
     removeField(...names) {
-        const collection = this.agentBuilder.publication.getCollection(this.name);
+        const collection = this.stack.publication.getCollection(this.name);
         for (const name of names)
             collection.changeFieldVisibility(name, false);
         return this;
     }
     /**
      * Add a new action on the collection.
-     * @param {string} name the name of the action
-     * @param {ActionDefinition} definition the definition of the action
+     * @param name the name of the action
+     * @param definition the definition of the action
      * @example
      * .addAction('is live', {
      *    scope: 'Single',
-     *    execute: async (context, responseBuilder) => {
-     *      return responseBuilder.success(`Is live!`);
+     *    execute: async (context, resultBuilder) => {
+     *      return resultBuilder.success(`Is live!`);
      *    },
      *  })
      */
     addAction(name, definition) {
-        this.agentBuilder.action.getCollection(this.name).addAction(name, definition);
+        this.stack.action
+            .getCollection(this.name)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .addAction(name, definition);
         return this;
     }
     /**
      * Add a new field on the collection.
-     * @param {string} name the name of the field
-     * @param {FieldDefinition} definition The definition of the field
+     * @param name the name of the field
+     * @param definition The definition of the field
      * @example
      * .addField('fullName', {
      *    columnType: 'String',
@@ -91,57 +120,141 @@ class CollectionBuilder {
     addField(name, definition) {
         const { beforeRelations, ...computedDefinition } = definition;
         const collection = definition.beforeRelations
-            ? this.agentBuilder.earlyComputed.getCollection(this.name)
-            : this.agentBuilder.lateComputed.getCollection(this.name);
+            ? this.stack.earlyComputed.getCollection(this.name)
+            : this.stack.lateComputed.getCollection(this.name);
         collection.registerComputed(name, computedDefinition);
         return this;
     }
     /**
-     * Add a relation between two collections.
+     * Add a many to one relation to the collection
      * @param name name of the new relation
-     * @param definition definition of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
      * @example
-     * .addRelation('author', {
-     *   type: 'ManyToOne',
-     *   foreignCollection: 'persons',
-     *   foreignKey: 'authorId'
-     * });
+     * books.addManyToOneRelation('myAuthor', 'persons', { foreignKey: 'authorId' })
      */
-    addRelation(name, definition) {
-        this.agentBuilder.relation.getCollection(this.name).addRelation(name, definition);
+    addManyToOneRelation(name, foreignCollection, options) {
+        this.addRelation(name, {
+            type: 'ManyToOne',
+            foreignCollection,
+            foreignKey: options.foreignKey,
+            foreignKeyTarget: options.foreignKeyTarget,
+        });
+        return this;
+    }
+    /**
+     * Add a one to many relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
+     * @example
+     * persons.addOneToManyRelation('writtenBooks', 'books', { originKey: 'authorId' })
+     */
+    addOneToManyRelation(name, foreignCollection, options) {
+        this.addRelation(name, {
+            type: 'OneToMany',
+            foreignCollection,
+            originKey: options.originKey,
+            originKeyTarget: options.originKeyTarget,
+        });
+        return this;
+    }
+    /**
+     * Add a one to one relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
+     * @example
+     * persons.addOneToOneRelation('bestFriend', 'persons', { originKey: 'bestFriendId' })
+     */
+    addOneToOneRelation(name, foreignCollection, options) {
+        this.addRelation(name, {
+            type: 'OneToOne',
+            foreignCollection,
+            originKey: options.originKey,
+            originKeyTarget: options.originKeyTarget,
+        });
+        return this;
+    }
+    /**
+     * Add a many to many relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param throughCollection name of the intermediary collection
+     * @param options extra information about the relation
+     * @example
+     * dvds.addManyToManyRelation('rentalsOfThisDvd', 'rentals', 'dvdRentals', {
+     *   originKey: 'dvdId',
+     *   foreignKey: 'rentalId'
+     * })
+     */
+    addManyToManyRelation(name, foreignCollection, throughCollection, options) {
+        this.addRelation(name, {
+            type: 'ManyToMany',
+            foreignCollection,
+            throughCollection,
+            originKey: options.originKey,
+            originKeyTarget: options.originKeyTarget,
+            foreignKey: options.foreignKey,
+            foreignKeyTarget: options.foreignKeyTarget,
+        });
         return this;
     }
+    /**
+     * Add a virtual collection into the related data of a record.
+     *
+     * @param name name of the relation
+     * @param definition the definition of the new relation
+     * @example
+     * .addExternalRelation('states', {
+     *   schema: { code: 'Number', name: 'String' },
+     *   listRecords: ({ id }) => {
+     *     return record.id == 34 ?
+     *      [{ code: 'AL', name: 'Alabama' }, { code: 'AK', name: 'Alaska' }] :
+     *      [{ code: 'AZ', name: 'Arizona' }, { code: 'TX', name: 'Texas' }];
+     *   }
+     * })
+     */
+    addExternalRelation(name, definition) {
+        const { schema } = this.stack.action.getCollection(this.name);
+        const primaryKeys = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(schema);
+        return this.addField(name, {
+            dependencies: definition.dependencies ?? primaryKeys,
+            columnType: [definition.schema],
+            getValues: async (records, context) => Promise.all(records.map(async (record) => definition.listRecords(record, context))),
+        });
+    }
     /**
      * Add a new segment on the collection.
-     * @param {string} name the name of the segment
-     * @param {SegmentDefinition} definition a function used to generate a condition tree
+     * @param name the name of the segment
+     * @param definition a function used to generate a condition tree
      * or a condition tree
      * @example
      * .addSegment(
      *    'Wrote more than 2 books',
-     *    new ConditionTreeLeaf('booksCount', 'GreaterThan', 2),
+     *    { field: 'booksCount', operator: 'GreaterThan', value: 2 }
      * );
      */
     addSegment(name, definition) {
-        this.agentBuilder.segment.getCollection(this.name).addSegment(name, definition);
+        this.stack.segment.getCollection(this.name).addSegment(name, definition);
         return this;
     }
     /**
      * Enable sorting on a specific field using emulation.
      * As for all the emulation method, the field sorting will be done in-memory.
-     * @param {string} name the name of the field to enable emulation on
+     * @param name the name of the field to enable emulation on
      * @example
      * .emulateFieldSorting('fullName');
      */
     emulateFieldSorting(name) {
-        this.agentBuilder.sortEmulate.getCollection(this.name).emulateFieldSorting(name);
+        this.stack.sortEmulate.getCollection(this.name).emulateFieldSorting(name);
         return this;
     }
     /**
      * Replace an implementation for the sorting.
      * The field sorting will be done by the datasource.
-     * @param {string} name the name of the field to enable sort
-     * @param {SortClause[]} equivalentSort the sort equivalent
+     * @param name the name of the field to enable sort
+     * @param equivalentSort the sort equivalent
      * @example
      * .replaceFieldSorting(
      *   'fullName',
@@ -152,7 +265,7 @@ class CollectionBuilder {
      * )
      */
     replaceFieldSorting(name, equivalentSort) {
-        this.agentBuilder.sortEmulate
+        this.stack.sortEmulate
             .getCollection(this.name)
             .replaceFieldSorting(name, equivalentSort);
         return this;
@@ -165,10 +278,10 @@ class CollectionBuilder {
      * .emulateFieldFiltering('aField');
      */
     emulateFieldFiltering(name) {
-        const collection = this.agentBuilder.lateOpEmulate.getCollection(this.name);
+        const collection = this.stack.lateOpEmulate.getCollection(this.name);
         const field = collection.schema.fields[name];
         for (const operator of filterable_1.default.getRequiredOperators(field.columnType)) {
-            if (!field.filterOperators.has(operator)) {
+            if (!field.filterOperators?.has(operator)) {
                 this.emulateFieldOperator(name, operator);
             }
         }
@@ -177,50 +290,97 @@ class CollectionBuilder {
     /**
      * Enable filtering on a specific field with a specific operator using emulation.
      * As for all the emulation method, the field filtering will be done in-memory.
-     * @param {string} name the name of the field to enable emulation on
-     * @param {Operator} operator the operator to emulate
+     * @param name the name of the field to enable emulation on
+     * @param operator the operator to emulate
      * @example
      * .emulateFieldOperator('aField', 'In');
      */
     emulateFieldOperator(name, operator) {
-        const collection = this.agentBuilder.earlyOpEmulate.getCollection(this.name).schema.fields[name]
-            ? this.agentBuilder.earlyOpEmulate.getCollection(this.name)
-            : this.agentBuilder.lateOpEmulate.getCollection(this.name);
+        const collection = this.stack.earlyOpEmulate.getCollection(this.name).schema.fields[name]
+            ? this.stack.earlyOpEmulate.getCollection(this.name)
+            : this.stack.lateOpEmulate.getCollection(this.name);
         collection.emulateFieldOperator(name, operator);
         return this;
     }
     /**
      * Replace an implementation for a specific operator on a specific field.
      * The operator replacement will be done by the datasource.
-     * @param {string} name the name of the field to filter on
-     * @param {Operator} operator the operator to replace
-     * @param {OperatorReplacer} replacer the proposed implementation
+     * @param name the name of the field to filter on
+     * @param operator the operator to replace
+     * @param replacer the proposed implementation
      * @example
-     * .replaceFieldOperator('booksCount', 'Equal', ({ value }) => new ConditionTreeNot(
-     *   new ConditionTreeLeaf('booksCount', 'Equal', value),
-     * ));
+     * .replaceFieldOperator('fullName', 'Contains', (value) => {
+     *    return {
+     *      aggregator: 'Or',
+     *      conditions: [{
+     *        field: 'firstName',
+     *        operator: 'Contains',
+     *        value
+     *      }, {
+     *        field: 'lastName',
+     *        operator: 'Contains',
+     *        value
+     *      }]
+     *    }
+     * });
      */
     replaceFieldOperator(name, operator, replacer) {
-        const collection = this.agentBuilder.earlyOpEmulate.getCollection(this.name).schema.fields[name]
-            ? this.agentBuilder.earlyOpEmulate.getCollection(this.name)
-            : this.agentBuilder.lateOpEmulate.getCollection(this.name);
+        const collection = this.stack.earlyOpEmulate.getCollection(this.name).schema.fields[name]
+            ? this.stack.earlyOpEmulate.getCollection(this.name)
+            : this.stack.lateOpEmulate.getCollection(this.name);
         collection.replaceFieldOperator(name, operator, replacer);
         return this;
     }
     /**
      * Replace the write behavior of a field.
-     * @param {string} name the name of the field
-     * @param {WriteDefinition} definition the function or a value to represent the write behavior
+     * @param name the name of the field
+     * @param definition the function or a value to represent the write behavior
      * @example
-     * .replaceFieldWriting('fullName', ({ patch: fullName }) => {
+     * .replaceFieldWriting('fullName', fullName => {
      *   const [firstName, lastName] = fullName.split(' ');
      *   return { firstName, lastName };
      * });
      */
     replaceFieldWriting(name, definition) {
-        this.agentBuilder.write.getCollection(this.name).replaceFieldWriting(name, definition);
+        this.stack.write.getCollection(this.name).replaceFieldWriting(name, definition);
+        return this;
+    }
+    /**
+     * Replace the behavior of the search bar
+     * @param definition handler to describe the new behavior
+     * @example
+     * .replaceSearch(async (searchString) => {
+     *   return { field: 'name', operator: 'Contains', value: searchString };
+     * });
+     */
+    replaceSearch(definition) {
+        this.stack.search
+            .getCollection(this.name)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .replaceSearch(definition);
+        return this;
+    }
+    addHook(position, type, handler) {
+        this.stack.hook
+            .getCollection(this.name)
+            .addHook(position, type, handler);
+        return this;
+    }
+    /**
+     * Add a relation between two collections.
+     * @param name name of the new relation
+     * @param definition definition of the new relation
+     * @example
+     * .addRelation('author', {
+     *   type: 'ManyToOne',
+     *   foreignCollection: 'persons',
+     *   foreignKey: 'authorId'
+     * });
+     */
+    addRelation(name, definition) {
+        this.stack.relation.getCollection(this.name).addRelation(name, definition);
         return this;
     }
 }
 exports.default = CollectionBuilder;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../src/builder/collection.ts"],"names":[],"mappings":"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"}

package/dist/builder/decorators-stack.d.ts

@@ -0,0 +1,24 @@
+import { ActionCollectionDecorator, ChartDataSourceDecorator, ComputedCollectionDecorator, DataSource, DataSourceDecorator, EmptyCollectionDecorator, HookCollectionDecorator, OperatorsEmulateCollectionDecorator, OperatorsReplaceCollectionDecorator, PublicationCollectionDecorator, RelationCollectionDecorator, RenameFieldCollectionDecorator, SchemaCollectionDecorator, SearchCollectionDecorator, SegmentCollectionDecorator, SortEmulateCollectionDecorator, WriteCollectionDecorator } from '@forestadmin/datasource-toolkit';
+export default class DecoratorsStack {
+    action: DataSourceDecorator<ActionCollectionDecorator>;
+    chart: ChartDataSourceDecorator;
+    earlyComputed: DataSourceDecorator<ComputedCollectionDecorator>;
+    earlyOpEmulate: DataSourceDecorator<OperatorsEmulateCollectionDecorator>;
+    earlyOpReplace: DataSourceDecorator<OperatorsReplaceCollectionDecorator>;
+    empty: DataSourceDecorator<EmptyCollectionDecorator>;
+    relation: DataSourceDecorator<RelationCollectionDecorator>;
+    lateComputed: DataSourceDecorator<ComputedCollectionDecorator>;
+    lateOpEmulate: DataSourceDecorator<OperatorsEmulateCollectionDecorator>;
+    lateOpReplace: DataSourceDecorator<OperatorsReplaceCollectionDecorator>;
+    publication: DataSourceDecorator<PublicationCollectionDecorator>;
+    renameField: DataSourceDecorator<RenameFieldCollectionDecorator>;
+    schema: DataSourceDecorator<SchemaCollectionDecorator>;
+    search: DataSourceDecorator<SearchCollectionDecorator>;
+    segment: DataSourceDecorator<SegmentCollectionDecorator>;
+    sortEmulate: DataSourceDecorator<SortEmulateCollectionDecorator>;
+    write: DataSourceDecorator<WriteCollectionDecorator>;
+    hook: DataSourceDecorator<HookCollectionDecorator>;
+    dataSource: DataSource;
+    constructor(dataSource: DataSource);
+}
+//# sourceMappingURL=decorators-stack.d.ts.map

package/dist/builder/decorators-stack.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class DecoratorsStack {
+    constructor(dataSource) {
+        let last = dataSource;
+        /* eslint-disable no-multi-assign */
+        // Step 0: Do not query datasource when we know the result with yield an empty set.
+        last = this.empty = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.EmptyCollectionDecorator);
+        // Step 1: Computed-Relation-Computed sandwich (needed because some emulated relations depend
+        // on computed fields, and some computed fields depend on relation...)
+        // Note that replacement goes before emulation, as replacements may use emulated operators.
+        last = this.earlyComputed = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.ComputedCollectionDecorator);
+        last = this.earlyOpEmulate = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.OperatorsEmulateCollectionDecorator);
+        last = this.earlyOpReplace = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.OperatorsReplaceCollectionDecorator);
+        last = this.relation = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.RelationCollectionDecorator);
+        last = this.lateComputed = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.ComputedCollectionDecorator);
+        last = this.lateOpEmulate = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.OperatorsEmulateCollectionDecorator);
+        last = this.lateOpReplace = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.OperatorsReplaceCollectionDecorator);
+        // Step 2: Those need access to all fields. They can be loaded in any order.
+        last = this.search = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.SearchCollectionDecorator);
+        last = this.segment = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.SegmentCollectionDecorator);
+        last = this.sortEmulate = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.SortEmulateCollectionDecorator);
+        last = this.write = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.WriteCollectionDecorator);
+        // Step 3: Access to all fields AND emulated capabilities
+        last = this.chart = new datasource_toolkit_1.ChartDataSourceDecorator(last);
+        last = this.action = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.ActionCollectionDecorator);
+        last = this.schema = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.SchemaCollectionDecorator);
+        last = this.hook = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.HookCollectionDecorator);
+        // Step 4: Renaming must be either the very first or very last so that naming in customer code
+        // is consistent.
+        last = this.publication = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.PublicationCollectionDecorator);
+        last = this.renameField = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.RenameFieldCollectionDecorator);
+        /* eslint-enable no-multi-assign */
+        this.dataSource = last;
+    }
+}
+exports.default = DecoratorsStack;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy1zdGFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9idWlsZGVyL2RlY29yYXRvcnMtc3RhY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx3RUFrQnlDO0FBRXpDLE1BQXFCLGVBQWU7SUFxQmxDLFlBQVksVUFBc0I7UUFDaEMsSUFBSSxJQUFJLEdBQWUsVUFBVSxDQUFDO1FBRWxDLG9DQUFvQztRQUNwQyxtRkFBbUY7UUFDbkYsSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSx3Q0FBbUIsQ0FBQyxJQUFJLEVBQUUsNkNBQXdCLENBQUMsQ0FBQztRQUU1RSw2RkFBNkY7UUFDN0Ysc0VBQXNFO1FBQ3RFLDJGQUEyRjtRQUMzRixJQUFJLEdBQUcsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLHdDQUFtQixDQUFDLElBQUksRUFBRSxnREFBMkIsQ0FBQyxDQUFDO1FBQ3ZGLElBQUksR0FBRyxJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksd0NBQW1CLENBQUMsSUFBSSxFQUFFLHdEQUFtQyxDQUFDLENBQUM7UUFDaEcsSUFBSSxHQUFHLElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSx3Q0FBbUIsQ0FBQyxJQUFJLEVBQUUsd0RBQW1DLENBQUMsQ0FBQztRQUNoRyxJQUFJLEdBQUcsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLHdDQUFtQixDQUFDLElBQUksRUFBRSxnREFBMkIsQ0FBQyxDQUFDO1FBQ2xGLElBQUksR0FBRyxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksd0NBQW1CLENBQUMsSUFBSSxFQUFFLGdEQUEyQixDQUFDLENBQUM7UUFDdEYsSUFBSSxHQUFHLElBQUksQ0FBQyxhQUFhLEdBQUcsSUFBSSx3Q0FBbUIsQ0FBQyxJQUFJLEVBQUUsd0RBQW1DLENBQUMsQ0FBQztRQUMvRixJQUFJLEdBQUcsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLHdDQUFtQixDQUFDLElBQUksRUFBRSx3REFBbUMsQ0FBQyxDQUFDO1FBRS9GLDRFQUE0RTtRQUM1RSxJQUFJLEdBQUcsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLHdDQUFtQixDQUFDLElBQUksRUFBRSw4Q0FBeUIsQ0FBQyxDQUFDO1FBQzlFLElBQUksR0FBRyxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksd0NBQW1CLENBQUMsSUFBSSxFQUFFLCtDQUEwQixDQUFDLENBQUM7UUFDaEYsSUFBSSxHQUFHLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSx3Q0FBbUIsQ0FBQyxJQUFJLEVBQUUsbURBQThCLENBQUMsQ0FBQztRQUN4RixJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLHdDQUFtQixDQUFDLElBQUksRUFBRSw2Q0FBd0IsQ0FBQyxDQUFDO1FBRTVFLHlEQUF5RDtRQUN6RCxJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLDZDQUF3QixDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3ZELElBQUksR0FBRyxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksd0NBQW1CLENBQUMsSUFBSSxFQUFFLDhDQUF5QixDQUFDLENBQUM7UUFDOUUsSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSx3Q0FBbUIsQ0FBQyxJQUFJLEVBQUUsOENBQXlCLENBQUMsQ0FBQztRQUM5RSxJQUFJLEdBQUcsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLHdDQUFtQixDQUFDLElBQUksRUFBRSw0Q0FBdUIsQ0FBQyxDQUFDO1FBRTFFLDhGQUE4RjtRQUM5RixpQkFBaUI7UUFDakIsSUFBSSxHQUFHLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSx3Q0FBbUIsQ0FBQyxJQUFJLEVBQUUsbURBQThCLENBQUMsQ0FBQztRQUN4RixJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLHdDQUFtQixDQUFDLElBQUksRUFBRSxtREFBOEIsQ0FBQyxDQUFDO1FBQ3hGLG1DQUFtQztRQUVuQyxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQztJQUN6QixDQUFDO0NBQ0Y7QUEzREQsa0NBMkRDIn0=

package/dist/builder/types.d.ts

@@ -1,5 +1,18 @@
-import { ComputedDefinition } from '@forestadmin/datasource-toolkit';
-export declare type FieldDefinition = ComputedDefinition & {
+/// <reference types="node" />
+import { CollectionCustomizationContext, ComputedDefinition, PrimitiveTypes, TCollectionName, TFieldName, TRow, TSchema } from '@forestadmin/datasource-toolkit';
+import { IncomingMessage, ServerResponse } from 'http';
+export declare type FieldDefinition<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = ComputedDefinition<S, N> & {
     beforeRelations?: boolean;
 };
+export declare type OneToManyEmbeddedDefinition<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = {
+    schema: Record<string, PrimitiveTypes>;
+    dependencies?: TFieldName<S, N>[];
+    listRecords(records: TRow<S, N>, context: CollectionCustomizationContext<S, N>): Promise<unknown[]> | unknown[];
+};
+export declare type HttpCallback = (req: IncomingMessage, res: ServerResponse) => void;
+export declare type DataSourceOptions = {
+    rename?: {
+        [oldName: string]: string;
+    };
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/{agent/utils/http-driver-options.d.ts → builder/utils/options-validator.d.ts}

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