@strapi/data-transfer 4.7.0 → 4.7.1

package/dist/providers/local-strapi-source-provider/index.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalStrapiSourceProvider = void 0;
+const stream_chain_1 = require("stream-chain");
+const stream_1 = require("stream");
+const entities_1 = require("./entities");
+const links_1 = require("./links");
+const configuration_1 = require("./configuration");
+const utils_1 = require("../../utils");
+const createLocalStrapiSourceProvider = (options) => {
+    return new LocalStrapiSourceProvider(options);
+};
+exports.createLocalStrapiSourceProvider = createLocalStrapiSourceProvider;
+class LocalStrapiSourceProvider {
+    constructor(options) {
+        this.name = 'source::local-strapi';
+        this.type = 'source';
+        this.options = options;
+    }
+    async bootstrap() {
+        this.strapi = await this.options.getStrapi();
+    }
+    async close() {
+        const { autoDestroy } = this.options;
+        // Basically `!== false` but more deterministic
+        if (autoDestroy === undefined || autoDestroy === true) {
+            await this.strapi?.destroy();
+        }
+    }
+    getMetadata() {
+        const strapiVersion = strapi.config.get('info.strapi');
+        const createdAt = new Date().toISOString();
+        const plugins = Object.keys(strapi.plugins);
+        return {
+            createdAt,
+            strapi: {
+                version: strapiVersion,
+                plugins: plugins.map((name) => ({
+                    name,
+                    // TODO: Get the plugin actual version when it'll be available
+                    version: strapiVersion,
+                })),
+            },
+        };
+    }
+    async streamEntities() {
+        if (!this.strapi) {
+            throw new Error('Not able to stream entities. Strapi instance not found');
+        }
+        return (0, stream_chain_1.chain)([
+            // Entities stream
+            (0, entities_1.createEntitiesStream)(this.strapi),
+            // Transform stream
+            (0, entities_1.createEntitiesTransformStream)(),
+        ]);
+    }
+    streamLinks() {
+        if (!this.strapi) {
+            throw new Error('Not able to stream links. Strapi instance not found');
+        }
+        return (0, links_1.createLinksStream)(this.strapi);
+    }
+    streamConfiguration() {
+        if (!this.strapi) {
+            throw new Error('Not able to stream configuration. Strapi instance not found');
+        }
+        return (0, configuration_1.createConfigurationStream)(strapi);
+    }
+    getSchemas() {
+        if (!this.strapi) {
+            throw new Error('Not able to get Schemas. Strapi instance not found');
+        }
+        const schemas = {
+            ...this.strapi.contentTypes,
+            ...this.strapi.components,
+        };
+        return (0, utils_1.mapSchemasValues)(schemas);
+    }
+    streamSchemas() {
+        return stream_1.Readable.from(Object.values(this.getSchemas()));
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/providers/local-strapi-source-provider/links/index.d.ts

@@ -0,0 +1,5 @@
+import { Readable } from 'stream';
+/**
+ * Create a Duplex instance which will stream all the links from a Strapi instance
+ */
+export declare const createLinksStream: (strapi: Strapi.Strapi) => Readable;

package/dist/providers/local-strapi-source-provider/links/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinksStream = void 0;
+const stream_1 = require("stream");
+const fp_1 = require("lodash/fp");
+const utils_1 = require("./utils");
+/**
+ * Create a Duplex instance which will stream all the links from a Strapi instance
+ */
+const createLinksStream = (strapi) => {
+    const schemas = Object.values(strapi.contentTypes);
+    // Destroy the Duplex stream instance
+    const destroy = () => {
+        if (!stream.destroyed) {
+            stream.destroy();
+        }
+    };
+    // Async generator stream that returns every link from a Strapi instance
+    const stream = stream_1.Readable.from((async function* () {
+        for (const schema of schemas) {
+            const populate = (0, utils_1.getDeepPopulateQuery)(schema, strapi);
+            const query = { fields: ['id'], populate };
+            // TODO: Replace with the DB stream API
+            const results = await strapi.entityService.findMany(schema.uid, query);
+            for (const entity of (0, fp_1.castArray)(results)) {
+                const links = (0, utils_1.parseEntityLinks)(entity, populate, schema, strapi);
+                for (const link of links) {
+                    yield link;
+                }
+            }
+        }
+        destroy();
+    })());
+    return stream;
+};
+exports.createLinksStream = createLinksStream;
+//# sourceMappingURL=index.js.map

package/dist/providers/local-strapi-source-provider/links/utils.d.ts

@@ -0,0 +1,27 @@
+import type { RelationsType } from '@strapi/strapi';
+import type { ILink } from '../../../../types';
+/**
+ * Parse every links from an entity result (including nested components and dynamic zone levels)
+ */
+export declare const parseEntityLinks: (entity: any, populate: any, schema: any, strapi: any) => any[];
+/**
+ * Parse links contained in a relational attribute
+ */
+export declare const parseRelationLinks: ({ entity, schema, fieldName, value }: any) => ILink[];
+/**
+ * Get a deep populate query for a given schema
+ * It will populate first level for relations and media as well as
+ * first-level relations for nested components and dynamic zones' components
+ */
+export declare const getDeepPopulateQuery: (schema: any, strapi: any) => {
+    [key: string]: any;
+};
+/**
+ * Domain util to create a link
+ * TODO: Move that to the domain layer when we'll update it
+ */
+export declare const linkBuilder: <T extends ILink = ILink>(kind: T["kind"], relation: RelationsType) => {
+    left(type: string, ref: string | number, field: string, pos?: number | undefined): any;
+    right(type: string, ref: string | number, field?: string | undefined): any;
+    readonly value: ILink | null;
+};

package/dist/providers/local-strapi-source-provider/links/utils.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkBuilder = exports.getDeepPopulateQuery = exports.parseRelationLinks = exports.parseEntityLinks = void 0;
+const fp_1 = require("lodash/fp");
+// TODO: Fix any typings when we'll have better Strapi types
+/**
+ * Parse every links from an entity result (including nested components and dynamic zone levels)
+ */
+const parseEntityLinks = (entity, populate, schema, strapi) => {
+    if (!entity) {
+        return [];
+    }
+    if (Array.isArray(entity)) {
+        return entity
+            .map((item) => (0, exports.parseEntityLinks)(item, populate, schema, strapi))
+            .reduce(fp_1.concat, [])
+            .flat();
+    }
+    const { attributes } = schema;
+    const links = [];
+    for (const key of Object.keys(populate)) {
+        const attribute = attributes[key];
+        const value = entity[key];
+        const subPopulate = populate[key];
+        // Ignore nil values (relations, components or dynamic zones not set)
+        if (!value) {
+            continue;
+        }
+        // Components
+        // Recurse to find relations
+        if (attribute.type === 'component') {
+            const componentSchema = strapi.components[attribute.component];
+            const componentLinks = (0, exports.parseEntityLinks)(value, subPopulate.populate, componentSchema, strapi);
+            links.push(...componentLinks);
+        }
+        // Dynamic Zones
+        // We need to extract links from each items in the DZ's components
+        if (attribute.type === 'dynamiczone') {
+            const dzLinks = value
+                .map(({ __component, ...item }) => (0, exports.parseEntityLinks)(item, subPopulate.populate, strapi.components[__component], strapi))
+                .reduce((acc, links) => acc.concat(...links), []);
+            links.push(...dzLinks);
+        }
+        // Relations
+        // If it's a regular relation, extract the links but do not recurse further
+        if (attribute.type === 'relation') {
+            const relationLinks = (0, exports.parseRelationLinks)({ entity, fieldName: key, value, schema });
+            links.push(...relationLinks);
+        }
+    }
+    return links;
+};
+exports.parseEntityLinks = parseEntityLinks;
+/**
+ * Parse links contained in a relational attribute
+ */
+const parseRelationLinks = ({ entity, schema, fieldName, value }) => {
+    const attribute = schema.attributes[fieldName];
+    const { relation, target } = attribute;
+    // Handle ToMany relations
+    if (Array.isArray(value)) {
+        return (value
+            // Get links from value
+            .map((item) => (0, exports.parseRelationLinks)({ entity, schema, fieldName, value: item }))
+            // Flatten the results, to make sure we're dealing with the right data structure
+            .flat()
+            // Update the pos with the relation index in the collection
+            .map((link, i) => (0, fp_1.set)('left.pos', i, link)));
+    }
+    const isMorphRelation = relation.startsWith('morph');
+    const isCircularRelation = !isMorphRelation && target === schema.uid;
+    const kind = isMorphRelation
+        ? // Polymorphic relations
+            'relation.morph'
+        : isCircularRelation
+            ? // Self referencing relations
+                'relation.circular'
+            : // Regular relations
+                'relation.basic';
+    const link = (0, exports.linkBuilder)(kind, relation)
+        .left(schema.uid, entity.id, fieldName)
+        .right(target, value.id, attribute.inversedBy).value;
+    return link ? [link] : [];
+};
+exports.parseRelationLinks = parseRelationLinks;
+/**
+ * Get a deep populate query for a given schema
+ * It will populate first level for relations and media as well as
+ * first-level relations for nested components and dynamic zones' components
+ */
+const getDeepPopulateQuery = (schema, strapi) => {
+    const populate = {};
+    for (const [key, attribute] of Object.entries(schema.attributes)) {
+        const setPopulateKey = (value) => {
+            populate[key] = value;
+        };
+        // Owning side of a relation
+        if (attribute.type === 'relation' && !attribute.mappedBy) {
+            setPopulateKey({ fields: ['id'] });
+        }
+        // Media
+        if (attribute.type === 'media') {
+            setPopulateKey({ fields: ['id'] });
+        }
+        // Dynamic zone (nested structure)
+        if (attribute.type === 'dynamiczone') {
+            const subPopulate = {};
+            for (const component of attribute.components) {
+                const componentSchema = strapi.components[component];
+                const componentPopulate = (0, exports.getDeepPopulateQuery)(componentSchema, strapi);
+                // FIXME: Same problem as when trying to populate dynamic zones,
+                // we don't have a way to discriminate components queries (which
+                // can cause issue when components share same fields name)
+                Object.assign(subPopulate, componentPopulate);
+            }
+            if (!(0, fp_1.isEmpty)(subPopulate)) {
+                setPopulateKey({ fields: ['id'], populate: subPopulate });
+            }
+        }
+        // Component (nested structure)
+        if (attribute.type === 'component') {
+            const componentSchema = strapi.components[attribute.component];
+            const componentPopulate = (0, exports.getDeepPopulateQuery)(componentSchema, strapi);
+            if (!(0, fp_1.isEmpty)(componentPopulate)) {
+                setPopulateKey({ fields: ['id'], populate: componentPopulate });
+            }
+        }
+    }
+    return populate;
+};
+exports.getDeepPopulateQuery = getDeepPopulateQuery;
+/**
+ * Domain util to create a link
+ * TODO: Move that to the domain layer when we'll update it
+ */
+const linkBuilder = (kind, relation) => {
+    const link = {};
+    link.kind = kind;
+    link.relation = relation;
+    return {
+        left(type, ref, field, pos) {
+            link.left = { type, ref, field, pos };
+            return this;
+        },
+        right(type, ref, field) {
+            link.right = { type, ref, field };
+            return this;
+        },
+        get value() {
+            return link.left && link.right ? link : null;
+        },
+    };
+};
+exports.linkBuilder = linkBuilder;
+//# sourceMappingURL=utils.js.map

package/dist/strategies/index.d.ts

@@ -0,0 +1,7 @@
+import type { Diff } from '../../types';
+declare const strategies: {
+    exact: (diffs: Diff[]) => Diff[];
+    strict: (diffs: Diff[]) => Diff[];
+};
+declare const compareSchemas: <T, P>(a: T, b: P, strategy: keyof typeof strategies) => Diff[];
+export default compareSchemas;

package/dist/strategies/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const strategies = {
+    // No diffs
+    exact: (diffs) => {
+        return diffs;
+    },
+    // Diffs allowed on specific attributes properties
+    strict: (diffs) => {
+        const isIgnorableDiff = ({ path }) => {
+            return (path.length === 3 &&
+                // Root property must be attributes
+                path[0] === 'attributes' &&
+                // Need a valid string attribute name
+                typeof path[1] === 'string' &&
+                // The diff must be on ignorable attribute properties
+                ['private', 'required', 'configurable'].includes(path[2]));
+        };
+        const shouldKeepDiff = (diff) => !isIgnorableDiff(diff);
+        return diffs.filter(shouldKeepDiff);
+    },
+};
+const compareSchemas = (a, b, strategy) => {
+    const diffs = (0, utils_1.jsonDiffs)(a, b);
+    return strategies[strategy](diffs);
+};
+exports.default = compareSchemas;
+//# sourceMappingURL=index.js.map

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import type { Readable } from 'stream';
+import type { Context, Diff } from '../types';
+/**
+ * Collect every entity in a Readable stream
+ */
+export declare const collect: <T = unknown>(stream: Readable) => Promise<T[]>;
+export declare const jsonDiffs: (a: unknown, b: unknown, ctx?: Context) => Diff[];
+export declare const mapSchemasValues: (schemas: any) => {
+    [x: string]: Partial<any>;
+};

package/dist/utils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapSchemasValues = exports.jsonDiffs = exports.collect = void 0;
+const fp_1 = require("lodash/fp");
+/**
+ * Collect every entity in a Readable stream
+ */
+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 diffs = [];
+    const { path } = ctx;
+    // Define helpers
+    const added = () => {
+        diffs.push({ kind: 'added', path, type: bType, value: b });
+        return diffs;
+    };
+    const deleted = () => {
+        diffs.push({ kind: 'deleted', path, type: aType, value: a });
+        return diffs;
+    };
+    const modified = () => {
+        diffs.push({
+            kind: 'modified',
+            path,
+            types: [aType, bType],
+            values: [a, b],
+        });
+        return diffs;
+    };
+    const aType = typeof a;
+    const bType = typeof b;
+    if (aType === 'undefined') {
+        return added();
+    }
+    if (bType === 'undefined') {
+        return deleted();
+    }
+    if ((0, fp_1.isArray)(a) && (0, fp_1.isArray)(b)) {
+        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);
+            diffs.push(...kDiffs);
+            k++;
+        }
+        return diffs;
+    }
+    if ((0, fp_1.isObject)(a) && (0, fp_1.isObject)(b)) {
+        const keys = (0, fp_1.uniq)(Object.keys(a).concat(Object.keys(b)));
+        for (const key of keys) {
+            const aValue = a[key];
+            const bValue = b[key];
+            const nestedDiffs = (0, exports.jsonDiffs)(aValue, bValue, { path: [...path, key] });
+            diffs.push(...nestedDiffs);
+        }
+        return diffs;
+    }
+    if (!(0, fp_1.isEqual)(a, b)) {
+        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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/data-transfer",
-  "version": "4.7.0",
+  "version": "4.7.1",
   "description": "Data transfer capabilities for Strapi",
   "keywords": [
     "strapi",
@@ -39,8 +39,8 @@
     "lib": "./lib"
   },
   "dependencies": {
-    "@strapi/logger": "4.7.0",
-    "@strapi/strapi": "4.7.0",
+    "@strapi/logger": "4.7.1",
+    "@strapi/strapi": "4.7.1",
     "chalk": "4.1.2",
     "fs-extra": "10.0.0",
     "lodash": "4.17.21",
@@ -73,5 +73,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "948dbb3121330ffd43f3a4f55522c797770e0b2a"
+  "gitHead": "0307fb4bf7b006c4cd902412967d3987d7810ed8"
 }