@forestadmin/datasource-replica 1.0.0 → 1.0.2-alpha-widgets.1

package/dist/synchronization/cache-target.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 sequelize_1 = require("sequelize");
+const flattener_1 = __importDefault(require("../flattener"));
+const utils_1 = require("../utils");
+class CacheTarget {
+    constructor(connection, options, logger) {
+        this.connection = connection;
+        this.options = options;
+        this.logger = logger;
+    }
+    async applyDump(changes, firstPage) {
+        if (firstPage) {
+            // Truncate tables
+            for (const collection of this.options.flattenSchema) {
+                await this.connection.model(collection.name).truncate();
+            }
+        }
+        const recordsByCollection = {};
+        const entries = changes.entries.flatMap(entry => this.flattenRecord(entry));
+        for (const entry of entries) {
+            if (entry !== undefined) {
+                if (!recordsByCollection[entry.collection])
+                    recordsByCollection[entry.collection] = [];
+                recordsByCollection[entry.collection].push(entry.record);
+            }
+        }
+        await this.connection.transaction(async (transaction) => {
+            for (const [collection, records] of Object.entries(recordsByCollection)) {
+                await this.connection.model(collection).bulkCreate(records, { transaction });
+            }
+        });
+    }
+    async applyDelta(changes) {
+        await this.connection.transaction(async (transaction) => {
+            for (const entry of changes.deletedEntries) {
+                if (this.checkCollection(entry.collection)) {
+                    await this.destroySubModels(entry, transaction);
+                    await this.connection
+                        .model(entry.collection)
+                        .destroy({ where: entry.record, transaction });
+                }
+            }
+            // Upsert records in both root and virtual collections
+            for (const entry of changes.newOrUpdatedEntries) {
+                if (this.checkCollection(entry.collection)) {
+                    await this.destroySubModels(entry, transaction);
+                    for (const subEntry of this.flattenRecord(entry))
+                        await this.connection
+                            .model(subEntry.collection)
+                            .upsert(subEntry.record, { transaction });
+                }
+            }
+        });
+    }
+    flattenRecord(recordWithCollection) {
+        if (this.checkCollection(recordWithCollection.collection))
+            return (0, flattener_1.default)(recordWithCollection, this.options.schema.find(s => s.name === recordWithCollection.collection).fields, this.options?.flattenOptions?.[recordWithCollection.collection]?.asFields ?? [], this.options?.flattenOptions?.[recordWithCollection.collection]?.asModels ?? []);
+    }
+    async destroySubModels(entry, transaction) {
+        const { asModels } = this.options.flattenOptions[entry.collection];
+        const { fields } = this.options.schema.find(c => c.name === entry.collection);
+        const promises = asModels.map(asModel => {
+            const recordId = (0, utils_1.getRecordId)(fields, entry.record);
+            return this.connection.model((0, utils_1.escape) `${entry.collection}.${asModel}`).destroy({
+                where: { _fid: { [sequelize_1.Op.startsWith]: `${recordId}.${asModel}` } },
+                transaction,
+            });
+        });
+        await Promise.all(promises);
+    }
+    checkCollection(collection) {
+        const collectionName = this.options.schema.find(s => s.name === collection);
+        if (!collectionName) {
+            this.logger('Error', `Collection '${collection}' not found in schema. Skipping.`);
+            return false;
+        }
+        return true;
+    }
+}
+exports.default = CacheTarget;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtdGFyZ2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N5bmNocm9uaXphdGlvbi9jYWNoZS10YXJnZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFXQSx5Q0FBNEM7QUFFNUMsNkRBQXlDO0FBQ3pDLG9DQUErQztBQUUvQyxNQUFxQixXQUFXO0lBSzlCLFlBQVksVUFBcUIsRUFBRSxPQUF3QixFQUFFLE1BQWM7UUFDekUsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7UUFDN0IsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7SUFDdkIsQ0FBQztJQUVELEtBQUssQ0FBQyxTQUFTLENBQUMsT0FBeUIsRUFBRSxTQUFrQjtRQUMzRCxJQUFJLFNBQVMsRUFBRTtZQUNiLGtCQUFrQjtZQUNsQixLQUFLLE1BQU0sVUFBVSxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxFQUFFO2dCQUNuRCxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQzthQUN6RDtTQUNGO1FBRUQsTUFBTSxtQkFBbUIsR0FBRyxFQUFrQyxDQUFDO1FBQy9ELE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBRTVFLEtBQUssTUFBTSxLQUFLLElBQUksT0FBTyxFQUFFO1lBQzNCLElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRTtnQkFDdkIsSUFBSSxDQUFDLG1CQUFtQixDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUM7b0JBQUUsbUJBQW1CLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQztnQkFDdkYsbUJBQW1CLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7YUFDMUQ7U0FDRjtRQUVELE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFDLFdBQVcsRUFBQyxFQUFFO1lBQ3BELEtBQUssTUFBTSxDQUFDLFVBQVUsRUFBRSxPQUFPLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLG1CQUFtQixDQUFDLEVBQUU7Z0JBQ3ZFLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxFQUFFLFdBQVcsRUFBRSxDQUFDLENBQUM7YUFDOUU7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxLQUFLLENBQUMsVUFBVSxDQUFDLE9BQTBCO1FBQ3pDLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFDLFdBQVcsRUFBQyxFQUFFO1lBQ3BELEtBQUssTUFBTSxLQUFLLElBQUksT0FBTyxDQUFDLGNBQWMsRUFBRTtnQkFDMUMsSUFBSSxJQUFJLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsRUFBRTtvQkFDMUMsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLFdBQVcsQ0FBQyxDQUFDO29CQUNoRCxNQUFNLElBQUksQ0FBQyxVQUFVO3lCQUNsQixLQUFLLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQzt5QkFDdkIsT0FBTyxDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssQ0FBQyxNQUFNLEVBQUUsV0FBVyxFQUFFLENBQUMsQ0FBQztpQkFDbEQ7YUFDRjtZQUVELHNEQUFzRDtZQUV0RCxLQUFLLE1BQU0sS0FBSyxJQUFJLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRTtnQkFDL0MsSUFBSSxJQUFJLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsRUFBRTtvQkFDMUMsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLFdBQVcsQ0FBQyxDQUFDO29CQUNoRCxLQUFLLE1BQU0sUUFBUSxJQUFJLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDO3dCQUM5QyxNQUFNLElBQUksQ0FBQyxVQUFVOzZCQUNsQixLQUFLLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQzs2QkFDMUIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsRUFBRSxXQUFXLEVBQUUsQ0FBQyxDQUFDO2lCQUMvQzthQUNGO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU8sYUFBYSxDQUNuQixvQkFBOEM7UUFFOUMsSUFBSSxJQUFJLENBQUMsZUFBZSxDQUFDLG9CQUFvQixDQUFDLFVBQVUsQ0FBQztZQUN2RCxPQUFPLElBQUEsbUJBQWEsRUFDbEIsb0JBQW9CLEVBQ3BCLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssb0JBQW9CLENBQUMsVUFBVSxDQUFDLENBQUMsTUFBTSxFQUNoRixJQUFJLENBQUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxDQUFDLG9CQUFvQixDQUFDLFVBQVUsQ0FBQyxFQUFFLFFBQVEsSUFBSSxFQUFFLEVBQy9FLElBQUksQ0FBQyxPQUFPLEVBQUUsY0FBYyxFQUFFLENBQUMsb0JBQW9CLENBQUMsVUFBVSxDQUFDLEVBQUUsUUFBUSxJQUFJLEVBQUUsQ0FDaEYsQ0FBQztJQUNOLENBQUM7SUFFTyxLQUFLLENBQUMsZ0JBQWdCLENBQzVCLEtBQStCLEVBQy9CLFdBQXlCO1FBRXpCLE1BQU0sRUFBRSxRQUFRLEVBQUUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDbkUsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQzlFLE1BQU0sUUFBUSxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLEVBQUU7WUFDdEMsTUFBTSxRQUFRLEdBQUcsSUFBQSxtQkFBVyxFQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7WUFFbkQsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxJQUFBLGNBQU0sRUFBQSxHQUFHLEtBQUssQ0FBQyxVQUFVLElBQUksT0FBTyxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUM7Z0JBQzNFLEtBQUssRUFBRSxFQUFFLElBQUksRUFBRSxFQUFFLENBQUMsY0FBRSxDQUFDLFVBQVUsQ0FBQyxFQUFFLEdBQUcsUUFBUSxJQUFJLE9BQU8sRUFBRSxFQUFFLEVBQUU7Z0JBQzlELFdBQVc7YUFDWixDQUFDLENBQUM7UUFDTCxDQUFDLENBQUMsQ0FBQztRQUVILE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUM5QixDQUFDO0lBRU8sZUFBZSxDQUFDLFVBQWtCO1FBQ3hDLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssVUFBVSxDQUFDLENBQUM7UUFFNUUsSUFBSSxDQUFDLGNBQWMsRUFBRTtZQUNuQixJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxlQUFlLFVBQVUsa0NBQWtDLENBQUMsQ0FBQztZQUVsRixPQUFPLEtBQUssQ0FBQztTQUNkO1FBRUQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0NBQ0Y7QUF0R0QsOEJBc0dDIn0=

