@strapi/strapi 4.9.0-alpha.0 → 4.9.0-beta.2

package/lib/commands/transfer/transfer.js

@@ -1,56 +1,62 @@
 'use strict';
 
-const { createTransferEngine } = require('@strapi/data-transfer/lib/engine');
 const {
-  providers: {
-    createRemoteStrapiDestinationProvider,
-    createLocalStrapiSourceProvider,
-    createLocalStrapiDestinationProvider,
+  engine: { createTransferEngine },
+  strapi: {
+    providers: {
+      createRemoteStrapiDestinationProvider,
+      createLocalStrapiSourceProvider,
+      createLocalStrapiDestinationProvider,
+      createRemoteStrapiSourceProvider,
+    },
   },
-} = require('@strapi/data-transfer/lib/strapi');
+} = require('@strapi/data-transfer');
 const { isObject } = require('lodash/fp');
-const chalk = require('chalk');
 
 const {
   buildTransferTable,
   createStrapiInstance,
   DEFAULT_IGNORED_CONTENT_TYPES,
   formatDiagnostic,
+  loadersFactory,
+  exitMessageText,
+  abortTransfer,
 } = require('./utils');
-
-const logger = console;
+const { exitWith } = require('../utils/helpers');
 
 /**
  * @typedef TransferCommandOptions Options given to the CLI transfer command
  *
  * @property {URL|undefined} [to] The url of a remote Strapi to use as remote destination
  * @property {URL|undefined} [from] The url of a remote Strapi to use as remote source
+ * @property {string|undefined} [toToken] The transfer token for the remote Strapi destination
+ * @property {string|undefined} [fromToken] The transfer token for the remote Strapi source
+ * @property {(keyof import('@strapi/data-transfer/src/engine').TransferGroupFilter)[]} [only] If present, only include these filtered groups of data
+ * @property {(keyof import('@strapi/data-transfer/src/engine').TransferGroupFilter)[]} [exclude] If present, exclude these filtered groups of data
+ * @property {number|undefined} [throttle] Delay in ms after each record
  */
 
 /**
  * Transfer command.
  *
- * It transfers data from a local file to a local strapi instance
+ * Transfers data between local Strapi and remote Strapi instances
  *
  * @param {TransferCommandOptions} opts
  */
 module.exports = async (opts) => {
   // Validate inputs from Commander
   if (!isObject(opts)) {
-    logger.error('Could not parse command arguments');
-    process.exit(1);
+    exitWith(1, 'Could not parse command arguments');
   }
 
-  const strapi = await createStrapiInstance();
+  if (!(opts.from || opts.to) || (opts.from && opts.to)) {
+    exitWith(1, 'Exactly one source (from) or destination (to) option must be provided');
+  }
 
+  const strapi = await createStrapiInstance();
   let source;
   let destination;
 
-  if (!opts.from && !opts.to) {
-    logger.error('At least one source (from) or destination (to) option must be provided');
-    process.exit(1);
-  }
-
   // if no URL provided, use local Strapi
   if (!opts.from) {
     source = createLocalStrapiSourceProvider({
@@ -59,21 +65,42 @@ module.exports = async (opts) => {
   }
   // if URL provided, set up a remote source provider
   else {
-    logger.error(`Remote Strapi source provider not yet implemented`);
-    process.exit(1);
+    if (!opts.fromToken) {
+      exitWith(1, 'Missing token for remote destination');
+    }
+
+    source = createRemoteStrapiSourceProvider({
+      getStrapi: () => strapi,
+      url: opts.from,
+      auth: {
+        type: 'token',
+        token: opts.fromToken,
+      },
+    });
   }
 
   // if no URL provided, use local Strapi
   if (!opts.to) {
     destination = createLocalStrapiDestinationProvider({
       getStrapi: () => strapi,
+      strategy: 'restore',
+      restore: {
+        entities: { exclude: DEFAULT_IGNORED_CONTENT_TYPES },
+      },
     });
   }
   // if URL provided, set up a remote destination provider
   else {
+    if (!opts.toToken) {
+      exitWith(1, 'Missing token for remote destination');
+    }
+
     destination = createRemoteStrapiDestinationProvider({
       url: opts.to,
-      auth: false,
+      auth: {
+        type: 'token',
+        token: opts.toToken,
+      },
       strategy: 'restore',
       restore: {
         entities: { exclude: DEFAULT_IGNORED_CONTENT_TYPES },
@@ -82,13 +109,15 @@ module.exports = async (opts) => {
   }
 
   if (!source || !destination) {
-    logger.error('Could not create providers');
-    process.exit(1);
+    exitWith(1, 'Could not create providers');
   }
 
   const engine = createTransferEngine(source, destination, {
-    versionStrategy: 'strict',
+    versionStrategy: 'exact',
     schemaStrategy: 'strict',
+    exclude: opts.exclude,
+    only: opts.only,
+    throttle: opts.throttle,
     transforms: {
       links: [
         {
@@ -112,18 +141,42 @@ module.exports = async (opts) => {
 
   engine.diagnostics.onDiagnostic(formatDiagnostic('transfer'));
 
-  try {
-    logger.log(`Starting transfer...`);
+  const progress = engine.progress.stream;
+
+  const { updateLoader } = loadersFactory();
 
-    const results = await engine.transfer();
+  progress.on(`stage::start`, ({ stage, data }) => {
+    updateLoader(stage, data).start();
+  });
+
+  progress.on('stage::finish', ({ stage, data }) => {
+    updateLoader(stage, data).succeed();
+  });
 
-    const table = buildTransferTable(results.engine);
-    logger.log(table.toString());
+  progress.on('stage::progress', ({ stage, data }) => {
+    updateLoader(stage, data);
+  });
 
-    logger.log(`${chalk.bold('Transfer process has been completed successfully!')}`);
-    process.exit(0);
+  progress.on('stage::error', ({ stage, data }) => {
+    updateLoader(stage, data).fail();
+  });
+
+  let results;
+  try {
+    console.log(`Starting transfer...`);
+
+    // Abort transfer if user interrupts process
+    ['SIGTERM', 'SIGINT', 'SIGQUIT'].forEach((signal) => {
+      process.removeAllListeners(signal);
+      process.on(signal, () => abortTransfer({ engine, strapi }));
+    });
+
+    results = await engine.transfer();
   } catch (e) {
-    logger.error('Transfer process failed.');
-    process.exit(1);
+    exitWith(1, exitMessageText('transfer', true));
   }
+
+  const table = buildTransferTable(results.engine);
+  console.log(table.toString());
+  exitWith(0, exitMessageText('transfer'));
 };

package/lib/commands/transfer/utils.js

@@ -3,15 +3,30 @@
 const chalk = require('chalk');
 const Table = require('cli-table3');
 const { Option } = require('commander');
-const { TransferGroupPresets } = require('@strapi/data-transfer/lib/engine');
+const {
+  engine: { TransferGroupPresets },
+} = require('@strapi/data-transfer');
 
 const {
   configs: { createOutputFileConfiguration },
   createLogger,
 } = require('@strapi/logger');
+const ora = require('ora');
 const { readableBytes, exitWith } = require('../utils/helpers');
 const strapi = require('../../index');
-const { getParseListWithChoices } = require('../utils/commander');
+const { getParseListWithChoices, parseInteger } = require('../utils/commander');
+
+const exitMessageText = (process, error = false) => {
+  const processCapitalized = process[0].toUpperCase() + process.slice(1);
+
+  if (!error) {
+    return chalk.bold(
+      chalk.green(`${processCapitalized} process has been completed successfully!`)
+    );
+  }
+
+  return chalk.bold(chalk.red(`${processCapitalized} process failed.`));
+};
 
 const pad = (n) => {
   return (n < 10 ? '0' : '') + String(n);
@@ -82,15 +97,28 @@ const DEFAULT_IGNORED_CONTENT_TYPES = [
   'admin::role',
   'admin::api-token',
   'admin::api-token-permission',
+  'admin::transfer-token',
+  'admin::transfer-token-permission',
   'admin::audit-log',
 ];
 
-const createStrapiInstance = async (logLevel = 'error') => {
+const abortTransfer = async ({ engine, strapi }) => {
+  try {
+    await engine.abortTransfer();
+    await strapi.destroy();
+  } catch (e) {
+    // ignore because there's not much else we can do
+    return false;
+  }
+  return true;
+};
+
+const createStrapiInstance = async (opts = {}) => {
   try {
     const appContext = await strapi.compile();
-    const app = strapi(appContext);
+    const app = strapi({ ...opts, ...appContext });
 
-    app.log.level = logLevel;
+    app.log.level = opts.logLevel || 'error';
     return await app.load();
   } catch (err) {
     if (err.code === 'ECONNREFUSED') {
@@ -102,6 +130,13 @@ const createStrapiInstance = async (logLevel = 'error') => {
 
 const transferDataTypes = Object.keys(TransferGroupPresets);
 
+const throttleOption = new Option(
+  '--throttle <delay after each entity>',
+  `Add a delay in milliseconds between each transferred entity`
+)
+  .argParser(parseInteger)
+  .hideHelp(); // This option is not publicly documented
+
 const excludeOption = new Option(
   '--exclude <comma-separated data types>',
   `Exclude data using comma-separated types. Available types: ${transferDataTypes.join(',')}`
@@ -169,13 +204,55 @@ const formatDiagnostic =
     }
   };
 
+const loadersFactory = (defaultLoaders = {}) => {
+  const loaders = defaultLoaders;
+  const updateLoader = (stage, data) => {
+    if (!(stage in loaders)) {
+      createLoader(stage);
+    }
+    const stageData = data[stage];
+    const elapsedTime = stageData?.startTime
+      ? (stageData?.endTime || Date.now()) - stageData.startTime
+      : 0;
+    const size = `size: ${readableBytes(stageData?.bytes ?? 0)}`;
+    const elapsed = `elapsed: ${elapsedTime} ms`;
+    const speed =
+      elapsedTime > 0 ? `(${readableBytes(((stageData?.bytes ?? 0) * 1000) / elapsedTime)}/s)` : '';
+
+    loaders[stage].text = `${stage}: ${stageData?.count ?? 0} transfered (${size}) (${elapsed}) ${
+      !stageData?.endTime ? speed : ''
+    }`;
+
+    return loaders[stage];
+  };
+
+  const createLoader = (stage) => {
+    Object.assign(loaders, { [stage]: ora() });
+    return loaders[stage];
+  };
+
+  const getLoader = (stage) => {
+    return loaders[stage];
+  };
+
+  return {
+    updateLoader,
+    createLoader,
+    getLoader,
+  };
+};
+
 module.exports = {
+  loadersFactory,
   buildTransferTable,
   getDefaultExportName,
   DEFAULT_IGNORED_CONTENT_TYPES,
   createStrapiInstance,
   excludeOption,
+  exitMessageText,
   onlyOption,
+  throttleOption,
   validateExcludeOnly,
   formatDiagnostic,
+  abortTransfer,
 };

package/lib/commands/utils/commander.js

@@ -7,6 +7,7 @@
 const inquirer = require('inquirer');
 const { InvalidOptionArgumentError, Option } = require('commander');
 const { bold, green, cyan } = require('chalk');
+const { isNaN } = require('lodash/fp');
 const { exitWith } = require('./helpers');
 
 /**
@@ -40,6 +41,18 @@ const getParseListWithChoices = (choices, errorMessage = 'Invalid options:') =>
   };
 };
 
+/**
+ * argParser: Parse a string as an integer
+ */
+const parseInteger = (value) => {
+  // parseInt takes a string and a radix
+  const parsedValue = parseInt(value, 10);
+  if (isNaN(parsedValue)) {
+    throw new InvalidOptionArgumentError(`Not an integer: ${value}`);
+  }
+  return parsedValue;
+};
+
 /**
  * argParser: Parse a string as a URL object
  */
@@ -96,8 +109,9 @@ const promptEncryptionKey = async (thisCommand) => {
  *
  * @param {string} message The message to confirm with user
  * @param {object} options Additional options
+ * @param {string|undefined} options.failMessage The message to display when prompt is not confirmed
  */
-const confirmMessage = (message) => {
+const confirmMessage = (message, { failMessage } = {}) => {
   return async (command) => {
     // if we have a force option, assume yes
     const opts = command.opts();
@@ -116,7 +130,7 @@ const confirmMessage = (message) => {
       },
     ]);
     if (!answers.confirm) {
-      exitWith(0);
+      exitWith(1, failMessage);
     }
   };
 };
@@ -130,6 +144,7 @@ module.exports = {
   getParseListWithChoices,
   parseList,
   parseURL,
+  parseInteger,
   promptEncryptionKey,
   confirmMessage,
   forceOption,

package/lib/commands/utils/helpers.js

@@ -36,22 +36,29 @@ const readableBytes = (bytes, decimals = 1, padStart = 0) => {
  *
  * @param {number} code Code to exit process with
  * @param {string | Array} message Message(s) to display before exiting
+ * @param {Object} options
+ * @param {console} options.logger - logger object, defaults to console
+ * @param {process} options.prc - process object, defaults to process
+ *
  */
-const exitWith = (code, message = undefined) => {
-  const logger = (message) => {
+const exitWith = (code, message = undefined, options = {}) => {
+  const { logger = console, prc = process } = options;
+
+  const log = (message) => {
     if (code === 0) {
-      console.log(chalk.green(message));
+      logger.log(chalk.green(message));
     } else {
-      console.error(chalk.red(message));
+      logger.error(chalk.red(message));
     }
   };
 
   if (isString(message)) {
-    logger(message);
+    log(message);
   } else if (isArray(message)) {
-    message.forEach((msg) => logger(msg));
+    message.forEach((msg) => log(msg));
   }
-  process.exit(code);
+
+  prc.exit(code);
 };
 
 /**

package/lib/core/registries/hooks.d.ts

@@ -1,4 +1,3 @@
-
 type Handler = (context: any) => any;
 
 type AsyncHook = {
@@ -8,7 +7,6 @@ type AsyncHook = {
   call(): Promise<void>;
 };
 
-
 type SyncHook = {
   get handlers(): Handler[];
   register(handler: Handler): this;
@@ -16,5 +14,4 @@ type SyncHook = {
   call(): void;
 };
 
-
-export type Hook = AsyncHook|SyncHook
+export type Hook = AsyncHook | SyncHook;

package/lib/core/registries/policies.d.ts

@@ -6,4 +6,8 @@ interface PolicyContext extends BaseContext {
   is(name): boolean;
 }
 
-export type Policy<T=unknown> = (ctx: PolicyContext,cfg:T, { strapi: Strapi }) => boolean | undefined;
+export type Policy<T = unknown> = (
+  ctx: PolicyContext,
+  cfg: T,
+  { strapi: Strapi }
+) => boolean | undefined;

package/lib/core-api/controller/collection-type.js

@@ -19,9 +19,8 @@ const createCollectionTypeController = ({ contentType }) => {
      * @return {Object|Array}
      */
     async find(ctx) {
-      const { query } = ctx;
-
-      const { results, pagination } = await strapi.service(uid).find(query);
+      const sanitizedQuery = await this.sanitizeQuery(ctx);
+      const { results, pagination } = await strapi.service(uid).find(sanitizedQuery);
       const sanitizedResults = await this.sanitizeOutput(results, ctx);
 
       return this.transformResponse(sanitizedResults, { pagination });

package/lib/core-api/controller/index.js

@@ -29,6 +29,12 @@ const createController = ({ contentType }) => {
 
       return sanitize.contentAPI.input(data, contentType, { auth });
     },
+
+    sanitizeQuery(ctx) {
+      const auth = getAuthFromKoaContext(ctx);
+
+      return sanitize.contentAPI.query(ctx.query, contentType, { auth });
+    },
   };
 
   let ctrl;

package/lib/core-api/controller/single-type.js

@@ -18,9 +18,9 @@ const createSingleTypeController = ({ contentType }) => {
      * @return {Object|Array}
      */
     async find(ctx) {
-      const { query } = ctx;
+      const sanitizedQuery = await this.sanitizeQuery(ctx);
+      const entity = await strapi.service(uid).find(sanitizedQuery);
 
-      const entity = await strapi.service(uid).find(query);
       const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
 
       return this.transformResponse(sanitizedEntity);

package/lib/global.d.ts

@@ -1,5 +1,10 @@
 import type { Strapi as StrapiInterface } from './types/core';
-import type { CollectionTypeSchema, SingleTypeSchema, ComponentSchema, ContentTypeSchema } from './types/core/schemas';
+import type {
+  CollectionTypeSchema,
+  SingleTypeSchema,
+  ComponentSchema,
+  ContentTypeSchema,
+} from './types/core/schemas';
 import type { KeysBy } from './types/utils';
 
 declare global {
@@ -7,7 +12,7 @@ declare global {
     /**
      * Map of UID / schemas used as a schemas database for other types.
      * It must be extended by the user application or plugins.
-     * 
+     *
      * @example
      * ```ts
      * declare global {
@@ -39,12 +44,12 @@ declare global {
     /**
      * Literal union type of every component registered in Strapi.Schemas
      */
-     type ComponentUIDs = KeysBy<Schemas, ComponentSchema>;
+    type ComponentUIDs = KeysBy<Schemas, ComponentSchema>;
 
-     /**
-      * Global shorthand to access the `StrapiInterface` type
-      */
-     type Strapi = StrapiInterface;
+    /**
+     * Global shorthand to access the `StrapiInterface` type
+     */
+    type Strapi = StrapiInterface;
   }
 
   /**

package/lib/index.d.ts

@@ -2,4 +2,4 @@ import './global';
 
 export * from './types';
 
-export default function(opts): Strapi;
+export default function (opts): Strapi;

package/lib/services/auth/index.js

@@ -43,7 +43,28 @@ const createAuthentication = () => {
         return next();
       }
 
-      const strategiesToUse = strategies[route.info.type];
+      const routeStrategies = strategies[route.info.type];
+      const configStrategies = config?.strategies ?? routeStrategies ?? [];
+
+      const strategiesToUse = configStrategies.reduce((acc, strategy) => {
+        // Resolve by strategy name
+        if (typeof strategy === 'string') {
+          const routeStrategy = routeStrategies.find((rs) => rs.name === strategy);
+
+          if (routeStrategy) {
+            acc.push(routeStrategy);
+          }
+        }
+
+        // Use the given strategy as is
+        else if (typeof strategy === 'object') {
+          validStrategy(strategy);
+
+          acc.push(strategy);
+        }
+
+        return acc;
+      }, []);
 
       for (const strategy of strategiesToUse) {
         const result = await strategy.authenticate(ctx);

package/lib/services/cron.js

@@ -14,10 +14,15 @@ const createCronService = () => {
 
         let fn;
         let options;
+        let taskName;
         if (isFunction(taskValue)) {
+          // don't use task name if key is the rule
+          taskName = null;
           fn = taskValue.bind(tasks);
           options = taskExpression;
         } else if (isFunction(taskValue.task)) {
+          // set task name if key is not the rule
+          taskName = taskExpression;
           fn = taskValue.task.bind(taskValue);
           options = taskValue.options;
         } else {
@@ -29,7 +34,7 @@ const createCronService = () => {
         const fnWithStrapi = (...args) => fn({ strapi }, ...args);
 
         const job = new Job(null, fnWithStrapi);
-        jobsSpecs.push({ job, options });
+        jobsSpecs.push({ job, options, name: taskName });
 
         if (running) {
           job.schedule(options);
@@ -37,6 +42,13 @@ const createCronService = () => {
       }
       return this;
     },
+    remove(name) {
+      if (!name) throw new Error('You must provide a name to remove a cron job.');
+      const matchingJobsSpecs = jobsSpecs.filter(({ name: jobSpecName }) => jobSpecName === name);
+      matchingJobsSpecs.forEach(({ job }) => job.cancel());
+      jobsSpecs = jobsSpecs.filter(({ name: jobSpecName }) => jobSpecName !== name);
+      return this;
+    },
     start() {
       jobsSpecs.forEach(({ job, options }) => job.schedule(options));
       running = true;
@@ -52,6 +64,7 @@ const createCronService = () => {
       jobsSpecs = [];
       return this;
     },
+    jobs: jobsSpecs,
   };
 };
 

package/lib/services/entity-service/index.d.ts

@@ -88,7 +88,7 @@ export interface EntityService {
   ): Promise<any>;
 }
 
-export default function(opts: {
+export default function (opts: {
   strapi: Strapi;
   db: Database;
   // TODO: define types

package/lib/types/core/attributes/component.d.ts

@@ -25,13 +25,10 @@ export type ComponentAttribute<
   PrivateOption &
   RequiredOption;
 
-export type ComponentValue<T extends Strapi.ComponentUIDs, R extends boolean> = GetAttributesValues<
-  T
-> extends infer V
-  ? R extends true
-    ? V[]
-    : V
-  : never;
+export type ComponentValue<
+  T extends Strapi.ComponentUIDs,
+  R extends boolean
+> = GetAttributesValues<T> extends infer V ? (R extends true ? V[] : V) : never;
 
 export type GetComponentAttributeValue<T extends Attribute> = T extends ComponentAttribute<
   infer U,

package/lib/types/core/attributes/utils.d.ts

@@ -83,11 +83,10 @@ export type GetAttributeValueByKey<
 export type GetAttributesValues<T extends SchemaUID> = {
   // Handle required attributes
   [key in GetAttributesRequiredKeys<T>]-?: GetAttributeValueByKey<T, key>;
-} &
-  {
-    // Handle optional attributes
-    [key in GetAttributesOptionalKeys<T>]?: GetAttributeValueByKey<T, key>;
-  };
+} & {
+  // Handle optional attributes
+  [key in GetAttributesOptionalKeys<T>]?: GetAttributeValueByKey<T, key>;
+};
 
 export type GetAttributesRequiredKeys<T extends SchemaUID> = KeysBy<
   GetAttributes<T>,

package/lib/types/core/index.d.ts

@@ -1,3 +1,3 @@
 export * from './attributes';
-export * from  './schemas';
-export * from './strapi'
+export * from './schemas';
+export * from './strapi';

package/lib/types/index.d.ts

@@ -1,4 +1,4 @@
 export * from './core';
 
-export * as utils from './utils'
-export * as factories from './factories';
+export * as utils from './utils';
+export * as factories from './factories';