@forestadmin/datasource-customizer 1.0.0-alpha.1

package/dist/decorators/validation/collection.js

@@ -0,0 +1,109 @@
+"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 collection_decorator_1 = __importDefault(require("../collection-decorator"));
+class ValidationDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.validation = {};
+    }
+    addValidation(name, validation) {
+        var _a;
+        datasource_toolkit_1.FieldValidator.validate(this, name);
+        const field = this.childCollection.schema.fields[name];
+        if (!field)
+            throw new Error('Cannot add validators on a relation, use the foreign key instead');
+        if (field.isReadOnly)
+            throw new Error('Cannot add validators on a readonly field');
+        (_a = this.validation)[name] ?? (_a[name] = []);
+        this.validation[name].push(validation);
+        this.markSchemaAsDirty();
+    }
+    async create(caller, data) {
+        for (const record of data)
+            this.validate(record, caller.timezone, true);
+        return super.create(caller, data);
+    }
+    async update(caller, filter, patch) {
+        this.validate(patch, caller.timezone, false);
+        return super.update(caller, filter, patch);
+    }
+    refineSchema(subSchema) {
+        const schema = { ...subSchema, fields: { ...subSchema.fields } };
+        for (const [name, rules] of Object.entries(this.validation)) {
+            const field = { ...schema.fields[name] };
+            field.validation = ValidationDecorator.deduplicate([...(field.validation ?? []), ...rules]);
+            schema.fields[name] = field;
+        }
+        return schema;
+    }
+    validate(record, timezone, allFields) {
+        for (const [name, field] of Object.entries(this.schema.fields)) {
+            if (field.type === 'Column' && (allFields || record[name] !== undefined)) {
+                // When setting a field to null, we skip all validators but "Present"
+                let rules = field.validation ?? [];
+                if (record[name] === null)
+                    rules = rules.filter(r => r.operator === 'Present');
+                for (const validator of rules) {
+                    const rawLeaf = { field: name, ...validator };
+                    const tree = datasource_toolkit_1.ConditionTreeFactory.fromPlainObject(rawLeaf);
+                    datasource_toolkit_1.ConditionTreeValidator.validate(tree, this);
+                    if (!tree.match(record, this, timezone)) {
+                        const message = `'${name}' failed validation rule:`;
+                        const rule = validator.value !== undefined
+                            ? `${validator.operator}(${validator.value})`
+                            : `${validator.operator}`;
+                        throw new datasource_toolkit_1.ValidationError(`${message} '${rule}'`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Deduplicate rules which the frontend understand
+     * We ignore other rules as duplications are not an issue within the agent
+     */
+    static deduplicate(rules) {
+        var _a;
+        const values = {};
+        for (const rule of rules) {
+            values[_a = rule.operator] ?? (values[_a] = []);
+            values[rule.operator].push(rule);
+        }
+        // Remove duplicate "Present"
+        while (values.Present?.length > 1)
+            values.Present.pop();
+        // Merge duplicate 'GreaterThan', 'After' and 'LongerThan' (keep the max value)
+        for (const operator of ['GreaterThan', 'After', 'LongerThan']) {
+            while (values[operator]?.length > 1) {
+                const last = values[operator].pop();
+                values[operator][0] = {
+                    operator,
+                    value: ValidationDecorator.max(last.value, values[operator][0].value),
+                };
+            }
+        }
+        // Merge duplicate 'LessThan', 'Before' and 'ShorterThan' (keep the min value)
+        for (const operator of ['LessThan', 'Before', 'ShorterThan']) {
+            while (values[operator]?.length > 1) {
+                const last = values[operator].pop();
+                values[operator][0] = {
+                    operator,
+                    value: ValidationDecorator.min(last.value, values[operator][0].value),
+                };
+            }
+        }
+        return Object.values(values).reduce((memo, r) => [...memo, ...r], []);
+    }
+    static min(valueA, valueB) {
+        return valueA < valueB ? valueA : valueB;
+    }
+    static max(valueA, valueB) {
+        return valueA < valueB ? valueB : valueA;
+    }
+}
+exports.default = ValidationDecorator;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/decorators/write/collection.d.ts

@@ -0,0 +1,26 @@
+import { Caller, CollectionSchema, Filter, RecordData } from '@forestadmin/datasource-toolkit';
+import { WriteDefinition } from './types';
+import CollectionDecorator from '../collection-decorator';
+import DataSourceDecorator from '../datasource-decorator';
+export default class WriteDecorator extends CollectionDecorator {
+    private replacedDefinitions;
+    readonly dataSource: DataSourceDecorator<WriteDecorator>;
+    replaceFieldWriting(fieldName: string, definition: WriteDefinition): void;
+    protected refineSchema(childSchema: CollectionSchema): CollectionSchema;
+    create(caller: Caller, data: RecordData[]): Promise<RecordData[]>;
+    update(caller: Caller, filter: Filter, patch: RecordData): Promise<void>;
+    private applyDefinitionsAndCreate;
+    private applyDefinitionsAndUpdate;
+    private createRecord;
+    private createOneToOneRelations;
+    private createManyToOneRelations;
+    private updateAllRelations;
+    private getImpactedRecordByUpdate;
+    private applyDefinitions;
+    private getReplacedDefinitionsColumns;
+    private getDefinitionResults;
+    private static checkCyclicDependency;
+    private getRelationFields;
+    private getPatchWithoutRelations;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/decorators/write/collection.js

@@ -0,0 +1,214 @@
+"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 collection_decorator_1 = __importDefault(require("../collection-decorator"));
+const context_1 = __importDefault(require("./context"));
+class WriteDecorator extends collection_decorator_1.default {
+    constructor() {
+        super(...arguments);
+        this.replacedDefinitions = {};
+    }
+    replaceFieldWriting(fieldName, definition) {
+        if (!Object.keys(this.schema.fields).includes(fieldName)) {
+            throw new Error(`The given field "${fieldName}" does not exist on the ${this.name} collection.`);
+        }
+        this.replacedDefinitions[fieldName] = definition;
+        this.markSchemaAsDirty();
+    }
+    refineSchema(childSchema) {
+        const schema = { ...childSchema, fields: { ...childSchema.fields } };
+        for (const name of Object.keys(this.replacedDefinitions)) {
+            schema.fields[name].isReadOnly = false;
+        }
+        return schema;
+    }
+    async create(caller, data) {
+        return Promise.all(data.map(record => this.applyDefinitionsAndCreate(caller, record)));
+    }
+    async update(caller, filter, patch) {
+        await this.applyDefinitionsAndUpdate(caller, filter, patch);
+    }
+    async applyDefinitionsAndCreate(caller, record) {
+        const patch = await this.applyDefinitions(caller, record, 'create');
+        if (this.getRelationFields(patch, ['ManyToOne', 'OneToOne']).length === 0) {
+            const result = await this.childCollection.create(caller, [patch]);
+            return result[0];
+        }
+        const manyToOneRecords = await this.createManyToOneRelations(caller, patch);
+        const createdRecord = await this.createRecord(caller, patch, manyToOneRecords);
+        await this.createOneToOneRelations(caller, patch, createdRecord);
+        return createdRecord;
+    }
+    async applyDefinitionsAndUpdate(caller, filter, patch) {
+        const updatedPatch = await this.applyDefinitions(caller, patch, 'update');
+        const relations = this.getRelationFields(updatedPatch, ['OneToOne', 'ManyToOne']);
+        const idsList = await this.getImpactedRecordByUpdate(caller, relations, filter);
+        await Promise.all([
+            ...this.updateAllRelations(caller, idsList, updatedPatch),
+            this.childCollection.update(caller, filter, this.getPatchWithoutRelations(updatedPatch, relations)),
+        ]);
+    }
+    async createRecord(caller, patch, manyToOneRecords) {
+        const refinedPatch = { ...patch };
+        const manyToOneRelations = this.getRelationFields(patch, ['ManyToOne']);
+        for (const [record] of manyToOneRecords) {
+            const relationName = manyToOneRelations.shift();
+            const relationSchema = this.schema.fields[relationName];
+            delete refinedPatch[relationName];
+            const relation = this.dataSource.getCollection(relationSchema.foreignCollection);
+            const [pk] = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(relation.schema);
+            refinedPatch[relationSchema.foreignKey] = record[pk];
+        }
+        for (const relationName of this.getRelationFields(patch, ['OneToOne'])) {
+            const relationSchema = this.schema.fields[relationName];
+            delete refinedPatch[relationName];
+            if (patch[relationSchema.originKey])
+                delete refinedPatch[relationSchema.originKey];
+        }
+        const result = await this.childCollection.create(caller, [refinedPatch]);
+        return result[0];
+    }
+    async createOneToOneRelations(caller, patch, createdRecord) {
+        const requests = [];
+        for (const oneToOneRelation of this.getRelationFields(patch, ['OneToOne'])) {
+            const relationSchema = this.schema.fields[oneToOneRelation];
+            const relationRecord = patch[oneToOneRelation];
+            const relation = this.dataSource.getCollection(relationSchema.foreignCollection);
+            const fk = relationSchema.originKey;
+            if (patch[fk]) {
+                const conditionTree = new datasource_toolkit_1.ConditionTreeLeaf(fk, 'Equal', patch[fk]);
+                const filter = new datasource_toolkit_1.Filter({ conditionTree });
+                const update = relation.update(caller, filter, relationRecord);
+                requests.push(update);
+            }
+            else {
+                const [pk] = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(this.schema);
+                requests.push(relation.create(caller, [{ ...relationRecord, [fk]: createdRecord[pk] }]));
+            }
+        }
+        await Promise.all(requests);
+    }
+    createManyToOneRelations(caller, patch) {
+        const resultsManyToOne = [];
+        for (const relationName of this.getRelationFields(patch, ['ManyToOne'])) {
+            const relationSchema = this.schema.fields[relationName];
+            const relationRecord = patch[relationName];
+            const fk = relationSchema.foreignKey;
+            const relation = this.dataSource.getCollection(relationSchema.foreignCollection);
+            if (patch[fk]) {
+                const [pk] = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(relation.schema);
+                const updateWrapper = async () => {
+                    const conditionTree = new datasource_toolkit_1.ConditionTreeLeaf(pk, 'Equal', patch[fk]);
+                    await relation.update(caller, new datasource_toolkit_1.Filter({ conditionTree }), relationRecord);
+                    return [{ [pk]: patch[fk] }];
+                };
+                resultsManyToOne.push(updateWrapper());
+            }
+            else {
+                resultsManyToOne.push(relation.create(caller, [relationRecord]));
+            }
+        }
+        return Promise.all(resultsManyToOne);
+    }
+    updateAllRelations(caller, listIds, patch) {
+        const updates = [];
+        const relations = this.getRelationFields(patch, ['OneToOne', 'ManyToOne']);
+        for (const recordIds of listIds) {
+            const relationName = relations.shift();
+            const relationSchema = this.schema.fields[relationName];
+            const relation = this.dataSource.getCollection(relationSchema.foreignCollection);
+            const ids = recordIds.map(field => Object.values(field)[0]);
+            let key;
+            if (relationSchema.type === 'OneToOne') {
+                key = relationSchema.originKey;
+            }
+            else {
+                [key] = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(relation.schema);
+            }
+            const idsFilter = new datasource_toolkit_1.Filter({ conditionTree: new datasource_toolkit_1.ConditionTreeLeaf(key, 'In', ids) });
+            updates.push(relation.update(caller, idsFilter, patch[relationName]));
+        }
+        return updates;
+    }
+    async getImpactedRecordByUpdate(caller, relations, filter) {
+        const records = [];
+        for (const relationName of relations) {
+            const relationSchema = this.schema.fields[relationName];
+            let projection;
+            if (relationSchema.type === 'OneToOne') {
+                projection = new datasource_toolkit_1.Projection(...datasource_toolkit_1.SchemaUtils.getPrimaryKeys(this.schema));
+            }
+            else if (relationSchema.type === 'ManyToOne') {
+                projection = new datasource_toolkit_1.Projection(relationSchema.foreignKey);
+            }
+            records.push(this.list(caller, filter, projection));
+        }
+        return Promise.all(records);
+    }
+    async applyDefinitions(caller, patch, action, stackCalls = []) {
+        if (Object.keys(patch).length === 0)
+            return {};
+        const replacedDefinitionsColumns = this.getReplacedDefinitionsColumns(patch);
+        WriteDecorator.checkCyclicDependency(replacedDefinitionsColumns, stackCalls);
+        const patches = await this.getDefinitionResults(caller, patch, replacedDefinitionsColumns, action);
+        const patchToExplore = {};
+        const copyPatch = { ...patch };
+        patches.forEach(recordData => {
+            const setValueColumn = replacedDefinitionsColumns.shift();
+            delete copyPatch[setValueColumn];
+            if (!recordData)
+                return;
+            if (recordData.constructor === Object) {
+                datasource_toolkit_1.RecordValidator.validate(this, recordData);
+            }
+            else {
+                throw new Error(`The write handler of ${setValueColumn} should return an object or nothing.`);
+            }
+            for (const [columnName, value] of Object.entries(recordData)) {
+                if (copyPatch[columnName]) {
+                    throw new datasource_toolkit_1.ValidationError(`Conflict value on the field "${columnName}". It receives several values.`);
+                }
+                if (columnName === setValueColumn) {
+                    copyPatch[columnName] = value;
+                }
+                else {
+                    patchToExplore[columnName] = value;
+                }
+            }
+        });
+        return {
+            ...copyPatch,
+            ...(await this.applyDefinitions(caller, patchToExplore, action, stackCalls)),
+        };
+    }
+    getReplacedDefinitionsColumns(patch) {
+        const patchKeys = Object.keys(patch);
+        return Object.keys(this.replacedDefinitions).filter(name => patchKeys.includes(name));
+    }
+    async getDefinitionResults(caller, patch, columns, action) {
+        return Promise.all(columns.map(column => {
+            const definition = this.replacedDefinitions[column];
+            const context = new context_1.default(this, caller, action, { ...patch });
+            return definition(patch[column], context);
+        }));
+    }
+    static checkCyclicDependency(columns, stackCalls) {
+        stackCalls.push(...columns);
+        if (stackCalls.length !== [...new Set(stackCalls)].length) {
+            throw new datasource_toolkit_1.ValidationError(`There is a cyclic dependency on the "${stackCalls.pop()}" column.`);
+        }
+    }
+    getRelationFields(patch, types) {
+        return Object.keys(patch).filter(field => types.includes(this.schema.fields[field]?.type));
+    }
+    getPatchWithoutRelations(patch, relations) {
+        const copy = { ...patch };
+        relations.forEach(relation => delete copy[relation]);
+        return copy;
+    }
+}
+exports.default = WriteDecorator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../../src/decorators/write/collection.ts"],"names":[],"mappings":";;;;;AAAA,wEAeyC;AAEzC,mFAA0D;AAE1D,wDAAkD;AAElD,MAAqB,cAAe,SAAQ,8BAAmB;IAA/D;;QACU,wBAAmB,GAAoC,EAAE,CAAC;IAmTpE,CAAC;IAhTC,mBAAmB,CAAC,SAAiB,EAAE,UAA2B;QAChE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;YACxD,MAAM,IAAI,KAAK,CACb,oBAAoB,SAAS,2BAA2B,IAAI,CAAC,IAAI,cAAc,CAChF,CAAC;SACH;QAED,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,GAAG,UAAU,CAAC;QACjD,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAEkB,YAAY,CAAC,WAA6B;QAC3D,MAAM,MAAM,GAAG,EAAE,GAAG,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC;QAErE,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE;YACvD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAkB,CAAC,UAAU,GAAG,KAAK,CAAC;SAC1D;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEQ,KAAK,CAAC,MAAM,CAAC,MAAc,EAAE,IAAkB;QACtD,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACzF,CAAC;IAEQ,KAAK,CAAC,MAAM,CAAC,MAAc,EAAE,MAAc,EAAE,KAAiB;QACrE,MAAM,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9D,CAAC;IAEO,KAAK,CAAC,yBAAyB,CAAC,MAAc,EAAE,MAAkB;QACxE,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QAEpE,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;YACzE,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;YAElE,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;SAClB;QAED,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAE5E,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,gBAAgB,CAAC,CAAC;QAE/E,MAAM,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC;QAEjE,OAAO,aAAa,CAAC;IACvB,CAAC;IAEO,KAAK,CAAC,yBAAyB,CACrC,MAAc,EACd,MAAc,EACd,KAAiB;QAEjB,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC1E,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC;QAElF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QAEhF,MAAM,OAAO,CAAC,GAAG,CAAC;YAChB,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC;YACzD,IAAI,CAAC,eAAe,CAAC,MAAM,CACzB,MAAM,EACN,MAAM,EACN,IAAI,CAAC,wBAAwB,CAAC,YAAY,EAAE,SAAS,CAAC,CACvD;SACF,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,YAAY,CACxB,MAAc,EACd,KAAiB,EACjB,gBAAgC;QAEhC,MAAM,YAAY,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;QAClC,MAAM,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;QAExE,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,gBAAgB,EAAE;YACvC,MAAM,YAAY,GAAG,kBAAkB,CAAC,KAAK,EAAE,CAAC;YAChD,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAoB,CAAC;YAE3E,OAAO,YAAY,CAAC,YAAY,CAAC,CAAC;YAElC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;YACjF,MAAM,CAAC,EAAE,CAAC,GAAG,gCAAW,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YACzD,YAAY,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;SACtD;QAED,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE;YACtE,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAmB,CAAC;YAE1E,OAAO,YAAY,CAAC,YAAY,CAAC,CAAC;YAElC,IAAI,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC;gBAAE,OAAO,YAAY,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;SACpF;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;QAEzE,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,uBAAuB,CACnC,MAAc,EACd,KAAiB,EACjB,aAAyB;QAEzB,MAAM,QAAQ,GAAmC,EAAE,CAAC;QAEpD,KAAK,MAAM,gBAAgB,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE;YAC1E,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAmB,CAAC;YAC9E,MAAM,cAAc,GAAG,KAAK,CAAC,gBAAgB,CAAe,CAAC;YAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;YACjF,MAAM,EAAE,GAAG,cAAc,CAAC,SAAS,CAAC;YAEpC,IAAI,KAAK,CAAC,EAAE,CAAC,EAAE;gBACb,MAAM,aAAa,GAAG,IAAI,sCAAiB,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;gBACpE,MAAM,MAAM,GAAG,IAAI,2BAAM,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC;gBAC7C,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;gBAC/D,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aACvB;iBAAM;gBACL,MAAM,CAAC,EAAE,CAAC,GAAG,gCAAW,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACrD,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,GAAG,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;aAC1F;SACF;QAED,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IAEO,wBAAwB,CAAC,MAAc,EAAE,KAAiB;QAChE,MAAM,gBAAgB,GAA4B,EAAE,CAAC;QAErD,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,WAAW,CAAC,CAAC,EAAE;YACvE,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAoB,CAAC;YAC3E,MAAM,cAAc,GAAG,KAAK,CAAC,YAAY,CAAe,CAAC;YACzD,MAAM,EAAE,GAAG,cAAc,CAAC,UAAU,CAAC;YAErC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;YAEjF,IAAI,KAAK,CAAC,EAAE,CAAC,EAAE;gBACb,MAAM,CAAC,EAAE,CAAC,GAAG,gCAAW,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAEzD,MAAM,aAAa,GAAG,KAAK,IAA2B,EAAE;oBACtD,MAAM,aAAa,GAAG,IAAI,sCAAiB,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;oBACpE,MAAM,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,2BAAM,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC;oBAE7E,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gBAC/B,CAAC,CAAC;gBAEF,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;aACxC;iBAAM;gBACL,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;aAClE;SACF;QAED,OAAO,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IACvC,CAAC;IAEO,kBAAkB,CACxB,MAAc,EACd,OAAuB,EACvB,KAAiB;QAEjB,MAAM,OAAO,GAAmC,EAAE,CAAC;QACnD,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC;QAE3E,KAAK,MAAM,SAAS,IAAI,OAAO,EAAE;YAC/B,MAAM,YAAY,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC;YACvC,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAmB,CAAC;YAC1E,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;YAEjF,MAAM,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5D,IAAI,GAAoB,CAAC;YAEzB,IAAI,cAAc,CAAC,IAAI,KAAK,UAAU,EAAE;gBACtC,GAAG,GAAG,cAAc,CAAC,SAAS,CAAC;aAChC;iBAAM;gBACL,CAAC,GAAG,CAAC,GAAG,gCAAW,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;aACrD;YAED,MAAM,SAAS,GAAG,IAAI,2BAAM,CAAC,EAAE,aAAa,EAAE,IAAI,sCAAiB,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;YACvF,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,YAAY,CAAe,CAAC,CAAC,CAAC;SACrF;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,KAAK,CAAC,yBAAyB,CACrC,MAAc,EACd,SAAmB,EACnB,MAAc;QAEd,MAAM,OAAO,GAA4B,EAAE,CAAC;QAE5C,KAAK,MAAM,YAAY,IAAI,SAAS,EAAE;YACpC,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAmB,CAAC;YAC1E,IAAI,UAAsB,CAAC;YAE3B,IAAI,cAAc,CAAC,IAAI,KAAK,UAAU,EAAE;gBACtC,UAAU,GAAG,IAAI,+BAAU,CAAC,GAAG,gCAAW,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;aACzE;iBAAM,IAAI,cAAc,CAAC,IAAI,KAAK,WAAW,EAAE;gBAC9C,UAAU,GAAG,IAAI,+BAAU,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;aACxD;YAED,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;SACrD;QAED,OAAO,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAC5B,MAAc,EACd,KAAiB,EACjB,MAA2B,EAC3B,aAAuB,EAAE;QAEzB,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAE/C,MAAM,0BAA0B,GAAG,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC;QAC7E,cAAc,CAAC,qBAAqB,CAAC,0BAA0B,EAAE,UAAU,CAAC,CAAC;QAC7E,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAC7C,MAAM,EACN,KAAK,EACL,0BAA0B,EAC1B,MAAM,CACP,CAAC;QAEF,MAAM,cAAc,GAAG,EAAE,CAAC;QAC1B,MAAM,SAAS,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;QAE/B,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;YAC3B,MAAM,cAAc,GAAG,0BAA0B,CAAC,KAAK,EAAE,CAAC;YAC1D,OAAO,SAAS,CAAC,cAAc,CAAC,CAAC;YAEjC,IAAI,CAAC,UAAU;gBAAE,OAAO;YAExB,IAAI,UAAU,CAAC,WAAW,KAAK,MAAM,EAAE;gBACrC,oCAAe,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;aAC5C;iBAAM;gBACL,MAAM,IAAI,KAAK,CACb,wBAAwB,cAAc,sCAAsC,CAC7E,CAAC;aACH;YAED,KAAK,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;gBAC5D,IAAI,SAAS,CAAC,UAAU,CAAC,EAAE;oBACzB,MAAM,IAAI,oCAAe,CACvB,gCAAgC,UAAU,gCAAgC,CAC3E,CAAC;iBACH;gBAED,IAAI,UAAU,KAAK,cAAc,EAAE;oBACjC,SAAS,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC;iBAC/B;qBAAM;oBACL,cAAc,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC;iBACpC;aACF;QACH,CAAC,CAAC,CAAC;QAEH,OAAO;YACL,GAAG,SAAS;YACZ,GAAG,CAAC,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;SAC7E,CAAC;IACJ,CAAC;IAEO,6BAA6B,CAAC,KAAiB;QACrD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAErC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACxF,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAChC,MAAc,EACd,KAAiB,EACjB,OAAiB,EACjB,MAA2B;QAE3B,OAAO,OAAO,CAAC,GAAG,CAChB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YACnB,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;YACpD,MAAM,OAAO,GAAG,IAAI,iBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;YAElF,OAAO,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC;QAC5C,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,qBAAqB,CAAC,OAAiB,EAAE,UAAoB;QAC1E,UAAU,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;QAE5B,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,EAAE;YACzD,MAAM,IAAI,oCAAe,CACvB,wCAAwC,UAAU,CAAC,GAAG,EAAE,WAAW,CACpE,CAAC;SACH;IACH,CAAC;IAEO,iBAAiB,CAAC,KAAiB,EAAE,KAAmB;QAC9D,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;IAC7F,CAAC;IAEO,wBAAwB,CAAC,KAAiB,EAAE,SAAmB;QACrE,MAAM,IAAI,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;QAC1B,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAErD,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AApTD,iCAoTC"}

package/dist/decorators/write/context.d.ts

@@ -0,0 +1,9 @@
+import { Caller, Collection } from '@forestadmin/datasource-toolkit';
+import { TCollectionName, TPartialSimpleRow, TSchema } from '../../templates';
+import CollectionCustomizationContext from '../../context/collection-context';
+export default class WriteCustomizationContext<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> extends CollectionCustomizationContext<S, N> {
+    readonly action: 'update' | 'create';
+    readonly record: TPartialSimpleRow<S, N>;
+    constructor(collection: Collection, caller: Caller, action: 'update' | 'create', record: TPartialSimpleRow<S, N>);
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/decorators/write/context.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const collection_context_1 = __importDefault(require("../../context/collection-context"));
+class WriteCustomizationContext extends collection_context_1.default {
+    constructor(collection, caller, action, record) {
+        super(collection, caller);
+        this.action = action;
+        this.record = record;
+    }
+}
+exports.default = WriteCustomizationContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kZWNvcmF0b3JzL3dyaXRlL2NvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFFQSwwRkFBOEU7QUFFOUUsTUFBcUIseUJBR25CLFNBQVEsNEJBQW9DO0lBSTVDLFlBQ0UsVUFBc0IsRUFDdEIsTUFBYyxFQUNkLE1BQTJCLEVBQzNCLE1BQStCO1FBRS9CLEtBQUssQ0FBQyxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFFMUIsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7UUFDckIsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7SUFDdkIsQ0FBQztDQUNGO0FBbEJELDRDQWtCQyJ9

package/dist/decorators/write/types.d.ts

@@ -0,0 +1,4 @@
+import { TCollectionName, TFieldName, TFieldType, TPartialRow, TSchema } from '../../templates';
+import WriteCustomizationContext from './context';
+export declare type WriteDefinition<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>, C extends TFieldName<S, N> = TFieldName<S, N>> = (value: TFieldType<S, N, C>, context: WriteCustomizationContext<S, N>) => Promise<TPartialRow<S, N> | void> | TPartialRow<S, N> | void;
+//# sourceMappingURL=types.d.ts.map

package/dist/decorators/write/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy93cml0ZS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { default as CollectionCustomizer } from './collection-customizer';
+export { default as DataSourceCustomizer } from './datasource-customizer';
+export * from './templates';
+export * from './types';
+export { ActionDefinition } from './decorators/actions/types/actions';
+export { ChartDefinition } from './decorators/chart/types';
+export { ComputedDefinition } from './decorators/computed/types';
+export { OperatorDefinition } from './decorators/operators-emulate/types';
+export { RelationDefinition } from './decorators/relation/types';
+export { SearchDefinition } from './decorators/search/types';
+export { SegmentDefinition } from './decorators/segment/types';
+export { WriteDefinition } from './decorators/write/types';
+export { HookHandler, HookType, HookPosition, HooksContext } from './decorators/hook/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceCustomizer = exports.CollectionCustomizer = void 0;
+var collection_customizer_1 = require("./collection-customizer");
+Object.defineProperty(exports, "CollectionCustomizer", { enumerable: true, get: function () { return __importDefault(collection_customizer_1).default; } });
+var datasource_customizer_1 = require("./datasource-customizer");
+Object.defineProperty(exports, "DataSourceCustomizer", { enumerable: true, get: function () { return __importDefault(datasource_customizer_1).default; } });
+__exportStar(require("./templates"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxpRUFBMEU7QUFBakUsOElBQUEsT0FBTyxPQUF3QjtBQUN4QyxpRUFBMEU7QUFBakUsOElBQUEsT0FBTyxPQUF3QjtBQUV4Qyw4Q0FBNEI7QUFDNUIsMENBQXdCIn0=

package/dist/templates.d.ts

@@ -0,0 +1,65 @@
+import { AggregationOperation, Aggregator, DateOperation, Operator, PlainPage, RecordData } from '@forestadmin/datasource-toolkit';
+declare type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+/** Global schema which is generated by agent */
+export declare type TSchema = Record<string, {
+    plain: RecordData;
+    nested: RecordData;
+    flat: RecordData;
+}>;
+/** Collection name */
+export declare type TCollectionName<S extends TSchema> = Extract<keyof S, string>;
+/** Column name (no relations) */
+export declare type TColumnName<S extends TSchema, N extends TCollectionName<S>> = Extract<keyof S[N]['plain'], string>;
+/** Field name (with relations) */
+export declare type TFieldName<S extends TSchema, N extends TCollectionName<S>> = Extract<keyof S[N]['plain'] | keyof S[N]['flat'], string>;
+/** Type of a given field */
+export declare type TFieldType<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>, C extends TFieldName<S, N> = TFieldName<S, N>> = (S[N]['plain'] & S[N]['flat'])[C];
+/** Row type only with columns (all required) */
+export declare type TSimpleRow<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = S[N]['plain'];
+/** Row type only with columns (all optional) */
+export declare type TPartialSimpleRow<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = RecursivePartial<TSimpleRow<S, N>>;
+/** Row type with columns and relationships (all required) */
+export declare type TRow<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = S[N]['plain'] & S[N]['nested'];
+/** Row type with columns and relationships (all optional) */
+export declare type TPartialRow<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = RecursivePartial<TRow<S, N>>;
+export declare type TPartialFlatRow<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = RecursivePartial<S[N]['plain'] & S[N]['flat']>;
+export declare type TConditionTreeLeaf<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = {
+    field: TFieldName<S, N>;
+    operator: Operator;
+    value?: unknown;
+};
+export declare type TConditionTreeBranch<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = {
+    aggregator: Aggregator;
+    conditions: Array<TConditionTreeBranch<S, N> | TConditionTreeLeaf<S, N>>;
+};
+export declare type TConditionTree<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = TConditionTreeBranch<S, N> | TConditionTreeLeaf<S, N>;
+export declare type TPaginatedFilter<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = TFilter<S, N> & {
+    sort?: Array<TSortClause<S, N>>;
+    page?: PlainPage;
+};
+export declare type TSortClause<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = {
+    field: TFieldName<S, N>;
+    ascending: boolean;
+};
+export declare type TAggregateResult<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = {
+    value: unknown;
+    group: TPartialFlatRow<S, N>;
+};
+export interface TAggregation<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> {
+    field?: TFieldName<S, N>;
+    operation: AggregationOperation;
+    groups?: Array<{
+        field: TFieldName<S, N>;
+        operation?: DateOperation;
+    }>;
+}
+export declare type TFilter<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = {
+    conditionTree?: TConditionTree<S, N>;
+    search?: string;
+    searchExtended?: boolean;
+    segment?: string;
+};
+export {};
+//# sourceMappingURL=templates.d.ts.map

package/dist/templates.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcGxhdGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3RlbXBsYXRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+import { PrimitiveTypes } from '@forestadmin/datasource-toolkit';
+import { ComputedDefinition } from './decorators/computed/types';
+import { TCollectionName, TFieldName, TRow, TSchema } from './templates';
+import CollectionCustomizationContext from './context/collection-context';
+export declare type FieldDefinition<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = ComputedDefinition<S, N> & {
+    beforeRelations?: boolean;
+};
+export declare type OneToManyEmbeddedDefinition<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> = {
+    schema: Record<string, PrimitiveTypes>;
+    dependencies?: TFieldName<S, N>[];
+    listRecords(records: TRow<S, N>, context: CollectionCustomizationContext<S, N>): Promise<unknown[]> | unknown[];
+};
+export declare type DataSourceOptions = {
+    rename?: {
+        [oldName: string]: string;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/typing-generator.d.ts

@@ -0,0 +1,19 @@
+import { DataSource } from '@forestadmin/datasource-toolkit';
+export default class TypingGenerator {
+    /**
+     * Write types to disk at a given path.
+     * This method read the file which is already there before overwriting so that customers
+     * using equivalents to nodemon to not enter restart loops.
+     */
+    static updateTypesOnFileSystem(dataSource: DataSource, typingsPath: string, typingsMaxDepth: number): Promise<void>;
+    /**
+     * Generates types on a string.
+     */
+    static generateTypes(dataSource: DataSource, maxDepth: number): string;
+    private static getRow;
+    private static getRelations;
+    private static getFlatRelations;
+    private static getFieldsRec;
+    private static getType;
+}
+//# sourceMappingURL=typing-generator.d.ts.map