package/dist/synchronization/customer-source.d.ts

@@ -0,0 +1,31 @@
+import type CacheDataSourceInterface from '../cache-interface/datasource';
+import type { PullDeltaReason, PullDumpReason, ReplicaDataSourceOptions, SynchronizationSource, SynchronizationTarget } from '../types';
+import type { Logger } from '@forestadmin/datasource-toolkit';
+import type { Sequelize } from 'sequelize';
+export default class CustomerSource implements SynchronizationSource {
+    requestCache: CacheDataSourceInterface;
+    private readonly logger;
+    private options;
+    private connection;
+    private isRunning;
+    private queuedPullDumpReasons;
+    private queuedPullDeltaReasons;
+    private queuedPushDeltaRequest;
+    private schedules;
+    private target;
+    constructor(connection: Sequelize, options: ReplicaDataSourceOptions, logger: Logger);
+    start(target: SynchronizationTarget): Promise<void>;
+    stop(): Promise<void>;
+    private queuePushDelta;
+    queuePullDump(reason: PullDumpReason): Promise<void>;
+    queuePullDelta(reason: PullDeltaReason): Promise<void>;
+    private tick;
+    private runPushDelta;
+    private runPullDump;
+    private runPullDelta;
+    private getStartupState;
+    private setStartupState;
+    private getDeltaState;
+    private setDeltaState;
+}
+//# sourceMappingURL=customer-source.d.ts.map

