@strapi/strapi 4.5.2 → 4.6.0-alpha.0

package/bin/strapi.js

@@ -7,11 +7,18 @@
 const _ = require('lodash');
 const resolveCwd = require('resolve-cwd');
 const { yellow } = require('chalk');
-const { Command } = require('commander');
+const { Command, Option } = require('commander');
+const inquirer = require('inquirer');
 
 const program = new Command();
 
 const packageJSON = require('../package.json');
+const {
+  parseInputList,
+  parseInputBool,
+  promptEncryptionKey,
+  confirmKeyValue,
+} = require('../lib/commands/utils/commander');
 
 const checkCwdIsStrapiApp = (name) => {
   const logErrorAndExit = () => {
@@ -60,6 +67,13 @@ const getLocalScript =
       });
   };
 
+// option to exclude types of data for the export, import, and transfer commands
+// TODO: validate these inputs. Hopefully here, but worst case it may require adding a hook on each command
+const excludeOption = new Option(
+  '--exclude <data,to,exclude>',
+  'Comma-separated list of data to exclude (files [localMediaFiles, providerMediaFiles], content [entities, links], schema, configuration)' // ['webhooks', 'content', 'localmedia', 'providermedia', 'relations']
+).argParser(parseInputList);
+
 // Initial program setup
 program.storeOptionsAsProperties(false).allowUnknownOption(true);
 
@@ -255,4 +269,97 @@ program
   .option('-s, --silent', `Run the generation silently, without any output`, false)
   .action(getLocalScript('ts/generate-types'));
 
+// `$ strapi export`
+program
+  .command('export')
+  .description('Export data from Strapi to file')
+  .addOption(
+    new Option(
+      '--encrypt <boolean>',
+      `Encrypt output file using the 'aes-128-ecb' algorithm. Prompts for key unless key option is used.`
+    )
+      .default(true)
+      .argParser(parseInputBool)
+  )
+  .addOption(
+    new Option('--compress <boolean>', 'Compress output file using gzip compression')
+      .default(true)
+      .argParser(parseInputBool)
+  )
+  .addOption(
+    new Option('--key <string>', 'Provide encryption key in command instead of using a prompt')
+  )
+  .addOption(
+    new Option('--max-size <max MB per file>', 'split final file when exceeding size in MB')
+  )
+  .addOption(
+    new Option(
+      '--max-size-jsonl <max MB per internal backup file>',
+      'split internal jsonl files when exceeding max size in MB'
+    )
+  )
+  .addOption(new Option('-f, --file <file>', 'name to use for exported file (without extensions)'))
+  .addOption(excludeOption)
+  .allowExcessArguments(false)
+  .hook('preAction', promptEncryptionKey)
+  .action(getLocalScript('transfer/export'));
+
+// `$ strapi import`
+program
+  .command('import')
+  .description('Import data from file to Strapi')
+  .addOption(
+    new Option('--conflictStrategy <conflictStrategy>', 'Which strategy to use for ID conflicts')
+      .choices(['restore', 'abort', 'keep', 'replace'])
+      .default('restore')
+  )
+  .addOption(excludeOption)
+  .addOption(
+    new Option(
+      '--schemaComparison <schemaComparison>',
+      'exact requires every field to match, strict requires Strapi version and content type schema fields do not break, subset requires source schema to exist in destination, bypass skips checks',
+      parseInputList
+    )
+      .choices(['exact', 'strict', 'subset', 'bypass'])
+      .default('exact')
+  )
+  .requiredOption(
+    '-f, --file <file>',
+    'path and filename to the Strapi export file you want to import'
+  )
+  .addOption(
+    new Option('--key <string>', 'Provide encryption key in command instead of using a prompt')
+  )
+  .allowExcessArguments(false)
+  .hook('preAction', async (thisCommand) => {
+    const opts = thisCommand.opts();
+
+    // check extension to guess if we should prompt for key
+    if (String(opts.file).endsWith('.enc')) {
+      if (!opts.key) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'password',
+            message: 'Please enter your decryption key',
+            name: 'key',
+          },
+        ]);
+        if (!answers.key?.length) {
+          console.log('No key entered, aborting import.');
+          process.exit(0);
+        }
+        opts.key = answers.key;
+      }
+    }
+  })
+  .hook(
+    'preAction',
+    confirmKeyValue(
+      'conflictStrategy',
+      'restore',
+      "Using strategy 'restore' will delete all data in your database. Are you sure you want to proceed?"
+    )
+  )
+  .action(getLocalScript('transfer/import'));
+
 program.parseAsync(process.argv);

