@forestadmin/agent 1.0.0-alpha.1

package/dist/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 path_1 = __importDefault(require("path"));
+const id_1 = __importDefault(require("../utils/id"));
+class Serializer {
+    constructor() {
+        // No need to keep references to serializers for outdated schemas => weakmap.
+        this.serializers = new WeakMap();
+    }
+    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 = path_1.default.posix.join('/forest', 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJ2aWNlcy9zZXJpYWxpemVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBS3lDO0FBQ3pDLDhFQUFvRDtBQUNwRCxnREFBd0I7QUFFeEIscURBQWtDO0FBSWxDLE1BQXFCLFVBQVU7SUFBL0I7UUFDRSw2RUFBNkU7UUFDNUQsZ0JBQVcsR0FBaUQsSUFBSSxPQUFPLEVBQUUsQ0FBQztJQXlJN0YsQ0FBQztJQXZJQyxTQUFTLENBQUMsVUFBc0IsRUFBRSxJQUErQjtRQUMvRCxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLFVBQVUsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQy9FLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUVwQyxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0lBRUQsV0FBVyxDQUFDLFVBQXNCLEVBQUUsSUFBYTtRQUMvQyxPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsVUFBVSxDQUFDLENBQUMsV0FBVyxDQUFDLFVBQVUsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDM0UsQ0FBQztJQUVELDJCQUEyQixDQUN6QixVQUFzQixFQUN0QixJQUFrQixFQUNsQixXQUFtQjtRQUVuQixNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsRUFBRSxJQUFJLENBQWUsQ0FBQztRQUUvRCxJQUFJLFdBQVcsSUFBSSxXQUFXLENBQUMsSUFBSSxFQUFFLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRTtZQUNoRCxNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBb0IsQ0FBQztZQUNqRCxNQUFNLFVBQVUsR0FBRyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUMsU0FBUyxFQUFFLE1BQWtCLEVBQUUsRUFBRTtnQkFDdEUsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxFQUFFO29CQUMvRCxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxDQUFDO29CQUUzQyxPQUFPLEtBQUssSUFBSSxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDO2dCQUNyRixDQUFDLENBQUMsQ0FBQztnQkFFSCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFO29CQUN2QixPQUFPLFNBQVMsQ0FBQztpQkFDbEI7Z0JBRUQsT0FBTyxFQUFFLEdBQUcsU0FBUyxFQUFFLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLEVBQUUsRUFBRSxNQUFNLENBQUMsRUFBRSxFQUFFLE1BQU0sRUFBRSxFQUFFLENBQUM7WUFDdEYsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1lBRVAsSUFBSSxNQUFNLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7Z0JBQzFDLE9BQU8sT0FBTyxDQUFDO2FBQ2hCO1lBRUQsT0FBTyxDQUFDLElBQUksR0FBRyxFQUFFLFVBQVUsRUFBRSxDQUFDO1NBQy9CO1FBRUQsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztJQUVPLGFBQWEsQ0FBQyxVQUFzQjtRQUMxQyxJQUFJLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsRUFBRTtZQUMzQyxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztTQUNoRDtRQUVELE1BQU0sVUFBVSxHQUFHLElBQUksNkJBQWlCLEVBQUUsQ0FBQztRQUUzQyxLQUFLLE1BQU0sT0FBTyxJQUFJLFVBQVUsQ0FBQyxVQUFVLENBQUMsV0FBVyxFQUFFO1lBQ3ZELElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLEVBQUUsVUFBVSxDQUFDLENBQUM7WUFDN0MsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxVQUFVLENBQUMsQ0FBQztTQUNsRDtRQUVELE9BQU8sVUFBVSxDQUFDO0lBQ3BCLENBQUM7SUFFTyxrQkFBa0IsQ0FBQyxVQUFzQixFQUFFLFVBQTZCO1FBQzlFLFVBQVUsQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRTtZQUNuQyxFQUFFLEVBQUUsVUFBVTtZQUNkLGFBQWEsRUFBRSxJQUFJLENBQUMsK0JBQStCLENBQUMsVUFBVSxDQUFDO1lBQy9ELGVBQWUsRUFBRSxDQUFDLElBQTZCLEVBQUUsRUFBRTtnQkFDakQsTUFBTSxJQUFJLEdBQUcsRUFBRSxHQUFHLElBQUksRUFBRSxDQUFDO2dCQUN6QixJQUFJLENBQUMsUUFBUSxHQUFHLFlBQU8sQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFFeEQsT0FBTyxJQUFJLENBQUM7WUFDZCxDQUFDO1lBQ0QsZ0JBQWdCLEVBQUUsQ0FBQyxJQUE2QixFQUFFLEVBQUU7Z0JBQ2xELE1BQU0sSUFBSSxHQUFHLEVBQUUsR0FBRyxJQUFJLEVBQUUsQ0FBQztnQkFFekIsSUFBSSxJQUFJLENBQUMsUUFBUSxFQUFFO29CQUNqQixNQUFNLEtBQUssR0FBRyxZQUFPLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLFFBQWtCLENBQUMsQ0FBQztvQkFDM0UsTUFBTSxXQUFXLEdBQUcsZ0NBQVcsQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDO29CQUNsRSxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFO3dCQUNuQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO29CQUM3QixDQUFDLENBQUMsQ0FBQztpQkFDSjtnQkFFRCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUM7Z0JBRXJCLE9BQU8sSUFBSSxDQUFDO1lBQ2QsQ0FBQztTQUNGLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTywrQkFBK0IsQ0FDckMsVUFBc0I7UUFFdEIsTUFBTSxhQUFhLEdBQTBELEVBQUUsQ0FBQztRQUNoRixNQUFNLFNBQVMsR0FBRyxjQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBRTlELEtBQUssTUFBTSxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUU7WUFDcEUsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLFdBQVcsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLFVBQVUsRUFBRTtnQkFDM0QsYUFBYSxDQUFDLElBQUksQ0FBQyxHQUFHO29CQUNwQixJQUFJLEVBQUUsS0FBSyxDQUFDLGlCQUFpQjtvQkFDN0IsV0FBVyxFQUFFLENBQUMsSUFBNkIsRUFBRSxFQUFFO3dCQUM3QyxNQUFNLGlCQUFpQixHQUFHLFVBQVUsQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO3dCQUV2RixPQUFPLFlBQU8sQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxFQUFZLENBQUMsQ0FBQztvQkFDdkUsQ0FBQztpQkFDRixDQUFDO2FBQ0g7WUFFRCxJQUFJLEtBQUssQ0FBQyxJQUFJLEtBQUssWUFBWSxJQUFJLEtBQUssQ0FBQyxJQUFJLEtBQUssV0FBVyxFQUFFO2dCQUM3RCxhQUFhLENBQUMsSUFBSSxDQUFDLEdBQUc7b0JBQ3BCLElBQUksRUFBRSxLQUFLLENBQUMsaUJBQWlCO29CQUM3QixLQUFLLEVBQUUsQ0FBQyxJQUFzQixFQUFFLEVBQUUsQ0FBQyxDQUFDO3dCQUNsQyxPQUFPLEVBQUU7NEJBQ1AsSUFBSSxFQUFFLEdBQUcsU0FBUyxJQUFJLElBQUksQ0FBQyxRQUFRLGtCQUFrQixJQUFJLEVBQUU7eUJBQzVEO3FCQUNGLENBQUM7aUJBQ0gsQ0FBQzthQUNIO1NBQ0Y7UUFFRCxPQUFPLGFBQWEsQ0FBQztJQUN2QixDQUFDO0lBRU8sc0JBQXNCLENBQUMsTUFBZTtRQUM1QyxJQUFJLE1BQU0sS0FBSyxJQUFJLElBQUksT0FBTyxNQUFNLEtBQUssUUFBUSxFQUFFO1lBQ2pELE9BQU87U0FDUjtRQUVELE1BQU0sU0FBUyxHQUFHLE1BQWlDLENBQUM7UUFFcEQsS0FBSyxNQUFNLEdBQUcsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxFQUFFO1lBQ3hDLElBQUksU0FBUyxDQUFDLEdBQUcsQ0FBQyxLQUFLLFNBQVMsRUFBRTtnQkFDaEMsT0FBTyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUM7YUFDdkI7aUJBQU07Z0JBQ0wsSUFBSSxDQUFDLHNCQUFzQixDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO2FBQzdDO1NBQ0Y7SUFDSCxDQUFDO0NBQ0Y7QUEzSUQsNkJBMklDIn0=

package/dist/types.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import { CompositeId, Logger, LoggerLevel } from '@forestadmin/datasource-toolkit';
+import { IncomingMessage, ServerResponse } from 'http';
+/** Options to configure behavior of an agent's forestadmin driver */
+export declare type AgentOptions = {
+    authSecret: string;
+    envSecret: string;
+    customizeErrorMessage?: ((error: Error) => string | null) | null;
+    forestServerUrl?: string;
+    logger?: Logger;
+    loggerLevel?: LoggerLevel;
+    prefix?: string;
+    isProduction: boolean;
+    schemaPath?: string;
+    typingsPath?: string | null;
+    typingsMaxDepth?: number;
+    permissionsCacheDurationInSeconds?: number;
+};
+export declare type AgentOptionsWithDefaults = Readonly<Required<AgentOptions>>;
+export declare type HttpCallback = (req: IncomingMessage, res: ServerResponse) => void;
+export declare enum HttpCode {
+    BadRequest = 400,
+    Forbidden = 403,
+    InternalServerError = 500,
+    NoContent = 204,
+    NotFound = 404,
+    Ok = 200,
+    Unprocessable = 422
+}
+export declare enum RouteType {
+    LoggerHandler = 0,
+    ErrorHandler = 1,
+    PublicRoute = 2,
+    Authentication = 3,
+    PrivateRoute = 4
+}
+export declare type SelectionIds = {
+    areExcluded: boolean;
+    ids: CompositeId[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,23 @@
+"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[HttpCode["Unprocessable"] = 422] = "Unprocessable";
+})(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["LoggerHandler"] = 0] = "LoggerHandler";
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBc0JBLElBQVksUUFRWDtBQVJELFdBQVksUUFBUTtJQUNsQixxREFBZ0IsQ0FBQTtJQUNoQixtREFBZSxDQUFBO0lBQ2YsdUVBQXlCLENBQUE7SUFDekIsbURBQWUsQ0FBQTtJQUNmLGlEQUFjLENBQUE7SUFDZCxxQ0FBUSxDQUFBO0lBQ1IsMkRBQW1CLENBQUE7QUFDckIsQ0FBQyxFQVJXLFFBQVEsR0FBUixnQkFBUSxLQUFSLGdCQUFRLFFBUW5CO0FBRUQsSUFBWSxTQU9YO0FBUEQsV0FBWSxTQUFTO0lBQ25CLGlHQUFpRztJQUNqRywyREFBaUIsQ0FBQTtJQUNqQix5REFBZ0IsQ0FBQTtJQUNoQix1REFBZSxDQUFBO0lBQ2YsNkRBQWtCLENBQUE7SUFDbEIseURBQWdCLENBQUE7QUFDbEIsQ0FBQyxFQVBXLFNBQVMsR0FBVCxpQkFBUyxLQUFULGlCQUFTLFFBT3BCIn0=

package/dist/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9keS1wYXJzZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYm9keS1wYXJzZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFHQSw4Q0FBMkI7QUFFM0IsTUFBcUIsVUFBVTtJQUM3QixNQUFNLENBQUMsaUJBQWlCLENBQUMsTUFBd0IsRUFBRSxPQUFnQjtRQUNqRSxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUM7UUFDeEMsTUFBTSxVQUFVLEdBQUcsSUFBSSxFQUFFLFVBQVUsQ0FBQztRQUNwQyxNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsVUFBVSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBQ3JELElBQUksR0FBRyxHQUFHLFVBQVUsRUFBRSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsSUFBSSxTQUFTLENBQUM7UUFDdkYsR0FBRyxHQUFHLFlBQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUMsVUFBVSxFQUFFLHdCQUF3QixDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUUxRixPQUFPLEVBQUUsV0FBVyxFQUFFLEdBQUcsRUFBRSxDQUFDO0lBQzlCLENBQUM7Q0FDRjtBQVZELDZCQVVDIn0=

package/dist/utils/condition-tree-parser.d.ts

@@ -0,0 +1,11 @@
+import { Collection, ConditionTree } from '@forestadmin/datasource-toolkit';
+export default class ConditionTreeParser {
+    static fromPlainObject(collection: Collection, json: unknown): ConditionTree;
+    /** Handle 'In' where the frontend unexpectedly sends strings */
+    private static parseValue;
+    /** Convert snake_case to PascalCase */
+    private static toPascalCase;
+    private static isLeaf;
+    private static isBranch;
+}
+//# sourceMappingURL=condition-tree-parser.d.ts.map

package/dist/utils/condition-tree-parser.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class ConditionTreeParser {
+    static fromPlainObject(collection, json) {
+        if (ConditionTreeParser.isLeaf(json)) {
+            const operator = ConditionTreeParser.toPascalCase(json.operator);
+            const value = ConditionTreeParser.parseValue(collection, { ...json, operator });
+            return new datasource_toolkit_1.ConditionTreeLeaf(json.field, operator, value);
+        }
+        if (ConditionTreeParser.isBranch(json)) {
+            const aggregator = ConditionTreeParser.toPascalCase(json.aggregator);
+            const conditions = json.conditions.map(subTree => ConditionTreeParser.fromPlainObject(collection, subTree));
+            return conditions.length !== 1
+                ? new datasource_toolkit_1.ConditionTreeBranch(aggregator, conditions)
+                : conditions[0];
+        }
+        throw new Error('Failed to instantiate condition tree from json');
+    }
+    /** Handle 'In' where the frontend unexpectedly sends strings */
+    static parseValue(collection, leaf) {
+        const schema = datasource_toolkit_1.CollectionUtils.getFieldSchema(collection, leaf.field);
+        if (leaf.operator === 'In' && typeof leaf.value === 'string') {
+            if (schema.columnType === 'Boolean') {
+                return leaf.value
+                    .split(',')
+                    .map(bool => !['false', '0', 'no'].includes(bool.toLowerCase().trim()));
+            }
+            if (schema.columnType === 'Number') {
+                return leaf.value
+                    .split(',')
+                    .map(string => Number(string.trim()))
+                    .filter(number => !Number.isNaN(number) && Number.isFinite(number));
+            }
+            return leaf.value.split(',').map(v => v.trim());
+        }
+        return leaf.value;
+    }
+    /** Convert snake_case to PascalCase */
+    static toPascalCase(value) {
+        const pascalCased = value.slice(0, 1).toUpperCase() +
+            value.slice(1).replace(/_[a-z]/g, match => match.slice(1).toUpperCase());
+        return pascalCased;
+    }
+    static isLeaf(raw) {
+        return typeof raw === 'object' && 'field' in raw && 'operator' in raw;
+    }
+    static isBranch(raw) {
+        return typeof raw === 'object' && 'aggregator' in raw && 'conditions' in raw;
+    }
+}
+exports.default = ConditionTreeParser;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uLXRyZWUtcGFyc2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2NvbmRpdGlvbi10cmVlLXBhcnNlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHdFQVN5QztBQUV6QyxNQUFxQixtQkFBbUI7SUFDdEMsTUFBTSxDQUFDLGVBQWUsQ0FBQyxVQUFzQixFQUFFLElBQWE7UUFDMUQsSUFBSSxtQkFBbUIsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDcEMsTUFBTSxRQUFRLEdBQUcsbUJBQW1CLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUNqRSxNQUFNLEtBQUssR0FBRyxtQkFBbUIsQ0FBQyxVQUFVLENBQUMsVUFBVSxFQUFFLEVBQUUsR0FBRyxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztZQUVoRixPQUFPLElBQUksc0NBQWlCLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxRQUFRLEVBQUUsS0FBSyxDQUFDLENBQUM7U0FDM0Q7UUFFRCxJQUFJLG1CQUFtQixDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUN0QyxNQUFNLFVBQVUsR0FBRyxtQkFBbUIsQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBZSxDQUFDO1lBQ25GLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQy9DLG1CQUFtQixDQUFDLGVBQWUsQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQ3pELENBQUM7WUFFRixPQUFPLFVBQVUsQ0FBQyxNQUFNLEtBQUssQ0FBQztnQkFDNUIsQ0FBQyxDQUFDLElBQUksd0NBQW1CLENBQUMsVUFBVSxFQUFFLFVBQVUsQ0FBQztnQkFDakQsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQztTQUNuQjtRQUVELE1BQU0sSUFBSSxLQUFLLENBQUMsZ0RBQWdELENBQUMsQ0FBQztJQUNwRSxDQUFDO0lBRUQsZ0VBQWdFO0lBQ3hELE1BQU0sQ0FBQyxVQUFVLENBQ3ZCLFVBQXNCLEVBQ3RCLElBQXlEO1FBRXpELE1BQU0sTUFBTSxHQUFHLG9DQUFlLENBQUMsY0FBYyxDQUFDLFVBQVUsRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFpQixDQUFDO1FBRXRGLElBQUksSUFBSSxDQUFDLFFBQVEsS0FBSyxJQUFJLElBQUksT0FBTyxJQUFJLENBQUMsS0FBSyxLQUFLLFFBQVEsRUFBRTtZQUM1RCxJQUFJLE1BQU0sQ0FBQyxVQUFVLEtBQUssU0FBUyxFQUFFO2dCQUNuQyxPQUFPLElBQUksQ0FBQyxLQUFLO3FCQUNkLEtBQUssQ0FBQyxHQUFHLENBQUM7cUJBQ1YsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sRUFBRSxHQUFHLEVBQUUsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7YUFDM0U7WUFFRCxJQUFJLE1BQU0sQ0FBQyxVQUFVLEtBQUssUUFBUSxFQUFFO2dCQUNsQyxPQUFPLElBQUksQ0FBQyxLQUFLO3FCQUNkLEtBQUssQ0FBQyxHQUFHLENBQUM7cUJBQ1YsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO3FCQUNwQyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLElBQUksTUFBTSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO2FBQ3ZFO1lBRUQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztTQUNqRDtRQUVELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztJQUNwQixDQUFDO0lBRUQsdUNBQXVDO0lBQy9CLE1BQU0sQ0FBQyxZQUFZLENBQUMsS0FBYTtRQUN2QyxNQUFNLFdBQVcsR0FDZixLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxXQUFXLEVBQUU7WUFDL0IsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDO1FBRTNFLE9BQU8sV0FBdUIsQ0FBQztJQUNqQyxDQUFDO0lBRU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFZO1FBQ2hDLE9BQU8sT0FBTyxHQUFHLEtBQUssUUFBUSxJQUFJLE9BQU8sSUFBSSxHQUFHLElBQUksVUFBVSxJQUFJLEdBQUcsQ0FBQztJQUN4RSxDQUFDO0lBRU8sTUFBTSxDQUFDLFFBQVEsQ0FBQyxHQUFZO1FBQ2xDLE9BQU8sT0FBTyxHQUFHLEtBQUssUUFBUSxJQUFJLFlBQVksSUFBSSxHQUFHLElBQUksWUFBWSxJQUFJLEdBQUcsQ0FBQztJQUMvRSxDQUFDO0NBQ0Y7QUFsRUQsc0NBa0VDIn0=

package/dist/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/utils/context-filter-factory.js

@@ -0,0 +1,28 @@
+"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),
+            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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC1maWx0ZXItZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9jb250ZXh0LWZpbHRlci1mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBTXlDO0FBRXpDLGtFQUErQztBQUUvQyxNQUFxQixvQkFBb0I7SUFDdkMsTUFBTSxDQUFDLGNBQWMsQ0FDbkIsVUFBc0IsRUFDdEIsT0FBZ0IsRUFDaEIsS0FBb0IsRUFDcEIsYUFBd0M7UUFFeEMsT0FBTyxJQUFJLG9DQUFlLENBQUM7WUFDekIsSUFBSSxFQUFFLHNCQUFpQixDQUFDLFNBQVMsQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDO1lBQ3RELElBQUksRUFBRSxzQkFBaUIsQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDO1lBQ2hELEdBQUcsb0JBQW9CLENBQUMsS0FBSyxDQUFDLFVBQVUsRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDO1lBQ3pELEdBQUcsYUFBYTtTQUNqQixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQUssQ0FDVixVQUFzQixFQUN0QixPQUFnQixFQUNoQixLQUFvQixFQUNwQixhQUErQjtRQUUvQixPQUFPLElBQUksMkJBQU0sQ0FBQztZQUNoQixNQUFNLEVBQUUsc0JBQWlCLENBQUMsV0FBVyxDQUFDLFVBQVUsRUFBRSxPQUFPLENBQUM7WUFDMUQsT0FBTyxFQUFFLHNCQUFpQixDQUFDLFlBQVksQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDO1lBQzVELGNBQWMsRUFBRSxzQkFBaUIsQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUM7WUFDOUQsYUFBYSxFQUFFLHlDQUFvQixDQUFDLFNBQVMsQ0FDM0Msc0JBQWlCLENBQUMsa0JBQWtCLENBQUMsVUFBVSxFQUFFLE9BQU8sQ0FBQyxFQUN6RCxLQUFLLENBQ047WUFDRCxHQUFHLGFBQWE7U0FDakIsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBaENELHVDQWdDQyJ9

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

@@ -0,0 +1,12 @@
+import { Caller, 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(caller: Caller, projection: Projection, header: string, filter: PaginatedFilter, collection: Collection, list: Collection['list']): AsyncGenerator<string>;
+    private static convert;
+}
+//# sourceMappingURL=csv-generator.d.ts.map

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

package/dist/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3N2LXJvdXRlLWNvbnRleHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvY3N2LXJvdXRlLWNvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxNQUFxQixlQUFlO0lBQ2xDLE1BQU0sQ0FBQyxhQUFhLENBQUMsT0FBZ0I7UUFDbkMsTUFBTSxFQUFFLFFBQVEsRUFBRSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO1FBRTNDLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSSxHQUFHLHlCQUF5QixDQUFDO1FBQ2xELE9BQU8sQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLHdCQUF3QixRQUFRLEVBQUUsQ0FBQyxDQUFDO1FBQ2hFLE9BQU8sQ0FBQyxRQUFRLENBQUMsWUFBWSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7UUFDM0MsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRSxtQkFBbUIsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQ3BELE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUUsZUFBZSxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDeEQsQ0FBQztDQUNGO0FBVkQsa0NBVUMifQ==

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

@@ -0,0 +1,68 @@
+import { IssuerMetadata } from 'openid-client';
+import { JSONAPIDocument } from 'json-api-serializer';
+import { PlainConditionTree } from '@forestadmin/datasource-toolkit';
+import { AgentOptions } from '../types';
+import { EnvironmentPermissionsV4, UserPermissionV4 } from '../services/authorization';
+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;
+    };
+    permissionLevel: string;
+};
+export declare type RenderingPermissions = {
+    actions: Set<string>;
+    actionsByUser: {
+        [actionName: string]: Set<number>;
+    };
+    scopes: {
+        [collectionName: string]: {
+            conditionTree: PlainConditionTree;
+            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>;
+    static getEnvironmentPermissions(options: HttpOptions): Promise<EnvironmentPermissionsV4>;
+    static getUsers(options: HttpOptions): Promise<UserPermissionV4[]>;
+    /** 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;
+    private static handleResponseError;
+}
+export {};
+//# sourceMappingURL=forest-http-api.d.ts.map