@forestadmin/agent 1.0.0-beta.1

package/dist/agent/utils/forest-http-api.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const object_hash_1 = __importDefault(require("object-hash"));
+const superagent_1 = __importDefault(require("superagent"));
+class ForestHttpApi {
+    static async getIpWhitelistConfiguration(options) {
+        try {
+            const response = await superagent_1.default
+                .get(new URL('/liana/v1/ip-whitelist-rules', options.forestServerUrl).toString())
+                .set('forest-secret-key', options.envSecret);
+            const { attributes } = response.body.data;
+            return { isFeatureEnabled: attributes.use_ip_whitelist, ipRules: attributes.rules };
+        }
+        catch {
+            throw new Error('An error occurred while retrieving your IP whitelist.');
+        }
+    }
+    static async getOpenIdIssuerMetadata(options) {
+        try {
+            const response = await superagent_1.default
+                .get(new URL('/oidc/.well-known/openid-configuration', options.forestServerUrl).toString())
+                .set('forest-secret-key', options.envSecret);
+            return response.body;
+        }
+        catch {
+            throw new Error('Failed to fetch open-id issuer metadata.');
+        }
+    }
+    static async getUserInformation(options, renderingId, accessToken) {
+        try {
+            const url = new URL(`/liana/v2/renderings/${renderingId}/authorization`, options.forestServerUrl);
+            const response = await superagent_1.default
+                .get(url.toString())
+                .set('forest-token', accessToken)
+                .set('forest-secret-key', options.envSecret);
+            const { attributes, id } = response.body.data;
+            return {
+                id: Number(id),
+                email: attributes.email,
+                firstName: attributes.first_name,
+                lastName: attributes.last_name,
+                team: attributes.teams[0],
+                role: attributes.role,
+                tags: attributes.tags?.reduce((memo, { key, value }) => ({ ...memo, [key]: value }), {}),
+                renderingId,
+            };
+        }
+        catch {
+            throw new Error('Failed to retrieve authorization informations.');
+        }
+    }
+    static async hasSchema(options, hash) {
+        const response = await superagent_1.default
+            .post(new URL('/forest/apimaps/hashcheck', options.forestServerUrl).toString())
+            .send({ schemaFileHash: hash })
+            .set('forest-secret-key', options.envSecret);
+        return !response?.body?.sendSchema;
+    }
+    static async uploadSchema(options, apimap) {
+        try {
+            await superagent_1.default
+                .post(new URL('/forest/apimaps', options.forestServerUrl).toString())
+                .send(apimap)
+                .set('forest-secret-key', options.envSecret);
+        }
+        catch (e) {
+            // Sending the schema to forestadmin-server is mandatory: crash the server gracefully
+            let message;
+            switch (e.response?.status) {
+                case 0:
+                    message = 'Cannot send the apimap to Forest. Are you online?';
+                    break;
+                case 404:
+                    message =
+                        'Cannot find the project related to the envSecret you configured. ' +
+                            'Can you check on Forest that you copied it properly in the Forest initialization?';
+                    break;
+                case 503:
+                    message =
+                        'Forest is in maintenance for a few minutes. ' +
+                            'We are upgrading your experience in the forest. ' +
+                            'We just need a few more minutes to get it right.';
+                    break;
+                default:
+                    message =
+                        'An error occured with the apimap sent to Forest. ' +
+                            'Please contact support@forestadmin.com for further investigations.';
+            }
+            throw new Error(message);
+        }
+    }
+    static async getPermissions(options, renderingId) {
+        const { body } = await superagent_1.default
+            .get(`${options.forestServerUrl}/liana/v3/permissions`)
+            .set('forest-secret-key', options.envSecret)
+            .query(`renderingId=${renderingId}`);
+        if (!body.meta?.rolesACLActivated) {
+            throw new Error('Roles V2 are unsupported');
+        }
+        const actions = new Set();
+        const actionsByUser = {};
+        ForestHttpApi.decodeChartPermissions(body?.stats ?? {}, actions);
+        ForestHttpApi.decodeActionPermissions(body?.data?.collections ?? {}, actions, actionsByUser);
+        return {
+            actions,
+            actionsByUser,
+            scopes: ForestHttpApi.decodeScopePermissions(body?.data?.renderings?.[renderingId] ?? {}),
+        };
+    }
+    /** Helper to format permissions into something easy to validate against */
+    static decodeChartPermissions(chartsByType, actions) {
+        const serverCharts = Object.values(chartsByType).flat();
+        const frontendCharts = serverCharts.map(chart => ({
+            type: chart.type,
+            filters: chart.filter,
+            aggregate: chart.aggregator,
+            aggregate_field: chart.aggregateFieldName,
+            collection: chart.sourceCollectionId,
+            time_range: chart.timeRange,
+            group_by_date_field: (chart.type === 'Line' && chart.groupByFieldName) || null,
+            group_by_field: (chart.type !== 'Line' && chart.groupByFieldName) || null,
+            limit: chart.limit,
+            label_field: chart.labelFieldName,
+            relationship_field: chart.relationshipFieldName,
+        }));
+        const hashes = frontendCharts.map(chart => (0, object_hash_1.default)(chart, {
+            respectType: false,
+            excludeKeys: key => chart[key] === null || chart[key] === undefined,
+        }));
+        hashes.forEach(hash => actions.add(`chart:${hash}`));
+    }
+    /**
+     * 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.
+     */
+    static decodeActionPermissions(collections, actions, actionsByUser) {
+        for (const [name, settings] of Object.entries(collections)) {
+            for (const [actionName, userIds] of Object.entries(settings.collection ?? {})) {
+                const shortName = actionName.substring(0, actionName.length - 'Enabled'.length);
+                if (typeof userIds === 'boolean')
+                    actions.add(`${shortName}:${name}`);
+                else
+                    actionsByUser[`${shortName}:${name}`] = new Set(userIds);
+            }
+            for (const [actionName, actionPerms] of Object.entries(settings.actions ?? {})) {
+                const userIds = actionPerms.triggerEnabled;
+                if (typeof userIds === 'boolean')
+                    actions.add(`custom:${actionName}:${name}`);
+                else
+                    actionsByUser[`custom:${actionName}:${name}`] = new Set(userIds);
+            }
+        }
+    }
+    /** Helper to format permissions into something easy to validate against */
+    static decodeScopePermissions(rendering) {
+        const scopes = {};
+        for (const [name, { scope }] of Object.entries(rendering)) {
+            scopes[name] = scope && {
+                conditionTree: datasource_toolkit_1.ConditionTreeFactory.fromPlainObject(scope.filter),
+                dynamicScopeValues: scope.dynamicScopesValues?.users ?? {},
+            };
+        }
+        return scopes;
+    }
+}
+exports.default = ForestHttpApi;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yZXN0LWh0dHAtYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FnZW50L3V0aWxzL2ZvcmVzdC1odHRwLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHVEQUF1RDtBQUN2RCx3RUFBc0Y7QUFHdEYsOERBQXFDO0FBQ3JDLDREQUFpRTtBQXVDakUsTUFBcUIsYUFBYTtJQUNoQyxNQUFNLENBQUMsS0FBSyxDQUFDLDJCQUEyQixDQUN0QyxPQUFvQjtRQUVwQixJQUFJO1lBQ0YsTUFBTSxRQUFRLEdBQWEsTUFBTSxvQkFBVTtpQkFDeEMsR0FBRyxDQUFDLElBQUksR0FBRyxDQUFDLDhCQUE4QixFQUFFLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztpQkFDaEYsR0FBRyxDQUFDLG1CQUFtQixFQUFFLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUUvQyxNQUFNLEVBQUUsVUFBVSxFQUFFLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUM7WUFFMUMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLFVBQVUsQ0FBQyxnQkFBZ0IsRUFBRSxPQUFPLEVBQUUsVUFBVSxDQUFDLEtBQUssRUFBRSxDQUFDO1NBQ3JGO1FBQUMsTUFBTTtZQUNOLE1BQU0sSUFBSSxLQUFLLENBQUMsdURBQXVELENBQUMsQ0FBQztTQUMxRTtJQUNILENBQUM7SUFFRCxNQUFNLENBQUMsS0FBSyxDQUFDLHVCQUF1QixDQUFDLE9BQW9CO1FBQ3ZELElBQUk7WUFDRixNQUFNLFFBQVEsR0FBYSxNQUFNLG9CQUFVO2lCQUN4QyxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUMsd0NBQXdDLEVBQUUsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDO2lCQUMxRixHQUFHLENBQUMsbUJBQW1CLEVBQUUsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBRS9DLE9BQU8sUUFBUSxDQUFDLElBQUksQ0FBQztTQUN0QjtRQUFDLE1BQU07WUFDTixNQUFNLElBQUksS0FBSyxDQUFDLDBDQUEwQyxDQUFDLENBQUM7U0FDN0Q7SUFDSCxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsQ0FDN0IsT0FBb0IsRUFDcEIsV0FBbUIsRUFDbkIsV0FBbUI7UUFFbkIsSUFBSTtZQUNGLE1BQU0sR0FBRyxHQUFHLElBQUksR0FBRyxDQUNqQix3QkFBd0IsV0FBVyxnQkFBZ0IsRUFDbkQsT0FBTyxDQUFDLGVBQWUsQ0FDeEIsQ0FBQztZQUVGLE1BQU0sUUFBUSxHQUFHLE1BQU0sb0JBQVU7aUJBQzlCLEdBQUcsQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLENBQUM7aUJBQ25CLEdBQUcsQ0FBQyxjQUFjLEVBQUUsV0FBVyxDQUFDO2lCQUNoQyxHQUFHLENBQUMsbUJBQW1CLEVBQUUsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBRS9DLE1BQU0sRUFBRSxVQUFVLEVBQUUsRUFBRSxFQUFFLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUM7WUFFOUMsT0FBTztnQkFDTCxFQUFFLEVBQUUsTUFBTSxDQUFDLEVBQUUsQ0FBQztnQkFDZCxLQUFLLEVBQUUsVUFBVSxDQUFDLEtBQUs7Z0JBQ3ZCLFNBQVMsRUFBRSxVQUFVLENBQUMsVUFBVTtnQkFDaEMsUUFBUSxFQUFFLFVBQVUsQ0FBQyxTQUFTO2dCQUM5QixJQUFJLEVBQUUsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7Z0JBQ3pCLElBQUksRUFBRSxVQUFVLENBQUMsSUFBSTtnQkFDckIsSUFBSSxFQUFFLFVBQVUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUUsR0FBRyxJQUFJLEVBQUUsQ0FBQyxHQUFHLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztnQkFDeEYsV0FBVzthQUNaLENBQUM7U0FDSDtRQUFDLE1BQU07WUFDTixNQUFNLElBQUksS0FBSyxDQUFDLGdEQUFnRCxDQUFDLENBQUM7U0FDbkU7SUFDSCxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsT0FBb0IsRUFBRSxJQUFZO1FBQ3ZELE1BQU0sUUFBUSxHQUFHLE1BQU0sb0JBQVU7YUFDOUIsSUFBSSxDQUFDLElBQUksR0FBRyxDQUFDLDJCQUEyQixFQUFFLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQzthQUM5RSxJQUFJLENBQUMsRUFBRSxjQUFjLEVBQUUsSUFBSSxFQUFFLENBQUM7YUFDOUIsR0FBRyxDQUFDLG1CQUFtQixFQUFFLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUUvQyxPQUFPLENBQUMsUUFBUSxFQUFFLElBQUksRUFBRSxVQUFVLENBQUM7SUFDckMsQ0FBQztJQUVELE1BQU0sQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLE9BQW9CLEVBQUUsTUFBdUI7UUFDckUsSUFBSTtZQUNGLE1BQU0sb0JBQVU7aUJBQ2IsSUFBSSxDQUFDLElBQUksR0FBRyxDQUFDLGlCQUFpQixFQUFFLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztpQkFDcEUsSUFBSSxDQUFDLE1BQU0sQ0FBQztpQkFDWixHQUFHLENBQUMsbUJBQW1CLEVBQUUsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1NBQ2hEO1FBQUMsT0FBTyxDQUFDLEVBQUU7WUFDVixxRkFBcUY7WUFDckYsSUFBSSxPQUFlLENBQUM7WUFFcEIsUUFBUyxDQUFtQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUU7Z0JBQzdDLEtBQUssQ0FBQztvQkFDSixPQUFPLEdBQUcsbURBQW1ELENBQUM7b0JBQzlELE1BQU07Z0JBQ1IsS0FBSyxHQUFHO29CQUNOLE9BQU87d0JBQ0wsbUVBQW1FOzRCQUNuRSxtRkFBbUYsQ0FBQztvQkFDdEYsTUFBTTtnQkFDUixLQUFLLEdBQUc7b0JBQ04sT0FBTzt3QkFDTCw4Q0FBOEM7NEJBQzlDLGtEQUFrRDs0QkFDbEQsa0RBQWtELENBQUM7b0JBQ3JELE1BQU07Z0JBQ1I7b0JBQ0UsT0FBTzt3QkFDTCxtREFBbUQ7NEJBQ25ELG9FQUFvRSxDQUFDO2FBQzFFO1lBRUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztTQUMxQjtJQUNILENBQUM7SUFFRCxNQUFNLENBQUMsS0FBSyxDQUFDLGNBQWMsQ0FDekIsT0FBb0IsRUFDcEIsV0FBbUI7UUFFbkIsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLE1BQU0sb0JBQVU7YUFDOUIsR0FBRyxDQUFDLEdBQUcsT0FBTyxDQUFDLGVBQWUsdUJBQXVCLENBQUM7YUFDdEQsR0FBRyxDQUFDLG1CQUFtQixFQUFFLE9BQU8sQ0FBQyxTQUFTLENBQUM7YUFDM0MsS0FBSyxDQUFDLGVBQWUsV0FBVyxFQUFFLENBQUMsQ0FBQztRQUV2QyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxpQkFBaUIsRUFBRTtZQUNqQyxNQUFNLElBQUksS0FBSyxDQUFDLDBCQUEwQixDQUFDLENBQUM7U0FDN0M7UUFFRCxNQUFNLE9BQU8sR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFDO1FBQ2xDLE1BQU0sYUFBYSxHQUFHLEVBQUUsQ0FBQztRQUV6QixhQUFhLENBQUMsc0JBQXNCLENBQUMsSUFBSSxFQUFFLEtBQUssSUFBSSxFQUFFLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDakUsYUFBYSxDQUFDLHVCQUF1QixDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsV0FBVyxJQUFJLEVBQUUsRUFBRSxPQUFPLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFFN0YsT0FBTztZQUNMLE9BQU87WUFDUCxhQUFhO1lBQ2IsTUFBTSxFQUFFLGFBQWEsQ0FBQyxzQkFBc0IsQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztTQUMxRixDQUFDO0lBQ0osQ0FBQztJQUVELDJFQUEyRTtJQUNuRSxNQUFNLENBQUMsc0JBQXNCLENBQUMsWUFBaUIsRUFBRSxPQUFvQjtRQUMzRSxNQUFNLFlBQVksR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFNLFlBQVksQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQzdELE1BQU0sY0FBYyxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ2hELElBQUksRUFBRSxLQUFLLENBQUMsSUFBSTtZQUNoQixPQUFPLEVBQUUsS0FBSyxDQUFDLE1BQU07WUFDckIsU0FBUyxFQUFFLEtBQUssQ0FBQyxVQUFVO1lBQzNCLGVBQWUsRUFBRSxLQUFLLENBQUMsa0JBQWtCO1lBQ3pDLFVBQVUsRUFBRSxLQUFLLENBQUMsa0JBQWtCO1lBQ3BDLFVBQVUsRUFBRSxLQUFLLENBQUMsU0FBUztZQUMzQixtQkFBbUIsRUFBRSxDQUFDLEtBQUssQ0FBQyxJQUFJLEtBQUssTUFBTSxJQUFJLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLElBQUk7WUFDOUUsY0FBYyxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxNQUFNLElBQUksS0FBSyxDQUFDLGdCQUFnQixDQUFDLElBQUksSUFBSTtZQUN6RSxLQUFLLEVBQUUsS0FBSyxDQUFDLEtBQUs7WUFDbEIsV0FBVyxFQUFFLEtBQUssQ0FBQyxjQUFjO1lBQ2pDLGtCQUFrQixFQUFFLEtBQUssQ0FBQyxxQkFBcUI7U0FDaEQsQ0FBQyxDQUFDLENBQUM7UUFFSixNQUFNLE1BQU0sR0FBRyxjQUFjLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQ3hDLElBQUEscUJBQVUsRUFBQyxLQUFLLEVBQUU7WUFDaEIsV0FBVyxFQUFFLEtBQUs7WUFDbEIsV0FBVyxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxLQUFLLElBQUksSUFBSSxLQUFLLENBQUMsR0FBRyxDQUFDLEtBQUssU0FBUztTQUNwRSxDQUFDLENBQ0gsQ0FBQztRQUVGLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLFNBQVMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7SUFFRDs7OztPQUlHO0lBQ0ssTUFBTSxDQUFDLHVCQUF1QixDQUNwQyxXQUFnQixFQUNoQixPQUFvQixFQUNwQixhQUFvRDtRQUVwRCxLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsUUFBUSxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBTSxXQUFXLENBQUMsRUFBRTtZQUMvRCxLQUFLLE1BQU0sQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBTSxRQUFRLENBQUMsVUFBVSxJQUFJLEVBQUUsQ0FBQyxFQUFFO2dCQUNsRixNQUFNLFNBQVMsR0FBRyxVQUFVLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxVQUFVLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQztnQkFDaEYsSUFBSSxPQUFPLE9BQU8sS0FBSyxTQUFTO29CQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxTQUFTLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQzs7b0JBQ2pFLGFBQWEsQ0FBQyxHQUFHLFNBQVMsSUFBSSxJQUFJLEVBQUUsQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFTLE9BQU8sQ0FBQyxDQUFDO2FBQ3ZFO1lBRUQsS0FBSyxNQUFNLENBQUMsVUFBVSxFQUFFLFdBQVcsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQU0sUUFBUSxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUMsRUFBRTtnQkFDbkYsTUFBTSxPQUFPLEdBQUcsV0FBVyxDQUFDLGNBQWMsQ0FBQztnQkFDM0MsSUFBSSxPQUFPLE9BQU8sS0FBSyxTQUFTO29CQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxVQUFVLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQzs7b0JBQ3pFLGFBQWEsQ0FBQyxVQUFVLFVBQVUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFTLE9BQU8sQ0FBQyxDQUFDO2FBQy9FO1NBQ0Y7SUFDSCxDQUFDO0lBRUQsMkVBQTJFO0lBQ25FLE1BQU0sQ0FBQyxzQkFBc0IsQ0FBQyxTQUFjO1FBQ2xELE1BQU0sTUFBTSxHQUFHLEVBQUUsQ0FBQztRQUVsQixLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsRUFBRSxLQUFLLEVBQUUsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQU0sU0FBUyxDQUFDLEVBQUU7WUFDOUQsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEtBQUssSUFBSTtnQkFDdEIsYUFBYSxFQUFFLHlDQUFvQixDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDO2dCQUNqRSxrQkFBa0IsRUFBRSxLQUFLLENBQUMsbUJBQW1CLEVBQUUsS0FBSyxJQUFJLEVBQUU7YUFDM0QsQ0FBQztTQUNIO1FBRUQsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQztDQUNGO0FBck1ELGdDQXFNQyJ9

