@strapi/data-transfer 4.6.2 → 4.7.0-exp.117579f4c13806c2cd518e7d7d2f9d0c8a20107d

package/lib/strapi/remote/flows/default.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [
+    {
+        kind: 'action',
+        action: 'bootstrap',
+    },
+    {
+        kind: 'action',
+        action: 'init',
+    },
+    {
+        kind: 'action',
+        action: 'beforeTransfer',
+    },
+    {
+        kind: 'transfer',
+        stage: 'schemas',
+    },
+    {
+        kind: 'transfer',
+        stage: 'entities',
+    },
+    {
+        kind: 'transfer',
+        stage: 'assets',
+    },
+    {
+        kind: 'transfer',
+        stage: 'links',
+    },
+    {
+        kind: 'transfer',
+        stage: 'configuration',
+    },
+    {
+        kind: 'action',
+        action: 'close',
+    },
+];
+//# sourceMappingURL=default.js.map

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

@@ -0,0 +1,18 @@
+import type { TransferStage } from '../../../../types';
+export declare type Step = {
+    kind: 'action';
+    action: string;
+} | {
+    kind: 'transfer';
+    stage: TransferStage;
+    locked?: boolean;
+};
+export { default as DEFAULT_TRANSFER_FLOW } from './default';
+export declare const createFlow: (flow: readonly Step[]) => {
+    has(step: Step): boolean;
+    can(step: Step): boolean;
+    cannot(step: Step): boolean;
+    set(step: Step): any;
+    get(): Step | null;
+};
+export declare type TransferFlow = ReturnType<typeof createFlow>;

package/lib/strapi/remote/flows/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFlow = exports.DEFAULT_TRANSFER_FLOW = void 0;
+var default_1 = require("./default");
+Object.defineProperty(exports, "DEFAULT_TRANSFER_FLOW", { enumerable: true, get: function () { return __importDefault(default_1).default; } });
+const createFlow = (flow) => {
+    const state = { step: null };
+    /**
+     * Equality check between two steps
+     */
+    const stepEqual = (stepA, stepB) => {
+        if (stepA.kind === 'action' && stepB.kind === 'action') {
+            return stepA.action === stepB.action;
+        }
+        if (stepA.kind === 'transfer' && stepB.kind === 'transfer') {
+            return stepA.stage === stepB.stage;
+        }
+        return false;
+    };
+    /**
+     * Find the index for a given step
+     */
+    const findStepIndex = (step) => flow.findIndex((flowStep) => stepEqual(step, flowStep));
+    return {
+        has(step) {
+            return findStepIndex(step) !== -1;
+        },
+        can(step) {
+            if (state.step === null) {
+                return true;
+            }
+            const indexesDifference = findStepIndex(step) - findStepIndex(state.step);
+            // It's possible to send multiple time the same transfer step in a row
+            if (indexesDifference === 0 && step.kind === 'transfer') {
+                return true;
+            }
+            return indexesDifference > 0;
+        },
+        cannot(step) {
+            return !this.can(step);
+        },
+        set(step) {
+            const canSwitch = this.can(step);
+            if (!canSwitch) {
+                throw new Error('Impossible to proceed to the given step');
+            }
+            state.step = step;
+            return this;
+        },
+        get() {
+            return state.step;
+        },
+    };
+};
+exports.createFlow = createFlow;
+//# sourceMappingURL=index.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,277 @@ 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 flows_1 = require("./flows");
+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,
-                    });
-                    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);
+    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;
+                function assertValidTransfer(transferState) {
+                    const { transfer, controller } = transferState;
+                    if (!controller || !transfer) {
+                        throw new providers_1.ProviderTransferError('Invalid transfer process');
+                    }
                 }
