@strapi/data-transfer 4.7.0-beta.0 → 4.9.0-alpha.0

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

@@ -19,7 +19,6 @@ 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);
 };
@@ -48,12 +47,6 @@ 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/strapi/index.d.ts

@@ -1,3 +1,4 @@
 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,9 +22,14 @@ 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.remote = exports.queries = exports.providers = void 0;
+exports.register = 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

@@ -153,13 +153,10 @@ 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.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}`));
+                        this.destroy(new providers_1.ProviderTransferError(`There was an error during the transfer process. 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,13 +4,18 @@ import { Writable } from 'stream';
 import { createDispatcher } from './utils';
 import type { IDestinationProvider, IMetadata, ProviderType } from '../../../../types';
 import type { ILocalStrapiDestinationProviderOptions } from '../local-destination';
-interface ITransferTokenAuth {
+interface ITokenAuth {
     type: 'token';
     token: string;
 }
+interface ICredentialsAuth {
+    type: 'credentials';
+    email: string;
+    password: string;
+}
 export interface IRemoteStrapiDestinationProviderOptions extends Pick<ILocalStrapiDestinationProviderOptions, 'restore' | 'strategy'> {
     url: URL;
-    auth?: ITransferTokenAuth;
+    auth?: ITokenAuth | ICredentialsAuth;
 }
 declare class RemoteStrapiDestinationProvider implements IDestinationProvider {
     #private;

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

@@ -56,6 +56,7 @@ 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);
@@ -67,10 +68,11 @@ class RemoteStrapiDestinationProvider {
         }
         // Invalid auth method provided
         else {
-            throw new providers_1.ProviderValidationError('Auth method not available', {
+            throw new providers_1.ProviderValidationError('Auth method not implemented', {
                 check: 'auth.type',
                 details: {
                     auth: auth.type,
+                    validAuthMethods,
                 },
             });
         }

package/lib/strapi/register.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+"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/constants.d.ts

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

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/runner/connect';
+exports.TRANSFER_PATH = '/transfer';
 exports.TRANSFER_METHODS = ['push', 'pull'];
 //# sourceMappingURL=constants.js.map

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

@@ -1,10 +1,3 @@
 import type { Context } from 'koa';
 import type { ServerOptions } from 'ws';
-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 {};
+export declare const createTransferHandler: (options?: ServerOptions) => (ctx: Context) => Promise<void>;

package/lib/strapi/remote/handlers.js

@@ -9,191 +9,185 @@ 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) => {
-    const { verify, server: serverOptions } = options;
+const createTransferHandler = (options = {}) => async (ctx) => {
+    const upgradeHeader = (ctx.request.headers.upgrade || '')
+        .split(',')
+        .map((s) => s.trim().toLowerCase());
     // Create the websocket server
-    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()));
-                    });
-                };
-                /**
-                 * 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 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 { 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,
-                        });
+                    const payload = JSON.stringify({
+                        uuid,
+                        data: data ?? null,
+                        error: e
+                            ? {
+                                code: 'ERR',
+                                message: e?.message,
+                            }
+                            : null,
+                    });
+                    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));
                     }
-                    // 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'],
+                        callback(new providers_1.ProviderTransferError('Unexpected error', {
+                            error: e,
                         }));
                     }
-                };
-                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'));
+                }
+            };
+            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),
+                        }));
                     }
-                });
+                    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'));
+                }
             });
-            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.handlers = exports.constants = exports.controllers = void 0;
+exports.constants = exports.routes = 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/strapi/remote/routes.d.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,22 @@
+"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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/data-transfer",
-  "version": "4.7.0-beta.0",
+  "version": "4.9.0-alpha.0",
   "description": "Data transfer capabilities for Strapi",
   "keywords": [
     "strapi",
@@ -39,8 +39,8 @@
     "lib": "./lib"
   },
   "dependencies": {
-    "@strapi/logger": "4.7.0-beta.0",
-    "@strapi/strapi": "4.7.0-beta.0",
+    "@strapi/logger": "4.9.0-alpha.0",
+    "@strapi/strapi": "4.9.0-alpha.0",
     "chalk": "4.1.2",
     "fs-extra": "10.0.0",
     "lodash": "4.17.21",
@@ -73,5 +73,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "880ba7af867ad43c4cc45b47467b76a9b5606b6e"
+  "gitHead": "35f783d0dc07db101e7e62cb4d682f751551f452"
 }