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

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

@@ -1,4 +1,6 @@
 /// <reference types="node" />
+/// <reference types="lodash" />
+import { Readable } from 'stream';
 import type { IMetadata, ISourceProvider, ProviderType } from '../../../types';
 export interface ILocalStrapiSourceProviderOptions {
     getStrapi(): Strapi.Strapi | Promise<Strapi.Strapi>;
@@ -14,13 +16,12 @@ declare class LocalStrapiSourceProvider implements ISourceProvider {
     bootstrap(): Promise<void>;
     close(): Promise<void>;
     getMetadata(): IMetadata;
-    streamEntities(): Promise<NodeJS.ReadableStream>;
-    streamLinks(): NodeJS.ReadableStream;
-    streamConfiguration(): NodeJS.ReadableStream;
-    getSchemas(): {
-        [x: string]: Partial<any>;
-    };
-    streamSchemas(): NodeJS.ReadableStream;
+    streamEntities(): Promise<Readable>;
+    streamLinks(): Readable;
+    streamConfiguration(): Readable;
+    getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;
+    streamSchemas(): Readable;
+    streamAssets(): Readable;
 }
 export declare type ILocalStrapiSourceProvider = InstanceType<typeof LocalStrapiSourceProvider>;
 export {};

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

@@ -1,4 +1,27 @@
 "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.createLocalStrapiSourceProvider = void 0;
 const stream_chain_1 = require("stream-chain");
@@ -6,7 +29,8 @@ 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 assets_1 = require("./assets");
+const utils = __importStar(require("../../utils"));
 const createLocalStrapiSourceProvider = (options) => {
     return new LocalStrapiSourceProvider(options);
 };
@@ -74,10 +98,16 @@ class LocalStrapiSourceProvider {
             ...this.strapi.contentTypes,
             ...this.strapi.components,
         };
-        return (0, utils_1.mapSchemasValues)(schemas);
+        return utils.schema.mapSchemasValues(schemas);
     }
     streamSchemas() {
         return stream_1.Readable.from(Object.values(this.getSchemas()));
     }
+    streamAssets() {
+        if (!this.strapi) {
+            throw new Error('Not able to stream assets. Strapi instance not found');
+        }
+        return (0, assets_1.createAssetsStream)(this.strapi);
+    }
 }
 //# sourceMappingURL=index.js.map

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

@@ -1,5 +1,5 @@
 import { Readable } from 'stream';
 /**
- * Create a Duplex instance which will stream all the links from a Strapi instance
+ * Create a Readable 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.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinksStream = void 0;
+const stream_1 = require("stream");
+const link_1 = require("../shared/strapi/link");
+/**
+ * Create a Readable which will stream all the links from a Strapi instance
+ */
+const createLinksStream = (strapi) => {
+    const uids = [...Object.keys(strapi.contentTypes), ...Object.keys(strapi.components)];
+    // Async generator stream that returns every link from a Strapi instance
+    return stream_1.Readable.from((async function* linkGenerator() {
+        const query = (0, link_1.createLinkQuery)(strapi);
+        for (const uid of uids) {
+            const generator = query().generateAll(uid);
+            for await (const link of generator) {
+                yield link;
+            }
+        }
+    })());
+};
+exports.createLinksStream = createLinksStream;
+//# sourceMappingURL=links.js.map

package/dist/providers/shared/index.d.ts

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

package/dist/providers/shared/index.js

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

package/dist/providers/shared/strapi/entity.d.ts

@@ -0,0 +1,19 @@
+import type { ContentTypeSchema } from '@strapi/strapi';
+declare const createEntityQuery: (strapi: Strapi.Strapi) => (uid: string) => {
+    create: <T extends {
+        data: U;
+    }, U extends object>(params: T) => Promise<any>;
+    createMany: <T_1 extends {
+        data: U_1[];
+    }, U_1 extends object>(params: T_1) => Promise<{
+        count: number;
+    }>;
+    deleteMany: <T_2 extends object>(params?: T_2 | undefined) => Promise<{
+        count: number;
+    } | null>;
+    getDeepPopulateComponentLikeQuery: (contentType: ContentTypeSchema, params?: {
+        select: string;
+    }) => any;
+    readonly deepPopulateComponentLikeQuery: any;
+};
+export { createEntityQuery };

