@forestadmin/agent 1.0.0-beta.1

package/dist/agent/utils/query-string.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const DEFAULT_ITEMS_PER_PAGE = 15;
+const DEFAULT_PAGE_TO_SKIP = 1;
+class QueryStringParser {
+    static parseConditionTree(collection, context) {
+        try {
+            const filters = context.request.body?.data?.attributes?.all_records_subset_query?.filters ??
+                context.request.body?.filters ??
+                context.request.query?.filters;
+            if (!filters)
+                return null;
+            const json = JSON.parse(filters.toString());
+            const conditionTree = datasource_toolkit_1.ConditionTreeFactory.fromPlainObject(json);
+            datasource_toolkit_1.ConditionTreeValidator.validate(conditionTree, collection);
+            return conditionTree;
+        }
+        catch (e) {
+            throw new datasource_toolkit_1.ValidationError(`Invalid filters (${e.message})`);
+        }
+    }
+    static parseProjection(collection, context) {
+        try {
+            const fields = context.request.query[`fields[${collection.name}]`];
+            if (fields === '' || fields === undefined) {
+                return datasource_toolkit_1.ProjectionFactory.all(collection);
+            }
+            const rootFields = fields.toString().split(',');
+            const explicitRequest = rootFields.map(field => {
+                const schema = collection.schema.fields[field];
+                return schema.type === 'Column'
+                    ? field
+                    : `${field}:${context.request.query[`fields[${field}]`]}`;
+            });
+            datasource_toolkit_1.ProjectionValidator.validate(collection, explicitRequest);
+            return new datasource_toolkit_1.Projection(...explicitRequest);
+        }
+        catch (e) {
+            throw new datasource_toolkit_1.ValidationError(`Invalid projection`);
+        }
+    }
+    static parseProjectionWithPks(collection, context) {
+        const projection = QueryStringParser.parseProjection(collection, context);
+        // Primary keys are not explicitly listed in the projections that the frontend
+        // is sending, but are still required for the frontend to work.
+        return projection.withPks(collection);
+    }
+    static parseSearch(collection, context) {
+        const search = context.request.body?.data?.attributes?.all_records_subset_query?.search?.toString() ??
+            context.request.query.search?.toString();
+        if (search && !collection.schema.searchable) {
+            throw new datasource_toolkit_1.ValidationError(`Collection is not searchable`);
+        }
+        return search ?? null;
+    }
+    static parseSearchExtended(context) {
+        const { request } = context;
+        const extended = request.body?.data?.attributes?.all_records_subset_query?.searchExtended?.toString() ??
+            request.query.searchExtended?.toString();
+        return !!extended && extended !== '0' && extended !== 'false';
+    }
+    static parseSegment(collection, context) {
+        const segment = context.request.body?.data?.attributes?.all_records_subset_query?.segment?.toString() ??
+            context.request.query.segment?.toString();
+        if (!segment) {
+            return null;
+        }
+        if (!collection.schema.segments.includes(segment)) {
+            throw new datasource_toolkit_1.ValidationError(`Invalid segment: "${segment}"`);
+        }
+        return segment;
+    }
+    static parseTimezone(context) {
+        const timezone = context.request.query.timezone?.toString();
+        if (!timezone) {
+            throw new datasource_toolkit_1.ValidationError('Missing timezone');
+        }
+        // This is a method to validate a timezone using node only
+        // @see https://stackoverflow.com/questions/44115681
+        if (!Intl || !Intl.DateTimeFormat().resolvedOptions().timeZone) {
+            throw new Error('Time zones are not available in this environment');
+        }
+        try {
+            Intl.DateTimeFormat('en-US', { timeZone: timezone });
+        }
+        catch {
+            throw new datasource_toolkit_1.ValidationError(`Invalid timezone: "${timezone}"`);
+        }
+        return timezone;
+    }
+    static parsePagination(context) {
+        const queryItemsPerPage = (context.request.body?.data?.attributes?.all_records_subset_query?.['page[size]'] ??
+            context.request.query['page[size]'] ??
+            DEFAULT_ITEMS_PER_PAGE).toString();
+        const queryPageToSkip = (context.request.body?.data?.attributes?.all_records_subset_query?.['page[number]'] ??
+            context.request.query['page[number]'] ??
+            DEFAULT_PAGE_TO_SKIP).toString();
+        const itemsPerPage = Number.parseInt(queryItemsPerPage, 10);
+        let pageToSkip = Number.parseInt(queryPageToSkip, 10);
+        if (Number.isNaN(itemsPerPage) ||
+            Number.isNaN(pageToSkip) ||
+            itemsPerPage <= 0 ||
+            pageToSkip <= 0) {
+            throw new datasource_toolkit_1.ValidationError(`Invalid pagination [limit: ${itemsPerPage}, skip: ${pageToSkip}]`);
+        }
+        pageToSkip = Math.max(pageToSkip - 1, 0);
+        pageToSkip *= itemsPerPage;
+        return new datasource_toolkit_1.Page(pageToSkip, itemsPerPage);
+    }
+    static parseSort(collection, context) {
+        const sortString = context.request.body?.data?.attributes?.all_records_subset_query?.sort?.toString() ??
+            context.request.query.sort?.toString();
+        try {
+            if (!sortString)
+                return datasource_toolkit_1.SortFactory.byPrimaryKeys(collection);
+            const sort = new datasource_toolkit_1.Sort({
+                field: sortString.replace(/^-/, '').replace('.', ':'),
+                ascending: !sortString.startsWith('-'),
+            });
+            datasource_toolkit_1.SortValidator.validate(collection, sort);
+            return sort;
+        }
+        catch {
+            throw new datasource_toolkit_1.ValidationError(`Invalid sort: ${sortString}`);
+        }
+    }
+}
+exports.default = QueryStringParser;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/builder/agent.d.ts

