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

package/lib/strapi/queries/entity.js

@@ -0,0 +1,130 @@
+"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.createEntityQuery = void 0;
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const componentsService = __importStar(require("@strapi/strapi/lib/services/entity-service/components"));
+const fp_1 = require("lodash/fp");
+const sanitizeComponentLikeAttributes = (model, data) => {
+    const { attributes } = model;
+    const componentLikeAttributesKey = Object.entries(attributes)
+        .filter(([, attribute]) => ['component', 'dynamiczone'].includes(attribute.type))
+        .map(([key]) => key);
+    return (0, fp_1.omit)(componentLikeAttributesKey, data);
+};
+const omitInvalidCreationAttributes = (0, fp_1.omit)(['id']);
+const createEntityQuery = (strapi) => {
+    const components = {
+        async assignToEntity(uid, data) {
+            const model = strapi.getModel(uid);
+            const entityComponents = await componentsService.createComponents(uid, data);
+            const dataWithoutComponents = sanitizeComponentLikeAttributes(model, data);
+            return (0, fp_1.assign)(entityComponents, dataWithoutComponents);
+        },
+        async get(uid, entity) {
+            return componentsService.getComponents(uid, entity);
+        },
+        delete(uid, componentsToDelete) {
+            return componentsService.deleteComponents(uid, componentsToDelete, { loadComponents: false });
+        },
+    };
+    const query = (uid) => {
+        const create = async (params) => {
+            const dataWithComponents = await components.assignToEntity(uid, params.data);
+            const sanitizedData = omitInvalidCreationAttributes(dataWithComponents);
+            return strapi.db.query(uid).create({ ...params, data: sanitizedData });
+        };
+        const createMany = async (params) => {
+            return (Promise.resolve(params.data)
+                // Create components for each entity
+                .then((0, fp_1.map)((data) => components.assignToEntity(uid, data)))
+                // Remove unwanted attributes
+                .then((0, fp_1.map)(omitInvalidCreationAttributes))
+                // Execute a strapi db createMany query with all the entities + their created components
+                .then((data) => strapi.db.query(uid).createMany({ ...params, data })));
+        };
+        const deleteMany = async (params) => {
+            const entitiesToDelete = await strapi.db.query(uid).findMany(params ?? {});
+            if (!entitiesToDelete.length) {
+                return null;
+            }
+            const componentsToDelete = await Promise.all(entitiesToDelete.map((entityToDelete) => components.get(uid, entityToDelete)));
+            const deletedEntities = await strapi.db.query(uid).deleteMany(params);
+            await Promise.all(componentsToDelete.map((compos) => components.delete(uid, compos)));
+            return deletedEntities;
+        };
+        const getDeepPopulateComponentLikeQuery = (contentType, params = { select: '*' }) => {
+            const { attributes } = contentType;
+            const populate = {};
+            const entries = Object.entries(attributes);
+            for (const [key, attribute] of entries) {
+                if (attribute.type === 'component') {
+                    const component = strapi.getModel(attribute.component);
+                    const subPopulate = getDeepPopulateComponentLikeQuery(component, params);
+                    if (((0, fp_1.isArray)(subPopulate) || (0, fp_1.isObject)(subPopulate)) && (0, fp_1.size)(subPopulate) > 0) {
+                        populate[key] = { ...params, populate: subPopulate };
+                    }
+                    if ((0, fp_1.isArray)(subPopulate) && (0, fp_1.isEmpty)(subPopulate)) {
+                        populate[key] = { ...params };
+                    }
+                }
+                if (attribute.type === 'dynamiczone') {
+                    const { components: componentsUID } = attribute;
+                    const on = {};
+                    for (const componentUID of componentsUID) {
+                        const component = strapi.getModel(componentUID);
+                        const subPopulate = getDeepPopulateComponentLikeQuery(component, params);
+                        if (((0, fp_1.isArray)(subPopulate) || (0, fp_1.isObject)(subPopulate)) && (0, fp_1.size)(subPopulate) > 0) {
+                            on[componentUID] = { ...params, populate: subPopulate };
+                        }
+                        if ((0, fp_1.isArray)(subPopulate) && (0, fp_1.isEmpty)(subPopulate)) {
+                            on[componentUID] = { ...params };
+                        }
+                    }
+                    populate[key] = (0, fp_1.size)(on) > 0 ? { on } : true;
+                }
+            }
+            const values = Object.values(populate);
+            if (values.every((value) => value === true)) {
+                return Object.keys(populate);
+            }
+            return populate;
+        };
+        return {
+            create,
+            createMany,
+            deleteMany,
+            getDeepPopulateComponentLikeQuery,
+            get deepPopulateComponentLikeQuery() {
+                const contentType = strapi.getModel(uid);
+                return getDeepPopulateComponentLikeQuery(contentType);
+            },
+        };
+    };
+    return query;
+};
+exports.createEntityQuery = createEntityQuery;
+//# sourceMappingURL=entity.js.map

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

