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

package/dist/providers/test-utils/index.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setGlobalStrapi = exports.createMockedQueryBuilder = exports.createMockedReadableFactory = exports.getContentTypes = exports.getStrapiFactory = exports.collect = void 0;
+const stream_1 = require("stream");
+/**
+ * Collect every entity in a Readable stream
+ */
+const collect = (stream) => {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream
+            .on('data', (chunk) => chunks.push(chunk))
+            .on('close', () => resolve(chunks))
+            .on('error', reject);
+    });
+};
+exports.collect = collect;
+/**
+ * Create a "Strapi" like object factory based on the
+ * given params and cast it to the correct type
+ */
+const getStrapiFactory = (properties) => () => {
+    return { ...properties };
+};
+exports.getStrapiFactory = getStrapiFactory;
+/**
+ * Factory to get default content types test values
+ */
+const getContentTypes = () => ({
+    foo: { uid: 'foo', attributes: { title: { type: 'string' } } },
+    bar: { uid: 'bar', attributes: { age: { type: 'number' } } },
+});
+exports.getContentTypes = getContentTypes;
+/**
+ * Create a factory of readable streams (wrapped with a jest mock function)
+ */
+const createMockedReadableFactory = (source) => jest.fn((uid) => {
+    return stream_1.Readable.from(source[uid] || []);
+});
+exports.createMockedReadableFactory = createMockedReadableFactory;
+/**
+ * Create a factory of mocked query builders
+ */
+const createMockedQueryBuilder = (data) => jest.fn((uid) => {
+    const state = { populate: undefined };
+    return {
+        populate(populate) {
+            state.populate = populate;
+            return this;
+        },
+        stream() {
+            return stream_1.Readable.from(data[uid]);
+        },
+    };
+});
+exports.createMockedQueryBuilder = createMockedQueryBuilder;
+/**
+ * Update the global store with the given strapi value
+ */
+const setGlobalStrapi = (strapi) => {
+    global.strapi = strapi;
+};
+exports.setGlobalStrapi = setGlobalStrapi;
+//# sourceMappingURL=index.js.map

package/dist/strategies/index.d.ts

