@forestadmin/agent 1.0.0-beta.1

package/dist/agent/services/permissions.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const object_hash_1 = __importDefault(require("object-hash"));
+const types_1 = require("../types");
+const forest_http_api_1 = __importDefault(require("../utils/forest-http-api"));
+class PermissionService {
+    constructor(options) {
+        this.options = options;
+        this.cache = new lru_cache_1.default({
+            max: 256,
+            ttl: this.options.permissionsCacheDurationInSeconds * 1000,
+        });
+    }
+    invalidateCache(renderingId) {
+        this.cache.delete(renderingId);
+    }
+    /** Checks that a charting query is in the list of allowed queries */
+    async canChart(context) {
+        const chart = { ...context.request.body };
+        // When the server sends the data of the allowed charts, the target column is not specified
+        // for relations => allow them all.
+        if (chart?.group_by_field?.includes(':'))
+            chart.group_by_field = chart.group_by_field.substring(0, chart.group_by_field.indexOf(':'));
+        const chartHash = (0, object_hash_1.default)(chart, {
+            respectType: false,
+            excludeKeys: key => chart[key] === null,
+        });
+        await this.can(context, `chart:${chartHash}`);
+    }
+    /** Check if a user is allowed to perform a specific action */
+    async can(context, action, allowRefetch = true) {
+        const { id: userId, renderingId } = context.state.user;
+        const perms = await this.getRenderingPermissions(renderingId);
+        const isAllowed = perms.actions.has(action) || perms.actionsByUser[action]?.has(userId);
+        if (!isAllowed && allowRefetch) {
+            this.invalidateCache(renderingId);
+            return this.can(context, action, false);
+        }
+        if (!isAllowed) {
+            context.throw(types_1.HttpCode.Forbidden, 'Forbidden');
+        }
+    }
+    async getScope(collection, context) {
+        const { user } = context.state;
+        const perms = await this.getRenderingPermissions(user.renderingId);
+        const scopes = perms.scopes[collection.name];
+        if (!scopes)
+            return null;
+        return scopes.conditionTree.replaceLeafs(leaf => {
+            const dynamicValues = scopes.dynamicScopeValues?.[user.id];
+            if (typeof leaf.value === 'string' && leaf.value.startsWith('$currentUser')) {
+                // Search replacement hash from forestadmin server
+                if (dynamicValues) {
+                    return leaf.override({ value: dynamicValues[leaf.value] });
+                }
+                // Search JWT token (new user)
+                return leaf.override({
+                    value: leaf.value.startsWith('$currentUser.tags.')
+                        ? user.tags[leaf.value.substring(18)]
+                        : user[leaf.value.substring(13)],
+                });
+            }
+            return leaf;
+        });
+    }
+    /** Get cached version of "rendering permissions" */
+    getRenderingPermissions(renderingId) {
+        if (!this.cache.has(renderingId))
+            this.cache.set(renderingId, forest_http_api_1.default.getPermissions(this.options, renderingId));
+        // We already checked the entry is up-to-date with the .has() call => allowStale
+        return this.cache.get(renderingId, { allowStale: true });
+    }
+}
+exports.default = PermissionService;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agent/services/serializer.d.ts

@@ -0,0 +1,17 @@
+import { Collection, RecordData } from '@forestadmin/datasource-toolkit';
+import { AgentOptionsWithDefaults } from '../types';
+declare type SerializerOptions = Pick<AgentOptionsWithDefaults, 'prefix'>;
+export default class Serializer {
+    private readonly serializers;
+    private readonly prefix;
+    constructor(options: SerializerOptions);
+    serialize(collection: Collection, data: RecordData | RecordData[]): unknown;
+    deserialize(collection: Collection, body: unknown): RecordData;
+    serializeWithSearchMetadata(collection: Collection, data: RecordData[], searchValue: string): unknown;
+    private getSerializer;
+    private registerCollection;
+    private buildRelationshipsConfiguration;
+    private stripUndefinedsInPlace;
+}
+export {};
+//# sourceMappingURL=serializer.d.ts.map

package/dist/agent/services/serializer.js

