@strapi/data-transfer 4.6.0-alpha.0 → 4.6.0-beta.2

package/lib/strapi/remote/handlers.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransferHandler = void 0;
+const crypto_1 = require("crypto");
+const ws_1 = require("ws");
+const push_1 = __importDefault(require("./controllers/push"));
+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({ ...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);
+                }
+                catch (e) {
+                    if (e instanceof Error) {
+                        callback(e);
+                    }
+                    else if (typeof e === 'string') {
+                        callback(new Error(e));
+                    }
+                    else {
+                        callback(new Error('Unexpected error'));
+                    }
+                }
+            };
+            const teardown = () => {
+                delete state.controller;
+                delete state.transfer;
+                return { ok: true };
+            };
+            const init = (msg) => {
+                if (state.controller) {
+                    throw new Error('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 Error(`Transfer not implemented: "${transfer}"`);
+                }
+                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 Error('Command not implemented: "status"'));
+                }
+            };
+            const onTransferCommand = async (msg) => {
+                const { transferID, kind } = msg;
+                const { controller } = state;
+                // TODO: (re)move this check
+                // It shouldn't be possible to strart 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 Error('Pull transfer not implemented'));
+                }
+                if (!controller) {
+                    return callback(new Error("The transfer hasn't been initialized"));
+                }
+                if (!transferID) {
+                    return callback(new Error('Missing transfer ID'));
+                }
+                // Action
+                if (kind === 'action') {
+                    const { action } = msg;
+                    if (!(action in controller.actions)) {
+                        return callback(new Error(`Invalid action provided: "${action}"`));
+                    }
+                    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();
+                console.error(e);
+            });
+            ws.on('message', async (raw) => {
+                const msg = JSON.parse(raw.toString());
+                if (!msg.uuid) {
+                    throw new Error('Missing uuid in message');
+                }
+                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 Error('Bad request'));
+                }
+            });
+        });
+        ctx.respond = false;
+    }
+};
+exports.createTransferHandler = createTransferHandler;
+//# sourceMappingURL=handlers.js.map

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

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

package/lib/strapi/remote/index.js

@@ -0,0 +1,30 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = exports.routes = exports.controllers = void 0;
+exports.controllers = __importStar(require("./controllers"));
+exports.routes = __importStar(require("./routes"));
+exports.constants = __importStar(require("./constants"));
+//# 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/lib/utils/encryption/decrypt.d.ts

@@ -0,0 +1,11 @@
+import { Cipher } from 'crypto';
+import { Algorithm } from '../../../types';
+/**
+ * It creates a cipher instance used for decryption
+ *
+ * @param key - The decryption key
+ * @param algorithm - The algorithm to use to create the Cipher
+ *
+ * @returns A {@link Cipher} instance created with the given key & algorithm
+ */
+export declare const createDecryptionCipher: (key: string, algorithm?: Algorithm) => Cipher;

package/{dist → lib/utils}/encryption/decrypt.js

