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

package/dist/options/flattener/options.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../types");
+const utils_1 = require("../utils");
+function listFields(field, depth) {
+    if (depth === 0)
+        return [];
+    if (Array.isArray(field))
+        return listFields(field[0], depth);
+    if ((0, types_1.isLeafField)(field))
+        return [''];
+    return Object.entries(field).flatMap(([fieldName, rawSubField]) => {
+        return listFields(rawSubField, depth - 1).map(f => (f ? `${fieldName}.${f}` : fieldName));
+    });
+}
+function getField(field, path) {
+    if (!path)
+        return field;
+    const [prefix, suffix] = path.split(/\.(.*)/);
+    const subField = field[prefix];
+    if (!subField)
+        throw new Error(`Field ${prefix} not found in ${JSON.stringify(field)}}`);
+    return getField(subField, suffix);
+}
+function getAutoFlattenHelper(field, distance) {
+    const options = { asModels: [], asFields: [] };
+    if (!(0, types_1.isLeafField)(field)) {
+        for (const [fieldName, subField] of Object.entries(field)) {
+            let subOptions;
+            if ((0, types_1.isLeafField)(subField)) {
+                subOptions = { asFields: [], asModels: [] };
+                if (distance > 0)
+                    options.asFields.push(fieldName);
+            }
+            else if (Array.isArray(subField)) {
+                subOptions = getAutoFlattenHelper(subField[0], 0);
+                options.asModels.push(fieldName);
+            }
+            else {
+                subOptions = getAutoFlattenHelper(subField, distance + 1);
+            }
+            options.asFields.push(...subOptions.asFields.map(f => `${fieldName}.${f}`));
+            options.asModels.push(...subOptions.asModels.map(f => `${fieldName}.${f}`));
+        }
+    }
+    return options;
+}
+function getAutoFlattenOptions(schema) {
+    return Object.fromEntries(schema.map(({ name, fields }) => {
+        const { asFields, asModels } = getAutoFlattenHelper(fields, 0);
+        asFields.sort();
+        asModels.sort();
+        return [name, { asFields, asModels }];
+    }));
+}
+async function getManualFlattenOptions(schema, rawOptions) {
+    var _a;
+    const rawFlattenOptions = await (0, utils_1.resolveValueOrPromiseOrFactory)(rawOptions.flattenOptions);
+    const result = {};
+    for (const [collectionName, collectionOptions] of Object.entries(rawFlattenOptions ?? {})) {
+        const field = schema.find(s => s.name === collectionName)?.fields;
+        if (!field)
+            throw new Error(`Collection ${collectionName} not found in schema`);
+        const asModels = [...(collectionOptions.asModels ?? [])].sort();
+        const asFields = (collectionOptions.asFields ?? [])
+            // expand fields and objects to a list of absolute paths
+            .flatMap(entry => {
+            const path = typeof entry === 'string' ? entry : entry.field;
+            const depth = typeof entry === 'string' ? 99 : entry.level;
+            const expanded = listFields(getField(field, path), depth);
+            return expanded.map(f => (f ? `${path}.${f}` : path));
+        })
+            // Keep only the paths which do something.
+            .filter(fullPath => {
+            // get the longest path in asModels which is a prefix of path
+            const prefix = collectionOptions.asModels
+                .filter(p => fullPath.startsWith(p))
+                .sort((a, b) => b.length - a.length)?.[0];
+            const suffix = prefix ? fullPath.substring(prefix.length + 1) : fullPath;
+            return suffix.includes('.');
+        })
+            .sort();
+        result[collectionName] = { asModels, asFields };
+    }
+    for (const collection of schema) {
+        result[_a = collection.name] ?? (result[_a] = { asFields: [], asModels: [] });
+    }
+    return result;
+}
+async function computeFlattenOptions(schema, rawOptions) {
+    if (rawOptions.flattenMode === 'auto') {
+        return getAutoFlattenOptions(schema);
+    }
+    try {
+        return await getManualFlattenOptions(schema, rawOptions);
+    }
+    catch (e) {
+        e.message = `Error while computing flattenOptions: ${e.message}`;
+        throw e;
+    }
+}
+exports.default = computeFlattenOptions;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9vcHRpb25zL2ZsYXR0ZW5lci9vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBT0EsdUNBQTBDO0FBQzFDLG9DQUEwRDtBQUsxRCxTQUFTLFVBQVUsQ0FBQyxLQUFZLEVBQUUsS0FBYTtJQUM3QyxJQUFJLEtBQUssS0FBSyxDQUFDO1FBQUUsT0FBTyxFQUFFLENBQUM7SUFDM0IsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztRQUFFLE9BQU8sVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUM3RCxJQUFJLElBQUEsbUJBQVcsRUFBQyxLQUFLLENBQUM7UUFBRSxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUM7SUFFcEMsT0FBTyxNQUFNLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQyxFQUFFLEVBQUU7UUFDaEUsT0FBTyxVQUFVLENBQUMsV0FBVyxFQUFFLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxTQUFTLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7SUFDNUYsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsU0FBUyxRQUFRLENBQUMsS0FBWSxFQUFFLElBQVk7SUFDMUMsSUFBSSxDQUFDLElBQUk7UUFBRSxPQUFPLEtBQUssQ0FBQztJQUV4QixNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUMsTUFBTSxRQUFRLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQy9CLElBQUksQ0FBQyxRQUFRO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxTQUFTLE1BQU0saUJBQWlCLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBRXpGLE9BQU8sUUFBUSxDQUFDLFFBQVEsRUFBRSxNQUFNLENBQUMsQ0FBQztBQUNwQyxDQUFDO0FBRUQsU0FBUyxvQkFBb0IsQ0FBQyxLQUFZLEVBQUUsUUFBZ0I7SUFDMUQsTUFBTSxPQUFPLEdBQXdCLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLENBQUM7SUFFcEUsSUFBSSxDQUFDLElBQUEsbUJBQVcsRUFBQyxLQUFLLENBQUMsRUFBRTtRQUN2QixLQUFLLE1BQU0sQ0FBQyxTQUFTLEVBQUUsUUFBUSxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRTtZQUN6RCxJQUFJLFVBQStCLENBQUM7WUFFcEMsSUFBSSxJQUFBLG1CQUFXLEVBQUMsUUFBUSxDQUFDLEVBQUU7Z0JBQ3pCLFVBQVUsR0FBRyxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxDQUFDO2dCQUM1QyxJQUFJLFFBQVEsR0FBRyxDQUFDO29CQUFFLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO2FBQ3BEO2lCQUFNLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsRUFBRTtnQkFDbEMsVUFBVSxHQUFHLG9CQUFvQixDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztnQkFDbEQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7YUFDbEM7aUJBQU07Z0JBQ0wsVUFBVSxHQUFHLG9CQUFvQixDQUFDLFFBQVEsRUFBRSxRQUFRLEdBQUcsQ0FBQyxDQUFDLENBQUM7YUFDM0Q7WUFFRCxPQUFPLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxHQUFHLFVBQVUsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsR0FBRyxTQUFTLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQzVFLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsVUFBVSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFNBQVMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7U0FDN0U7S0FDRjtJQUVELE9BQU8sT0FBTyxDQUFDO0FBQ2pCLENBQUM7QUFFRCxTQUFTLHFCQUFxQixDQUFDLE1BQWlDO0lBQzlELE9BQU8sTUFBTSxDQUFDLFdBQVcsQ0FDdkIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUU7UUFDOUIsTUFBTSxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsR0FBRyxvQkFBb0IsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDL0QsUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ2hCLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUVoQixPQUFPLENBQUMsSUFBSSxFQUFFLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDeEMsQ0FBQyxDQUFDLENBQ0gsQ0FBQztBQUNKLENBQUM7QUFFRCxLQUFLLFVBQVUsdUJBQXVCLENBQ3BDLE1BQWlDLEVBQ2pDLFVBQW9DOztJQUVwQyxNQUFNLGlCQUFpQixHQUFHLE1BQU0sSUFBQSxzQ0FBOEIsRUFBQyxVQUFVLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDMUYsTUFBTSxNQUFNLEdBQTJCLEVBQUUsQ0FBQztJQUUxQyxLQUFLLE1BQU0sQ0FBQyxjQUFjLEVBQUUsaUJBQWlCLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLGlCQUFpQixJQUFJLEVBQUUsQ0FBQyxFQUFFO1FBQ3pGLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztRQUVsRSxJQUFJLENBQUMsS0FBSztZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsY0FBYyxjQUFjLHNCQUFzQixDQUFDLENBQUM7UUFFaEYsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsUUFBUSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUM7UUFFaEUsTUFBTSxRQUFRLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxRQUFRLElBQUksRUFBRSxDQUFDO1lBQ2pELHdEQUF3RDthQUN2RCxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDZixNQUFNLElBQUksR0FBRyxPQUFPLEtBQUssS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQztZQUM3RCxNQUFNLEtBQUssR0FBRyxPQUFPLEtBQUssS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQztZQUMzRCxNQUFNLFFBQVEsR0FBRyxVQUFVLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztZQUUxRCxPQUFPLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7UUFDeEQsQ0FBQyxDQUFDO1lBQ0YsMENBQTBDO2FBQ3pDLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRTtZQUNqQiw2REFBNkQ7WUFDN0QsTUFBTSxNQUFNLEdBQUcsaUJBQWlCLENBQUMsUUFBUTtpQkFDdEMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQztpQkFDbkMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUM1QyxNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDO1lBRXpFLE9BQU8sTUFBTSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUM5QixDQUFDLENBQUM7YUFDRCxJQUFJLEVBQUUsQ0FBQztRQUVWLE1BQU0sQ0FBQyxjQUFjLENBQUMsR0FBRyxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsQ0FBQztLQUNqRDtJQUVELEtBQUssTUFBTSxVQUFVLElBQUksTUFBTSxFQUFFO1FBQy9CLE1BQU0sTUFBQyxVQUFVLENBQUMsSUFBSSxNQUF0QixNQUFNLE9BQXNCLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxRQUFRLEVBQUUsRUFBRSxFQUFFLEVBQUM7S0FDNUQ7SUFFRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDO0FBRWMsS0FBSyxVQUFVLHFCQUFxQixDQUNqRCxNQUFpQyxFQUNqQyxVQUFvQztJQUVwQyxJQUFJLFVBQVUsQ0FBQyxXQUFXLEtBQUssTUFBTSxFQUFFO1FBQ3JDLE9BQU8scUJBQXFCLENBQUMsTUFBTSxDQUFDLENBQUM7S0FDdEM7SUFFRCxJQUFJO1FBQ0YsT0FBTyxNQUFNLHVCQUF1QixDQUFDLE1BQU0sRUFBRSxVQUFVLENBQUMsQ0FBQztLQUMxRDtJQUFDLE9BQU8sQ0FBQyxFQUFFO1FBQ1YsQ0FBQyxDQUFDLE9BQU8sR0FBRyx5Q0FBeUMsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2pFLE1BQU0sQ0FBQyxDQUFDO0tBQ1Q7QUFDSCxDQUFDO0FBZEQsd0NBY0MifQ==