@@ -0,0 +1,81 @@
+import { ActionCollectionDecorator, BaseDataSource, Collection, ComputedCollectionDecorator, DataSource, DataSourceDecorator, OperatorsEmulateCollectionDecorator, OperatorsReplaceCollectionDecorator, PublicationCollectionDecorator, RelationCollectionDecorator, RenameCollectionDecorator, SearchCollectionDecorator, SegmentCollectionDecorator, SortEmulateCollectionDecorator, WriteCollectionDecorator } from '@forestadmin/datasource-toolkit';
+import { AgentOptions } from '../types';
+import CollectionBuilder from './collection';
+import ForestAdminHttpDriver, { HttpCallback } from '../agent/forestadmin-http-driver';
+/**
+ * Allow to create a new Forest Admin agent from scratch.
+ * Builds the application by composing and configuring all the collection decorators.
+ *
+ * Minimal code to add a datasource
+ * @example
+ * new AgentBuilder(options)
+ *  .addDatasource(new SomeDatasource())
+ *  .start();
+ */
+export default class AgentBuilder {
+    forestAdminHttpDriver: ForestAdminHttpDriver;
+    compositeDatasource: BaseDataSource<Collection>;
+    action: DataSourceDecorator<ActionCollectionDecorator>;
+    earlyComputed: DataSourceDecorator<ComputedCollectionDecorator>;
+    earlyOpEmulate: DataSourceDecorator<OperatorsEmulateCollectionDecorator>;
+    earlyOpReplace: DataSourceDecorator<OperatorsReplaceCollectionDecorator>;
+    relation: DataSourceDecorator<RelationCollectionDecorator>;
+    lateComputed: DataSourceDecorator<ComputedCollectionDecorator>;
+    lateOpEmulate: DataSourceDecorator<OperatorsEmulateCollectionDecorator>;
+    lateOpReplace: DataSourceDecorator<OperatorsReplaceCollectionDecorator>;
+    publication: DataSourceDecorator<PublicationCollectionDecorator>;
+    rename: DataSourceDecorator<RenameCollectionDecorator>;
+    search: DataSourceDecorator<SearchCollectionDecorator>;
+    segment: DataSourceDecorator<SegmentCollectionDecorator>;
+    sortEmulate: DataSourceDecorator<SortEmulateCollectionDecorator>;
+    write: DataSourceDecorator<WriteCollectionDecorator>;
+    /**
+     * Native nodejs HttpCallback object
+     * @example
+     * import http from 'http';
+     * ...
+     * const server = http.createServer(agent.httpCallback);
+     */
+    get httpCallback(): HttpCallback;
+    /**
+     * Create a new Agent Builder.
+     * If any options are missing, the default will be applied:
+     * ```
+     *  clientId: null,
+     *  forestServerUrl: 'https://api.forestadmin.com',
+     *  logger: (level, data) => console.error(OptionsUtils.loggerPrefix[level], data),
+     *  prefix: '/forest',
+     *  schemaPath: '.forestadmin-schema.json',
+     *  permissionsCacheDurationInSeconds: 15 * 60,
+     * ```
+     * @param {AgentOptions} options options
+     * @example
+     * new AgentBuilder(options)
+     *  .addDatasource(new Datasource())
+     *  .start();
+     */
+    constructor(options: AgentOptions);
+    /**
+     * Add a datasource
+     * @param {DataSource} datasource the datasource to add
+     */
+    addDatasource(datasource: DataSource): this;
+    /**
+     * Allow to interact with a decorated collection
+     * @param {string} name the name of the collection to manipulate
+     * @param {(collection: CollectionBuilder) => unknown} handle a function that provide a
+     *   collection builder on the given collection name
+     * @example
+     * .customizeCollection('books', books => books.renameField('xx', 'yy'))
+     */
+    customizeCollection(name: string, handle: (collection: CollectionBuilder) => unknown): this;
+    /**
+     * Start the agent.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the agent gracefully.
+     */
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/builder/agent.js

@@ -0,0 +1,113 @@
+"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 collection_1 = __importDefault(require("./collection"));
+const forestadmin_http_driver_1 = __importDefault(require("../agent/forestadmin-http-driver"));
+/**
+ * Allow to create a new Forest Admin agent from scratch.
+ * Builds the application by composing and configuring all the collection decorators.
+ *
+ * Minimal code to add a datasource
+ * @example
+ * new AgentBuilder(options)
+ *  .addDatasource(new SomeDatasource())
+ *  .start();
+ */
+class AgentBuilder {
+    /**
+     * Create a new Agent Builder.
+     * If any options are missing, the default will be applied:
+     * ```
+     *  clientId: null,
+     *  forestServerUrl: 'https://api.forestadmin.com',
+     *  logger: (level, data) => console.error(OptionsUtils.loggerPrefix[level], data),
+     *  prefix: '/forest',
+     *  schemaPath: '.forestadmin-schema.json',
+     *  permissionsCacheDurationInSeconds: 15 * 60,
+     * ```
+     * @param {AgentOptions} options options
+     * @example
+     * new AgentBuilder(options)
+     *  .addDatasource(new Datasource())
+     *  .start();
+     */
+    constructor(options) {
+        let last;
+        /* eslint-disable no-multi-assign */
+        last = this.compositeDatasource = new datasource_toolkit_1.BaseDataSource();
+        // 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 five need access to all fields. They can be loaded in any order.
+        last = this.publication = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.PublicationCollectionDecorator);
+        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.action = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.ActionCollectionDecorator);
+        // Step 4: Renaming must be either the very first or very last so that naming in customer code
+        // is consistent.
+        last = this.rename = new datasource_toolkit_1.DataSourceDecorator(last, datasource_toolkit_1.RenameCollectionDecorator);
+        /* eslint-enable no-multi-assign */
+        this.forestAdminHttpDriver = new forestadmin_http_driver_1.default(last, options);
+    }
+    /**
+     * Native nodejs HttpCallback object
+     * @example
+     * import http from 'http';
+     * ...
+     * const server = http.createServer(agent.httpCallback);
+     */
+    get httpCallback() {
+        return this.forestAdminHttpDriver.handler;
+    }
+    /**
+     * Add a datasource
+     * @param {DataSource} datasource the datasource to add
+     */
+    addDatasource(datasource) {
+        datasource.collections.forEach(collection => {
+            this.compositeDatasource.addCollection(collection);
+        });
+        return this;
+    }
+    /**
+     * Allow to interact with a decorated collection
+     * @param {string} name the name of the collection to manipulate
+     * @param {(collection: CollectionBuilder) => unknown} handle a function that provide a
+     *   collection builder on the given collection name
+     * @example
+     * .customizeCollection('books', books => books.renameField('xx', 'yy'))
+     */
+    customizeCollection(name, handle) {
+        if (this.publication.getCollection(name)) {
+            handle(new collection_1.default(this, name));
+        }
+        return this;
+    }
+    /**
+     * Start the agent.
+     */
+    async start() {
+        return this.forestAdminHttpDriver.start();
+    }
+    /**
+     * Stop the agent gracefully.
+     */
+    async stop() {
+        return this.forestAdminHttpDriver.stop();
+    }
+}
+exports.default = AgentBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/builder/collection.d.ts