package/lib/commands/transfer/export.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const {
+  createLocalFileDestinationProvider,
+  createLocalStrapiSourceProvider,
+  createTransferEngine,
+  // TODO: we need to solve this issue with typescript modules
+  // eslint-disable-next-line import/no-unresolved, node/no-missing-require
+} = require('@strapi/data-transfer');
+const _ = require('lodash/fp');
+const Table = require('cli-table3');
+const fs = require('fs-extra');
+
+const chalk = require('chalk');
+const strapi = require('../../index');
+const { readableBytes } = require('../utils');
+
+const pad = (n) => {
+  return (n < 10 ? '0' : '') + String(n);
+};
+
+const yyyymmddHHMMSS = () => {
+  const date = new Date();
+
+  return (
+    date.getFullYear() +
+    pad(date.getMonth() + 1) +
+    pad(date.getDate()) +
+    pad(date.getHours()) +
+    pad(date.getMinutes()) +
+    pad(date.getSeconds())
+  );
+};
+
+const getDefaultExportName = () => {
+  return `export_${yyyymmddHHMMSS()}`;
+};
+
+const logger = console;
+
+const BYTES_IN_MB = 1024 * 1024;
+
+module.exports = async (opts) => {
+  // validate inputs from Commander
+  if (!_.isObject(opts)) {
+    logger.error('Could not parse arguments');
+    process.exit(1);
+  }
+  const filename = opts.file;
+
+  /**
+   * From local Strapi instance
+   */
+  const sourceOptions = {
+    async getStrapi() {
+      return strapi(await strapi.compile()).load();
+    },
+  };
+  const source = createLocalStrapiSourceProvider(sourceOptions);
+
+  const file = _.isString(filename) && filename.length > 0 ? filename : getDefaultExportName();
+
+  /**
+   * To a Strapi backup file
+   */
+  // treat any unknown arguments as filenames
+  const destinationOptions = {
+    file: {
+      path: file,
+      maxSize: _.isFinite(opts.maxSize) ? Math.floor(opts.maxSize) * BYTES_IN_MB : undefined,
+      maxSizeJsonl: _.isFinite(opts.maxSizeJsonl)
+        ? Math.floor(opts.maxSizeJsonl) * BYTES_IN_MB
+        : undefined,
+    },
+    encryption: {
+      enabled: opts.encrypt,
+      key: opts.key,
+    },
+    compression: {
+      enabled: opts.compress,
+    },
+  };
+  const destination = createLocalFileDestinationProvider(destinationOptions);
+
+  /**
+   * Configure and run the transfer engine
+   */
+  const engineOptions = {
+    strategy: 'restore', // for an export to file, strategy will always be 'restore'
+    versionMatching: 'ignore', // for an export to file, versionMatching will always be skipped
+    exclude: opts.exclude,
+  };
+  const engine = createTransferEngine(source, destination, engineOptions);
+
+  try {
+    let resultData = [];
+    logger.log(`Starting export...`);
+
+    engine.progress.stream.on('start', ({ stage }) => {
+      logger.log(`Starting transfer of ${stage}...`);
+    });
+
+    // engine.progress.stream..on('progress', ({ stage, data }) => {
+    //   logger.log('progress');
+    // });
+
+    engine.progress.stream.on('complete', ({ stage, data }) => {
+      logger.log(`...${stage} complete`);
+      resultData = data;
+    });
+
+    const results = await engine.transfer();
+
+    // Build pretty table
+    const table = new Table({
+      head: ['Type', 'Count', 'Size'],
+    });
+
+    let totalBytes = 0;
+    let totalItems = 0;
+    Object.keys(resultData).forEach((key) => {
+      const item = resultData[key];
+
+      table.push([
+        { hAlign: 'left', content: chalk.bold(key) },
+        { hAlign: 'right', content: item.count },
+        { hAlign: 'right', content: `${readableBytes(item.bytes, 1, 11)} ` },
+      ]);
+      totalBytes += item.bytes;
+      totalItems += item.count;
+
+      if (item.aggregates) {
+        Object.keys(item.aggregates).forEach((subkey) => {
+          const subitem = item.aggregates[subkey];
+
+          table.push([
+            { hAlign: 'left', content: `-- ${chalk.bold(subkey)}` },
+            { hAlign: 'right', content: subitem.count },
+            { hAlign: 'right', content: `(${chalk.grey(readableBytes(subitem.bytes, 1, 11))})` },
+          ]);
+        });
+      }
+    });
+    table.push([
+      { hAlign: 'left', content: chalk.bold.green('Total') },
+      { hAlign: 'right', content: chalk.bold.green(totalItems) },
+      { hAlign: 'right', content: `${chalk.bold.green(readableBytes(totalBytes, 1, 11))} ` },
+    ]);
+    logger.log(table.toString());
+
+    // TODO: once archiving is implemented, we need to check file extensions
+    if (!fs.pathExistsSync(results.destination.file.path)) {
+      logger.log(file);
+      throw new Error('Export file not created');
+    }
+
+    logger.log(`
+${chalk.bold('Export process has been completed successfully!')}
+Export archive is in ${chalk.green(results.destination.file.path)}
+`);
+    process.exit(0);
+  } catch (e) {
+    logger.error('Export process failed unexpectedly:', e.toString());
+    process.exit(1);
+  }
+};

