@strapi/data-transfer 4.6.0 → 4.7.0-beta.0

package/lib/engine/index.js

@@ -374,7 +374,7 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     keys.forEach((key) => {
         const sourceSchema = sourceSchemas[key];
         const destinationSchema = destinationSchemas[key];
-        const schemaDiffs = (0, validation_1.compareSchemas)(destinationSchema, sourceSchema, strategy);
+        const schemaDiffs = (0, validation_1.compareSchemas)(sourceSchema, destinationSchema, strategy);
         if (schemaDiffs.length) {
             diffs[key] = schemaDiffs;
         }
@@ -388,13 +388,16 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
                 .map((diff) => {
                 const path = diff.path.join('.');
                 if (diff.kind === 'added') {
-                    return `Added "${path}": "${diff.value}" (${diff.type})`;
+                    return `${path} exists in destination schema but not in source schema`;
                 }
                 if (diff.kind === 'deleted') {
-                    return `Removed "${path}"`;
+                    return `${path} exists in source schema but not in destination schema`;
                 }
                 if (diff.kind === 'modified') {
-                    return `Modified "${path}": "${diff.values[0]}" (${diff.types[0]}) => "${diff.values[1]}" (${diff.types[1]})`;
+                    if (diff.types[0] === diff.types[1]) {
+                        return `Schema value changed at "${path}": "${diff.values[0]}" (${diff.types[0]}) => "${diff.values[1]}" (${diff.types[1]})`;
+                    }
+                    return `Schema has differing data types at "${path}": "${diff.values[0]}" (${diff.types[0]}) => "${diff.values[1]}" (${diff.types[1]})`;
                 }
                 throw new errors_1.TransferEngineValidationError(`Invalid diff found for "${uid}"`, {
                     check: `schema on ${uid}`,

package/lib/file/providers/destination/index.js

@@ -19,6 +19,7 @@ const stream_chain_1 = require("stream-chain");
 const stream_1 = require("stream");
 const encryption_1 = require("../../../utils/encryption");
 const utils_1 = require("./utils");
+const providers_1 = require("../../../errors/providers");
 const createLocalFileDestinationProvider = (options) => {
     return new LocalFileDestinationProvider(options);
 };
@@ -47,6 +48,12 @@ class LocalFileDestinationProvider {
         }
         __classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream = tar_stream_1.default.pack();
         const outStream = (0, fs_extra_1.createWriteStream)(__classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "a", _LocalFileDestinationProvider_archivePath_get));
+        outStream.on('error', (err) => {
+            if (err.code === 'ENOSPC') {
+                throw new providers_1.ProviderTransferError("Your server doesn't have space to proceed with the import.");
+            }
+            throw err;
+        });
         const archiveTransforms = [];
         if (compression.enabled) {
             archiveTransforms.push(this.createGzip());

package/lib/file/providers/source/index.js

@@ -26,6 +26,7 @@ const stream_1 = require("stream");
 const Parser_1 = require("stream-json/jsonl/Parser");
 const encryption_1 = require("../../../utils/encryption");
 const stream_2 = require("../../../utils/stream");
+const providers_1 = require("../../../errors/providers");
 /**
  * Constant for the metadata file path
  */
@@ -56,7 +57,10 @@ class LocalFileSourceProvider {
             __classPrivateFieldSet(this, _LocalFileSourceProvider_metadata, await this.getMetadata(), "f");
         }
         catch (e) {
-            throw new Error(`Can't read file "${filePath}".`);
+            if (this.options?.encryption?.enabled) {
+                throw new providers_1.ProviderInitializationError(`Key is incorrect or the file '${filePath}' is not a valid Strapi data file.`);
+            }
+            throw new providers_1.ProviderInitializationError(`File '${filePath}' is not a valid Strapi data file.`);
         }
     }
     getMetadata() {
@@ -147,13 +151,24 @@ _LocalFileSourceProvider_metadata = new WeakMap(), _LocalFileSourceProvider_inst
             async onentry(entry) {
                 const transforms = [
                     // JSONL parser to read the data chunks one by one (line by line)
-                    (0, Parser_1.parser)(),
+                    (0, Parser_1.parser)({
+                        checkErrors: true,
+                    }),
                     // The JSONL parser returns each line as key/value
                     (line) => line.value,
                 ];
                 const stream = entry.pipe((0, stream_chain_1.chain)(transforms));
-                for await (const chunk of stream) {
-                    outStream.write(chunk);
+                try {
+                    for await (const chunk of stream) {
+                        outStream.write(chunk);
+                    }
+                }
+                catch (e) {
+                    outStream.destroy(new providers_1.ProviderTransferError(`Error parsing backup files from backup file ${entry.path}: ${e.message}`, {
+                        details: {
+                            error: e,
+                        },
+                    }));
                 }
             },
         }),
@@ -163,7 +178,9 @@ _LocalFileSourceProvider_metadata = new WeakMap(), _LocalFileSourceProvider_inst
         outStream.end();
     });
     return outStream;
-}, _LocalFileSourceProvider_parseJSONFile = async function _LocalFileSourceProvider_parseJSONFile(fileStream, filePath) {
+}, _LocalFileSourceProvider_parseJSONFile = 
+// For collecting an entire JSON file then parsing it, not for streaming JSONL
+async function _LocalFileSourceProvider_parseJSONFile(fileStream, filePath) {
     return new Promise((resolve, reject) => {
         (0, stream_1.pipeline)([
             fileStream,

package/lib/strapi/index.d.ts

@@ -1,4 +1,3 @@
 export * as providers from './providers';
 export * as queries from './queries';
 export * as remote from './remote';
-export { default as register } from './register';

package/lib/strapi/index.js

@@ -22,14 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.register = exports.remote = exports.queries = exports.providers = void 0;
+exports.remote = exports.queries = exports.providers = void 0;
 exports.providers = __importStar(require("./providers"));
 exports.queries = __importStar(require("./queries"));
 exports.remote = __importStar(require("./remote"));
-var register_1 = require("./register");
-Object.defineProperty(exports, "register", { enumerable: true, get: function () { return __importDefault(register_1).default; } });
 //# sourceMappingURL=index.js.map

package/lib/strapi/providers/local-destination/index.js

@@ -136,7 +136,7 @@ class LocalStrapiDestinationProvider {
         (0, providers_2.assertValidStrapi)(this.strapi, 'Not able to stream Assets');
         const assetsDirectory = path_1.default.join(this.strapi.dirs.static.public, 'uploads');
         const backupDirectory = path_1.default.join(this.strapi.dirs.static.public, `uploads_backup_${Date.now()}`);
-        await fse.rename(assetsDirectory, backupDirectory);
+        await fse.move(assetsDirectory, backupDirectory);
         await fse.mkdir(assetsDirectory);
         // Create a .gitkeep file to ensure the directory is not empty
         await fse.outputFile(path_1.default.join(assetsDirectory, '.gitkeep'), '');
@@ -153,10 +153,13 @@ class LocalStrapiDestinationProvider {
                     .pipe(writableStream)
                     .on('close', callback)
                     .on('error', async (error) => {
+                    const errorMessage = error.code === 'ENOSPC'
+                        ? " Your server doesn't have space to proceed with the import. "
+                        : ' ';
                     try {
                         await fse.rm(assetsDirectory, { recursive: true, force: true });
-                        await fse.rename(backupDirectory, assetsDirectory);
-                        this.destroy(new providers_1.ProviderTransferError(`There was an error during the transfer process. The original files have been restored to ${assetsDirectory}`));
+                        await fse.move(backupDirectory, assetsDirectory);
+                        this.destroy(new providers_1.ProviderTransferError(`There was an error during the transfer process.${errorMessage}The original files have been restored to ${assetsDirectory}`));
                     }
                     catch (err) {
                         throw new providers_1.ProviderTransferError(`There was an error doing the rollback process. The original files are in ${backupDirectory}, but we failed to restore them to ${assetsDirectory}`);

package/lib/strapi/providers/remote-destination/index.d.ts

@@ -4,18 +4,13 @@ import { Writable } from 'stream';
 import { createDispatcher } from './utils';
 import type { IDestinationProvider, IMetadata, ProviderType } from '../../../../types';
 import type { ILocalStrapiDestinationProviderOptions } from '../local-destination';
-interface ITokenAuth {
+interface ITransferTokenAuth {
     type: 'token';
     token: string;
 }
-interface ICredentialsAuth {
-    type: 'credentials';
-    email: string;
-    password: string;
-}
 export interface IRemoteStrapiDestinationProviderOptions extends Pick<ILocalStrapiDestinationProviderOptions, 'restore' | 'strategy'> {
     url: URL;
-    auth?: ITokenAuth | ICredentialsAuth;
+    auth?: ITransferTokenAuth;
 }
 declare class RemoteStrapiDestinationProvider implements IDestinationProvider {
     #private;

package/lib/strapi/providers/remote-destination/index.js

@@ -56,7 +56,6 @@ class RemoteStrapiDestinationProvider {
         }
         const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
         const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}`;
-        const validAuthMethods = ['token'];
         // No auth defined, trying public access for transfer
         if (!auth) {
             ws = new ws_1.WebSocket(wsUrl);
@@ -68,11 +67,10 @@ class RemoteStrapiDestinationProvider {
         }
         // Invalid auth method provided
         else {
-            throw new providers_1.ProviderValidationError('Auth method not implemented', {
+            throw new providers_1.ProviderValidationError('Auth method not available', {
                 check: 'auth.type',
                 details: {
                     auth: auth.type,
-                    validAuthMethods,
                 },
             });
         }

package/lib/strapi/remote/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const TRANSFER_PATH = "/transfer";
-export declare const TRANSFER_METHODS: string[];
+export declare const TRANSFER_PATH: "/transfer/runner/connect";
+export declare const TRANSFER_METHODS: readonly ["push", "pull"];

package/lib/strapi/remote/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRANSFER_METHODS = exports.TRANSFER_PATH = void 0;
-exports.TRANSFER_PATH = '/transfer';
+exports.TRANSFER_PATH = '/transfer/runner/connect';
 exports.TRANSFER_METHODS = ['push', 'pull'];
 //# sourceMappingURL=constants.js.map

package/lib/strapi/remote/handlers.d.ts

@@ -1,3 +1,10 @@
 import type { Context } from 'koa';
 import type { ServerOptions } from 'ws';
-export declare const createTransferHandler: (options?: ServerOptions) => (ctx: Context) => Promise<void>;
+import { TRANSFER_METHODS } from './constants';
+declare type TransferMethod = typeof TRANSFER_METHODS[number];
+interface IHandlerOptions {
+    verify: (ctx: Context, scope?: TransferMethod) => Promise<void>;
+    server?: ServerOptions;
+}
+export declare const createTransferHandler: (options: IHandlerOptions) => (ctx: Context) => Promise<void>;
+export {};

package/lib/strapi/remote/handlers.js

@@ -9,185 +9,191 @@ const ws_1 = require("ws");
 const push_1 = __importDefault(require("./controllers/push"));
 const providers_1 = require("../../errors/providers");
 const constants_1 = require("./constants");
-const createTransferHandler = (options = {}) => async (ctx) => {
-    const upgradeHeader = (ctx.request.headers.upgrade || '')
-        .split(',')
-        .map((s) => s.trim().toLowerCase());
+const createTransferHandler = (options) => {
+    const { verify, server: serverOptions } = options;
     // Create the websocket server
-    const wss = new ws_1.WebSocket.Server({ ...options, noServer: true });
-    if (upgradeHeader.includes('websocket')) {
-        wss.handleUpgrade(ctx.req, ctx.request.socket, Buffer.alloc(0), (ws) => {
-            // Create a connection between the client & the server
-            wss.emit('connection', ws, ctx.req);
-            const state = {};
-            let uuid;
-            /**
-             * Format error & message to follow the remote transfer protocol
-             */
-            const callback = (e = null, data) => {
-                return new Promise((resolve, reject) => {
-                    if (!uuid) {
-                        reject(new Error('Missing uuid for this message'));
-                        return;
-                    }
-                    const payload = JSON.stringify({
-                        uuid,
-                        data: data ?? null,
-                        error: e
-                            ? {
-                                code: 'ERR',
-                                message: e?.message,
-                            }
-                            : null,
+    const wss = new ws_1.WebSocket.Server({ ...serverOptions, noServer: true });
+    return async (ctx) => {
+        const verifyAuth = (scope) => verify(ctx, scope);
+        const upgradeHeader = (ctx.request.headers.upgrade || '')
+            .split(',')
+            .map((s) => s.trim().toLowerCase());
+        if (upgradeHeader.includes('websocket')) {
+            wss.handleUpgrade(ctx.req, ctx.request.socket, Buffer.alloc(0), (ws) => {
+                // Create a connection between the client & the server
+                wss.emit('connection', ws, ctx.req);
+                const state = {};
+                let uuid;
+                /**
+                 * Format error & message to follow the remote transfer protocol
+                 */
+                const callback = (e = null, data) => {
+                    return new Promise((resolve, reject) => {
+                        if (!uuid) {
+                            reject(new Error('Missing uuid for this message'));
+                            return;
+                        }
+                        const payload = JSON.stringify({
+                            uuid,
+                            data: data ?? null,
+                            error: e
+                                ? {
+                                    code: 'ERR',
+                                    message: e?.message,
+                                }
+                                : null,
+                        });
+                        ws.send(payload, (error) => (error ? reject(error) : resolve()));
                     });
-                    ws.send(payload, (error) => (error ? reject(error) : resolve()));
-                });
-            };
-            /**
-             * Wrap a function call to catch errors and answer the request with the correct format
-             */
-            const answer = async (fn) => {
-                try {
-                    const response = await fn();
-                    callback(null, response);
-                }
-                catch (e) {
-                    if (e instanceof Error) {
-                        callback(e);
-                    }
-                    else if (typeof e === 'string') {
-                        callback(new providers_1.ProviderTransferError(e));
+                };
+                /**
+                 * Wrap a function call to catch errors and answer the request with the correct format
+                 */
+                const answer = async (fn) => {
+                    try {
+                        const response = await fn();
+                        callback(null, response);
+                    }
+                    catch (e) {
+                        if (e instanceof Error) {
+                            callback(e);
+                        }
+                        else if (typeof e === 'string') {
+                            callback(new providers_1.ProviderTransferError(e));
+                        }
+                        else {
+                            callback(new providers_1.ProviderTransferError('Unexpected error', {
+                                error: e,
+                            }));
+                        }
                     }
+                };
+                const teardown = async () => {
+                    await verifyAuth(state.transfer?.kind);
+                    delete state.controller;
+                    delete state.transfer;
+                    return { ok: true };
+                };
+                const init = async (msg) => {
+                    // TODO: this only checks for this instance of node: we should consider a database lock
+                    if (state.controller) {
+                        throw new providers_1.ProviderInitializationError('Transfer already in progres');
+                    }
+                    const { transfer } = msg.params;
+                    await verifyAuth(transfer);
+                    // Push transfer
+                    if (transfer === 'push') {
+                        const { options: controllerOptions } = msg.params;
+                        state.controller = (0, push_1.default)({
+                            ...controllerOptions,
+                            autoDestroy: false,
+                            getStrapi: () => strapi,
+                        });
+                    }
+                    // Pull or any other string
                     else {
-                        callback(new providers_1.ProviderTransferError('Unexpected error', {
-                            error: e,
-                        }));
+                        throw new providers_1.ProviderTransferError(`Transfer type not implemented: "${transfer}"`, {
+                            transfer,
+                            validTransfers: constants_1.TRANSFER_METHODS,
+                        });
                     }
-                }
-            };
-            const teardown = () => {
-                delete state.controller;
-                delete state.transfer;
-                return { ok: true };
-            };
-            const init = (msg) => {
-                // TODO: this only checks for this instance of node: we should consider a database lock
-                if (state.controller) {
-                    throw new providers_1.ProviderInitializationError('Transfer already in progres');
-                }
-                const { transfer } = msg.params;
-                // Push transfer
-                if (transfer === 'push') {
-                    const { options: controllerOptions } = msg.params;
-                    state.controller = (0, push_1.default)({
-                        ...controllerOptions,
-                        autoDestroy: false,
-                        getStrapi: () => strapi,
-                    });
-                }
-                // Pull or any other string
-                else {
-                    throw new providers_1.ProviderTransferError(`Transfer type not implemented: "${transfer}"`, {
-                        transfer,
-                        validTransfers: constants_1.TRANSFER_METHODS,
-                    });
-                }
-                state.transfer = { id: (0, crypto_1.randomUUID)(), kind: transfer };
-                return { transferID: state.transfer.id };
-            };
-            /**
-             * On command message (init, end, status, ...)
-             */
-            const onCommand = async (msg) => {
-                const { command } = msg;
-                if (command === 'init') {
-                    await answer(() => init(msg));
-                }
-                if (command === 'end') {
-                    await answer(teardown);
-                }
-                if (command === 'status') {
-                    await callback(new providers_1.ProviderTransferError('Command not implemented: "status"', {
-                        command,
-                        validCommands: ['init', 'end', 'status'],
-                    }));
-                }
-            };
-            const onTransferCommand = async (msg) => {
-                const { transferID, kind } = msg;
-                const { controller } = state;
-                // TODO: (re)move this check
-                // It shouldn't be possible to start a pull transfer for now, so reaching
-                // this code should be impossible too, but this has been added by security
-                if (state.transfer?.kind === 'pull') {
-                    return callback(new providers_1.ProviderTransferError('Pull transfer not implemented'));
-                }
-                if (!controller) {
-                    return callback(new providers_1.ProviderTransferError("The transfer hasn't been initialized"));
-                }
-                if (!transferID) {
-                    return callback(new providers_1.ProviderTransferError('Missing transfer ID'));
-                }
-                // Action
-                if (kind === 'action') {
-                    const { action } = msg;
-                    if (!(action in controller.actions)) {
-                        return callback(new providers_1.ProviderTransferError(`Invalid action provided: "${action}"`, {
-                            action,
-                            validActions: Object.keys(controller.actions),
+                    state.transfer = { id: (0, crypto_1.randomUUID)(), kind: transfer };
+                    return { transferID: state.transfer.id };
+                };
+                /**
+                 * On command message (init, end, status, ...)
+                 */
+                const onCommand = async (msg) => {
+                    const { command } = msg;
+                    if (command === 'init') {
+                        await answer(() => init(msg));
+                    }
+                    if (command === 'end') {
+                        await answer(teardown);
+                    }
+                    if (command === 'status') {
+                        await callback(new providers_1.ProviderTransferError('Command not implemented: "status"', {
+                            command,
+                            validCommands: ['init', 'end', 'status'],
                         }));
                     }
-                    await answer(() => controller.actions[action]());
-                }
-                // Transfer
-                else if (kind === 'step') {
-                    // We can only have push transfer message for the moment
-                    const message = msg;
-                    // TODO: lock transfer process
-                    if (message.action === 'start') {
-                        // console.log('Starting transfer for ', message.step);
-                    }
-                    // Stream step
-                    else if (message.action === 'stream') {
-                        await answer(() => controller.transfer[message.step]?.(message.data));
-                    }
-                    // TODO: unlock transfer process
-                    else if (message.action === 'end') {
-                        // console.log('Ending transfer for ', message.step);
-                    }
-                }
-            };
-            ws.on('close', () => {
-                teardown();
-            });
-            ws.on('error', (e) => {
-                teardown();
-                // TODO: is logging a console error to the running instance of Strapi ok to do? Should we check for an existing strapi.logger to use?
-                console.error(e);
-            });
-            ws.on('message', async (raw) => {
-                const msg = JSON.parse(raw.toString());
-                if (!msg.uuid) {
-                    await callback(new providers_1.ProviderTransferError('Missing uuid in message'));
-                    return;
-                }
-                uuid = msg.uuid;
-                // Regular command message (init, end, status)
-                if (msg.type === 'command') {
-                    await onCommand(msg);
-                }
-                // Transfer message (the transfer must be initialized first)
-                else if (msg.type === 'transfer') {
-                    await onTransferCommand(msg);
-                }
-                // Invalid messages
-                else {
-                    await callback(new providers_1.ProviderTransferError('Bad request'));
-                }
+                };
+                const onTransferCommand = async (msg) => {
+                    const { transferID, kind } = msg;
+                    const { controller } = state;
+                    await verifyAuth(state.transfer?.kind);
+                    // TODO: (re)move this check
+                    // It shouldn't be possible to start a pull transfer for now, so reaching
+                    // this code should be impossible too, but this has been added by security
+                    if (state.transfer?.kind === 'pull') {
+                        return callback(new providers_1.ProviderTransferError('Pull transfer not implemented'));
+                    }
+                    if (!controller) {
+                        return callback(new providers_1.ProviderTransferError("The transfer hasn't been initialized"));
+                    }
+                    if (!transferID) {
+                        return callback(new providers_1.ProviderTransferError('Missing transfer ID'));
+                    }
+                    // Action
+                    if (kind === 'action') {
+                        const { action } = msg;
+                        if (!(action in controller.actions)) {
+                            return callback(new providers_1.ProviderTransferError(`Invalid action provided: "${action}"`, {
+                                action,
+                                validActions: Object.keys(controller.actions),
+                            }));
+                        }
+                        await answer(() => controller.actions[action]());
+                    }
+                    // Transfer
+                    else if (kind === 'step') {
+                        // We can only have push transfer message for the moment
+                        const message = msg;
+                        // TODO: lock transfer process
+                        if (message.action === 'start') {
+                            // console.log('Starting transfer for ', message.step);
+                        }
+                        // Stream step
+                        else if (message.action === 'stream') {
+                            await answer(() => controller.transfer[message.step]?.(message.data));
+                        }
+                        // TODO: unlock transfer process
+                        else if (message.action === 'end') {
+                            // console.log('Ending transfer for ', message.step);
+                        }
+                    }
+                };
+                ws.on('close', () => {
+                    teardown();
+                });
+                ws.on('error', (e) => {
+                    teardown();
+                    strapi.log.error(e);
+                });
+                ws.on('message', async (raw) => {
+                    const msg = JSON.parse(raw.toString());
+                    if (!msg.uuid) {
+                        await callback(new providers_1.ProviderTransferError('Missing uuid in message'));
+                        return;
+                    }
+                    uuid = msg.uuid;
+                    // Regular command message (init, end, status)
+                    if (msg.type === 'command') {
+                        await onCommand(msg);
+                    }
+                    // Transfer message (the transfer must be initialized first)
+                    else if (msg.type === 'transfer') {
+                        await onTransferCommand(msg);
+                    }
+                    // Invalid messages
+                    else {
+                        await callback(new providers_1.ProviderTransferError('Bad request'));
+                    }
+                });
             });
-        });
-        ctx.respond = false;
-    }
+            ctx.respond = false;
+        }
+    };
 };
 exports.createTransferHandler = createTransferHandler;
 //# sourceMappingURL=handlers.js.map

package/lib/strapi/remote/index.d.ts

@@ -1,3 +1,3 @@
 export * as controllers from './controllers';
-export * as routes from './routes';
 export * as constants from './constants';
+export * as handlers from './handlers';

package/lib/strapi/remote/index.js

@@ -23,8 +23,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.constants = exports.routes = exports.controllers = void 0;
+exports.handlers = exports.constants = exports.controllers = void 0;
 exports.controllers = __importStar(require("./controllers"));
-exports.routes = __importStar(require("./routes"));
 exports.constants = __importStar(require("./constants"));
+exports.handlers = __importStar(require("./handlers"));
 //# sourceMappingURL=index.js.map

package/lib/utils/json.js

@@ -33,12 +33,6 @@ const diff = (a, b, ctx = createContext()) => {
         });
         return diffs;
     };
-    if (aType === 'undefined') {
-        return added();
-    }
-    if (bType === 'undefined') {
-        return deleted();
-    }
     if ((0, fp_1.isArray)(a) && (0, fp_1.isArray)(b)) {
         let k = 0;
         for (const [aItem, bItem] of (0, fp_1.zip)(a, b)) {
@@ -60,6 +54,12 @@ const diff = (a, b, ctx = createContext()) => {
         return diffs;
     }
     if (!(0, fp_1.isEqual)(a, b)) {
+        if (aType === 'undefined') {
+            return added();
+        }
+        if (bType === 'undefined') {
+            return deleted();
+        }
         return modified();
     }
     return diffs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/data-transfer",
-  "version": "4.6.0",
+  "version": "4.7.0-beta.0",
   "description": "Data transfer capabilities for Strapi",
   "keywords": [
     "strapi",
@@ -39,8 +39,8 @@
     "lib": "./lib"
   },
   "dependencies": {
-    "@strapi/logger": "4.6.0",
-    "@strapi/strapi": "4.6.0",
+    "@strapi/logger": "4.7.0-beta.0",
+    "@strapi/strapi": "4.7.0-beta.0",
     "chalk": "4.1.2",
     "fs-extra": "10.0.0",
     "lodash": "4.17.21",
@@ -60,7 +60,7 @@
     "@types/koa": "2.13.4",
     "@types/semver": "7.3.13",
     "@types/stream-chain": "2.0.1",
-    "@types/stream-json": "1.7.2",
+    "@types/stream-json": "1.7.3",
     "@types/tar": "6.1.3",
     "@types/tar-stream": "2.2.2",
     "@types/uuid": "9.0.0",
@@ -73,5 +73,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "a9e55435c489f3379d88565bf3f729deb29bfb45"
+  "gitHead": "880ba7af867ad43c4cc45b47467b76a9b5606b6e"
 }

package/lib/strapi/register.d.ts

@@ -1,7 +0,0 @@
-/**
- * This is intended to be called on Strapi register phase.
- *
- * It registers a transfer route in the Strapi admin router.
- */
-declare const register: (strapi: Strapi.Strapi) => void;
-export default register;

package/lib/strapi/register.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const remote_1 = require("./remote");
-/**
- * This is intended to be called on Strapi register phase.
- *
- * It registers a transfer route in the Strapi admin router.
- */
-const register = (strapi) => {
-    remote_1.routes.registerAdminTransferRoute(strapi);
-};
-exports.default = register;
-//# sourceMappingURL=register.js.map

package/lib/strapi/remote/routes.d.ts

@@ -1,21 +0,0 @@
-import type { Context } from 'koa';
-declare module '@strapi/strapi' {
-    interface Strapi {
-        admin: {
-            routes: {
-                method: string;
-                path: string;
-                handler: (ctx: Context) => Promise<void>;
-                config: unknown;
-            }[];
-        };
-    }
-}
-/**
- * Register a transfer route in the Strapi admin router.
- *
- * It exposes a WS server that can be used to run and manage transfer processes.
- *
- * @param strapi - A Strapi instance
- */
-export declare const registerAdminTransferRoute: (strapi: Strapi.Strapi) => void;

package/lib/strapi/remote/routes.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerAdminTransferRoute = void 0;
-const constants_1 = require("./constants");
-const handlers_1 = require("./handlers");
-/**
- * Register a transfer route in the Strapi admin router.
- *
- * It exposes a WS server that can be used to run and manage transfer processes.
- *
- * @param strapi - A Strapi instance
- */
-const registerAdminTransferRoute = (strapi) => {
-    strapi.admin.routes.push({
-        method: 'GET',
-        path: constants_1.TRANSFER_PATH,
-        handler: (0, handlers_1.createTransferHandler)(),
-        config: { auth: false },
-    });
-};
-exports.registerAdminTransferRoute = registerAdminTransferRoute;
-//# sourceMappingURL=routes.js.map