@@ -0,0 +1,120 @@
+"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 json_api_serializer_1 = __importDefault(require("json-api-serializer"));
+const id_1 = __importDefault(require("../utils/id"));
+class Serializer {
+    constructor(options) {
+        // No need to keep references to serializers for outdated schemas => weakmap.
+        this.serializers = new WeakMap();
+        this.prefix = options.prefix;
+    }
+    serialize(collection, data) {
+        const result = this.getSerializer(collection).serialize(collection.name, data);
+        this.stripUndefinedsInPlace(result);
+        return result;
+    }
+    deserialize(collection, body) {
+        return this.getSerializer(collection).deserialize(collection.name, body);
+    }
+    serializeWithSearchMetadata(collection, data, searchValue) {
+        const results = this.serialize(collection, data);
+        if (searchValue && searchValue.trim().length > 0) {
+            const resultsData = results.data;
+            const decorators = resultsData.reduce((decorator, record) => {
+                const search = Object.keys(record.attributes).filter(attribute => {
+                    const value = record.attributes[attribute];
+                    return value && value.toString().toLowerCase().includes(searchValue.toLowerCase());
+                });
+                if (search.length === 0) {
+                    return decorator;
+                }
+                return { ...decorator, [Object.keys(decorator).length]: { id: record.id, search } };
+            }, {});
+            if (Object.values(decorators).length === 0) {
+                return results;
+            }
+            results.meta = { decorators };
+        }
+        return results;
+    }
+    getSerializer(collection) {
+        if (this.serializers.has(collection.schema)) {
+            return this.serializers.get(collection.schema);
+        }
+        const serializer = new json_api_serializer_1.default();
+        for (const sibling of collection.dataSource.collections) {
+            this.registerCollection(sibling, serializer);
+            this.serializers.set(sibling.schema, serializer);
+        }
+        return serializer;
+    }
+    registerCollection(collection, serializer) {
+        serializer.register(collection.name, {
+            id: 'forestId',
+            relationships: this.buildRelationshipsConfiguration(collection),
+            beforeSerialize: (data) => {
+                const copy = { ...data };
+                copy.forestId = id_1.default.packId(collection.schema, data);
+                return copy;
+            },
+            afterDeserialize: (data) => {
+                const copy = { ...data };
+                if (data.forestId) {
+                    const parts = id_1.default.unpackId(collection.schema, data.forestId);
+                    const primaryKeys = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(collection.schema);
+                    primaryKeys.forEach((field, index) => {
+                        copy[field] = parts[index];
+                    });
+                }
+                delete copy.forestId;
+                return copy;
+            },
+        });
+    }
+    buildRelationshipsConfiguration(collection) {
+        const relationships = {};
+        const urlPrefix = `${this.prefix}/${collection.name}`;
+        for (const [name, field] of Object.entries(collection.schema.fields)) {
+            if (field.type === 'ManyToOne' || field.type === 'OneToOne') {
+                relationships[name] = {
+                    type: field.foreignCollection,
+                    deserialize: (data) => {
+                        const foreignCollection = collection.dataSource.getCollection(field.foreignCollection);
+                        return id_1.default.unpackId(foreignCollection.schema, data.id);
+                    },
+                };
+            }
+            if (field.type === 'ManyToMany' || field.type === 'OneToMany') {
+                relationships[name] = {
+                    type: field.foreignCollection,
+                    links: (data) => ({
+                        related: {
+                            href: `${urlPrefix}/${data.forestId}/relationships/${name}`,
+                        },
+                    }),
+                };
+            }
+        }
+        return relationships;
+    }
+    stripUndefinedsInPlace(record) {
+        if (record === null || typeof record !== 'object') {
+            return;
+        }
+        const indexable = record;
+        for (const key of Object.keys(indexable)) {
+            if (indexable[key] === undefined) {
+                delete indexable[key];
+            }
+            else {
+                this.stripUndefinedsInPlace(indexable[key]);
+            }
+        }
+    }
+}
+exports.default = Serializer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hZ2VudC9zZXJ2aWNlcy9zZXJpYWxpemVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBS3lDO0FBQ3pDLDhFQUFvRDtBQUdwRCxxREFBa0M7QUFLbEMsTUFBcUIsVUFBVTtJQUs3QixZQUFZLE9BQTBCO1FBSnRDLDZFQUE2RTtRQUM1RCxnQkFBVyxHQUFpRCxJQUFJLE9BQU8sRUFBRSxDQUFDO1FBSXpGLElBQUksQ0FBQyxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQztJQUMvQixDQUFDO0lBRUQsU0FBUyxDQUFDLFVBQXNCLEVBQUUsSUFBK0I7UUFDL0QsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztRQUMvRSxJQUFJLENBQUMsc0JBQXNCLENBQUMsTUFBTSxDQUFDLENBQUM7UUFFcEMsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQztJQUVELFdBQVcsQ0FBQyxVQUFzQixFQUFFLElBQWE7UUFDL0MsT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLFVBQVUsQ0FBQyxDQUFDLFdBQVcsQ0FBQyxVQUFVLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQzNFLENBQUM7SUFFRCwyQkFBMkIsQ0FDekIsVUFBc0IsRUFDdEIsSUFBa0IsRUFDbEIsV0FBbUI7UUFFbkIsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxVQUFVLEVBQUUsSUFBSSxDQUFlLENBQUM7UUFFL0QsSUFBSSxXQUFXLElBQUksV0FBVyxDQUFDLElBQUksRUFBRSxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7WUFDaEQsTUFBTSxXQUFXLEdBQUcsT0FBTyxDQUFDLElBQW9CLENBQUM7WUFDakQsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDLFNBQVMsRUFBRSxNQUFrQixFQUFFLEVBQUU7Z0JBQ3RFLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsRUFBRTtvQkFDL0QsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsQ0FBQztvQkFFM0MsT0FBTyxLQUFLLElBQUksS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztnQkFDckYsQ0FBQyxDQUFDLENBQUM7Z0JBRUgsSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtvQkFDdkIsT0FBTyxTQUFTLENBQUM7aUJBQ2xCO2dCQUVELE9BQU8sRUFBRSxHQUFHLFNBQVMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsTUFBTSxDQUFDLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxDQUFDO1lBQ3RGLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztZQUVQLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFO2dCQUMxQyxPQUFPLE9BQU8sQ0FBQzthQUNoQjtZQUVELE9BQU8sQ0FBQyxJQUFJLEdBQUcsRUFBRSxVQUFVLEVBQUUsQ0FBQztTQUMvQjtRQUVELE9BQU8sT0FBTyxDQUFDO0lBQ2pCLENBQUM7SUFFTyxhQUFhLENBQUMsVUFBc0I7UUFDMUMsSUFBSSxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLEVBQUU7WUFDM0MsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUM7U0FDaEQ7UUFFRCxNQUFNLFVBQVUsR0FBRyxJQUFJLDZCQUFpQixFQUFFLENBQUM7UUFFM0MsS0FBSyxNQUFNLE9BQU8sSUFBSSxVQUFVLENBQUMsVUFBVSxDQUFDLFdBQVcsRUFBRTtZQUN2RCxJQUFJLENBQUMsa0JBQWtCLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBQzdDLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsVUFBVSxDQUFDLENBQUM7U0FDbEQ7UUFFRCxPQUFPLFVBQVUsQ0FBQztJQUNwQixDQUFDO0lBRU8sa0JBQWtCLENBQUMsVUFBc0IsRUFBRSxVQUE2QjtRQUM5RSxVQUFVLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxJQUFJLEVBQUU7WUFDbkMsRUFBRSxFQUFFLFVBQVU7WUFDZCxhQUFhLEVBQUUsSUFBSSxDQUFDLCtCQUErQixDQUFDLFVBQVUsQ0FBQztZQUMvRCxlQUFlLEVBQUUsQ0FBQyxJQUE2QixFQUFFLEVBQUU7Z0JBQ2pELE1BQU0sSUFBSSxHQUFHLEVBQUUsR0FBRyxJQUFJLEVBQUUsQ0FBQztnQkFDekIsSUFBSSxDQUFDLFFBQVEsR0FBRyxZQUFPLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7Z0JBRXhELE9BQU8sSUFBSSxDQUFDO1lBQ2QsQ0FBQztZQUNELGdCQUFnQixFQUFFLENBQUMsSUFBNkIsRUFBRSxFQUFFO2dCQUNsRCxNQUFNLElBQUksR0FBRyxFQUFFLEdBQUcsSUFBSSxFQUFFLENBQUM7Z0JBRXpCLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRTtvQkFDakIsTUFBTSxLQUFLLEdBQUcsWUFBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxRQUFrQixDQUFDLENBQUM7b0JBQzNFLE1BQU0sV0FBVyxHQUFHLGdDQUFXLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztvQkFDbEUsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRTt3QkFDbkMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztvQkFDN0IsQ0FBQyxDQUFDLENBQUM7aUJBQ0o7Z0JBRUQsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDO2dCQUVyQixPQUFPLElBQUksQ0FBQztZQUNkLENBQUM7U0FDRixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU8sK0JBQStCLENBQ3JDLFVBQXNCO1FBRXRCLE1BQU0sYUFBYSxHQUEwRCxFQUFFLENBQUM7UUFDaEYsTUFBTSxTQUFTLEdBQUcsR0FBRyxJQUFJLENBQUMsTUFBTSxJQUFJLFVBQVUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUV0RCxLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQ3BFLElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxXQUFXLElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxVQUFVLEVBQUU7Z0JBQzNELGFBQWEsQ0FBQyxJQUFJLENBQUMsR0FBRztvQkFDcEIsSUFBSSxFQUFFLEtBQUssQ0FBQyxpQkFBaUI7b0JBQzdCLFdBQVcsRUFBRSxDQUFDLElBQTZCLEVBQUUsRUFBRTt3QkFDN0MsTUFBTSxpQkFBaUIsR0FBRyxVQUFVLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsaUJBQWlCLENBQUMsQ0FBQzt3QkFFdkYsT0FBTyxZQUFPLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBWSxDQUFDLENBQUM7b0JBQ3ZFLENBQUM7aUJBQ0YsQ0FBQzthQUNIO1lBRUQsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLFlBQVksSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLFdBQVcsRUFBRTtnQkFDN0QsYUFBYSxDQUFDLElBQUksQ0FBQyxHQUFHO29CQUNwQixJQUFJLEVBQUUsS0FBSyxDQUFDLGlCQUFpQjtvQkFDN0IsS0FBSyxFQUFFLENBQUMsSUFBc0IsRUFBRSxFQUFFLENBQUMsQ0FBQzt3QkFDbEMsT0FBTyxFQUFFOzRCQUNQLElBQUksRUFBRSxHQUFHLFNBQVMsSUFBSSxJQUFJLENBQUMsUUFBUSxrQkFBa0IsSUFBSSxFQUFFO3lCQUM1RDtxQkFDRixDQUFDO2lCQUNILENBQUM7YUFDSDtTQUNGO1FBRUQsT0FBTyxhQUFhLENBQUM7SUFDdkIsQ0FBQztJQUVPLHNCQUFzQixDQUFDLE1BQWU7UUFDNUMsSUFBSSxNQUFNLEtBQUssSUFBSSxJQUFJLE9BQU8sTUFBTSxLQUFLLFFBQVEsRUFBRTtZQUNqRCxPQUFPO1NBQ1I7UUFFRCxNQUFNLFNBQVMsR0FBRyxNQUFpQyxDQUFDO1FBRXBELEtBQUssTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUN4QyxJQUFJLFNBQVMsQ0FBQyxHQUFHLENBQUMsS0FBSyxTQUFTLEVBQUU7Z0JBQ2hDLE9BQU8sU0FBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDO2FBQ3ZCO2lCQUFNO2dCQUNMLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQzthQUM3QztTQUNGO0lBQ0gsQ0FBQztDQUNGO0FBaEpELDZCQWdKQyJ9

