@forestadmin/agent 1.0.0-alpha.1

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

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 (e) {
+            this.handleResponseError(e);
+        }
+    }
+    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 (e) {
+            this.handleResponseError(e);
+        }
+    }
+    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,
+                permissionLevel: attributes.permission_level,
+            };
+        }
+        catch (e) {
+            this.handleResponseError(e);
+        }
+    }
+    static async hasSchema(options, hash) {
+        try {
+            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;
+        }
+        catch (e) {
+            this.handleResponseError(e);
+        }
+    }
+    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) {
+            this.handleResponseError(e);
+        }
+    }
+    static async getPermissions(options, renderingId) {
+        try {
+            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] ?? {}),
+            };
+        }
+        catch (e) {
+            this.handleResponseError(e);
+        }
+    }
+    static async getEnvironmentPermissions(options) {
+        try {
+            const { body } = await superagent_1.default
+                .get(`${options.forestServerUrl}/liana/v4/permissions/environment`)
+                .set('forest-secret-key', options.envSecret);
+            return body;
+        }
+        catch (e) {
+            this.handleResponseError(e);
+        }
+    }
+    static async getUsers(options) {
+        try {
+            const { body } = await superagent_1.default
+                .get(`${options.forestServerUrl}/liana/v4/permissions/users`)
+                .set('forest-secret-key', options.envSecret);
+            return body;
+        }
+        catch (e) {
+            this.handleResponseError(e);
+        }
+    }
+    /** 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: scope.filter,
+                dynamicScopeValues: scope.dynamicScopesValues?.users ?? {},
+            };
+        }
+        return scopes;
+    }
+    static handleResponseError(e) {
+        if (/certificate/i.test(e.message))
+            throw new Error('ForestAdmin server TLS certificate cannot be verified. ' +
+                'Please check that your system time is set properly.');
+        if (e.response) {
+            const status = e?.response?.status;
+            // 0 == offline, 502 == bad gateway from proxy
+            if (status === 0 || status === 502)
+                throw new Error('Failed to reach ForestAdmin server. Are you online?');
+            if (status === 404)
+                throw new Error('ForestAdmin server failed to find the project related to the envSecret you configured.' +
+                    ' Can you check that you copied it properly in the Forest initialization?');
+            if (status === 503)
+                throw new Error('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.');
+            throw new Error('An unexpected error occured while contacting the ForestAdmin server. ' +
+                'Please contact support@forestadmin.com for further investigations.');
+        }
+        throw e;
+    }
+}
+exports.default = ForestHttpApi;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forest-http-api.js","sourceRoot":"","sources":["../../src/utils/forest-http-api.ts"],"names":[],"mappings":"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"}

package/dist/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 action forms.
+ */
+export default class ForestValueConverter {
+    /**
+     * Proper form data parser which converts data from an 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/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 action forms.
+ */
+class ForestValueConverter {
+    /**
+     * Proper form data parser which converts data from an 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLXZhbHVlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9mb3Jlc3Qtc2NoZW1hL2FjdGlvbi12YWx1ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFDQSwrQ0FBNEI7QUFDNUIsNEVBQXlEO0FBSXpEOzs7R0FHRztBQUNILE1BQXFCLG9CQUFvQjtJQUN2Qzs7O09BR0c7SUFDSCxNQUFNLENBQUMsWUFBWSxDQUFDLFVBQXNCLEVBQUUsT0FBaUIsRUFBRSxNQUFxQjtRQUNsRixNQUFNLElBQUksR0FBRyxFQUFFLENBQUM7UUFFaEIsS0FBSyxNQUFNLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEVBQUU7WUFDbEQsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxLQUFLLEtBQUssR0FBRyxDQUFDLENBQUM7WUFFaEQsb0NBQW9DO1lBQ3BDLElBQUksQ0FBQywyQkFBc0IsQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRTtnQkFDekUsSUFBSSxLQUFLLEVBQUUsSUFBSSxLQUFLLFlBQVksSUFBSSxLQUFLLEVBQUU7b0JBQ3pDLE1BQU0sVUFBVSxHQUFHLFVBQVUsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLGNBQWMsQ0FBQyxDQUFDO29CQUVsRSxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsWUFBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLEtBQWUsQ0FBQyxDQUFDO2lCQUNsRTtxQkFBTSxJQUFJLEtBQUssRUFBRSxJQUFJLEtBQUssTUFBTSxFQUFFO29CQUNqQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFlLENBQUMsQ0FBQztpQkFDaEQ7cUJBQU0sSUFBSSxLQUFLLEVBQUUsSUFBSSxLQUFLLFVBQVUsRUFBRTtvQkFDckMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFJLEtBQWtCLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2lCQUNqRTtxQkFBTTtvQkFDTCxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDO2lCQUNuQjthQUNGO1NBQ0Y7UUFFRCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRDs7O09BR0c7SUFDSCw4REFBOEQ7SUFDOUQsTUFBTSxDQUFDLHNCQUFzQixDQUFDLFVBQXNCLEVBQUUsTUFBYTtRQUNqRSxNQUFNLElBQUksR0FBYSxFQUFFLENBQUM7UUFFMUIsS0FBSyxNQUFNLEtBQUssSUFBSSxNQUFNLEVBQUU7WUFDMUIsb0NBQW9DO1lBQ3BDLElBQUksQ0FBQywyQkFBc0IsQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEVBQUU7Z0JBQ2pGLElBQUksS0FBSyxDQUFDLFNBQVMsSUFBSSxLQUFLLENBQUMsS0FBSyxFQUFFO29CQUNsQyxNQUFNLENBQUMsY0FBYyxDQUFDLEdBQUcsS0FBSyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7b0JBQ3BELE1BQU0sVUFBVSxHQUFHLFVBQVUsQ0FBQyxhQUFhLENBQUMsY0FBYyxDQUFDLENBQUM7b0JBQzVELElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsWUFBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxLQUFlLENBQUMsQ0FBQztpQkFDaEY7cUJBQU0sSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLE1BQU0sRUFBRTtvQkFDaEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxLQUFlLENBQUMsQ0FBQztpQkFDOUQ7cUJBQU0sSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxLQUFLLE1BQU0sRUFBRTtvQkFDaEUsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsR0FBSSxLQUFLLENBQUMsS0FBa0IsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7aUJBQy9FO3FCQUFNO29CQUNMLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsS0FBSyxDQUFDLEtBQUssQ0FBQztpQkFDakM7YUFDRjtTQUNGO1FBRUQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSCxNQUFNLENBQUMsa0JBQWtCLENBQUMsT0FBaUI7UUFDekMsTUFBTSxJQUFJLEdBQWEsRUFBRSxDQUFDO1FBRTFCLEtBQUssTUFBTSxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ2xELG9DQUFvQztZQUNwQyxJQUFJLENBQUMsMkJBQXNCLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUU7Z0JBQ3pFLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFO29CQUMvRCxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztpQkFDdEQ7cUJBQU0sSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxFQUFFO29CQUNoQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFlLENBQUMsQ0FBQztpQkFDaEQ7cUJBQU07b0JBQ0wsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQztpQkFDbkI7YUFDRjtTQUNGO1FBRUQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQsTUFBTSxDQUFDLGFBQWEsQ0FBQyxLQUFrQixFQUFFLEtBQWM7UUFDckQsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLE1BQU0sRUFBRTtZQUN6QixPQUFPLEtBQUssQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLEtBQWUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztTQUNsRTtRQUVELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxVQUFVLEVBQUU7WUFDN0IsT0FBUSxLQUFrQixFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7U0FDdkU7UUFFRCxJQUFJLEtBQUssQ0FBQyxJQUFJLEtBQUssWUFBWSxFQUFFO1lBQy9CLE9BQVEsS0FBcUIsRUFBRSxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7U0FDMUM7UUFFRCxJQUFJLEtBQUssQ0FBQyxJQUFJLEtBQUssTUFBTSxFQUFFO1lBQ3pCLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFhLENBQUMsQ0FBQztTQUN4QztRQUVELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxVQUFVLEVBQUU7WUFDN0IsT0FBUSxLQUFnQixFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztTQUN6RDtRQUVELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVPLE1BQU0sQ0FBQyxZQUFZLENBQUMsT0FBZTtRQUN6QyxJQUFJLENBQUMsT0FBTztZQUFFLE9BQU8sSUFBSSxDQUFDO1FBRTFCLDJFQUEyRTtRQUMzRSxpQ0FBaUM7UUFDakMsTUFBTSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUN2RCxNQUFNLENBQUMsUUFBUSxFQUFFLEdBQUcsVUFBVSxDQUFDLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNwRCxNQUFNLE1BQU0sR0FBRyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsUUFBUSxDQUFDLEVBQUUsQ0FBQztRQUVqRSxLQUFLLE1BQU0sU0FBUyxJQUFJLFVBQVUsRUFBRTtZQUNsQyxNQUFNLEtBQUssR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3JDLElBQUksS0FBSyxLQUFLLENBQUMsQ0FBQztnQkFDZCxNQUFNLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUMsR0FBRyxrQkFBa0IsQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQzlGO1FBRUQsT0FBTyxNQUFjLENBQUM7SUFDeEIsQ0FBQztJQUVPLE1BQU0sQ0FBQyxXQUFXLENBQUMsSUFBVTtRQUNuQyxJQUFJLENBQUMsSUFBSTtZQUFFLE9BQU8sSUFBSSxDQUFDO1FBRXZCLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEdBQUcsSUFBSSxFQUFFLEdBQUcsSUFBSSxDQUFDO1FBQzNDLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDO2FBQ3BDLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEdBQUcsSUFBSSxrQkFBa0IsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO2FBQzVELElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUViLE9BQU8sVUFBVSxDQUFDLE1BQU07WUFDdEIsQ0FBQyxDQUFDLFFBQVEsSUFBSSxDQUFDLFFBQVEsSUFBSSxVQUFVLFdBQVcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsRUFBRTtZQUMzRSxDQUFDLENBQUMsUUFBUSxJQUFJLENBQUMsUUFBUSxXQUFXLE1BQU0sQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztJQUNsRSxDQUFDO0lBRU8sTUFBTSxDQUFDLFNBQVMsQ0FBQyxLQUFjO1FBQ3JDLE9BQU8sT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLEtBQUssQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDaEUsQ0FBQztDQUNGO0FBaEpELHVDQWdKQyJ9

package/dist/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' | '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/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(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(dataSource) {
+        const allCollectionSchemas = [];
+        const dataSourceCollectionSchemas = dataSource.collections.map(collection => generator_collection_1.default.buildSchema(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,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

package/dist/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/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/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(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