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

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

@@ -12,6 +12,7 @@ const uuid_1 = require("uuid");
 const stream_1 = require("stream");
 const utils_1 = require("./utils");
 const constants_1 = require("../../remote/constants");
+const providers_1 = require("../../../errors/providers");
 class RemoteStrapiDestinationProvider {
     constructor(options) {
         _RemoteStrapiDestinationProvider_instances.add(this);
@@ -33,7 +34,7 @@ class RemoteStrapiDestinationProvider {
                 });
                 const res = (await query);
                 if (!res?.transferID) {
-                    return reject(new Error('Init failed, invalid response from the server'));
+                    return reject(new providers_1.ProviderTransferError('Init failed, invalid response from the server'));
                 }
                 resolve(res.transferID);
             })
@@ -42,12 +43,20 @@ class RemoteStrapiDestinationProvider {
     }
     async bootstrap() {
         const { url, auth } = this.options;
+        const validProtocols = ['https:', 'http:'];
         let ws;
-        if (!['https:', 'http:'].includes(url.protocol)) {
-            throw new Error(`Invalid protocol "${url.protocol}"`);
+        if (!validProtocols.includes(url.protocol)) {
+            throw new providers_1.ProviderValidationError(`Invalid protocol "${url.protocol}"`, {
+                check: 'url',
+                details: {
+                    protocol: url.protocol,
+                    validProtocols,
+                },
+            });
         }
         const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
         const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}`;
+        const validAuthMethods = ['token'];
         // No auth defined, trying public access for transfer
         if (!auth) {
             ws = new ws_1.WebSocket(wsUrl);
@@ -59,7 +68,13 @@ class RemoteStrapiDestinationProvider {
         }
         // Invalid auth method provided
         else {
-            throw new Error('Auth method not implemented');
+            throw new providers_1.ProviderValidationError('Auth method not implemented', {
+                check: 'auth.type',
+                details: {
+                    auth: auth.type,
+                    validAuthMethods,
+                },
+            });
         }
         this.ws = ws;
         this.dispatcher = (0, utils_1.createDispatcher)(this.ws);
@@ -158,9 +173,9 @@ _RemoteStrapiDestinationProvider_instances = new WeakSet(), _RemoteStrapiDestina
             return e;
         }
         if (typeof e === 'string') {
-            return new Error(e);
+            return new providers_1.ProviderTransferError(e);
         }
-        return new Error('Unexpected error');
+        return new providers_1.ProviderTransferError('Unexpected error');
     }
     return null;
 };

package/lib/strapi/queries/link.d.ts

@@ -1,5 +1,5 @@
 import { ILink } from '../../../types';
-export declare const createLinkQuery: (strapi: Strapi.Strapi) => () => {
+export declare const createLinkQuery: (strapi: Strapi.Strapi, trx?: any) => () => {
     generateAll: (uid: string) => AsyncGenerator<ILink>;
     generateAllForAttribute: (uid: string, fieldName: string) => AsyncGenerator<ILink>;
     insert: (link: ILink) => Promise<void>;

package/lib/strapi/queries/link.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinkQuery = void 0;
 const fp_1 = require("lodash/fp");
 // TODO: Remove any types when we'll have types for DB metadata
-const createLinkQuery = (strapi) => {
+const createLinkQuery = (strapi, trx) => {
     const query = () => {
         const { connection } = strapi.db;
         async function* generateAllForAttribute(uid, fieldName) {
@@ -23,6 +23,9 @@ const createLinkQuery = (strapi) => {
             if (attribute.joinColumn) {
                 const joinColumnName = attribute.joinColumn.name;
                 const qb = connection.queryBuilder().select('id', joinColumnName).from(metadata.tableName);
+                if (trx) {
+                    qb.transacting(trx);
+                }
                 // TODO: stream the query to improve performances
                 const entries = await qb;
                 for (const entry of entries) {
@@ -77,6 +80,9 @@ const createLinkQuery = (strapi) => {
                     columns.right.order,
                 ].filter((column) => !(0, fp_1.isNil)(column));
                 qb.select(validColumns);
+                if (trx) {
+                    qb.transacting(trx);
+                }
                 // TODO: stream the query to improve performances
                 const entries = await qb;
                 for (const entry of entries) {
@@ -127,9 +133,13 @@ const createLinkQuery = (strapi) => {
             const payload = {};
             if (attribute.joinColumn) {
                 const joinColumnName = attribute.joinColumn.name;
-                await connection(metadata.tableName)
+                const qb = connection(metadata.tableName)
                     .where('id', left.ref)
                     .update({ [joinColumnName]: right.ref });
+                if (trx) {
+                    qb.transacting(trx);
+                }
+                await qb;
             }
             if (attribute.joinTable) {
                 const { name, joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName, morphColumn, } = attribute.joinTable;
@@ -168,7 +178,11 @@ const createLinkQuery = (strapi) => {
                     assignMorphColumns();
                 }
                 assignOrderColumns();
-                await connection.insert(payload).into(name);
+                const qb = connection.insert(payload).into(name);
+                if (trx) {
+                    qb.transacting(trx);
+                }
+                await qb;
             }
         };
         return { generateAll, generateAllForAttribute, insert };

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

@@ -1 +1,2 @@
 export declare const TRANSFER_PATH = "/transfer";
+export declare const TRANSFER_METHODS: string[];

package/lib/strapi/remote/constants.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRANSFER_PATH = void 0;
+exports.TRANSFER_METHODS = exports.TRANSFER_PATH = void 0;
 exports.TRANSFER_PATH = '/transfer';
+exports.TRANSFER_METHODS = ['push', 'pull'];
 //# sourceMappingURL=constants.js.map

package/lib/strapi/remote/handlers.js

@@ -7,6 +7,8 @@ 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(',')
@@ -54,10 +56,12 @@ const createTransferHandler = (options = {}) => async (ctx) => {
                         callback(e);
                     }
                     else if (typeof e === 'string') {
-                        callback(new Error(e));
+                        callback(new providers_1.ProviderTransferError(e));
                     }
                     else {
-                        callback(new Error('Unexpected error'));
+                        callback(new providers_1.ProviderTransferError('Unexpected error', {
+                            error: e,
+                        }));
                     }
                 }
             };
@@ -67,8 +71,9 @@ const createTransferHandler = (options = {}) => async (ctx) => {
                 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 Error('Transfer already in progres');
+                    throw new providers_1.ProviderInitializationError('Transfer already in progres');
                 }
                 const { transfer } = msg.params;
                 // Push transfer
@@ -82,7 +87,10 @@ const createTransferHandler = (options = {}) => async (ctx) => {
                 }
                 // Pull or any other string
                 else {
-                    throw new Error(`Transfer not implemented: "${transfer}"`);
+                    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 };
@@ -99,29 +107,35 @@ const createTransferHandler = (options = {}) => async (ctx) => {
                     await answer(teardown);
                 }
                 if (command === 'status') {
-                    await callback(new Error('Command not implemented: "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 strart a pull transfer for now, so reaching
+                // 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 Error('Pull transfer not implemented'));
+                    return callback(new providers_1.ProviderTransferError('Pull transfer not implemented'));
                 }
                 if (!controller) {
-                    return callback(new Error("The transfer hasn't been initialized"));
+                    return callback(new providers_1.ProviderTransferError("The transfer hasn't been initialized"));
                 }
                 if (!transferID) {
-                    return callback(new Error('Missing transfer ID'));
+                    return callback(new providers_1.ProviderTransferError('Missing transfer ID'));
                 }
                 // Action
                 if (kind === 'action') {
                     const { action } = msg;
                     if (!(action in controller.actions)) {
-                        return callback(new Error(`Invalid action provided: "${action}"`));
+                        return callback(new providers_1.ProviderTransferError(`Invalid action provided: "${action}"`, {
+                            action,
+                            validActions: Object.keys(controller.actions),
+                        }));
                     }
                     await answer(() => controller.actions[action]());
                 }
@@ -148,12 +162,14 @@ const createTransferHandler = (options = {}) => async (ctx) => {
             });
             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) {
-                    throw new Error('Missing uuid in message');
+                    await callback(new providers_1.ProviderTransferError('Missing uuid in message'));
+                    return;
                 }
                 uuid = msg.uuid;
                 // Regular command message (init, end, status)
@@ -166,7 +182,7 @@ const createTransferHandler = (options = {}) => async (ctx) => {
                 }
                 // Invalid messages
                 else {
-                    await callback(new Error('Bad request'));
+                    await callback(new providers_1.ProviderTransferError('Bad request'));
                 }
             });
         });

package/lib/utils/index.d.ts

@@ -2,3 +2,4 @@ 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/lib/utils/index.js

@@ -23,9 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema = exports.json = exports.stream = exports.encryption = 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/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/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/data-transfer",
-  "version": "4.6.0-beta.2",
+  "version": "4.6.0",
   "description": "Data transfer capabilities for Strapi",
   "keywords": [
     "strapi",
@@ -30,7 +30,7 @@
     "build": "yarn build:ts",
     "build:ts": "tsc -p tsconfig.json",
     "build:clean": "yarn clean && yarn build",
-    "clean": "rimraf ./dist",
+    "clean": "rimraf ./lib",
     "prepublishOnly": "yarn build:clean",
     "test:unit": "jest --verbose",
     "watch": "yarn build:ts -w --preserveWatchOutput"
@@ -39,8 +39,8 @@
     "lib": "./lib"
   },
   "dependencies": {
-    "@strapi/logger": "4.6.0-beta.2",
-    "@strapi/strapi": "4.6.0-beta.2",
+    "@strapi/logger": "4.6.0",
+    "@strapi/strapi": "4.6.0",
     "chalk": "4.1.2",
     "fs-extra": "10.0.0",
     "lodash": "4.17.21",
@@ -64,6 +64,7 @@
     "@types/tar": "6.1.3",
     "@types/tar-stream": "2.2.2",
     "@types/uuid": "9.0.0",
+    "knex": "2.4.0",
     "koa": "2.13.4",
     "rimraf": "3.0.2",
     "typescript": "4.6.2"
@@ -72,5 +73,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "b852090f931cd21868c4016f24db2f9fdfc7a7ab"
+  "gitHead": "a9e55435c489f3379d88565bf3f729deb29bfb45"
 }