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

package/lib/strapi/index.js

@@ -0,0 +1,35 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = exports.remote = exports.queries = exports.providers = void 0;
+exports.providers = __importStar(require("./providers"));
+exports.queries = __importStar(require("./queries"));
+exports.remote = __importStar(require("./remote"));
+var register_1 = require("./register");
+Object.defineProperty(exports, "register", { enumerable: true, get: function () { return __importDefault(register_1).default; } });
+//# sourceMappingURL=index.js.map

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

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

package/lib/strapi/providers/index.js

@@ -0,0 +1,22 @@
+"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 });
+// Local
+__exportStar(require("./local-destination"), exports);
+__exportStar(require("./local-source"), exports);
+// Remote
+__exportStar(require("./remote-destination"), exports);
+//# sourceMappingURL=index.js.map

package/{dist/providers/local-strapi-destination-provider → lib/strapi/providers/local-destination}/index.d.ts

@@ -1,12 +1,13 @@
 /// <reference types="lodash" />
 /// <reference types="node" />
 import { Writable } from 'stream';
-import type { IDestinationProvider, IMetadata, ProviderType } from '../../../types';
+import type { IDestinationProvider, IMetadata, ProviderType } from '../../../../types';
 import { restore } from './strategies';
 export declare const VALID_CONFLICT_STRATEGIES: string[];
 export declare const DEFAULT_CONFLICT_STRATEGY = "restore";