package/dist/agent/utils/forest-schema/action-values.d.ts

@@ -0,0 +1,34 @@
+import { ActionField, DataSource } from '@forestadmin/datasource-toolkit';
+declare type FormData = Record<string, unknown>;
+/**
+ * This utility class converts form values from our internal format to the format that is
+ * used in the frontend for smart action forms.
+ */
+export default class ForestValueConverter {
+    /**
+     * Proper form data parser which converts data from a smart action form result to the format
+     * that is internally used in datasources.
+     */
+    static makeFormData(dataSource: DataSource, rawData: FormData, fields: ActionField[]): FormData;
+    /**
+     * Form data parser which extracts the data from what is provided by the frontend when
+     * change hooks are called.
+     */
+    static makeFormDataFromFields(dataSource: DataSource, fields: any[]): FormData;
+    /**
+     * This last form data parser tries to guess the types from the data itself.
+     *
+     * - Fields with type "Collection" which target collections where the pk is not a string or
+     * derivative (mongoid, uuid, ...) won't be parser correctly, as we don't have enough information
+     * to properly guess the type
+     * - Fields of type "String" but where the final user entered a data-uri manually in the frontend
+     * will be wrongfully parsed.
+     */
+    static makeFormDataUnsafe(rawData: FormData): FormData;
+    static valueToForest(field: ActionField, value: unknown): unknown;
+    private static parseDataUri;
+    private static makeDataUri;
+    private static isDataUri;
+}
+export {};
+//# sourceMappingURL=action-values.d.ts.map