-                catch (e) {
-                    if (e instanceof Error) {
-                        callback(e);
+                /**
+                 * 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 cleanup = () => {
+                    delete state.controller;
+                    delete state.transfer;
+                };
+                const teardown = async () => {
+                    if (state.controller) {
+                        await state.controller.actions.rollback();
                     }
-                    else if (typeof e === 'string') {
-                        callback(new providers_1.ProviderTransferError(e));
+                    cleanup();
+                };
+                const end = async (msg) => {
+                    await verifyAuth(state.transfer?.kind);
+                    if (msg.params.transferID !== state.transfer?.id) {
+                        throw new providers_1.ProviderTransferError('Bad transfer ID provided');
                     }
+                    cleanup();
+                    return { ok: true };
+                };
+                const init = async (msg) => {
+                    // TODO: For push transfer, we'll probably have to trigger a
+                    // maintenance mode to prevent other transfer at the same time.
+                    if (state.transfer || 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),
-                        }));
-                    }
-                    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);
+                    state.transfer = {
+                        id: (0, crypto_1.randomUUID)(),
+                        kind: transfer,
+                        startedAt: Date.now(),
+                        flow: (0, flows_1.createFlow)(flows_1.DEFAULT_TRANSFER_FLOW),
+                    };
+                    return { transferID: state.transfer.id };
+                };
+                const status = () => {
+                    if (state.transfer) {
+                        const { transfer } = state;
+                        const elapsed = Date.now() - transfer.startedAt;
+                        return {
+                            active: true,
+                            kind: transfer.kind,
+                            startedAt: transfer.startedAt,
+                            elapsed,
+                        };
                     }
-                }
-            };
-            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'));
-                }
+                    return { active: false, kind: null, elapsed: null, startedAt: null };
+                };
+                /**
+                 * 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(() => {
+                            assertValidTransfer(state);
+                            end(msg);
+                        });
+                    }
+                    if (command === 'status') {
+                        await answer(status);
+                    }
+                };
+                const onTransferCommand = async (msg) => {
+                    assertValidTransfer(state);
+                    const { transferID, kind } = msg;
+                    const { controller, transfer } = state;
+                    await verifyAuth(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 (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),
+                            }));
+                        }
+                        const step = { kind: 'action', action };
+                        const isStepRegistered = transfer.flow.has(step);
+                        if (isStepRegistered) {
+                            if (transfer.flow.cannot(step)) {
+                                return callback(new providers_1.ProviderTransferError(`Invalid action "${action}" found for the current flow `, {
+                                    action,
+                                }));
+                            }
+                            transfer.flow.set(step);
+                        }
+                        await answer(() => controller.actions[action]());
+                    }
+                    // Transfer
+                    else if (kind === 'step') {
+                        // We can only have push transfer message for the moment
+                        const message = msg;
+                        const currentStep = transfer.flow.get();
+                        const step = { kind: 'transfer', stage: message.step };
+                        // Lock the current transfer stage
+                        if (message.action === 'start') {
+                            if (currentStep?.kind === 'transfer' && currentStep.locked) {
+                                return callback(new providers_1.ProviderTransferError(`It's not possible to start a new transfer stage (${message.step}) while another one is in progress (${currentStep.stage})`));
+                            }
+                            if (transfer.flow.cannot(step)) {
+                                return callback(new providers_1.ProviderTransferError(`Invalid stage (${message.step}) provided for the current flow`, { step }));
+                            }
+                            transfer?.flow.set({ ...step, locked: true });
+                            return callback(null, { ok: true });
+                        }
+                        // Stream operation on the current transfer stage
+                        if (message.action === 'stream') {
+                            if (currentStep?.kind === 'transfer' && !currentStep.locked) {
+                                return callback(new providers_1.ProviderTransferError(`You need to initialize the transfer stage (${message.step}) before starting to stream data`));
+                            }
+                            if (transfer?.flow.cannot(step)) {
+                                return callback(new providers_1.ProviderTransferError(`Invalid stage (${message.step}) provided for the current flow`, { step }));
+                            }
+                            await answer(() => controller.transfer[message.step]?.(message.data));
+                        }
+                        // Unlock the current transfer stage
+                        if (message.action === 'end') {
+                            // Cannot unlock if not locked (aka: started)
+                            if (currentStep?.kind === 'transfer' && !currentStep.locked) {
+                                return callback(new providers_1.ProviderTransferError(`You need to initialize the transfer stage (${message.step}) before ending it`));
+                            }
+                            // Cannot unlock if invalid step provided
+                            if (transfer?.flow.cannot(step)) {
+                                return callback(new providers_1.ProviderTransferError(`Invalid stage (${message.step}) provided for the current flow`, { step }));
+                            }
+                            transfer?.flow.set({ ...step, locked: false });
+                            return callback(null, { ok: true });
+                        }
+                    }
+                };
+                ws.on('close', async () => {
+                    await teardown();
+                });
+                ws.on('error', async (e) => {
+                    await teardown();
+                    strapi.log.error(e);
+                });
+                ws.on('message', async (raw) => {
+                    try {
+                        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'));
+                        }
+                    }
+                    catch (e) {
+                        // Only known errors should be returned to client
+                        if (e instanceof providers_1.ProviderError || e instanceof SyntaxError) {
+                            await callback(e);
+                        }
+                        else {
+                            // TODO: log error to server?
+                            // Unknown errors should not be sent to client
+                            await callback(new providers_1.ProviderTransferError('Unknown transfer error'));
+                        }
+                    }
+                });
             });
-        });
-        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/transaction.js

@@ -13,12 +13,26 @@ const createTransaction = (strapi) => {
         resume?.();
     });
     e.on('close', () => {
+        e.removeAllListeners('rollback');
+        e.removeAllListeners('spawn');
         done = true;
         resume?.();
     });
     strapi.db.transaction(async ({ trx, rollback }) => {
-        e.on('rollback', async () => {
-            await rollback();
+        e.once('rollback', async () => {
+            e.removeAllListeners('close');
+            e.removeAllListeners('spawn');
+            try {
+                await rollback();
+                e.emit('rollback_completed');
+            }
+            catch {
+                e.emit('rollback_failed');
+            }
+            finally {
+                done = true;
+                resume?.();
+            }
         });
         while (!done) {
             while (fns.length) {
@@ -62,7 +76,11 @@ const createTransaction = (strapi) => {
             return e.emit('close');
         },
         rollback() {
-            return e.emit('rollback');
+            return new Promise((resolve) => {
+                e.emit('rollback');
+                e.once('rollback_failed', () => resolve(false));
+                e.once('rollback_completed', () => resolve(true));
+            });
         },
     };
 };