@@ -0,0 +1,2 @@
+export * as entity from './entity';
+export * as link from './link';

package/lib/strapi/queries/index.js

@@ -0,0 +1,29 @@
+"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.link = exports.entity = void 0;
+exports.entity = __importStar(require("./entity"));
+exports.link = __importStar(require("./link"));
+//# sourceMappingURL=index.js.map

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

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

package/lib/strapi/queries/link.js

@@ -0,0 +1,201 @@
+"use strict";
+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 query = () => {
+        const { connection } = strapi.db;
+        async function* generateAllForAttribute(uid, fieldName) {
+            const metadata = strapi.db.metadata.get(uid);
+            if (!metadata) {
+                throw new Error(`No metadata found for ${uid}`);
+            }
+            const attributes = filterValidRelationalAttributes(metadata.attributes);
+            if (!(fieldName in attributes)) {
+                throw new Error(`${fieldName} is not a valid relational attribute name`);
+            }
+            const attribute = attributes[fieldName];
+            const kind = getLinkKind(attribute, uid);
+            const { relation, target } = attribute;
+            // The relation is stored in the same table
+            // TODO: handle manyToOne joinColumn
+            if (attribute.joinColumn) {
+                const joinColumnName = attribute.joinColumn.name;
+                const qb = connection.queryBuilder().select('id', joinColumnName).from(metadata.tableName);
+                // TODO: stream the query to improve performances
+                const entries = await qb;
+                for (const entry of entries) {
+                    const ref = entry[joinColumnName];
+                    if (ref !== null) {
+                        yield {
+                            kind,
+                            relation,
+                            left: { type: uid, ref: entry.id, field: fieldName },
+                            right: { type: target, ref },
+                        };
+                    }
+                }
+            }
+            // The relation uses a join table
+            if (attribute.joinTable) {
+                const { name, joinColumn, inverseJoinColumn, orderColumnName, morphColumn, inverseOrderColumnName, } = attribute.joinTable;
+                const qb = connection.queryBuilder().from(name);
+                const columns = {
+                    left: { ref: null },
+                    right: { ref: null },
+                };
+                const left = { type: uid, field: fieldName };
+                const right = {};
+                if (kind === 'relation.basic' || kind === 'relation.circular') {
+                    right.type = attribute.target;
+                    right.field = attribute.inversedBy;
+                    columns.left.ref = joinColumn.name;
+                    columns.right.ref = inverseJoinColumn.name;
+                    if (orderColumnName) {
+                        columns.left.order = orderColumnName;
+                    }
+                    if (inverseOrderColumnName) {
+                        columns.right.order = inverseOrderColumnName;
+                    }
+                }
+                if (kind === 'relation.morph') {
+                    columns.left.ref = joinColumn.name;
+                    columns.right.ref = morphColumn.idColumn.name;
+                    columns.right.type = morphColumn.typeColumn.name;
+                    columns.right.field = 'field';
+                    columns.right.order = 'order';
+                }
+                const validColumns = [
+                    // Left
+                    columns.left.ref,
+                    columns.left.order,
+                    // Right
+                    columns.right.ref,
+                    columns.right.type,
+                    columns.right.field,
+                    columns.right.order,
+                ].filter((column) => !(0, fp_1.isNil)(column));
+                qb.select(validColumns);
+                // TODO: stream the query to improve performances
+                const entries = await qb;
+                for (const entry of entries) {
+                    if (columns.left.ref) {
+                        left.ref = entry[columns.left.ref];
+                    }
+                    if (columns.right.ref) {
+                        right.ref = entry[columns.right.ref];
+                    }
+                    if (columns.left.order) {
+                        left.pos = entry[columns.left.order];
+                    }
+                    if (columns.right.order) {
+                        right.pos = entry[columns.right.order];
+                    }
+                    if (columns.right.type) {
+                        right.type = entry[columns.right.type];
+                    }
+                    if (columns.right.field) {
+                        right.field = entry[columns.right.field];
+                    }
+                    const link = {
+                        kind,
+                        relation,
+                        left: (0, fp_1.clone)(left),
+                        right: (0, fp_1.clone)(right),
+                    };
+                    yield link;
+                }
+            }
+        }
+        async function* generateAll(uid) {
+            const metadata = strapi.db.metadata.get(uid);
+            if (!metadata) {
+                throw new Error(`No metadata found for ${uid}`);
+            }
+            const attributes = filterValidRelationalAttributes(metadata.attributes);
+            for (const fieldName of Object.keys(attributes)) {
+                for await (const link of generateAllForAttribute(uid, fieldName)) {
+                    yield link;
+                }
+            }
+        }
+        const insert = async (link) => {
+            const { kind, left, right } = link;
+            const metadata = strapi.db.metadata.get(left.type);
+            const attribute = metadata.attributes[left.field];
+            const payload = {};
+            if (attribute.joinColumn) {
+                const joinColumnName = attribute.joinColumn.name;
+                await connection(metadata.tableName)
+                    .where('id', left.ref)
+                    .update({ [joinColumnName]: right.ref });
+            }
+            if (attribute.joinTable) {
+                const { name, joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName, morphColumn, } = attribute.joinTable;
+                if (joinColumn) {
+                    Object.assign(payload, { [joinColumn.name]: left.ref });
+                }
+                const assignInverseColumn = () => {
+                    if (inverseJoinColumn) {
+                        Object.assign(payload, {
+                            [inverseJoinColumn.name]: right.ref,
+                        });
+                    }
+                };
+                const assignOrderColumns = () => {
+                    if (orderColumnName) {
+                        Object.assign(payload, { [orderColumnName]: left.pos ?? null });
+                    }
+                    if (inverseOrderColumnName) {
+                        Object.assign(payload, { [inverseOrderColumnName]: right.pos ?? null });
+                    }
+                };
+                const assignMorphColumns = () => {
+                    const { idColumn, typeColumn } = morphColumn ?? {};
+                    if (idColumn) {
+                        Object.assign(payload, { [idColumn.name]: right.ref });
+                    }
+                    if (typeColumn) {
+                        Object.assign(payload, { [typeColumn.name]: right.type });
+                    }
+                    Object.assign(payload, { order: right.pos ?? null, field: right.field ?? null });
+                };
+                if (kind === 'relation.basic' || kind === 'relation.circular') {
+                    assignInverseColumn();
+                }
+                if (kind === 'relation.morph') {
+                    assignMorphColumns();
+                }
+                assignOrderColumns();
+                await connection.insert(payload).into(name);
+            }
+        };
+        return { generateAll, generateAllForAttribute, insert };
+    };
+    return query;
+};
+exports.createLinkQuery = createLinkQuery;
+const filterValidRelationalAttributes = (attributes) => {
+    const isOwner = (attribute) => {
+        return attribute.owner || (!attribute.mappedBy && !attribute.morphBy);
+    };
+    const isComponentLike = (attribute) => {
+        return attribute.component || attribute.components;
+    };
+    return Object.entries(attributes)
+        .filter(([, attribute]) => {
+        return attribute.type === 'relation' && isOwner(attribute) && !isComponentLike(attribute);
+    })
+        .reduce((acc, [key, attribute]) => ({ ...acc, [key]: attribute }), {});
+};
+const getLinkKind = (attribute, uid) => {
+    if (attribute.relation.startsWith('morph')) {
+        return 'relation.morph';
+    }
+    if (attribute.target === uid) {
+        return 'relation.circular';
+    }
+    return 'relation.basic';
+};
+//# sourceMappingURL=link.js.map

