@strapi/data-transfer 4.8.2 → 4.9.0-beta.1

package/lib/engine/index.d.ts

@@ -22,6 +22,7 @@ declare class TransferEngine<S extends ISourceProvider = ISourceProvider, D exte
     diagnostics: IDiagnosticReporter;
     constructor(sourceProvider: S, destinationProvider: D, options: ITransferEngineOptions);
     shouldSkipStage(stage: TransferStage): boolean;
+    abortTransfer(): Promise<void>;
     init(): Promise<void>;
     /**
      * Run the bootstrap method in both source and destination providers

package/lib/engine/index.js

@@ -27,7 +27,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _TransferEngine_instances, _TransferEngine_metadata, _TransferEngine_panic, _TransferEngine_reportError, _TransferEngine_reportWarning, _TransferEngine_reportInfo, _TransferEngine_createStageTransformStream, _TransferEngine_updateTransferProgress, _TransferEngine_progressTracker, _TransferEngine_emitTransferUpdate, _TransferEngine_emitStageUpdate, _TransferEngine_assertStrapiVersionIntegrity, _TransferEngine_assertSchemasMatching, _TransferEngine_transferStage, _TransferEngine_resolveProviderResource;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _TransferEngine_instances, _TransferEngine_metadata, _TransferEngine_currentStream, _TransferEngine_panic, _TransferEngine_reportError, _TransferEngine_reportWarning, _TransferEngine_reportInfo, _TransferEngine_createStageTransformStream, _TransferEngine_updateTransferProgress, _TransferEngine_progressTracker, _TransferEngine_emitTransferUpdate, _TransferEngine_emitStageUpdate, _TransferEngine_assertStrapiVersionIntegrity, _TransferEngine_assertSchemasMatching, _TransferEngine_transferStage, _TransferEngine_resolveProviderResource;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errors = exports.createTransferEngine = exports.DEFAULT_SCHEMA_STRATEGY = exports.DEFAULT_VERSION_STRATEGY = exports.TransferGroupPresets = exports.TRANSFER_STAGES = void 0;
 const stream_1 = require("stream");
@@ -77,6 +83,8 @@ class TransferEngine {
     constructor(sourceProvider, destinationProvider, options) {
         _TransferEngine_instances.add(this);
         _TransferEngine_metadata.set(this, {});
+        // Save the currently open stream so that we can access it at any time
+        _TransferEngine_currentStream.set(this, void 0);
         this.diagnostics = (0, diagnostic_1.createDiagnosticReporter)();
         (0, validation_1.validateProvider)('source', sourceProvider);
         (0, validation_1.validateProvider)('destination', destinationProvider);
@@ -107,6 +115,10 @@ class TransferEngine {
         }
         return !included;
     }
+    // Cause an ongoing transfer to abort gracefully
+    async abortTransfer() {
+        __classPrivateFieldGet(this, _TransferEngine_currentStream, "f")?.destroy(new errors_1.TransferEngineError('fatal', 'Transfer aborted.'));
+    }
     async init() {
         // Resolve providers' resource and store
         // them in the engine's internal state
@@ -266,7 +278,7 @@ class TransferEngine {
         await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
     }
 }
-_TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_panic = function _TransferEngine_panic(error) {
+_TransferEngine_metadata = new WeakMap(), _TransferEngine_currentStream = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_panic = function _TransferEngine_panic(error) {
     __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_reportError).call(this, error, 'fatal');
     throw error;
 }, _TransferEngine_reportError = function _TransferEngine_reportError(error, severity) {
@@ -292,6 +304,7 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     });
 }, _TransferEngine_createStageTransformStream = function _TransferEngine_createStageTransformStream(key, options = {}) {
     const { includeGlobal = true } = options;
+    const { throttle } = this.options;
     const { global: globalTransforms, [key]: stageTransforms } = this.options?.transforms ?? {};
     let stream = new stream_1.PassThrough({ objectMode: true });
     const applyTransforms = (transforms = []) => {
@@ -307,6 +320,17 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     if (includeGlobal) {
         applyTransforms(globalTransforms);
     }
+    if ((0, fp_1.isNumber)(throttle) && throttle > 0) {
+        stream = stream.pipe(new stream_1.PassThrough({
+            objectMode: true,
+            async transform(data, _encoding, callback) {
+                await new Promise((resolve) => {
+                    setTimeout(resolve, throttle);
+                });
+                callback(null, data);
+            },
+        }));
+    }
     applyTransforms(stageTransforms);
     return stream;
 }, _TransferEngine_updateTransferProgress = function _TransferEngine_updateTransferProgress(stage, data, aggregate) {
@@ -474,18 +498,20 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
         if (tracker) {
             stream = stream.pipe(tracker);
         }
-        stream
+        __classPrivateFieldSet(this, _TransferEngine_currentStream, stream
             .pipe(destination)
             .on('error', (e) => {
             updateEndTime();
+            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'error', stage);
             __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_reportError).call(this, e, 'error');
             destination.destroy(e);
             reject(e);
         })
             .on('close', () => {
+            __classPrivateFieldSet(this, _TransferEngine_currentStream, undefined, "f");
             updateEndTime();
             resolve();
-        });
+        }), "f");
     });
     __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'finish', stage);
 }, _TransferEngine_resolveProviderResource = async function _TransferEngine_resolveProviderResource() {

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

@@ -1,3 +1,4 @@
 export * from './local-destination';
 export * from './local-source';
 export * from './remote-destination';
+export * from './remote-source';

package/lib/strapi/providers/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./local-destination"), exports);
 __exportStar(require("./local-source"), exports);
 // Remote
 __exportStar(require("./remote-destination"), exports);
+__exportStar(require("./remote-source"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { WebSocket } from 'ws';
 import { Writable } from 'stream';
-import { createDispatcher } from './utils';
+import { createDispatcher } from '../utils';
 import type { IDestinationProvider, IMetadata, ProviderType } from '../../../../types';
 import type { ILocalStrapiDestinationProviderOptions } from '../local-destination';
 interface ITransferTokenAuth {

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

@@ -11,7 +11,7 @@ const ws_1 = require("ws");
 const uuid_1 = require("uuid");
 const stream_1 = require("stream");
 const fp_1 = require("lodash/fp");
-const utils_1 = require("./utils");
+const utils_1 = require("../utils");
 const constants_1 = require("../../remote/constants");
 const providers_1 = require("../../../errors/providers");
 const jsonLength = (obj) => Buffer.byteLength(JSON.stringify(obj));
@@ -34,7 +34,7 @@ class RemoteStrapiDestinationProvider {
                 try {
                     const query = this.dispatcher?.dispatchCommand({
                         command: 'init',
-                        params: { options: { strategy, restore }, transfer: 'push' },
+                        params: { strategy, restore },
                     });
                     const res = (await query);
                     if (!res?.transferID) {
@@ -65,7 +65,7 @@ class RemoteStrapiDestinationProvider {
             });
         }
         const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-        const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}`;
+        const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}/push`;
         // No auth defined, trying public access for transfer
         if (!auth) {
             ws = new ws_1.WebSocket(wsUrl);

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

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { WebSocket } from 'ws';
+import type { IMetadata, ISourceProvider, ISourceProviderTransferResults, MaybePromise, ProviderType } from '../../../../types';
+import { ILocalStrapiSourceProviderOptions } from '../local-source';
+import { createDispatcher } from '../utils';
+interface ITransferTokenAuth {
+    type: 'token';
+    token: string;
+}
+export interface IRemoteStrapiSourceProviderOptions extends ILocalStrapiSourceProviderOptions {
+    url: URL;
+    auth?: ITransferTokenAuth;
+}
+declare class RemoteStrapiSourceProvider implements ISourceProvider {
+    #private;
+    name: string;
+    type: ProviderType;
+    options: IRemoteStrapiSourceProviderOptions;
+    ws: WebSocket | null;
+    dispatcher: ReturnType<typeof createDispatcher> | null;
+    constructor(options: IRemoteStrapiSourceProviderOptions);
+    results?: ISourceProviderTransferResults | undefined;
+    createEntitiesReadStream(): MaybePromise<Readable>;
+    createLinksReadStream(): MaybePromise<Readable>;
+    createAssetsReadStream(): Promise<Readable>;
+    createConfigurationReadStream(): MaybePromise<Readable>;
+    getMetadata(): Promise<IMetadata | null>;
+    assertValidProtocol(url: URL): void;
+    initTransfer(): Promise<string>;
+    bootstrap(): Promise<void>;
+    close(): Promise<void>;
+    getSchemas(): Promise<Strapi.Schemas | null>;
+}
+export declare const createRemoteStrapiSourceProvider: (options: IRemoteStrapiSourceProviderOptions) => RemoteStrapiSourceProvider;
+export {};

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

@@ -0,0 +1,228 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RemoteStrapiSourceProvider_instances, _RemoteStrapiSourceProvider_createStageReadStream, _RemoteStrapiSourceProvider_startStep, _RemoteStrapiSourceProvider_respond, _RemoteStrapiSourceProvider_endStep;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemoteStrapiSourceProvider = void 0;
+const stream_1 = require("stream");
+const ws_1 = require("ws");
+const providers_1 = require("../../../errors/providers");
+const constants_1 = require("../../remote/constants");
+const utils_1 = require("../utils");
+class RemoteStrapiSourceProvider {
+    constructor(options) {
+        _RemoteStrapiSourceProvider_instances.add(this);
+        this.name = 'source::remote-strapi';
+        this.type = 'source';
+        this.options = options;
+        this.ws = null;
+        this.dispatcher = null;
+    }
+    createEntitiesReadStream() {
+        return __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_createStageReadStream).call(this, 'entities');
+    }
+    createLinksReadStream() {
+        return __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_createStageReadStream).call(this, 'links');
+    }
+    async createAssetsReadStream() {
+        const assets = {};
+        const stream = await __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_createStageReadStream).call(this, 'assets');
+        const pass = new stream_1.PassThrough({ objectMode: true });
+        stream
+            .on('data', (asset) => {
+            const { chunk, ...rest } = asset;
+            if (!(asset.filename in assets)) {
+                const assetStream = new stream_1.PassThrough();
+                assets[asset.filename] = assetStream;
+                pass.push({ ...rest, stream: assetStream });
+            }
+            if (asset.filename in assets) {
+                // The buffer has gone through JSON operations and is now of shape { type: "Buffer"; data: UInt8Array }
+                // We need to transform it back into a Buffer instance
+                assets[asset.filename].push(Buffer.from(chunk.data));
+            }
+        })
+            .on('end', () => {
+            Object.values(assets).forEach((s) => {
+                s.push(null);
+            });
+        })
+            .on('close', () => {
+            pass.end();
+        });
+        return pass;
+    }
+    createConfigurationReadStream() {
+        return __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_createStageReadStream).call(this, 'configuration');
+    }
+    async getMetadata() {
+        const metadata = await this.dispatcher?.dispatchTransferAction('getMetadata');
+        return metadata ?? null;
+    }
+    assertValidProtocol(url) {
+        const validProtocols = ['https:', 'http:'];
+        if (!validProtocols.includes(url.protocol)) {
+            throw new providers_1.ProviderValidationError(`Invalid protocol "${url.protocol}"`, {
+                check: 'url',
+                details: {
+                    protocol: url.protocol,
+                    validProtocols,
+                },
+            });
+        }
+    }
+    async initTransfer() {
+        return new Promise((resolve, reject) => {
+            this.ws
+                ?.on('unexpected-response', (_req, res) => {
+                if (res.statusCode === 401) {
+                    return reject(new providers_1.ProviderInitializationError('Failed to initialize the connexion: Authentication Error'));
+                }
+                if (res.statusCode === 403) {
+                    return reject(new providers_1.ProviderInitializationError('Failed to initialize the connexion: Authorization Error'));
+                }
+                if (res.statusCode === 404) {
+                    return reject(new providers_1.ProviderInitializationError('Failed to initialize the connexion: Data transfer is not enabled on the remote host'));
+                }
+                return reject(new providers_1.ProviderInitializationError(`Failed to initialize the connexion: Unexpected server response ${res.statusCode}`));
+            })
+                ?.once('open', async () => {
+                const query = this.dispatcher?.dispatchCommand({
+                    command: 'init',
+                });
+                const res = (await query);
+                if (!res?.transferID) {
+                    return reject(new providers_1.ProviderTransferError('Init failed, invalid response from the server'));
+                }
+                resolve(res.transferID);
+            })
+                .once('error', reject);
+        });
+    }
+    async bootstrap() {
+        const { url, auth } = this.options;
+        let ws;
+        this.assertValidProtocol(url);
+        const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+        const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}/pull`;
+        // No auth defined, trying public access for transfer
+        if (!auth) {
+            ws = new ws_1.WebSocket(wsUrl);
+        }
+        // Common token auth, this should be the main auth method
+        else if (auth.type === 'token') {
+            const headers = { Authorization: `Bearer ${auth.token}` };
+            ws = new ws_1.WebSocket(wsUrl, { headers });
+        }
+        // Invalid auth method provided
+        else {
+            throw new providers_1.ProviderValidationError('Auth method not available', {
+                check: 'auth.type',
+                details: {
+                    auth: auth.type,
+                },
+            });
+        }
+        this.ws = ws;
+        this.dispatcher = (0, utils_1.createDispatcher)(this.ws);
+        const transferID = await this.initTransfer();
+        this.dispatcher.setTransferProperties({ id: transferID, kind: 'pull' });
+        await this.dispatcher.dispatchTransferAction('bootstrap');
+    }
+    async close() {
+        await this.dispatcher?.dispatchTransferAction('close');
+        await new Promise((resolve) => {
+            const { ws } = this;
+            if (!ws || ws.CLOSED) {
+                resolve();
+                return;
+            }
+            ws.on('close', () => resolve()).close();
+        });
+    }
+    async getSchemas() {
+        const schemas = (await this.dispatcher?.dispatchTransferAction('getSchemas')) ?? null;
+        return schemas;
+    }
+}
+_RemoteStrapiSourceProvider_instances = new WeakSet(), _RemoteStrapiSourceProvider_createStageReadStream = async function _RemoteStrapiSourceProvider_createStageReadStream(stage) {
+    const startResult = await __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_startStep).call(this, stage);
+    if (startResult instanceof Error) {
+        throw startResult;
+    }
+    const { id: processID } = startResult;
+    const stream = new stream_1.PassThrough({ objectMode: true });
+    const listener = async (raw) => {
+        const parsed = JSON.parse(raw.toString());
+        // If not a message related to our transfer process, ignore it
+        if (!parsed.uuid || parsed?.data?.type !== 'transfer' || parsed?.data?.id !== processID) {
+            this.ws?.once('message', listener);
+            return;
+        }
+        const { uuid, data: message } = parsed;
+        const { ended, error, data } = message;
+        if (ended) {
+            await __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_respond).call(this, uuid);
+            await __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_endStep).call(this, stage);
+            stream.end();
+            return;
+        }
+        if (error) {
+            await __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_respond).call(this, uuid);
+            await __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_endStep).call(this, stage);
+            stream.destroy(error);
+            return;
+        }
+        stream.push(data);
+        this.ws?.once('message', listener);
+        await __classPrivateFieldGet(this, _RemoteStrapiSourceProvider_instances, "m", _RemoteStrapiSourceProvider_respond).call(this, uuid);
+    };
+    this.ws?.once('message', listener);
+    return stream;
+}, _RemoteStrapiSourceProvider_startStep = async function _RemoteStrapiSourceProvider_startStep(step) {
+    try {
+        return await this.dispatcher?.dispatchTransferStep({ action: 'start', step });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return e;
+        }
+        if (typeof e === 'string') {
+            return new providers_1.ProviderTransferError(e);
+        }
+        return new providers_1.ProviderTransferError('Unexpected error');
+    }
+}, _RemoteStrapiSourceProvider_respond = async function _RemoteStrapiSourceProvider_respond(uuid) {
+    return new Promise((resolve, reject) => {
+        this.ws?.send(JSON.stringify({ uuid }), (e) => {
+            if (e) {
+                reject(e);
+            }
+            else {
+                resolve(e);
+            }
+        });
+    });
+}, _RemoteStrapiSourceProvider_endStep = async function _RemoteStrapiSourceProvider_endStep(step) {
+    try {
+        await this.dispatcher?.dispatchTransferStep({ action: 'end', step });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return e;
+        }
+        if (typeof e === 'string') {
+            return new providers_1.ProviderTransferError(e);
+        }
+        return new providers_1.ProviderTransferError('Unexpected error');
+    }
+    return null;
+};
+const createRemoteStrapiSourceProvider = (options) => {
+    return new RemoteStrapiSourceProvider(options);
+};
+exports.createRemoteStrapiSourceProvider = createRemoteStrapiSourceProvider;
+//# sourceMappingURL=index.js.map

package/lib/strapi/providers/{remote-destination/utils.d.ts → utils.d.ts}

@@ -1,5 +1,5 @@
 import { WebSocket } from 'ws';
-import type { client } from '../../../../types/remote/protocol';
+import type { client } from '../../../types/remote/protocol';
 interface IDispatcherState {
     transfer?: {
         kind: client.TransferKind;
@@ -12,13 +12,13 @@ interface IDispatchOptions {
 declare type Dispatch<T> = Omit<T, 'transferID' | 'uuid'>;
 declare const createDispatcher: (ws: WebSocket) => {
     readonly transferID: string | undefined;
-    readonly transferKind: "push" | "pull" | undefined;
+    readonly transferKind: any;
     setTransferProperties: (properties: Exclude<IDispatcherState['transfer'], undefined>) => void;
     dispatch: <U = null>(message: Dispatch<client.Message>, options?: IDispatchOptions) => Promise<U | null>;
     dispatchCommand: <U_1 extends "end" | "init" | "status">(payload: {
         command: U_1;
     } & ([client.GetCommandParams<U_1>] extends [never] ? unknown : {
-        params: client.GetCommandParams<U_1>;
+        params?: client.GetCommandParams<U_1> | undefined;
     })) => Promise<null>;
     dispatchTransferAction: <T>(action: client.Action['action']) => Promise<T | null>;
     dispatchTransferStep: <T_1, A extends "stream" | "end" | "start" = "stream" | "end" | "start", S extends "entities" | "links" | "configuration" | "assets" = "entities" | "links" | "configuration" | "assets">(payload: {

package/lib/strapi/providers/{remote-destination/utils.js → utils.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDispatcher = void 0;
 const uuid_1 = require("uuid");
-const providers_1 = require("../../../errors/providers");
+const providers_1 = require("../../errors/providers");
 const createDispatcher = (ws) => {
     const state = {};
     const dispatch = async (message, options = {}) => {

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

@@ -1,2 +1,4 @@
-export declare const TRANSFER_PATH: "/transfer/runner/connect";
+export declare const TRANSFER_PATH: "/transfer/runner";
 export declare const TRANSFER_METHODS: readonly ["push", "pull"];
+export declare type TransferPath = typeof TRANSFER_PATH;
+export declare type TransferMethod = (typeof TRANSFER_METHODS)[number];

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

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

@@ -8,11 +8,11 @@ export declare type Step = {
     locked?: boolean;
 };
 export { default as DEFAULT_TRANSFER_FLOW } from './default';
-export declare const createFlow: (flow: readonly Step[]) => {
+export interface TransferFlow {
     has(step: Step): boolean;
     can(step: Step): boolean;
     cannot(step: Step): boolean;
-    set(step: Step): any;
+    set(step: Step): this;
     get(): Step | null;
-};
-export declare type TransferFlow = ReturnType<typeof createFlow>;
+}
+export declare const createFlow: (flow: readonly Step[]) => TransferFlow;

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

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import type { WebSocket, RawData } from 'ws';
+import type { ValidTransferCommand } from './constants';
+import type { TransferMethod } from '../constants';
+declare type BufferLike = Parameters<WebSocket['send']>[0];
+export interface TransferState {
+    id?: string;
+    startedAt?: number;
+}
+export interface Handler {
+    get transferID(): TransferState['id'];
+    set transferID(id: TransferState['id']);
+    get startedAt(): TransferState['startedAt'];
+    set startedAt(id: TransferState['startedAt']);
+    /**
+     * Returns whether a transfer is currently in progress or not
+     */
+    isTransferStarted(): boolean;
+    /**
+     * Make sure the current transfer is started and initialized
+     */
+    assertValidTransfer(): void;
+    /**
+     * Checks that the given string is a valid transfer command
+     */
+    assertValidTransferCommand(command: string): asserts command is ValidTransferCommand;
+    /**
+     * Respond to a specific message
+     */
+    respond<T = unknown>(uuid?: string, e?: Error | null, data?: T): Promise<void>;
+    /**
+     * It sends a message to the client
+     */
+    send<T extends BufferLike>(message: T, cb?: (err?: Error) => void): void;
+    /**
+     * It sends a message to the client and waits for a confirmation
+     */
+    confirm<T = unknown>(message: T): Promise<void>;
+    /**
+     * Check the current auth has the permission for the given scope
+     */
+    verifyAuth(scope?: TransferMethod): Promise<void>;
+    /**
+     * Invoke a function and return its result to the client
+     */
+    executeAndRespond<T = unknown>(uuid: string, fn: () => T): Promise<void>;
+    /**
+     * Lifecycle called on error or when the ws connection is closed
+     */
+    teardown(): Promise<void> | void;
+    /**
+     * Lifecycle called to cleanup the transfer state
+     */
+    cleanup(): Promise<void> | void;
+    init(...args: unknown[]): unknown;
+    end(...args: unknown[]): unknown;
+    status(...args: unknown[]): unknown;
+    onMessage(message: RawData, isBinary: boolean): Promise<void> | void;
+    onClose(code: number, reason: Buffer): Promise<void> | void;
+    onError(err: Error): Promise<void> | void;
+}
+export {};