@@ -0,0 +1,148 @@
+import { ActionDefinition, Operator, OperatorReplacer, PartialRelationSchema, PlainSortClause, SegmentDefinition, WriteDefinition } from '@forestadmin/datasource-toolkit';
+import { FieldDefinition } from './types';
+import AgentBuilder from './agent';
+export default class CollectionBuilder {
+    private agentBuilder;
+    private readonly name;
+    constructor(agentBuilder: AgentBuilder, name: string);
+    /**
+     * Import a field from a many to one or one to one relation.
+     *
+     * @param name the name of the field that will be created on the collection
+     * @param options options to import the field
+     * @example
+     * .importField('authorName', { path: 'author:fullName' })
+     */
+    importField(name: string, options: {
+        path: string;
+        beforeRelations?: boolean;
+    }): 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
+     * @example
+     * .renameField('theCurrentNameOfTheField', 'theNewNameOfTheField');
+     */
+    renameField(oldName: string, newName: string): this;
+    /**
+     * Remove field by setting its visibility to false.
+     * @param {...string[]} names the fields to remove
+     * @example
+     * .removeField('aFieldToRemove', 'anOtherFieldToRemove');
+     */
+    removeField(...names: string[]): this;
+    /**
+     * Add a new action on the collection.
+     * @param {string} name the name of the action
+     * @param {ActionDefinition} definition the definition of the action
+     * @example
+     * .addAction('is live', {
+     *    scope: 'Single',
+     *    execute: async (context, responseBuilder) => {
+     *      return responseBuilder.success(`Is live!`);
+     *    },
+     *  })
+     */
+    addAction(name: string, definition: ActionDefinition): this;
+    /**
+     * Add a new field on the collection.
+     * @param {string} name the name of the field
+     * @param {FieldDefinition} definition The definition of the field
+     * @example
+     * .addField('fullName', {
+     *    columnType: 'String',
+     *    dependencies: ['firstName', 'lastName'],
+     *    getValues: (records) => records.map(record => `${record.lastName} ${record.firstName}`),
+     * });
+     */
+    addField(name: string, definition: FieldDefinition): 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: string, definition: PartialRelationSchema): this;
+    /**
+     * 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
+     * or a condition tree
+     * @example
+     * .addSegment(
+     *    'Wrote more than 2 books',
+     *    new ConditionTreeLeaf('booksCount', 'GreaterThan', 2),
+     * );
+     */
+    addSegment(name: string, definition: SegmentDefinition): 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
+     * @example
+     * .emulateFieldSorting('fullName');
+     */
+    emulateFieldSorting(name: string): 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
+     * @example
+     * .replaceFieldSorting(
+     *   'fullName',
+     *   [
+     *     { field: 'firstName', ascending: true },
+     *     { field: 'lastName',  ascending: true },
+     *   ]
+     * )
+     */
+    replaceFieldSorting(name: string, equivalentSort: PlainSortClause[]): this;
+    /**
+     * Enable filtering on a specific field using emulation.
+     * As for all the emulation method, the field filtering will be done in-memory.
+     * @param name the name of the field to enable emulation on
+     * @example
+     * .emulateFieldFiltering('aField');
+     */
+    emulateFieldFiltering(name: string): this;
+    /**
+     * 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
+     * @example
+     * .emulateFieldOperator('aField', 'In');
+     */
+    emulateFieldOperator(name: string, operator: Operator): 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
+     * @example
+     * .replaceFieldOperator('booksCount', 'Equal', ({ value }) => new ConditionTreeNot(
+     *   new ConditionTreeLeaf('booksCount', 'Equal', value),
+     * ));
+     */
+    replaceFieldOperator(name: string, operator: Operator, replacer: OperatorReplacer): 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
+     * @example
+     * .replaceFieldWriting('fullName', ({ patch: fullName }) => {
+     *   const [firstName, lastName] = fullName.split(' ');
+     *   return { firstName, lastName };
+     * });
+     */
+    replaceFieldWriting(name: string, definition: WriteDefinition): this;
+}
+//# sourceMappingURL=collection.d.ts.map