package/dist/agent/utils/forest-schema/action-values.js

@@ -0,0 +1,144 @@
+"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"));
+const generator_actions_1 = __importDefault(require("./generator-actions"));
+/**
+ * This utility class converts form values from our internal format to the format that is
+ * used in the frontend for smart action forms.
+ */
+class ForestValueConverter {
+    /**
+     * Proper form data parser which converts data from a smart action form result to the format
+     * that is internally used in datasources.
+     */
+    static makeFormData(dataSource, rawData, fields) {
+        const data = {};
+        for (const [key, value] of Object.entries(rawData)) {
+            const field = fields.find(f => f.label === key);
+            // Skip fields from the default form
+            if (!generator_actions_1.default.defaultFields.map(f => f.field).includes(key)) {
+                if (field?.type === 'Collection' && value) {
+                    const collection = dataSource.getCollection(field.collectionName);
+                    data[key] = id_1.default.unpackId(collection.schema, value);
+                }
+                else if (field?.type === 'File') {
+                    data[key] = this.parseDataUri(value);
+                }
+                else if (field?.type === 'FileList') {
+                    data[key] = value?.map(v => this.parseDataUri(v));
+                }
+                else {
+                    data[key] = value;
+                }
+            }
+        }
+        return data;
+    }
+    /**
+     * Form data parser which extracts the data from what is provided by the frontend when
+     * change hooks are called.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static makeFormDataFromFields(dataSource, fields) {
+        const data = {};
+        for (const field of fields) {
+            // Skip fields from the default form
+            if (!generator_actions_1.default.defaultFields.map(f => f.field).includes(field.field)) {
+                if (field.reference && field.value) {
+                    const [collectionName] = field.reference.split('.');
+                    const collection = dataSource.getCollection(collectionName);
+                    data[field.field] = id_1.default.unpackId(collection.schema, field.value);
+                }
+                else if (field.type === 'File') {
+                    data[field.field] = this.parseDataUri(field.value);
+                }
+                else if (Array.isArray(field.type) && field.type[0] === 'File') {
+                    data[field.field] = field.value?.map(v => this.parseDataUri(v));
+                }
+                else {
+                    data[field.field] = field.value;
+                }
+            }
+        }
+        return data;
+    }
+    /**
+     * This last form data parser tries to guess the types from the data itself.
+     *
+     * - Fields with type "Collection" which target collections where the pk is not a string or
+     * derivative (mongoid, uuid, ...) won't be parser correctly, as we don't have enough information
+     * to properly guess the type
+     * - Fields of type "String" but where the final user entered a data-uri manually in the frontend
+     * will be wrongfully parsed.
+     */
+    static makeFormDataUnsafe(rawData) {
+        const data = {};
+        for (const [key, value] of Object.entries(rawData)) {
+            // Skip fields from the default form
+            if (!generator_actions_1.default.defaultFields.map(f => f.field).includes(key)) {
+                if (Array.isArray(value) && value.every(v => this.isDataUri(v))) {
+                    data[key] = value.map(uri => this.parseDataUri(uri));
+                }
+                else if (this.isDataUri(value)) {
+                    data[key] = this.parseDataUri(value);
+                }
+                else {
+                    data[key] = value;
+                }
+            }
+        }
+        return data;
+    }
+    static valueToForest(field, value) {
+        if (field.type === 'Enum') {
+            return field.enumValues.includes(value) ? value : null;
+        }
+        if (field.type === 'EnumList') {
+            return value?.filter(v => field.enumValues.includes(v));
+        }
+        if (field.type === 'Collection') {
+            return value?.join('|');
+        }
+        if (field.type === 'File') {
+            return this.makeDataUri(value);
+        }
+        if (field.type === 'FileList') {
+            return value?.map(f => this.makeDataUri(f));
+        }
+        return value;
+    }
+    static parseDataUri(dataUri) {
+        if (!dataUri)
+            return null;
+        // Poor man's data uri parser (spec compliants one don't get the filename).
+        // Hopefully this does not break.
+        const [header, data] = dataUri.substring(5).split(',');
+        const [mimeType, ...mediaTypes] = header.split(';');
+        const result = { mimeType, buffer: Buffer.from(data, 'base64') };
+        for (const mediaType of mediaTypes) {
+            const index = mediaType.indexOf('=');
+            if (index !== -1)
+                result[mediaType.substring(0, index)] = decodeURIComponent(mediaType.substring(index + 1));
+        }
+        return result;
+    }
+    static makeDataUri(file) {
+        if (!file)
+            return null;
+        const { mimeType, buffer, ...rest } = file;
+        const mediaTypes = Object.entries(rest)
+            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+            .join(';');
+        return mediaTypes.length
+            ? `data:${file.mimeType};${mediaTypes};base64,${buffer.toString('base64')}`
+            : `data:${file.mimeType};base64,${buffer.toString('base64')}`;
+    }
+    static isDataUri(value) {
+        return typeof value === 'string' && value.startsWith('data:');
+    }
+}
+exports.default = ForestValueConverter;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agent/utils/forest-schema/emitter.d.ts