package/lib/strapi/remote/handlers/abstract.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=abstract.js.map

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

@@ -0,0 +1,2 @@
+export declare const VALID_TRANSFER_COMMANDS: readonly ["init", "end", "status"];
+export declare type ValidTransferCommand = (typeof VALID_TRANSFER_COMMANDS)[number];

package/lib/strapi/remote/handlers/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_TRANSFER_COMMANDS = void 0;
+exports.VALID_TRANSFER_COMMANDS = ['init', 'end', 'status'];
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,3 @@
+export { createPushController, PushHandler } from './push';
+export { createPullController, PullHandler } from './pull';
+export { handlerControllerFactory, HandlerOptions } from './utils';

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlerControllerFactory = exports.createPullController = exports.createPushController = void 0;
+var push_1 = require("./push");
+Object.defineProperty(exports, "createPushController", { enumerable: true, get: function () { return push_1.createPushController; } });
+var pull_1 = require("./pull");
+Object.defineProperty(exports, "createPullController", { enumerable: true, get: function () { return pull_1.createPullController; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "handlerControllerFactory", { enumerable: true, get: function () { return utils_1.handlerControllerFactory; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="koa" />
+import { Readable } from 'stream';
+import { Handler } from './abstract';
+import { ILocalStrapiSourceProvider } from '../../providers';
+import type { TransferStage, Protocol } from '../../../../types';
+declare const VALID_TRANSFER_ACTIONS: readonly ["bootstrap", "close", "getMetadata", "getSchemas"];
+declare type PullTransferAction = (typeof VALID_TRANSFER_ACTIONS)[number];
+export interface PullHandler extends Handler {
+    provider?: ILocalStrapiSourceProvider;
+    streams?: {
+        [stage in TransferStage]?: Readable;
+    };
+    assertValidTransferAction(action: string): asserts action is PullTransferAction;
+    onTransferMessage(msg: Protocol.client.TransferMessage): Promise<unknown> | unknown;
+    onTransferAction(msg: Protocol.client.Action): Promise<unknown> | unknown;
+    onTransferStep(msg: Protocol.client.TransferPullMessage): Promise<unknown> | unknown;
+    createReadableStreamForStep(step: TransferStage): Promise<void>;
+    flush(stage: TransferStage, id: string): Promise<void> | void;
+}
+export declare const createPullController: (options: import("./utils").HandlerOptions) => (ctx: import("koa").Context) => Promise<void>;
+export {};