package/lib/commands/transfer/import.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const {
+  createLocalFileSourceProvider,
+  createLocalStrapiDestinationProvider,
+  createTransferEngine,
+  // TODO: we need to solve this issue with typescript modules
+  // eslint-disable-next-line import/no-unresolved, node/no-missing-require
+} = require('@strapi/data-transfer');
+const { isObject } = require('lodash/fp');
+const strapi = require('../../index');
+
+const logger = console;
+
+module.exports = async (opts) => {
+  // validate inputs from Commander
+  if (!isObject(opts)) {
+    logger.error('Could not parse arguments');
+    process.exit(1);
+  }
+  const filename = opts.file;
+
+  /**
+   * From strapi backup file
+   */
+
+  // treat any unknown arguments as filenames
+  const sourceOptions = {
+    backupFilePath: filename,
+  };
+  const source = createLocalFileSourceProvider(sourceOptions);
+
+  /**
+   * To local Strapi instance
+   */
+  const destinationOptions = {
+    async getStrapi() {
+      return strapi(await strapi.compile()).load();
+    },
+  };
+  const destination = createLocalStrapiDestinationProvider(destinationOptions);
+
+  /**
+   * Configure and run the transfer engine
+   */
+  const engineOptions = {
+    strategy: opts.conflictStrategy,
+    versionMatching: opts.schemaComparison,
+    exclude: opts.exclude,
+  };
+  const engine = createTransferEngine(source, destination, engineOptions);
+
+  try {
+    logger.log('Importing data...');
+    const result = await engine.transfer();
+    logger.log('Import process has been completed successfully!');
+
+    // TODO: this won't dump the entire results, we will print a pretty summary
+    logger.log('Results:', result);
+    process.exit(0);
+  } catch (e) {
+    logger.log(`Import process failed unexpectedly: ${e.message}`);
+    process.exit(1);
+  }
+};

