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

package/lib/strapi/providers/local-source/assets.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAssetsStream = void 0;
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const stream_1 = require("stream");
+const IGNORED_FILES = ['.gitkeep'];
+/**
+ * Generate and consume assets streams in order to stream each file individually
+ */
+const createAssetsStream = (strapi) => {
+    const assetsDirectory = (0, path_1.join)(strapi.dirs.static.public, 'uploads');
+    const generator = async function* () {
+        const files = await (0, fs_extra_1.readdir)(assetsDirectory);
+        const validFiles = files.filter((file) => !IGNORED_FILES.includes(file));
+        for (const filename of validFiles) {
+            const filepath = (0, path_1.join)(assetsDirectory, filename);
+            const stats = await (0, fs_extra_1.stat)(filepath);
+            const stream = (0, fs_extra_1.createReadStream)(filepath);
+            yield {
+                filename,
+                filepath,
+                stream,
+                stats: { size: stats.size },
+            };
+        }
+    };
+    return stream_1.Duplex.from(generator());
+};
+exports.createAssetsStream = createAssetsStream;
+//# sourceMappingURL=assets.js.map

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* () {
+    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/lib/strapi/providers/local-source/entities.js

@@ -0,0 +1,85 @@
+"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.createEntitiesTransformStream = exports.createEntitiesStream = void 0;
+const stream_1 = require("stream");
+const shared = __importStar(require("../../queries"));
+/**
+ * Generate and consume content-types streams in order to stream each entity individually
+ */
+const createEntitiesStream = (strapi) => {
+    const contentTypes = Object.values(strapi.contentTypes);
+    async function* contentTypeStreamGenerator() {
+        for (const contentType of contentTypes) {
+            const query = shared.entity.createEntityQuery(strapi).call(null, contentType.uid);
+            const stream = strapi.db
+                // Create a query builder instance (default type is 'select')
+                .queryBuilder(contentType.uid)
+                // Fetch all columns
+                .select('*')
+                // Apply the populate
+                .populate(query.deepPopulateComponentLikeQuery)
+                // Get a readable stream
+                .stream();
+            yield { contentType, stream };
+        }
+    }
+    return stream_1.Readable.from((async function* entitiesGenerator() {
+        for await (const { stream, contentType } of contentTypeStreamGenerator()) {
+            try {
+                for await (const entity of stream) {
+                    yield { entity, contentType };
+                }
+            }
+            catch {
+                // ignore
+            }
+            finally {
+                stream.destroy();
+            }
+        }
+    })());
+};
+exports.createEntitiesStream = createEntitiesStream;
+/**
+ * Create an entity transform stream which convert the output of
+ * the multi-content-types stream to the transfer entity format
+ */
+const createEntitiesTransformStream = () => {
+    return new stream_1.PassThrough({
+        objectMode: true,
+        transform(data, _encoding, callback) {
+            const { entity, contentType } = data;
+            const { id, ...attributes } = entity;
+            callback(null, {
+                type: contentType.uid,
+                id,
+                data: attributes,
+            });
+        },
+    });
+};
+exports.createEntitiesTransformStream = createEntitiesTransformStream;
+//# sourceMappingURL=entities.js.map

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

@@ -1,5 +1,7 @@
 /// <reference types="node" />
-import type { IMetadata, ISourceProvider, ProviderType } from '../../../types';
+/// <reference types="lodash" />
+import { Readable } from 'stream';
+import type { IMetadata, ISourceProvider, ProviderType } from '../../../../types';
 export interface ILocalStrapiSourceProviderOptions {
     getStrapi(): Strapi.Strapi | Promise<Strapi.Strapi>;
     autoDestroy?: boolean;
@@ -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;
+    createEntitiesReadStream(): Promise<Readable>;
+    createLinksReadStream(): Readable;
+    createConfigurationReadStream(): Readable;
+    getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;
+    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

@@ -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);
 };
@@ -43,7 +67,7 @@ class LocalStrapiSourceProvider {
             },
         };
     }
-    async streamEntities() {
+    async createEntitiesReadStream() {
         if (!this.strapi) {
             throw new Error('Not able to stream entities. Strapi instance not found');
         }
@@ -54,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');
         }
@@ -74,10 +98,16 @@ class LocalStrapiSourceProvider {
             ...this.strapi.contentTypes,
             ...this.strapi.components,
         };
-        return (0, utils_1.mapSchemasValues)(schemas);
+        return utils.schema.mapSchemasValues(schemas);
     }
