@forestadmin/agent 1.65.1 → 1.66.1

package/dist/services/authorization/internal/types.d.ts

@@ -0,0 +1,255 @@
+import { GenericTree } from '@forestadmin/datasource-toolkit';
+
+export declare type EnvironmentPermissionsV4 = EnvironmentPermissionsV4Remote | true;
+export declare type RightDescriptionWithRolesV4 = {
+  roles: number[];
+};
+export declare type RightDescriptionV4 = boolean | RightDescriptionWithRolesV4;
+export interface EnvironmentCollectionAccessPermissionsV4 {
+  browseEnabled: RightDescriptionV4;
+  readEnabled: RightDescriptionV4;
+  editEnabled: RightDescriptionV4;
+  addEnabled: RightDescriptionV4;
+  deleteEnabled: RightDescriptionV4;
+  exportEnabled: RightDescriptionV4;
+}
+export interface EnvironmentSmartActionPermissionsV4 {
+  triggerEnabled: RightDescriptionV4;
+  approvalRequired: RightDescriptionV4;
+  userApprovalEnabled: RightDescriptionV4;
+  selfApprovalEnabled: RightDescriptionV4;
+}
+export interface EnvironmentCollectionActionPermissionsV4 {
+  [actionName: string]: EnvironmentSmartActionPermissionsV4;
+}
+export interface EnvironmentCollectionPermissionsV4 {
+  collection: EnvironmentCollectionAccessPermissionsV4;
+  actions: EnvironmentCollectionActionPermissionsV4;
+}
+export interface EnvironmentCollectionsPermissionsV4 {
+  [id: string]: EnvironmentCollectionPermissionsV4;
+}
+export interface EnvironmentPermissionsV4Remote {
+  collections: EnvironmentCollectionsPermissionsV4;
+}
+export declare enum PermissionLevel {
+  Admin = 'admin',
+  Developer = 'developer',
+  Editor = 'editor',
+  User = 'user',
+}
+export declare type UserPermissionV4 = {
+  id: number;
+  firstName: string;
+  lastName: string;
+  email: string;
+  permissionLevel: PermissionLevel;
+  tags: Record<string, string>;
+  roleId: number;
+};
+export declare enum CollectionActionEvent {
+  Browse = 'browse',
+  Export = 'export',
+  Read = 'read',
+  Edit = 'edit',
+  Delete = 'delete',
+  Add = 'add',
+}
+export declare enum CustomActionEvent {
+  Trigger = 'trigger',
+  Approve = 'approve',
+  SelfApprove = 'self-approve',
+  RequireApproval = 'require-approval',
+}
+export declare enum ChartType {
+  Pie = 'Pie',
+  Value = 'Value',
+  Leaderboard = 'Leaderboard',
+  Line = 'Line',
+  Objective = 'Objective',
+  Percentage = 'Percentage',
+  Smart = 'Smart',
+}
+export interface DisplaySettings {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+export interface BaseChart {
+  type: ChartType;
+}
+export interface SmartRouteChart extends BaseChart {
+  type: Exclude<ChartType, ChartType.Smart>;
+  smartRoute: string;
+}
+export interface ApiRouteChart extends BaseChart {
+  type: Exclude<ChartType, ChartType.Smart>;
+  apiRoute: string;
+}
+export interface QueryChart extends BaseChart {
+  type: Exclude<ChartType, ChartType.Smart>;
+  query: string;
+  filter?: Record<string, any>;
+}
+export interface S3Versions {
+  'component.js': string;
+  'template.hbs': string;
+}
+export interface FilterableChart extends BaseChart {
+  filter?: string;
+}
+export interface AggregatedChart extends BaseChart {
+  aggregator: 'Sum' | 'Count';
+  aggregateFieldName: string | null;
+}
+export interface CollectionChart extends BaseChart {
+  sourceCollectionName: string | number;
+}
+export interface GroupedByChart extends BaseChart {
+  groupByFieldName: string | null;
+}
+export interface SmartChart extends BaseChart {
+  type: ChartType.Smart;
+  s3Versions: S3Versions & {
+    'style.css': string;
+  };
+  id: string;
+}
+export interface LeaderboardChart extends BaseChart, AggregatedChart, CollectionChart {
+  type: ChartType.Leaderboard;
+  labelFieldName: string;
+  relationshipFieldName: string;
+  limit: number;
+}
+export interface LineChart
+  extends BaseChart,
+    FilterableChart,
+    AggregatedChart,
+    CollectionChart,
+    GroupedByChart {
+  type: ChartType.Line;
+  timeRange: 'Day' | 'Week' | 'Month' | 'Year';
+}
+export interface ObjectiveChart
+  extends BaseChart,
+    FilterableChart,
+    AggregatedChart,
+    CollectionChart {
+  type: ChartType.Objective;
+  objective: number;
+}
+export interface PercentageChart extends BaseChart {
+  type: ChartType.Percentage;
+  numeratorChartId: string;
+  denominatorChartId: string;
+}
+export interface PieChart
+  extends BaseChart,
+    FilterableChart,
+    AggregatedChart,
+    CollectionChart,
+    GroupedByChart {
+  type: ChartType.Pie;
+}
+export interface ValueChart extends BaseChart, FilterableChart, AggregatedChart, CollectionChart {
+  type: ChartType.Value;
+}
+export declare type Chart =
+  | SmartChart
+  | ApiRouteChart
+  | QueryChart
+  | SmartRouteChart
+  | LeaderboardChart
+  | LineChart
+  | ObjectiveChart
+  | PercentageChart
+  | PieChart
+  | ValueChart;
+export interface CollectionColumn {
+  id: string | number;
+  fieldName: string;
+  position: number | null;
+  isVisible: boolean;
+}
+export interface BaseCollectionSegment {
+  id: string | number;
+  type: 'manual' | 'smart';
+  name: string;
+  position: number;
+  defaultSortingFieldName: string | null;
+  defaultSortingFieldOrder: 'ascending' | 'descending' | null;
+  isVisible: boolean;
+  hasColumnsConfiguration: boolean;
+  columns: CollectionColumn[];
+}
+export interface FilterCondition {
+  id: string;
+  value: boolean | number | string | string[];
+  fieldName: string | null;
+  subFieldName: string | null;
+  embeddedFieldName?: string | null;
+  operator: string;
+  embeddedField?: {
+    id?: number;
+    type: string;
+    field: string;
+    enums?: Array<string | number | Record<string, string>>;
+  } | null;
+}
+export interface Filter {
+  id?: string;
+  type: 'and' | 'or';
+  conditions: FilterCondition[] | null;
+}
+export interface ManualCollectionSegment extends BaseCollectionSegment {
+  type: 'manual';
+  filter: Filter | null;
+  query: string | null;
+}
+export interface SmartCollectionSegment extends BaseCollectionSegment {
+  type: 'smart';
+}
+export declare type CollectionSegment = ManualCollectionSegment | SmartCollectionSegment;
+export declare type DynamicScopesValues = {
+  users: Record<string, Record<string, string | number>>;
+};
+export declare type CollectionRenderingPermissionV4 = {
+  scope: GenericTree | null;
+  segments: CollectionSegment[];
+};
+export declare type Team = {
+  id: number;
+  name: string;
+};
+export declare type RenderingPermissionV4 = {
+  team: Team;
+  collections: Record<string, CollectionRenderingPermissionV4>;
+  stats: Chart[];
+};
+export declare type User = Record<string, any> & {
+  id: number;
+  tags: Record<string, string>;
+};
+export interface ActionApprovalAttributes {
+  requester_id: number;
+  ids: Array<string>;
+  collection_name: string;
+  smart_action_id: string;
+  values: any | null;
+  parent_collection_name: string | null;
+  parent_collection_id: string | null;
+  parent_association_name: string | null;
+  all_records: boolean;
+  all_records_subset_query: null;
+}
+export declare type ActionApprovalJWT = {
+  data: {
+    id: string | number;
+    type: string;
+    attributes: ActionApprovalAttributes;
+  };
+};
+export declare class JTWUnableToVerifyError extends Error {}
+export declare class JTWTokenExpiredError extends Error {}
+// # sourceMappingURL=types.d.ts.map

package/dist/services/authorization/internal/types.js

@@ -0,0 +1,54 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.JTWTokenExpiredError =
+  exports.JTWUnableToVerifyError =
+  exports.ChartType =
+  exports.CustomActionEvent =
+  exports.CollectionActionEvent =
+  exports.PermissionLevel =
+    void 0;
+let PermissionLevel;
+
+(function (PermissionLevel) {
+  PermissionLevel.Admin = 'admin';
+  PermissionLevel.Developer = 'developer';
+  PermissionLevel.Editor = 'editor';
+  PermissionLevel.User = 'user';
+})((PermissionLevel = exports.PermissionLevel || (exports.PermissionLevel = {})));
+
+let CollectionActionEvent;
+
+(function (CollectionActionEvent) {
+  CollectionActionEvent.Browse = 'browse';
+  CollectionActionEvent.Export = 'export';
+  CollectionActionEvent.Read = 'read';
+  CollectionActionEvent.Edit = 'edit';
+  CollectionActionEvent.Delete = 'delete';
+  CollectionActionEvent.Add = 'add';
+})((CollectionActionEvent = exports.CollectionActionEvent || (exports.CollectionActionEvent = {})));
+
+let CustomActionEvent;
+
+(function (CustomActionEvent) {
+  CustomActionEvent.Trigger = 'trigger';
+  CustomActionEvent.Approve = 'approve';
+  CustomActionEvent.SelfApprove = 'self-approve';
+  CustomActionEvent.RequireApproval = 'require-approval';
+})((CustomActionEvent = exports.CustomActionEvent || (exports.CustomActionEvent = {})));
+
+let ChartType;
+
+(function (ChartType) {
+  ChartType.Pie = 'Pie';
+  ChartType.Value = 'Value';
+  ChartType.Leaderboard = 'Leaderboard';
+  ChartType.Line = 'Line';
+  ChartType.Objective = 'Objective';
+  ChartType.Percentage = 'Percentage';
+  ChartType.Smart = 'Smart';
+})((ChartType = exports.ChartType || (exports.ChartType = {})));
+
+class JTWUnableToVerifyError extends Error {}
+exports.JTWUnableToVerifyError = JTWUnableToVerifyError;
+class JTWTokenExpiredError extends Error {}
+exports.JTWTokenExpiredError = JTWTokenExpiredError;
+// # sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvYXV0aG9yaXphdGlvbi9pbnRlcm5hbC90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUF5Q0EsSUFBWSxlQUtYO0FBTEQsV0FBWSxlQUFlO0lBQ3pCLGtDQUFlLENBQUE7SUFDZiwwQ0FBdUIsQ0FBQTtJQUN2QixvQ0FBaUIsQ0FBQTtJQUNqQixnQ0FBYSxDQUFBO0FBQ2YsQ0FBQyxFQUxXLGVBQWUsR0FBZix1QkFBZSxLQUFmLHVCQUFlLFFBSzFCO0FBWUQsSUFBWSxxQkFPWDtBQVBELFdBQVkscUJBQXFCO0lBQy9CLDBDQUFpQixDQUFBO0lBQ2pCLDBDQUFpQixDQUFBO0lBQ2pCLHNDQUFhLENBQUE7SUFDYixzQ0FBYSxDQUFBO0lBQ2IsMENBQWlCLENBQUE7SUFDakIsb0NBQVcsQ0FBQTtBQUNiLENBQUMsRUFQVyxxQkFBcUIsR0FBckIsNkJBQXFCLEtBQXJCLDZCQUFxQixRQU9oQztBQUVELElBQVksaUJBS1g7QUFMRCxXQUFZLGlCQUFpQjtJQUMzQix3Q0FBbUIsQ0FBQTtJQUNuQix3Q0FBbUIsQ0FBQTtJQUNuQixpREFBNEIsQ0FBQTtJQUM1Qix5REFBb0MsQ0FBQTtBQUN0QyxDQUFDLEVBTFcsaUJBQWlCLEdBQWpCLHlCQUFpQixLQUFqQix5QkFBaUIsUUFLNUI7QUFFRCxJQUFZLFNBUVg7QUFSRCxXQUFZLFNBQVM7SUFDbkIsd0JBQVcsQ0FBQTtJQUNYLDRCQUFlLENBQUE7SUFDZix3Q0FBMkIsQ0FBQTtJQUMzQiwwQkFBYSxDQUFBO0lBQ2Isb0NBQXVCLENBQUE7SUFDdkIsc0NBQXlCLENBQUE7SUFDekIsNEJBQWUsQ0FBQTtBQUNqQixDQUFDLEVBUlcsU0FBUyxHQUFULGlCQUFTLEtBQVQsaUJBQVMsUUFRcEI7QUErTUQsTUFBYSxzQkFBdUIsU0FBUSxLQUFLO0NBQUc7QUFBcEQsd0RBQW9EO0FBQ3BELE1BQWEsb0JBQXFCLFNBQVEsS0FBSztDQUFHO0FBQWxELG9EQUFrRCJ9

package/dist/services/authorization/internal/user-permission.d.ts

@@ -0,0 +1,16 @@
+import { AgentOptionsWithDefaults } from '../../../types';
+import { UserPermissionV4 } from './types';
+
+export declare type UserPermissionOptions = Pick<
+  AgentOptionsWithDefaults,
+  'forestServerUrl' | 'envSecret' | 'isProduction' | 'permissionsCacheDurationInSeconds' | 'logger'
+>;
+export default class UserPermissionService {
+  private readonly options;
+  private cacheExpirationTimestamp;
+  private userInfoById;
+  constructor(options: UserPermissionOptions);
+  getUserInfo(userId: number): Promise<UserPermissionV4 | undefined>;
+  clearCache(): void;
+}
+// # sourceMappingURL=user-permission.d.ts.map

package/dist/services/authorization/internal/user-permission.js

@@ -0,0 +1,46 @@
+const __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+
+Object.defineProperty(exports, '__esModule', { value: true });
+const forest_http_api_1 = __importDefault(require('../../../utils/forest-http-api'));
+
+class UserPermissionService {
+  constructor(options) {
+    this.options = options;
+    this.cacheExpirationTimestamp = 0;
+    // The trick here is to keep the cache as a Promise and not a Map
+    // in order to avoid doing the same HTTP request twice when
+    // 2 calls are made to getUserInfo at the same time.
+    this.userInfoById = null;
+  }
+
+  async getUserInfo(userId) {
+    if (
+      !this.cacheExpirationTimestamp ||
+      this.cacheExpirationTimestamp < Date.now() ||
+      !(await this.userInfoById).has(userId)
+    ) {
+      this.cacheExpirationTimestamp =
+        Date.now() + this.options.permissionsCacheDurationInSeconds * 1000;
+      this.options.logger('Debug', `Refreshing user permissions cache`);
+      // The response here is not awaited in order to be set in the cache
+      // allowing subsequent calls to getUserInfo to use the cache even if
+      // the response is not yet available.
+      this.userInfoById = forest_http_api_1.default
+        .getUsers(this.options)
+        .then(users => new Map(users.map(user => [user.id, user])));
+    }
+
+    return (await this.userInfoById).get(userId);
+  }
+
+  clearCache() {
+    this.userInfoById = null;
+    this.cacheExpirationTimestamp = Number.NEGATIVE_INFINITY;
+  }
+}
+exports.default = UserPermissionService;
+// # sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1wZXJtaXNzaW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2F1dGhvcml6YXRpb24vaW50ZXJuYWwvdXNlci1wZXJtaXNzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEscUZBQTJEO0FBTzNELE1BQXFCLHFCQUFxQjtJQVF4QyxZQUE2QixPQUE4QjtRQUE5QixZQUFPLEdBQVAsT0FBTyxDQUF1QjtRQVBuRCw2QkFBd0IsR0FBRyxDQUFDLENBQUM7UUFFckMsaUVBQWlFO1FBQ2pFLDJEQUEyRDtRQUMzRCxvREFBb0Q7UUFDNUMsaUJBQVksR0FBMkMsSUFBSSxDQUFDO0lBRU4sQ0FBQztJQUV4RCxLQUFLLENBQUMsV0FBVyxDQUFDLE1BQWM7UUFDckMsSUFDRSxDQUFDLElBQUksQ0FBQyx3QkFBd0I7WUFDOUIsSUFBSSxDQUFDLHdCQUF3QixHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUU7WUFDMUMsQ0FBQyxDQUFDLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFDdEM7WUFDQSxJQUFJLENBQUMsd0JBQXdCO2dCQUMzQixJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxpQ0FBaUMsR0FBRyxJQUFJLENBQUM7WUFFckUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLG1DQUFtQyxDQUFDLENBQUM7WUFFbEUsbUVBQW1FO1lBQ25FLG9FQUFvRTtZQUNwRSxxQ0FBcUM7WUFDckMsSUFBSSxDQUFDLFlBQVksR0FBRyx5QkFBYSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUMzRCxLQUFLLENBQUMsRUFBRSxDQUFDLElBQUksR0FBRyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUNyRCxDQUFDO1NBQ0g7UUFFRCxPQUFPLENBQUMsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQy9DLENBQUM7SUFFTSxVQUFVO1FBQ2YsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7UUFDekIsSUFBSSxDQUFDLHdCQUF3QixHQUFHLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQztJQUMzRCxDQUFDO0NBQ0Y7QUFwQ0Qsd0NBb0NDIn0=

package/dist/services/permissions.d.ts

@@ -0,0 +1,19 @@
+import { Collection, ConditionTree } from '@forestadmin/datasource-toolkit';
+import { Context } from 'koa';
+import { AgentOptionsWithDefaults } from '../types';
+declare type RolesOptions = Pick<AgentOptionsWithDefaults, 'forestServerUrl' | 'envSecret' | 'isProduction' | 'permissionsCacheDurationInSeconds'>;
+export default class PermissionService {
+    private options;
+    private cache;
+    constructor(options: RolesOptions);
+    invalidateCache(renderingId: number): void;
+    /** Checks that a charting query is in the list of allowed queries */
+    canChart(context: Context): Promise<void>;
+    /** Check if a user is allowed to perform a specific action */
+    can(context: Context, action: string, allowRefetch?: boolean): Promise<void>;
+    getScope(collection: Collection, context: Context): Promise<ConditionTree>;
+    /** Get cached version of "rendering permissions" */
+    private getRenderingPermissions;
+}
+export {};
+//# sourceMappingURL=permissions.d.ts.map

package/dist/services/permissions.js

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

package/dist/types.d.ts

@@ -19,6 +19,7 @@ export type AgentOptions = {
     permissionsCacheDurationInSeconds?: number;
     skipSchemaUpdate?: boolean;
     forestAdminClient?: ForestAdminClient;
+    limitExportSize?: number;
     experimental?: {
         webhookCustomActions?: boolean;
         updateRecordCustomActions?: boolean;

package/dist/types.js

@@ -20,4 +20,4 @@ var RouteType;
     RouteType[RouteType["Authentication"] = 3] = "Authentication";
     RouteType[RouteType["PrivateRoute"] = 4] = "PrivateRoute";
 })(RouteType = exports.RouteType || (exports.RouteType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBa0RBLElBQVksUUFRWDtBQVJELFdBQVksUUFBUTtJQUNsQixxREFBZ0IsQ0FBQTtJQUNoQixtREFBZSxDQUFBO0lBQ2YsdUVBQXlCLENBQUE7SUFDekIsbURBQWUsQ0FBQTtJQUNmLGlEQUFjLENBQUE7SUFDZCxxQ0FBUSxDQUFBO0lBQ1IsMkRBQW1CLENBQUE7QUFDckIsQ0FBQyxFQVJXLFFBQVEsR0FBUixnQkFBUSxLQUFSLGdCQUFRLFFBUW5CO0FBRUQsSUFBWSxTQU9YO0FBUEQsV0FBWSxTQUFTO0lBQ25CLGlHQUFpRztJQUNqRywyREFBaUIsQ0FBQTtJQUNqQix5REFBZ0IsQ0FBQTtJQUNoQix1REFBZSxDQUFBO0lBQ2YsNkRBQWtCLENBQUE7SUFDbEIseURBQWdCLENBQUE7QUFDbEIsQ0FBQyxFQVBXLFNBQVMsR0FBVCxpQkFBUyxLQUFULGlCQUFTLFFBT3BCIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBbURBLElBQVksUUFRWDtBQVJELFdBQVksUUFBUTtJQUNsQixxREFBZ0IsQ0FBQTtJQUNoQixtREFBZSxDQUFBO0lBQ2YsdUVBQXlCLENBQUE7SUFDekIsbURBQWUsQ0FBQTtJQUNmLGlEQUFjLENBQUE7SUFDZCxxQ0FBUSxDQUFBO0lBQ1IsMkRBQW1CLENBQUE7QUFDckIsQ0FBQyxFQVJXLFFBQVEsR0FBUixnQkFBUSxLQUFSLGdCQUFRLFFBUW5CO0FBRUQsSUFBWSxTQU9YO0FBUEQsV0FBWSxTQUFTO0lBQ25CLGlHQUFpRztJQUNqRywyREFBaUIsQ0FBQTtJQUNqQix5REFBZ0IsQ0FBQTtJQUNoQix1REFBZSxDQUFBO0lBQ2YsNkRBQWtCLENBQUE7SUFDbEIseURBQWdCLENBQUE7QUFDbEIsQ0FBQyxFQVBXLFNBQVMsR0FBVCxpQkFBUyxLQUFULGlCQUFTLFFBT3BCIn0=

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

@@ -6,7 +6,7 @@ export default class CsvGenerator {
      * - 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>;
+    static generate(caller: Caller, projection: Projection, header: string, filter: PaginatedFilter, limitExportSize: number, collection: Collection, list: Collection['list']): AsyncGenerator<string>;
     private static convert;
 }
 //# sourceMappingURL=csv-generator.d.ts.map

package/dist/utils/csv-generator.js

@@ -10,23 +10,30 @@ class CsvGenerator {
      * - 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) {
+    static async *generate(caller, projection, header, filter, limitExportSize, collection, list) {
         yield (0, format_1.writeToString)([header.split(',')], { headers: true, includeEndRowDelimiter: true });
         const copiedFilter = { ...filter };
         if (!copiedFilter.sort || copiedFilter.sort.length === 0) {
             copiedFilter.sort = datasource_toolkit_1.SortFactory.byPrimaryKeys(collection);
         }
         let currentIndex = 0;
+        let pageLimit = limitExportSize != null ? Math.min(limitExportSize, exports.CHUNK_SIZE) : exports.CHUNK_SIZE;
         let areAllRecordsFetched = false;
         while (!areAllRecordsFetched) {
             // the first argument is included in the range, the second is excluded
-            copiedFilter.page = new datasource_toolkit_1.Page(currentIndex, exports.CHUNK_SIZE);
+            copiedFilter.page = new datasource_toolkit_1.Page(currentIndex, pageLimit);
             // eslint-disable-next-line no-await-in-loop
             const records = await list(caller, new datasource_toolkit_1.PaginatedFilter(copiedFilter), projection);
             if (records.length !== 0)
                 yield CsvGenerator.convert(records, projection);
-            areAllRecordsFetched = records.length < exports.CHUNK_SIZE;
-            currentIndex += exports.CHUNK_SIZE;
+            currentIndex += pageLimit;
+            areAllRecordsFetched = records.length < exports.CHUNK_SIZE || limitExportSize === currentIndex;
+            if (limitExportSize) {
+                pageLimit = Math.min(exports.CHUNK_SIZE, limitExportSize - currentIndex);
+            }
+            else {
+                pageLimit = exports.CHUNK_SIZE;
+            }
         }
     }
     static convert(records, projection) {
@@ -40,4 +47,4 @@ class CsvGenerator {
     }
 }
 exports.default = CsvGenerator;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3N2LWdlbmVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9jc3YtZ2VuZXJhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDZDQUFpRDtBQUNqRCx3RUFTeUM7QUFFNUIsUUFBQSxVQUFVLEdBQUcsSUFBSSxDQUFDO0FBRS9CLE1BQXFCLFlBQVk7SUFDL0I7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxRQUFRLENBQ3BCLE1BQWMsRUFDZCxVQUFzQixFQUN0QixNQUFjLEVBQ2QsTUFBdUIsRUFDdkIsZUFBdUIsRUFDdkIsVUFBc0IsRUFDdEIsSUFBd0I7UUFFeEIsTUFBTSxJQUFBLHNCQUFhLEVBQUMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLHNCQUFzQixFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFFMUYsTUFBTSxZQUFZLEdBQUcsRUFBRSxHQUFHLE1BQU0sRUFBRSxDQUFDO1FBRW5DLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxJQUFJLFlBQVksQ0FBQyxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtZQUN4RCxZQUFZLENBQUMsSUFBSSxHQUFHLGdDQUFXLENBQUMsYUFBYSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1NBQzNEO1FBRUQsSUFBSSxZQUFZLEdBQUcsQ0FBQyxDQUFDO1FBQ3JCLElBQUksU0FBUyxHQUFHLGVBQWUsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsZUFBZSxFQUFFLGtCQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsa0JBQVUsQ0FBQztRQUM3RixJQUFJLG9CQUFvQixHQUFHLEtBQUssQ0FBQztRQUVqQyxPQUFPLENBQUMsb0JBQW9CLEVBQUU7WUFDNUIsc0VBQXNFO1lBQ3RFLFlBQVksQ0FBQyxJQUFJLEdBQUcsSUFBSSx5QkFBSSxDQUFDLFlBQVksRUFBRSxTQUFTLENBQUMsQ0FBQztZQUV0RCw0Q0FBNEM7WUFDNUMsTUFBTSxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksb0NBQWUsQ0FBQyxZQUFZLENBQUMsRUFBRSxVQUFVLENBQUMsQ0FBQztZQUVsRixJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssQ0FBQztnQkFBRSxNQUFNLFlBQVksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBRTFFLFlBQVksSUFBSSxTQUFTLENBQUM7WUFDMUIsb0JBQW9CLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxrQkFBVSxJQUFJLGVBQWUsS0FBSyxZQUFZLENBQUM7WUFFdkYsSUFBSSxlQUFlLEVBQUU7Z0JBQ25CLFNBQVMsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLGtCQUFVLEVBQUUsZUFBZSxHQUFHLFlBQVksQ0FBQyxDQUFDO2FBQ2xFO2lCQUFNO2dCQUNMLFNBQVMsR0FBRyxrQkFBVSxDQUFDO2FBQ3hCO1NBQ0Y7SUFDSCxDQUFDO0lBRU8sTUFBTSxDQUFDLE9BQU8sQ0FBQyxPQUFxQixFQUFFLFVBQXNCO1FBQ2xFLE9BQU8sSUFBQSxzQkFBYSxFQUNsQixPQUFPLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQ25CLFVBQVUsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDckIsTUFBTSxLQUFLLEdBQUcsZ0NBQVcsQ0FBQyxhQUFhLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBRXZELElBQUksS0FBSyxFQUFFLFFBQVEsRUFBRSxLQUFLLGlCQUFpQixFQUFFO2dCQUMzQyxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7YUFDOUI7WUFFRCxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUMsQ0FBQyxDQUNILEVBQ0QsRUFBRSxzQkFBc0IsRUFBRSxJQUFJLEVBQUUsQ0FDakMsQ0FBQztJQUNKLENBQUM7Q0FDRjtBQS9ERCwrQkErREMifQ==

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

@@ -0,0 +1,37 @@
+import { JSONAPIDocument } from 'json-api-serializer';
+import { IssuerMetadata } from 'openid-client';
+import { AgentOptions } from '../types';
+export declare type IpWhitelistConfiguration = {
+    isFeatureEnabled: boolean;
+    ipRules: Array<{
+        type: number;
+        ipMinimum?: string;
+        ipMaximum?: string;
+        ip?: string;
+        range?: string;
+    }>;
+};
+export declare type UserInfo = {
+    id: number;
+    email: string;
+    firstName: string;
+    lastName: string;
+    team: string;
+    renderingId: number;
+    role: string;
+    tags: {
+        [key: string]: string;
+    };
+    permissionLevel: string;
+};
+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>;
+    private static handleResponseError;
+}
+export {};
+//# sourceMappingURL=forest-http-api.d.ts.map