@@ -0,0 +1,20 @@
+import { DataSource } from '@forestadmin/datasource-toolkit';
+import { AgentOptions } from '../../../types';
+declare type SerializedSchema = {
+    meta: {
+        schemaFileHash: string;
+    };
+};
+declare type Options = Pick<AgentOptions, 'isProduction' | 'prefix' | 'schemaPath'>;
+/**
+ * Generate and dispatch dataSource schema on agent start.
+ */
+export default class SchemaEmitter {
+    private static readonly meta;
+    static getSerializedSchema(options: Options, dataSource: DataSource): Promise<SerializedSchema>;
+    private static loadFromDisk;
+    private static generate;
+    private static serialize;
+}
+export {};
+//# sourceMappingURL=emitter.d.ts.map

package/dist/agent/utils/forest-schema/emitter.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("fs/promises");
+const json_api_serializer_1 = __importDefault(require("json-api-serializer"));
+const crypto_1 = __importDefault(require("crypto"));
+const json_stringify_pretty_compact_1 = __importDefault(require("json-stringify-pretty-compact"));
+const generator_collection_1 = __importDefault(require("./generator-collection"));
+// Load version from package.json at startup
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { version } = require('../../../../package.json');
+/**
+ * Generate and dispatch dataSource schema on agent start.
+ */
+class SchemaEmitter {
+    static async getSerializedSchema(options, dataSource) {
+        const schema = options.isProduction
+            ? await SchemaEmitter.loadFromDisk(options.schemaPath)
+            : await SchemaEmitter.generate(options.prefix, dataSource);
+        if (!options.isProduction) {
+            const pretty = (0, json_stringify_pretty_compact_1.default)(schema, { maxLength: 80 });
+            await (0, promises_1.writeFile)(options.schemaPath, pretty, { encoding: 'utf-8' });
+        }
+        const hash = crypto_1.default.createHash('sha1').update(JSON.stringify(schema)).digest('hex');
+        return SchemaEmitter.serialize(schema, hash);
+    }
+    static async loadFromDisk(schemaPath) {
+        try {
+            const fileContent = await (0, promises_1.readFile)(schemaPath, { encoding: 'utf-8' });
+            return JSON.parse(fileContent);
+        }
+        catch (e) {
+            throw new Error(`Cannot load ${schemaPath}. Providing a schema is mandatory in production mode.`);
+        }
+    }
+    static async generate(prefix, dataSource) {
+        const allCollectionSchemas = [];
+        const dataSourceCollectionSchemas = dataSource.collections.map(collection => generator_collection_1.default.buildSchema(prefix, collection));
+        allCollectionSchemas.push(...dataSourceCollectionSchemas);
+        return Promise.all(allCollectionSchemas);
+    }
+    static serialize(schema, hash) {
+        // Build serializer
+        const serializer = new json_api_serializer_1.default();
+        serializer.register('collections', {
+            // Pass the metadata provided to the serialization fn
+            topLevelMeta: (extraData) => extraData,
+            relationships: {
+                segments: { type: 'segments' },
+                actions: { type: 'actions' },
+            },
+        });
+        serializer.register('segments', {});
+        serializer.register('actions', {});
+        // Serialize
+        return serializer.serialize('collections', schema.map(c => ({ id: c.name, ...c })), { ...SchemaEmitter.meta, schemaFileHash: hash });
+    }
+}
+exports.default = SchemaEmitter;
+SchemaEmitter.meta = {
+    liana: 'forest-nodejs-agent',
+    liana_version: version,
+    stack: {
+        engine: 'nodejs',
+        engine_version: process.versions && process.versions.node,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1pdHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hZ2VudC91dGlscy9mb3Jlc3Qtc2NoZW1hL2VtaXR0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFDQSwwQ0FBa0Q7QUFDbEQsOEVBQW9EO0FBQ3BELG9EQUE0QjtBQUM1QixrR0FBc0Q7QUFJdEQsa0ZBQStEO0FBTS9ELDRDQUE0QztBQUM1Qyw4REFBOEQ7QUFDOUQsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLE9BQU8sQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO0FBRXhEOztHQUVHO0FBQ0gsTUFBcUIsYUFBYTtJQVVoQyxNQUFNLENBQUMsS0FBSyxDQUFDLG1CQUFtQixDQUM5QixPQUFnQixFQUNoQixVQUFzQjtRQUV0QixNQUFNLE1BQU0sR0FBYyxPQUFPLENBQUMsWUFBWTtZQUM1QyxDQUFDLENBQUMsTUFBTSxhQUFhLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUM7WUFDdEQsQ0FBQyxDQUFDLE1BQU0sYUFBYSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBRTdELElBQUksQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFO1lBQ3pCLE1BQU0sTUFBTSxHQUFHLElBQUEsdUNBQVMsRUFBQyxNQUFNLEVBQUUsRUFBRSxTQUFTLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztZQUNwRCxNQUFNLElBQUEsb0JBQVMsRUFBQyxPQUFPLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO1NBQ3BFO1FBRUQsTUFBTSxJQUFJLEdBQUcsZ0JBQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFcEYsT0FBTyxhQUFhLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsQ0FBQztJQUMvQyxDQUFDO0lBRU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsVUFBa0I7UUFDbEQsSUFBSTtZQUNGLE1BQU0sV0FBVyxHQUFHLE1BQU0sSUFBQSxtQkFBUSxFQUFDLFVBQVUsRUFBRSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO1lBRXRFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUMsQ0FBQztTQUNoQztRQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ1YsTUFBTSxJQUFJLEtBQUssQ0FDYixlQUFlLFVBQVUsdURBQXVELENBQ2pGLENBQUM7U0FDSDtJQUNILENBQUM7SUFFTyxNQUFNLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxNQUFjLEVBQUUsVUFBc0I7UUFDbEUsTUFBTSxvQkFBb0IsR0FBRyxFQUFFLENBQUM7UUFFaEMsTUFBTSwyQkFBMkIsR0FBRyxVQUFVLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUMxRSw4QkFBeUIsQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUMxRCxDQUFDO1FBQ0Ysb0JBQW9CLENBQUMsSUFBSSxDQUFDLEdBQUcsMkJBQTJCLENBQUMsQ0FBQztRQUUxRCxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBRU8sTUFBTSxDQUFDLFNBQVMsQ0FBQyxNQUFpQixFQUFFLElBQVk7UUFDdEQsbUJBQW1CO1FBQ25CLE1BQU0sVUFBVSxHQUFHLElBQUksNkJBQWlCLEVBQUUsQ0FBQztRQUUzQyxVQUFVLENBQUMsUUFBUSxDQUFDLGFBQWEsRUFBRTtZQUNqQyxxREFBcUQ7WUFDckQsWUFBWSxFQUFFLENBQUMsU0FBa0IsRUFBRSxFQUFFLENBQUMsU0FBUztZQUMvQyxhQUFhLEVBQUU7Z0JBQ2IsUUFBUSxFQUFFLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRTtnQkFDOUIsT0FBTyxFQUFFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRTthQUM3QjtTQUNGLENBQUMsQ0FBQztRQUNILFVBQVUsQ0FBQyxRQUFRLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3BDLFVBQVUsQ0FBQyxRQUFRLENBQUMsU0FBUyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRW5DLFlBQVk7UUFDWixPQUFPLFVBQVUsQ0FBQyxTQUFTLENBQ3pCLGFBQWEsRUFDYixNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUN2QyxFQUFFLEdBQUcsYUFBYSxDQUFDLElBQUksRUFBRSxjQUFjLEVBQUUsSUFBSSxFQUFFLENBQzVCLENBQUM7SUFDeEIsQ0FBQzs7QUF4RUgsZ0NBeUVDO0FBeEV5QixrQkFBSSxHQUFHO0lBQzdCLEtBQUssRUFBRSxxQkFBcUI7SUFDNUIsYUFBYSxFQUFFLE9BQU87SUFDdEIsS0FBSyxFQUFFO1FBQ0wsTUFBTSxFQUFFLFFBQVE7UUFDaEIsY0FBYyxFQUFFLE9BQU8sQ0FBQyxRQUFRLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJO0tBQzFEO0NBQ0YsQ0FBQyJ9

package/dist/agent/utils/forest-schema/filterable.d.ts

@@ -0,0 +1,16 @@
+import { ColumnType, Operator } from '@forestadmin/datasource-toolkit';
+export default class FrontendFilterableUtils {
+    private static readonly baseOperators;
+    private static readonly dateOperators;
+    private static readonly operatorByType;
+    /**
+     * Compute if a column if filterable according to forestadmin's frontend.
+     *
+     * @param type column's type (string, number, or a composite type)
+     * @param operators list of operators that the column supports
+     * @returns either if the frontend would consider this column filterable or not.
+     */
+    static isFilterable(type: ColumnType, operators?: Set<Operator>): boolean;
+    static getRequiredOperators(type: ColumnType): Operator[] | null;
+}
+//# sourceMappingURL=filterable.d.ts.map

package/dist/agent/utils/forest-schema/filterable.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FrontendFilterableUtils {
+    /**
+     * Compute if a column if filterable according to forestadmin's frontend.
+     *
+     * @param type column's type (string, number, or a composite type)
+     * @param operators list of operators that the column supports
+     * @returns either if the frontend would consider this column filterable or not.
+     */
+    static isFilterable(type, operators) {
+        const neededOperators = FrontendFilterableUtils.getRequiredOperators(type);
+        const supportedOperators = operators ?? new Set();
+        return Boolean(neededOperators && neededOperators.every(op => supportedOperators.has(op)));
+    }
+    static getRequiredOperators(type) {
+        if (typeof type === 'string' && FrontendFilterableUtils.operatorByType[type]) {
+            return FrontendFilterableUtils.operatorByType[type];
+        }
+        // It sound highly unlikely that this operator can work with dates, or nested objects
+        // and they should be more restricted, however the frontend code does not seems to check the
+        // array's content so I'm replicating the same test here
+        if (Array.isArray(type)) {
+            return ['IncludesAll'];
+        }
+        return null;
+    }
+}
+exports.default = FrontendFilterableUtils;
+FrontendFilterableUtils.baseOperators = ['Equal', 'NotEqual', 'Present', 'Blank'];
+FrontendFilterableUtils.dateOperators = [
+    ...FrontendFilterableUtils.baseOperators,
+    'LessThan',
+    'GreaterThan',
+    'Today',
+    'Yesterday',
+    'PreviousXDays',
+    'PreviousWeek',
+    'PreviousQuarter',
+    'PreviousYear',
+    'PreviousXDaysToDate',
+    'PreviousWeekToDate',
+    'PreviousMonthToDate',
+    'PreviousQuarterToDate',
+    'PreviousYearToDate',
+    'Past',
+    'Future',
+    'BeforeXHoursAgo',
+    'AfterXHoursAgo',
+];
+FrontendFilterableUtils.operatorByType = {
+    Boolean: FrontendFilterableUtils.baseOperators,
+    Date: FrontendFilterableUtils.dateOperators,
+    Dateonly: FrontendFilterableUtils.dateOperators,
+    Enum: [...FrontendFilterableUtils.baseOperators, 'In'],
+    Number: [...FrontendFilterableUtils.baseOperators, 'In', 'GreaterThan', 'LessThan'],
+    String: [
+        ...FrontendFilterableUtils.baseOperators,
+        'In',
+        'StartsWith',
+        'EndsWith',
+        'Contains',
+        'NotContains',
+    ],
+    Timeonly: [...FrontendFilterableUtils.baseOperators, 'GreaterThan', 'LessThan'],
+    Uuid: FrontendFilterableUtils.baseOperators,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agent/utils/forest-schema/generator-actions.d.ts

@@ -0,0 +1,14 @@
+import { ActionField, Collection, DataSource } from '@forestadmin/datasource-toolkit';
+import { ForestServerAction, ForestServerActionField } from './types';
+export default class 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.
+     */
+    static defaultFields: ForestServerActionField[];
+    static buildSchema(prefix: string, collection: Collection, name: string): Promise<ForestServerAction>;
+    /** Build schema for given field */
+    static buildFieldSchema(dataSource: DataSource, field: ActionField): ForestServerActionField;
+    private static buildFields;
+}
+//# sourceMappingURL=generator-actions.d.ts.map