package/dist/synchronization/customer-source.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const croner_1 = require("croner");
+class CustomerSource {
+    constructor(connection, options, logger) {
+        this.requestCache = null;
+        this.isRunning = false;
+        this.queuedPullDumpReasons = null;
+        this.queuedPullDeltaReasons = null;
+        this.queuedPushDeltaRequest = null;
+        this.schedules = [];
+        this.connection = connection;
+        this.options = options;
+        this.logger = logger;
+        const hasPullDeltaFlag = options.pullDeltaOnRestart ||
+            options.pullDeltaOnSchedule ||
+            options.pullDeltaOnAfterWrite ||
+            options.pullDeltaOnBeforeAccess;
+        if (options.pullDeltaHandler && !hasPullDeltaFlag)
+            throw new Error('Using pullDeltaHandler without pullDelta[*] flags');
+        if (hasPullDeltaFlag && !options.pullDeltaHandler)
+            throw new Error('Using pullDelta[*] flags without pullDeltaHandler');
+    }
+    async start(target) {
+        const { options } = this;
+        if (this.target)
+            throw new Error('Already started');
+        this.target = target;
+        if (options.pullDumpHandler &&
+            (options.pullDumpOnRestart || (await this.getStartupState()) !== 'done'))
+            await this.queuePullDump({ name: 'startup' });
+        if (options.pullDeltaHandler && options.pullDeltaOnRestart)
+            await this.queuePullDelta({ name: 'startup' });
+        if (options.pushDeltaHandler) {
+            options.pushDeltaHandler({ cache: this.requestCache, getPreviousDeltaState: () => this.getDeltaState() }, async (changes) => this.queuePushDelta(changes));
+        }
+        if (options.pullDumpHandler && options.pullDumpOnSchedule) {
+            const schedule = options.pullDumpOnSchedule;
+            for (const pattern of Array.isArray(schedule) ? schedule : [schedule]) {
+                this.schedules.push((0, croner_1.Cron)(pattern, () => this.queuePullDump({ name: 'schedule' })));
+            }
+        }
+        if (options.pullDeltaHandler && options.pullDeltaOnSchedule) {
+            const schedule = options.pullDeltaOnSchedule;
+            for (const pattern of Array.isArray(schedule) ? schedule : [schedule]) {
+                this.schedules.push((0, croner_1.Cron)(pattern, () => this.queuePullDelta({ name: 'schedule' })));
+            }
+        }
+    }
+    async stop() {
+        this.schedules.forEach(cron => cron.stop());
+        this.schedules.length = 0;
+    }
+    queuePushDelta(delta) {
+        if (!this.queuedPushDeltaRequest)
+            this.queuedPushDeltaRequest = { newOrUpdatedEntries: [], deletedEntries: [] };
+        this.queuedPushDeltaRequest.deletedEntries.push(...delta.deletedEntries);
+        this.queuedPushDeltaRequest.newOrUpdatedEntries.push(...delta.newOrUpdatedEntries);
+        if (delta.nextDeltaState)
+            this.queuedPushDeltaRequest.nextDeltaState = delta.nextDeltaState;
+        this.tick();
+    }
+    queuePullDump(reason) {
+        if (!this.queuedPullDumpReasons)
+            this.queuedPullDumpReasons = { deferred: new datasource_toolkit_1.Deferred(), reasons: [] };
+        const { deferred } = this.queuedPullDumpReasons;
+        this.queuedPullDumpReasons.reasons.push({ ...reason, at: new Date() });
+        this.tick();
+        return deferred.promise;
+    }
+    queuePullDelta(reason) {
+        if (!this.queuedPullDeltaReasons)
+            this.queuedPullDeltaReasons = { deferred: new datasource_toolkit_1.Deferred(), reasons: [] };
+        const { deferred } = this.queuedPullDeltaReasons;
+        this.queuedPullDeltaReasons.reasons.push({ ...reason, at: new Date() });
+        // We wait for the access delay before running the delta
+        // This allows to batch delta requests at the cost of adding a floor delay to all requests.
+        if (this.options.pullDeltaOnBeforeAccessDelay)
+            setTimeout(() => this.tick(), this.options.pullDeltaOnBeforeAccessDelay);
+        else
+            this.tick();
+        return deferred.promise;
+    }
+    tick() {
+        if (!this.isRunning) {
+            if (this.queuedPushDeltaRequest) {
+                this.runPushDelta(this.queuedPushDeltaRequest);
+                this.queuedPushDeltaRequest = null;
+            }
+            else if (this.queuedPullDumpReasons) {
+                this.runPullDump(this.queuedPullDumpReasons);
+                this.queuedPullDumpReasons = null;
+            }
+            else if (this.queuedPullDeltaReasons) {
+                this.runPullDelta(this.queuedPullDeltaReasons);
+                this.queuedPullDeltaReasons = null;
+            }
+        }
+    }
+    async runPushDelta(changes) {
+        this.isRunning = true;
+        await this.target.applyDelta(changes);
+        this.isRunning = false;
+        this.tick();
+    }
+    /* eslint-disable no-await-in-loop */
+    async runPullDump(queue) {
+        this.isRunning = true;
+        let state = null;
+        let more = true;
+        let firstPage = true;
+        await this.setStartupState('in_progress');
+        // Fill table with dump
+        while (more) {
+            try {
+                const changes = await this.options.pullDumpHandler({
+                    reasons: queue.reasons,
+                    cache: this.requestCache,
+                    previousDumpState: state,
+                });
+                await this.target.applyDump(changes, firstPage);
+                firstPage = false;
+                more = changes.more;
+                if (changes.more === true)
+                    state = changes.nextDumpState;
+                if (changes.more === false && changes.nextDeltaState)
+                    await this.setDeltaState(changes.nextDeltaState);
+            }
+            catch (error) {
+                more = false;
+                this.logger('Warn', `Dump failed for the namespace "${this.options.cacheNamespace}": ${error.message}`);
+            }
+        }
+        await this.setStartupState('done');
+        this.isRunning = false;
+        queue.deferred.resolve();
+        this.tick();
+    }
+    async runPullDelta(queue) {
+        this.isRunning = true;
+        let more = true;
+        while (more) {
+            // Update records in database
+            const previousState = await this.getDeltaState();
+            const collections = queue.reasons.flatMap(r => 'affectedCollections' in r ? r.affectedCollections : []);
+            try {
+                const changes = await this.options.pullDeltaHandler({
+                    reasons: queue.reasons,
+                    affectedCollections: [...new Set(collections)],
+                    cache: this.requestCache,
+                    previousDeltaState: previousState,
+                });
+                await this.target.applyDelta(changes);
+                await this.setDeltaState(changes.nextDeltaState);
+                more = changes.more;
+            }
+            catch (error) {
+                more = false;
+                this.logger('Warn', `Delta failed for the namespace "${this.options.cacheNamespace}": ${error.message}`);
+            }
+        }
+        this.isRunning = false;
+        queue.deferred.resolve();
+        this.tick();
+    }
+    /* eslint-enable no-await-in-loop */
+    async getStartupState() {
+        const metadataModel = this.connection.model(`${this.options.cacheNamespace}_metadata`);
+        const stateRecord = await metadataModel.findByPk('statup_state');
+        return stateRecord ? JSON.parse(stateRecord.dataValues.content) : 'pending';
+    }
+    async setStartupState(state) {
+        const metadataModel = this.connection.model(`${this.options.cacheNamespace}_metadata`);
+        await metadataModel.upsert({ id: 'statup_state', content: JSON.stringify(state) });
+    }
+    async getDeltaState() {
+        const metadataModel = this.connection.model(`${this.options.cacheNamespace}_metadata`);
+        const stateRecord = await metadataModel.findByPk('delta_state');
+        return stateRecord ? JSON.parse(stateRecord.dataValues.content) : null;
+    }
+    async setDeltaState(state) {
+        const metadataModel = this.connection.model(`${this.options.cacheNamespace}_metadata`);
+        await metadataModel.upsert({ id: 'delta_state', content: JSON.stringify(state) });
+    }
+}
+exports.default = CustomerSource;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customer-source.js","sourceRoot":"","sources":["../../src/synchronization/customer-source.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,176 @@
+import type CacheDataSourceInterface from './cache-interface/datasource';
+import type { TFilter, TPaginatedFilter } from '@forestadmin/datasource-customizer';
+import type { ConnectionOptions } from '@forestadmin/datasource-sql';
+import type { Aggregation, Caller, ColumnSchema, Logger, PrimitiveTypes, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+export type ValueOrPromiseOrFactory<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+export type RecordDataWithCollection = {
+    collection: string;
+    record: RecordData;
+};
+export declare function isLeafField(field: Field): field is LeafField;
+export type ObjectField = {
+    [key: string]: Field;
+};
+export type ArrayField = [Field];
+export type LeafField = {
+    type: PrimitiveTypes | 'Integer';
+    defaultValue?: unknown;
+    enumValues?: string[];
+    isPrimaryKey?: boolean;
+    isReadOnly?: boolean;
+    unique?: boolean;
+    validation?: ColumnSchema['validation'];
+    reference?: {
+        relationName: string;
+        targetCollection: string;
+        targetField: string;
+        relationInverse?: string;
+    };
+};
+export type Field = ArrayField | ObjectField | LeafField;
+export type CollectionReplicaSchema = {
+    name: string;
+    fields: Record<string, Field>;
+};
+export type PullDumpReason = {
+    name: 'startup' | 'schedule';
+};
+export type PullDeltaReason = {
+    collection?: string;
+    affectedCollections?: string[];
+} & ({
+    name: 'startup';
+} | {
+    name: 'schedule';
+} | {
+    name: 'before-list';
+    caller: Caller;
+    filter: TPaginatedFilter;
+    projection: Projection;
+} | {
+    name: 'before-aggregate';
+    caller: Caller;
+    filter: TFilter;
+    aggregation: Aggregation;
+} | {
+    name: 'after-create';
+    caller: Caller;
+    records: RecordData[];
+} | {
+    name: 'after-update';
+    caller: Caller;
+    filter: TFilter;
+    patch: RecordData;
+} | {
+    name: 'after-delete';
+    caller: Caller;
+    filter: TFilter;
+});
+export type PullDeltaRequest = {
+    previousDeltaState: unknown;
+    cache: CacheDataSourceInterface;
+    affectedCollections: string[];
+    reasons: Array<PullDeltaReason & {
+        at: Date;
+    }>;
+};
+export type PullDumpRequest = {
+    previousDumpState: unknown;
+    cache: CacheDataSourceInterface;
+    reasons: Array<PullDumpReason & {
+        at: Date;
+    }>;
+};
+export type PushDeltaRequest = {
+    getPreviousDeltaState(): unknown;
+    cache: CacheDataSourceInterface;
+};
+export type PullDumpResponse = {
+    more: true;
+    entries: RecordDataWithCollection[];
+    nextDumpState: unknown;
+} | {
+    more: false;
+    entries: RecordDataWithCollection[];
+    nextDeltaState?: unknown;
+};
+export type PullDeltaResponse = {
+    more: boolean;
+    nextDeltaState: unknown;
+    newOrUpdatedEntries: RecordDataWithCollection[];
+    deletedEntries: RecordDataWithCollection[];
+};
+export type PushDeltaResponse = Omit<PullDeltaResponse, 'more' | 'nextDeltaState'> & {
+    nextDeltaState?: unknown;
+};
+export type FlattenOptions = {
+    [modelName: string]: {
+        asModels?: string[];
+        asFields?: Array<string | {
+            field: string;
+            level: number;
+        }>;
+    };
+};
+export type ReplicaDataSourceOptions = {
+    /** URL of the cache database (default to in-memory sqlite) */
+    cacheInto?: ConnectionOptions;
+    /**
+     * Prefix that should be used when creating the tables on the cache
+     * Defaults to 'forest_cache_'.
+     *
+     * Using a prefix allows to share the same database between multiple projects, environments, or
+     * datasources.
+     */
+    cacheNamespace?: string;
+    /** Schema options */
+    schema?: ValueOrPromiseOrFactory<CollectionReplicaSchema[]>;
+    flattenMode?: 'auto' | 'manual';
+    flattenOptions?: ValueOrPromiseOrFactory<FlattenOptions>;
+    /** Writing options */
+    createRecordHandler?: (collectionName: string, record: RecordData) => Promise<RecordData>;
+    updateRecordHandler?: (collectionName: string, record: RecordData) => Promise<void>;
+    deleteRecordHandler?: (collectionName: string, record: RecordData) => Promise<void>;
+    /** Push options */
+    pushDeltaHandler?: (request: PushDeltaRequest, onChanges: (changes: PushDeltaResponse) => Promise<void>) => void | Promise<void>;
+    /** Pull dump options */
+    pullDumpHandler?: (request: PullDumpRequest) => Promise<PullDumpResponse>;
+    pullDumpOnRestart?: boolean;
+    pullDumpOnSchedule?: string | string[];
+    /** Pull delta options */
+    pullDeltaHandler?: (request: PullDeltaRequest) => Promise<PullDeltaResponse>;
+    pullDeltaOnRestart?: boolean;
+    pullDeltaOnSchedule?: string | string[];
+    pullDeltaOnBeforeAccess?: boolean;
+    pullDeltaOnAfterWrite?: boolean;
+    /**
+     * Delay that should be waited before each cache access to give the opportunity for
+     * multiple requests to be batched together.
+     *
+     * Note that this delay will add latency to each request, so set it to a low value (< 100ms)
+     */
+    pullDeltaOnBeforeAccessDelay?: number;
+};
+export type ResolvedOptions = Pick<ReplicaDataSourceOptions, 'cacheInto' | 'cacheNamespace' | 'createRecordHandler' | 'updateRecordHandler' | 'deleteRecordHandler' | 'pullDeltaOnBeforeAccess' | 'pullDeltaOnAfterWrite'> & {
+    schema?: CollectionReplicaSchema[];
+    flattenSchema?: CollectionReplicaSchema[];
+    flattenOptions?: {
+        [modelName: string]: {
+            asModels?: string[];
+            asFields?: string[];
+        };
+    };
+    logger: Logger;
+    source: SynchronizationSource;
+};
+export interface SynchronizationTarget {
+    applyDump(changes: PullDumpResponse, firstPage: boolean): Promise<void>;
+    applyDelta(changes: PushDeltaResponse): Promise<void>;
+}
+export interface SynchronizationSource {
+    requestCache: CacheDataSourceInterface;
+    start(target: SynchronizationTarget): Promise<void>;
+    queuePullDump(reason: PullDumpReason): Promise<void>;
+    queuePullDelta(reason: PullDeltaReason): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLeafField = void 0;
+/// //////
+// Schema
+/// //////
+function isLeafField(field) {
+    return typeof field === 'object' && 'type' in field;
+}
+exports.isLeafField = isLeafField;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBZ0JBLFVBQVU7QUFDVixTQUFTO0FBQ1QsVUFBVTtBQUVWLFNBQWdCLFdBQVcsQ0FBQyxLQUFZO0lBQ3RDLE9BQU8sT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLE1BQU0sSUFBSSxLQUFLLENBQUM7QUFDdEQsQ0FBQztBQUZELGtDQUVDIn0=

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import type { CollectionReplicaSchema } from './types';
+import type { RecordData } from '@forestadmin/datasource-toolkit';
+export declare function escape(strings: TemplateStringsArray, ...exps: unknown[]): string;
+export declare function deepclone(any: unknown): any;
+export declare function extractValue(record: RecordData, path: string, remove: boolean): any;
+export declare function getRecordId(fields: CollectionReplicaSchema['fields'], record: RecordData): unknown;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecordId = exports.extractValue = exports.deepclone = exports.escape = void 0;
+function escape(strings, ...exps) {
+    return strings.reduce((acc, str, i) => acc + str + (exps[i] ?? ''), '').replace(/\./g, '_');
+}
+exports.escape = escape;
+function deepclone(any) {
+    return JSON.parse(JSON.stringify(any));
+}
+exports.deepclone = deepclone;
+function extractValue(record, path, remove) {
+    if (!path)
+        return record;
+    const [prefix, suffix] = path.split(/\.(.*)/);
+    const value = extractValue(record?.[prefix], suffix, remove);
+    if (remove && record && (!suffix || !Object.keys(record?.[prefix] ?? {}).length))
+        delete record[prefix];
+    return value;
+}
+exports.extractValue = extractValue;
+function getRecordId(fields, record) {
+    // eslint-disable-next-line no-underscore-dangle
+    if (record._fid)
+        return record._fid;
+    const pks = Object.entries(fields)
+        .filter(([, v]) => 'type' in v && v.isPrimaryKey)
+        .map(([k]) => record[k]);
+    if (pks.length === 0)
+        throw new Error('No primary key found');
+    else if (pks.length === 1)
+        return pks[0];
+}
+exports.getRecordId = getRecordId;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR0EsU0FBZ0IsTUFBTSxDQUFDLE9BQTZCLEVBQUUsR0FBRyxJQUFlO0lBQ3RFLE9BQU8sT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEdBQUcsR0FBRyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLENBQUM7QUFDOUYsQ0FBQztBQUZELHdCQUVDO0FBRUQsU0FBZ0IsU0FBUyxDQUFDLEdBQVk7SUFDcEMsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztBQUN6QyxDQUFDO0FBRkQsOEJBRUM7QUFFRCxTQUFnQixZQUFZLENBQUMsTUFBa0IsRUFBRSxJQUFZLEVBQUUsTUFBZTtJQUM1RSxJQUFJLENBQUMsSUFBSTtRQUFFLE9BQU8sTUFBTSxDQUFDO0lBRXpCLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUM5QyxNQUFNLEtBQUssR0FBRyxZQUFZLENBQUMsTUFBTSxFQUFFLENBQUMsTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzdELElBQUksTUFBTSxJQUFJLE1BQU0sSUFBSSxDQUFDLENBQUMsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUM7UUFDOUUsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7SUFFeEIsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDO0FBVEQsb0NBU0M7QUFFRCxTQUFnQixXQUFXLENBQ3pCLE1BQXlDLEVBQ3pDLE1BQWtCO0lBRWxCLGdEQUFnRDtJQUNoRCxJQUFJLE1BQU0sQ0FBQyxJQUFJO1FBQUUsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDO0lBRXBDLE1BQU0sR0FBRyxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDO1NBQy9CLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsWUFBWSxDQUFDO1NBQ2hELEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRTNCLElBQUksR0FBRyxDQUFDLE1BQU0sS0FBSyxDQUFDO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO1NBQ3pELElBQUksR0FBRyxDQUFDLE1BQU0sS0FBSyxDQUFDO1FBQUUsT0FBTyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDM0MsQ0FBQztBQWJELGtDQWFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/datasource-replica",
-  "version": "1.0.0",
+  "version": "1.0.2-alpha-widgets.1",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "publishConfig": {
@@ -12,8 +12,8 @@
     "directory": "packages/datasource-replica"
   },
   "files": [
-    "dist/src/**/*.js",
-    "dist/src/**/*.d.ts"
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
   ],
   "scripts": {
     "build": "tsc",
@@ -23,10 +23,10 @@
     "test": "jest"
   },
   "dependencies": {
-    "@forestadmin/datasource-customizer": "1.15.0",
-    "@forestadmin/datasource-sequelize": "1.5.0",
-    "@forestadmin/datasource-sql": "1.7.10",
-    "@forestadmin/datasource-toolkit": "1.9.0",
+    "@forestadmin/datasource-customizer": "1.16.0-alpha-widgets.1",
+    "@forestadmin/datasource-sequelize": "1.5.1-alpha-widgets.1",
+    "@forestadmin/datasource-sql": "1.7.11-alpha-widgets.1",
+    "@forestadmin/datasource-toolkit": "1.10.0-alpha-widgets.1",
     "croner": "^6.0.6",
     "sequelize": "^6.28.0"
   }