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

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

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlerControllerFactory = exports.handleWSUpgrade = exports.isDataTransferMessage = exports.assertValidHeader = exports.transformUpgradeHeader = void 0;
+const crypto_1 = require("crypto");
+const ws_1 = require("ws");
+const providers_1 = require("../../../errors/providers");
+const constants_1 = require("./constants");
+const transformUpgradeHeader = (header = '') => {
+    return header.split(',').map((s) => s.trim().toLowerCase());
+};
+exports.transformUpgradeHeader = transformUpgradeHeader;
+/**
+ * Make sure that the upgrade header is a valid websocket one
+ */
+const assertValidHeader = (ctx) => {
+    const upgradeHeader = (0, exports.transformUpgradeHeader)(ctx.headers.upgrade);
+    if (!upgradeHeader.includes('websocket')) {
+        throw new Error('Invalid Header');
+    }
+};
+exports.assertValidHeader = assertValidHeader;
+const isDataTransferMessage = (message) => {
+    if (!message || typeof message !== 'object') {
+        return false;
+    }
+    const { uuid, type } = message;
+    if (typeof uuid !== 'string' || typeof type !== 'string') {
+        return false;
+    }
+    if (!['command', 'transfer'].includes(type)) {
+        return false;
+    }
+    return true;
+};
+exports.isDataTransferMessage = isDataTransferMessage;
+/**
+ * Handle the upgrade to ws connection
+ */
+const handleWSUpgrade = (wss, ctx, callback) => {
+    (0, exports.assertValidHeader)(ctx);
+    wss.handleUpgrade(ctx.req, ctx.request.socket, Buffer.alloc(0), (client, request) => {
+        // Create a connection between the client & the server
+        wss.emit('connection', client, ctx.req);
+        // Invoke the ws callback
+        callback(client, request);
+    });
+    ctx.respond = false;
+};
+exports.handleWSUpgrade = handleWSUpgrade;
+// Protocol related functions
+const handlerControllerFactory = (implementation) => (options) => {
+    const { verify, server: serverOptions } = options ?? {};
+    const wss = new ws_1.WebSocket.Server({ ...serverOptions, noServer: true });
+    return async (ctx) => {
+        (0, exports.handleWSUpgrade)(wss, ctx, (ws) => {
+            const state = { id: undefined };
+            const prototype = {
+                // Transfer ID
+                get transferID() {
+                    return state.id;
+                },
+                set transferID(id) {
+                    state.id = id;
+                },
+                // Started at
+                get startedAt() {
+                    return state.startedAt;
+                },
+                set startedAt(timestamp) {
+                    state.startedAt = timestamp;
+                },
+                isTransferStarted() {
+                    return this.transferID !== undefined && this.startedAt !== undefined;
+                },
+                assertValidTransfer() {
+                    const isStarted = this.isTransferStarted();
+                    if (!isStarted) {
+                        throw new Error('Invalid Transfer Process');
+                    }
+                },
+                assertValidTransferCommand(command) {
+                    const isDefined = typeof this[command] === 'function';
+                    const isValidTransferCommand = constants_1.VALID_TRANSFER_COMMANDS.includes(command);
+                    if (!isDefined || !isValidTransferCommand) {
+                        throw new Error('Invalid transfer command');
+                    }
+                },
+                respond(uuid, e, data) {
+                    return new Promise((resolve, reject) => {
+                        if (!uuid && !e) {
+                            reject(new Error('Missing uuid for this message'));
+                            return;
+                        }
+                        const payload = JSON.stringify({
+                            uuid,
+                            data: data ?? null,
+                            error: e
+                                ? {
+                                    code: e?.name ?? 'ERR',
+                                    message: e?.message,
+                                }
+                                : null,
+                        });
+                        this.send(payload, (error) => (error ? reject(error) : resolve()));
+                    });
+                },
+                send(message, cb) {
+                    ws.send(message, cb);
+                },
+                confirm(message) {
+                    return new Promise((resolve, reject) => {
+                        const uuid = (0, crypto_1.randomUUID)();
+                        const payload = JSON.stringify({ uuid, data: message });
+                        this.send(payload, (error) => {
+                            if (error) {
+                                reject(error);
+                            }
+                        });
+                        const onResponse = (raw) => {
+                            const response = JSON.parse(raw.toString());
+                            if (response.uuid === uuid) {
+                                if (response.error) {
+                                    return reject(new Error(response.error.message));
+                                }
+                                resolve(response.data ?? null);
+                            }
+                            else {
+                                ws.once('message', onResponse);
+                            }
+                        };
+                        ws.once('message', onResponse);
+                    });
+                },
+                async executeAndRespond(uuid, fn) {
+                    try {
+                        const response = await fn();
+                        this.respond(uuid, null, response);
+                    }
+                    catch (e) {
+                        if (e instanceof Error) {
+                            this.respond(uuid, e);
+                        }
+                        else if (typeof e === 'string') {
+                            this.respond(uuid, new providers_1.ProviderTransferError(e));
+                        }
+                        else {
+                            this.respond(uuid, new providers_1.ProviderTransferError('Unexpected error', {
+                                error: e,
+                            }));
+                        }
+                    }
+                },
+                cleanup() {
+                    this.transferID = undefined;
+                    this.startedAt = undefined;
+                },
+                teardown() {
+                    this.cleanup();
+                },
+                verifyAuth(scope) {
+                    return verify(ctx, scope);
+                },
+                // Transfer commands
+                init() { },
+                end() { },
+                status() { },
+                // Default prototype implementation for events
+                onMessage() { },
+                onError() { },
+                onClose() { },
+            };
+            const handler = Object.assign(Object.create(prototype), implementation(prototype));
+            // Bind ws events to handler methods
+            ws.on('close', (...args) => handler.onClose(...args));
+            ws.on('error', (...args) => handler.onError(...args));
+            ws.on('message', (...args) => handler.onMessage(...args));
+        });
+    };
+};
+exports.handlerControllerFactory = handlerControllerFactory;
+//# sourceMappingURL=utils.js.map

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

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