-interface ILocalStrapiDestinationProviderOptions {
+export interface ILocalStrapiDestinationProviderOptions {
     getStrapi(): Strapi.Strapi | Promise<Strapi.Strapi>;
+    autoDestroy?: boolean;
     restore?: restore.IRestoreOptions;
     strategy: 'restore' | 'merge';
 }
@@ -20,12 +21,12 @@ declare class LocalStrapiDestinationProvider implements IDestinationProvider {
     bootstrap(): Promise<void>;
     close(): Promise<void>;
     beforeTransfer(): Promise<void>;
-    getMetadata(): IMetadata | Promise<IMetadata>;
+    getMetadata(): IMetadata;
     getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;
-    getEntitiesStream(): Writable;
-    getAssetsStream(): Promise<Writable>;
-    getConfigurationStream(): Promise<Writable>;
-    getLinksStream(): Promise<Writable>;
+    createEntitiesWriteStream(): Writable;
+    createAssetsWriteStream(): Promise<Writable>;
+    createConfigurationWriteStream(): Promise<Writable>;
+    createLinksWriteStream(): Promise<Writable>;
 }
 export declare const createLocalStrapiDestinationProvider: (options: ILocalStrapiDestinationProviderOptions) => LocalStrapiDestinationProvider;
 export {};

package/{dist/providers/local-strapi-destination-provider → lib/strapi/providers/local-destination}/index.js

@@ -43,7 +43,7 @@ const stream_1 = require("stream");
 const path_1 = __importDefault(require("path"));
 const fse = __importStar(require("fs-extra"));
 const strategies_1 = require("./strategies");
-const utils = __importStar(require("../../utils"));
+const utils = __importStar(require("../../../utils"));
 exports.VALID_CONFLICT_STRATEGIES = ['restore', 'merge'];
 exports.DEFAULT_CONFLICT_STRATEGY = 'restore';
 class LocalStrapiDestinationProvider {
@@ -51,6 +51,9 @@ class LocalStrapiDestinationProvider {
         _LocalStrapiDestinationProvider_instances.add(this);
         this.name = 'destination::local-strapi';
         this.type = 'destination';
+        /**
+         * The entities mapper is used to map old entities to their new IDs
+         */
         _LocalStrapiDestinationProvider_entitiesMapper.set(this, void 0);
         this.options = options;
         __classPrivateFieldSet(this, _LocalStrapiDestinationProvider_entitiesMapper, {}, "f");
@@ -60,7 +63,11 @@ class LocalStrapiDestinationProvider {
         this.strapi = await this.options.getStrapi();
     }
     async close() {
-        await this.strapi?.destroy?.();
+        const { autoDestroy } = this.options;
+        // Basically `!== false` but more deterministic
+        if (autoDestroy === undefined || autoDestroy === true) {
+            await this.strapi?.destroy();
+        }
     }
     async beforeTransfer() {
         if (this.options.strategy === 'restore') {
@@ -93,7 +100,7 @@ class LocalStrapiDestinationProvider {
         };
         return utils.schema.mapSchemasValues(schemas);
     }
-    getEntitiesStream() {
+    createEntitiesWriteStream() {
         if (!this.strapi) {
             throw new Error('Not able to import entities. Strapi instance not found');
         }
@@ -112,7 +119,8 @@ class LocalStrapiDestinationProvider {
         }
         throw new Error(`Invalid strategy supplied: "${strategy}"`);
     }
-    async getAssetsStream() {
+    // TODO: Move this logic to the restore strategy
+    async createAssetsWriteStream() {
         if (!this.strapi) {
             throw new Error('Not able to stream Assets. Strapi instance not found');
         }
@@ -148,7 +156,7 @@ class LocalStrapiDestinationProvider {
             },
         });
     }
-    async getConfigurationStream() {
+    async createConfigurationWriteStream() {
         if (!this.strapi) {
             throw new Error('Not able to stream Configurations. Strapi instance not found');
         }
@@ -158,7 +166,7 @@ class LocalStrapiDestinationProvider {
         }
         throw new Error(`Invalid strategy supplied: "${strategy}"`);
     }
-    async getLinksStream() {
+    async createLinksWriteStream() {
         if (!this.strapi) {
             throw new Error('Not able to stream links. Strapi instance not found');
         }

package/{dist/providers/local-strapi-destination-provider → lib/strapi/providers/local-destination}/strategies/restore/configuration.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
 import { Writable } from 'stream';
-import { IConfiguration } from '../../../../../types';
+import { IConfiguration } from '../../../../../../types';
 export declare const restoreConfigs: (strapi: Strapi.Strapi, config: IConfiguration) => Promise<any>;
 export declare const createConfigurationWriteStream: (strapi: Strapi.Strapi) => Promise<Writable>;

package/{dist/providers/local-strapi-destination-provider → lib/strapi/providers/local-destination}/strategies/restore/entities.js

@@ -26,49 +26,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEntitiesWriteStream = void 0;
 const fp_1 = require("lodash/fp");
 const stream_1 = require("stream");
-const utils_1 = require("../../../../utils");
-const shared = __importStar(require("../../../shared"));
+const utils_1 = require("../../../../../utils");
+const queries = __importStar(require("../../../../queries"));
 const createEntitiesWriteStream = (options) => {
     const { strapi, updateMappingTable } = options;
-    const query = shared.strapi.entity.createEntityQuery(strapi);
+    const query = queries.entity.createEntityQuery(strapi);
     return new stream_1.Writable({
         objectMode: true,
         async write(entity, _encoding, callback) {
             const { type, id, data } = entity;
             const { create, getDeepPopulateComponentLikeQuery } = query(type);
             const contentType = strapi.getModel(type);
+            /**
+             * Resolve the component UID of an entity's attribute based
+             * on a given path (components & dynamic zones only)
+             */
             const resolveType = (paths) => {
-                let type = contentType;
+                let cType = contentType;
                 let value = data;
                 for (const path of paths) {
                     value = (0, fp_1.get)(path, value);
-                    if (typeof type === 'function') {
-                        type = type(value);
+                    // Needed when the value of cType should be computed
+                    // based on the next value (eg: dynamic zones)
+                    if (typeof cType === 'function') {
+                        cType = cType(value);
                     }
-                    if (path in type.attributes) {
-                        const attribute = type.attributes[path];
+                    if (path in cType.attributes) {
+                        const attribute = cType.attributes[path];
                         if (attribute.type === 'component') {
-                            type = strapi.getModel(attribute.component);
+                            cType = strapi.getModel(attribute.component);
                         }
                         if (attribute.type === 'dynamiczone') {
-                            type = ({ __component }) => strapi.getModel(__component);
+                            cType = ({ __component }) => strapi.getModel(__component);
                         }
                     }
                 }
-                return type.uid;
+                return cType?.uid;
             };
             try {
-                // Create the entity
                 const created = await create({
                     data,
                     populate: getDeepPopulateComponentLikeQuery(contentType, { select: 'id' }),
                     select: 'id',
                 });
+                // Compute differences between original & new entities
                 const diffs = utils_1.json.diff(data, created);
                 updateMappingTable(type, id, created.id);
+                // For each difference found on an ID attribute,
+                // update the mapping the table accordingly
                 diffs.forEach((diff) => {
-                    if (diff.kind === 'modified' && diff.path.at(-1) === 'id') {
+                    if (diff.kind === 'modified' && (0, fp_1.last)(diff.path) === 'id') {
                         const target = resolveType(diff.path);
+                        // If no type is found for the given path, then ignore the diff
+                        if (!target) {
+                            return;
+                        }
                         const [oldID, newID] = diff.values;
                         updateMappingTable(target, oldID, newID);
                     }

package/{dist/providers/local-strapi-destination-provider → lib/strapi/providers/local-destination}/strategies/restore/index.js

@@ -27,7 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteRecords = void 0;
-const shared = __importStar(require("../../../shared"));
+const queries = __importStar(require("../../../../queries"));
 const deleteRecords = async (strapi, options) => {
     const entities = await deleteEntitiesRecord(strapi, options);
     const configuration = await deleteConfigurationRecords(strapi, options);
@@ -40,7 +40,7 @@ const deleteRecords = async (strapi, options) => {
 exports.deleteRecords = deleteRecords;
 const deleteEntitiesRecord = async (strapi, options = {}) => {
     const { entities } = options;
-    const query = shared.strapi.entity.createEntityQuery(strapi);
+    const query = queries.entity.createEntityQuery(strapi);
     const contentTypes = Object.values(strapi.contentTypes);
     const contentTypesToClear = contentTypes.filter((contentType) => {
         let keep = true;

package/{dist/providers/local-strapi-destination-provider → lib/strapi/providers/local-destination}/strategies/restore/links.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinksWriteStream = void 0;
 const stream_1 = require("stream");
-const link_1 = require("../../../shared/strapi/link");
+const link_1 = require("../../../../queries/link");
 const createLinksWriteStream = (mapID, strapi) => {
     return new stream_1.Writable({
         objectMode: true,

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/configuration.js

@@ -8,20 +8,19 @@ const fp_1 = require("lodash/fp");
  * Create a readable stream that export the Strapi app configuration
  */
 const createConfigurationStream = (strapi) => {
-    // Core Store
-    const coreStoreStream = (0, stream_chain_1.chain)([
-        strapi.db.queryBuilder('strapi::core-store').stream(),
-        (data) => (0, fp_1.set)('value', JSON.parse(data.value), data),
-        wrapConfigurationItem('core-store'),
-    ]);
-    // Webhook
-    const webhooksStream = (0, stream_chain_1.chain)([
-        strapi.db.queryBuilder('webhook').stream(),
-        wrapConfigurationItem('webhook'),
-    ]);
-    const streams = [coreStoreStream, webhooksStream];
-    // Readable configuration stream
     return stream_1.Readable.from((async function* configurationGenerator() {
+        // Core Store
+        const coreStoreStream = (0, stream_chain_1.chain)([
+            strapi.db.queryBuilder('strapi::core-store').stream(),
+            (data) => (0, fp_1.set)('value', JSON.parse(data.value), data),
+            wrapConfigurationItem('core-store'),
+        ]);
+        // Webhook
+        const webhooksStream = (0, stream_chain_1.chain)([
+            strapi.db.queryBuilder('webhook').stream(),
+            wrapConfigurationItem('webhook'),
+        ]);
+        const streams = [coreStoreStream, webhooksStream];
         for (const stream of streams) {
             for await (const item of stream) {
                 yield item;

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/entities.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEntitiesTransformStream = exports.createEntitiesStream = void 0;
 const stream_1 = require("stream");
-const shared = __importStar(require("../shared/strapi"));
+const shared = __importStar(require("../../queries"));
 /**
  * Generate and consume content-types streams in order to stream each entity individually
  */
@@ -48,10 +48,17 @@ const createEntitiesStream = (strapi) => {
     }
     return stream_1.Readable.from((async function* entitiesGenerator() {
         for await (const { stream, contentType } of contentTypeStreamGenerator()) {
-            for await (const entity of stream) {
-                yield { entity, contentType };
+            try {
+                for await (const entity of stream) {
+                    yield { entity, contentType };
+                }
+            }
+            catch {
+                // ignore
+            }
+            finally {
+                stream.destroy();
             }
-            stream.destroy();
         }
     })());
 };

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/index.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="lodash" />
 import { Readable } from 'stream';
-import type { IMetadata, ISourceProvider, ProviderType } from '../../../types';
+import type { IMetadata, ISourceProvider, ProviderType } from '../../../../types';
 export interface ILocalStrapiSourceProviderOptions {
     getStrapi(): Strapi.Strapi | Promise<Strapi.Strapi>;
     autoDestroy?: boolean;
@@ -16,12 +16,12 @@ declare class LocalStrapiSourceProvider implements ISourceProvider {
     bootstrap(): Promise<void>;
     close(): Promise<void>;
     getMetadata(): IMetadata;
-    streamEntities(): Promise<Readable>;
-    streamLinks(): Readable;
-    streamConfiguration(): Readable;
+    createEntitiesReadStream(): Promise<Readable>;
+    createLinksReadStream(): Readable;
+    createConfigurationReadStream(): Readable;
     getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;
-    streamSchemas(): Readable;
-    streamAssets(): Readable;
+    createSchemasReadStream(): Readable;
+    createAssetsReadStream(): Readable;
 }
 export declare type ILocalStrapiSourceProvider = InstanceType<typeof LocalStrapiSourceProvider>;
 export {};

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/index.js

@@ -30,7 +30,7 @@ const entities_1 = require("./entities");
 const links_1 = require("./links");
 const configuration_1 = require("./configuration");
 const assets_1 = require("./assets");
-const utils = __importStar(require("../../utils"));
+const utils = __importStar(require("../../../utils"));
 const createLocalStrapiSourceProvider = (options) => {
     return new LocalStrapiSourceProvider(options);
 };
@@ -67,7 +67,7 @@ class LocalStrapiSourceProvider {
             },
         };
     }
-    async streamEntities() {
+    async createEntitiesReadStream() {
         if (!this.strapi) {
             throw new Error('Not able to stream entities. Strapi instance not found');
         }
@@ -78,13 +78,13 @@ class LocalStrapiSourceProvider {
             (0, entities_1.createEntitiesTransformStream)(),
         ]);
     }
-    streamLinks() {
+    createLinksReadStream() {
         if (!this.strapi) {
             throw new Error('Not able to stream links. Strapi instance not found');
         }
         return (0, links_1.createLinksStream)(this.strapi);
     }
-    streamConfiguration() {
+    createConfigurationReadStream() {
         if (!this.strapi) {
             throw new Error('Not able to stream configuration. Strapi instance not found');
         }
@@ -100,10 +100,10 @@ class LocalStrapiSourceProvider {
         };
         return utils.schema.mapSchemasValues(schemas);
     }
-    streamSchemas() {
+    createSchemasReadStream() {
         return stream_1.Readable.from(Object.values(this.getSchemas()));
     }
-    streamAssets() {
+    createAssetsReadStream() {
         if (!this.strapi) {
             throw new Error('Not able to stream assets. Strapi instance not found');
         }

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/links.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinksStream = void 0;
 const stream_1 = require("stream");
-const link_1 = require("../shared/strapi/link");
+const link_1 = require("../../queries/link");
 /**
  * Create a Readable which will stream all the links from a Strapi instance
  */

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

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { WebSocket } from 'ws';
+import { Writable } from 'stream';
+import { createDispatcher } from './utils';
+import type { IDestinationProvider, IMetadata, ProviderType } from '../../../../types';
+import type { ILocalStrapiDestinationProviderOptions } from '../local-destination';
+interface ITokenAuth {
+    type: 'token';
+    token: string;
+}
+interface ICredentialsAuth {
+    type: 'credentials';
+    email: string;
+    password: string;
+}
+export interface IRemoteStrapiDestinationProviderOptions extends Pick<ILocalStrapiDestinationProviderOptions, 'restore' | 'strategy'> {
+    url: URL;
+    auth?: ITokenAuth | ICredentialsAuth;
+}
+declare class RemoteStrapiDestinationProvider implements IDestinationProvider {
+    #private;
+    name: string;
+    type: ProviderType;
+    options: IRemoteStrapiDestinationProviderOptions;
+    ws: WebSocket | null;
+    dispatcher: ReturnType<typeof createDispatcher> | null;
+    constructor(options: IRemoteStrapiDestinationProviderOptions);
+    initTransfer(): Promise<string>;
+    bootstrap(): Promise<void>;
+    close(): Promise<void>;
+    getMetadata(): Promise<IMetadata | null> | null;
+    beforeTransfer(): Promise<void>;
+    getSchemas(): Promise<Strapi.Schemas | null>;
+    createEntitiesWriteStream(): Writable;
+    createLinksWriteStream(): Writable;
+    createConfigurationWriteStream(): Writable;
+    createAssetsWriteStream(): Writable | Promise<Writable>;
+}
+export declare const createRemoteStrapiDestinationProvider: (options: IRemoteStrapiDestinationProviderOptions) => RemoteStrapiDestinationProvider;
+export {};