@strapi/data-transfer 4.6.0-beta.1 → 4.6.0

package/lib/strapi/remote/handlers.js

@@ -0,0 +1,193 @@
+"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 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());
+    // 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 providers_1.ProviderTransferError(e));
+                    }
+                    else {
+                        callback(new providers_1.ProviderTransferError('Unexpected error', {
+                            error: e,
+                        }));
+                    }
+                }
+            };
+            const teardown = () => {
+                delete state.controller;
+                delete state.transfer;
+                return { ok: true };
+            };
+            const init = (msg) => {
+                // TODO: this only checks for this instance of node: we should consider a database lock
+                if (state.controller) {
+                    throw new providers_1.ProviderInitializationError('Transfer already in progres');
+                }
+                const { transfer } = msg.params;
+                // Push transfer
+                if (transfer === 'push') {
+                    const { options: controllerOptions } = msg.params;
+                    state.controller = (0, push_1.default)({
+                        ...controllerOptions,
+                        autoDestroy: false,
+                        getStrapi: () => strapi,
+                    });
+                }
+                // Pull or any other string
+                else {
+                    throw new providers_1.ProviderTransferError(`Transfer type not implemented: "${transfer}"`, {
+                        transfer,
+                        validTransfers: constants_1.TRANSFER_METHODS,
+                    });
+                }
+                state.transfer = { id: (0, crypto_1.randomUUID)(), kind: transfer };
+                return { transferID: state.transfer.id };
+            };
+            /**
+             * On command message (init, end, status, ...)
+             */
+            const onCommand = async (msg) => {
+                const { command } = msg;
+                if (command === 'init') {
+                    await answer(() => init(msg));
+                }
+                if (command === 'end') {
+                    await answer(teardown);
+                }
+                if (command === 'status') {
+                    await callback(new providers_1.ProviderTransferError('Command not implemented: "status"', {
+                        command,
+                        validCommands: ['init', 'end', 'status'],
+                    }));
+                }
+            };
+            const onTransferCommand = async (msg) => {
+                const { transferID, kind } = msg;
+                const { controller } = state;
+                // TODO: (re)move this check
+                // It shouldn't be possible to start a pull transfer for now, so reaching
+                // this code should be impossible too, but this has been added by security
+                if (state.transfer?.kind === 'pull') {
+                    return callback(new providers_1.ProviderTransferError('Pull transfer not implemented'));
+                }
+                if (!controller) {
+                    return callback(new providers_1.ProviderTransferError("The transfer hasn't been initialized"));
+                }
+                if (!transferID) {
+                    return callback(new providers_1.ProviderTransferError('Missing transfer ID'));
+                }
+                // Action
+                if (kind === 'action') {
+                    const { action } = msg;
+                    if (!(action in controller.actions)) {
+                        return callback(new providers_1.ProviderTransferError(`Invalid action provided: "${action}"`, {
+                            action,
+                            validActions: Object.keys(controller.actions),
+                        }));
+                    }
+                    await answer(() => controller.actions[action]());
+                }
+                // Transfer
+                else if (kind === 'step') {
+                    // We can only have push transfer message for the moment
+                    const message = msg;
+                    // TODO: lock transfer process
+                    if (message.action === 'start') {
+                        // console.log('Starting transfer for ', message.step);
+                    }
+                    // Stream step
+                    else if (message.action === 'stream') {
+                        await answer(() => controller.transfer[message.step]?.(message.data));
+                    }
+                    // TODO: unlock transfer process
+                    else if (message.action === 'end') {
+                        // console.log('Ending transfer for ', message.step);
+                    }
+                }
+            };
+            ws.on('close', () => {
+                teardown();
+            });
+            ws.on('error', (e) => {
+                teardown();
+                // TODO: is logging a console error to the running instance of Strapi ok to do? Should we check for an existing strapi.logger to use?
+                console.error(e);
+            });
+            ws.on('message', async (raw) => {
+                const msg = JSON.parse(raw.toString());
+                if (!msg.uuid) {
+                    await callback(new providers_1.ProviderTransferError('Missing uuid in message'));
+                    return;
+                }
+                uuid = msg.uuid;
+                // Regular command message (init, end, status)
+                if (msg.type === 'command') {
+                    await onCommand(msg);
+                }
+                // Transfer message (the transfer must be initialized first)
+                else if (msg.type === 'transfer') {
+                    await onTransferCommand(msg);
+                }
+                // Invalid messages
+                else {
+                    await callback(new providers_1.ProviderTransferError('Bad request'));
+                }
+            });
+        });
+        ctx.respond = false;
+    }
+};
+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