package/lib/strapi/register.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This is intended to be called on Strapi register phase.
+ *
+ * It registers a transfer route in the Strapi admin router.
+ */
+declare const register: (strapi: Strapi.Strapi) => void;
+export default register;

package/lib/strapi/register.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const remote_1 = require("./remote");
+/**
+ * This is intended to be called on Strapi register phase.
+ *
+ * It registers a transfer route in the Strapi admin router.
+ */
+const register = (strapi) => {
+    remote_1.routes.registerAdminTransferRoute(strapi);
+};
+exports.default = register;
+//# sourceMappingURL=register.js.map

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

@@ -0,0 +1 @@
+export declare const TRANSFER_PATH = "/transfer";

package/lib/strapi/remote/constants.js

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

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

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

package/{dist → lib/strapi/remote/controllers}/index.js

@@ -14,6 +14,5 @@ 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("./engine"), exports);
-__exportStar(require("./providers"), exports);
+__exportStar(require("./push"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,25 @@
+/// <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>;
+    };
+    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

@@ -0,0 +1,95 @@
+"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();
+            },
+        },
+        transfer: {
+            async entities(entity) {
+                if (!streams.entities) {
+                    streams.entities = provider.createEntitiesWriteStream();
+                }
+                await writeAsync(streams.entities, entity);
+            },
+            async links(link) {
+                if (!streams.links) {
+                    streams.links = await provider.createLinksWriteStream();
+                }
+                await writeAsync(streams.links, link);
+            },
+            async configuration(config) {
+                if (!streams.configuration) {
+                    streams.configuration = await provider.createConfigurationWriteStream();
+                }
+                await writeAsync(streams.configuration, config);
+            },
+            async assets(payload) {
+                // TODO: close the stream upong receiving an 'end' event instead
+                if (payload === null) {
+                    streams.assets?.end();
+                    return;
+                }
+                const { action, assetID } = payload;
+                if (!streams.assets) {
+                    streams.assets = await provider.createAssetsWriteStream();
+                }
+                if (action === 'start') {
+                    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', reject)
+                            .end();
+                    });
+                }
+            },
+        },
+    };
+};
+exports.default = createPushController;
+//# sourceMappingURL=push.js.map

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

@@ -0,0 +1,3 @@
+import type { Context } from 'koa';
+import type { ServerOptions } from 'ws';
+export declare const createTransferHandler: (options?: ServerOptions) => (ctx: Context) => Promise<void>;