package/dist/agent/types.d.ts

@@ -0,0 +1,23 @@
+import { CompositeId } from '@forestadmin/datasource-toolkit';
+import { AgentOptions } from '../types';
+export declare enum HttpCode {
+    BadRequest = 400,
+    Forbidden = 403,
+    InternalServerError = 500,
+    NoContent = 204,
+    NotFound = 404,
+    Ok = 200
+}
+export declare enum RouteType {
+    Logger = 0,
+    ErrorHandler = 1,
+    PublicRoute = 2,
+    Authentication = 3,
+    PrivateRoute = 4
+}
+export declare type SelectionIds = {
+    areExcluded: boolean;
+    ids: CompositeId[];
+};
+export declare type AgentOptionsWithDefaults = Readonly<Required<AgentOptions>>;
+//# sourceMappingURL=types.d.ts.map

package/dist/agent/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteType = exports.HttpCode = void 0;
+var HttpCode;
+(function (HttpCode) {
+    HttpCode[HttpCode["BadRequest"] = 400] = "BadRequest";
+    HttpCode[HttpCode["Forbidden"] = 403] = "Forbidden";
+    HttpCode[HttpCode["InternalServerError"] = 500] = "InternalServerError";
+    HttpCode[HttpCode["NoContent"] = 204] = "NoContent";
+    HttpCode[HttpCode["NotFound"] = 404] = "NotFound";
+    HttpCode[HttpCode["Ok"] = 200] = "Ok";
+})(HttpCode = exports.HttpCode || (exports.HttpCode = {}));
+var RouteType;
+(function (RouteType) {
+    // Changing the values of this enum changes the order in which routes are loaded into koa-router.
+    RouteType[RouteType["Logger"] = 0] = "Logger";
+    RouteType[RouteType["ErrorHandler"] = 1] = "ErrorHandler";
+    RouteType[RouteType["PublicRoute"] = 2] = "PublicRoute";
+    RouteType[RouteType["Authentication"] = 3] = "Authentication";
+    RouteType[RouteType["PrivateRoute"] = 4] = "PrivateRoute";
+})(RouteType = exports.RouteType || (exports.RouteType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWdlbnQvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBSUEsSUFBWSxRQU9YO0FBUEQsV0FBWSxRQUFRO0lBQ2xCLHFEQUFnQixDQUFBO0lBQ2hCLG1EQUFlLENBQUE7SUFDZix1RUFBeUIsQ0FBQTtJQUN6QixtREFBZSxDQUFBO0lBQ2YsaURBQWMsQ0FBQTtJQUNkLHFDQUFRLENBQUE7QUFDVixDQUFDLEVBUFcsUUFBUSxHQUFSLGdCQUFRLEtBQVIsZ0JBQVEsUUFPbkI7QUFFRCxJQUFZLFNBT1g7QUFQRCxXQUFZLFNBQVM7SUFDbkIsaUdBQWlHO0lBQ2pHLDZDQUFVLENBQUE7SUFDVix5REFBZ0IsQ0FBQTtJQUNoQix1REFBZSxDQUFBO0lBQ2YsNkRBQWtCLENBQUE7SUFDbEIseURBQWdCLENBQUE7QUFDbEIsQ0FBQyxFQVBXLFNBQVMsR0FBVCxpQkFBUyxLQUFULGlCQUFTLFFBT3BCIn0=

package/dist/agent/utils/body-parser.d.ts

@@ -0,0 +1,7 @@
+import { CollectionSchema } from '@forestadmin/datasource-toolkit';
+import { Context } from 'koa';
+import { SelectionIds } from '../types';
+export default class BodyParser {
+    static parseSelectionIds(schema: CollectionSchema, context: Context): SelectionIds;
+}
+//# sourceMappingURL=body-parser.d.ts.map

package/dist/agent/utils/body-parser.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const id_1 = __importDefault(require("./id"));
+class BodyParser {
+    static parseSelectionIds(schema, context) {
+        const data = context.request.body?.data;
+        const attributes = data?.attributes;
+        const areExcluded = Boolean(attributes?.all_records);
+        let ids = attributes?.ids || (Array.isArray(data) && data.map(r => r.id)) || undefined;
+        ids = id_1.default.unpackIds(schema, areExcluded ? attributes?.all_records_ids_excluded : ids);
+        return { areExcluded, ids };
+    }
+}
+exports.default = BodyParser;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9keS1wYXJzZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWdlbnQvdXRpbHMvYm9keS1wYXJzZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFHQSw4Q0FBMkI7QUFFM0IsTUFBcUIsVUFBVTtJQUM3QixNQUFNLENBQUMsaUJBQWlCLENBQUMsTUFBd0IsRUFBRSxPQUFnQjtRQUNqRSxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUM7UUFDeEMsTUFBTSxVQUFVLEdBQUcsSUFBSSxFQUFFLFVBQVUsQ0FBQztRQUNwQyxNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsVUFBVSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBQ3JELElBQUksR0FBRyxHQUFHLFVBQVUsRUFBRSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsSUFBSSxTQUFTLENBQUM7UUFDdkYsR0FBRyxHQUFHLFlBQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUMsVUFBVSxFQUFFLHdCQUF3QixDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUUxRixPQUFPLEVBQUUsV0FBVyxFQUFFLEdBQUcsRUFBRSxDQUFDO0lBQzlCLENBQUM7Q0FDRjtBQVZELDZCQVVDIn0=

package/dist/agent/utils/context-filter-factory.d.ts

@@ -0,0 +1,7 @@
+import { Collection, ConditionTree, Filter, PaginatedFilter } from '@forestadmin/datasource-toolkit';
+import { Context } from 'koa';
+export default class ContextFilterFactory {
+    static buildPaginated(collection: Collection, context: Context, scope: ConditionTree, partialFilter?: Partial<PaginatedFilter>): PaginatedFilter;
+    static build(collection: Collection, context: Context, scope: ConditionTree, partialFilter?: Partial<Filter>): PaginatedFilter;
+}
+//# sourceMappingURL=context-filter-factory.d.ts.map

package/dist/agent/utils/context-filter-factory.js

@@ -0,0 +1,29 @@
+"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 query_string_1 = __importDefault(require("./query-string"));
+class ContextFilterFactory {
+    static buildPaginated(collection, context, scope, partialFilter) {
+        return new datasource_toolkit_1.PaginatedFilter({
+            sort: query_string_1.default.parseSort(collection, context),
+            page: query_string_1.default.parsePagination(context),
+            ...ContextFilterFactory.build(collection, context, scope),
+            ...partialFilter,
+        });
+    }
+    static build(collection, context, scope, partialFilter) {
+        return new datasource_toolkit_1.Filter({
+            search: query_string_1.default.parseSearch(collection, context),
+            segment: query_string_1.default.parseSegment(collection, context),
+            timezone: query_string_1.default.parseTimezone(context),
+            searchExtended: query_string_1.default.parseSearchExtended(context),
+            conditionTree: datasource_toolkit_1.ConditionTreeFactory.intersect(query_string_1.default.parseConditionTree(collection, context), scope),
+            ...partialFilter,
+        });
+    }
+}
+exports.default = ContextFilterFactory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC1maWx0ZXItZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hZ2VudC91dGlscy9jb250ZXh0LWZpbHRlci1mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBTXlDO0FBRXpDLGtFQUErQztBQUUvQyxNQUFxQixvQkFBb0I7SUFDdkMsTUFBTSxDQUFDLGNBQWMsQ0FDbkIsVUFBc0IsRUFDdEIsT0FBZ0IsRUFDaEIsS0FBb0IsRUFDcEIsYUFBd0M7UUFFeEMsT0FBTyxJQUFJLG9DQUFlLENBQUM7WUFDekIsSUFBSSxFQUFFLHNCQUFpQixDQUFDLFNBQVMsQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDO1lBQ3RELElBQUksRUFBRSxzQkFBaUIsQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDO1lBQ2hELEdBQUcsb0JBQW9CLENBQUMsS0FBSyxDQUFDLFVBQVUsRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDO1lBQ3pELEdBQUcsYUFBYTtTQUNqQixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQUssQ0FDVixVQUFzQixFQUN0QixPQUFnQixFQUNoQixLQUFvQixFQUNwQixhQUErQjtRQUUvQixPQUFPLElBQUksMkJBQU0sQ0FBQztZQUNoQixNQUFNLEVBQUUsc0JBQWlCLENBQUMsV0FBVyxDQUFDLFVBQVUsRUFBRSxPQUFPLENBQUM7WUFDMUQsT0FBTyxFQUFFLHNCQUFpQixDQUFDLFlBQVksQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDO1lBQzVELFFBQVEsRUFBRSxzQkFBaUIsQ0FBQyxhQUFhLENBQUMsT0FBTyxDQUFDO1lBQ2xELGNBQWMsRUFBRSxzQkFBaUIsQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUM7WUFDOUQsYUFBYSxFQUFFLHlDQUFvQixDQUFDLFNBQVMsQ0FDM0Msc0JBQWlCLENBQUMsa0JBQWtCLENBQUMsVUFBVSxFQUFFLE9BQU8sQ0FBQyxFQUN6RCxLQUFLLENBQ047WUFDRCxHQUFHLGFBQWE7U0FDakIsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBakNELHVDQWlDQyJ9

package/dist/agent/utils/csv-generator.d.ts

@@ -0,0 +1,12 @@
+import { Collection, PaginatedFilter, Projection } from '@forestadmin/datasource-toolkit';
+export declare const CHUNK_SIZE = 1000;
+export default class CsvGenerator {
+    /**
+     * Use an async generator to ensure that
+     * - backpressure is properly applied without needing to extend Readable (for slow clients)
+     * - we stop making queries to the database if the client closes the connection.
+     */
+    static generate(projection: Projection, header: string, filter: PaginatedFilter, collection: Collection, list: Collection['list']): AsyncGenerator<string>;
+    private static convert;
+}
+//# sourceMappingURL=csv-generator.d.ts.map

package/dist/agent/utils/csv-generator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHUNK_SIZE = void 0;
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const format_1 = require("@fast-csv/format");
+exports.CHUNK_SIZE = 1000;
+class CsvGenerator {
+    /**
+     * Use an async generator to ensure that
+     * - backpressure is properly applied without needing to extend Readable (for slow clients)
+     * - we stop making queries to the database if the client closes the connection.
+     */
+    static async *generate(projection, header, filter, collection, list) {
+        yield (0, format_1.writeToString)([header.split(',')], { headers: true, includeEndRowDelimiter: true });
+        const limit = filter.page?.limit;
+        let skip = filter.page?.skip || 0;
+        let areAllRecordsFetched = false;
+        const copiedFilter = { ...filter };
+        while (!areAllRecordsFetched) {
+            let currentPageSize = exports.CHUNK_SIZE;
+            if (limit < skip)
+                currentPageSize = skip - limit;
+            copiedFilter.page = new datasource_toolkit_1.Page(skip, currentPageSize);
+            if (!copiedFilter.sort || copiedFilter.sort.length === 0) {
+                copiedFilter.sort = datasource_toolkit_1.SortFactory.byPrimaryKeys(collection);
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const records = await list(new datasource_toolkit_1.PaginatedFilter(copiedFilter), projection);
+            yield CsvGenerator.convert(records, projection);
+            areAllRecordsFetched = records.length < exports.CHUNK_SIZE;
+            skip += currentPageSize;
+        }
+    }
+    static convert(records, projection) {
+        return (0, format_1.writeToString)(records.map(record => projection.map(field => datasource_toolkit_1.RecordUtils.getFieldValue(record, field))));
+    }
+}
+exports.default = CsvGenerator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3N2LWdlbmVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hZ2VudC91dGlscy9jc3YtZ2VuZXJhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHdFQVF5QztBQUN6Qyw2Q0FBaUQ7QUFFcEMsUUFBQSxVQUFVLEdBQUcsSUFBSSxDQUFDO0FBRS9CLE1BQXFCLFlBQVk7SUFDL0I7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxRQUFRLENBQ3BCLFVBQXNCLEVBQ3RCLE1BQWMsRUFDZCxNQUF1QixFQUN2QixVQUFzQixFQUN0QixJQUF3QjtRQUV4QixNQUFNLElBQUEsc0JBQWEsRUFBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsc0JBQXNCLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUUxRixNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQztRQUNqQyxJQUFJLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxFQUFFLElBQUksSUFBSSxDQUFDLENBQUM7UUFFbEMsSUFBSSxvQkFBb0IsR0FBRyxLQUFLLENBQUM7UUFDakMsTUFBTSxZQUFZLEdBQUcsRUFBRSxHQUFHLE1BQU0sRUFBRSxDQUFDO1FBRW5DLE9BQU8sQ0FBQyxvQkFBb0IsRUFBRTtZQUM1QixJQUFJLGVBQWUsR0FBRyxrQkFBVSxDQUFDO1lBQ2pDLElBQUksS0FBSyxHQUFHLElBQUk7Z0JBQUUsZUFBZSxHQUFHLElBQUksR0FBRyxLQUFLLENBQUM7WUFFakQsWUFBWSxDQUFDLElBQUksR0FBRyxJQUFJLHlCQUFJLENBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxDQUFDO1lBRXBELElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxJQUFJLFlBQVksQ0FBQyxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtnQkFDeEQsWUFBWSxDQUFDLElBQUksR0FBRyxnQ0FBVyxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsQ0FBQzthQUMzRDtZQUVELDRDQUE0QztZQUM1QyxNQUFNLE9BQU8sR0FBRyxNQUFNLElBQUksQ0FBQyxJQUFJLG9DQUFlLENBQUMsWUFBWSxDQUFDLEVBQUUsVUFBVSxDQUFDLENBQUM7WUFFMUUsTUFBTSxZQUFZLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsQ0FBQztZQUVoRCxvQkFBb0IsR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLGtCQUFVLENBQUM7WUFDbkQsSUFBSSxJQUFJLGVBQWUsQ0FBQztTQUN6QjtJQUNILENBQUM7SUFFTyxNQUFNLENBQUMsT0FBTyxDQUFDLE9BQXFCLEVBQUUsVUFBc0I7UUFDbEUsT0FBTyxJQUFBLHNCQUFhLEVBQ2xCLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsZ0NBQVcsQ0FBQyxhQUFhLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FDekYsQ0FBQztJQUNKLENBQUM7Q0FDRjtBQTlDRCwrQkE4Q0MifQ==

package/dist/agent/utils/csv-route-context.d.ts

@@ -0,0 +1,5 @@
+import { Context } from 'koa';
+export default class CsvRouteContext {
+    static buildResponse(context: Context): void;
+}
+//# sourceMappingURL=csv-route-context.d.ts.map

package/dist/agent/utils/csv-route-context.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CsvRouteContext {
+    static buildResponse(context) {
+        const { filename } = context.request.query;
+        context.response.type = 'text/csv; charset=utf-8';
+        context.response.attachment(`attachment; filename=${filename}`);
+        context.response.lastModified = new Date();
+        context.response.set({ 'X-Accel-Buffering': 'no' });
+        context.response.set({ 'Cache-Control': 'no-cache' });
+    }
+}
+exports.default = CsvRouteContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3N2LXJvdXRlLWNvbnRleHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWdlbnQvdXRpbHMvY3N2LXJvdXRlLWNvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxNQUFxQixlQUFlO0lBQ2xDLE1BQU0sQ0FBQyxhQUFhLENBQUMsT0FBZ0I7UUFDbkMsTUFBTSxFQUFFLFFBQVEsRUFBRSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO1FBRTNDLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSSxHQUFHLHlCQUF5QixDQUFDO1FBQ2xELE9BQU8sQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLHdCQUF3QixRQUFRLEVBQUUsQ0FBQyxDQUFDO1FBQ2hFLE9BQU8sQ0FBQyxRQUFRLENBQUMsWUFBWSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7UUFDM0MsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRSxtQkFBbUIsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQ3BELE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUUsZUFBZSxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDeEQsQ0FBQztDQUNGO0FBVkQsa0NBVUMifQ==

package/dist/agent/utils/forest-http-api.d.ts

@@ -0,0 +1,63 @@
+import { ConditionTree } from '@forestadmin/datasource-toolkit';
+import { IssuerMetadata } from 'openid-client';
+import { JSONAPIDocument } from 'json-api-serializer';
+import { AgentOptions } from '../../types';
+export declare type IpWhitelistConfiguration = {
+    isFeatureEnabled: boolean;
+    ipRules: Array<{
+        type: number;
+        ipMinimum?: string;
+        ipMaximum?: string;
+        ip?: string;
+        range?: string;
+    }>;
+};
+export declare type UserInfo = {
+    id: number;
+    email: string;
+    firstName: string;
+    lastName: string;
+    team: string;
+    renderingId: number;
+    role: string;
+    tags: {
+        [key: string]: string;
+    };
+};
+export declare type RenderingPermissions = {
+    actions: Set<string>;
+    actionsByUser: {
+        [actionName: string]: Set<number>;
+    };
+    scopes: {
+        [collectionName: string]: {
+            conditionTree: ConditionTree;
+            dynamicScopeValues: {
+                [userId: number]: {
+                    [replacementKey: string]: unknown;
+                };
+            };
+        };
+    };
+};
+declare type HttpOptions = Pick<AgentOptions, 'envSecret' | 'forestServerUrl' | 'isProduction'>;
+export default class ForestHttpApi {
+    static getIpWhitelistConfiguration(options: HttpOptions): Promise<IpWhitelistConfiguration>;
+    static getOpenIdIssuerMetadata(options: HttpOptions): Promise<IssuerMetadata>;
+    static getUserInformation(options: HttpOptions, renderingId: number, accessToken: string): Promise<UserInfo>;
+    static hasSchema(options: HttpOptions, hash: string): Promise<boolean>;
+    static uploadSchema(options: HttpOptions, apimap: JSONAPIDocument): Promise<void>;
+    static getPermissions(options: HttpOptions, renderingId: number): Promise<RenderingPermissions>;
+    /** Helper to format permissions into something easy to validate against */
+    private static decodeChartPermissions;
+    /**
+     * Helper to format permissions into something easy to validate against
+     * Note that the format the server is sending varies depending on if we're using a remote or
+     * local environment.
+     */
+    private static decodeActionPermissions;
+    /** Helper to format permissions into something easy to validate against */
+    private static decodeScopePermissions;
+}
+export {};
+//# sourceMappingURL=forest-http-api.d.ts.map