-    streamSchemas() {
+    createSchemasReadStream() {
         return stream_1.Readable.from(Object.values(this.getSchemas()));
     }
+    createAssetsReadStream() {
+        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 → lib/strapi/providers/local-source/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/lib/strapi/providers/local-source/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("../../queries/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/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 {};

package/lib/strapi/providers/remote-destination/index.js

@@ -0,0 +1,171 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RemoteStrapiDestinationProvider_instances, _RemoteStrapiDestinationProvider_streamStep;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemoteStrapiDestinationProvider = void 0;
+const ws_1 = require("ws");
+const uuid_1 = require("uuid");
+const stream_1 = require("stream");
+const utils_1 = require("./utils");
+const constants_1 = require("../../remote/constants");
+class RemoteStrapiDestinationProvider {
+    constructor(options) {
+        _RemoteStrapiDestinationProvider_instances.add(this);
+        this.name = 'destination::remote-strapi';
+        this.type = 'destination';
+        this.options = options;
+        this.ws = null;
+        this.dispatcher = null;
+    }
+    async initTransfer() {
+        const { strategy, restore } = this.options;
+        // Wait for the connection to be made to the server, then init the transfer
+        return new Promise((resolve, reject) => {
+            this.ws
+                ?.once('open', async () => {
+                const query = this.dispatcher?.dispatchCommand({
+                    command: 'init',
+                    params: { options: { strategy, restore }, transfer: 'push' },
+                });
+                const res = (await query);
+                if (!res?.transferID) {
+                    return reject(new Error('Init failed, invalid response from the server'));
+                }
+                resolve(res.transferID);
+            })
+                .once('error', reject);
+        });
+    }
+    async bootstrap() {
+        const { url, auth } = this.options;
+        let ws;
+        if (!['https:', 'http:'].includes(url.protocol)) {
+            throw new Error(`Invalid protocol "${url.protocol}"`);
+        }
+        const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+        const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}`;
+        // No auth defined, trying public access for transfer
+        if (!auth) {
+            ws = new ws_1.WebSocket(wsUrl);
+        }
+        // Common token auth, this should be the main auth method
+        else if (auth.type === 'token') {
+            const headers = { Authorization: `Bearer ${auth.token}` };
+            ws = new ws_1.WebSocket(wsUrl, { headers });
+        }
+        // Invalid auth method provided
+        else {
+            throw new Error('Auth method not implemented');
+        }
+        this.ws = ws;
+        this.dispatcher = (0, utils_1.createDispatcher)(this.ws);
+        const transferID = await this.initTransfer();
+        this.dispatcher.setTransferProperties({ id: transferID, kind: 'push' });
+        await this.dispatcher.dispatchTransferAction('bootstrap');
+    }
+    async close() {
+        await this.dispatcher?.dispatchTransferAction('close');
+        await new Promise((resolve) => {
+            const { ws } = this;
+            if (!ws || ws.CLOSED) {
+                resolve();
+                return;
+            }
+            ws.on('close', () => resolve()).close();
+        });
+    }
+    getMetadata() {
+        return this.dispatcher?.dispatchTransferAction('getMetadata') ?? null;
+    }
+    async beforeTransfer() {
+        await this.dispatcher?.dispatchTransferAction('beforeTransfer');
+    }
+    getSchemas() {
+        if (!this.dispatcher) {
+            return Promise.resolve(null);
+        }
+        return this.dispatcher.dispatchTransferAction('getSchemas');
+    }
+    createEntitiesWriteStream() {
+        return new stream_1.Writable({
+            objectMode: true,
+            write: async (entity, _encoding, callback) => {
+                const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'entities', entity);
+                callback(e);
+            },
+        });
+    }
+    createLinksWriteStream() {
+        return new stream_1.Writable({
+            objectMode: true,
+            write: async (link, _encoding, callback) => {
+                const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'links', link);
+                callback(e);
+            },
+        });
+    }
+    createConfigurationWriteStream() {
+        return new stream_1.Writable({
+            objectMode: true,
+            write: async (configuration, _encoding, callback) => {
+                const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'configuration', configuration);
+                callback(e);
+            },
+        });
+    }
+    createAssetsWriteStream() {
+        return new stream_1.Writable({
+            objectMode: true,
+            final: async (callback) => {
+                // TODO: replace this stream call by an end call
+                const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', null);
+                callback(e);
+            },
+            write: async (asset, _encoding, callback) => {
+                const { filename, filepath, stats, stream } = asset;
+                const assetID = (0, uuid_1.v4)();
+                await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', {
+                    action: 'start',
+                    assetID,
+                    data: { filename, filepath, stats },
+                });
+                for await (const chunk of stream) {
+                    await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', {
+                        action: 'stream',
+                        assetID,
+                        data: chunk,
+                    });
+                }
+                await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', {
+                    action: 'end',
+                    assetID,
+                });
+                callback();
+            },
+        });
+    }
+}
+_RemoteStrapiDestinationProvider_instances = new WeakSet(), _RemoteStrapiDestinationProvider_streamStep = async function _RemoteStrapiDestinationProvider_streamStep(step, data) {
+    try {
+        await this.dispatcher?.dispatchTransferStep({ action: 'stream', step, data });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return e;
+        }
+        if (typeof e === 'string') {
+            return new Error(e);
+        }
+        return new Error('Unexpected error');
+    }
+    return null;
+};
+const createRemoteStrapiDestinationProvider = (options) => {
+    return new RemoteStrapiDestinationProvider(options);
+};
+exports.createRemoteStrapiDestinationProvider = createRemoteStrapiDestinationProvider;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,31 @@
+import { WebSocket } from 'ws';
+import type { client } from '../../../../types/remote/protocol';
+interface IDispatcherState {
+    transfer?: {
+        kind: client.TransferKind;
+        id: string;
+    };
+}
+interface IDispatchOptions {
+    attachTransfer?: boolean;
+}
+declare type Dispatch<T> = Omit<T, 'transferID' | 'uuid'>;
+declare const createDispatcher: (ws: WebSocket) => {
+    readonly transferID: string | undefined;
+    readonly transferKind: "push" | "pull" | undefined;
+    setTransferProperties: (properties: Exclude<IDispatcherState['transfer'], undefined>) => void;
+    dispatch: <U = null>(message: Dispatch<client.Message>, options?: IDispatchOptions) => Promise<U | null>;
+    dispatchCommand: <U_1 extends "end" | "init" | "status">(payload: {
+        command: U_1;
+    } & ([client.GetCommandParams<U_1>] extends [never] ? unknown : {
+        params: client.GetCommandParams<U_1>;
+    })) => Promise<null>;
+    dispatchTransferAction: <T>(action: client.Action['action']) => Promise<T | null>;
+    dispatchTransferStep: <T_1, A extends "stream" | "end" | "start" = "stream" | "end" | "start", S extends "entities" | "links" | "configuration" | "assets" = "entities" | "links" | "configuration" | "assets">(payload: {
+        step: S;
+        action: A;
+    } & (A extends "stream" ? {
+        data: client.GetTransferPushStreamData<S>;
+    } : unknown)) => Promise<T_1 | null>;
+};
+export { createDispatcher };

package/lib/strapi/providers/remote-destination/utils.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDispatcher = void 0;
+const uuid_1 = require("uuid");
+const createDispatcher = (ws) => {
+    const state = {};
+    const dispatch = async (message, options = {}) => {
+        if (!ws) {
+            throw new Error('No websocket connection found');
+        }
+        return new Promise((resolve, reject) => {
+            const uuid = (0, uuid_1.v4)();
+            const payload = { ...message, uuid };
+            if (options.attachTransfer) {
+                Object.assign(payload, { transferID: state.transfer?.id });
+            }
+            const stringifiedPayload = JSON.stringify(payload);
+            ws.send(stringifiedPayload, (error) => {
+                if (error) {
+                    reject(error);
+                }
+            });
+            const onResponse = (raw) => {
+                const response = JSON.parse(raw.toString());
+                if (response.uuid === uuid) {
+                    if (response.error) {
+                        return reject(new Error(response.error.message));
+                    }
+                    resolve(response.data ?? null);
+                }
+                else {
+                    ws.once('message', onResponse);
+                }
+            };
+            // TODO: What happens if the server sends another message (not a response to this message)
+            ws.once('message', onResponse);
+        });
+    };
+    const dispatchCommand = (payload) => {
+        return dispatch({ type: 'command', ...payload });
+    };
+    const dispatchTransferAction = async (action) => {
+        const payload = { type: 'transfer', kind: 'action', action };
+        return dispatch(payload, { attachTransfer: true }) ?? Promise.resolve(null);
+    };
+    const dispatchTransferStep = async (payload) => {
+        const message = {
+            type: 'transfer',
+            kind: 'step',
+            ...payload,
+        };
+        return dispatch(message, { attachTransfer: true }) ?? Promise.resolve(null);
+    };
+    const setTransferProperties = (properties) => {
+        state.transfer = { ...properties };
+    };
+    return {
+        get transferID() {
+            return state.transfer?.id;
+        },
+        get transferKind() {
+            return state.transfer?.kind;
+        },
+        setTransferProperties,
+        dispatch,
+        dispatchCommand,
+        dispatchTransferAction,
+        dispatchTransferStep,
+    };
+};
+exports.createDispatcher = createDispatcher;
+//# sourceMappingURL=utils.js.map

package/lib/strapi/queries/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 };