@@ -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

@@ -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/{dist → lib}/utils/index.d.ts

@@ -1,3 +1,5 @@
+export * as encryption from './encryption';
 export * as stream from './stream';
 export * as json from './json';
 export * as schema from './schema';
+export * as transaction from './transaction';

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

@@ -23,8 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema = exports.json = exports.stream = void 0;
+exports.transaction = 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"));
+exports.transaction = __importStar(require("./transaction"));
 //# sourceMappingURL=index.js.map

package/{dist → lib}/utils/json.d.ts

@@ -1,3 +1,10 @@
+/**
+ * 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';

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

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.diff = void 0;
 const fp_1 = require("lodash/fp");
 const createContext = () => ({ path: [] });
+/**
+ * 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 diff = (a, b, ctx = createContext()) => {
     const diffs = [];
     const { path } = ctx;
@@ -53,7 +60,7 @@ const diff = (a, b, ctx = createContext()) => {
         return diffs;
     }
     if (!(0, fp_1.isEqual)(a, b)) {
-        modified();
+        return modified();
     }
     return diffs;
 };

package/lib/utils/providers.d.ts

@@ -0,0 +1,2 @@
+export declare type ValidStrapiAssertion = (strapi: unknown, msg?: string) => asserts strapi is Strapi.Strapi;
+export declare const assertValidStrapi: ValidStrapiAssertion;

package/lib/utils/providers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidStrapi = void 0;
+const providers_1 = require("../errors/providers");
+const assertValidStrapi = (strapi, msg = '') => {
+    if (!strapi) {
+        throw new providers_1.ProviderInitializationError(`${msg}. Strapi instance not found.`);
+    }
+};
+exports.assertValidStrapi = assertValidStrapi;
+//# sourceMappingURL=providers.js.map

package/{dist → lib}/utils/schema.d.ts

@@ -1,3 +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/{dist → lib}/utils/schema.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapSchemasValues = void 0;
 const fp_1 = require("lodash/fp");
-const schemaSelectedKeys = [
+/**
+ * List of schema properties that should be kept when sanitizing schemas
+ */
+const VALID_SCHEMA_PROPERTIES = [
     'collectionName',
     'info',
     'options',
@@ -15,8 +18,12 @@ const schemaSelectedKeys = [
     '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)(schemaSelectedKeys), 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

package/lib/utils/transaction.d.ts

@@ -0,0 +1,3 @@
+import { Strapi } from '@strapi/strapi';
+import { Transaction } from '../../types/utils';
+export declare const createTransaction: (strapi: Strapi) => Transaction;

package/lib/utils/transaction.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransaction = void 0;
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+const createTransaction = (strapi) => {
+    const fns = [];
+    let done = false;
+    let resume = null;
+    const e = new events_1.EventEmitter();
+    e.on('spawn', (uuid, cb) => {
+        fns.push({ fn: cb, uuid });
+        resume?.();
+    });
+    e.on('close', () => {
+        done = true;
+        resume?.();
+    });
+    strapi.db.transaction(async ({ trx, rollback }) => {
+        e.on('rollback', async () => {
+            await rollback();
+        });
+        while (!done) {
+            while (fns.length) {
+                const item = fns.shift();
+                if (item) {
+                    const { fn, uuid } = item;
+                    try {
+                        const res = await fn(trx);
+                        e.emit(uuid, { data: res });
+                    }
+                    catch (error) {
+                        e.emit(uuid, { error });
+                    }
+                }
+            }
+            if (!done && !fns.length) {
+                // eslint-disable-next-line @typescript-eslint/no-loop-func
+                await new Promise((resolve) => {
+                    resume = resolve;
+                });
+            }
+        }
+    });
+    return {
+        async attach(callback) {
+            const uuid = (0, crypto_1.randomUUID)();
+            e.emit('spawn', uuid, callback);
+            return new Promise((resolve, reject) => {
+                e.on(uuid, ({ data, error }) => {
+                    if (data) {
+                        resolve(data);
+                    }
+                    if (error) {
+                        reject(error);
+                    }
+                    resolve(undefined);
+                });
+            });
+        },
+        end() {
+            return e.emit('close');
+        },
+        rollback() {
+            return e.emit('rollback');
+        },
+    };
+};
+exports.createTransaction = createTransaction;
+//# sourceMappingURL=transaction.js.map