package/lib/strapi/remote/index.js

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

package/package.json

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

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

@@ -1 +0,0 @@
-export * from './push';

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

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./push"), exports);
-//# sourceMappingURL=index.js.map

package/lib/strapi/remote/controllers/push.d.ts

@@ -1,26 +0,0 @@
-/// <reference types="node" />
-import { Writable } from 'stream-chain';
-import type { IMetadata } from '../../../../types';
-import type { TransferPushMessage, TransferPushStep } from '../../../../types/remote/protocol/client';
-import { ILocalStrapiDestinationProviderOptions } from '../../providers';
-export interface IPushController {
-    streams: {
-        [stage in TransferPushStep]?: Writable;
-    };
-    actions: {
-        getMetadata(): Promise<IMetadata>;
-        getSchemas(): Strapi.Schemas;
-        bootstrap(): Promise<void>;
-        close(): Promise<void>;
-        beforeTransfer(): Promise<void>;
-        rollback(): Promise<void>;
-    };
-    transfer: {
-        [key in TransferPushStep]: <T extends TransferPushMessage>(value: T extends {
-            step: key;
-            data: infer U;
-        } ? U : never) => Promise<void>;
-    };
-}
-declare const createPushController: (options: ILocalStrapiDestinationProviderOptions) => IPushController;
-export default createPushController;

package/lib/strapi/remote/controllers/push.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_chain_1 = require("stream-chain");
-const providers_1 = require("../../providers");
-const createPushController = (options) => {
-    const provider = (0, providers_1.createLocalStrapiDestinationProvider)(options);
-    const streams = {};
-    const assets = {};
-    const writeAsync = (stream, data) => {
-        return new Promise((resolve, reject) => {
-            stream.write(data, (error) => {
-                if (error) {
-                    reject(error);
-                }
-                resolve();
-            });
-        });
-    };
-    return {
-        streams,
-        actions: {
-            async getSchemas() {
-                return provider.getSchemas();
-            },
-            async getMetadata() {
-                return provider.getMetadata();
-            },
-            async bootstrap() {
-                return provider.bootstrap();
-            },
-            async close() {
-                return provider.close();
-            },
-            async beforeTransfer() {
-                return provider.beforeTransfer();
-            },
-            async rollback() {
-                await provider.rollback();
-            },
-        },
-        transfer: {
-            async entities(entities) {
-                if (!streams.entities) {
-                    streams.entities = provider.createEntitiesWriteStream();
-                }
-                for (const entity of entities) {
-                    if (streams.entities) {
-                        await writeAsync(streams.entities, entity);
-                    }
-                }
-            },
-            async links(links) {
-                if (!streams.links) {
-                    streams.links = await provider.createLinksWriteStream();
-                }
-                for (const link of links) {
-                    if (streams.links) {
-                        await writeAsync(streams.links, link);
-                    }
-                }
-            },
-            async configuration(configs) {
-                if (!streams.configuration) {
-                    streams.configuration = await provider.createConfigurationWriteStream();
-                }
-                for (const config of configs) {
-                    if (streams.configuration) {
-                        await writeAsync(streams.configuration, config);
-                    }
-                }
-            },
-            async assets(payloads) {
-                if (payloads === null) {
-                    streams.assets?.end();
-                    return;
-                }
-                if (!streams.assets) {
-                    streams.assets = await provider.createAssetsWriteStream();
-                }
-                for (const payload of payloads) {
-                    if (streams.assets.closed) {
-                        return;
-                    }
-                    const { action, assetID } = payload;
-                    if (action === 'start' && streams.assets) {
-                        assets[assetID] = { ...payload.data, stream: new stream_chain_1.PassThrough() };
-                        writeAsync(streams.assets, assets[assetID]);
-                    }
-                    if (action === 'stream') {
-                        // 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
-                        const rawBuffer = payload.data;
-                        const chunk = Buffer.from(rawBuffer.data);
-                        await writeAsync(assets[assetID].stream, chunk);
-                    }
-                    if (action === 'end') {
-                        await new Promise((resolve, reject) => {
-                            const { stream } = assets[assetID];
-                            stream
-                                .on('close', () => {
-                                delete assets[assetID];
-                                resolve();
-                            })
-                                .on('error', (e) => {
-                                reject(e);
-                            })
-                                .end();
-                        });
-                    }
-                }
-            },
-        },
-    };
-};
-exports.default = createPushController;
-//# sourceMappingURL=push.js.map

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

@@ -1,10 +0,0 @@
-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 {};