package/dist/providers/shared/strapi/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/dist/providers/shared/strapi/index.d.ts

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

package/dist/providers/shared/strapi/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/dist/providers/shared/strapi/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/dist/providers/shared/strapi/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/dist/providers/test-utils/index.d.ts

@@ -0,0 +1,111 @@
+/// <reference types="node" />
+/// <reference types="jest" />
+import { Readable } from 'stream';
+/**
+ * Collect every entity in a Readable stream
+ */
+export declare const collect: <T = unknown>(stream: Readable) => Promise<T[]>;
+/**
+ * Create a "Strapi" like object factory based on the
+ * given params and cast it to the correct type
+ */
+export declare const getStrapiFactory: <T extends {
+    readonly EE?: unknown;
+    readonly config?: unknown;
+    readonly auth?: unknown;
+    readonly contentAPI?: unknown;
+    readonly sanitizers?: unknown;
+    readonly services?: unknown;
+    service?: unknown;
+    readonly controllers?: unknown;
+    controller?: unknown;
+    readonly contentTypes?: unknown;
+    contentType?: unknown;
+    readonly components?: unknown;
+    readonly customFields?: unknown;
+    readonly policies?: unknown;
+    policy?: unknown;
+    readonly middlewares?: unknown;
+    middleware?: unknown;
+    readonly plugins?: unknown;
+    plugin?: unknown;
+    readonly hooks?: unknown;
+    hook?: unknown;
+    readonly api?: unknown;
+    register?: unknown;
+    bootstrap?: unknown;
+    destroy?: unknown;
+    runLifecyclesFunctions?: unknown;
+    start?: unknown;
+    stopWithError?: unknown;
+    stop?: unknown;
+    load?: unknown;
+    reload?: unknown;
+    startWebhooks?: unknown;
+    postListen?: unknown;
+    listen?: unknown;
+    openAdmin?: unknown;
+    loadAdmin?: unknown;
+    loadPlugins?: unknown;
+    loadPolicies?: unknown;
+    loadAPIs?: unknown;
+    loadComponents?: unknown;
+    loadMiddlewares?: unknown;
+    loadApp?: unknown;
+    registerInternalHooks?: unknown;
+    getModel?: unknown;
+    query?: unknown;
+    container?: unknown;
+    dirs?: unknown;
+    isLoaded?: unknown;
+    server?: unknown;
+    fs?: unknown;
+    eventHub?: unknown;
+    startupLogger?: unknown;
+    log?: unknown;
+    cron?: unknown;
+    telemetry?: unknown;
+    db?: unknown;
+    store?: unknown;
+    entityValidator?: unknown;
+    entityService?: unknown;
+}>(properties?: T | undefined) => () => import("@strapi/strapi").Strapi;
+/**
+ * Union type used to represent the default content types available
+ */
+export declare type ContentType = 'foo' | 'bar';
+/**
+ * Factory to get default content types test values
+ */
+export declare const getContentTypes: () => {
+    foo: {
+        uid: "foo";
+        attributes: {
+            [attribute: string]: unknown;
+        };
+    };
+    bar: {
+        uid: "bar";
+        attributes: {
+            [attribute: string]: unknown;
+        };
+    };
+};
+/**
+ * Create a factory of readable streams (wrapped with a jest mock function)
+ */
+export declare const createMockedReadableFactory: <T extends string = ContentType>(source: { [ct in T]: {
+    [key: string]: unknown;
+    id: number;
+}[]; }) => jest.Mock<Readable, [uid: T]>;
+/**
+ * Create a factory of mocked query builders
+ */
+export declare const createMockedQueryBuilder: <T extends string = ContentType>(data: { [key in T]: unknown[]; }) => jest.Mock<{
+    populate(populate: unknown): any;
+    stream(): Readable;
+}, [uid: T]>;
+/**
+ * Update the global store with the given strapi value
+ */
+export declare const setGlobalStrapi: (strapi: Strapi.Strapi) => void;