package/dist/options/flattener/schema.d.ts

@@ -0,0 +1,8 @@
+import type { CollectionReplicaSchema, ResolvedOptions } from '../../types';
+/**
+ * Abuse the flattenRecordRec logic with ❤️
+ * And then fix the _fpid and _fid fields which are not correct
+ */
+export declare function flattenCollectionSchema(schema: CollectionReplicaSchema, asFields: string[], asModels: string[]): CollectionReplicaSchema[];
+export declare function flattenSchema(schema: CollectionReplicaSchema[], flattenOptions: ResolvedOptions['flattenOptions']): CollectionReplicaSchema[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/options/flattener/schema.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenSchema = exports.flattenCollectionSchema = void 0;
+const flattener_1 = __importDefault(require("../../flattener"));
+const types_1 = require("../../types");
+/**
+ * Abuse the flattenRecordRec logic with ❤️
+ * And then fix the _fpid and _fid fields which are not correct
+ */
+function flattenCollectionSchema(schema, asFields, asModels) {
+    const recordWithCollection = { collection: schema.name, record: schema.fields };
+    const output = (0, flattener_1.default)(recordWithCollection, schema.fields, asFields, asModels);
+    for (let i = output.length - 2; i >= 0; i -= 1) {
+        const { collection, record } = output[i];
+        const parent = output.slice(i + 1).find(r => collection.startsWith(r.collection));
+        const [parentPkName, parentPkField] = Object.entries(parent.record).find(([, v]) => (0, types_1.isLeafField)(v) ? v.isPrimaryKey : false) ?? ['_fid', { type: 'String', isPrimaryKey: true }];
+        record._fpid = {
+            type: parentPkField.type,
+            unique: !record._fid.endsWith('.0'),
+            reference: {
+                targetCollection: parent.collection,
+                targetField: parentPkName,
+                relationName: 'parent',
+                relationInverse: collection.substring(parent.collection.length + 1),
+            },
+        };
+        record._fid = { type: 'String', isPrimaryKey: true };
+    }
+    return output.map(({ collection, record }) => ({ name: collection, fields: record }));
+}
+exports.flattenCollectionSchema = flattenCollectionSchema;
+function flattenSchema(schema, flattenOptions) {
+    return schema.flatMap(collectionSchema => flattenCollectionSchema(collectionSchema, flattenOptions?.[collectionSchema.name]?.asFields ?? [], flattenOptions?.[collectionSchema.name]?.asModels ?? []));
+}
+exports.flattenSchema = flattenSchema;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/options/index.d.ts

@@ -0,0 +1,5 @@
+import type { ReplicaDataSourceOptions, ResolvedOptions } from '../types';
+import type { Logger } from '@forestadmin/datasource-toolkit';
+import type { Sequelize } from 'sequelize';
+export default function resolveOptions(options: ReplicaDataSourceOptions, logger: Logger, connection: Sequelize): Promise<ResolvedOptions>;
+//# sourceMappingURL=index.d.ts.map

package/dist/options/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = __importDefault(require("./flattener/options"));
+const schema_1 = require("./flattener/schema");
+const schema_2 = require("./schema");
+const analysis_passthrough_1 = __importDefault(require("../synchronization/analysis-passthrough"));
+const customer_source_1 = __importDefault(require("../synchronization/customer-source"));
+async function resolveOptions(options, logger, connection) {
+    let source = new customer_source_1.default(connection, options, logger);
+    let resolvedSchema = await (0, schema_2.getSchema)(options, connection);
+    if (!resolvedSchema) {
+        const passThrough = new analysis_passthrough_1.default(connection, source, options.cacheNamespace);
+        await source.start(passThrough); // This should block until the analysis is done.
+        source = passThrough;
+        resolvedSchema = await (0, schema_2.buildSchema)(passThrough.nodes);
+    }
+    const flattenOptions = await (0, options_1.default)(resolvedSchema, options);
+    return {
+        cacheInto: options.cacheInto,
+        cacheNamespace: options.cacheNamespace,
+        createRecordHandler: options.createRecordHandler,
+        deleteRecordHandler: options.deleteRecordHandler,
+        flattenOptions,
+        flattenSchema: (0, schema_1.flattenSchema)(resolvedSchema, flattenOptions),
+        logger,
+        pullDeltaOnAfterWrite: options.pullDeltaHandler && options.pullDeltaOnAfterWrite,
+        pullDeltaOnBeforeAccess: options.pullDeltaHandler && options.pullDeltaOnBeforeAccess,
+        schema: resolvedSchema,
+        source,
+        updateRecordHandler: options.updateRecordHandler,
+    };
+}
+exports.default = resolveOptions;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3B0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQVNBLGtFQUF3RDtBQUN4RCwrQ0FBbUQ7QUFDbkQscUNBQWtEO0FBQ2xELG1HQUF5RTtBQUN6RSx5RkFBZ0U7QUFFakQsS0FBSyxVQUFVLGNBQWMsQ0FDMUMsT0FBaUMsRUFDakMsTUFBYyxFQUNkLFVBQXFCO0lBRXJCLElBQUksTUFBTSxHQUEwQixJQUFJLHlCQUFjLENBQUMsVUFBVSxFQUFFLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNwRixJQUFJLGNBQWMsR0FBOEIsTUFBTSxJQUFBLGtCQUFTLEVBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBRXJGLElBQUksQ0FBQyxjQUFjLEVBQUU7UUFDbkIsTUFBTSxXQUFXLEdBQUcsSUFBSSw4QkFBa0IsQ0FBQyxVQUFVLEVBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUN2RixNQUFNLE1BQU0sQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxnREFBZ0Q7UUFFakYsTUFBTSxHQUFHLFdBQVcsQ0FBQztRQUNyQixjQUFjLEdBQUcsTUFBTSxJQUFBLG9CQUFXLEVBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDO0tBQ3ZEO0lBRUQsTUFBTSxjQUFjLEdBQUcsTUFBTSxJQUFBLGlCQUFxQixFQUFDLGNBQWMsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUU1RSxPQUFPO1FBQ0wsU0FBUyxFQUFFLE9BQU8sQ0FBQyxTQUFTO1FBQzVCLGNBQWMsRUFBRSxPQUFPLENBQUMsY0FBYztRQUN0QyxtQkFBbUIsRUFBRSxPQUFPLENBQUMsbUJBQW1CO1FBQ2hELG1CQUFtQixFQUFFLE9BQU8sQ0FBQyxtQkFBbUI7UUFDaEQsY0FBYztRQUNkLGFBQWEsRUFBRSxJQUFBLHNCQUFhLEVBQUMsY0FBYyxFQUFFLGNBQWMsQ0FBQztRQUM1RCxNQUFNO1FBQ04scUJBQXFCLEVBQUUsT0FBTyxDQUFDLGdCQUFnQixJQUFJLE9BQU8sQ0FBQyxxQkFBcUI7UUFDaEYsdUJBQXVCLEVBQUUsT0FBTyxDQUFDLGdCQUFnQixJQUFJLE9BQU8sQ0FBQyx1QkFBdUI7UUFDcEYsTUFBTSxFQUFFLGNBQWM7UUFDdEIsTUFBTTtRQUNOLG1CQUFtQixFQUFFLE9BQU8sQ0FBQyxtQkFBbUI7S0FDakQsQ0FBQztBQUNKLENBQUM7QUFoQ0QsaUNBZ0NDIn0=

package/dist/options/schema/analyzer.d.ts

@@ -0,0 +1,11 @@
+import type { PrimitiveTypes } from '@forestadmin/datasource-toolkit';
+export type Primitive = 'Null' | 'Object' | 'Array' | 'Integer' | PrimitiveTypes;
+export type NodeStudy = {
+    types: Partial<Record<Primitive, number>>;
+    seen: number;
+    object?: Record<string, NodeStudy>;
+    arrayElement?: NodeStudy;
+};
+export declare function createNode(): NodeStudy;
+export declare function walkNode(node: NodeStudy, sample: unknown): void;
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/options/schema/analyzer.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkNode = exports.createNode = void 0;
+function getSampleType(sample) {
+    if (sample === null)
+        return 'Null';
+    if (sample instanceof Buffer)
+        return 'Binary';
+    if (sample instanceof Date)
+        return 'Date';
+    if (Array.isArray(sample))
+        return 'Array';
+    if (sample?.constructor === Object)
+        return 'Object';
+    if (Number.isInteger(sample))
+        return 'Integer';
+    const type = typeof sample;
+    return (type[0].toUpperCase() + type.slice(1));
+}
+function annotateNode(node, sample) {
+    const type = getSampleType(sample);
+    // Increment counters
+    node.seen += 1;
+    node.types[type] = (node.types[type] || 0) + 1;
+}
+function walkArrayNode(node, sample) {
+    if (!node.arrayElement)
+        node.arrayElement = createNode();
+    for (const subSample of sample)
+        walkNode(node.arrayElement, subSample);
+}
+function walkObjectNode(node, sample) {
+    if (!node.object)
+        node.object = {};
+    for (const [key, subSample] of Object.entries(sample)) {
+        if (!node.object[key])
+            node.object[key] = createNode();
+        walkNode(node.object[key], subSample);
+    }
+}
+function createNode() {
+    return { types: {}, seen: 0 };
+}
+exports.createNode = createNode;
+function walkNode(node, sample) {
+    if (Array.isArray(sample))
+        walkArrayNode(node, sample);
+    if (sample?.constructor === Object)
+        walkObjectNode(node, sample);
+    annotateNode(node, sample);
+}
+exports.walkNode = walkNode;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/options/schema/index.d.ts

@@ -0,0 +1,6 @@
+import type { NodeStudy } from './analyzer';
+import type { CollectionReplicaSchema, ReplicaDataSourceOptions } from '../../types';
+import type { Sequelize } from 'sequelize';
+export declare function getSchema(rawOptions: ReplicaDataSourceOptions, connection: Sequelize): Promise<CollectionReplicaSchema[]>;
+export declare function buildSchema(analysis: Record<string, NodeStudy>): Promise<CollectionReplicaSchema[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/options/schema/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSchema = exports.getSchema = void 0;
+const types_1 = require("../../types");
+const utils_1 = require("../utils");
+function convertAnalysisToSchema(node) {
+    const types = Object.keys(node.types).filter(t => t !== 'null');
+    if (types.length > 1)
+        return { type: 'Json' };
+    if (types[0] === 'Object') {
+        const entries = Object.entries(node.object).map(([k, v]) => [k, convertAnalysisToSchema(v)]);
+        return Object.fromEntries(entries);
+    }
+    if (types[0] === 'Array') {
+        return [convertAnalysisToSchema(node.arrayElement)];
+    }
+    return { type: types[0] };
+}
+async function getSchema(rawOptions, connection) {
+    // Schema is provided by the user
+    if (rawOptions.schema) {
+        return (0, utils_1.resolveValueOrPromiseOrFactory)(rawOptions.schema);
+    }
+    // Schema was already computed and cached
+    const metadata = connection.model(`${rawOptions.cacheNamespace}_metadata`);
+    const schemaFromDb = await metadata.findByPk('schema');
+    if (schemaFromDb)
+        return schemaFromDb.dataValues.content;
+    return null;
+}
+exports.getSchema = getSchema;
+async function buildSchema(analysis) {
+    return Object.entries(analysis).map(([name, node]) => {
+        const fields = convertAnalysisToSchema(node);
+        if ((0, types_1.isLeafField)(fields.id))
+            fields.id.isPrimaryKey = true;
+        else
+            throw new Error(`No primary key found in the schema of the collection ${name}`);
+        return { name, fields };
+    });
+}
+exports.buildSchema = buildSchema;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/options/utils.d.ts

@@ -0,0 +1,3 @@
+import type { ValueOrPromiseOrFactory } from '../types';
+export declare function resolveValueOrPromiseOrFactory<T extends object>(v: ValueOrPromiseOrFactory<T>): Promise<T>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/options/utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveValueOrPromiseOrFactory = void 0;
+async function resolveValueOrPromiseOrFactory(v) {
+    return typeof v === 'function' ? v() : v;
+}
+exports.resolveValueOrPromiseOrFactory = resolveValueOrPromiseOrFactory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3B0aW9ucy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHTyxLQUFLLFVBQVUsOEJBQThCLENBQ2xELENBQTZCO0lBRTdCLE9BQU8sT0FBTyxDQUFDLEtBQUssVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQzNDLENBQUM7QUFKRCx3RUFJQyJ9

package/dist/sequelize.d.ts

@@ -0,0 +1,6 @@
+import type { ReplicaDataSourceOptions, ResolvedOptions } from './types';
+import type { Logger } from '@forestadmin/datasource-toolkit';
+import type { Sequelize } from 'sequelize';
+export declare function createSequelize(logger: Logger, options: ReplicaDataSourceOptions): Promise<Sequelize>;
+export declare function createModels(sequelize: Sequelize, options: ResolvedOptions): Promise<void>;
+//# sourceMappingURL=sequelize.d.ts.map

package/dist/sequelize.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModels = exports.createSequelize = void 0;
+const datasource_sql_1 = require("@forestadmin/datasource-sql");
+const sequelize_1 = require("sequelize");
+const types_1 = require("./types");
+function convertField(field) {
+    if ((0, types_1.isLeafField)(field)) {
+        let type = sequelize_1.DataTypes.JSON;
+        if (field.type === 'Binary')
+            type = sequelize_1.DataTypes.BLOB('long');
+        if (field.type === 'Boolean')
+            type = sequelize_1.DataTypes.BOOLEAN;
+        if (field.type === 'Date')
+            type = sequelize_1.DataTypes.DATE;
+        if (field.type === 'Dateonly')
+            type = sequelize_1.DataTypes.DATEONLY;
+        if (field.type === 'Integer')
+            type = sequelize_1.DataTypes.INTEGER;
+        if (field.type === 'Number')
+            type = sequelize_1.DataTypes.DOUBLE;
+        if (field.type === 'String')
+            type = sequelize_1.DataTypes.TEXT;
+        if (field.type === 'Enum')
+            type = new sequelize_1.DataTypes.ENUM(...field.enumValues);
+        return {
+            type,
+            allowNull: true,
+            primaryKey: field.isPrimaryKey,
+            defaultValue: field.defaultValue,
+        };
+    }
+    return { type: sequelize_1.DataTypes.JSON, allowNull: true, primaryKey: false };
+}
+async function defineModels(sync, namespace, schema, sequelize) {
+    for (const model of schema) {
+        const attributes = {};
+        for (const [name, field] of Object.entries(model.fields)) {
+            attributes[name] = convertField(field);
+        }
+        const sequelizeModel = sequelize.define(model.name, attributes, {
+            timestamps: false,
+            tableName: `${namespace}_${model.name}`,
+            indexes: Object.entries(model.fields)
+                .filter(([, field]) => (0, types_1.isLeafField)(field) && field.reference)
+                .map(([name]) => ({ fields: [name] })),
+        });
+        // eslint-disable-next-line no-await-in-loop
+        if (sync)
+            await sequelizeModel.sync({ force: true });
+    }
+}
+function defineRelationships(schema, sequelize) {
+    for (const model of schema) {
+        const sequelizeModel = sequelize.model(model.name);
+        for (const [name, field] of Object.entries(model.fields)) {
+            if ((0, types_1.isLeafField)(field) && field.reference) {
+                const otherSequelizeModel = sequelize.model(field.reference.targetCollection);
+                sequelizeModel.belongsTo(otherSequelizeModel, {
+                    as: field.reference.relationName,
+                    foreignKey: name,
+                    targetKey: field.reference.targetField,
+                });
+                if (field.reference.relationInverse) {
+                    const handler = field.unique ? otherSequelizeModel.hasOne : otherSequelizeModel.hasMany;
+                    handler.call(otherSequelizeModel, sequelizeModel, {
+                        as: field.reference.relationInverse,
+                        foreignKey: name,
+                        sourceKey: field.reference.targetField,
+                    });
+                }
+            }
+        }
+    }
+}
+async function createSequelize(logger, options) {
+    const sequelize = await (0, datasource_sql_1.buildSequelizeInstance)(options.cacheInto, logger, []);
+    // This table should never need to change => use normal sync
+    await sequelize
+        .define(`${options.cacheNamespace}_metadata`, {
+        id: { type: sequelize_1.DataTypes.STRING, primaryKey: true },
+        content: sequelize_1.DataTypes.JSON,
+    })
+        .sync();
+    // This table should never be reused between runs => force: true
+    await sequelize
+        .define(`${options.cacheNamespace}_pending_operations`, {
+        id: { type: sequelize_1.DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+        type: sequelize_1.DataTypes.ENUM('dump', 'delta'),
+        content: sequelize_1.DataTypes.JSON,
+    })
+        .sync({ force: true });
+    return sequelize;
+}
+exports.createSequelize = createSequelize;
+async function createModels(sequelize, options) {
+    const metadata = sequelize.model(`${options.cacheNamespace}_metadata`);
+    const replicaSchema = (await metadata.findByPk('flat_schema'))?.dataValues?.content;
+    const sync = JSON.stringify(replicaSchema) !== JSON.stringify(options.flattenSchema);
+    // Tell the use what we are doing
+    const level = options.cacheInto !== 'sqlite::memory:' ? 'Info' : 'Debug';
+    if (!replicaSchema) {
+        options.logger(level, `${options.cacheNamespace}: Initializing cache.`);
+    }
+    else if (sync) {
+        options.logger(level, `${options.cacheNamespace}: Schema changed, reinitializing cache.`);
+    }
+    else {
+        options.logger(level, `${options.cacheNamespace}: Cache already initialized.`);
+    }
+    // Sync
+    await defineModels(sync, options.cacheNamespace, options.flattenSchema, sequelize);
+    defineRelationships(options.flattenSchema, sequelize);
+    // Set up metadata depending on the type of sync we did
+    if (sync) {
+        await metadata.truncate();
+        await metadata.create({ id: 'schema', content: options.schema });
+        await metadata.create({ id: 'flat_schema', content: options.flattenSchema });
+    }
+}
+exports.createModels = createModels;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/synchronization/analysis-passthrough.d.ts

@@ -0,0 +1,20 @@
+import type CacheDataSourceInterface from '../cache-interface/datasource';
+import type { NodeStudy } from '../options/schema/analyzer';
+import type { PullDeltaReason, PullDumpReason, PullDumpResponse, PushDeltaResponse, SynchronizationSource, SynchronizationTarget } from '../types';
+import type { Model, ModelStatic, Sequelize } from 'sequelize';
+export default class AnalysisPassThough implements SynchronizationTarget, SynchronizationSource {
+    recordCache: ModelStatic<Model>;
+    nodes: Record<string, NodeStudy>;
+    target: SynchronizationTarget;
+    source: SynchronizationSource;
+    namespace: string;
+    get requestCache(): CacheDataSourceInterface;
+    set requestCache(value: CacheDataSourceInterface);
+    constructor(connection: Sequelize, source: SynchronizationSource, namespace: string);
+    start(target: SynchronizationTarget): Promise<void>;
+    queuePullDump(reason: PullDumpReason): Promise<void>;
+    queuePullDelta(reason: PullDeltaReason): Promise<void>;
+    applyDump(changes: PullDumpResponse, firstPage: boolean): Promise<void>;
+    applyDelta(changes: PushDeltaResponse): Promise<void>;
+}
+//# sourceMappingURL=analysis-passthrough.d.ts.map

package/dist/synchronization/analysis-passthrough.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const analyzer_1 = require("../options/schema/analyzer");
+class AnalysisPassThough {
+    get requestCache() {
+        return this.source?.requestCache;
+    }
+    set requestCache(value) {
+        this.source.requestCache = value;
+    }
+    constructor(connection, source, namespace) {
+        this.target = null;
+        this.source = source;
+        this.recordCache = connection.model(`${namespace}_pending_operations`);
+        this.namespace = namespace;
+        this.nodes = {};
+    }
+    async start(target) {
+        if (!this.target) {
+            // Replay dump/delta that we received while analyzing the schema
+            let record = { dataValues: { id: 0 } };
+            while (record) {
+                // eslint-disable-next-line no-await-in-loop
+                record = await this.recordCache.findOne({
+                    where: { id: { [sequelize_1.Op.gt]: record.dataValues.id } },
+                    order: [['id', 'ASC']],
+                });
+                if (record)
+                    // eslint-disable-next-line no-await-in-loop
+                    await (record.dataValues.type === 'dump'
+                        ? target.applyDump(...record.dataValues.content)
+                        : target.applyDelta(...record.dataValues.content));
+            }
+            await this.recordCache.truncate();
+            // Set target so that from now on we just forward the requests
+            this.target = target;
+        }
+        else {
+            throw new Error('Already started');
+        }
+    }
+    queuePullDump(reason) {
+        return this.source.queuePullDump(reason);
+    }
+    queuePullDelta(reason) {
+        return this.source.queuePullDelta(reason);
+    }
+    async applyDump(changes, firstPage) {
+        if (this.target) {
+            await this.target.applyDump(changes, firstPage);
+        }
+        else {
+            for (const record of changes.entries) {
+                if (!this.nodes[record.collection]) {
+                    this.nodes[record.collection] = (0, analyzer_1.createNode)();
+                }
+                (0, analyzer_1.walkNode)(this.nodes[record.collection], record.record);
+            }
+            await this.recordCache.create({ type: 'dump', content: [changes, firstPage] });
+        }
+    }
+    async applyDelta(changes) {
+        if (this.target) {
+            await this.target.applyDelta(changes);
+        }
+        else {
+            for (const record of changes.newOrUpdatedEntries) {
+                if (!this.nodes[record.collection]) {
+                    this.nodes[record.collection] = (0, analyzer_1.createNode)();
+                }
+                (0, analyzer_1.walkNode)(this.nodes[record.collection], record.record);
+            }
+            await this.recordCache.create({ type: 'delta', content: [changes] });
+        }
+    }
+}
+exports.default = AnalysisPassThough;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5hbHlzaXMtcGFzc3Rocm91Z2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3luY2hyb25pemF0aW9uL2FuYWx5c2lzLXBhc3N0aHJvdWdoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBWUEseUNBQStCO0FBRS9CLHlEQUFrRTtBQUVsRSxNQUFxQixrQkFBa0I7SUFPckMsSUFBSSxZQUFZO1FBQ2QsT0FBTyxJQUFJLENBQUMsTUFBTSxFQUFFLFlBQVksQ0FBQztJQUNuQyxDQUFDO0lBRUQsSUFBSSxZQUFZLENBQUMsS0FBK0I7UUFDOUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxZQUFZLEdBQUcsS0FBSyxDQUFDO0lBQ25DLENBQUM7SUFFRCxZQUFZLFVBQXFCLEVBQUUsTUFBNkIsRUFBRSxTQUFpQjtRQVpuRixXQUFNLEdBQTBCLElBQUksQ0FBQztRQWFuQyxJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQyxLQUFLLENBQUMsR0FBRyxTQUFTLHFCQUFxQixDQUFDLENBQUM7UUFDdkUsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDM0IsSUFBSSxDQUFDLEtBQUssR0FBRyxFQUFFLENBQUM7SUFDbEIsQ0FBQztJQUVELEtBQUssQ0FBQyxLQUFLLENBQUMsTUFBNkI7UUFDdkMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDaEIsZ0VBQWdFO1lBQ2hFLElBQUksTUFBTSxHQUFVLEVBQUUsVUFBVSxFQUFFLEVBQUUsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFXLENBQUM7WUFFdkQsT0FBTyxNQUFNLEVBQUU7Z0JBQ2IsNENBQTRDO2dCQUM1QyxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQztvQkFDdEMsS0FBSyxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsQ0FBQyxjQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsTUFBTSxDQUFDLFVBQVUsQ0FBQyxFQUFFLEVBQUUsRUFBRTtvQkFDaEQsS0FBSyxFQUFFLENBQUMsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUM7aUJBQ3ZCLENBQUMsQ0FBQztnQkFFSCxJQUFJLE1BQU07b0JBQ1IsNENBQTRDO29CQUM1QyxNQUFNLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxJQUFJLEtBQUssTUFBTTt3QkFDdEMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsR0FBSSxNQUFNLENBQUMsVUFBVSxDQUFDLE9BQXVDLENBQUM7d0JBQ2pGLENBQUMsQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLEdBQUksTUFBTSxDQUFDLFVBQVUsQ0FBQyxPQUErQixDQUFDLENBQUMsQ0FBQzthQUNqRjtZQUVELE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUVsQyw4REFBOEQ7WUFDOUQsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7U0FDdEI7YUFBTTtZQUNMLE1BQU0sSUFBSSxLQUFLLENBQUMsaUJBQWlCLENBQUMsQ0FBQztTQUNwQztJQUNILENBQUM7SUFFRCxhQUFhLENBQUMsTUFBc0I7UUFDbEMsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBRUQsY0FBYyxDQUFDLE1BQXVCO1FBQ3BDLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUVELEtBQUssQ0FBQyxTQUFTLENBQUMsT0FBeUIsRUFBRSxTQUFrQjtRQUMzRCxJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDZixNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxTQUFTLENBQUMsQ0FBQztTQUNqRDthQUFNO1lBQ0wsS0FBSyxNQUFNLE1BQU0sSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFO2dCQUNwQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLEVBQUU7b0JBQ2xDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLElBQUEscUJBQVUsR0FBRSxDQUFDO2lCQUM5QztnQkFFRCxJQUFBLG1CQUFRLEVBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO2FBQ3hEO1lBRUQsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUMsT0FBTyxFQUFFLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQztTQUNoRjtJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsVUFBVSxDQUFDLE9BQTBCO1FBQ3pDLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRTtZQUNmLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUM7U0FDdkM7YUFBTTtZQUNMLEtBQUssTUFBTSxNQUFNLElBQUksT0FBTyxDQUFDLG1CQUFtQixFQUFFO2dCQUNoRCxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLEVBQUU7b0JBQ2xDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLElBQUEscUJBQVUsR0FBRSxDQUFDO2lCQUM5QztnQkFFRCxJQUFBLG1CQUFRLEVBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO2FBQ3hEO1lBRUQsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1NBQ3RFO0lBQ0gsQ0FBQztDQUNGO0FBekZELHFDQXlGQyJ9

package/dist/synchronization/cache-target.d.ts

@@ -0,0 +1,15 @@
+import type { PullDumpResponse, PushDeltaResponse, ResolvedOptions, SynchronizationTarget } from '../types';
+import type { Logger } from '@forestadmin/datasource-toolkit';
+import type { Sequelize } from 'sequelize';
+export default class CacheTarget implements SynchronizationTarget {
+    connection: Sequelize;
+    options: ResolvedOptions;
+    logger: Logger;
+    constructor(connection: Sequelize, options: ResolvedOptions, logger: Logger);
+    applyDump(changes: PullDumpResponse, firstPage: boolean): Promise<void>;
+    applyDelta(changes: PushDeltaResponse): Promise<void>;
+    private flattenRecord;
+    private destroySubModels;
+    private checkCollection;
+}
+//# sourceMappingURL=cache-target.d.ts.map