package/lib/commands/utils/commander.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const { parseType } = require('@strapi/utils/lib');
+const inquirer = require('inquirer');
+
+/**
+ * argsParser: Parse a string argument from the command line as a boolean
+ */
+const parseInputBool = (arg) => {
+  try {
+    return parseType({ type: 'boolean', value: arg });
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+};
+
+/**
+ * argsParser: Parse a comma-delimited string as an array
+ */
+const parseInputList = (value) => {
+  return value.split(',');
+};
+
+/**
+ * hook: if encrpyt=true and key not provided, prompt for it
+ */
+const promptEncryptionKey = async (thisCommand) => {
+  const opts = thisCommand.opts();
+
+  if (!opts.encrypt && opts.key) {
+    console.error('Key may not be present unless encryption is used');
+    process.exit(1);
+  }
+
+  // if encrypt is set but we have no key, prompt for it
+  if (opts.encrypt && !(opts.key && opts.key.length > 0)) {
+    try {
+      const answers = await inquirer.prompt([
+        {
+          type: 'password',
+          message: 'Please enter an encryption key',
+          name: 'key',
+          validate(key) {
+            if (key.length > 0) return true;
+
+            return 'Key must be present when using the encrypt option';
+          },
+        },
+      ]);
+      opts.key = answers.key;
+    } catch (e) {
+      console.error('Failed to get encryption key');
+      process.exit(1);
+    }
+    if (!opts.key) {
+      console.error('Failed to get encryption key');
+      process.exit(1);
+    }
+  }
+};
+
+/**
+ * hook: confirm that key has a value with a provided message
+ */
+const confirmKeyValue = (key, value, message) => {
+  return async (thisCommand) => {
+    const opts = thisCommand.opts();
+
+    if (!opts[key] || opts[key] !== value) {
+      console.error(`Could not confirm key ${key}, halting operation.`);
+      process.exit(1);
+    }
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        message,
+        name: `confirm_${key}`,
+      },
+    ]);
+    if (!answers[`confirm_${key}`]) {
+      process.exit(0);
+    }
+  };
+};
+
+module.exports = {
+  parseInputList,
+  parseInputBool,
+  promptEncryptionKey,
+  confirmKeyValue,
+};

package/lib/commands/utils/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const bytesPerKb = 1024;
+const sizes = ['B ', 'KB', 'MB', 'GB', 'TB', 'PB'];
+
+const readableBytes = (bytes, decimals = 1, padStart = 0) => {
+  if (!bytes) {
+    return '0';
+  }
+  const i = Math.floor(Math.log(bytes) / Math.log(bytesPerKb));
+  const result = `${parseFloat((bytes / bytesPerKb ** i).toFixed(decimals))} ${sizes[i].padStart(
+    2
+  )}`;
+
+  return result.padStart(padStart);
+};
+
+module.exports = {
+  readableBytes,
+};

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

@@ -3,7 +3,7 @@ import { Attribute, ConfigurableOption, PrivateOption } from './base';
 import { GetAttributesByType, GetAttributesValues } from './utils';
 
 export type BasicRelationsType = 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany';
-export type PolymorphicRelationsType =  'morphToOne' | 'morphToMany' | 'morphOne' | 'morphMany';
+export type PolymorphicRelationsType = 'morphToOne' | 'morphToMany' | 'morphOne' | 'morphMany';
 export type RelationsType = BasicRelationsType | PolymorphicRelationsType;
 
 export interface BasicRelationAttributeProperties<
@@ -17,16 +17,14 @@ export interface BasicRelationAttributeProperties<
   mappedBy?: RelationsKeysFromTo<T, S>;
 }
 