@@ -5,25 +5,25 @@ const crypto_1 = require("crypto");
 // different key values depending on algorithm chosen
 const getDecryptionStrategy = (algorithm) => {
     const strategies = {
-        'aes-128-ecb': (key) => {
+        'aes-128-ecb'(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 16);
             const initVector = null;
             const securityKey = hashedKey;
             return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
         },
-        aes128: (key) => {
+        aes128(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 32);
             const initVector = hashedKey.slice(16);
             const securityKey = hashedKey.slice(0, 16);
             return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
         },
-        aes192: (key) => {
+        aes192(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 40);
             const initVector = hashedKey.slice(24);
             const securityKey = hashedKey.slice(0, 24);
             return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
         },
-        aes256: (key) => {
+        aes256(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 48);
             const initVector = hashedKey.slice(32);
             const securityKey = hashedKey.slice(0, 32);
@@ -32,6 +32,14 @@ const getDecryptionStrategy = (algorithm) => {
     };
     return strategies[algorithm];
 };
+/**
+ * It creates a cipher instance used for decryption
+ *
+ * @param key - The decryption key
+ * @param algorithm - The algorithm to use to create the Cipher
+ *
+ * @returns A {@link Cipher} instance created with the given key & algorithm
+ */
 const createDecryptionCipher = (key, algorithm = 'aes-128-ecb') => {
     return getDecryptionStrategy(algorithm)(key);
 };

package/lib/utils/encryption/encrypt.d.ts

@@ -0,0 +1,11 @@
+import { Cipher } from 'crypto';
+import { Algorithm } from '../../../types';
+/**
+ * It creates a cipher instance used for encryption
+ *
+ * @param key - The encryption key
+ * @param algorithm - The algorithm to use to create the Cipher
+ *
+ * @returns A {@link Cipher} instance created with the given key & algorithm
+ */
+export declare const createEncryptionCipher: (key: string, algorithm?: Algorithm) => Cipher;

package/{dist → lib/utils}/encryption/encrypt.js

@@ -5,25 +5,25 @@ const crypto_1 = require("crypto");
 // different key values depending on algorithm chosen
 const getEncryptionStrategy = (algorithm) => {
     const strategies = {
-        'aes-128-ecb': (key) => {
+        'aes-128-ecb'(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 16);
             const initVector = null;
             const securityKey = hashedKey;
             return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
         },
-        aes128: (key) => {
+        aes128(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 32);
             const initVector = hashedKey.slice(16);
             const securityKey = hashedKey.slice(0, 16);
             return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
         },
-        aes192: (key) => {
+        aes192(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 40);
             const initVector = hashedKey.slice(24);
             const securityKey = hashedKey.slice(0, 24);
             return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
         },
-        aes256: (key) => {
+        aes256(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 48);
             const initVector = hashedKey.slice(32);
             const securityKey = hashedKey.slice(0, 32);
@@ -32,6 +32,14 @@ const getEncryptionStrategy = (algorithm) => {
     };
     return strategies[algorithm];
 };
+/**
+ * It creates a cipher instance used for encryption
+ *
+ * @param key - The encryption key
+ * @param algorithm - The algorithm to use to create the Cipher
+ *
+ * @returns A {@link Cipher} instance created with the given key & algorithm
+ */
 const createEncryptionCipher = (key, algorithm = 'aes-128-ecb') => {
     return getEncryptionStrategy(algorithm)(key);
 };

package/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * as encryption from './encryption';
+export * as stream from './stream';
+export * as json from './json';
+export * as schema from './schema';

package/lib/utils/index.js

@@ -0,0 +1,31 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.json = exports.stream = exports.encryption = void 0;
+exports.encryption = __importStar(require("./encryption"));
+exports.stream = __importStar(require("./stream"));
+exports.json = __importStar(require("./json"));
+exports.schema = __importStar(require("./schema"));
+//# sourceMappingURL=index.js.map

package/lib/utils/json.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Compute differences between two JSON objects and returns them
+ *
+ * @param a - First object
+ * @param b - Second object
+ * @param ctx - Context used to keep track of the current path during recursion
+ */
+export declare const diff: (a: unknown, b: unknown, ctx?: Context) => Diff[];
+export interface AddedDiff<T = unknown> {
+    kind: 'added';
+    path: string[];
+    type: string;
+    value: T;
+}
+export interface ModifiedDiff<T = unknown, P = unknown> {
+    kind: 'modified';
+    path: string[];
+    types: [string, string];
+    values: [T, P];
+}
+export interface DeletedDiff<T = unknown> {
+    kind: 'deleted';
+    path: string[];
+    type: string;
+    value: T;
+}
+export declare type Diff = AddedDiff | ModifiedDiff | DeletedDiff;
+export interface Context {
+    path: string[];
+}

package/{dist/utils.js → lib/utils/json.js}

@@ -1,25 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapSchemasValues = exports.jsonDiffs = exports.collect = void 0;
+exports.diff = void 0;
 const fp_1 = require("lodash/fp");
+const createContext = () => ({ path: [] });
 /**
- * Collect every entity in a Readable stream
+ * Compute differences between two JSON objects and returns them
+ *
+ * @param a - First object
+ * @param b - Second object
+ * @param ctx - Context used to keep track of the current path during recursion
  */
-const collect = (stream) => {
-    const chunks = [];
-    return new Promise((resolve) => {
-        stream.on('data', (chunk) => chunks.push(chunk));
-        stream.on('end', () => {
-            stream.destroy();
-            resolve(chunks);
-        });
-    });
-};
-exports.collect = collect;
-const createContext = () => ({ path: [] });
-const jsonDiffs = (a, b, ctx = createContext()) => {
+const diff = (a, b, ctx = createContext()) => {
     const diffs = [];
     const { path } = ctx;
+    const aType = typeof a;
+    const bType = typeof b;
     // Define helpers
     const added = () => {
         diffs.push({ kind: 'added', path, type: bType, value: b });
@@ -38,8 +33,6 @@ const jsonDiffs = (a, b, ctx = createContext()) => {
         });
         return diffs;
     };
-    const aType = typeof a;
-    const bType = typeof b;
     if (aType === 'undefined') {
         return added();
     }
@@ -50,9 +43,9 @@ const jsonDiffs = (a, b, ctx = createContext()) => {
         let k = 0;
         for (const [aItem, bItem] of (0, fp_1.zip)(a, b)) {
             const kCtx = { path: [...path, k.toString()] };
-            const kDiffs = (0, exports.jsonDiffs)(aItem, bItem, kCtx);
+            const kDiffs = (0, exports.diff)(aItem, bItem, kCtx);
             diffs.push(...kDiffs);
-            k++;
+            k += 1;
         }
         return diffs;
     }
@@ -61,30 +54,15 @@ const jsonDiffs = (a, b, ctx = createContext()) => {
         for (const key of keys) {
             const aValue = a[key];
             const bValue = b[key];
-            const nestedDiffs = (0, exports.jsonDiffs)(aValue, bValue, { path: [...path, key] });
+            const nestedDiffs = (0, exports.diff)(aValue, bValue, { path: [...path, key] });
             diffs.push(...nestedDiffs);
         }
         return diffs;
     }
     if (!(0, fp_1.isEqual)(a, b)) {
-        modified();
+        return modified();
     }
     return diffs;
 };
-exports.jsonDiffs = jsonDiffs;
-const schemaSelectedKeys = [
-    'collectionName',
-    'info',
-    'options',
-    'pluginOptions',
-    'attributes',
-    'kind',
-    'modelType',
-    'modelName',
-    'uid',
-    'plugin',
-    'globalId',
-];
-const mapSchemasValues = (schemas) => (0, fp_1.mapValues)((0, fp_1.pick)(schemaSelectedKeys), schemas);
-exports.mapSchemasValues = mapSchemasValues;
-//# sourceMappingURL=utils.js.map
+exports.diff = diff;
+//# sourceMappingURL=json.js.map

package/lib/utils/schema.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="lodash" />
+import type { Schema } from '@strapi/strapi';
+/**
+ * Sanitize a schemas dictionnary by omiting unwanted properties
+ * The list of allowed properties can be found here: {@link VALID_SCHEMA_PROPERTIES}
+ */
+export declare const mapSchemasValues: (schemas: Record<string, Schema>) => import("lodash").Dictionary<Partial<Schema>>;

package/lib/utils/schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapSchemasValues = void 0;
+const fp_1 = require("lodash/fp");
+/**
+ * List of schema properties that should be kept when sanitizing schemas
+ */
+const VALID_SCHEMA_PROPERTIES = [
+    'collectionName',
+    'info',
+    'options',
+    'pluginOptions',
+    'attributes',
+    'kind',
+    'modelType',
+    'modelName',
+    'uid',
+    'plugin',
+    'globalId',
+];
+/**
+ * Sanitize a schemas dictionnary by omiting unwanted properties
+ * The list of allowed properties can be found here: {@link VALID_SCHEMA_PROPERTIES}
+ */
+const mapSchemasValues = (schemas) => {
+    return (0, fp_1.mapValues)((0, fp_1.pick)(VALID_SCHEMA_PROPERTIES), schemas);
+};
+exports.mapSchemasValues = mapSchemasValues;
+//# sourceMappingURL=schema.js.map

package/lib/utils/stream.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { Transform, Readable } from 'stream';
+declare type TransformOptions = ConstructorParameters<typeof Transform>[0];
+/**
+ * Create a filter stream that discard chunks which doesn't satisfies the given predicate
+ *
+ * @param predicate - A filter predicate, takes a stream data chunk as parameter and returns a boolean value
+ * @param options - Transform stream options
+ */
+export declare const filter: <T>(predicate: (value: T) => boolean | Promise<boolean>, options?: TransformOptions) => Transform;
+/**
+ * Create a map stream that transform chunks using the given predicate
+ *
+ * @param predicate - A map predicate, takes a stream data chunk as parameter and returns a mapped value
+ * @param options - Transform stream options
+ */
+export declare const map: <T, U = T>(predicate: (value: T) => U | Promise<U>, options?: TransformOptions) => Transform;
+/**
+ * Collect every chunks from a Readable stream.
+ *
+ * @param stream - The redable stream to collect data from
+ * @param options.destroy - If set to true, it automatically calls `destroy()` on the given stream upon receiving the 'end' event
+ */
+export declare const collect: <T = unknown>(stream: Readable, options?: {
+    destroy: boolean;
+}) => Promise<T[]>;
+export {};

package/lib/utils/stream.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collect = exports.map = exports.filter = void 0;
+const stream_1 = require("stream");
+/**
+ * Create a filter stream that discard chunks which doesn't satisfies the given predicate
+ *
+ * @param predicate - A filter predicate, takes a stream data chunk as parameter and returns a boolean value
+ * @param options - Transform stream options
+ */
+const filter = (predicate, options = { objectMode: true }) => {
+    return new stream_1.Transform({
+        ...options,
+        async transform(chunk, _encoding, callback) {
+            const keep = await predicate(chunk);
+            callback(null, keep ? chunk : undefined);
+        },
+    });
+};
+exports.filter = filter;
+/**
+ * Create a map stream that transform chunks using the given predicate
+ *
+ * @param predicate - A map predicate, takes a stream data chunk as parameter and returns a mapped value
+ * @param options - Transform stream options
+ */
+const map = (predicate, options = { objectMode: true }) => {
+    return new stream_1.Transform({
+        ...options,
+        async transform(chunk, _encoding, callback) {
+            const mappedValue = await predicate(chunk);
+            callback(null, mappedValue);
+        },
+    });
+};
+exports.map = map;
+/**
+ * Collect every chunks from a Readable stream.
+ *
+ * @param stream - The redable stream to collect data from
+ * @param options.destroy - If set to true, it automatically calls `destroy()` on the given stream upon receiving the 'end' event
+ */
+const collect = (stream, options = { destroy: true }) => {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream
+            .on('close', () => resolve(chunks))
+            .on('error', reject)
+            .on('data', (chunk) => chunks.push(chunk))
+            .on('end', () => {
+            if (options.destroy) {
+                stream.destroy();
+            }
+            resolve(chunks);
+        });
+    });
+};
+exports.collect = collect;
+//# sourceMappingURL=stream.js.map