@forestadmin/agent 1.0.0-beta.1

package/dist/agent/utils/forest-schema/generator-actions.js

@@ -0,0 +1,99 @@
+"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 path_1 = __importDefault(require("path"));
+const action_values_1 = __importDefault(require("./action-values"));
+class SchemaGeneratorActions {
+    static async buildSchema(prefix, collection, name) {
+        const schema = collection.schema.actions[name];
+        const actionIndex = Object.keys(collection.schema.actions).indexOf(name);
+        // Generate url-safe friendly name (which won't be unique, but that's OK).
+        const slug = name.toLocaleLowerCase().replace(/[^a-z0-9-]+/g, '-');
+        const fields = await SchemaGeneratorActions.buildFields(collection, name, schema);
+        return {
+            id: `${collection.name}-${actionIndex}-${slug}`,
+            name,
+            type: schema.scope.toLowerCase(),
+            baseUrl: null,
+            endpoint: path_1.default.join('/', prefix, '_actions', collection.name, String(actionIndex), slug),
+            httpMethod: 'POST',
+            redirect: null,
+            download: Boolean(schema.generateFile),
+            fields,
+            hooks: {
+                load: !schema.staticForm,
+                // Always registering the change hook has no consequences, even if we don't use it.
+                change: ['changeHook'],
+            },
+        };
+    }
+    /** Build schema for given field */
+    static buildFieldSchema(dataSource, field) {
+        const { label, description, isRequired, isReadOnly, watchChanges, type } = field;
+        const output = { description, isRequired, isReadOnly };
+        output.field = label;
+        output.value = action_values_1.default.valueToForest(field, field.value);
+        if (watchChanges)
+            output.hook = 'changeHook';
+        if (type === 'Collection') {
+            const collection = dataSource.getCollection(field.collectionName);
+            const [pk] = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(collection.schema);
+            const pkSchema = collection.schema.fields[pk];
+            output.type = pkSchema.columnType;
+            output.reference = `${collection.name}.${pk}`;
+        }
+        else if (type.endsWith('List')) {
+            output.type = [type.substring(0, type.length - 4)];
+        }
+        else {
+            output.type = type;
+        }
+        if (type === 'Enum' || type === 'EnumList') {
+            output.enums = field.enumValues;
+        }
+        return output;
+    }
+    static async buildFields(collection, name, schema) {
+        // We want the schema to be generated on usage => send dummy schema
+        if (!schema.staticForm) {
+            return SchemaGeneratorActions.defaultFields;
+        }
+        // Ask the action to generate a form
+        const fields = await collection.getForm(name);
+        if (fields) {
+            // When sending to server, we need to rename 'value' into 'defaultValue'
+            // otherwise, it does not gets applied 🤷‍♂️
+            return fields.map(field => {
+                const newField = SchemaGeneratorActions.buildFieldSchema(collection.dataSource, field);
+                newField.defaultValue = newField.value;
+                delete newField.value;
+                return newField;
+            });
+        }
+        return [];
+    }
+}
+exports.default = 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.
+ */
+SchemaGeneratorActions.defaultFields = [
+    {
+        field: 'Loading...',
+        type: 'String',
+        isReadOnly: true,
+        defaultValue: 'Form is loading',
+        value: undefined,
+        description: '',
+        enums: null,
+        hook: null,
+        isRequired: false,
+        reference: null,
+        widget: null,
+    },
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+import { Collection } from '@forestadmin/datasource-toolkit';
+import { ForestServerCollection } from './types';
+export default class SchemaGeneratorCollection {
+    /** Build forest-server schema for a collection */
+    static buildSchema(prefix: string, collection: Collection): Promise<ForestServerCollection>;
+}
+//# sourceMappingURL=generator-collection.d.ts.map

package/dist/agent/utils/forest-schema/generator-collection.js

@@ -0,0 +1,31 @@
+"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 generator_actions_1 = __importDefault(require("./generator-actions"));
+const generator_fields_1 = __importDefault(require("./generator-fields"));
+const generator_segments_1 = __importDefault(require("./generator-segments"));
+class SchemaGeneratorCollection {
+    /** Build forest-server schema for a collection */
+    static async buildSchema(prefix, collection) {
+        return {
+            actions: await Promise.all(Object.keys(collection.schema.actions).map(name => generator_actions_1.default.buildSchema(prefix, collection, name))),
+            fields: Object.keys(collection.schema.fields)
+                .filter(name => !datasource_toolkit_1.SchemaUtils.isForeignKey(collection.schema, name))
+                .map(name => generator_fields_1.default.buildSchema(collection, name)),
+            icon: null,
+            integration: null,
+            isReadOnly: Object.values(collection.schema.fields).every(field => field.type === 'Column' && field.isReadOnly),
+            isSearchable: collection.schema.searchable,
+            isVirtual: false,
+            name: collection.name,
+            onlyForRelationships: false,
+            paginationType: 'page',
+            segments: collection.schema.segments.map(name => generator_segments_1.default.buildSchema(collection, name)),
+        };
+    }
+}
+exports.default = SchemaGeneratorCollection;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdG9yLWNvbGxlY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYWdlbnQvdXRpbHMvZm9yZXN0LXNjaGVtYS9nZW5lcmF0b3ItY29sbGVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHdFQUEwRTtBQUUxRSw0RUFBeUQ7QUFDekQsMEVBQXVEO0FBQ3ZELDhFQUEyRDtBQUUzRCxNQUFxQix5QkFBeUI7SUFDNUMsa0RBQWtEO0lBQ2xELE1BQU0sQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUN0QixNQUFjLEVBQ2QsVUFBc0I7UUFFdEIsT0FBTztZQUNMLE9BQU8sRUFBRSxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQ3hCLE1BQU0sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDaEQsMkJBQXNCLENBQUMsV0FBVyxDQUFDLE1BQU0sRUFBRSxVQUFVLEVBQUUsSUFBSSxDQUFDLENBQzdELENBQ0Y7WUFDRCxNQUFNLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQztpQkFDMUMsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxnQ0FBVyxDQUFDLFlBQVksQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO2lCQUNsRSxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQywwQkFBcUIsQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQ25FLElBQUksRUFBRSxJQUFJO1lBQ1YsV0FBVyxFQUFFLElBQUk7WUFDakIsVUFBVSxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLENBQ3ZELEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxRQUFRLElBQUksS0FBSyxDQUFDLFVBQVUsQ0FDckQ7WUFDRCxZQUFZLEVBQUUsVUFBVSxDQUFDLE1BQU0sQ0FBQyxVQUFVO1lBQzFDLFNBQVMsRUFBRSxLQUFLO1lBQ2hCLElBQUksRUFBRSxVQUFVLENBQUMsSUFBSTtZQUNyQixvQkFBb0IsRUFBRSxLQUFLO1lBQzNCLGNBQWMsRUFBRSxNQUFNO1lBQ3RCLFFBQVEsRUFBRSxVQUFVLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDOUMsNEJBQXVCLENBQUMsV0FBVyxDQUFDLFVBQVUsRUFBRSxJQUFJLENBQUMsQ0FDdEQ7U0FDRixDQUFDO0lBQ0osQ0FBQztDQUNGO0FBOUJELDRDQThCQyJ9

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

@@ -0,0 +1,13 @@
+import { Collection } from '@forestadmin/datasource-toolkit';
+import { ForestServerField } from './types';
+export default class SchemaGeneratorFields {
+    private static relationMap;
+    static buildSchema(collection: Collection, name: string): ForestServerField;
+    private static buildColumnSchema;
+    private static buildToManyRelationSchema;
+    private static isForeignCollectionFilterable;
+    private static buildOneToOneSchema;
+    private static buildManyToOneSchema;
+    private static buildRelationSchema;
+}
+//# sourceMappingURL=generator-fields.d.ts.map

package/dist/agent/utils/forest-schema/generator-fields.js

@@ -0,0 +1,131 @@
+"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 filterable_1 = __importDefault(require("./filterable"));
+const validation_1 = __importDefault(require("./validation"));
+class SchemaGeneratorFields {
+    static buildSchema(collection, name) {
+        const { type } = collection.schema.fields[name];
+        let schema;
+        switch (type) {
+            case 'Column':
+                schema = SchemaGeneratorFields.buildColumnSchema(collection, name);
+                break;
+            case 'ManyToOne':
+            case 'OneToMany':
+            case 'ManyToMany':
+            case 'OneToOne':
+                schema = SchemaGeneratorFields.buildRelationSchema(collection, name);
+                break;
+            default:
+                throw new Error('Invalid field type');
+        }
+        return Object.entries(schema)
+            .sort()
+            .reduce((sortedSchema, [key, value]) => {
+            sortedSchema[key] = value;
+            return sortedSchema;
+        }, {});
+    }
+    static buildColumnSchema(collection, name) {
+        const column = collection.schema.fields[name];
+        return {
+            defaultValue: column.defaultValue ?? null,
+            enums: column.enumValues ?? null,
+            field: name,
+            integration: null,
+            inverseOf: null,
+            isFilterable: filterable_1.default.isFilterable(column.columnType, column.filterOperators),
+            isPrimaryKey: Boolean(column.isPrimaryKey),
+            isReadOnly: Boolean(column.isReadOnly),
+            isRequired: column.validation?.some(v => v.operator === 'Present') ?? false,
+            isSortable: Boolean(column.isSortable),
+            isVirtual: false,
+            reference: null,
+            type: column.columnType,
+            validations: validation_1.default.convertValidationList(column.validation),
+        };
+    }
+    static buildToManyRelationSchema(relation, foreignCollection, baseSchema) {
+        const key = relation.type === 'OneToMany' ? relation.originKeyTarget : relation.foreignKeyTarget;
+        const keySchema = foreignCollection.schema.fields[key];
+        return {
+            type: [keySchema.columnType],
+            defaultValue: null,
+            isFilterable: false,
+            isPrimaryKey: false,
+            isRequired: false,
+            isSortable: false,
+            validations: [],
+            reference: `${foreignCollection.name}.${key}`,
+            ...baseSchema,
+        };
+    }
+    static isForeignCollectionFilterable(foreignCollection) {
+        return Object.values(foreignCollection.schema.fields).some(field => field.type === 'Column' &&
+            filterable_1.default.isFilterable(field.columnType, field.filterOperators));
+    }
+    static buildOneToOneSchema(relation, foreignCollection, baseSchema) {
+        const key = relation.originKeyTarget;
+        const keySchema = foreignCollection.schema.fields[key];
+        return {
+            type: keySchema.columnType,
+            defaultValue: null,
+            isFilterable: SchemaGeneratorFields.isForeignCollectionFilterable(foreignCollection),
+            isPrimaryKey: false,
+            isRequired: false,
+            isSortable: Boolean(keySchema.isSortable),
+            validations: [],
+            reference: `${foreignCollection.name}.${key}`,
+            ...baseSchema,
+        };
+    }
+    static buildManyToOneSchema(relation, collection, foreignCollection, baseSchema) {
+        const key = relation.foreignKey;
+        const keySchema = collection.schema.fields[key];
+        return {
+            type: keySchema.columnType,
+            defaultValue: keySchema.defaultValue ?? null,
+            isFilterable: SchemaGeneratorFields.isForeignCollectionFilterable(foreignCollection),
+            isPrimaryKey: Boolean(keySchema.isPrimaryKey),
+            isRequired: keySchema.validation?.some(v => v.operator === 'Present') ?? false,
+            isSortable: Boolean(keySchema.isSortable),
+            validations: validation_1.default.convertValidationList(keySchema.validation),
+            reference: `${foreignCollection.name}.${relation.foreignKeyTarget}`,
+            ...baseSchema,
+        };
+    }
+    static buildRelationSchema(collection, name) {
+        const relation = collection.schema.fields[name];
+        const foreignCollection = collection.dataSource.getCollection(relation.foreignCollection);
+        const relationSchema = {
+            field: name,
+            enums: null,
+            integration: null,
+            isReadOnly: false,
+            isVirtual: false,
+            inverseOf: datasource_toolkit_1.CollectionUtils.getInverseRelation(collection, name),
+            relationship: SchemaGeneratorFields.relationMap[relation.type],
+        };
+        switch (relation.type) {
+            case 'ManyToMany':
+            case 'OneToMany':
+                return SchemaGeneratorFields.buildToManyRelationSchema(relation, foreignCollection, relationSchema);
+            case 'OneToOne':
+                return SchemaGeneratorFields.buildOneToOneSchema(relation, foreignCollection, relationSchema);
+            default:
+                return SchemaGeneratorFields.buildManyToOneSchema(relation, collection, foreignCollection, relationSchema);
+        }
+    }
+}
+exports.default = SchemaGeneratorFields;
+SchemaGeneratorFields.relationMap = {
+    ManyToMany: 'BelongsToMany',
+    ManyToOne: 'BelongsTo',
+    OneToMany: 'HasMany',
+    OneToOne: 'HasOne',
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+import { Collection, CollectionSchema } from '@forestadmin/datasource-toolkit';
+import { ForestServerSegment } from './types';
+export default class SchemaGeneratorSegments {
+    static buildSchema(collection: Collection, name: CollectionSchema['segments'][number]): ForestServerSegment;
+}
+//# sourceMappingURL=generator-segments.d.ts.map

package/dist/agent/utils/forest-schema/generator-segments.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SchemaGeneratorSegments {
+    static buildSchema(collection, name) {
+        return { id: `${collection.name}.${name}`, name };
+    }
+}
+exports.default = SchemaGeneratorSegments;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdG9yLXNlZ21lbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FnZW50L3V0aWxzL2ZvcmVzdC1zY2hlbWEvZ2VuZXJhdG9yLXNlZ21lbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0EsTUFBcUIsdUJBQXVCO0lBQzFDLE1BQU0sQ0FBQyxXQUFXLENBQ2hCLFVBQXNCLEVBQ3RCLElBQTBDO1FBRTFDLE9BQU8sRUFBRSxFQUFFLEVBQUUsR0FBRyxVQUFVLENBQUMsSUFBSSxJQUFJLElBQUksRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDO0lBQ3BELENBQUM7Q0FDRjtBQVBELDBDQU9DIn0=

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

@@ -0,0 +1,79 @@
+import { ColumnType } from '@forestadmin/datasource-toolkit';
+export declare type ForestServerCollection = {
+    name: string;
+    icon: null;
+    integration: null;
+    isReadOnly: boolean;
+    isSearchable: boolean;
+    isVirtual: false;
+    onlyForRelationships: boolean;
+    paginationType: 'page';
+    actions: Array<ForestServerAction>;
+    fields: Array<ForestServerField>;
+    segments: Array<ForestServerSegment>;
+};
+export declare type ForestServerAction = {
+    id: string;
+    name: string;
+    type: 'single' | 'bulk' | 'global';
+    baseUrl: string;
+    endpoint: string;
+    httpMethod: 'POST';
+    redirect: unknown;
+    download: boolean;
+    fields: ForestServerActionField[];
+    hooks: {
+        load: boolean;
+        change: Array<unknown>;
+    };
+};
+export declare type ForestServerActionField = {
+    value: unknown;
+    defaultValue: unknown;
+    description: string | null;
+    enums: string[];
+    field: string;
+    hook: string;
+    isReadOnly: boolean;
+    isRequired: boolean;
+    reference: string | null;
+    type: ColumnType;
+    widget: null | 'belongsto select' | 'file picker';
+};
+export declare type ForestServerField = Partial<{
+    field: string;
+    type: ColumnType;
+    defaultValue: unknown;
+    enums: null | string[];
+    integration: null;
+    isFilterable: boolean;
+    isPrimaryKey: boolean;
+    isReadOnly: boolean;
+    isRequired: boolean;
+    isSortable: boolean;
+    isVirtual: boolean;
+    reference: null | string;
+    inverseOf: null | string;
+    relationship: 'BelongsTo' | 'BelongsToMany' | 'HasMany' | 'HasOne';
+    validations: Array<{
+        message: null;
+        type: ValidationType;
+        value: unknown;
+    }>;
+}>;
+export declare type ForestServerSegment = {
+    id: string;
+    name: string;
+};
+export declare enum ValidationType {
+    Present = "is present",
+    GreaterThan = "is greater than",
+    LessThan = "is less than",
+    Before = "is before",
+    After = "is after",
+    LongerThan = "is longer than",
+    ShorterThan = "is shorter than",
+    Contains = "contains",
+    Like = "is like"
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationType = void 0;
+var ValidationType;
+(function (ValidationType) {
+    ValidationType["Present"] = "is present";
+    ValidationType["GreaterThan"] = "is greater than";
+    ValidationType["LessThan"] = "is less than";
+    ValidationType["Before"] = "is before";
+    ValidationType["After"] = "is after";
+    ValidationType["LongerThan"] = "is longer than";
+    ValidationType["ShorterThan"] = "is shorter than";
+    ValidationType["Contains"] = "contains";
+    ValidationType["Like"] = "is like";
+})(ValidationType = exports.ValidationType || (exports.ValidationType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYWdlbnQvdXRpbHMvZm9yZXN0LXNjaGVtYS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFxRUEsSUFBWSxjQVVYO0FBVkQsV0FBWSxjQUFjO0lBQ3hCLHdDQUFzQixDQUFBO0lBQ3RCLGlEQUErQixDQUFBO0lBQy9CLDJDQUF5QixDQUFBO0lBQ3pCLHNDQUFvQixDQUFBO0lBQ3BCLG9DQUFrQixDQUFBO0lBQ2xCLCtDQUE2QixDQUFBO0lBQzdCLGlEQUErQixDQUFBO0lBQy9CLHVDQUFxQixDQUFBO0lBQ3JCLGtDQUFnQixDQUFBO0FBQ2xCLENBQUMsRUFWVyxjQUFjLEdBQWQsc0JBQWMsS0FBZCxzQkFBYyxRQVV6QiJ9

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

@@ -0,0 +1,10 @@
+import { ColumnSchema } from '@forestadmin/datasource-toolkit';
+import { ForestServerField } from './types';
+declare type FrontendValidation = ForestServerField['validations'][number];
+declare type Validation = ColumnSchema['validation'][number];
+export default class FrontendValidationUtils {
+    private static operatorValidationTypeMap;
+    static convertValidationList(predicates?: Validation[]): FrontendValidation[];
+}
+export {};
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+class FrontendValidationUtils {
+    static convertValidationList(predicates) {
+        if (!predicates)
+            return [];
+        return predicates
+            .map(p => {
+            const type = FrontendValidationUtils.operatorValidationTypeMap[p.operator];
+            return type ? { type, value: p.value, message: null } : null;
+        })
+            .filter(Boolean);
+    }
+}
+exports.default = FrontendValidationUtils;
+FrontendValidationUtils.operatorValidationTypeMap = {
+    Present: types_1.ValidationType.Present,
+    GreaterThan: types_1.ValidationType.GreaterThan,
+    LessThan: types_1.ValidationType.LessThan,
+    LongerThan: types_1.ValidationType.LongerThan,
+    ShorterThan: types_1.ValidationType.ShorterThan,
+    Contains: types_1.ValidationType.Contains,
+    Like: types_1.ValidationType.Like,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hZ2VudC91dGlscy9mb3Jlc3Qtc2NoZW1hL3ZhbGlkYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFDQSxtQ0FBNEQ7QUFLNUQsTUFBcUIsdUJBQXVCO0lBVzFDLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxVQUF5QjtRQUNwRCxJQUFJLENBQUMsVUFBVTtZQUFFLE9BQU8sRUFBRSxDQUFDO1FBRTNCLE9BQU8sVUFBVTthQUNkLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRTtZQUNQLE1BQU0sSUFBSSxHQUFHLHVCQUF1QixDQUFDLHlCQUF5QixDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUUzRSxPQUFPLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7UUFDL0QsQ0FBQyxDQUFDO2FBQ0QsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3JCLENBQUM7O0FBckJILDBDQXNCQztBQXJCZ0IsaURBQXlCLEdBQThDO0lBQ3BGLE9BQU8sRUFBRSxzQkFBYyxDQUFDLE9BQU87SUFDL0IsV0FBVyxFQUFFLHNCQUFjLENBQUMsV0FBVztJQUN2QyxRQUFRLEVBQUUsc0JBQWMsQ0FBQyxRQUFRO0lBQ2pDLFVBQVUsRUFBRSxzQkFBYyxDQUFDLFVBQVU7SUFDckMsV0FBVyxFQUFFLHNCQUFjLENBQUMsV0FBVztJQUN2QyxRQUFRLEVBQUUsc0JBQWMsQ0FBQyxRQUFRO0lBQ2pDLElBQUksRUFBRSxzQkFBYyxDQUFDLElBQUk7Q0FDMUIsQ0FBQyJ9

package/dist/agent/utils/http-driver-options.d.ts

@@ -0,0 +1,13 @@
+import { AgentOptions } from '../../types';
+import { AgentOptionsWithDefaults } from '../types';
+export default class OptionsUtils {
+    private static loggerPrefix;
+    static withDefaults(options: AgentOptions): AgentOptionsWithDefaults;
+    static validate(options: AgentOptionsWithDefaults): void;
+    private static checkForestServerOptions;
+    private static checkAuthOptions;
+    private static checkOtherOptions;
+    private static isExistingPath;
+    private static isUrl;
+}
+//# sourceMappingURL=http-driver-options.d.ts.map

package/dist/agent/utils/http-driver-options.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const types_1 = require("../../types");
+class OptionsUtils {
+    static withDefaults(options) {
+        return Object.freeze({
+            clientId: null,
+            forestServerUrl: 'https://api.forestadmin.com',
+            logger: (level, data) => console.error(OptionsUtils.loggerPrefix[level], data),
+            prefix: '/forest',
+            schemaPath: '.forestadmin-schema.json',
+            permissionsCacheDurationInSeconds: 15 * 60,
+            ...options,
+        });
+    }
+    static validate(options) {
+        OptionsUtils.checkForestServerOptions(options);
+        OptionsUtils.checkAuthOptions(options);
+        OptionsUtils.checkOtherOptions(options);
+    }
+    static checkForestServerOptions(options) {
+        if (typeof options.envSecret !== 'string' || !/^[0-9a-f]{64}$/.test(options.envSecret)) {
+            throw new Error('options.envSecret is invalid. You can retrieve its value from ' +
+                'https://www.forestadmin.com');
+        }
+        if (!OptionsUtils.isUrl(options.forestServerUrl)) {
+            throw new Error('options.forestServerUrl is invalid. It should contain an URL ' +
+                '(i.e. "https://api.forestadmin.com")');
+        }
+        if (!OptionsUtils.isExistingPath(options.schemaPath)) {
+            throw new Error('options.schemaPath is invalid. It should contain a relative filepath ' +
+                'where the schema should be loaded/updated (i.e. "./.forestadmin-schema.json")');
+        }
+    }
+    static checkAuthOptions(options) {
+        if (!OptionsUtils.isUrl(options.agentUrl)) {
+            throw new Error('options.agentUrl is invalid. It should contain an url where your agent is reachable ' +
+                '(i.e. "https://api-forestadmin.mycompany.com")');
+        }
+        if (typeof options.authSecret !== 'string') {
+            throw new Error('options.authSecret is invalid. Any long random string should work ' +
+                '(i.e. "OfpssLrbgF3P4vHJTTpb"');
+        }
+        if (options.clientId === null) {
+            options.logger?.(types_1.LoggerLevel.Warn, 'options.clientId was not provided. Using NodeJS cluster mode, ' +
+                'or multiple instances of the agent  will break authentication');
+        }
+        else if (typeof options.clientId !== 'string') {
+            throw new Error('options.clientId is invalid.');
+        }
+    }
+    static checkOtherOptions(options) {
+        if (typeof options.prefix !== 'string' || !/[-/a-z+]/.test(options.prefix)) {
+            throw new Error('options.prefix is invalid. It should contain the prefix on which ' +
+                'forest admin routes should be mounted (i.e. "/forest")');
+        }
+    }
+    static isExistingPath(string) {
+        if (typeof string !== 'string') {
+            return false;
+        }
+        const parsed = (0, path_1.parse)(string);
+        return parsed.dir.length ? (0, fs_1.existsSync)(parsed.dir) : true;
+    }
+    static isUrl(string) {
+        if (typeof string !== 'string') {
+            return false;
+        }
+        try {
+            const url = new URL(string);
+            return url.protocol === 'http:' || url.protocol === 'https:';
+        }
+        catch (_) {
+            return false;
+        }
+    }
+}
+exports.default = OptionsUtils;
+OptionsUtils.loggerPrefix = {
+    [types_1.LoggerLevel.Info]: '\x1b[34minfo:\x1b[0m',
+    [types_1.LoggerLevel.Warn]: '\x1b[33mwarning:\x1b[0m',
+    [types_1.LoggerLevel.Error]: '\x1b[31merror:\x1b[0m',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agent/utils/id.d.ts

@@ -0,0 +1,8 @@
+import { CollectionSchema, CompositeId, RecordData } from '@forestadmin/datasource-toolkit';
+export default class IdUtils {
+    static packIds(schema: CollectionSchema, records: RecordData[]): string[];
+    static packId(schema: CollectionSchema, record: RecordData): string;
+    static unpackIds(schema: CollectionSchema, packedIds: string[]): CompositeId[];
+    static unpackId(schema: CollectionSchema, packedId: string): CompositeId;
+}
+//# sourceMappingURL=id.d.ts.map

package/dist/agent/utils/id.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class IdUtils {
+    static packIds(schema, records) {
+        return records.map(packedId => IdUtils.packId(schema, packedId));
+    }
+    static packId(schema, record) {
+        const pkNames = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(schema);
+        if (!pkNames.length) {
+            throw new Error('This collection has no primary key');
+        }
+        if (pkNames.some(pkName => record[pkName] === undefined)) {
+            throw new Error(`Missing one of expected fields: '${pkNames.join("', '")}'`);
+        }
+        return pkNames.map(pk => String(record[pk])).join('|');
+    }
+    static unpackIds(schema, packedIds) {
+        if (!Array.isArray(packedIds)) {
+            throw new datasource_toolkit_1.ValidationError(`Expected array, received: ${typeof packedIds}`);
+        }
+        return packedIds.map(packedId => IdUtils.unpackId(schema, packedId));
+    }
+    static unpackId(schema, packedId) {
+        if (typeof packedId !== 'string') {
+            throw new datasource_toolkit_1.ValidationError(`Expected string, received: ${typeof packedId}`);
+        }
+        const pkNames = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(schema);
+        const pkValues = packedId.split('|');
+        if (pkValues.length !== pkNames.length) {
+            throw new datasource_toolkit_1.ValidationError(`Expected ${pkNames.length} values, found ${pkValues.length}`);
+        }
+        return pkNames.map((pkName, index) => {
+            const schemaField = schema.fields[pkName];
+            const value = pkValues[index];
+            const castedValue = schemaField.columnType === 'Number' ? Number(value) : value;
+            datasource_toolkit_1.FieldValidator.validateValue(pkName, schemaField, castedValue);
+            return castedValue;
+        });
+    }
+}
+exports.default = IdUtils;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agent/utils/query-string.d.ts

@@ -0,0 +1,14 @@
+import { Collection, ConditionTree, Page, Projection, Sort } from '@forestadmin/datasource-toolkit';
+import { Context } from 'koa';
+export default class QueryStringParser {
+    static parseConditionTree(collection: Collection, context: Context): ConditionTree;
+    static parseProjection(collection: Collection, context: Context): Projection;
+    static parseProjectionWithPks(collection: Collection, context: Context): Projection;
+    static parseSearch(collection: Collection, context: Context): string;
+    static parseSearchExtended(context: Context): boolean;
+    static parseSegment(collection: Collection, context: Context): string;
+    static parseTimezone(context: Context): string;
+    static parsePagination(context: Context): Page;
+    static parseSort(collection: Collection, context: Context): Sort;
+}
+//# sourceMappingURL=query-string.d.ts.map