@@ -1,7 +1,7 @@
-import type { Diff } from '../../types';
+import type { Diff } from '../utils/json';
 declare const strategies: {
-    exact: (diffs: Diff[]) => Diff[];
-    strict: (diffs: Diff[]) => Diff[];
+    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

@@ -1,13 +1,36 @@
 "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 });
-const utils_1 = require("../utils");
+const utils = __importStar(require("../utils"));
 const strategies = {
     // No diffs
-    exact: (diffs) => {
+    exact(diffs) {
         return diffs;
     },
     // Diffs allowed on specific attributes properties
-    strict: (diffs) => {
+    strict(diffs) {
         const isIgnorableDiff = ({ path }) => {
             return (path.length === 3 &&
                 // Root property must be attributes
@@ -22,7 +45,7 @@ const strategies = {
     },
 };
 const compareSchemas = (a, b, strategy) => {
-    const diffs = (0, utils_1.jsonDiffs)(a, b);
+    const diffs = utils.json.diff(a, b);
     return strategies[strategy](diffs);
 };
 exports.default = compareSchemas;

package/dist/utils/index.d.ts

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

package/dist/utils/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.schema = exports.json = exports.stream = void 0;
+exports.stream = __importStar(require("./stream"));
+exports.json = __importStar(require("./json"));
+exports.schema = __importStar(require("./schema"));
+//# sourceMappingURL=index.js.map

package/dist/utils/json.d.ts

@@ -0,0 +1,23 @@
+export declare const diff: (a: unknown, b: unknown, ctx?: Context) => Diff[];
+export interface AddedDiff<T = unknown> {
+    kind: 'added';
+    path: string[];
+    type: string;
+    value: T;
+}
+export interface ModifiedDiff<T = unknown, P = unknown> {
+    kind: 'modified';
+    path: string[];
+    types: [string, string];
+    values: [T, P];
+}
+export interface DeletedDiff<T = unknown> {
+    kind: 'deleted';
+    path: string[];
+    type: string;
+    value: T;
+}
+export declare type Diff = AddedDiff | ModifiedDiff | DeletedDiff;
+export interface Context {
+    path: string[];
+}

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

@@ -1,25 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapSchemasValues = exports.jsonDiffs = exports.collect = void 0;
+exports.diff = 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 diff = (a, b, ctx = createContext()) => {
     const diffs = [];
     const { path } = ctx;
+    const aType = typeof a;
+    const bType = typeof b;
     // Define helpers
     const added = () => {
         diffs.push({ kind: 'added', path, type: bType, value: b });
@@ -38,8 +26,6 @@ const jsonDiffs = (a, b, ctx = createContext()) => {
         });
         return diffs;
     };
-    const aType = typeof a;
-    const bType = typeof b;
     if (aType === 'undefined') {
         return added();
     }
@@ -50,9 +36,9 @@ const jsonDiffs = (a, b, ctx = createContext()) => {
         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);
+            const kDiffs = (0, exports.diff)(aItem, bItem, kCtx);
             diffs.push(...kDiffs);
-            k++;
+            k += 1;
         }
         return diffs;
     }
@@ -61,7 +47,7 @@ const jsonDiffs = (a, b, ctx = createContext()) => {
         for (const key of keys) {
             const aValue = a[key];
             const bValue = b[key];
-            const nestedDiffs = (0, exports.jsonDiffs)(aValue, bValue, { path: [...path, key] });
+            const nestedDiffs = (0, exports.diff)(aValue, bValue, { path: [...path, key] });
             diffs.push(...nestedDiffs);
         }
         return diffs;
@@ -71,20 +57,5 @@ const jsonDiffs = (a, b, ctx = createContext()) => {
     }
     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
+exports.diff = diff;
+//# sourceMappingURL=json.js.map

package/dist/utils/schema.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="lodash" />
+import type { Schema } from '@strapi/strapi';
+export declare const mapSchemasValues: (schemas: Record<string, Schema>) => import("lodash").Dictionary<Partial<Schema>>;

package/dist/utils/schema.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapSchemasValues = void 0;
+const fp_1 = require("lodash/fp");
+const schemaSelectedKeys = [
+    'collectionName',
+    'info',
+    'options',
+    'pluginOptions',
+    'attributes',
+    'kind',
+    'modelType',
+    'modelName',
+    'uid',
+    'plugin',
+    'globalId',
+];
+const mapSchemasValues = (schemas) => {
+    return (0, fp_1.mapValues)((0, fp_1.pick)(schemaSelectedKeys), schemas);
+};
+exports.mapSchemasValues = mapSchemasValues;
+//# sourceMappingURL=schema.js.map

package/dist/utils/stream.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Transform, Readable } from 'stream';
+declare type TransformOptions = ConstructorParameters<typeof Transform>[0];
+export declare const filter: <T>(predicate: (value: T) => boolean | Promise<boolean>, options?: TransformOptions) => Transform;
+export declare const map: <T>(predicate: (value: T) => T | Promise<T>, options?: TransformOptions) => Transform;
+/**
+ * Collect every entity in a Readable stream
+ */
+export declare const collect: <T = unknown>(stream: Readable) => Promise<T[]>;
+export {};

package/dist/utils/stream.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collect = exports.map = exports.filter = void 0;
+const stream_1 = require("stream");
+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;
+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 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;
+//# sourceMappingURL=stream.js.map

package/jest.config.js

@@ -5,8 +5,10 @@ const pkg = require('./package.json');
 
 module.exports = {
   ...baseConfig,
-  preset: 'ts-jest',
   displayName: (pkg.strapi && pkg.strapi.name) || pkg.name,
   roots: [__dirname],
   testMatch: ['**/__tests__/**/*.test.ts'],
+  transform: {
+    '^.+\\.(t|j)sx?$': ['@swc/jest'],
+  },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/data-transfer",
-  "version": "0.0.0",
+  "version": "4.6.0-beta.1",
   "description": "Data transfer capabilities for Strapi",
   "keywords": [
     "strapi",
@@ -37,8 +37,8 @@
     "lib": "./dist"
   },
   "dependencies": {
-    "@strapi/logger": "4.5.2",
-    "@strapi/strapi": "4.5.2",
+    "@strapi/logger": "4.6.0-beta.1",
+    "@strapi/strapi": "4.6.0-beta.1",
     "chalk": "4.1.2",
     "fs-extra": "10.0.0",
     "lodash": "4.17.21",
@@ -64,5 +64,6 @@
   "engines": {
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
-  }
+  },
+  "gitHead": "2c0bcabdf0bf2a269fed50c6f23ba777845968a0"
 }

package/dist/providers/local-strapi-destination-provider.d.ts

@@ -1,22 +0,0 @@
-/// <reference types="node" />
-import type { IDestinationProvider, IMetadata, ProviderType } from '../../types';
-import { Duplex } from 'stream';
-interface ILocalStrapiDestinationProviderOptions {
-    getStrapi(): Promise<Strapi.Strapi>;
-}
-export declare const createLocalStrapiDestinationProvider: (options: ILocalStrapiDestinationProviderOptions) => LocalStrapiDestinationProvider;
-declare class LocalStrapiDestinationProvider implements IDestinationProvider {
-    name: string;
-    type: ProviderType;
-    options: ILocalStrapiDestinationProviderOptions;
-    strapi?: Strapi.Strapi;
-    constructor(options: ILocalStrapiDestinationProviderOptions);
-    bootstrap(): Promise<void>;
-    close(): Promise<void>;
-    getMetadata(): IMetadata | Promise<IMetadata>;
-    getSchemas(): {
-        [x: string]: Partial<any>;
-    };
-    getEntitiesStream(): Duplex;
-}
-export {};

package/dist/providers/local-strapi-destination-provider.js

@@ -1,78 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLocalStrapiDestinationProvider = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const stream_1 = require("stream");
-const utils_1 = require("../utils");
-// TODO: getting some type errors with @strapi/logger that need to be resolved first
-// const log = createLogger();
-const log = console;
-const createLocalStrapiDestinationProvider = (options) => {
-    return new LocalStrapiDestinationProvider(options);
-};
-exports.createLocalStrapiDestinationProvider = createLocalStrapiDestinationProvider;
-class LocalStrapiDestinationProvider {
-    constructor(options) {
-        this.name = 'destination::local-strapi';
-        this.type = 'destination';
-        this.options = options;
-    }
-    async bootstrap() {
-        this.strapi = await this.options.getStrapi();
-    }
-    async close() {
-        await this.strapi?.destroy?.();
-    }
-    // TODO
-    getMetadata() {
-        return {};
-    }
-    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);
-    }
-    getEntitiesStream() {
-        const self = this;
-        return new stream_1.Duplex({
-            objectMode: true,
-            async write(entity, _encoding, callback) {
-                if (!self.strapi) {
-                    callback(new Error('Strapi instance not found'));
-                }
-                const { type: uid, id, data } = entity;
-                try {
-                    await strapi.entityService.create(uid, { data });
-                }
-                catch (e) {
-                    // TODO: remove "any" cast
-                    log.warn(chalk_1.default.bold(`Failed to import ${chalk_1.default.yellowBright(uid)} (${chalk_1.default.greenBright(id)})`));
-                    e.details.errors
-                        .map((err, i) => {
-                        // TODO: add correct error type
-                        const info = {
-                            uid: chalk_1.default.yellowBright(`[${uid}]`),
-                            path: chalk_1.default.blueBright(`[${err.path.join('.')}]`),
-                            id: chalk_1.default.greenBright(`[${id}]`),
-                            message: err.message,
-                        };
-                        return `(${i}) ${info.uid}${info.id}${info.path}: ${info.message}`;
-                    })
-                        .forEach((message) => log.warn(message));
-                }
-                finally {
-                    callback();
-                }
-            },
-        });
-    }
-}
-//# sourceMappingURL=local-strapi-destination-provider.js.map

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

@@ -1,37 +0,0 @@
-"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

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