-export interface PolymorphicRelationAttributeProperties<
-  R extends RelationsType,
-> {
+export interface PolymorphicRelationAttributeProperties<R extends RelationsType> {
   relation: R;
 }
 
 export type RelationAttribute<
   S extends SchemaUID,
   R extends RelationsType,
-  T extends R extends PolymorphicRelationsType ? never: SchemaUID = never
+  T extends R extends PolymorphicRelationsType ? never : SchemaUID = never
 > = Attribute<'relation'> &
   // Properties
   (R extends BasicRelationsType
@@ -34,22 +32,21 @@ export type RelationAttribute<
     : PolymorphicRelationAttributeProperties<R>) &
   // Options
   ConfigurableOption &
-  PrivateOption
+  PrivateOption;
 
 export type RelationsKeysFromTo<
   TTarget extends SchemaUID,
   TSource extends SchemaUID
 > = keyof PickRelationsFromTo<TTarget, TSource>;
 
-export type PickRelationsFromTo<TTarget extends SchemaUID, TSource extends SchemaUID> = GetAttributesByType<
-  TTarget,
-  'relation',
-  { target: TSource }
->;
+export type PickRelationsFromTo<
+  TTarget extends SchemaUID,
+  TSource extends SchemaUID
+> = GetAttributesByType<TTarget, 'relation', { target: TSource }>;
 
 export type RelationPluralityModifier<
   TRelation extends RelationsType,
-  TValue extends Object
+  TValue extends Record<string, unknown>
 > = TRelation extends `${string}Many` ? TValue[] : TValue;
 
 export type RelationValue<

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

@@ -1,5 +1,5 @@
 import { Attribute, ComponentAttribute } from '../attributes';
-import { KeysBy, StringRecord } from '../../utils';
+import { KeysBy, SchemaUID, StringRecord } from '../../utils';
 
 /**
  * Literal union type representing the possible natures of a content type
@@ -98,6 +98,11 @@ export interface PluginOptions {}
 export interface ContentTypeSchema extends Schema {
   modelType: 'contentType';
 
+  /**
+   * Unique identifier of the schema
+   */
+  uid: SchemaUID;
+
   /**
    * Determine the type of the content type (single-type or collection-type)
    */

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

@@ -2,8 +2,8 @@ import type Koa from 'koa';
 import { Database } from '@strapi/database';
 
 import type { StringMap } from './utils';
-import type { GenericController } from '../../../core-api/controller'
-import type { GenericService } from '../../../core-api/service'
+import type { GenericController } from '../../../core-api/controller';
+import type { GenericService } from '../../../core-api/service';
 
 // TODO move custom fields types to a separate file
 interface CustomFieldServerOptions {
@@ -92,9 +92,16 @@ export interface Strapi {
    */
   contentType(uid: string): any;
 
+  /**
+   * Getter for the Strapi component container
+   *
+   * It returns all the registered components
+   */
+  readonly components: any;
+
   /**
    * The custom fields registry
-   * 
+   *
    * It returns the custom fields interface
    */
   readonly customFields: CustomFields;
@@ -361,7 +368,6 @@ export interface Strapi {
    */
   log: any;
 
-
   /**
    * Used to manage cron within Strapi
    */

package/lib/types/factories.d.ts

@@ -1,8 +1,8 @@
-import { Service,GenericService } from '../core-api/service';
+import { Service, GenericService } from '../core-api/service';
 import { Controller, GenericController } from '../core-api/controller';
 import { Middleware } from '../middlewares';
 import { Policy } from '../core/registries/policies';
-import { Strapi } from '@strapi/strapi';
+import { Strapi } from './core/strapi';
 
 type ControllerConfig<T extends Controller = Controller> = T;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.5.2",
+  "version": "4.6.0-alpha.0",
   "description": "An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite",
   "keywords": [
     "strapi",
@@ -80,18 +80,19 @@
   "dependencies": {
     "@koa/cors": "3.4.3",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.5.2",
-    "@strapi/database": "4.5.2",
-    "@strapi/generate-new": "4.5.2",
-    "@strapi/generators": "4.5.2",
-    "@strapi/logger": "4.5.2",
-    "@strapi/permissions": "4.5.2",
-    "@strapi/plugin-content-manager": "4.5.2",
-    "@strapi/plugin-content-type-builder": "4.5.2",
-    "@strapi/plugin-email": "4.5.2",
-    "@strapi/plugin-upload": "4.5.2",
-    "@strapi/typescript-utils": "4.5.2",
-    "@strapi/utils": "4.5.2",
+    "@strapi/admin": "4.6.0-alpha.0",
+    "@strapi/data-transfer": "4.6.0-alpha.0",
+    "@strapi/database": "4.6.0-alpha.0",
+    "@strapi/generate-new": "4.6.0-alpha.0",
+    "@strapi/generators": "4.6.0-alpha.0",
+    "@strapi/logger": "4.6.0-alpha.0",
+    "@strapi/permissions": "4.6.0-alpha.0",
+    "@strapi/plugin-content-manager": "4.6.0-alpha.0",
+    "@strapi/plugin-content-type-builder": "4.6.0-alpha.0",
+    "@strapi/plugin-email": "4.6.0-alpha.0",
+    "@strapi/plugin-upload": "4.6.0-alpha.0",
+    "@strapi/typescript-utils": "4.6.0-alpha.0",
+    "@strapi/utils": "4.6.0-alpha.0",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -140,5 +141,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "bcb1b7f472aae2556a9b59d59ee66d241c497a3e"
+  "gitHead": "b7a87dcffc6f44e18eedef92e354096ffe32ce0c"
 }